1 /* tc-sh.c -- Assemble code for the Hitachi Super-H
3 Copyright (C) 1993, 94, 95, 1996 Free Software Foundation.
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. */
23 Written By Steve Chamberlain
32 #include "opcodes/sh-opc.h"
34 const char comment_chars
[] = "!";
35 const char line_separator_chars
[] = ";";
36 const char line_comment_chars
[] = "!#";
38 static void s_uses
PARAMS ((int));
40 /* This table describes all the machine specific pseudo-ops the assembler
41 has to support. The fields are:
42 pseudo-op name without dot
43 function to call to execute this pseudo-op
44 Integer arg to pass to the function
48 void s_align_bytes ();
57 target_big_endian
= 0;
60 const pseudo_typeS md_pseudo_table
[] =
64 {"form", listing_psize
, 0},
65 {"little", little
, 0},
66 {"heading", listing_title
, 0},
67 {"import", s_ignore
, 0},
68 {"page", listing_eject
, 0},
69 {"program", s_ignore
, 0},
74 /*int md_reloc_size; */
76 int sh_relax
; /* set if -relax seen */
78 const char EXP_CHARS
[] = "eE";
80 /* Chars that mean this number is a floating point constant */
83 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
85 #define C(a,b) ENCODE_RELAX(a,b)
87 #define JREG 14 /* Register used as a temp when relaxing */
88 #define ENCODE_RELAX(what,length) (((what) << 4) + (length))
89 #define GET_WHAT(x) ((x>>4))
91 /* These are the two types of relaxable instrction */
101 #define UNDEF_WORD_DISP 4
107 /* Branch displacements are from the address of the branch plus
108 four, thus all minimum and maximum values have 4 added to them. */
111 #define COND8_LENGTH 2
113 /* There is one extra instruction before the branch, so we must add
114 two more bytes to account for it. */
115 #define COND12_F 4100
116 #define COND12_M -4090
117 #define COND12_LENGTH 6
119 /* ??? The minimum and maximum values are wrong, but this does not matter
120 since this relocation type is not supported yet. */
121 #define COND32_F (1<<30)
122 #define COND32_M -(1<<30)
123 #define COND32_LENGTH 14
125 #define UNCOND12_F 4098
126 #define UNCOND12_M -4092
127 #define UNCOND12_LENGTH 2
129 /* ??? The minimum and maximum values are wrong, but this does not matter
130 since this relocation type is not supported yet. */
131 #define UNCOND32_F (1<<30)
132 #define UNCOND32_M -(1<<30)
133 #define UNCOND32_LENGTH 14
135 const relax_typeS md_relax_table
[C (END
, 0)] = {
136 { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 },
137 { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 },
140 /* C (COND_JUMP, COND8) */
141 { COND8_F
, COND8_M
, COND8_LENGTH
, C (COND_JUMP
, COND12
) },
142 /* C (COND_JUMP, COND12) */
143 { COND12_F
, COND12_M
, COND12_LENGTH
, C (COND_JUMP
, COND32
), },
144 /* C (COND_JUMP, COND32) */
145 { COND32_F
, COND32_M
, COND32_LENGTH
, 0, },
146 { 0 }, { 0 }, { 0 }, { 0 },
147 { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 },
150 /* C (UNCOND_JUMP, UNCOND12) */
151 { UNCOND12_F
, UNCOND12_M
, UNCOND12_LENGTH
, C (UNCOND_JUMP
, UNCOND32
), },
152 /* C (UNCOND_JUMP, UNCOND32) */
153 { UNCOND32_F
, UNCOND32_M
, UNCOND32_LENGTH
, 0, },
154 { 0 }, { 0 }, { 0 }, { 0 }, { 0 },
155 { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 }, { 0 },
158 static struct hash_control
*opcode_hash_control
; /* Opcode mnemonics */
161 This function is called once, at assembler startup time. This should
162 set up all the tables, etc that the MD part of the assembler needs
168 sh_opcode_info
*opcode
;
169 char *prev_name
= "";
172 target_big_endian
= 1;
174 opcode_hash_control
= hash_new ();
176 /* Insert unique names into hash table */
177 for (opcode
= sh_table
; opcode
->name
; opcode
++)
179 if (strcmp (prev_name
, opcode
->name
))
181 prev_name
= opcode
->name
;
182 hash_insert (opcode_hash_control
, opcode
->name
, (char *) opcode
);
186 /* Make all the opcodes with the same name point to the same
188 opcode
->name
= prev_name
;
197 static expressionS immediate
; /* absolute expression */
207 /* try and parse a reg name, returns number of chars consumed */
209 parse_reg (src
, mode
, reg
)
214 /* We use !isalnum for the next character after the register name, to
215 make sure that we won't accidentally recognize a symbol name such as
216 'sram' as being a reference to the register 'sr'. */
220 if (src
[1] >= '0' && src
[1] <= '7' && strncmp(&src
[2], "_bank", 5) == 0
221 && ! isalnum (src
[7]))
224 *reg
= (src
[1] - '0');
233 if (src
[2] >= '0' && src
[2] <= '5' && ! isalnum (src
[3]))
236 *reg
= 10 + src
[2] - '0';
240 if (src
[1] >= '0' && src
[1] <= '9' && ! isalnum (src
[2]))
243 *reg
= (src
[1] - '0');
248 if (src
[0] == 's' && src
[1] == 's' && src
[2] == 'r' && ! isalnum (src
[3]))
254 if (src
[0] == 's' && src
[1] == 'p' && src
[2] == 'c' && ! isalnum (src
[3]))
260 if (src
[0] == 's' && src
[1] == 'r' && ! isalnum (src
[2]))
266 if (src
[0] == 's' && src
[1] == 'p' && ! isalnum (src
[2]))
273 if (src
[0] == 'p' && src
[1] == 'r' && ! isalnum (src
[2]))
278 if (src
[0] == 'p' && src
[1] == 'c' && ! isalnum (src
[2]))
283 if (src
[0] == 'g' && src
[1] == 'b' && src
[2] == 'r' && ! isalnum (src
[3]))
288 if (src
[0] == 'v' && src
[1] == 'b' && src
[2] == 'r' && ! isalnum (src
[3]))
294 if (src
[0] == 'm' && src
[1] == 'a' && src
[2] == 'c' && ! isalnum (src
[4]))
307 if (src
[0] == 'f' && src
[1] == 'r')
311 if (src
[3] >= '0' && src
[3] <= '5' && ! isalnum (src
[4]))
314 *reg
= 10 + src
[3] - '0';
318 if (src
[2] >= '0' && src
[2] <= '9' && ! isalnum (src
[3]))
321 *reg
= (src
[2] - '0');
325 if (src
[0] == 'f' && src
[1] == 'p' && src
[2] == 'u' && src
[3] == 'l'
326 && ! isalnum (src
[4]))
332 if (src
[0] == 'f' && src
[1] == 'p' && src
[2] == 's' && src
[3] == 'c'
333 && src
[4] == 'r' && ! isalnum (src
[5]))
342 static symbolS
*dot()
346 /* JF: '.' is pseudo symbol with value of current location
347 in current segment. */
348 fake
= FAKE_LABEL_NAME
;
349 return symbol_new (fake
,
351 (valueT
) frag_now_fix (),
365 save
= input_line_pointer
;
366 input_line_pointer
= s
;
367 expression (&immediate
);
368 if (immediate
.X_op
== O_absent
)
369 as_bad ("missing operand");
370 new = input_line_pointer
;
371 input_line_pointer
= save
;
376 /* The many forms of operand:
379 @Rn Register indirect
392 pr, gbr, vbr, macl, mach
407 /* Must be predecrement */
410 len
= parse_reg (src
, &mode
, &(op
->reg
));
412 as_bad ("illegal register after @-");
417 else if (src
[0] == '(')
419 /* Could be @(disp, rn), @(disp, gbr), @(disp, pc), @(r0, gbr) or
422 len
= parse_reg (src
, &mode
, &(op
->reg
));
423 if (len
&& mode
== A_REG_N
)
428 as_bad ("must be @(r0,...)");
432 /* Now can be rn or gbr */
433 len
= parse_reg (src
, &mode
, &(op
->reg
));
438 else if (mode
== A_REG_N
)
440 op
->type
= A_IND_R0_REG_N
;
444 as_bad ("syntax error in @(r0,...)");
449 /* Must be an @(disp,.. thing) */
450 src
= parse_exp (src
);
453 /* Now can be rn, gbr or pc */
454 len
= parse_reg (src
, &mode
, &op
->reg
);
459 op
->type
= A_DISP_REG_N
;
461 else if (mode
== A_GBR
)
463 op
->type
= A_DISP_GBR
;
465 else if (mode
== A_DISP_PC
)
467 /* Turn a plain @(4,pc) into @(.+4,pc) */
468 if (immediate
.X_op
== O_constant
) {
469 immediate
.X_add_symbol
= dot();
470 immediate
.X_op
= O_symbol
;
472 op
->type
= A_DISP_PC
;
476 as_bad ("syntax error in @(disp,[Rn, gbr, pc])");
481 as_bad ("syntax error in @(disp,[Rn, gbr, pc])");
486 as_bad ("expecting )");
492 src
+= parse_reg (src
, &mode
, &(op
->reg
));
495 as_bad ("illegal register after @");
511 get_operand (ptr
, op
)
522 *ptr
= parse_exp (src
);
527 else if (src
[0] == '@')
529 *ptr
= parse_at (src
, op
);
532 len
= parse_reg (src
, &mode
, &(op
->reg
));
541 /* Not a reg, the only thing left is a displacement */
542 *ptr
= parse_exp (src
);
543 op
->type
= A_DISP_PC
;
550 get_operands (info
, args
, operand
)
551 sh_opcode_info
*info
;
553 sh_operand_info
*operand
;
561 get_operand (&ptr
, operand
+ 0);
568 get_operand (&ptr
, operand
+ 1);
575 get_operand (&ptr
, operand
+ 2);
597 /* Passed a pointer to a list of opcodes which use different
598 addressing modes, return the opcode which matches the opcodes
604 get_specific (opcode
, operands
)
605 sh_opcode_info
*opcode
;
606 sh_operand_info
*operands
;
608 sh_opcode_info
*this_try
= opcode
;
609 char *name
= opcode
->name
;
614 if (this_try
->name
!= name
)
616 /* We've looked so far down the table that we've run out of
617 opcodes with the same name */
620 /* look at both operands needed by the opcodes and provided by
621 the user - since an arg test will often fail on the same arg
622 again and again, we'll try and test the last failing arg the
623 first on each opcode try */
625 for (n
= 0; this_try
->arg
[n
]; n
++)
627 sh_operand_info
*user
= operands
+ n
;
628 sh_arg_type arg
= this_try
->arg
[n
];
639 if (user
->type
!= arg
)
643 /* opcode needs r0 */
644 if (user
->type
!= A_REG_N
|| user
->reg
!= 0)
648 if (user
->type
!= A_R0_GBR
|| user
->reg
!= 0)
652 if (user
->type
!= F_REG_N
|| user
->reg
!= 0)
665 /* Opcode needs rn */
666 if (user
->type
!= arg
)
675 if (user
->type
!= arg
)
680 if (user
->type
!= arg
)
691 /* Opcode needs rn */
692 if (user
->type
!= arg
- A_REG_M
+ A_REG_N
)
700 /* Opcode needs rn */
701 if (user
->type
!= arg
- F_REG_M
+ F_REG_N
)
707 printf ("unhandled %d\n", arg
);
719 check (operand
, low
, high
)
720 expressionS
*operand
;
724 if (operand
->X_op
!= O_constant
725 || operand
->X_add_number
< low
726 || operand
->X_add_number
> high
)
728 as_bad ("operand must be absolute in range %d..%d", low
, high
);
730 return operand
->X_add_number
;
735 insert (where
, how
, pcrel
)
740 fix_new_exp (frag_now
,
741 where
- frag_now
->fr_literal
,
750 sh_opcode_info
*opcode
;
752 int high_byte
= target_big_endian
? 0 : 1;
755 if (opcode
->arg
[0] == A_BDISP8
)
757 p
= frag_var (rs_machine_dependent
,
758 md_relax_table
[C (COND_JUMP
, COND32
)].rlx_length
,
759 md_relax_table
[C (COND_JUMP
, COND8
)].rlx_length
,
761 immediate
.X_add_symbol
,
762 immediate
.X_add_number
,
764 p
[high_byte
] = (opcode
->nibbles
[0] << 4) | (opcode
->nibbles
[1]);
766 else if (opcode
->arg
[0] == A_BDISP12
)
768 p
= frag_var (rs_machine_dependent
,
769 md_relax_table
[C (UNCOND_JUMP
, UNCOND32
)].rlx_length
,
770 md_relax_table
[C (UNCOND_JUMP
, UNCOND12
)].rlx_length
,
772 immediate
.X_add_symbol
,
773 immediate
.X_add_number
,
775 p
[high_byte
] = (opcode
->nibbles
[0] << 4);
780 /* Now we know what sort of opcodes it is, lets build the bytes -
783 build_Mytes (opcode
, operand
)
784 sh_opcode_info
*opcode
;
785 sh_operand_info
*operand
;
790 char *output
= frag_more (2);
791 int low_byte
= target_big_endian
? 1 : 0;
797 for (index
= 0; index
< 4; index
++)
799 sh_nibble_type i
= opcode
->nibbles
[index
];
815 nbuf
[index
] = reg_b
| 0x08;
818 insert (output
+ low_byte
, R_SH_IMM4
, 0);
821 insert (output
+ low_byte
, R_SH_IMM4BY4
, 0);
824 insert (output
+ low_byte
, R_SH_IMM4BY2
, 0);
827 insert (output
+ low_byte
, R_SH_IMM4
, 0);
830 insert (output
+ low_byte
, R_SH_IMM8BY4
, 0);
833 insert (output
+ low_byte
, R_SH_IMM8BY2
, 0);
836 insert (output
+ low_byte
, R_SH_IMM8
, 0);
839 insert (output
, R_SH_PCRELIMM8BY4
, 1);
842 insert (output
, R_SH_PCRELIMM8BY2
, 1);
845 printf ("failed for %d\n", i
);
849 if (! target_big_endian
) {
850 output
[1] = (nbuf
[0] << 4) | (nbuf
[1]);
851 output
[0] = (nbuf
[2] << 4) | (nbuf
[3]);
854 output
[0] = (nbuf
[0] << 4) | (nbuf
[1]);
855 output
[1] = (nbuf
[2] << 4) | (nbuf
[3]);
859 /* This is the guts of the machine-dependent assembler. STR points to a
860 machine dependent instruction. This function is supposed to emit
861 the frags/bytes it assembles to.
868 unsigned char *op_start
;
869 unsigned char *op_end
;
870 sh_operand_info operand
[3];
871 sh_opcode_info
*opcode
;
874 /* Drop leading whitespace */
878 /* find the op code end */
879 for (op_start
= op_end
= (unsigned char *) (str
);
882 && !is_end_of_line
[*op_end
] && *op_end
!= ' ';
885 name
[nlen
] = op_start
[nlen
];
892 as_bad ("can't find opcode ");
895 opcode
= (sh_opcode_info
*) hash_find (opcode_hash_control
, name
);
899 as_bad ("unknown opcode");
903 if (opcode
->arg
[0] == A_BDISP12
904 || opcode
->arg
[0] == A_BDISP8
)
906 parse_exp (op_end
+ 1);
907 build_relax (opcode
);
911 if (opcode
->arg
[0] != A_END
)
913 get_operands (opcode
, op_end
, operand
);
915 opcode
= get_specific (opcode
, operand
);
919 /* Couldn't find an opcode which matched the operands */
920 char *where
= frag_more (2);
924 as_bad ("invalid operands for opcode");
928 build_Mytes (opcode
, operand
);
934 DEFUN (tc_crawl_symbol_chain
, (headers
),
935 object_headers
* headers
)
937 printf ("call to tc_crawl_symbol_chain \n");
941 DEFUN (md_undefined_symbol
, (name
),
948 DEFUN (tc_headers_hook
, (headers
),
949 object_headers
* headers
)
951 printf ("call to tc_headers_hook \n");
954 /* Various routines to kill one day */
955 /* Equal to MAX_PRECISION in atof-ieee.c */
956 #define MAX_LITTLENUMS 6
958 /* Turn a string in input_line_pointer into a floating point constant of type
959 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
960 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
963 md_atof (type
, litP
, sizeP
)
969 LITTLENUM_TYPE words
[4];
985 return "bad call to md_atof";
988 t
= atof_ieee (input_line_pointer
, type
, words
);
990 input_line_pointer
= t
;
994 if (! target_big_endian
)
996 for (i
= prec
- 1; i
>= 0; i
--)
998 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
1004 for (i
= 0; i
< prec
; i
++)
1006 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
1014 /* Handle the .uses pseudo-op. This pseudo-op is used just before a
1015 call instruction. It refers to a label of the instruction which
1016 loads the register which the call uses. We use it to generate a
1017 special reloc for the linker. */
1026 as_warn (".uses pseudo-op seen when not relaxing");
1030 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
1032 as_bad ("bad .uses format");
1033 ignore_rest_of_line ();
1037 fix_new_exp (frag_now
, frag_now_fix (), 2, &ex
, 1, R_SH_USES
);
1039 demand_empty_rest_of_line ();
1042 CONST
char *md_shortopts
= "";
1043 struct option md_longopts
[] = {
1045 #define OPTION_RELAX (OPTION_MD_BASE)
1046 #define OPTION_LITTLE (OPTION_MD_BASE+1)
1048 {"relax", no_argument
, NULL
, OPTION_RELAX
},
1049 {"little", no_argument
, NULL
, OPTION_LITTLE
},
1050 {NULL
, no_argument
, NULL
, 0}
1052 size_t md_longopts_size
= sizeof(md_longopts
);
1055 md_parse_option (c
, arg
)
1066 target_big_endian
= 0;
1077 md_show_usage (stream
)
1082 -little generate little endian code\n\
1083 -relax alter jump instructions for long displacements\n");
1086 int md_short_jump_size
;
1089 tc_Nout_fix_to_chars ()
1091 printf ("call to tc_Nout_fix_to_chars \n");
1096 md_create_short_jump (ptr
, from_Nddr
, to_Nddr
, frag
, to_symbol
)
1103 as_fatal ("failed sanity check.");
1107 md_create_long_jump (ptr
, from_Nddr
, to_Nddr
, frag
, to_symbol
)
1109 addressT from_Nddr
, to_Nddr
;
1113 as_fatal ("failed sanity check.");
1116 /* This is function is called after the symbol table has been
1117 completed, but before md_convert_frag has been called. If we have
1118 seen any .uses pseudo-ops, they point to an instruction which loads
1119 a register with the address of a function. We look through the
1120 fixups to find where the function address is being loaded from. We
1121 then generate a COUNT reloc giving the number of times that
1122 function address is referred to. The linker uses this information
1123 when doing relaxing, to decide when it can eliminate the stored
1124 function address entirely. */
1127 sh_coff_frob_file ()
1134 for (iseg
= SEG_E0
; iseg
< SEG_UNKNOWN
; iseg
++)
1138 for (fix
= segment_info
[iseg
].fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
1146 if (fix
->fx_r_type
!= R_SH_USES
)
1149 /* The R_SH_USES reloc should refer to a defined local
1150 symbol in the same section. */
1151 sym
= fix
->fx_addsy
;
1153 || fix
->fx_subsy
!= NULL
1154 || fix
->fx_addnumber
!= 0
1155 || S_GET_SEGMENT (sym
) != iseg
1156 || S_GET_STORAGE_CLASS (sym
) == C_EXT
)
1158 as_warn_where (fix
->fx_file
, fix
->fx_line
,
1159 ".uses does not refer to a local symbol in the same section");
1163 /* Look through the fixups again, this time looking for one
1164 at the same location as sym. */
1165 val
= S_GET_VALUE (sym
);
1166 for (fscan
= segment_info
[iseg
].fix_root
;
1168 fscan
= fscan
->fx_next
)
1169 if (val
== fscan
->fx_frag
->fr_address
+ fscan
->fx_where
)
1173 as_warn_where (fix
->fx_file
, fix
->fx_line
,
1174 "can't find fixup pointed to by .uses");
1178 if (fscan
->fx_tcbit
)
1180 /* We've already done this one. */
1184 /* fscan should also be a fixup to a local symbol in the same
1186 sym
= fscan
->fx_addsy
;
1188 || fscan
->fx_subsy
!= NULL
1189 || fscan
->fx_addnumber
!= 0
1190 || S_GET_SEGMENT (sym
) != iseg
1191 || S_GET_STORAGE_CLASS (sym
) == C_EXT
)
1193 as_warn_where (fix
->fx_file
, fix
->fx_line
,
1194 ".uses target does not refer to a local symbol in the same section");
1198 /* Now we look through all the fixups of all the sections,
1199 counting the number of times we find a reference to sym. */
1201 for (iscan
= SEG_E0
; iscan
< SEG_UNKNOWN
; iscan
++)
1203 for (fscan
= segment_info
[iscan
].fix_root
;
1205 fscan
= fscan
->fx_next
)
1207 if (fscan
->fx_addsy
== sym
)
1210 fscan
->fx_tcbit
= 1;
1218 /* Generate a R_SH_COUNT fixup at the location of sym. We
1219 have already adjusted the value of sym to include the
1220 fragment address, so we undo that adjustment here. */
1221 subseg_change (iseg
, 0);
1222 fix_new (sym
->sy_frag
, S_GET_VALUE (sym
) - sym
->sy_frag
->fr_address
,
1223 4, &abs_symbol
, count
, 0, R_SH_COUNT
);
1228 /* Called after relaxing. Set the correct sizes of the fragments, and
1229 create relocs so that md_apply_fix will fill in the correct values. */
1232 md_convert_frag (headers
, seg
, fragP
)
1233 object_headers
*headers
;
1239 switch (fragP
->fr_subtype
)
1241 case C (COND_JUMP
, COND8
):
1242 subseg_change (seg
, 0);
1243 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
1244 1, R_SH_PCDISP8BY2
);
1249 case C (UNCOND_JUMP
, UNCOND12
):
1250 subseg_change (seg
, 0);
1251 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
1257 case C (UNCOND_JUMP
, UNCOND32
):
1258 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
1259 if (fragP
->fr_symbol
== NULL
)
1260 as_bad ("at 0x%lx, displacement overflows 12-bit field",
1261 (unsigned long) fragP
->fr_address
);
1263 as_bad ("at 0x%lx, displacement to %sdefined symbol %s overflows 12-bit field",
1264 (unsigned long) fragP
->fr_address
,
1265 S_IS_DEFINED (fragP
->fr_symbol
) ? "" : "un",
1266 S_GET_NAME (fragP
->fr_symbol
));
1268 #if 0 /* This code works, but generates poor code and the compiler
1269 should never produce a sequence that requires it to be used. */
1271 /* A jump wont fit in 12 bits, make code which looks like
1277 int t
= buffer
[0] & 0x10;
1279 buffer
[highbyte
] = 0xa0; /* branch over move and disp */
1280 buffer
[lowbyte
] = 3;
1281 buffer
[highbyte
+2] = 0xd0 | JREG
; /* Build mov insn */
1282 buffer
[lowbyte
+2] = 0x00;
1284 buffer
[highbyte
+4] = 0; /* space for 32 bit jump disp */
1285 buffer
[lowbyte
+4] = 0;
1286 buffer
[highbyte
+6] = 0;
1287 buffer
[lowbyte
+6] = 0;
1289 buffer
[highbyte
+8] = 0x40 | JREG
; /* Build jmp @JREG */
1290 buffer
[lowbyte
+8] = t
? 0xb : 0x2b;
1292 buffer
[highbyte
+10] = 0x20; /* build nop */
1293 buffer
[lowbyte
+10] = 0x0b;
1295 /* Make reloc for the long disp */
1303 fragP
->fr_fix
+= UNCOND32_LENGTH
;
1310 case C (COND_JUMP
, COND12
):
1311 /* A bcond won't fit, so turn it into a b!cond; bra disp; nop */
1313 unsigned char *buffer
=
1314 (unsigned char *) (fragP
->fr_fix
+ fragP
->fr_literal
);
1315 int highbyte
= target_big_endian
? 0 : 1;
1316 int lowbyte
= target_big_endian
? 1 : 0;
1318 /* Toggle the true/false bit of the bcond. */
1319 buffer
[highbyte
] ^= 0x2;
1321 /* Build a relocation to six bytes farther on. */
1322 subseg_change (seg
, 0);
1323 fix_new (fragP
, fragP
->fr_fix
, 2,
1324 segment_info
[seg
].dot
,
1325 fragP
->fr_address
+ fragP
->fr_fix
+ 6,
1326 1, R_SH_PCDISP8BY2
);
1328 /* Set up a jump instruction. */
1329 buffer
[highbyte
+ 2] = 0xa0;
1330 buffer
[lowbyte
+ 2] = 0;
1331 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
1332 fragP
->fr_offset
, 1, R_SH_PCDISP
);
1334 /* Fill in a NOP instruction. */
1335 buffer
[highbyte
+ 4] = 0x0;
1336 buffer
[lowbyte
+ 4] = 0x9;
1344 case C (COND_JUMP
, COND32
):
1345 case C (COND_JUMP
, UNDEF_WORD_DISP
):
1346 if (fragP
->fr_symbol
== NULL
)
1347 as_bad ("at %0xlx, displacement overflows 8-bit field",
1348 (unsigned long) fragP
->fr_address
);
1350 as_bad ("at 0x%lx, displacement to %sdefined symbol %s overflows 8-bit field ",
1351 (unsigned long) fragP
->fr_address
,
1352 S_IS_DEFINED (fragP
->fr_symbol
) ? "" : "un",
1353 S_GET_NAME (fragP
->fr_symbol
));
1355 #if 0 /* This code works, but generates poor code, and the compiler
1356 should never produce a sequence that requires it to be used. */
1358 /* A bcond won't fit and it won't go into a 12 bit
1359 displacement either, the code sequence looks like:
1368 buffer
[0] ^= 0x2; /* Toggle T/F bit */
1370 buffer
[1] = 5; /* branch over mov, jump, nop and ptr */
1371 buffer
[2] = 0xd0 | JREG
; /* Build mov insn */
1373 buffer
[4] = 0x40 | JREG
; /* Build jmp @JREG */
1375 buffer
[6] = 0x20; /* build nop */
1377 buffer
[8] = 0; /* space for 32 bit jump disp */
1383 /* Make reloc for the long disp */
1391 fragP
->fr_fix
+= COND32_LENGTH
;
1402 if (donerelax
&& !sh_relax
)
1403 as_warn ("Offset doesn't fit at 0x%lx, trying to get to %s+0x%lx",
1404 (unsigned long) fragP
->fr_address
,
1405 fragP
->fr_symbol
? S_GET_NAME(fragP
->fr_symbol
): "",
1406 (unsigned long) fragP
->fr_offset
);
1410 DEFUN (md_section_align
, (seg
, size
),
1414 return ((size
+ (1 << section_alignment
[(int) seg
]) - 1)
1415 & (-1 << section_alignment
[(int) seg
]));
1419 /* When relaxing, we need to output a reloc for any .align directive
1420 that requests alignment to a four byte boundary or larger. */
1423 sh_handle_align (frag
)
1427 && frag
->fr_type
== rs_align
1428 && frag
->fr_address
+ frag
->fr_fix
> 0
1429 && frag
->fr_offset
> 1
1430 && now_seg
!= bss_section
)
1431 fix_new (frag
, frag
->fr_fix
, 2, &abs_symbol
, frag
->fr_offset
, 0,
1435 /* This macro decides whether a particular reloc is an entry in a
1436 switch table. It is used when relaxing, because the linker needs
1437 to know about all such entries so that it can adjust them if
1440 #define SWITCH_TABLE(fix) \
1441 ((fix)->fx_addsy != NULL \
1442 && (fix)->fx_subsy != NULL \
1443 && S_GET_SEGMENT ((fix)->fx_addsy) == text_section \
1444 && S_GET_SEGMENT ((fix)->fx_subsy) == text_section \
1445 && ((fix)->fx_r_type == R_SH_IMM32 \
1446 || (fix)->fx_r_type == R_SH_IMM16 \
1447 || ((fix)->fx_r_type == 0 \
1448 && ((fix)->fx_size == 2 \
1449 || (fix)->fx_size == 4))))
1451 /* See whether we need to force a relocation into the output file.
1452 This is used to force out switch and PC relative relocations when
1456 sh_force_relocation (fix
)
1462 return (fix
->fx_pcrel
1463 || SWITCH_TABLE (fix
)
1464 || fix
->fx_r_type
== R_SH_COUNT
1465 || fix
->fx_r_type
== R_SH_ALIGN
);
1468 /* Apply a fixup to the object file. */
1471 md_apply_fix (fixP
, val
)
1475 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
1476 int lowbyte
= target_big_endian
? 1 : 0;
1477 int highbyte
= target_big_endian
? 0 : 1;
1479 if (fixP
->fx_r_type
== 0)
1481 if (fixP
->fx_size
== 2)
1482 fixP
->fx_r_type
= R_SH_IMM16
;
1483 else if (fixP
->fx_size
== 4)
1484 fixP
->fx_r_type
= R_SH_IMM32
;
1485 else if (fixP
->fx_size
== 1)
1486 fixP
->fx_r_type
= R_SH_IMM8
;
1491 switch (fixP
->fx_r_type
)
1494 *buf
= (*buf
& 0xf0) | (val
& 0xf);
1498 *buf
= (*buf
& 0xf0) | ((val
>> 1) & 0xf);
1502 *buf
= (*buf
& 0xf0) | ((val
>> 2) & 0xf);
1517 case R_SH_PCRELIMM8BY4
:
1518 /* The lower two bits of the PC are cleared before the
1519 displacement is added in. We can assume that the destination
1520 is on a 4 byte bounday. If this instruction is also on a 4
1521 byte boundary, then we want
1523 and target - here is a multiple of 4.
1524 Otherwise, we are on a 2 byte boundary, and we want
1525 (target - (here - 2)) / 4
1526 and target - here is not a multiple of 4. Computing
1527 (target - (here - 2)) / 4 == (target - here + 2) / 4
1528 works for both cases, since in the first case the addition of
1529 2 will be removed by the division. target - here is in the
1531 val
= (val
+ 2) / 4;
1533 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, "pcrel too far");
1537 case R_SH_PCRELIMM8BY2
:
1540 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, "pcrel too far");
1544 case R_SH_PCDISP8BY2
:
1546 if (val
< -0x80 || val
> 0x7f)
1547 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, "pcrel too far");
1553 if (val
< -0x800 || val
>= 0x7ff)
1554 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, "pcrel too far");
1555 buf
[lowbyte
] = val
& 0xff;
1556 buf
[highbyte
] |= (val
>> 8) & 0xf;
1560 if (! target_big_endian
)
1577 if (! target_big_endian
)
1590 /* Pass the value into sh_coff_reloc_mangle. */
1591 fixP
->fx_addnumber
= val
;
1596 /* Nothing to do here. */
1604 int md_long_jump_size
;
1606 /* Called just before address relaxation. Return the length
1607 by which a fragment must grow to reach it's destination. */
1610 md_estimate_size_before_relax (fragP
, segment_type
)
1611 register fragS
*fragP
;
1612 register segT segment_type
;
1614 switch (fragP
->fr_subtype
)
1616 case C (UNCOND_JUMP
, UNDEF_DISP
):
1617 /* used to be a branch to somewhere which was unknown */
1618 if (!fragP
->fr_symbol
)
1620 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
1621 fragP
->fr_var
= md_relax_table
[C (UNCOND_JUMP
, UNCOND12
)].rlx_length
;
1623 else if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
1625 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
1626 fragP
->fr_var
= md_relax_table
[C (UNCOND_JUMP
, UNCOND12
)].rlx_length
;
1630 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNDEF_WORD_DISP
);
1631 fragP
->fr_var
= md_relax_table
[C (UNCOND_JUMP
, UNCOND32
)].rlx_length
;
1632 return md_relax_table
[C (UNCOND_JUMP
, UNCOND32
)].rlx_length
;
1638 case C (COND_JUMP
, UNDEF_DISP
):
1639 /* used to be a branch to somewhere which was unknown */
1640 if (fragP
->fr_symbol
1641 && S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
1643 /* Got a symbol and it's defined in this segment, become byte
1644 sized - maybe it will fix up */
1645 fragP
->fr_subtype
= C (COND_JUMP
, COND8
);
1646 fragP
->fr_var
= md_relax_table
[C (COND_JUMP
, COND8
)].rlx_length
;
1648 else if (fragP
->fr_symbol
)
1650 /* Its got a segment, but its not ours, so it will always be long */
1651 fragP
->fr_subtype
= C (COND_JUMP
, UNDEF_WORD_DISP
);
1652 fragP
->fr_var
= md_relax_table
[C (COND_JUMP
, COND32
)].rlx_length
;
1653 return md_relax_table
[C (COND_JUMP
, COND32
)].rlx_length
;
1657 /* We know the abs value */
1658 fragP
->fr_subtype
= C (COND_JUMP
, COND8
);
1659 fragP
->fr_var
= md_relax_table
[C (COND_JUMP
, COND8
)].rlx_length
;
1664 return fragP
->fr_var
;
1667 /* Put number into target byte order */
1670 md_number_to_chars (ptr
, use
, nbytes
)
1675 if (! target_big_endian
)
1676 number_to_chars_littleendian (ptr
, use
, nbytes
);
1678 number_to_chars_bigendian (ptr
, use
, nbytes
);
1682 md_pcrel_from (fixP
)
1685 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
+ 2;
1689 tc_coff_sizemachdep (frag
)
1692 return md_relax_table
[frag
->fr_subtype
].rlx_length
;
1695 /* When we align the .text section, insert the correct NOP pattern. */
1698 sh_do_align (n
, fill
, len
)
1703 if ((fill
== NULL
|| (*fill
== 0 && len
== 1))
1704 && (now_seg
== text_section
1705 #ifdef BFD_ASSEMBLER
1706 || (now_seg
->flags
& SEC_CODE
) != 0
1708 || strcmp (obj_segment_name (now_seg
), ".init") == 0))
1710 static const unsigned char big_nop_pattern
[] = { 0x00, 0x09 };
1711 static const unsigned char little_nop_pattern
[] = { 0x09, 0x00 };
1713 /* First align to a 2 byte boundary, in case there is an odd
1716 if (target_big_endian
)
1717 frag_align_pattern (n
, big_nop_pattern
, sizeof big_nop_pattern
);
1719 frag_align_pattern (n
, little_nop_pattern
, sizeof little_nop_pattern
);
1728 /* Adjust a reloc for the SH. This is similar to the generic code,
1729 but does some minor tweaking. */
1732 sh_coff_reloc_mangle (seg
, fix
, intr
, paddr
)
1733 segment_info_type
*seg
;
1735 struct internal_reloc
*intr
;
1738 symbolS
*symbol_ptr
= fix
->fx_addsy
;
1741 intr
->r_vaddr
= paddr
+ fix
->fx_frag
->fr_address
+ fix
->fx_where
;
1743 if (! SWITCH_TABLE (fix
))
1745 intr
->r_type
= fix
->fx_r_type
;
1752 if (fix
->fx_r_type
== R_SH_IMM16
)
1753 intr
->r_type
= R_SH_SWITCH16
;
1754 else if (fix
->fx_r_type
== R_SH_IMM32
)
1755 intr
->r_type
= R_SH_SWITCH32
;
1759 /* For a switch reloc, we set r_offset to the difference between
1760 the reloc address and the subtrahend. When the linker is
1761 doing relaxing, it can use the determine the starting and
1762 ending points of the switch difference expression. */
1763 intr
->r_offset
= intr
->r_vaddr
- S_GET_VALUE (fix
->fx_subsy
);
1766 /* PC relative relocs are always against the current section. */
1767 if (symbol_ptr
== NULL
)
1769 switch (fix
->fx_r_type
)
1771 case R_SH_PCRELIMM8BY2
:
1772 case R_SH_PCRELIMM8BY4
:
1773 case R_SH_PCDISP8BY2
:
1776 symbol_ptr
= seg
->dot
;
1783 if (fix
->fx_r_type
== R_SH_USES
)
1785 /* We can't store the offset in the object file, since this
1786 reloc does not take up any space, so we store it in r_offset.
1787 The fx_addnumber field was set in md_apply_fix. */
1788 intr
->r_offset
= fix
->fx_addnumber
;
1790 else if (fix
->fx_r_type
== R_SH_COUNT
)
1792 /* We can't store the count in the object file, since this reloc
1793 does not take up any space, so we store it in r_offset. The
1794 fx_offset field was set when the fixup was created in
1795 sh_coff_frob_file. */
1796 intr
->r_offset
= fix
->fx_offset
;
1797 /* This reloc is always absolute. */
1800 else if (fix
->fx_r_type
== R_SH_ALIGN
)
1802 /* Store the alignment in the r_offset field. */
1803 intr
->r_offset
= fix
->fx_offset
;
1804 /* This reloc is always absolute. */
1808 /* Turn the segment of the symbol into an offset. */
1809 if (symbol_ptr
!= NULL
)
1811 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
1813 intr
->r_symndx
= dot
->sy_number
;
1815 intr
->r_symndx
= symbol_ptr
->sy_number
;
1818 intr
->r_symndx
= -1;