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");
904 && ! seg_info (now_seg
)->tc_segment_info_data
.in_code
)
906 /* Output a CODE reloc to tell the linker that the following
907 bytes are instructions, not data. */
908 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0, R_SH_CODE
);
909 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 1;
912 if (opcode
->arg
[0] == A_BDISP12
913 || opcode
->arg
[0] == A_BDISP8
)
915 parse_exp (op_end
+ 1);
916 build_relax (opcode
);
920 if (opcode
->arg
[0] != A_END
)
922 get_operands (opcode
, op_end
, operand
);
924 opcode
= get_specific (opcode
, operand
);
928 /* Couldn't find an opcode which matched the operands */
929 char *where
= frag_more (2);
933 as_bad ("invalid operands for opcode");
937 build_Mytes (opcode
, operand
);
942 /* This routine is called each time a label definition is seen. It
943 emits a R_SH_LABEL reloc if necessary. */
949 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
950 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0, R_SH_LABEL
);
953 /* This routine is called when the assembler is about to output some
954 data. It emits a R_SH_DATA reloc if necessary. */
957 sh_flush_pending_output ()
960 && seg_info (now_seg
)->tc_segment_info_data
.in_code
)
962 fix_new (frag_now
, frag_now_fix (), 2, &abs_symbol
, 0, 0, R_SH_DATA
);
963 seg_info (now_seg
)->tc_segment_info_data
.in_code
= 0;
968 DEFUN (tc_crawl_symbol_chain
, (headers
),
969 object_headers
* headers
)
971 printf ("call to tc_crawl_symbol_chain \n");
975 DEFUN (md_undefined_symbol
, (name
),
982 DEFUN (tc_headers_hook
, (headers
),
983 object_headers
* headers
)
985 printf ("call to tc_headers_hook \n");
988 /* Various routines to kill one day */
989 /* Equal to MAX_PRECISION in atof-ieee.c */
990 #define MAX_LITTLENUMS 6
992 /* Turn a string in input_line_pointer into a floating point constant of type
993 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
994 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
997 md_atof (type
, litP
, sizeP
)
1003 LITTLENUM_TYPE words
[4];
1019 return "bad call to md_atof";
1022 t
= atof_ieee (input_line_pointer
, type
, words
);
1024 input_line_pointer
= t
;
1028 if (! target_big_endian
)
1030 for (i
= prec
- 1; i
>= 0; i
--)
1032 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
1038 for (i
= 0; i
< prec
; i
++)
1040 md_number_to_chars (litP
, (valueT
) words
[i
], 2);
1048 /* Handle the .uses pseudo-op. This pseudo-op is used just before a
1049 call instruction. It refers to a label of the instruction which
1050 loads the register which the call uses. We use it to generate a
1051 special reloc for the linker. */
1060 as_warn (".uses pseudo-op seen when not relaxing");
1064 if (ex
.X_op
!= O_symbol
|| ex
.X_add_number
!= 0)
1066 as_bad ("bad .uses format");
1067 ignore_rest_of_line ();
1071 fix_new_exp (frag_now
, frag_now_fix (), 2, &ex
, 1, R_SH_USES
);
1073 demand_empty_rest_of_line ();
1076 CONST
char *md_shortopts
= "";
1077 struct option md_longopts
[] = {
1079 #define OPTION_RELAX (OPTION_MD_BASE)
1080 #define OPTION_LITTLE (OPTION_MD_BASE+1)
1082 {"relax", no_argument
, NULL
, OPTION_RELAX
},
1083 {"little", no_argument
, NULL
, OPTION_LITTLE
},
1084 {NULL
, no_argument
, NULL
, 0}
1086 size_t md_longopts_size
= sizeof(md_longopts
);
1089 md_parse_option (c
, arg
)
1100 target_big_endian
= 0;
1111 md_show_usage (stream
)
1116 -little generate little endian code\n\
1117 -relax alter jump instructions for long displacements\n");
1120 int md_short_jump_size
;
1123 tc_Nout_fix_to_chars ()
1125 printf ("call to tc_Nout_fix_to_chars \n");
1130 md_create_short_jump (ptr
, from_Nddr
, to_Nddr
, frag
, to_symbol
)
1137 as_fatal ("failed sanity check.");
1141 md_create_long_jump (ptr
, from_Nddr
, to_Nddr
, frag
, to_symbol
)
1143 addressT from_Nddr
, to_Nddr
;
1147 as_fatal ("failed sanity check.");
1150 /* This is function is called after the symbol table has been
1151 completed, but before md_convert_frag has been called. If we have
1152 seen any .uses pseudo-ops, they point to an instruction which loads
1153 a register with the address of a function. We look through the
1154 fixups to find where the function address is being loaded from. We
1155 then generate a COUNT reloc giving the number of times that
1156 function address is referred to. The linker uses this information
1157 when doing relaxing, to decide when it can eliminate the stored
1158 function address entirely. */
1161 sh_coff_frob_file ()
1168 for (iseg
= SEG_E0
; iseg
< SEG_UNKNOWN
; iseg
++)
1172 for (fix
= segment_info
[iseg
].fix_root
; fix
!= NULL
; fix
= fix
->fx_next
)
1180 if (fix
->fx_r_type
!= R_SH_USES
)
1183 /* The R_SH_USES reloc should refer to a defined local
1184 symbol in the same section. */
1185 sym
= fix
->fx_addsy
;
1187 || fix
->fx_subsy
!= NULL
1188 || fix
->fx_addnumber
!= 0
1189 || S_GET_SEGMENT (sym
) != iseg
1190 || S_GET_STORAGE_CLASS (sym
) == C_EXT
)
1192 as_warn_where (fix
->fx_file
, fix
->fx_line
,
1193 ".uses does not refer to a local symbol in the same section");
1197 /* Look through the fixups again, this time looking for one
1198 at the same location as sym. */
1199 val
= S_GET_VALUE (sym
);
1200 for (fscan
= segment_info
[iseg
].fix_root
;
1202 fscan
= fscan
->fx_next
)
1203 if (val
== fscan
->fx_frag
->fr_address
+ fscan
->fx_where
1204 && fscan
->fx_r_type
!= R_SH_ALIGN
1205 && fscan
->fx_r_type
!= R_SH_CODE
1206 && fscan
->fx_r_type
!= R_SH_DATA
1207 && fscan
->fx_r_type
!= R_SH_LABEL
)
1211 as_warn_where (fix
->fx_file
, fix
->fx_line
,
1212 "can't find fixup pointed to by .uses");
1216 if (fscan
->fx_tcbit
)
1218 /* We've already done this one. */
1222 /* fscan should also be a fixup to a local symbol in the same
1224 sym
= fscan
->fx_addsy
;
1226 || fscan
->fx_subsy
!= NULL
1227 || fscan
->fx_addnumber
!= 0
1228 || S_GET_SEGMENT (sym
) != iseg
1229 || S_GET_STORAGE_CLASS (sym
) == C_EXT
)
1231 as_warn_where (fix
->fx_file
, fix
->fx_line
,
1232 ".uses target does not refer to a local symbol in the same section");
1236 /* Now we look through all the fixups of all the sections,
1237 counting the number of times we find a reference to sym. */
1239 for (iscan
= SEG_E0
; iscan
< SEG_UNKNOWN
; iscan
++)
1241 for (fscan
= segment_info
[iscan
].fix_root
;
1243 fscan
= fscan
->fx_next
)
1245 if (fscan
->fx_addsy
== sym
)
1248 fscan
->fx_tcbit
= 1;
1256 /* Generate a R_SH_COUNT fixup at the location of sym. We
1257 have already adjusted the value of sym to include the
1258 fragment address, so we undo that adjustment here. */
1259 subseg_change (iseg
, 0);
1260 fix_new (sym
->sy_frag
, S_GET_VALUE (sym
) - sym
->sy_frag
->fr_address
,
1261 4, &abs_symbol
, count
, 0, R_SH_COUNT
);
1266 /* Called after relaxing. Set the correct sizes of the fragments, and
1267 create relocs so that md_apply_fix will fill in the correct values. */
1270 md_convert_frag (headers
, seg
, fragP
)
1271 object_headers
*headers
;
1277 switch (fragP
->fr_subtype
)
1279 case C (COND_JUMP
, COND8
):
1280 subseg_change (seg
, 0);
1281 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
1282 1, R_SH_PCDISP8BY2
);
1287 case C (UNCOND_JUMP
, UNCOND12
):
1288 subseg_change (seg
, 0);
1289 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
1295 case C (UNCOND_JUMP
, UNCOND32
):
1296 case C (UNCOND_JUMP
, UNDEF_WORD_DISP
):
1297 if (fragP
->fr_symbol
== NULL
)
1298 as_bad ("at 0x%lx, displacement overflows 12-bit field",
1299 (unsigned long) fragP
->fr_address
);
1301 as_bad ("at 0x%lx, displacement to %sdefined symbol %s overflows 12-bit field",
1302 (unsigned long) fragP
->fr_address
,
1303 S_IS_DEFINED (fragP
->fr_symbol
) ? "" : "un",
1304 S_GET_NAME (fragP
->fr_symbol
));
1306 #if 0 /* This code works, but generates poor code and the compiler
1307 should never produce a sequence that requires it to be used. */
1309 /* A jump wont fit in 12 bits, make code which looks like
1315 int t
= buffer
[0] & 0x10;
1317 buffer
[highbyte
] = 0xa0; /* branch over move and disp */
1318 buffer
[lowbyte
] = 3;
1319 buffer
[highbyte
+2] = 0xd0 | JREG
; /* Build mov insn */
1320 buffer
[lowbyte
+2] = 0x00;
1322 buffer
[highbyte
+4] = 0; /* space for 32 bit jump disp */
1323 buffer
[lowbyte
+4] = 0;
1324 buffer
[highbyte
+6] = 0;
1325 buffer
[lowbyte
+6] = 0;
1327 buffer
[highbyte
+8] = 0x40 | JREG
; /* Build jmp @JREG */
1328 buffer
[lowbyte
+8] = t
? 0xb : 0x2b;
1330 buffer
[highbyte
+10] = 0x20; /* build nop */
1331 buffer
[lowbyte
+10] = 0x0b;
1333 /* Make reloc for the long disp */
1341 fragP
->fr_fix
+= UNCOND32_LENGTH
;
1348 case C (COND_JUMP
, COND12
):
1349 /* A bcond won't fit, so turn it into a b!cond; bra disp; nop */
1351 unsigned char *buffer
=
1352 (unsigned char *) (fragP
->fr_fix
+ fragP
->fr_literal
);
1353 int highbyte
= target_big_endian
? 0 : 1;
1354 int lowbyte
= target_big_endian
? 1 : 0;
1356 /* Toggle the true/false bit of the bcond. */
1357 buffer
[highbyte
] ^= 0x2;
1359 /* Build a relocation to six bytes farther on. */
1360 subseg_change (seg
, 0);
1361 fix_new (fragP
, fragP
->fr_fix
, 2,
1362 segment_info
[seg
].dot
,
1363 fragP
->fr_address
+ fragP
->fr_fix
+ 6,
1364 1, R_SH_PCDISP8BY2
);
1366 /* Set up a jump instruction. */
1367 buffer
[highbyte
+ 2] = 0xa0;
1368 buffer
[lowbyte
+ 2] = 0;
1369 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
1370 fragP
->fr_offset
, 1, R_SH_PCDISP
);
1372 /* Fill in a NOP instruction. */
1373 buffer
[highbyte
+ 4] = 0x0;
1374 buffer
[lowbyte
+ 4] = 0x9;
1382 case C (COND_JUMP
, COND32
):
1383 case C (COND_JUMP
, UNDEF_WORD_DISP
):
1384 if (fragP
->fr_symbol
== NULL
)
1385 as_bad ("at 0x%lx, displacement overflows 8-bit field",
1386 (unsigned long) fragP
->fr_address
);
1388 as_bad ("at 0x%lx, displacement to %sdefined symbol %s overflows 8-bit field ",
1389 (unsigned long) fragP
->fr_address
,
1390 S_IS_DEFINED (fragP
->fr_symbol
) ? "" : "un",
1391 S_GET_NAME (fragP
->fr_symbol
));
1393 #if 0 /* This code works, but generates poor code, and the compiler
1394 should never produce a sequence that requires it to be used. */
1396 /* A bcond won't fit and it won't go into a 12 bit
1397 displacement either, the code sequence looks like:
1406 buffer
[0] ^= 0x2; /* Toggle T/F bit */
1408 buffer
[1] = 5; /* branch over mov, jump, nop and ptr */
1409 buffer
[2] = 0xd0 | JREG
; /* Build mov insn */
1411 buffer
[4] = 0x40 | JREG
; /* Build jmp @JREG */
1413 buffer
[6] = 0x20; /* build nop */
1415 buffer
[8] = 0; /* space for 32 bit jump disp */
1421 /* Make reloc for the long disp */
1429 fragP
->fr_fix
+= COND32_LENGTH
;
1440 if (donerelax
&& !sh_relax
)
1441 as_warn ("Offset doesn't fit at 0x%lx, trying to get to %s+0x%lx",
1442 (unsigned long) fragP
->fr_address
,
1443 fragP
->fr_symbol
? S_GET_NAME(fragP
->fr_symbol
): "",
1444 (unsigned long) fragP
->fr_offset
);
1448 DEFUN (md_section_align
, (seg
, size
),
1452 return ((size
+ (1 << section_alignment
[(int) seg
]) - 1)
1453 & (-1 << section_alignment
[(int) seg
]));
1457 /* When relaxing, we need to output a reloc for any .align directive
1458 that requests alignment to a four byte boundary or larger. */
1461 sh_handle_align (frag
)
1465 && frag
->fr_type
== rs_align
1466 && frag
->fr_address
+ frag
->fr_fix
> 0
1467 && frag
->fr_offset
> 1
1468 && now_seg
!= bss_section
)
1469 fix_new (frag
, frag
->fr_fix
, 2, &abs_symbol
, frag
->fr_offset
, 0,
1473 /* This macro decides whether a particular reloc is an entry in a
1474 switch table. It is used when relaxing, because the linker needs
1475 to know about all such entries so that it can adjust them if
1478 #define SWITCH_TABLE(fix) \
1479 ((fix)->fx_addsy != NULL \
1480 && (fix)->fx_subsy != NULL \
1481 && S_GET_SEGMENT ((fix)->fx_addsy) == text_section \
1482 && S_GET_SEGMENT ((fix)->fx_subsy) == text_section \
1483 && ((fix)->fx_r_type == R_SH_IMM32 \
1484 || (fix)->fx_r_type == R_SH_IMM16 \
1485 || ((fix)->fx_r_type == 0 \
1486 && ((fix)->fx_size == 2 \
1487 || (fix)->fx_size == 4))))
1489 /* See whether we need to force a relocation into the output file.
1490 This is used to force out switch and PC relative relocations when
1494 sh_force_relocation (fix
)
1500 return (fix
->fx_pcrel
1501 || SWITCH_TABLE (fix
)
1502 || fix
->fx_r_type
== R_SH_COUNT
1503 || fix
->fx_r_type
== R_SH_ALIGN
1504 || fix
->fx_r_type
== R_SH_CODE
1505 || fix
->fx_r_type
== R_SH_DATA
1506 || fix
->fx_r_type
== R_SH_LABEL
);
1509 /* Apply a fixup to the object file. */
1512 md_apply_fix (fixP
, val
)
1516 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
1517 int lowbyte
= target_big_endian
? 1 : 0;
1518 int highbyte
= target_big_endian
? 0 : 1;
1520 if (fixP
->fx_r_type
== 0)
1522 if (fixP
->fx_size
== 2)
1523 fixP
->fx_r_type
= R_SH_IMM16
;
1524 else if (fixP
->fx_size
== 4)
1525 fixP
->fx_r_type
= R_SH_IMM32
;
1526 else if (fixP
->fx_size
== 1)
1527 fixP
->fx_r_type
= R_SH_IMM8
;
1532 switch (fixP
->fx_r_type
)
1535 *buf
= (*buf
& 0xf0) | (val
& 0xf);
1539 *buf
= (*buf
& 0xf0) | ((val
>> 1) & 0xf);
1543 *buf
= (*buf
& 0xf0) | ((val
>> 2) & 0xf);
1558 case R_SH_PCRELIMM8BY4
:
1559 /* The lower two bits of the PC are cleared before the
1560 displacement is added in. We can assume that the destination
1561 is on a 4 byte bounday. If this instruction is also on a 4
1562 byte boundary, then we want
1564 and target - here is a multiple of 4.
1565 Otherwise, we are on a 2 byte boundary, and we want
1566 (target - (here - 2)) / 4
1567 and target - here is not a multiple of 4. Computing
1568 (target - (here - 2)) / 4 == (target - here + 2) / 4
1569 works for both cases, since in the first case the addition of
1570 2 will be removed by the division. target - here is in the
1572 val
= (val
+ 2) / 4;
1574 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, "pcrel too far");
1578 case R_SH_PCRELIMM8BY2
:
1581 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, "pcrel too far");
1585 case R_SH_PCDISP8BY2
:
1587 if (val
< -0x80 || val
> 0x7f)
1588 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, "pcrel too far");
1594 if (val
< -0x800 || val
>= 0x7ff)
1595 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, "pcrel too far");
1596 buf
[lowbyte
] = val
& 0xff;
1597 buf
[highbyte
] |= (val
>> 8) & 0xf;
1601 if (! target_big_endian
)
1618 if (! target_big_endian
)
1631 /* Pass the value into sh_coff_reloc_mangle. */
1632 fixP
->fx_addnumber
= val
;
1640 /* Nothing to do here. */
1648 int md_long_jump_size
;
1650 /* Called just before address relaxation. Return the length
1651 by which a fragment must grow to reach it's destination. */
1654 md_estimate_size_before_relax (fragP
, segment_type
)
1655 register fragS
*fragP
;
1656 register segT segment_type
;
1658 switch (fragP
->fr_subtype
)
1660 case C (UNCOND_JUMP
, UNDEF_DISP
):
1661 /* used to be a branch to somewhere which was unknown */
1662 if (!fragP
->fr_symbol
)
1664 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
1665 fragP
->fr_var
= md_relax_table
[C (UNCOND_JUMP
, UNCOND12
)].rlx_length
;
1667 else if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
1669 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNCOND12
);
1670 fragP
->fr_var
= md_relax_table
[C (UNCOND_JUMP
, UNCOND12
)].rlx_length
;
1674 fragP
->fr_subtype
= C (UNCOND_JUMP
, UNDEF_WORD_DISP
);
1675 fragP
->fr_var
= md_relax_table
[C (UNCOND_JUMP
, UNCOND32
)].rlx_length
;
1676 return md_relax_table
[C (UNCOND_JUMP
, UNCOND32
)].rlx_length
;
1682 case C (COND_JUMP
, UNDEF_DISP
):
1683 /* used to be a branch to somewhere which was unknown */
1684 if (fragP
->fr_symbol
1685 && S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
1687 /* Got a symbol and it's defined in this segment, become byte
1688 sized - maybe it will fix up */
1689 fragP
->fr_subtype
= C (COND_JUMP
, COND8
);
1690 fragP
->fr_var
= md_relax_table
[C (COND_JUMP
, COND8
)].rlx_length
;
1692 else if (fragP
->fr_symbol
)
1694 /* Its got a segment, but its not ours, so it will always be long */
1695 fragP
->fr_subtype
= C (COND_JUMP
, UNDEF_WORD_DISP
);
1696 fragP
->fr_var
= md_relax_table
[C (COND_JUMP
, COND32
)].rlx_length
;
1697 return md_relax_table
[C (COND_JUMP
, COND32
)].rlx_length
;
1701 /* We know the abs value */
1702 fragP
->fr_subtype
= C (COND_JUMP
, COND8
);
1703 fragP
->fr_var
= md_relax_table
[C (COND_JUMP
, COND8
)].rlx_length
;
1708 return fragP
->fr_var
;
1711 /* Put number into target byte order */
1714 md_number_to_chars (ptr
, use
, nbytes
)
1719 if (! target_big_endian
)
1720 number_to_chars_littleendian (ptr
, use
, nbytes
);
1722 number_to_chars_bigendian (ptr
, use
, nbytes
);
1726 md_pcrel_from (fixP
)
1729 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
+ 2;
1733 tc_coff_sizemachdep (frag
)
1736 return md_relax_table
[frag
->fr_subtype
].rlx_length
;
1739 /* When we align the .text section, insert the correct NOP pattern. */
1742 sh_do_align (n
, fill
, len
)
1747 if ((fill
== NULL
|| (*fill
== 0 && len
== 1))
1748 && (now_seg
== text_section
1749 #ifdef BFD_ASSEMBLER
1750 || (now_seg
->flags
& SEC_CODE
) != 0
1752 || strcmp (obj_segment_name (now_seg
), ".init") == 0)
1755 static const unsigned char big_nop_pattern
[] = { 0x00, 0x09 };
1756 static const unsigned char little_nop_pattern
[] = { 0x09, 0x00 };
1758 /* First align to a 2 byte boundary, in case there is an odd
1761 if (target_big_endian
)
1762 frag_align_pattern (n
, big_nop_pattern
, sizeof big_nop_pattern
);
1764 frag_align_pattern (n
, little_nop_pattern
, sizeof little_nop_pattern
);
1773 /* Adjust a reloc for the SH. This is similar to the generic code,
1774 but does some minor tweaking. */
1777 sh_coff_reloc_mangle (seg
, fix
, intr
, paddr
)
1778 segment_info_type
*seg
;
1780 struct internal_reloc
*intr
;
1783 symbolS
*symbol_ptr
= fix
->fx_addsy
;
1786 intr
->r_vaddr
= paddr
+ fix
->fx_frag
->fr_address
+ fix
->fx_where
;
1788 if (! SWITCH_TABLE (fix
))
1790 intr
->r_type
= fix
->fx_r_type
;
1797 if (fix
->fx_r_type
== R_SH_IMM16
)
1798 intr
->r_type
= R_SH_SWITCH16
;
1799 else if (fix
->fx_r_type
== R_SH_IMM32
)
1800 intr
->r_type
= R_SH_SWITCH32
;
1804 /* For a switch reloc, we set r_offset to the difference between
1805 the reloc address and the subtrahend. When the linker is
1806 doing relaxing, it can use the determine the starting and
1807 ending points of the switch difference expression. */
1808 intr
->r_offset
= intr
->r_vaddr
- S_GET_VALUE (fix
->fx_subsy
);
1811 /* PC relative relocs are always against the current section. */
1812 if (symbol_ptr
== NULL
)
1814 switch (fix
->fx_r_type
)
1816 case R_SH_PCRELIMM8BY2
:
1817 case R_SH_PCRELIMM8BY4
:
1818 case R_SH_PCDISP8BY2
:
1821 symbol_ptr
= seg
->dot
;
1828 if (fix
->fx_r_type
== R_SH_USES
)
1830 /* We can't store the offset in the object file, since this
1831 reloc does not take up any space, so we store it in r_offset.
1832 The fx_addnumber field was set in md_apply_fix. */
1833 intr
->r_offset
= fix
->fx_addnumber
;
1835 else if (fix
->fx_r_type
== R_SH_COUNT
)
1837 /* We can't store the count in the object file, since this reloc
1838 does not take up any space, so we store it in r_offset. The
1839 fx_offset field was set when the fixup was created in
1840 sh_coff_frob_file. */
1841 intr
->r_offset
= fix
->fx_offset
;
1842 /* This reloc is always absolute. */
1845 else if (fix
->fx_r_type
== R_SH_ALIGN
)
1847 /* Store the alignment in the r_offset field. */
1848 intr
->r_offset
= fix
->fx_offset
;
1849 /* This reloc is always absolute. */
1852 else if (fix
->fx_r_type
== R_SH_CODE
1853 || fix
->fx_r_type
== R_SH_DATA
1854 || fix
->fx_r_type
== R_SH_LABEL
)
1856 /* These relocs are always absolute. */
1860 /* Turn the segment of the symbol into an offset. */
1861 if (symbol_ptr
!= NULL
)
1863 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
1865 intr
->r_symndx
= dot
->sy_number
;
1867 intr
->r_symndx
= symbol_ptr
->sy_number
;
1870 intr
->r_symndx
= -1;