projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2004-01-01 Michael Chastain <mec.gnu@mindspring.com>
[deliverable/binutils-gdb.git] / gas / config / tc-sh64.c
CommitLineData
ef230218 1/* tc-sh64.c -- Assemble code for the SuperH SH SHcompact and SHmedia.
f0abc2a1 2 Copyright 2000, 2001, 2002, 2003 Free Software Foundation.
324bfcf3
AO		 3
4 This file is part of GAS, the GNU Assembler.
5
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.
10
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.
15
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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
20
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. */
25
26#define HAVE_SH64
27
28#include <stdio.h>
29#include "as.h"
30#include "safe-ctype.h"
31#include "opcodes/sh64-opc.h"
32
33#ifndef OBJ_ELF
34#error This file assumes object output is in the ELF format
35#endif
36
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"
41
42/* See shmedia_md_apply_fix3 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)
45
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
51
52typedef struct
53 {
54 shmedia_arg_type type;
55
56 /* These could go into a union, but that would uglify the code. */
57 int reg;
58 expressionS immediate;
59
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;
67
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. */
71fragS *sh64_last_insn_frag = NULL;
72
73typedef struct
74 {
75 shmedia_operand_info operands[3];
76 unsigned long ops_val;
77 } shmedia_operands_info;
78
79enum sh64_abi_values
80 { sh64_abi_unspecified, sh64_abi_32, sh64_abi_64 };
81
82/* What ISA are we assembling code for? */
83enum sh64_isa_values sh64_isa_mode = sh64_isa_unspecified;
84
85/* What ABI was specified, if any (implicitly or explicitly)? */
86static enum sh64_abi_values sh64_abi = sh64_abi_unspecified;
87
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. */
b34976b6 90static bfd_boolean seen_insn = FALSE;
324bfcf3 91
b34976b6 92/* This is set to TRUE in shmedia_md_end, so that we don't emit any
324bfcf3
AO		 93 .cranges entries when the assembler calls output functions while
94 grinding along after all input is seen. */
b34976b6 95static bfd_boolean sh64_end_of_assembly = FALSE;
324bfcf3
AO		 96
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. */
b34976b6 102static bfd_boolean sh64_mix = TRUE;
324bfcf3 103
b34976b6 104static bfd_boolean sh64_shcompact_const_crange = FALSE;
324bfcf3
AO		 105
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. */
b34976b6 110static bfd_boolean sh64_expand = TRUE;
324bfcf3
AO		 111
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. */
b34976b6 115static bfd_boolean sh64_pt32 = FALSE;
324bfcf3
AO		 116
117/* When emitting a .cranges descriptor, we want to avoid getting recursive
118 calls through emit_expr. */
b34976b6 119static bfd_boolean emitting_crange = FALSE;
324bfcf3
AO		 120
121/* SHmedia mnemonics. */
122static struct hash_control *shmedia_opcode_hash_control = NULL;
123
124static const unsigned char shmedia_big_nop_pattern[4] =
125 {
126 (SHMEDIA_NOP_OPC >> 24) & 255, (SHMEDIA_NOP_OPC >> 16) & 255,
127 (SHMEDIA_NOP_OPC >> 8) & 255, SHMEDIA_NOP_OPC & 255
128 };
129
130static const unsigned char shmedia_little_nop_pattern[4] =
131 {
132 SHMEDIA_NOP_OPC & 255, (SHMEDIA_NOP_OPC >> 8) & 255,
133 (SHMEDIA_NOP_OPC >> 16) & 255, (SHMEDIA_NOP_OPC >> 24) & 255
134 };
135
8edc77b9
KK		 136static void shmedia_md_begin (void);
137static int shmedia_parse_reg (char *, int *, int *, shmedia_arg_type);
138static void shmedia_md_assemble (char *);
139static void shmedia_md_apply_fix3 (fixS *, valueT *);
140static int shmedia_md_estimate_size_before_relax (fragS *, segT);
141static int shmedia_init_reloc (arelent *, fixS *);
142static char *shmedia_get_operands (shmedia_opcode_info *, char *,
143 shmedia_operands_info *);
144static void s_sh64_mode (int);
145static void s_sh64_abi (int);
146static void shmedia_md_convert_frag (bfd *, segT, fragS *, bfd_boolean);
147static void shmedia_check_limits (offsetT *, bfd_reloc_code_real_type,
148 fixS *);
149static void sh64_set_contents_type (enum sh64_elf_cr_type);
150static void shmedia_get_operand (char **, shmedia_operand_info *,
151 shmedia_arg_type);
152static unsigned long shmedia_immediate_op (char *, shmedia_operand_info *,
153 int, bfd_reloc_code_real_type);
154static char *shmedia_parse_exp (char *, shmedia_operand_info *);
155static void shmedia_frob_file_before_adjust (void);
156static void sh64_emit_crange (symbolS *, symbolS *, enum sh64_elf_cr_type);
157static void sh64_flush_last_crange (bfd *, asection *, void *);
158static void sh64_flag_output (void);
159static void sh64_update_contents_mark (bfd_boolean);
160static void sh64_vtable_entry (int);
161static void sh64_vtable_inherit (int);
162static char *strip_datalabels (void);
163static int shmedia_build_Mytes (shmedia_opcode_info *,
164 shmedia_operands_info *);
165static shmedia_opcode_info *shmedia_find_cooked_opcode (char **);
166static unsigned long shmedia_mask_number (unsigned long,
167 bfd_reloc_code_real_type);
324bfcf3
AO		 168
169#include "tc-sh.c"
170
171void
8edc77b9 172shmedia_md_end (void)
324bfcf3
AO		 173{
174 symbolS *symp;
175
176 /* First, update the last range to include whatever data was last
177 emitted. */
b34976b6 178 sh64_update_contents_mark (TRUE);
324bfcf3
AO		 179
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;
186
b34976b6 187 sh64_end_of_assembly = TRUE;
324bfcf3
AO		 188
189 bfd_map_over_sections (stdoutput, sh64_flush_last_crange, NULL);
190
191 /* Iterate over segments and emit the last .cranges descriptor. */
192 for (symp = symbol_rootP; symp != NULL; symp = symp->sy_next)
193 {
194 symbolS *mainsym = *symbol_get_tc (symp);
195
196 /* Is this a datalabel symbol; does it have a pointer to the main
197 symbol? */
198 if (mainsym != NULL)
199 {
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)
203 {
204 segT symseg;
205
206 symseg = S_GET_SEGMENT (mainsym);
207
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)
213 {
214 if (S_GET_OTHER (mainsym) != STO_SH5_ISA32)
215 {
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);
223 }
224 else
225 {
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);
237
238 /* Unset the BranchTarget mark that can be set at
5d6255fe 239 attribute-copying. */
324bfcf3 240 S_SET_OTHER (symp,
5d6255fe 241 S_GET_OTHER (symp) & ~STO_SH5_ISA32);
324bfcf3
AO		 242
243 /* The GLOBAL and WEAK attributes are not copied
5d6255fe 244 over by copy_symbol_attributes. Do it here. */
324bfcf3
AO		 245 if (S_IS_WEAK (mainsym))
246 S_SET_WEAK (symp);
247 else if (S_IS_EXTERNAL (mainsym))
248 S_SET_EXTERNAL (symp);
249 }
250 }
251 else
252 {
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);
260 }
261 }
262 }
263 }
264
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++;
268}
269
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. */
276
277static void
8edc77b9 278shmedia_frob_file_before_adjust (void)
324bfcf3
AO		 279{
280 symbolS *symp;
281 for (symp = symbol_rootP; symp != NULL; symp = symp->sy_next)
282 {
283 symbolS *mainsym = *symbol_get_tc (symp);
284
285 if (mainsym != NULL
286 && S_GET_OTHER (mainsym) != STO_SH5_ISA32
287 && (S_IS_EXTERN (mainsym) || S_IS_WEAK (mainsym)))
288 {
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;
293
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);
299
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);
303 }
304 }
305}
306
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.
310
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. */
315
316void
8edc77b9 317sh64_do_align (int n, const char *fill, int len, int max)
324bfcf3
AO		 318{
319 /* Update region, or put a data region in front. */
b34976b6 320 sh64_update_contents_mark (TRUE);
324bfcf3
AO		 321
322 /* Only make a frag if we HAVE to... */
323 if (n != 0 && !need_pass_2)
324 {
325 if (fill == NULL)
326 {
327 if (subseg_text_p (now_seg))
328 frag_align_code (n, max);
329 else
330 frag_align (n, 0, max);
331 }
332 else if (len <= 1)
333 frag_align (n, *fill, max);
334 else
335 frag_align_pattern (n, fill, len, max);
336 }
337
338 /* Update mark for current region with current type. */
b34976b6 339 sh64_update_contents_mark (FALSE);
324bfcf3
AO		 340}
341
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). */
348
349int
8edc77b9 350sh64_max_mem_for_rs_align_code (void)
324bfcf3
AO		 351{
352 segment_info_type *seginfo;
353 fragS *mode_start_frag;
354 seginfo = seg_info (now_seg);
355
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);
377}
378
379/* Put in SHmedia NOP:s if the alignment was created when in SHmedia mode. */
380
381void
8edc77b9 382sh64_handle_align (fragS * frag)
324bfcf3
AO		 383{
384 int bytes = frag->fr_next->fr_address - frag->fr_address - frag->fr_fix;
385 char * p = frag->fr_literal + frag->fr_fix;
386
387 if (frag->tc_frag_data.isa == sh64_isa_shmedia
388 && frag->fr_type == rs_align_code)
389 {
390 while (bytes & 3)
391 {
392 *p++ = 0;
393 bytes--;
394 frag->fr_fix += 1;
395 }
396
397 if (target_big_endian)
398 {
399 memcpy (p, shmedia_big_nop_pattern,
400 sizeof shmedia_big_nop_pattern);
401 frag->fr_var = sizeof shmedia_big_nop_pattern;
402 }
403 else
404 {
405 memcpy (p, shmedia_little_nop_pattern,
406 sizeof shmedia_little_nop_pattern);
407 frag->fr_var = sizeof shmedia_little_nop_pattern;
408 }
409 }
410 else
411 /* Punt to SHcompact function. */
412 sh_handle_align (frag);
413}
414
415/* Set SEC_SH64_ISA32 for SHmedia sections. */
416
417void
8edc77b9 418shmedia_frob_section_type (asection *sec)
324bfcf3
AO		 419{
420 segment_info_type *seginfo;
421 seginfo = seg_info (sec);
422
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. */
0d78efdf 430 if (seginfo && sh64_abi == sh64_abi_32)
324bfcf3
AO		 431 {
432 struct sh64_section_data *sec_elf_data;
433 flagword sec_type = 0;
434
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;
439
f0abc2a1 440 sec_elf_data = sh64_elf_section_data (sec)->sh64_info;
324bfcf3
AO		 441 if (sec_elf_data == NULL)
442 {
443 sec_elf_data = xcalloc (1, sizeof (*sec_elf_data));
f0abc2a1 444 sh64_elf_section_data (sec)->sh64_info = sec_elf_data;
324bfcf3
AO		 445 }
446
447 sec_elf_data->contents_flags = sec_type;
448 }
449}
450
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.
455
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. */
461
462void
8edc77b9 463sh64_adjust_symtab (void)
324bfcf3
AO		 464{
465 symbolS *symp;
466
467 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
468 {
469 symbolS *main_symbol = *symbol_get_tc (symp);
470
471 if (main_symbol)
472 {
473 char *sym_name = (char *) S_GET_NAME (symp);
5d6255fe 474
324bfcf3
AO		 475 /* All datalabels not used in relocs should be gone by now.
476
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;
483
484 /* Also set this symbol to "undefined", so we'll have only one
485 definition. */
486 S_SET_SEGMENT (symp, undefined_section);
487 }
488 else if (S_GET_OTHER (symp) & STO_SH5_ISA32)
489 {
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--;
493
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. */
504 }
505 }
506}
507
508/* Fill-in an allocated arelent. */
509
510static int
8edc77b9 511shmedia_init_reloc (arelent *rel, fixS *fixP)
324bfcf3
AO		 512{
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)
516 {
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;
563
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;
570
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:
574 ;
575 }
576
577 return 0;
578}
579
580/* Hook called from md_apply_fix3 in tc-sh.c. */
581
582static void
8edc77b9 583shmedia_md_apply_fix3 (fixS *fixP, valueT *valp)
324bfcf3
AO		 584{
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;
590
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)
594 {
595 switch (orig_fx_r_type)
596 {
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_fix3, 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;
612
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;
623
624 default:
625 ;
626 }
627
628 /* We might need to change some relocs into the corresponding
629 PC-relative one. */
630 switch (orig_fx_r_type)
631 {
632 case BFD_RELOC_64:
633 fixP->fx_r_type = BFD_RELOC_64_PCREL;
634 break;
635
636 case BFD_RELOC_SH_IMM_LOW16:
637 fixP->fx_r_type = BFD_RELOC_SH_IMM_LOW16_PCREL;
638 break;
639
640 case BFD_RELOC_SH_IMM_MEDLOW16:
641 fixP->fx_r_type = BFD_RELOC_SH_IMM_MEDLOW16_PCREL;
642 break;
643
644 case BFD_RELOC_SH_IMM_MEDHI16:
645 fixP->fx_r_type = BFD_RELOC_SH_IMM_MEDHI16_PCREL;
646 break;
647
648 case BFD_RELOC_SH_IMM_HI16:
649 fixP->fx_r_type = BFD_RELOC_SH_IMM_HI16_PCREL;
650 break;
651
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;
659
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;
668
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;
676
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;
683 }
684
685 return;
686 }
687
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)
692 {
693 /* Emit error for an out-of-range value. */
694 shmedia_check_limits (valp, fixP->fx_r_type, fixP);
695
696 switch (fixP->fx_r_type)
697 {
698 case BFD_RELOC_SH_IMM_LOW16:
699 md_number_to_chars (buf, insn | ((val & 65535) << 10), 4);
700 break;
701
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;
708
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;
715
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;
722
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;
727
728 case BFD_RELOC_SH_IMMS10:
729 md_number_to_chars (buf, insn | ((val & 0x3ff) << 10), 4);
730 break;
731
732 case BFD_RELOC_SH_IMMS10BY2:
733 md_number_to_chars (buf,
734 insn | ((val & (0x3ff << 1)) << (10 - 1)), 4);
735 break;
736
737 case BFD_RELOC_SH_IMMS10BY4:
738 md_number_to_chars (buf,
739 insn | ((val & (0x3ff << 2)) << (10 - 2)), 4);
740 break;
741
742 case BFD_RELOC_SH_SHMEDIA_CODE:
743 /* We just ignore and remove this one for the moment. FIXME:
744 Use it when implementing relaxing. */
745 break;
746
747 case BFD_RELOC_64:
748 md_number_to_chars (buf, val, 8);
749 break;
750
751 case SHMEDIA_BFD_RELOC_PT:
752 /* Change a PT to PTB if the operand turned out to be SHcompact.
753 The basic opcode specified with PT is equivalent to PTA. */
754 if ((val & 1) == 0)
755 insn |= SHMEDIA_PTB_BIT;
756 /* Fall through. */
757
758 case BFD_RELOC_SH_PT_16:
759 if (! sh64_expand || sh_relax)
760 {
761 /* Check if the operand of a PTA or PTB was for the "wrong"
762 ISA. A PT had an incoming fixup of SHMEDIA_BFD_RELOC_PT,
763 which we have changed to the right type above. */
764 if (orig_fx_r_type != SHMEDIA_BFD_RELOC_PT)
765 {
766 if ((insn & SHMEDIA_PTB_BIT) != 0 && (val & 1) != 0)
767 as_bad_where (fixP->fx_file, fixP->fx_line,
768 _("PTB operand is a SHmedia symbol"));
769 else if ((insn & SHMEDIA_PTB_BIT) == 0 && (val & 1) == 0)
770 as_bad_where (fixP->fx_file, fixP->fx_line,
771 _("PTA operand is a SHcompact symbol"));
772 }
773
774 md_number_to_chars (buf,
775 insn | ((val & (0xffff << 2))
776 << (10 - 2)),
777 4);
778 break;
779 }
780 /* Fall through. */
781
782 default:
783 /* This isn't a BAD_CASE, because presumably we can get here
784 from unexpected operands. Since we don't handle them, make
785 them syntax errors. */
786 as_bad_where (fixP->fx_file, fixP->fx_line,
787 _("invalid expression in operand"));
788 }
789 fixP->fx_done = 1;
790 }
791}
792
793/* Hook called from md_convert_frag in tc-sh.c. */
794
795static void
8edc77b9
KK		 796shmedia_md_convert_frag (bfd *output_bfd ATTRIBUTE_UNUSED,
797 segT seg ATTRIBUTE_UNUSED, fragS *fragP,
798 bfd_boolean final)
324bfcf3
AO		 799{
800 /* Pointer to first byte in variable-sized part of the frag. */
801 char *var_partp;
802
803 /* Pointer to first opcode byte in frag. */
804 char *opcodep;
805
806 /* Pointer to frag of opcode. */
807 fragS *opc_fragP = fragP->tc_frag_data.opc_frag;
808
809 /* Size in bytes of variable-sized part of frag. */
810 int var_part_size = 0;
811
812 /* This is part of *fragP. It contains all information about addresses
813 and offsets to varying parts. */
814 symbolS *symbolP = fragP->fr_symbol;
815
b34976b6 816 bfd_boolean reloc_needed
324bfcf3
AO		 817 = (! final
818 || sh_relax
819 || symbolP == NULL
820 || ! S_IS_DEFINED (symbolP)
821 || S_IS_EXTERN (symbolP)
822 || S_IS_WEAK (symbolP)
823 || (S_GET_SEGMENT (fragP->fr_symbol) != absolute_section
824 && S_GET_SEGMENT (fragP->fr_symbol) != seg));
825
826 bfd_reloc_code_real_type reloctype = BFD_RELOC_NONE;
827
828 unsigned long var_part_offset;
829
830 /* Where, in file space, does addr point? */
831 bfd_vma target_address;
832 bfd_vma opcode_address;
833
834 /* What was the insn? */
835 unsigned long insn;
836 know (fragP->fr_type == rs_machine_dependent);
837
838 var_part_offset = fragP->fr_fix;
839 var_partp = fragP->fr_literal + var_part_offset;
840 opcodep = fragP->fr_opcode;
841
842 insn = target_big_endian ? bfd_getb32 (opcodep) : bfd_getl32 (opcodep);
843
844 target_address
845 = ((symbolP && final && ! sh_relax ? S_GET_VALUE (symbolP) : 0)
846 + fragP->fr_offset);
847
848 /* The opcode that would be extended is the last four "fixed" bytes. */
849 opcode_address = fragP->fr_address + fragP->fr_fix - 4;
850
851 switch (fragP->fr_subtype)
852 {
853 case C (SH64PCREL16PT_64, SH64PCREL16):
854 case C (SH64PCREL16PT_32, SH64PCREL16):
855 /* We can get a PT to a relaxed SHcompact address if it is in the
856 same section; a mixed-ISA section. Change the opcode to PTB if
857 so. */
858 if ((target_address & 1) == 0)
859 insn |= SHMEDIA_PTB_BIT;
860 /* Fall through. */
861
862 case C (SH64PCREL16_32, SH64PCREL16):
863 case C (SH64PCREL16_64, SH64PCREL16):
864 /* Check that a PTA or PTB points to the right type of target. We
865 can get here for a SHcompact target if we are in a mixed-ISA
866 section. */
867 if (((target_address & 1) == 0) && ((insn & SHMEDIA_PTB_BIT) == 0))
868 as_bad_where (fragP->fr_file, fragP->fr_line,
869 _("PTA operand is a SHcompact symbol"));
870 if (((target_address & 1) != 0) && ((insn & SHMEDIA_PTB_BIT) != 0))
871 as_bad_where (fragP->fr_file, fragP->fr_line,
872 _("PTB operand is a SHmedia symbol"));
873
874 /* When relaxing, we do not output the address in the insn, but
875 instead a 1 into the low bit. This matches what the linker
876 expects to find for a BFD_RELOC_SH_PT_16 reloc, when it checks
877 correctness for PTA/PTB insn; used when the target address is
878 unknown (which is not the case here). */
879 md_number_to_chars (opcodep,
880 insn
881 | (((sh_relax
882 ? 1 : ((target_address - opcode_address) / 4))
883 & ((1 << 16) - 1)) << 10),
884 4);
885
886 /* Note that we do not emit info that this was originally a PT since
887 we have resolved to which one of PTA or PTB it will be. */
888 if (sh_relax)
889 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
890 fragP->fr_symbol, fragP->fr_offset, 1, BFD_RELOC_SH_PT_16);
891 var_part_size = 0;
892 break;
893
894 case C (SH64PCREL16_32, SH64PCRELPLT):
895 case C (SH64PCREL16PT_32, SH64PCRELPLT):
896 reloctype = BFD_RELOC_32_PLT_PCREL;
897 reloc_needed = 1;
898 /* Fall through */
899
900 case C (SH64PCREL16_32, SH64PCREL32):
901 case C (SH64PCREL16_64, SH64PCREL32):
902 case C (SH64PCREL16PT_32, SH64PCREL32):
903 case C (SH64PCREL16PT_64, SH64PCREL32):
904 /* In the fixed bit, put in a MOVI. */
905 md_number_to_chars (opcodep,
906 SHMEDIA_MOVI_OPC
907 | (SHMEDIA_TEMP_REG << 4)
908 | ((((reloc_needed
909 ? 0 : (target_address - (opcode_address + 8))
910 ) >> 16) & 65535) << 10),
911 4);
912
913 /* Fill in a SHORI for the low part. */
914 md_number_to_chars (var_partp,
915 SHMEDIA_SHORI_OPC
916 | (SHMEDIA_TEMP_REG << 4)
917 | (((reloc_needed
918 ? 0 : (target_address - (opcode_address + 8)))
919 & 65535) << 10),
920 4);
921
922 /* End with a "PTREL R25,TRd". */
923 md_number_to_chars (var_partp + 4,
924 SHMEDIA_PTREL_OPC | (insn & SHMEDIA_LIKELY_BIT)
925 | (SHMEDIA_TEMP_REG << 10)
926 | (insn & (7 << 4)),
927 4);
928
929 /* We need relocs only if the target symbol was undefined or if
930 we're relaxing. */
931 if (reloc_needed)
932 {
933 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
934 fragP->fr_symbol, fragP->fr_offset - 8, 1,
935 reloctype == BFD_RELOC_32_PLT_PCREL
936 ? BFD_RELOC_SH_PLT_MEDLOW16
937 : BFD_RELOC_SH_IMM_MEDLOW16_PCREL);
938 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
939 fragP->fr_offset - 4, 1,
940 reloctype == BFD_RELOC_32_PLT_PCREL
941 ? BFD_RELOC_SH_PLT_LOW16
942 : BFD_RELOC_SH_IMM_LOW16_PCREL);
943 }
944
945 var_part_size = 8;
946 break;
947
948 case C (SH64PCREL16_64, SH64PCREL48):
949 case C (SH64PCREL16PT_64, SH64PCREL48):
950 /* In the fixed bit, put in a MOVI. */
951 md_number_to_chars (opcodep,
952 SHMEDIA_MOVI_OPC
953 | (SHMEDIA_TEMP_REG << 4)
954 | ((((reloc_needed
955 ? 0 : (target_address - (opcode_address + 12))
956 ) >> 32) & 65535) << 10),
957 4);
958
959 /* The first SHORI, for the medium part. */
960 md_number_to_chars (var_partp,
961 SHMEDIA_SHORI_OPC
962 | (SHMEDIA_TEMP_REG << 4)
963 | ((((reloc_needed
964 ? 0 : (target_address - (opcode_address + 12))
965 ) >> 16) & 65535) << 10),
966 4);
967
968 /* Fill in a SHORI for the low part. */
969 md_number_to_chars (var_partp + 4,
970 SHMEDIA_SHORI_OPC
971 | (SHMEDIA_TEMP_REG << 4)
972 | (((reloc_needed
973 ? 0 : (target_address - (opcode_address + 12)))
974 & 65535) << 10),
975 4);
976
977 /* End with a "PTREL R25,TRd". */
978 md_number_to_chars (var_partp + 8,
979 SHMEDIA_PTREL_OPC | (insn & SHMEDIA_LIKELY_BIT)
980 | (SHMEDIA_TEMP_REG << 10)
981 | (insn & (7 << 4)),
982 4);
983
984 /* We need relocs only if the target symbol was undefined or if
985 we're relaxing. */
986 if (reloc_needed)
987 {
988 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
989 fragP->fr_symbol, fragP->fr_offset - 12, 1,
990 reloctype == BFD_RELOC_32_PLT_PCREL
991 ? BFD_RELOC_SH_PLT_MEDHI16
992 : BFD_RELOC_SH_IMM_MEDHI16_PCREL);
993 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
994 fragP->fr_offset - 8, 1,
995 reloctype == BFD_RELOC_32_PLT_PCREL
996 ? BFD_RELOC_SH_PLT_MEDLOW16
997 : BFD_RELOC_SH_IMM_MEDLOW16_PCREL);
998 fix_new (fragP, var_partp - fragP->fr_literal + 4, 4, fragP->fr_symbol,
999 fragP->fr_offset - 4, 1,
1000 reloctype == BFD_RELOC_32_PLT_PCREL
1001 ? BFD_RELOC_SH_PLT_LOW16
1002 : BFD_RELOC_SH_IMM_LOW16_PCREL);
1003 }
1004
1005 var_part_size = 12;
1006 break;
1007
1008 case C (SH64PCREL16_64, SH64PCRELPLT):
1009 case C (SH64PCREL16PT_64, SH64PCRELPLT):
1010 reloctype = BFD_RELOC_32_PLT_PCREL;
1011 reloc_needed = 1;
1012 /* Fall through */
1013
1014 case C (SH64PCREL16_64, SH64PCREL64):
1015 case C (SH64PCREL16PT_64, SH64PCREL64):
1016 /* In the fixed bit, put in a MOVI. */
1017 md_number_to_chars (opcodep,
1018 SHMEDIA_MOVI_OPC
1019 | (SHMEDIA_TEMP_REG << 4)
1020 | ((((reloc_needed
1021 ? 0 : (target_address - (opcode_address + 16))
1022 ) >> 48) & 65535) << 10),
1023 4);
1024
1025 /* The first SHORI, for the medium-high part. */
1026 md_number_to_chars (var_partp,
1027 SHMEDIA_SHORI_OPC
1028 | (SHMEDIA_TEMP_REG << 4)
1029 | ((((reloc_needed
1030 ? 0 : (target_address - (opcode_address + 16))
1031 ) >> 32) & 65535) << 10),
1032 4);
1033
1034 /* A SHORI, for the medium-low part. */
1035 md_number_to_chars (var_partp + 4,
1036 SHMEDIA_SHORI_OPC
1037 | (SHMEDIA_TEMP_REG << 4)
1038 | ((((reloc_needed
1039 ? 0 : (target_address - (opcode_address + 16))
1040 ) >> 16) & 65535) << 10),
1041 4);
1042
1043 /* Fill in a SHORI for the low part. */
1044 md_number_to_chars (var_partp + 8,
1045 SHMEDIA_SHORI_OPC
1046 | (SHMEDIA_TEMP_REG << 4)
1047 | (((reloc_needed
1048 ? 0 : (target_address - (opcode_address + 16)))
1049 & 65535) << 10),
1050 4);
1051
1052 /* End with a "PTREL R25,TRd". */
1053 md_number_to_chars (var_partp + 12,
1054 SHMEDIA_PTREL_OPC | (insn & SHMEDIA_LIKELY_BIT)
1055 | (SHMEDIA_TEMP_REG << 10)
1056 | (insn & (7 << 4)),
1057 4);
1058
1059 /* We need relocs only if the target symbol was undefined or if
1060 we're relaxing. */
1061 if (reloc_needed)
1062 {
1063 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1064 fragP->fr_symbol, fragP->fr_offset - 16, 1,
1065 reloctype == BFD_RELOC_32_PLT_PCREL
1066 ? BFD_RELOC_SH_PLT_HI16
1067 : BFD_RELOC_SH_IMM_HI16_PCREL);
1068 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1069 fragP->fr_offset - 12, 1,
1070 reloctype == BFD_RELOC_32_PLT_PCREL
1071 ? BFD_RELOC_SH_PLT_MEDHI16
1072 : BFD_RELOC_SH_IMM_MEDHI16_PCREL);
1073 fix_new (fragP, var_partp - fragP->fr_literal + 4, 4, fragP->fr_symbol,
1074 fragP->fr_offset - 8, 1,
1075 reloctype == BFD_RELOC_32_PLT_PCREL
1076 ? BFD_RELOC_SH_PLT_MEDLOW16
1077 : BFD_RELOC_SH_IMM_MEDLOW16_PCREL);
1078 fix_new (fragP, var_partp - fragP->fr_literal + 8, 4, fragP->fr_symbol,
1079 fragP->fr_offset - 4, 1,
1080 reloctype == BFD_RELOC_32_PLT_PCREL
1081 ? BFD_RELOC_SH_PLT_LOW16
1082 : BFD_RELOC_SH_IMM_LOW16_PCREL);
1083 }
1084
1085 var_part_size = 16;
1086 break;
1087
1088 case C (MOVI_IMM_64, MOVI_GOTOFF):
1089 reloctype = BFD_RELOC_32_GOTOFF;
1090 reloc_needed = 1;
1091 /* Fall through. */
5d6255fe 1092
324bfcf3
AO		 1093 case C (MOVI_IMM_64, UNDEF_MOVI):
1094 case C (MOVI_IMM_64, MOVI_64):
1095 {
1096 /* We only get here for undefined symbols, so we can simplify
1097 handling compared to those above; we have 0 in the parts that
1098 will be filled with the symbol parts. */
1099
1100 int reg = (insn >> 4) & 0x3f;
1101
1102 /* In the fixed bit, put in a MOVI. */
1103 md_number_to_chars (opcodep, SHMEDIA_MOVI_OPC | (reg << 4), 4);
1104 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1105 fragP->fr_symbol, fragP->fr_offset, 0,
1106 reloctype == BFD_RELOC_NONE
1107 ? BFD_RELOC_SH_IMM_HI16
1108 : reloctype == BFD_RELOC_32_GOTOFF
1109 ? BFD_RELOC_SH_GOTOFF_HI16
1110 : (abort (), BFD_RELOC_SH_IMM_HI16));
1111
1112 /* The first SHORI, for the medium-high part. */
1113 md_number_to_chars (var_partp, SHMEDIA_SHORI_OPC | (reg << 4), 4);
1114 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1115 fragP->fr_offset, 0,
1116 reloctype == BFD_RELOC_NONE
1117 ? BFD_RELOC_SH_IMM_MEDHI16
1118 : reloctype == BFD_RELOC_32_GOTOFF
1119 ? BFD_RELOC_SH_GOTOFF_MEDHI16
1120 : (abort (), BFD_RELOC_SH_IMM_MEDHI16));
1121
1122 /* A SHORI, for the medium-low part. */
1123 md_number_to_chars (var_partp + 4,
1124 SHMEDIA_SHORI_OPC | (reg << 4), 4);
1125 fix_new (fragP, var_partp - fragP->fr_literal + 4, 4, fragP->fr_symbol,
1126 fragP->fr_offset, 0,
1127 reloctype == BFD_RELOC_NONE
1128 ? BFD_RELOC_SH_IMM_MEDLOW16
1129 : reloctype == BFD_RELOC_32_GOTOFF
1130 ? BFD_RELOC_SH_GOTOFF_MEDLOW16
1131 : (abort (), BFD_RELOC_SH_IMM_MEDLOW16));
1132
1133 /* Fill in a SHORI for the low part. */
1134 md_number_to_chars (var_partp + 8,
1135 SHMEDIA_SHORI_OPC | (reg << 4), 4);
1136 fix_new (fragP, var_partp - fragP->fr_literal + 8, 4, fragP->fr_symbol,
1137 fragP->fr_offset, 0,
1138 reloctype == BFD_RELOC_NONE
1139 ? BFD_RELOC_SH_IMM_LOW16
1140 : reloctype == BFD_RELOC_32_GOTOFF
1141 ? BFD_RELOC_SH_GOTOFF_LOW16
1142 : (abort (), BFD_RELOC_SH_IMM_LOW16));
1143
1144 var_part_size = 12;
1145 break;
1146 }
1147
1148 case C (MOVI_IMM_32, MOVI_GOTOFF):
1149 reloctype = BFD_RELOC_32_GOTOFF;
1150 reloc_needed = 1;
1151 /* Fall through. */
5d6255fe 1152
324bfcf3
AO		 1153 case C (MOVI_IMM_32, UNDEF_MOVI):
1154 case C (MOVI_IMM_32, MOVI_32):
1155 {
1156 /* Note that we only get here for undefined symbols. */
1157
1158 int reg = (insn >> 4) & 0x3f;
1159
1160 /* A MOVI, for the high part. */
1161 md_number_to_chars (opcodep, SHMEDIA_MOVI_OPC | (reg << 4), 4);
1162 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1163 fragP->fr_symbol, fragP->fr_offset, 0,
1164 reloctype == BFD_RELOC_NONE
1165 ? BFD_RELOC_SH_IMM_MEDLOW16
1166 : reloctype == BFD_RELOC_32_GOTOFF
1167 ? BFD_RELOC_SH_GOTOFF_MEDLOW16
1168 : reloctype == BFD_RELOC_SH_GOTPC
1169 ? BFD_RELOC_SH_GOTPC_MEDLOW16
1170 : reloctype == BFD_RELOC_32_PLT_PCREL
1171 ? BFD_RELOC_SH_PLT_MEDLOW16
1172 : (abort (), BFD_RELOC_SH_IMM_MEDLOW16));
1173
1174 /* Fill in a SHORI for the low part. */
1175 md_number_to_chars (var_partp,
1176 SHMEDIA_SHORI_OPC | (reg << 4), 4);
1177 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1178 fragP->fr_offset, 0,
1179 reloctype == BFD_RELOC_NONE
1180 ? BFD_RELOC_SH_IMM_LOW16
1181 : reloctype == BFD_RELOC_32_GOTOFF
1182 ? BFD_RELOC_SH_GOTOFF_LOW16
1183 : reloctype == BFD_RELOC_SH_GOTPC
1184 ? BFD_RELOC_SH_GOTPC_LOW16
1185 : reloctype == BFD_RELOC_32_PLT_PCREL
1186 ? BFD_RELOC_SH_PLT_LOW16
1187 : (abort (), BFD_RELOC_SH_IMM_LOW16));
1188
1189 var_part_size = 4;
1190 break;
1191 }
1192
1193 case C (MOVI_IMM_32_PCREL, MOVI_16):
1194 case C (MOVI_IMM_64_PCREL, MOVI_16):
1195 md_number_to_chars (opcodep,
1196 insn
1197 | (((reloc_needed
1198 ? 0 : (target_address - opcode_address))
1199 & 65535) << 10),
1200 4);
1201 if (reloc_needed)
1202 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1203 fragP->fr_symbol, fragP->fr_offset, 1,
1204 BFD_RELOC_SH_IMM_LOW16_PCREL);
1205 var_part_size = 0;
1206 break;
1207
1208 case C (MOVI_IMM_32, MOVI_16):
1209 case C (MOVI_IMM_64, MOVI_16):
1210 md_number_to_chars (opcodep,
1211 insn
1212 | (((reloc_needed ? 0 : target_address)
1213 & 65535) << 10),
1214 4);
1215 if (reloc_needed)
1216 abort ();
1217 var_part_size = 0;
1218 break;
1219
1220 case C (MOVI_IMM_32_PCREL, MOVI_PLT):
1221 reloctype = BFD_RELOC_32_PLT_PCREL;
1222 goto movi_imm_32_pcrel_reloc_needed;
1223
1224 case C (MOVI_IMM_32_PCREL, MOVI_GOTPC):
1225 reloctype = BFD_RELOC_SH_GOTPC;
1226 /* Fall through. */
1227
1228 movi_imm_32_pcrel_reloc_needed:
1229 reloc_needed = 1;
1230 /* Fall through. */
1231
1232 case C (MOVI_IMM_32_PCREL, MOVI_32):
1233 case C (MOVI_IMM_64_PCREL, MOVI_32):
1234 {
1235 int reg = (insn >> 4) & 0x3f;
1236
1237 md_number_to_chars (opcodep,
1238 insn
1239 | (((((reloc_needed
1240 ? 0 : (target_address - opcode_address)))
1241 >> 16) & 65535) << 10), 4);
1242
1243 /* A SHORI, for the low part. */
1244 md_number_to_chars (var_partp,
1245 SHMEDIA_SHORI_OPC
1246 | (reg << 4)
1247 | (((reloc_needed
1248 ? 0 : (target_address - opcode_address))
1249 & 65535) << 10), 4);
1250 if (reloc_needed)
1251 {
1252 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1253 fragP->fr_symbol, fragP->fr_offset, 1,
1254 reloctype == BFD_RELOC_NONE
1255 ? BFD_RELOC_SH_IMM_MEDLOW16_PCREL
1256 : reloctype == BFD_RELOC_SH_GOTPC
1257 ? BFD_RELOC_SH_GOTPC_MEDLOW16
1258 : reloctype == BFD_RELOC_32_PLT_PCREL
1259 ? BFD_RELOC_SH_PLT_MEDLOW16
1260 : (abort (), BFD_RELOC_SH_IMM_MEDLOW16_PCREL));
1261 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1262 fragP->fr_offset + 4, 1,
1263 reloctype == BFD_RELOC_NONE
1264 ? BFD_RELOC_SH_IMM_LOW16_PCREL
1265 : reloctype == BFD_RELOC_SH_GOTPC
1266 ? BFD_RELOC_SH_GOTPC_LOW16
1267 : reloctype == BFD_RELOC_32_PLT_PCREL
1268 ? BFD_RELOC_SH_PLT_LOW16
1269 : (abort (), BFD_RELOC_SH_IMM_LOW16_PCREL));
1270 }
1271 var_part_size = 4;
1272 }
1273 break;
1274
1275 case C (MOVI_IMM_32_PCREL, MOVI_48):
1276 case C (MOVI_IMM_64_PCREL, MOVI_48):
1277 {
1278 int reg = (insn >> 4) & 0x3f;
1279
1280 md_number_to_chars (opcodep,
1281 insn
1282 | (((((reloc_needed
1283 ? 0 : (target_address - opcode_address)))
1284 >> 32) & 65535) << 10), 4);
1285
1286 /* A SHORI, for the medium part. */
1287 md_number_to_chars (var_partp,
1288 SHMEDIA_SHORI_OPC
1289 | (reg << 4)
1290 | ((((reloc_needed
1291 ? 0 : (target_address - opcode_address))
1292 >> 16) & 65535) << 10), 4);
1293
1294 /* A SHORI, for the low part. */
1295 md_number_to_chars (var_partp + 4,
1296 SHMEDIA_SHORI_OPC
1297 | (reg << 4)
1298 | (((reloc_needed
1299 ? 0 : (target_address - opcode_address))
1300 & 65535) << 10), 4);
1301 if (reloc_needed)
1302 {
1303 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1304 fragP->fr_symbol, fragP->fr_offset, 1,
1305 BFD_RELOC_SH_IMM_MEDHI16_PCREL);
1306 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1307 fragP->fr_offset + 4, 1, BFD_RELOC_SH_IMM_MEDLOW16_PCREL);
1308 fix_new (fragP, var_partp - fragP->fr_literal + 4, 4, fragP->fr_symbol,
1309 fragP->fr_offset + 8, 1, BFD_RELOC_SH_IMM_LOW16_PCREL);
1310 }
1311 var_part_size = 8;
1312 }
1313 break;
1314
1315 case C (MOVI_IMM_64_PCREL, MOVI_PLT):
1316 reloctype = BFD_RELOC_32_PLT_PCREL;
1317 goto movi_imm_64_pcrel_reloc_needed;
1318
1319 case C (MOVI_IMM_64_PCREL, MOVI_GOTPC):
1320 reloctype = BFD_RELOC_SH_GOTPC;
1321 /* Fall through. */
1322
1323 movi_imm_64_pcrel_reloc_needed:
1324 reloc_needed = 1;
1325 /* Fall through. */
5d6255fe 1326
324bfcf3
AO		 1327 case C (MOVI_IMM_32_PCREL, MOVI_64):
1328 case C (MOVI_IMM_64_PCREL, MOVI_64):
1329 {
1330 int reg = (insn >> 4) & 0x3f;
1331
1332 md_number_to_chars (opcodep,
1333 insn
1334 | (((((reloc_needed
1335 ? 0 : (target_address - opcode_address)))
1336 >> 48) & 65535) << 10), 4);
1337
1338 /* A SHORI, for the medium-high part. */
1339 md_number_to_chars (var_partp,
1340 SHMEDIA_SHORI_OPC
1341 | (reg << 4)
1342 | ((((reloc_needed
1343 ? 0 : (target_address - opcode_address))
1344 >> 32) & 65535) << 10), 4);
1345
1346 /* A SHORI, for the medium-low part. */
1347 md_number_to_chars (var_partp + 4,
1348 SHMEDIA_SHORI_OPC
1349 | (reg << 4)
1350 | ((((reloc_needed
1351 ? 0 : (target_address - opcode_address))
1352 >> 16) & 65535) << 10), 4);
1353
1354 /* A SHORI, for the low part. */
1355 md_number_to_chars (var_partp + 8,
1356 SHMEDIA_SHORI_OPC
1357 | (reg << 4)
1358 | (((reloc_needed
1359 ? 0 : (target_address - opcode_address))
1360 & 65535) << 10), 4);
1361 if (reloc_needed)
1362 {
1363 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1364 fragP->fr_symbol, fragP->fr_offset, 1,
1365 reloctype == BFD_RELOC_NONE
1366 ? BFD_RELOC_SH_IMM_HI16_PCREL
1367 : reloctype == BFD_RELOC_SH_GOTPC
1368 ? BFD_RELOC_SH_GOTPC_HI16
1369 : reloctype == BFD_RELOC_32_PLT_PCREL
1370 ? BFD_RELOC_SH_PLT_HI16
1371 : (abort (), BFD_RELOC_SH_IMM_HI16_PCREL));
1372 fix_new (fragP, var_partp - fragP->fr_literal, 4, fragP->fr_symbol,
1373 fragP->fr_offset + 4, 1,
1374 reloctype == BFD_RELOC_NONE
1375 ? BFD_RELOC_SH_IMM_MEDHI16_PCREL
1376 : reloctype == BFD_RELOC_SH_GOTPC
1377 ? BFD_RELOC_SH_GOTPC_MEDHI16
1378 : reloctype == BFD_RELOC_32_PLT_PCREL
1379 ? BFD_RELOC_SH_PLT_MEDHI16
1380 : (abort (), BFD_RELOC_SH_IMM_MEDHI16_PCREL));
1381 fix_new (fragP, var_partp - fragP->fr_literal + 4, 4,
1382 fragP->fr_symbol,
1383 fragP->fr_offset + 8, 1,
1384 reloctype == BFD_RELOC_NONE
1385 ? BFD_RELOC_SH_IMM_MEDLOW16_PCREL
1386 : reloctype == BFD_RELOC_SH_GOTPC
1387 ? BFD_RELOC_SH_GOTPC_MEDLOW16
1388 : reloctype == BFD_RELOC_32_PLT_PCREL
1389 ? BFD_RELOC_SH_PLT_MEDLOW16
1390 : (abort (), BFD_RELOC_SH_IMM_MEDLOW16_PCREL));
1391 fix_new (fragP, var_partp - fragP->fr_literal + 8, 4,
1392 fragP->fr_symbol,
1393 fragP->fr_offset + 12, 1,
1394 reloctype == BFD_RELOC_NONE
1395 ? BFD_RELOC_SH_IMM_LOW16_PCREL
1396 : reloctype == BFD_RELOC_SH_GOTPC
1397 ? BFD_RELOC_SH_GOTPC_LOW16
1398 : reloctype == BFD_RELOC_32_PLT_PCREL
1399 ? BFD_RELOC_SH_PLT_LOW16
1400 : (abort (), BFD_RELOC_SH_IMM_LOW16_PCREL));
1401 }
1402 var_part_size = 12;
1403 }
1404 break;
1405
1406 default:
1407 BAD_CASE (fragP->fr_subtype);
1408 }
1409
1410 fragP->fr_fix += var_part_size;
1411 fragP->fr_var = 0;
1412}
1413
1414/* Mask NUMBER (originating from a signed number) corresponding to the HOW
1415 reloc. */
1416
1417static unsigned long
8edc77b9 1418shmedia_mask_number (unsigned long number, bfd_reloc_code_real_type how)
324bfcf3
AO		 1419{
1420 switch (how)
1421 {
1422 case BFD_RELOC_SH_IMMU5:
1423 number &= (1 << 5) - 1;
1424 break;
1425
1426 case BFD_RELOC_SH_IMMS6:
1427 case BFD_RELOC_SH_IMMU6:
1428 number &= (1 << 6) - 1;
1429 break;
1430
1431 case BFD_RELOC_SH_IMMS6BY32:
1432 number = (number & ((1 << (6 + 5)) - 1)) >> 5;
1433 break;
1434
1435 case BFD_RELOC_SH_IMMS10:
1436 number &= (1 << 10) - 1;
1437 break;
1438
1439 case BFD_RELOC_SH_IMMS10BY2:
1440 number = (number & ((1 << (10 + 1)) - 1)) >> 1;
1441 break;
1442
1443 case BFD_RELOC_SH_IMMS10BY4:
1444 number = (number & ((1 << (10 + 2)) - 1)) >> 2;
1445 break;
1446
1447 case BFD_RELOC_SH_IMMS10BY8:
1448 number = (number & ((1 << (10 + 3)) - 1)) >> 3;
1449 break;
1450
1451 case BFD_RELOC_SH_IMMS16:
1452 case BFD_RELOC_SH_IMMU16:
1453 number &= (1 << 16) - 1;
1454 break;
1455
1456 default:
1457 BAD_CASE (how);
1458 }
1459
1460 return number;
1461}
1462
1463/* Emit errors for values out-of-range, using as_bad_where if FRAGP is
1464 non-NULL, as_bad otherwise. */
1465
1466static void
8edc77b9
KK		 1467shmedia_check_limits (offsetT *valp, bfd_reloc_code_real_type reloc,
1468 fixS *fixp)
324bfcf3
AO		 1469{
1470 offsetT val = *valp;
1471
1472 char *msg = NULL;
1473
1474 switch (reloc)
1475 {
1476 case BFD_RELOC_SH_IMMU5:
1477 if (val < 0 || val > (1 << 5) - 1)
1478 msg = _("invalid operand, not a 5-bit unsigned value: %d");
1479 break;
1480
1481 case BFD_RELOC_SH_IMMS6:
1482 if (val < -(1 << 5) || val > (1 << 5) - 1)
1483 msg = _("invalid operand, not a 6-bit signed value: %d");
1484 break;
1485
1486 case BFD_RELOC_SH_IMMU6:
1487 if (val < 0 || val > (1 << 6) - 1)
1488 msg = _("invalid operand, not a 6-bit unsigned value: %d");
1489 break;
1490
1491 case BFD_RELOC_SH_IMMS6BY32:
1492 if (val < -(1 << 10) || val > (1 << 10) - 1)
1493 msg = _("invalid operand, not a 11-bit signed value: %d");
1494 else if (val & 31)
1495 msg = _("invalid operand, not a multiple of 32: %d");
1496 break;
1497
1498 case BFD_RELOC_SH_IMMS10:
1499 if (val < -(1 << 9) || val > (1 << 9) - 1)
1500 msg = _("invalid operand, not a 10-bit signed value: %d");
1501 break;
1502
1503 case BFD_RELOC_SH_IMMS10BY2:
1504 if (val < -(1 << 10) || val > (1 << 10) - 1)
1505 msg = _("invalid operand, not a 11-bit signed value: %d");
1506 else if (val & 1)
1507 msg = _("invalid operand, not an even value: %d");
1508 break;
1509
1510 case BFD_RELOC_SH_IMMS10BY4:
1511 if (val < -(1 << 11) || val > (1 << 11) - 1)
1512 msg = _("invalid operand, not a 12-bit signed value: %d");
1513 else if (val & 3)
1514 msg = _("invalid operand, not a multiple of 4: %d");
1515 break;
1516
1517 case BFD_RELOC_SH_IMMS10BY8:
1518 if (val < -(1 << 12) || val > (1 << 12) - 1)
1519 msg = _("invalid operand, not a 13-bit signed value: %d");
1520 else if (val & 7)
1521 msg = _("invalid operand, not a multiple of 8: %d");
1522 break;
1523
1524 case BFD_RELOC_SH_IMMS16:
1525 if (val < -(1 << 15) || val > (1 << 15) - 1)
1526 msg = _("invalid operand, not a 16-bit signed value: %d");
1527 break;
1528
1529 case BFD_RELOC_SH_IMMU16:
1530 if (val < 0 || val > (1 << 16) - 1)
1531 msg = _("invalid operand, not an 16-bit unsigned value: %d");
1532 break;
1533
1534 case BFD_RELOC_SH_PT_16:
1535 case SHMEDIA_BFD_RELOC_PT:
1536 if (val < -(1 << 15) * 4 || val > ((1 << 15) - 1) * 4 + 1)
1537 msg = _("operand out of range for PT, PTA and PTB");
1538 else if ((val % 4) != 0 && ((val - 1) % 4) != 0)
1539 msg = _("operand not a multiple of 4 for PT, PTA or PTB: %d");
1540 break;
1541
1542 /* These have no limits; they take a 16-bit slice of a 32- or 64-bit
1543 number. */
1544 case BFD_RELOC_SH_IMM_HI16:
1545 case BFD_RELOC_SH_IMM_MEDHI16:
1546 case BFD_RELOC_SH_IMM_MEDLOW16:
1547 case BFD_RELOC_SH_IMM_LOW16:
1548 case BFD_RELOC_SH_IMM_HI16_PCREL:
1549 case BFD_RELOC_SH_IMM_MEDHI16_PCREL:
1550 case BFD_RELOC_SH_IMM_MEDLOW16_PCREL:
1551 case BFD_RELOC_SH_IMM_LOW16_PCREL:
1552
1553 case BFD_RELOC_SH_SHMEDIA_CODE:
1554 break;
1555
1556 /* This one has limits out of our reach. */
1557 case BFD_RELOC_64:
1558 break;
1559
1560 default:
1561 BAD_CASE (reloc);
1562 }
1563
1564 if (msg)
1565 {
1566 if (fixp)
1567 as_bad_where (fixp->fx_file, fixp->fx_line, msg, val);
1568 else
1569 as_bad (msg, val);
1570 }
1571}
1572
1573/* Handle an immediate operand by checking limits and noting it for later
1574 evaluation if not computable yet, and return a bitfield suitable to
1575 "or" into the opcode (non-zero if the value was a constant number). */
1576
1577static unsigned long
8edc77b9
KK		 1578shmedia_immediate_op (char *where, shmedia_operand_info *op, int pcrel,
1579 bfd_reloc_code_real_type how)
324bfcf3
AO		 1580{
1581 unsigned long retval = 0;
1582
1583 /* If this is not an absolute number, make it a fixup. A constant in
1584 place of a pc-relative operand also needs a fixup. */
1585 if (op->immediate.X_op != O_constant || pcrel)
1586 fix_new_exp (frag_now,
1587 where - frag_now->fr_literal,
1588 4,
1589 &op->immediate,
1590 pcrel,
1591 how);
1592 else
1593 {
1594 /* Check that the number is within limits as represented by the
1595 reloc, and return the number. */
1596 shmedia_check_limits (&op->immediate.X_add_number, how, NULL);
1597
1598 retval
1599 = shmedia_mask_number ((unsigned long) op->immediate.X_add_number,
1600 how);
1601 }
1602
1603 return retval << 10;
1604}
1605
1606/* Try and parse a register name case-insensitively, return the number of
1607 chars consumed. */
1608
1609static int
8edc77b9 1610shmedia_parse_reg (char *src, int *mode, int *reg, shmedia_arg_type argtype)
324bfcf3
AO		 1611{
1612 int l0 = TOLOWER (src[0]);
1613 int l1 = l0 ? TOLOWER (src[1]) : 0;
1614
1615 if (l0 == 'r')
1616 {
1617 if (src[1] >= '1' && src[1] <= '5')
1618 {
1619 if (src[2] >= '0' && src[2] <= '9'
1620 && ! IDENT_CHAR ((unsigned char) src[3]))
1621 {
1622 *mode = A_GREG_M;
1623 *reg = 10 * (src[1] - '0') + src[2] - '0';
1624 return 3;
1625 }
1626 }
1627
1628 if (src[1] == '6')
1629 {
1630 if (src[2] >= '0' && src[2] <= '3'
1631 && ! IDENT_CHAR ((unsigned char) src[3]))
1632 {
1633 *mode = A_GREG_M;
1634 *reg = 60 + src[2] - '0';
1635 return 3;
1636 }
1637 }
1638
1639 if (src[1] >= '0' && src[1] <= '9'
1640 && ! IDENT_CHAR ((unsigned char) src[2]))
1641 {
1642 *mode = A_GREG_M;
1643 *reg = (src[1] - '0');
1644 return 2;
1645 }
1646 }
1647
1648 if (l0 == 't' && l1 == 'r')
1649 {
1650 if (src[2] >= '0' && src[2] <= '7'
1651 && ! IDENT_CHAR ((unsigned char) src[3]))
1652 {
1653 *mode = A_TREG_B;
1654 *reg = (src[2] - '0');
1655 return 3;
1656 }
1657 }
1658
1659 if (l0 == 'f' && l1 == 'r')
1660 {
1661 if (src[2] >= '1' && src[2] <= '5')
1662 {
1663 if (src[3] >= '0' && src[3] <= '9'
1664 && ! IDENT_CHAR ((unsigned char) src[4]))
1665 {
1666 *mode = A_FREG_G;
1667 *reg = 10 * (src[2] - '0') + src[3] - '0';
1668 return 4;
1669 }
1670 }
1671 if (src[2] == '6')
1672 {
1673 if (src[3] >= '0' && src[3] <= '3'
1674 && ! IDENT_CHAR ((unsigned char) src[4]))
1675 {
1676 *mode = A_FREG_G;
1677 *reg = 60 + src[3] - '0';
1678 return 4;
1679 }
1680 }
1681 if (src[2] >= '0' && src[2] <= '9'
1682 && ! IDENT_CHAR ((unsigned char) src[3]))
1683 {
1684 *mode = A_FREG_G;
1685 *reg = (src[2] - '0');
1686 return 3;
1687 }
1688 }
1689
1690 if (l0 == 'f' && l1 == 'v')
1691 {
1692 if (src[2] >= '1' && src[2] <= '5')
1693 {
1694 if (src[3] >= '0' && src[3] <= '9'
1695 && ((10 * (src[2] - '0') + src[3] - '0') % 4) == 0
1696 && ! IDENT_CHAR ((unsigned char) src[4]))
1697 {
1698 *mode = A_FVREG_G;
1699 *reg = 10 * (src[2] - '0') + src[3] - '0';
1700 return 4;
1701 }
1702 }
1703 if (src[2] == '6')
1704 {
1705 if (src[3] == '0'
1706 && ! IDENT_CHAR ((unsigned char) src[4]))
1707 {
1708 *mode = A_FVREG_G;
1709 *reg = 60 + src[3] - '0';
1710 return 4;
1711 }
1712 }
1713 if (src[2] >= '0' && src[2] <= '9'
1714 && ((src[2] - '0') % 4) == 0
1715 && ! IDENT_CHAR ((unsigned char) src[3]))
1716 {
1717 *mode = A_FVREG_G;
1718 *reg = (src[2] - '0');
1719 return 3;
1720 }
1721 }
1722
1723 if (l0 == 'd' && l1 == 'r')
1724 {
1725 if (src[2] >= '1' && src[2] <= '5')
1726 {
1727 if (src[3] >= '0' && src[3] <= '9'
1728 && ((src[3] - '0') % 2) == 0
1729 && ! IDENT_CHAR ((unsigned char) src[4]))
1730 {
1731 *mode = A_DREG_G;
1732 *reg = 10 * (src[2] - '0') + src[3] - '0';
1733 return 4;
1734 }
1735 }
1736
1737 if (src[2] == '6')
1738 {
1739 if ((src[3] == '0' || src[3] == '2')
1740 && ! IDENT_CHAR ((unsigned char) src[4]))
1741 {
1742 *mode = A_DREG_G;
1743 *reg = 60 + src[3] - '0';
1744 return 4;
1745 }
1746 }
1747
1748 if (src[2] >= '0' && src[2] <= '9'
1749 && ((src[2] - '0') % 2) == 0
1750 && ! IDENT_CHAR ((unsigned char) src[3]))
1751 {
1752 *mode = A_DREG_G;
1753 *reg = (src[2] - '0');
1754 return 3;
1755 }
1756 }
1757
1758 if (l0 == 'f' && l1 == 'p')
1759 {
1760 if (src[2] >= '1' && src[2] <= '5')
1761 {
1762 if (src[3] >= '0' && src[3] <= '9'
1763 && ((src[3] - '0') % 2) == 0
1764 && ! IDENT_CHAR ((unsigned char) src[4]))
1765 {
1766 *mode = A_FPREG_G;
1767 *reg = 10 * (src[2] - '0') + src[3] - '0';
1768 return 4;
1769 }
1770 }
1771
1772 if (src[2] == '6')
1773 {
1774 if ((src[3] == '0' || src[3] == '2')
1775 && ! IDENT_CHAR ((unsigned char) src[4]))
1776 {
1777 *mode = A_FPREG_G;
1778 *reg = 60 + src[3] - '0';
1779 return 4;
1780 }
1781 }
1782
1783 if (src[2] >= '0' && src[2] <= '9'
1784 && ((src[2] - '0') % 2) == 0
1785 && ! IDENT_CHAR ((unsigned char) src[3]))
1786 {
1787 *mode = A_FPREG_G;
1788 *reg = (src[2] - '0');
1789 return 3;
1790 }
1791 }
1792
1793 if (l0 == 'm' && strncasecmp (src, "mtrx", 4) == 0)
1794 {
1795 if (src[4] == '0' && ! IDENT_CHAR ((unsigned char) src[5]))
1796 {
1797 *mode = A_FMREG_G;
1798 *reg = 0;
1799 return 5;
1800 }
1801
1802 if (src[4] == '1' && src[5] == '6'
1803 && ! IDENT_CHAR ((unsigned char) src[6]))
1804 {
1805 *mode = A_FMREG_G;
1806 *reg = 16;
1807 return 6;
1808 }
1809
1810 if (src[4] == '3' && src[5] == '2'
1811 && ! IDENT_CHAR ((unsigned char) src[6]))
1812 {
1813 *mode = A_FMREG_G;
1814 *reg = 32;
1815 return 6;
1816 }
1817
1818 if (src[4] == '4' && src[5] == '8'
1819 && ! IDENT_CHAR ((unsigned char) src[6]))
1820 {
1821 *mode = A_FMREG_G;
1822 *reg = 48;
1823 return 6;
1824 }
1825 }
1826
1827 if (l0 == 'c' && l1 == 'r')
1828 {
1829 if (src[2] >= '1' && src[2] <= '5')
1830 {
1831 if (src[3] >= '0' && src[3] <= '9'
1832 && ! IDENT_CHAR ((unsigned char) src[4]))
1833 {
1834 *mode = A_CREG_K;
1835 *reg = 10 * (src[2] - '0') + src[3] - '0';
1836 return 4;
1837 }
1838 }
1839 if (src[2] == '6')
1840 {
1841 if (src[3] >= '0' && src[3] <= '3'
1842 && ! IDENT_CHAR ((unsigned char) src[4]))
1843 {
1844 *mode = A_CREG_K;
1845 *reg = 60 + src[3] - '0';
1846 return 4;
1847 }
1848 }
1849 if (src[2] >= '0' && src[2] <= '9'
1850 && ! IDENT_CHAR ((unsigned char) src[3]))
1851 {
1852 *mode = A_CREG_K;
1853 *reg = (src[2] - '0');
1854 return 3;
1855 }
1856 }
1857
1858 /* We either have an error, a symbol or a control register by predefined
1859 name. To keep things simple but still fast for normal cases, we do
1860 linear search in the (not to big) table of predefined control
1861 registers. We only do this when we *expect* a control register.
1862 Those instructions should be rare enough that linear searching is ok.
1863 Or just read them into a hash-table in shmedia_md_begin. Since they
1864 cannot be specified in the same place of symbol operands, don't add
1865 them there to the *main* symbol table as being in "reg_section". */
1866 if (argtype == A_CREG_J || argtype == A_CREG_K)
1867 {
1868 const shmedia_creg_info *cregp;
1869 int len = 0;
1870
1871 for (cregp = shmedia_creg_table; cregp->name != NULL; cregp++)
1872 {
1873 len = strlen (cregp->name);
1874 if (strncasecmp (cregp->name, src, len) == 0
1875 && ! IDENT_CHAR (src[len]))
1876 break;
1877 }
1878
1879 if (cregp->name != NULL)
1880 {
1881 *mode = A_CREG_K;
1882 *reg = cregp->cregno;
1883 return len;
1884 }
1885 }
1886
1887 return 0;
1888}
1889
1890/* Called from md_estimate_size_before_relax in tc-sh.c */
1891
1892static int
8edc77b9
KK		 1893shmedia_md_estimate_size_before_relax (fragS *fragP,
1894 segT segment_type ATTRIBUTE_UNUSED)
324bfcf3
AO		 1895{
1896 int old_fr_fix;
1897 expressionS *exp;
1898
1899 /* For ELF, we can't relax externally visible symbols; see tc-i386.c. */
b34976b6 1900 bfd_boolean sym_relaxable
324bfcf3
AO		 1901 = (fragP->fr_symbol
1902 && S_GET_SEGMENT (fragP->fr_symbol) == segment_type
1903 && ! S_IS_EXTERNAL (fragP->fr_symbol)
1904 && ! S_IS_WEAK (fragP->fr_symbol));
1905
1906 old_fr_fix = fragP->fr_fix;
1907
1908 switch (fragP->fr_subtype)
1909 {
1910 case C (SH64PCREL16_32, UNDEF_SH64PCREL):
1911 case C (SH64PCREL16PT_32, UNDEF_SH64PCREL):
1912 /* Used to be to somewhere which was unknown. */
1913 if (sym_relaxable)
1914 {
1915 int what = GET_WHAT (fragP->fr_subtype);
1916
1917 /* In this segment, so head for shortest. */
1918 fragP->fr_subtype = C (what, SH64PCREL16);
1919 }
1920 else
1921 {
1922 int what = GET_WHAT (fragP->fr_subtype);
1923 /* We know the abs value, but we don't know where we will be
1924 linked, so we must make it the longest. Presumably we could
1925 switch to a non-pcrel representation, but having absolute
1926 values in PT operands should be rare enough not to be worth
1927 adding that code. */
1928 fragP->fr_subtype = C (what, SH64PCREL32);
1929 }
1930 fragP->fr_var = md_relax_table[fragP->fr_subtype].rlx_length;
1931 break;
1932
1933 case C (SH64PCREL16_64, UNDEF_SH64PCREL):
1934 case C (SH64PCREL16PT_64, UNDEF_SH64PCREL):
1935 /* Used to be to somewhere which was unknown. */
1936 if (sym_relaxable)
1937 {
1938 int what = GET_WHAT (fragP->fr_subtype);
1939
1940 /* In this segment, so head for shortest. */
1941 fragP->fr_subtype = C (what, SH64PCREL16);
1942 }
1943 else
1944 {
1945 int what = GET_WHAT (fragP->fr_subtype);
1946 /* We know the abs value, but we don't know where we will be
1947 linked, so we must make it the longest. Presumably we could
1948 switch to a non-pcrel representation, but having absolute
1949 values in PT operands should be rare enough not to be worth
1950 adding that code. */
1951 fragP->fr_subtype = C (what, SH64PCREL64);
1952 }
1953 fragP->fr_var = md_relax_table[fragP->fr_subtype].rlx_length;
1954 break;
1955
1956 case C (MOVI_IMM_64, UNDEF_MOVI):
1957 case C (MOVI_IMM_32, UNDEF_MOVI):
1958 exp = NULL;
1959
1960 /* Look inside the "symbol". If we find a PC-relative expression,
1961 change this to a PC-relative, relaxable expression. */
1962 if (fragP->fr_symbol != NULL
1963 && (exp = symbol_get_value_expression (fragP->fr_symbol)) != NULL
1964 && exp->X_op == O_subtract
1965 && exp->X_op_symbol != NULL
1966 && S_GET_SEGMENT (exp->X_op_symbol) == segment_type)
1967 {
1968 int what = GET_WHAT (fragP->fr_subtype);
1969 int what_high = what == MOVI_IMM_32 ? MOVI_32 : MOVI_64;
1970 expressionS *opexp
1971 = symbol_get_value_expression (exp->X_op_symbol);
1972 expressionS *addexp
1973 = symbol_get_value_expression (exp->X_add_symbol);
1974
1975 /* Change the MOVI expression to the "X" in "X - Y" and subtract
1976 Y:s offset to this location from X. Note that we can only
1977 allow an Y which is offset from this frag. */
1978 if (opexp != NULL
1979 && addexp != NULL
1980 && opexp->X_op == O_constant
1981 && fragP == symbol_get_frag (exp->X_op_symbol))
1982 {
1983 /* At this point, before relaxing, the add-number of opexp
1984 is the offset from the fr_fix part. */
1985 fragP->fr_offset
1986 = (exp->X_add_number
1987 - (opexp->X_add_number - (fragP->fr_fix - 4)));
1988 fragP->fr_symbol = exp->X_add_symbol;
1989
1990 what = what == MOVI_IMM_32
1991 ? MOVI_IMM_32_PCREL : MOVI_IMM_64_PCREL;
1992
1993 /* Check the "X" symbol to estimate the size of this
1994 PC-relative expression. */
1995 if (S_GET_SEGMENT (exp->X_add_symbol) == segment_type
1996 && ! S_IS_EXTERNAL (exp->X_add_symbol)
1997 && ! S_IS_WEAK (exp->X_add_symbol))
1998 fragP->fr_subtype = C (what, MOVI_16);
1999 else
2000 fragP->fr_subtype = C (what, what_high);
2001
2002 /* This is now a PC-relative expression, fit to be relaxed. */
2003 }
2004 else
2005 fragP->fr_subtype = C (what, what_high);
2006 }
2007 else if (fragP->fr_symbol == NULL
2008 || (S_GET_SEGMENT (fragP->fr_symbol) == absolute_section
2009 && exp->X_op == O_constant))
2010 {
2011 unsigned long insn
2012 = (target_big_endian
2013 ? bfd_getb32 (fragP->fr_opcode)
2014 : bfd_getl32 (fragP->fr_opcode));
2015 offsetT one = (offsetT) 1;
2016 offsetT value = fragP->fr_offset
2017 + (fragP->fr_symbol == NULL ? 0 : S_GET_VALUE (fragP->fr_symbol));
2018
2019 if (value >= ((offsetT) -1 << 15) && value < ((offsetT) 1 << 15))
2020 {
2021 /* Fits in 16-bit signed number. */
2022 int what = GET_WHAT (fragP->fr_subtype);
2023 fragP->fr_subtype = C (what, MOVI_16);
2024
2025 /* Just "or" in the value. */
2026 md_number_to_chars (fragP->fr_opcode,
2027 insn | ((value & ((1 << 16) - 1)) << 10),
2028 4);
2029 }
2030 else if (value >= -(one << 31)
2031 && (value < (one << 31)
2032 || (sh64_abi == sh64_abi_32 && value < (one << 32))))
2033 {
2034 /* The value fits in a 32-bit signed number. */
2035 int reg = (insn >> 4) & 0x3f;
2036
2037 /* Just "or" in the high bits of the value, making the first
2038 MOVI. */
2039 md_number_to_chars (fragP->fr_opcode,
2040 insn
2041 | (((value >> 16) & ((1 << 16) - 1)) << 10),
2042 4);
2043
2044 /* Add a SHORI with the low bits. Note that this insn lives
2045 in the variable fragment part. */
2046 md_number_to_chars (fragP->fr_literal + old_fr_fix,
2047 SHMEDIA_SHORI_OPC
2048 | (reg << 4)
2049 | ((value & ((1 << 16) - 1)) << 10),
2050 4);
2051
2052 /* We took a piece of the variable part. */
2053 fragP->fr_fix += 4;
2054 }
2055 else if (GET_WHAT (fragP->fr_subtype) == MOVI_IMM_32)
2056 {
2057 /* Value out of range. */
2058 as_bad_where (fragP->fr_file, fragP->fr_line,
2059 _("MOVI operand is not a 32-bit signed value: 0x%8x%08x"),
2060 ((unsigned int) (value >> 32)
2061 & (unsigned int) 0xffffffff),
2062 (unsigned int) value & (unsigned int) 0xffffffff);
2063
2064 /* Must advance size, or we will get internal inconsistency
2065 and fall into an assert. */
2066 fragP->fr_fix += 4;
2067 }
2068 /* Now we know we are allowed to expand to 48- and 64-bit values. */
2069 else if (value >= -(one << 47) && value < (one << 47))
2070 {
2071 /* The value fits in a 48-bit signed number. */
2072 int reg = (insn >> 4) & 0x3f;
2073
2074 /* Just "or" in the high bits of the value, making the first
2075 MOVI. */
2076 md_number_to_chars (fragP->fr_opcode,
2077 insn
2078 | (((value >> 32) & ((1 << 16) - 1)) << 10),
2079 4);
2080
2081 /* Add a SHORI with the middle bits. Note that this insn lives
2082 in the variable fragment part. */
2083 md_number_to_chars (fragP->fr_literal + old_fr_fix,
2084 SHMEDIA_SHORI_OPC
2085 | (reg << 4)
2086 | (((value >> 16) & ((1 << 16) - 1)) << 10),
2087 4);
2088
2089 /* Add a SHORI with the low bits. */
2090 md_number_to_chars (fragP->fr_literal + old_fr_fix + 4,
2091 SHMEDIA_SHORI_OPC
2092 | (reg << 4)
2093 | ((value & ((1 << 16) - 1)) << 10),
2094 4);
2095
2096 /* We took a piece of the variable part. */
2097 fragP->fr_fix += 8;
2098 }
2099 else
2100 {
2101 /* A 64-bit number. */
2102 int reg = (insn >> 4) & 0x3f;
2103
2104 /* Just "or" in the high bits of the value, making the first
2105 MOVI. */
2106 md_number_to_chars (fragP->fr_opcode,
2107 insn
2108 | (((value >> 48) & ((1 << 16) - 1)) << 10),
2109 4);
2110
2111 /* Add a SHORI with the midhigh bits. Note that this insn lives
2112 in the variable fragment part. */
2113 md_number_to_chars (fragP->fr_literal + old_fr_fix,
2114 SHMEDIA_SHORI_OPC
2115 | (reg << 4)
2116 | (((value >> 32) & ((1 << 16) - 1)) << 10),
2117 4);
2118
2119 /* Add a SHORI with the midlow bits. */
2120 md_number_to_chars (fragP->fr_literal + old_fr_fix + 4,
2121 SHMEDIA_SHORI_OPC
2122 | (reg << 4)
2123 | (((value >> 16) & ((1 << 16) - 1)) << 10),
2124 4);
2125
2126 /* Add a SHORI with the low bits. */
2127 md_number_to_chars (fragP->fr_literal + old_fr_fix + 8,
2128 SHMEDIA_SHORI_OPC
2129 | (reg << 4)
2130 | ((value & ((1 << 16) - 1)) << 10), 4);
2131 /* We took all of the variable part. */
2132 fragP->fr_fix += 12;
2133 }
2134
2135 /* MOVI expansions that get here have not been converted to
2136 PC-relative frags, but instead expanded by
2137 md_number_to_chars or by calling shmedia_md_convert_frag
b34976b6 2138 with final == FALSE. We must not have them around as
324bfcf3
AO		 2139 frags anymore; symbols would be prematurely evaluated
2140 when relaxing. We will not need to have md_convert_frag
2141 called again with them; any further handling is through
2142 the already emitted fixups. */
2143 frag_wane (fragP);
2144 break;
2145 }
2146 fragP->fr_var = md_relax_table[fragP->fr_subtype].rlx_length;
2147 break;
2148
2149 /* For relaxation states that remain unchanged, report the
2150 estimated length. */
2151 case C (SH64PCREL16_32, SH64PCREL16):
2152 case C (SH64PCREL16PT_32, SH64PCREL16):
2153 case C (SH64PCREL16_32, SH64PCREL32):
2154 case C (SH64PCREL16PT_32, SH64PCREL32):
2155 case C (SH64PCREL16_32, SH64PCRELPLT):
2156 case C (SH64PCREL16PT_32, SH64PCRELPLT):
2157 case C (SH64PCREL16_64, SH64PCREL16):
2158 case C (SH64PCREL16PT_64, SH64PCREL16):
2159 case C (SH64PCREL16_64, SH64PCREL32):
2160 case C (SH64PCREL16PT_64, SH64PCREL32):
2161 case C (SH64PCREL16_64, SH64PCREL48):
2162 case C (SH64PCREL16PT_64, SH64PCREL48):
2163 case C (SH64PCREL16_64, SH64PCREL64):
2164 case C (SH64PCREL16PT_64, SH64PCREL64):
2165 case C (SH64PCREL16_64, SH64PCRELPLT):
2166 case C (SH64PCREL16PT_64, SH64PCRELPLT):
2167 case C (MOVI_IMM_32, MOVI_16):
2168 case C (MOVI_IMM_32, MOVI_32):
2169 case C (MOVI_IMM_32, MOVI_GOTOFF):
2170 case C (MOVI_IMM_32_PCREL, MOVI_16):
2171 case C (MOVI_IMM_32_PCREL, MOVI_32):
2172 case C (MOVI_IMM_32_PCREL, MOVI_PLT):
2173 case C (MOVI_IMM_32_PCREL, MOVI_GOTPC):
2174 case C (MOVI_IMM_64, MOVI_16):
2175 case C (MOVI_IMM_64, MOVI_32):
2176 case C (MOVI_IMM_64, MOVI_48):
2177 case C (MOVI_IMM_64, MOVI_64):
2178 case C (MOVI_IMM_64, MOVI_GOTOFF):
2179 case C (MOVI_IMM_64_PCREL, MOVI_16):
2180 case C (MOVI_IMM_64_PCREL, MOVI_32):
2181 case C (MOVI_IMM_64_PCREL, MOVI_48):
2182 case C (MOVI_IMM_64_PCREL, MOVI_64):
2183 case C (MOVI_IMM_64_PCREL, MOVI_PLT):
2184 case C (MOVI_IMM_64_PCREL, MOVI_GOTPC):
2185 fragP->fr_var = md_relax_table[fragP->fr_subtype].rlx_length;
2186 break;
5d6255fe 2187
324bfcf3
AO		 2188 default:
2189 abort ();
2190 }
2191
2192 return fragP->fr_var + (fragP->fr_fix - old_fr_fix);
2193}
2194
2195/* Parse an expression, SH64-style. Copied from tc-sh.c, but with
2196 datatypes adjusted. */
2197
2198static char *
8edc77b9 2199shmedia_parse_exp (char *s, shmedia_operand_info *op)
324bfcf3
AO		 2200{
2201 char *save;
2202 char *new;
2203
2204 save = input_line_pointer;
2205 input_line_pointer = s;
2206 expression (&op->immediate);
2207 if (op->immediate.X_op == O_absent)
2208 as_bad (_("missing operand"));
2209 new = input_line_pointer;
2210 input_line_pointer = save;
2211 return new;
2212}
2213
2214/* Parse an operand. Store pointer to next character in *PTR. */
2215
2216static void
8edc77b9
KK		 2217shmedia_get_operand (char **ptr, shmedia_operand_info *op,
2218 shmedia_arg_type argtype)
324bfcf3
AO		 2219{
2220 char *src = *ptr;
2221 int mode = -1;
2222 unsigned int len;
2223
2224 len = shmedia_parse_reg (src, &mode, &(op->reg), argtype);
2225 if (len)
2226 {
2227 *ptr = src + len;
2228 op->type = mode;
2229 }
2230 else
2231 {
2232 /* Not a reg, so it must be a displacement. */
2233 *ptr = shmedia_parse_exp (src, op);
2234 op->type = A_IMMM;
2235
2236 /* This is just an initialization; shmedia_get_operands will change
2237 as needed. */
2238 op->reloctype = BFD_RELOC_NONE;
2239 }
2240}
2241
2242/* Parse the operands for this insn; return NULL if invalid, else return
2243 how much text was consumed. */
2244
2245static char *
8edc77b9
KK		 2246shmedia_get_operands (shmedia_opcode_info *info, char *args,
2247 shmedia_operands_info *operands)
324bfcf3
AO		 2248{
2249 char *ptr = args;
2250 int i;
2251
2252 if (*ptr == ' ')
2253 ptr++;
2254
2255 for (i = 0; info->arg[i] != 0; i++)
2256 {
2257 memset (operands->operands + i, 0, sizeof (operands->operands[0]));
2258
2259 /* No operand to get for these fields. */
2260 if (info->arg[i] == A_REUSE_PREV)
2261 continue;
2262
2263 shmedia_get_operand (&ptr, &operands->operands[i], info->arg[i]);
2264
2265 /* Check operands type match. */
2266 switch (info->arg[i])
2267 {
2268 case A_GREG_M:
2269 case A_GREG_N:
2270 case A_GREG_D:
2271 if (operands->operands[i].type != A_GREG_M)
2272 return NULL;
2273 break;
2274
2275 case A_FREG_G:
2276 case A_FREG_H:
2277 case A_FREG_F:
2278 if (operands->operands[i].type != A_FREG_G)
2279 return NULL;
2280 break;
2281
2282 case A_FVREG_G:
2283 case A_FVREG_H:
2284 case A_FVREG_F:
2285 if (operands->operands[i].type != A_FVREG_G)
2286 return NULL;
2287 break;
2288
2289 case A_FMREG_G:
2290 case A_FMREG_H:
2291 case A_FMREG_F:
2292 if (operands->operands[i].type != A_FMREG_G)
2293 return NULL;
2294 break;
2295
2296 case A_FPREG_G:
2297 case A_FPREG_H:
2298 case A_FPREG_F:
2299 if (operands->operands[i].type != A_FPREG_G)
2300 return NULL;
2301 break;
2302
2303 case A_DREG_G:
2304 case A_DREG_H:
2305 case A_DREG_F:
2306 if (operands->operands[i].type != A_DREG_G)
2307 return NULL;
2308 break;
2309
2310 case A_TREG_A:
2311 case A_TREG_B:
2312 if (operands->operands[i].type != A_TREG_B)
2313 return NULL;
2314 break;
2315
2316 case A_CREG_J:
2317 case A_CREG_K:
2318 if (operands->operands[i].type != A_CREG_K)
2319 return NULL;
2320 break;
2321
2322 case A_IMMS16:
2323 case A_IMMU16:
2324 /* Check for an expression that looks like S & 65535 or
2325 (S >> N) & 65535, where N = 0, 16, 32, 48.
2326
2327 Get the S and put at operands->operands[i].immediate, and
2328 adjust operands->operands[i].reloctype. */
2329 {
2330 expressionS *imm_expr = &operands->operands[i].immediate;
2331 expressionS *right_expr;
2332
2333 if (operands->operands[i].type == A_IMMM
2334 && imm_expr->X_op == O_bit_and
2335 && imm_expr->X_op_symbol != NULL
2336 && ((right_expr
2337 = symbol_get_value_expression (imm_expr->X_op_symbol))
2338 ->X_op == O_constant)
2339 && right_expr->X_add_number == 0xffff)
2340 {
2341 symbolS *inner = imm_expr->X_add_symbol;
2342 bfd_reloc_code_real_type reloctype = BFD_RELOC_SH_IMM_LOW16;
2343 expressionS *inner_expr
2344 = symbol_get_value_expression (inner);
2345
2346 if (inner_expr->X_op == O_right_shift)
2347 {
2348 expressionS *inner_right;
2349
2350 if (inner_expr->X_op_symbol != NULL
2351 && ((inner_right
2352 = symbol_get_value_expression (inner_expr
2353 ->X_op_symbol))
2354 ->X_op == O_constant))
2355 {
2356 offsetT addnum
2357 = inner_right->X_add_number;
2358
2359 if (addnum == 0 || addnum == 16 || addnum == 32
2360 || addnum == 48)
2361 {
2362 reloctype
2363 = (addnum == 0
2364 ? BFD_RELOC_SH_IMM_LOW16
2365 : (addnum == 16
2366 ? BFD_RELOC_SH_IMM_MEDLOW16
2367 : (addnum == 32
2368 ? BFD_RELOC_SH_IMM_MEDHI16
2369 : BFD_RELOC_SH_IMM_HI16)));
2370
2371 inner = inner_expr->X_add_symbol;
2372 inner_expr = symbol_get_value_expression (inner);
2373 }
2374 }
2375 }
2376
2377 /* I'm not sure I understand the logic, but evidently the
2378 inner expression of a lone symbol is O_constant, with
2379 the actual symbol in expr_section. For a constant, the
2380 section would be absolute_section. For sym+offset,
2381 it's O_symbol as always. See expr.c:make_expr_symbol,
2382 first statements. */
2383
2384 if (inner_expr->X_op == O_constant
2385 && S_GET_SEGMENT (inner) != absolute_section)
2386 {
2387 operands->operands[i].immediate.X_op = O_symbol;
2388 operands->operands[i].immediate.X_add_symbol = inner;
2389 operands->operands[i].immediate.X_add_number = 0;
2390 }
2391 else
2392 operands->operands[i].immediate
2393 = *symbol_get_value_expression (inner);
2394
2395 operands->operands[i].reloctype = reloctype;
2396 }
2397 }
2398 /* Fall through. */
2399 case A_IMMS6:
2400 case A_IMMS6BY32:
2401 case A_IMMS10:
2402 case A_IMMS10BY1:
2403 case A_IMMS10BY2:
2404 case A_IMMS10BY4:
2405 case A_IMMS10BY8:
2406 case A_PCIMMS16BY4:
2407 case A_PCIMMS16BY4_PT:
2408 case A_IMMU5:
2409 case A_IMMU6:
2410 if (operands->operands[i].type != A_IMMM)
2411 return NULL;
2412
2413 if (sh_check_fixup (&operands->operands[i].immediate,
2414 &operands->operands[i].reloctype))
2415 {
2416 as_bad (_("invalid PIC reference"));
2417 return NULL;
2418 }
2419
2420 break;
2421
2422 default:
2423 BAD_CASE (info->arg[i]);
2424 }
2425
2426 if (*ptr == ',' && info->arg[i + 1])
2427 ptr++;
2428 }
2429 return ptr;
2430}
2431
2432
2433/* Find an opcode at the start of *STR_P in the hash table, and set
2434 *STR_P to the first character after the last one read. */
2435
2436static shmedia_opcode_info *
8edc77b9 2437shmedia_find_cooked_opcode (char **str_p)
324bfcf3
AO		 2438{
2439 char *str = *str_p;
2440 char *op_start;
2441 char *op_end;
2442 char name[20];
2443 unsigned int nlen = 0;
2444
2445 /* Drop leading whitespace. */
2446 while (*str == ' ')
2447 str++;
2448
2449 /* Find the op code end. */
2450 for (op_start = op_end = str;
2451 *op_end
2452 && nlen < sizeof (name) - 1
2453 && ! is_end_of_line[(unsigned char) *op_end]
2454 && ! ISSPACE ((unsigned char) *op_end);
2455 op_end++)
2456 {
2457 unsigned char c = op_start[nlen];
2458
2459 /* The machine independent code will convert CMP/EQ into cmp/EQ
2460 because it thinks the '/' is the end of the symbol. Moreover,
2461 all but the first sub-insn is a parallel processing insn won't
67c1ffbe 2462 be capitalized. Instead of hacking up the machine independent
324bfcf3
AO		 2463 code, we just deal with it here. */
2464 c = TOLOWER (c);
2465 name[nlen] = c;
2466 nlen++;
2467 }
2468
2469 name[nlen] = 0;
2470 *str_p = op_end;
2471
2472 if (nlen == 0)
2473 as_bad (_("can't find opcode"));
2474
2475 return
2476 (shmedia_opcode_info *) hash_find (shmedia_opcode_hash_control, name);
2477}
2478
2479/* Build up an instruction, including allocating the frag. */
2480
2481static int
8edc77b9
KK		 2482shmedia_build_Mytes (shmedia_opcode_info *opcode,
2483 shmedia_operands_info *operands)
324bfcf3
AO		 2484{
2485 unsigned long insn = opcode->opcode_base;
2486 int i, j;
2487 char *insn_loc = frag_more (4);
2488
2489 /* The parameter to dwarf2_emit_insn is actually the offset to the start
2490 of the insn from the fix piece of instruction that was emitted.
2491 Since we want .debug_line addresses to record (address | 1) for
2492 SHmedia insns, we get the wanted effect by taking one off the size,
2493 knowing it's a multiple of 4. We count from the first fix piece of
2494 the insn. There must be no frags changes (frag_more or frag_var)
2495 calls in-between the frag_more call we account for, and this
2496 dwarf2_emit_insn call. */
2497 dwarf2_emit_insn (3);
2498
2499 /* This is stored into any frag_var operand. */
2500 sh64_last_insn_frag = frag_now;
2501
2502 /* Loop over opcode info, emit an instruction. */
2503 for (i = 0, j = 0; opcode->arg[i]; i++)
2504 {
2505 shmedia_arg_type argtype = opcode->arg[i];
2506 shmedia_operand_info *opjp = &operands->operands[j];
2507 switch (argtype)
2508 {
2509 case A_TREG_A:
2510 case A_TREG_B:
2511 case A_GREG_M:
2512 case A_GREG_N:
2513 case A_GREG_D:
2514 case A_FREG_G:
2515 case A_FREG_H:
2516 case A_FREG_F:
2517 case A_FVREG_G:
2518 case A_FVREG_H:
2519 case A_FVREG_F:
2520 case A_FMREG_G:
2521 case A_FMREG_H:
2522 case A_FMREG_F:
2523 case A_FPREG_G:
2524 case A_FPREG_H:
2525 case A_FPREG_F:
2526 case A_DREG_G:
2527 case A_DREG_H:
2528 case A_DREG_F:
2529 case A_CREG_J:
2530 case A_CREG_K:
2531 /* Six-bit register fields. They just get filled with the
2532 parsed register number. */
2533 insn |= (opjp->reg << opcode->nibbles[i]);
2534 j++;
2535 break;
2536
2537 case A_REUSE_PREV:
2538 /* Copy the register for the previous operand to this position. */
2539 insn |= (operands->operands[j - 1].reg << opcode->nibbles[i]);
2540 j++;
2541 break;
2542
2543 case A_IMMS6:
2544 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2545 BFD_RELOC_SH_IMMS6);
2546 j++;
2547 break;
2548
2549 case A_IMMS6BY32:
2550 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2551 BFD_RELOC_SH_IMMS6BY32);
2552 j++;
2553 break;
2554
2555 case A_IMMS10BY1:
2556 case A_IMMS10:
2557 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2558 BFD_RELOC_SH_IMMS10);
2559 j++;
2560 break;
2561
2562 case A_IMMS10BY2:
2563 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2564 BFD_RELOC_SH_IMMS10BY2);
2565 j++;
2566 break;
2567
2568 case A_IMMS10BY4:
2569 if (opjp->reloctype == BFD_RELOC_NONE)
2570 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2571 BFD_RELOC_SH_IMMS10BY4);
2572 else if (opjp->reloctype == BFD_RELOC_SH_GOTPLT32)
2573 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2574 BFD_RELOC_SH_GOTPLT10BY4);
2575 else if (opjp->reloctype == BFD_RELOC_32_GOT_PCREL)
2576 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2577 BFD_RELOC_SH_GOT10BY4);
2578 else
2579 as_bad (_("invalid PIC reference"));
2580 j++;
2581 break;
2582
2583 case A_IMMS10BY8:
2584 if (opjp->reloctype == BFD_RELOC_NONE)
2585 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2586 BFD_RELOC_SH_IMMS10BY8);
2587 else if (opjp->reloctype == BFD_RELOC_SH_GOTPLT32)
2588 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2589 BFD_RELOC_SH_GOTPLT10BY8);
2590 else if (opjp->reloctype == BFD_RELOC_32_GOT_PCREL)
2591 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2592 BFD_RELOC_SH_GOT10BY8);
2593 else
2594 as_bad (_("invalid PIC reference"));
2595 j++;
2596 break;
2597
2598 case A_IMMS16:
2599 /* Sneak a peek if this is the MOVI insn. If so, check if we
2600 should expand it. */
2601 if (opjp->reloctype == BFD_RELOC_32_GOT_PCREL)
2602 opjp->reloctype = BFD_RELOC_SH_GOT_LOW16;
2603 else if (opjp->reloctype == BFD_RELOC_SH_GOTPLT32)
2604 opjp->reloctype = BFD_RELOC_SH_GOTPLT_LOW16;
5d6255fe 2605
324bfcf3
AO		 2606 if ((opjp->reloctype == BFD_RELOC_NONE
2607 || opjp->reloctype == BFD_RELOC_32_GOTOFF
2608 || opjp->reloctype == BFD_RELOC_32_PLT_PCREL
2609 || opjp->reloctype == BFD_RELOC_SH_GOTPC)
2610 && opcode->opcode_base == SHMEDIA_MOVI_OPC
2611 && (opjp->immediate.X_op != O_constant
2612 || opjp->immediate.X_add_number < -32768
2613 || opjp->immediate.X_add_number > 32767)
2614 && (sh64_expand
2615 || opjp->reloctype == BFD_RELOC_32_GOTOFF
2616 || opjp->reloctype == BFD_RELOC_32_PLT_PCREL
2617 || opjp->reloctype == BFD_RELOC_SH_GOTPC))
2618 {
2619 int what = sh64_abi == sh64_abi_64 ? MOVI_IMM_64 : MOVI_IMM_32;
2620 offsetT max = sh64_abi == sh64_abi_64 ? MOVI_64 : MOVI_32;
2621 offsetT min = MOVI_16;
2622 offsetT init = UNDEF_MOVI;
2623 valueT addvalue
2624 = opjp->immediate.X_op_symbol != NULL
2625 ? 0 : opjp->immediate.X_add_number;
2626 symbolS *sym
2627 = opjp->immediate.X_op_symbol != NULL
2628 ? make_expr_symbol (&opjp->immediate)
2629 : opjp->immediate.X_add_symbol;
2630
2631 if (opjp->reloctype == BFD_RELOC_32_GOTOFF)
2632 init = max = min = MOVI_GOTOFF;
2633 else if (opjp->reloctype == BFD_RELOC_32_PLT_PCREL)
2634 {
2635 init = max = min = MOVI_PLT;
2636 what = (sh64_abi == sh64_abi_64
2637 ? MOVI_IMM_64_PCREL
2638 : MOVI_IMM_32_PCREL);
2639 }
2640 else if (opjp->reloctype == BFD_RELOC_SH_GOTPC)
2641 {
2642 init = max = min = MOVI_GOTPC;
2643 what = (sh64_abi == sh64_abi_64
2644 ? MOVI_IMM_64_PCREL
2645 : MOVI_IMM_32_PCREL);
2646 }
2647
2648 frag_var (rs_machine_dependent,
2649 md_relax_table[C (what, max)].rlx_length,
2650 md_relax_table[C (what, min)].rlx_length,
2651 C (what, init), sym, addvalue, insn_loc);
2652 }
2653 else
2654 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2655 (opjp->reloctype
2656 == BFD_RELOC_NONE)
2657 ? BFD_RELOC_SH_IMMS16
2658 : opjp->reloctype);
2659 j++;
2660 break;
2661
2662 case A_PCIMMS16BY4:
2663 {
2664 int what
2665 = ((sh64_abi == sh64_abi_64 && ! sh64_pt32)
2666 ? SH64PCREL16_64 : SH64PCREL16_32);
2667 offsetT max
2668 = ((sh64_abi == sh64_abi_64 && ! sh64_pt32)
2669 ? SH64PCREL64 : SH64PCREL32);
2670 offsetT min = SH64PCREL16;
2671 offsetT init = UNDEF_SH64PCREL;
2672
2673 /* Don't allow complex expressions here. */
2674 if (opjp->immediate.X_op_symbol != NULL)
2675 return 0;
2676
2677 if (opjp->reloctype == BFD_RELOC_32_PLT_PCREL)
2678 init = max = min = SH64PCRELPLT;
2679
2680 /* If we're not expanding, then just emit a fixup. */
2681 if (sh64_expand || opjp->reloctype != BFD_RELOC_NONE)
2682 frag_var (rs_machine_dependent,
2683 md_relax_table[C (what, max)].rlx_length,
2684 md_relax_table[C (what, min)].rlx_length,
2685 C (what, init),
2686 opjp->immediate.X_add_symbol,
2687 opjp->immediate.X_add_number,
2688 insn_loc);
2689 else
2690 insn |= shmedia_immediate_op (insn_loc, opjp, 1,
2691 opjp->reloctype == BFD_RELOC_NONE
2692 ? BFD_RELOC_SH_PT_16
2693 : opjp->reloctype);
5d6255fe 2694
324bfcf3
AO		 2695 j++;
2696 break;
2697 }
2698
2699 case A_PCIMMS16BY4_PT:
2700 {
2701 int what
2702 = ((sh64_abi == sh64_abi_64 && ! sh64_pt32)
2703 ? SH64PCREL16PT_64 : SH64PCREL16PT_32);
2704 offsetT max
2705 = ((sh64_abi == sh64_abi_64 && ! sh64_pt32)
2706 ? SH64PCREL64 : SH64PCREL32);
2707 offsetT min = SH64PCREL16;
2708 offsetT init = UNDEF_SH64PCREL;
2709
2710 /* Don't allow complex expressions here. */
2711 if (opjp->immediate.X_op_symbol != NULL)
2712 return 0;
2713
2714 if (opjp->reloctype == BFD_RELOC_32_PLT_PCREL)
2715 init = max = min = SH64PCRELPLT;
2716
2717 /* If we're not expanding, then just emit a fixup. */
2718 if (sh64_expand || opjp->reloctype != BFD_RELOC_NONE)
2719 frag_var (rs_machine_dependent,
2720 md_relax_table[C (what, max)].rlx_length,
2721 md_relax_table[C (what, min)].rlx_length,
2722 C (what, init),
2723 opjp->immediate.X_add_symbol,
2724 opjp->immediate.X_add_number,
2725 insn_loc);
2726 else
2727 /* This reloc-type is just temporary, so we can distinguish
2728 PTA from PT. It is changed in shmedia_md_apply_fix3 to
2729 BFD_RELOC_SH_PT_16. */
2730 insn |= shmedia_immediate_op (insn_loc, opjp, 1,
2731 opjp->reloctype == BFD_RELOC_NONE
2732 ? SHMEDIA_BFD_RELOC_PT
2733 : opjp->reloctype);
5d6255fe 2734
324bfcf3
AO		 2735 j++;
2736 break;
2737 }
2738
2739 case A_IMMU5:
2740 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2741 BFD_RELOC_SH_IMMU5);
2742 j++;
2743 break;
2744
2745 case A_IMMU6:
2746 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2747 BFD_RELOC_SH_IMMU6);
2748 j++;
2749 break;
2750
2751 case A_IMMU16:
2752 insn |= shmedia_immediate_op (insn_loc, opjp, 0,
2753 (opjp->reloctype
2754 == BFD_RELOC_NONE)
2755 ? BFD_RELOC_SH_IMMU16
2756 : opjp->reloctype);
2757 j++;
2758 break;
2759
2760 default:
2761 BAD_CASE (argtype);
2762 }
2763 }
2764
2765 md_number_to_chars (insn_loc, insn, 4);
2766 return 4;
2767}
2768
2769/* Assemble a SHmedia instruction. */
2770
2771static void
8edc77b9 2772shmedia_md_assemble (char *str)
324bfcf3
AO		 2773{
2774 char *op_end;
2775 shmedia_opcode_info *opcode;
2776 shmedia_operands_info operands;
2777 int size;
2778
2779 opcode = shmedia_find_cooked_opcode (&str);
2780 op_end = str;
2781
2782 if (opcode == NULL)
2783 {
2784 as_bad (_("unknown opcode"));
2785 return;
2786 }
2787
2788 /* Start a SHmedia code region, if there has been pseudoinsns or similar
2789 seen since the last one. */
b34976b6 2790 if (!seen_insn)
324bfcf3 2791 {
b34976b6 2792 sh64_update_contents_mark (TRUE);
324bfcf3 2793 sh64_set_contents_type (CRT_SH5_ISA32);
b34976b6 2794 seen_insn = TRUE;
324bfcf3
AO		 2795 }
2796
2797 op_end = shmedia_get_operands (opcode, op_end, &operands);
2798
2799 if (op_end == NULL)
2800 {
2801 as_bad (_("invalid operands to %s"), opcode->name);
2802 return;
2803 }
2804
2805 if (*op_end)
2806 {
2807 as_bad (_("excess operands to %s"), opcode->name);
2808 return;
2809 }
2810
2811 size = shmedia_build_Mytes (opcode, &operands);
2812 if (size == 0)
2813 return;
2814}
2815
2816/* Hook called from md_begin in tc-sh.c. */
2817
2818void
8edc77b9 2819shmedia_md_begin (void)
324bfcf3
AO		 2820{
2821 const shmedia_opcode_info *shmedia_opcode;
2822 shmedia_opcode_hash_control = hash_new ();
2823
2824 /* Create opcode table for SHmedia mnemonics. */
2825 for (shmedia_opcode = shmedia_table;
2826 shmedia_opcode->name;
2827 shmedia_opcode++)
2828 hash_insert (shmedia_opcode_hash_control, shmedia_opcode->name,
2829 (char *) shmedia_opcode);
2830}
2831
2832/* Switch instruction set. Only valid if one of the --isa or --abi
2833 options was specified. */
2834
2835static void
8edc77b9 2836s_sh64_mode (int ignore ATTRIBUTE_UNUSED)
324bfcf3
AO		 2837{
2838 char *name = input_line_pointer, ch;
2839
2840 /* Make sure data up to this location is handled according to the
2841 previous ISA. */
b34976b6 2842 sh64_update_contents_mark (TRUE);
324bfcf3
AO		 2843
2844 while (!is_end_of_line[(unsigned char) *input_line_pointer])
2845 input_line_pointer++;
2846 ch = *input_line_pointer;
2847 *input_line_pointer = '\0';
2848
2849 /* If the mode was not set before, explicitly or implicitly, then we're
2850 not emitting SH64 code, so this pseudo is invalid. */
2851 if (sh64_isa_mode == sh64_isa_unspecified)
2852 as_bad (_("The `.mode %s' directive is not valid with this architecture"),
2853 name);
2854
2855 if (strcasecmp (name, "shcompact") == 0)
2856 sh64_isa_mode = sh64_isa_shcompact;
2857 else if (strcasecmp (name, "shmedia") == 0)
2858 sh64_isa_mode = sh64_isa_shmedia;
2859 else
2860 as_bad (_("Invalid argument to .mode: %s"), name);
2861
2862 /* Make a new frag, marking it with the supposedly-changed ISA. */
2863 frag_wane (frag_now);
2864 frag_new (0);
2865
2866 /* Contents type up to this new point is the same as before; don't add a
2867 data region just because the new frag we created. */
b34976b6 2868 sh64_update_contents_mark (FALSE);
324bfcf3
AO		 2869
2870 *input_line_pointer = ch;
2871 demand_empty_rest_of_line ();
2872}
2873
2874/* Check that the right ABI is used. Only valid if one of the --isa or
2875 --abi options was specified. */
2876
2877static void
8edc77b9 2878s_sh64_abi (int ignore ATTRIBUTE_UNUSED)
324bfcf3
AO		 2879{
2880 char *name = input_line_pointer, ch;
2881
2882 while (!is_end_of_line[(unsigned char) *input_line_pointer])
2883 input_line_pointer++;
2884 ch = *input_line_pointer;
2885 *input_line_pointer = '\0';
2886
2887 /* If the mode was not set before, explicitly or implicitly, then we're
2888 not emitting SH64 code, so this pseudo is invalid. */
2889 if (sh64_abi == sh64_abi_unspecified)
2890 as_bad (_("The `.abi %s' directive is not valid with this architecture"),
2891 name);
2892
2893 if (strcmp (name, "64") == 0)
2894 {
2895 if (sh64_abi != sh64_abi_64)
2896 as_bad (_("`.abi 64' but command-line options do not specify 64-bit ABI"));
2897 }
2898 else if (strcmp (name, "32") == 0)
2899 {
2900 if (sh64_abi != sh64_abi_32)
2901 as_bad (_("`.abi 32' but command-line options do not specify 32-bit ABI"));
2902 }
2903 else
2904 as_bad (_("Invalid argument to .abi: %s"), name);
2905
2906 *input_line_pointer = ch;
2907 demand_empty_rest_of_line ();
2908}
2909
2910/* This function is the first target-specific function called after
2911 parsing command-line options. Therefore we set default values from
2912 command-line options here and do some sanity checking we couldn't do
2913 when options were being parsed. */
2914
2915const char *
8edc77b9 2916sh64_target_format (void)
324bfcf3 2917{
5b0e55b6
JT		 2918#ifdef TE_NetBSD
2919 /* For NetBSD, if the ISA is unspecified, always use SHmedia. */
2920 if (sh64_isa_mode == sh64_isa_unspecified)
2921 sh64_isa_mode = sh64_isa_shmedia;
2922
2923 /* If the ABI is unspecified, select a default: based on how
2924 we were configured: sh64 == sh64_abi_64, else sh64_abi_32. */
2925 if (sh64_abi == sh64_abi_unspecified)
2926 {
2927 if (sh64_isa_mode == sh64_isa_shcompact)
2928 sh64_abi = sh64_abi_32;
2929 else if (strncmp (TARGET_CPU, "sh64", 4) == 0)
2930 sh64_abi = sh64_abi_64;
2931 else
2932 sh64_abi = sh64_abi_32;
2933 }
2934#endif
2935
f61dfddf
SC		 2936#ifdef TE_LINUX
2937 if (sh64_isa_mode == sh64_isa_unspecified)
2938 sh64_isa_mode = sh64_isa_shmedia;
2939
2940 if (sh64_abi == sh64_abi_unspecified)
2941 sh64_abi = sh64_abi_32;
2942#endif
2943
324bfcf3
AO		 2944 if (sh64_abi == sh64_abi_64 && sh64_isa_mode == sh64_isa_unspecified)
2945 sh64_isa_mode = sh64_isa_shmedia;
2946
2947 if (sh64_abi == sh64_abi_32 && sh64_isa_mode == sh64_isa_unspecified)
2948 sh64_isa_mode = sh64_isa_shcompact;
2949
2950 if (sh64_isa_mode == sh64_isa_shcompact
2951 && sh64_abi == sh64_abi_unspecified)
2952 sh64_abi = sh64_abi_32;
2953
2954 if (sh64_isa_mode == sh64_isa_shmedia
2955 && sh64_abi == sh64_abi_unspecified)
2956 sh64_abi = sh64_abi_64;
2957
2958 if (sh64_isa_mode == sh64_isa_unspecified && ! sh64_mix)
2959 as_bad (_("-no-mix is invalid without specifying SHcompact or SHmedia"));
2960
2961 if ((sh64_isa_mode == sh64_isa_unspecified
2962 || sh64_isa_mode == sh64_isa_shmedia)
2963 && sh64_shcompact_const_crange)
2964 as_bad (_("-shcompact-const-crange is invalid without SHcompact"));
2965
2966 if (sh64_pt32 && sh64_abi != sh64_abi_64)
2967 as_bad (_("-expand-pt32 only valid with -abi=64"));
2968
2969 if (! sh64_expand && sh64_isa_mode == sh64_isa_unspecified)
2970 as_bad (_("-no-expand only valid with SHcompact or SHmedia"));
2971
2972 if (sh64_pt32 && ! sh64_expand)
2973 as_bad (_("-expand-pt32 invalid together with -no-expand"));
2974
5b0e55b6
JT		 2975#ifdef TE_NetBSD
2976 if (sh64_abi == sh64_abi_64)
2977 return (target_big_endian ? "elf64-sh64-nbsd" : "elf64-sh64l-nbsd");
2978 else
2979 return (target_big_endian ? "elf32-sh64-nbsd" : "elf32-sh64l-nbsd");
f61dfddf
SC		 2980#elif defined (TE_LINUX)
2981 if (sh64_abi == sh64_abi_64)
2982 return (target_big_endian ? "elf64-sh64big-linux" : "elf64-sh64-linux");
2983 else
2984 return (target_big_endian ? "elf32-sh64big-linux" : "elf32-sh64-linux");
5b0e55b6 2985#else
324bfcf3
AO		 2986 /* When the ISA is not one of SHmedia or SHcompact, use the old SH
2987 object format. */
2988 if (sh64_isa_mode == sh64_isa_unspecified)
2989 return (target_big_endian ? "elf32-sh" : "elf32-shl");
2990 else if (sh64_abi == sh64_abi_64)
2991 return (target_big_endian ? "elf64-sh64" : "elf64-sh64l");
2992 else
2993 return (target_big_endian ? "elf32-sh64" : "elf32-sh64l");
5b0e55b6 2994#endif
324bfcf3
AO		 2995}
2996
2997/* The worker function of TARGET_MACH. */
2998
2999int
8edc77b9 3000sh64_target_mach (void)
324bfcf3
AO		 3001{
3002 /* We need to explicitly set bfd_mach_sh5 instead of the default 0. But
3003 we only do this for the 64-bit ABI: if we do it for the 32-bit ABI,
3004 the SH5 info in the bfd_arch_info structure will be selected.
3005 However correct, as the machine has 64-bit addresses, functions
3006 expected to emit 32-bit data for addresses will start failing. For
3007 example, the dwarf2dbg.c functions will emit 64-bit debugging format,
3008 and we don't want that in the 32-bit ABI.
3009
3010 We could have two bfd_arch_info structures for SH64; one for the
3011 32-bit ABI and one for the rest (64-bit ABI). But that would be a
3012 bigger kludge: it's a flaw in the BFD design, and we need to just
3013 work around it by having the default machine set here in the
3014 assembler. For everything else but the assembler, the various bfd
3015 functions will set the machine type right to bfd_mach_sh5 from object
3016 file header flags regardless of the 0 here. */
3017
3018 return (sh64_abi == sh64_abi_64) ? bfd_mach_sh5 : 0;
3019}
3020
3021/* This is MD_PCREL_FROM_SECTION, we we define so it is called instead of
3022 md_pcrel_from (in tc-sh.c). */
3023
3024valueT
8edc77b9 3025shmedia_md_pcrel_from_section (struct fix *fixP, segT sec ATTRIBUTE_UNUSED)
324bfcf3
AO		 3026{
3027 know (fixP->fx_frag->fr_type == rs_machine_dependent);
3028
3029 /* Use the ISA for the instruction to decide which offset to use. We
3030 can glean it from the fisup type. */
3031 switch (fixP->fx_r_type)
3032 {
3033 case BFD_RELOC_SH_IMM_LOW16:
3034 case BFD_RELOC_SH_IMM_MEDLOW16:
3035 case BFD_RELOC_SH_IMM_MEDHI16:
3036 case BFD_RELOC_SH_IMM_HI16:
3037 case BFD_RELOC_SH_IMM_LOW16_PCREL:
3038 case BFD_RELOC_SH_IMM_MEDLOW16_PCREL:
3039 case BFD_RELOC_SH_IMM_MEDHI16_PCREL:
3040 case BFD_RELOC_SH_IMM_HI16_PCREL:
3041 case BFD_RELOC_SH_IMMU5:
3042 case BFD_RELOC_SH_IMMU6:
3043 case BFD_RELOC_SH_IMMS6:
3044 case BFD_RELOC_SH_IMMS10:
3045 case BFD_RELOC_SH_IMMS10BY2:
3046 case BFD_RELOC_SH_IMMS10BY4:
3047 case BFD_RELOC_SH_IMMS10BY8:
3048 case BFD_RELOC_SH_IMMS16:
3049 case BFD_RELOC_SH_IMMU16:
3050 case BFD_RELOC_SH_PT_16:
3051 case SHMEDIA_BFD_RELOC_PT:
3052 /* PC-relative relocs are relative to the address of the last generated
3053 instruction, i.e. fx_size - 4. */
3054 return SHMEDIA_MD_PCREL_FROM_FIX (fixP);
3055
3056 case BFD_RELOC_64:
3057 case BFD_RELOC_64_PCREL:
3058 know (0 /* Shouldn't get here. */);
3059 break;
3060
3061 default:
3062 /* If section was SHcompact, use its function. */
3063 return (valueT) md_pcrel_from_section (fixP, sec);
3064 }
3065
3066 know (0 /* Shouldn't get here. */);
3067 return 0;
3068}
3069
3070/* Create one .cranges descriptor from two symbols, STARTSYM marking begin
3071 and ENDSYM marking end, and CR_TYPE specifying the type. */
3072
3073static void
8edc77b9
KK		 3074sh64_emit_crange (symbolS *startsym, symbolS *endsym,
3075 enum sh64_elf_cr_type cr_type)
324bfcf3
AO		 3076{
3077 expressionS exp;
3078 segT current_seg = now_seg;
3079 subsegT current_subseg = now_subseg;
3080
3081 asection *cranges
3082 = bfd_make_section_old_way (stdoutput,
3083 SH64_CRANGES_SECTION_NAME);
3084
3085 /* Temporarily change to the .cranges section. */
3086 subseg_set (cranges, 0);
3087
3088 /* Emit the cr_addr part. */
3089 exp.X_op = O_symbol;
3090 exp.X_add_number = 0;
3091 exp.X_op_symbol = NULL;
3092 exp.X_add_symbol = startsym;
3093 emit_expr (&exp, 4);
3094
3095 /* Emit the cr_size part. */
3096 exp.X_op = O_subtract;
3097 exp.X_add_number = 0;
3098 exp.X_add_symbol = endsym;
3099 exp.X_op_symbol = startsym;
3100 emit_expr (&exp, 4);
3101
5d6255fe 3102 /* Emit the cr_size part. */
324bfcf3
AO		 3103 exp.X_op = O_constant;
3104 exp.X_add_number = cr_type;
3105 exp.X_add_symbol = NULL;
3106 exp.X_op_symbol = NULL;
3107 emit_expr (&exp, 2);
3108
3109 /* Now back to our regular program. */
3110 subseg_set (current_seg, current_subseg);
3111}
3112
3113/* Called when the assembler is about to emit contents of some type into
3114 SEG, so it is *known* that the type of that new contents is in
3115 NEW_CONTENTS_TYPE. If just switching back and forth between different
3116 contents types (for example, with consecutive .mode pseudos), then this
3117 function isn't called. */
3118
3119static void
8edc77b9 3120sh64_set_contents_type (enum sh64_elf_cr_type new_contents_type)
324bfcf3
AO		 3121{
3122 segment_info_type *seginfo;
3123
3124 /* We will not be called when emitting .cranges output, since callers
3125 stop that. Validize that assumption. */
b34976b6 3126 know (!emitting_crange);
324bfcf3
AO		 3127
3128 seginfo = seg_info (now_seg);
3129
3130 if (seginfo)
3131 {
3132 symbolS *symp = seginfo->tc_segment_info_data.last_contents_mark;
3133
3134 enum sh64_elf_cr_type contents_type
3135 = seginfo->tc_segment_info_data.contents_type;
3136
3137 /* If it was just SHcompact switching between code and constant
3138 pool, don't change contents type. Just make sure we don't set
3139 the contents type to data, as that would join with a data-region
3140 in SHmedia mode. */
3141 if (sh64_isa_mode == sh64_isa_shcompact
3142 && ! sh64_shcompact_const_crange)
3143 new_contents_type = CRT_SH5_ISA16;
3144
3145 /* If nothing changed, stop here. */
3146 if (contents_type == new_contents_type)
3147 return;
3148
3149 /* If we're in 64-bit ABI mode, we do not emit .cranges, as it is
3150 only specified for 32-bit addresses. It could presumably be
3151 extended, but in 64-bit ABI mode we don't have SHcompact code, so
3152 we would only use it to mark code and data. */
3153 if (sh64_abi == sh64_abi_64)
3154 {
3155 /* Make the code type "sticky". We don't want to set the
3156 sections contents type to data if there's any code in it as
3157 we don't have .cranges in 64-bit mode to notice the
3158 difference. */
3159 seginfo->tc_segment_info_data.contents_type
3160 = (new_contents_type == CRT_SH5_ISA32
3161 || contents_type == CRT_SH5_ISA32)
3162 ? CRT_SH5_ISA32 : new_contents_type;
3163 return;
3164 }
3165
3166 /* If none was marked, create a start symbol for this range and
3167 perhaps as a closing symbol for the old one. */
3168 if (symp == NULL)
3169 symp = symbol_new (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (),
3170 frag_now);
3171
3172 /* We will use this symbol, so don't leave a pointer behind. */
3173 seginfo->tc_segment_info_data.last_contents_mark = NULL;
3174
3175 /* We'll be making only datalabel references to it, if we emit a
3176 .cranges descriptor, so remove any code flag. */
3177 S_SET_OTHER (symp, S_GET_OTHER (symp) & ~STO_SH5_ISA32);
3178
3179 /* If we have already marked the start of a range, we need to close
3180 and emit it before marking a new one, so emit a new .cranges
3181 descriptor into the .cranges section. */
3182 if (seginfo->tc_segment_info_data.mode_start_symbol)
3183 {
3184 /* If we're not supposed to emit mixed-mode sections, make it an
3185 error, but continue processing. */
3186 if (! sh64_mix
3187 && (new_contents_type == CRT_SH5_ISA32
3188 || contents_type == CRT_SH5_ISA32))
3189 as_bad (
3190_("SHmedia code not allowed in same section as constants and SHcompact code"));
3191
b34976b6 3192 emitting_crange = TRUE;
324bfcf3
AO		 3193 sh64_emit_crange (seginfo->tc_segment_info_data.mode_start_symbol,
3194 symp, contents_type);
b34976b6 3195 emitting_crange = FALSE;
324bfcf3
AO		 3196 seginfo->tc_segment_info_data.emitted_ranges++;
3197 }
3198
3199 seginfo->tc_segment_info_data.mode_start_symbol = symp;
3200 seginfo->tc_segment_info_data.mode_start_subseg = now_subseg;
3201 seginfo->tc_segment_info_data.contents_type = new_contents_type;
3202
3203 /* Always reset this, so the SHcompact code will emit a reloc when
3204 it prepares to relax. */
3205 seginfo->tc_segment_info_data.in_code = 0;
3206 }
3207 else
3208 as_bad (_("No segment info for current section"));
3209}
3210
3211/* Hook when defining symbols and labels. We set the ST_OTHER field if
3212 the symbol is "shmedia" (with "bitor 1" automatically applied). Simple
3213 semantics for a label being "shmedia" : It was defined when .mode
3214 SHmedia was in effect, and it was defined in a code section. It
3215 doesn't matter whether or not an assembled opcode is nearby. */
3216
3217void
8edc77b9 3218sh64_frob_label (symbolS *symp)
324bfcf3
AO		 3219{
3220 segT seg = S_GET_SEGMENT (symp);
3221 static const symbolS *null = NULL;
3222
3223 /* Reset the tc marker for all newly created symbols. */
3224 symbol_set_tc (symp, (symbolS **) &null);
3225
3226 if (seg != NULL && sh64_isa_mode == sh64_isa_shmedia && subseg_text_p (seg))
3227 S_SET_OTHER (symp, S_GET_OTHER (symp) | STO_SH5_ISA32);
3228}
3229
3230/* Handle the "datalabel" qualifier. We need to call "operand", but it's
3231 static, so a function pointer is passed here instead. FIXME: A target
3232 hook for qualifiers is needed; we currently use the md_parse_name
3233 symbol hook. */
3234
3235int
8edc77b9
KK		 3236sh64_consume_datalabel (const char *name, expressionS *exp, char *cp,
3237 segT (*operandf) (expressionS *))
324bfcf3
AO		 3238{
3239 static int parsing_datalabel = 0;
3240
3241 if (strcasecmp (name, "datalabel") == 0)
3242 {
3243 int save_parsing_datalabel = parsing_datalabel;
3244
3245 if (parsing_datalabel)
3246 as_bad (_("duplicate datalabel operator ignored"));
3247
3248 *input_line_pointer = *cp;
3249 parsing_datalabel = 1;
3250 (*operandf) (exp);
3251 parsing_datalabel = save_parsing_datalabel;
3252
3253 if (exp->X_op == O_symbol || exp->X_op == O_PIC_reloc)
3254 {
3255 symbolS *symp = exp->X_add_symbol;
3256 segT symseg = S_GET_SEGMENT (symp);
3257
3258 /* If the symbol is defined to something that is already a
3259 datalabel, we don't need to bother with any special handling. */
3260 if (symseg != undefined_section
3261 && S_GET_OTHER (symp) != STO_SH5_ISA32)
3262 /* Do nothing. */
3263 ;
3264 else
3265 {
3266 symbolS *dl_symp;
3267 const char *name = S_GET_NAME (symp);
3268 char *dl_name
3269 = xmalloc (strlen (name) + sizeof (DATALABEL_SUFFIX));
3270
3271 /* Now we copy the datalabel-qualified symbol into a symbol
3272 with the same name, but with " DL" appended. We mark the
3273 symbol using the TC_SYMFIELD_TYPE field with a pointer to
3274 the main symbol, so we don't have to inspect all symbol
3275 names. Note that use of "datalabel" is not expected to
3276 be a common case. */
3277 strcpy (dl_name, name);
3278 strcat (dl_name, DATALABEL_SUFFIX);
3279
3280 /* A FAKE_LABEL_NAME marks "$" or ".". There can be any
3281 number of them and all have the same (faked) name; we
3282 must make a new one each time. */
3283 if (strcmp (name, FAKE_LABEL_NAME) == 0)
3284 dl_symp = symbol_make (dl_name);
3285 else
3286 dl_symp = symbol_find_or_make (dl_name);
3287
3288 free (dl_name);
3289 symbol_set_value_expression (dl_symp,
3290 symbol_get_value_expression (symp));
3291 S_SET_SEGMENT (dl_symp, symseg);
3292 symbol_set_frag (dl_symp, symbol_get_frag (symp));
3293 symbol_set_tc (dl_symp, &symp);
3294 copy_symbol_attributes (dl_symp, symp);
3295 exp->X_add_symbol = dl_symp;
3296
3297 /* Unset the BranchTarget mark that can be set at symbol
5d6255fe 3298 creation or attributes copying. */
324bfcf3
AO		 3299 S_SET_OTHER (dl_symp, S_GET_OTHER (dl_symp) & ~STO_SH5_ISA32);
3300
3301 /* The GLOBAL and WEAK attributes are not copied over by
5d6255fe 3302 copy_symbol_attributes. Do it here. */
324bfcf3
AO		 3303 if (S_IS_WEAK (symp))
3304 S_SET_WEAK (dl_symp);
3305 else if (S_IS_EXTERNAL (symp))
3306 S_SET_EXTERNAL (dl_symp);
3307 }
3308 }
3309 /* Complain about other types of operands than symbol, unless they
3310 have already been complained about. A constant is always a
3311 datalabel. Removing the low bit would therefore be wrong.
3312 Complaining about it would also be wrong. */
3313 else if (exp->X_op != O_illegal
3314 && exp->X_op != O_absent
3315 && exp->X_op != O_constant)
3316 as_bad (_("Invalid DataLabel expression"));
3317
3318 *cp = *input_line_pointer;
3319
3320 return 1;
3321 }
3322
3323 return sh_parse_name (name, exp, cp);
3324}
3325
3326/* This function is called just before symbols are being output. It
3327 returns zero when a symbol must be output, non-zero otherwise.
3328 Datalabel references that were fully resolved to local symbols are not
3329 necessary to output. We also do not want to output undefined symbols
3330 that are not used in relocs. For symbols that are used in a reloc, it
3331 does not matter what we set here. If it is *not* used in a reloc, then
3332 it was probably the datalabel counterpart that was used in a reloc;
3333 then we need not output the main symbol. */
3334
3335int
8edc77b9 3336sh64_exclude_symbol (symbolS *symp)
324bfcf3
AO		 3337{
3338 symbolS *main_symbol = *symbol_get_tc (symp);
3339
3340 return main_symbol != NULL || ! S_IS_DEFINED (symp);
3341}
3342
3343/* If we haven't seen an insn since the last update, and location
3344 indicators have moved (a new frag, new location within frag) we have
3345 emitted data, so change contents type to data. Forget that we have
3346 seen a sequence of insns and store the current location so we can mark
3347 a new region if needed. */
3348
3349static void
8edc77b9 3350sh64_update_contents_mark (bfd_boolean update_type)
324bfcf3
AO		 3351{
3352 segment_info_type *seginfo;
3353 seginfo = seg_info (now_seg);
3354
3355 if (seginfo != NULL)
3356 {
3357 symbolS *symp = seginfo->tc_segment_info_data.last_contents_mark;
3358
3359 if (symp == NULL)
3360 {
3361 symp = symbol_new (FAKE_LABEL_NAME, now_seg,
3362 (valueT) frag_now_fix (), frag_now);
3363 seginfo->tc_segment_info_data.last_contents_mark = symp;
3364 }
3365 else
3366 {
3367 /* If we have moved location since last flush, we need to emit a
3368 data range. The previous contents type ended at the location
3369 of the last update. */
3370 if ((S_GET_VALUE (symp) != frag_now_fix ()
3371 || symbol_get_frag (symp) != frag_now))
3372 {
3373 enum sh64_elf_cr_type contents_type
3374 = seginfo->tc_segment_info_data.contents_type;
3375
3376 if (update_type
3377 && contents_type != CRT_DATA
3378 && contents_type != CRT_NONE
3379 && ! seen_insn)
3380 {
3381 sh64_set_contents_type (CRT_DATA);
3382 symp = seginfo->tc_segment_info_data.last_contents_mark;
3383 }
3384
3385 /* If the symbol wasn't used up to make up a new range
3386 descriptor, update it to this new location. */
3387 if (symp)
3388 {
3389 S_SET_VALUE (symp, (valueT) frag_now_fix ());
3390 symbol_set_frag (symp, frag_now);
3391 }
3392 }
3393 }
3394 }
3395
b34976b6 3396 seen_insn = FALSE;
324bfcf3
AO		 3397}
3398
3399/* Called when the assembler is about to output some data, or maybe it's
3400 just switching segments. */
3401
3402void
8edc77b9 3403sh64_flush_pending_output (void)
324bfcf3 3404{
b34976b6 3405 sh64_update_contents_mark (TRUE);
324bfcf3
AO		 3406 sh_flush_pending_output ();
3407}
3408
3409/* Flush out the last crange descriptor after all insns have been emitted. */
3410
3411static void
8edc77b9
KK		 3412sh64_flush_last_crange (bfd *abfd ATTRIBUTE_UNUSED, asection *seg,
3413 void *countparg ATTRIBUTE_UNUSED)
324bfcf3
AO		 3414{
3415 segment_info_type *seginfo;
3416
3417 seginfo = seg_info (seg);
3418
3419 if (seginfo
3420 /* Only emit .cranges descriptors if we would make it more than one. */
3421 && seginfo->tc_segment_info_data.emitted_ranges != 0)
3422 {
3423 symbolS *symp;
3424
3425 /* We need a closing symbol, so switch to the indicated section and
3426 emit it. */
3427
3428 /* Change to the section we're about to handle. */
3429 subseg_set (seg, seginfo->tc_segment_info_data.mode_start_subseg);
3430
3431 symp = symbol_new (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (),
3432 frag_now);
3433
3434 /* We'll be making a datalabel reference to it, so remove any code
3435 flag. */
3436 S_SET_OTHER (symp, S_GET_OTHER (symp) & ~STO_SH5_ISA32);
3437
3438 sh64_emit_crange (seginfo->tc_segment_info_data.mode_start_symbol,
3439 symp,
3440 seginfo->tc_segment_info_data.contents_type);
3441 }
3442}
3443
3444/* If and only if we see a call to md_number_to_chars without flagging the
3445 start of an insn, we set the contents type to CRT_DATA, and only when
3446 in SHmedia mode. Note that by default we don't bother changing when
3447 going from SHcompact to data, as the constant pools in GCC-generated
3448 SHcompact code would create an inordinate amount of .cranges
3449 descriptors. */
3450
3451static void
8edc77b9 3452sh64_flag_output (void)
324bfcf3
AO		 3453{
3454 if (sh64_isa_mode != sh64_isa_unspecified
b34976b6
AM		 3455 && !seen_insn
3456 && !sh64_end_of_assembly
3457 && !emitting_crange)
324bfcf3
AO		 3458 {
3459 md_flush_pending_output ();
3460 sh64_set_contents_type (CRT_DATA);
3461 }
3462}
3463
3464/* Vtables don't need "datalabel" but we allow it by simply deleting
5d6255fe 3465 any we find. */
324bfcf3
AO		 3466
3467static char *
8edc77b9 3468strip_datalabels (void)
324bfcf3
AO		 3469{
3470 char *src, *dest, *start=input_line_pointer;
3471
3472 for (src=input_line_pointer, dest=input_line_pointer; *src != '\n'; )
3473 {
3474 if (strncasecmp (src, "datalabel", 9) == 0
3475 && ISSPACE (src[9])
3476 && (src == start || !(ISALNUM (src[-1])) || src[-1] == '_'))
3477 src += 10;
3478 else
3479 *dest++ = *src++;
3480 }
3481
3482 if (dest < src)
3483 *dest = '\n';
3484 return src + 1;
3485}
3486
3487static void
8edc77b9 3488sh64_vtable_entry (int ignore ATTRIBUTE_UNUSED)
324bfcf3
AO		 3489{
3490 char *eol = strip_datalabels ();
3491
3492 obj_elf_vtable_entry (0);
3493 input_line_pointer = eol;
3494}
3495
3496static void
8edc77b9 3497sh64_vtable_inherit (int ignore ATTRIBUTE_UNUSED)
324bfcf3
AO		 3498{
3499 char *eol = strip_datalabels ();
3500
3501 obj_elf_vtable_inherit (0);
3502 input_line_pointer = eol;
3503}
8edc77b9 3504
GDB Binutils - Deliverables
This page took 0.241898 seconds and 4 git commands to generate.