1 /* tc-sh.c -- Assemble code for the Hitachi Super-H
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Written By Steve Chamberlain <sac@cygnus.com> */
29 #include "opcodes/sh-opc.h"
30 #include "safe-ctype.h"
31 #include "struc-symbol.h"
37 #include "dwarf2dbg.h"
43 expressionS immediate
;
47 const char comment_chars
[] = "!";
48 const char line_separator_chars
[] = ";";
49 const char line_comment_chars
[] = "!#";
51 static void s_uses
PARAMS ((int));
53 static void sh_count_relocs
PARAMS ((bfd
*, segT
, PTR
));
54 static void sh_frob_section
PARAMS ((bfd
*, segT
, PTR
));
56 static void s_uacons
PARAMS ((int));
57 static sh_opcode_info
*find_cooked_opcode
PARAMS ((char **));
58 static unsigned int assemble_ppi
PARAMS ((char *, sh_opcode_info
*));
59 static void little
PARAMS ((int));
60 static void big
PARAMS ((int));
61 static int parse_reg
PARAMS ((char *, int *, int *));
62 static char *parse_exp
PARAMS ((char *, sh_operand_info
*));
63 static char *parse_at
PARAMS ((char *, sh_operand_info
*));
64 static void get_operand
PARAMS ((char **, sh_operand_info
*));
65 static char *get_operands
66 PARAMS ((sh_opcode_info
*, char *, sh_operand_info
*));
67 static sh_opcode_info
*get_specific
68 PARAMS ((sh_opcode_info
*, sh_operand_info
*));
69 static void insert
PARAMS ((char *, int, int, sh_operand_info
*));
70 static void build_relax
PARAMS ((sh_opcode_info
*, sh_operand_info
*));
71 static char *insert_loop_bounds
PARAMS ((char *, sh_operand_info
*));
72 static unsigned int build_Mytes
73 PARAMS ((sh_opcode_info
*, sh_operand_info
*));
74 static boolean sh_local_pcrel
PARAMS ((fixS
*fix
));
77 static void sh_elf_cons
PARAMS ((int));
79 inline static int sh_PIC_related_p
PARAMS ((symbolS
*));
80 static int sh_check_fixup
PARAMS ((expressionS
*, bfd_reloc_code_real_type
*));
81 inline static char *sh_end_of_match
PARAMS ((char *, char *));
83 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
88 int ignore ATTRIBUTE_UNUSED
;
90 if (! target_big_endian
)
91 as_bad (_("directive .big encountered when option -big required"));
93 /* Stop further messages. */
94 target_big_endian
= 1;
99 int ignore ATTRIBUTE_UNUSED
;
101 if (target_big_endian
)
102 as_bad (_("directive .little encountered when option -little required"));
104 /* Stop further messages. */
105 target_big_endian
= 0;
108 /* This table describes all the machine specific pseudo-ops the assembler
109 has to support. The fields are:
110 pseudo-op name without dot
111 function to call to execute this pseudo-op
112 Integer arg to pass to the function. */
114 const pseudo_typeS md_pseudo_table
[] =
117 {"long", sh_elf_cons
, 4},
118 {"int", sh_elf_cons
, 4},
119 {"word", sh_elf_cons
, 2},
120 {"short", sh_elf_cons
, 2},
126 {"form", listing_psize
, 0},
127 {"little", little
, 0},
128 {"heading", listing_title
, 0},
129 {"import", s_ignore
, 0},
130 {"page", listing_eject
, 0},
131 {"program", s_ignore
, 0},
133 {"uaword", s_uacons
, 2},
134 {"ualong", s_uacons
, 4},
135 {"uaquad", s_uacons
, 8},
136 {"2byte", s_uacons
, 2},
137 {"4byte", s_uacons
, 4},
138 {"8byte", s_uacons
, 8},
140 {"file", (void (*) PARAMS ((int))) dwarf2_directive_file
, 0 },
141 {"loc", dwarf2_directive_loc
, 0 },
144 {"mode", s_sh64_mode
, 0 },
146 /* Have the old name too. */
147 {"isa", s_sh64_mode
, 0 },
149 /* Assert that the right ABI is used. */
150 {"abi", s_sh64_abi
, 0 },
152 { "vtable_inherit", sh64_vtable_inherit
, 0 },
153 { "vtable_entry", sh64_vtable_entry
, 0 },
154 #endif /* HAVE_SH64 */
158 /*int md_reloc_size; */
160 int sh_relax
; /* set if -relax seen */
162 /* Whether -small was seen. */
166 /* Whether -dsp was seen. */
170 /* The bit mask of architectures that could
171 accomodate the insns seen so far. */
172 static int valid_arch
;
174 const char EXP_CHARS
[] = "eE";
176 /* Chars that mean this number is a floating point constant. */
179 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
181 #define C(a,b) ENCODE_RELAX(a,b)
183 #define ENCODE_RELAX(what,length) (((what) << 4) + (length))
184 #define GET_WHAT(x) ((x>>4))
186 /* These are the three types of relaxable instrction. */
187 /* These are the types of relaxable instructions; except for END which is
190 #define COND_JUMP_DELAY 2
191 #define UNCOND_JUMP 3
195 /* A 16-bit (times four) pc-relative operand, at most expanded to 32 bits. */
196 #define SH64PCREL16_32 4
197 /* A 16-bit (times four) pc-relative operand, at most expanded to 64 bits. */
198 #define SH64PCREL16_64 5
200 /* Variants of the above for adjusting the insn to PTA or PTB according to
202 #define SH64PCREL16PT_32 6
203 #define SH64PCREL16PT_64 7
205 /* A MOVI expansion, expanding to at most 32 or 64 bits. */
206 #define MOVI_IMM_32 8
207 #define MOVI_IMM_32_PCREL 9
208 #define MOVI_IMM_64 10
209 #define MOVI_IMM_64_PCREL 11
212 #else /* HAVE_SH64 */
216 #endif /* HAVE_SH64 */
222 #define UNDEF_WORD_DISP 4
228 #define UNDEF_SH64PCREL 0
229 #define SH64PCREL16 1
230 #define SH64PCREL32 2
231 #define SH64PCREL48 3
232 #define SH64PCREL64 4
233 #define SH64PCRELPLT 5
241 #define MOVI_GOTOFF 6
243 #endif /* HAVE_SH64 */
245 /* Branch displacements are from the address of the branch plus
246 four, thus all minimum and maximum values have 4 added to them. */
249 #define COND8_LENGTH 2
251 /* There is one extra instruction before the branch, so we must add
252 two more bytes to account for it. */
253 #define COND12_F 4100
254 #define COND12_M -4090
255 #define COND12_LENGTH 6
257 #define COND12_DELAY_LENGTH 4
259 /* ??? The minimum and maximum values are wrong, but this does not matter
260 since this relocation type is not supported yet. */
261 #define COND32_F (1<<30)
262 #define COND32_M -(1<<30)
263 #define COND32_LENGTH 14
265 #define UNCOND12_F 4098
266 #define UNCOND12_M -4092
267 #define UNCOND12_LENGTH 2
269 /* ??? The minimum and maximum values are wrong, but this does not matter
270 since this relocation type is not supported yet. */
271 #define UNCOND32_F (1<<30)
272 #define UNCOND32_M -(1<<30)
273 #define UNCOND32_LENGTH 14
276 /* The trivial expansion of a SH64PCREL16 relaxation is just a "PT label,
277 TRd" as is the current insn, so no extra length. Note that the "reach"
278 is calculated from the address *after* that insn, but the offset in the
279 insn is calculated from the beginning of the insn. We also need to
280 take into account the implicit 1 coded as the "A" in PTA when counting
281 forward. If PTB reaches an odd address, we trap that as an error
282 elsewhere, so we don't have to have different relaxation entries. We
283 don't add a one to the negative range, since PTB would then have the
284 farthest backward-reaching value skipped, not generated at relaxation. */
285 #define SH64PCREL16_F (32767 * 4 - 4 + 1)
286 #define SH64PCREL16_M (-32768 * 4 - 4)
287 #define SH64PCREL16_LENGTH 0
289 /* The next step is to change that PT insn into
290 MOVI ((label - datalabel Ln) >> 16) & 65535, R25
291 SHORI (label - datalabel Ln) & 65535, R25
294 which means two extra insns, 8 extra bytes. This is the limit for the
297 The expressions look a bit bad since we have to adjust this to avoid overflow on a
299 #define SH64PCREL32_F ((((long) 1 << 30) - 1) * 2 + 1 - 4)
300 #define SH64PCREL32_LENGTH (2 * 4)
302 /* Similarly, we just change the MOVI and add a SHORI for the 48-bit
304 #if BFD_HOST_64BIT_LONG
305 /* The "reach" type is long, so we can only do this for a 64-bit-long
307 #define SH64PCREL32_M (((long) -1 << 30) * 2 - 4)
308 #define SH64PCREL48_F ((((long) 1 << 47) - 1) - 4)
309 #define SH64PCREL48_M (((long) -1 << 47) - 4)
310 #define SH64PCREL48_LENGTH (3 * 4)
312 /* If the host does not have 64-bit longs, just make this state identical
313 in reach to the 32-bit state. Note that we have a slightly incorrect
314 reach, but the correct one above will overflow a 32-bit number. */
315 #define SH64PCREL32_M (((long) -1 << 30) * 2)
316 #define SH64PCREL48_F SH64PCREL32_F
317 #define SH64PCREL48_M SH64PCREL32_M
318 #define SH64PCREL48_LENGTH (3 * 4)
319 #endif /* BFD_HOST_64BIT_LONG */
321 /* And similarly for the 64-bit expansion; a MOVI + SHORI + SHORI + SHORI
323 #define SH64PCREL64_LENGTH (4 * 4)
325 /* For MOVI, we make the MOVI + SHORI... expansion you can see in the
326 SH64PCREL expansions. The PCREL one is similar, but the other has no
327 pc-relative reach; it must be fully expanded in
328 shmedia_md_estimate_size_before_relax. */
329 #define MOVI_16_LENGTH 0
330 #define MOVI_16_F (32767 - 4)
331 #define MOVI_16_M (-32768 - 4)
332 #define MOVI_32_LENGTH 4
333 #define MOVI_32_F ((((long) 1 << 30) - 1) * 2 + 1 - 4)
334 #define MOVI_48_LENGTH 8
336 #if BFD_HOST_64BIT_LONG
337 /* The "reach" type is long, so we can only do this for a 64-bit-long
339 #define MOVI_32_M (((long) -1 << 30) * 2 - 4)
340 #define MOVI_48_F ((((long) 1 << 47) - 1) - 4)
341 #define MOVI_48_M (((long) -1 << 47) - 4)
343 /* If the host does not have 64-bit longs, just make this state identical
344 in reach to the 32-bit state. Note that we have a slightly incorrect
345 reach, but the correct one above will overflow a 32-bit number. */
346 #define MOVI_32_M (((long) -1 << 30) * 2)
347 #define MOVI_48_F MOVI_32_F
348 #define MOVI_48_M MOVI_32_M
349 #endif /* BFD_HOST_64BIT_LONG */
351 #define MOVI_64_LENGTH 12
352 #endif /* HAVE_SH64 */
354 #define EMPTY { 0, 0, 0, 0 }
356 const relax_typeS md_relax_table
[C (END
, 0)] = {
357 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
358 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
361 /* C (COND_JUMP, COND8) */
362 { COND8_F
, COND8_M
, COND8_LENGTH
, C (COND_JUMP
, COND12
) },
363 /* C (COND_JUMP, COND12) */
364 { COND12_F
, COND12_M
, COND12_LENGTH
, C (COND_JUMP
, COND32
), },
365 /* C (COND_JUMP, COND32) */
366 { COND32_F
, COND32_M
, COND32_LENGTH
, 0, },
367 /* C (COND_JUMP, UNDEF_WORD_DISP) */
368 { 0, 0, COND32_LENGTH
, 0, },
370 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
373 /* C (COND_JUMP_DELAY, COND8) */
374 { COND8_F
, COND8_M
, COND8_LENGTH
, C (COND_JUMP_DELAY
, COND12
) },
375 /* C (COND_JUMP_DELAY, COND12) */
376 { COND12_F
, COND12_M
, COND12_DELAY_LENGTH
, C (COND_JUMP_DELAY
, COND32
), },
377 /* C (COND_JUMP_DELAY, COND32) */
378 { COND32_F
, COND32_M
, COND32_LENGTH
, 0, },
379 /* C (COND_JUMP_DELAY, UNDEF_WORD_DISP) */
380 { 0, 0, COND32_LENGTH
, 0, },
382 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
385 /* C (UNCOND_JUMP, UNCOND12) */
386 { UNCOND12_F
, UNCOND12_M
, UNCOND12_LENGTH
, C (UNCOND_JUMP
, UNCOND32
), },
387 /* C (UNCOND_JUMP, UNCOND32) */
388 { UNCOND32_F
, UNCOND32_M
, UNCOND32_LENGTH
, 0, },
390 /* C (UNCOND_JUMP, UNDEF_WORD_DISP) */
391 { 0, 0, UNCOND32_LENGTH
, 0, },
393 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
396 /* C (SH64PCREL16_32, SH64PCREL16) */
398 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16_32
, SH64PCREL32
) },
399 /* C (SH64PCREL16_32, SH64PCREL32) */
400 { 0, 0, SH64PCREL32_LENGTH
, 0 },
402 /* C (SH64PCREL16_32, SH64PCRELPLT) */
403 { 0, 0, SH64PCREL32_LENGTH
, 0 },
405 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
407 /* C (SH64PCREL16_64, SH64PCREL16) */
409 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16_64
, SH64PCREL32
) },
410 /* C (SH64PCREL16_64, SH64PCREL32) */
411 { SH64PCREL32_F
, SH64PCREL32_M
, SH64PCREL32_LENGTH
, C (SH64PCREL16_64
, SH64PCREL48
) },
412 /* C (SH64PCREL16_64, SH64PCREL48) */
413 { SH64PCREL48_F
, SH64PCREL48_M
, SH64PCREL48_LENGTH
, C (SH64PCREL16_64
, SH64PCREL64
) },
414 /* C (SH64PCREL16_64, SH64PCREL64) */
415 { 0, 0, SH64PCREL64_LENGTH
, 0 },
416 /* C (SH64PCREL16_64, SH64PCRELPLT) */
417 { 0, 0, SH64PCREL64_LENGTH
, 0 },
419 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
421 /* C (SH64PCREL16PT_32, SH64PCREL16) */
423 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16PT_32
, SH64PCREL32
) },
424 /* C (SH64PCREL16PT_32, SH64PCREL32) */
425 { 0, 0, SH64PCREL32_LENGTH
, 0 },
427 /* C (SH64PCREL16PT_32, SH64PCRELPLT) */
428 { 0, 0, SH64PCREL32_LENGTH
, 0 },
430 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
432 /* C (SH64PCREL16PT_64, SH64PCREL16) */
434 { SH64PCREL16_F
, SH64PCREL16_M
, SH64PCREL16_LENGTH
, C (SH64PCREL16PT_64
, SH64PCREL32
) },
435 /* C (SH64PCREL16PT_64, SH64PCREL32) */
439 C (SH64PCREL16PT_64
, SH64PCREL48
) },
440 /* C (SH64PCREL16PT_64, SH64PCREL48) */
441 { SH64PCREL48_F
, SH64PCREL48_M
, SH64PCREL48_LENGTH
, C (SH64PCREL16PT_64
, SH64PCREL64
) },
442 /* C (SH64PCREL16PT_64, SH64PCREL64) */
443 { 0, 0, SH64PCREL64_LENGTH
, 0 },
444 /* C (SH64PCREL16PT_64, SH64PCRELPLT) */
445 { 0, 0, SH64PCREL64_LENGTH
, 0},
447 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
449 /* C (MOVI_IMM_32, UNDEF_MOVI) */
450 { 0, 0, MOVI_32_LENGTH
, 0 },
451 /* C (MOVI_IMM_32, MOVI_16) */
452 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_32
, MOVI_32
) },
453 /* C (MOVI_IMM_32, MOVI_32) */
454 { MOVI_32_F
, MOVI_32_M
, MOVI_32_LENGTH
, 0 },
456 /* C (MOVI_IMM_32, MOVI_GOTOFF) */
457 { 0, 0, MOVI_32_LENGTH
, 0 },
458 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
460 /* C (MOVI_IMM_32_PCREL, MOVI_16) */
462 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_32_PCREL
, MOVI_32
) },
463 /* C (MOVI_IMM_32_PCREL, MOVI_32) */
464 { 0, 0, MOVI_32_LENGTH
, 0 },
466 /* C (MOVI_IMM_32_PCREL, MOVI_PLT) */
467 { 0, 0, MOVI_32_LENGTH
, 0 },
469 /* C (MOVI_IMM_32_PCREL, MOVI_GOTPC) */
470 { 0, 0, MOVI_32_LENGTH
, 0 },
471 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
473 /* C (MOVI_IMM_64, UNDEF_MOVI) */
474 { 0, 0, MOVI_64_LENGTH
, 0 },
475 /* C (MOVI_IMM_64, MOVI_16) */
476 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_64
, MOVI_32
) },
477 /* C (MOVI_IMM_64, MOVI_32) */
478 { MOVI_32_F
, MOVI_32_M
, MOVI_32_LENGTH
, C (MOVI_IMM_64
, MOVI_48
) },
479 /* C (MOVI_IMM_64, MOVI_48) */
480 { MOVI_48_F
, MOVI_48_M
, MOVI_48_LENGTH
, C (MOVI_IMM_64
, MOVI_64
) },
481 /* C (MOVI_IMM_64, MOVI_64) */
482 { 0, 0, MOVI_64_LENGTH
, 0 },
484 /* C (MOVI_IMM_64, MOVI_GOTOFF) */
485 { 0, 0, MOVI_64_LENGTH
, 0 },
486 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
488 /* C (MOVI_IMM_64_PCREL, MOVI_16) */
490 { MOVI_16_F
, MOVI_16_M
, MOVI_16_LENGTH
, C (MOVI_IMM_64_PCREL
, MOVI_32
) },
491 /* C (MOVI_IMM_64_PCREL, MOVI_32) */
492 { MOVI_32_F
, MOVI_32_M
, MOVI_32_LENGTH
, C (MOVI_IMM_64_PCREL
, MOVI_48
) },
493 /* C (MOVI_IMM_64_PCREL, MOVI_48) */
494 { MOVI_48_F
, MOVI_48_M
, MOVI_48_LENGTH
, C (MOVI_IMM_64_PCREL
, MOVI_64
) },
495 /* C (MOVI_IMM_64_PCREL, MOVI_64) */
496 { 0, 0, MOVI_64_LENGTH
, 0 },
497 /* C (MOVI_IMM_64_PCREL, MOVI_PLT) */
498 { 0, 0, MOVI_64_LENGTH
, 0 },
500 /* C (MOVI_IMM_64_PCREL, MOVI_GOTPC) */
501 { 0, 0, MOVI_64_LENGTH
, 0 },
502 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
504 #endif /* HAVE_SH64 */
510 static struct hash_control
*opcode_hash_control
; /* Opcode mnemonics */
514 /* Determinet whether the symbol needs any kind of PIC relocation. */
517 sh_PIC_related_p (sym
)
525 if (sym
== GOT_symbol
)
529 if (sh_PIC_related_p (*symbol_get_tc (sym
)))
533 exp
= symbol_get_value_expression (sym
);
535 return (exp
->X_op
== O_PIC_reloc
536 || sh_PIC_related_p (exp
->X_add_symbol
)
537 || sh_PIC_related_p (exp
->X_op_symbol
));
540 /* Determine the relocation type to be used to represent the
541 expression, that may be rearranged. */
544 sh_check_fixup (main_exp
, r_type_p
)
545 expressionS
*main_exp
;
546 bfd_reloc_code_real_type
*r_type_p
;
548 expressionS
*exp
= main_exp
;
550 /* This is here for backward-compatibility only. GCC used to generated:
552 f@PLT + . - (.LPCS# + 2)
554 but we'd rather be able to handle this as a PIC-related reference
555 plus/minus a symbol. However, gas' parser gives us:
557 O_subtract (O_add (f@PLT, .), .LPCS#+2)
559 so we attempt to transform this into:
561 O_subtract (f@PLT, O_subtract (.LPCS#+2, .))
563 which we can handle simply below. */
564 if (exp
->X_op
== O_subtract
)
566 if (sh_PIC_related_p (exp
->X_op_symbol
))
569 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
571 if (exp
&& sh_PIC_related_p (exp
->X_op_symbol
))
574 if (exp
&& exp
->X_op
== O_add
575 && sh_PIC_related_p (exp
->X_add_symbol
))
577 symbolS
*sym
= exp
->X_add_symbol
;
579 exp
->X_op
= O_subtract
;
580 exp
->X_add_symbol
= main_exp
->X_op_symbol
;
582 main_exp
->X_op_symbol
= main_exp
->X_add_symbol
;
583 main_exp
->X_add_symbol
= sym
;
585 main_exp
->X_add_number
+= exp
->X_add_number
;
586 exp
->X_add_number
= 0;
591 else if (exp
->X_op
== O_add
&& sh_PIC_related_p (exp
->X_op_symbol
))
594 if (exp
->X_op
== O_symbol
|| exp
->X_op
== O_add
|| exp
->X_op
== O_subtract
)
597 if (exp
->X_add_symbol
598 && (exp
->X_add_symbol
== GOT_symbol
600 && *symbol_get_tc (exp
->X_add_symbol
) == GOT_symbol
)))
604 case BFD_RELOC_SH_IMM_LOW16
:
605 *r_type_p
= BFD_RELOC_SH_GOTPC_LOW16
;
608 case BFD_RELOC_SH_IMM_MEDLOW16
:
609 *r_type_p
= BFD_RELOC_SH_GOTPC_MEDLOW16
;
612 case BFD_RELOC_SH_IMM_MEDHI16
:
613 *r_type_p
= BFD_RELOC_SH_GOTPC_MEDHI16
;
616 case BFD_RELOC_SH_IMM_HI16
:
617 *r_type_p
= BFD_RELOC_SH_GOTPC_HI16
;
621 case BFD_RELOC_UNUSED
:
622 *r_type_p
= BFD_RELOC_SH_GOTPC
;
631 if (exp
->X_add_symbol
&& exp
->X_add_symbol
== GOT_symbol
)
633 *r_type_p
= BFD_RELOC_SH_GOTPC
;
637 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
642 if (exp
->X_op
== O_PIC_reloc
)
648 case BFD_RELOC_UNUSED
:
649 *r_type_p
= exp
->X_md
;
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
;
752 *r_type_p
= exp
->X_md
;
755 exp
->X_op
= O_symbol
;
758 main_exp
->X_add_symbol
= exp
->X_add_symbol
;
759 main_exp
->X_add_number
+= exp
->X_add_number
;
763 return (sh_PIC_related_p (exp
->X_add_symbol
)
764 || sh_PIC_related_p (exp
->X_op_symbol
));
769 /* Add expression EXP of SIZE bytes to offset OFF of fragment FRAG. */
772 sh_cons_fix_new (frag
, off
, size
, exp
)
777 bfd_reloc_code_real_type r_type
= BFD_RELOC_UNUSED
;
779 if (sh_check_fixup (exp
, &r_type
))
780 as_bad (_("Invalid PIC expression."));
782 if (r_type
== BFD_RELOC_UNUSED
)
786 r_type
= BFD_RELOC_8
;
790 r_type
= BFD_RELOC_16
;
794 r_type
= BFD_RELOC_32
;
799 r_type
= BFD_RELOC_64
;
809 as_bad (_("unsupported BFD relocation size %u"), size
);
810 r_type
= BFD_RELOC_UNUSED
;
813 fix_new_exp (frag
, off
, size
, exp
, 0, r_type
);
816 /* The regular cons() function, that reads constants, doesn't support
817 suffixes such as @GOT, @GOTOFF and @PLT, that generate
818 machine-specific relocation types. So we must define it here. */
819 /* Clobbers input_line_pointer, checks end-of-line. */
822 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
828 /* Update existing range to include a previous insn, if there was one. */
829 sh64_update_contents_mark (true);
831 /* We need to make sure the contents type is set to data. */
834 #endif /* HAVE_SH64 */
836 if (is_it_end_of_statement ())
838 demand_empty_rest_of_line ();
845 emit_expr (&exp
, (unsigned int) nbytes
);
847 while (*input_line_pointer
++ == ',');
849 input_line_pointer
--; /* Put terminator back into stream. */
850 if (*input_line_pointer
== '#' || *input_line_pointer
== '!')
852 while (! is_end_of_line
[(unsigned char) *input_line_pointer
++]);
855 demand_empty_rest_of_line ();
860 /* This function is called once, at assembler startup time. This should
861 set up all the tables, etc that the MD part of the assembler needs. */
866 sh_opcode_info
*opcode
;
867 char *prev_name
= "";
870 target_arch
= arch_sh1_up
& ~(sh_dsp
? arch_sh3e_up
: arch_sh_dsp_up
);
871 valid_arch
= target_arch
;
877 opcode_hash_control
= hash_new ();
879 /* Insert unique names into hash table. */
880 for (opcode
= sh_table
; opcode
->name
; opcode
++)
882 if (strcmp (prev_name
, opcode
->name
))
884 if (! (opcode
->arch
& target_arch
))
886 prev_name
= opcode
->name
;
887 hash_insert (opcode_hash_control
, opcode
->name
, (char *) opcode
);
891 /* Make all the opcodes with the same name point to the same
893 opcode
->name
= prev_name
;
900 static int reg_x
, reg_y
;
904 #define IDENT_CHAR(c) (ISALNUM (c) || (c) == '_')
906 /* Try to parse a reg name. Return the number of chars consumed. */
909 parse_reg (src
, mode
, reg
)
914 char l0
= TOLOWER (src
[0]);
915 char l1
= l0
? TOLOWER (src
[1]) : 0;
917 /* We use ! IDENT_CHAR for the next character after the register name, to
918 make sure that we won't accidentally recognize a symbol name such as
919 'sram' or sr_ram as being a reference to the register 'sr'. */
925 if (src
[2] >= '0' && src
[2] <= '5'
926 && ! IDENT_CHAR ((unsigned char) src
[3]))
929 *reg
= 10 + src
[2] - '0';
933 if (l1
>= '0' && l1
<= '9'
934 && ! IDENT_CHAR ((unsigned char) src
[2]))
940 if (l1
>= '0' && l1
<= '7' && strncasecmp (&src
[2], "_bank", 5) == 0
941 && ! IDENT_CHAR ((unsigned char) src
[7]))
948 if (l1
== 'e' && ! IDENT_CHAR ((unsigned char) src
[2]))
953 if (l1
== 's' && ! IDENT_CHAR ((unsigned char) src
[2]))
964 if (! IDENT_CHAR ((unsigned char) src
[2]))
970 if (TOLOWER (src
[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src
[3]))
979 if (! IDENT_CHAR ((unsigned char) src
[2]))
985 if (TOLOWER (src
[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src
[3]))
993 if (l1
== 'x' && src
[2] >= '0' && src
[2] <= '1'
994 && ! IDENT_CHAR ((unsigned char) src
[3]))
997 *reg
= 4 + (l1
- '0');
1000 if (l1
== 'y' && src
[2] >= '0' && src
[2] <= '1'
1001 && ! IDENT_CHAR ((unsigned char) src
[3]))
1004 *reg
= 6 + (l1
- '0');
1007 if (l1
== 's' && src
[2] >= '0' && src
[2] <= '3'
1008 && ! IDENT_CHAR ((unsigned char) src
[3]))
1013 *reg
= n
| ((~n
& 2) << 1);
1018 if (l0
== 'i' && l1
&& ! IDENT_CHAR ((unsigned char) src
[2]))
1040 if (l0
== 'x' && l1
>= '0' && l1
<= '1'
1041 && ! IDENT_CHAR ((unsigned char) src
[2]))
1044 *reg
= A_X0_NUM
+ l1
- '0';
1048 if (l0
== 'y' && l1
>= '0' && l1
<= '1'
1049 && ! IDENT_CHAR ((unsigned char) src
[2]))
1052 *reg
= A_Y0_NUM
+ l1
- '0';
1056 if (l0
== 'm' && l1
>= '0' && l1
<= '1'
1057 && ! IDENT_CHAR ((unsigned char) src
[2]))
1060 *reg
= l1
== '0' ? A_M0_NUM
: A_M1_NUM
;
1066 && TOLOWER (src
[2]) == 'r' && ! IDENT_CHAR ((unsigned char) src
[3]))
1072 if (l0
== 's' && l1
== 'p' && TOLOWER (src
[2]) == 'c'
1073 && ! IDENT_CHAR ((unsigned char) src
[3]))
1079 if (l0
== 's' && l1
== 'g' && TOLOWER (src
[2]) == 'r'
1080 && ! IDENT_CHAR ((unsigned char) src
[3]))
1086 if (l0
== 'd' && l1
== 's' && TOLOWER (src
[2]) == 'r'
1087 && ! IDENT_CHAR ((unsigned char) src
[3]))
1093 if (l0
== 'd' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1094 && ! IDENT_CHAR ((unsigned char) src
[3]))
1100 if (l0
== 's' && l1
== 'r' && ! IDENT_CHAR ((unsigned char) src
[2]))
1106 if (l0
== 's' && l1
== 'p' && ! IDENT_CHAR ((unsigned char) src
[2]))
1113 if (l0
== 'p' && l1
== 'r' && ! IDENT_CHAR ((unsigned char) src
[2]))
1118 if (l0
== 'p' && l1
== 'c' && ! IDENT_CHAR ((unsigned char) src
[2]))
1120 /* Don't use A_DISP_PC here - that would accept stuff like 'mova pc,r0'
1121 and use an uninitialized immediate. */
1125 if (l0
== 'g' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1126 && ! IDENT_CHAR ((unsigned char) src
[3]))
1131 if (l0
== 'v' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1132 && ! IDENT_CHAR ((unsigned char) src
[3]))
1138 if (l0
== 'm' && l1
== 'a' && TOLOWER (src
[2]) == 'c'
1139 && ! IDENT_CHAR ((unsigned char) src
[4]))
1141 if (TOLOWER (src
[3]) == 'l')
1146 if (TOLOWER (src
[3]) == 'h')
1152 if (l0
== 'm' && l1
== 'o' && TOLOWER (src
[2]) == 'd'
1153 && ! IDENT_CHAR ((unsigned char) src
[3]))
1158 if (l0
== 'f' && l1
== 'r')
1162 if (src
[3] >= '0' && src
[3] <= '5'
1163 && ! IDENT_CHAR ((unsigned char) src
[4]))
1166 *reg
= 10 + src
[3] - '0';
1170 if (src
[2] >= '0' && src
[2] <= '9'
1171 && ! IDENT_CHAR ((unsigned char) src
[3]))
1174 *reg
= (src
[2] - '0');
1178 if (l0
== 'd' && l1
== 'r')
1182 if (src
[3] >= '0' && src
[3] <= '4' && ! ((src
[3] - '0') & 1)
1183 && ! IDENT_CHAR ((unsigned char) src
[4]))
1186 *reg
= 10 + src
[3] - '0';
1190 if (src
[2] >= '0' && src
[2] <= '8' && ! ((src
[2] - '0') & 1)
1191 && ! IDENT_CHAR ((unsigned char) src
[3]))
1194 *reg
= (src
[2] - '0');
1198 if (l0
== 'x' && l1
== 'd')
1202 if (src
[3] >= '0' && src
[3] <= '4' && ! ((src
[3] - '0') & 1)
1203 && ! IDENT_CHAR ((unsigned char) src
[4]))
1206 *reg
= 11 + src
[3] - '0';
1210 if (src
[2] >= '0' && src
[2] <= '8' && ! ((src
[2] - '0') & 1)
1211 && ! IDENT_CHAR ((unsigned char) src
[3]))
1214 *reg
= (src
[2] - '0') + 1;
1218 if (l0
== 'f' && l1
== 'v')
1220 if (src
[2] == '1'&& src
[3] == '2' && ! IDENT_CHAR ((unsigned char) src
[4]))
1226 if ((src
[2] == '0' || src
[2] == '4' || src
[2] == '8')
1227 && ! IDENT_CHAR ((unsigned char) src
[3]))
1230 *reg
= (src
[2] - '0');
1234 if (l0
== 'f' && l1
== 'p' && TOLOWER (src
[2]) == 'u'
1235 && TOLOWER (src
[3]) == 'l'
1236 && ! IDENT_CHAR ((unsigned char) src
[4]))
1242 if (l0
== 'f' && l1
== 'p' && TOLOWER (src
[2]) == 's'
1243 && TOLOWER (src
[3]) == 'c'
1244 && TOLOWER (src
[4]) == 'r' && ! IDENT_CHAR ((unsigned char) src
[5]))
1250 if (l0
== 'x' && l1
== 'm' && TOLOWER (src
[2]) == 't'
1251 && TOLOWER (src
[3]) == 'r'
1252 && TOLOWER (src
[4]) == 'x' && ! IDENT_CHAR ((unsigned char) src
[5]))
1264 sh_operand_info
*op
;
1269 save
= input_line_pointer
;
1270 input_line_pointer
= s
;
1271 expression (&op
->immediate
);
1272 if (op
->immediate
.X_op
== O_absent
)
1273 as_bad (_("missing operand"));
1275 else if (op
->immediate
.X_op
== O_PIC_reloc
1276 || sh_PIC_related_p (op
->immediate
.X_add_symbol
)
1277 || sh_PIC_related_p (op
->immediate
.X_op_symbol
))
1278 as_bad (_("misplaced PIC operand"));
1280 new = input_line_pointer
;
1281 input_line_pointer
= save
;
1285 /* The many forms of operand:
1288 @Rn Register indirect
1301 pr, gbr, vbr, macl, mach
1307 sh_operand_info
*op
;
1314 /* Must be predecrement. */
1317 len
= parse_reg (src
, &mode
, &(op
->reg
));
1318 if (mode
!= A_REG_N
)
1319 as_bad (_("illegal register after @-"));
1324 else if (src
[0] == '(')
1326 /* Could be @(disp, rn), @(disp, gbr), @(disp, pc), @(r0, gbr) or
1329 len
= parse_reg (src
, &mode
, &(op
->reg
));
1330 if (len
&& mode
== A_REG_N
)
1335 as_bad (_("must be @(r0,...)"));
1340 /* Now can be rn or gbr. */
1341 len
= parse_reg (src
, &mode
, &(op
->reg
));
1351 op
->type
= A_R0_GBR
;
1353 else if (mode
== A_REG_N
)
1355 op
->type
= A_IND_R0_REG_N
;
1359 as_bad (_("syntax error in @(r0,...)"));
1364 as_bad (_("syntax error in @(r0...)"));
1369 /* Must be an @(disp,.. thing). */
1370 src
= parse_exp (src
, op
);
1373 /* Now can be rn, gbr or pc. */
1374 len
= parse_reg (src
, &mode
, &op
->reg
);
1377 if (mode
== A_REG_N
)
1379 op
->type
= A_DISP_REG_N
;
1381 else if (mode
== A_GBR
)
1383 op
->type
= A_DISP_GBR
;
1385 else if (mode
== A_PC
)
1387 /* We want @(expr, pc) to uniformly address . + expr,
1388 no matter if expr is a constant, or a more complex
1389 expression, e.g. sym-. or sym1-sym2.
1390 However, we also used to accept @(sym,pc)
1391 as adressing sym, i.e. meaning the same as plain sym.
1392 Some existing code does use the @(sym,pc) syntax, so
1393 we give it the old semantics for now, but warn about
1394 its use, so that users have some time to fix their code.
1396 Note that due to this backward compatibility hack,
1397 we'll get unexpected results when @(offset, pc) is used,
1398 and offset is a symbol that is set later to an an address
1399 difference, or an external symbol that is set to an
1400 address difference in another source file, so we want to
1401 eventually remove it. */
1402 if (op
->immediate
.X_op
== O_symbol
)
1404 op
->type
= A_DISP_PC
;
1405 as_warn (_("Deprecated syntax."));
1409 op
->type
= A_DISP_PC_ABS
;
1410 /* Such operands don't get corrected for PC==.+4, so
1411 make the correction here. */
1412 op
->immediate
.X_add_number
-= 4;
1417 as_bad (_("syntax error in @(disp,[Rn, gbr, pc])"));
1422 as_bad (_("syntax error in @(disp,[Rn, gbr, pc])"));
1427 as_bad (_("expecting )"));
1433 src
+= parse_reg (src
, &mode
, &(op
->reg
));
1434 if (mode
!= A_REG_N
)
1435 as_bad (_("illegal register after @"));
1442 l0
= TOLOWER (src
[0]);
1443 l1
= TOLOWER (src
[1]);
1445 if ((l0
== 'r' && l1
== '8')
1446 || (l0
== 'i' && (l1
== 'x' || l1
== 's')))
1449 op
->type
= A_PMOD_N
;
1451 else if ( (l0
== 'r' && l1
== '9')
1452 || (l0
== 'i' && l1
== 'y'))
1455 op
->type
= A_PMODY_N
;
1467 get_operand (ptr
, op
)
1469 sh_operand_info
*op
;
1478 *ptr
= parse_exp (src
, op
);
1483 else if (src
[0] == '@')
1485 *ptr
= parse_at (src
, op
);
1488 len
= parse_reg (src
, &mode
, &(op
->reg
));
1497 /* Not a reg, the only thing left is a displacement. */
1498 *ptr
= parse_exp (src
, op
);
1499 op
->type
= A_DISP_PC
;
1505 get_operands (info
, args
, operand
)
1506 sh_opcode_info
*info
;
1508 sh_operand_info
*operand
;
1513 /* The pre-processor will eliminate whitespace in front of '@'
1514 after the first argument; we may be called multiple times
1515 from assemble_ppi, so don't insist on finding whitespace here. */
1519 get_operand (&ptr
, operand
+ 0);
1526 get_operand (&ptr
, operand
+ 1);
1527 /* ??? Hack: psha/pshl have a varying operand number depending on
1528 the type of the first operand. We handle this by having the
1529 three-operand version first and reducing the number of operands
1530 parsed to two if we see that the first operand is an immediate.
1531 This works because no insn with three operands has an immediate
1532 as first operand. */
1533 if (info
->arg
[2] && operand
[0].type
!= A_IMM
)
1539 get_operand (&ptr
, operand
+ 2);
1543 operand
[2].type
= 0;
1548 operand
[1].type
= 0;
1549 operand
[2].type
= 0;
1554 operand
[0].type
= 0;
1555 operand
[1].type
= 0;
1556 operand
[2].type
= 0;
1561 /* Passed a pointer to a list of opcodes which use different
1562 addressing modes, return the opcode which matches the opcodes
1565 static sh_opcode_info
*
1566 get_specific (opcode
, operands
)
1567 sh_opcode_info
*opcode
;
1568 sh_operand_info
*operands
;
1570 sh_opcode_info
*this_try
= opcode
;
1571 char *name
= opcode
->name
;
1574 while (opcode
->name
)
1576 this_try
= opcode
++;
1577 if (this_try
->name
!= name
)
1579 /* We've looked so far down the table that we've run out of
1580 opcodes with the same name. */
1584 /* Look at both operands needed by the opcodes and provided by
1585 the user - since an arg test will often fail on the same arg
1586 again and again, we'll try and test the last failing arg the
1587 first on each opcode try. */
1588 for (n
= 0; this_try
->arg
[n
]; n
++)
1590 sh_operand_info
*user
= operands
+ n
;
1591 sh_arg_type arg
= this_try
->arg
[n
];
1596 if (user
->type
== A_DISP_PC_ABS
)
1606 if (user
->type
!= arg
)
1610 /* opcode needs r0 */
1611 if (user
->type
!= A_REG_N
|| user
->reg
!= 0)
1615 if (user
->type
!= A_R0_GBR
|| user
->reg
!= 0)
1619 if (user
->type
!= F_REG_N
|| user
->reg
!= 0)
1627 case A_IND_R0_REG_N
:
1638 /* Opcode needs rn */
1639 if (user
->type
!= arg
)
1644 if (user
->type
!= D_REG_N
&& user
->type
!= X_REG_N
)
1659 if (user
->type
!= arg
)
1664 if (user
->type
!= arg
)
1673 case A_IND_R0_REG_M
:
1676 /* Opcode needs rn */
1677 if (user
->type
!= arg
- A_REG_M
+ A_REG_N
)
1683 if (user
->type
!= DSP_REG_N
)
1705 if (user
->type
!= DSP_REG_N
)
1727 if (user
->type
!= DSP_REG_N
)
1749 if (user
->type
!= DSP_REG_N
)
1771 if (user
->type
!= DSP_REG_N
)
1793 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_A0_NUM
)
1797 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_X0_NUM
)
1801 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_X1_NUM
)
1805 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_Y0_NUM
)
1809 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_Y1_NUM
)
1819 /* Opcode needs rn */
1820 if (user
->type
!= arg
- F_REG_M
+ F_REG_N
)
1825 if (user
->type
!= D_REG_N
&& user
->type
!= X_REG_N
)
1830 if (user
->type
!= XMTRX_M4
)
1836 printf (_("unhandled %d\n"), arg
);
1840 if ( !(valid_arch
& this_try
->arch
))
1842 valid_arch
&= this_try
->arch
;
1852 insert (where
, how
, pcrel
, op
)
1856 sh_operand_info
*op
;
1858 fix_new_exp (frag_now
,
1859 where
- frag_now
->fr_literal
,
1867 build_relax (opcode
, op
)
1868 sh_opcode_info
*opcode
;
1869 sh_operand_info
*op
;
1871 int high_byte
= target_big_endian
? 0 : 1;
1874 if (opcode
->arg
[0] == A_BDISP8
)
1876 int what
= (opcode
->nibbles
[1] & 4) ? COND_JUMP_DELAY
: COND_JUMP
;
1877 p
= frag_var (rs_machine_dependent
,
1878 md_relax_table
[C (what
, COND32
)].rlx_length
,
1879 md_relax_table
[C (what
, COND8
)].rlx_length
,
1881 op
->immediate
.X_add_symbol
,
1882 op
->immediate
.X_add_number
,
1884 p
[high_byte
] = (opcode
->nibbles
[0] << 4) | (opcode
->nibbles
[1]);
1886 else if (opcode
->arg
[0] == A_BDISP12
)
1888 p
= frag_var (rs_machine_dependent
,
1889 md_relax_table
[C (UNCOND_JUMP
, UNCOND32
)].rlx_length
,
1890 md_relax_table
[C (UNCOND_JUMP
, UNCOND12
)].rlx_length
,
1892 op
->immediate
.X_add_symbol
,
1893 op
->immediate
.X_add_number
,
1895 p
[high_byte
] = (opcode
->nibbles
[0] << 4);
1900 /* Insert ldrs & ldre with fancy relocations that relaxation can recognize. */
1903 insert_loop_bounds (output
, operand
)
1905 sh_operand_info
*operand
;
1910 /* Since the low byte of the opcode will be overwritten by the reloc, we
1911 can just stash the high byte into both bytes and ignore endianness. */
1914 insert (output
, BFD_RELOC_SH_LOOP_START
, 1, operand
);
1915 insert (output
, BFD_RELOC_SH_LOOP_END
, 1, operand
+ 1);
1919 static int count
= 0;
1921 /* If the last loop insn is a two-byte-insn, it is in danger of being
1922 swapped with the insn after it. To prevent this, create a new
1923 symbol - complete with SH_LABEL reloc - after the last loop insn.
1924 If the last loop insn is four bytes long, the symbol will be
1925 right in the middle, but four byte insns are not swapped anyways. */
1926 /* A REPEAT takes 6 bytes. The SH has a 32 bit address space.
1927 Hence a 9 digit number should be enough to count all REPEATs. */
1929 sprintf (name
, "_R%x", count
++ & 0x3fffffff);
1930 end_sym
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
1931 /* Make this a local symbol. */
1933 SF_SET_LOCAL (end_sym
);
1934 #endif /* OBJ_COFF */
1935 symbol_table_insert (end_sym
);
1936 end_sym
->sy_value
= operand
[1].immediate
;
1937 end_sym
->sy_value
.X_add_number
+= 2;
1938 fix_new (frag_now
, frag_now_fix (), 2, end_sym
, 0, 1, BFD_RELOC_SH_LABEL
);
1941 output
= frag_more (2);
1944 insert (output
, BFD_RELOC_SH_LOOP_START
, 1, operand
);
1945 insert (output
, BFD_RELOC_SH_LOOP_END
, 1, operand
+ 1);
1947 return frag_more (2);
1950 /* Now we know what sort of opcodes it is, let's build the bytes. */
1953 build_Mytes (opcode
, operand
)
1954 sh_opcode_info
*opcode
;
1955 sh_operand_info
*operand
;
1959 char *output
= frag_more (2);
1960 unsigned int size
= 2;
1961 int low_byte
= target_big_endian
? 1 : 0;
1967 for (index
= 0; index
< 4; index
++)
1969 sh_nibble_type i
= opcode
->nibbles
[index
];
1979 nbuf
[index
] = reg_n
;
1982 nbuf
[index
] = reg_m
;
1985 if (reg_n
< 2 || reg_n
> 5)
1986 as_bad (_("Invalid register: 'r%d'"), reg_n
);
1987 nbuf
[index
] = (reg_n
& 3) | 4;
1990 nbuf
[index
] = reg_n
| (reg_m
>> 2);
1993 nbuf
[index
] = reg_b
| 0x08;
1996 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY4
, 0, operand
);
1999 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY2
, 0, operand
);
2002 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4
, 0, operand
);
2005 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY4
, 0, operand
+ 1);
2008 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY2
, 0, operand
+ 1);
2011 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4
, 0, operand
+ 1);
2014 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY4
, 0, operand
);
2017 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY2
, 0, operand
);
2020 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8
, 0, operand
);
2023 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY4
, 0, operand
+ 1);
2026 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY2
, 0, operand
+ 1);
2029 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8
, 0, operand
+ 1);
2032 insert (output
, BFD_RELOC_SH_PCRELIMM8BY4
,
2033 operand
->type
!= A_DISP_PC_ABS
, operand
);
2036 insert (output
, BFD_RELOC_SH_PCRELIMM8BY2
,
2037 operand
->type
!= A_DISP_PC_ABS
, operand
);
2040 output
= insert_loop_bounds (output
, operand
);
2041 nbuf
[index
] = opcode
->nibbles
[3];
2045 printf (_("failed for %d\n"), i
);
2049 if (!target_big_endian
)
2051 output
[1] = (nbuf
[0] << 4) | (nbuf
[1]);
2052 output
[0] = (nbuf
[2] << 4) | (nbuf
[3]);
2056 output
[0] = (nbuf
[0] << 4) | (nbuf
[1]);
2057 output
[1] = (nbuf
[2] << 4) | (nbuf
[3]);
2062 /* Find an opcode at the start of *STR_P in the hash table, and set
2063 *STR_P to the first character after the last one read. */
2065 static sh_opcode_info
*
2066 find_cooked_opcode (str_p
)
2070 unsigned char *op_start
;
2071 unsigned char *op_end
;
2075 /* Drop leading whitespace. */
2079 /* Find the op code end.
2080 The pre-processor will eliminate whitespace in front of
2081 any '@' after the first argument; we may be called from
2082 assemble_ppi, so the opcode might be terminated by an '@'. */
2083 for (op_start
= op_end
= (unsigned char *) (str
);
2086 && !is_end_of_line
[*op_end
] && *op_end
!= ' ' && *op_end
!= '@';
2089 unsigned char c
= op_start
[nlen
];
2091 /* The machine independent code will convert CMP/EQ into cmp/EQ
2092 because it thinks the '/' is the end of the symbol. Moreover,
2093 all but the first sub-insn is a parallel processing insn won't
2094 be capitalized. Instead of hacking up the machine independent
2095 code, we just deal with it here. */
2105 as_bad (_("can't find opcode "));
2107 return (sh_opcode_info
*) hash_find (opcode_hash_control
, name
);
2110 /* Assemble a parallel processing insn. */
2111 #define DDT_BASE 0xf000 /* Base value for double data transfer insns */
2114 assemble_ppi (op_end
, opcode
)
2116 sh_opcode_info
*opcode
;
2128 sh_operand_info operand
[3];
2130 /* Some insn ignore one or more register fields, e.g. psts machl,a0.
2131 Make sure we encode a defined insn pattern. */
2136 if (opcode
->arg
[0] != A_END
)
2137 op_end
= get_operands (opcode
, op_end
, operand
);
2138 opcode
= get_specific (opcode
, operand
);
2141 /* Couldn't find an opcode which matched the operands. */
2142 char *where
= frag_more (2);
2147 as_bad (_("invalid operands for opcode"));
2151 if (opcode
->nibbles
[0] != PPI
)
2152 as_bad (_("insn can't be combined with parallel processing insn"));
2154 switch (opcode
->nibbles
[1])
2159 as_bad (_("multiple movx specifications"));
2164 as_bad (_("multiple movy specifications"));
2170 as_bad (_("multiple movx specifications"));
2171 if (reg_n
< 4 || reg_n
> 5)
2172 as_bad (_("invalid movx address register"));
2173 if (opcode
->nibbles
[2] & 8)
2175 if (reg_m
== A_A1_NUM
)
2177 else if (reg_m
!= A_A0_NUM
)
2178 as_bad (_("invalid movx dsp register"));
2183 as_bad (_("invalid movx dsp register"));
2186 movx
+= ((reg_n
- 4) << 9) + (opcode
->nibbles
[2] << 2) + DDT_BASE
;
2191 as_bad (_("multiple movy specifications"));
2192 if (opcode
->nibbles
[2] & 8)
2194 /* Bit 3 in nibbles[2] is intended for bit 4 of the opcode,
2197 if (reg_m
== A_A1_NUM
)
2199 else if (reg_m
!= A_A0_NUM
)
2200 as_bad (_("invalid movy dsp register"));
2205 as_bad (_("invalid movy dsp register"));
2208 if (reg_n
< 6 || reg_n
> 7)
2209 as_bad (_("invalid movy address register"));
2210 movy
+= ((reg_n
- 6) << 8) + opcode
->nibbles
[2] + DDT_BASE
;
2214 if (operand
[0].immediate
.X_op
!= O_constant
)
2215 as_bad (_("dsp immediate shift value not constant"));
2216 field_b
= ((opcode
->nibbles
[2] << 12)
2217 | (operand
[0].immediate
.X_add_number
& 127) << 4
2222 as_bad (_("multiple parallel processing specifications"));
2223 field_b
= ((opcode
->nibbles
[2] << 12) + (opcode
->nibbles
[3] << 8)
2224 + (reg_x
<< 6) + (reg_y
<< 4) + reg_n
);
2228 as_bad (_("multiple condition specifications"));
2229 cond
= opcode
->nibbles
[2] << 8;
2231 goto skip_cond_check
;
2235 as_bad (_("multiple parallel processing specifications"));
2236 field_b
= ((opcode
->nibbles
[2] << 12) + (opcode
->nibbles
[3] << 8)
2237 + cond
+ (reg_x
<< 6) + (reg_y
<< 4) + reg_n
);
2243 if ((field_b
& 0xef00) != 0xa100)
2244 as_bad (_("insn cannot be combined with pmuls"));
2246 switch (field_b
& 0xf)
2249 field_b
+= 0 - A_X0_NUM
;
2252 field_b
+= 1 - A_Y0_NUM
;
2255 field_b
+= 2 - A_A0_NUM
;
2258 field_b
+= 3 - A_A1_NUM
;
2261 as_bad (_("bad padd / psub pmuls output operand"));
2263 /* Generate warning if the destination register for padd / psub
2264 and pmuls is the same ( only for A0 or A1 ).
2265 If the last nibble is 1010 then A0 is used in both
2266 padd / psub and pmuls. If it is 1111 then A1 is used
2267 as destination register in both padd / psub and pmuls. */
2269 if ((((field_b
| reg_efg
) & 0x000F) == 0x000A)
2270 || (((field_b
| reg_efg
) & 0x000F) == 0x000F))
2271 as_warn (_("destination register is same for parallel insns"));
2273 field_b
+= 0x4000 + reg_efg
;
2280 as_bad (_("condition not followed by conditionalizable insn"));
2286 opcode
= find_cooked_opcode (&op_end
);
2290 (_("unrecognized characters at end of parallel processing insn")));
2295 move_code
= movx
| movy
;
2298 /* Parallel processing insn. */
2299 unsigned long ppi_code
= (movx
| movy
| 0xf800) << 16 | field_b
;
2301 output
= frag_more (4);
2303 if (! target_big_endian
)
2305 output
[3] = ppi_code
>> 8;
2306 output
[2] = ppi_code
;
2310 output
[2] = ppi_code
>> 8;
2311 output
[3] = ppi_code
;
2313 move_code
|= 0xf800;
2317 /* Just a double data transfer. */
2318 output
= frag_more (2);
2321 if (! target_big_endian
)
2323 output
[1] = move_code
>> 8;
2324 output
[0] = move_code
;
2328 output
[0] = move_code
>> 8;
2329 output
[1] = move_code
;
2334 /* This is the guts of the machine-dependent assembler. STR points to a
2335 machine dependent instruction. This function is supposed to emit
2336 the frags/bytes it assembles to. */
2342 unsigned char *op_end
;
2343 sh_operand_info operand
[3];
2344 sh_opcode_info
*opcode
;
2345 unsigned int size
= 0;
2348 if (sh64_isa_mode
== sh64_isa_shmedia
)
2350 shmedia_md_assemble (str
);
2355 /* If we've seen pseudo-directives, make sure any emitted data or
2356 frags are marked as data. */
2357 if (seen_insn
== false)
2359 sh64_update_contents_mark (true);
2360 sh64_set_contents_type (CRT_SH5_ISA16
);
2365 #endif /* HAVE_SH64 */
2367 opcode
= find_cooked_opcode (&str
);
2372 as_bad (_("unknown opcode"));
2377 && ! seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2379 /* Output a CODE reloc to tell the linker that the following
2380 bytes are instructions, not data. */
2381 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0,
2383 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 1;
2386 if (opcode
->nibbles
[0] == PPI
)
2388 size
= assemble_ppi (op_end
, opcode
);
2392 if (opcode
->arg
[0] == A_BDISP12
2393 || opcode
->arg
[0] == A_BDISP8
)
2395 parse_exp (op_end
+ 1, &operand
[0]);
2396 build_relax (opcode
, &operand
[0]);
2400 if (opcode
->arg
[0] == A_END
)
2402 /* Ignore trailing whitespace. If there is any, it has already
2403 been compressed to a single space. */
2409 op_end
= get_operands (opcode
, op_end
, operand
);
2411 opcode
= get_specific (opcode
, operand
);
2415 /* Couldn't find an opcode which matched the operands. */
2416 char *where
= frag_more (2);
2421 as_bad (_("invalid operands for opcode"));
2426 as_bad (_("excess operands: '%s'"), op_end
);
2428 size
= build_Mytes (opcode
, operand
);
2433 #ifdef BFD_ASSEMBLER
2434 dwarf2_emit_insn (size
);
2438 /* This routine is called each time a label definition is seen. It
2439 emits a BFD_RELOC_SH_LABEL reloc if necessary. */
2444 static fragS
*last_label_frag
;
2445 static int last_label_offset
;
2448 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2452 offset
= frag_now_fix ();
2453 if (frag_now
!= last_label_frag
2454 || offset
!= last_label_offset
)
2456 fix_new (frag_now
, offset
, 2, &abs_symbol
, 0, 0, BFD_RELOC_SH_LABEL
);
2457 last_label_frag
= frag_now
;
2458 last_label_offset
= offset
;
2463 /* This routine is called when the assembler is about to output some
2464 data. It emits a BFD_RELOC_SH_DATA reloc if necessary. */
2467 sh_flush_pending_output ()
2470 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2472 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0,
2474 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 0;
2479 md_undefined_symbol (name
)
2480 char *name ATTRIBUTE_UNUSED
;
2486 #ifndef BFD_ASSEMBLER
2489 tc_crawl_symbol_chain (headers
)
2490 object_headers
*headers ATTRIBUTE_UNUSED
;
2492 printf (_("call to tc_crawl_symbol_chain \n"));
2496 tc_headers_hook (headers
)
2497 object_headers
*headers ATTRIBUTE_UNUSED
;
2499 printf (_("call to tc_headers_hook \n"));
2505 /* Various routines to kill one day. */
2506 /* Equal to MAX_PRECISION in atof-ieee.c. */
2507 #define MAX_LITTLENUMS 6
2509 /* Turn a string in input_line_pointer into a floating point constant
2510 of type TYPE, and store the appropriate bytes in *LITP. The number
2511 of LITTLENUMS emitted is stored in *SIZEP . An error message is
2512 returned, or NULL on OK. */
2515 md_atof (type
, litP
, sizeP
)
2521 LITTLENUM_TYPE words
[4];
2537 return _("bad call to md_atof");
2540 t
= atof_ieee (input_line_pointer
, type
, words
);
2542 input_line_pointer
= t
;
2546 if (! target_big_endian
)
2548 for (i
= prec
- 1; i
>= 0; i
--)
2550 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
2556 for (i
= 0; i
< prec
; i
++)
2558 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
2566 /* Handle the .uses pseudo-op. This pseudo-op is used just before a
2567 call instruction. It refers to a label of the instruction which
2568 loads the register which the call uses. We use it to generate a
2569 special reloc for the linker. */
2573 int ignore ATTRIBUTE_UNUSED
;
2578 as_warn (_(".uses pseudo-op seen when not relaxing"));
2582 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
2584 as_bad (_("bad .uses format"));
2585 ignore_rest_of_line ();
2589 fix_new_exp (frag_now
, frag_now_fix (), 2, &ex
, 1, BFD_RELOC_SH_USES
);
2591 demand_empty_rest_of_line ();
2594 const char *md_shortopts
= "";
2595 struct option md_longopts
[] =
2597 #define OPTION_RELAX (OPTION_MD_BASE)
2598 #define OPTION_BIG (OPTION_MD_BASE + 1)
2599 #define OPTION_LITTLE (OPTION_BIG + 1)
2600 #define OPTION_SMALL (OPTION_LITTLE + 1)
2601 #define OPTION_DSP (OPTION_SMALL + 1)
2603 {"relax", no_argument
, NULL
, OPTION_RELAX
},
2604 {"big", no_argument
, NULL
, OPTION_BIG
},
2605 {"little", no_argument
, NULL
, OPTION_LITTLE
},
2606 {"small", no_argument
, NULL
, OPTION_SMALL
},
2607 {"dsp", no_argument
, NULL
, OPTION_DSP
},
2609 #define OPTION_ISA (OPTION_DSP + 1)
2610 #define OPTION_ABI (OPTION_ISA + 1)
2611 #define OPTION_NO_MIX (OPTION_ABI + 1)
2612 #define OPTION_SHCOMPACT_CONST_CRANGE (OPTION_NO_MIX + 1)
2613 #define OPTION_NO_EXPAND (OPTION_SHCOMPACT_CONST_CRANGE + 1)
2614 #define OPTION_PT32 (OPTION_NO_EXPAND + 1)
2615 {"isa", required_argument
, NULL
, OPTION_ISA
},
2616 {"abi", required_argument
, NULL
, OPTION_ABI
},
2617 {"no-mix", no_argument
, NULL
, OPTION_NO_MIX
},
2618 {"shcompact-const-crange", no_argument
, NULL
, OPTION_SHCOMPACT_CONST_CRANGE
},
2619 {"no-expand", no_argument
, NULL
, OPTION_NO_EXPAND
},
2620 {"expand-pt32", no_argument
, NULL
, OPTION_PT32
},
2621 #endif /* HAVE_SH64 */
2623 {NULL
, no_argument
, NULL
, 0}
2625 size_t md_longopts_size
= sizeof (md_longopts
);
2628 md_parse_option (c
, arg
)
2630 char *arg ATTRIBUTE_UNUSED
;
2639 target_big_endian
= 1;
2643 target_big_endian
= 0;
2656 if (strcasecmp (arg
, "shmedia") == 0)
2658 if (sh64_isa_mode
== sh64_isa_shcompact
)
2659 as_bad (_("Invalid combination: --isa=SHcompact with --isa=SHmedia"));
2660 sh64_isa_mode
= sh64_isa_shmedia
;
2662 else if (strcasecmp (arg
, "shcompact") == 0)
2664 if (sh64_isa_mode
== sh64_isa_shmedia
)
2665 as_bad (_("Invalid combination: --isa=SHmedia with --isa=SHcompact"));
2666 if (sh64_abi
== sh64_abi_64
)
2667 as_bad (_("Invalid combination: --abi=64 with --isa=SHcompact"));
2668 sh64_isa_mode
= sh64_isa_shcompact
;
2671 as_bad ("Invalid argument to --isa option: %s", arg
);
2675 if (strcmp (arg
, "32") == 0)
2677 if (sh64_abi
== sh64_abi_64
)
2678 as_bad (_("Invalid combination: --abi=32 with --abi=64"));
2679 sh64_abi
= sh64_abi_32
;
2681 else if (strcmp (arg
, "64") == 0)
2683 if (sh64_abi
== sh64_abi_32
)
2684 as_bad (_("Invalid combination: --abi=64 with --abi=32"));
2685 if (sh64_isa_mode
== sh64_isa_shcompact
)
2686 as_bad (_("Invalid combination: --isa=SHcompact with --abi=64"));
2687 sh64_abi
= sh64_abi_64
;
2690 as_bad ("Invalid argument to --abi option: %s", arg
);
2697 case OPTION_SHCOMPACT_CONST_CRANGE
:
2698 sh64_shcompact_const_crange
= true;
2701 case OPTION_NO_EXPAND
:
2702 sh64_expand
= false;
2708 #endif /* HAVE_SH64 */
2718 md_show_usage (stream
)
2721 fprintf (stream
, _("\
2723 -little generate little endian code\n\
2724 -big generate big endian code\n\
2725 -relax alter jump instructions for long displacements\n\
2726 -small align sections to 4 byte boundaries, not 16\n\
2727 -dsp enable sh-dsp insns, and disable sh3e / sh4 insns.\n"));
2729 fprintf (stream
, _("\
2730 -isa=[shmedia set default instruction set for SH64\n\
2734 -abi=[32|64] set size of expanded SHmedia operands and object\n\
2736 -shcompact-const-crange emit code-range descriptors for constants in\n\
2737 SHcompact code sections\n\
2738 -no-mix disallow SHmedia code in the same section as\n\
2739 constants and SHcompact code\n\
2740 -no-expand do not expand MOVI, PT, PTA or PTB instructions\n\
2741 -expand-pt32 with -abi=64, expand PT, PTA and PTB instructions\n\
2743 #endif /* HAVE_SH64 */
2746 /* This struct is used to pass arguments to sh_count_relocs through
2747 bfd_map_over_sections. */
2749 struct sh_count_relocs
2751 /* Symbol we are looking for. */
2753 /* Count of relocs found. */
2757 /* Count the number of fixups in a section which refer to a particular
2758 symbol. When using BFD_ASSEMBLER, this is called via
2759 bfd_map_over_sections. */
2762 sh_count_relocs (abfd
, sec
, data
)
2763 bfd
*abfd ATTRIBUTE_UNUSED
;
2767 struct sh_count_relocs
*info
= (struct sh_count_relocs
*) data
;
2768 segment_info_type
*seginfo
;
2772 seginfo
= seg_info (sec
);
2773 if (seginfo
== NULL
)
2777 for (fix
= seginfo
->fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
2779 if (fix
->fx_addsy
== sym
)
2787 /* Handle the count relocs for a particular section. When using
2788 BFD_ASSEMBLER, this is called via bfd_map_over_sections. */
2791 sh_frob_section (abfd
, sec
, ignore
)
2792 bfd
*abfd ATTRIBUTE_UNUSED
;
2794 PTR ignore ATTRIBUTE_UNUSED
;
2796 segment_info_type
*seginfo
;
2799 seginfo
= seg_info (sec
);
2800 if (seginfo
== NULL
)
2803 for (fix
= seginfo
->fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
2808 struct sh_count_relocs info
;
2810 if (fix
->fx_r_type
!= BFD_RELOC_SH_USES
)
2813 /* The BFD_RELOC_SH_USES reloc should refer to a defined local
2814 symbol in the same section. */
2815 sym
= fix
->fx_addsy
;
2817 || fix
->fx_subsy
!= NULL
2818 || fix
->fx_addnumber
!= 0
2819 || S_GET_SEGMENT (sym
) != sec
2820 #if ! defined (BFD_ASSEMBLER) && defined (OBJ_COFF)
2821 || S_GET_STORAGE_CLASS (sym
) == C_EXT
2823 || S_IS_EXTERNAL (sym
))
2825 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2826 _(".uses does not refer to a local symbol in the same section"));
2830 /* Look through the fixups again, this time looking for one
2831 at the same location as sym. */
2832 val
= S_GET_VALUE (sym
);
2833 for (fscan
= seginfo
->fix_root
;
2835 fscan
= fscan
->fx_next
)
2836 if (val
== fscan
->fx_frag
->fr_address
+ fscan
->fx_where
2837 && fscan
->fx_r_type
!= BFD_RELOC_SH_ALIGN
2838 && fscan
->fx_r_type
!= BFD_RELOC_SH_CODE
2839 && fscan
->fx_r_type
!= BFD_RELOC_SH_DATA
2840 && fscan
->fx_r_type
!= BFD_RELOC_SH_LABEL
)
2844 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2845 _("can't find fixup pointed to by .uses"));
2849 if (fscan
->fx_tcbit
)
2851 /* We've already done this one. */
2855 /* The variable fscan should also be a fixup to a local symbol
2856 in the same section. */
2857 sym
= fscan
->fx_addsy
;
2859 || fscan
->fx_subsy
!= NULL
2860 || fscan
->fx_addnumber
!= 0
2861 || S_GET_SEGMENT (sym
) != sec
2862 #if ! defined (BFD_ASSEMBLER) && defined (OBJ_COFF)
2863 || S_GET_STORAGE_CLASS (sym
) == C_EXT
2865 || S_IS_EXTERNAL (sym
))
2867 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2868 _(".uses target does not refer to a local symbol in the same section"));
2872 /* Now we look through all the fixups of all the sections,
2873 counting the number of times we find a reference to sym. */
2876 #ifdef BFD_ASSEMBLER
2877 bfd_map_over_sections (stdoutput
, sh_count_relocs
, (PTR
) &info
);
2882 for (iscan
= SEG_E0
; iscan
< SEG_UNKNOWN
; iscan
++)
2883 sh_count_relocs ((bfd
*) NULL
, iscan
, (PTR
) &info
);
2890 /* Generate a BFD_RELOC_SH_COUNT fixup at the location of sym.
2891 We have already adjusted the value of sym to include the
2892 fragment address, so we undo that adjustment here. */
2893 subseg_change (sec
, 0);
2894 fix_new (fscan
->fx_frag
,
2895 S_GET_VALUE (sym
) - fscan
->fx_frag
->fr_address
,
2896 4, &abs_symbol
, info
.count
, 0, BFD_RELOC_SH_COUNT
);
2900 /* This function is called after the symbol table has been completed,
2901 but before the relocs or section contents have been written out.
2902 If we have seen any .uses pseudo-ops, they point to an instruction
2903 which loads a register with the address of a function. We look
2904 through the fixups to find where the function address is being
2905 loaded from. We then generate a COUNT reloc giving the number of
2906 times that function address is referred to. The linker uses this
2907 information when doing relaxing, to decide when it can eliminate
2908 the stored function address entirely. */
2914 shmedia_frob_file_before_adjust ();
2920 #ifdef BFD_ASSEMBLER
2921 bfd_map_over_sections (stdoutput
, sh_frob_section
, (PTR
) NULL
);
2926 for (iseg
= SEG_E0
; iseg
< SEG_UNKNOWN
; iseg
++)
2927 sh_frob_section ((bfd
*) NULL
, iseg
, (PTR
) NULL
);
2932 /* Called after relaxing. Set the correct sizes of the fragments, and
2933 create relocs so that md_apply_fix3 will fill in the correct values. */
2936 md_convert_frag (headers
, seg
, fragP
)
2937 #ifdef BFD_ASSEMBLER
2938 bfd
*headers ATTRIBUTE_UNUSED
;
2940 object_headers
*headers ATTRIBUTE_UNUSED
;
2947 switch (fragP
->fr_subtype
)
2949 case C (COND_JUMP
, COND8
):
2950 case C (COND_JUMP_DELAY
, COND8
):
2951 subseg_change (seg
, 0);
2952 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
2953 1, BFD_RELOC_SH_PCDISP8BY2
);
2958 case C (UNCOND_JUMP
, UNCOND12
):
2959 subseg_change (seg
, 0);
2960 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
2961 1, BFD_RELOC_SH_PCDISP12BY2
);
2966 case C (UNCOND_JUMP
, UNCOND32
):
2967 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
2968 if (fragP
->fr_symbol
== NULL
)
2969 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2970 _("displacement overflows 12-bit field"));
2971 else if (S_IS_DEFINED (fragP
->fr_symbol
))
2972 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2973 _("displacement to defined symbol %s overflows 12-bit field"),
2974 S_GET_NAME (fragP
->fr_symbol
));
2976 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2977 _("displacement to undefined symbol %s overflows 12-bit field"),
2978 S_GET_NAME (fragP
->fr_symbol
));
2979 /* Stabilize this frag, so we don't trip an assert. */
2980 fragP
->fr_fix
+= fragP
->fr_var
;
2984 case C (COND_JUMP
, COND12
):
2985 case C (COND_JUMP_DELAY
, COND12
):
2986 /* A bcond won't fit, so turn it into a b!cond; bra disp; nop. */
2987 /* I found that a relax failure for gcc.c-torture/execute/930628-1.c
2988 was due to gas incorrectly relaxing an out-of-range conditional
2989 branch with delay slot. It turned:
2990 bf.s L6 (slot mov.l r12,@(44,r0))
2993 2c: 8f 01 a0 8b bf.s 32 <_main+32> (slot bra L6)
2995 32: 10 cb mov.l r12,@(44,r0)
2996 Therefore, branches with delay slots have to be handled
2997 differently from ones without delay slots. */
2999 unsigned char *buffer
=
3000 (unsigned char *) (fragP
->fr_fix
+ fragP
->fr_literal
);
3001 int highbyte
= target_big_endian
? 0 : 1;
3002 int lowbyte
= target_big_endian
? 1 : 0;
3003 int delay
= fragP
->fr_subtype
== C (COND_JUMP_DELAY
, COND12
);
3005 /* Toggle the true/false bit of the bcond. */
3006 buffer
[highbyte
] ^= 0x2;
3008 /* If this is a delayed branch, we may not put the bra in the
3009 slot. So we change it to a non-delayed branch, like that:
3010 b! cond slot_label; bra disp; slot_label: slot_insn
3011 ??? We should try if swapping the conditional branch and
3012 its delay-slot insn already makes the branch reach. */
3014 /* Build a relocation to six / four bytes farther on. */
3015 subseg_change (seg
, 0);
3016 fix_new (fragP
, fragP
->fr_fix
, 2,
3017 #ifdef BFD_ASSEMBLER
3018 section_symbol (seg
),
3020 seg_info (seg
)->dot
,
3022 fragP
->fr_address
+ fragP
->fr_fix
+ (delay
? 4 : 6),
3023 1, BFD_RELOC_SH_PCDISP8BY2
);
3025 /* Set up a jump instruction. */
3026 buffer
[highbyte
+ 2] = 0xa0;
3027 buffer
[lowbyte
+ 2] = 0;
3028 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
3029 fragP
->fr_offset
, 1, BFD_RELOC_SH_PCDISP12BY2
);
3033 buffer
[highbyte
] &= ~0x4; /* Removes delay slot from branch. */
3038 /* Fill in a NOP instruction. */
3039 buffer
[highbyte
+ 4] = 0x0;
3040 buffer
[lowbyte
+ 4] = 0x9;
3049 case C (COND_JUMP
, COND32
):
3050 case C (COND_JUMP_DELAY
, COND32
):
3051 case C (COND_JUMP
, UNDEF_WORD_DISP
):
3052 case C (COND_JUMP_DELAY
, UNDEF_WORD_DISP
):
3053 if (fragP
->fr_symbol
== NULL
)
3054 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3055 _("displacement overflows 8-bit field"));
3056 else if (S_IS_DEFINED (fragP
->fr_symbol
))
3057 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3058 _("displacement to defined symbol %s overflows 8-bit field"),
3059 S_GET_NAME (fragP
->fr_symbol
));
3061 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3062 _("displacement to undefined symbol %s overflows 8-bit field "),
3063 S_GET_NAME (fragP
->fr_symbol
));
3064 /* Stabilize this frag, so we don't trip an assert. */
3065 fragP
->fr_fix
+= fragP
->fr_var
;
3071 shmedia_md_convert_frag (headers
, seg
, fragP
, true);
3077 if (donerelax
&& !sh_relax
)
3078 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
3079 _("overflow in branch to %s; converted into longer instruction sequence"),
3080 (fragP
->fr_symbol
!= NULL
3081 ? S_GET_NAME (fragP
->fr_symbol
)
3086 md_section_align (seg
, size
)
3087 segT seg ATTRIBUTE_UNUSED
;
3090 #ifdef BFD_ASSEMBLER
3093 #else /* ! OBJ_ELF */
3094 return ((size
+ (1 << bfd_get_section_alignment (stdoutput
, seg
)) - 1)
3095 & (-1 << bfd_get_section_alignment (stdoutput
, seg
)));
3096 #endif /* ! OBJ_ELF */
3097 #else /* ! BFD_ASSEMBLER */
3098 return ((size
+ (1 << section_alignment
[(int) seg
]) - 1)
3099 & (-1 << section_alignment
[(int) seg
]));
3100 #endif /* ! BFD_ASSEMBLER */
3103 /* This static variable is set by s_uacons to tell sh_cons_align that
3104 the expession does not need to be aligned. */
3106 static int sh_no_align_cons
= 0;
3108 /* This handles the unaligned space allocation pseudo-ops, such as
3109 .uaword. .uaword is just like .word, but the value does not need
3116 /* Tell sh_cons_align not to align this value. */
3117 sh_no_align_cons
= 1;
3121 /* If a .word, et. al., pseud-op is seen, warn if the value is not
3122 aligned correctly. Note that this can cause warnings to be issued
3123 when assembling initialized structured which were declared with the
3124 packed attribute. FIXME: Perhaps we should require an option to
3125 enable this warning? */
3128 sh_cons_align (nbytes
)
3134 if (sh_no_align_cons
)
3136 /* This is an unaligned pseudo-op. */
3137 sh_no_align_cons
= 0;
3142 while ((nbytes
& 1) == 0)
3151 if (now_seg
== absolute_section
)
3153 if ((abs_section_offset
& ((1 << nalign
) - 1)) != 0)
3154 as_warn (_("misaligned data"));
3158 p
= frag_var (rs_align_test
, 1, 1, (relax_substateT
) 0,
3159 (symbolS
*) NULL
, (offsetT
) nalign
, (char *) NULL
);
3161 record_alignment (now_seg
, nalign
);
3164 /* When relaxing, we need to output a reloc for any .align directive
3165 that requests alignment to a four byte boundary or larger. This is
3166 also where we check for misaligned data. */
3169 sh_handle_align (frag
)
3172 int bytes
= frag
->fr_next
->fr_address
- frag
->fr_address
- frag
->fr_fix
;
3174 if (frag
->fr_type
== rs_align_code
)
3176 static const unsigned char big_nop_pattern
[] = { 0x00, 0x09 };
3177 static const unsigned char little_nop_pattern
[] = { 0x09, 0x00 };
3179 char *p
= frag
->fr_literal
+ frag
->fr_fix
;
3188 if (target_big_endian
)
3190 memcpy (p
, big_nop_pattern
, sizeof big_nop_pattern
);
3191 frag
->fr_var
= sizeof big_nop_pattern
;
3195 memcpy (p
, little_nop_pattern
, sizeof little_nop_pattern
);
3196 frag
->fr_var
= sizeof little_nop_pattern
;
3199 else if (frag
->fr_type
== rs_align_test
)
3202 as_warn_where (frag
->fr_file
, frag
->fr_line
, _("misaligned data"));
3206 && (frag
->fr_type
== rs_align
3207 || frag
->fr_type
== rs_align_code
)
3208 && frag
->fr_address
+ frag
->fr_fix
> 0
3209 && frag
->fr_offset
> 1
3210 && now_seg
!= bss_section
)
3211 fix_new (frag
, frag
->fr_fix
, 2, &abs_symbol
, frag
->fr_offset
, 0,
3212 BFD_RELOC_SH_ALIGN
);
3215 /* See whether the relocation should be resolved locally. */
3218 sh_local_pcrel (fix
)
3221 return (! sh_relax
&&
3222 (fix
->fx_r_type
== BFD_RELOC_SH_PCDISP8BY2
3223 || fix
->fx_r_type
== BFD_RELOC_SH_PCDISP12BY2
3224 || fix
->fx_r_type
== BFD_RELOC_SH_PCRELIMM8BY2
3225 || fix
->fx_r_type
== BFD_RELOC_SH_PCRELIMM8BY4
3226 || fix
->fx_r_type
== BFD_RELOC_8_PCREL
3227 || fix
->fx_r_type
== BFD_RELOC_SH_SWITCH16
3228 || fix
->fx_r_type
== BFD_RELOC_SH_SWITCH32
));
3231 /* See whether we need to force a relocation into the output file.
3232 This is used to force out switch and PC relative relocations when
3236 sh_force_relocation (fix
)
3239 /* These relocations can't make it into a DSO, so no use forcing
3240 them for global symbols. */
3241 if (sh_local_pcrel (fix
))
3244 /* Make sure some relocations get emitted. */
3245 if (fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
3246 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
3247 || fix
->fx_r_type
== BFD_RELOC_SH_LOOP_START
3248 || fix
->fx_r_type
== BFD_RELOC_SH_LOOP_END
3249 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_GD_32
3250 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_LD_32
3251 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_IE_32
3252 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_LDO_32
3253 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_LE_32
3254 || S_FORCE_RELOC (fix
->fx_addsy
))
3260 return (fix
->fx_pcrel
3261 || SWITCH_TABLE (fix
)
3262 || fix
->fx_r_type
== BFD_RELOC_SH_COUNT
3263 || fix
->fx_r_type
== BFD_RELOC_SH_ALIGN
3264 || fix
->fx_r_type
== BFD_RELOC_SH_CODE
3265 || fix
->fx_r_type
== BFD_RELOC_SH_DATA
3267 || fix
->fx_r_type
== BFD_RELOC_SH_SHMEDIA_CODE
3269 || fix
->fx_r_type
== BFD_RELOC_SH_LABEL
);
3274 sh_fix_adjustable (fixP
)
3277 if (fixP
->fx_r_type
== BFD_RELOC_32_PLT_PCREL
3278 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
3279 || fixP
->fx_r_type
== BFD_RELOC_SH_GOTPC
3280 || fixP
->fx_r_type
== BFD_RELOC_RVA
)
3283 /* We need the symbol name for the VTABLE entries */
3284 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
3285 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
3292 sh_elf_final_processing ()
3296 /* Set file-specific flags to indicate if this code needs
3297 a processor with the sh-dsp / sh3e ISA to execute. */
3299 /* SH5 and above don't know about the valid_arch arch_sh* bits defined
3300 in sh-opc.h, so check SH64 mode before checking valid_arch. */
3301 if (sh64_isa_mode
!= sh64_isa_unspecified
)
3304 #endif /* HAVE_SH64 */
3305 if (valid_arch
& arch_sh1
)
3307 else if (valid_arch
& arch_sh2
)
3309 else if (valid_arch
& arch_sh_dsp
)
3311 else if (valid_arch
& arch_sh3
)
3313 else if (valid_arch
& arch_sh3_dsp
)
3315 else if (valid_arch
& arch_sh3e
)
3317 else if (valid_arch
& arch_sh4
)
3322 elf_elfheader (stdoutput
)->e_flags
&= ~EF_SH_MACH_MASK
;
3323 elf_elfheader (stdoutput
)->e_flags
|= val
;
3327 /* Apply a fixup to the object file. */
3330 md_apply_fix3 (fixP
, valP
, seg
)
3333 segT seg ATTRIBUTE_UNUSED
;
3335 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
3336 int lowbyte
= target_big_endian
? 1 : 0;
3337 int highbyte
= target_big_endian
? 0 : 1;
3338 long val
= (long) *valP
;
3342 #ifdef BFD_ASSEMBLER
3343 /* A difference between two symbols, the second of which is in the
3344 current section, is transformed in a PC-relative relocation to
3345 the other symbol. We have to adjust the relocation type here. */
3348 switch (fixP
->fx_r_type
)
3354 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
3357 /* Currently, we only support 32-bit PCREL relocations.
3358 We'd need a new reloc type to handle 16_PCREL, and
3359 8_PCREL is already taken for R_SH_SWITCH8, which
3360 apparently does something completely different than what
3363 bfd_set_error (bfd_error_bad_value
);
3367 bfd_set_error (bfd_error_bad_value
);
3372 /* The function adjust_reloc_syms won't convert a reloc against a weak
3373 symbol into a reloc against a section, but bfd_install_relocation
3374 will screw up if the symbol is defined, so we have to adjust val here
3375 to avoid the screw up later.
3377 For ordinary relocs, this does not happen for ELF, since for ELF,
3378 bfd_install_relocation uses the "special function" field of the
3379 howto, and does not execute the code that needs to be undone, as long
3380 as the special function does not return bfd_reloc_continue.
3381 It can happen for GOT- and PLT-type relocs the way they are
3382 described in elf32-sh.c as they use bfd_elf_generic_reloc, but it
3383 doesn't matter here since those relocs don't use VAL; see below. */
3384 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
3385 && fixP
->fx_addsy
!= NULL
3386 && S_IS_WEAK (fixP
->fx_addsy
))
3387 val
-= S_GET_VALUE (fixP
->fx_addsy
);
3390 #ifndef BFD_ASSEMBLER
3391 if (fixP
->fx_r_type
== 0)
3393 if (fixP
->fx_size
== 2)
3394 fixP
->fx_r_type
= BFD_RELOC_16
;
3395 else if (fixP
->fx_size
== 4)
3396 fixP
->fx_r_type
= BFD_RELOC_32
;
3397 else if (fixP
->fx_size
== 1)
3398 fixP
->fx_r_type
= BFD_RELOC_8
;
3406 switch (fixP
->fx_r_type
)
3408 case BFD_RELOC_SH_IMM4
:
3410 *buf
= (*buf
& 0xf0) | (val
& 0xf);
3413 case BFD_RELOC_SH_IMM4BY2
:
3416 *buf
= (*buf
& 0xf0) | ((val
>> 1) & 0xf);
3419 case BFD_RELOC_SH_IMM4BY4
:
3422 *buf
= (*buf
& 0xf0) | ((val
>> 2) & 0xf);
3425 case BFD_RELOC_SH_IMM8BY2
:
3431 case BFD_RELOC_SH_IMM8BY4
:
3438 case BFD_RELOC_SH_IMM8
:
3439 /* Sometimes the 8 bit value is sign extended (e.g., add) and
3440 sometimes it is not (e.g., and). We permit any 8 bit value.
3441 Note that adding further restrictions may invalidate
3442 reasonable looking assembly code, such as ``and -0x1,r0''. */
3448 case BFD_RELOC_SH_PCRELIMM8BY4
:
3449 /* The lower two bits of the PC are cleared before the
3450 displacement is added in. We can assume that the destination
3451 is on a 4 byte bounday. If this instruction is also on a 4
3452 byte boundary, then we want
3454 and target - here is a multiple of 4.
3455 Otherwise, we are on a 2 byte boundary, and we want
3456 (target - (here - 2)) / 4
3457 and target - here is not a multiple of 4. Computing
3458 (target - (here - 2)) / 4 == (target - here + 2) / 4
3459 works for both cases, since in the first case the addition of
3460 2 will be removed by the division. target - here is in the
3462 val
= (val
+ 2) / 4;
3464 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3468 case BFD_RELOC_SH_PCRELIMM8BY2
:
3471 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3475 case BFD_RELOC_SH_PCDISP8BY2
:
3477 if (val
< -0x80 || val
> 0x7f)
3478 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3482 case BFD_RELOC_SH_PCDISP12BY2
:
3484 if (val
< -0x800 || val
> 0x7ff)
3485 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3486 buf
[lowbyte
] = val
& 0xff;
3487 buf
[highbyte
] |= (val
>> 8) & 0xf;
3491 case BFD_RELOC_32_PCREL
:
3492 md_number_to_chars (buf
, val
, 4);
3496 md_number_to_chars (buf
, val
, 2);
3499 case BFD_RELOC_SH_USES
:
3500 /* Pass the value into sh_coff_reloc_mangle. */
3501 fixP
->fx_addnumber
= val
;
3504 case BFD_RELOC_SH_COUNT
:
3505 case BFD_RELOC_SH_ALIGN
:
3506 case BFD_RELOC_SH_CODE
:
3507 case BFD_RELOC_SH_DATA
:
3508 case BFD_RELOC_SH_LABEL
:
3509 /* Nothing to do here. */
3512 case BFD_RELOC_SH_LOOP_START
:
3513 case BFD_RELOC_SH_LOOP_END
:
3515 case BFD_RELOC_VTABLE_INHERIT
:
3516 case BFD_RELOC_VTABLE_ENTRY
:
3521 case BFD_RELOC_32_PLT_PCREL
:
3522 /* Make the jump instruction point to the address of the operand. At
3523 runtime we merely add the offset to the actual PLT entry. */
3524 * valP
= 0xfffffffc;
3527 val
-= S_GET_VALUE (fixP
->fx_subsy
);
3528 fixP
->fx_addnumber
= val
;
3529 md_number_to_chars (buf
, val
, 4);
3532 case BFD_RELOC_SH_GOTPC
:
3533 /* This is tough to explain. We end up with this one if we have
3534 operands that look like "_GLOBAL_OFFSET_TABLE_+[.-.L284]".
3535 The goal here is to obtain the absolute address of the GOT,
3536 and it is strongly preferable from a performance point of
3537 view to avoid using a runtime relocation for this. There are
3538 cases where you have something like:
3540 .long _GLOBAL_OFFSET_TABLE_+[.-.L66]
3542 and here no correction would be required. Internally in the
3543 assembler we treat operands of this form as not being pcrel
3544 since the '.' is explicitly mentioned, and I wonder whether
3545 it would simplify matters to do it this way. Who knows. In
3546 earlier versions of the PIC patches, the pcrel_adjust field
3547 was used to store the correction, but since the expression is
3548 not pcrel, I felt it would be confusing to do it this way. */
3550 md_number_to_chars (buf
, val
, 4);
3553 case BFD_RELOC_32_GOT_PCREL
:
3554 case BFD_RELOC_SH_GOTPLT32
:
3555 case BFD_RELOC_SH_TLS_GD_32
:
3556 case BFD_RELOC_SH_TLS_LD_32
:
3557 case BFD_RELOC_SH_TLS_IE_32
:
3558 * valP
= 0; /* Fully resolved at runtime. No addend. */
3559 md_number_to_chars (buf
, 0, 4);
3562 case BFD_RELOC_32_GOTOFF
:
3563 case BFD_RELOC_SH_TLS_LDO_32
:
3564 case BFD_RELOC_SH_TLS_LE_32
:
3565 md_number_to_chars (buf
, val
, 4);
3571 shmedia_md_apply_fix3 (fixP
, valP
);
3580 if ((val
& ((1 << shift
) - 1)) != 0)
3581 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("misaligned offset"));
3585 val
= ((val
>> shift
)
3586 | ((long) -1 & ~ ((long) -1 >> shift
)));
3588 if (max
!= 0 && (val
< min
|| val
> max
))
3589 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("offset out of range"));
3591 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
3595 /* Called just before address relaxation. Return the length
3596 by which a fragment must grow to reach it's destination. */
3599 md_estimate_size_before_relax (fragP
, segment_type
)
3600 register fragS
*fragP
;
3601 register segT segment_type
;
3605 switch (fragP
->fr_subtype
)
3609 return shmedia_md_estimate_size_before_relax (fragP
, segment_type
);
3615 case C (UNCOND_JUMP
, UNDEF_DISP
):
3616 /* Used to be a branch to somewhere which was unknown. */
3617 if (!fragP
->fr_symbol
)
3619 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
3621 else if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
3623 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
3627 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNDEF_WORD_DISP
);
3631 case C (COND_JUMP
, UNDEF_DISP
):
3632 case C (COND_JUMP_DELAY
, UNDEF_DISP
):
3633 what
= GET_WHAT (fragP
->fr_subtype
);
3634 /* Used to be a branch to somewhere which was unknown. */
3635 if (fragP
->fr_symbol
3636 && S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
3638 /* Got a symbol and it's defined in this segment, become byte
3639 sized - maybe it will fix up. */
3640 fragP
->fr_subtype
= C (what
, COND8
);
3642 else if (fragP
->fr_symbol
)
3644 /* Its got a segment, but its not ours, so it will always be long. */
3645 fragP
->fr_subtype
= C (what
, UNDEF_WORD_DISP
);
3649 /* We know the abs value. */
3650 fragP
->fr_subtype
= C (what
, COND8
);
3654 case C (UNCOND_JUMP
, UNCOND12
):
3655 case C (UNCOND_JUMP
, UNCOND32
):
3656 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
3657 case C (COND_JUMP
, COND8
):
3658 case C (COND_JUMP
, COND12
):
3659 case C (COND_JUMP
, COND32
):
3660 case C (COND_JUMP
, UNDEF_WORD_DISP
):
3661 case C (COND_JUMP_DELAY
, COND8
):
3662 case C (COND_JUMP_DELAY
, COND12
):
3663 case C (COND_JUMP_DELAY
, COND32
):
3664 case C (COND_JUMP_DELAY
, UNDEF_WORD_DISP
):
3665 /* When relaxing a section for the second time, we don't need to
3666 do anything besides return the current size. */
3670 fragP
->fr_var
= md_relax_table
[fragP
->fr_subtype
].rlx_length
;
3671 return fragP
->fr_var
;
3674 /* Put number into target byte order. */
3677 md_number_to_chars (ptr
, use
, nbytes
)
3683 /* We might need to set the contents type to data. */
3684 sh64_flag_output ();
3687 if (! target_big_endian
)
3688 number_to_chars_littleendian (ptr
, use
, nbytes
);
3690 number_to_chars_bigendian (ptr
, use
, nbytes
);
3693 /* This version is used in obj-coff.c when not using BFD_ASSEMBLER.
3694 eg for the sh-hms target. */
3697 md_pcrel_from (fixP
)
3700 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
+ 2;
3704 md_pcrel_from_section (fixP
, sec
)
3708 if (! sh_local_pcrel (fixP
)
3709 && fixP
->fx_addsy
!= (symbolS
*) NULL
3710 && (S_FORCE_RELOC (fixP
->fx_addsy
)
3711 || S_GET_SEGMENT (fixP
->fx_addsy
) != sec
))
3713 /* The symbol is undefined (or is defined but not in this section,
3714 or we're not sure about it being the final definition). Let the
3715 linker figure it out. We need to adjust the subtraction of a
3716 symbol to the position of the relocated data, though. */
3717 return fixP
->fx_subsy
? fixP
->fx_where
+ fixP
->fx_frag
->fr_address
: 0;
3720 return md_pcrel_from (fixP
);
3726 tc_coff_sizemachdep (frag
)
3729 return md_relax_table
[frag
->fr_subtype
].rlx_length
;
3732 #endif /* OBJ_COFF */
3734 #ifndef BFD_ASSEMBLER
3737 /* Map BFD relocs to SH COFF relocs. */
3741 bfd_reloc_code_real_type bfd_reloc
;
3745 static const struct reloc_map coff_reloc_map
[] =
3747 { BFD_RELOC_32
, R_SH_IMM32
},
3748 { BFD_RELOC_16
, R_SH_IMM16
},
3749 { BFD_RELOC_8
, R_SH_IMM8
},
3750 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_PCDISP8BY2
},
3751 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_PCDISP
},
3752 { BFD_RELOC_SH_IMM4
, R_SH_IMM4
},
3753 { BFD_RELOC_SH_IMM4BY2
, R_SH_IMM4BY2
},
3754 { BFD_RELOC_SH_IMM4BY4
, R_SH_IMM4BY4
},
3755 { BFD_RELOC_SH_IMM8
, R_SH_IMM8
},
3756 { BFD_RELOC_SH_IMM8BY2
, R_SH_IMM8BY2
},
3757 { BFD_RELOC_SH_IMM8BY4
, R_SH_IMM8BY4
},
3758 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_PCRELIMM8BY2
},
3759 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_PCRELIMM8BY4
},
3760 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
3761 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
3762 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
3763 { BFD_RELOC_SH_USES
, R_SH_USES
},
3764 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
3765 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
3766 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
3767 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
3768 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
3769 { BFD_RELOC_UNUSED
, 0 }
3772 /* Adjust a reloc for the SH. This is similar to the generic code,
3773 but does some minor tweaking. */
3776 sh_coff_reloc_mangle (seg
, fix
, intr
, paddr
)
3777 segment_info_type
*seg
;
3779 struct internal_reloc
*intr
;
3782 symbolS
*symbol_ptr
= fix
->fx_addsy
;
3785 intr
->r_vaddr
= paddr
+ fix
->fx_frag
->fr_address
+ fix
->fx_where
;
3787 if (! SWITCH_TABLE (fix
))
3789 const struct reloc_map
*rm
;
3791 for (rm
= coff_reloc_map
; rm
->bfd_reloc
!= BFD_RELOC_UNUSED
; rm
++)
3792 if (rm
->bfd_reloc
== (bfd_reloc_code_real_type
) fix
->fx_r_type
)
3794 if (rm
->bfd_reloc
== BFD_RELOC_UNUSED
)
3795 as_bad_where (fix
->fx_file
, fix
->fx_line
,
3796 _("Can not represent %s relocation in this object file format"),
3797 bfd_get_reloc_code_name (fix
->fx_r_type
));
3798 intr
->r_type
= rm
->sh_reloc
;
3805 if (fix
->fx_r_type
== BFD_RELOC_16
)
3806 intr
->r_type
= R_SH_SWITCH16
;
3807 else if (fix
->fx_r_type
== BFD_RELOC_8
)
3808 intr
->r_type
= R_SH_SWITCH8
;
3809 else if (fix
->fx_r_type
== BFD_RELOC_32
)
3810 intr
->r_type
= R_SH_SWITCH32
;
3814 /* For a switch reloc, we set r_offset to the difference between
3815 the reloc address and the subtrahend. When the linker is
3816 doing relaxing, it can use the determine the starting and
3817 ending points of the switch difference expression. */
3818 intr
->r_offset
= intr
->r_vaddr
- S_GET_VALUE (fix
->fx_subsy
);
3821 /* PC relative relocs are always against the current section. */
3822 if (symbol_ptr
== NULL
)
3824 switch (fix
->fx_r_type
)
3826 case BFD_RELOC_SH_PCRELIMM8BY2
:
3827 case BFD_RELOC_SH_PCRELIMM8BY4
:
3828 case BFD_RELOC_SH_PCDISP8BY2
:
3829 case BFD_RELOC_SH_PCDISP12BY2
:
3830 case BFD_RELOC_SH_USES
:
3831 symbol_ptr
= seg
->dot
;
3838 if (fix
->fx_r_type
== BFD_RELOC_SH_USES
)
3840 /* We can't store the offset in the object file, since this
3841 reloc does not take up any space, so we store it in r_offset.
3842 The fx_addnumber field was set in md_apply_fix3. */
3843 intr
->r_offset
= fix
->fx_addnumber
;
3845 else if (fix
->fx_r_type
== BFD_RELOC_SH_COUNT
)
3847 /* We can't store the count in the object file, since this reloc
3848 does not take up any space, so we store it in r_offset. The
3849 fx_offset field was set when the fixup was created in
3850 sh_coff_frob_file. */
3851 intr
->r_offset
= fix
->fx_offset
;
3852 /* This reloc is always absolute. */
3855 else if (fix
->fx_r_type
== BFD_RELOC_SH_ALIGN
)
3857 /* Store the alignment in the r_offset field. */
3858 intr
->r_offset
= fix
->fx_offset
;
3859 /* This reloc is always absolute. */
3862 else if (fix
->fx_r_type
== BFD_RELOC_SH_CODE
3863 || fix
->fx_r_type
== BFD_RELOC_SH_DATA
3864 || fix
->fx_r_type
== BFD_RELOC_SH_LABEL
)
3866 /* These relocs are always absolute. */
3870 /* Turn the segment of the symbol into an offset. */
3871 if (symbol_ptr
!= NULL
)
3873 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
3875 intr
->r_symndx
= dot
->sy_number
;
3877 intr
->r_symndx
= symbol_ptr
->sy_number
;
3880 intr
->r_symndx
= -1;
3883 #endif /* OBJ_COFF */
3884 #endif /* ! BFD_ASSEMBLER */
3886 #ifdef BFD_ASSEMBLER
3888 /* Create a reloc. */
3891 tc_gen_reloc (section
, fixp
)
3892 asection
*section ATTRIBUTE_UNUSED
;
3896 bfd_reloc_code_real_type r_type
;
3898 rel
= (arelent
*) xmalloc (sizeof (arelent
));
3899 rel
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
3900 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
3901 rel
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
3903 r_type
= fixp
->fx_r_type
;
3905 if (SWITCH_TABLE (fixp
))
3907 rel
->addend
= rel
->address
- S_GET_VALUE (fixp
->fx_subsy
);
3908 if (r_type
== BFD_RELOC_16
)
3909 r_type
= BFD_RELOC_SH_SWITCH16
;
3910 else if (r_type
== BFD_RELOC_8
)
3911 r_type
= BFD_RELOC_8_PCREL
;
3912 else if (r_type
== BFD_RELOC_32
)
3913 r_type
= BFD_RELOC_SH_SWITCH32
;
3917 else if (r_type
== BFD_RELOC_SH_USES
)
3918 rel
->addend
= fixp
->fx_addnumber
;
3919 else if (r_type
== BFD_RELOC_SH_COUNT
)
3920 rel
->addend
= fixp
->fx_offset
;
3921 else if (r_type
== BFD_RELOC_SH_ALIGN
)
3922 rel
->addend
= fixp
->fx_offset
;
3923 else if (r_type
== BFD_RELOC_VTABLE_INHERIT
3924 || r_type
== BFD_RELOC_VTABLE_ENTRY
)
3925 rel
->addend
= fixp
->fx_offset
;
3926 else if (r_type
== BFD_RELOC_SH_LOOP_START
3927 || r_type
== BFD_RELOC_SH_LOOP_END
)
3928 rel
->addend
= fixp
->fx_offset
;
3929 else if (r_type
== BFD_RELOC_SH_LABEL
&& fixp
->fx_pcrel
)
3932 rel
->address
= rel
->addend
= fixp
->fx_offset
;
3935 else if (shmedia_init_reloc (rel
, fixp
))
3938 else if (fixp
->fx_pcrel
)
3939 rel
->addend
= fixp
->fx_addnumber
;
3940 else if (r_type
== BFD_RELOC_32
|| r_type
== BFD_RELOC_32_GOTOFF
)
3941 rel
->addend
= fixp
->fx_addnumber
;
3945 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, r_type
);
3946 if (rel
->howto
== NULL
)
3948 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
3949 _("Cannot represent relocation type %s"),
3950 bfd_get_reloc_code_name (r_type
));
3951 /* Set howto to a garbage value so that we can keep going. */
3952 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
3953 assert (rel
->howto
!= NULL
);
3960 inline static char *
3961 sh_end_of_match (cont
, what
)
3964 int len
= strlen (what
);
3966 if (strncasecmp (cont
, what
, strlen (what
)) == 0
3967 && ! is_part_of_name (cont
[len
]))
3974 sh_parse_name (name
, exprP
, nextcharP
)
3979 char *next
= input_line_pointer
;
3984 exprP
->X_op_symbol
= NULL
;
3986 if (strcmp (name
, GLOBAL_OFFSET_TABLE_NAME
) == 0)
3989 GOT_symbol
= symbol_find_or_make (name
);
3991 exprP
->X_add_symbol
= GOT_symbol
;
3993 /* If we have an absolute symbol or a reg, then we know its
3995 segment
= S_GET_SEGMENT (exprP
->X_add_symbol
);
3996 if (segment
== absolute_section
)
3998 exprP
->X_op
= O_constant
;
3999 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
4000 exprP
->X_add_symbol
= NULL
;
4002 else if (segment
== reg_section
)
4004 exprP
->X_op
= O_register
;
4005 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
4006 exprP
->X_add_symbol
= NULL
;
4010 exprP
->X_op
= O_symbol
;
4011 exprP
->X_add_number
= 0;
4017 exprP
->X_add_symbol
= symbol_find_or_make (name
);
4019 if (*nextcharP
!= '@')
4021 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTOFF")))
4022 reloc_type
= BFD_RELOC_32_GOTOFF
;
4023 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTPLT")))
4024 reloc_type
= BFD_RELOC_SH_GOTPLT32
;
4025 else if ((next_end
= sh_end_of_match (next
+ 1, "GOT")))
4026 reloc_type
= BFD_RELOC_32_GOT_PCREL
;
4027 else if ((next_end
= sh_end_of_match (next
+ 1, "PLT")))
4028 reloc_type
= BFD_RELOC_32_PLT_PCREL
;
4029 else if ((next_end
= sh_end_of_match (next
+ 1, "TLSGD")))
4030 reloc_type
= BFD_RELOC_SH_TLS_GD_32
;
4031 else if ((next_end
= sh_end_of_match (next
+ 1, "TLSLDM")))
4032 reloc_type
= BFD_RELOC_SH_TLS_LD_32
;
4033 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTTPOFF")))
4034 reloc_type
= BFD_RELOC_SH_TLS_IE_32
;
4035 else if ((next_end
= sh_end_of_match (next
+ 1, "TPOFF")))
4036 reloc_type
= BFD_RELOC_SH_TLS_LE_32
;
4037 else if ((next_end
= sh_end_of_match (next
+ 1, "DTPOFF")))
4038 reloc_type
= BFD_RELOC_SH_TLS_LDO_32
;
4042 *input_line_pointer
= *nextcharP
;
4043 input_line_pointer
= next_end
;
4044 *nextcharP
= *input_line_pointer
;
4045 *input_line_pointer
= '\0';
4047 exprP
->X_op
= O_PIC_reloc
;
4048 exprP
->X_add_number
= 0;
4049 exprP
->X_md
= reloc_type
;
4054 #endif /* BFD_ASSEMBLER */