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