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