1 /* tc-m32c.c -- Assembler for the Renesas M32C. 2 Copyright (C) 2005-2018 Free Software Foundation, Inc. 3 Contributed by RedHat. 4 5 This file is part of GAS, the GNU Assembler. 6 7 GAS is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GAS is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 #include "as.h" 23 #include "subsegs.h" 24 #include "symcat.h" 25 #include "opcodes/m32c-desc.h" 26 #include "opcodes/m32c-opc.h" 27 #include "cgen.h" 28 #include "elf/common.h" 29 #include "elf/m32c.h" 30 #include "safe-ctype.h" 31 32 /* Structure to hold all of the different components 33 describing an individual instruction. */ 34 typedef struct 35 { 36 const CGEN_INSN * insn; 37 const CGEN_INSN * orig_insn; 38 CGEN_FIELDS fields; 39 #if CGEN_INT_INSN_P 40 CGEN_INSN_INT buffer [1]; 41 #define INSN_VALUE(buf) (*(buf)) 42 #else 43 unsigned char buffer [CGEN_MAX_INSN_SIZE]; 44 #define INSN_VALUE(buf) (buf) 45 #endif 46 char * addr; 47 fragS * frag; 48 int num_fixups; 49 fixS * fixups [GAS_CGEN_MAX_FIXUPS]; 50 int indices [MAX_OPERAND_INSTANCES]; 51 } 52 m32c_insn; 53 54 #define rl_for(_insn) (CGEN_ATTR_CGEN_INSN_RL_TYPE_VALUE (&((_insn).insn->base->attrs))) 55 #define relaxable(_insn) (CGEN_ATTR_CGEN_INSN_RELAXABLE_VALUE (&((_insn).insn->base->attrs))) 56 57 const char comment_chars[] = ";"; 58 const char line_comment_chars[] = "#"; 59 const char line_separator_chars[] = "|"; 60 const char EXP_CHARS[] = "eE"; 61 const char FLT_CHARS[] = "dD"; 62 63 #define M32C_SHORTOPTS "" 64 const char * md_shortopts = M32C_SHORTOPTS; 65 66 /* assembler options */ 67 #define OPTION_CPU_M16C (OPTION_MD_BASE) 68 #define OPTION_CPU_M32C (OPTION_MD_BASE + 1) 69 #define OPTION_LINKRELAX (OPTION_MD_BASE + 2) 70 #define OPTION_H_TICK_HEX (OPTION_MD_BASE + 3) 71 72 struct option md_longopts[] = 73 { 74 { "m16c", no_argument, NULL, OPTION_CPU_M16C }, 75 { "m32c", no_argument, NULL, OPTION_CPU_M32C }, 76 { "relax", no_argument, NULL, OPTION_LINKRELAX }, 77 { "h-tick-hex", no_argument, NULL, OPTION_H_TICK_HEX }, 78 {NULL, no_argument, NULL, 0} 79 }; 80 size_t md_longopts_size = sizeof (md_longopts); 81 82 /* Default machine */ 83 84 #define DEFAULT_MACHINE bfd_mach_m16c 85 #define DEFAULT_FLAGS EF_M32C_CPU_M16C 86 87 static unsigned long m32c_mach = bfd_mach_m16c; 88 static int cpu_mach = (1 << MACH_M16C); 89 static int insn_size; 90 static int m32c_relax = 0; 91 92 /* Flags to set in the elf header */ 93 static flagword m32c_flags = DEFAULT_FLAGS; 94 95 static char default_isa = 1 << (7 - ISA_M16C); 96 static CGEN_BITSET m32c_isa = {1, & default_isa}; 97 98 static void 99 set_isa (enum isa_attr isa_num) 100 { 101 cgen_bitset_set (& m32c_isa, isa_num); 102 } 103 104 static void s_bss (int); 105 106 int 107 md_parse_option (int c, const char * arg ATTRIBUTE_UNUSED) 108 { 109 switch (c) 110 { 111 case OPTION_CPU_M16C: 112 m32c_flags = (m32c_flags & ~EF_M32C_CPU_MASK) | EF_M32C_CPU_M16C; 113 m32c_mach = bfd_mach_m16c; 114 cpu_mach = (1 << MACH_M16C); 115 set_isa (ISA_M16C); 116 break; 117 118 case OPTION_CPU_M32C: 119 m32c_flags = (m32c_flags & ~EF_M32C_CPU_MASK) | EF_M32C_CPU_M32C; 120 m32c_mach = bfd_mach_m32c; 121 cpu_mach = (1 << MACH_M32C); 122 set_isa (ISA_M32C); 123 break; 124 125 case OPTION_LINKRELAX: 126 m32c_relax = 1; 127 break; 128 129 case OPTION_H_TICK_HEX: 130 enable_h_tick_hex = 1; 131 break; 132 133 default: 134 return 0; 135 } 136 return 1; 137 } 138 139 void 140 md_show_usage (FILE * stream) 141 { 142 fprintf (stream, _(" M32C specific command line options:\n")); 143 } 144 145 static void 146 s_bss (int ignore ATTRIBUTE_UNUSED) 147 { 148 int temp; 149 150 temp = get_absolute_expression (); 151 subseg_set (bss_section, (subsegT) temp); 152 demand_empty_rest_of_line (); 153 } 154 155 /* The target specific pseudo-ops which we support. */ 156 const pseudo_typeS md_pseudo_table[] = 157 { 158 { "bss", s_bss, 0}, 159 { "3byte", cons, 3 }, 160 { "word", cons, 4 }, 161 { NULL, NULL, 0 } 162 }; 163 164 165 void 166 md_begin (void) 167 { 168 /* Initialize the `cgen' interface. */ 169 170 /* Set the machine number and endian. */ 171 gas_cgen_cpu_desc = m32c_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, cpu_mach, 172 CGEN_CPU_OPEN_ENDIAN, 173 CGEN_ENDIAN_BIG, 174 CGEN_CPU_OPEN_ISAS, & m32c_isa, 175 CGEN_CPU_OPEN_END); 176 177 m32c_cgen_init_asm (gas_cgen_cpu_desc); 178 179 /* This is a callback from cgen to gas to parse operands. */ 180 cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand); 181 182 /* Set the ELF flags if desired. */ 183 if (m32c_flags) 184 bfd_set_private_flags (stdoutput, m32c_flags); 185 186 /* Set the machine type */ 187 bfd_default_set_arch_mach (stdoutput, bfd_arch_m32c, m32c_mach); 188 189 insn_size = 0; 190 } 191 192 void 193 m32c_md_end (void) 194 { 195 int i, n_nops; 196 197 if (bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) 198 { 199 /* Pad with nops for objdump. */ 200 n_nops = (32 - ((insn_size) % 32)) / 8; 201 for (i = 1; i <= n_nops; i++) 202 md_assemble ((char *) "nop"); 203 } 204 } 205 206 void 207 m32c_start_line_hook (void) 208 { 209 #if 0 /* not necessary....handled in the .cpu file */ 210 char *s = input_line_pointer; 211 char *sg; 212 213 for (s = input_line_pointer ; s && s[0] != '\n'; s++) 214 { 215 if (s[0] == ':') 216 { 217 /* Remove :g suffix. Squeeze out blanks. */ 218 if (s[1] == 'g') 219 { 220 for (sg = s - 1; sg && sg >= input_line_pointer; sg--) 221 { 222 sg[2] = sg[0]; 223 } 224 sg[1] = ' '; 225 sg[2] = ' '; 226 input_line_pointer += 2; 227 } 228 } 229 } 230 #endif 231 } 232 233 /* Process [[indirect-operands]] in instruction str. */ 234 235 static bfd_boolean 236 m32c_indirect_operand (char *str) 237 { 238 char *new_str; 239 char *s; 240 char *ns; 241 int ns_len; 242 char *ns_end; 243 enum indirect_type {none, relative, absolute} ; 244 enum indirect_type indirection [3] = { none, none, none }; 245 int brace_n [3] = { 0, 0, 0 }; 246 int operand; 247 248 s = str; 249 operand = 1; 250 for (s = str; *s; s++) 251 { 252 if (s[0] == ',') 253 operand = 2; 254 /* [abs] where abs is not a0 or a1 */ 255 if (s[1] == '[' && ! (s[2] == 'a' && (s[3] == '0' || s[3] == '1')) 256 && (ISBLANK (s[0]) || s[0] == ',')) 257 indirection[operand] = absolute; 258 if (s[0] == ']' && s[1] == ']') 259 indirection[operand] = relative; 260 if (s[0] == '[' && s[1] == '[') 261 indirection[operand] = relative; 262 } 263 264 if (indirection[1] == none && indirection[2] == none) 265 return FALSE; 266 267 operand = 1; 268 ns_len = strlen (str); 269 new_str = XNEWVEC (char, ns_len); 270 ns = new_str; 271 ns_end = ns + ns_len; 272 273 for (s = str; *s; s++) 274 { 275 if (s[0] == ',') 276 operand = 2; 277 278 if (s[0] == '[' && ! brace_n[operand]) 279 { 280 brace_n[operand] += 1; 281 /* Squeeze [[ to [ if this is an indirect operand. */ 282 if (indirection[operand] != none) 283 continue; 284 } 285 286 else if (s[0] == '[' && brace_n[operand]) 287 { 288 brace_n[operand] += 1; 289 } 290 else if (s[0] == ']' && s[1] == ']' && indirection[operand] == relative) 291 { 292 s += 1; /* skip one ]. */ 293 brace_n[operand] -= 2; /* allow for 2 [. */ 294 } 295 else if (s[0] == ']' && indirection[operand] == absolute) 296 { 297 brace_n[operand] -= 1; 298 continue; /* skip closing ]. */ 299 } 300 else if (s[0] == ']') 301 { 302 brace_n[operand] -= 1; 303 } 304 *ns = s[0]; 305 ns += 1; 306 if (ns >= ns_end) 307 return FALSE; 308 if (s[0] == 0) 309 break; 310 } 311 *ns = '\0'; 312 for (operand = 1; operand <= 2; operand++) 313 if (brace_n[operand]) 314 { 315 fprintf (stderr, "Unmatched [[operand-%d]] %d\n", operand, brace_n[operand]); 316 } 317 318 if (indirection[1] != none && indirection[2] != none) 319 md_assemble ((char *) "src-dest-indirect"); 320 else if (indirection[1] != none) 321 md_assemble ((char *) "src-indirect"); 322 else if (indirection[2] != none) 323 md_assemble ((char *) "dest-indirect"); 324 325 md_assemble (new_str); 326 free (new_str); 327 return TRUE; 328 } 329 330 void 331 md_assemble (char * str) 332 { 333 static int last_insn_had_delay_slot = 0; 334 m32c_insn insn; 335 char * errmsg; 336 finished_insnS results; 337 int rl_type; 338 339 if (m32c_mach == bfd_mach_m32c && m32c_indirect_operand (str)) 340 return; 341 342 /* Initialize GAS's cgen interface for a new instruction. */ 343 gas_cgen_init_parse (); 344 345 insn.insn = m32c_cgen_assemble_insn 346 (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg); 347 348 if (!insn.insn) 349 { 350 as_bad ("%s", errmsg); 351 return; 352 } 353 354 results.num_fixups = 0; 355 /* Doesn't really matter what we pass for RELAX_P here. */ 356 gas_cgen_finish_insn (insn.insn, insn.buffer, 357 CGEN_FIELDS_BITSIZE (& insn.fields), 1, &results); 358 359 last_insn_had_delay_slot 360 = CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_DELAY_SLOT); 361 (void) last_insn_had_delay_slot; 362 insn_size = CGEN_INSN_BITSIZE(insn.insn); 363 364 rl_type = rl_for (insn); 365 366 /* We have to mark all the jumps, because we need to adjust them 367 when we delete bytes, but we only need to mark the displacements 368 if they're symbolic - if they're not, we've already picked the 369 shortest opcode by now. The linker, however, will still have to 370 check any operands to see if they're the displacement type, since 371 we don't know (nor record) *which* operands are relaxable. */ 372 if (m32c_relax 373 && rl_type != RL_TYPE_NONE 374 && (rl_type == RL_TYPE_JUMP || results.num_fixups) 375 && !relaxable (insn)) 376 { 377 int reloc = 0; 378 int addend = results.num_fixups + 16 * insn_size/8; 379 380 switch (rl_for (insn)) 381 { 382 case RL_TYPE_JUMP: reloc = BFD_RELOC_M32C_RL_JUMP; break; 383 case RL_TYPE_1ADDR: reloc = BFD_RELOC_M32C_RL_1ADDR; break; 384 case RL_TYPE_2ADDR: reloc = BFD_RELOC_M32C_RL_2ADDR; break; 385 } 386 if (insn.insn->base->num == M32C_INSN_JMP16_S 387 || insn.insn->base->num == M32C_INSN_JMP32_S) 388 addend = 0x10; 389 390 fix_new (results.frag, 391 results.addr - results.frag->fr_literal, 392 0, abs_section_sym, addend, 0, 393 reloc); 394 } 395 } 396 397 /* The syntax in the manual says constants begin with '#'. 398 We just ignore it. */ 399 400 void 401 md_operand (expressionS * exp) 402 { 403 /* In case of a syntax error, escape back to try next syntax combo. */ 404 if (exp->X_op == O_absent) 405 gas_cgen_md_operand (exp); 406 } 407 408 valueT 409 md_section_align (segT segment, valueT size) 410 { 411 int align = bfd_get_section_alignment (stdoutput, segment); 412 return ((size + (1 << align) - 1) & -(1 << align)); 413 } 414 415 symbolS * 416 md_undefined_symbol (char * name ATTRIBUTE_UNUSED) 417 { 418 return 0; 419 } 420 421 const relax_typeS md_relax_table[] = 422 { 423 /* The fields are: 424 1) most positive reach of this state, 425 2) most negative reach of this state, 426 3) how many bytes this mode will have in the variable part of the frag 427 4) which index into the table to try if we can't fit into this one. */ 428 429 /* 0 */ { 0, 0, 0, 0 }, /* unused */ 430 /* 1 */ { 0, 0, 0, 0 }, /* marker for "don't know yet" */ 431 432 /* 2 */ { 127, -128, 2, 3 }, /* jcnd16_5.b */ 433 /* 3 */ { 32767, -32768, 5, 4 }, /* jcnd16_5.w */ 434 /* 4 */ { 0, 0, 6, 0 }, /* jcnd16_5.a */ 435 436 /* 5 */ { 127, -128, 2, 6 }, /* jcnd16.b */ 437 /* 6 */ { 32767, -32768, 5, 7 }, /* jcnd16.w */ 438 /* 7 */ { 0, 0, 6, 0 }, /* jcnd16.a */ 439 440 /* 8 */ { 8, 1, 1, 9 }, /* jmp16.s */ 441 /* 9 */ { 127, -128, 2, 10 }, /* jmp16.b */ 442 /* 10 */ { 32767, -32768, 3, 11 }, /* jmp16.w */ 443 /* 11 */ { 0, 0, 4, 0 }, /* jmp16.a */ 444 445 /* 12 */ { 127, -128, 2, 13 }, /* jcnd32.b */ 446 /* 13 */ { 32767, -32768, 5, 14 }, /* jcnd32.w */ 447 /* 14 */ { 0, 0, 6, 0 }, /* jcnd32.a */ 448 449 /* 15 */ { 8, 1, 1, 16 }, /* jmp32.s */ 450 /* 16 */ { 127, -128, 2, 17 }, /* jmp32.b */ 451 /* 17 */ { 32767, -32768, 3, 18 }, /* jmp32.w */ 452 /* 18 */ { 0, 0, 4, 0 }, /* jmp32.a */ 453 454 /* 19 */ { 32767, -32768, 3, 20 }, /* jsr16.w */ 455 /* 20 */ { 0, 0, 4, 0 }, /* jsr16.a */ 456 /* 21 */ { 32767, -32768, 3, 11 }, /* jsr32.w */ 457 /* 22 */ { 0, 0, 4, 0 }, /* jsr32.a */ 458 459 /* 23 */ { 0, 0, 3, 0 }, /* adjnz pc8 */ 460 /* 24 */ { 0, 0, 4, 0 }, /* adjnz disp8 pc8 */ 461 /* 25 */ { 0, 0, 5, 0 }, /* adjnz disp16 pc8 */ 462 /* 26 */ { 0, 0, 6, 0 } /* adjnz disp24 pc8 */ 463 }; 464 465 enum { 466 M32C_MACRO_JCND16_5_W, 467 M32C_MACRO_JCND16_5_A, 468 M32C_MACRO_JCND16_W, 469 M32C_MACRO_JCND16_A, 470 M32C_MACRO_JCND32_W, 471 M32C_MACRO_JCND32_A, 472 /* the digit is the array index of the pcrel byte */ 473 M32C_MACRO_ADJNZ_2, 474 M32C_MACRO_ADJNZ_3, 475 M32C_MACRO_ADJNZ_4, 476 M32C_MACRO_ADJNZ_5, 477 }; 478 479 static struct { 480 int insn; 481 int bytes; 482 int insn_for_extern; 483 int pcrel_aim_offset; 484 } subtype_mappings[] = { 485 /* 0 */ { 0, 0, 0, 0 }, 486 /* 1 */ { 0, 0, 0, 0 }, 487 488 /* 2 */ { M32C_INSN_JCND16_5, 2, -M32C_MACRO_JCND16_5_A, 1 }, 489 /* 3 */ { -M32C_MACRO_JCND16_5_W, 5, -M32C_MACRO_JCND16_5_A, 4 }, 490 /* 4 */ { -M32C_MACRO_JCND16_5_A, 6, -M32C_MACRO_JCND16_5_A, 0 }, 491 492 /* 5 */ { M32C_INSN_JCND16, 3, -M32C_MACRO_JCND16_A, 1 }, 493 /* 6 */ { -M32C_MACRO_JCND16_W, 6, -M32C_MACRO_JCND16_A, 4 }, 494 /* 7 */ { -M32C_MACRO_JCND16_A, 7, -M32C_MACRO_JCND16_A, 0 }, 495 496 /* 8 */ { M32C_INSN_JMP16_S, 1, M32C_INSN_JMP16_A, 0 }, 497 /* 9 */ { M32C_INSN_JMP16_B, 2, M32C_INSN_JMP16_A, 1 }, 498 /* 10 */ { M32C_INSN_JMP16_W, 3, M32C_INSN_JMP16_A, 2 }, 499 /* 11 */ { M32C_INSN_JMP16_A, 4, M32C_INSN_JMP16_A, 0 }, 500 501 /* 12 */ { M32C_INSN_JCND32, 2, -M32C_MACRO_JCND32_A, 1 }, 502 /* 13 */ { -M32C_MACRO_JCND32_W, 5, -M32C_MACRO_JCND32_A, 4 }, 503 /* 14 */ { -M32C_MACRO_JCND32_A, 6, -M32C_MACRO_JCND32_A, 0 }, 504 505 /* 15 */ { M32C_INSN_JMP32_S, 1, M32C_INSN_JMP32_A, 0 }, 506 /* 16 */ { M32C_INSN_JMP32_B, 2, M32C_INSN_JMP32_A, 1 }, 507 /* 17 */ { M32C_INSN_JMP32_W, 3, M32C_INSN_JMP32_A, 2 }, 508 /* 18 */ { M32C_INSN_JMP32_A, 4, M32C_INSN_JMP32_A, 0 }, 509 510 /* 19 */ { M32C_INSN_JSR16_W, 3, M32C_INSN_JSR16_A, 2 }, 511 /* 20 */ { M32C_INSN_JSR16_A, 4, M32C_INSN_JSR16_A, 0 }, 512 /* 21 */ { M32C_INSN_JSR32_W, 3, M32C_INSN_JSR32_A, 2 }, 513 /* 22 */ { M32C_INSN_JSR32_A, 4, M32C_INSN_JSR32_A, 0 }, 514 515 /* 23 */ { -M32C_MACRO_ADJNZ_2, 3, -M32C_MACRO_ADJNZ_2, 0 }, 516 /* 24 */ { -M32C_MACRO_ADJNZ_3, 4, -M32C_MACRO_ADJNZ_3, 0 }, 517 /* 25 */ { -M32C_MACRO_ADJNZ_4, 5, -M32C_MACRO_ADJNZ_4, 0 }, 518 /* 26 */ { -M32C_MACRO_ADJNZ_5, 6, -M32C_MACRO_ADJNZ_5, 0 } 519 }; 520 #define NUM_MAPPINGS (sizeof (subtype_mappings) / sizeof (subtype_mappings[0])) 521 522 void 523 m32c_prepare_relax_scan (fragS *fragP, offsetT *aim, relax_substateT this_state) 524 { 525 symbolS *symbolP = fragP->fr_symbol; 526 if (symbolP && !S_IS_DEFINED (symbolP)) 527 *aim = 0; 528 /* Adjust for m32c pcrel not being relative to the next opcode. */ 529 *aim += subtype_mappings[this_state].pcrel_aim_offset; 530 } 531 532 static int 533 insn_to_subtype (int inum, const CGEN_INSN *insn) 534 { 535 unsigned int i; 536 537 if (insn 538 && (strncmp (insn->base->mnemonic, "adjnz", 5) == 0 539 || strncmp (insn->base->mnemonic, "sbjnz", 5) == 0)) 540 { 541 i = 23 + insn->base->bitsize/8 - 3; 542 /*printf("mapping %d used for %s\n", i, insn->base->mnemonic);*/ 543 return i; 544 } 545 546 for (i=0; i<NUM_MAPPINGS; i++) 547 if (inum == subtype_mappings[i].insn) 548 { 549 /*printf("mapping %d used\n", i);*/ 550 return i; 551 } 552 abort (); 553 } 554 555 /* Return an initial guess of the length by which a fragment must grow to 556 hold a branch to reach its destination. 557 Also updates fr_type/fr_subtype as necessary. 558 559 Called just before doing relaxation. 560 Any symbol that is now undefined will not become defined. 561 The guess for fr_var is ACTUALLY the growth beyond fr_fix. 562 Whatever we do to grow fr_fix or fr_var contributes to our returned value. 563 Although it may not be explicit in the frag, pretend fr_var starts with a 564 0 value. */ 565 566 int 567 md_estimate_size_before_relax (fragS * fragP, segT segment ATTRIBUTE_UNUSED) 568 { 569 int where = fragP->fr_opcode - fragP->fr_literal; 570 571 if (fragP->fr_subtype == 1) 572 fragP->fr_subtype = insn_to_subtype (fragP->fr_cgen.insn->base->num, fragP->fr_cgen.insn); 573 574 if (S_GET_SEGMENT (fragP->fr_symbol) != segment) 575 { 576 int new_insn; 577 578 new_insn = subtype_mappings[fragP->fr_subtype].insn_for_extern; 579 fragP->fr_subtype = insn_to_subtype (new_insn, 0); 580 } 581 582 if (fragP->fr_cgen.insn->base 583 && fragP->fr_cgen.insn->base->num 584 != subtype_mappings[fragP->fr_subtype].insn 585 && subtype_mappings[fragP->fr_subtype].insn > 0) 586 { 587 int new_insn= subtype_mappings[fragP->fr_subtype].insn; 588 if (new_insn >= 0) 589 { 590 fragP->fr_cgen.insn = (fragP->fr_cgen.insn 591 - fragP->fr_cgen.insn->base->num 592 + new_insn); 593 } 594 } 595 596 return subtype_mappings[fragP->fr_subtype].bytes - (fragP->fr_fix - where); 597 } 598 599 /* *fragP has been relaxed to its final size, and now needs to have 600 the bytes inside it modified to conform to the new size. 601 602 Called after relaxation is finished. 603 fragP->fr_type == rs_machine_dependent. 604 fragP->fr_subtype is the subtype of what the address relaxed to. */ 605 606 static int 607 target_address_for (fragS *frag) 608 { 609 int rv = frag->fr_offset; 610 symbolS *sym = frag->fr_symbol; 611 612 if (sym) 613 rv += S_GET_VALUE (sym); 614 615 /*printf("target_address_for returns %d\n", rv);*/ 616 return rv; 617 } 618 619 void 620 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED, 621 segT sec ATTRIBUTE_UNUSED, 622 fragS * fragP ATTRIBUTE_UNUSED) 623 { 624 int addend; 625 int operand; 626 int where = fragP->fr_opcode - fragP->fr_literal; 627 int rl_where = fragP->fr_opcode - fragP->fr_literal; 628 unsigned char *op = (unsigned char *)fragP->fr_opcode; 629 int rl_addend = 0; 630 631 addend = target_address_for (fragP) - (fragP->fr_address + where); 632 633 fragP->fr_fix = where + subtype_mappings[fragP->fr_subtype].bytes; 634 635 switch (subtype_mappings[fragP->fr_subtype].insn) 636 { 637 case M32C_INSN_JCND16_5: 638 op[1] = addend - 1; 639 operand = M32C_OPERAND_LAB_8_8; 640 rl_addend = 0x21; 641 break; 642 643 case -M32C_MACRO_JCND16_5_W: 644 op[0] ^= 0x04; 645 op[1] = 4; 646 op[2] = 0xf4; 647 op[3] = addend - 3; 648 op[4] = (addend - 3) >> 8; 649 operand = M32C_OPERAND_LAB_8_16; 650 where += 2; 651 rl_addend = 0x51; 652 break; 653 654 case -M32C_MACRO_JCND16_5_A: 655 op[0] ^= 0x04; 656 op[1] = 5; 657 op[2] = 0xfc; 658 operand = M32C_OPERAND_LAB_8_24; 659 where += 2; 660 rl_addend = 0x61; 661 break; 662 663 664 case M32C_INSN_JCND16: 665 op[2] = addend - 2; 666 operand = M32C_OPERAND_LAB_16_8; 667 rl_addend = 0x31; 668 break; 669 670 case -M32C_MACRO_JCND16_W: 671 op[1] ^= 0x04; 672 op[2] = 4; 673 op[3] = 0xf4; 674 op[4] = addend - 4; 675 op[5] = (addend - 4) >> 8; 676 operand = M32C_OPERAND_LAB_8_16; 677 where += 3; 678 rl_addend = 0x61; 679 break; 680 681 case -M32C_MACRO_JCND16_A: 682 op[1] ^= 0x04; 683 op[2] = 5; 684 op[3] = 0xfc; 685 operand = M32C_OPERAND_LAB_8_24; 686 where += 3; 687 rl_addend = 0x71; 688 break; 689 690 case M32C_INSN_JMP16_S: 691 op[0] = 0x60 | ((addend-2) & 0x07); 692 operand = M32C_OPERAND_LAB_5_3; 693 rl_addend = 0x10; 694 break; 695 696 case M32C_INSN_JMP16_B: 697 op[0] = 0xfe; 698 op[1] = addend - 1; 699 operand = M32C_OPERAND_LAB_8_8; 700 rl_addend = 0x21; 701 break; 702 703 case M32C_INSN_JMP16_W: 704 op[0] = 0xf4; 705 op[1] = addend - 1; 706 op[2] = (addend - 1) >> 8; 707 operand = M32C_OPERAND_LAB_8_16; 708 rl_addend = 0x31; 709 break; 710 711 case M32C_INSN_JMP16_A: 712 op[0] = 0xfc; 713 op[1] = 0; 714 op[2] = 0; 715 op[3] = 0; 716 operand = M32C_OPERAND_LAB_8_24; 717 rl_addend = 0x41; 718 break; 719 720 case M32C_INSN_JCND32: 721 op[1] = addend - 1; 722 operand = M32C_OPERAND_LAB_8_8; 723 rl_addend = 0x21; 724 break; 725 726 case -M32C_MACRO_JCND32_W: 727 op[0] ^= 0x40; 728 op[1] = 4; 729 op[2] = 0xce; 730 op[3] = addend - 3; 731 op[4] = (addend - 3) >> 8; 732 operand = M32C_OPERAND_LAB_8_16; 733 where += 2; 734 rl_addend = 0x51; 735 break; 736 737 case -M32C_MACRO_JCND32_A: 738 op[0] ^= 0x40; 739 op[1] = 5; 740 op[2] = 0xcc; 741 operand = M32C_OPERAND_LAB_8_24; 742 where += 2; 743 rl_addend = 0x61; 744 break; 745 746 case M32C_INSN_JMP32_S: 747 addend = ((addend-2) & 0x07); 748 op[0] = 0x4a | (addend & 0x01) | ((addend << 3) & 0x30); 749 operand = M32C_OPERAND_LAB32_JMP_S; 750 rl_addend = 0x10; 751 break; 752 753 case M32C_INSN_JMP32_B: 754 op[0] = 0xbb; 755 op[1] = addend - 1; 756 operand = M32C_OPERAND_LAB_8_8; 757 rl_addend = 0x21; 758 break; 759 760 case M32C_INSN_JMP32_W: 761 op[0] = 0xce; 762 op[1] = addend - 1; 763 op[2] = (addend - 1) >> 8; 764 operand = M32C_OPERAND_LAB_8_16; 765 rl_addend = 0x31; 766 break; 767 768 case M32C_INSN_JMP32_A: 769 op[0] = 0xcc; 770 op[1] = 0; 771 op[2] = 0; 772 op[3] = 0; 773 operand = M32C_OPERAND_LAB_8_24; 774 rl_addend = 0x41; 775 break; 776 777 778 case M32C_INSN_JSR16_W: 779 op[0] = 0xf5; 780 op[1] = addend - 1; 781 op[2] = (addend - 1) >> 8; 782 operand = M32C_OPERAND_LAB_8_16; 783 rl_addend = 0x31; 784 break; 785 786 case M32C_INSN_JSR16_A: 787 op[0] = 0xfd; 788 op[1] = 0; 789 op[2] = 0; 790 op[3] = 0; 791 operand = M32C_OPERAND_LAB_8_24; 792 rl_addend = 0x41; 793 break; 794 795 case M32C_INSN_JSR32_W: 796 op[0] = 0xcf; 797 op[1] = addend - 1; 798 op[2] = (addend - 1) >> 8; 799 operand = M32C_OPERAND_LAB_8_16; 800 rl_addend = 0x31; 801 break; 802 803 case M32C_INSN_JSR32_A: 804 op[0] = 0xcd; 805 op[1] = 0; 806 op[2] = 0; 807 op[3] = 0; 808 operand = M32C_OPERAND_LAB_8_24; 809 rl_addend = 0x41; 810 break; 811 812 case -M32C_MACRO_ADJNZ_2: 813 rl_addend = 0x31; 814 op[2] = addend - 2; 815 operand = M32C_OPERAND_LAB_16_8; 816 break; 817 case -M32C_MACRO_ADJNZ_3: 818 rl_addend = 0x41; 819 op[3] = addend - 2; 820 operand = M32C_OPERAND_LAB_24_8; 821 break; 822 case -M32C_MACRO_ADJNZ_4: 823 rl_addend = 0x51; 824 op[4] = addend - 2; 825 operand = M32C_OPERAND_LAB_32_8; 826 break; 827 case -M32C_MACRO_ADJNZ_5: 828 rl_addend = 0x61; 829 op[5] = addend - 2; 830 operand = M32C_OPERAND_LAB_40_8; 831 break; 832 833 default: 834 printf("\nHey! Need more opcode converters! missing: %d %s\n\n", 835 fragP->fr_subtype, 836 fragP->fr_cgen.insn->base->name); 837 abort(); 838 } 839 840 if (m32c_relax) 841 { 842 if (operand != M32C_OPERAND_LAB_8_24) 843 fragP->fr_offset = (fragP->fr_address + where); 844 845 fix_new (fragP, 846 rl_where, 847 0, abs_section_sym, rl_addend, 0, 848 BFD_RELOC_M32C_RL_JUMP); 849 } 850 851 if (S_GET_SEGMENT (fragP->fr_symbol) != sec 852 || operand == M32C_OPERAND_LAB_8_24 853 || (m32c_relax && (operand != M32C_OPERAND_LAB_5_3 854 && operand != M32C_OPERAND_LAB32_JMP_S))) 855 { 856 gas_assert (fragP->fr_cgen.insn != 0); 857 gas_cgen_record_fixup (fragP, 858 where, 859 fragP->fr_cgen.insn, 860 (fragP->fr_fix - where) * 8, 861 cgen_operand_lookup_by_num (gas_cgen_cpu_desc, 862 operand), 863 fragP->fr_cgen.opinfo, 864 fragP->fr_symbol, 865 fragP->fr_offset); 866 } 867 } 868 869 /* Functions concerning relocs. */ 870 871 /* The location from which a PC relative jump should be calculated, 872 given a PC relative reloc. */ 873 874 long 875 md_pcrel_from_section (fixS * fixP, segT sec) 876 { 877 if (fixP->fx_addsy != (symbolS *) NULL 878 && (! S_IS_DEFINED (fixP->fx_addsy) 879 || S_GET_SEGMENT (fixP->fx_addsy) != sec)) 880 /* The symbol is undefined (or is defined but not in this section). 881 Let the linker figure it out. */ 882 return 0; 883 884 return (fixP->fx_frag->fr_address + fixP->fx_where); 885 } 886 887 /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP. 888 Returns BFD_RELOC_NONE if no reloc type can be found. 889 *FIXP may be modified if desired. */ 890 891 bfd_reloc_code_real_type 892 md_cgen_lookup_reloc (const CGEN_INSN * insn ATTRIBUTE_UNUSED, 893 const CGEN_OPERAND * operand, 894 fixS * fixP ATTRIBUTE_UNUSED) 895 { 896 static const struct op_reloc { 897 /* A CGEN operand type that can be a relocatable expression. */ 898 CGEN_OPERAND_TYPE operand; 899 900 /* The appropriate BFD reloc type to use for that. */ 901 bfd_reloc_code_real_type reloc; 902 903 /* The offset from the start of the instruction to the field to be 904 relocated, in bytes. */ 905 int offset; 906 } op_reloc_table[] = { 907 908 /* PC-REL relocs for 8-bit fields. */ 909 { M32C_OPERAND_LAB_8_8, BFD_RELOC_8_PCREL, 1 }, 910 { M32C_OPERAND_LAB_16_8, BFD_RELOC_8_PCREL, 2 }, 911 { M32C_OPERAND_LAB_24_8, BFD_RELOC_8_PCREL, 3 }, 912 { M32C_OPERAND_LAB_32_8, BFD_RELOC_8_PCREL, 4 }, 913 { M32C_OPERAND_LAB_40_8, BFD_RELOC_8_PCREL, 5 }, 914 915 /* PC-REL relocs for 16-bit fields. */ 916 { M32C_OPERAND_LAB_8_16, BFD_RELOC_16_PCREL, 1 }, 917 918 /* Absolute relocs for 8-bit fields. */ 919 { M32C_OPERAND_IMM_8_QI, BFD_RELOC_8, 1 }, 920 { M32C_OPERAND_IMM_16_QI, BFD_RELOC_8, 2 }, 921 { M32C_OPERAND_IMM_24_QI, BFD_RELOC_8, 3 }, 922 { M32C_OPERAND_IMM_32_QI, BFD_RELOC_8, 4 }, 923 { M32C_OPERAND_IMM_40_QI, BFD_RELOC_8, 5 }, 924 { M32C_OPERAND_IMM_48_QI, BFD_RELOC_8, 6 }, 925 { M32C_OPERAND_IMM_56_QI, BFD_RELOC_8, 7 }, 926 { M32C_OPERAND_DSP_8_S8, BFD_RELOC_8, 1 }, 927 { M32C_OPERAND_DSP_16_S8, BFD_RELOC_8, 2 }, 928 { M32C_OPERAND_DSP_24_S8, BFD_RELOC_8, 3 }, 929 { M32C_OPERAND_DSP_32_S8, BFD_RELOC_8, 4 }, 930 { M32C_OPERAND_DSP_40_S8, BFD_RELOC_8, 5 }, 931 { M32C_OPERAND_DSP_48_S8, BFD_RELOC_8, 6 }, 932 { M32C_OPERAND_DSP_8_U8, BFD_RELOC_8, 1 }, 933 { M32C_OPERAND_DSP_16_U8, BFD_RELOC_8, 2 }, 934 { M32C_OPERAND_DSP_24_U8, BFD_RELOC_8, 3 }, 935 { M32C_OPERAND_DSP_32_U8, BFD_RELOC_8, 4 }, 936 { M32C_OPERAND_DSP_40_U8, BFD_RELOC_8, 5 }, 937 { M32C_OPERAND_DSP_48_U8, BFD_RELOC_8, 6 }, 938 { M32C_OPERAND_BITBASE32_16_S11_UNPREFIXED, BFD_RELOC_8, 2 }, 939 { M32C_OPERAND_BITBASE32_16_U11_UNPREFIXED, BFD_RELOC_8, 2 }, 940 { M32C_OPERAND_BITBASE32_24_S11_PREFIXED, BFD_RELOC_8, 3 }, 941 { M32C_OPERAND_BITBASE32_24_U11_PREFIXED, BFD_RELOC_8, 3 }, 942 943 /* Absolute relocs for 16-bit fields. */ 944 { M32C_OPERAND_IMM_8_HI, BFD_RELOC_16, 1 }, 945 { M32C_OPERAND_IMM_16_HI, BFD_RELOC_16, 2 }, 946 { M32C_OPERAND_IMM_24_HI, BFD_RELOC_16, 3 }, 947 { M32C_OPERAND_IMM_32_HI, BFD_RELOC_16, 4 }, 948 { M32C_OPERAND_IMM_40_HI, BFD_RELOC_16, 5 }, 949 { M32C_OPERAND_IMM_48_HI, BFD_RELOC_16, 6 }, 950 { M32C_OPERAND_IMM_56_HI, BFD_RELOC_16, 7 }, 951 { M32C_OPERAND_IMM_64_HI, BFD_RELOC_16, 8 }, 952 { M32C_OPERAND_DSP_16_S16, BFD_RELOC_16, 2 }, 953 { M32C_OPERAND_DSP_24_S16, BFD_RELOC_16, 3 }, 954 { M32C_OPERAND_DSP_32_S16, BFD_RELOC_16, 4 }, 955 { M32C_OPERAND_DSP_40_S16, BFD_RELOC_16, 5 }, 956 { M32C_OPERAND_DSP_8_U16, BFD_RELOC_16, 1 }, 957 { M32C_OPERAND_DSP_16_U16, BFD_RELOC_16, 2 }, 958 { M32C_OPERAND_DSP_24_U16, BFD_RELOC_16, 3 }, 959 { M32C_OPERAND_DSP_32_U16, BFD_RELOC_16, 4 }, 960 { M32C_OPERAND_DSP_40_U16, BFD_RELOC_16, 5 }, 961 { M32C_OPERAND_DSP_48_U16, BFD_RELOC_16, 6 }, 962 { M32C_OPERAND_BITBASE32_16_S19_UNPREFIXED, BFD_RELOC_16, 2 }, 963 { M32C_OPERAND_BITBASE32_16_U19_UNPREFIXED, BFD_RELOC_16, 2 }, 964 { M32C_OPERAND_BITBASE32_24_S19_PREFIXED, BFD_RELOC_16, 3 }, 965 { M32C_OPERAND_BITBASE32_24_U19_PREFIXED, BFD_RELOC_16, 3 }, 966 967 /* Absolute relocs for 24-bit fields. */ 968 { M32C_OPERAND_LAB_8_24, BFD_RELOC_24, 1 }, 969 { M32C_OPERAND_DSP_8_S24, BFD_RELOC_24, 1 }, 970 { M32C_OPERAND_DSP_8_U24, BFD_RELOC_24, 1 }, 971 { M32C_OPERAND_DSP_16_U24, BFD_RELOC_24, 2 }, 972 { M32C_OPERAND_DSP_24_U24, BFD_RELOC_24, 3 }, 973 { M32C_OPERAND_DSP_32_U24, BFD_RELOC_24, 4 }, 974 { M32C_OPERAND_DSP_40_U24, BFD_RELOC_24, 5 }, 975 { M32C_OPERAND_DSP_48_U24, BFD_RELOC_24, 6 }, 976 { M32C_OPERAND_DSP_16_U20, BFD_RELOC_24, 2 }, 977 { M32C_OPERAND_DSP_24_U20, BFD_RELOC_24, 3 }, 978 { M32C_OPERAND_DSP_32_U20, BFD_RELOC_24, 4 }, 979 { M32C_OPERAND_BITBASE32_16_U27_UNPREFIXED, BFD_RELOC_24, 2 }, 980 { M32C_OPERAND_BITBASE32_24_U27_PREFIXED, BFD_RELOC_24, 3 }, 981 982 /* Absolute relocs for 32-bit fields. */ 983 { M32C_OPERAND_IMM_16_SI, BFD_RELOC_32, 2 }, 984 { M32C_OPERAND_IMM_24_SI, BFD_RELOC_32, 3 }, 985 { M32C_OPERAND_IMM_32_SI, BFD_RELOC_32, 4 }, 986 { M32C_OPERAND_IMM_40_SI, BFD_RELOC_32, 5 }, 987 988 }; 989 990 int i; 991 992 for (i = ARRAY_SIZE (op_reloc_table); --i >= 0; ) 993 { 994 const struct op_reloc *or = &op_reloc_table[i]; 995 996 if (or->operand == operand->type) 997 { 998 fixP->fx_where += or->offset; 999 fixP->fx_size -= or->offset; 1000 1001 if (fixP->fx_cgen.opinfo 1002 && fixP->fx_cgen.opinfo != BFD_RELOC_NONE) 1003 return fixP->fx_cgen.opinfo; 1004 1005 return or->reloc; 1006 } 1007 } 1008 1009 fprintf 1010 (stderr, 1011 "Error: tc-m32c.c:md_cgen_lookup_reloc Unimplemented relocation for operand %s\n", 1012 operand->name); 1013 1014 return BFD_RELOC_NONE; 1015 } 1016 1017 void 1018 m32c_cons_fix_new (fragS * frag, 1019 int where, 1020 int size, 1021 expressionS *exp, 1022 bfd_reloc_code_real_type type) 1023 { 1024 switch (size) 1025 { 1026 case 1: 1027 type = BFD_RELOC_8; 1028 break; 1029 case 2: 1030 type = BFD_RELOC_16; 1031 break; 1032 case 3: 1033 type = BFD_RELOC_24; 1034 break; 1035 case 4: 1036 default: 1037 type = BFD_RELOC_32; 1038 break; 1039 case 8: 1040 type = BFD_RELOC_64; 1041 break; 1042 } 1043 1044 fix_new_exp (frag, where, (int) size, exp, 0, type); 1045 } 1046 1047 void 1048 m32c_apply_fix (struct fix *f, valueT *t, segT s) 1049 { 1050 if (f->fx_r_type == BFD_RELOC_M32C_RL_JUMP 1051 || f->fx_r_type == BFD_RELOC_M32C_RL_1ADDR 1052 || f->fx_r_type == BFD_RELOC_M32C_RL_2ADDR) 1053 return; 1054 gas_cgen_md_apply_fix (f, t, s); 1055 } 1056 1057 arelent * 1058 tc_gen_reloc (asection *sec, fixS *fx) 1059 { 1060 if (fx->fx_r_type == BFD_RELOC_M32C_RL_JUMP 1061 || fx->fx_r_type == BFD_RELOC_M32C_RL_1ADDR 1062 || fx->fx_r_type == BFD_RELOC_M32C_RL_2ADDR) 1063 { 1064 arelent * reloc; 1065 1066 reloc = XNEW (arelent); 1067 1068 reloc->sym_ptr_ptr = XNEW (asymbol *); 1069 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fx->fx_addsy); 1070 reloc->address = fx->fx_frag->fr_address + fx->fx_where; 1071 reloc->howto = bfd_reloc_type_lookup (stdoutput, fx->fx_r_type); 1072 reloc->addend = fx->fx_offset; 1073 return reloc; 1074 1075 } 1076 return gas_cgen_tc_gen_reloc (sec, fx); 1077 } 1078 1079 /* See whether we need to force a relocation into the output file. 1080 This is used to force out switch and PC relative relocations when 1081 relaxing. */ 1082 1083 int 1084 m32c_force_relocation (fixS * fixp) 1085 { 1086 int reloc = fixp->fx_r_type; 1087 1088 if (reloc > (int)BFD_RELOC_UNUSED) 1089 { 1090 reloc -= (int)BFD_RELOC_UNUSED; 1091 switch (reloc) 1092 { 1093 case M32C_OPERAND_DSP_32_S16: 1094 case M32C_OPERAND_DSP_32_U16: 1095 case M32C_OPERAND_IMM_32_HI: 1096 case M32C_OPERAND_DSP_16_S16: 1097 case M32C_OPERAND_DSP_16_U16: 1098 case M32C_OPERAND_IMM_16_HI: 1099 case M32C_OPERAND_DSP_24_S16: 1100 case M32C_OPERAND_DSP_24_U16: 1101 case M32C_OPERAND_IMM_24_HI: 1102 return 1; 1103 1104 /* If we're doing linker relaxing, we need to keep all the 1105 pc-relative jumps in case we need to fix them due to 1106 deleted bytes between the jump and its destination. */ 1107 case M32C_OPERAND_LAB_8_8: 1108 case M32C_OPERAND_LAB_8_16: 1109 case M32C_OPERAND_LAB_8_24: 1110 case M32C_OPERAND_LAB_16_8: 1111 case M32C_OPERAND_LAB_24_8: 1112 case M32C_OPERAND_LAB_32_8: 1113 case M32C_OPERAND_LAB_40_8: 1114 if (m32c_relax) 1115 return 1; 1116 default: 1117 break; 1118 } 1119 } 1120 else 1121 { 1122 switch (fixp->fx_r_type) 1123 { 1124 case BFD_RELOC_16: 1125 return 1; 1126 1127 case BFD_RELOC_M32C_RL_JUMP: 1128 case BFD_RELOC_M32C_RL_1ADDR: 1129 case BFD_RELOC_M32C_RL_2ADDR: 1130 case BFD_RELOC_8_PCREL: 1131 case BFD_RELOC_16_PCREL: 1132 if (m32c_relax) 1133 return 1; 1134 default: 1135 break; 1136 } 1137 } 1138 1139 return generic_force_reloc (fixp); 1140 } 1141 1142 /* Write a value out to the object file, using the appropriate endianness. */ 1143 1144 void 1145 md_number_to_chars (char * buf, valueT val, int n) 1146 { 1147 number_to_chars_littleendian (buf, val, n); 1148 } 1149 1150 /* Turn a string in input_line_pointer into a floating point constant of type 1151 type, and store the appropriate bytes in *litP. The number of LITTLENUMS 1152 emitted is stored in *sizeP . An error message is returned, or NULL on OK. */ 1153 1154 /* Equal to MAX_PRECISION in atof-ieee.c. */ 1155 #define MAX_LITTLENUMS 6 1156 1157 const char * 1158 md_atof (int type, char * litP, int * sizeP) 1159 { 1160 return ieee_md_atof (type, litP, sizeP, TRUE); 1161 } 1162 1163 bfd_boolean 1164 m32c_fix_adjustable (fixS * fixP) 1165 { 1166 int reloc; 1167 if (fixP->fx_addsy == NULL) 1168 return 1; 1169 1170 /* We need the symbol name for the VTABLE entries. */ 1171 reloc = fixP->fx_r_type; 1172 if (reloc > (int)BFD_RELOC_UNUSED) 1173 { 1174 reloc -= (int)BFD_RELOC_UNUSED; 1175 switch (reloc) 1176 { 1177 case M32C_OPERAND_DSP_32_S16: 1178 case M32C_OPERAND_DSP_32_U16: 1179 case M32C_OPERAND_IMM_32_HI: 1180 case M32C_OPERAND_DSP_16_S16: 1181 case M32C_OPERAND_DSP_16_U16: 1182 case M32C_OPERAND_IMM_16_HI: 1183 case M32C_OPERAND_DSP_24_S16: 1184 case M32C_OPERAND_DSP_24_U16: 1185 case M32C_OPERAND_IMM_24_HI: 1186 return 0; 1187 } 1188 } 1189 else 1190 { 1191 if (fixP->fx_r_type == BFD_RELOC_16) 1192 return 0; 1193 } 1194 1195 /* Do not adjust relocations involving symbols in merged sections. 1196 1197 A reloc patching in the value of some symbol S plus some addend A 1198 can be produced in different ways: 1199 1200 1) It might simply be a reference to the data at S + A. Clearly, 1201 if linker merging shift that data around, the value patched in 1202 by the reloc needs to be adjusted accordingly. 1203 1204 2) Or, it might be a reference to S, with A added in as a constant 1205 bias. For example, given code like this: 1206 1207 static int S[100]; 1208 1209 ... S[i - 8] ... 1210 1211 it would be reasonable for the compiler to rearrange the array 1212 reference to something like: 1213 1214 ... (S-8)[i] ... 1215 1216 and emit assembly code that refers to S - (8 * sizeof (int)), 1217 so the subtraction is done entirely at compile-time. In this 1218 case, the reloc's addend A would be -(8 * sizeof (int)), and 1219 shifting around code or data at S + A should not affect the 1220 reloc: the reloc isn't referring to that code or data at all. 1221 1222 The linker has no way of knowing which case it has in hand. So, 1223 to disambiguate, we have the linker always treat reloc addends as 1224 in case 2): they're constants that should be simply added to the 1225 symbol value, just like the reloc says. And we express case 1) 1226 in different way: we have the compiler place a label at the real 1227 target, and reference that label with an addend of zero. (The 1228 compiler is unlikely to reference code using a label plus an 1229 offset anyway, since it doesn't know the sizes of the 1230 instructions.) 1231 1232 The simplification being done by gas/write.c:adjust_reloc_syms, 1233 however, turns the explicit-label usage into the label-plus- 1234 offset usage, re-introducing the ambiguity the compiler avoided. 1235 So we need to disable that simplification for symbols referring 1236 to merged data. 1237 1238 This only affects object size a little bit. */ 1239 if (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) 1240 return 0; 1241 1242 if (m32c_relax) 1243 return 0; 1244 1245 return 1; 1246 } 1247 1248 /* Worker function for m32c_is_colon_insn(). */ 1249 static int 1250 restore_colon (char *next_i_l_p, char *nul_char) 1251 { 1252 /* Restore the colon, and advance input_line_pointer to 1253 the end of the new symbol. */ 1254 *input_line_pointer = *nul_char; 1255 input_line_pointer = next_i_l_p; 1256 *nul_char = *next_i_l_p; 1257 *next_i_l_p = 0; 1258 return 1; 1259 } 1260 1261 /* Determines if the symbol starting at START and ending in 1262 a colon that was at the location pointed to by INPUT_LINE_POINTER 1263 (but which has now been replaced bu a NUL) is in fact an 1264 :Z, :S, :Q, or :G suffix. 1265 If it is, then it restores the colon, advances INPUT_LINE_POINTER 1266 to the real end of the instruction/symbol, saves the char there to 1267 NUL_CHAR and pokes a NUL, and returns 1. Otherwise it returns 0. */ 1268 int 1269 m32c_is_colon_insn (char *start ATTRIBUTE_UNUSED, char *nul_char) 1270 { 1271 char * i_l_p = input_line_pointer; 1272 1273 if (*nul_char == '"') 1274 ++i_l_p; 1275 1276 /* Check to see if the text following the colon is 'G' */ 1277 if (TOLOWER (i_l_p[1]) == 'g' && (i_l_p[2] == ' ' || i_l_p[2] == '\t')) 1278 return restore_colon (i_l_p + 2, nul_char); 1279 1280 /* Check to see if the text following the colon is 'Q' */ 1281 if (TOLOWER (i_l_p[1]) == 'q' && (i_l_p[2] == ' ' || i_l_p[2] == '\t')) 1282 return restore_colon (i_l_p + 2, nul_char); 1283 1284 /* Check to see if the text following the colon is 'S' */ 1285 if (TOLOWER (i_l_p[1]) == 's' && (i_l_p[2] == ' ' || i_l_p[2] == '\t')) 1286 return restore_colon (i_l_p + 2, nul_char); 1287 1288 /* Check to see if the text following the colon is 'Z' */ 1289 if (TOLOWER (i_l_p[1]) == 'z' && (i_l_p[2] == ' ' || i_l_p[2] == '\t')) 1290 return restore_colon (i_l_p + 2, nul_char); 1291 1292 return 0; 1293 } 1294