1 /* tc-sh.c -- Assemble code for the Renesas / SuperH SH
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to
20 the Free Software Foundation, 51 Franklin Street - Fifth Floor,
21 Boston, MA 02110-1301, USA. */
23 /* Written By Steve Chamberlain <sac@cygnus.com> */
28 #include "opcodes/sh-opc.h"
29 #include "safe-ctype.h"
30 #include "struc-symbol.h"
36 #include "dwarf2dbg.h"
37 #include "dw2gencfi.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 (int);
52 static void s_uacons (int);
55 static void sh_elf_cons (int);
57 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
61 big (int ignore ATTRIBUTE_UNUSED
)
63 if (! target_big_endian
)
64 as_bad (_("directive .big encountered when option -big required"));
66 /* Stop further messages. */
67 target_big_endian
= 1;
71 little (int ignore ATTRIBUTE_UNUSED
)
73 if (target_big_endian
)
74 as_bad (_("directive .little encountered when option -little required"));
76 /* Stop further messages. */
77 target_big_endian
= 0;
80 /* This table describes all the machine specific pseudo-ops the assembler
81 has to support. The fields are:
82 pseudo-op name without dot
83 function to call to execute this pseudo-op
84 Integer arg to pass to the function. */
86 const pseudo_typeS md_pseudo_table
[] =
89 {"long", sh_elf_cons
, 4},
90 {"int", sh_elf_cons
, 4},
91 {"word", sh_elf_cons
, 2},
92 {"short", sh_elf_cons
, 2},
98 {"form", listing_psize
, 0},
99 {"little", little
, 0},
100 {"heading", listing_title
, 0},
101 {"import", s_ignore
, 0},
102 {"page", listing_eject
, 0},
103 {"program", s_ignore
, 0},
105 {"uaword", s_uacons
, 2},
106 {"ualong", s_uacons
, 4},
107 {"uaquad", s_uacons
, 8},
108 {"2byte", s_uacons
, 2},
109 {"4byte", s_uacons
, 4},
110 {"8byte", s_uacons
, 8},
112 {"mode", s_sh64_mode
, 0 },
114 /* Have the old name too. */
115 {"isa", s_sh64_mode
, 0 },
117 /* Assert that the right ABI is used. */
118 {"abi", s_sh64_abi
, 0 },
120 { "vtable_inherit", sh64_vtable_inherit
, 0 },
121 { "vtable_entry", sh64_vtable_entry
, 0 },
122 #endif /* HAVE_SH64 */
126 int sh_relax
; /* set if -relax seen */
128 /* Whether -small was seen. */
132 /* Flag to generate relocations against symbol values for local symbols. */
134 static int dont_adjust_reloc_32
;
136 /* Flag to indicate that '$' is allowed as a register prefix. */
138 static int allow_dollar_register_prefix
;
140 /* Preset architecture set, if given; zero otherwise. */
142 static unsigned int preset_target_arch
;
144 /* The bit mask of architectures that could
145 accommodate the insns seen so far. */
146 static unsigned int valid_arch
;
149 /* Whether --fdpic was given. */
153 const char EXP_CHARS
[] = "eE";
155 /* Chars that mean this number is a floating point constant. */
158 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
160 #define C(a,b) ENCODE_RELAX(a,b)
162 #define ENCODE_RELAX(what,length) (((what) << 4) + (length))
163 #define GET_WHAT(x) ((x>>4))
165 /* These are the three types of relaxable instruction. */
166 /* These are the types of relaxable instructions; except for END which is
169 #define COND_JUMP_DELAY 2
170 #define UNCOND_JUMP 3
174 /* A 16-bit (times four) pc-relative operand, at most expanded to 32 bits. */
175 #define SH64PCREL16_32 4
176 /* A 16-bit (times four) pc-relative operand, at most expanded to 64 bits. */
177 #define SH64PCREL16_64 5
179 /* Variants of the above for adjusting the insn to PTA or PTB according to
181 #define SH64PCREL16PT_32 6
182 #define SH64PCREL16PT_64 7
184 /* A MOVI expansion, expanding to at most 32 or 64 bits. */
185 #define MOVI_IMM_32 8
186 #define MOVI_IMM_32_PCREL 9
187 #define MOVI_IMM_64 10
188 #define MOVI_IMM_64_PCREL 11
191 #else /* HAVE_SH64 */
195 #endif /* HAVE_SH64 */
201 #define UNDEF_WORD_DISP 4
207 #define UNDEF_SH64PCREL 0
208 #define SH64PCREL16 1
209 #define SH64PCREL32 2
210 #define SH64PCREL48 3
211 #define SH64PCREL64 4
212 #define SH64PCRELPLT 5
220 #define MOVI_GOTOFF 6
222 #endif /* HAVE_SH64 */
224 /* Branch displacements are from the address of the branch plus
225 four, thus all minimum and maximum values have 4 added to them. */
228 #define COND8_LENGTH 2
230 /* There is one extra instruction before the branch, so we must add
231 two more bytes to account for it. */
232 #define COND12_F 4100
233 #define COND12_M -4090
234 #define COND12_LENGTH 6
236 #define COND12_DELAY_LENGTH 4
238 /* ??? The minimum and maximum values are wrong, but this does not matter
239 since this relocation type is not supported yet. */
240 #define COND32_F (1<<30)
241 #define COND32_M -(1<<30)
242 #define COND32_LENGTH 14
244 #define UNCOND12_F 4098
245 #define UNCOND12_M -4092
246 #define UNCOND12_LENGTH 2
248 /* ??? The minimum and maximum values are wrong, but this does not matter
249 since this relocation type is not supported yet. */
250 #define UNCOND32_F (1<<30)
251 #define UNCOND32_M -(1<<30)
252 #define UNCOND32_LENGTH 14
255 /* The trivial expansion of a SH64PCREL16 relaxation is just a "PT label,
256 TRd" as is the current insn, so no extra length. Note that the "reach"
257 is calculated from the address *after* that insn, but the offset in the
258 insn is calculated from the beginning of the insn. We also need to
259 take into account the implicit 1 coded as the "A" in PTA when counting
260 forward. If PTB reaches an odd address, we trap that as an error
261 elsewhere, so we don't have to have different relaxation entries. We
262 don't add a one to the negative range, since PTB would then have the
263 farthest backward-reaching value skipped, not generated at relaxation. */
264 #define SH64PCREL16_F (32767 * 4 - 4 + 1)
265 #define SH64PCREL16_M (-32768 * 4 - 4)
266 #define SH64PCREL16_LENGTH 0
268 /* The next step is to change that PT insn into
269 MOVI ((label - datalabel Ln) >> 16) & 65535, R25
270 SHORI (label - datalabel Ln) & 65535, R25
273 which means two extra insns, 8 extra bytes. This is the limit for the
276 The expressions look a bit bad since we have to adjust this to avoid overflow on a
278 #define SH64PCREL32_F ((((long) 1 << 30) - 1) * 2 + 1 - 4)
279 #define SH64PCREL32_LENGTH (2 * 4)
281 /* Similarly, we just change the MOVI and add a SHORI for the 48-bit
283 #if BFD_HOST_64BIT_LONG
284 /* The "reach" type is long, so we can only do this for a 64-bit-long
286 #define SH64PCREL32_M (((long) -1 << 30) * 2 - 4)
287 #define SH64PCREL48_F ((((long) 1 << 47) - 1) - 4)
288 #define SH64PCREL48_M (((long) -1 << 47) - 4)
289 #define SH64PCREL48_LENGTH (3 * 4)
291 /* If the host does not have 64-bit longs, just make this state identical
292 in reach to the 32-bit state. Note that we have a slightly incorrect
293 reach, but the correct one above will overflow a 32-bit number. */
294 #define SH64PCREL32_M (((long) -1 << 30) * 2)
295 #define SH64PCREL48_F SH64PCREL32_F
296 #define SH64PCREL48_M SH64PCREL32_M
297 #define SH64PCREL48_LENGTH (3 * 4)
298 #endif /* BFD_HOST_64BIT_LONG */
300 /* And similarly for the 64-bit expansion; a MOVI + SHORI + SHORI + SHORI
302 #define SH64PCREL64_LENGTH (4 * 4)
304 /* For MOVI, we make the MOVI + SHORI... expansion you can see in the
305 SH64PCREL expansions. The PCREL one is similar, but the other has no
306 pc-relative reach; it must be fully expanded in
307 shmedia_md_estimate_size_before_relax. */
308 #define MOVI_16_LENGTH 0
309 #define MOVI_16_F (32767 - 4)
310 #define MOVI_16_M (-32768 - 4)
311 #define MOVI_32_LENGTH 4
312 #define MOVI_32_F ((((long) 1 << 30) - 1) * 2 + 1 - 4)
313 #define MOVI_48_LENGTH 8
315 #if BFD_HOST_64BIT_LONG
316 /* The "reach" type is long, so we can only do this for a 64-bit-long
318 #define MOVI_32_M (((long) -1 << 30) * 2 - 4)
319 #define MOVI_48_F ((((long) 1 << 47) - 1) - 4)
320 #define MOVI_48_M (((long) -1 << 47) - 4)
322 /* If the host does not have 64-bit longs, just make this state identical
323 in reach to the 32-bit state. Note that we have a slightly incorrect
324 reach, but the correct one above will overflow a 32-bit number. */
325 #define MOVI_32_M (((long) -1 << 30) * 2)
326 #define MOVI_48_F MOVI_32_F
327 #define MOVI_48_M MOVI_32_M
328 #endif /* BFD_HOST_64BIT_LONG */
330 #define MOVI_64_LENGTH 12
331 #endif /* HAVE_SH64 */
333 #define EMPTY { 0, 0, 0, 0 }
335 const relax_typeS md_relax_table
[C (END
, 0)] = {
336 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
337 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
340 /* C (COND_JUMP, COND8) */
341 { COND8_F
, COND8_M
, COND8_LENGTH
, C (COND_JUMP
, COND12
) },
342 /* C (COND_JUMP, COND12) */
343 { COND12_F
, COND12_M
, COND12_LENGTH
, C (COND_JUMP
, COND32
), },
344 /* C (COND_JUMP, COND32) */
345 { COND32_F
, COND32_M
, COND32_LENGTH
, 0, },
346 /* C (COND_JUMP, UNDEF_WORD_DISP) */
347 { 0, 0, COND32_LENGTH
, 0, },
349 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
352 /* C (COND_JUMP_DELAY, COND8) */
353 { COND8_F
, COND8_M
, COND8_LENGTH
, C (COND_JUMP_DELAY
, COND12
) },
354 /* C (COND_JUMP_DELAY, COND12) */
355 { COND12_F
, COND12_M
, COND12_DELAY_LENGTH
, C (COND_JUMP_DELAY
, COND32
), },
356 /* C (COND_JUMP_DELAY, COND32) */
357 { COND32_F
, COND32_M
, COND32_LENGTH
, 0, },
358 /* C (COND_JUMP_DELAY, UNDEF_WORD_DISP) */
359 { 0, 0, COND32_LENGTH
, 0, },
361 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
364 /* C (UNCOND_JUMP, UNCOND12) */
365 { UNCOND12_F
, UNCOND12_M
, UNCOND12_LENGTH
, C (UNCOND_JUMP
, UNCOND32
), },
366 /* C (UNCOND_JUMP, UNCOND32) */
367 { UNCOND32_F
, UNCOND32_M
, UNCOND32_LENGTH
, 0, },
369 /* C (UNCOND_JUMP, UNDEF_WORD_DISP) */
370 { 0, 0, UNCOND32_LENGTH
, 0, },
372 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
375 /* C (SH64PCREL16_32, SH64PCREL16) */
377 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16_32
, SH64PCREL32
) },
378 /* C (SH64PCREL16_32, SH64PCREL32) */
379 { 0, 0, SH64PCREL32_LENGTH
, 0 },
381 /* C (SH64PCREL16_32, SH64PCRELPLT) */
382 { 0, 0, SH64PCREL32_LENGTH
, 0 },
384 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
386 /* C (SH64PCREL16_64, SH64PCREL16) */
388 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16_64
, SH64PCREL32
) },
389 /* C (SH64PCREL16_64, SH64PCREL32) */
390 { SH64PCREL32_F
, SH64PCREL32_M
, SH64PCREL32_LENGTH
, C (SH64PCREL16_64
, SH64PCREL48
) },
391 /* C (SH64PCREL16_64, SH64PCREL48) */
392 { SH64PCREL48_F
, SH64PCREL48_M
, SH64PCREL48_LENGTH
, C (SH64PCREL16_64
, SH64PCREL64
) },
393 /* C (SH64PCREL16_64, SH64PCREL64) */
394 { 0, 0, SH64PCREL64_LENGTH
, 0 },
395 /* C (SH64PCREL16_64, SH64PCRELPLT) */
396 { 0, 0, SH64PCREL64_LENGTH
, 0 },
398 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
400 /* C (SH64PCREL16PT_32, SH64PCREL16) */
402 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16PT_32
, SH64PCREL32
) },
403 /* C (SH64PCREL16PT_32, SH64PCREL32) */
404 { 0, 0, SH64PCREL32_LENGTH
, 0 },
406 /* C (SH64PCREL16PT_32, SH64PCRELPLT) */
407 { 0, 0, SH64PCREL32_LENGTH
, 0 },
409 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
411 /* C (SH64PCREL16PT_64, SH64PCREL16) */
413 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16PT_64
, SH64PCREL32
) },
414 /* C (SH64PCREL16PT_64, SH64PCREL32) */
418 C (SH64PCREL16PT_64
, SH64PCREL48
) },
419 /* C (SH64PCREL16PT_64, SH64PCREL48) */
420 { SH64PCREL48_F
, SH64PCREL48_M
, SH64PCREL48_LENGTH
, C (SH64PCREL16PT_64
, SH64PCREL64
) },
421 /* C (SH64PCREL16PT_64, SH64PCREL64) */
422 { 0, 0, SH64PCREL64_LENGTH
, 0 },
423 /* C (SH64PCREL16PT_64, SH64PCRELPLT) */
424 { 0, 0, SH64PCREL64_LENGTH
, 0},
426 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
428 /* C (MOVI_IMM_32, UNDEF_MOVI) */
429 { 0, 0, MOVI_32_LENGTH
, 0 },
430 /* C (MOVI_IMM_32, MOVI_16) */
431 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_32
, MOVI_32
) },
432 /* C (MOVI_IMM_32, MOVI_32) */
433 { MOVI_32_F
, MOVI_32_M
, MOVI_32_LENGTH
, 0 },
435 /* C (MOVI_IMM_32, MOVI_GOTOFF) */
436 { 0, 0, MOVI_32_LENGTH
, 0 },
437 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
439 /* C (MOVI_IMM_32_PCREL, MOVI_16) */
441 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_32_PCREL
, MOVI_32
) },
442 /* C (MOVI_IMM_32_PCREL, MOVI_32) */
443 { 0, 0, MOVI_32_LENGTH
, 0 },
445 /* C (MOVI_IMM_32_PCREL, MOVI_PLT) */
446 { 0, 0, MOVI_32_LENGTH
, 0 },
448 /* C (MOVI_IMM_32_PCREL, MOVI_GOTPC) */
449 { 0, 0, MOVI_32_LENGTH
, 0 },
450 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
452 /* C (MOVI_IMM_64, UNDEF_MOVI) */
453 { 0, 0, MOVI_64_LENGTH
, 0 },
454 /* C (MOVI_IMM_64, MOVI_16) */
455 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_64
, MOVI_32
) },
456 /* C (MOVI_IMM_64, MOVI_32) */
457 { MOVI_32_F
, MOVI_32_M
, MOVI_32_LENGTH
, C (MOVI_IMM_64
, MOVI_48
) },
458 /* C (MOVI_IMM_64, MOVI_48) */
459 { MOVI_48_F
, MOVI_48_M
, MOVI_48_LENGTH
, C (MOVI_IMM_64
, MOVI_64
) },
460 /* C (MOVI_IMM_64, MOVI_64) */
461 { 0, 0, MOVI_64_LENGTH
, 0 },
463 /* C (MOVI_IMM_64, MOVI_GOTOFF) */
464 { 0, 0, MOVI_64_LENGTH
, 0 },
465 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
467 /* C (MOVI_IMM_64_PCREL, MOVI_16) */
469 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_64_PCREL
, MOVI_32
) },
470 /* C (MOVI_IMM_64_PCREL, MOVI_32) */
471 { MOVI_32_F
, MOVI_32_M
, MOVI_32_LENGTH
, C (MOVI_IMM_64_PCREL
, MOVI_48
) },
472 /* C (MOVI_IMM_64_PCREL, MOVI_48) */
473 { MOVI_48_F
, MOVI_48_M
, MOVI_48_LENGTH
, C (MOVI_IMM_64_PCREL
, MOVI_64
) },
474 /* C (MOVI_IMM_64_PCREL, MOVI_64) */
475 { 0, 0, MOVI_64_LENGTH
, 0 },
476 /* C (MOVI_IMM_64_PCREL, MOVI_PLT) */
477 { 0, 0, MOVI_64_LENGTH
, 0 },
479 /* C (MOVI_IMM_64_PCREL, MOVI_GOTPC) */
480 { 0, 0, MOVI_64_LENGTH
, 0 },
481 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
483 #endif /* HAVE_SH64 */
489 static struct hash_control
*opcode_hash_control
; /* Opcode mnemonics */
493 /* Determinet whether the symbol needs any kind of PIC relocation. */
496 sh_PIC_related_p (symbolS
*sym
)
503 if (sym
== GOT_symbol
)
507 if (sh_PIC_related_p (*symbol_get_tc (sym
)))
511 exp
= symbol_get_value_expression (sym
);
513 return (exp
->X_op
== O_PIC_reloc
514 || sh_PIC_related_p (exp
->X_add_symbol
)
515 || sh_PIC_related_p (exp
->X_op_symbol
));
518 /* Determine the relocation type to be used to represent the
519 expression, that may be rearranged. */
522 sh_check_fixup (expressionS
*main_exp
, bfd_reloc_code_real_type
*r_type_p
)
524 expressionS
*exp
= main_exp
;
526 /* This is here for backward-compatibility only. GCC used to generated:
528 f@PLT + . - (.LPCS# + 2)
530 but we'd rather be able to handle this as a PIC-related reference
531 plus/minus a symbol. However, gas' parser gives us:
533 O_subtract (O_add (f@PLT, .), .LPCS#+2)
535 so we attempt to transform this into:
537 O_subtract (f@PLT, O_subtract (.LPCS#+2, .))
539 which we can handle simply below. */
540 if (exp
->X_op
== O_subtract
)
542 if (sh_PIC_related_p (exp
->X_op_symbol
))
545 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
547 if (exp
&& sh_PIC_related_p (exp
->X_op_symbol
))
550 if (exp
&& exp
->X_op
== O_add
551 && sh_PIC_related_p (exp
->X_add_symbol
))
553 symbolS
*sym
= exp
->X_add_symbol
;
555 exp
->X_op
= O_subtract
;
556 exp
->X_add_symbol
= main_exp
->X_op_symbol
;
558 main_exp
->X_op_symbol
= main_exp
->X_add_symbol
;
559 main_exp
->X_add_symbol
= sym
;
561 main_exp
->X_add_number
+= exp
->X_add_number
;
562 exp
->X_add_number
= 0;
567 else if (exp
->X_op
== O_add
&& sh_PIC_related_p (exp
->X_op_symbol
))
570 if (exp
->X_op
== O_symbol
|| exp
->X_op
== O_add
|| exp
->X_op
== O_subtract
)
573 if (exp
->X_add_symbol
574 && (exp
->X_add_symbol
== GOT_symbol
576 && *symbol_get_tc (exp
->X_add_symbol
) == GOT_symbol
)))
580 case BFD_RELOC_SH_IMM_LOW16
:
581 *r_type_p
= BFD_RELOC_SH_GOTPC_LOW16
;
584 case BFD_RELOC_SH_IMM_MEDLOW16
:
585 *r_type_p
= BFD_RELOC_SH_GOTPC_MEDLOW16
;
588 case BFD_RELOC_SH_IMM_MEDHI16
:
589 *r_type_p
= BFD_RELOC_SH_GOTPC_MEDHI16
;
592 case BFD_RELOC_SH_IMM_HI16
:
593 *r_type_p
= BFD_RELOC_SH_GOTPC_HI16
;
597 case BFD_RELOC_UNUSED
:
598 *r_type_p
= BFD_RELOC_SH_GOTPC
;
607 if (exp
->X_add_symbol
&& exp
->X_add_symbol
== GOT_symbol
)
609 *r_type_p
= BFD_RELOC_SH_GOTPC
;
613 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
618 if (exp
->X_op
== O_PIC_reloc
)
623 case BFD_RELOC_UNUSED
:
624 *r_type_p
= exp
->X_md
;
627 case BFD_RELOC_SH_DISP20
:
630 case BFD_RELOC_32_GOT_PCREL
:
631 *r_type_p
= BFD_RELOC_SH_GOT20
;
634 case BFD_RELOC_32_GOTOFF
:
635 *r_type_p
= BFD_RELOC_SH_GOTOFF20
;
638 case BFD_RELOC_SH_GOTFUNCDESC
:
639 *r_type_p
= BFD_RELOC_SH_GOTFUNCDESC20
;
642 case BFD_RELOC_SH_GOTOFFFUNCDESC
:
643 *r_type_p
= BFD_RELOC_SH_GOTOFFFUNCDESC20
;
652 case BFD_RELOC_SH_IMM_LOW16
:
655 case BFD_RELOC_32_GOTOFF
:
656 *r_type_p
= BFD_RELOC_SH_GOTOFF_LOW16
;
659 case BFD_RELOC_SH_GOTPLT32
:
660 *r_type_p
= BFD_RELOC_SH_GOTPLT_LOW16
;
663 case BFD_RELOC_32_GOT_PCREL
:
664 *r_type_p
= BFD_RELOC_SH_GOT_LOW16
;
667 case BFD_RELOC_32_PLT_PCREL
:
668 *r_type_p
= BFD_RELOC_SH_PLT_LOW16
;
676 case BFD_RELOC_SH_IMM_MEDLOW16
:
679 case BFD_RELOC_32_GOTOFF
:
680 *r_type_p
= BFD_RELOC_SH_GOTOFF_MEDLOW16
;
683 case BFD_RELOC_SH_GOTPLT32
:
684 *r_type_p
= BFD_RELOC_SH_GOTPLT_MEDLOW16
;
687 case BFD_RELOC_32_GOT_PCREL
:
688 *r_type_p
= BFD_RELOC_SH_GOT_MEDLOW16
;
691 case BFD_RELOC_32_PLT_PCREL
:
692 *r_type_p
= BFD_RELOC_SH_PLT_MEDLOW16
;
700 case BFD_RELOC_SH_IMM_MEDHI16
:
703 case BFD_RELOC_32_GOTOFF
:
704 *r_type_p
= BFD_RELOC_SH_GOTOFF_MEDHI16
;
707 case BFD_RELOC_SH_GOTPLT32
:
708 *r_type_p
= BFD_RELOC_SH_GOTPLT_MEDHI16
;
711 case BFD_RELOC_32_GOT_PCREL
:
712 *r_type_p
= BFD_RELOC_SH_GOT_MEDHI16
;
715 case BFD_RELOC_32_PLT_PCREL
:
716 *r_type_p
= BFD_RELOC_SH_PLT_MEDHI16
;
724 case BFD_RELOC_SH_IMM_HI16
:
727 case BFD_RELOC_32_GOTOFF
:
728 *r_type_p
= BFD_RELOC_SH_GOTOFF_HI16
;
731 case BFD_RELOC_SH_GOTPLT32
:
732 *r_type_p
= BFD_RELOC_SH_GOTPLT_HI16
;
735 case BFD_RELOC_32_GOT_PCREL
:
736 *r_type_p
= BFD_RELOC_SH_GOT_HI16
;
739 case BFD_RELOC_32_PLT_PCREL
:
740 *r_type_p
= BFD_RELOC_SH_PLT_HI16
;
753 exp
->X_op
= O_symbol
;
756 main_exp
->X_add_symbol
= exp
->X_add_symbol
;
757 main_exp
->X_add_number
+= exp
->X_add_number
;
761 return (sh_PIC_related_p (exp
->X_add_symbol
)
762 || sh_PIC_related_p (exp
->X_op_symbol
));
767 /* Add expression EXP of SIZE bytes to offset OFF of fragment FRAG. */
770 sh_cons_fix_new (fragS
*frag
, int off
, int size
, expressionS
*exp
)
772 bfd_reloc_code_real_type r_type
= BFD_RELOC_UNUSED
;
774 if (sh_check_fixup (exp
, &r_type
))
775 as_bad (_("Invalid PIC expression."));
777 if (r_type
== BFD_RELOC_UNUSED
)
781 r_type
= BFD_RELOC_8
;
785 r_type
= BFD_RELOC_16
;
789 r_type
= BFD_RELOC_32
;
793 r_type
= BFD_RELOC_64
;
802 as_bad (_("unsupported BFD relocation size %u"), size
);
803 r_type
= BFD_RELOC_UNUSED
;
806 fix_new_exp (frag
, off
, size
, exp
, 0, r_type
);
809 /* The regular cons() function, that reads constants, doesn't support
810 suffixes such as @GOT, @GOTOFF and @PLT, that generate
811 machine-specific relocation types. So we must define it here. */
812 /* Clobbers input_line_pointer, checks end-of-line. */
813 /* NBYTES 1=.byte, 2=.word, 4=.long */
815 sh_elf_cons (register int nbytes
)
821 /* Update existing range to include a previous insn, if there was one. */
822 sh64_update_contents_mark (TRUE
);
824 /* We need to make sure the contents type is set to data. */
827 #endif /* HAVE_SH64 */
829 if (is_it_end_of_statement ())
831 demand_empty_rest_of_line ();
836 md_cons_align (nbytes
);
842 emit_expr (&exp
, (unsigned int) nbytes
);
844 while (*input_line_pointer
++ == ',');
846 input_line_pointer
--; /* Put terminator back into stream. */
847 if (*input_line_pointer
== '#' || *input_line_pointer
== '!')
849 while (! is_end_of_line
[(unsigned char) *input_line_pointer
++]);
852 demand_empty_rest_of_line ();
855 /* The regular frag_offset_fixed_p doesn't work for rs_align_test
859 align_test_frag_offset_fixed_p (const fragS
*frag1
, const fragS
*frag2
,
865 /* Start with offset initialised to difference between the two frags.
866 Prior to assigning frag addresses this will be zero. */
867 off
= frag1
->fr_address
- frag2
->fr_address
;
874 /* Maybe frag2 is after frag1. */
876 while (frag
->fr_type
== rs_fill
877 || frag
->fr_type
== rs_align_test
)
879 if (frag
->fr_type
== rs_fill
)
880 off
+= frag
->fr_fix
+ frag
->fr_offset
* frag
->fr_var
;
883 frag
= frag
->fr_next
;
893 /* Maybe frag1 is after frag2. */
894 off
= frag1
->fr_address
- frag2
->fr_address
;
896 while (frag
->fr_type
== rs_fill
897 || frag
->fr_type
== rs_align_test
)
899 if (frag
->fr_type
== rs_fill
)
900 off
-= frag
->fr_fix
+ frag
->fr_offset
* frag
->fr_var
;
903 frag
= frag
->fr_next
;
916 /* Optimize a difference of symbols which have rs_align_test frag if
920 sh_optimize_expr (expressionS
*l
, operatorT op
, expressionS
*r
)
925 && l
->X_op
== O_symbol
926 && r
->X_op
== O_symbol
927 && S_GET_SEGMENT (l
->X_add_symbol
) == S_GET_SEGMENT (r
->X_add_symbol
)
928 && (SEG_NORMAL (S_GET_SEGMENT (l
->X_add_symbol
))
929 || r
->X_add_symbol
== l
->X_add_symbol
)
930 && align_test_frag_offset_fixed_p (symbol_get_frag (l
->X_add_symbol
),
931 symbol_get_frag (r
->X_add_symbol
),
934 offsetT symval_diff
= S_GET_VALUE (l
->X_add_symbol
)
935 - S_GET_VALUE (r
->X_add_symbol
);
936 subtract_from_result (l
, r
->X_add_number
, r
->X_extrabit
);
937 subtract_from_result (l
, frag_off
/ OCTETS_PER_BYTE
, 0);
938 add_to_result (l
, symval_diff
, symval_diff
< 0);
939 l
->X_op
= O_constant
;
947 /* This function is called once, at assembler startup time. This should
948 set up all the tables, etc that the MD part of the assembler needs. */
953 const sh_opcode_info
*opcode
;
954 char *prev_name
= "";
955 unsigned int target_arch
;
958 = preset_target_arch
? preset_target_arch
: arch_sh_up
& ~arch_sh_has_dsp
;
959 valid_arch
= target_arch
;
965 opcode_hash_control
= hash_new ();
967 /* Insert unique names into hash table. */
968 for (opcode
= sh_table
; opcode
->name
; opcode
++)
970 if (strcmp (prev_name
, opcode
->name
) != 0)
972 if (!SH_MERGE_ARCH_SET_VALID (opcode
->arch
, target_arch
))
974 prev_name
= opcode
->name
;
975 hash_insert (opcode_hash_control
, opcode
->name
, (char *) opcode
);
982 static int reg_x
, reg_y
;
986 #define IDENT_CHAR(c) (ISALNUM (c) || (c) == '_')
988 /* Try to parse a reg name. Return the number of chars consumed. */
991 parse_reg_without_prefix (char *src
, int *mode
, int *reg
)
993 char l0
= TOLOWER (src
[0]);
994 char l1
= l0
? TOLOWER (src
[1]) : 0;
996 /* We use ! IDENT_CHAR for the next character after the register name, to
997 make sure that we won't accidentally recognize a symbol name such as
998 'sram' or sr_ram as being a reference to the register 'sr'. */
1004 if (src
[2] >= '0' && src
[2] <= '5'
1005 && ! IDENT_CHAR ((unsigned char) src
[3]))
1008 *reg
= 10 + src
[2] - '0';
1012 if (l1
>= '0' && l1
<= '9'
1013 && ! IDENT_CHAR ((unsigned char) src
[2]))
1019 if (l1
>= '0' && l1
<= '7' && strncasecmp (&src
[2], "_bank", 5) == 0
1020 && ! IDENT_CHAR ((unsigned char) src
[7]))
1027 if (l1
== 'e' && ! IDENT_CHAR ((unsigned char) src
[2]))
1032 if (l1
== 's' && ! IDENT_CHAR ((unsigned char) src
[2]))
1043 if (! IDENT_CHAR ((unsigned char) src
[2]))
1049 if (TOLOWER (src
[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src
[3]))
1058 if (! IDENT_CHAR ((unsigned char) src
[2]))
1064 if (TOLOWER (src
[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src
[3]))
1072 if (l1
== 'x' && src
[2] >= '0' && src
[2] <= '1'
1073 && ! IDENT_CHAR ((unsigned char) src
[3]))
1076 *reg
= 4 + (l1
- '0');
1079 if (l1
== 'y' && src
[2] >= '0' && src
[2] <= '1'
1080 && ! IDENT_CHAR ((unsigned char) src
[3]))
1083 *reg
= 6 + (l1
- '0');
1086 if (l1
== 's' && src
[2] >= '0' && src
[2] <= '3'
1087 && ! IDENT_CHAR ((unsigned char) src
[3]))
1092 *reg
= n
| ((~n
& 2) << 1);
1097 if (l0
== 'i' && l1
&& ! IDENT_CHAR ((unsigned char) src
[2]))
1119 if (l0
== 'x' && l1
>= '0' && l1
<= '1'
1120 && ! IDENT_CHAR ((unsigned char) src
[2]))
1123 *reg
= A_X0_NUM
+ l1
- '0';
1127 if (l0
== 'y' && l1
>= '0' && l1
<= '1'
1128 && ! IDENT_CHAR ((unsigned char) src
[2]))
1131 *reg
= A_Y0_NUM
+ l1
- '0';
1135 if (l0
== 'm' && l1
>= '0' && l1
<= '1'
1136 && ! IDENT_CHAR ((unsigned char) src
[2]))
1139 *reg
= l1
== '0' ? A_M0_NUM
: A_M1_NUM
;
1145 && TOLOWER (src
[2]) == 'r' && ! IDENT_CHAR ((unsigned char) src
[3]))
1151 if (l0
== 's' && l1
== 'p' && TOLOWER (src
[2]) == 'c'
1152 && ! IDENT_CHAR ((unsigned char) src
[3]))
1158 if (l0
== 's' && l1
== 'g' && TOLOWER (src
[2]) == 'r'
1159 && ! IDENT_CHAR ((unsigned char) src
[3]))
1165 if (l0
== 'd' && l1
== 's' && TOLOWER (src
[2]) == 'r'
1166 && ! IDENT_CHAR ((unsigned char) src
[3]))
1172 if (l0
== 'd' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1173 && ! IDENT_CHAR ((unsigned char) src
[3]))
1179 if (l0
== 's' && l1
== 'r' && ! IDENT_CHAR ((unsigned char) src
[2]))
1185 if (l0
== 's' && l1
== 'p' && ! IDENT_CHAR ((unsigned char) src
[2]))
1192 if (l0
== 'p' && l1
== 'r' && ! IDENT_CHAR ((unsigned char) src
[2]))
1197 if (l0
== 'p' && l1
== 'c' && ! IDENT_CHAR ((unsigned char) src
[2]))
1199 /* Don't use A_DISP_PC here - that would accept stuff like 'mova pc,r0'
1200 and use an uninitialized immediate. */
1204 if (l0
== 'g' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1205 && ! IDENT_CHAR ((unsigned char) src
[3]))
1210 if (l0
== 'v' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1211 && ! IDENT_CHAR ((unsigned char) src
[3]))
1217 if (l0
== 't' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1218 && ! IDENT_CHAR ((unsigned char) src
[3]))
1223 if (l0
== 'm' && l1
== 'a' && TOLOWER (src
[2]) == 'c'
1224 && ! IDENT_CHAR ((unsigned char) src
[4]))
1226 if (TOLOWER (src
[3]) == 'l')
1231 if (TOLOWER (src
[3]) == 'h')
1237 if (l0
== 'm' && l1
== 'o' && TOLOWER (src
[2]) == 'd'
1238 && ! IDENT_CHAR ((unsigned char) src
[3]))
1243 if (l0
== 'f' && l1
== 'r')
1247 if (src
[3] >= '0' && src
[3] <= '5'
1248 && ! IDENT_CHAR ((unsigned char) src
[4]))
1251 *reg
= 10 + src
[3] - '0';
1255 if (src
[2] >= '0' && src
[2] <= '9'
1256 && ! IDENT_CHAR ((unsigned char) src
[3]))
1259 *reg
= (src
[2] - '0');
1263 if (l0
== 'd' && l1
== 'r')
1267 if (src
[3] >= '0' && src
[3] <= '4' && ! ((src
[3] - '0') & 1)
1268 && ! IDENT_CHAR ((unsigned char) src
[4]))
1271 *reg
= 10 + src
[3] - '0';
1275 if (src
[2] >= '0' && src
[2] <= '8' && ! ((src
[2] - '0') & 1)
1276 && ! IDENT_CHAR ((unsigned char) src
[3]))
1279 *reg
= (src
[2] - '0');
1283 if (l0
== 'x' && l1
== 'd')
1287 if (src
[3] >= '0' && src
[3] <= '4' && ! ((src
[3] - '0') & 1)
1288 && ! IDENT_CHAR ((unsigned char) src
[4]))
1291 *reg
= 11 + src
[3] - '0';
1295 if (src
[2] >= '0' && src
[2] <= '8' && ! ((src
[2] - '0') & 1)
1296 && ! IDENT_CHAR ((unsigned char) src
[3]))
1299 *reg
= (src
[2] - '0') + 1;
1303 if (l0
== 'f' && l1
== 'v')
1305 if (src
[2] == '1'&& src
[3] == '2' && ! IDENT_CHAR ((unsigned char) src
[4]))
1311 if ((src
[2] == '0' || src
[2] == '4' || src
[2] == '8')
1312 && ! IDENT_CHAR ((unsigned char) src
[3]))
1315 *reg
= (src
[2] - '0');
1319 if (l0
== 'f' && l1
== 'p' && TOLOWER (src
[2]) == 'u'
1320 && TOLOWER (src
[3]) == 'l'
1321 && ! IDENT_CHAR ((unsigned char) src
[4]))
1327 if (l0
== 'f' && l1
== 'p' && TOLOWER (src
[2]) == 's'
1328 && TOLOWER (src
[3]) == 'c'
1329 && TOLOWER (src
[4]) == 'r' && ! IDENT_CHAR ((unsigned char) src
[5]))
1335 if (l0
== 'x' && l1
== 'm' && TOLOWER (src
[2]) == 't'
1336 && TOLOWER (src
[3]) == 'r'
1337 && TOLOWER (src
[4]) == 'x' && ! IDENT_CHAR ((unsigned char) src
[5]))
1346 /* Like parse_reg_without_prefix, but this version supports
1347 $-prefixed register names if enabled by the user. */
1350 parse_reg (char *src
, int *mode
, int *reg
)
1352 unsigned int prefix
;
1353 unsigned int consumed
;
1357 if (allow_dollar_register_prefix
)
1368 consumed
= parse_reg_without_prefix (src
, mode
, reg
);
1373 return consumed
+ prefix
;
1377 parse_exp (char *s
, sh_operand_info
*op
)
1382 save
= input_line_pointer
;
1383 input_line_pointer
= s
;
1384 expression (&op
->immediate
);
1385 if (op
->immediate
.X_op
== O_absent
)
1386 as_bad (_("missing operand"));
1387 new_pointer
= input_line_pointer
;
1388 input_line_pointer
= save
;
1392 /* The many forms of operand:
1395 @Rn Register indirect
1408 pr, gbr, vbr, macl, mach
1412 parse_at (char *src
, sh_operand_info
*op
)
1419 src
= parse_at (src
, op
);
1420 if (op
->type
== A_DISP_TBR
)
1421 op
->type
= A_DISP2_TBR
;
1423 as_bad (_("illegal double indirection"));
1425 else if (src
[0] == '-')
1427 /* Must be predecrement. */
1430 len
= parse_reg (src
, &mode
, &(op
->reg
));
1431 if (mode
!= A_REG_N
)
1432 as_bad (_("illegal register after @-"));
1437 else if (src
[0] == '(')
1439 /* Could be @(disp, rn), @(disp, gbr), @(disp, pc), @(r0, gbr) or
1442 len
= parse_reg (src
, &mode
, &(op
->reg
));
1443 if (len
&& mode
== A_REG_N
)
1448 as_bad (_("must be @(r0,...)"));
1453 /* Now can be rn or gbr. */
1454 len
= parse_reg (src
, &mode
, &(op
->reg
));
1464 op
->type
= A_R0_GBR
;
1466 else if (mode
== A_REG_N
)
1468 op
->type
= A_IND_R0_REG_N
;
1472 as_bad (_("syntax error in @(r0,...)"));
1477 as_bad (_("syntax error in @(r0...)"));
1482 /* Must be an @(disp,.. thing). */
1483 src
= parse_exp (src
, op
);
1486 /* Now can be rn, gbr or pc. */
1487 len
= parse_reg (src
, &mode
, &op
->reg
);
1490 if (mode
== A_REG_N
)
1492 op
->type
= A_DISP_REG_N
;
1494 else if (mode
== A_GBR
)
1496 op
->type
= A_DISP_GBR
;
1498 else if (mode
== A_TBR
)
1500 op
->type
= A_DISP_TBR
;
1502 else if (mode
== A_PC
)
1504 /* We want @(expr, pc) to uniformly address . + expr,
1505 no matter if expr is a constant, or a more complex
1506 expression, e.g. sym-. or sym1-sym2.
1507 However, we also used to accept @(sym,pc)
1508 as addressing sym, i.e. meaning the same as plain sym.
1509 Some existing code does use the @(sym,pc) syntax, so
1510 we give it the old semantics for now, but warn about
1511 its use, so that users have some time to fix their code.
1513 Note that due to this backward compatibility hack,
1514 we'll get unexpected results when @(offset, pc) is used,
1515 and offset is a symbol that is set later to an an address
1516 difference, or an external symbol that is set to an
1517 address difference in another source file, so we want to
1518 eventually remove it. */
1519 if (op
->immediate
.X_op
== O_symbol
)
1521 op
->type
= A_DISP_PC
;
1522 as_warn (_("Deprecated syntax."));
1526 op
->type
= A_DISP_PC_ABS
;
1527 /* Such operands don't get corrected for PC==.+4, so
1528 make the correction here. */
1529 op
->immediate
.X_add_number
-= 4;
1534 as_bad (_("syntax error in @(disp,[Rn, gbr, pc])"));
1539 as_bad (_("syntax error in @(disp,[Rn, gbr, pc])"));
1544 as_bad (_("expecting )"));
1550 src
+= parse_reg (src
, &mode
, &(op
->reg
));
1551 if (mode
!= A_REG_N
)
1552 as_bad (_("illegal register after @"));
1559 l0
= TOLOWER (src
[0]);
1560 l1
= TOLOWER (src
[1]);
1562 if ((l0
== 'r' && l1
== '8')
1563 || (l0
== 'i' && (l1
== 'x' || l1
== 's')))
1566 op
->type
= AX_PMOD_N
;
1568 else if ( (l0
== 'r' && l1
== '9')
1569 || (l0
== 'i' && l1
== 'y'))
1572 op
->type
= AY_PMOD_N
;
1584 get_operand (char **ptr
, sh_operand_info
*op
)
1593 *ptr
= parse_exp (src
, op
);
1598 else if (src
[0] == '@')
1600 *ptr
= parse_at (src
, op
);
1603 len
= parse_reg (src
, &mode
, &(op
->reg
));
1612 /* Not a reg, the only thing left is a displacement. */
1613 *ptr
= parse_exp (src
, op
);
1614 op
->type
= A_DISP_PC
;
1620 get_operands (sh_opcode_info
*info
, char *args
, sh_operand_info
*operand
)
1625 /* The pre-processor will eliminate whitespace in front of '@'
1626 after the first argument; we may be called multiple times
1627 from assemble_ppi, so don't insist on finding whitespace here. */
1631 get_operand (&ptr
, operand
+ 0);
1638 get_operand (&ptr
, operand
+ 1);
1639 /* ??? Hack: psha/pshl have a varying operand number depending on
1640 the type of the first operand. We handle this by having the
1641 three-operand version first and reducing the number of operands
1642 parsed to two if we see that the first operand is an immediate.
1643 This works because no insn with three operands has an immediate
1644 as first operand. */
1645 if (info
->arg
[2] && operand
[0].type
!= A_IMM
)
1651 get_operand (&ptr
, operand
+ 2);
1655 operand
[2].type
= 0;
1660 operand
[1].type
= 0;
1661 operand
[2].type
= 0;
1666 operand
[0].type
= 0;
1667 operand
[1].type
= 0;
1668 operand
[2].type
= 0;
1673 /* Passed a pointer to a list of opcodes which use different
1674 addressing modes, return the opcode which matches the opcodes
1677 static sh_opcode_info
*
1678 get_specific (sh_opcode_info
*opcode
, sh_operand_info
*operands
)
1680 sh_opcode_info
*this_try
= opcode
;
1681 char *name
= opcode
->name
;
1684 while (opcode
->name
)
1686 this_try
= opcode
++;
1687 if ((this_try
->name
!= name
) && (strcmp (this_try
->name
, name
) != 0))
1689 /* We've looked so far down the table that we've run out of
1690 opcodes with the same name. */
1694 /* Look at both operands needed by the opcodes and provided by
1695 the user - since an arg test will often fail on the same arg
1696 again and again, we'll try and test the last failing arg the
1697 first on each opcode try. */
1698 for (n
= 0; this_try
->arg
[n
]; n
++)
1700 sh_operand_info
*user
= operands
+ n
;
1701 sh_arg_type arg
= this_try
->arg
[n
];
1706 if (user
->type
== A_DISP_PC_ABS
)
1717 if (user
->type
!= arg
)
1721 /* opcode needs r0 */
1722 if (user
->type
!= A_REG_N
|| user
->reg
!= 0)
1726 if (user
->type
!= A_R0_GBR
|| user
->reg
!= 0)
1730 if (user
->type
!= F_REG_N
|| user
->reg
!= 0)
1738 case A_IND_R0_REG_N
:
1747 /* Opcode needs rn */
1748 if (user
->type
!= arg
)
1753 if (user
->type
!= D_REG_N
&& user
->type
!= X_REG_N
)
1769 if (user
->type
!= arg
)
1774 if (user
->type
!= arg
)
1780 if (user
->type
!= A_INC_N
)
1782 if (user
->reg
!= 15)
1788 if (user
->type
!= A_DEC_N
)
1790 if (user
->reg
!= 15)
1799 case A_IND_R0_REG_M
:
1802 /* Opcode needs rn */
1803 if (user
->type
!= arg
- A_REG_M
+ A_REG_N
)
1809 if (user
->type
!= A_DEC_N
)
1811 if (user
->reg
< 2 || user
->reg
> 5)
1817 if (user
->type
!= A_INC_N
)
1819 if (user
->reg
< 2 || user
->reg
> 5)
1825 if (user
->type
!= A_IND_N
)
1827 if (user
->reg
< 2 || user
->reg
> 5)
1833 if (user
->type
!= AX_PMOD_N
)
1835 if (user
->reg
< 2 || user
->reg
> 5)
1841 if (user
->type
!= A_INC_N
)
1843 if (user
->reg
< 4 || user
->reg
> 5)
1849 if (user
->type
!= A_IND_N
)
1851 if (user
->reg
< 4 || user
->reg
> 5)
1857 if (user
->type
!= AX_PMOD_N
)
1859 if (user
->reg
< 4 || user
->reg
> 5)
1865 if (user
->type
!= A_INC_N
)
1867 if ((user
->reg
< 4 || user
->reg
> 5)
1868 && (user
->reg
< 0 || user
->reg
> 1))
1874 if (user
->type
!= A_IND_N
)
1876 if ((user
->reg
< 4 || user
->reg
> 5)
1877 && (user
->reg
< 0 || user
->reg
> 1))
1883 if (user
->type
!= AX_PMOD_N
)
1885 if ((user
->reg
< 4 || user
->reg
> 5)
1886 && (user
->reg
< 0 || user
->reg
> 1))
1892 if (user
->type
!= A_INC_N
)
1894 if (user
->reg
< 6 || user
->reg
> 7)
1900 if (user
->type
!= A_IND_N
)
1902 if (user
->reg
< 6 || user
->reg
> 7)
1908 if (user
->type
!= AY_PMOD_N
)
1910 if (user
->reg
< 6 || user
->reg
> 7)
1916 if (user
->type
!= A_INC_N
)
1918 if ((user
->reg
< 6 || user
->reg
> 7)
1919 && (user
->reg
< 2 || user
->reg
> 3))
1925 if (user
->type
!= A_IND_N
)
1927 if ((user
->reg
< 6 || user
->reg
> 7)
1928 && (user
->reg
< 2 || user
->reg
> 3))
1934 if (user
->type
!= AY_PMOD_N
)
1936 if ((user
->reg
< 6 || user
->reg
> 7)
1937 && (user
->reg
< 2 || user
->reg
> 3))
1943 if (user
->type
!= DSP_REG_N
)
1945 if (user
->reg
!= A_A0_NUM
1946 && user
->reg
!= A_A1_NUM
)
1952 if (user
->type
!= DSP_REG_N
)
1974 if (user
->type
!= DSP_REG_N
)
1996 if (user
->type
!= DSP_REG_N
)
2018 if (user
->type
!= DSP_REG_N
)
2040 if (user
->type
!= DSP_REG_N
)
2062 if (user
->type
!= DSP_REG_N
)
2084 if (user
->type
!= DSP_REG_N
)
2106 if (user
->type
!= DSP_REG_N
)
2128 if (user
->type
!= DSP_REG_N
)
2150 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_A0_NUM
)
2154 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_X0_NUM
)
2158 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_X1_NUM
)
2162 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_Y0_NUM
)
2166 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_Y1_NUM
)
2176 /* Opcode needs rn */
2177 if (user
->type
!= arg
- F_REG_M
+ F_REG_N
)
2182 if (user
->type
!= D_REG_N
&& user
->type
!= X_REG_N
)
2187 if (user
->type
!= XMTRX_M4
)
2193 printf (_("unhandled %d\n"), arg
);
2196 if (SH_MERGE_ARCH_SET_VALID (valid_arch
, arch_sh2a_nofpu_up
)
2197 && ( arg
== A_DISP_REG_M
2198 || arg
== A_DISP_REG_N
))
2200 /* Check a few key IMM* fields for overflow. */
2202 long val
= user
->immediate
.X_add_number
;
2204 for (opf
= 0; opf
< 4; opf
++)
2205 switch (this_try
->nibbles
[opf
])
2209 if (val
< 0 || val
> 15)
2214 if (val
< 0 || val
> 15 * 2)
2219 if (val
< 0 || val
> 15 * 4)
2227 if ( !SH_MERGE_ARCH_SET_VALID (valid_arch
, this_try
->arch
))
2229 valid_arch
= SH_MERGE_ARCH_SET (valid_arch
, this_try
->arch
);
2239 insert (char *where
, int how
, int pcrel
, sh_operand_info
*op
)
2241 fix_new_exp (frag_now
,
2242 where
- frag_now
->fr_literal
,
2250 insert4 (char * where
, int how
, int pcrel
, sh_operand_info
* op
)
2252 fix_new_exp (frag_now
,
2253 where
- frag_now
->fr_literal
,
2260 build_relax (sh_opcode_info
*opcode
, sh_operand_info
*op
)
2262 int high_byte
= target_big_endian
? 0 : 1;
2265 if (opcode
->arg
[0] == A_BDISP8
)
2267 int what
= (opcode
->nibbles
[1] & 4) ? COND_JUMP_DELAY
: COND_JUMP
;
2268 p
= frag_var (rs_machine_dependent
,
2269 md_relax_table
[C (what
, COND32
)].rlx_length
,
2270 md_relax_table
[C (what
, COND8
)].rlx_length
,
2272 op
->immediate
.X_add_symbol
,
2273 op
->immediate
.X_add_number
,
2275 p
[high_byte
] = (opcode
->nibbles
[0] << 4) | (opcode
->nibbles
[1]);
2277 else if (opcode
->arg
[0] == A_BDISP12
)
2279 p
= frag_var (rs_machine_dependent
,
2280 md_relax_table
[C (UNCOND_JUMP
, UNCOND32
)].rlx_length
,
2281 md_relax_table
[C (UNCOND_JUMP
, UNCOND12
)].rlx_length
,
2283 op
->immediate
.X_add_symbol
,
2284 op
->immediate
.X_add_number
,
2286 p
[high_byte
] = (opcode
->nibbles
[0] << 4);
2291 /* Insert ldrs & ldre with fancy relocations that relaxation can recognize. */
2294 insert_loop_bounds (char *output
, sh_operand_info
*operand
)
2299 /* Since the low byte of the opcode will be overwritten by the reloc, we
2300 can just stash the high byte into both bytes and ignore endianness. */
2303 insert (output
, BFD_RELOC_SH_LOOP_START
, 1, operand
);
2304 insert (output
, BFD_RELOC_SH_LOOP_END
, 1, operand
+ 1);
2308 static int count
= 0;
2310 /* If the last loop insn is a two-byte-insn, it is in danger of being
2311 swapped with the insn after it. To prevent this, create a new
2312 symbol - complete with SH_LABEL reloc - after the last loop insn.
2313 If the last loop insn is four bytes long, the symbol will be
2314 right in the middle, but four byte insns are not swapped anyways. */
2315 /* A REPEAT takes 6 bytes. The SH has a 32 bit address space.
2316 Hence a 9 digit number should be enough to count all REPEATs. */
2318 sprintf (name
, "_R%x", count
++ & 0x3fffffff);
2319 end_sym
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
2320 /* Make this a local symbol. */
2322 SF_SET_LOCAL (end_sym
);
2323 #endif /* OBJ_COFF */
2324 symbol_table_insert (end_sym
);
2325 end_sym
->sy_value
= operand
[1].immediate
;
2326 end_sym
->sy_value
.X_add_number
+= 2;
2327 fix_new (frag_now
, frag_now_fix (), 2, end_sym
, 0, 1, BFD_RELOC_SH_LABEL
);
2330 output
= frag_more (2);
2333 insert (output
, BFD_RELOC_SH_LOOP_START
, 1, operand
);
2334 insert (output
, BFD_RELOC_SH_LOOP_END
, 1, operand
+ 1);
2336 return frag_more (2);
2339 /* Now we know what sort of opcodes it is, let's build the bytes. */
2342 build_Mytes (sh_opcode_info
*opcode
, sh_operand_info
*operand
)
2347 unsigned int size
= 2;
2348 int low_byte
= target_big_endian
? 1 : 0;
2350 bfd_reloc_code_real_type r_type
;
2352 int unhandled_pic
= 0;
2365 for (indx
= 0; indx
< 3; indx
++)
2366 if (opcode
->arg
[indx
] == A_IMM
2367 && operand
[indx
].type
== A_IMM
2368 && (operand
[indx
].immediate
.X_op
== O_PIC_reloc
2369 || sh_PIC_related_p (operand
[indx
].immediate
.X_add_symbol
)
2370 || sh_PIC_related_p (operand
[indx
].immediate
.X_op_symbol
)))
2374 if (SH_MERGE_ARCH_SET (opcode
->arch
, arch_op32
))
2376 output
= frag_more (4);
2381 output
= frag_more (2);
2383 for (indx
= 0; indx
< max_index
; indx
++)
2385 sh_nibble_type i
= opcode
->nibbles
[indx
];
2402 if (reg_n
< 2 || reg_n
> 5)
2403 as_bad (_("Invalid register: 'r%d'"), reg_n
);
2404 nbuf
[indx
] = (reg_n
& 3) | 4;
2407 nbuf
[indx
] = reg_n
| (reg_m
>> 2);
2410 nbuf
[indx
] = reg_b
| 0x08;
2413 nbuf
[indx
] = reg_n
| 0x01;
2418 insert (output
+ low_byte
, BFD_RELOC_SH_IMM3
, 0, operand
);
2423 insert (output
+ low_byte
, BFD_RELOC_SH_IMM3U
, 0, operand
);
2426 insert (output
+ 2, BFD_RELOC_SH_DISP12
, 0, operand
);
2429 insert (output
+ 2, BFD_RELOC_SH_DISP12BY2
, 0, operand
);
2432 insert (output
+ 2, BFD_RELOC_SH_DISP12BY4
, 0, operand
);
2435 insert (output
+ 2, BFD_RELOC_SH_DISP12BY8
, 0, operand
);
2438 insert (output
+ 2, BFD_RELOC_SH_DISP12
, 0, operand
+1);
2441 insert (output
+ 2, BFD_RELOC_SH_DISP12BY2
, 0, operand
+1);
2444 insert (output
+ 2, BFD_RELOC_SH_DISP12BY4
, 0, operand
+1);
2447 insert (output
+ 2, BFD_RELOC_SH_DISP12BY8
, 0, operand
+1);
2452 r_type
= BFD_RELOC_SH_DISP20
;
2454 if (sh_check_fixup (&operand
->immediate
, &r_type
))
2455 as_bad (_("Invalid PIC expression."));
2458 insert4 (output
, r_type
, 0, operand
);
2461 insert4 (output
, BFD_RELOC_SH_DISP20BY8
, 0, operand
);
2464 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY4
, 0, operand
);
2467 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY2
, 0, operand
);
2470 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4
, 0, operand
);
2473 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY4
, 0, operand
+ 1);
2476 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY2
, 0, operand
+ 1);
2479 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4
, 0, operand
+ 1);
2482 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY4
, 0, operand
);
2485 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY2
, 0, operand
);
2488 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8
, 0, operand
);
2491 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY4
, 0, operand
+ 1);
2494 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY2
, 0, operand
+ 1);
2497 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8
, 0, operand
+ 1);
2500 insert (output
, BFD_RELOC_SH_PCRELIMM8BY4
,
2501 operand
->type
!= A_DISP_PC_ABS
, operand
);
2504 insert (output
, BFD_RELOC_SH_PCRELIMM8BY2
,
2505 operand
->type
!= A_DISP_PC_ABS
, operand
);
2508 output
= insert_loop_bounds (output
, operand
);
2509 nbuf
[indx
] = opcode
->nibbles
[3];
2513 printf (_("failed for %d\n"), i
);
2519 as_bad (_("misplaced PIC operand"));
2521 if (!target_big_endian
)
2523 output
[1] = (nbuf
[0] << 4) | (nbuf
[1]);
2524 output
[0] = (nbuf
[2] << 4) | (nbuf
[3]);
2528 output
[0] = (nbuf
[0] << 4) | (nbuf
[1]);
2529 output
[1] = (nbuf
[2] << 4) | (nbuf
[3]);
2531 if (SH_MERGE_ARCH_SET (opcode
->arch
, arch_op32
))
2533 if (!target_big_endian
)
2535 output
[3] = (nbuf
[4] << 4) | (nbuf
[5]);
2536 output
[2] = (nbuf
[6] << 4) | (nbuf
[7]);
2540 output
[2] = (nbuf
[4] << 4) | (nbuf
[5]);
2541 output
[3] = (nbuf
[6] << 4) | (nbuf
[7]);
2547 /* Find an opcode at the start of *STR_P in the hash table, and set
2548 *STR_P to the first character after the last one read. */
2550 static sh_opcode_info
*
2551 find_cooked_opcode (char **str_p
)
2554 unsigned char *op_start
;
2555 unsigned char *op_end
;
2557 unsigned int nlen
= 0;
2559 /* Drop leading whitespace. */
2563 /* Find the op code end.
2564 The pre-processor will eliminate whitespace in front of
2565 any '@' after the first argument; we may be called from
2566 assemble_ppi, so the opcode might be terminated by an '@'. */
2567 for (op_start
= op_end
= (unsigned char *) str
;
2569 && nlen
< sizeof (name
) - 1
2570 && !is_end_of_line
[*op_end
] && *op_end
!= ' ' && *op_end
!= '@';
2573 unsigned char c
= op_start
[nlen
];
2575 /* The machine independent code will convert CMP/EQ into cmp/EQ
2576 because it thinks the '/' is the end of the symbol. Moreover,
2577 all but the first sub-insn is a parallel processing insn won't
2578 be capitalized. Instead of hacking up the machine independent
2579 code, we just deal with it here. */
2586 *str_p
= (char *) op_end
;
2589 as_bad (_("can't find opcode "));
2591 return (sh_opcode_info
*) hash_find (opcode_hash_control
, name
);
2594 /* Assemble a parallel processing insn. */
2595 #define DDT_BASE 0xf000 /* Base value for double data transfer insns */
2598 assemble_ppi (char *op_end
, sh_opcode_info
*opcode
)
2610 sh_operand_info operand
[3];
2612 /* Some insn ignore one or more register fields, e.g. psts machl,a0.
2613 Make sure we encode a defined insn pattern. */
2618 if (opcode
->arg
[0] != A_END
)
2619 op_end
= get_operands (opcode
, op_end
, operand
);
2621 opcode
= get_specific (opcode
, operand
);
2624 /* Couldn't find an opcode which matched the operands. */
2625 char *where
= frag_more (2);
2630 as_bad (_("invalid operands for opcode"));
2634 if (opcode
->nibbles
[0] != PPI
)
2635 as_bad (_("insn can't be combined with parallel processing insn"));
2637 switch (opcode
->nibbles
[1])
2642 as_bad (_("multiple movx specifications"));
2647 as_bad (_("multiple movy specifications"));
2653 as_bad (_("multiple movx specifications"));
2654 if ((reg_n
< 4 || reg_n
> 5)
2655 && (reg_n
< 0 || reg_n
> 1))
2656 as_bad (_("invalid movx address register"));
2657 if (movy
&& movy
!= DDT_BASE
)
2658 as_bad (_("insn cannot be combined with non-nopy"));
2659 movx
= ((((reg_n
& 1) != 0) << 9)
2660 + (((reg_n
& 4) == 0) << 8)
2662 + (opcode
->nibbles
[2] << 4)
2663 + opcode
->nibbles
[3]
2669 as_bad (_("multiple movy specifications"));
2670 if ((reg_n
< 6 || reg_n
> 7)
2671 && (reg_n
< 2 || reg_n
> 3))
2672 as_bad (_("invalid movy address register"));
2673 if (movx
&& movx
!= DDT_BASE
)
2674 as_bad (_("insn cannot be combined with non-nopx"));
2675 movy
= ((((reg_n
& 1) != 0) << 8)
2676 + (((reg_n
& 4) == 0) << 9)
2678 + (opcode
->nibbles
[2] << 4)
2679 + opcode
->nibbles
[3]
2685 as_bad (_("multiple movx specifications"));
2687 as_bad (_("previous movy requires nopx"));
2688 if (reg_n
< 4 || reg_n
> 5)
2689 as_bad (_("invalid movx address register"));
2690 if (opcode
->nibbles
[2] & 8)
2692 if (reg_m
== A_A1_NUM
)
2694 else if (reg_m
!= A_A0_NUM
)
2695 as_bad (_("invalid movx dsp register"));
2700 as_bad (_("invalid movx dsp register"));
2703 movx
+= ((reg_n
- 4) << 9) + (opcode
->nibbles
[2] << 2) + DDT_BASE
;
2708 as_bad (_("multiple movy specifications"));
2710 as_bad (_("previous movx requires nopy"));
2711 if (opcode
->nibbles
[2] & 8)
2713 /* Bit 3 in nibbles[2] is intended for bit 4 of the opcode,
2716 if (reg_m
== A_A1_NUM
)
2718 else if (reg_m
!= A_A0_NUM
)
2719 as_bad (_("invalid movy dsp register"));
2724 as_bad (_("invalid movy dsp register"));
2727 if (reg_n
< 6 || reg_n
> 7)
2728 as_bad (_("invalid movy address register"));
2729 movy
+= ((reg_n
- 6) << 8) + opcode
->nibbles
[2] + DDT_BASE
;
2733 if (operand
[0].immediate
.X_op
!= O_constant
)
2734 as_bad (_("dsp immediate shift value not constant"));
2735 field_b
= ((opcode
->nibbles
[2] << 12)
2736 | (operand
[0].immediate
.X_add_number
& 127) << 4
2743 goto try_another_opcode
;
2748 as_bad (_("multiple parallel processing specifications"));
2749 field_b
= ((opcode
->nibbles
[2] << 12) + (opcode
->nibbles
[3] << 8)
2750 + (reg_x
<< 6) + (reg_y
<< 4) + reg_n
);
2751 switch (opcode
->nibbles
[4])
2759 field_b
+= opcode
->nibbles
[4] << 4;
2767 as_bad (_("multiple condition specifications"));
2768 cond
= opcode
->nibbles
[2] << 8;
2770 goto skip_cond_check
;
2774 as_bad (_("multiple parallel processing specifications"));
2775 field_b
= ((opcode
->nibbles
[2] << 12) + (opcode
->nibbles
[3] << 8)
2776 + cond
+ (reg_x
<< 6) + (reg_y
<< 4) + reg_n
);
2778 switch (opcode
->nibbles
[4])
2786 field_b
+= opcode
->nibbles
[4] << 4;
2795 if ((field_b
& 0xef00) == 0xa100)
2797 /* pclr Dz pmuls Se,Sf,Dg */
2798 else if ((field_b
& 0xff00) == 0x8d00
2799 && (SH_MERGE_ARCH_SET_VALID (valid_arch
, arch_sh4al_dsp_up
)))
2801 valid_arch
= SH_MERGE_ARCH_SET (valid_arch
, arch_sh4al_dsp_up
);
2805 as_bad (_("insn cannot be combined with pmuls"));
2806 switch (field_b
& 0xf)
2809 field_b
+= 0 - A_X0_NUM
;
2812 field_b
+= 1 - A_Y0_NUM
;
2815 field_b
+= 2 - A_A0_NUM
;
2818 field_b
+= 3 - A_A1_NUM
;
2821 as_bad (_("bad combined pmuls output operand"));
2823 /* Generate warning if the destination register for padd / psub
2824 and pmuls is the same ( only for A0 or A1 ).
2825 If the last nibble is 1010 then A0 is used in both
2826 padd / psub and pmuls. If it is 1111 then A1 is used
2827 as destination register in both padd / psub and pmuls. */
2829 if ((((field_b
| reg_efg
) & 0x000F) == 0x000A)
2830 || (((field_b
| reg_efg
) & 0x000F) == 0x000F))
2831 as_warn (_("destination register is same for parallel insns"));
2833 field_b
+= 0x4000 + reg_efg
;
2840 as_bad (_("condition not followed by conditionalizable insn"));
2846 opcode
= find_cooked_opcode (&op_end
);
2850 (_("unrecognized characters at end of parallel processing insn")));
2855 move_code
= movx
| movy
;
2858 /* Parallel processing insn. */
2859 unsigned long ppi_code
= (movx
| movy
| 0xf800) << 16 | field_b
;
2861 output
= frag_more (4);
2863 if (! target_big_endian
)
2865 output
[3] = ppi_code
>> 8;
2866 output
[2] = ppi_code
;
2870 output
[2] = ppi_code
>> 8;
2871 output
[3] = ppi_code
;
2873 move_code
|= 0xf800;
2877 /* Just a double data transfer. */
2878 output
= frag_more (2);
2881 if (! target_big_endian
)
2883 output
[1] = move_code
>> 8;
2884 output
[0] = move_code
;
2888 output
[0] = move_code
>> 8;
2889 output
[1] = move_code
;
2894 /* This is the guts of the machine-dependent assembler. STR points to a
2895 machine dependent instruction. This function is supposed to emit
2896 the frags/bytes it assembles to. */
2899 md_assemble (char *str
)
2902 sh_operand_info operand
[3];
2903 sh_opcode_info
*opcode
;
2904 unsigned int size
= 0;
2905 char *initial_str
= str
;
2908 if (sh64_isa_mode
== sh64_isa_shmedia
)
2910 shmedia_md_assemble (str
);
2915 /* If we've seen pseudo-directives, make sure any emitted data or
2916 frags are marked as data. */
2919 sh64_update_contents_mark (TRUE
);
2920 sh64_set_contents_type (CRT_SH5_ISA16
);
2925 #endif /* HAVE_SH64 */
2927 opcode
= find_cooked_opcode (&str
);
2932 /* The opcode is not in the hash table.
2933 This means we definitely have an assembly failure,
2934 but the instruction may be valid in another CPU variant.
2935 In this case emit something better than 'unknown opcode'.
2936 Search the full table in sh-opc.h to check. */
2938 char *name
= initial_str
;
2939 int name_length
= 0;
2940 const sh_opcode_info
*op
;
2943 /* identify opcode in string */
2944 while (ISSPACE (*name
))
2948 while (!ISSPACE (name
[name_length
]))
2953 /* search for opcode in full list */
2954 for (op
= sh_table
; op
->name
; op
++)
2956 if (strncasecmp (op
->name
, name
, name_length
) == 0
2957 && op
->name
[name_length
] == '\0')
2966 as_bad (_("opcode not valid for this cpu variant"));
2970 as_bad (_("unknown opcode"));
2976 && ! seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2978 /* Output a CODE reloc to tell the linker that the following
2979 bytes are instructions, not data. */
2980 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0,
2982 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 1;
2985 if (opcode
->nibbles
[0] == PPI
)
2987 size
= assemble_ppi (op_end
, opcode
);
2991 if (opcode
->arg
[0] == A_BDISP12
2992 || opcode
->arg
[0] == A_BDISP8
)
2994 /* Since we skip get_specific here, we have to check & update
2996 if (SH_MERGE_ARCH_SET_VALID (valid_arch
, opcode
->arch
))
2997 valid_arch
= SH_MERGE_ARCH_SET (valid_arch
, opcode
->arch
);
2999 as_bad (_("Delayed branches not available on SH1"));
3000 parse_exp (op_end
+ 1, &operand
[0]);
3001 build_relax (opcode
, &operand
[0]);
3003 /* All branches are currently 16 bit. */
3008 if (opcode
->arg
[0] == A_END
)
3010 /* Ignore trailing whitespace. If there is any, it has already
3011 been compressed to a single space. */
3017 op_end
= get_operands (opcode
, op_end
, operand
);
3019 opcode
= get_specific (opcode
, operand
);
3023 /* Couldn't find an opcode which matched the operands. */
3024 char *where
= frag_more (2);
3029 as_bad (_("invalid operands for opcode"));
3034 as_bad (_("excess operands: '%s'"), op_end
);
3036 size
= build_Mytes (opcode
, operand
);
3041 dwarf2_emit_insn (size
);
3044 /* This routine is called each time a label definition is seen. It
3045 emits a BFD_RELOC_SH_LABEL reloc if necessary. */
3048 sh_frob_label (symbolS
*sym
)
3050 static fragS
*last_label_frag
;
3051 static int last_label_offset
;
3054 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
3058 offset
= frag_now_fix ();
3059 if (frag_now
!= last_label_frag
3060 || offset
!= last_label_offset
)
3062 fix_new (frag_now
, offset
, 2, &abs_symbol
, 0, 0, BFD_RELOC_SH_LABEL
);
3063 last_label_frag
= frag_now
;
3064 last_label_offset
= offset
;
3068 dwarf2_emit_label (sym
);
3071 /* This routine is called when the assembler is about to output some
3072 data. It emits a BFD_RELOC_SH_DATA reloc if necessary. */
3075 sh_flush_pending_output (void)
3078 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
3080 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0,
3082 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 0;
3087 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
3092 /* Various routines to kill one day. */
3095 md_atof (int type
, char *litP
, int *sizeP
)
3097 return ieee_md_atof (type
, litP
, sizeP
, target_big_endian
);
3100 /* Handle the .uses pseudo-op. This pseudo-op is used just before a
3101 call instruction. It refers to a label of the instruction which
3102 loads the register which the call uses. We use it to generate a
3103 special reloc for the linker. */
3106 s_uses (int ignore ATTRIBUTE_UNUSED
)
3111 as_warn (_(".uses pseudo-op seen when not relaxing"));
3115 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
3117 as_bad (_("bad .uses format"));
3118 ignore_rest_of_line ();
3122 fix_new_exp (frag_now
, frag_now_fix (), 2, &ex
, 1, BFD_RELOC_SH_USES
);
3124 demand_empty_rest_of_line ();
3129 OPTION_RELAX
= OPTION_MD_BASE
,
3136 OPTION_ALLOW_REG_PREFIX
,
3140 OPTION_SHCOMPACT_CONST_CRANGE
,
3148 OPTION_DUMMY
/* Not used. This is just here to make it easy to add and subtract options from this enum. */
3151 const char *md_shortopts
= "";
3152 struct option md_longopts
[] =
3154 {"relax", no_argument
, NULL
, OPTION_RELAX
},
3155 {"big", no_argument
, NULL
, OPTION_BIG
},
3156 {"little", no_argument
, NULL
, OPTION_LITTLE
},
3157 /* The next two switches are here because the
3158 generic parts of the linker testsuite uses them. */
3159 {"EB", no_argument
, NULL
, OPTION_BIG
},
3160 {"EL", no_argument
, NULL
, OPTION_LITTLE
},
3161 {"small", no_argument
, NULL
, OPTION_SMALL
},
3162 {"dsp", no_argument
, NULL
, OPTION_DSP
},
3163 {"isa", required_argument
, NULL
, OPTION_ISA
},
3164 {"renesas", no_argument
, NULL
, OPTION_RENESAS
},
3165 {"allow-reg-prefix", no_argument
, NULL
, OPTION_ALLOW_REG_PREFIX
},
3168 {"abi", required_argument
, NULL
, OPTION_ABI
},
3169 {"no-mix", no_argument
, NULL
, OPTION_NO_MIX
},
3170 {"shcompact-const-crange", no_argument
, NULL
, OPTION_SHCOMPACT_CONST_CRANGE
},
3171 {"no-expand", no_argument
, NULL
, OPTION_NO_EXPAND
},
3172 {"expand-pt32", no_argument
, NULL
, OPTION_PT32
},
3173 #endif /* HAVE_SH64 */
3174 { "h-tick-hex", no_argument
, NULL
, OPTION_H_TICK_HEX
},
3177 {"fdpic", no_argument
, NULL
, OPTION_FDPIC
},
3180 {NULL
, no_argument
, NULL
, 0}
3182 size_t md_longopts_size
= sizeof (md_longopts
);
3185 md_parse_option (int c
, char *arg ATTRIBUTE_UNUSED
)
3194 target_big_endian
= 1;
3198 target_big_endian
= 0;
3206 preset_target_arch
= arch_sh_up
& ~(arch_sh_sp_fpu
|arch_sh_dp_fpu
);
3209 case OPTION_RENESAS
:
3210 dont_adjust_reloc_32
= 1;
3213 case OPTION_ALLOW_REG_PREFIX
:
3214 allow_dollar_register_prefix
= 1;
3218 if (strcasecmp (arg
, "dsp") == 0)
3219 preset_target_arch
= arch_sh_up
& ~(arch_sh_sp_fpu
|arch_sh_dp_fpu
);
3220 else if (strcasecmp (arg
, "fp") == 0)
3221 preset_target_arch
= arch_sh_up
& ~arch_sh_has_dsp
;
3222 else if (strcasecmp (arg
, "any") == 0)
3223 preset_target_arch
= arch_sh_up
;
3225 else if (strcasecmp (arg
, "shmedia") == 0)
3227 if (sh64_isa_mode
== sh64_isa_shcompact
)
3228 as_bad (_("Invalid combination: --isa=SHcompact with --isa=SHmedia"));
3229 sh64_isa_mode
= sh64_isa_shmedia
;
3231 else if (strcasecmp (arg
, "shcompact") == 0)
3233 if (sh64_isa_mode
== sh64_isa_shmedia
)
3234 as_bad (_("Invalid combination: --isa=SHmedia with --isa=SHcompact"));
3235 if (sh64_abi
== sh64_abi_64
)
3236 as_bad (_("Invalid combination: --abi=64 with --isa=SHcompact"));
3237 sh64_isa_mode
= sh64_isa_shcompact
;
3239 #endif /* HAVE_SH64 */
3242 extern const bfd_arch_info_type bfd_sh_arch
;
3243 bfd_arch_info_type
const *bfd_arch
= &bfd_sh_arch
;
3245 preset_target_arch
= 0;
3246 for (; bfd_arch
; bfd_arch
=bfd_arch
->next
)
3248 int len
= strlen(bfd_arch
->printable_name
);
3250 if (bfd_arch
->mach
== bfd_mach_sh5
)
3253 if (strncasecmp (bfd_arch
->printable_name
, arg
, len
) != 0)
3256 if (arg
[len
] == '\0')
3257 preset_target_arch
=
3258 sh_get_arch_from_bfd_mach (bfd_arch
->mach
);
3259 else if (strcasecmp(&arg
[len
], "-up") == 0)
3260 preset_target_arch
=
3261 sh_get_arch_up_from_bfd_mach (bfd_arch
->mach
);
3267 if (!preset_target_arch
)
3268 as_bad (_("Invalid argument to --isa option: %s"), arg
);
3274 if (strcmp (arg
, "32") == 0)
3276 if (sh64_abi
== sh64_abi_64
)
3277 as_bad (_("Invalid combination: --abi=32 with --abi=64"));
3278 sh64_abi
= sh64_abi_32
;
3280 else if (strcmp (arg
, "64") == 0)
3282 if (sh64_abi
== sh64_abi_32
)
3283 as_bad (_("Invalid combination: --abi=64 with --abi=32"));
3284 if (sh64_isa_mode
== sh64_isa_shcompact
)
3285 as_bad (_("Invalid combination: --isa=SHcompact with --abi=64"));
3286 sh64_abi
= sh64_abi_64
;
3289 as_bad (_("Invalid argument to --abi option: %s"), arg
);
3296 case OPTION_SHCOMPACT_CONST_CRANGE
:
3297 sh64_shcompact_const_crange
= TRUE
;
3300 case OPTION_NO_EXPAND
:
3301 sh64_expand
= FALSE
;
3307 #endif /* HAVE_SH64 */
3309 case OPTION_H_TICK_HEX
:
3310 enable_h_tick_hex
= 1;
3317 #endif /* OBJ_ELF */
3327 md_show_usage (FILE *stream
)
3329 fprintf (stream
, _("\
3331 --little generate little endian code\n\
3332 --big generate big endian code\n\
3333 --relax alter jump instructions for long displacements\n\
3334 --renesas disable optimization with section symbol for\n\
3335 compatibility with Renesas assembler.\n\
3336 --small align sections to 4 byte boundaries, not 16\n\
3337 --dsp enable sh-dsp insns, and disable floating-point ISAs.\n\
3338 --allow-reg-prefix allow '$' as a register name prefix.\n\
3339 --isa=[any use most appropriate isa\n\
3340 | dsp same as '-dsp'\n\
3343 extern const bfd_arch_info_type bfd_sh_arch
;
3344 bfd_arch_info_type
const *bfd_arch
= &bfd_sh_arch
;
3346 for (; bfd_arch
; bfd_arch
=bfd_arch
->next
)
3347 if (bfd_arch
->mach
!= bfd_mach_sh5
)
3349 fprintf (stream
, "\n | %s", bfd_arch
->printable_name
);
3350 fprintf (stream
, "\n | %s-up", bfd_arch
->printable_name
);
3353 fprintf (stream
, "]\n");
3355 fprintf (stream
, _("\
3356 --isa=[shmedia set as the default instruction set for SH64\n\
3360 fprintf (stream
, _("\
3361 --abi=[32|64] set size of expanded SHmedia operands and object\n\
3363 --shcompact-const-crange emit code-range descriptors for constants in\n\
3364 SHcompact code sections\n\
3365 --no-mix disallow SHmedia code in the same section as\n\
3366 constants and SHcompact code\n\
3367 --no-expand do not expand MOVI, PT, PTA or PTB instructions\n\
3368 --expand-pt32 with -abi=64, expand PT, PTA and PTB instructions\n\
3369 to 32 bits only\n"));
3370 #endif /* HAVE_SH64 */
3372 fprintf (stream
, _("\
3373 --fdpic generate an FDPIC object file\n"));
3374 #endif /* OBJ_ELF */
3377 /* This struct is used to pass arguments to sh_count_relocs through
3378 bfd_map_over_sections. */
3380 struct sh_count_relocs
3382 /* Symbol we are looking for. */
3384 /* Count of relocs found. */
3388 /* Count the number of fixups in a section which refer to a particular
3389 symbol. This is called via bfd_map_over_sections. */
3392 sh_count_relocs (bfd
*abfd ATTRIBUTE_UNUSED
, segT sec
, void *data
)
3394 struct sh_count_relocs
*info
= (struct sh_count_relocs
*) data
;
3395 segment_info_type
*seginfo
;
3399 seginfo
= seg_info (sec
);
3400 if (seginfo
== NULL
)
3404 for (fix
= seginfo
->fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
3406 if (fix
->fx_addsy
== sym
)
3414 /* Handle the count relocs for a particular section.
3415 This is called via bfd_map_over_sections. */
3418 sh_frob_section (bfd
*abfd ATTRIBUTE_UNUSED
, segT sec
,
3419 void *ignore ATTRIBUTE_UNUSED
)
3421 segment_info_type
*seginfo
;
3424 seginfo
= seg_info (sec
);
3425 if (seginfo
== NULL
)
3428 for (fix
= seginfo
->fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
3432 sym
= fix
->fx_addsy
;
3433 /* Check for a local_symbol. */
3434 if (sym
&& sym
->bsym
== NULL
)
3436 struct local_symbol
*ls
= (struct local_symbol
*)sym
;
3437 /* See if it's been converted. If so, canonicalize. */
3438 if (local_symbol_converted_p (ls
))
3439 fix
->fx_addsy
= local_symbol_get_real_symbol (ls
);
3443 for (fix
= seginfo
->fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
3448 struct sh_count_relocs info
;
3450 if (fix
->fx_r_type
!= BFD_RELOC_SH_USES
)
3453 /* The BFD_RELOC_SH_USES reloc should refer to a defined local
3454 symbol in the same section. */
3455 sym
= fix
->fx_addsy
;
3457 || fix
->fx_subsy
!= NULL
3458 || fix
->fx_addnumber
!= 0
3459 || S_GET_SEGMENT (sym
) != sec
3460 || S_IS_EXTERNAL (sym
))
3462 as_warn_where (fix
->fx_file
, fix
->fx_line
,
3463 _(".uses does not refer to a local symbol in the same section"));
3467 /* Look through the fixups again, this time looking for one
3468 at the same location as sym. */
3469 val
= S_GET_VALUE (sym
);
3470 for (fscan
= seginfo
->fix_root
;
3472 fscan
= fscan
->fx_next
)
3473 if (val
== fscan
->fx_frag
->fr_address
+ fscan
->fx_where
3474 && fscan
->fx_r_type
!= BFD_RELOC_SH_ALIGN
3475 && fscan
->fx_r_type
!= BFD_RELOC_SH_CODE
3476 && fscan
->fx_r_type
!= BFD_RELOC_SH_DATA
3477 && fscan
->fx_r_type
!= BFD_RELOC_SH_LABEL
)
3481 as_warn_where (fix
->fx_file
, fix
->fx_line
,
3482 _("can't find fixup pointed to by .uses"));
3486 if (fscan
->fx_tcbit
)
3488 /* We've already done this one. */
3492 /* The variable fscan should also be a fixup to a local symbol
3493 in the same section. */
3494 sym
= fscan
->fx_addsy
;
3496 || fscan
->fx_subsy
!= NULL
3497 || fscan
->fx_addnumber
!= 0
3498 || S_GET_SEGMENT (sym
) != sec
3499 || S_IS_EXTERNAL (sym
))
3501 as_warn_where (fix
->fx_file
, fix
->fx_line
,
3502 _(".uses target does not refer to a local symbol in the same section"));
3506 /* Now we look through all the fixups of all the sections,
3507 counting the number of times we find a reference to sym. */
3510 bfd_map_over_sections (stdoutput
, sh_count_relocs
, &info
);
3515 /* Generate a BFD_RELOC_SH_COUNT fixup at the location of sym.
3516 We have already adjusted the value of sym to include the
3517 fragment address, so we undo that adjustment here. */
3518 subseg_change (sec
, 0);
3519 fix_new (fscan
->fx_frag
,
3520 S_GET_VALUE (sym
) - fscan
->fx_frag
->fr_address
,
3521 4, &abs_symbol
, info
.count
, 0, BFD_RELOC_SH_COUNT
);
3525 /* This function is called after the symbol table has been completed,
3526 but before the relocs or section contents have been written out.
3527 If we have seen any .uses pseudo-ops, they point to an instruction
3528 which loads a register with the address of a function. We look
3529 through the fixups to find where the function address is being
3530 loaded from. We then generate a COUNT reloc giving the number of
3531 times that function address is referred to. The linker uses this
3532 information when doing relaxing, to decide when it can eliminate
3533 the stored function address entirely. */
3539 shmedia_frob_file_before_adjust ();
3545 bfd_map_over_sections (stdoutput
, sh_frob_section
, NULL
);
3548 /* Called after relaxing. Set the correct sizes of the fragments, and
3549 create relocs so that md_apply_fix will fill in the correct values. */
3552 md_convert_frag (bfd
*headers ATTRIBUTE_UNUSED
, segT seg
, fragS
*fragP
)
3556 switch (fragP
->fr_subtype
)
3558 case C (COND_JUMP
, COND8
):
3559 case C (COND_JUMP_DELAY
, COND8
):
3560 subseg_change (seg
, 0);
3561 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
3562 1, BFD_RELOC_SH_PCDISP8BY2
);
3567 case C (UNCOND_JUMP
, UNCOND12
):
3568 subseg_change (seg
, 0);
3569 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
3570 1, BFD_RELOC_SH_PCDISP12BY2
);
3575 case C (UNCOND_JUMP
, UNCOND32
):
3576 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
3577 if (fragP
->fr_symbol
== NULL
)
3578 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3579 _("displacement overflows 12-bit field"));
3580 else if (S_IS_DEFINED (fragP
->fr_symbol
))
3581 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3582 _("displacement to defined symbol %s overflows 12-bit field"),
3583 S_GET_NAME (fragP
->fr_symbol
));
3585 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3586 _("displacement to undefined symbol %s overflows 12-bit field"),
3587 S_GET_NAME (fragP
->fr_symbol
));
3588 /* Stabilize this frag, so we don't trip an assert. */
3589 fragP
->fr_fix
+= fragP
->fr_var
;
3593 case C (COND_JUMP
, COND12
):
3594 case C (COND_JUMP_DELAY
, COND12
):
3595 /* A bcond won't fit, so turn it into a b!cond; bra disp; nop. */
3596 /* I found that a relax failure for gcc.c-torture/execute/930628-1.c
3597 was due to gas incorrectly relaxing an out-of-range conditional
3598 branch with delay slot. It turned:
3599 bf.s L6 (slot mov.l r12,@(44,r0))
3602 2c: 8f 01 a0 8b bf.s 32 <_main+32> (slot bra L6)
3604 32: 10 cb mov.l r12,@(44,r0)
3605 Therefore, branches with delay slots have to be handled
3606 differently from ones without delay slots. */
3608 unsigned char *buffer
=
3609 (unsigned char *) (fragP
->fr_fix
+ fragP
->fr_literal
);
3610 int highbyte
= target_big_endian
? 0 : 1;
3611 int lowbyte
= target_big_endian
? 1 : 0;
3612 int delay
= fragP
->fr_subtype
== C (COND_JUMP_DELAY
, COND12
);
3614 /* Toggle the true/false bit of the bcond. */
3615 buffer
[highbyte
] ^= 0x2;
3617 /* If this is a delayed branch, we may not put the bra in the
3618 slot. So we change it to a non-delayed branch, like that:
3619 b! cond slot_label; bra disp; slot_label: slot_insn
3620 ??? We should try if swapping the conditional branch and
3621 its delay-slot insn already makes the branch reach. */
3623 /* Build a relocation to six / four bytes farther on. */
3624 subseg_change (seg
, 0);
3625 fix_new (fragP
, fragP
->fr_fix
, 2, section_symbol (seg
),
3626 fragP
->fr_address
+ fragP
->fr_fix
+ (delay
? 4 : 6),
3627 1, BFD_RELOC_SH_PCDISP8BY2
);
3629 /* Set up a jump instruction. */
3630 buffer
[highbyte
+ 2] = 0xa0;
3631 buffer
[lowbyte
+ 2] = 0;
3632 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
3633 fragP
->fr_offset
, 1, BFD_RELOC_SH_PCDISP12BY2
);
3637 buffer
[highbyte
] &= ~0x4; /* Removes delay slot from branch. */
3642 /* Fill in a NOP instruction. */
3643 buffer
[highbyte
+ 4] = 0x0;
3644 buffer
[lowbyte
+ 4] = 0x9;
3653 case C (COND_JUMP
, COND32
):
3654 case C (COND_JUMP_DELAY
, COND32
):
3655 case C (COND_JUMP
, UNDEF_WORD_DISP
):
3656 case C (COND_JUMP_DELAY
, UNDEF_WORD_DISP
):
3657 if (fragP
->fr_symbol
== NULL
)
3658 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3659 _("displacement overflows 8-bit field"));
3660 else if (S_IS_DEFINED (fragP
->fr_symbol
))
3661 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3662 _("displacement to defined symbol %s overflows 8-bit field"),
3663 S_GET_NAME (fragP
->fr_symbol
));
3665 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3666 _("displacement to undefined symbol %s overflows 8-bit field "),
3667 S_GET_NAME (fragP
->fr_symbol
));
3668 /* Stabilize this frag, so we don't trip an assert. */
3669 fragP
->fr_fix
+= fragP
->fr_var
;
3675 shmedia_md_convert_frag (headers
, seg
, fragP
, TRUE
);
3681 if (donerelax
&& !sh_relax
)
3682 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
3683 _("overflow in branch to %s; converted into longer instruction sequence"),
3684 (fragP
->fr_symbol
!= NULL
3685 ? S_GET_NAME (fragP
->fr_symbol
)
3690 md_section_align (segT seg ATTRIBUTE_UNUSED
, valueT size
)
3694 #else /* ! OBJ_ELF */
3695 return ((size
+ (1 << bfd_get_section_alignment (stdoutput
, seg
)) - 1)
3696 & (-1 << bfd_get_section_alignment (stdoutput
, seg
)));
3697 #endif /* ! OBJ_ELF */
3700 /* This static variable is set by s_uacons to tell sh_cons_align that
3701 the expression does not need to be aligned. */
3703 static int sh_no_align_cons
= 0;
3705 /* This handles the unaligned space allocation pseudo-ops, such as
3706 .uaword. .uaword is just like .word, but the value does not need
3710 s_uacons (int bytes
)
3712 /* Tell sh_cons_align not to align this value. */
3713 sh_no_align_cons
= 1;
3717 /* If a .word, et. al., pseud-op is seen, warn if the value is not
3718 aligned correctly. Note that this can cause warnings to be issued
3719 when assembling initialized structured which were declared with the
3720 packed attribute. FIXME: Perhaps we should require an option to
3721 enable this warning? */
3724 sh_cons_align (int nbytes
)
3728 if (sh_no_align_cons
)
3730 /* This is an unaligned pseudo-op. */
3731 sh_no_align_cons
= 0;
3736 while ((nbytes
& 1) == 0)
3745 if (now_seg
== absolute_section
)
3747 if ((abs_section_offset
& ((1 << nalign
) - 1)) != 0)
3748 as_warn (_("misaligned data"));
3752 frag_var (rs_align_test
, 1, 1, (relax_substateT
) 0,
3753 (symbolS
*) NULL
, (offsetT
) nalign
, (char *) NULL
);
3755 record_alignment (now_seg
, nalign
);
3758 /* When relaxing, we need to output a reloc for any .align directive
3759 that requests alignment to a four byte boundary or larger. This is
3760 also where we check for misaligned data. */
3763 sh_handle_align (fragS
*frag
)
3765 int bytes
= frag
->fr_next
->fr_address
- frag
->fr_address
- frag
->fr_fix
;
3767 if (frag
->fr_type
== rs_align_code
)
3769 static const unsigned char big_nop_pattern
[] = { 0x00, 0x09 };
3770 static const unsigned char little_nop_pattern
[] = { 0x09, 0x00 };
3772 char *p
= frag
->fr_literal
+ frag
->fr_fix
;
3781 if (target_big_endian
)
3783 memcpy (p
, big_nop_pattern
, sizeof big_nop_pattern
);
3784 frag
->fr_var
= sizeof big_nop_pattern
;
3788 memcpy (p
, little_nop_pattern
, sizeof little_nop_pattern
);
3789 frag
->fr_var
= sizeof little_nop_pattern
;
3792 else if (frag
->fr_type
== rs_align_test
)
3795 as_bad_where (frag
->fr_file
, frag
->fr_line
, _("misaligned data"));
3799 && (frag
->fr_type
== rs_align
3800 || frag
->fr_type
== rs_align_code
)
3801 && frag
->fr_address
+ frag
->fr_fix
> 0
3802 && frag
->fr_offset
> 1
3803 && now_seg
!= bss_section
)
3804 fix_new (frag
, frag
->fr_fix
, 2, &abs_symbol
, frag
->fr_offset
, 0,
3805 BFD_RELOC_SH_ALIGN
);
3808 /* See whether the relocation should be resolved locally. */
3811 sh_local_pcrel (fixS
*fix
)
3814 && (fix
->fx_r_type
== BFD_RELOC_SH_PCDISP8BY2
3815 || fix
->fx_r_type
== BFD_RELOC_SH_PCDISP12BY2
3816 || fix
->fx_r_type
== BFD_RELOC_SH_PCRELIMM8BY2
3817 || fix
->fx_r_type
== BFD_RELOC_SH_PCRELIMM8BY4
3818 || fix
->fx_r_type
== BFD_RELOC_8_PCREL
3819 || fix
->fx_r_type
== BFD_RELOC_SH_SWITCH16
3820 || fix
->fx_r_type
== BFD_RELOC_SH_SWITCH32
));
3823 /* See whether we need to force a relocation into the output file.
3824 This is used to force out switch and PC relative relocations when
3828 sh_force_relocation (fixS
*fix
)
3830 /* These relocations can't make it into a DSO, so no use forcing
3831 them for global symbols. */
3832 if (sh_local_pcrel (fix
))
3835 /* Make sure some relocations get emitted. */
3836 if (fix
->fx_r_type
== BFD_RELOC_SH_LOOP_START
3837 || fix
->fx_r_type
== BFD_RELOC_SH_LOOP_END
3838 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_GD_32
3839 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_LD_32
3840 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_IE_32
3841 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_LDO_32
3842 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_LE_32
3843 || generic_force_reloc (fix
))
3849 return (fix
->fx_pcrel
3850 || SWITCH_TABLE (fix
)
3851 || fix
->fx_r_type
== BFD_RELOC_SH_COUNT
3852 || fix
->fx_r_type
== BFD_RELOC_SH_ALIGN
3853 || fix
->fx_r_type
== BFD_RELOC_SH_CODE
3854 || fix
->fx_r_type
== BFD_RELOC_SH_DATA
3856 || fix
->fx_r_type
== BFD_RELOC_SH_SHMEDIA_CODE
3858 || fix
->fx_r_type
== BFD_RELOC_SH_LABEL
);
3863 sh_fix_adjustable (fixS
*fixP
)
3865 if (fixP
->fx_r_type
== BFD_RELOC_32_PLT_PCREL
3866 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
3867 || fixP
->fx_r_type
== BFD_RELOC_SH_GOT20
3868 || fixP
->fx_r_type
== BFD_RELOC_SH_GOTPC
3869 || fixP
->fx_r_type
== BFD_RELOC_SH_GOTFUNCDESC
3870 || fixP
->fx_r_type
== BFD_RELOC_SH_GOTFUNCDESC20
3871 || fixP
->fx_r_type
== BFD_RELOC_SH_GOTOFFFUNCDESC
3872 || fixP
->fx_r_type
== BFD_RELOC_SH_GOTOFFFUNCDESC20
3873 || fixP
->fx_r_type
== BFD_RELOC_SH_FUNCDESC
3874 || ((fixP
->fx_r_type
== BFD_RELOC_32
) && dont_adjust_reloc_32
)
3875 || fixP
->fx_r_type
== BFD_RELOC_RVA
)
3878 /* We need the symbol name for the VTABLE entries */
3879 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
3880 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
3887 sh_elf_final_processing (void)
3891 /* Set file-specific flags to indicate if this code needs
3892 a processor with the sh-dsp / sh2e ISA to execute. */
3894 /* SH5 and above don't know about the valid_arch arch_sh* bits defined
3895 in sh-opc.h, so check SH64 mode before checking valid_arch. */
3896 if (sh64_isa_mode
!= sh64_isa_unspecified
)
3899 #elif defined TARGET_SYMBIAN
3902 extern int sh_symbian_find_elf_flags (unsigned int);
3904 val
= sh_symbian_find_elf_flags (valid_arch
);
3907 #endif /* HAVE_SH64 */
3908 val
= sh_find_elf_flags (valid_arch
);
3910 elf_elfheader (stdoutput
)->e_flags
&= ~EF_SH_MACH_MASK
;
3911 elf_elfheader (stdoutput
)->e_flags
|= val
;
3914 elf_elfheader (stdoutput
)->e_flags
|= EF_SH_FDPIC
;
3919 /* Return the target format for uClinux. */
3922 sh_uclinux_target_format (void)
3925 return (!target_big_endian
? "elf32-sh-fdpic" : "elf32-shbig-fdpic");
3927 return (!target_big_endian
? "elf32-shl" : "elf32-sh");
3931 /* Apply fixup FIXP to SIZE-byte field BUF given that VAL is its
3932 assembly-time value. If we're generating a reloc for FIXP,
3933 see whether the addend should be stored in-place or whether
3934 it should be in an ELF r_addend field. */
3937 apply_full_field_fix (fixS
*fixP
, char *buf
, bfd_vma val
, int size
)
3939 reloc_howto_type
*howto
;
3941 if (fixP
->fx_addsy
!= NULL
|| fixP
->fx_pcrel
)
3943 howto
= bfd_reloc_type_lookup (stdoutput
, fixP
->fx_r_type
);
3944 if (howto
&& !howto
->partial_inplace
)
3946 fixP
->fx_addnumber
= val
;
3950 md_number_to_chars (buf
, val
, size
);
3953 /* Apply a fixup to the object file. */
3956 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
3958 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
3959 int lowbyte
= target_big_endian
? 1 : 0;
3960 int highbyte
= target_big_endian
? 0 : 1;
3961 long val
= (long) *valP
;
3965 /* A difference between two symbols, the second of which is in the
3966 current section, is transformed in a PC-relative relocation to
3967 the other symbol. We have to adjust the relocation type here. */
3971 /* Safeguard; this must not occur for non-sh64 configurations. */
3972 gas_assert (fixP
->fx_r_type
!= BFD_RELOC_64
);
3975 switch (fixP
->fx_r_type
)
3981 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
3984 /* Currently, we only support 32-bit PCREL relocations.
3985 We'd need a new reloc type to handle 16_PCREL, and
3986 8_PCREL is already taken for R_SH_SWITCH8, which
3987 apparently does something completely different than what
3990 bfd_set_error (bfd_error_bad_value
);
3994 bfd_set_error (bfd_error_bad_value
);
3999 /* The function adjust_reloc_syms won't convert a reloc against a weak
4000 symbol into a reloc against a section, but bfd_install_relocation
4001 will screw up if the symbol is defined, so we have to adjust val here
4002 to avoid the screw up later.
4004 For ordinary relocs, this does not happen for ELF, since for ELF,
4005 bfd_install_relocation uses the "special function" field of the
4006 howto, and does not execute the code that needs to be undone, as long
4007 as the special function does not return bfd_reloc_continue.
4008 It can happen for GOT- and PLT-type relocs the way they are
4009 described in elf32-sh.c as they use bfd_elf_generic_reloc, but it
4010 doesn't matter here since those relocs don't use VAL; see below. */
4011 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
4012 && fixP
->fx_addsy
!= NULL
4013 && S_IS_WEAK (fixP
->fx_addsy
))
4014 val
-= S_GET_VALUE (fixP
->fx_addsy
);
4016 if (SWITCH_TABLE (fixP
))
4017 val
-= S_GET_VALUE (fixP
->fx_subsy
);
4021 switch (fixP
->fx_r_type
)
4023 case BFD_RELOC_SH_IMM3
:
4025 * buf
= (* buf
& 0xf8) | (val
& 0x7);
4027 case BFD_RELOC_SH_IMM3U
:
4029 * buf
= (* buf
& 0x8f) | ((val
& 0x7) << 4);
4031 case BFD_RELOC_SH_DISP12
:
4033 buf
[lowbyte
] = val
& 0xff;
4034 buf
[highbyte
] |= (val
>> 8) & 0x0f;
4036 case BFD_RELOC_SH_DISP12BY2
:
4039 buf
[lowbyte
] = (val
>> 1) & 0xff;
4040 buf
[highbyte
] |= (val
>> 9) & 0x0f;
4042 case BFD_RELOC_SH_DISP12BY4
:
4045 buf
[lowbyte
] = (val
>> 2) & 0xff;
4046 buf
[highbyte
] |= (val
>> 10) & 0x0f;
4048 case BFD_RELOC_SH_DISP12BY8
:
4051 buf
[lowbyte
] = (val
>> 3) & 0xff;
4052 buf
[highbyte
] |= (val
>> 11) & 0x0f;
4054 case BFD_RELOC_SH_DISP20
:
4055 if (! target_big_endian
)
4059 buf
[1] = (buf
[1] & 0x0f) | ((val
>> 12) & 0xf0);
4060 buf
[2] = (val
>> 8) & 0xff;
4061 buf
[3] = val
& 0xff;
4063 case BFD_RELOC_SH_DISP20BY8
:
4064 if (!target_big_endian
)
4069 buf
[1] = (buf
[1] & 0x0f) | ((val
>> 20) & 0xf0);
4070 buf
[2] = (val
>> 16) & 0xff;
4071 buf
[3] = (val
>> 8) & 0xff;
4074 case BFD_RELOC_SH_IMM4
:
4076 *buf
= (*buf
& 0xf0) | (val
& 0xf);
4079 case BFD_RELOC_SH_IMM4BY2
:
4082 *buf
= (*buf
& 0xf0) | ((val
>> 1) & 0xf);
4085 case BFD_RELOC_SH_IMM4BY4
:
4088 *buf
= (*buf
& 0xf0) | ((val
>> 2) & 0xf);
4091 case BFD_RELOC_SH_IMM8BY2
:
4097 case BFD_RELOC_SH_IMM8BY4
:
4104 case BFD_RELOC_SH_IMM8
:
4105 /* Sometimes the 8 bit value is sign extended (e.g., add) and
4106 sometimes it is not (e.g., and). We permit any 8 bit value.
4107 Note that adding further restrictions may invalidate
4108 reasonable looking assembly code, such as ``and -0x1,r0''. */
4114 case BFD_RELOC_SH_PCRELIMM8BY4
:
4115 /* If we are dealing with a known destination ... */
4116 if ((fixP
->fx_addsy
== NULL
|| S_IS_DEFINED (fixP
->fx_addsy
))
4117 && (fixP
->fx_subsy
== NULL
|| S_IS_DEFINED (fixP
->fx_addsy
)))
4119 /* Don't silently move the destination due to misalignment.
4120 The absolute address is the fragment base plus the offset into
4121 the fragment plus the pc relative offset to the label. */
4122 if ((fixP
->fx_frag
->fr_address
+ fixP
->fx_where
+ val
) & 3)
4123 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4124 _("offset to unaligned destination"));
4126 /* The displacement cannot be zero or backward even if aligned.
4127 Allow -2 because val has already been adjusted somewhere. */
4129 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("negative offset"));
4132 /* The lower two bits of the PC are cleared before the
4133 displacement is added in. We can assume that the destination
4134 is on a 4 byte boundary. If this instruction is also on a 4
4135 byte boundary, then we want
4137 and target - here is a multiple of 4.
4138 Otherwise, we are on a 2 byte boundary, and we want
4139 (target - (here - 2)) / 4
4140 and target - here is not a multiple of 4. Computing
4141 (target - (here - 2)) / 4 == (target - here + 2) / 4
4142 works for both cases, since in the first case the addition of
4143 2 will be removed by the division. target - here is in the
4145 val
= (val
+ 2) / 4;
4147 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
4151 case BFD_RELOC_SH_PCRELIMM8BY2
:
4154 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
4158 case BFD_RELOC_SH_PCDISP8BY2
:
4160 if (val
< -0x80 || val
> 0x7f)
4161 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
4165 case BFD_RELOC_SH_PCDISP12BY2
:
4167 if (val
< -0x800 || val
> 0x7ff)
4168 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
4169 buf
[lowbyte
] = val
& 0xff;
4170 buf
[highbyte
] |= (val
>> 8) & 0xf;
4175 apply_full_field_fix (fixP
, buf
, *valP
, 8);
4180 case BFD_RELOC_32_PCREL
:
4181 apply_full_field_fix (fixP
, buf
, val
, 4);
4185 apply_full_field_fix (fixP
, buf
, val
, 2);
4188 case BFD_RELOC_SH_USES
:
4189 /* Pass the value into sh_reloc(). */
4190 fixP
->fx_addnumber
= val
;
4193 case BFD_RELOC_SH_COUNT
:
4194 case BFD_RELOC_SH_ALIGN
:
4195 case BFD_RELOC_SH_CODE
:
4196 case BFD_RELOC_SH_DATA
:
4197 case BFD_RELOC_SH_LABEL
:
4198 /* Nothing to do here. */
4201 case BFD_RELOC_SH_LOOP_START
:
4202 case BFD_RELOC_SH_LOOP_END
:
4204 case BFD_RELOC_VTABLE_INHERIT
:
4205 case BFD_RELOC_VTABLE_ENTRY
:
4210 case BFD_RELOC_32_PLT_PCREL
:
4211 /* Make the jump instruction point to the address of the operand. At
4212 runtime we merely add the offset to the actual PLT entry. */
4213 * valP
= 0xfffffffc;
4214 val
= fixP
->fx_offset
;
4216 val
-= S_GET_VALUE (fixP
->fx_subsy
);
4217 apply_full_field_fix (fixP
, buf
, val
, 4);
4220 case BFD_RELOC_SH_GOTPC
:
4221 /* This is tough to explain. We end up with this one if we have
4222 operands that look like "_GLOBAL_OFFSET_TABLE_+[.-.L284]".
4223 The goal here is to obtain the absolute address of the GOT,
4224 and it is strongly preferable from a performance point of
4225 view to avoid using a runtime relocation for this. There are
4226 cases where you have something like:
4228 .long _GLOBAL_OFFSET_TABLE_+[.-.L66]
4230 and here no correction would be required. Internally in the
4231 assembler we treat operands of this form as not being pcrel
4232 since the '.' is explicitly mentioned, and I wonder whether
4233 it would simplify matters to do it this way. Who knows. In
4234 earlier versions of the PIC patches, the pcrel_adjust field
4235 was used to store the correction, but since the expression is
4236 not pcrel, I felt it would be confusing to do it this way. */
4238 apply_full_field_fix (fixP
, buf
, val
, 4);
4241 case BFD_RELOC_SH_TLS_GD_32
:
4242 case BFD_RELOC_SH_TLS_LD_32
:
4243 case BFD_RELOC_SH_TLS_IE_32
:
4244 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
4246 case BFD_RELOC_32_GOT_PCREL
:
4247 case BFD_RELOC_SH_GOT20
:
4248 case BFD_RELOC_SH_GOTPLT32
:
4249 case BFD_RELOC_SH_GOTFUNCDESC
:
4250 case BFD_RELOC_SH_GOTFUNCDESC20
:
4251 case BFD_RELOC_SH_GOTOFFFUNCDESC
:
4252 case BFD_RELOC_SH_GOTOFFFUNCDESC20
:
4253 case BFD_RELOC_SH_FUNCDESC
:
4254 * valP
= 0; /* Fully resolved at runtime. No addend. */
4255 apply_full_field_fix (fixP
, buf
, 0, 4);
4258 case BFD_RELOC_SH_TLS_LDO_32
:
4259 case BFD_RELOC_SH_TLS_LE_32
:
4260 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
4262 case BFD_RELOC_32_GOTOFF
:
4263 case BFD_RELOC_SH_GOTOFF20
:
4264 apply_full_field_fix (fixP
, buf
, val
, 4);
4270 shmedia_md_apply_fix (fixP
, valP
);
4279 if ((val
& ((1 << shift
) - 1)) != 0)
4280 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("misaligned offset"));
4284 val
= ((val
>> shift
)
4285 | ((long) -1 & ~ ((long) -1 >> shift
)));
4288 /* Extend sign for 64-bit host. */
4289 val
= ((val
& 0xffffffff) ^ 0x80000000) - 0x80000000;
4290 if (max
!= 0 && (val
< min
|| val
> max
))
4291 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("offset out of range"));
4293 /* Stop the generic code from trying to overlow check the value as well.
4294 It may not have the correct value anyway, as we do not store val back
4296 fixP
->fx_no_overflow
= 1;
4298 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
4302 /* Called just before address relaxation. Return the length
4303 by which a fragment must grow to reach it's destination. */
4306 md_estimate_size_before_relax (fragS
*fragP
, segT segment_type
)
4310 switch (fragP
->fr_subtype
)
4314 return shmedia_md_estimate_size_before_relax (fragP
, segment_type
);
4320 case C (UNCOND_JUMP
, UNDEF_DISP
):
4321 /* Used to be a branch to somewhere which was unknown. */
4322 if (!fragP
->fr_symbol
)
4324 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
4326 else if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
4328 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
4332 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNDEF_WORD_DISP
);
4336 case C (COND_JUMP
, UNDEF_DISP
):
4337 case C (COND_JUMP_DELAY
, UNDEF_DISP
):
4338 what
= GET_WHAT (fragP
->fr_subtype
);
4339 /* Used to be a branch to somewhere which was unknown. */
4340 if (fragP
->fr_symbol
4341 && S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
4343 /* Got a symbol and it's defined in this segment, become byte
4344 sized - maybe it will fix up. */
4345 fragP
->fr_subtype
= C (what
, COND8
);
4347 else if (fragP
->fr_symbol
)
4349 /* Its got a segment, but its not ours, so it will always be long. */
4350 fragP
->fr_subtype
= C (what
, UNDEF_WORD_DISP
);
4354 /* We know the abs value. */
4355 fragP
->fr_subtype
= C (what
, COND8
);
4359 case C (UNCOND_JUMP
, UNCOND12
):
4360 case C (UNCOND_JUMP
, UNCOND32
):
4361 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
4362 case C (COND_JUMP
, COND8
):
4363 case C (COND_JUMP
, COND12
):
4364 case C (COND_JUMP
, COND32
):
4365 case C (COND_JUMP
, UNDEF_WORD_DISP
):
4366 case C (COND_JUMP_DELAY
, COND8
):
4367 case C (COND_JUMP_DELAY
, COND12
):
4368 case C (COND_JUMP_DELAY
, COND32
):
4369 case C (COND_JUMP_DELAY
, UNDEF_WORD_DISP
):
4370 /* When relaxing a section for the second time, we don't need to
4371 do anything besides return the current size. */
4375 fragP
->fr_var
= md_relax_table
[fragP
->fr_subtype
].rlx_length
;
4376 return fragP
->fr_var
;
4379 /* Put number into target byte order. */
4382 md_number_to_chars (char *ptr
, valueT use
, int nbytes
)
4385 /* We might need to set the contents type to data. */
4386 sh64_flag_output ();
4389 if (! target_big_endian
)
4390 number_to_chars_littleendian (ptr
, use
, nbytes
);
4392 number_to_chars_bigendian (ptr
, use
, nbytes
);
4395 /* This version is used in obj-coff.c eg. for the sh-hms target. */
4398 md_pcrel_from (fixS
*fixP
)
4400 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
+ 2;
4404 md_pcrel_from_section (fixS
*fixP
, segT sec
)
4406 if (! sh_local_pcrel (fixP
)
4407 && fixP
->fx_addsy
!= (symbolS
*) NULL
4408 && (generic_force_reloc (fixP
)
4409 || S_GET_SEGMENT (fixP
->fx_addsy
) != sec
))
4411 /* The symbol is undefined (or is defined but not in this section,
4412 or we're not sure about it being the final definition). Let the
4413 linker figure it out. We need to adjust the subtraction of a
4414 symbol to the position of the relocated data, though. */
4415 return fixP
->fx_subsy
? fixP
->fx_where
+ fixP
->fx_frag
->fr_address
: 0;
4418 return md_pcrel_from (fixP
);
4421 /* Create a reloc. */
4424 tc_gen_reloc (asection
*section ATTRIBUTE_UNUSED
, fixS
*fixp
)
4427 bfd_reloc_code_real_type r_type
;
4429 rel
= (arelent
*) xmalloc (sizeof (arelent
));
4430 rel
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
4431 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
4432 rel
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4434 r_type
= fixp
->fx_r_type
;
4436 if (SWITCH_TABLE (fixp
))
4438 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_subsy
);
4440 if (r_type
== BFD_RELOC_16
)
4441 r_type
= BFD_RELOC_SH_SWITCH16
;
4442 else if (r_type
== BFD_RELOC_8
)
4443 r_type
= BFD_RELOC_8_PCREL
;
4444 else if (r_type
== BFD_RELOC_32
)
4445 r_type
= BFD_RELOC_SH_SWITCH32
;
4449 else if (r_type
== BFD_RELOC_SH_USES
)
4450 rel
->addend
= fixp
->fx_addnumber
;
4451 else if (r_type
== BFD_RELOC_SH_COUNT
)
4452 rel
->addend
= fixp
->fx_offset
;
4453 else if (r_type
== BFD_RELOC_SH_ALIGN
)
4454 rel
->addend
= fixp
->fx_offset
;
4455 else if (r_type
== BFD_RELOC_VTABLE_INHERIT
4456 || r_type
== BFD_RELOC_VTABLE_ENTRY
)
4457 rel
->addend
= fixp
->fx_offset
;
4458 else if (r_type
== BFD_RELOC_SH_LOOP_START
4459 || r_type
== BFD_RELOC_SH_LOOP_END
)
4460 rel
->addend
= fixp
->fx_offset
;
4461 else if (r_type
== BFD_RELOC_SH_LABEL
&& fixp
->fx_pcrel
)
4464 rel
->address
= rel
->addend
= fixp
->fx_offset
;
4467 else if (shmedia_init_reloc (rel
, fixp
))
4471 rel
->addend
= fixp
->fx_addnumber
;
4473 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, r_type
);
4475 if (rel
->howto
== NULL
)
4477 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4478 _("Cannot represent relocation type %s"),
4479 bfd_get_reloc_code_name (r_type
));
4480 /* Set howto to a garbage value so that we can keep going. */
4481 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
4482 gas_assert (rel
->howto
!= NULL
);
4485 else if (rel
->howto
->type
== R_SH_IND12W
)
4486 rel
->addend
+= fixp
->fx_offset
- 4;
4493 inline static char *
4494 sh_end_of_match (char *cont
, char *what
)
4496 int len
= strlen (what
);
4498 if (strncasecmp (cont
, what
, strlen (what
)) == 0
4499 && ! is_part_of_name (cont
[len
]))
4506 sh_parse_name (char const *name
,
4508 enum expr_mode mode
,
4511 char *next
= input_line_pointer
;
4516 exprP
->X_op_symbol
= NULL
;
4518 if (strcmp (name
, GLOBAL_OFFSET_TABLE_NAME
) == 0)
4521 GOT_symbol
= symbol_find_or_make (name
);
4523 exprP
->X_add_symbol
= GOT_symbol
;
4525 /* If we have an absolute symbol or a reg, then we know its
4527 segment
= S_GET_SEGMENT (exprP
->X_add_symbol
);
4528 if (mode
!= expr_defer
&& segment
== absolute_section
)
4530 exprP
->X_op
= O_constant
;
4531 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
4532 exprP
->X_add_symbol
= NULL
;
4534 else if (mode
!= expr_defer
&& segment
== reg_section
)
4536 exprP
->X_op
= O_register
;
4537 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
4538 exprP
->X_add_symbol
= NULL
;
4542 exprP
->X_op
= O_symbol
;
4543 exprP
->X_add_number
= 0;
4549 exprP
->X_add_symbol
= symbol_find_or_make (name
);
4551 if (*nextcharP
!= '@')
4553 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTOFF")))
4554 reloc_type
= BFD_RELOC_32_GOTOFF
;
4555 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTPLT")))
4556 reloc_type
= BFD_RELOC_SH_GOTPLT32
;
4557 else if ((next_end
= sh_end_of_match (next
+ 1, "GOT")))
4558 reloc_type
= BFD_RELOC_32_GOT_PCREL
;
4559 else if ((next_end
= sh_end_of_match (next
+ 1, "PLT")))
4560 reloc_type
= BFD_RELOC_32_PLT_PCREL
;
4561 else if ((next_end
= sh_end_of_match (next
+ 1, "TLSGD")))
4562 reloc_type
= BFD_RELOC_SH_TLS_GD_32
;
4563 else if ((next_end
= sh_end_of_match (next
+ 1, "TLSLDM")))
4564 reloc_type
= BFD_RELOC_SH_TLS_LD_32
;
4565 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTTPOFF")))
4566 reloc_type
= BFD_RELOC_SH_TLS_IE_32
;
4567 else if ((next_end
= sh_end_of_match (next
+ 1, "TPOFF")))
4568 reloc_type
= BFD_RELOC_SH_TLS_LE_32
;
4569 else if ((next_end
= sh_end_of_match (next
+ 1, "DTPOFF")))
4570 reloc_type
= BFD_RELOC_SH_TLS_LDO_32
;
4571 else if ((next_end
= sh_end_of_match (next
+ 1, "PCREL")))
4572 reloc_type
= BFD_RELOC_32_PCREL
;
4573 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTFUNCDESC")))
4574 reloc_type
= BFD_RELOC_SH_GOTFUNCDESC
;
4575 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTOFFFUNCDESC")))
4576 reloc_type
= BFD_RELOC_SH_GOTOFFFUNCDESC
;
4577 else if ((next_end
= sh_end_of_match (next
+ 1, "FUNCDESC")))
4578 reloc_type
= BFD_RELOC_SH_FUNCDESC
;
4582 *input_line_pointer
= *nextcharP
;
4583 input_line_pointer
= next_end
;
4584 *nextcharP
= *input_line_pointer
;
4585 *input_line_pointer
= '\0';
4587 exprP
->X_op
= O_PIC_reloc
;
4588 exprP
->X_add_number
= 0;
4589 exprP
->X_md
= reloc_type
;
4595 sh_cfi_frame_initial_instructions (void)
4597 cfi_add_CFA_def_cfa (15, 0);
4601 sh_regname_to_dw2regnum (char *regname
)
4603 unsigned int regnum
= -1;
4607 static struct { char *name
; int dw2regnum
; } regnames
[] =
4609 { "pr", 17 }, { "t", 18 }, { "gbr", 19 }, { "mach", 20 },
4610 { "macl", 21 }, { "fpul", 23 }
4613 for (i
= 0; i
< ARRAY_SIZE (regnames
); ++i
)
4614 if (strcmp (regnames
[i
].name
, regname
) == 0)
4615 return regnames
[i
].dw2regnum
;
4617 if (regname
[0] == 'r')
4620 regnum
= strtoul (p
, &q
, 10);
4621 if (p
== q
|| *q
|| regnum
>= 16)
4624 else if (regname
[0] == 'f' && regname
[1] == 'r')
4627 regnum
= strtoul (p
, &q
, 10);
4628 if (p
== q
|| *q
|| regnum
>= 16)
4632 else if (regname
[0] == 'x' && regname
[1] == 'd')
4635 regnum
= strtoul (p
, &q
, 10);
4636 if (p
== q
|| *q
|| regnum
>= 8)
4642 #endif /* OBJ_ELF */