* config/tc-mips.c (append_insn): Correctly handle mips16 case
[binutils.git] / gas / config / tc-sh64.c
blob7964579268db3906bf1540c55993b122bafb806b
1 /* tc-sh64.c -- Assemble code for the SuperH SH SHcompact and SHmedia.
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 51 Franklin Street - Fifth Floor,
19 Boston, MA 02110-1301, USA. */
21 /* This file defines SHmedia ISA-specific functions and includes tc-sh.c.
22 The SHcompact ISA is in all useful aspects the "old" sh4 as implemented
23 in tc-sh.c. Not making this file part of tc-sh.c makes it easier to
24 keep a leaner sh[1-4]-only implementation. */
26 #define HAVE_SH64
28 #include <stdio.h>
29 #include "as.h"
30 #include "safe-ctype.h"
31 #include "opcodes/sh64-opc.h"
33 #ifndef OBJ_ELF
34 #error This file assumes object output is in the ELF format
35 #endif
37 /* Suffix used when we make "datalabel" symbol copies. It must not
38 collide with anything that can normally appear in a symbol, "faked
39 symbol" or local symbol. */
40 #define DATALABEL_SUFFIX " DL"
42 /* See shmedia_md_apply_fix and shmedia_md_pcrel_from_section for usage. */
43 #define SHMEDIA_MD_PCREL_FROM_FIX(FIXP) \
44 ((FIXP)->fx_size + (FIXP)->fx_where + (FIXP)->fx_frag->fr_address - 4)
46 /* We use this internally to see which one is PT and which is a PTA/PTB
47 that should be error-checked. We give it a better name here (but not
48 one that looks official). Adding it to reloc.c would make it look too
49 much of a real reloc; it is just used temporarily as a fixup-type. */
50 #define SHMEDIA_BFD_RELOC_PT BFD_RELOC_12_PCREL
52 typedef struct
54 shmedia_arg_type type;
56 /* These could go into a union, but that would uglify the code. */
57 int reg;
58 expressionS immediate;
60 /* If IMMEDIATE was a shift-expression, like "(S >> N) & 65535", where
61 N = 0, 16, 32, 48, used to extract a certain 16-bit-field to make up
62 a MOVI or SHORI relocation for a symbol, then we put the
63 corresponding reloc-type here and modify the "immediate" expression
64 to S. Otherwise, this is just BFD_RELOC_NONE. */
65 bfd_reloc_code_real_type reloctype;
66 } shmedia_operand_info;
68 /* Frag containing last base instruction. This is put in the TC field in
69 a frag, so we can emit fixups for fr_opcode without needing to make
70 sure that the opcode is in the same frag as any variant operand. */
71 fragS *sh64_last_insn_frag = NULL;
73 typedef struct
75 shmedia_operand_info operands[3];
76 unsigned long ops_val;
77 } shmedia_operands_info;
79 enum sh64_abi_values
80 { sh64_abi_unspecified, sh64_abi_32, sh64_abi_64 };
82 /* What ISA are we assembling code for? */
83 enum sh64_isa_values sh64_isa_mode = sh64_isa_unspecified;
85 /* What ABI was specified, if any (implicitly or explicitly)? */
86 static enum sh64_abi_values sh64_abi = sh64_abi_unspecified;
88 /* A note that says if we're in a sequence of insns without label
89 settings, segment or ISA mode changes or emitted data. */
90 static bfd_boolean seen_insn = FALSE;
92 /* This is set to TRUE in shmedia_md_end, so that we don't emit any
93 .cranges entries when the assembler calls output functions while
94 grinding along after all input is seen. */
95 static bfd_boolean sh64_end_of_assembly = FALSE;
97 /* Controlled by the option -no-mix, this invalidates mixing SHcompact and
98 SHmedia code in the same section, and also invalidates mixing data and
99 SHmedia code in the same section. No .cranges will therefore be
100 emitted, unless -shcompact-const-crange is specified and there is a
101 constant pool in SHcompact code. */
102 static bfd_boolean sh64_mix = TRUE;
104 static bfd_boolean sh64_shcompact_const_crange = FALSE;
106 /* Controlled by the option -no-expand, this says whether or not we expand
107 MOVI and PT/PTA/PTB. When we do not expand these insns to fit an
108 operand, we will emit errors for operands out of range and generate the
109 basic instruction and reloc for an external symbol. */
110 static bfd_boolean sh64_expand = TRUE;
112 /* Controlled by the option -expand-pt32, this says whether we expand
113 PT/PTA/PTB of an external symbol to (only) 32 or (the full) 64 bits
114 when -abi=64 is in effect. */
115 static bfd_boolean sh64_pt32 = FALSE;
117 /* When emitting a .cranges descriptor, we want to avoid getting recursive
118 calls through emit_expr. */
119 static bfd_boolean emitting_crange = FALSE;
121 /* SHmedia mnemonics. */
122 static struct hash_control *shmedia_opcode_hash_control = NULL;
124 static const unsigned char shmedia_big_nop_pattern[4] =
126 (SHMEDIA_NOP_OPC >> 24) & 255, (SHMEDIA_NOP_OPC >> 16) & 255,
127 (SHMEDIA_NOP_OPC >> 8) & 255, SHMEDIA_NOP_OPC & 255
130 static const unsigned char shmedia_little_nop_pattern[4] =
132 SHMEDIA_NOP_OPC & 255, (SHMEDIA_NOP_OPC >> 8) & 255,
133 (SHMEDIA_NOP_OPC >> 16) & 255, (SHMEDIA_NOP_OPC >> 24) & 255
136 static void shmedia_md_begin (void);
137 static int shmedia_parse_reg (char *, int *, int *, shmedia_arg_type);
138 static void shmedia_md_assemble (char *);
139 static void shmedia_md_apply_fix (fixS *, valueT *);
140 static int shmedia_md_estimate_size_before_relax (fragS *, segT);
141 static int shmedia_init_reloc (arelent *, fixS *);
142 static char *shmedia_get_operands (shmedia_opcode_info *, char *,
143 shmedia_operands_info *);
144 static void s_sh64_mode (int);
145 static void s_sh64_abi (int);
146 static void shmedia_md_convert_frag (bfd *, segT, fragS *, bfd_boolean);
147 static void shmedia_check_limits (offsetT *, bfd_reloc_code_real_type,
148 fixS *);
149 static void sh64_set_contents_type (enum sh64_elf_cr_type);
150 static void shmedia_get_operand (char **, shmedia_operand_info *,
151 shmedia_arg_type);
152 static unsigned long shmedia_immediate_op (char *, shmedia_operand_info *,
153 int, bfd_reloc_code_real_type);
154 static char *shmedia_parse_exp (char *, shmedia_operand_info *);
155 static void shmedia_frob_file_before_adjust (void);
156 static void sh64_emit_crange (symbolS *, symbolS *, enum sh64_elf_cr_type);
157 static void sh64_flush_last_crange (bfd *, asection *, void *);
158 static void sh64_flag_output (void);
159 static void sh64_update_contents_mark (bfd_boolean);
160 static void sh64_vtable_entry (int);
161 static void sh64_vtable_inherit (int);
162 static char *strip_datalabels (void);
163 static int shmedia_build_Mytes (shmedia_opcode_info *,
164 shmedia_operands_info *);
165 static shmedia_opcode_info *shmedia_find_cooked_opcode (char **);
166 static unsigned long shmedia_mask_number (unsigned long,
167 bfd_reloc_code_real_type);
169 #include "tc-sh.c"
171 void
172 shmedia_md_end (void)
174 symbolS *symp;
176 /* First, update the last range to include whatever data was last
177 emitted. */
178 sh64_update_contents_mark (TRUE);
180 /* Make sure frags generated after this point are not marked with the
181 wrong ISA; make them easily spottable. We still want to distinguish
182 it from sh64_isa_unspecified when we compile for SHcompact or
183 SHmedia. */
184 if (sh64_isa_mode != sh64_isa_unspecified)
185 sh64_isa_mode = sh64_isa_sh5_guard;
187 sh64_end_of_assembly = TRUE;
189 bfd_map_over_sections (stdoutput, sh64_flush_last_crange, NULL);
191 /* Iterate over segments and emit the last .cranges descriptor. */
192 for (symp = symbol_rootP; symp != NULL; symp = symp->sy_next)
194 symbolS *mainsym = *symbol_get_tc (symp);
196 /* Is this a datalabel symbol; does it have a pointer to the main
197 symbol? */
198 if (mainsym != NULL)
200 /* If the datalabel symbol is undefined, check if the main
201 symbol has changed in that respect. */
202 if (S_GET_SEGMENT (symp) == undefined_section)
204 segT symseg;
206 symseg = S_GET_SEGMENT (mainsym);
208 /* If the symbol is now defined to something that is not
209 global and without STO_SH5_ISA32, we just equate the
210 datalabel symbol to the main symbol, and the lack of
211 STO_SH5_ISA32 will handle the datalabelness. */
212 if (symseg != undefined_section)
214 if (S_GET_OTHER (mainsym) != STO_SH5_ISA32)
216 symp->sy_value.X_op = O_symbol;
217 symp->sy_value.X_add_symbol = mainsym;
218 symp->sy_value.X_op_symbol = NULL;
219 symp->sy_value.X_add_number = 0;
220 S_SET_SEGMENT (symp, S_GET_SEGMENT (mainsym));
221 symbol_set_frag (symp, &zero_address_frag);
222 copy_symbol_attributes (symp, mainsym);
224 else
226 /* An undefined symbol has since we saw it at
227 "datalabel", been defined to a BranchTarget
228 symbol. What we need to do here is very similar
229 to when we find the "datalabel" for a defined
230 symbol. FIXME: Break out to common function. */
231 symbol_set_value_expression (symp,
232 symbol_get_value_expression
233 (mainsym));
234 S_SET_SEGMENT (symp, symseg);
235 symbol_set_frag (symp, symbol_get_frag (mainsym));
236 copy_symbol_attributes (symp, mainsym);
238 /* Unset the BranchTarget mark that can be set at
239 attribute-copying. */
240 S_SET_OTHER (symp,
241 S_GET_OTHER (symp) & ~STO_SH5_ISA32);
243 /* The GLOBAL and WEAK attributes are not copied
244 over by copy_symbol_attributes. Do it here. */
245 if (S_IS_WEAK (mainsym))
246 S_SET_WEAK (symp);
247 else if (S_IS_EXTERNAL (mainsym))
248 S_SET_EXTERNAL (symp);
251 else
253 /* A symbol that was defined at the time we saw
254 "datalabel" can since have been attributed with being
255 weak or global. */
256 if (S_IS_WEAK (mainsym))
257 S_SET_WEAK (symp);
258 else if (S_IS_EXTERNAL (mainsym))
259 S_SET_EXTERNAL (symp);
265 for (symp = symbol_rootP; symp != NULL; symp = symp->sy_next)
266 if (S_GET_OTHER (symp) & STO_SH5_ISA32)
267 symp->sy_value.X_add_number++;
270 /* When resolving symbols, the main assembler has done us a misfavour. It
271 has removed the equation to the main symbol for a datalabel reference
272 that should be equal to the main symbol, e.g. when it's a global or
273 weak symbol and is a non-BranchTarget symbol anyway. We change that
274 back, so that relocs are against the main symbol, not the local "section
275 + offset" value. */
277 static void
278 shmedia_frob_file_before_adjust (void)
280 symbolS *symp;
281 for (symp = symbol_rootP; symp != NULL; symp = symp->sy_next)
283 symbolS *mainsym = *symbol_get_tc (symp);
285 if (mainsym != NULL
286 && S_GET_OTHER (mainsym) != STO_SH5_ISA32
287 && (S_IS_EXTERNAL (mainsym) || S_IS_WEAK (mainsym)))
289 symp->sy_value.X_op = O_symbol;
290 symp->sy_value.X_add_symbol = mainsym;
291 symp->sy_value.X_op_symbol = NULL;
292 symp->sy_value.X_add_number = 0;
294 /* For the "equation trick" to work, we have to set the section
295 to undefined. */
296 S_SET_SEGMENT (symp, undefined_section);
297 symbol_set_frag (symp, &zero_address_frag);
298 copy_symbol_attributes (symp, mainsym);
300 /* Don't forget to remove the STO_SH5_ISA32 attribute after
301 copying the other attributes. */
302 S_SET_OTHER (symp, S_GET_OTHER (symp) & ~STO_SH5_ISA32);
307 /* We need to mark the current location after the alignment. This is
308 copied code the caller, do_align. We mark the frag location before and
309 after as we need and arrange to skip the same code in do_align.
311 An alternative to code duplication is to call the do_align recursively,
312 arranging to fall through into do_align if we're already here. That
313 would require do_align as an incoming function parameter, since it's
314 static in read.c. That solution was discarded a too kludgy. */
316 void
317 sh64_do_align (int n, const char *fill, int len, int max)
319 /* Update region, or put a data region in front. */
320 sh64_update_contents_mark (TRUE);
322 /* Only make a frag if we HAVE to... */
323 if (n != 0 && !need_pass_2)
325 if (fill == NULL)
327 if (subseg_text_p (now_seg))
328 frag_align_code (n, max);
329 else
330 frag_align (n, 0, max);
332 else if (len <= 1)
333 frag_align (n, *fill, max);
334 else
335 frag_align_pattern (n, fill, len, max);
338 /* Update mark for current region with current type. */
339 sh64_update_contents_mark (FALSE);
342 /* The MAX_MEM_FOR_RS_ALIGN_CODE worker. We have to find out the ISA of
343 the current segment at this position. We can't look just at
344 sh64_isa_shmedia, and we can't look at frag_now. This is brittle:
345 callers are currently frag_align_code from subsegs_finish in write.c
346 (end of assembly) and frag_align_code from do_align in read.c (during
347 assembly). */
350 sh64_max_mem_for_rs_align_code (void)
352 segment_info_type *seginfo;
353 fragS *mode_start_frag;
354 seginfo = seg_info (now_seg);
356 /* We don't use the contents type we find at the tc_segment_info_data,
357 since that does not give us absolute information about the ISA; the
358 contents type can presumably be CRT_DATA and we'd be none the wiser.
359 Instead we use the information stored at the frag of the symbol at
360 the start of this range. If any information is missing or NULL,
361 assume SHcompact. */
362 return
363 /* If the current ISA mode is SHmedia, that's the mode that we're
364 going to assign to the new frag, so request enough memory for
365 it, even if we switch modes afterwards, otherwise we may
366 allocate too little memory and end up overflowing our buffer. */
367 (sh64_isa_mode == sh64_isa_shmedia
368 || (sh64_isa_mode != sh64_isa_unspecified
369 && seginfo != NULL
370 && seginfo->tc_segment_info_data.mode_start_symbol != NULL
371 && ((mode_start_frag
372 = (symbol_get_frag
373 (seginfo->tc_segment_info_data.mode_start_symbol)))
374 != NULL)
375 && mode_start_frag->tc_frag_data.isa == sh64_isa_shmedia))
376 ? (3 + 4) : (2 + 1);
379 /* Put in SHmedia NOP:s if the alignment was created when in SHmedia mode. */
381 void
382 sh64_handle_align (fragS * frag)
384 int bytes = frag->fr_next->fr_address - frag->fr_address - frag->fr_fix;
385 char * p = frag->fr_literal + frag->fr_fix;
387 if (frag->tc_frag_data.isa == sh64_isa_shmedia
388 && frag->fr_type == rs_align_code)
390 while (bytes & 3)
392 *p++ = 0;
393 bytes--;
394 frag->fr_fix += 1;
397 if (target_big_endian)
399 memcpy (p, shmedia_big_nop_pattern,
400 sizeof shmedia_big_nop_pattern);
401 frag->fr_var = sizeof shmedia_big_nop_pattern;
403 else
405 memcpy (p, shmedia_little_nop_pattern,
406 sizeof shmedia_little_nop_pattern);
407 frag->fr_var = sizeof shmedia_little_nop_pattern;
410 else
411 /* Punt to SHcompact function. */
412 sh_handle_align (frag);
415 /* Set SEC_SH64_ISA32 for SHmedia sections. */
417 void
418 shmedia_frob_section_type (asection *sec)
420 segment_info_type *seginfo;
421 seginfo = seg_info (sec);
423 /* This and elf32-sh64.c:sh64_elf_fake_sections are the only places
424 where we use anything else than ELF header flags to communicate the
425 section as containing SHmedia or other contents. BFD SEC_* section
426 flags are running out and should not be overloaded with
427 target-specific semantics. This target is ELF only (semantics not
428 defined for other formats), so we use the target-specific pointer
429 field of the ELF section data. */
430 if (seginfo && sh64_abi == sh64_abi_32)
432 struct sh64_section_data *sec_elf_data;
433 flagword sec_type = 0;
435 if (seginfo->tc_segment_info_data.emitted_ranges != 0)
436 sec_type = SHF_SH5_ISA32_MIXED;
437 else if (seginfo->tc_segment_info_data.contents_type == CRT_SH5_ISA32)
438 sec_type = SHF_SH5_ISA32;
440 sec_elf_data = sh64_elf_section_data (sec)->sh64_info;
441 if (sec_elf_data == NULL)
443 sec_elf_data = xcalloc (1, sizeof (*sec_elf_data));
444 sh64_elf_section_data (sec)->sh64_info = sec_elf_data;
447 sec_elf_data->contents_flags = sec_type;
451 /* This function is called by write_object_file right before the symbol
452 table is written. We subtract 1 from all symbols marked STO_SH5_ISA32,
453 as their values are temporarily incremented in shmedia_md_end, before
454 symbols values are used by relocs and fixups.
456 To increment all symbols and then decrement here is admittedly a
457 hackish solution. The alternative is to add infrastructure and hooks
458 to symbol evaluation that evaluates symbols differently internally to
459 the value output into the object file, but at the moment that just
460 seems too much for little benefit. */
462 void
463 sh64_adjust_symtab (void)
465 symbolS *symp;
467 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
469 symbolS *main_symbol = *symbol_get_tc (symp);
471 if (main_symbol)
473 char *sym_name = (char *) S_GET_NAME (symp);
475 /* All datalabels not used in relocs should be gone by now.
477 We change those remaining to have the name of the main
478 symbol, and we set the ELF type of the symbol of the reloc to
479 STT_DATALABEL. */
480 sym_name[strlen (sym_name) - strlen (DATALABEL_SUFFIX)] = 0;
481 elf_symbol (symbol_get_bfdsym (symp))->internal_elf_sym.st_info
482 = STT_DATALABEL;
484 /* Also set this symbol to "undefined", so we'll have only one
485 definition. */
486 S_SET_SEGMENT (symp, undefined_section);
488 else if (S_GET_OTHER (symp) & STO_SH5_ISA32)
490 /* It's important to change the BFD symbol value, since it is now
491 set to the GAS symbolS value. */
492 symp->bsym->value--;
494 /* Note that we do *not* adjust symp->sy_value.X_add_number. If
495 you do this, the test case in sh/sh64/immexpr2.s will fail.
496 This is because *after* symbols have been output but before
497 relocs are output, fixups are inspected one more time, and
498 some leftover expressions are resolved. To resolve to the
499 same values, those expressions must have the same GAS symbol
500 values before as after symbols have been output. We could
501 "symp->sy_value.X_add_number++" on the STO_SH5_ISA32 symbols
502 through tc_frob_file after symbols have been output, but that
503 would be too gross. */
508 /* Fill-in an allocated arelent. */
510 static int
511 shmedia_init_reloc (arelent *rel, fixS *fixP)
513 /* Adjust parts of *relp according to *fixp, and tell that it has been
514 done, so default initializations will not happen. */
515 switch (fixP->fx_r_type)
517 case BFD_RELOC_64:
518 case BFD_RELOC_64_PCREL:
519 case BFD_RELOC_SH_IMM_LOW16:
520 case BFD_RELOC_SH_IMM_MEDLOW16:
521 case BFD_RELOC_SH_IMM_MEDHI16:
522 case BFD_RELOC_SH_IMM_HI16:
523 case BFD_RELOC_SH_IMM_LOW16_PCREL:
524 case BFD_RELOC_SH_IMM_MEDLOW16_PCREL:
525 case BFD_RELOC_SH_IMM_MEDHI16_PCREL:
526 case BFD_RELOC_SH_IMM_HI16_PCREL:
527 case BFD_RELOC_SH_IMMU5:
528 case BFD_RELOC_SH_IMMU6:
529 case BFD_RELOC_SH_IMMS6:
530 case BFD_RELOC_SH_IMMS10:
531 case BFD_RELOC_SH_IMMS10BY2:
532 case BFD_RELOC_SH_IMMS10BY4:
533 case BFD_RELOC_SH_IMMS10BY8:
534 case BFD_RELOC_SH_IMMS16:
535 case BFD_RELOC_SH_IMMU16:
536 case BFD_RELOC_SH_PT_16:
537 case BFD_RELOC_SH_GOT_LOW16:
538 case BFD_RELOC_SH_GOT_MEDLOW16:
539 case BFD_RELOC_SH_GOT_MEDHI16:
540 case BFD_RELOC_SH_GOT_HI16:
541 case BFD_RELOC_SH_GOT10BY4:
542 case BFD_RELOC_SH_GOT10BY8:
543 case BFD_RELOC_SH_GOTPLT_LOW16:
544 case BFD_RELOC_SH_GOTPLT_MEDLOW16:
545 case BFD_RELOC_SH_GOTPLT_MEDHI16:
546 case BFD_RELOC_SH_GOTPLT_HI16:
547 case BFD_RELOC_SH_GOTPLT10BY4:
548 case BFD_RELOC_SH_GOTPLT10BY8:
549 case BFD_RELOC_SH_GOTOFF_LOW16:
550 case BFD_RELOC_SH_GOTOFF_MEDLOW16:
551 case BFD_RELOC_SH_GOTOFF_MEDHI16:
552 case BFD_RELOC_SH_GOTOFF_HI16:
553 case BFD_RELOC_SH_GOTPC_LOW16:
554 case BFD_RELOC_SH_GOTPC_MEDLOW16:
555 case BFD_RELOC_SH_GOTPC_MEDHI16:
556 case BFD_RELOC_SH_GOTPC_HI16:
557 case BFD_RELOC_SH_PLT_LOW16:
558 case BFD_RELOC_SH_PLT_MEDLOW16:
559 case BFD_RELOC_SH_PLT_MEDHI16:
560 case BFD_RELOC_SH_PLT_HI16:
561 rel->addend = fixP->fx_addnumber + fixP->fx_offset;
562 return 1;
564 case BFD_RELOC_SH_IMMS6BY32:
565 /* This must be resolved in assembly; we do not support it as a
566 reloc in an object file. */
567 as_bad_where (fixP->fx_file, fixP->fx_line,
568 _("This operand must be constant at assembly time"));
569 break;
571 /* There are valid cases where we get here for other than SHmedia
572 relocs, so don't make a BAD_CASE out of this. */
573 default:
577 return 0;
580 /* Hook called from md_apply_fix in tc-sh.c. */
582 static void
583 shmedia_md_apply_fix (fixS *fixP, valueT *valp)
585 offsetT val = *valp;
586 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
587 unsigned long insn
588 = target_big_endian ? bfd_getb32 (buf) : bfd_getl32 (buf);
589 bfd_reloc_code_real_type orig_fx_r_type = fixP->fx_r_type;
591 /* Change a 64-bit pc-relative reloc into the correct type, just like
592 tc-sh.c:md_apply_fix. */
593 if (fixP->fx_pcrel)
595 switch (orig_fx_r_type)
597 case BFD_RELOC_64:
598 case BFD_RELOC_SH_IMM_LOW16:
599 case BFD_RELOC_SH_IMM_MEDLOW16:
600 case BFD_RELOC_SH_IMM_MEDHI16:
601 case BFD_RELOC_SH_IMM_HI16:
602 /* Because write.c calls MD_PCREL_FROM_SECTION twice, we need to
603 undo one of the adjustments, if the relocation is not
604 actually for a symbol within the same segment (which we
605 cannot check, because we're not called from md_apply_fix, so
606 we have to keep the reloc). FIXME: This is a bug in
607 write.c:fixup_segment affecting most targets that change
608 ordinary relocs to pcrel relocs in md_apply_fix. */
609 fixP->fx_offset
610 = *valp + SHMEDIA_MD_PCREL_FROM_FIX (fixP);
611 break;
613 case BFD_RELOC_SH_PLT_LOW16:
614 case BFD_RELOC_SH_PLT_MEDLOW16:
615 case BFD_RELOC_SH_PLT_MEDHI16:
616 case BFD_RELOC_SH_PLT_HI16:
617 case BFD_RELOC_SH_GOTPC_LOW16:
618 case BFD_RELOC_SH_GOTPC_MEDLOW16:
619 case BFD_RELOC_SH_GOTPC_MEDHI16:
620 case BFD_RELOC_SH_GOTPC_HI16:
621 *valp = 0;
622 return;
624 default:
628 /* We might need to change some relocs into the corresponding
629 PC-relative one. */
630 switch (orig_fx_r_type)
632 case BFD_RELOC_64:
633 fixP->fx_r_type = BFD_RELOC_64_PCREL;
634 break;
636 case BFD_RELOC_SH_IMM_LOW16:
637 fixP->fx_r_type = BFD_RELOC_SH_IMM_LOW16_PCREL;
638 break;
640 case BFD_RELOC_SH_IMM_MEDLOW16:
641 fixP->fx_r_type = BFD_RELOC_SH_IMM_MEDLOW16_PCREL;
642 break;
644 case BFD_RELOC_SH_IMM_MEDHI16:
645 fixP->fx_r_type = BFD_RELOC_SH_IMM_MEDHI16_PCREL;
646 break;
648 case BFD_RELOC_SH_IMM_HI16:
649 fixP->fx_r_type = BFD_RELOC_SH_IMM_HI16_PCREL;
650 break;
652 case SHMEDIA_BFD_RELOC_PT:
653 /* This is how we see a difference between PT and PTA when not
654 expanding (in which case we handle it in
655 shmedia_md_convert_frag). Note that we don't see a
656 difference after the reloc is emitted. */
657 fixP->fx_r_type = BFD_RELOC_SH_PT_16;
658 break;
660 case BFD_RELOC_SH_PT_16:
661 /* This tells us there was a PTA or PTB insn explicitly
662 expressed as such (not as PT). We "or" in a 1 into the
663 lowest bit in the (unused) destination field to tell the
664 linker that it should check the right ISA type of the
665 destination and not just change a PTA to PTB (if necessary). */
666 md_number_to_chars (buf, insn | (1 << 10), 4);
667 break;
669 case BFD_RELOC_64_PCREL:
670 case BFD_RELOC_SH_IMM_LOW16_PCREL:
671 case BFD_RELOC_SH_IMM_MEDLOW16_PCREL:
672 case BFD_RELOC_SH_IMM_MEDHI16_PCREL:
673 case BFD_RELOC_SH_IMM_HI16_PCREL:
674 /* Already handled. */
675 break;
677 default:
678 /* Everything else that changes into a pc-relative relocation is
679 an error. */
680 as_bad_where (fixP->fx_file, fixP->fx_line,
681 _("Invalid operand expression"));
682 break;
685 return;
688 /* If an expression looked like it was PC-relative, but was completely
689 resolvable, we end up here with the result only in *VALP, and no
690 relocation will be emitted. */
691 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
693 /* Emit error for an out-of-range value. */
694 shmedia_check_limits ((offsetT *) valp, fixP->fx_r_type, fixP);
696 switch (fixP->fx_r_type)
698 case BFD_RELOC_SH_IMM_LOW16:
699 md_number_to_chars (buf, insn | ((val & 65535) << 10), 4);
700 break;
702 case BFD_RELOC_SH_IMM_MEDLOW16:
703 md_number_to_chars (buf,
704 insn
705 | ((valueT) (val & ((valueT) 65535 << 16))
706 >> (16 - 10)), 4);
707 break;
709 case BFD_RELOC_SH_IMM_MEDHI16:
710 md_number_to_chars (buf,
711 insn
712 | ((valueT) (val & ((valueT) 65535 << 32))
713 >> (32 - 10)), 4);
714 break;
716 case BFD_RELOC_SH_IMM_HI16:
717 md_number_to_chars (buf,
718 insn
719 | ((valueT) (val & ((valueT) 65535 << 48))
720 >> (48 - 10)), 4);
721 break;
723 case BFD_RELOC_SH_IMMS16:
724 case BFD_RELOC_SH_IMMU16:
725 md_number_to_chars (buf, insn | ((val & 65535) << 10), 4);
726 break;
728 case BFD_RELOC_SH_IMMS10:
729 md_number_to_chars (buf, insn | ((val & 0x3ff) << 10), 4);
730 break;
732 case BFD_RELOC_SH_IMMS10BY2:
733 md_number_to_chars (buf,
734 insn | ((val & (0x3ff << 1)) << (10 - 1)), 4);
735 break;
737 case BFD_RELOC_SH_IMMS10BY4:
738 md_number_to_chars (buf,
739 insn | ((val & (0x3ff << 2)) << (10 - 2)), 4);
740 break;
742 case BFD_RELOC_SH_IMMS10BY8:
743 md_number_to_chars (buf,
744 insn | ((val & (0x3ff << 3)) << (10 - 3)), 4);
745 break;
747 case BFD_RELOC_SH_SHMEDIA_CODE:
748 /* We just ignore and remove this one for the moment. FIXME:
749 Use it when implementing relaxing. */
750 break;
752 case BFD_RELOC_64:
753 md_number_to_chars (buf, val, 8);
754 break;
756 case SHMEDIA_BFD_RELOC_PT:
757 /* Change a PT to PTB if the operand turned out to be SHcompact.
758 The basic opcode specified with PT is equivalent to PTA. */
759 if ((val & 1) == 0)
760 insn |= SHMEDIA_PTB_BIT;
761 /* Fall through. */
763 case BFD_RELOC_SH_PT_16:
764 if (! sh64_expand || sh_relax)
766 /* Check if the operand of a PTA or PTB was for the "wrong"
767 ISA. A PT had an incoming fixup of SHMEDIA_BFD_RELOC_PT,
768 which we have changed to the right type above. */
769 if (orig_fx_r_type != SHMEDIA_BFD_RELOC_PT)
771 if ((insn & SHMEDIA_PTB_BIT) != 0 && (val & 1) != 0)
772 as_bad_where (fixP->fx_file, fixP->fx_line,
773 _("PTB operand is a SHmedia symbol"));
774 else if ((insn & SHMEDIA_PTB_BIT) == 0 && (val & 1) == 0)
775 as_bad_where (fixP->fx_file, fixP->fx_line,
776 _("PTA operand is a SHcompact symbol"));
779 md_number_to_chars (buf,
780 insn | ((val & (0xffff << 2))
781 << (10 - 2)),
783 break;
785 /* Fall through. */
787 default:
788 /* This isn't a BAD_CASE, because presumably we can get here
789 from unexpected operands. Since we don't handle them, make
790 them syntax errors. */
791 as_bad_where (fixP->fx_file, fixP->fx_line,
792 _("invalid expression in operand"));
794 fixP->fx_done = 1;
798 /* Hook called from md_convert_frag in tc-sh.c. */
800 static void
801 shmedia_md_convert_frag (bfd *output_bfd ATTRIBUTE_UNUSED,
802 segT seg ATTRIBUTE_UNUSED, fragS *fragP,
803 bfd_boolean final)
805 /* Pointer to first byte in variable-sized part of the frag. */
806 char *var_partp;
808 /* Pointer to first opcode byte in frag. */
809 char *opcodep;
811 /* Pointer to frag of opcode. */
812 fragS *opc_fragP = fragP->tc_frag_data.opc_frag;
814 /* Size in bytes of variable-sized part of frag. */
815 int var_part_size = 0;
817 /* This is part of *fragP. It contains all information about addresses
818 and offsets to varying parts. */
819 symbolS *symbolP = fragP->fr_symbol;
821 bfd_boolean reloc_needed
822 = (! final
823 || sh_relax
824 || symbolP == NULL
825 || ! S_IS_DEFINED (symbolP)
826 || S_IS_EXTERNAL (symbolP)
827 || S_IS_WEAK (symbolP)
828 || (S_GET_SEGMENT (fragP->fr_symbol) != absolute_section
829 && S_GET_SEGMENT (fragP->fr_symbol) != seg));
831 bfd_reloc_code_real_type reloctype = BFD_RELOC_NONE;
833 unsigned long var_part_offset;
835 /* Where, in file space, does addr point? */
836 bfd_vma target_address;
837 bfd_vma opcode_address;
839 /* What was the insn? */
840 unsigned long insn;
841 know (fragP->fr_type == rs_machine_dependent);
843 var_part_offset = fragP->fr_fix;
844 var_partp = fragP->fr_literal + var_part_offset;
845 opcodep = fragP->fr_opcode;
847 insn = target_big_endian ? bfd_getb32 (opcodep) : bfd_getl32 (opcodep);
849 target_address
850 = ((symbolP && final && ! sh_relax ? S_GET_VALUE (symbolP) : 0)
851 + fragP->fr_offset);
853 /* The opcode that would be extended is the last four "fixed" bytes. */
854 opcode_address = fragP->fr_address + fragP->fr_fix - 4;
856 switch (fragP->fr_subtype)
858 case C (SH64PCREL16PT_64, SH64PCREL16):
859 case C (SH64PCREL16PT_32, SH64PCREL16):
860 /* We can get a PT to a relaxed SHcompact address if it is in the
861 same section; a mixed-ISA section. Change the opcode to PTB if
862 so. */
863 if ((target_address & 1) == 0)
864 insn |= SHMEDIA_PTB_BIT;
865 /* Fall through. */
867 case C (SH64PCREL16_32, SH64PCREL16):
868 case C (SH64PCREL16_64, SH64PCREL16):
869 /* Check that a PTA or PTB points to the right type of target. We
870 can get here for a SHcompact target if we are in a mixed-ISA
871 section. */
872 if (((target_address & 1) == 0) && ((insn & SHMEDIA_PTB_BIT) == 0))
873 as_bad_where (fragP->fr_file, fragP->fr_line,
874 _("PTA operand is a SHcompact symbol"));
875 if (((target_address & 1) != 0) && ((insn & SHMEDIA_PTB_BIT) != 0))
876 as_bad_where (fragP->fr_file, fragP->fr_line,
877 _("PTB operand is a SHmedia symbol"));
879 /* When relaxing, we do not output the address in the insn, but
880 instead a 1 into the low bit. This matches what the linker
881 expects to find for a BFD_RELOC_SH_PT_16 reloc, when it checks
882 correctness for PTA/PTB insn; used when the target address is
883 unknown (which is not the case here). */
884 md_number_to_chars (opcodep,
885 insn
886 | (((sh_relax
887 ? 1 : ((target_address - opcode_address) / 4))
888 & ((1 << 16) - 1)) << 10),
891 /* Note that we do not emit info that this was originally a PT since
892 we have resolved to which one of PTA or PTB it will be. */
893 if (sh_relax)
894 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
895 fragP->fr_symbol, fragP->fr_offset, 1, BFD_RELOC_SH_PT_16);
896 var_part_size = 0;
897 break;
899 case C (SH64PCREL16_32, SH64PCRELPLT):
900 case C (SH64PCREL16PT_32, SH64PCRELPLT):
901 reloctype = BFD_RELOC_32_PLT_PCREL;
902 reloc_needed = 1;
903 /* Fall through */
905 case C (SH64PCREL16_32, SH64PCREL32):
906 case C (SH64PCREL16_64, SH64PCREL32):
907 case C (SH64PCREL16PT_32, SH64PCREL32):
908 case C (SH64PCREL16PT_64, SH64PCREL32):
909 /* In the fixed bit, put in a MOVI. */
910 md_number_to_chars (opcodep,
911 SHMEDIA_MOVI_OPC
912 | (SHMEDIA_TEMP_REG << 4)
913 | ((((reloc_needed
914 ? 0 : (target_address - (opcode_address + 8))
915 ) >> 16) & 65535) << 10),
918 /* Fill in a SHORI for the low part. */
919 md_number_to_chars (var_partp,
920 SHMEDIA_SHORI_OPC
921 | (SHMEDIA_TEMP_REG << 4)
922 | (((reloc_needed
923 ? 0 : (target_address - (opcode_address + 8)))
924 & 65535) << 10),
927 /* End with a "PTREL R25,TRd". */
928 md_number_to_chars (var_partp + 4,
929 SHMEDIA_PTREL_OPC | (insn & SHMEDIA_LIKELY_BIT)
930 | (SHMEDIA_TEMP_REG << 10)
931 | (insn & (7 << 4)),
934 /* We need relocs only if the target symbol was undefined or if
935 we're relaxing. */
936 if (reloc_needed)
938 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
939 fragP->fr_symbol, fragP->fr_offset - 8, 1,
940 reloctype == BFD_RELOC_32_PLT_PCREL
941 ? BFD_RELOC_SH_PLT_MEDLOW16
942 : BFD_RELOC_SH_IMM_MEDLOW16_PCREL);
943 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
944 fragP->fr_offset - 4, 1,
945 reloctype == BFD_RELOC_32_PLT_PCREL
946 ? BFD_RELOC_SH_PLT_LOW16
947 : BFD_RELOC_SH_IMM_LOW16_PCREL);
950 var_part_size = 8;
951 break;
953 case C (SH64PCREL16_64, SH64PCREL48):
954 case C (SH64PCREL16PT_64, SH64PCREL48):
955 /* In the fixed bit, put in a MOVI. */
956 md_number_to_chars (opcodep,
957 SHMEDIA_MOVI_OPC
958 | (SHMEDIA_TEMP_REG << 4)
959 | ((((reloc_needed
960 ? 0 : (target_address - (opcode_address + 12))
961 ) >> 32) & 65535) << 10),
964 /* The first SHORI, for the medium part. */
965 md_number_to_chars (var_partp,
966 SHMEDIA_SHORI_OPC
967 | (SHMEDIA_TEMP_REG << 4)
968 | ((((reloc_needed
969 ? 0 : (target_address - (opcode_address + 12))
970 ) >> 16) & 65535) << 10),
973 /* Fill in a SHORI for the low part. */
974 md_number_to_chars (var_partp + 4,
975 SHMEDIA_SHORI_OPC
976 | (SHMEDIA_TEMP_REG << 4)
977 | (((reloc_needed
978 ? 0 : (target_address - (opcode_address + 12)))
979 & 65535) << 10),
982 /* End with a "PTREL R25,TRd". */
983 md_number_to_chars (var_partp + 8,
984 SHMEDIA_PTREL_OPC | (insn & SHMEDIA_LIKELY_BIT)
985 | (SHMEDIA_TEMP_REG << 10)
986 | (insn & (7 << 4)),
989 /* We need relocs only if the target symbol was undefined or if
990 we're relaxing. */
991 if (reloc_needed)
993 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
994 fragP->fr_symbol, fragP->fr_offset - 12, 1,
995 reloctype == BFD_RELOC_32_PLT_PCREL
996 ? BFD_RELOC_SH_PLT_MEDHI16
997 : BFD_RELOC_SH_IMM_MEDHI16_PCREL);
998 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
999 fragP->fr_offset - 8, 1,
1000 reloctype == BFD_RELOC_32_PLT_PCREL
1001 ? BFD_RELOC_SH_PLT_MEDLOW16
1002 : BFD_RELOC_SH_IMM_MEDLOW16_PCREL);
1003 fix_new (fragP, var_partp - fragP->fr_literal + 4, 4, fragP->fr_symbol,
1004 fragP->fr_offset - 4, 1,
1005 reloctype == BFD_RELOC_32_PLT_PCREL
1006 ? BFD_RELOC_SH_PLT_LOW16
1007 : BFD_RELOC_SH_IMM_LOW16_PCREL);
1010 var_part_size = 12;
1011 break;
1013 case C (SH64PCREL16_64, SH64PCRELPLT):
1014 case C (SH64PCREL16PT_64, SH64PCRELPLT):
1015 reloctype = BFD_RELOC_32_PLT_PCREL;
1016 reloc_needed = 1;
1017 /* Fall through */
1019 case C (SH64PCREL16_64, SH64PCREL64):
1020 case C (SH64PCREL16PT_64, SH64PCREL64):
1021 /* In the fixed bit, put in a MOVI. */
1022 md_number_to_chars (opcodep,
1023 SHMEDIA_MOVI_OPC
1024 | (SHMEDIA_TEMP_REG << 4)
1025 | ((((reloc_needed
1026 ? 0 : (target_address - (opcode_address + 16))
1027 ) >> 48) & 65535) << 10),
1030 /* The first SHORI, for the medium-high part. */
1031 md_number_to_chars (var_partp,
1032 SHMEDIA_SHORI_OPC
1033 | (SHMEDIA_TEMP_REG << 4)
1034 | ((((reloc_needed
1035 ? 0 : (target_address - (opcode_address + 16))
1036 ) >> 32) & 65535) << 10),
1039 /* A SHORI, for the medium-low part. */
1040 md_number_to_chars (var_partp + 4,
1041 SHMEDIA_SHORI_OPC
1042 | (SHMEDIA_TEMP_REG << 4)
1043 | ((((reloc_needed
1044 ? 0 : (target_address - (opcode_address + 16))
1045 ) >> 16) & 65535) << 10),
1048 /* Fill in a SHORI for the low part. */
1049 md_number_to_chars (var_partp + 8,
1050 SHMEDIA_SHORI_OPC
1051 | (SHMEDIA_TEMP_REG << 4)
1052 | (((reloc_needed
1053 ? 0 : (target_address - (opcode_address + 16)))
1054 & 65535) << 10),
1057 /* End with a "PTREL R25,TRd". */
1058 md_number_to_chars (var_partp + 12,
1059 SHMEDIA_PTREL_OPC | (insn & SHMEDIA_LIKELY_BIT)
1060 | (SHMEDIA_TEMP_REG << 10)
1061 | (insn & (7 << 4)),
1064 /* We need relocs only if the target symbol was undefined or if
1065 we're relaxing. */
1066 if (reloc_needed)
1068 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1069 fragP->fr_symbol, fragP->fr_offset - 16, 1,
1070 reloctype == BFD_RELOC_32_PLT_PCREL
1071 ? BFD_RELOC_SH_PLT_HI16
1072 : BFD_RELOC_SH_IMM_HI16_PCREL);
1073 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1074 fragP->fr_offset - 12, 1,
1075 reloctype == BFD_RELOC_32_PLT_PCREL
1076 ? BFD_RELOC_SH_PLT_MEDHI16
1077 : BFD_RELOC_SH_IMM_MEDHI16_PCREL);
1078 fix_new (fragP, var_partp - fragP->fr_literal + 4, 4, fragP->fr_symbol,
1079 fragP->fr_offset - 8, 1,
1080 reloctype == BFD_RELOC_32_PLT_PCREL
1081 ? BFD_RELOC_SH_PLT_MEDLOW16
1082 : BFD_RELOC_SH_IMM_MEDLOW16_PCREL);
1083 fix_new (fragP, var_partp - fragP->fr_literal + 8, 4, fragP->fr_symbol,
1084 fragP->fr_offset - 4, 1,
1085 reloctype == BFD_RELOC_32_PLT_PCREL
1086 ? BFD_RELOC_SH_PLT_LOW16
1087 : BFD_RELOC_SH_IMM_LOW16_PCREL);
1090 var_part_size = 16;
1091 break;
1093 case C (MOVI_IMM_64, MOVI_GOTOFF):
1094 reloctype = BFD_RELOC_32_GOTOFF;
1095 reloc_needed = 1;
1096 /* Fall through. */
1098 case C (MOVI_IMM_64, UNDEF_MOVI):
1099 case C (MOVI_IMM_64, MOVI_64):
1101 /* We only get here for undefined symbols, so we can simplify
1102 handling compared to those above; we have 0 in the parts that
1103 will be filled with the symbol parts. */
1105 int reg = (insn >> 4) & 0x3f;
1107 /* In the fixed bit, put in a MOVI. */
1108 md_number_to_chars (opcodep, SHMEDIA_MOVI_OPC | (reg << 4), 4);
1109 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1110 fragP->fr_symbol, fragP->fr_offset, 0,
1111 reloctype == BFD_RELOC_NONE
1112 ? BFD_RELOC_SH_IMM_HI16
1113 : reloctype == BFD_RELOC_32_GOTOFF
1114 ? BFD_RELOC_SH_GOTOFF_HI16
1115 : (abort (), BFD_RELOC_SH_IMM_HI16));
1117 /* The first SHORI, for the medium-high part. */
1118 md_number_to_chars (var_partp, SHMEDIA_SHORI_OPC | (reg << 4), 4);
1119 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1120 fragP->fr_offset, 0,
1121 reloctype == BFD_RELOC_NONE
1122 ? BFD_RELOC_SH_IMM_MEDHI16
1123 : reloctype == BFD_RELOC_32_GOTOFF
1124 ? BFD_RELOC_SH_GOTOFF_MEDHI16
1125 : (abort (), BFD_RELOC_SH_IMM_MEDHI16));
1127 /* A SHORI, for the medium-low part. */
1128 md_number_to_chars (var_partp + 4,
1129 SHMEDIA_SHORI_OPC | (reg << 4), 4);
1130 fix_new (fragP, var_partp - fragP->fr_literal + 4, 4, fragP->fr_symbol,
1131 fragP->fr_offset, 0,
1132 reloctype == BFD_RELOC_NONE
1133 ? BFD_RELOC_SH_IMM_MEDLOW16
1134 : reloctype == BFD_RELOC_32_GOTOFF
1135 ? BFD_RELOC_SH_GOTOFF_MEDLOW16
1136 : (abort (), BFD_RELOC_SH_IMM_MEDLOW16));
1138 /* Fill in a SHORI for the low part. */
1139 md_number_to_chars (var_partp + 8,
1140 SHMEDIA_SHORI_OPC | (reg << 4), 4);
1141 fix_new (fragP, var_partp - fragP->fr_literal + 8, 4, fragP->fr_symbol,
1142 fragP->fr_offset, 0,
1143 reloctype == BFD_RELOC_NONE
1144 ? BFD_RELOC_SH_IMM_LOW16
1145 : reloctype == BFD_RELOC_32_GOTOFF
1146 ? BFD_RELOC_SH_GOTOFF_LOW16
1147 : (abort (), BFD_RELOC_SH_IMM_LOW16));
1149 var_part_size = 12;
1150 break;
1153 case C (MOVI_IMM_32, MOVI_GOTOFF):
1154 reloctype = BFD_RELOC_32_GOTOFF;
1155 reloc_needed = 1;
1156 /* Fall through. */
1158 case C (MOVI_IMM_32, UNDEF_MOVI):
1159 case C (MOVI_IMM_32, MOVI_32):
1161 /* Note that we only get here for undefined symbols. */
1163 int reg = (insn >> 4) & 0x3f;
1165 /* A MOVI, for the high part. */
1166 md_number_to_chars (opcodep, SHMEDIA_MOVI_OPC | (reg << 4), 4);
1167 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1168 fragP->fr_symbol, fragP->fr_offset, 0,
1169 reloctype == BFD_RELOC_NONE
1170 ? BFD_RELOC_SH_IMM_MEDLOW16
1171 : reloctype == BFD_RELOC_32_GOTOFF
1172 ? BFD_RELOC_SH_GOTOFF_MEDLOW16
1173 : reloctype == BFD_RELOC_SH_GOTPC
1174 ? BFD_RELOC_SH_GOTPC_MEDLOW16
1175 : reloctype == BFD_RELOC_32_PLT_PCREL
1176 ? BFD_RELOC_SH_PLT_MEDLOW16
1177 : (abort (), BFD_RELOC_SH_IMM_MEDLOW16));
1179 /* Fill in a SHORI for the low part. */
1180 md_number_to_chars (var_partp,
1181 SHMEDIA_SHORI_OPC | (reg << 4), 4);
1182 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1183 fragP->fr_offset, 0,
1184 reloctype == BFD_RELOC_NONE
1185 ? BFD_RELOC_SH_IMM_LOW16
1186 : reloctype == BFD_RELOC_32_GOTOFF
1187 ? BFD_RELOC_SH_GOTOFF_LOW16
1188 : reloctype == BFD_RELOC_SH_GOTPC
1189 ? BFD_RELOC_SH_GOTPC_LOW16
1190 : reloctype == BFD_RELOC_32_PLT_PCREL
1191 ? BFD_RELOC_SH_PLT_LOW16
1192 : (abort (), BFD_RELOC_SH_IMM_LOW16));
1194 var_part_size = 4;
1195 break;
1198 case C (MOVI_IMM_32_PCREL, MOVI_16):
1199 case C (MOVI_IMM_64_PCREL, MOVI_16):
1200 md_number_to_chars (opcodep,
1201 insn
1202 | (((reloc_needed
1203 ? 0 : (target_address - opcode_address))
1204 & 65535) << 10),
1206 if (reloc_needed)
1207 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1208 fragP->fr_symbol, fragP->fr_offset, 1,
1209 BFD_RELOC_SH_IMM_LOW16_PCREL);
1210 var_part_size = 0;
1211 break;
1213 case C (MOVI_IMM_32, MOVI_16):
1214 case C (MOVI_IMM_64, MOVI_16):
1215 md_number_to_chars (opcodep,
1216 insn
1217 | (((reloc_needed ? 0 : target_address)
1218 & 65535) << 10),
1220 if (reloc_needed)
1221 abort ();
1222 var_part_size = 0;
1223 break;
1225 case C (MOVI_IMM_32_PCREL, MOVI_PLT):
1226 reloctype = BFD_RELOC_32_PLT_PCREL;
1227 goto movi_imm_32_pcrel_reloc_needed;
1229 case C (MOVI_IMM_32_PCREL, MOVI_GOTPC):
1230 reloctype = BFD_RELOC_SH_GOTPC;
1231 /* Fall through. */
1233 movi_imm_32_pcrel_reloc_needed:
1234 reloc_needed = 1;
1235 /* Fall through. */
1237 case C (MOVI_IMM_32_PCREL, MOVI_32):
1238 case C (MOVI_IMM_64_PCREL, MOVI_32):
1240 int reg = (insn >> 4) & 0x3f;
1242 md_number_to_chars (opcodep,
1243 insn
1244 | (((((reloc_needed
1245 ? 0 : (target_address - opcode_address)))
1246 >> 16) & 65535) << 10), 4);
1248 /* A SHORI, for the low part. */
1249 md_number_to_chars (var_partp,
1250 SHMEDIA_SHORI_OPC
1251 | (reg << 4)
1252 | (((reloc_needed
1253 ? 0 : (target_address - opcode_address))
1254 & 65535) << 10), 4);
1255 if (reloc_needed)
1257 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1258 fragP->fr_symbol, fragP->fr_offset, 1,
1259 reloctype == BFD_RELOC_NONE
1260 ? BFD_RELOC_SH_IMM_MEDLOW16_PCREL
1261 : reloctype == BFD_RELOC_SH_GOTPC
1262 ? BFD_RELOC_SH_GOTPC_MEDLOW16
1263 : reloctype == BFD_RELOC_32_PLT_PCREL
1264 ? BFD_RELOC_SH_PLT_MEDLOW16
1265 : (abort (), BFD_RELOC_SH_IMM_MEDLOW16_PCREL));
1266 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1267 fragP->fr_offset + 4, 1,
1268 reloctype == BFD_RELOC_NONE
1269 ? BFD_RELOC_SH_IMM_LOW16_PCREL
1270 : reloctype == BFD_RELOC_SH_GOTPC
1271 ? BFD_RELOC_SH_GOTPC_LOW16
1272 : reloctype == BFD_RELOC_32_PLT_PCREL
1273 ? BFD_RELOC_SH_PLT_LOW16
1274 : (abort (), BFD_RELOC_SH_IMM_LOW16_PCREL));
1276 var_part_size = 4;
1278 break;
1280 case C (MOVI_IMM_32_PCREL, MOVI_48):
1281 case C (MOVI_IMM_64_PCREL, MOVI_48):
1283 int reg = (insn >> 4) & 0x3f;
1285 md_number_to_chars (opcodep,
1286 insn
1287 | (((((reloc_needed
1288 ? 0 : (target_address - opcode_address)))
1289 >> 32) & 65535) << 10), 4);
1291 /* A SHORI, for the medium part. */
1292 md_number_to_chars (var_partp,
1293 SHMEDIA_SHORI_OPC
1294 | (reg << 4)
1295 | ((((reloc_needed
1296 ? 0 : (target_address - opcode_address))
1297 >> 16) & 65535) << 10), 4);
1299 /* A SHORI, for the low part. */
1300 md_number_to_chars (var_partp + 4,
1301 SHMEDIA_SHORI_OPC
1302 | (reg << 4)
1303 | (((reloc_needed
1304 ? 0 : (target_address - opcode_address))
1305 & 65535) << 10), 4);
1306 if (reloc_needed)
1308 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1309 fragP->fr_symbol, fragP->fr_offset, 1,
1310 BFD_RELOC_SH_IMM_MEDHI16_PCREL);
1311 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1312 fragP->fr_offset + 4, 1, BFD_RELOC_SH_IMM_MEDLOW16_PCREL);
1313 fix_new (fragP, var_partp - fragP->fr_literal + 4, 4, fragP->fr_symbol,
1314 fragP->fr_offset + 8, 1, BFD_RELOC_SH_IMM_LOW16_PCREL);
1316 var_part_size = 8;
1318 break;
1320 case C (MOVI_IMM_64_PCREL, MOVI_PLT):
1321 reloctype = BFD_RELOC_32_PLT_PCREL;
1322 goto movi_imm_64_pcrel_reloc_needed;
1324 case C (MOVI_IMM_64_PCREL, MOVI_GOTPC):
1325 reloctype = BFD_RELOC_SH_GOTPC;
1326 /* Fall through. */
1328 movi_imm_64_pcrel_reloc_needed:
1329 reloc_needed = 1;
1330 /* Fall through. */
1332 case C (MOVI_IMM_32_PCREL, MOVI_64):
1333 case C (MOVI_IMM_64_PCREL, MOVI_64):
1335 int reg = (insn >> 4) & 0x3f;
1337 md_number_to_chars (opcodep,
1338 insn
1339 | (((((reloc_needed
1340 ? 0 : (target_address - opcode_address)))
1341 >> 48) & 65535) << 10), 4);
1343 /* A SHORI, for the medium-high part. */
1344 md_number_to_chars (var_partp,
1345 SHMEDIA_SHORI_OPC
1346 | (reg << 4)
1347 | ((((reloc_needed
1348 ? 0 : (target_address - opcode_address))
1349 >> 32) & 65535) << 10), 4);
1351 /* A SHORI, for the medium-low part. */
1352 md_number_to_chars (var_partp + 4,
1353 SHMEDIA_SHORI_OPC
1354 | (reg << 4)
1355 | ((((reloc_needed
1356 ? 0 : (target_address - opcode_address))
1357 >> 16) & 65535) << 10), 4);
1359 /* A SHORI, for the low part. */
1360 md_number_to_chars (var_partp + 8,
1361 SHMEDIA_SHORI_OPC
1362 | (reg << 4)
1363 | (((reloc_needed
1364 ? 0 : (target_address - opcode_address))
1365 & 65535) << 10), 4);
1366 if (reloc_needed)
1368 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1369 fragP->fr_symbol, fragP->fr_offset, 1,
1370 reloctype == BFD_RELOC_NONE
1371 ? BFD_RELOC_SH_IMM_HI16_PCREL
1372 : reloctype == BFD_RELOC_SH_GOTPC
1373 ? BFD_RELOC_SH_GOTPC_HI16
1374 : reloctype == BFD_RELOC_32_PLT_PCREL
1375 ? BFD_RELOC_SH_PLT_HI16
1376 : (abort (), BFD_RELOC_SH_IMM_HI16_PCREL));
1377 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1378 fragP->fr_offset + 4, 1,
1379 reloctype == BFD_RELOC_NONE
1380 ? BFD_RELOC_SH_IMM_MEDHI16_PCREL
1381 : reloctype == BFD_RELOC_SH_GOTPC
1382 ? BFD_RELOC_SH_GOTPC_MEDHI16
1383 : reloctype == BFD_RELOC_32_PLT_PCREL
1384 ? BFD_RELOC_SH_PLT_MEDHI16
1385 : (abort (), BFD_RELOC_SH_IMM_MEDHI16_PCREL));
1386 fix_new (fragP, var_partp - fragP->fr_literal + 4, 4,
1387 fragP->fr_symbol,
1388 fragP->fr_offset + 8, 1,
1389 reloctype == BFD_RELOC_NONE
1390 ? BFD_RELOC_SH_IMM_MEDLOW16_PCREL
1391 : reloctype == BFD_RELOC_SH_GOTPC
1392 ? BFD_RELOC_SH_GOTPC_MEDLOW16
1393 : reloctype == BFD_RELOC_32_PLT_PCREL
1394 ? BFD_RELOC_SH_PLT_MEDLOW16
1395 : (abort (), BFD_RELOC_SH_IMM_MEDLOW16_PCREL));
1396 fix_new (fragP, var_partp - fragP->fr_literal + 8, 4,
1397 fragP->fr_symbol,
1398 fragP->fr_offset + 12, 1,
1399 reloctype == BFD_RELOC_NONE
1400 ? BFD_RELOC_SH_IMM_LOW16_PCREL
1401 : reloctype == BFD_RELOC_SH_GOTPC
1402 ? BFD_RELOC_SH_GOTPC_LOW16
1403 : reloctype == BFD_RELOC_32_PLT_PCREL
1404 ? BFD_RELOC_SH_PLT_LOW16
1405 : (abort (), BFD_RELOC_SH_IMM_LOW16_PCREL));
1407 var_part_size = 12;
1409 break;
1411 default:
1412 BAD_CASE (fragP->fr_subtype);
1415 fragP->fr_fix += var_part_size;
1416 fragP->fr_var = 0;
1419 /* Mask NUMBER (originating from a signed number) corresponding to the HOW
1420 reloc. */
1422 static unsigned long
1423 shmedia_mask_number (unsigned long number, bfd_reloc_code_real_type how)
1425 switch (how)
1427 case BFD_RELOC_SH_IMMU5:
1428 number &= (1 << 5) - 1;
1429 break;
1431 case BFD_RELOC_SH_IMMS6:
1432 case BFD_RELOC_SH_IMMU6:
1433 number &= (1 << 6) - 1;
1434 break;
1436 case BFD_RELOC_SH_IMMS6BY32:
1437 number = (number & ((1 << (6 + 5)) - 1)) >> 5;
1438 break;
1440 case BFD_RELOC_SH_IMMS10:
1441 number &= (1 << 10) - 1;
1442 break;
1444 case BFD_RELOC_SH_IMMS10BY2:
1445 number = (number & ((1 << (10 + 1)) - 1)) >> 1;
1446 break;
1448 case BFD_RELOC_SH_IMMS10BY4:
1449 number = (number & ((1 << (10 + 2)) - 1)) >> 2;
1450 break;
1452 case BFD_RELOC_SH_IMMS10BY8:
1453 number = (number & ((1 << (10 + 3)) - 1)) >> 3;
1454 break;
1456 case BFD_RELOC_SH_IMMS16:
1457 case BFD_RELOC_SH_IMMU16:
1458 number &= (1 << 16) - 1;
1459 break;
1461 default:
1462 BAD_CASE (how);
1465 return number;
1468 /* Emit errors for values out-of-range, using as_bad_where if FRAGP is
1469 non-NULL, as_bad otherwise. */
1471 static void
1472 shmedia_check_limits (offsetT *valp, bfd_reloc_code_real_type reloc,
1473 fixS *fixp)
1475 offsetT val = *valp;
1477 char *msg = NULL;
1479 switch (reloc)
1481 case BFD_RELOC_SH_IMMU5:
1482 if (val < 0 || val > (1 << 5) - 1)
1483 msg = _("invalid operand, not a 5-bit unsigned value: %d");
1484 break;
1486 case BFD_RELOC_SH_IMMS6:
1487 if (val < -(1 << 5) || val > (1 << 5) - 1)
1488 msg = _("invalid operand, not a 6-bit signed value: %d");
1489 break;
1491 case BFD_RELOC_SH_IMMU6:
1492 if (val < 0 || val > (1 << 6) - 1)
1493 msg = _("invalid operand, not a 6-bit unsigned value: %d");
1494 break;
1496 case BFD_RELOC_SH_IMMS6BY32:
1497 if (val < -(1 << 10) || val > (1 << 10) - 1)
1498 msg = _("invalid operand, not a 11-bit signed value: %d");
1499 else if (val & 31)
1500 msg = _("invalid operand, not a multiple of 32: %d");
1501 break;
1503 case BFD_RELOC_SH_IMMS10:
1504 if (val < -(1 << 9) || val > (1 << 9) - 1)
1505 msg = _("invalid operand, not a 10-bit signed value: %d");
1506 break;
1508 case BFD_RELOC_SH_IMMS10BY2:
1509 if (val < -(1 << 10) || val > (1 << 10) - 1)
1510 msg = _("invalid operand, not a 11-bit signed value: %d");
1511 else if (val & 1)
1512 msg = _("invalid operand, not an even value: %d");
1513 break;
1515 case BFD_RELOC_SH_IMMS10BY4:
1516 if (val < -(1 << 11) || val > (1 << 11) - 1)
1517 msg = _("invalid operand, not a 12-bit signed value: %d");
1518 else if (val & 3)
1519 msg = _("invalid operand, not a multiple of 4: %d");
1520 break;
1522 case BFD_RELOC_SH_IMMS10BY8:
1523 if (val < -(1 << 12) || val > (1 << 12) - 1)
1524 msg = _("invalid operand, not a 13-bit signed value: %d");
1525 else if (val & 7)
1526 msg = _("invalid operand, not a multiple of 8: %d");
1527 break;
1529 case BFD_RELOC_SH_IMMS16:
1530 if (val < -(1 << 15) || val > (1 << 15) - 1)
1531 msg = _("invalid operand, not a 16-bit signed value: %d");
1532 break;
1534 case BFD_RELOC_SH_IMMU16:
1535 if (val < 0 || val > (1 << 16) - 1)
1536 msg = _("invalid operand, not an 16-bit unsigned value: %d");
1537 break;
1539 case BFD_RELOC_SH_PT_16:
1540 case SHMEDIA_BFD_RELOC_PT:
1541 if (val < -(1 << 15) * 4 || val > ((1 << 15) - 1) * 4 + 1)
1542 msg = _("operand out of range for PT, PTA and PTB");
1543 else if ((val % 4) != 0 && ((val - 1) % 4) != 0)
1544 msg = _("operand not a multiple of 4 for PT, PTA or PTB: %d");
1545 break;
1547 /* These have no limits; they take a 16-bit slice of a 32- or 64-bit
1548 number. */
1549 case BFD_RELOC_SH_IMM_HI16:
1550 case BFD_RELOC_SH_IMM_MEDHI16:
1551 case BFD_RELOC_SH_IMM_MEDLOW16:
1552 case BFD_RELOC_SH_IMM_LOW16:
1553 case BFD_RELOC_SH_IMM_HI16_PCREL:
1554 case BFD_RELOC_SH_IMM_MEDHI16_PCREL:
1555 case BFD_RELOC_SH_IMM_MEDLOW16_PCREL:
1556 case BFD_RELOC_SH_IMM_LOW16_PCREL:
1558 case BFD_RELOC_SH_SHMEDIA_CODE:
1559 break;
1561 /* This one has limits out of our reach. */
1562 case BFD_RELOC_64:
1563 break;
1565 default:
1566 BAD_CASE (reloc);
1569 if (msg)
1571 if (fixp)
1572 as_bad_where (fixp->fx_file, fixp->fx_line, msg, val);
1573 else
1574 as_bad (msg, val);
1578 /* Handle an immediate operand by checking limits and noting it for later
1579 evaluation if not computable yet, and return a bitfield suitable to
1580 "or" into the opcode (non-zero if the value was a constant number). */
1582 static unsigned long
1583 shmedia_immediate_op (char *where, shmedia_operand_info *op, int pcrel,
1584 bfd_reloc_code_real_type how)
1586 unsigned long retval = 0;
1588 /* If this is not an absolute number, make it a fixup. A constant in
1589 place of a pc-relative operand also needs a fixup. */
1590 if (op->immediate.X_op != O_constant || pcrel)
1591 fix_new_exp (frag_now,
1592 where - frag_now->fr_literal,
1594 &op->immediate,
1595 pcrel,
1596 how);
1597 else
1599 /* Check that the number is within limits as represented by the
1600 reloc, and return the number. */
1601 shmedia_check_limits (&op->immediate.X_add_number, how, NULL);
1603 retval
1604 = shmedia_mask_number ((unsigned long) op->immediate.X_add_number,
1605 how);
1608 return retval << 10;
1611 /* Try and parse a register name case-insensitively, return the number of
1612 chars consumed. */
1614 static int
1615 shmedia_parse_reg (char *src, int *mode, int *reg, shmedia_arg_type argtype)
1617 int l0 = TOLOWER (src[0]);
1618 int l1 = l0 ? TOLOWER (src[1]) : 0;
1620 if (l0 == 'r')
1622 if (src[1] >= '1' && src[1] <= '5')
1624 if (src[2] >= '0' && src[2] <= '9'
1625 && ! IDENT_CHAR ((unsigned char) src[3]))
1627 *mode = A_GREG_M;
1628 *reg = 10 * (src[1] - '0') + src[2] - '0';
1629 return 3;
1633 if (src[1] == '6')
1635 if (src[2] >= '0' && src[2] <= '3'
1636 && ! IDENT_CHAR ((unsigned char) src[3]))
1638 *mode = A_GREG_M;
1639 *reg = 60 + src[2] - '0';
1640 return 3;
1644 if (src[1] >= '0' && src[1] <= '9'
1645 && ! IDENT_CHAR ((unsigned char) src[2]))
1647 *mode = A_GREG_M;
1648 *reg = (src[1] - '0');
1649 return 2;
1653 if (l0 == 't' && l1 == 'r')
1655 if (src[2] >= '0' && src[2] <= '7'
1656 && ! IDENT_CHAR ((unsigned char) src[3]))
1658 *mode = A_TREG_B;
1659 *reg = (src[2] - '0');
1660 return 3;
1664 if (l0 == 'f' && l1 == 'r')
1666 if (src[2] >= '1' && src[2] <= '5')
1668 if (src[3] >= '0' && src[3] <= '9'
1669 && ! IDENT_CHAR ((unsigned char) src[4]))
1671 *mode = A_FREG_G;
1672 *reg = 10 * (src[2] - '0') + src[3] - '0';
1673 return 4;
1676 if (src[2] == '6')
1678 if (src[3] >= '0' && src[3] <= '3'
1679 && ! IDENT_CHAR ((unsigned char) src[4]))
1681 *mode = A_FREG_G;
1682 *reg = 60 + src[3] - '0';
1683 return 4;
1686 if (src[2] >= '0' && src[2] <= '9'
1687 && ! IDENT_CHAR ((unsigned char) src[3]))
1689 *mode = A_FREG_G;
1690 *reg = (src[2] - '0');
1691 return 3;
1695 if (l0 == 'f' && l1 == 'v')
1697 if (src[2] >= '1' && src[2] <= '5')
1699 if (src[3] >= '0' && src[3] <= '9'
1700 && ((10 * (src[2] - '0') + src[3] - '0') % 4) == 0
1701 && ! IDENT_CHAR ((unsigned char) src[4]))
1703 *mode = A_FVREG_G;
1704 *reg = 10 * (src[2] - '0') + src[3] - '0';
1705 return 4;
1708 if (src[2] == '6')
1710 if (src[3] == '0'
1711 && ! IDENT_CHAR ((unsigned char) src[4]))
1713 *mode = A_FVREG_G;
1714 *reg = 60 + src[3] - '0';
1715 return 4;
1718 if (src[2] >= '0' && src[2] <= '9'
1719 && ((src[2] - '0') % 4) == 0
1720 && ! IDENT_CHAR ((unsigned char) src[3]))
1722 *mode = A_FVREG_G;
1723 *reg = (src[2] - '0');
1724 return 3;
1728 if (l0 == 'd' && l1 == 'r')
1730 if (src[2] >= '1' && src[2] <= '5')
1732 if (src[3] >= '0' && src[3] <= '9'
1733 && ((src[3] - '0') % 2) == 0
1734 && ! IDENT_CHAR ((unsigned char) src[4]))
1736 *mode = A_DREG_G;
1737 *reg = 10 * (src[2] - '0') + src[3] - '0';
1738 return 4;
1742 if (src[2] == '6')
1744 if ((src[3] == '0' || src[3] == '2')
1745 && ! IDENT_CHAR ((unsigned char) src[4]))
1747 *mode = A_DREG_G;
1748 *reg = 60 + src[3] - '0';
1749 return 4;
1753 if (src[2] >= '0' && src[2] <= '9'
1754 && ((src[2] - '0') % 2) == 0
1755 && ! IDENT_CHAR ((unsigned char) src[3]))
1757 *mode = A_DREG_G;
1758 *reg = (src[2] - '0');
1759 return 3;
1763 if (l0 == 'f' && l1 == 'p')
1765 if (src[2] >= '1' && src[2] <= '5')
1767 if (src[3] >= '0' && src[3] <= '9'
1768 && ((src[3] - '0') % 2) == 0
1769 && ! IDENT_CHAR ((unsigned char) src[4]))
1771 *mode = A_FPREG_G;
1772 *reg = 10 * (src[2] - '0') + src[3] - '0';
1773 return 4;
1777 if (src[2] == '6')
1779 if ((src[3] == '0' || src[3] == '2')
1780 && ! IDENT_CHAR ((unsigned char) src[4]))
1782 *mode = A_FPREG_G;
1783 *reg = 60 + src[3] - '0';
1784 return 4;
1788 if (src[2] >= '0' && src[2] <= '9'
1789 && ((src[2] - '0') % 2) == 0
1790 && ! IDENT_CHAR ((unsigned char) src[3]))
1792 *mode = A_FPREG_G;
1793 *reg = (src[2] - '0');
1794 return 3;
1798 if (l0 == 'm' && strncasecmp (src, "mtrx", 4) == 0)
1800 if (src[4] == '0' && ! IDENT_CHAR ((unsigned char) src[5]))
1802 *mode = A_FMREG_G;
1803 *reg = 0;
1804 return 5;
1807 if (src[4] == '1' && src[5] == '6'
1808 && ! IDENT_CHAR ((unsigned char) src[6]))
1810 *mode = A_FMREG_G;
1811 *reg = 16;
1812 return 6;
1815 if (src[4] == '3' && src[5] == '2'
1816 && ! IDENT_CHAR ((unsigned char) src[6]))
1818 *mode = A_FMREG_G;
1819 *reg = 32;
1820 return 6;
1823 if (src[4] == '4' && src[5] == '8'
1824 && ! IDENT_CHAR ((unsigned char) src[6]))
1826 *mode = A_FMREG_G;
1827 *reg = 48;
1828 return 6;
1832 if (l0 == 'c' && l1 == 'r')
1834 if (src[2] >= '1' && src[2] <= '5')
1836 if (src[3] >= '0' && src[3] <= '9'
1837 && ! IDENT_CHAR ((unsigned char) src[4]))
1839 *mode = A_CREG_K;
1840 *reg = 10 * (src[2] - '0') + src[3] - '0';
1841 return 4;
1844 if (src[2] == '6')
1846 if (src[3] >= '0' && src[3] <= '3'
1847 && ! IDENT_CHAR ((unsigned char) src[4]))
1849 *mode = A_CREG_K;
1850 *reg = 60 + src[3] - '0';
1851 return 4;
1854 if (src[2] >= '0' && src[2] <= '9'
1855 && ! IDENT_CHAR ((unsigned char) src[3]))
1857 *mode = A_CREG_K;
1858 *reg = (src[2] - '0');
1859 return 3;
1863 /* We either have an error, a symbol or a control register by predefined
1864 name. To keep things simple but still fast for normal cases, we do
1865 linear search in the (not to big) table of predefined control
1866 registers. We only do this when we *expect* a control register.
1867 Those instructions should be rare enough that linear searching is ok.
1868 Or just read them into a hash-table in shmedia_md_begin. Since they
1869 cannot be specified in the same place of symbol operands, don't add
1870 them there to the *main* symbol table as being in "reg_section". */
1871 if (argtype == A_CREG_J || argtype == A_CREG_K)
1873 const shmedia_creg_info *cregp;
1874 int len = 0;
1876 for (cregp = shmedia_creg_table; cregp->name != NULL; cregp++)
1878 len = strlen (cregp->name);
1879 if (strncasecmp (cregp->name, src, len) == 0
1880 && ! IDENT_CHAR (src[len]))
1881 break;
1884 if (cregp->name != NULL)
1886 *mode = A_CREG_K;
1887 *reg = cregp->cregno;
1888 return len;
1892 return 0;
1895 /* Called from md_estimate_size_before_relax in tc-sh.c */
1897 static int
1898 shmedia_md_estimate_size_before_relax (fragS *fragP,
1899 segT segment_type ATTRIBUTE_UNUSED)
1901 int old_fr_fix;
1902 expressionS *exp;
1904 /* For ELF, we can't relax externally visible symbols; see tc-i386.c. */
1905 bfd_boolean sym_relaxable
1906 = (fragP->fr_symbol
1907 && S_GET_SEGMENT (fragP->fr_symbol) == segment_type
1908 && ! S_IS_EXTERNAL (fragP->fr_symbol)
1909 && ! S_IS_WEAK (fragP->fr_symbol));
1911 old_fr_fix = fragP->fr_fix;
1913 switch (fragP->fr_subtype)
1915 case C (SH64PCREL16_32, UNDEF_SH64PCREL):
1916 case C (SH64PCREL16PT_32, UNDEF_SH64PCREL):
1917 /* Used to be to somewhere which was unknown. */
1918 if (sym_relaxable)
1920 int what = GET_WHAT (fragP->fr_subtype);
1922 /* In this segment, so head for shortest. */
1923 fragP->fr_subtype = C (what, SH64PCREL16);
1925 else
1927 int what = GET_WHAT (fragP->fr_subtype);
1928 /* We know the abs value, but we don't know where we will be
1929 linked, so we must make it the longest. Presumably we could
1930 switch to a non-pcrel representation, but having absolute
1931 values in PT operands should be rare enough not to be worth
1932 adding that code. */
1933 fragP->fr_subtype = C (what, SH64PCREL32);
1935 fragP->fr_var = md_relax_table[fragP->fr_subtype].rlx_length;
1936 break;
1938 case C (SH64PCREL16_64, UNDEF_SH64PCREL):
1939 case C (SH64PCREL16PT_64, UNDEF_SH64PCREL):
1940 /* Used to be to somewhere which was unknown. */
1941 if (sym_relaxable)
1943 int what = GET_WHAT (fragP->fr_subtype);
1945 /* In this segment, so head for shortest. */
1946 fragP->fr_subtype = C (what, SH64PCREL16);
1948 else
1950 int what = GET_WHAT (fragP->fr_subtype);
1951 /* We know the abs value, but we don't know where we will be
1952 linked, so we must make it the longest. Presumably we could
1953 switch to a non-pcrel representation, but having absolute
1954 values in PT operands should be rare enough not to be worth
1955 adding that code. */
1956 fragP->fr_subtype = C (what, SH64PCREL64);
1958 fragP->fr_var = md_relax_table[fragP->fr_subtype].rlx_length;
1959 break;
1961 case C (MOVI_IMM_64, UNDEF_MOVI):
1962 case C (MOVI_IMM_32, UNDEF_MOVI):
1963 exp = NULL;
1965 /* Look inside the "symbol". If we find a PC-relative expression,
1966 change this to a PC-relative, relaxable expression. */
1967 if (fragP->fr_symbol != NULL
1968 && (exp = symbol_get_value_expression (fragP->fr_symbol)) != NULL
1969 && exp->X_op == O_subtract
1970 && exp->X_op_symbol != NULL
1971 && S_GET_SEGMENT (exp->X_op_symbol) == segment_type)
1973 int what = GET_WHAT (fragP->fr_subtype);
1974 int what_high = what == MOVI_IMM_32 ? MOVI_32 : MOVI_64;
1975 expressionS *opexp
1976 = symbol_get_value_expression (exp->X_op_symbol);
1977 expressionS *addexp
1978 = symbol_get_value_expression (exp->X_add_symbol);
1980 /* Change the MOVI expression to the "X" in "X - Y" and subtract
1981 Y:s offset to this location from X. Note that we can only
1982 allow an Y which is offset from this frag. */
1983 if (opexp != NULL
1984 && addexp != NULL
1985 && opexp->X_op == O_constant
1986 && fragP == symbol_get_frag (exp->X_op_symbol))
1988 /* At this point, before relaxing, the add-number of opexp
1989 is the offset from the fr_fix part. */
1990 fragP->fr_offset
1991 = (exp->X_add_number
1992 - (opexp->X_add_number - (fragP->fr_fix - 4)));
1993 fragP->fr_symbol = exp->X_add_symbol;
1995 what = what == MOVI_IMM_32
1996 ? MOVI_IMM_32_PCREL : MOVI_IMM_64_PCREL;
1998 /* Check the "X" symbol to estimate the size of this
1999 PC-relative expression. */
2000 if (S_GET_SEGMENT (exp->X_add_symbol) == segment_type
2001 && ! S_IS_EXTERNAL (exp->X_add_symbol)
2002 && ! S_IS_WEAK (exp->X_add_symbol))
2003 fragP->fr_subtype = C (what, MOVI_16);
2004 else
2005 fragP->fr_subtype = C (what, what_high);
2007 /* This is now a PC-relative expression, fit to be relaxed. */
2009 else
2010 fragP->fr_subtype = C (what, what_high);
2012 else if (fragP->fr_symbol == NULL
2013 || (S_GET_SEGMENT (fragP->fr_symbol) == absolute_section
2014 && exp->X_op == O_constant))
2016 unsigned long insn
2017 = (target_big_endian
2018 ? bfd_getb32 (fragP->fr_opcode)
2019 : bfd_getl32 (fragP->fr_opcode));
2020 offsetT one = (offsetT) 1;
2021 offsetT value = fragP->fr_offset
2022 + (fragP->fr_symbol == NULL ? 0 : S_GET_VALUE (fragP->fr_symbol));
2024 if (value >= ((offsetT) -1 << 15) && value < ((offsetT) 1 << 15))
2026 /* Fits in 16-bit signed number. */
2027 int what = GET_WHAT (fragP->fr_subtype);
2028 fragP->fr_subtype = C (what, MOVI_16);
2030 /* Just "or" in the value. */
2031 md_number_to_chars (fragP->fr_opcode,
2032 insn | ((value & ((1 << 16) - 1)) << 10),
2035 else if (value >= -(one << 31)
2036 && (value < (one << 31)
2037 || (sh64_abi == sh64_abi_32 && value < (one << 32))))
2039 /* The value fits in a 32-bit signed number. */
2040 int reg = (insn >> 4) & 0x3f;
2042 /* Just "or" in the high bits of the value, making the first
2043 MOVI. */
2044 md_number_to_chars (fragP->fr_opcode,
2045 insn
2046 | (((value >> 16) & ((1 << 16) - 1)) << 10),
2049 /* Add a SHORI with the low bits. Note that this insn lives
2050 in the variable fragment part. */
2051 md_number_to_chars (fragP->fr_literal + old_fr_fix,
2052 SHMEDIA_SHORI_OPC
2053 | (reg << 4)
2054 | ((value & ((1 << 16) - 1)) << 10),
2057 /* We took a piece of the variable part. */
2058 fragP->fr_fix += 4;
2060 else if (GET_WHAT (fragP->fr_subtype) == MOVI_IMM_32)
2062 /* Value out of range. */
2063 as_bad_where (fragP->fr_file, fragP->fr_line,
2064 _("MOVI operand is not a 32-bit signed value: 0x%8x%08x"),
2065 ((unsigned int) (value >> 32)
2066 & (unsigned int) 0xffffffff),
2067 (unsigned int) value & (unsigned int) 0xffffffff);
2069 /* Must advance size, or we will get internal inconsistency
2070 and fall into an assert. */
2071 fragP->fr_fix += 4;
2073 /* Now we know we are allowed to expand to 48- and 64-bit values. */
2074 else if (value >= -(one << 47) && value < (one << 47))
2076 /* The value fits in a 48-bit signed number. */
2077 int reg = (insn >> 4) & 0x3f;
2079 /* Just "or" in the high bits of the value, making the first
2080 MOVI. */
2081 md_number_to_chars (fragP->fr_opcode,
2082 insn
2083 | (((value >> 32) & ((1 << 16) - 1)) << 10),
2086 /* Add a SHORI with the middle bits. Note that this insn lives
2087 in the variable fragment part. */
2088 md_number_to_chars (fragP->fr_literal + old_fr_fix,
2089 SHMEDIA_SHORI_OPC
2090 | (reg << 4)
2091 | (((value >> 16) & ((1 << 16) - 1)) << 10),
2094 /* Add a SHORI with the low bits. */
2095 md_number_to_chars (fragP->fr_literal + old_fr_fix + 4,
2096 SHMEDIA_SHORI_OPC
2097 | (reg << 4)
2098 | ((value & ((1 << 16) - 1)) << 10),
2101 /* We took a piece of the variable part. */
2102 fragP->fr_fix += 8;
2104 else
2106 /* A 64-bit number. */
2107 int reg = (insn >> 4) & 0x3f;
2109 /* Just "or" in the high bits of the value, making the first
2110 MOVI. */
2111 md_number_to_chars (fragP->fr_opcode,
2112 insn
2113 | (((value >> 48) & ((1 << 16) - 1)) << 10),
2116 /* Add a SHORI with the midhigh bits. Note that this insn lives
2117 in the variable fragment part. */
2118 md_number_to_chars (fragP->fr_literal + old_fr_fix,
2119 SHMEDIA_SHORI_OPC
2120 | (reg << 4)
2121 | (((value >> 32) & ((1 << 16) - 1)) << 10),
2124 /* Add a SHORI with the midlow bits. */
2125 md_number_to_chars (fragP->fr_literal + old_fr_fix + 4,
2126 SHMEDIA_SHORI_OPC
2127 | (reg << 4)
2128 | (((value >> 16) & ((1 << 16) - 1)) << 10),
2131 /* Add a SHORI with the low bits. */
2132 md_number_to_chars (fragP->fr_literal + old_fr_fix + 8,
2133 SHMEDIA_SHORI_OPC
2134 | (reg << 4)
2135 | ((value & ((1 << 16) - 1)) << 10), 4);
2136 /* We took all of the variable part. */
2137 fragP->fr_fix += 12;
2140 /* MOVI expansions that get here have not been converted to
2141 PC-relative frags, but instead expanded by
2142 md_number_to_chars or by calling shmedia_md_convert_frag
2143 with final == FALSE. We must not have them around as
2144 frags anymore; symbols would be prematurely evaluated
2145 when relaxing. We will not need to have md_convert_frag
2146 called again with them; any further handling is through
2147 the already emitted fixups. */
2148 frag_wane (fragP);
2149 break;
2151 fragP->fr_var = md_relax_table[fragP->fr_subtype].rlx_length;
2152 break;
2154 /* For relaxation states that remain unchanged, report the
2155 estimated length. */
2156 case C (SH64PCREL16_32, SH64PCREL16):
2157 case C (SH64PCREL16PT_32, SH64PCREL16):
2158 case C (SH64PCREL16_32, SH64PCREL32):
2159 case C (SH64PCREL16PT_32, SH64PCREL32):
2160 case C (SH64PCREL16_32, SH64PCRELPLT):
2161 case C (SH64PCREL16PT_32, SH64PCRELPLT):
2162 case C (SH64PCREL16_64, SH64PCREL16):
2163 case C (SH64PCREL16PT_64, SH64PCREL16):
2164 case C (SH64PCREL16_64, SH64PCREL32):
2165 case C (SH64PCREL16PT_64, SH64PCREL32):
2166 case C (SH64PCREL16_64, SH64PCREL48):
2167 case C (SH64PCREL16PT_64, SH64PCREL48):
2168 case C (SH64PCREL16_64, SH64PCREL64):
2169 case C (SH64PCREL16PT_64, SH64PCREL64):
2170 case C (SH64PCREL16_64, SH64PCRELPLT):
2171 case C (SH64PCREL16PT_64, SH64PCRELPLT):
2172 case C (MOVI_IMM_32, MOVI_16):
2173 case C (MOVI_IMM_32, MOVI_32):
2174 case C (MOVI_IMM_32, MOVI_GOTOFF):
2175 case C (MOVI_IMM_32_PCREL, MOVI_16):
2176 case C (MOVI_IMM_32_PCREL, MOVI_32):
2177 case C (MOVI_IMM_32_PCREL, MOVI_PLT):
2178 case C (MOVI_IMM_32_PCREL, MOVI_GOTPC):
2179 case C (MOVI_IMM_64, MOVI_16):
2180 case C (MOVI_IMM_64, MOVI_32):
2181 case C (MOVI_IMM_64, MOVI_48):
2182 case C (MOVI_IMM_64, MOVI_64):
2183 case C (MOVI_IMM_64, MOVI_GOTOFF):
2184 case C (MOVI_IMM_64_PCREL, MOVI_16):
2185 case C (MOVI_IMM_64_PCREL, MOVI_32):
2186 case C (MOVI_IMM_64_PCREL, MOVI_48):
2187 case C (MOVI_IMM_64_PCREL, MOVI_64):
2188 case C (MOVI_IMM_64_PCREL, MOVI_PLT):
2189 case C (MOVI_IMM_64_PCREL, MOVI_GOTPC):
2190 fragP->fr_var = md_relax_table[fragP->fr_subtype].rlx_length;
2191 break;
2193 default:
2194 abort ();
2197 return fragP->fr_var + (fragP->fr_fix - old_fr_fix);
2200 /* Parse an expression, SH64-style. Copied from tc-sh.c, but with
2201 datatypes adjusted. */
2203 static char *
2204 shmedia_parse_exp (char *s, shmedia_operand_info *op)
2206 char *save;
2207 char *new;
2209 save = input_line_pointer;
2210 input_line_pointer = s;
2211 expression (&op->immediate);
2212 if (op->immediate.X_op == O_absent)
2213 as_bad (_("missing operand"));
2214 new = input_line_pointer;
2215 input_line_pointer = save;
2216 return new;
2219 /* Parse an operand. Store pointer to next character in *PTR. */
2221 static void
2222 shmedia_get_operand (char **ptr, shmedia_operand_info *op,
2223 shmedia_arg_type argtype)
2225 char *src = *ptr;
2226 int mode = -1;
2227 unsigned int len;
2229 len = shmedia_parse_reg (src, &mode, &(op->reg), argtype);
2230 if (len)
2232 *ptr = src + len;
2233 op->type = mode;
2235 else
2237 /* Not a reg, so it must be a displacement. */
2238 *ptr = shmedia_parse_exp (src, op);
2239 op->type = A_IMMM;
2241 /* This is just an initialization; shmedia_get_operands will change
2242 as needed. */
2243 op->reloctype = BFD_RELOC_NONE;
2247 /* Parse the operands for this insn; return NULL if invalid, else return
2248 how much text was consumed. */
2250 static char *
2251 shmedia_get_operands (shmedia_opcode_info *info, char *args,
2252 shmedia_operands_info *operands)
2254 char *ptr = args;
2255 int i;
2257 if (*ptr == ' ')
2258 ptr++;
2260 for (i = 0; info->arg[i] != 0; i++)
2262 memset (operands->operands + i, 0, sizeof (operands->operands[0]));
2264 /* No operand to get for these fields. */
2265 if (info->arg[i] == A_REUSE_PREV)
2266 continue;
2268 shmedia_get_operand (&ptr, &operands->operands[i], info->arg[i]);
2270 /* Check operands type match. */
2271 switch (info->arg[i])
2273 case A_GREG_M:
2274 case A_GREG_N:
2275 case A_GREG_D:
2276 if (operands->operands[i].type != A_GREG_M)
2277 return NULL;
2278 break;
2280 case A_FREG_G:
2281 case A_FREG_H:
2282 case A_FREG_F:
2283 if (operands->operands[i].type != A_FREG_G)
2284 return NULL;
2285 break;
2287 case A_FVREG_G:
2288 case A_FVREG_H:
2289 case A_FVREG_F:
2290 if (operands->operands[i].type != A_FVREG_G)
2291 return NULL;
2292 break;
2294 case A_FMREG_G:
2295 case A_FMREG_H:
2296 case A_FMREG_F:
2297 if (operands->operands[i].type != A_FMREG_G)
2298 return NULL;
2299 break;
2301 case A_FPREG_G:
2302 case A_FPREG_H:
2303 case A_FPREG_F:
2304 if (operands->operands[i].type != A_FPREG_G)
2305 return NULL;
2306 break;
2308 case A_DREG_G:
2309 case A_DREG_H:
2310 case A_DREG_F:
2311 if (operands->operands[i].type != A_DREG_G)
2312 return NULL;
2313 break;
2315 case A_TREG_A:
2316 case A_TREG_B:
2317 if (operands->operands[i].type != A_TREG_B)
2318 return NULL;
2319 break;
2321 case A_CREG_J:
2322 case A_CREG_K:
2323 if (operands->operands[i].type != A_CREG_K)
2324 return NULL;
2325 break;
2327 case A_IMMS16:
2328 case A_IMMU16:
2329 /* Check for an expression that looks like S & 65535 or
2330 (S >> N) & 65535, where N = 0, 16, 32, 48.
2332 Get the S and put at operands->operands[i].immediate, and
2333 adjust operands->operands[i].reloctype. */
2335 expressionS *imm_expr = &operands->operands[i].immediate;
2336 expressionS *right_expr;
2338 if (operands->operands[i].type == A_IMMM
2339 && imm_expr->X_op == O_bit_and
2340 && imm_expr->X_op_symbol != NULL
2341 && ((right_expr
2342 = symbol_get_value_expression (imm_expr->X_op_symbol))
2343 ->X_op == O_constant)
2344 && right_expr->X_add_number == 0xffff)
2346 symbolS *inner = imm_expr->X_add_symbol;
2347 bfd_reloc_code_real_type reloctype = BFD_RELOC_SH_IMM_LOW16;
2348 expressionS *inner_expr
2349 = symbol_get_value_expression (inner);
2351 if (inner_expr->X_op == O_right_shift)
2353 expressionS *inner_right;
2355 if (inner_expr->X_op_symbol != NULL
2356 && ((inner_right
2357 = symbol_get_value_expression (inner_expr
2358 ->X_op_symbol))
2359 ->X_op == O_constant))
2361 offsetT addnum
2362 = inner_right->X_add_number;
2364 if (addnum == 0 || addnum == 16 || addnum == 32
2365 || addnum == 48)
2367 reloctype
2368 = (addnum == 0
2369 ? BFD_RELOC_SH_IMM_LOW16
2370 : (addnum == 16
2371 ? BFD_RELOC_SH_IMM_MEDLOW16
2372 : (addnum == 32
2373 ? BFD_RELOC_SH_IMM_MEDHI16
2374 : BFD_RELOC_SH_IMM_HI16)));
2376 inner = inner_expr->X_add_symbol;
2377 inner_expr = symbol_get_value_expression (inner);
2382 /* I'm not sure I understand the logic, but evidently the
2383 inner expression of a lone symbol is O_constant, with
2384 the actual symbol in expr_section. For a constant, the
2385 section would be absolute_section. For sym+offset,
2386 it's O_symbol as always. See expr.c:make_expr_symbol,
2387 first statements. */
2389 if (inner_expr->X_op == O_constant
2390 && S_GET_SEGMENT (inner) != absolute_section)
2392 operands->operands[i].immediate.X_op = O_symbol;
2393 operands->operands[i].immediate.X_add_symbol = inner;
2394 operands->operands[i].immediate.X_add_number = 0;
2396 else
2397 operands->operands[i].immediate
2398 = *symbol_get_value_expression (inner);
2400 operands->operands[i].reloctype = reloctype;
2403 /* Fall through. */
2404 case A_IMMS6:
2405 case A_IMMS6BY32:
2406 case A_IMMS10:
2407 case A_IMMS10BY1:
2408 case A_IMMS10BY2:
2409 case A_IMMS10BY4:
2410 case A_IMMS10BY8:
2411 case A_PCIMMS16BY4:
2412 case A_PCIMMS16BY4_PT:
2413 case A_IMMU5:
2414 case A_IMMU6:
2415 if (operands->operands[i].type != A_IMMM)
2416 return NULL;
2418 if (sh_check_fixup (&operands->operands[i].immediate,
2419 &operands->operands[i].reloctype))
2421 as_bad (_("invalid PIC reference"));
2422 return NULL;
2425 break;
2427 default:
2428 BAD_CASE (info->arg[i]);
2431 if (*ptr == ',' && info->arg[i + 1])
2432 ptr++;
2434 return ptr;
2438 /* Find an opcode at the start of *STR_P in the hash table, and set
2439 *STR_P to the first character after the last one read. */
2441 static shmedia_opcode_info *
2442 shmedia_find_cooked_opcode (char **str_p)
2444 char *str = *str_p;
2445 char *op_start;
2446 char *op_end;
2447 char name[20];
2448 unsigned int nlen = 0;
2450 /* Drop leading whitespace. */
2451 while (*str == ' ')
2452 str++;
2454 /* Find the op code end. */
2455 for (op_start = op_end = str;
2456 *op_end
2457 && nlen < sizeof (name) - 1
2458 && ! is_end_of_line[(unsigned char) *op_end]
2459 && ! ISSPACE ((unsigned char) *op_end);
2460 op_end++)
2462 unsigned char c = op_start[nlen];
2464 /* The machine independent code will convert CMP/EQ into cmp/EQ
2465 because it thinks the '/' is the end of the symbol. Moreover,
2466 all but the first sub-insn is a parallel processing insn won't
2467 be capitalized. Instead of hacking up the machine independent
2468 code, we just deal with it here. */
2469 c = TOLOWER (c);
2470 name[nlen] = c;
2471 nlen++;
2474 name[nlen] = 0;
2475 *str_p = op_end;
2477 if (nlen == 0)
2478 as_bad (_("can't find opcode"));
2480 return
2481 (shmedia_opcode_info *) hash_find (shmedia_opcode_hash_control, name);
2484 /* Build up an instruction, including allocating the frag. */
2486 static int
2487 shmedia_build_Mytes (shmedia_opcode_info *opcode,
2488 shmedia_operands_info *operands)
2490 unsigned long insn = opcode->opcode_base;
2491 int i, j;
2492 char *insn_loc = frag_more (4);
2494 /* The parameter to dwarf2_emit_insn is actually the offset to the start
2495 of the insn from the fix piece of instruction that was emitted.
2496 Since we want .debug_line addresses to record (address | 1) for
2497 SHmedia insns, we get the wanted effect by taking one off the size,
2498 knowing it's a multiple of 4. We count from the first fix piece of
2499 the insn. There must be no frags changes (frag_more or frag_var)
2500 calls in-between the frag_more call we account for, and this
2501 dwarf2_emit_insn call. */
2502 dwarf2_emit_insn (3);
2504 /* This is stored into any frag_var operand. */
2505 sh64_last_insn_frag = frag_now;
2507 /* Loop over opcode info, emit an instruction. */
2508 for (i = 0, j = 0; opcode->arg[i]; i++)
2510 shmedia_arg_type argtype = opcode->arg[i];
2511 shmedia_operand_info *opjp = &operands->operands[j];
2512 switch (argtype)
2514 case A_TREG_A:
2515 case A_TREG_B:
2516 case A_GREG_M:
2517 case A_GREG_N:
2518 case A_GREG_D:
2519 case A_FREG_G:
2520 case A_FREG_H:
2521 case A_FREG_F:
2522 case A_FVREG_G:
2523 case A_FVREG_H:
2524 case A_FVREG_F:
2525 case A_FMREG_G:
2526 case A_FMREG_H:
2527 case A_FMREG_F:
2528 case A_FPREG_G:
2529 case A_FPREG_H:
2530 case A_FPREG_F:
2531 case A_DREG_G:
2532 case A_DREG_H:
2533 case A_DREG_F:
2534 case A_CREG_J:
2535 case A_CREG_K:
2536 /* Six-bit register fields. They just get filled with the
2537 parsed register number. */
2538 insn |= (opjp->reg << opcode->nibbles[i]);
2539 j++;
2540 break;
2542 case A_REUSE_PREV:
2543 /* Copy the register for the previous operand to this position. */
2544 insn |= (operands->operands[j - 1].reg << opcode->nibbles[i]);
2545 j++;
2546 break;
2548 case A_IMMS6:
2549 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2550 BFD_RELOC_SH_IMMS6);
2551 j++;
2552 break;
2554 case A_IMMS6BY32:
2555 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2556 BFD_RELOC_SH_IMMS6BY32);
2557 j++;
2558 break;
2560 case A_IMMS10BY1:
2561 case A_IMMS10:
2562 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2563 BFD_RELOC_SH_IMMS10);
2564 j++;
2565 break;
2567 case A_IMMS10BY2:
2568 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2569 BFD_RELOC_SH_IMMS10BY2);
2570 j++;
2571 break;
2573 case A_IMMS10BY4:
2574 if (opjp->reloctype == BFD_RELOC_NONE)
2575 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2576 BFD_RELOC_SH_IMMS10BY4);
2577 else if (opjp->reloctype == BFD_RELOC_SH_GOTPLT32)
2578 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2579 BFD_RELOC_SH_GOTPLT10BY4);
2580 else if (opjp->reloctype == BFD_RELOC_32_GOT_PCREL)
2581 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2582 BFD_RELOC_SH_GOT10BY4);
2583 else
2584 as_bad (_("invalid PIC reference"));
2585 j++;
2586 break;
2588 case A_IMMS10BY8:
2589 if (opjp->reloctype == BFD_RELOC_NONE)
2590 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2591 BFD_RELOC_SH_IMMS10BY8);
2592 else if (opjp->reloctype == BFD_RELOC_SH_GOTPLT32)
2593 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2594 BFD_RELOC_SH_GOTPLT10BY8);
2595 else if (opjp->reloctype == BFD_RELOC_32_GOT_PCREL)
2596 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2597 BFD_RELOC_SH_GOT10BY8);
2598 else
2599 as_bad (_("invalid PIC reference"));
2600 j++;
2601 break;
2603 case A_IMMS16:
2604 /* Sneak a peek if this is the MOVI insn. If so, check if we
2605 should expand it. */
2606 if (opjp->reloctype == BFD_RELOC_32_GOT_PCREL)
2607 opjp->reloctype = BFD_RELOC_SH_GOT_LOW16;
2608 else if (opjp->reloctype == BFD_RELOC_SH_GOTPLT32)
2609 opjp->reloctype = BFD_RELOC_SH_GOTPLT_LOW16;
2611 if ((opjp->reloctype == BFD_RELOC_NONE
2612 || opjp->reloctype == BFD_RELOC_32_GOTOFF
2613 || opjp->reloctype == BFD_RELOC_32_PLT_PCREL
2614 || opjp->reloctype == BFD_RELOC_SH_GOTPC)
2615 && opcode->opcode_base == SHMEDIA_MOVI_OPC
2616 && (opjp->immediate.X_op != O_constant
2617 || opjp->immediate.X_add_number < -32768
2618 || opjp->immediate.X_add_number > 32767)
2619 && (sh64_expand
2620 || opjp->reloctype == BFD_RELOC_32_GOTOFF
2621 || opjp->reloctype == BFD_RELOC_32_PLT_PCREL
2622 || opjp->reloctype == BFD_RELOC_SH_GOTPC))
2624 int what = sh64_abi == sh64_abi_64 ? MOVI_IMM_64 : MOVI_IMM_32;
2625 offsetT max = sh64_abi == sh64_abi_64 ? MOVI_64 : MOVI_32;
2626 offsetT min = MOVI_16;
2627 offsetT init = UNDEF_MOVI;
2628 valueT addvalue
2629 = opjp->immediate.X_op_symbol != NULL
2630 ? 0 : opjp->immediate.X_add_number;
2631 symbolS *sym
2632 = opjp->immediate.X_op_symbol != NULL
2633 ? make_expr_symbol (&opjp->immediate)
2634 : opjp->immediate.X_add_symbol;
2636 if (opjp->reloctype == BFD_RELOC_32_GOTOFF)
2637 init = max = min = MOVI_GOTOFF;
2638 else if (opjp->reloctype == BFD_RELOC_32_PLT_PCREL)
2640 init = max = min = MOVI_PLT;
2641 what = (sh64_abi == sh64_abi_64
2642 ? MOVI_IMM_64_PCREL
2643 : MOVI_IMM_32_PCREL);
2645 else if (opjp->reloctype == BFD_RELOC_SH_GOTPC)
2647 init = max = min = MOVI_GOTPC;
2648 what = (sh64_abi == sh64_abi_64
2649 ? MOVI_IMM_64_PCREL
2650 : MOVI_IMM_32_PCREL);
2653 frag_var (rs_machine_dependent,
2654 md_relax_table[C (what, max)].rlx_length,
2655 md_relax_table[C (what, min)].rlx_length,
2656 C (what, init), sym, addvalue, insn_loc);
2658 else
2659 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2660 (opjp->reloctype
2661 == BFD_RELOC_NONE)
2662 ? BFD_RELOC_SH_IMMS16
2663 : opjp->reloctype);
2664 j++;
2665 break;
2667 case A_PCIMMS16BY4:
2669 int what
2670 = ((sh64_abi == sh64_abi_64 && ! sh64_pt32)
2671 ? SH64PCREL16_64 : SH64PCREL16_32);
2672 offsetT max
2673 = ((sh64_abi == sh64_abi_64 && ! sh64_pt32)
2674 ? SH64PCREL64 : SH64PCREL32);
2675 offsetT min = SH64PCREL16;
2676 offsetT init = UNDEF_SH64PCREL;
2678 /* Don't allow complex expressions here. */
2679 if (opjp->immediate.X_op_symbol != NULL)
2681 as_bad(_("invalid operand: expression in PT target"));
2682 return 0;
2685 if (opjp->reloctype == BFD_RELOC_32_PLT_PCREL)
2686 init = max = min = SH64PCRELPLT;
2688 /* If we're not expanding, then just emit a fixup. */
2689 if (sh64_expand || opjp->reloctype != BFD_RELOC_NONE)
2690 frag_var (rs_machine_dependent,
2691 md_relax_table[C (what, max)].rlx_length,
2692 md_relax_table[C (what, min)].rlx_length,
2693 C (what, init),
2694 opjp->immediate.X_add_symbol,
2695 opjp->immediate.X_add_number,
2696 insn_loc);
2697 else
2698 insn |= shmedia_immediate_op (insn_loc, opjp, 1,
2699 opjp->reloctype == BFD_RELOC_NONE
2700 ? BFD_RELOC_SH_PT_16
2701 : opjp->reloctype);
2703 j++;
2704 break;
2707 case A_PCIMMS16BY4_PT:
2709 int what
2710 = ((sh64_abi == sh64_abi_64 && ! sh64_pt32)
2711 ? SH64PCREL16PT_64 : SH64PCREL16PT_32);
2712 offsetT max
2713 = ((sh64_abi == sh64_abi_64 && ! sh64_pt32)
2714 ? SH64PCREL64 : SH64PCREL32);
2715 offsetT min = SH64PCREL16;
2716 offsetT init = UNDEF_SH64PCREL;
2718 /* Don't allow complex expressions here. */
2719 if (opjp->immediate.X_op_symbol != NULL)
2721 as_bad(_("invalid operand: expression in PT target"));
2722 return 0;
2725 if (opjp->reloctype == BFD_RELOC_32_PLT_PCREL)
2726 init = max = min = SH64PCRELPLT;
2728 /* If we're not expanding, then just emit a fixup. */
2729 if (sh64_expand || opjp->reloctype != BFD_RELOC_NONE)
2730 frag_var (rs_machine_dependent,
2731 md_relax_table[C (what, max)].rlx_length,
2732 md_relax_table[C (what, min)].rlx_length,
2733 C (what, init),
2734 opjp->immediate.X_add_symbol,
2735 opjp->immediate.X_add_number,
2736 insn_loc);
2737 else
2738 /* This reloc-type is just temporary, so we can distinguish
2739 PTA from PT. It is changed in shmedia_md_apply_fix to
2740 BFD_RELOC_SH_PT_16. */
2741 insn |= shmedia_immediate_op (insn_loc, opjp, 1,
2742 opjp->reloctype == BFD_RELOC_NONE
2743 ? SHMEDIA_BFD_RELOC_PT
2744 : opjp->reloctype);
2746 j++;
2747 break;
2750 case A_IMMU5:
2751 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2752 BFD_RELOC_SH_IMMU5);
2753 j++;
2754 break;
2756 case A_IMMU6:
2757 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2758 BFD_RELOC_SH_IMMU6);
2759 j++;
2760 break;
2762 case A_IMMU16:
2763 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2764 (opjp->reloctype
2765 == BFD_RELOC_NONE)
2766 ? BFD_RELOC_SH_IMMU16
2767 : opjp->reloctype);
2768 j++;
2769 break;
2771 default:
2772 BAD_CASE (argtype);
2776 md_number_to_chars (insn_loc, insn, 4);
2777 return 4;
2780 /* Assemble a SHmedia instruction. */
2782 static void
2783 shmedia_md_assemble (char *str)
2785 char *op_end;
2786 shmedia_opcode_info *opcode;
2787 shmedia_operands_info operands;
2788 int size;
2790 opcode = shmedia_find_cooked_opcode (&str);
2791 op_end = str;
2793 if (opcode == NULL)
2795 as_bad (_("unknown opcode"));
2796 return;
2799 /* Start a SHmedia code region, if there has been pseudoinsns or similar
2800 seen since the last one. */
2801 if (!seen_insn)
2803 sh64_update_contents_mark (TRUE);
2804 sh64_set_contents_type (CRT_SH5_ISA32);
2805 seen_insn = TRUE;
2808 op_end = shmedia_get_operands (opcode, op_end, &operands);
2810 if (op_end == NULL)
2812 as_bad (_("invalid operands to %s"), opcode->name);
2813 return;
2816 if (*op_end)
2818 as_bad (_("excess operands to %s"), opcode->name);
2819 return;
2822 size = shmedia_build_Mytes (opcode, &operands);
2823 if (size == 0)
2824 return;
2827 /* Hook called from md_begin in tc-sh.c. */
2829 void
2830 shmedia_md_begin (void)
2832 const shmedia_opcode_info *shmedia_opcode;
2833 shmedia_opcode_hash_control = hash_new ();
2835 /* Create opcode table for SHmedia mnemonics. */
2836 for (shmedia_opcode = shmedia_table;
2837 shmedia_opcode->name;
2838 shmedia_opcode++)
2839 hash_insert (shmedia_opcode_hash_control, shmedia_opcode->name,
2840 (char *) shmedia_opcode);
2843 /* Switch instruction set. Only valid if one of the --isa or --abi
2844 options was specified. */
2846 static void
2847 s_sh64_mode (int ignore ATTRIBUTE_UNUSED)
2849 char *name = input_line_pointer, ch;
2851 /* Make sure data up to this location is handled according to the
2852 previous ISA. */
2853 sh64_update_contents_mark (TRUE);
2855 while (!is_end_of_line[(unsigned char) *input_line_pointer])
2856 input_line_pointer++;
2857 ch = *input_line_pointer;
2858 *input_line_pointer = '\0';
2860 /* If the mode was not set before, explicitly or implicitly, then we're
2861 not emitting SH64 code, so this pseudo is invalid. */
2862 if (sh64_isa_mode == sh64_isa_unspecified)
2863 as_bad (_("The `.mode %s' directive is not valid with this architecture"),
2864 name);
2866 if (strcasecmp (name, "shcompact") == 0)
2867 sh64_isa_mode = sh64_isa_shcompact;
2868 else if (strcasecmp (name, "shmedia") == 0)
2869 sh64_isa_mode = sh64_isa_shmedia;
2870 else
2871 as_bad (_("Invalid argument to .mode: %s"), name);
2873 /* Make a new frag, marking it with the supposedly-changed ISA. */
2874 frag_wane (frag_now);
2875 frag_new (0);
2877 /* Contents type up to this new point is the same as before; don't add a
2878 data region just because the new frag we created. */
2879 sh64_update_contents_mark (FALSE);
2881 *input_line_pointer = ch;
2882 demand_empty_rest_of_line ();
2885 /* Check that the right ABI is used. Only valid if one of the --isa or
2886 --abi options was specified. */
2888 static void
2889 s_sh64_abi (int ignore ATTRIBUTE_UNUSED)
2891 char *name = input_line_pointer, ch;
2893 while (!is_end_of_line[(unsigned char) *input_line_pointer])
2894 input_line_pointer++;
2895 ch = *input_line_pointer;
2896 *input_line_pointer = '\0';
2898 /* If the mode was not set before, explicitly or implicitly, then we're
2899 not emitting SH64 code, so this pseudo is invalid. */
2900 if (sh64_abi == sh64_abi_unspecified)
2901 as_bad (_("The `.abi %s' directive is not valid with this architecture"),
2902 name);
2904 if (strcmp (name, "64") == 0)
2906 if (sh64_abi != sh64_abi_64)
2907 as_bad (_("`.abi 64' but command-line options do not specify 64-bit ABI"));
2909 else if (strcmp (name, "32") == 0)
2911 if (sh64_abi != sh64_abi_32)
2912 as_bad (_("`.abi 32' but command-line options do not specify 32-bit ABI"));
2914 else
2915 as_bad (_("Invalid argument to .abi: %s"), name);
2917 *input_line_pointer = ch;
2918 demand_empty_rest_of_line ();
2921 /* This function is the first target-specific function called after
2922 parsing command-line options. Therefore we set default values from
2923 command-line options here and do some sanity checking we couldn't do
2924 when options were being parsed. */
2926 const char *
2927 sh64_target_format (void)
2929 #ifdef TE_NetBSD
2930 /* For NetBSD, if the ISA is unspecified, always use SHmedia. */
2931 if (preset_target_arch == 0 && sh64_isa_mode == sh64_isa_unspecified)
2932 sh64_isa_mode = sh64_isa_shmedia;
2934 /* If the ABI is unspecified, select a default: based on how
2935 we were configured: sh64 == sh64_abi_64, else sh64_abi_32. */
2936 if (sh64_abi == sh64_abi_unspecified)
2938 if (preset_target_arch != 0 || sh64_isa_mode == sh64_isa_shcompact)
2939 sh64_abi = sh64_abi_32;
2940 else if (strncmp (TARGET_CPU, "sh64", 4) == 0)
2941 sh64_abi = sh64_abi_64;
2942 else
2943 sh64_abi = sh64_abi_32;
2945 #endif
2947 #ifdef TE_LINUX
2948 if (preset_target_arch == 0 && sh64_isa_mode == sh64_isa_unspecified)
2949 sh64_isa_mode = sh64_isa_shmedia;
2951 if (sh64_abi == sh64_abi_unspecified)
2952 sh64_abi = sh64_abi_32;
2953 #endif
2955 if (sh64_abi == sh64_abi_64 && sh64_isa_mode == sh64_isa_unspecified)
2956 sh64_isa_mode = sh64_isa_shmedia;
2958 if (sh64_abi == sh64_abi_32 && sh64_isa_mode == sh64_isa_unspecified)
2959 sh64_isa_mode = sh64_isa_shcompact;
2961 if (sh64_isa_mode == sh64_isa_shcompact
2962 && sh64_abi == sh64_abi_unspecified)
2963 sh64_abi = sh64_abi_32;
2965 if (sh64_isa_mode == sh64_isa_shmedia
2966 && sh64_abi == sh64_abi_unspecified)
2967 sh64_abi = sh64_abi_64;
2969 if (sh64_isa_mode == sh64_isa_unspecified && ! sh64_mix)
2970 as_bad (_("-no-mix is invalid without specifying SHcompact or SHmedia"));
2972 if ((sh64_isa_mode == sh64_isa_unspecified
2973 || sh64_isa_mode == sh64_isa_shmedia)
2974 && sh64_shcompact_const_crange)
2975 as_bad (_("-shcompact-const-crange is invalid without SHcompact"));
2977 if (sh64_pt32 && sh64_abi != sh64_abi_64)
2978 as_bad (_("-expand-pt32 only valid with -abi=64"));
2980 if (! sh64_expand && sh64_isa_mode == sh64_isa_unspecified)
2981 as_bad (_("-no-expand only valid with SHcompact or SHmedia"));
2983 if (sh64_pt32 && ! sh64_expand)
2984 as_bad (_("-expand-pt32 invalid together with -no-expand"));
2986 #ifdef TE_NetBSD
2987 if (sh64_abi == sh64_abi_64)
2988 return (target_big_endian ? "elf64-sh64-nbsd" : "elf64-sh64l-nbsd");
2989 else
2990 return (target_big_endian ? "elf32-sh64-nbsd" : "elf32-sh64l-nbsd");
2991 #elif defined (TE_LINUX)
2992 if (sh64_abi == sh64_abi_64)
2993 return (target_big_endian ? "elf64-sh64big-linux" : "elf64-sh64-linux");
2994 else
2995 return (target_big_endian ? "elf32-sh64big-linux" : "elf32-sh64-linux");
2996 #else
2997 /* When the ISA is not one of SHmedia or SHcompact, use the old SH
2998 object format. */
2999 if (sh64_isa_mode == sh64_isa_unspecified)
3000 return (target_big_endian ? "elf32-sh" : "elf32-shl");
3001 else if (sh64_abi == sh64_abi_64)
3002 return (target_big_endian ? "elf64-sh64" : "elf64-sh64l");
3003 else
3004 return (target_big_endian ? "elf32-sh64" : "elf32-sh64l");
3005 #endif
3008 /* The worker function of TARGET_MACH. */
3011 sh64_target_mach (void)
3013 /* We need to explicitly set bfd_mach_sh5 instead of the default 0. But
3014 we only do this for the 64-bit ABI: if we do it for the 32-bit ABI,
3015 the SH5 info in the bfd_arch_info structure will be selected.
3016 However correct, as the machine has 64-bit addresses, functions
3017 expected to emit 32-bit data for addresses will start failing. For
3018 example, the dwarf2dbg.c functions will emit 64-bit debugging format,
3019 and we don't want that in the 32-bit ABI.
3021 We could have two bfd_arch_info structures for SH64; one for the
3022 32-bit ABI and one for the rest (64-bit ABI). But that would be a
3023 bigger kludge: it's a flaw in the BFD design, and we need to just
3024 work around it by having the default machine set here in the
3025 assembler. For everything else but the assembler, the various bfd
3026 functions will set the machine type right to bfd_mach_sh5 from object
3027 file header flags regardless of the 0 here. */
3029 return (sh64_abi == sh64_abi_64) ? bfd_mach_sh5 : 0;
3032 /* This is MD_PCREL_FROM_SECTION, we we define so it is called instead of
3033 md_pcrel_from (in tc-sh.c). */
3035 valueT
3036 shmedia_md_pcrel_from_section (struct fix *fixP, segT sec ATTRIBUTE_UNUSED)
3038 know (fixP->fx_frag->fr_type == rs_machine_dependent);
3040 /* Use the ISA for the instruction to decide which offset to use. We
3041 can glean it from the fisup type. */
3042 switch (fixP->fx_r_type)
3044 case BFD_RELOC_SH_IMM_LOW16:
3045 case BFD_RELOC_SH_IMM_MEDLOW16:
3046 case BFD_RELOC_SH_IMM_MEDHI16:
3047 case BFD_RELOC_SH_IMM_HI16:
3048 case BFD_RELOC_SH_IMM_LOW16_PCREL:
3049 case BFD_RELOC_SH_IMM_MEDLOW16_PCREL:
3050 case BFD_RELOC_SH_IMM_MEDHI16_PCREL:
3051 case BFD_RELOC_SH_IMM_HI16_PCREL:
3052 case BFD_RELOC_SH_IMMU5:
3053 case BFD_RELOC_SH_IMMU6:
3054 case BFD_RELOC_SH_IMMS6:
3055 case BFD_RELOC_SH_IMMS10:
3056 case BFD_RELOC_SH_IMMS10BY2:
3057 case BFD_RELOC_SH_IMMS10BY4:
3058 case BFD_RELOC_SH_IMMS10BY8:
3059 case BFD_RELOC_SH_IMMS16:
3060 case BFD_RELOC_SH_IMMU16:
3061 case BFD_RELOC_SH_PT_16:
3062 case SHMEDIA_BFD_RELOC_PT:
3063 /* PC-relative relocs are relative to the address of the last generated
3064 instruction, i.e. fx_size - 4. */
3065 return SHMEDIA_MD_PCREL_FROM_FIX (fixP);
3067 case BFD_RELOC_64:
3068 case BFD_RELOC_64_PCREL:
3069 know (0 /* Shouldn't get here. */);
3070 break;
3072 default:
3073 /* If section was SHcompact, use its function. */
3074 return (valueT) md_pcrel_from_section (fixP, sec);
3077 know (0 /* Shouldn't get here. */);
3078 return 0;
3081 /* Create one .cranges descriptor from two symbols, STARTSYM marking begin
3082 and ENDSYM marking end, and CR_TYPE specifying the type. */
3084 static void
3085 sh64_emit_crange (symbolS *startsym, symbolS *endsym,
3086 enum sh64_elf_cr_type cr_type)
3088 expressionS exp;
3089 segT current_seg = now_seg;
3090 subsegT current_subseg = now_subseg;
3092 asection *cranges
3093 = bfd_make_section_old_way (stdoutput,
3094 SH64_CRANGES_SECTION_NAME);
3096 /* Temporarily change to the .cranges section. */
3097 subseg_set (cranges, 0);
3099 /* Emit the cr_addr part. */
3100 exp.X_op = O_symbol;
3101 exp.X_add_number = 0;
3102 exp.X_op_symbol = NULL;
3103 exp.X_add_symbol = startsym;
3104 emit_expr (&exp, 4);
3106 /* Emit the cr_size part. */
3107 exp.X_op = O_subtract;
3108 exp.X_add_number = 0;
3109 exp.X_add_symbol = endsym;
3110 exp.X_op_symbol = startsym;
3111 emit_expr (&exp, 4);
3113 /* Emit the cr_size part. */
3114 exp.X_op = O_constant;
3115 exp.X_add_number = cr_type;
3116 exp.X_add_symbol = NULL;
3117 exp.X_op_symbol = NULL;
3118 emit_expr (&exp, 2);
3120 /* Now back to our regular program. */
3121 subseg_set (current_seg, current_subseg);
3124 /* Called when the assembler is about to emit contents of some type into
3125 SEG, so it is *known* that the type of that new contents is in
3126 NEW_CONTENTS_TYPE. If just switching back and forth between different
3127 contents types (for example, with consecutive .mode pseudos), then this
3128 function isn't called. */
3130 static void
3131 sh64_set_contents_type (enum sh64_elf_cr_type new_contents_type)
3133 segment_info_type *seginfo;
3135 /* We will not be called when emitting .cranges output, since callers
3136 stop that. Validize that assumption. */
3137 know (!emitting_crange);
3139 seginfo = seg_info (now_seg);
3141 if (seginfo)
3143 symbolS *symp = seginfo->tc_segment_info_data.last_contents_mark;
3145 enum sh64_elf_cr_type contents_type
3146 = seginfo->tc_segment_info_data.contents_type;
3148 /* If it was just SHcompact switching between code and constant
3149 pool, don't change contents type. Just make sure we don't set
3150 the contents type to data, as that would join with a data-region
3151 in SHmedia mode. */
3152 if (sh64_isa_mode == sh64_isa_shcompact
3153 && ! sh64_shcompact_const_crange)
3154 new_contents_type = CRT_SH5_ISA16;
3156 /* If nothing changed, stop here. */
3157 if (contents_type == new_contents_type)
3158 return;
3160 /* If we're in 64-bit ABI mode, we do not emit .cranges, as it is
3161 only specified for 32-bit addresses. It could presumably be
3162 extended, but in 64-bit ABI mode we don't have SHcompact code, so
3163 we would only use it to mark code and data. */
3164 if (sh64_abi == sh64_abi_64)
3166 /* Make the code type "sticky". We don't want to set the
3167 sections contents type to data if there's any code in it as
3168 we don't have .cranges in 64-bit mode to notice the
3169 difference. */
3170 seginfo->tc_segment_info_data.contents_type
3171 = (new_contents_type == CRT_SH5_ISA32
3172 || contents_type == CRT_SH5_ISA32)
3173 ? CRT_SH5_ISA32 : new_contents_type;
3174 return;
3177 /* If none was marked, create a start symbol for this range and
3178 perhaps as a closing symbol for the old one. */
3179 if (symp == NULL)
3180 symp = symbol_new (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (),
3181 frag_now);
3183 /* We will use this symbol, so don't leave a pointer behind. */
3184 seginfo->tc_segment_info_data.last_contents_mark = NULL;
3186 /* We'll be making only datalabel references to it, if we emit a
3187 .cranges descriptor, so remove any code flag. */
3188 S_SET_OTHER (symp, S_GET_OTHER (symp) & ~STO_SH5_ISA32);
3190 /* If we have already marked the start of a range, we need to close
3191 and emit it before marking a new one, so emit a new .cranges
3192 descriptor into the .cranges section. */
3193 if (seginfo->tc_segment_info_data.mode_start_symbol)
3195 /* If we're not supposed to emit mixed-mode sections, make it an
3196 error, but continue processing. */
3197 if (! sh64_mix
3198 && (new_contents_type == CRT_SH5_ISA32
3199 || contents_type == CRT_SH5_ISA32))
3200 as_bad (
3201 _("SHmedia code not allowed in same section as constants and SHcompact code"));
3203 emitting_crange = TRUE;
3204 sh64_emit_crange (seginfo->tc_segment_info_data.mode_start_symbol,
3205 symp, contents_type);
3206 emitting_crange = FALSE;
3207 seginfo->tc_segment_info_data.emitted_ranges++;
3210 seginfo->tc_segment_info_data.mode_start_symbol = symp;
3211 seginfo->tc_segment_info_data.mode_start_subseg = now_subseg;
3212 seginfo->tc_segment_info_data.contents_type = new_contents_type;
3214 /* Always reset this, so the SHcompact code will emit a reloc when
3215 it prepares to relax. */
3216 seginfo->tc_segment_info_data.in_code = 0;
3218 else
3219 as_bad (_("No segment info for current section"));
3222 /* Hook when defining symbols and labels. We set the ST_OTHER field if
3223 the symbol is "shmedia" (with "bitor 1" automatically applied). Simple
3224 semantics for a label being "shmedia" : It was defined when .mode
3225 SHmedia was in effect, and it was defined in a code section. It
3226 doesn't matter whether or not an assembled opcode is nearby. */
3228 void
3229 sh64_frob_label (symbolS *symp)
3231 segT seg = S_GET_SEGMENT (symp);
3232 static const symbolS *null = NULL;
3234 /* Reset the tc marker for all newly created symbols. */
3235 symbol_set_tc (symp, (symbolS **) &null);
3237 if (seg != NULL && sh64_isa_mode == sh64_isa_shmedia && subseg_text_p (seg))
3238 S_SET_OTHER (symp, S_GET_OTHER (symp) | STO_SH5_ISA32);
3241 /* Handle the "datalabel" qualifier. We need to call "operand", but it's
3242 static, so a function pointer is passed here instead. FIXME: A target
3243 hook for qualifiers is needed; we currently use the md_parse_name
3244 symbol hook. */
3247 sh64_consume_datalabel (const char *name, expressionS *exp, char *cp,
3248 segT (*operandf) (expressionS *))
3250 static int parsing_datalabel = 0;
3252 if (strcasecmp (name, "datalabel") == 0)
3254 int save_parsing_datalabel = parsing_datalabel;
3256 if (parsing_datalabel)
3257 as_bad (_("duplicate datalabel operator ignored"));
3259 *input_line_pointer = *cp;
3260 parsing_datalabel = 1;
3261 (*operandf) (exp);
3262 parsing_datalabel = save_parsing_datalabel;
3264 if (exp->X_op == O_symbol || exp->X_op == O_PIC_reloc)
3266 symbolS *symp = exp->X_add_symbol;
3267 segT symseg = S_GET_SEGMENT (symp);
3269 /* If the symbol is defined to something that is already a
3270 datalabel, we don't need to bother with any special handling. */
3271 if (symseg != undefined_section
3272 && S_GET_OTHER (symp) != STO_SH5_ISA32)
3273 /* Do nothing. */
3275 else
3277 symbolS *dl_symp;
3278 const char *name = S_GET_NAME (symp);
3279 char *dl_name
3280 = xmalloc (strlen (name) + sizeof (DATALABEL_SUFFIX));
3282 /* Now we copy the datalabel-qualified symbol into a symbol
3283 with the same name, but with " DL" appended. We mark the
3284 symbol using the TC_SYMFIELD_TYPE field with a pointer to
3285 the main symbol, so we don't have to inspect all symbol
3286 names. Note that use of "datalabel" is not expected to
3287 be a common case. */
3288 strcpy (dl_name, name);
3289 strcat (dl_name, DATALABEL_SUFFIX);
3291 /* A FAKE_LABEL_NAME marks "$" or ".". There can be any
3292 number of them and all have the same (faked) name; we
3293 must make a new one each time. */
3294 if (strcmp (name, FAKE_LABEL_NAME) == 0)
3295 dl_symp = symbol_make (dl_name);
3296 else
3297 dl_symp = symbol_find_or_make (dl_name);
3299 free (dl_name);
3300 symbol_set_value_expression (dl_symp,
3301 symbol_get_value_expression (symp));
3302 S_SET_SEGMENT (dl_symp, symseg);
3303 symbol_set_frag (dl_symp, symbol_get_frag (symp));
3304 symbol_set_tc (dl_symp, &symp);
3305 copy_symbol_attributes (dl_symp, symp);
3306 exp->X_add_symbol = dl_symp;
3308 /* Unset the BranchTarget mark that can be set at symbol
3309 creation or attributes copying. */
3310 S_SET_OTHER (dl_symp, S_GET_OTHER (dl_symp) & ~STO_SH5_ISA32);
3312 /* The GLOBAL and WEAK attributes are not copied over by
3313 copy_symbol_attributes. Do it here. */
3314 if (S_IS_WEAK (symp))
3315 S_SET_WEAK (dl_symp);
3316 else if (S_IS_EXTERNAL (symp))
3317 S_SET_EXTERNAL (dl_symp);
3320 /* Complain about other types of operands than symbol, unless they
3321 have already been complained about. A constant is always a
3322 datalabel. Removing the low bit would therefore be wrong.
3323 Complaining about it would also be wrong. */
3324 else if (exp->X_op != O_illegal
3325 && exp->X_op != O_absent
3326 && exp->X_op != O_constant)
3327 as_bad (_("Invalid DataLabel expression"));
3329 *cp = *input_line_pointer;
3331 return 1;
3334 return sh_parse_name (name, exp, cp);
3337 /* This function is called just before symbols are being output. It
3338 returns zero when a symbol must be output, non-zero otherwise.
3339 Datalabel references that were fully resolved to local symbols are not
3340 necessary to output. We also do not want to output undefined symbols
3341 that are not used in relocs. For symbols that are used in a reloc, it
3342 does not matter what we set here. If it is *not* used in a reloc, then
3343 it was probably the datalabel counterpart that was used in a reloc;
3344 then we need not output the main symbol. */
3347 sh64_exclude_symbol (symbolS *symp)
3349 symbolS *main_symbol = *symbol_get_tc (symp);
3351 return main_symbol != NULL || ! S_IS_DEFINED (symp);
3354 /* If we haven't seen an insn since the last update, and location
3355 indicators have moved (a new frag, new location within frag) we have
3356 emitted data, so change contents type to data. Forget that we have
3357 seen a sequence of insns and store the current location so we can mark
3358 a new region if needed. */
3360 static void
3361 sh64_update_contents_mark (bfd_boolean update_type)
3363 segment_info_type *seginfo;
3364 seginfo = seg_info (now_seg);
3366 if (seginfo != NULL)
3368 symbolS *symp = seginfo->tc_segment_info_data.last_contents_mark;
3370 if (symp == NULL)
3372 symp = symbol_new (FAKE_LABEL_NAME, now_seg,
3373 (valueT) frag_now_fix (), frag_now);
3374 seginfo->tc_segment_info_data.last_contents_mark = symp;
3376 else
3378 /* If we have moved location since last flush, we need to emit a
3379 data range. The previous contents type ended at the location
3380 of the last update. */
3381 if ((S_GET_VALUE (symp) != frag_now_fix ()
3382 || symbol_get_frag (symp) != frag_now))
3384 enum sh64_elf_cr_type contents_type
3385 = seginfo->tc_segment_info_data.contents_type;
3387 if (update_type
3388 && contents_type != CRT_DATA
3389 && contents_type != CRT_NONE
3390 && ! seen_insn)
3392 sh64_set_contents_type (CRT_DATA);
3393 symp = seginfo->tc_segment_info_data.last_contents_mark;
3396 /* If the symbol wasn't used up to make up a new range
3397 descriptor, update it to this new location. */
3398 if (symp)
3400 S_SET_VALUE (symp, (valueT) frag_now_fix ());
3401 symbol_set_frag (symp, frag_now);
3407 seen_insn = FALSE;
3410 /* Called when the assembler is about to output some data, or maybe it's
3411 just switching segments. */
3413 void
3414 sh64_flush_pending_output (void)
3416 sh64_update_contents_mark (TRUE);
3417 sh_flush_pending_output ();
3420 /* Flush out the last crange descriptor after all insns have been emitted. */
3422 static void
3423 sh64_flush_last_crange (bfd *abfd ATTRIBUTE_UNUSED, asection *seg,
3424 void *countparg ATTRIBUTE_UNUSED)
3426 segment_info_type *seginfo;
3428 seginfo = seg_info (seg);
3430 if (seginfo
3431 /* Only emit .cranges descriptors if we would make it more than one. */
3432 && seginfo->tc_segment_info_data.emitted_ranges != 0)
3434 symbolS *symp;
3436 /* We need a closing symbol, so switch to the indicated section and
3437 emit it. */
3439 /* Change to the section we're about to handle. */
3440 subseg_set (seg, seginfo->tc_segment_info_data.mode_start_subseg);
3442 symp = symbol_new (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (),
3443 frag_now);
3445 /* We'll be making a datalabel reference to it, so remove any code
3446 flag. */
3447 S_SET_OTHER (symp, S_GET_OTHER (symp) & ~STO_SH5_ISA32);
3449 sh64_emit_crange (seginfo->tc_segment_info_data.mode_start_symbol,
3450 symp,
3451 seginfo->tc_segment_info_data.contents_type);
3455 /* If and only if we see a call to md_number_to_chars without flagging the
3456 start of an insn, we set the contents type to CRT_DATA, and only when
3457 in SHmedia mode. Note that by default we don't bother changing when
3458 going from SHcompact to data, as the constant pools in GCC-generated
3459 SHcompact code would create an inordinate amount of .cranges
3460 descriptors. */
3462 static void
3463 sh64_flag_output (void)
3465 if (sh64_isa_mode != sh64_isa_unspecified
3466 && !seen_insn
3467 && !sh64_end_of_assembly
3468 && !emitting_crange)
3470 md_flush_pending_output ();
3471 sh64_set_contents_type (CRT_DATA);
3475 /* Vtables don't need "datalabel" but we allow it by simply deleting
3476 any we find. */
3478 static char *
3479 strip_datalabels (void)
3481 char *src, *dest, *start=input_line_pointer;
3483 for (src=input_line_pointer, dest=input_line_pointer; *src != '\n'; )
3485 if (strncasecmp (src, "datalabel", 9) == 0
3486 && ISSPACE (src[9])
3487 && (src == start || !(ISALNUM (src[-1])) || src[-1] == '_'))
3488 src += 10;
3489 else
3490 *dest++ = *src++;
3493 if (dest < src)
3494 *dest = '\n';
3495 return src + 1;
3498 static void
3499 sh64_vtable_entry (int ignore ATTRIBUTE_UNUSED)
3501 char *eol = strip_datalabels ();
3503 obj_elf_vtable_entry (0);
3504 input_line_pointer = eol;
3507 static void
3508 sh64_vtable_inherit (int ignore ATTRIBUTE_UNUSED)
3510 char *eol = strip_datalabels ();
3512 obj_elf_vtable_inherit (0);
3513 input_line_pointer = eol;
3517 sh64_fake_label (const char *name)
3519 size_t len;
3521 if (strcmp (name, FAKE_LABEL_NAME) == 0)
3522 return 1;
3524 len = strlen (name);
3525 if (len >= (sizeof (DATALABEL_SUFFIX) - 1))
3526 return strcmp (&name [len - sizeof (DATALABEL_SUFFIX) + 1],
3527 DATALABEL_SUFFIX) == 0;
3529 return 0;