1 /* tc-rl78.c -- Assembler for the Renesas RL78 2 Copyright (C) 2011-2018 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 the Free 18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 19 02110-1301, USA. */ 20 21 #include "as.h" 22 #include "struc-symbol.h" 23 #include "safe-ctype.h" 24 #include "dwarf2dbg.h" 25 #include "elf/common.h" 26 #include "elf/rl78.h" 27 #include "rl78-defs.h" 28 #include "filenames.h" 29 #include "listing.h" 30 #include "sb.h" 31 #include "macro.h" 32 33 const char comment_chars[] = ";"; 34 /* Note that input_file.c hand checks for '#' at the beginning of the 35 first line of the input file. This is because the compiler outputs 36 #NO_APP at the beginning of its output. */ 37 const char line_comment_chars[] = "#"; 38 /* Use something that isn't going to be needed by any expressions or 39 other syntax. */ 40 const char line_separator_chars[] = "@"; 41 42 const char EXP_CHARS[] = "eE"; 43 const char FLT_CHARS[] = "dD"; 44 45 /* ELF flags to set in the output file header. */ 46 static int elf_flags = 0; 47 48 /*------------------------------------------------------------------*/ 49 50 char * rl78_lex_start; 51 char * rl78_lex_end; 52 53 typedef struct rl78_bytesT 54 { 55 char prefix[1]; 56 int n_prefix; 57 char base[4]; 58 int n_base; 59 char ops[8]; 60 int n_ops; 61 struct 62 { 63 expressionS exp; 64 char offset; 65 char nbits; 66 char type; /* RL78REL_*. */ 67 int reloc; 68 fixS * fixP; 69 } fixups[2]; 70 int n_fixups; 71 struct 72 { 73 char type; 74 char field_pos; 75 char val_ofs; 76 } relax[2]; 77 int n_relax; 78 int link_relax; 79 fixS *link_relax_fixP; 80 char times_grown; 81 char times_shrank; 82 } rl78_bytesT; 83 84 static rl78_bytesT rl78_bytes; 85 86 void 87 rl78_relax (int type, int pos) 88 { 89 rl78_bytes.relax[rl78_bytes.n_relax].type = type; 90 rl78_bytes.relax[rl78_bytes.n_relax].field_pos = pos; 91 rl78_bytes.relax[rl78_bytes.n_relax].val_ofs = rl78_bytes.n_base + rl78_bytes.n_ops; 92 rl78_bytes.n_relax ++; 93 } 94 95 void 96 rl78_linkrelax_addr16 (void) 97 { 98 rl78_bytes.link_relax |= RL78_RELAXA_ADDR16; 99 } 100 101 void 102 rl78_linkrelax_branch (void) 103 { 104 rl78_relax (RL78_RELAX_BRANCH, 0); 105 rl78_bytes.link_relax |= RL78_RELAXA_BRA; 106 } 107 108 static void 109 rl78_fixup (expressionS exp, int offsetbits, int nbits, int type) 110 { 111 rl78_bytes.fixups[rl78_bytes.n_fixups].exp = exp; 112 rl78_bytes.fixups[rl78_bytes.n_fixups].offset = offsetbits; 113 rl78_bytes.fixups[rl78_bytes.n_fixups].nbits = nbits; 114 rl78_bytes.fixups[rl78_bytes.n_fixups].type = type; 115 rl78_bytes.fixups[rl78_bytes.n_fixups].reloc = exp.X_md; 116 rl78_bytes.n_fixups ++; 117 } 118 119 #define rl78_field_fixup(exp, offset, nbits, type) \ 120 rl78_fixup (exp, offset + 8 * rl78_bytes.n_prefix), nbits, type) 121 122 #define rl78_op_fixup(exp, offset, nbits, type) \ 123 rl78_fixup (exp, offset + 8 * (rl78_bytes.n_prefix + rl78_bytes.n_base), nbits, type) 124 125 void 126 rl78_prefix (int p) 127 { 128 rl78_bytes.prefix[0] = p; 129 rl78_bytes.n_prefix = 1; 130 } 131 132 int 133 rl78_has_prefix (void) 134 { 135 return rl78_bytes.n_prefix; 136 } 137 138 void 139 rl78_base1 (int b1) 140 { 141 rl78_bytes.base[0] = b1; 142 rl78_bytes.n_base = 1; 143 } 144 145 void 146 rl78_base2 (int b1, int b2) 147 { 148 rl78_bytes.base[0] = b1; 149 rl78_bytes.base[1] = b2; 150 rl78_bytes.n_base = 2; 151 } 152 153 void 154 rl78_base3 (int b1, int b2, int b3) 155 { 156 rl78_bytes.base[0] = b1; 157 rl78_bytes.base[1] = b2; 158 rl78_bytes.base[2] = b3; 159 rl78_bytes.n_base = 3; 160 } 161 162 void 163 rl78_base4 (int b1, int b2, int b3, int b4) 164 { 165 rl78_bytes.base[0] = b1; 166 rl78_bytes.base[1] = b2; 167 rl78_bytes.base[2] = b3; 168 rl78_bytes.base[3] = b4; 169 rl78_bytes.n_base = 4; 170 } 171 172 #define F_PRECISION 2 173 174 void 175 rl78_op (expressionS exp, int nbytes, int type) 176 { 177 int v = 0; 178 179 if ((exp.X_op == O_constant || exp.X_op == O_big) 180 && type != RL78REL_PCREL) 181 { 182 if (exp.X_op == O_big && exp.X_add_number <= 0) 183 { 184 LITTLENUM_TYPE w[2]; 185 char * ip = rl78_bytes.ops + rl78_bytes.n_ops; 186 187 gen_to_words (w, F_PRECISION, 8); 188 ip[3] = w[0] >> 8; 189 ip[2] = w[0]; 190 ip[1] = w[1] >> 8; 191 ip[0] = w[1]; 192 rl78_bytes.n_ops += 4; 193 } 194 else 195 { 196 v = exp.X_add_number; 197 while (nbytes) 198 { 199 rl78_bytes.ops[rl78_bytes.n_ops++] =v & 0xff; 200 v >>= 8; 201 nbytes --; 202 } 203 } 204 } 205 else 206 { 207 if (nbytes > 2 208 && exp.X_md == BFD_RELOC_RL78_CODE) 209 exp.X_md = 0; 210 211 if (nbytes == 1 212 && (exp.X_md == BFD_RELOC_RL78_LO16 213 || exp.X_md == BFD_RELOC_RL78_HI16)) 214 as_bad (_("16-bit relocation used in 8-bit operand")); 215 216 if (nbytes == 2 217 && exp.X_md == BFD_RELOC_RL78_HI8) 218 as_bad (_("8-bit relocation used in 16-bit operand")); 219 220 rl78_op_fixup (exp, rl78_bytes.n_ops * 8, nbytes * 8, type); 221 memset (rl78_bytes.ops + rl78_bytes.n_ops, 0, nbytes); 222 rl78_bytes.n_ops += nbytes; 223 } 224 } 225 226 /* This gets complicated when the field spans bytes, because fields 227 are numbered from the MSB of the first byte as zero, and bits are 228 stored LSB towards the LSB of the byte. Thus, a simple four-bit 229 insertion of 12 at position 4 of 0x00 yields: 0x0b. A three-bit 230 insertion of b'MXL at position 7 is like this: 231 232 - - - - - - - - - - - - - - - - 233 M X L */ 234 235 void 236 rl78_field (int val, int pos, int sz) 237 { 238 int valm; 239 int bytep, bitp; 240 241 if (sz > 0) 242 { 243 if (val < 0 || val >= (1 << sz)) 244 as_bad (_("Value %d doesn't fit in unsigned %d-bit field"), val, sz); 245 } 246 else 247 { 248 sz = - sz; 249 if (val < -(1 << (sz - 1)) || val >= (1 << (sz - 1))) 250 as_bad (_("Value %d doesn't fit in signed %d-bit field"), val, sz); 251 } 252 253 /* This code points at 'M' in the above example. */ 254 bytep = pos / 8; 255 bitp = pos % 8; 256 257 while (bitp + sz > 8) 258 { 259 int ssz = 8 - bitp; 260 int svalm; 261 262 svalm = val >> (sz - ssz); 263 svalm = svalm & ((1 << ssz) - 1); 264 svalm = svalm << (8 - bitp - ssz); 265 gas_assert (bytep < rl78_bytes.n_base); 266 rl78_bytes.base[bytep] |= svalm; 267 268 bitp = 0; 269 sz -= ssz; 270 bytep ++; 271 } 272 valm = val & ((1 << sz) - 1); 273 valm = valm << (8 - bitp - sz); 274 gas_assert (bytep < rl78_bytes.n_base); 275 rl78_bytes.base[bytep] |= valm; 276 } 277 278 /*------------------------------------------------------------------*/ 279 280 enum options 281 { 282 OPTION_RELAX = OPTION_MD_BASE, 283 OPTION_NORELAX, 284 OPTION_G10, 285 OPTION_G13, 286 OPTION_G14, 287 OPTION_32BIT_DOUBLES, 288 OPTION_64BIT_DOUBLES, 289 }; 290 291 #define RL78_SHORTOPTS "" 292 const char * md_shortopts = RL78_SHORTOPTS; 293 294 /* Assembler options. */ 295 struct option md_longopts[] = 296 { 297 {"relax", no_argument, NULL, OPTION_RELAX}, 298 {"norelax", no_argument, NULL, OPTION_NORELAX}, 299 {"mg10", no_argument, NULL, OPTION_G10}, 300 {"mg13", no_argument, NULL, OPTION_G13}, 301 {"mg14", no_argument, NULL, OPTION_G14}, 302 {"mrl78", no_argument, NULL, OPTION_G14}, 303 {"m32bit-doubles", no_argument, NULL, OPTION_32BIT_DOUBLES}, 304 {"m64bit-doubles", no_argument, NULL, OPTION_64BIT_DOUBLES}, 305 {NULL, no_argument, NULL, 0} 306 }; 307 size_t md_longopts_size = sizeof (md_longopts); 308 309 int 310 md_parse_option (int c, const char * arg ATTRIBUTE_UNUSED) 311 { 312 switch (c) 313 { 314 case OPTION_RELAX: 315 linkrelax = 1; 316 return 1; 317 case OPTION_NORELAX: 318 linkrelax = 0; 319 return 1; 320 321 case OPTION_G10: 322 elf_flags &= ~ E_FLAG_RL78_CPU_MASK; 323 elf_flags |= E_FLAG_RL78_G10; 324 return 1; 325 326 case OPTION_G13: 327 elf_flags &= ~ E_FLAG_RL78_CPU_MASK; 328 elf_flags |= E_FLAG_RL78_G13; 329 return 1; 330 331 case OPTION_G14: 332 elf_flags &= ~ E_FLAG_RL78_CPU_MASK; 333 elf_flags |= E_FLAG_RL78_G14; 334 return 1; 335 336 case OPTION_32BIT_DOUBLES: 337 elf_flags &= ~ E_FLAG_RL78_64BIT_DOUBLES; 338 return 1; 339 340 case OPTION_64BIT_DOUBLES: 341 elf_flags |= E_FLAG_RL78_64BIT_DOUBLES; 342 return 1; 343 } 344 return 0; 345 } 346 347 int 348 rl78_isa_g10 (void) 349 { 350 return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G10; 351 } 352 353 int 354 rl78_isa_g13 (void) 355 { 356 return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G13; 357 } 358 359 int 360 rl78_isa_g14 (void) 361 { 362 return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G14; 363 } 364 365 void 366 md_show_usage (FILE * stream) 367 { 368 fprintf (stream, _(" RL78 specific command line options:\n")); 369 fprintf (stream, _(" --mrelax Enable link time relaxation\n")); 370 fprintf (stream, _(" --mg10 Enable support for G10 variant\n")); 371 fprintf (stream, _(" --mg13 Selects the G13 core.\n")); 372 fprintf (stream, _(" --mg14 Selects the G14 core [default]\n")); 373 fprintf (stream, _(" --mrl78 Alias for --mg14\n")); 374 fprintf (stream, _(" --m32bit-doubles [default]\n")); 375 fprintf (stream, _(" --m64bit-doubles Source code uses 64-bit doubles\n")); 376 } 377 378 static void 379 s_bss (int ignore ATTRIBUTE_UNUSED) 380 { 381 int temp; 382 383 temp = get_absolute_expression (); 384 subseg_set (bss_section, (subsegT) temp); 385 demand_empty_rest_of_line (); 386 } 387 388 static void 389 rl78_float_cons (int ignore ATTRIBUTE_UNUSED) 390 { 391 if (elf_flags & E_FLAG_RL78_64BIT_DOUBLES) 392 return float_cons ('d'); 393 return float_cons ('f'); 394 } 395 396 /* The target specific pseudo-ops which we support. */ 397 const pseudo_typeS md_pseudo_table[] = 398 { 399 /* Our "standard" pseudos. */ 400 { "double", rl78_float_cons, 'd' }, 401 { "bss", s_bss, 0 }, 402 { "3byte", cons, 3 }, 403 { "int", cons, 4 }, 404 { "word", cons, 4 }, 405 406 /* End of list marker. */ 407 { NULL, NULL, 0 } 408 }; 409 410 static symbolS * rl78_abs_sym = NULL; 411 412 void 413 md_begin (void) 414 { 415 rl78_abs_sym = symbol_make ("__rl78_abs__"); 416 } 417 418 void 419 rl78_md_end (void) 420 { 421 } 422 423 /* Set the ELF specific flags. */ 424 void 425 rl78_elf_final_processing (void) 426 { 427 elf_elfheader (stdoutput)->e_flags |= elf_flags; 428 } 429 430 /* Write a value out to the object file, using the appropriate endianness. */ 431 void 432 md_number_to_chars (char * buf, valueT val, int n) 433 { 434 number_to_chars_littleendian (buf, val, n); 435 } 436 437 static void 438 require_end_of_expr (const char *fname) 439 { 440 while (* input_line_pointer == ' ' 441 || * input_line_pointer == '\t') 442 input_line_pointer ++; 443 444 if (! * input_line_pointer 445 || strchr ("\n\r,", * input_line_pointer) 446 || strchr (comment_chars, * input_line_pointer) 447 || strchr (line_comment_chars, * input_line_pointer) 448 || strchr (line_separator_chars, * input_line_pointer)) 449 return; 450 451 as_bad (_("%%%s() must be outermost term in expression"), fname); 452 } 453 454 static struct 455 { 456 const char * fname; 457 int reloc; 458 } 459 reloc_functions[] = 460 { 461 { "code", BFD_RELOC_RL78_CODE }, 462 { "lo16", BFD_RELOC_RL78_LO16 }, 463 { "hi16", BFD_RELOC_RL78_HI16 }, 464 { "hi8", BFD_RELOC_RL78_HI8 }, 465 { 0, 0 } 466 }; 467 468 void 469 md_operand (expressionS * exp ATTRIBUTE_UNUSED) 470 { 471 int reloc = 0; 472 int i; 473 474 for (i = 0; reloc_functions[i].fname; i++) 475 { 476 int flen = strlen (reloc_functions[i].fname); 477 478 if (input_line_pointer[0] == '%' 479 && strncasecmp (input_line_pointer + 1, reloc_functions[i].fname, flen) == 0 480 && input_line_pointer[flen + 1] == '(') 481 { 482 reloc = reloc_functions[i].reloc; 483 input_line_pointer += flen + 2; 484 break; 485 } 486 } 487 if (reloc == 0) 488 return; 489 490 expression (exp); 491 if (* input_line_pointer == ')') 492 input_line_pointer ++; 493 494 exp->X_md = reloc; 495 496 require_end_of_expr (reloc_functions[i].fname); 497 } 498 499 void 500 rl78_frag_init (fragS * fragP) 501 { 502 if (rl78_bytes.n_relax || rl78_bytes.link_relax) 503 { 504 fragP->tc_frag_data = XNEW (rl78_bytesT); 505 memcpy (fragP->tc_frag_data, & rl78_bytes, sizeof (rl78_bytesT)); 506 } 507 else 508 fragP->tc_frag_data = 0; 509 } 510 511 /* When relaxing, we need to output a reloc for any .align directive 512 so that we can retain this alignment as we adjust opcode sizes. */ 513 void 514 rl78_handle_align (fragS * frag) 515 { 516 if (linkrelax 517 && (frag->fr_type == rs_align 518 || frag->fr_type == rs_align_code) 519 && frag->fr_address + frag->fr_fix > 0 520 && frag->fr_offset > 0 521 && now_seg != bss_section) 522 { 523 fix_new (frag, frag->fr_fix, 0, 524 &abs_symbol, RL78_RELAXA_ALIGN + frag->fr_offset, 525 0, BFD_RELOC_RL78_RELAX); 526 /* For the purposes of relaxation, this relocation is attached 527 to the byte *after* the alignment - i.e. the byte that must 528 remain aligned. */ 529 fix_new (frag->fr_next, 0, 0, 530 &abs_symbol, RL78_RELAXA_ELIGN + frag->fr_offset, 531 0, BFD_RELOC_RL78_RELAX); 532 } 533 } 534 535 const char * 536 md_atof (int type, char * litP, int * sizeP) 537 { 538 return ieee_md_atof (type, litP, sizeP, target_big_endian); 539 } 540 541 symbolS * 542 md_undefined_symbol (char * name ATTRIBUTE_UNUSED) 543 { 544 return NULL; 545 } 546 547 #define APPEND(B, N_B) \ 548 if (rl78_bytes.N_B) \ 549 { \ 550 memcpy (bytes + idx, rl78_bytes.B, rl78_bytes.N_B); \ 551 idx += rl78_bytes.N_B; \ 552 } 553 554 555 void 556 md_assemble (char * str) 557 { 558 char * bytes; 559 fragS * frag_then = frag_now; 560 int idx = 0; 561 int i; 562 int rel; 563 expressionS *exp; 564 565 /*printf("\033[32mASM: %s\033[0m\n", str);*/ 566 567 dwarf2_emit_insn (0); 568 569 memset (& rl78_bytes, 0, sizeof (rl78_bytes)); 570 571 rl78_lex_init (str, str + strlen (str)); 572 573 rl78_parse (); 574 575 /* This simplifies the relaxation code. */ 576 if (rl78_bytes.n_relax || rl78_bytes.link_relax) 577 { 578 int olen = rl78_bytes.n_prefix + rl78_bytes.n_base + rl78_bytes.n_ops; 579 /* We do it this way because we want the frag to have the 580 rl78_bytes in it, which we initialize above. The extra bytes 581 are for relaxing. */ 582 bytes = frag_more (olen + 3); 583 frag_then = frag_now; 584 frag_variant (rs_machine_dependent, 585 olen /* max_chars */, 586 0 /* var */, 587 olen /* subtype */, 588 0 /* symbol */, 589 0 /* offset */, 590 0 /* opcode */); 591 frag_then->fr_opcode = bytes; 592 frag_then->fr_fix = olen + (bytes - frag_then->fr_literal); 593 frag_then->fr_subtype = olen; 594 frag_then->fr_var = 0; 595 } 596 else 597 { 598 bytes = frag_more (rl78_bytes.n_prefix + rl78_bytes.n_base + rl78_bytes.n_ops); 599 frag_then = frag_now; 600 } 601 602 APPEND (prefix, n_prefix); 603 APPEND (base, n_base); 604 APPEND (ops, n_ops); 605 606 if (rl78_bytes.link_relax) 607 { 608 fixS * f; 609 610 f = fix_new (frag_then, 611 (char *) bytes - frag_then->fr_literal, 612 0, 613 abs_section_sym, 614 rl78_bytes.link_relax | rl78_bytes.n_fixups, 615 0, 616 BFD_RELOC_RL78_RELAX); 617 frag_then->tc_frag_data->link_relax_fixP = f; 618 } 619 620 for (i = 0; i < rl78_bytes.n_fixups; i ++) 621 { 622 /* index: [nbytes][type] */ 623 static int reloc_map[5][4] = 624 { 625 { 0, 0 }, 626 { BFD_RELOC_8, BFD_RELOC_8_PCREL }, 627 { BFD_RELOC_16, BFD_RELOC_16_PCREL }, 628 { BFD_RELOC_24, BFD_RELOC_24_PCREL }, 629 { BFD_RELOC_32, BFD_RELOC_32_PCREL }, 630 }; 631 fixS * f; 632 633 idx = rl78_bytes.fixups[i].offset / 8; 634 rel = reloc_map [rl78_bytes.fixups[i].nbits / 8][(int) rl78_bytes.fixups[i].type]; 635 636 if (rl78_bytes.fixups[i].reloc) 637 rel = rl78_bytes.fixups[i].reloc; 638 639 if (frag_then->tc_frag_data) 640 exp = & frag_then->tc_frag_data->fixups[i].exp; 641 else 642 exp = & rl78_bytes.fixups[i].exp; 643 644 f = fix_new_exp (frag_then, 645 (char *) bytes + idx - frag_then->fr_literal, 646 rl78_bytes.fixups[i].nbits / 8, 647 exp, 648 rl78_bytes.fixups[i].type == RL78REL_PCREL ? 1 : 0, 649 rel); 650 if (frag_then->tc_frag_data) 651 frag_then->tc_frag_data->fixups[i].fixP = f; 652 } 653 } 654 655 void 656 rl78_cons_fix_new (fragS * frag, 657 int where, 658 int size, 659 expressionS * exp) 660 { 661 bfd_reloc_code_real_type type; 662 fixS *fixP; 663 664 switch (size) 665 { 666 case 1: 667 type = BFD_RELOC_8; 668 break; 669 case 2: 670 type = BFD_RELOC_16; 671 break; 672 case 3: 673 type = BFD_RELOC_24; 674 break; 675 case 4: 676 type = BFD_RELOC_32; 677 break; 678 default: 679 as_bad (_("unsupported constant size %d\n"), size); 680 return; 681 } 682 683 switch (exp->X_md) 684 { 685 case BFD_RELOC_RL78_CODE: 686 if (size == 2) 687 type = exp->X_md; 688 break; 689 case BFD_RELOC_RL78_LO16: 690 case BFD_RELOC_RL78_HI16: 691 if (size != 2) 692 { 693 /* Fixups to assembler generated expressions do not use %hi or %lo. */ 694 if (frag->fr_file) 695 as_bad (_("%%hi16/%%lo16 only applies to .short or .hword")); 696 } 697 else 698 type = exp->X_md; 699 break; 700 case BFD_RELOC_RL78_HI8: 701 if (size != 1) 702 { 703 /* Fixups to assembler generated expressions do not use %hi or %lo. */ 704 if (frag->fr_file) 705 as_bad (_("%%hi8 only applies to .byte")); 706 } 707 else 708 type = exp->X_md; 709 break; 710 default: 711 break; 712 } 713 714 if (exp->X_op == O_subtract && exp->X_op_symbol) 715 { 716 if (size != 4 && size != 2 && size != 1) 717 as_bad (_("difference of two symbols only supported with .long, .short, or .byte")); 718 else 719 type = BFD_RELOC_RL78_DIFF; 720 } 721 722 fixP = fix_new_exp (frag, where, (int) size, exp, 0, type); 723 switch (exp->X_md) 724 { 725 /* These are intended to have values larger than the container, 726 since the backend puts only the portion we need in it. 727 However, we don't have a backend-specific reloc for them as 728 they're handled with complex relocations. */ 729 case BFD_RELOC_RL78_LO16: 730 case BFD_RELOC_RL78_HI16: 731 case BFD_RELOC_RL78_HI8: 732 fixP->fx_no_overflow = 1; 733 break; 734 default: 735 break; 736 } 737 } 738 739 740 /*----------------------------------------------------------------------*/ 741 /* To recap: we estimate everything based on md_estimate_size, then 742 adjust based on rl78_relax_frag. When it all settles, we call 743 md_convert frag to update the bytes. The relaxation types and 744 relocations are in fragP->tc_frag_data, which is a copy of that 745 rl78_bytes. 746 747 Our scheme is as follows: fr_fix has the size of the smallest 748 opcode (like BRA.S). We store the number of total bytes we need in 749 fr_subtype. When we're done relaxing, we use fr_subtype and the 750 existing opcode bytes to figure out what actual opcode we need to 751 put in there. If the fixup isn't resolvable now, we use the 752 maximal size. */ 753 754 #define TRACE_RELAX 0 755 #define tprintf if (TRACE_RELAX) printf 756 757 758 typedef enum 759 { 760 OT_other, 761 OT_bt, 762 OT_bt_sfr, 763 OT_bt_es, 764 OT_bc, 765 OT_bh, 766 OT_sk, 767 OT_call, 768 OT_br, 769 } op_type_T; 770 771 /* We're looking for these types of relaxations: 772 773 BT 00110001 sbit0cc1 addr---- (cc is 10 (BF) or 01 (BT)) 774 B~T 00110001 sbit0cc1 00000011 11101110 pcrel16- -------- (BR $!pcrel20) 775 776 BT sfr 00110001 sbit0cc0 sfr----- addr---- 777 BT ES: 00010001 00101110 sbit0cc1 addr---- 778 779 BC 110111cc addr---- 780 B~C 110111cc 00000011 11101110 pcrel16- -------- (BR $!pcrel20) 781 782 BH 01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20) 783 B~H 01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20) 784 */ 785 786 /* Given the opcode bytes at OP, figure out which opcode it is and 787 return the type of opcode. We use this to re-encode the opcode as 788 a different size later. */ 789 790 static op_type_T 791 rl78_opcode_type (char * ops) 792 { 793 unsigned char *op = (unsigned char *)ops; 794 795 if (op[0] == 0x31 796 && ((op[1] & 0x0f) == 0x05 797 || (op[1] & 0x0f) == 0x03)) 798 return OT_bt; 799 800 if (op[0] == 0x31 801 && ((op[1] & 0x0f) == 0x04 802 || (op[1] & 0x0f) == 0x02)) 803 return OT_bt_sfr; 804 805 if (op[0] == 0x11 806 && op[1] == 0x31 807 && ((op[2] & 0x0f) == 0x05 808 || (op[2] & 0x0f) == 0x03)) 809 return OT_bt_es; 810 811 if ((op[0] & 0xfc) == 0xdc) 812 return OT_bc; 813 814 if (op[0] == 0x61 815 && (op[1] & 0xef) == 0xc3) 816 return OT_bh; 817 818 if (op[0] == 0x61 819 && (op[1] & 0xcf) == 0xc8) 820 return OT_sk; 821 822 if (op[0] == 0x61 823 && (op[1] & 0xef) == 0xe3) 824 return OT_sk; 825 826 if (op[0] == 0xfc) 827 return OT_call; 828 829 if ((op[0] & 0xec) == 0xec) 830 return OT_br; 831 832 return OT_other; 833 } 834 835 /* Returns zero if *addrP has the target address. Else returns nonzero 836 if we cannot compute the target address yet. */ 837 838 static int 839 rl78_frag_fix_value (fragS * fragP, 840 segT segment, 841 int which, 842 addressT * addrP, 843 int need_diff, 844 addressT * sym_addr) 845 { 846 addressT addr = 0; 847 rl78_bytesT * b = fragP->tc_frag_data; 848 expressionS * exp = & b->fixups[which].exp; 849 850 if (need_diff && exp->X_op != O_subtract) 851 return 1; 852 853 if (exp->X_add_symbol) 854 { 855 if (S_FORCE_RELOC (exp->X_add_symbol, 1)) 856 return 1; 857 if (S_GET_SEGMENT (exp->X_add_symbol) != segment) 858 return 1; 859 addr += S_GET_VALUE (exp->X_add_symbol); 860 } 861 862 if (exp->X_op_symbol) 863 { 864 if (exp->X_op != O_subtract) 865 return 1; 866 if (S_FORCE_RELOC (exp->X_op_symbol, 1)) 867 return 1; 868 if (S_GET_SEGMENT (exp->X_op_symbol) != segment) 869 return 1; 870 addr -= S_GET_VALUE (exp->X_op_symbol); 871 } 872 if (sym_addr) 873 * sym_addr = addr; 874 addr += exp->X_add_number; 875 * addrP = addr; 876 return 0; 877 } 878 879 /* Estimate how big the opcode is after this relax pass. The return 880 value is the difference between fr_fix and the actual size. We 881 compute the total size in rl78_relax_frag and store it in fr_subtype, 882 so we only need to subtract fx_fix and return it. */ 883 884 int 885 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED, segT segment ATTRIBUTE_UNUSED) 886 { 887 int opfixsize; 888 int delta; 889 890 /* This is the size of the opcode that's accounted for in fr_fix. */ 891 opfixsize = fragP->fr_fix - (fragP->fr_opcode - fragP->fr_literal); 892 /* This is the size of the opcode that isn't. */ 893 delta = (fragP->fr_subtype - opfixsize); 894 895 tprintf (" -> opfixsize %d delta %d\n", opfixsize, delta); 896 return delta; 897 } 898 899 /* Given the new addresses for this relax pass, figure out how big 900 each opcode must be. We store the total number of bytes needed in 901 fr_subtype. The return value is the difference between the size 902 after the last pass and the size after this pass, so we use the old 903 fr_subtype to calculate the difference. */ 904 905 int 906 rl78_relax_frag (segT segment ATTRIBUTE_UNUSED, fragS * fragP, long stretch) 907 { 908 addressT addr0, sym_addr; 909 addressT mypc; 910 int disp; 911 int oldsize = fragP->fr_subtype; 912 int newsize = oldsize; 913 op_type_T optype; 914 int ri; 915 916 mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal); 917 918 /* If we ever get more than one reloc per opcode, this is the one 919 we're relaxing. */ 920 ri = 0; 921 922 optype = rl78_opcode_type (fragP->fr_opcode); 923 /* Try to get the target address. */ 924 if (rl78_frag_fix_value (fragP, segment, ri, & addr0, 925 fragP->tc_frag_data->relax[ri].type != RL78_RELAX_BRANCH, 926 & sym_addr)) 927 { 928 /* If we don't expect the linker to do relaxing, don't emit 929 expanded opcodes that only the linker will relax. */ 930 if (!linkrelax) 931 return newsize - oldsize; 932 933 /* If we don't, we must use the maximum size for the linker. */ 934 switch (fragP->tc_frag_data->relax[ri].type) 935 { 936 case RL78_RELAX_BRANCH: 937 switch (optype) 938 { 939 case OT_bt: 940 newsize = 6; 941 break; 942 case OT_bt_sfr: 943 case OT_bt_es: 944 newsize = 7; 945 break; 946 case OT_bc: 947 newsize = 5; 948 break; 949 case OT_bh: 950 newsize = 6; 951 break; 952 case OT_sk: 953 newsize = 2; 954 break; 955 default: 956 newsize = oldsize; 957 break; 958 } 959 break; 960 961 } 962 fragP->fr_subtype = newsize; 963 tprintf (" -> new %d old %d delta %d (external)\n", newsize, oldsize, newsize-oldsize); 964 return newsize - oldsize; 965 } 966 967 if (sym_addr > mypc) 968 addr0 += stretch; 969 970 switch (fragP->tc_frag_data->relax[ri].type) 971 { 972 case RL78_RELAX_BRANCH: 973 disp = (int) addr0 - (int) mypc; 974 975 switch (optype) 976 { 977 case OT_bt: 978 if (disp >= -128 && (disp - (oldsize-2)) <= 127) 979 newsize = 3; 980 else 981 newsize = 6; 982 break; 983 case OT_bt_sfr: 984 case OT_bt_es: 985 if (disp >= -128 && (disp - (oldsize-3)) <= 127) 986 newsize = 4; 987 else 988 newsize = 7; 989 break; 990 case OT_bc: 991 if (disp >= -128 && (disp - (oldsize-1)) <= 127) 992 newsize = 2; 993 else 994 newsize = 5; 995 break; 996 case OT_bh: 997 if (disp >= -128 && (disp - (oldsize-2)) <= 127) 998 newsize = 3; 999 else 1000 newsize = 6; 1001 break; 1002 case OT_sk: 1003 newsize = 2; 1004 break; 1005 default: 1006 newsize = oldsize; 1007 break; 1008 } 1009 break; 1010 } 1011 1012 /* This prevents infinite loops in align-heavy sources. */ 1013 if (newsize < oldsize) 1014 { 1015 if (fragP->tc_frag_data->times_shrank > 10 1016 && fragP->tc_frag_data->times_grown > 10) 1017 newsize = oldsize; 1018 if (fragP->tc_frag_data->times_shrank < 20) 1019 fragP->tc_frag_data->times_shrank ++; 1020 } 1021 else if (newsize > oldsize) 1022 { 1023 if (fragP->tc_frag_data->times_grown < 20) 1024 fragP->tc_frag_data->times_grown ++; 1025 } 1026 1027 fragP->fr_subtype = newsize; 1028 tprintf (" -> new %d old %d delta %d\n", newsize, oldsize, newsize-oldsize); 1029 return newsize - oldsize; 1030 } 1031 1032 /* This lets us test for the opcode type and the desired size in a 1033 switch statement. */ 1034 #define OPCODE(type,size) ((type) * 16 + (size)) 1035 1036 /* Given the opcode stored in fr_opcode and the number of bytes we 1037 think we need, encode a new opcode. We stored a pointer to the 1038 fixup for this opcode in the tc_frag_data structure. If we can do 1039 the fixup here, we change the relocation type to "none" (we test 1040 for that in tc_gen_reloc) else we change it to the right type for 1041 the new (biggest) opcode. */ 1042 1043 void 1044 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED, 1045 segT segment ATTRIBUTE_UNUSED, 1046 fragS * fragP ATTRIBUTE_UNUSED) 1047 { 1048 rl78_bytesT * rl78b = fragP->tc_frag_data; 1049 addressT addr0, mypc; 1050 int disp; 1051 int reloc_type, reloc_adjust; 1052 char * op = fragP->fr_opcode; 1053 int keep_reloc = 0; 1054 int ri; 1055 int fi = (rl78b->n_fixups > 1) ? 1 : 0; 1056 fixS * fix = rl78b->fixups[fi].fixP; 1057 1058 /* If we ever get more than one reloc per opcode, this is the one 1059 we're relaxing. */ 1060 ri = 0; 1061 1062 /* We used a new frag for this opcode, so the opcode address should 1063 be the frag address. */ 1064 mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal); 1065 tprintf ("\033[32mmypc: 0x%x\033[0m\n", (int)mypc); 1066 1067 /* Try to get the target address. If we fail here, we just use the 1068 largest format. */ 1069 if (rl78_frag_fix_value (fragP, segment, 0, & addr0, 1070 fragP->tc_frag_data->relax[ri].type != RL78_RELAX_BRANCH, 0)) 1071 { 1072 /* We don't know the target address. */ 1073 keep_reloc = 1; 1074 addr0 = 0; 1075 disp = 0; 1076 tprintf ("unknown addr ? - %x = ?\n", (int)mypc); 1077 } 1078 else 1079 { 1080 /* We know the target address, and it's in addr0. */ 1081 disp = (int) addr0 - (int) mypc; 1082 tprintf ("known addr %x - %x = %d\n", (int)addr0, (int)mypc, disp); 1083 } 1084 1085 if (linkrelax) 1086 keep_reloc = 1; 1087 1088 reloc_type = BFD_RELOC_NONE; 1089 reloc_adjust = 0; 1090 1091 switch (fragP->tc_frag_data->relax[ri].type) 1092 { 1093 case RL78_RELAX_BRANCH: 1094 switch (OPCODE (rl78_opcode_type (fragP->fr_opcode), fragP->fr_subtype)) 1095 { 1096 1097 case OPCODE (OT_bt, 3): /* BT A,$ - no change. */ 1098 disp -= 3; 1099 op[2] = disp; 1100 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE; 1101 break; 1102 1103 case OPCODE (OT_bt, 6): /* BT A,$ - long version. */ 1104 disp -= 3; 1105 op[1] ^= 0x06; /* toggle conditional. */ 1106 op[2] = 3; /* displacement over long branch. */ 1107 disp -= 3; 1108 op[3] = 0xEE; /* BR $!addr20 */ 1109 op[4] = disp & 0xff; 1110 op[5] = disp >> 8; 1111 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE; 1112 reloc_adjust = 2; 1113 break; 1114 1115 case OPCODE (OT_bt_sfr, 4): /* BT PSW,$ - no change. */ 1116 disp -= 4; 1117 op[3] = disp; 1118 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE; 1119 break; 1120 1121 case OPCODE (OT_bt_sfr, 7): /* BT PSW,$ - long version. */ 1122 disp -= 4; 1123 op[1] ^= 0x06; /* toggle conditional. */ 1124 op[3] = 3; /* displacement over long branch. */ 1125 disp -= 3; 1126 op[4] = 0xEE; /* BR $!addr20 */ 1127 op[5] = disp & 0xff; 1128 op[6] = disp >> 8; 1129 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE; 1130 reloc_adjust = 2; 1131 break; 1132 1133 case OPCODE (OT_bt_es, 4): /* BT ES:[HL],$ - no change. */ 1134 disp -= 4; 1135 op[3] = disp; 1136 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE; 1137 break; 1138 1139 case OPCODE (OT_bt_es, 7): /* BT PSW,$ - long version. */ 1140 disp -= 4; 1141 op[2] ^= 0x06; /* toggle conditional. */ 1142 op[3] = 3; /* displacement over long branch. */ 1143 disp -= 3; 1144 op[4] = 0xEE; /* BR $!addr20 */ 1145 op[5] = disp & 0xff; 1146 op[6] = disp >> 8; 1147 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE; 1148 reloc_adjust = 2; 1149 break; 1150 1151 case OPCODE (OT_bc, 2): /* BC $ - no change. */ 1152 disp -= 2; 1153 op[1] = disp; 1154 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE; 1155 break; 1156 1157 case OPCODE (OT_bc, 5): /* BC $ - long version. */ 1158 disp -= 2; 1159 op[0] ^= 0x02; /* toggle conditional. */ 1160 op[1] = 3; 1161 disp -= 3; 1162 op[2] = 0xEE; /* BR $!addr20 */ 1163 op[3] = disp & 0xff; 1164 op[4] = disp >> 8; 1165 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE; 1166 reloc_adjust = 2; 1167 break; 1168 1169 case OPCODE (OT_bh, 3): /* BH $ - no change. */ 1170 disp -= 3; 1171 op[2] = disp; 1172 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE; 1173 break; 1174 1175 case OPCODE (OT_bh, 6): /* BC $ - long version. */ 1176 disp -= 3; 1177 op[1] ^= 0x10; /* toggle conditional. */ 1178 op[2] = 3; 1179 disp -= 3; 1180 op[3] = 0xEE; /* BR $!addr20 */ 1181 op[4] = disp & 0xff; 1182 op[5] = disp >> 8; 1183 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE; 1184 reloc_adjust = 2; 1185 break; 1186 1187 case OPCODE (OT_sk, 2): /* SK<cond> - no change */ 1188 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE; 1189 break; 1190 1191 default: 1192 reloc_type = fix ? fix->fx_r_type : BFD_RELOC_NONE; 1193 break; 1194 } 1195 break; 1196 1197 default: 1198 if (rl78b->n_fixups) 1199 { 1200 reloc_type = fix->fx_r_type; 1201 reloc_adjust = 0; 1202 } 1203 break; 1204 } 1205 1206 if (rl78b->n_fixups) 1207 { 1208 1209 fix->fx_r_type = reloc_type; 1210 fix->fx_where += reloc_adjust; 1211 switch (reloc_type) 1212 { 1213 case BFD_RELOC_NONE: 1214 fix->fx_size = 0; 1215 break; 1216 case BFD_RELOC_8: 1217 fix->fx_size = 1; 1218 break; 1219 case BFD_RELOC_16_PCREL: 1220 fix->fx_size = 2; 1221 break; 1222 } 1223 } 1224 1225 fragP->fr_fix = fragP->fr_subtype + (fragP->fr_opcode - fragP->fr_literal); 1226 tprintf ("fragP->fr_fix now %ld (%d + (%p - %p)\n", (long) fragP->fr_fix, 1227 fragP->fr_subtype, fragP->fr_opcode, fragP->fr_literal); 1228 fragP->fr_var = 0; 1229 1230 tprintf ("compare 0x%lx vs 0x%lx - 0x%lx = 0x%lx (%p)\n", 1231 (long)fragP->fr_fix, 1232 (long)fragP->fr_next->fr_address, (long)fragP->fr_address, 1233 (long)(fragP->fr_next->fr_address - fragP->fr_address), 1234 fragP->fr_next); 1235 1236 if (fragP->fr_next != NULL 1237 && ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address) 1238 != fragP->fr_fix)) 1239 as_bad (_("bad frag at %p : fix %ld addr %ld %ld \n"), fragP, 1240 (long) fragP->fr_fix, 1241 (long) fragP->fr_address, (long) fragP->fr_next->fr_address); 1242 } 1243 1244 /* End of relaxation code. 1245 ----------------------------------------------------------------------*/ 1246 1247 1248 arelent ** 1249 tc_gen_reloc (asection * seg ATTRIBUTE_UNUSED, fixS * fixp) 1250 { 1251 static arelent * reloc[8]; 1252 int rp; 1253 1254 if (fixp->fx_r_type == BFD_RELOC_NONE) 1255 { 1256 reloc[0] = NULL; 1257 return reloc; 1258 } 1259 1260 if (fixp->fx_r_type == BFD_RELOC_RL78_RELAX && !linkrelax) 1261 { 1262 reloc[0] = NULL; 1263 return reloc; 1264 } 1265 1266 if (fixp->fx_subsy 1267 && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section) 1268 { 1269 fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy); 1270 fixp->fx_subsy = NULL; 1271 } 1272 1273 reloc[0] = XNEW (arelent); 1274 reloc[0]->sym_ptr_ptr = XNEW (asymbol *); 1275 * reloc[0]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); 1276 reloc[0]->address = fixp->fx_frag->fr_address + fixp->fx_where; 1277 reloc[0]->addend = fixp->fx_offset; 1278 1279 if (fixp->fx_r_type == BFD_RELOC_RL78_32_OP 1280 && fixp->fx_subsy) 1281 { 1282 fixp->fx_r_type = BFD_RELOC_RL78_DIFF; 1283 } 1284 1285 #define OPX(REL,SYM,ADD) \ 1286 reloc[rp] = XNEW (arelent); \ 1287 reloc[rp]->sym_ptr_ptr = XNEW (asymbol *); \ 1288 reloc[rp]->howto = bfd_reloc_type_lookup (stdoutput, REL); \ 1289 reloc[rp]->addend = ADD; \ 1290 * reloc[rp]->sym_ptr_ptr = SYM; \ 1291 reloc[rp]->address = fixp->fx_frag->fr_address + fixp->fx_where; \ 1292 reloc[++rp] = NULL 1293 #define OPSYM(SYM) OPX(BFD_RELOC_RL78_SYM, SYM, 0) 1294 1295 /* FIXME: We cannot do the normal thing for an immediate value reloc, 1296 ie creating a RL78_SYM reloc in the *ABS* section with an offset 1297 equal to the immediate value we want to store. This fails because 1298 the reloc processing in bfd_perform_relocation and bfd_install_relocation 1299 will short circuit such relocs and never pass them on to the special 1300 reloc processing code. So instead we create a RL78_SYM reloc against 1301 the __rl78_abs__ symbol and arrange for the linker scripts to place 1302 this symbol at address 0. */ 1303 #define OPIMM(IMM) OPX (BFD_RELOC_RL78_SYM, symbol_get_bfdsym (rl78_abs_sym), IMM) 1304 1305 #define OP(OP) OPX(BFD_RELOC_RL78_##OP, *reloc[0]->sym_ptr_ptr, 0) 1306 #define SYM0() reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RL78_SYM) 1307 1308 rp = 1; 1309 1310 /* Certain BFD relocations cannot be translated directly into 1311 a single (non-Red Hat) RL78 relocation, but instead need 1312 multiple RL78 relocations - handle them here. */ 1313 switch (fixp->fx_r_type) 1314 { 1315 case BFD_RELOC_RL78_DIFF: 1316 SYM0 (); 1317 OPSYM (symbol_get_bfdsym (fixp->fx_subsy)); 1318 OP(OP_SUBTRACT); 1319 1320 switch (fixp->fx_size) 1321 { 1322 case 1: 1323 OP(ABS8); 1324 break; 1325 case 2: 1326 OP (ABS16); 1327 break; 1328 case 4: 1329 OP (ABS32); 1330 break; 1331 } 1332 break; 1333 1334 case BFD_RELOC_RL78_NEG32: 1335 SYM0 (); 1336 OP (OP_NEG); 1337 OP (ABS32); 1338 break; 1339 1340 case BFD_RELOC_RL78_CODE: 1341 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RL78_16U); 1342 reloc[1] = NULL; 1343 break; 1344 1345 case BFD_RELOC_RL78_LO16: 1346 SYM0 (); 1347 OPIMM (0xffff); 1348 OP (OP_AND); 1349 OP (ABS16); 1350 break; 1351 1352 case BFD_RELOC_RL78_HI16: 1353 SYM0 (); 1354 OPIMM (16); 1355 OP (OP_SHRA); 1356 OP (ABS16); 1357 break; 1358 1359 case BFD_RELOC_RL78_HI8: 1360 SYM0 (); 1361 OPIMM (16); 1362 OP (OP_SHRA); 1363 OPIMM (0xff); 1364 OP (OP_AND); 1365 OP (ABS8); 1366 break; 1367 1368 default: 1369 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type); 1370 reloc[1] = NULL; 1371 break; 1372 } 1373 1374 return reloc; 1375 } 1376 1377 int 1378 rl78_validate_fix_sub (struct fix * f) 1379 { 1380 /* We permit the subtraction of two symbols in a few cases. */ 1381 /* mov #sym1-sym2, R3 */ 1382 if (f->fx_r_type == BFD_RELOC_RL78_32_OP) 1383 return 1; 1384 /* .long sym1-sym2 */ 1385 if (f->fx_r_type == BFD_RELOC_RL78_DIFF 1386 && ! f->fx_pcrel 1387 && (f->fx_size == 4 || f->fx_size == 2 || f->fx_size == 1)) 1388 return 1; 1389 return 0; 1390 } 1391 1392 long 1393 md_pcrel_from_section (fixS * fixP, segT sec) 1394 { 1395 long rv; 1396 1397 if (fixP->fx_addsy != NULL 1398 && (! S_IS_DEFINED (fixP->fx_addsy) 1399 || S_GET_SEGMENT (fixP->fx_addsy) != sec)) 1400 /* The symbol is undefined (or is defined but not in this section). 1401 Let the linker figure it out. */ 1402 return 0; 1403 1404 rv = fixP->fx_frag->fr_address + fixP->fx_where; 1405 switch (fixP->fx_r_type) 1406 { 1407 case BFD_RELOC_8_PCREL: 1408 rv += 1; 1409 break; 1410 case BFD_RELOC_16_PCREL: 1411 rv += 2; 1412 break; 1413 default: 1414 break; 1415 } 1416 return rv; 1417 } 1418 1419 void 1420 md_apply_fix (struct fix * f ATTRIBUTE_UNUSED, 1421 valueT * t ATTRIBUTE_UNUSED, 1422 segT s ATTRIBUTE_UNUSED) 1423 { 1424 char * op; 1425 unsigned long val; 1426 1427 /* We always defer overflow checks for these to the linker, as it 1428 needs to do PLT stuff. */ 1429 if (f->fx_r_type == BFD_RELOC_RL78_CODE) 1430 f->fx_no_overflow = 1; 1431 1432 if (f->fx_addsy && S_FORCE_RELOC (f->fx_addsy, 1)) 1433 return; 1434 if (f->fx_subsy && S_FORCE_RELOC (f->fx_subsy, 1)) 1435 return; 1436 1437 op = f->fx_frag->fr_literal + f->fx_where; 1438 val = (unsigned long) * t; 1439 1440 if (f->fx_addsy == NULL) 1441 f->fx_done = 1; 1442 1443 switch (f->fx_r_type) 1444 { 1445 case BFD_RELOC_NONE: 1446 break; 1447 1448 case BFD_RELOC_RL78_RELAX: 1449 f->fx_done = 0; 1450 break; 1451 1452 case BFD_RELOC_8_PCREL: 1453 if ((long)val < -128 || (long)val > 127) 1454 as_bad_where (f->fx_file, f->fx_line, 1455 _("value of %ld too large for 8-bit branch"), 1456 val); 1457 /* Fall through. */ 1458 case BFD_RELOC_8: 1459 case BFD_RELOC_RL78_SADDR: /* We need to store the 8 LSB, but this works. */ 1460 op[0] = val; 1461 break; 1462 1463 case BFD_RELOC_16_PCREL: 1464 if ((long)val < -32768 || (long)val > 32767) 1465 as_bad_where (f->fx_file, f->fx_line, 1466 _("value of %ld too large for 16-bit branch"), 1467 val); 1468 /* Fall through. */ 1469 case BFD_RELOC_16: 1470 case BFD_RELOC_RL78_CODE: 1471 op[0] = val; 1472 op[1] = val >> 8; 1473 break; 1474 1475 case BFD_RELOC_24: 1476 op[0] = val; 1477 op[1] = val >> 8; 1478 op[2] = val >> 16; 1479 break; 1480 1481 case BFD_RELOC_32: 1482 op[0] = val; 1483 op[1] = val >> 8; 1484 op[2] = val >> 16; 1485 op[3] = val >> 24; 1486 break; 1487 1488 case BFD_RELOC_RL78_DIFF: 1489 op[0] = val; 1490 if (f->fx_size > 1) 1491 op[1] = val >> 8; 1492 if (f->fx_size > 2) 1493 op[2] = val >> 16; 1494 if (f->fx_size > 3) 1495 op[3] = val >> 24; 1496 break; 1497 1498 case BFD_RELOC_RL78_HI8: 1499 val = val >> 16; 1500 op[0] = val; 1501 break; 1502 1503 case BFD_RELOC_RL78_HI16: 1504 val = val >> 16; 1505 op[0] = val; 1506 op[1] = val >> 8; 1507 break; 1508 1509 case BFD_RELOC_RL78_LO16: 1510 op[0] = val; 1511 op[1] = val >> 8; 1512 break; 1513 1514 default: 1515 as_bad (_("Unknown reloc in md_apply_fix: %s"), 1516 bfd_get_reloc_code_name (f->fx_r_type)); 1517 break; 1518 } 1519 1520 } 1521 1522 valueT 1523 md_section_align (segT segment, valueT size) 1524 { 1525 int align = bfd_get_section_alignment (stdoutput, segment); 1526 return ((size + (1 << align) - 1) & -(1 << align)); 1527 } 1528