1 /* tc-sh.c -- Assemble code for the Renesas / SuperH SH
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
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 bfd_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 /* preset architecture set, if given; zero otherwise. */
168 static int preset_target_arch
;
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 const sh_opcode_info
*opcode
;
867 char *prev_name
= "";
871 = preset_target_arch
? preset_target_arch
: arch_sh1_up
& ~arch_sh_dsp_up
;
872 valid_arch
= target_arch
;
878 opcode_hash_control
= hash_new ();
880 /* Insert unique names into hash table. */
881 for (opcode
= sh_table
; opcode
->name
; opcode
++)
883 if (strcmp (prev_name
, opcode
->name
) != 0)
885 if (! (opcode
->arch
& target_arch
))
887 prev_name
= opcode
->name
;
888 hash_insert (opcode_hash_control
, opcode
->name
, (char *) opcode
);
895 static int reg_x
, reg_y
;
899 #define IDENT_CHAR(c) (ISALNUM (c) || (c) == '_')
901 /* Try to parse a reg name. Return the number of chars consumed. */
904 parse_reg (src
, mode
, reg
)
909 char l0
= TOLOWER (src
[0]);
910 char l1
= l0
? TOLOWER (src
[1]) : 0;
912 /* We use ! IDENT_CHAR for the next character after the register name, to
913 make sure that we won't accidentally recognize a symbol name such as
914 'sram' or sr_ram as being a reference to the register 'sr'. */
920 if (src
[2] >= '0' && src
[2] <= '5'
921 && ! IDENT_CHAR ((unsigned char) src
[3]))
924 *reg
= 10 + src
[2] - '0';
928 if (l1
>= '0' && l1
<= '9'
929 && ! IDENT_CHAR ((unsigned char) src
[2]))
935 if (l1
>= '0' && l1
<= '7' && strncasecmp (&src
[2], "_bank", 5) == 0
936 && ! IDENT_CHAR ((unsigned char) src
[7]))
943 if (l1
== 'e' && ! IDENT_CHAR ((unsigned char) src
[2]))
948 if (l1
== 's' && ! IDENT_CHAR ((unsigned char) src
[2]))
959 if (! IDENT_CHAR ((unsigned char) src
[2]))
965 if (TOLOWER (src
[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src
[3]))
974 if (! IDENT_CHAR ((unsigned char) src
[2]))
980 if (TOLOWER (src
[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src
[3]))
988 if (l1
== 'x' && src
[2] >= '0' && src
[2] <= '1'
989 && ! IDENT_CHAR ((unsigned char) src
[3]))
992 *reg
= 4 + (l1
- '0');
995 if (l1
== 'y' && src
[2] >= '0' && src
[2] <= '1'
996 && ! IDENT_CHAR ((unsigned char) src
[3]))
999 *reg
= 6 + (l1
- '0');
1002 if (l1
== 's' && src
[2] >= '0' && src
[2] <= '3'
1003 && ! IDENT_CHAR ((unsigned char) src
[3]))
1008 *reg
= n
| ((~n
& 2) << 1);
1013 if (l0
== 'i' && l1
&& ! IDENT_CHAR ((unsigned char) src
[2]))
1035 if (l0
== 'x' && l1
>= '0' && l1
<= '1'
1036 && ! IDENT_CHAR ((unsigned char) src
[2]))
1039 *reg
= A_X0_NUM
+ l1
- '0';
1043 if (l0
== 'y' && l1
>= '0' && l1
<= '1'
1044 && ! IDENT_CHAR ((unsigned char) src
[2]))
1047 *reg
= A_Y0_NUM
+ l1
- '0';
1051 if (l0
== 'm' && l1
>= '0' && l1
<= '1'
1052 && ! IDENT_CHAR ((unsigned char) src
[2]))
1055 *reg
= l1
== '0' ? A_M0_NUM
: A_M1_NUM
;
1061 && TOLOWER (src
[2]) == 'r' && ! IDENT_CHAR ((unsigned char) src
[3]))
1067 if (l0
== 's' && l1
== 'p' && TOLOWER (src
[2]) == 'c'
1068 && ! IDENT_CHAR ((unsigned char) src
[3]))
1074 if (l0
== 's' && l1
== 'g' && TOLOWER (src
[2]) == 'r'
1075 && ! IDENT_CHAR ((unsigned char) src
[3]))
1081 if (l0
== 'd' && l1
== 's' && TOLOWER (src
[2]) == 'r'
1082 && ! IDENT_CHAR ((unsigned char) src
[3]))
1088 if (l0
== 'd' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1089 && ! IDENT_CHAR ((unsigned char) src
[3]))
1095 if (l0
== 's' && l1
== 'r' && ! IDENT_CHAR ((unsigned char) src
[2]))
1101 if (l0
== 's' && l1
== 'p' && ! IDENT_CHAR ((unsigned char) src
[2]))
1108 if (l0
== 'p' && l1
== 'r' && ! IDENT_CHAR ((unsigned char) src
[2]))
1113 if (l0
== 'p' && l1
== 'c' && ! IDENT_CHAR ((unsigned char) src
[2]))
1115 /* Don't use A_DISP_PC here - that would accept stuff like 'mova pc,r0'
1116 and use an uninitialized immediate. */
1120 if (l0
== 'g' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1121 && ! IDENT_CHAR ((unsigned char) src
[3]))
1126 if (l0
== 'v' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
1127 && ! IDENT_CHAR ((unsigned char) src
[3]))
1133 if (l0
== 'm' && l1
== 'a' && TOLOWER (src
[2]) == 'c'
1134 && ! IDENT_CHAR ((unsigned char) src
[4]))
1136 if (TOLOWER (src
[3]) == 'l')
1141 if (TOLOWER (src
[3]) == 'h')
1147 if (l0
== 'm' && l1
== 'o' && TOLOWER (src
[2]) == 'd'
1148 && ! IDENT_CHAR ((unsigned char) src
[3]))
1153 if (l0
== 'f' && l1
== 'r')
1157 if (src
[3] >= '0' && src
[3] <= '5'
1158 && ! IDENT_CHAR ((unsigned char) src
[4]))
1161 *reg
= 10 + src
[3] - '0';
1165 if (src
[2] >= '0' && src
[2] <= '9'
1166 && ! IDENT_CHAR ((unsigned char) src
[3]))
1169 *reg
= (src
[2] - '0');
1173 if (l0
== 'd' && l1
== 'r')
1177 if (src
[3] >= '0' && src
[3] <= '4' && ! ((src
[3] - '0') & 1)
1178 && ! IDENT_CHAR ((unsigned char) src
[4]))
1181 *reg
= 10 + src
[3] - '0';
1185 if (src
[2] >= '0' && src
[2] <= '8' && ! ((src
[2] - '0') & 1)
1186 && ! IDENT_CHAR ((unsigned char) src
[3]))
1189 *reg
= (src
[2] - '0');
1193 if (l0
== 'x' && l1
== 'd')
1197 if (src
[3] >= '0' && src
[3] <= '4' && ! ((src
[3] - '0') & 1)
1198 && ! IDENT_CHAR ((unsigned char) src
[4]))
1201 *reg
= 11 + src
[3] - '0';
1205 if (src
[2] >= '0' && src
[2] <= '8' && ! ((src
[2] - '0') & 1)
1206 && ! IDENT_CHAR ((unsigned char) src
[3]))
1209 *reg
= (src
[2] - '0') + 1;
1213 if (l0
== 'f' && l1
== 'v')
1215 if (src
[2] == '1'&& src
[3] == '2' && ! IDENT_CHAR ((unsigned char) src
[4]))
1221 if ((src
[2] == '0' || src
[2] == '4' || src
[2] == '8')
1222 && ! IDENT_CHAR ((unsigned char) src
[3]))
1225 *reg
= (src
[2] - '0');
1229 if (l0
== 'f' && l1
== 'p' && TOLOWER (src
[2]) == 'u'
1230 && TOLOWER (src
[3]) == 'l'
1231 && ! IDENT_CHAR ((unsigned char) src
[4]))
1237 if (l0
== 'f' && l1
== 'p' && TOLOWER (src
[2]) == 's'
1238 && TOLOWER (src
[3]) == 'c'
1239 && TOLOWER (src
[4]) == 'r' && ! IDENT_CHAR ((unsigned char) src
[5]))
1245 if (l0
== 'x' && l1
== 'm' && TOLOWER (src
[2]) == 't'
1246 && TOLOWER (src
[3]) == 'r'
1247 && TOLOWER (src
[4]) == 'x' && ! IDENT_CHAR ((unsigned char) src
[5]))
1259 sh_operand_info
*op
;
1264 save
= input_line_pointer
;
1265 input_line_pointer
= s
;
1266 expression (&op
->immediate
);
1267 if (op
->immediate
.X_op
== O_absent
)
1268 as_bad (_("missing operand"));
1270 else if (op
->immediate
.X_op
== O_PIC_reloc
1271 || sh_PIC_related_p (op
->immediate
.X_add_symbol
)
1272 || sh_PIC_related_p (op
->immediate
.X_op_symbol
))
1273 as_bad (_("misplaced PIC operand"));
1275 new = input_line_pointer
;
1276 input_line_pointer
= save
;
1280 /* The many forms of operand:
1283 @Rn Register indirect
1296 pr, gbr, vbr, macl, mach
1302 sh_operand_info
*op
;
1309 /* Must be predecrement. */
1312 len
= parse_reg (src
, &mode
, &(op
->reg
));
1313 if (mode
!= A_REG_N
)
1314 as_bad (_("illegal register after @-"));
1319 else if (src
[0] == '(')
1321 /* Could be @(disp, rn), @(disp, gbr), @(disp, pc), @(r0, gbr) or
1324 len
= parse_reg (src
, &mode
, &(op
->reg
));
1325 if (len
&& mode
== A_REG_N
)
1330 as_bad (_("must be @(r0,...)"));
1335 /* Now can be rn or gbr. */
1336 len
= parse_reg (src
, &mode
, &(op
->reg
));
1346 op
->type
= A_R0_GBR
;
1348 else if (mode
== A_REG_N
)
1350 op
->type
= A_IND_R0_REG_N
;
1354 as_bad (_("syntax error in @(r0,...)"));
1359 as_bad (_("syntax error in @(r0...)"));
1364 /* Must be an @(disp,.. thing). */
1365 src
= parse_exp (src
, op
);
1368 /* Now can be rn, gbr or pc. */
1369 len
= parse_reg (src
, &mode
, &op
->reg
);
1372 if (mode
== A_REG_N
)
1374 op
->type
= A_DISP_REG_N
;
1376 else if (mode
== A_GBR
)
1378 op
->type
= A_DISP_GBR
;
1380 else if (mode
== A_PC
)
1382 /* We want @(expr, pc) to uniformly address . + expr,
1383 no matter if expr is a constant, or a more complex
1384 expression, e.g. sym-. or sym1-sym2.
1385 However, we also used to accept @(sym,pc)
1386 as adressing sym, i.e. meaning the same as plain sym.
1387 Some existing code does use the @(sym,pc) syntax, so
1388 we give it the old semantics for now, but warn about
1389 its use, so that users have some time to fix their code.
1391 Note that due to this backward compatibility hack,
1392 we'll get unexpected results when @(offset, pc) is used,
1393 and offset is a symbol that is set later to an an address
1394 difference, or an external symbol that is set to an
1395 address difference in another source file, so we want to
1396 eventually remove it. */
1397 if (op
->immediate
.X_op
== O_symbol
)
1399 op
->type
= A_DISP_PC
;
1400 as_warn (_("Deprecated syntax."));
1404 op
->type
= A_DISP_PC_ABS
;
1405 /* Such operands don't get corrected for PC==.+4, so
1406 make the correction here. */
1407 op
->immediate
.X_add_number
-= 4;
1412 as_bad (_("syntax error in @(disp,[Rn, gbr, pc])"));
1417 as_bad (_("syntax error in @(disp,[Rn, gbr, pc])"));
1422 as_bad (_("expecting )"));
1428 src
+= parse_reg (src
, &mode
, &(op
->reg
));
1429 if (mode
!= A_REG_N
)
1430 as_bad (_("illegal register after @"));
1437 l0
= TOLOWER (src
[0]);
1438 l1
= TOLOWER (src
[1]);
1440 if ((l0
== 'r' && l1
== '8')
1441 || (l0
== 'i' && (l1
== 'x' || l1
== 's')))
1444 op
->type
= A_PMOD_N
;
1446 else if ( (l0
== 'r' && l1
== '9')
1447 || (l0
== 'i' && l1
== 'y'))
1450 op
->type
= A_PMODY_N
;
1462 get_operand (ptr
, op
)
1464 sh_operand_info
*op
;
1473 *ptr
= parse_exp (src
, op
);
1478 else if (src
[0] == '@')
1480 *ptr
= parse_at (src
, op
);
1483 len
= parse_reg (src
, &mode
, &(op
->reg
));
1492 /* Not a reg, the only thing left is a displacement. */
1493 *ptr
= parse_exp (src
, op
);
1494 op
->type
= A_DISP_PC
;
1500 get_operands (info
, args
, operand
)
1501 sh_opcode_info
*info
;
1503 sh_operand_info
*operand
;
1508 /* The pre-processor will eliminate whitespace in front of '@'
1509 after the first argument; we may be called multiple times
1510 from assemble_ppi, so don't insist on finding whitespace here. */
1514 get_operand (&ptr
, operand
+ 0);
1521 get_operand (&ptr
, operand
+ 1);
1522 /* ??? Hack: psha/pshl have a varying operand number depending on
1523 the type of the first operand. We handle this by having the
1524 three-operand version first and reducing the number of operands
1525 parsed to two if we see that the first operand is an immediate.
1526 This works because no insn with three operands has an immediate
1527 as first operand. */
1528 if (info
->arg
[2] && operand
[0].type
!= A_IMM
)
1534 get_operand (&ptr
, operand
+ 2);
1538 operand
[2].type
= 0;
1543 operand
[1].type
= 0;
1544 operand
[2].type
= 0;
1549 operand
[0].type
= 0;
1550 operand
[1].type
= 0;
1551 operand
[2].type
= 0;
1556 /* Passed a pointer to a list of opcodes which use different
1557 addressing modes, return the opcode which matches the opcodes
1560 static sh_opcode_info
*
1561 get_specific (opcode
, operands
)
1562 sh_opcode_info
*opcode
;
1563 sh_operand_info
*operands
;
1565 sh_opcode_info
*this_try
= opcode
;
1566 char *name
= opcode
->name
;
1569 while (opcode
->name
)
1571 this_try
= opcode
++;
1572 if ((this_try
->name
!= name
) && (strcmp (this_try
->name
, name
) != 0))
1574 /* We've looked so far down the table that we've run out of
1575 opcodes with the same name. */
1579 /* Look at both operands needed by the opcodes and provided by
1580 the user - since an arg test will often fail on the same arg
1581 again and again, we'll try and test the last failing arg the
1582 first on each opcode try. */
1583 for (n
= 0; this_try
->arg
[n
]; n
++)
1585 sh_operand_info
*user
= operands
+ n
;
1586 sh_arg_type arg
= this_try
->arg
[n
];
1591 if (user
->type
== A_DISP_PC_ABS
)
1601 if (user
->type
!= arg
)
1605 /* opcode needs r0 */
1606 if (user
->type
!= A_REG_N
|| user
->reg
!= 0)
1610 if (user
->type
!= A_R0_GBR
|| user
->reg
!= 0)
1614 if (user
->type
!= F_REG_N
|| user
->reg
!= 0)
1622 case A_IND_R0_REG_N
:
1633 /* Opcode needs rn */
1634 if (user
->type
!= arg
)
1639 if (user
->type
!= D_REG_N
&& user
->type
!= X_REG_N
)
1654 if (user
->type
!= arg
)
1659 if (user
->type
!= arg
)
1668 case A_IND_R0_REG_M
:
1671 /* Opcode needs rn */
1672 if (user
->type
!= arg
- A_REG_M
+ A_REG_N
)
1678 if (user
->type
!= DSP_REG_N
)
1700 if (user
->type
!= DSP_REG_N
)
1722 if (user
->type
!= DSP_REG_N
)
1744 if (user
->type
!= DSP_REG_N
)
1766 if (user
->type
!= DSP_REG_N
)
1788 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_A0_NUM
)
1792 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_X0_NUM
)
1796 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_X1_NUM
)
1800 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_Y0_NUM
)
1804 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_Y1_NUM
)
1814 /* Opcode needs rn */
1815 if (user
->type
!= arg
- F_REG_M
+ F_REG_N
)
1820 if (user
->type
!= D_REG_N
&& user
->type
!= X_REG_N
)
1825 if (user
->type
!= XMTRX_M4
)
1831 printf (_("unhandled %d\n"), arg
);
1835 if ( !(valid_arch
& this_try
->arch
))
1837 valid_arch
&= this_try
->arch
;
1847 insert (where
, how
, pcrel
, op
)
1851 sh_operand_info
*op
;
1853 fix_new_exp (frag_now
,
1854 where
- frag_now
->fr_literal
,
1862 build_relax (opcode
, op
)
1863 sh_opcode_info
*opcode
;
1864 sh_operand_info
*op
;
1866 int high_byte
= target_big_endian
? 0 : 1;
1869 if (opcode
->arg
[0] == A_BDISP8
)
1871 int what
= (opcode
->nibbles
[1] & 4) ? COND_JUMP_DELAY
: COND_JUMP
;
1872 p
= frag_var (rs_machine_dependent
,
1873 md_relax_table
[C (what
, COND32
)].rlx_length
,
1874 md_relax_table
[C (what
, COND8
)].rlx_length
,
1876 op
->immediate
.X_add_symbol
,
1877 op
->immediate
.X_add_number
,
1879 p
[high_byte
] = (opcode
->nibbles
[0] << 4) | (opcode
->nibbles
[1]);
1881 else if (opcode
->arg
[0] == A_BDISP12
)
1883 p
= frag_var (rs_machine_dependent
,
1884 md_relax_table
[C (UNCOND_JUMP
, UNCOND32
)].rlx_length
,
1885 md_relax_table
[C (UNCOND_JUMP
, UNCOND12
)].rlx_length
,
1887 op
->immediate
.X_add_symbol
,
1888 op
->immediate
.X_add_number
,
1890 p
[high_byte
] = (opcode
->nibbles
[0] << 4);
1895 /* Insert ldrs & ldre with fancy relocations that relaxation can recognize. */
1898 insert_loop_bounds (output
, operand
)
1900 sh_operand_info
*operand
;
1905 /* Since the low byte of the opcode will be overwritten by the reloc, we
1906 can just stash the high byte into both bytes and ignore endianness. */
1909 insert (output
, BFD_RELOC_SH_LOOP_START
, 1, operand
);
1910 insert (output
, BFD_RELOC_SH_LOOP_END
, 1, operand
+ 1);
1914 static int count
= 0;
1916 /* If the last loop insn is a two-byte-insn, it is in danger of being
1917 swapped with the insn after it. To prevent this, create a new
1918 symbol - complete with SH_LABEL reloc - after the last loop insn.
1919 If the last loop insn is four bytes long, the symbol will be
1920 right in the middle, but four byte insns are not swapped anyways. */
1921 /* A REPEAT takes 6 bytes. The SH has a 32 bit address space.
1922 Hence a 9 digit number should be enough to count all REPEATs. */
1924 sprintf (name
, "_R%x", count
++ & 0x3fffffff);
1925 end_sym
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
1926 /* Make this a local symbol. */
1928 SF_SET_LOCAL (end_sym
);
1929 #endif /* OBJ_COFF */
1930 symbol_table_insert (end_sym
);
1931 end_sym
->sy_value
= operand
[1].immediate
;
1932 end_sym
->sy_value
.X_add_number
+= 2;
1933 fix_new (frag_now
, frag_now_fix (), 2, end_sym
, 0, 1, BFD_RELOC_SH_LABEL
);
1936 output
= frag_more (2);
1939 insert (output
, BFD_RELOC_SH_LOOP_START
, 1, operand
);
1940 insert (output
, BFD_RELOC_SH_LOOP_END
, 1, operand
+ 1);
1942 return frag_more (2);
1945 /* Now we know what sort of opcodes it is, let's build the bytes. */
1948 build_Mytes (opcode
, operand
)
1949 sh_opcode_info
*opcode
;
1950 sh_operand_info
*operand
;
1954 char *output
= frag_more (2);
1955 unsigned int size
= 2;
1956 int low_byte
= target_big_endian
? 1 : 0;
1962 for (index
= 0; index
< 4; index
++)
1964 sh_nibble_type i
= opcode
->nibbles
[index
];
1974 nbuf
[index
] = reg_n
;
1977 nbuf
[index
] = reg_m
;
1980 if (reg_n
< 2 || reg_n
> 5)
1981 as_bad (_("Invalid register: 'r%d'"), reg_n
);
1982 nbuf
[index
] = (reg_n
& 3) | 4;
1985 nbuf
[index
] = reg_n
| (reg_m
>> 2);
1988 nbuf
[index
] = reg_b
| 0x08;
1991 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY4
, 0, operand
);
1994 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY2
, 0, operand
);
1997 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4
, 0, operand
);
2000 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY4
, 0, operand
+ 1);
2003 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY2
, 0, operand
+ 1);
2006 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4
, 0, operand
+ 1);
2009 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY4
, 0, operand
);
2012 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY2
, 0, operand
);
2015 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8
, 0, operand
);
2018 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY4
, 0, operand
+ 1);
2021 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY2
, 0, operand
+ 1);
2024 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8
, 0, operand
+ 1);
2027 insert (output
, BFD_RELOC_SH_PCRELIMM8BY4
,
2028 operand
->type
!= A_DISP_PC_ABS
, operand
);
2031 insert (output
, BFD_RELOC_SH_PCRELIMM8BY2
,
2032 operand
->type
!= A_DISP_PC_ABS
, operand
);
2035 output
= insert_loop_bounds (output
, operand
);
2036 nbuf
[index
] = opcode
->nibbles
[3];
2040 printf (_("failed for %d\n"), i
);
2044 if (!target_big_endian
)
2046 output
[1] = (nbuf
[0] << 4) | (nbuf
[1]);
2047 output
[0] = (nbuf
[2] << 4) | (nbuf
[3]);
2051 output
[0] = (nbuf
[0] << 4) | (nbuf
[1]);
2052 output
[1] = (nbuf
[2] << 4) | (nbuf
[3]);
2057 /* Find an opcode at the start of *STR_P in the hash table, and set
2058 *STR_P to the first character after the last one read. */
2060 static sh_opcode_info
*
2061 find_cooked_opcode (str_p
)
2065 unsigned char *op_start
;
2066 unsigned char *op_end
;
2070 /* Drop leading whitespace. */
2074 /* Find the op code end.
2075 The pre-processor will eliminate whitespace in front of
2076 any '@' after the first argument; we may be called from
2077 assemble_ppi, so the opcode might be terminated by an '@'. */
2078 for (op_start
= op_end
= (unsigned char *) (str
);
2081 && !is_end_of_line
[*op_end
] && *op_end
!= ' ' && *op_end
!= '@';
2084 unsigned char c
= op_start
[nlen
];
2086 /* The machine independent code will convert CMP/EQ into cmp/EQ
2087 because it thinks the '/' is the end of the symbol. Moreover,
2088 all but the first sub-insn is a parallel processing insn won't
2089 be capitalized. Instead of hacking up the machine independent
2090 code, we just deal with it here. */
2100 as_bad (_("can't find opcode "));
2102 return (sh_opcode_info
*) hash_find (opcode_hash_control
, name
);
2105 /* Assemble a parallel processing insn. */
2106 #define DDT_BASE 0xf000 /* Base value for double data transfer insns */
2109 assemble_ppi (op_end
, opcode
)
2111 sh_opcode_info
*opcode
;
2123 sh_operand_info operand
[3];
2125 /* Some insn ignore one or more register fields, e.g. psts machl,a0.
2126 Make sure we encode a defined insn pattern. */
2131 if (opcode
->arg
[0] != A_END
)
2132 op_end
= get_operands (opcode
, op_end
, operand
);
2133 opcode
= get_specific (opcode
, operand
);
2136 /* Couldn't find an opcode which matched the operands. */
2137 char *where
= frag_more (2);
2142 as_bad (_("invalid operands for opcode"));
2146 if (opcode
->nibbles
[0] != PPI
)
2147 as_bad (_("insn can't be combined with parallel processing insn"));
2149 switch (opcode
->nibbles
[1])
2154 as_bad (_("multiple movx specifications"));
2159 as_bad (_("multiple movy specifications"));
2165 as_bad (_("multiple movx specifications"));
2166 if (reg_n
< 4 || reg_n
> 5)
2167 as_bad (_("invalid movx address register"));
2168 if (opcode
->nibbles
[2] & 8)
2170 if (reg_m
== A_A1_NUM
)
2172 else if (reg_m
!= A_A0_NUM
)
2173 as_bad (_("invalid movx dsp register"));
2178 as_bad (_("invalid movx dsp register"));
2181 movx
+= ((reg_n
- 4) << 9) + (opcode
->nibbles
[2] << 2) + DDT_BASE
;
2186 as_bad (_("multiple movy specifications"));
2187 if (opcode
->nibbles
[2] & 8)
2189 /* Bit 3 in nibbles[2] is intended for bit 4 of the opcode,
2192 if (reg_m
== A_A1_NUM
)
2194 else if (reg_m
!= A_A0_NUM
)
2195 as_bad (_("invalid movy dsp register"));
2200 as_bad (_("invalid movy dsp register"));
2203 if (reg_n
< 6 || reg_n
> 7)
2204 as_bad (_("invalid movy address register"));
2205 movy
+= ((reg_n
- 6) << 8) + opcode
->nibbles
[2] + DDT_BASE
;
2209 if (operand
[0].immediate
.X_op
!= O_constant
)
2210 as_bad (_("dsp immediate shift value not constant"));
2211 field_b
= ((opcode
->nibbles
[2] << 12)
2212 | (operand
[0].immediate
.X_add_number
& 127) << 4
2217 as_bad (_("multiple parallel processing specifications"));
2218 field_b
= ((opcode
->nibbles
[2] << 12) + (opcode
->nibbles
[3] << 8)
2219 + (reg_x
<< 6) + (reg_y
<< 4) + reg_n
);
2223 as_bad (_("multiple condition specifications"));
2224 cond
= opcode
->nibbles
[2] << 8;
2226 goto skip_cond_check
;
2230 as_bad (_("multiple parallel processing specifications"));
2231 field_b
= ((opcode
->nibbles
[2] << 12) + (opcode
->nibbles
[3] << 8)
2232 + cond
+ (reg_x
<< 6) + (reg_y
<< 4) + reg_n
);
2238 if ((field_b
& 0xef00) != 0xa100)
2239 as_bad (_("insn cannot be combined with pmuls"));
2241 switch (field_b
& 0xf)
2244 field_b
+= 0 - A_X0_NUM
;
2247 field_b
+= 1 - A_Y0_NUM
;
2250 field_b
+= 2 - A_A0_NUM
;
2253 field_b
+= 3 - A_A1_NUM
;
2256 as_bad (_("bad padd / psub pmuls output operand"));
2258 /* Generate warning if the destination register for padd / psub
2259 and pmuls is the same ( only for A0 or A1 ).
2260 If the last nibble is 1010 then A0 is used in both
2261 padd / psub and pmuls. If it is 1111 then A1 is used
2262 as destination register in both padd / psub and pmuls. */
2264 if ((((field_b
| reg_efg
) & 0x000F) == 0x000A)
2265 || (((field_b
| reg_efg
) & 0x000F) == 0x000F))
2266 as_warn (_("destination register is same for parallel insns"));
2268 field_b
+= 0x4000 + reg_efg
;
2275 as_bad (_("condition not followed by conditionalizable insn"));
2281 opcode
= find_cooked_opcode (&op_end
);
2285 (_("unrecognized characters at end of parallel processing insn")));
2290 move_code
= movx
| movy
;
2293 /* Parallel processing insn. */
2294 unsigned long ppi_code
= (movx
| movy
| 0xf800) << 16 | field_b
;
2296 output
= frag_more (4);
2298 if (! target_big_endian
)
2300 output
[3] = ppi_code
>> 8;
2301 output
[2] = ppi_code
;
2305 output
[2] = ppi_code
>> 8;
2306 output
[3] = ppi_code
;
2308 move_code
|= 0xf800;
2312 /* Just a double data transfer. */
2313 output
= frag_more (2);
2316 if (! target_big_endian
)
2318 output
[1] = move_code
>> 8;
2319 output
[0] = move_code
;
2323 output
[0] = move_code
>> 8;
2324 output
[1] = move_code
;
2329 /* This is the guts of the machine-dependent assembler. STR points to a
2330 machine dependent instruction. This function is supposed to emit
2331 the frags/bytes it assembles to. */
2337 unsigned char *op_end
;
2338 sh_operand_info operand
[3];
2339 sh_opcode_info
*opcode
;
2340 unsigned int size
= 0;
2343 if (sh64_isa_mode
== sh64_isa_shmedia
)
2345 shmedia_md_assemble (str
);
2350 /* If we've seen pseudo-directives, make sure any emitted data or
2351 frags are marked as data. */
2354 sh64_update_contents_mark (TRUE
);
2355 sh64_set_contents_type (CRT_SH5_ISA16
);
2360 #endif /* HAVE_SH64 */
2362 opcode
= find_cooked_opcode (&str
);
2367 as_bad (_("unknown opcode"));
2372 && ! seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2374 /* Output a CODE reloc to tell the linker that the following
2375 bytes are instructions, not data. */
2376 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0,
2378 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 1;
2381 if (opcode
->nibbles
[0] == PPI
)
2383 size
= assemble_ppi (op_end
, opcode
);
2387 if (opcode
->arg
[0] == A_BDISP12
2388 || opcode
->arg
[0] == A_BDISP8
)
2390 parse_exp (op_end
+ 1, &operand
[0]);
2391 build_relax (opcode
, &operand
[0]);
2395 if (opcode
->arg
[0] == A_END
)
2397 /* Ignore trailing whitespace. If there is any, it has already
2398 been compressed to a single space. */
2404 op_end
= get_operands (opcode
, op_end
, operand
);
2406 opcode
= get_specific (opcode
, operand
);
2410 /* Couldn't find an opcode which matched the operands. */
2411 char *where
= frag_more (2);
2416 as_bad (_("invalid operands for opcode"));
2421 as_bad (_("excess operands: '%s'"), op_end
);
2423 size
= build_Mytes (opcode
, operand
);
2428 #ifdef BFD_ASSEMBLER
2429 dwarf2_emit_insn (size
);
2433 /* This routine is called each time a label definition is seen. It
2434 emits a BFD_RELOC_SH_LABEL reloc if necessary. */
2439 static fragS
*last_label_frag
;
2440 static int last_label_offset
;
2443 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2447 offset
= frag_now_fix ();
2448 if (frag_now
!= last_label_frag
2449 || offset
!= last_label_offset
)
2451 fix_new (frag_now
, offset
, 2, &abs_symbol
, 0, 0, BFD_RELOC_SH_LABEL
);
2452 last_label_frag
= frag_now
;
2453 last_label_offset
= offset
;
2458 /* This routine is called when the assembler is about to output some
2459 data. It emits a BFD_RELOC_SH_DATA reloc if necessary. */
2462 sh_flush_pending_output ()
2465 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2467 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0,
2469 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 0;
2474 md_undefined_symbol (name
)
2475 char *name ATTRIBUTE_UNUSED
;
2481 #ifndef BFD_ASSEMBLER
2484 tc_crawl_symbol_chain (headers
)
2485 object_headers
*headers ATTRIBUTE_UNUSED
;
2487 printf (_("call to tc_crawl_symbol_chain \n"));
2491 tc_headers_hook (headers
)
2492 object_headers
*headers ATTRIBUTE_UNUSED
;
2494 printf (_("call to tc_headers_hook \n"));
2500 /* Various routines to kill one day. */
2501 /* Equal to MAX_PRECISION in atof-ieee.c. */
2502 #define MAX_LITTLENUMS 6
2504 /* Turn a string in input_line_pointer into a floating point constant
2505 of type TYPE, and store the appropriate bytes in *LITP. The number
2506 of LITTLENUMS emitted is stored in *SIZEP . An error message is
2507 returned, or NULL on OK. */
2510 md_atof (type
, litP
, sizeP
)
2516 LITTLENUM_TYPE words
[4];
2532 return _("bad call to md_atof");
2535 t
= atof_ieee (input_line_pointer
, type
, words
);
2537 input_line_pointer
= t
;
2541 if (! target_big_endian
)
2543 for (i
= prec
- 1; i
>= 0; i
--)
2545 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
2551 for (i
= 0; i
< prec
; i
++)
2553 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
2561 /* Handle the .uses pseudo-op. This pseudo-op is used just before a
2562 call instruction. It refers to a label of the instruction which
2563 loads the register which the call uses. We use it to generate a
2564 special reloc for the linker. */
2568 int ignore ATTRIBUTE_UNUSED
;
2573 as_warn (_(".uses pseudo-op seen when not relaxing"));
2577 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
2579 as_bad (_("bad .uses format"));
2580 ignore_rest_of_line ();
2584 fix_new_exp (frag_now
, frag_now_fix (), 2, &ex
, 1, BFD_RELOC_SH_USES
);
2586 demand_empty_rest_of_line ();
2589 const char *md_shortopts
= "";
2590 struct option md_longopts
[] =
2592 #define OPTION_RELAX (OPTION_MD_BASE)
2593 #define OPTION_BIG (OPTION_MD_BASE + 1)
2594 #define OPTION_LITTLE (OPTION_BIG + 1)
2595 #define OPTION_SMALL (OPTION_LITTLE + 1)
2596 #define OPTION_DSP (OPTION_SMALL + 1)
2597 #define OPTION_ISA (OPTION_DSP + 1)
2599 {"relax", no_argument
, NULL
, OPTION_RELAX
},
2600 {"big", no_argument
, NULL
, OPTION_BIG
},
2601 {"little", no_argument
, NULL
, OPTION_LITTLE
},
2602 {"small", no_argument
, NULL
, OPTION_SMALL
},
2603 {"dsp", no_argument
, NULL
, OPTION_DSP
},
2604 {"isa", required_argument
, NULL
, OPTION_ISA
},
2606 #define OPTION_ABI (OPTION_ISA + 1)
2607 #define OPTION_NO_MIX (OPTION_ABI + 1)
2608 #define OPTION_SHCOMPACT_CONST_CRANGE (OPTION_NO_MIX + 1)
2609 #define OPTION_NO_EXPAND (OPTION_SHCOMPACT_CONST_CRANGE + 1)
2610 #define OPTION_PT32 (OPTION_NO_EXPAND + 1)
2611 {"abi", required_argument
, NULL
, OPTION_ABI
},
2612 {"no-mix", no_argument
, NULL
, OPTION_NO_MIX
},
2613 {"shcompact-const-crange", no_argument
, NULL
, OPTION_SHCOMPACT_CONST_CRANGE
},
2614 {"no-expand", no_argument
, NULL
, OPTION_NO_EXPAND
},
2615 {"expand-pt32", no_argument
, NULL
, OPTION_PT32
},
2616 #endif /* HAVE_SH64 */
2618 {NULL
, no_argument
, NULL
, 0}
2620 size_t md_longopts_size
= sizeof (md_longopts
);
2623 md_parse_option (c
, arg
)
2625 char *arg ATTRIBUTE_UNUSED
;
2634 target_big_endian
= 1;
2638 target_big_endian
= 0;
2646 preset_target_arch
= arch_sh1_up
& ~arch_sh3e_up
;
2650 if (strcasecmp (arg
, "sh4") == 0)
2651 preset_target_arch
= arch_sh4
;
2652 else if (strcasecmp (arg
, "any") == 0)
2653 preset_target_arch
= arch_sh1_up
;
2655 else if (strcasecmp (arg
, "shmedia") == 0)
2657 if (sh64_isa_mode
== sh64_isa_shcompact
)
2658 as_bad (_("Invalid combination: --isa=SHcompact with --isa=SHmedia"));
2659 sh64_isa_mode
= sh64_isa_shmedia
;
2661 else if (strcasecmp (arg
, "shcompact") == 0)
2663 if (sh64_isa_mode
== sh64_isa_shmedia
)
2664 as_bad (_("Invalid combination: --isa=SHmedia with --isa=SHcompact"));
2665 if (sh64_abi
== sh64_abi_64
)
2666 as_bad (_("Invalid combination: --abi=64 with --isa=SHcompact"));
2667 sh64_isa_mode
= sh64_isa_shcompact
;
2669 #endif /* HAVE_SH64 */
2671 as_bad ("Invalid argument to --isa option: %s", arg
);
2676 if (strcmp (arg
, "32") == 0)
2678 if (sh64_abi
== sh64_abi_64
)
2679 as_bad (_("Invalid combination: --abi=32 with --abi=64"));
2680 sh64_abi
= sh64_abi_32
;
2682 else if (strcmp (arg
, "64") == 0)
2684 if (sh64_abi
== sh64_abi_32
)
2685 as_bad (_("Invalid combination: --abi=64 with --abi=32"));
2686 if (sh64_isa_mode
== sh64_isa_shcompact
)
2687 as_bad (_("Invalid combination: --isa=SHcompact with --abi=64"));
2688 sh64_abi
= sh64_abi_64
;
2691 as_bad ("Invalid argument to --abi option: %s", arg
);
2698 case OPTION_SHCOMPACT_CONST_CRANGE
:
2699 sh64_shcompact_const_crange
= TRUE
;
2702 case OPTION_NO_EXPAND
:
2703 sh64_expand
= FALSE
;
2709 #endif /* HAVE_SH64 */
2719 md_show_usage (stream
)
2722 fprintf (stream
, _("\
2724 -little generate little endian code\n\
2725 -big generate big endian code\n\
2726 -relax alter jump instructions for long displacements\n\
2727 -small align sections to 4 byte boundaries, not 16\n\
2728 -dsp enable sh-dsp insns, and disable sh2e/sh3e/sh4 insns.\n"));
2730 fprintf (stream
, _("\
2731 -isa=[shmedia set default instruction set for SH64\n\
2735 -abi=[32|64] set size of expanded SHmedia operands and object\n\
2737 -shcompact-const-crange emit code-range descriptors for constants in\n\
2738 SHcompact code sections\n\
2739 -no-mix disallow SHmedia code in the same section as\n\
2740 constants and SHcompact code\n\
2741 -no-expand do not expand MOVI, PT, PTA or PTB instructions\n\
2742 -expand-pt32 with -abi=64, expand PT, PTA and PTB instructions\n\
2744 #endif /* HAVE_SH64 */
2747 /* This struct is used to pass arguments to sh_count_relocs through
2748 bfd_map_over_sections. */
2750 struct sh_count_relocs
2752 /* Symbol we are looking for. */
2754 /* Count of relocs found. */
2758 /* Count the number of fixups in a section which refer to a particular
2759 symbol. When using BFD_ASSEMBLER, this is called via
2760 bfd_map_over_sections. */
2763 sh_count_relocs (abfd
, sec
, data
)
2764 bfd
*abfd ATTRIBUTE_UNUSED
;
2768 struct sh_count_relocs
*info
= (struct sh_count_relocs
*) data
;
2769 segment_info_type
*seginfo
;
2773 seginfo
= seg_info (sec
);
2774 if (seginfo
== NULL
)
2778 for (fix
= seginfo
->fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
2780 if (fix
->fx_addsy
== sym
)
2788 /* Handle the count relocs for a particular section. When using
2789 BFD_ASSEMBLER, this is called via bfd_map_over_sections. */
2792 sh_frob_section (abfd
, sec
, ignore
)
2793 bfd
*abfd ATTRIBUTE_UNUSED
;
2795 PTR ignore ATTRIBUTE_UNUSED
;
2797 segment_info_type
*seginfo
;
2800 seginfo
= seg_info (sec
);
2801 if (seginfo
== NULL
)
2804 for (fix
= seginfo
->fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
2809 struct sh_count_relocs info
;
2811 if (fix
->fx_r_type
!= BFD_RELOC_SH_USES
)
2814 /* The BFD_RELOC_SH_USES reloc should refer to a defined local
2815 symbol in the same section. */
2816 sym
= fix
->fx_addsy
;
2818 || fix
->fx_subsy
!= NULL
2819 || fix
->fx_addnumber
!= 0
2820 || S_GET_SEGMENT (sym
) != sec
2821 #if ! defined (BFD_ASSEMBLER) && defined (OBJ_COFF)
2822 || S_GET_STORAGE_CLASS (sym
) == C_EXT
2824 || S_IS_EXTERNAL (sym
))
2826 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2827 _(".uses does not refer to a local symbol in the same section"));
2831 /* Look through the fixups again, this time looking for one
2832 at the same location as sym. */
2833 val
= S_GET_VALUE (sym
);
2834 for (fscan
= seginfo
->fix_root
;
2836 fscan
= fscan
->fx_next
)
2837 if (val
== fscan
->fx_frag
->fr_address
+ fscan
->fx_where
2838 && fscan
->fx_r_type
!= BFD_RELOC_SH_ALIGN
2839 && fscan
->fx_r_type
!= BFD_RELOC_SH_CODE
2840 && fscan
->fx_r_type
!= BFD_RELOC_SH_DATA
2841 && fscan
->fx_r_type
!= BFD_RELOC_SH_LABEL
)
2845 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2846 _("can't find fixup pointed to by .uses"));
2850 if (fscan
->fx_tcbit
)
2852 /* We've already done this one. */
2856 /* The variable fscan should also be a fixup to a local symbol
2857 in the same section. */
2858 sym
= fscan
->fx_addsy
;
2860 || fscan
->fx_subsy
!= NULL
2861 || fscan
->fx_addnumber
!= 0
2862 || S_GET_SEGMENT (sym
) != sec
2863 #if ! defined (BFD_ASSEMBLER) && defined (OBJ_COFF)
2864 || S_GET_STORAGE_CLASS (sym
) == C_EXT
2866 || S_IS_EXTERNAL (sym
))
2868 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2869 _(".uses target does not refer to a local symbol in the same section"));
2873 /* Now we look through all the fixups of all the sections,
2874 counting the number of times we find a reference to sym. */
2877 #ifdef BFD_ASSEMBLER
2878 bfd_map_over_sections (stdoutput
, sh_count_relocs
, (PTR
) &info
);
2883 for (iscan
= SEG_E0
; iscan
< SEG_UNKNOWN
; iscan
++)
2884 sh_count_relocs ((bfd
*) NULL
, iscan
, (PTR
) &info
);
2891 /* Generate a BFD_RELOC_SH_COUNT fixup at the location of sym.
2892 We have already adjusted the value of sym to include the
2893 fragment address, so we undo that adjustment here. */
2894 subseg_change (sec
, 0);
2895 fix_new (fscan
->fx_frag
,
2896 S_GET_VALUE (sym
) - fscan
->fx_frag
->fr_address
,
2897 4, &abs_symbol
, info
.count
, 0, BFD_RELOC_SH_COUNT
);
2901 /* This function is called after the symbol table has been completed,
2902 but before the relocs or section contents have been written out.
2903 If we have seen any .uses pseudo-ops, they point to an instruction
2904 which loads a register with the address of a function. We look
2905 through the fixups to find where the function address is being
2906 loaded from. We then generate a COUNT reloc giving the number of
2907 times that function address is referred to. The linker uses this
2908 information when doing relaxing, to decide when it can eliminate
2909 the stored function address entirely. */
2915 shmedia_frob_file_before_adjust ();
2921 #ifdef BFD_ASSEMBLER
2922 bfd_map_over_sections (stdoutput
, sh_frob_section
, (PTR
) NULL
);
2927 for (iseg
= SEG_E0
; iseg
< SEG_UNKNOWN
; iseg
++)
2928 sh_frob_section ((bfd
*) NULL
, iseg
, (PTR
) NULL
);
2933 /* Called after relaxing. Set the correct sizes of the fragments, and
2934 create relocs so that md_apply_fix3 will fill in the correct values. */
2937 md_convert_frag (headers
, seg
, fragP
)
2938 #ifdef BFD_ASSEMBLER
2939 bfd
*headers ATTRIBUTE_UNUSED
;
2941 object_headers
*headers ATTRIBUTE_UNUSED
;
2948 switch (fragP
->fr_subtype
)
2950 case C (COND_JUMP
, COND8
):
2951 case C (COND_JUMP_DELAY
, COND8
):
2952 subseg_change (seg
, 0);
2953 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
2954 1, BFD_RELOC_SH_PCDISP8BY2
);
2959 case C (UNCOND_JUMP
, UNCOND12
):
2960 subseg_change (seg
, 0);
2961 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
2962 1, BFD_RELOC_SH_PCDISP12BY2
);
2967 case C (UNCOND_JUMP
, UNCOND32
):
2968 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
2969 if (fragP
->fr_symbol
== NULL
)
2970 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2971 _("displacement overflows 12-bit field"));
2972 else if (S_IS_DEFINED (fragP
->fr_symbol
))
2973 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2974 _("displacement to defined symbol %s overflows 12-bit field"),
2975 S_GET_NAME (fragP
->fr_symbol
));
2977 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2978 _("displacement to undefined symbol %s overflows 12-bit field"),
2979 S_GET_NAME (fragP
->fr_symbol
));
2980 /* Stabilize this frag, so we don't trip an assert. */
2981 fragP
->fr_fix
+= fragP
->fr_var
;
2985 case C (COND_JUMP
, COND12
):
2986 case C (COND_JUMP_DELAY
, COND12
):
2987 /* A bcond won't fit, so turn it into a b!cond; bra disp; nop. */
2988 /* I found that a relax failure for gcc.c-torture/execute/930628-1.c
2989 was due to gas incorrectly relaxing an out-of-range conditional
2990 branch with delay slot. It turned:
2991 bf.s L6 (slot mov.l r12,@(44,r0))
2994 2c: 8f 01 a0 8b bf.s 32 <_main+32> (slot bra L6)
2996 32: 10 cb mov.l r12,@(44,r0)
2997 Therefore, branches with delay slots have to be handled
2998 differently from ones without delay slots. */
3000 unsigned char *buffer
=
3001 (unsigned char *) (fragP
->fr_fix
+ fragP
->fr_literal
);
3002 int highbyte
= target_big_endian
? 0 : 1;
3003 int lowbyte
= target_big_endian
? 1 : 0;
3004 int delay
= fragP
->fr_subtype
== C (COND_JUMP_DELAY
, COND12
);
3006 /* Toggle the true/false bit of the bcond. */
3007 buffer
[highbyte
] ^= 0x2;
3009 /* If this is a delayed branch, we may not put the bra in the
3010 slot. So we change it to a non-delayed branch, like that:
3011 b! cond slot_label; bra disp; slot_label: slot_insn
3012 ??? We should try if swapping the conditional branch and
3013 its delay-slot insn already makes the branch reach. */
3015 /* Build a relocation to six / four bytes farther on. */
3016 subseg_change (seg
, 0);
3017 fix_new (fragP
, fragP
->fr_fix
, 2,
3018 #ifdef BFD_ASSEMBLER
3019 section_symbol (seg
),
3021 seg_info (seg
)->dot
,
3023 fragP
->fr_address
+ fragP
->fr_fix
+ (delay
? 4 : 6),
3024 1, BFD_RELOC_SH_PCDISP8BY2
);
3026 /* Set up a jump instruction. */
3027 buffer
[highbyte
+ 2] = 0xa0;
3028 buffer
[lowbyte
+ 2] = 0;
3029 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
3030 fragP
->fr_offset
, 1, BFD_RELOC_SH_PCDISP12BY2
);
3034 buffer
[highbyte
] &= ~0x4; /* Removes delay slot from branch. */
3039 /* Fill in a NOP instruction. */
3040 buffer
[highbyte
+ 4] = 0x0;
3041 buffer
[lowbyte
+ 4] = 0x9;
3050 case C (COND_JUMP
, COND32
):
3051 case C (COND_JUMP_DELAY
, COND32
):
3052 case C (COND_JUMP
, UNDEF_WORD_DISP
):
3053 case C (COND_JUMP_DELAY
, UNDEF_WORD_DISP
):
3054 if (fragP
->fr_symbol
== NULL
)
3055 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3056 _("displacement overflows 8-bit field"));
3057 else if (S_IS_DEFINED (fragP
->fr_symbol
))
3058 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3059 _("displacement to defined symbol %s overflows 8-bit field"),
3060 S_GET_NAME (fragP
->fr_symbol
));
3062 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
3063 _("displacement to undefined symbol %s overflows 8-bit field "),
3064 S_GET_NAME (fragP
->fr_symbol
));
3065 /* Stabilize this frag, so we don't trip an assert. */
3066 fragP
->fr_fix
+= fragP
->fr_var
;
3072 shmedia_md_convert_frag (headers
, seg
, fragP
, TRUE
);
3078 if (donerelax
&& !sh_relax
)
3079 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
3080 _("overflow in branch to %s; converted into longer instruction sequence"),
3081 (fragP
->fr_symbol
!= NULL
3082 ? S_GET_NAME (fragP
->fr_symbol
)
3087 md_section_align (seg
, size
)
3088 segT seg ATTRIBUTE_UNUSED
;
3091 #ifdef BFD_ASSEMBLER
3094 #else /* ! OBJ_ELF */
3095 return ((size
+ (1 << bfd_get_section_alignment (stdoutput
, seg
)) - 1)
3096 & (-1 << bfd_get_section_alignment (stdoutput
, seg
)));
3097 #endif /* ! OBJ_ELF */
3098 #else /* ! BFD_ASSEMBLER */
3099 return ((size
+ (1 << section_alignment
[(int) seg
]) - 1)
3100 & (-1 << section_alignment
[(int) seg
]));
3101 #endif /* ! BFD_ASSEMBLER */
3104 /* This static variable is set by s_uacons to tell sh_cons_align that
3105 the expession does not need to be aligned. */
3107 static int sh_no_align_cons
= 0;
3109 /* This handles the unaligned space allocation pseudo-ops, such as
3110 .uaword. .uaword is just like .word, but the value does not need
3117 /* Tell sh_cons_align not to align this value. */
3118 sh_no_align_cons
= 1;
3122 /* If a .word, et. al., pseud-op is seen, warn if the value is not
3123 aligned correctly. Note that this can cause warnings to be issued
3124 when assembling initialized structured which were declared with the
3125 packed attribute. FIXME: Perhaps we should require an option to
3126 enable this warning? */
3129 sh_cons_align (nbytes
)
3135 if (sh_no_align_cons
)
3137 /* This is an unaligned pseudo-op. */
3138 sh_no_align_cons
= 0;
3143 while ((nbytes
& 1) == 0)
3152 if (now_seg
== absolute_section
)
3154 if ((abs_section_offset
& ((1 << nalign
) - 1)) != 0)
3155 as_warn (_("misaligned data"));
3159 p
= frag_var (rs_align_test
, 1, 1, (relax_substateT
) 0,
3160 (symbolS
*) NULL
, (offsetT
) nalign
, (char *) NULL
);
3162 record_alignment (now_seg
, nalign
);
3165 /* When relaxing, we need to output a reloc for any .align directive
3166 that requests alignment to a four byte boundary or larger. This is
3167 also where we check for misaligned data. */
3170 sh_handle_align (frag
)
3173 int bytes
= frag
->fr_next
->fr_address
- frag
->fr_address
- frag
->fr_fix
;
3175 if (frag
->fr_type
== rs_align_code
)
3177 static const unsigned char big_nop_pattern
[] = { 0x00, 0x09 };
3178 static const unsigned char little_nop_pattern
[] = { 0x09, 0x00 };
3180 char *p
= frag
->fr_literal
+ frag
->fr_fix
;
3189 if (target_big_endian
)
3191 memcpy (p
, big_nop_pattern
, sizeof big_nop_pattern
);
3192 frag
->fr_var
= sizeof big_nop_pattern
;
3196 memcpy (p
, little_nop_pattern
, sizeof little_nop_pattern
);
3197 frag
->fr_var
= sizeof little_nop_pattern
;
3200 else if (frag
->fr_type
== rs_align_test
)
3203 as_warn_where (frag
->fr_file
, frag
->fr_line
, _("misaligned data"));
3207 && (frag
->fr_type
== rs_align
3208 || frag
->fr_type
== rs_align_code
)
3209 && frag
->fr_address
+ frag
->fr_fix
> 0
3210 && frag
->fr_offset
> 1
3211 && now_seg
!= bss_section
)
3212 fix_new (frag
, frag
->fr_fix
, 2, &abs_symbol
, frag
->fr_offset
, 0,
3213 BFD_RELOC_SH_ALIGN
);
3216 /* See whether the relocation should be resolved locally. */
3219 sh_local_pcrel (fix
)
3223 && (fix
->fx_r_type
== BFD_RELOC_SH_PCDISP8BY2
3224 || fix
->fx_r_type
== BFD_RELOC_SH_PCDISP12BY2
3225 || fix
->fx_r_type
== BFD_RELOC_SH_PCRELIMM8BY2
3226 || fix
->fx_r_type
== BFD_RELOC_SH_PCRELIMM8BY4
3227 || fix
->fx_r_type
== BFD_RELOC_8_PCREL
3228 || fix
->fx_r_type
== BFD_RELOC_SH_SWITCH16
3229 || fix
->fx_r_type
== BFD_RELOC_SH_SWITCH32
));
3232 /* See whether we need to force a relocation into the output file.
3233 This is used to force out switch and PC relative relocations when
3237 sh_force_relocation (fix
)
3240 /* These relocations can't make it into a DSO, so no use forcing
3241 them for global symbols. */
3242 if (sh_local_pcrel (fix
))
3245 /* Make sure some relocations get emitted. */
3246 if (fix
->fx_r_type
== BFD_RELOC_SH_LOOP_START
3247 || fix
->fx_r_type
== BFD_RELOC_SH_LOOP_END
3248 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_GD_32
3249 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_LD_32
3250 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_IE_32
3251 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_LDO_32
3252 || fix
->fx_r_type
== BFD_RELOC_SH_TLS_LE_32
3253 || generic_force_reloc (fix
))
3259 return (fix
->fx_pcrel
3260 || SWITCH_TABLE (fix
)
3261 || fix
->fx_r_type
== BFD_RELOC_SH_COUNT
3262 || fix
->fx_r_type
== BFD_RELOC_SH_ALIGN
3263 || fix
->fx_r_type
== BFD_RELOC_SH_CODE
3264 || fix
->fx_r_type
== BFD_RELOC_SH_DATA
3266 || fix
->fx_r_type
== BFD_RELOC_SH_SHMEDIA_CODE
3268 || fix
->fx_r_type
== BFD_RELOC_SH_LABEL
);
3273 sh_fix_adjustable (fixP
)
3276 if (fixP
->fx_r_type
== BFD_RELOC_32_PLT_PCREL
3277 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
3278 || fixP
->fx_r_type
== BFD_RELOC_SH_GOTPC
3279 || fixP
->fx_r_type
== BFD_RELOC_RVA
)
3282 /* We need the symbol name for the VTABLE entries */
3283 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
3284 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
3291 sh_elf_final_processing ()
3295 /* Set file-specific flags to indicate if this code needs
3296 a processor with the sh-dsp / sh3e ISA to execute. */
3298 /* SH5 and above don't know about the valid_arch arch_sh* bits defined
3299 in sh-opc.h, so check SH64 mode before checking valid_arch. */
3300 if (sh64_isa_mode
!= sh64_isa_unspecified
)
3303 #endif /* HAVE_SH64 */
3304 if (valid_arch
& arch_sh1
)
3306 else if (valid_arch
& arch_sh2
)
3308 else if (valid_arch
& arch_sh2e
)
3310 else if (valid_arch
& arch_sh_dsp
)
3312 else if (valid_arch
& arch_sh3
)
3314 else if (valid_arch
& arch_sh3_dsp
)
3316 else if (valid_arch
& arch_sh3e
)
3318 else if (valid_arch
& arch_sh4
)
3323 elf_elfheader (stdoutput
)->e_flags
&= ~EF_SH_MACH_MASK
;
3324 elf_elfheader (stdoutput
)->e_flags
|= val
;
3328 /* Apply a fixup to the object file. */
3331 md_apply_fix3 (fixP
, valP
, seg
)
3334 segT seg ATTRIBUTE_UNUSED
;
3336 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
3337 int lowbyte
= target_big_endian
? 1 : 0;
3338 int highbyte
= target_big_endian
? 0 : 1;
3339 long val
= (long) *valP
;
3343 #ifdef BFD_ASSEMBLER
3344 /* A difference between two symbols, the second of which is in the
3345 current section, is transformed in a PC-relative relocation to
3346 the other symbol. We have to adjust the relocation type here. */
3349 switch (fixP
->fx_r_type
)
3355 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
3358 /* Currently, we only support 32-bit PCREL relocations.
3359 We'd need a new reloc type to handle 16_PCREL, and
3360 8_PCREL is already taken for R_SH_SWITCH8, which
3361 apparently does something completely different than what
3364 bfd_set_error (bfd_error_bad_value
);
3368 bfd_set_error (bfd_error_bad_value
);
3373 /* The function adjust_reloc_syms won't convert a reloc against a weak
3374 symbol into a reloc against a section, but bfd_install_relocation
3375 will screw up if the symbol is defined, so we have to adjust val here
3376 to avoid the screw up later.
3378 For ordinary relocs, this does not happen for ELF, since for ELF,
3379 bfd_install_relocation uses the "special function" field of the
3380 howto, and does not execute the code that needs to be undone, as long
3381 as the special function does not return bfd_reloc_continue.
3382 It can happen for GOT- and PLT-type relocs the way they are
3383 described in elf32-sh.c as they use bfd_elf_generic_reloc, but it
3384 doesn't matter here since those relocs don't use VAL; see below. */
3385 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
3386 && fixP
->fx_addsy
!= NULL
3387 && S_IS_WEAK (fixP
->fx_addsy
))
3388 val
-= S_GET_VALUE (fixP
->fx_addsy
);
3391 #ifdef BFD_ASSEMBLER
3392 if (SWITCH_TABLE (fixP
))
3393 val
-= S_GET_VALUE (fixP
->fx_subsy
);
3395 if (fixP
->fx_r_type
== 0)
3397 if (fixP
->fx_size
== 2)
3398 fixP
->fx_r_type
= BFD_RELOC_16
;
3399 else if (fixP
->fx_size
== 4)
3400 fixP
->fx_r_type
= BFD_RELOC_32
;
3401 else if (fixP
->fx_size
== 1)
3402 fixP
->fx_r_type
= BFD_RELOC_8
;
3410 switch (fixP
->fx_r_type
)
3412 case BFD_RELOC_SH_IMM4
:
3414 *buf
= (*buf
& 0xf0) | (val
& 0xf);
3417 case BFD_RELOC_SH_IMM4BY2
:
3420 *buf
= (*buf
& 0xf0) | ((val
>> 1) & 0xf);
3423 case BFD_RELOC_SH_IMM4BY4
:
3426 *buf
= (*buf
& 0xf0) | ((val
>> 2) & 0xf);
3429 case BFD_RELOC_SH_IMM8BY2
:
3435 case BFD_RELOC_SH_IMM8BY4
:
3442 case BFD_RELOC_SH_IMM8
:
3443 /* Sometimes the 8 bit value is sign extended (e.g., add) and
3444 sometimes it is not (e.g., and). We permit any 8 bit value.
3445 Note that adding further restrictions may invalidate
3446 reasonable looking assembly code, such as ``and -0x1,r0''. */
3452 case BFD_RELOC_SH_PCRELIMM8BY4
:
3453 /* The lower two bits of the PC are cleared before the
3454 displacement is added in. We can assume that the destination
3455 is on a 4 byte bounday. If this instruction is also on a 4
3456 byte boundary, then we want
3458 and target - here is a multiple of 4.
3459 Otherwise, we are on a 2 byte boundary, and we want
3460 (target - (here - 2)) / 4
3461 and target - here is not a multiple of 4. Computing
3462 (target - (here - 2)) / 4 == (target - here + 2) / 4
3463 works for both cases, since in the first case the addition of
3464 2 will be removed by the division. target - here is in the
3466 val
= (val
+ 2) / 4;
3468 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3472 case BFD_RELOC_SH_PCRELIMM8BY2
:
3475 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3479 case BFD_RELOC_SH_PCDISP8BY2
:
3481 if (val
< -0x80 || val
> 0x7f)
3482 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3486 case BFD_RELOC_SH_PCDISP12BY2
:
3488 if (val
< -0x800 || val
> 0x7ff)
3489 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
3490 buf
[lowbyte
] = val
& 0xff;
3491 buf
[highbyte
] |= (val
>> 8) & 0xf;
3495 case BFD_RELOC_32_PCREL
:
3496 md_number_to_chars (buf
, val
, 4);
3500 md_number_to_chars (buf
, val
, 2);
3503 case BFD_RELOC_SH_USES
:
3504 /* Pass the value into sh_coff_reloc_mangle. */
3505 fixP
->fx_addnumber
= val
;
3508 case BFD_RELOC_SH_COUNT
:
3509 case BFD_RELOC_SH_ALIGN
:
3510 case BFD_RELOC_SH_CODE
:
3511 case BFD_RELOC_SH_DATA
:
3512 case BFD_RELOC_SH_LABEL
:
3513 /* Nothing to do here. */
3516 case BFD_RELOC_SH_LOOP_START
:
3517 case BFD_RELOC_SH_LOOP_END
:
3519 case BFD_RELOC_VTABLE_INHERIT
:
3520 case BFD_RELOC_VTABLE_ENTRY
:
3525 case BFD_RELOC_32_PLT_PCREL
:
3526 /* Make the jump instruction point to the address of the operand. At
3527 runtime we merely add the offset to the actual PLT entry. */
3528 * valP
= 0xfffffffc;
3529 val
= fixP
->fx_offset
;
3531 val
-= S_GET_VALUE (fixP
->fx_subsy
);
3532 fixP
->fx_addnumber
= val
;
3533 md_number_to_chars (buf
, val
, 4);
3536 case BFD_RELOC_SH_GOTPC
:
3537 /* This is tough to explain. We end up with this one if we have
3538 operands that look like "_GLOBAL_OFFSET_TABLE_+[.-.L284]".
3539 The goal here is to obtain the absolute address of the GOT,
3540 and it is strongly preferable from a performance point of
3541 view to avoid using a runtime relocation for this. There are
3542 cases where you have something like:
3544 .long _GLOBAL_OFFSET_TABLE_+[.-.L66]
3546 and here no correction would be required. Internally in the
3547 assembler we treat operands of this form as not being pcrel
3548 since the '.' is explicitly mentioned, and I wonder whether
3549 it would simplify matters to do it this way. Who knows. In
3550 earlier versions of the PIC patches, the pcrel_adjust field
3551 was used to store the correction, but since the expression is
3552 not pcrel, I felt it would be confusing to do it this way. */
3554 md_number_to_chars (buf
, val
, 4);
3557 case BFD_RELOC_SH_TLS_GD_32
:
3558 case BFD_RELOC_SH_TLS_LD_32
:
3559 case BFD_RELOC_SH_TLS_IE_32
:
3560 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
3562 case BFD_RELOC_32_GOT_PCREL
:
3563 case BFD_RELOC_SH_GOTPLT32
:
3564 * valP
= 0; /* Fully resolved at runtime. No addend. */
3565 md_number_to_chars (buf
, 0, 4);
3568 case BFD_RELOC_SH_TLS_LDO_32
:
3569 case BFD_RELOC_SH_TLS_LE_32
:
3570 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
3572 case BFD_RELOC_32_GOTOFF
:
3573 md_number_to_chars (buf
, val
, 4);
3579 shmedia_md_apply_fix3 (fixP
, valP
);
3588 if ((val
& ((1 << shift
) - 1)) != 0)
3589 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("misaligned offset"));
3593 val
= ((val
>> shift
)
3594 | ((long) -1 & ~ ((long) -1 >> shift
)));
3596 if (max
!= 0 && (val
< min
|| val
> max
))
3597 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("offset out of range"));
3599 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
3603 /* Called just before address relaxation. Return the length
3604 by which a fragment must grow to reach it's destination. */
3607 md_estimate_size_before_relax (fragP
, segment_type
)
3608 register fragS
*fragP
;
3609 register segT segment_type
;
3613 switch (fragP
->fr_subtype
)
3617 return shmedia_md_estimate_size_before_relax (fragP
, segment_type
);
3623 case C (UNCOND_JUMP
, UNDEF_DISP
):
3624 /* Used to be a branch to somewhere which was unknown. */
3625 if (!fragP
->fr_symbol
)
3627 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
3629 else if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
3631 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
3635 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNDEF_WORD_DISP
);
3639 case C (COND_JUMP
, UNDEF_DISP
):
3640 case C (COND_JUMP_DELAY
, UNDEF_DISP
):
3641 what
= GET_WHAT (fragP
->fr_subtype
);
3642 /* Used to be a branch to somewhere which was unknown. */
3643 if (fragP
->fr_symbol
3644 && S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
3646 /* Got a symbol and it's defined in this segment, become byte
3647 sized - maybe it will fix up. */
3648 fragP
->fr_subtype
= C (what
, COND8
);
3650 else if (fragP
->fr_symbol
)
3652 /* Its got a segment, but its not ours, so it will always be long. */
3653 fragP
->fr_subtype
= C (what
, UNDEF_WORD_DISP
);
3657 /* We know the abs value. */
3658 fragP
->fr_subtype
= C (what
, COND8
);
3662 case C (UNCOND_JUMP
, UNCOND12
):
3663 case C (UNCOND_JUMP
, UNCOND32
):
3664 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
3665 case C (COND_JUMP
, COND8
):
3666 case C (COND_JUMP
, COND12
):
3667 case C (COND_JUMP
, COND32
):
3668 case C (COND_JUMP
, UNDEF_WORD_DISP
):
3669 case C (COND_JUMP_DELAY
, COND8
):
3670 case C (COND_JUMP_DELAY
, COND12
):
3671 case C (COND_JUMP_DELAY
, COND32
):
3672 case C (COND_JUMP_DELAY
, UNDEF_WORD_DISP
):
3673 /* When relaxing a section for the second time, we don't need to
3674 do anything besides return the current size. */
3678 fragP
->fr_var
= md_relax_table
[fragP
->fr_subtype
].rlx_length
;
3679 return fragP
->fr_var
;
3682 /* Put number into target byte order. */
3685 md_number_to_chars (ptr
, use
, nbytes
)
3691 /* We might need to set the contents type to data. */
3692 sh64_flag_output ();
3695 if (! target_big_endian
)
3696 number_to_chars_littleendian (ptr
, use
, nbytes
);
3698 number_to_chars_bigendian (ptr
, use
, nbytes
);
3701 /* This version is used in obj-coff.c when not using BFD_ASSEMBLER.
3702 eg for the sh-hms target. */
3705 md_pcrel_from (fixP
)
3708 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
+ 2;
3712 md_pcrel_from_section (fixP
, sec
)
3716 if (! sh_local_pcrel (fixP
)
3717 && fixP
->fx_addsy
!= (symbolS
*) NULL
3718 && (generic_force_reloc (fixP
)
3719 || S_GET_SEGMENT (fixP
->fx_addsy
) != sec
))
3721 /* The symbol is undefined (or is defined but not in this section,
3722 or we're not sure about it being the final definition). Let the
3723 linker figure it out. We need to adjust the subtraction of a
3724 symbol to the position of the relocated data, though. */
3725 return fixP
->fx_subsy
? fixP
->fx_where
+ fixP
->fx_frag
->fr_address
: 0;
3728 return md_pcrel_from (fixP
);
3734 tc_coff_sizemachdep (frag
)
3737 return md_relax_table
[frag
->fr_subtype
].rlx_length
;
3740 #endif /* OBJ_COFF */
3742 #ifndef BFD_ASSEMBLER
3745 /* Map BFD relocs to SH COFF relocs. */
3749 bfd_reloc_code_real_type bfd_reloc
;
3753 static const struct reloc_map coff_reloc_map
[] =
3755 { BFD_RELOC_32
, R_SH_IMM32
},
3756 { BFD_RELOC_16
, R_SH_IMM16
},
3757 { BFD_RELOC_8
, R_SH_IMM8
},
3758 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_PCDISP8BY2
},
3759 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_PCDISP
},
3760 { BFD_RELOC_SH_IMM4
, R_SH_IMM4
},
3761 { BFD_RELOC_SH_IMM4BY2
, R_SH_IMM4BY2
},
3762 { BFD_RELOC_SH_IMM4BY4
, R_SH_IMM4BY4
},
3763 { BFD_RELOC_SH_IMM8
, R_SH_IMM8
},
3764 { BFD_RELOC_SH_IMM8BY2
, R_SH_IMM8BY2
},
3765 { BFD_RELOC_SH_IMM8BY4
, R_SH_IMM8BY4
},
3766 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_PCRELIMM8BY2
},
3767 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_PCRELIMM8BY4
},
3768 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
3769 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
3770 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
3771 { BFD_RELOC_SH_USES
, R_SH_USES
},
3772 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
3773 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
3774 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
3775 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
3776 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
3777 { BFD_RELOC_UNUSED
, 0 }
3780 /* Adjust a reloc for the SH. This is similar to the generic code,
3781 but does some minor tweaking. */
3784 sh_coff_reloc_mangle (seg
, fix
, intr
, paddr
)
3785 segment_info_type
*seg
;
3787 struct internal_reloc
*intr
;
3790 symbolS
*symbol_ptr
= fix
->fx_addsy
;
3793 intr
->r_vaddr
= paddr
+ fix
->fx_frag
->fr_address
+ fix
->fx_where
;
3795 if (! SWITCH_TABLE (fix
))
3797 const struct reloc_map
*rm
;
3799 for (rm
= coff_reloc_map
; rm
->bfd_reloc
!= BFD_RELOC_UNUSED
; rm
++)
3800 if (rm
->bfd_reloc
== (bfd_reloc_code_real_type
) fix
->fx_r_type
)
3802 if (rm
->bfd_reloc
== BFD_RELOC_UNUSED
)
3803 as_bad_where (fix
->fx_file
, fix
->fx_line
,
3804 _("Can not represent %s relocation in this object file format"),
3805 bfd_get_reloc_code_name (fix
->fx_r_type
));
3806 intr
->r_type
= rm
->sh_reloc
;
3813 if (fix
->fx_r_type
== BFD_RELOC_16
)
3814 intr
->r_type
= R_SH_SWITCH16
;
3815 else if (fix
->fx_r_type
== BFD_RELOC_8
)
3816 intr
->r_type
= R_SH_SWITCH8
;
3817 else if (fix
->fx_r_type
== BFD_RELOC_32
)
3818 intr
->r_type
= R_SH_SWITCH32
;
3822 /* For a switch reloc, we set r_offset to the difference between
3823 the reloc address and the subtrahend. When the linker is
3824 doing relaxing, it can use the determine the starting and
3825 ending points of the switch difference expression. */
3826 intr
->r_offset
= intr
->r_vaddr
- S_GET_VALUE (fix
->fx_subsy
);
3829 /* PC relative relocs are always against the current section. */
3830 if (symbol_ptr
== NULL
)
3832 switch (fix
->fx_r_type
)
3834 case BFD_RELOC_SH_PCRELIMM8BY2
:
3835 case BFD_RELOC_SH_PCRELIMM8BY4
:
3836 case BFD_RELOC_SH_PCDISP8BY2
:
3837 case BFD_RELOC_SH_PCDISP12BY2
:
3838 case BFD_RELOC_SH_USES
:
3839 symbol_ptr
= seg
->dot
;
3846 if (fix
->fx_r_type
== BFD_RELOC_SH_USES
)
3848 /* We can't store the offset in the object file, since this
3849 reloc does not take up any space, so we store it in r_offset.
3850 The fx_addnumber field was set in md_apply_fix3. */
3851 intr
->r_offset
= fix
->fx_addnumber
;
3853 else if (fix
->fx_r_type
== BFD_RELOC_SH_COUNT
)
3855 /* We can't store the count in the object file, since this reloc
3856 does not take up any space, so we store it in r_offset. The
3857 fx_offset field was set when the fixup was created in
3858 sh_coff_frob_file. */
3859 intr
->r_offset
= fix
->fx_offset
;
3860 /* This reloc is always absolute. */
3863 else if (fix
->fx_r_type
== BFD_RELOC_SH_ALIGN
)
3865 /* Store the alignment in the r_offset field. */
3866 intr
->r_offset
= fix
->fx_offset
;
3867 /* This reloc is always absolute. */
3870 else if (fix
->fx_r_type
== BFD_RELOC_SH_CODE
3871 || fix
->fx_r_type
== BFD_RELOC_SH_DATA
3872 || fix
->fx_r_type
== BFD_RELOC_SH_LABEL
)
3874 /* These relocs are always absolute. */
3878 /* Turn the segment of the symbol into an offset. */
3879 if (symbol_ptr
!= NULL
)
3881 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
3883 intr
->r_symndx
= dot
->sy_number
;
3885 intr
->r_symndx
= symbol_ptr
->sy_number
;
3888 intr
->r_symndx
= -1;
3891 #endif /* OBJ_COFF */
3892 #endif /* ! BFD_ASSEMBLER */
3894 #ifdef BFD_ASSEMBLER
3896 /* Create a reloc. */
3899 tc_gen_reloc (section
, fixp
)
3900 asection
*section ATTRIBUTE_UNUSED
;
3904 bfd_reloc_code_real_type r_type
;
3906 rel
= (arelent
*) xmalloc (sizeof (arelent
));
3907 rel
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
3908 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
3909 rel
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
3911 r_type
= fixp
->fx_r_type
;
3913 if (SWITCH_TABLE (fixp
))
3915 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_subsy
);
3917 if (r_type
== BFD_RELOC_16
)
3918 r_type
= BFD_RELOC_SH_SWITCH16
;
3919 else if (r_type
== BFD_RELOC_8
)
3920 r_type
= BFD_RELOC_8_PCREL
;
3921 else if (r_type
== BFD_RELOC_32
)
3922 r_type
= BFD_RELOC_SH_SWITCH32
;
3926 else if (r_type
== BFD_RELOC_SH_USES
)
3927 rel
->addend
= fixp
->fx_addnumber
;
3928 else if (r_type
== BFD_RELOC_SH_COUNT
)
3929 rel
->addend
= fixp
->fx_offset
;
3930 else if (r_type
== BFD_RELOC_SH_ALIGN
)
3931 rel
->addend
= fixp
->fx_offset
;
3932 else if (r_type
== BFD_RELOC_VTABLE_INHERIT
3933 || r_type
== BFD_RELOC_VTABLE_ENTRY
)
3934 rel
->addend
= fixp
->fx_offset
;
3935 else if (r_type
== BFD_RELOC_SH_LOOP_START
3936 || r_type
== BFD_RELOC_SH_LOOP_END
)
3937 rel
->addend
= fixp
->fx_offset
;
3938 else if (r_type
== BFD_RELOC_SH_LABEL
&& fixp
->fx_pcrel
)
3941 rel
->address
= rel
->addend
= fixp
->fx_offset
;
3944 else if (shmedia_init_reloc (rel
, fixp
))
3947 else if (fixp
->fx_pcrel
)
3948 rel
->addend
= fixp
->fx_addnumber
;
3949 else if (r_type
== BFD_RELOC_32
|| r_type
== BFD_RELOC_32_GOTOFF
)
3950 rel
->addend
= fixp
->fx_addnumber
;
3954 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, r_type
);
3955 if (rel
->howto
->type
== R_SH_IND12W
)
3956 rel
->addend
+= fixp
->fx_offset
- 4;
3957 if (rel
->howto
== NULL
)
3959 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
3960 _("Cannot represent relocation type %s"),
3961 bfd_get_reloc_code_name (r_type
));
3962 /* Set howto to a garbage value so that we can keep going. */
3963 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
3964 assert (rel
->howto
!= NULL
);
3971 inline static char *
3972 sh_end_of_match (cont
, what
)
3975 int len
= strlen (what
);
3977 if (strncasecmp (cont
, what
, strlen (what
)) == 0
3978 && ! is_part_of_name (cont
[len
]))
3985 sh_parse_name (name
, exprP
, nextcharP
)
3990 char *next
= input_line_pointer
;
3995 exprP
->X_op_symbol
= NULL
;
3997 if (strcmp (name
, GLOBAL_OFFSET_TABLE_NAME
) == 0)
4000 GOT_symbol
= symbol_find_or_make (name
);
4002 exprP
->X_add_symbol
= GOT_symbol
;
4004 /* If we have an absolute symbol or a reg, then we know its
4006 segment
= S_GET_SEGMENT (exprP
->X_add_symbol
);
4007 if (segment
== absolute_section
)
4009 exprP
->X_op
= O_constant
;
4010 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
4011 exprP
->X_add_symbol
= NULL
;
4013 else if (segment
== reg_section
)
4015 exprP
->X_op
= O_register
;
4016 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
4017 exprP
->X_add_symbol
= NULL
;
4021 exprP
->X_op
= O_symbol
;
4022 exprP
->X_add_number
= 0;
4028 exprP
->X_add_symbol
= symbol_find_or_make (name
);
4030 if (*nextcharP
!= '@')
4032 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTOFF")))
4033 reloc_type
= BFD_RELOC_32_GOTOFF
;
4034 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTPLT")))
4035 reloc_type
= BFD_RELOC_SH_GOTPLT32
;
4036 else if ((next_end
= sh_end_of_match (next
+ 1, "GOT")))
4037 reloc_type
= BFD_RELOC_32_GOT_PCREL
;
4038 else if ((next_end
= sh_end_of_match (next
+ 1, "PLT")))
4039 reloc_type
= BFD_RELOC_32_PLT_PCREL
;
4040 else if ((next_end
= sh_end_of_match (next
+ 1, "TLSGD")))
4041 reloc_type
= BFD_RELOC_SH_TLS_GD_32
;
4042 else if ((next_end
= sh_end_of_match (next
+ 1, "TLSLDM")))
4043 reloc_type
= BFD_RELOC_SH_TLS_LD_32
;
4044 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTTPOFF")))
4045 reloc_type
= BFD_RELOC_SH_TLS_IE_32
;
4046 else if ((next_end
= sh_end_of_match (next
+ 1, "TPOFF")))
4047 reloc_type
= BFD_RELOC_SH_TLS_LE_32
;
4048 else if ((next_end
= sh_end_of_match (next
+ 1, "DTPOFF")))
4049 reloc_type
= BFD_RELOC_SH_TLS_LDO_32
;
4053 *input_line_pointer
= *nextcharP
;
4054 input_line_pointer
= next_end
;
4055 *nextcharP
= *input_line_pointer
;
4056 *input_line_pointer
= '\0';
4058 exprP
->X_op
= O_PIC_reloc
;
4059 exprP
->X_add_number
= 0;
4060 exprP
->X_md
= reloc_type
;
4065 #endif /* BFD_ASSEMBLER */