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