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
;
2980 val
-= S_GET_VALUE (fixP
->fx_subsy
);
2981 md_number_to_chars (buf
, val
, 4);
2984 case BFD_RELOC_SH_GOTPC
:
2985 /* This is tough to explain. We end up with this one if we have
2986 operands that look like "_GLOBAL_OFFSET_TABLE_+[.-.L284]".
2987 The goal here is to obtain the absolute address of the GOT,
2988 and it is strongly preferable from a performance point of
2989 view to avoid using a runtime relocation for this. There are
2990 cases where you have something like:
2992 .long _GLOBAL_OFFSET_TABLE_+[.-.L66]
2994 and here no correction would be required. Internally in the
2995 assembler we treat operands of this form as not being pcrel
2996 since the '.' is explicitly mentioned, and I wonder whether
2997 it would simplify matters to do it this way. Who knows. In
2998 earlier versions of the PIC patches, the pcrel_adjust field
2999 was used to store the correction, but since the expression is
3000 not pcrel, I felt it would be confusing to do it this way. */
3002 md_number_to_chars (buf
, val
, 4);
3005 case BFD_RELOC_32_GOT_PCREL
:
3006 * valP
= 0; /* Fully resolved at runtime. No addend. */
3007 md_number_to_chars (buf
, 0, 4);
3010 case BFD_RELOC_32_GOTOFF
:
3011 md_number_to_chars (buf
, val
, 4);
3021 if ((val
& ((1 << shift
) - 1)) != 0)
3022 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("misaligned offset"));
3026 val
= ((val
>> shift
)
3027 | ((long) -1 & ~ ((long) -1 >> shift
)));
3029 if (max
!= 0 && (val
< min
|| val
> max
))
3030 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("offset out of range"));
3032 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
3036 /* Called just before address relaxation. Return the length
3037 by which a fragment must grow to reach it's destination. */
3040 md_estimate_size_before_relax (fragP
, segment_type
)
3041 register fragS
*fragP
;
3042 register segT segment_type
;
3046 switch (fragP
->fr_subtype
)
3051 case C (UNCOND_JUMP
, UNDEF_DISP
):
3052 /* Used to be a branch to somewhere which was unknown. */
3053 if (!fragP
->fr_symbol
)
3055 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
3057 else if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
3059 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
3063 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNDEF_WORD_DISP
);
3067 case C (COND_JUMP
, UNDEF_DISP
):
3068 case C (COND_JUMP_DELAY
, UNDEF_DISP
):
3069 what
= GET_WHAT (fragP
->fr_subtype
);
3070 /* Used to be a branch to somewhere which was unknown. */
3071 if (fragP
->fr_symbol
3072 && S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
3074 /* Got a symbol and it's defined in this segment, become byte
3075 sized - maybe it will fix up. */
3076 fragP
->fr_subtype
= C (what
, COND8
);
3078 else if (fragP
->fr_symbol
)
3080 /* Its got a segment, but its not ours, so it will always be long. */
3081 fragP
->fr_subtype
= C (what
, UNDEF_WORD_DISP
);
3085 /* We know the abs value. */
3086 fragP
->fr_subtype
= C (what
, COND8
);
3090 case C (UNCOND_JUMP
, UNCOND12
):
3091 case C (UNCOND_JUMP
, UNCOND32
):
3092 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
3093 case C (COND_JUMP
, COND8
):
3094 case C (COND_JUMP
, COND12
):
3095 case C (COND_JUMP
, COND32
):
3096 case C (COND_JUMP
, UNDEF_WORD_DISP
):
3097 case C (COND_JUMP_DELAY
, COND8
):
3098 case C (COND_JUMP_DELAY
, COND12
):
3099 case C (COND_JUMP_DELAY
, COND32
):
3100 case C (COND_JUMP_DELAY
, UNDEF_WORD_DISP
):
3101 /* When relaxing a section for the second time, we don't need to
3102 do anything besides return the current size. */
3106 fragP
->fr_var
= md_relax_table
[fragP
->fr_subtype
].rlx_length
;
3107 return fragP
->fr_var
;
3110 /* Put number into target byte order. */
3113 md_number_to_chars (ptr
, use
, nbytes
)
3118 if (! target_big_endian
)
3119 number_to_chars_littleendian (ptr
, use
, nbytes
);
3121 number_to_chars_bigendian (ptr
, use
, nbytes
);
3125 md_pcrel_from_section (fixP
, sec
)
3129 if (fixP
->fx_addsy
!= (symbolS
*) NULL
3130 && (! S_IS_DEFINED (fixP
->fx_addsy
)
3131 || S_IS_EXTERN (fixP
->fx_addsy
)
3132 || S_IS_WEAK (fixP
->fx_addsy
)
3133 || S_GET_SEGMENT (fixP
->fx_addsy
) != sec
))
3135 /* The symbol is undefined (or is defined but not in this section,
3136 or we're not sure about it being the final definition). Let the
3137 linker figure it out. We need to adjust the subtraction of a
3138 symbol to the position of the relocated data, though. */
3139 return fixP
->fx_subsy
? fixP
->fx_where
+ fixP
->fx_frag
->fr_address
: 0;
3142 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
+ 2;
3148 tc_coff_sizemachdep (frag
)
3151 return md_relax_table
[frag
->fr_subtype
].rlx_length
;
3154 #endif /* OBJ_COFF */
3156 #ifndef BFD_ASSEMBLER
3159 /* Map BFD relocs to SH COFF relocs. */
3163 bfd_reloc_code_real_type bfd_reloc
;
3167 static const struct reloc_map coff_reloc_map
[] =
3169 { BFD_RELOC_32
, R_SH_IMM32
},
3170 { BFD_RELOC_16
, R_SH_IMM16
},
3171 { BFD_RELOC_8
, R_SH_IMM8
},
3172 { BFD_RELOC_SH_PCDISP8BY2
, R_SH_PCDISP8BY2
},
3173 { BFD_RELOC_SH_PCDISP12BY2
, R_SH_PCDISP
},
3174 { BFD_RELOC_SH_IMM4
, R_SH_IMM4
},
3175 { BFD_RELOC_SH_IMM4BY2
, R_SH_IMM4BY2
},
3176 { BFD_RELOC_SH_IMM4BY4
, R_SH_IMM4BY4
},
3177 { BFD_RELOC_SH_IMM8
, R_SH_IMM8
},
3178 { BFD_RELOC_SH_IMM8BY2
, R_SH_IMM8BY2
},
3179 { BFD_RELOC_SH_IMM8BY4
, R_SH_IMM8BY4
},
3180 { BFD_RELOC_SH_PCRELIMM8BY2
, R_SH_PCRELIMM8BY2
},
3181 { BFD_RELOC_SH_PCRELIMM8BY4
, R_SH_PCRELIMM8BY4
},
3182 { BFD_RELOC_8_PCREL
, R_SH_SWITCH8
},
3183 { BFD_RELOC_SH_SWITCH16
, R_SH_SWITCH16
},
3184 { BFD_RELOC_SH_SWITCH32
, R_SH_SWITCH32
},
3185 { BFD_RELOC_SH_USES
, R_SH_USES
},
3186 { BFD_RELOC_SH_COUNT
, R_SH_COUNT
},
3187 { BFD_RELOC_SH_ALIGN
, R_SH_ALIGN
},
3188 { BFD_RELOC_SH_CODE
, R_SH_CODE
},
3189 { BFD_RELOC_SH_DATA
, R_SH_DATA
},
3190 { BFD_RELOC_SH_LABEL
, R_SH_LABEL
},
3191 { BFD_RELOC_UNUSED
, 0 }
3194 /* Adjust a reloc for the SH. This is similar to the generic code,
3195 but does some minor tweaking. */
3198 sh_coff_reloc_mangle (seg
, fix
, intr
, paddr
)
3199 segment_info_type
*seg
;
3201 struct internal_reloc
*intr
;
3204 symbolS
*symbol_ptr
= fix
->fx_addsy
;
3207 intr
->r_vaddr
= paddr
+ fix
->fx_frag
->fr_address
+ fix
->fx_where
;
3209 if (! SWITCH_TABLE (fix
))
3211 const struct reloc_map
*rm
;
3213 for (rm
= coff_reloc_map
; rm
->bfd_reloc
!= BFD_RELOC_UNUSED
; rm
++)
3214 if (rm
->bfd_reloc
== (bfd_reloc_code_real_type
) fix
->fx_r_type
)
3216 if (rm
->bfd_reloc
== BFD_RELOC_UNUSED
)
3217 as_bad_where (fix
->fx_file
, fix
->fx_line
,
3218 _("Can not represent %s relocation in this object file format"),
3219 bfd_get_reloc_code_name (fix
->fx_r_type
));
3220 intr
->r_type
= rm
->sh_reloc
;
3227 if (fix
->fx_r_type
== BFD_RELOC_16
)
3228 intr
->r_type
= R_SH_SWITCH16
;
3229 else if (fix
->fx_r_type
== BFD_RELOC_8
)
3230 intr
->r_type
= R_SH_SWITCH8
;
3231 else if (fix
->fx_r_type
== BFD_RELOC_32
)
3232 intr
->r_type
= R_SH_SWITCH32
;
3236 /* For a switch reloc, we set r_offset to the difference between
3237 the reloc address and the subtrahend. When the linker is
3238 doing relaxing, it can use the determine the starting and
3239 ending points of the switch difference expression. */
3240 intr
->r_offset
= intr
->r_vaddr
- S_GET_VALUE (fix
->fx_subsy
);
3243 /* PC relative relocs are always against the current section. */
3244 if (symbol_ptr
== NULL
)
3246 switch (fix
->fx_r_type
)
3248 case BFD_RELOC_SH_PCRELIMM8BY2
:
3249 case BFD_RELOC_SH_PCRELIMM8BY4
:
3250 case BFD_RELOC_SH_PCDISP8BY2
:
3251 case BFD_RELOC_SH_PCDISP12BY2
:
3252 case BFD_RELOC_SH_USES
:
3253 symbol_ptr
= seg
->dot
;
3260 if (fix
->fx_r_type
== BFD_RELOC_SH_USES
)
3262 /* We can't store the offset in the object file, since this
3263 reloc does not take up any space, so we store it in r_offset.
3264 The fx_addnumber field was set in md_apply_fix3. */
3265 intr
->r_offset
= fix
->fx_addnumber
;
3267 else if (fix
->fx_r_type
== BFD_RELOC_SH_COUNT
)
3269 /* We can't store the count in the object file, since this reloc
3270 does not take up any space, so we store it in r_offset. The
3271 fx_offset field was set when the fixup was created in
3272 sh_coff_frob_file. */
3273 intr
->r_offset
= fix
->fx_offset
;
3274 /* This reloc is always absolute. */
3277 else if (fix
->fx_r_type
== BFD_RELOC_SH_ALIGN
)
3279 /* Store the alignment in the r_offset field. */
3280 intr
->r_offset
= fix
->fx_offset
;
3281 /* This reloc is always absolute. */
3284 else if (fix
->fx_r_type
== BFD_RELOC_SH_CODE
3285 || fix
->fx_r_type
== BFD_RELOC_SH_DATA
3286 || fix
->fx_r_type
== BFD_RELOC_SH_LABEL
)
3288 /* These relocs are always absolute. */
3292 /* Turn the segment of the symbol into an offset. */
3293 if (symbol_ptr
!= NULL
)
3295 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
3297 intr
->r_symndx
= dot
->sy_number
;
3299 intr
->r_symndx
= symbol_ptr
->sy_number
;
3302 intr
->r_symndx
= -1;
3305 #endif /* OBJ_COFF */
3306 #endif /* ! BFD_ASSEMBLER */
3308 #ifdef BFD_ASSEMBLER
3310 /* Create a reloc. */
3313 tc_gen_reloc (section
, fixp
)
3314 asection
*section ATTRIBUTE_UNUSED
;
3318 bfd_reloc_code_real_type r_type
;
3320 rel
= (arelent
*) xmalloc (sizeof (arelent
));
3321 rel
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
3322 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
3323 rel
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
3326 && S_GET_SEGMENT (fixp
->fx_subsy
) == absolute_section
)
3328 fixp
->fx_addnumber
-= S_GET_VALUE (fixp
->fx_subsy
);
3332 r_type
= fixp
->fx_r_type
;
3334 if (SWITCH_TABLE (fixp
))
3336 rel
->addend
= rel
->address
- S_GET_VALUE (fixp
->fx_subsy
);
3337 if (r_type
== BFD_RELOC_16
)
3338 r_type
= BFD_RELOC_SH_SWITCH16
;
3339 else if (r_type
== BFD_RELOC_8
)
3340 r_type
= BFD_RELOC_8_PCREL
;
3341 else if (r_type
== BFD_RELOC_32
)
3342 r_type
= BFD_RELOC_SH_SWITCH32
;
3346 else if (r_type
== BFD_RELOC_SH_USES
)
3347 rel
->addend
= fixp
->fx_addnumber
;
3348 else if (r_type
== BFD_RELOC_SH_COUNT
)
3349 rel
->addend
= fixp
->fx_offset
;
3350 else if (r_type
== BFD_RELOC_SH_ALIGN
)
3351 rel
->addend
= fixp
->fx_offset
;
3352 else if (r_type
== BFD_RELOC_VTABLE_INHERIT
3353 || r_type
== BFD_RELOC_VTABLE_ENTRY
)
3354 rel
->addend
= fixp
->fx_offset
;
3355 else if (r_type
== BFD_RELOC_SH_LOOP_START
3356 || r_type
== BFD_RELOC_SH_LOOP_END
)
3357 rel
->addend
= fixp
->fx_offset
;
3358 else if (r_type
== BFD_RELOC_SH_LABEL
&& fixp
->fx_pcrel
)
3361 rel
->address
= rel
->addend
= fixp
->fx_offset
;
3363 else if (fixp
->fx_pcrel
)
3364 rel
->addend
= fixp
->fx_addnumber
;
3365 else if (r_type
== BFD_RELOC_32
|| r_type
== BFD_RELOC_32_GOTOFF
)
3366 rel
->addend
= fixp
->fx_addnumber
;
3370 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, r_type
);
3371 if (rel
->howto
== NULL
|| fixp
->fx_subsy
)
3373 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
3374 _("Cannot represent relocation type %s"),
3375 bfd_get_reloc_code_name (r_type
));
3376 /* Set howto to a garbage value so that we can keep going. */
3377 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
3378 assert (rel
->howto
!= NULL
);
3385 inline static char *
3386 sh_end_of_match (cont
, what
)
3389 int len
= strlen (what
);
3391 if (strncasecmp (cont
, what
, strlen (what
)) == 0
3392 && ! is_part_of_name (cont
[len
]))
3399 sh_parse_name (name
, exprP
, nextcharP
)
3404 char *next
= input_line_pointer
;
3409 exprP
->X_op_symbol
= NULL
;
3411 if (strcmp (name
, GLOBAL_OFFSET_TABLE_NAME
) == 0)
3414 GOT_symbol
= symbol_find_or_make (name
);
3416 exprP
->X_add_symbol
= GOT_symbol
;
3418 /* If we have an absolute symbol or a reg, then we know its
3420 segment
= S_GET_SEGMENT (exprP
->X_add_symbol
);
3421 if (segment
== absolute_section
)
3423 exprP
->X_op
= O_constant
;
3424 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
3425 exprP
->X_add_symbol
= NULL
;
3427 else if (segment
== reg_section
)
3429 exprP
->X_op
= O_register
;
3430 exprP
->X_add_number
= S_GET_VALUE (exprP
->X_add_symbol
);
3431 exprP
->X_add_symbol
= NULL
;
3435 exprP
->X_op
= O_symbol
;
3436 exprP
->X_add_number
= 0;
3442 exprP
->X_add_symbol
= symbol_find_or_make (name
);
3444 if (*nextcharP
!= '@')
3446 else if ((next_end
= sh_end_of_match (next
+ 1, "GOTOFF")))
3447 reloc_type
= BFD_RELOC_32_GOTOFF
;
3448 else if ((next_end
= sh_end_of_match (next
+ 1, "GOT")))
3449 reloc_type
= BFD_RELOC_32_GOT_PCREL
;
3450 else if ((next_end
= sh_end_of_match (next
+ 1, "PLT")))
3451 reloc_type
= BFD_RELOC_32_PLT_PCREL
;
3455 *input_line_pointer
= *nextcharP
;
3456 input_line_pointer
= next_end
;
3457 *nextcharP
= *input_line_pointer
;
3458 *input_line_pointer
= '\0';
3460 exprP
->X_op
= O_PIC_reloc
;
3461 exprP
->X_add_number
= 0;
3462 exprP
->X_md
= reloc_type
;
3467 #endif /* BFD_ASSEMBLER */