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 symbolS
*dot
PARAMS ((void));
63 static char *parse_exp
PARAMS ((char *, sh_operand_info
*));
64 static char *parse_at
PARAMS ((char *, sh_operand_info
*));
65 static void get_operand
PARAMS ((char **, sh_operand_info
*));
66 static char *get_operands
67 PARAMS ((sh_opcode_info
*, char *, sh_operand_info
*));
68 static sh_opcode_info
*get_specific
69 PARAMS ((sh_opcode_info
*, sh_operand_info
*));
70 static void insert
PARAMS ((char *, int, int, sh_operand_info
*));
71 static void build_relax
PARAMS ((sh_opcode_info
*, sh_operand_info
*));
72 static char *insert_loop_bounds
PARAMS ((char *, sh_operand_info
*));
73 static unsigned int build_Mytes
74 PARAMS ((sh_opcode_info
*, sh_operand_info
*));
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", dwarf2_directive_file
, 0 },
141 {"loc", dwarf2_directive_loc
, 0 },
146 /*int md_reloc_size; */
148 int sh_relax
; /* set if -relax seen */
150 /* Whether -small was seen. */
154 /* Whether -dsp was seen. */
158 /* The bit mask of architectures that could
159 accomodate the insns seen so far. */
160 static int valid_arch
;
162 const char EXP_CHARS
[] = "eE";
164 /* Chars that mean this number is a floating point constant. */
167 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
169 #define C(a,b) ENCODE_RELAX(a,b)
171 #define ENCODE_RELAX(what,length) (((what) << 4) + (length))
172 #define GET_WHAT(x) ((x>>4))
174 /* These are the three types of relaxable instrction. */
176 #define COND_JUMP_DELAY 2
177 #define UNCOND_JUMP 3
184 #define UNDEF_WORD_DISP 4
189 /* Branch displacements are from the address of the branch plus
190 four, thus all minimum and maximum values have 4 added to them. */
193 #define COND8_LENGTH 2
195 /* There is one extra instruction before the branch, so we must add
196 two more bytes to account for it. */
197 #define COND12_F 4100
198 #define COND12_M -4090
199 #define COND12_LENGTH 6
201 #define COND12_DELAY_LENGTH 4
203 /* ??? The minimum and maximum values are wrong, but this does not matter
204 since this relocation type is not supported yet. */
205 #define COND32_F (1<<30)
206 #define COND32_M -(1<<30)
207 #define COND32_LENGTH 14
209 #define UNCOND12_F 4098
210 #define UNCOND12_M -4092
211 #define UNCOND12_LENGTH 2
213 /* ??? The minimum and maximum values are wrong, but this does not matter
214 since this relocation type is not supported yet. */
215 #define UNCOND32_F (1<<30)
216 #define UNCOND32_M -(1<<30)
217 #define UNCOND32_LENGTH 14
219 #define EMPTY { 0, 0, 0, 0 }
221 const relax_typeS md_relax_table
[C (END
, 0)] = {
222 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
223 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
226 /* C (COND_JUMP, COND8) */
227 { COND8_F
, COND8_M
, COND8_LENGTH
, C (COND_JUMP
, COND12
) },
228 /* C (COND_JUMP, COND12) */
229 { COND12_F
, COND12_M
, COND12_LENGTH
, C (COND_JUMP
, COND32
), },
230 /* C (COND_JUMP, COND32) */
231 { COND32_F
, COND32_M
, COND32_LENGTH
, 0, },
232 /* C (COND_JUMP, UNDEF_WORD_DISP) */
233 { 0, 0, COND32_LENGTH
, 0, },
235 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
238 /* C (COND_JUMP_DELAY, COND8) */
239 { COND8_F
, COND8_M
, COND8_LENGTH
, C (COND_JUMP_DELAY
, COND12
) },
240 /* C (COND_JUMP_DELAY, COND12) */
241 { COND12_F
, COND12_M
, COND12_DELAY_LENGTH
, C (COND_JUMP_DELAY
, COND32
), },
242 /* C (COND_JUMP_DELAY, COND32) */
243 { COND32_F
, COND32_M
, COND32_LENGTH
, 0, },
244 /* C (COND_JUMP_DELAY, UNDEF_WORD_DISP) */
245 { 0, 0, COND32_LENGTH
, 0, },
247 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
250 /* C (UNCOND_JUMP, UNCOND12) */
251 { UNCOND12_F
, UNCOND12_M
, UNCOND12_LENGTH
, C (UNCOND_JUMP
, UNCOND32
), },
252 /* C (UNCOND_JUMP, UNCOND32) */
253 { UNCOND32_F
, UNCOND32_M
, UNCOND32_LENGTH
, 0, },
255 /* C (UNCOND_JUMP, UNDEF_WORD_DISP) */
256 { 0, 0, UNCOND32_LENGTH
, 0, },
258 EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
, EMPTY
,
263 static struct hash_control
*opcode_hash_control
; /* Opcode mnemonics */
267 /* Determinet whether the symbol needs any kind of PIC relocation. */
270 sh_PIC_related_p (sym
)
278 if (sym
== GOT_symbol
)
281 exp
= symbol_get_value_expression (sym
);
283 return (exp
->X_op
== O_PIC_reloc
284 || sh_PIC_related_p (exp
->X_add_symbol
)
285 || sh_PIC_related_p (exp
->X_op_symbol
));
288 /* Determine the relocation type to be used to represent the
289 expression, that may be rearranged. */
292 sh_check_fixup (main_exp
, r_type_p
)
293 expressionS
*main_exp
;
294 bfd_reloc_code_real_type
*r_type_p
;
296 expressionS
*exp
= main_exp
;
298 /* This is here for backward-compatibility only. GCC used to generated:
300 f@PLT + . - (.LPCS# + 2)
302 but we'd rather be able to handle this as a PIC-related reference
303 plus/minus a symbol. However, gas' parser gives us:
305 O_subtract (O_add (f@PLT, .), .LPCS#+2)
307 so we attempt to transform this into:
309 O_subtract (f@PLT, O_subtract (.LPCS#+2, .))
311 which we can handle simply below. */
312 if (exp
->X_op
== O_subtract
)
314 if (sh_PIC_related_p (exp
->X_op_symbol
))
317 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
319 if (exp
&& sh_PIC_related_p (exp
->X_op_symbol
))
322 if (exp
&& exp
->X_op
== O_add
323 && sh_PIC_related_p (exp
->X_add_symbol
))
325 symbolS
*sym
= exp
->X_add_symbol
;
327 exp
->X_op
= O_subtract
;
328 exp
->X_add_symbol
= main_exp
->X_op_symbol
;
330 main_exp
->X_op_symbol
= main_exp
->X_add_symbol
;
331 main_exp
->X_add_symbol
= sym
;
333 main_exp
->X_add_number
+= exp
->X_add_number
;
334 exp
->X_add_number
= 0;
339 else if (exp
->X_op
== O_add
&& sh_PIC_related_p (exp
->X_op_symbol
))
342 if (exp
->X_op
== O_symbol
|| exp
->X_op
== O_add
|| exp
->X_op
== O_subtract
)
344 if (exp
->X_add_symbol
&& exp
->X_add_symbol
== GOT_symbol
)
346 *r_type_p
= BFD_RELOC_SH_GOTPC
;
349 exp
= symbol_get_value_expression (exp
->X_add_symbol
);
354 if (exp
->X_op
== O_PIC_reloc
)
356 *r_type_p
= exp
->X_md
;
358 exp
->X_op
= O_symbol
;
361 main_exp
->X_add_symbol
= exp
->X_add_symbol
;
362 main_exp
->X_add_number
+= exp
->X_add_number
;
366 return (sh_PIC_related_p (exp
->X_add_symbol
)
367 || sh_PIC_related_p (exp
->X_op_symbol
));
372 /* Add expression EXP of SIZE bytes to offset OFF of fragment FRAG. */
375 sh_cons_fix_new (frag
, off
, size
, exp
)
380 bfd_reloc_code_real_type r_type
= BFD_RELOC_UNUSED
;
382 if (sh_check_fixup (exp
, &r_type
))
383 as_bad (_("Invalid PIC expression."));
385 if (r_type
== BFD_RELOC_UNUSED
)
389 r_type
= BFD_RELOC_8
;
393 r_type
= BFD_RELOC_16
;
397 r_type
= BFD_RELOC_32
;
406 as_bad (_("unsupported BFD relocation size %u"), size
);
407 r_type
= BFD_RELOC_UNUSED
;
410 fix_new_exp (frag
, off
, size
, exp
, 0, r_type
);
413 /* The regular cons() function, that reads constants, doesn't support
414 suffixes such as @GOT, @GOTOFF and @PLT, that generate
415 machine-specific relocation types. So we must define it here. */
416 /* Clobbers input_line_pointer, checks end-of-line. */
419 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
423 if (is_it_end_of_statement ())
425 demand_empty_rest_of_line ();
432 emit_expr (&exp
, (unsigned int) nbytes
);
434 while (*input_line_pointer
++ == ',');
436 input_line_pointer
--; /* Put terminator back into stream. */
437 if (*input_line_pointer
== '#' || *input_line_pointer
== '!')
439 while (! is_end_of_line
[(unsigned char) *input_line_pointer
++]);
442 demand_empty_rest_of_line ();
447 /* This function is called once, at assembler startup time. This should
448 set up all the tables, etc that the MD part of the assembler needs. */
453 sh_opcode_info
*opcode
;
454 char *prev_name
= "";
457 target_arch
= arch_sh1_up
& ~(sh_dsp
? arch_sh3e_up
: arch_sh_dsp_up
);
458 valid_arch
= target_arch
;
460 opcode_hash_control
= hash_new ();
462 /* Insert unique names into hash table. */
463 for (opcode
= sh_table
; opcode
->name
; opcode
++)
465 if (strcmp (prev_name
, opcode
->name
))
467 if (! (opcode
->arch
& target_arch
))
469 prev_name
= opcode
->name
;
470 hash_insert (opcode_hash_control
, opcode
->name
, (char *) opcode
);
474 /* Make all the opcodes with the same name point to the same
476 opcode
->name
= prev_name
;
483 static int reg_x
, reg_y
;
487 #define IDENT_CHAR(c) (ISALNUM (c) || (c) == '_')
489 /* Try to parse a reg name. Return the number of chars consumed. */
492 parse_reg (src
, mode
, reg
)
497 char l0
= TOLOWER (src
[0]);
498 char l1
= l0
? TOLOWER (src
[1]) : 0;
500 /* We use ! IDENT_CHAR for the next character after the register name, to
501 make sure that we won't accidentally recognize a symbol name such as
502 'sram' or sr_ram as being a reference to the register 'sr'. */
508 if (src
[2] >= '0' && src
[2] <= '5'
509 && ! IDENT_CHAR ((unsigned char) src
[3]))
512 *reg
= 10 + src
[2] - '0';
516 if (l1
>= '0' && l1
<= '9'
517 && ! IDENT_CHAR ((unsigned char) src
[2]))
523 if (l1
>= '0' && l1
<= '7' && strncasecmp (&src
[2], "_bank", 5) == 0
524 && ! IDENT_CHAR ((unsigned char) src
[7]))
531 if (l1
== 'e' && ! IDENT_CHAR ((unsigned char) src
[2]))
536 if (l1
== 's' && ! IDENT_CHAR ((unsigned char) src
[2]))
547 if (! IDENT_CHAR ((unsigned char) src
[2]))
553 if (TOLOWER (src
[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src
[3]))
562 if (! IDENT_CHAR ((unsigned char) src
[2]))
568 if (TOLOWER (src
[2]) == 'g' && ! IDENT_CHAR ((unsigned char) src
[3]))
576 if (l1
== 'x' && src
[2] >= '0' && src
[2] <= '1'
577 && ! IDENT_CHAR ((unsigned char) src
[3]))
580 *reg
= 4 + (l1
- '0');
583 if (l1
== 'y' && src
[2] >= '0' && src
[2] <= '1'
584 && ! IDENT_CHAR ((unsigned char) src
[3]))
587 *reg
= 6 + (l1
- '0');
590 if (l1
== 's' && src
[2] >= '0' && src
[2] <= '3'
591 && ! IDENT_CHAR ((unsigned char) src
[3]))
596 *reg
= n
| ((~n
& 2) << 1);
601 if (l0
== 'i' && l1
&& ! IDENT_CHAR ((unsigned char) src
[2]))
623 if (l0
== 'x' && l1
>= '0' && l1
<= '1'
624 && ! IDENT_CHAR ((unsigned char) src
[2]))
627 *reg
= A_X0_NUM
+ l1
- '0';
631 if (l0
== 'y' && l1
>= '0' && l1
<= '1'
632 && ! IDENT_CHAR ((unsigned char) src
[2]))
635 *reg
= A_Y0_NUM
+ l1
- '0';
639 if (l0
== 'm' && l1
>= '0' && l1
<= '1'
640 && ! IDENT_CHAR ((unsigned char) src
[2]))
643 *reg
= l1
== '0' ? A_M0_NUM
: A_M1_NUM
;
649 && TOLOWER (src
[2]) == 'r' && ! IDENT_CHAR ((unsigned char) src
[3]))
655 if (l0
== 's' && l1
== 'p' && TOLOWER (src
[2]) == 'c'
656 && ! IDENT_CHAR ((unsigned char) src
[3]))
662 if (l0
== 's' && l1
== 'g' && TOLOWER (src
[2]) == 'r'
663 && ! IDENT_CHAR ((unsigned char) src
[3]))
669 if (l0
== 'd' && l1
== 's' && TOLOWER (src
[2]) == 'r'
670 && ! IDENT_CHAR ((unsigned char) src
[3]))
676 if (l0
== 'd' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
677 && ! IDENT_CHAR ((unsigned char) src
[3]))
683 if (l0
== 's' && l1
== 'r' && ! IDENT_CHAR ((unsigned char) src
[2]))
689 if (l0
== 's' && l1
== 'p' && ! IDENT_CHAR ((unsigned char) src
[2]))
696 if (l0
== 'p' && l1
== 'r' && ! IDENT_CHAR ((unsigned char) src
[2]))
701 if (l0
== 'p' && l1
== 'c' && ! IDENT_CHAR ((unsigned char) src
[2]))
703 /* Don't use A_DISP_PC here - that would accept stuff like 'mova pc,r0'
704 and use an uninitialized immediate. */
708 if (l0
== 'g' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
709 && ! IDENT_CHAR ((unsigned char) src
[3]))
714 if (l0
== 'v' && l1
== 'b' && TOLOWER (src
[2]) == 'r'
715 && ! IDENT_CHAR ((unsigned char) src
[3]))
721 if (l0
== 'm' && l1
== 'a' && TOLOWER (src
[2]) == 'c'
722 && ! IDENT_CHAR ((unsigned char) src
[4]))
724 if (TOLOWER (src
[3]) == 'l')
729 if (TOLOWER (src
[3]) == 'h')
735 if (l0
== 'm' && l1
== 'o' && TOLOWER (src
[2]) == 'd'
736 && ! IDENT_CHAR ((unsigned char) src
[3]))
741 if (l0
== 'f' && l1
== 'r')
745 if (src
[3] >= '0' && src
[3] <= '5'
746 && ! IDENT_CHAR ((unsigned char) src
[4]))
749 *reg
= 10 + src
[3] - '0';
753 if (src
[2] >= '0' && src
[2] <= '9'
754 && ! IDENT_CHAR ((unsigned char) src
[3]))
757 *reg
= (src
[2] - '0');
761 if (l0
== 'd' && l1
== 'r')
765 if (src
[3] >= '0' && src
[3] <= '4' && ! ((src
[3] - '0') & 1)
766 && ! IDENT_CHAR ((unsigned char) src
[4]))
769 *reg
= 10 + src
[3] - '0';
773 if (src
[2] >= '0' && src
[2] <= '8' && ! ((src
[2] - '0') & 1)
774 && ! IDENT_CHAR ((unsigned char) src
[3]))
777 *reg
= (src
[2] - '0');
781 if (l0
== 'x' && l1
== 'd')
785 if (src
[3] >= '0' && src
[3] <= '4' && ! ((src
[3] - '0') & 1)
786 && ! IDENT_CHAR ((unsigned char) src
[4]))
789 *reg
= 11 + src
[3] - '0';
793 if (src
[2] >= '0' && src
[2] <= '8' && ! ((src
[2] - '0') & 1)
794 && ! IDENT_CHAR ((unsigned char) src
[3]))
797 *reg
= (src
[2] - '0') + 1;
801 if (l0
== 'f' && l1
== 'v')
803 if (src
[2] == '1'&& src
[3] == '2' && ! IDENT_CHAR ((unsigned char) src
[4]))
809 if ((src
[2] == '0' || src
[2] == '4' || src
[2] == '8')
810 && ! IDENT_CHAR ((unsigned char) src
[3]))
813 *reg
= (src
[2] - '0');
817 if (l0
== 'f' && l1
== 'p' && TOLOWER (src
[2]) == 'u'
818 && TOLOWER (src
[3]) == 'l'
819 && ! IDENT_CHAR ((unsigned char) src
[4]))
825 if (l0
== 'f' && l1
== 'p' && TOLOWER (src
[2]) == 's'
826 && TOLOWER (src
[3]) == 'c'
827 && TOLOWER (src
[4]) == 'r' && ! IDENT_CHAR ((unsigned char) src
[5]))
833 if (l0
== 'x' && l1
== 'm' && TOLOWER (src
[2]) == 't'
834 && TOLOWER (src
[3]) == 'r'
835 && TOLOWER (src
[4]) == 'x' && ! IDENT_CHAR ((unsigned char) src
[5]))
849 /* JF: '.' is pseudo symbol with value of current location
850 in current segment. */
851 fake
= FAKE_LABEL_NAME
;
852 return symbol_new (fake
,
854 (valueT
) frag_now_fix (),
866 save
= input_line_pointer
;
867 input_line_pointer
= s
;
868 expression (&op
->immediate
);
869 if (op
->immediate
.X_op
== O_absent
)
870 as_bad (_("missing operand"));
872 else if (op
->immediate
.X_op
== O_PIC_reloc
873 || sh_PIC_related_p (op
->immediate
.X_add_symbol
)
874 || sh_PIC_related_p (op
->immediate
.X_op_symbol
))
875 as_bad (_("misplaced PIC operand"));
877 new = input_line_pointer
;
878 input_line_pointer
= save
;
882 /* The many forms of operand:
885 @Rn Register indirect
898 pr, gbr, vbr, macl, mach
911 /* Must be predecrement. */
914 len
= parse_reg (src
, &mode
, &(op
->reg
));
916 as_bad (_("illegal register after @-"));
921 else if (src
[0] == '(')
923 /* Could be @(disp, rn), @(disp, gbr), @(disp, pc), @(r0, gbr) or
926 len
= parse_reg (src
, &mode
, &(op
->reg
));
927 if (len
&& mode
== A_REG_N
)
932 as_bad (_("must be @(r0,...)"));
937 /* Now can be rn or gbr. */
938 len
= parse_reg (src
, &mode
, &(op
->reg
));
950 else if (mode
== A_REG_N
)
952 op
->type
= A_IND_R0_REG_N
;
956 as_bad (_("syntax error in @(r0,...)"));
961 as_bad (_("syntax error in @(r0...)"));
966 /* Must be an @(disp,.. thing). */
967 src
= parse_exp (src
, op
);
970 /* Now can be rn, gbr or pc. */
971 len
= parse_reg (src
, &mode
, &op
->reg
);
976 op
->type
= A_DISP_REG_N
;
978 else if (mode
== A_GBR
)
980 op
->type
= A_DISP_GBR
;
982 else if (mode
== A_PC
)
984 /* Turn a plain @(4,pc) into @(.+4,pc). */
985 if (op
->immediate
.X_op
== O_constant
)
987 op
->immediate
.X_add_symbol
= dot ();
988 op
->immediate
.X_op
= O_symbol
;
989 op
->type
= A_DISP_PC
;
992 op
->type
= A_DISP_PC_ABS
;
996 as_bad (_("syntax error in @(disp,[Rn, gbr, pc])"));
1001 as_bad (_("syntax error in @(disp,[Rn, gbr, pc])"));
1006 as_bad (_("expecting )"));
1012 src
+= parse_reg (src
, &mode
, &(op
->reg
));
1013 if (mode
!= A_REG_N
)
1014 as_bad (_("illegal register after @"));
1021 l0
= TOLOWER (src
[0]);
1022 l1
= TOLOWER (src
[1]);
1024 if ((l0
== 'r' && l1
== '8')
1025 || (l0
== 'i' && (l1
== 'x' || l1
== 's')))
1028 op
->type
= A_PMOD_N
;
1030 else if ( (l0
== 'r' && l1
== '9')
1031 || (l0
== 'i' && l1
== 'y'))
1034 op
->type
= A_PMODY_N
;
1046 get_operand (ptr
, op
)
1048 sh_operand_info
*op
;
1057 *ptr
= parse_exp (src
, op
);
1062 else if (src
[0] == '@')
1064 *ptr
= parse_at (src
, op
);
1067 len
= parse_reg (src
, &mode
, &(op
->reg
));
1076 /* Not a reg, the only thing left is a displacement. */
1077 *ptr
= parse_exp (src
, op
);
1078 op
->type
= A_DISP_PC
;
1084 get_operands (info
, args
, operand
)
1085 sh_opcode_info
*info
;
1087 sh_operand_info
*operand
;
1092 /* The pre-processor will eliminate whitespace in front of '@'
1093 after the first argument; we may be called multiple times
1094 from assemble_ppi, so don't insist on finding whitespace here. */
1098 get_operand (&ptr
, operand
+ 0);
1105 get_operand (&ptr
, operand
+ 1);
1106 /* ??? Hack: psha/pshl have a varying operand number depending on
1107 the type of the first operand. We handle this by having the
1108 three-operand version first and reducing the number of operands
1109 parsed to two if we see that the first operand is an immediate.
1110 This works because no insn with three operands has an immediate
1111 as first operand. */
1112 if (info
->arg
[2] && operand
[0].type
!= A_IMM
)
1118 get_operand (&ptr
, operand
+ 2);
1122 operand
[2].type
= 0;
1127 operand
[1].type
= 0;
1128 operand
[2].type
= 0;
1133 operand
[0].type
= 0;
1134 operand
[1].type
= 0;
1135 operand
[2].type
= 0;
1140 /* Passed a pointer to a list of opcodes which use different
1141 addressing modes, return the opcode which matches the opcodes
1144 static sh_opcode_info
*
1145 get_specific (opcode
, operands
)
1146 sh_opcode_info
*opcode
;
1147 sh_operand_info
*operands
;
1149 sh_opcode_info
*this_try
= opcode
;
1150 char *name
= opcode
->name
;
1153 while (opcode
->name
)
1155 this_try
= opcode
++;
1156 if (this_try
->name
!= name
)
1158 /* We've looked so far down the table that we've run out of
1159 opcodes with the same name. */
1163 /* Look at both operands needed by the opcodes and provided by
1164 the user - since an arg test will often fail on the same arg
1165 again and again, we'll try and test the last failing arg the
1166 first on each opcode try. */
1167 for (n
= 0; this_try
->arg
[n
]; n
++)
1169 sh_operand_info
*user
= operands
+ n
;
1170 sh_arg_type arg
= this_try
->arg
[n
];
1175 if (user
->type
== A_DISP_PC_ABS
)
1185 if (user
->type
!= arg
)
1189 /* opcode needs r0 */
1190 if (user
->type
!= A_REG_N
|| user
->reg
!= 0)
1194 if (user
->type
!= A_R0_GBR
|| user
->reg
!= 0)
1198 if (user
->type
!= F_REG_N
|| user
->reg
!= 0)
1206 case A_IND_R0_REG_N
:
1217 /* Opcode needs rn */
1218 if (user
->type
!= arg
)
1223 if (user
->type
!= D_REG_N
&& user
->type
!= X_REG_N
)
1238 if (user
->type
!= arg
)
1243 if (user
->type
!= arg
)
1252 case A_IND_R0_REG_M
:
1255 /* Opcode needs rn */
1256 if (user
->type
!= arg
- A_REG_M
+ A_REG_N
)
1262 if (user
->type
!= DSP_REG_N
)
1284 if (user
->type
!= DSP_REG_N
)
1306 if (user
->type
!= DSP_REG_N
)
1328 if (user
->type
!= DSP_REG_N
)
1350 if (user
->type
!= DSP_REG_N
)
1372 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_A0_NUM
)
1376 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_X0_NUM
)
1380 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_X1_NUM
)
1384 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_Y0_NUM
)
1388 if (user
->type
!= DSP_REG_N
|| user
->reg
!= A_Y1_NUM
)
1398 /* Opcode needs rn */
1399 if (user
->type
!= arg
- F_REG_M
+ F_REG_N
)
1404 if (user
->type
!= D_REG_N
&& user
->type
!= X_REG_N
)
1409 if (user
->type
!= XMTRX_M4
)
1415 printf (_("unhandled %d\n"), arg
);
1419 if ( !(valid_arch
& this_try
->arch
))
1421 valid_arch
&= this_try
->arch
;
1431 insert (where
, how
, pcrel
, op
)
1435 sh_operand_info
*op
;
1437 fix_new_exp (frag_now
,
1438 where
- frag_now
->fr_literal
,
1446 build_relax (opcode
, op
)
1447 sh_opcode_info
*opcode
;
1448 sh_operand_info
*op
;
1450 int high_byte
= target_big_endian
? 0 : 1;
1453 if (opcode
->arg
[0] == A_BDISP8
)
1455 int what
= (opcode
->nibbles
[1] & 4) ? COND_JUMP_DELAY
: COND_JUMP
;
1456 p
= frag_var (rs_machine_dependent
,
1457 md_relax_table
[C (what
, COND32
)].rlx_length
,
1458 md_relax_table
[C (what
, COND8
)].rlx_length
,
1460 op
->immediate
.X_add_symbol
,
1461 op
->immediate
.X_add_number
,
1463 p
[high_byte
] = (opcode
->nibbles
[0] << 4) | (opcode
->nibbles
[1]);
1465 else if (opcode
->arg
[0] == A_BDISP12
)
1467 p
= frag_var (rs_machine_dependent
,
1468 md_relax_table
[C (UNCOND_JUMP
, UNCOND32
)].rlx_length
,
1469 md_relax_table
[C (UNCOND_JUMP
, UNCOND12
)].rlx_length
,
1471 op
->immediate
.X_add_symbol
,
1472 op
->immediate
.X_add_number
,
1474 p
[high_byte
] = (opcode
->nibbles
[0] << 4);
1479 /* Insert ldrs & ldre with fancy relocations that relaxation can recognize. */
1482 insert_loop_bounds (output
, operand
)
1484 sh_operand_info
*operand
;
1489 /* Since the low byte of the opcode will be overwritten by the reloc, we
1490 can just stash the high byte into both bytes and ignore endianness. */
1493 insert (output
, BFD_RELOC_SH_LOOP_START
, 1, operand
);
1494 insert (output
, BFD_RELOC_SH_LOOP_END
, 1, operand
+ 1);
1498 static int count
= 0;
1500 /* If the last loop insn is a two-byte-insn, it is in danger of being
1501 swapped with the insn after it. To prevent this, create a new
1502 symbol - complete with SH_LABEL reloc - after the last loop insn.
1503 If the last loop insn is four bytes long, the symbol will be
1504 right in the middle, but four byte insns are not swapped anyways. */
1505 /* A REPEAT takes 6 bytes. The SH has a 32 bit address space.
1506 Hence a 9 digit number should be enough to count all REPEATs. */
1508 sprintf (name
, "_R%x", count
++ & 0x3fffffff);
1509 end_sym
= symbol_new (name
, undefined_section
, 0, &zero_address_frag
);
1510 /* Make this a local symbol. */
1512 SF_SET_LOCAL (end_sym
);
1513 #endif /* OBJ_COFF */
1514 symbol_table_insert (end_sym
);
1515 end_sym
->sy_value
= operand
[1].immediate
;
1516 end_sym
->sy_value
.X_add_number
+= 2;
1517 fix_new (frag_now
, frag_now_fix (), 2, end_sym
, 0, 1, BFD_RELOC_SH_LABEL
);
1520 output
= frag_more (2);
1523 insert (output
, BFD_RELOC_SH_LOOP_START
, 1, operand
);
1524 insert (output
, BFD_RELOC_SH_LOOP_END
, 1, operand
+ 1);
1526 return frag_more (2);
1529 /* Now we know what sort of opcodes it is, let's build the bytes. */
1532 build_Mytes (opcode
, operand
)
1533 sh_opcode_info
*opcode
;
1534 sh_operand_info
*operand
;
1538 char *output
= frag_more (2);
1539 unsigned int size
= 2;
1540 int low_byte
= target_big_endian
? 1 : 0;
1546 for (index
= 0; index
< 4; index
++)
1548 sh_nibble_type i
= opcode
->nibbles
[index
];
1558 nbuf
[index
] = reg_n
;
1561 nbuf
[index
] = reg_m
;
1564 if (reg_n
< 2 || reg_n
> 5)
1565 as_bad (_("Invalid register: 'r%d'"), reg_n
);
1566 nbuf
[index
] = (reg_n
& 3) | 4;
1569 nbuf
[index
] = reg_n
| (reg_m
>> 2);
1572 nbuf
[index
] = reg_b
| 0x08;
1575 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY4
, 0, operand
);
1578 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY2
, 0, operand
);
1581 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4
, 0, operand
);
1584 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY4
, 0, operand
+ 1);
1587 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4BY2
, 0, operand
+ 1);
1590 insert (output
+ low_byte
, BFD_RELOC_SH_IMM4
, 0, operand
+ 1);
1593 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY4
, 0, operand
);
1596 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY2
, 0, operand
);
1599 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8
, 0, operand
);
1602 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY4
, 0, operand
+ 1);
1605 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8BY2
, 0, operand
+ 1);
1608 insert (output
+ low_byte
, BFD_RELOC_SH_IMM8
, 0, operand
+ 1);
1611 insert (output
, BFD_RELOC_SH_PCRELIMM8BY4
,
1612 operand
->type
!= A_DISP_PC_ABS
, operand
);
1615 insert (output
, BFD_RELOC_SH_PCRELIMM8BY2
,
1616 operand
->type
!= A_DISP_PC_ABS
, operand
);
1619 output
= insert_loop_bounds (output
, operand
);
1620 nbuf
[index
] = opcode
->nibbles
[3];
1624 printf (_("failed for %d\n"), i
);
1628 if (!target_big_endian
)
1630 output
[1] = (nbuf
[0] << 4) | (nbuf
[1]);
1631 output
[0] = (nbuf
[2] << 4) | (nbuf
[3]);
1635 output
[0] = (nbuf
[0] << 4) | (nbuf
[1]);
1636 output
[1] = (nbuf
[2] << 4) | (nbuf
[3]);
1641 /* Find an opcode at the start of *STR_P in the hash table, and set
1642 *STR_P to the first character after the last one read. */
1644 static sh_opcode_info
*
1645 find_cooked_opcode (str_p
)
1649 unsigned char *op_start
;
1650 unsigned char *op_end
;
1654 /* Drop leading whitespace. */
1658 /* Find the op code end.
1659 The pre-processor will eliminate whitespace in front of
1660 any '@' after the first argument; we may be called from
1661 assemble_ppi, so the opcode might be terminated by an '@'. */
1662 for (op_start
= op_end
= (unsigned char *) (str
);
1665 && !is_end_of_line
[*op_end
] && *op_end
!= ' ' && *op_end
!= '@';
1668 unsigned char c
= op_start
[nlen
];
1670 /* The machine independent code will convert CMP/EQ into cmp/EQ
1671 because it thinks the '/' is the end of the symbol. Moreover,
1672 all but the first sub-insn is a parallel processing insn won't
1673 be capitalized. Instead of hacking up the machine independent
1674 code, we just deal with it here. */
1684 as_bad (_("can't find opcode "));
1686 return (sh_opcode_info
*) hash_find (opcode_hash_control
, name
);
1689 /* Assemble a parallel processing insn. */
1690 #define DDT_BASE 0xf000 /* Base value for double data transfer insns */
1693 assemble_ppi (op_end
, opcode
)
1695 sh_opcode_info
*opcode
;
1705 /* Some insn ignore one or more register fields, e.g. psts machl,a0.
1706 Make sure we encode a defined insn pattern. */
1712 sh_operand_info operand
[3];
1714 if (opcode
->arg
[0] != A_END
)
1715 op_end
= get_operands (opcode
, op_end
, operand
);
1716 opcode
= get_specific (opcode
, operand
);
1719 /* Couldn't find an opcode which matched the operands. */
1720 char *where
= frag_more (2);
1725 as_bad (_("invalid operands for opcode"));
1729 if (opcode
->nibbles
[0] != PPI
)
1730 as_bad (_("insn can't be combined with parallel processing insn"));
1732 switch (opcode
->nibbles
[1])
1737 as_bad (_("multiple movx specifications"));
1742 as_bad (_("multiple movy specifications"));
1748 as_bad (_("multiple movx specifications"));
1749 if (reg_n
< 4 || reg_n
> 5)
1750 as_bad (_("invalid movx address register"));
1751 if (opcode
->nibbles
[2] & 8)
1753 if (reg_m
== A_A1_NUM
)
1755 else if (reg_m
!= A_A0_NUM
)
1756 as_bad (_("invalid movx dsp register"));
1761 as_bad (_("invalid movx dsp register"));
1764 movx
+= ((reg_n
- 4) << 9) + (opcode
->nibbles
[2] << 2) + DDT_BASE
;
1769 as_bad (_("multiple movy specifications"));
1770 if (opcode
->nibbles
[2] & 8)
1772 /* Bit 3 in nibbles[2] is intended for bit 4 of the opcode,
1775 if (reg_m
== A_A1_NUM
)
1777 else if (reg_m
!= A_A0_NUM
)
1778 as_bad (_("invalid movy dsp register"));
1783 as_bad (_("invalid movy dsp register"));
1786 if (reg_n
< 6 || reg_n
> 7)
1787 as_bad (_("invalid movy address register"));
1788 movy
+= ((reg_n
- 6) << 8) + opcode
->nibbles
[2] + DDT_BASE
;
1792 if (operand
[0].immediate
.X_op
!= O_constant
)
1793 as_bad (_("dsp immediate shift value not constant"));
1794 field_b
= ((opcode
->nibbles
[2] << 12)
1795 | (operand
[0].immediate
.X_add_number
& 127) << 4
1800 as_bad (_("multiple parallel processing specifications"));
1801 field_b
= ((opcode
->nibbles
[2] << 12) + (opcode
->nibbles
[3] << 8)
1802 + (reg_x
<< 6) + (reg_y
<< 4) + reg_n
);
1806 as_bad (_("multiple condition specifications"));
1807 cond
= opcode
->nibbles
[2] << 8;
1809 goto skip_cond_check
;
1813 as_bad (_("multiple parallel processing specifications"));
1814 field_b
= ((opcode
->nibbles
[2] << 12) + (opcode
->nibbles
[3] << 8)
1815 + cond
+ (reg_x
<< 6) + (reg_y
<< 4) + reg_n
);
1821 if ((field_b
& 0xef00) != 0xa100)
1822 as_bad (_("insn cannot be combined with pmuls"));
1824 switch (field_b
& 0xf)
1827 field_b
+= 0 - A_X0_NUM
;
1830 field_b
+= 1 - A_Y0_NUM
;
1833 field_b
+= 2 - A_A0_NUM
;
1836 field_b
+= 3 - A_A1_NUM
;
1839 as_bad (_("bad padd / psub pmuls output operand"));
1842 field_b
+= 0x4000 + reg_efg
;
1849 as_bad (_("condition not followed by conditionalizable insn"));
1855 opcode
= find_cooked_opcode (&op_end
);
1859 (_("unrecognized characters at end of parallel processing insn")));
1864 move_code
= movx
| movy
;
1867 /* Parallel processing insn. */
1868 unsigned long ppi_code
= (movx
| movy
| 0xf800) << 16 | field_b
;
1870 output
= frag_more (4);
1872 if (! target_big_endian
)
1874 output
[3] = ppi_code
>> 8;
1875 output
[2] = ppi_code
;
1879 output
[2] = ppi_code
>> 8;
1880 output
[3] = ppi_code
;
1882 move_code
|= 0xf800;
1886 /* Just a double data transfer. */
1887 output
= frag_more (2);
1890 if (! target_big_endian
)
1892 output
[1] = move_code
>> 8;
1893 output
[0] = move_code
;
1897 output
[0] = move_code
>> 8;
1898 output
[1] = move_code
;
1903 /* This is the guts of the machine-dependent assembler. STR points to a
1904 machine dependent instruction. This function is supposed to emit
1905 the frags/bytes it assembles to. */
1911 unsigned char *op_end
;
1912 sh_operand_info operand
[3];
1913 sh_opcode_info
*opcode
;
1914 unsigned int size
= 0;
1916 opcode
= find_cooked_opcode (&str
);
1921 as_bad (_("unknown opcode"));
1926 && ! seg_info (now_seg
)->tc_segment_info_data
.in_code
)
1928 /* Output a CODE reloc to tell the linker that the following
1929 bytes are instructions, not data. */
1930 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0,
1932 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 1;
1935 if (opcode
->nibbles
[0] == PPI
)
1937 size
= assemble_ppi (op_end
, opcode
);
1941 if (opcode
->arg
[0] == A_BDISP12
1942 || opcode
->arg
[0] == A_BDISP8
)
1944 parse_exp (op_end
+ 1, &operand
[0]);
1945 build_relax (opcode
, &operand
[0]);
1949 if (opcode
->arg
[0] == A_END
)
1951 /* Ignore trailing whitespace. If there is any, it has already
1952 been compressed to a single space. */
1958 op_end
= get_operands (opcode
, op_end
, operand
);
1960 opcode
= get_specific (opcode
, operand
);
1964 /* Couldn't find an opcode which matched the operands. */
1965 char *where
= frag_more (2);
1970 as_bad (_("invalid operands for opcode"));
1975 as_bad (_("excess operands: '%s'"), op_end
);
1977 size
= build_Mytes (opcode
, operand
);
1982 #ifdef BFD_ASSEMBLER
1983 dwarf2_emit_insn (size
);
1987 /* This routine is called each time a label definition is seen. It
1988 emits a BFD_RELOC_SH_LABEL reloc if necessary. */
1993 static fragS
*last_label_frag
;
1994 static int last_label_offset
;
1997 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2001 offset
= frag_now_fix ();
2002 if (frag_now
!= last_label_frag
2003 || offset
!= last_label_offset
)
2005 fix_new (frag_now
, offset
, 2, &abs_symbol
, 0, 0, BFD_RELOC_SH_LABEL
);
2006 last_label_frag
= frag_now
;
2007 last_label_offset
= offset
;
2012 /* This routine is called when the assembler is about to output some
2013 data. It emits a BFD_RELOC_SH_DATA reloc if necessary. */
2016 sh_flush_pending_output ()
2019 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
2021 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0,
2023 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 0;
2028 md_undefined_symbol (name
)
2029 char *name ATTRIBUTE_UNUSED
;
2035 #ifndef BFD_ASSEMBLER
2038 tc_crawl_symbol_chain (headers
)
2039 object_headers
*headers
;
2041 printf (_("call to tc_crawl_symbol_chain \n"));
2045 tc_headers_hook (headers
)
2046 object_headers
*headers
;
2048 printf (_("call to tc_headers_hook \n"));
2054 /* Various routines to kill one day. */
2055 /* Equal to MAX_PRECISION in atof-ieee.c. */
2056 #define MAX_LITTLENUMS 6
2058 /* Turn a string in input_line_pointer into a floating point constant
2059 of type TYPE, and store the appropriate bytes in *LITP. The number
2060 of LITTLENUMS emitted is stored in *SIZEP . An error message is
2061 returned, or NULL on OK. */
2064 md_atof (type
, litP
, sizeP
)
2070 LITTLENUM_TYPE words
[4];
2086 return _("bad call to md_atof");
2089 t
= atof_ieee (input_line_pointer
, type
, words
);
2091 input_line_pointer
= t
;
2095 if (! target_big_endian
)
2097 for (i
= prec
- 1; i
>= 0; i
--)
2099 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
2105 for (i
= 0; i
< prec
; i
++)
2107 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
2115 /* Handle the .uses pseudo-op. This pseudo-op is used just before a
2116 call instruction. It refers to a label of the instruction which
2117 loads the register which the call uses. We use it to generate a
2118 special reloc for the linker. */
2122 int ignore ATTRIBUTE_UNUSED
;
2127 as_warn (_(".uses pseudo-op seen when not relaxing"));
2131 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
2133 as_bad (_("bad .uses format"));
2134 ignore_rest_of_line ();
2138 fix_new_exp (frag_now
, frag_now_fix (), 2, &ex
, 1, BFD_RELOC_SH_USES
);
2140 demand_empty_rest_of_line ();
2143 CONST
char *md_shortopts
= "";
2144 struct option md_longopts
[] =
2146 #define OPTION_RELAX (OPTION_MD_BASE)
2147 #define OPTION_BIG (OPTION_MD_BASE + 1)
2148 #define OPTION_LITTLE (OPTION_BIG + 1)
2149 #define OPTION_SMALL (OPTION_LITTLE + 1)
2150 #define OPTION_DSP (OPTION_SMALL + 1)
2152 {"relax", no_argument
, NULL
, OPTION_RELAX
},
2153 {"big", no_argument
, NULL
, OPTION_BIG
},
2154 {"little", no_argument
, NULL
, OPTION_LITTLE
},
2155 {"small", no_argument
, NULL
, OPTION_SMALL
},
2156 {"dsp", no_argument
, NULL
, OPTION_DSP
},
2157 {NULL
, no_argument
, NULL
, 0}
2159 size_t md_longopts_size
= sizeof (md_longopts
);
2162 md_parse_option (c
, arg
)
2164 char *arg ATTRIBUTE_UNUSED
;
2173 target_big_endian
= 1;
2177 target_big_endian
= 0;
2196 md_show_usage (stream
)
2199 fprintf (stream
, _("\
2201 -little generate little endian code\n\
2202 -big generate big endian code\n\
2203 -relax alter jump instructions for long displacements\n\
2204 -small align sections to 4 byte boundaries, not 16\n\
2205 -dsp enable sh-dsp insns, and disable sh3e / sh4 insns.\n"));
2208 /* This struct is used to pass arguments to sh_count_relocs through
2209 bfd_map_over_sections. */
2211 struct sh_count_relocs
2213 /* Symbol we are looking for. */
2215 /* Count of relocs found. */
2219 /* Count the number of fixups in a section which refer to a particular
2220 symbol. When using BFD_ASSEMBLER, this is called via
2221 bfd_map_over_sections. */
2224 sh_count_relocs (abfd
, sec
, data
)
2225 bfd
*abfd ATTRIBUTE_UNUSED
;
2229 struct sh_count_relocs
*info
= (struct sh_count_relocs
*) data
;
2230 segment_info_type
*seginfo
;
2234 seginfo
= seg_info (sec
);
2235 if (seginfo
== NULL
)
2239 for (fix
= seginfo
->fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
2241 if (fix
->fx_addsy
== sym
)
2249 /* Handle the count relocs for a particular section. When using
2250 BFD_ASSEMBLER, this is called via bfd_map_over_sections. */
2253 sh_frob_section (abfd
, sec
, ignore
)
2254 bfd
*abfd ATTRIBUTE_UNUSED
;
2256 PTR ignore ATTRIBUTE_UNUSED
;
2258 segment_info_type
*seginfo
;
2261 seginfo
= seg_info (sec
);
2262 if (seginfo
== NULL
)
2265 for (fix
= seginfo
->fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
2270 struct sh_count_relocs info
;
2272 if (fix
->fx_r_type
!= BFD_RELOC_SH_USES
)
2275 /* The BFD_RELOC_SH_USES reloc should refer to a defined local
2276 symbol in the same section. */
2277 sym
= fix
->fx_addsy
;
2279 || fix
->fx_subsy
!= NULL
2280 || fix
->fx_addnumber
!= 0
2281 || S_GET_SEGMENT (sym
) != sec
2282 #if ! defined (BFD_ASSEMBLER) && defined (OBJ_COFF)
2283 || S_GET_STORAGE_CLASS (sym
) == C_EXT
2285 || S_IS_EXTERNAL (sym
))
2287 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2288 _(".uses does not refer to a local symbol in the same section"));
2292 /* Look through the fixups again, this time looking for one
2293 at the same location as sym. */
2294 val
= S_GET_VALUE (sym
);
2295 for (fscan
= seginfo
->fix_root
;
2297 fscan
= fscan
->fx_next
)
2298 if (val
== fscan
->fx_frag
->fr_address
+ fscan
->fx_where
2299 && fscan
->fx_r_type
!= BFD_RELOC_SH_ALIGN
2300 && fscan
->fx_r_type
!= BFD_RELOC_SH_CODE
2301 && fscan
->fx_r_type
!= BFD_RELOC_SH_DATA
2302 && fscan
->fx_r_type
!= BFD_RELOC_SH_LABEL
)
2306 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2307 _("can't find fixup pointed to by .uses"));
2311 if (fscan
->fx_tcbit
)
2313 /* We've already done this one. */
2317 /* The variable fscan should also be a fixup to a local symbol
2318 in the same section. */
2319 sym
= fscan
->fx_addsy
;
2321 || fscan
->fx_subsy
!= NULL
2322 || fscan
->fx_addnumber
!= 0
2323 || S_GET_SEGMENT (sym
) != sec
2324 #if ! defined (BFD_ASSEMBLER) && defined (OBJ_COFF)
2325 || S_GET_STORAGE_CLASS (sym
) == C_EXT
2327 || S_IS_EXTERNAL (sym
))
2329 as_warn_where (fix
->fx_file
, fix
->fx_line
,
2330 _(".uses target does not refer to a local symbol in the same section"));
2334 /* Now we look through all the fixups of all the sections,
2335 counting the number of times we find a reference to sym. */
2338 #ifdef BFD_ASSEMBLER
2339 bfd_map_over_sections (stdoutput
, sh_count_relocs
, (PTR
) &info
);
2344 for (iscan
= SEG_E0
; iscan
< SEG_UNKNOWN
; iscan
++)
2345 sh_count_relocs ((bfd
*) NULL
, iscan
, (PTR
) &info
);
2352 /* Generate a BFD_RELOC_SH_COUNT fixup at the location of sym.
2353 We have already adjusted the value of sym to include the
2354 fragment address, so we undo that adjustment here. */
2355 subseg_change (sec
, 0);
2356 fix_new (fscan
->fx_frag
,
2357 S_GET_VALUE (sym
) - fscan
->fx_frag
->fr_address
,
2358 4, &abs_symbol
, info
.count
, 0, BFD_RELOC_SH_COUNT
);
2362 /* This function is called after the symbol table has been completed,
2363 but before the relocs or section contents have been written out.
2364 If we have seen any .uses pseudo-ops, they point to an instruction
2365 which loads a register with the address of a function. We look
2366 through the fixups to find where the function address is being
2367 loaded from. We then generate a COUNT reloc giving the number of
2368 times that function address is referred to. The linker uses this
2369 information when doing relaxing, to decide when it can eliminate
2370 the stored function address entirely. */
2378 #ifdef BFD_ASSEMBLER
2379 bfd_map_over_sections (stdoutput
, sh_frob_section
, (PTR
) NULL
);
2384 for (iseg
= SEG_E0
; iseg
< SEG_UNKNOWN
; iseg
++)
2385 sh_frob_section ((bfd
*) NULL
, iseg
, (PTR
) NULL
);
2390 /* Called after relaxing. Set the correct sizes of the fragments, and
2391 create relocs so that md_apply_fix3 will fill in the correct values. */
2394 md_convert_frag (headers
, seg
, fragP
)
2395 #ifdef BFD_ASSEMBLER
2396 bfd
*headers ATTRIBUTE_UNUSED
;
2398 object_headers
*headers
;
2405 switch (fragP
->fr_subtype
)
2407 case C (COND_JUMP
, COND8
):
2408 case C (COND_JUMP_DELAY
, COND8
):
2409 subseg_change (seg
, 0);
2410 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
2411 1, BFD_RELOC_SH_PCDISP8BY2
);
2416 case C (UNCOND_JUMP
, UNCOND12
):
2417 subseg_change (seg
, 0);
2418 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
2419 1, BFD_RELOC_SH_PCDISP12BY2
);
2424 case C (UNCOND_JUMP
, UNCOND32
):
2425 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
2426 if (fragP
->fr_symbol
== NULL
)
2427 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2428 _("displacement overflows 12-bit field"));
2429 else if (S_IS_DEFINED (fragP
->fr_symbol
))
2430 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2431 _("displacement to defined symbol %s overflows 12-bit field"),
2432 S_GET_NAME (fragP
->fr_symbol
));
2434 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2435 _("displacement to undefined symbol %s overflows 12-bit field"),
2436 S_GET_NAME (fragP
->fr_symbol
));
2437 /* Stabilize this frag, so we don't trip an assert. */
2438 fragP
->fr_fix
+= fragP
->fr_var
;
2442 case C (COND_JUMP
, COND12
):
2443 case C (COND_JUMP_DELAY
, COND12
):
2444 /* A bcond won't fit, so turn it into a b!cond; bra disp; nop. */
2445 /* I found that a relax failure for gcc.c-torture/execute/930628-1.c
2446 was due to gas incorrectly relaxing an out-of-range conditional
2447 branch with delay slot. It turned:
2448 bf.s L6 (slot mov.l r12,@(44,r0))
2451 2c: 8f 01 a0 8b bf.s 32 <_main+32> (slot bra L6)
2453 32: 10 cb mov.l r12,@(44,r0)
2454 Therefore, branches with delay slots have to be handled
2455 differently from ones without delay slots. */
2457 unsigned char *buffer
=
2458 (unsigned char *) (fragP
->fr_fix
+ fragP
->fr_literal
);
2459 int highbyte
= target_big_endian
? 0 : 1;
2460 int lowbyte
= target_big_endian
? 1 : 0;
2461 int delay
= fragP
->fr_subtype
== C (COND_JUMP_DELAY
, COND12
);
2463 /* Toggle the true/false bit of the bcond. */
2464 buffer
[highbyte
] ^= 0x2;
2466 /* If this is a delayed branch, we may not put the bra in the
2467 slot. So we change it to a non-delayed branch, like that:
2468 b! cond slot_label; bra disp; slot_label: slot_insn
2469 ??? We should try if swapping the conditional branch and
2470 its delay-slot insn already makes the branch reach. */
2472 /* Build a relocation to six / four bytes farther on. */
2473 subseg_change (seg
, 0);
2474 fix_new (fragP
, fragP
->fr_fix
, 2,
2475 #ifdef BFD_ASSEMBLER
2476 section_symbol (seg
),
2478 seg_info (seg
)->dot
,
2480 fragP
->fr_address
+ fragP
->fr_fix
+ (delay
? 4 : 6),
2481 1, BFD_RELOC_SH_PCDISP8BY2
);
2483 /* Set up a jump instruction. */
2484 buffer
[highbyte
+ 2] = 0xa0;
2485 buffer
[lowbyte
+ 2] = 0;
2486 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
2487 fragP
->fr_offset
, 1, BFD_RELOC_SH_PCDISP12BY2
);
2491 buffer
[highbyte
] &= ~0x4; /* Removes delay slot from branch. */
2496 /* Fill in a NOP instruction. */
2497 buffer
[highbyte
+ 4] = 0x0;
2498 buffer
[lowbyte
+ 4] = 0x9;
2507 case C (COND_JUMP
, COND32
):
2508 case C (COND_JUMP_DELAY
, COND32
):
2509 case C (COND_JUMP
, UNDEF_WORD_DISP
):
2510 case C (COND_JUMP_DELAY
, UNDEF_WORD_DISP
):
2511 if (fragP
->fr_symbol
== NULL
)
2512 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2513 _("displacement overflows 8-bit field"));
2514 else if (S_IS_DEFINED (fragP
->fr_symbol
))
2515 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2516 _("displacement to defined symbol %s overflows 8-bit field"),
2517 S_GET_NAME (fragP
->fr_symbol
));
2519 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
2520 _("displacement to undefined symbol %s overflows 8-bit field "),
2521 S_GET_NAME (fragP
->fr_symbol
));
2522 /* Stabilize this frag, so we don't trip an assert. */
2523 fragP
->fr_fix
+= fragP
->fr_var
;
2531 if (donerelax
&& !sh_relax
)
2532 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
2533 _("overflow in branch to %s; converted into longer instruction sequence"),
2534 (fragP
->fr_symbol
!= NULL
2535 ? S_GET_NAME (fragP
->fr_symbol
)
2540 md_section_align (seg
, size
)
2541 segT seg ATTRIBUTE_UNUSED
;
2544 #ifdef BFD_ASSEMBLER
2547 #else /* ! OBJ_ELF */
2548 return ((size
+ (1 << bfd_get_section_alignment (stdoutput
, seg
)) - 1)
2549 & (-1 << bfd_get_section_alignment (stdoutput
, seg
)));
2550 #endif /* ! OBJ_ELF */
2551 #else /* ! BFD_ASSEMBLER */
2552 return ((size
+ (1 << section_alignment
[(int) seg
]) - 1)
2553 & (-1 << section_alignment
[(int) seg
]));
2554 #endif /* ! BFD_ASSEMBLER */
2557 /* This static variable is set by s_uacons to tell sh_cons_align that
2558 the expession does not need to be aligned. */
2560 static int sh_no_align_cons
= 0;
2562 /* This handles the unaligned space allocation pseudo-ops, such as
2563 .uaword. .uaword is just like .word, but the value does not need
2570 /* Tell sh_cons_align not to align this value. */
2571 sh_no_align_cons
= 1;
2575 /* If a .word, et. al., pseud-op is seen, warn if the value is not
2576 aligned correctly. Note that this can cause warnings to be issued
2577 when assembling initialized structured which were declared with the
2578 packed attribute. FIXME: Perhaps we should require an option to
2579 enable this warning? */
2582 sh_cons_align (nbytes
)
2588 if (sh_no_align_cons
)
2590 /* This is an unaligned pseudo-op. */
2591 sh_no_align_cons
= 0;
2596 while ((nbytes
& 1) == 0)
2605 if (now_seg
== absolute_section
)
2607 if ((abs_section_offset
& ((1 << nalign
) - 1)) != 0)
2608 as_warn (_("misaligned data"));
2612 p
= frag_var (rs_align_test
, 1, 1, (relax_substateT
) 0,
2613 (symbolS
*) NULL
, (offsetT
) nalign
, (char *) NULL
);
2615 record_alignment (now_seg
, nalign
);
2618 /* When relaxing, we need to output a reloc for any .align directive
2619 that requests alignment to a four byte boundary or larger. This is
2620 also where we check for misaligned data. */
2623 sh_handle_align (frag
)
2626 int bytes
= frag
->fr_next
->fr_address
- frag
->fr_address
- frag
->fr_fix
;
2628 if (frag
->fr_type
== rs_align_code
)
2630 static const unsigned char big_nop_pattern
[] = { 0x00, 0x09 };
2631 static const unsigned char little_nop_pattern
[] = { 0x09, 0x00 };
2633 char *p
= frag
->fr_literal
+ frag
->fr_fix
;
2642 if (target_big_endian
)
2644 memcpy (p
, big_nop_pattern
, sizeof big_nop_pattern
);
2645 frag
->fr_var
= sizeof big_nop_pattern
;
2649 memcpy (p
, little_nop_pattern
, sizeof little_nop_pattern
);
2650 frag
->fr_var
= sizeof little_nop_pattern
;
2653 else if (frag
->fr_type
== rs_align_test
)
2656 as_warn_where (frag
->fr_file
, frag
->fr_line
, _("misaligned data"));
2660 && (frag
->fr_type
== rs_align
2661 || frag
->fr_type
== rs_align_code
)
2662 && frag
->fr_address
+ frag
->fr_fix
> 0
2663 && frag
->fr_offset
> 1
2664 && now_seg
!= bss_section
)
2665 fix_new (frag
, frag
->fr_fix
, 2, &abs_symbol
, frag
->fr_offset
, 0,
2666 BFD_RELOC_SH_ALIGN
);
2669 /* This macro decides whether a particular reloc is an entry in a
2670 switch table. It is used when relaxing, because the linker needs
2671 to know about all such entries so that it can adjust them if
2674 #ifdef BFD_ASSEMBLER
2675 #define SWITCH_TABLE_CONS(fix) (0)
2677 #define SWITCH_TABLE_CONS(fix) \
2678 ((fix)->fx_r_type == 0 \
2679 && ((fix)->fx_size == 2 \
2680 || (fix)->fx_size == 1 \
2681 || (fix)->fx_size == 4))
2684 #define SWITCH_TABLE(fix) \
2685 ((fix)->fx_addsy != NULL \
2686 && (fix)->fx_subsy != NULL \
2687 && S_GET_SEGMENT ((fix)->fx_addsy) == text_section \
2688 && S_GET_SEGMENT ((fix)->fx_subsy) == text_section \
2689 && ((fix)->fx_r_type == BFD_RELOC_32 \
2690 || (fix)->fx_r_type == BFD_RELOC_16 \
2691 || (fix)->fx_r_type == BFD_RELOC_8 \
2692 || SWITCH_TABLE_CONS (fix)))
2694 /* See whether we need to force a relocation into the output file.
2695 This is used to force out switch and PC relative relocations when
2699 sh_force_relocation (fix
)
2703 if (fix
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2704 || fix
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
2705 || fix
->fx_r_type
== BFD_RELOC_SH_LOOP_START
2706 || fix
->fx_r_type
== BFD_RELOC_SH_LOOP_END
)
2712 return (fix
->fx_pcrel
2713 || SWITCH_TABLE (fix
)
2714 || fix
->fx_r_type
== BFD_RELOC_SH_COUNT
2715 || fix
->fx_r_type
== BFD_RELOC_SH_ALIGN
2716 || fix
->fx_r_type
== BFD_RELOC_SH_CODE
2717 || fix
->fx_r_type
== BFD_RELOC_SH_DATA
2718 || fix
->fx_r_type
== BFD_RELOC_SH_LABEL
);
2723 sh_fix_adjustable (fixP
)
2727 if (fixP
->fx_addsy
== NULL
)
2730 if (fixP
->fx_r_type
== BFD_RELOC_SH_PCDISP8BY2
2731 || fixP
->fx_r_type
== BFD_RELOC_SH_PCDISP12BY2
2732 || fixP
->fx_r_type
== BFD_RELOC_SH_PCRELIMM8BY2
2733 || fixP
->fx_r_type
== BFD_RELOC_SH_PCRELIMM8BY4
2734 || fixP
->fx_r_type
== BFD_RELOC_8_PCREL
2735 || fixP
->fx_r_type
== BFD_RELOC_SH_SWITCH16
2736 || fixP
->fx_r_type
== BFD_RELOC_SH_SWITCH32
)
2739 if (! TC_RELOC_RTSYM_LOC_FIXUP (fixP
)
2740 || fixP
->fx_r_type
== BFD_RELOC_RVA
)
2743 /* We need the symbol name for the VTABLE entries */
2744 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2745 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2752 sh_elf_final_processing ()
2756 /* Set file-specific flags to indicate if this code needs
2757 a processor with the sh-dsp / sh3e ISA to execute. */
2758 if (valid_arch
& arch_sh1
)
2760 else if (valid_arch
& arch_sh2
)
2762 else if (valid_arch
& arch_sh_dsp
)
2764 else if (valid_arch
& arch_sh3
)
2766 else if (valid_arch
& arch_sh3_dsp
)
2768 else if (valid_arch
& arch_sh3e
)
2770 else if (valid_arch
& arch_sh4
)
2775 elf_elfheader (stdoutput
)->e_flags
&= ~EF_SH_MACH_MASK
;
2776 elf_elfheader (stdoutput
)->e_flags
|= val
;
2780 /* Apply a fixup to the object file. */
2783 md_apply_fix3 (fixP
, valP
, seg
)
2786 segT seg ATTRIBUTE_UNUSED
;
2788 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
2789 int lowbyte
= target_big_endian
? 1 : 0;
2790 int highbyte
= target_big_endian
? 0 : 1;
2791 long val
= * (long *) valP
;
2795 #ifdef BFD_ASSEMBLER
2796 /* A difference between two symbols, the second of which is in the
2797 current section, is transformed in a PC-relative relocation to
2798 the other symbol. We have to adjust the relocation type here. */
2801 switch (fixP
->fx_r_type
)
2807 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2810 /* Currently, we only support 32-bit PCREL relocations.
2811 We'd need a new reloc type to handle 16_PCREL, and
2812 8_PCREL is already taken for R_SH_SWITCH8, which
2813 apparently does something completely different than what
2816 bfd_set_error (bfd_error_bad_value
);
2820 bfd_set_error (bfd_error_bad_value
);
2825 /* The function adjust_reloc_syms won't convert a reloc against a weak
2826 symbol into a reloc against a section, but bfd_install_relocation
2827 will screw up if the symbol is defined, so we have to adjust val here
2828 to avoid the screw up later.
2830 For ordinary relocs, this does not happen for ELF, since for ELF,
2831 bfd_install_relocation uses the "special function" field of the
2832 howto, and does not execute the code that needs to be undone, as long
2833 as the special function does not return bfd_reloc_continue.
2834 It can happen for GOT- and PLT-type relocs the way they are
2835 described in elf32-sh.c as they use bfd_elf_generic_reloc, but it
2836 doesn't matter here since those relocs don't use VAL; see below. */
2837 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
2838 && fixP
->fx_addsy
!= NULL
2839 && S_IS_WEAK (fixP
->fx_addsy
))
2840 val
-= S_GET_VALUE (fixP
->fx_addsy
);
2843 #ifndef BFD_ASSEMBLER
2844 if (fixP
->fx_r_type
== 0)
2846 if (fixP
->fx_size
== 2)
2847 fixP
->fx_r_type
= BFD_RELOC_16
;
2848 else if (fixP
->fx_size
== 4)
2849 fixP
->fx_r_type
= BFD_RELOC_32
;
2850 else if (fixP
->fx_size
== 1)
2851 fixP
->fx_r_type
= BFD_RELOC_8
;
2859 switch (fixP
->fx_r_type
)
2861 case BFD_RELOC_SH_IMM4
:
2863 *buf
= (*buf
& 0xf0) | (val
& 0xf);
2866 case BFD_RELOC_SH_IMM4BY2
:
2869 *buf
= (*buf
& 0xf0) | ((val
>> 1) & 0xf);
2872 case BFD_RELOC_SH_IMM4BY4
:
2875 *buf
= (*buf
& 0xf0) | ((val
>> 2) & 0xf);
2878 case BFD_RELOC_SH_IMM8BY2
:
2884 case BFD_RELOC_SH_IMM8BY4
:
2891 case BFD_RELOC_SH_IMM8
:
2892 /* Sometimes the 8 bit value is sign extended (e.g., add) and
2893 sometimes it is not (e.g., and). We permit any 8 bit value.
2894 Note that adding further restrictions may invalidate
2895 reasonable looking assembly code, such as ``and -0x1,r0''. */
2901 case BFD_RELOC_SH_PCRELIMM8BY4
:
2902 /* The lower two bits of the PC are cleared before the
2903 displacement is added in. We can assume that the destination
2904 is on a 4 byte bounday. If this instruction is also on a 4
2905 byte boundary, then we want
2907 and target - here is a multiple of 4.
2908 Otherwise, we are on a 2 byte boundary, and we want
2909 (target - (here - 2)) / 4
2910 and target - here is not a multiple of 4. Computing
2911 (target - (here - 2)) / 4 == (target - here + 2) / 4
2912 works for both cases, since in the first case the addition of
2913 2 will be removed by the division. target - here is in the
2915 val
= (val
+ 2) / 4;
2917 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
2921 case BFD_RELOC_SH_PCRELIMM8BY2
:
2924 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
2928 case BFD_RELOC_SH_PCDISP8BY2
:
2930 if (val
< -0x80 || val
> 0x7f)
2931 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
2935 case BFD_RELOC_SH_PCDISP12BY2
:
2937 if (val
< -0x800 || val
> 0x7ff)
2938 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("pcrel too far"));
2939 buf
[lowbyte
] = val
& 0xff;
2940 buf
[highbyte
] |= (val
>> 8) & 0xf;
2944 case BFD_RELOC_32_PCREL
:
2945 md_number_to_chars (buf
, val
, 4);
2949 md_number_to_chars (buf
, val
, 2);
2952 case BFD_RELOC_SH_USES
:
2953 /* Pass the value into sh_coff_reloc_mangle. */
2954 fixP
->fx_addnumber
= val
;
2957 case BFD_RELOC_SH_COUNT
:
2958 case BFD_RELOC_SH_ALIGN
:
2959 case BFD_RELOC_SH_CODE
:
2960 case BFD_RELOC_SH_DATA
:
2961 case BFD_RELOC_SH_LABEL
:
2962 /* Nothing to do here. */
2965 case BFD_RELOC_SH_LOOP_START
:
2966 case BFD_RELOC_SH_LOOP_END
:
2968 case BFD_RELOC_VTABLE_INHERIT
:
2969 case BFD_RELOC_VTABLE_ENTRY
:
2974 case BFD_RELOC_32_PLT_PCREL
:
2975 /* Make the jump instruction point to the address of the operand. At
2976 runtime we merely add the offset to the actual PLT entry. */
2977 * valP
= 0xfffffffc;
2978 val
= fixP
->fx_addnumber
- S_GET_VALUE (fixP
->fx_subsy
);
2979 md_number_to_chars (buf
, val
, 4);
2982 case BFD_RELOC_SH_GOTPC
:
2983 /* This is tough to explain. We end up with this one if we have
2984 operands that look like "_GLOBAL_OFFSET_TABLE_+[.-.L284]".
2985 The goal here is to obtain the absolute address of the GOT,
2986 and it is strongly preferable from a performance point of
2987 view to avoid using a runtime relocation for this. There are
2988 cases where you have something like:
2990 .long _GLOBAL_OFFSET_TABLE_+[.-.L66]
2992 and here no correction would be required. Internally in the
2993 assembler we treat operands of this form as not being pcrel
2994 since the '.' is explicitly mentioned, and I wonder whether
2995 it would simplify matters to do it this way. Who knows. In
2996 earlier versions of the PIC patches, the pcrel_adjust field
2997 was used to store the correction, but since the expression is
2998 not pcrel, I felt it would be confusing to do it this way. */
3000 md_number_to_chars (buf
, val
, 4);
3003 case BFD_RELOC_32_GOT_PCREL
:
3004 * valP
= 0; /* Fully resolved at runtime. No addend. */
3005 md_number_to_chars (buf
, 0, 4);
3008 case BFD_RELOC_32_GOTOFF
:
3009 md_number_to_chars (buf
, val
, 4);
3019 if ((val
& ((1 << shift
) - 1)) != 0)
3020 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("misaligned offset"));
3024 val
= ((val
>> shift
)
3025 | ((long) -1 & ~ ((long) -1 >> shift
)));
3027 if (max
!= 0 && (val
< min
|| val
> max
))
3028 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("offset out of range"));
3030 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
3034 /* Called just before address relaxation. Return the length
3035 by which a fragment must grow to reach it's destination. */
3038 md_estimate_size_before_relax (fragP
, segment_type
)
3039 register fragS
*fragP
;
3040 register segT segment_type
;
3044 switch (fragP
->fr_subtype
)
3049 case C (UNCOND_JUMP
, UNDEF_DISP
):
3050 /* Used to be a branch to somewhere which was unknown. */
3051 if (!fragP
->fr_symbol
)
3053 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
3055 else if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
3057 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
3061 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNDEF_WORD_DISP
);
3065 case C (COND_JUMP
, UNDEF_DISP
):
3066 case C (COND_JUMP_DELAY
, UNDEF_DISP
):
3067 what
= GET_WHAT (fragP
->fr_subtype
);
3068 /* Used to be a branch to somewhere which was unknown. */
3069 if (fragP
->fr_symbol
3070 && S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
3072 /* Got a symbol and it's defined in this segment, become byte
3073 sized - maybe it will fix up. */
3074 fragP
->fr_subtype
= C (what
, COND8
);
3076 else if (fragP
->fr_symbol
)
3078 /* Its got a segment, but its not ours, so it will always be long. */
3079 fragP
->fr_subtype
= C (what
, UNDEF_WORD_DISP
);
3083 /* We know the abs value. */
3084 fragP
->fr_subtype
= C (what
, COND8
);
3088 case C (UNCOND_JUMP
, UNCOND12
):
3089 case C (UNCOND_JUMP
, UNCOND32
):
3090 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
3091 case C (COND_JUMP
, COND8
):
3092 case C (COND_JUMP
, COND12
):
3093 case C (COND_JUMP
, COND32
):
3094 case C (COND_JUMP
, UNDEF_WORD_DISP
):
3095 case C (COND_JUMP_DELAY
, COND8
):
3096 case C (COND_JUMP_DELAY
, COND12
):
3097 case C (COND_JUMP_DELAY
, COND32
):
3098 case C (COND_JUMP_DELAY
, UNDEF_WORD_DISP
):
3099 /* When relaxing a section for the second time, we don't need to
3100 do anything besides return the current size. */
3104 fragP
->fr_var
= md_relax_table
[fragP
->fr_subtype
].rlx_length
;
3105 return fragP
->fr_var
;
3108 /* Put number into target byte order. */
3111 md_number_to_chars (ptr
, use
, nbytes
)
3116 if (! target_big_endian
)
3117 number_to_chars_littleendian (ptr
, use
, nbytes
);
3119 number_to_chars_bigendian (ptr
, use
, nbytes
);
3123 md_pcrel_from_section (fixP
, sec
)
3127 if (fixP
->fx_addsy
!= (symbolS
*) NULL
3128 && (! S_IS_DEFINED (fixP
->fx_addsy
)
3129 || S_IS_EXTERN (fixP
->fx_addsy
)
3130 || S_IS_WEAK (fixP
->fx_addsy
)
3131 || S_GET_SEGMENT (fixP
->fx_addsy
) != sec
))
3133 /* The symbol is undefined (or is defined but not in this section,
3134 or we're not sure about it being the final definition). Let the
3135 linker figure it out. We need to adjust the subtraction of a
3136 symbol to the position of the relocated data, though. */
3137 return fixP
->fx_subsy
? fixP
->fx_where
+ fixP
->fx_frag
->fr_address
: 0;
3140 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
+ 2;
3146 tc_coff_sizemachdep (frag
)
3149 return md_relax_table
[frag
->fr_subtype
].rlx_length
;
3152 #endif /* OBJ_COFF */
3154 #ifndef BFD_ASSEMBLER
3157 /* Map BFD relocs to SH COFF relocs. */
3161 bfd_reloc_code_real_type bfd_reloc
;
3165 static const struct reloc_map coff_reloc_map
[] =
3167 { BFD_RELOC_32
, R_SH_IMM32
},
3168 { BFD_RELOC_16
, R_SH_IMM16
},
3169 { BFD_RELOC_8
, R_SH_IMM8
},
3170 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_PCDISP8BY2
},
3171 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_PCDISP
},
3172 { BFD_RELOC_SH_IMM4
, R_SH_IMM4
},
3173 { BFD_RELOC_SH_IMM4BY2
, R_SH_IMM4BY2
},
3174 { BFD_RELOC_SH_IMM4BY4
, R_SH_IMM4BY4
},
3175 { BFD_RELOC_SH_IMM8
, R_SH_IMM8
},
3176 { BFD_RELOC_SH_IMM8BY2
, R_SH_IMM8BY2
},
3177 { BFD_RELOC_SH_IMM8BY4
, R_SH_IMM8BY4
},
3178 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_PCRELIMM8BY2
},
3179 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_PCRELIMM8BY4
},
3180 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
3181 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
3182 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
3183 { BFD_RELOC_SH_USES
, R_SH_USES
},
3184 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
3185 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
3186 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
3187 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
3188 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
3189 { BFD_RELOC_UNUSED
, 0 }
3192 /* Adjust a reloc for the SH. This is similar to the generic code,
3193 but does some minor tweaking. */
3196 sh_coff_reloc_mangle (seg
, fix
, intr
, paddr
)
3197 segment_info_type
*seg
;
3199 struct internal_reloc
*intr
;
3202 symbolS
*symbol_ptr
= fix
->fx_addsy
;
3205 intr
->r_vaddr
= paddr
+ fix
->fx_frag
->fr_address
+ fix
->fx_where
;
3207 if (! SWITCH_TABLE (fix
))
3209 const struct reloc_map
*rm
;
3211 for (rm
= coff_reloc_map
; rm
->bfd_reloc
!= BFD_RELOC_UNUSED
; rm
++)
3212 if (rm
->bfd_reloc
== (bfd_reloc_code_real_type
) fix
->fx_r_type
)
3214 if (rm
->bfd_reloc
== BFD_RELOC_UNUSED
)
3215 as_bad_where (fix
->fx_file
, fix
->fx_line
,
3216 _("Can not represent %s relocation in this object file format"),
3217 bfd_get_reloc_code_name (fix
->fx_r_type
));
3218 intr
->r_type
= rm
->sh_reloc
;
3225 if (fix
->fx_r_type
== BFD_RELOC_16
)
3226 intr
->r_type
= R_SH_SWITCH16
;
3227 else if (fix
->fx_r_type
== BFD_RELOC_8
)
3228 intr
->r_type
= R_SH_SWITCH8
;
3229 else if (fix
->fx_r_type
== BFD_RELOC_32
)
3230 intr
->r_type
= R_SH_SWITCH32
;
3234 /* For a switch reloc, we set r_offset to the difference between
3235 the reloc address and the subtrahend. When the linker is
3236 doing relaxing, it can use the determine the starting and
3237 ending points of the switch difference expression. */
3238 intr
->r_offset
= intr
->r_vaddr
- S_GET_VALUE (fix
->fx_subsy
);
3241 /* PC relative relocs are always against the current section. */
3242 if (symbol_ptr
== NULL
)
3244 switch (fix
->fx_r_type
)
3246 case BFD_RELOC_SH_PCRELIMM8BY2
:
3247 case BFD_RELOC_SH_PCRELIMM8BY4
:
3248 case BFD_RELOC_SH_PCDISP8BY2
:
3249 case BFD_RELOC_SH_PCDISP12BY2
:
3250 case BFD_RELOC_SH_USES
:
3251 symbol_ptr
= seg
->dot
;
3258 if (fix
->fx_r_type
== BFD_RELOC_SH_USES
)
3260 /* We can't store the offset in the object file, since this
3261 reloc does not take up any space, so we store it in r_offset.
3262 The fx_addnumber field was set in md_apply_fix3. */
3263 intr
->r_offset
= fix
->fx_addnumber
;
3265 else if (fix
->fx_r_type
== BFD_RELOC_SH_COUNT
)
3267 /* We can't store the count in the object file, since this reloc
3268 does not take up any space, so we store it in r_offset. The
3269 fx_offset field was set when the fixup was created in
3270 sh_coff_frob_file. */
3271 intr
->r_offset
= fix
->fx_offset
;
3272 /* This reloc is always absolute. */
3275 else if (fix
->fx_r_type
== BFD_RELOC_SH_ALIGN
)
3277 /* Store the alignment in the r_offset field. */
3278 intr
->r_offset
= fix
->fx_offset
;
3279 /* This reloc is always absolute. */
3282 else if (fix
->fx_r_type
== BFD_RELOC_SH_CODE
3283 || fix
->fx_r_type
== BFD_RELOC_SH_DATA
3284 || fix
->fx_r_type
== BFD_RELOC_SH_LABEL
)
3286 /* These relocs are always absolute. */
3290 /* Turn the segment of the symbol into an offset. */
3291 if (symbol_ptr
!= NULL
)
3293 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
3295 intr
->r_symndx
= dot
->sy_number
;
3297 intr
->r_symndx
= symbol_ptr
->sy_number
;
3300 intr
->r_symndx
= -1;
3303 #endif /* OBJ_COFF */
3304 #endif /* ! BFD_ASSEMBLER */
3306 #ifdef BFD_ASSEMBLER
3308 /* Create a reloc. */
3311 tc_gen_reloc (section
, fixp
)
3312 asection
*section ATTRIBUTE_UNUSED
;
3316 bfd_reloc_code_real_type r_type
;
3318 rel
= (arelent
*) xmalloc (sizeof (arelent
));
3319 rel
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
3320 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
3321 rel
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
3324 && S_GET_SEGMENT (fixp
->fx_subsy
) == absolute_section
)
3326 fixp
->fx_addnumber
-= S_GET_VALUE (fixp
->fx_subsy
);
3330 r_type
= fixp
->fx_r_type
;
3332 if (SWITCH_TABLE (fixp
))
3334 rel
->addend
= rel
->address
- S_GET_VALUE (fixp
->fx_subsy
);
3335 if (r_type
== BFD_RELOC_16
)
3336 r_type
= BFD_RELOC_SH_SWITCH16
;
3337 else if (r_type
== BFD_RELOC_8
)
3338 r_type
= BFD_RELOC_8_PCREL
;
3339 else if (r_type
== BFD_RELOC_32
)
3340 r_type
= BFD_RELOC_SH_SWITCH32
;
3344 else if (r_type
== BFD_RELOC_SH_USES
)
3345 rel
->addend
= fixp
->fx_addnumber
;
3346 else if (r_type
== BFD_RELOC_SH_COUNT
)
3347 rel
->addend
= fixp
->fx_offset
;
3348 else if (r_type
== BFD_RELOC_SH_ALIGN
)
3349 rel
->addend
= fixp
->fx_offset
;
3350 else if (r_type
== BFD_RELOC_VTABLE_INHERIT
3351 || r_type
== BFD_RELOC_VTABLE_ENTRY
)
3352 rel
->addend
= fixp
->fx_offset
;
3353 else if (r_type
== BFD_RELOC_SH_LOOP_START
3354 || r_type
== BFD_RELOC_SH_LOOP_END
)
3355 rel
->addend
= fixp
->fx_offset
;
3356 else if (r_type
== BFD_RELOC_SH_LABEL
&& fixp
->fx_pcrel
)
3359 rel
->address
= rel
->addend
= fixp
->fx_offset
;
3361 else if (fixp
->fx_pcrel
)
3362 rel
->addend
= fixp
->fx_addnumber
;
3363 else if (r_type
== BFD_RELOC_32
|| r_type
== BFD_RELOC_32_GOTOFF
)
3364 rel
->addend
= fixp
->fx_addnumber
;
3368 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, r_type
);
3369 if (rel
->howto
== NULL
|| fixp
->fx_subsy
)
3371 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
3372 _("Cannot represent relocation type %s"),
3373 bfd_get_reloc_code_name (r_type
));
3374 /* Set howto to a garbage value so that we can keep going. */
3375 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
3376 assert (rel
->howto
!= NULL
);
3383 inline static char *
3384 sh_end_of_match (cont
, what
)
3387 int len
= strlen (what
);
3389 if (strncasecmp (cont
, what
, strlen (what
)) == 0
3390 && ! is_part_of_name (cont
[len
]))
3397 sh_parse_name (name
, exprP
, nextcharP
)
3402 char *next
= input_line_pointer
;
3407 exprP
->X_op_symbol
= NULL
;
3409 if (strcmp (name
, GLOBAL_OFFSET_TABLE_NAME
) == 0)
3412 GOT_symbol
= symbol_find_or_make (name
);
3414 exprP
->X_add_symbol
= GOT_symbol
;
3416 /* If we have an absolute symbol or a reg, then we know its
3418 segment
= S_GET_SEGMENT (exprP
->X_add_symbol
);
3419 if (segment
== absolute_section
)
3421 exprP
->X_op
= O_constant
;
3422 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
3423 exprP
->X_add_symbol
= NULL
;
3425 else if (segment
== reg_section
)
3427 exprP
->X_op
= O_register
;
3428 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
3429 exprP
->X_add_symbol
= NULL
;
3433 exprP
->X_op
= O_symbol
;
3434 exprP
->X_add_number
= 0;
3440 exprP
->X_add_symbol
= symbol_find_or_make (name
);
3442 if (*nextcharP
!= '@')
3444 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTOFF")))
3445 reloc_type
= BFD_RELOC_32_GOTOFF
;
3446 else if ((next_end
= sh_end_of_match (next
+ 1, "GOT")))
3447 reloc_type
= BFD_RELOC_32_GOT_PCREL
;
3448 else if ((next_end
= sh_end_of_match (next
+ 1, "PLT")))
3449 reloc_type
= BFD_RELOC_32_PLT_PCREL
;
3453 *input_line_pointer
= *nextcharP
;
3454 input_line_pointer
= next_end
;
3455 *nextcharP
= *input_line_pointer
;
3456 *input_line_pointer
= '\0';
3458 exprP
->X_op
= O_PIC_reloc
;
3459 exprP
->X_add_number
= 0;
3460 exprP
->X_md
= reloc_type
;
3465 #endif /* BFD_ASSEMBLER */