tc-mn10300.c revision 1.9
1 /* tc-mn10300.c -- Assembler code for the Matsushita 10300 2 Copyright (C) 1996-2024 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 #include "as.h" 22 #include "safe-ctype.h" 23 #include "subsegs.h" 24 #include "opcode/mn10300.h" 25 #include "dwarf2dbg.h" 26 #include "libiberty.h" 27 28 /* Structure to hold information about predefined registers. */ 30 struct reg_name 31 { 32 const char *name; 33 int value; 34 }; 35 36 /* Generic assembler global variables which must be defined by all 37 targets. */ 38 39 /* Characters which always start a comment. */ 40 const char comment_chars[] = "#"; 41 42 /* Characters which start a comment at the beginning of a line. */ 43 const char line_comment_chars[] = ";#"; 44 45 /* Characters which may be used to separate multiple commands on a 46 single line. */ 47 const char line_separator_chars[] = ";"; 48 49 /* Characters which are used to indicate an exponent in a floating 50 point number. */ 51 const char EXP_CHARS[] = "eE"; 52 53 /* Characters which mean that a number is a floating point constant, 54 as in 0d1.0. */ 55 const char FLT_CHARS[] = "dD"; 56 57 const relax_typeS md_relax_table[] = 59 { 60 /* The plus values for the bCC and fBCC instructions in the table below 61 are because the branch instruction is translated into a jump 62 instruction that is now +2 or +3 bytes further on in memory, and the 63 correct size of jump instruction must be selected. */ 64 /* bCC relaxing. */ 65 {0x7f, -0x80, 2, 1}, 66 {0x7fff + 2, -0x8000 + 2, 5, 2}, 67 {0x7fffffff, -0x80000000, 7, 0}, 68 69 /* bCC relaxing (uncommon cases for 3byte length instructions) */ 70 {0x7f, -0x80, 3, 4}, 71 {0x7fff + 3, -0x8000 + 3, 6, 5}, 72 {0x7fffffff, -0x80000000, 8, 0}, 73 74 /* call relaxing. */ 75 {0x7fff, -0x8000, 5, 7}, 76 {0x7fffffff, -0x80000000, 7, 0}, 77 78 /* calls relaxing. */ 79 {0x7fff, -0x8000, 4, 9}, 80 {0x7fffffff, -0x80000000, 6, 0}, 81 82 /* jmp relaxing. */ 83 {0x7f, -0x80, 2, 11}, 84 {0x7fff, -0x8000, 3, 12}, 85 {0x7fffffff, -0x80000000, 5, 0}, 86 87 /* fbCC relaxing. */ 88 {0x7f, -0x80, 3, 14}, 89 {0x7fff + 3, -0x8000 + 3, 6, 15}, 90 {0x7fffffff, -0x80000000, 8, 0}, 91 92 }; 93 94 static int current_machine; 95 96 /* Fixups. */ 97 #define MAX_INSN_FIXUPS 5 98 99 struct mn10300_fixup 100 { 101 expressionS exp; 102 int opindex; 103 bfd_reloc_code_real_type reloc; 104 }; 105 struct mn10300_fixup fixups[MAX_INSN_FIXUPS]; 106 static int fc; 107 108 /* We must store the value of each register operand so that we can 109 verify that certain registers do not match. */ 110 int mn10300_reg_operands[MN10300_MAX_OPERANDS]; 111 112 const char *md_shortopts = ""; 114 115 struct option md_longopts[] = 116 { 117 {NULL, no_argument, NULL, 0} 118 }; 119 120 size_t md_longopts_size = sizeof (md_longopts); 121 122 #define HAVE_AM33_2 (current_machine == AM33_2) 123 #define HAVE_AM33 (current_machine == AM33 || HAVE_AM33_2) 124 #define HAVE_AM30 (current_machine == AM30) 125 126 /* Opcode hash table. */ 127 static htab_t mn10300_hash; 128 129 /* This table is sorted. Suitable for searching by a binary search. */ 130 static const struct reg_name data_registers[] = 131 { 132 { "d0", 0 }, 133 { "d1", 1 }, 134 { "d2", 2 }, 135 { "d3", 3 }, 136 }; 137 138 static const struct reg_name address_registers[] = 139 { 140 { "a0", 0 }, 141 { "a1", 1 }, 142 { "a2", 2 }, 143 { "a3", 3 }, 144 }; 145 146 static const struct reg_name r_registers[] = 147 { 148 { "a0", 8 }, 149 { "a1", 9 }, 150 { "a2", 10 }, 151 { "a3", 11 }, 152 { "d0", 12 }, 153 { "d1", 13 }, 154 { "d2", 14 }, 155 { "d3", 15 }, 156 { "e0", 0 }, 157 { "e1", 1 }, 158 { "e10", 10 }, 159 { "e11", 11 }, 160 { "e12", 12 }, 161 { "e13", 13 }, 162 { "e14", 14 }, 163 { "e15", 15 }, 164 { "e2", 2 }, 165 { "e3", 3 }, 166 { "e4", 4 }, 167 { "e5", 5 }, 168 { "e6", 6 }, 169 { "e7", 7 }, 170 { "e8", 8 }, 171 { "e9", 9 }, 172 { "r0", 0 }, 173 { "r1", 1 }, 174 { "r10", 10 }, 175 { "r11", 11 }, 176 { "r12", 12 }, 177 { "r13", 13 }, 178 { "r14", 14 }, 179 { "r15", 15 }, 180 { "r2", 2 }, 181 { "r3", 3 }, 182 { "r4", 4 }, 183 { "r5", 5 }, 184 { "r6", 6 }, 185 { "r7", 7 }, 186 { "r8", 8 }, 187 { "r9", 9 }, 188 }; 189 190 static const struct reg_name xr_registers[] = 191 { 192 { "mcrh", 2 }, 193 { "mcrl", 3 }, 194 { "mcvf", 4 }, 195 { "mdrq", 1 }, 196 { "sp", 0 }, 197 { "xr0", 0 }, 198 { "xr1", 1 }, 199 { "xr10", 10 }, 200 { "xr11", 11 }, 201 { "xr12", 12 }, 202 { "xr13", 13 }, 203 { "xr14", 14 }, 204 { "xr15", 15 }, 205 { "xr2", 2 }, 206 { "xr3", 3 }, 207 { "xr4", 4 }, 208 { "xr5", 5 }, 209 { "xr6", 6 }, 210 { "xr7", 7 }, 211 { "xr8", 8 }, 212 { "xr9", 9 }, 213 }; 214 215 static const struct reg_name float_registers[] = 216 { 217 { "fs0", 0 }, 218 { "fs1", 1 }, 219 { "fs10", 10 }, 220 { "fs11", 11 }, 221 { "fs12", 12 }, 222 { "fs13", 13 }, 223 { "fs14", 14 }, 224 { "fs15", 15 }, 225 { "fs16", 16 }, 226 { "fs17", 17 }, 227 { "fs18", 18 }, 228 { "fs19", 19 }, 229 { "fs2", 2 }, 230 { "fs20", 20 }, 231 { "fs21", 21 }, 232 { "fs22", 22 }, 233 { "fs23", 23 }, 234 { "fs24", 24 }, 235 { "fs25", 25 }, 236 { "fs26", 26 }, 237 { "fs27", 27 }, 238 { "fs28", 28 }, 239 { "fs29", 29 }, 240 { "fs3", 3 }, 241 { "fs30", 30 }, 242 { "fs31", 31 }, 243 { "fs4", 4 }, 244 { "fs5", 5 }, 245 { "fs6", 6 }, 246 { "fs7", 7 }, 247 { "fs8", 8 }, 248 { "fs9", 9 }, 249 }; 250 251 static const struct reg_name double_registers[] = 252 { 253 { "fd0", 0 }, 254 { "fd10", 10 }, 255 { "fd12", 12 }, 256 { "fd14", 14 }, 257 { "fd16", 16 }, 258 { "fd18", 18 }, 259 { "fd2", 2 }, 260 { "fd20", 20 }, 261 { "fd22", 22 }, 262 { "fd24", 24 }, 263 { "fd26", 26 }, 264 { "fd28", 28 }, 265 { "fd30", 30 }, 266 { "fd4", 4 }, 267 { "fd6", 6 }, 268 { "fd8", 8 }, 269 }; 270 271 /* We abuse the `value' field, that would be otherwise unused, to 272 encode the architecture on which (access to) the register was 273 introduced. FIXME: we should probably warn when we encounter a 274 register name when assembling for an architecture that doesn't 275 support it, before parsing it as a symbol name. */ 276 static const struct reg_name other_registers[] = 277 { 278 { "epsw", AM33 }, 279 { "mdr", 0 }, 280 { "pc", AM33 }, 281 { "psw", 0 }, 282 { "sp", 0 }, 283 { "ssp", 0 }, 284 { "usp", 0 }, 285 }; 286 287 #define OTHER_REG_NAME_CNT ARRAY_SIZE (other_registers) 288 289 /* Perform a binary search of the given register table REGS to see 290 if NAME is a valid register name. Returns the register number from 291 the array on success, or -1 on failure. */ 292 293 static int 294 reg_name_search (const struct reg_name *regs, 295 int regcount, 296 const char *name) 297 { 298 int low, high; 299 300 low = 0; 301 high = regcount - 1; 302 303 do 304 { 305 int cmp, middle; 306 307 middle = (low + high) / 2; 308 cmp = strcasecmp (name, regs[middle].name); 309 if (cmp < 0) 310 high = middle - 1; 311 else if (cmp > 0) 312 low = middle + 1; 313 else 314 return regs[middle].value; 315 } 316 while (low <= high); 317 318 return -1; 319 } 320 321 /* Looks at the current position in the input line to see if it is 322 the name of a register in TABLE. If it is, then the name is 323 converted into an expression returned in EXPRESSIONP (with X_op 324 set to O_register and X_add_number set to the register number), the 325 input pointer is left pointing at the first non-blank character after 326 the name and the function returns TRUE. Otherwise the input pointer 327 is left alone and the function returns FALSE. */ 328 329 static bool 330 get_register_name (expressionS * expressionP, 331 const struct reg_name * table, 332 size_t table_length) 333 { 334 int reg_number; 335 char *name; 336 char *start; 337 char c; 338 339 /* Find the spelling of the operand. */ 340 start = input_line_pointer; 341 342 c = get_symbol_name (&name); 343 reg_number = reg_name_search (table, table_length, name); 344 345 /* Put back the delimiting char. */ 346 (void) restore_line_pointer (c); 347 348 /* Look to see if it's in the register table. */ 349 if (reg_number >= 0) 350 { 351 expressionP->X_op = O_register; 352 expressionP->X_add_number = reg_number; 353 354 /* Make the rest nice. */ 355 expressionP->X_add_symbol = NULL; 356 expressionP->X_op_symbol = NULL; 357 358 return true; 359 } 360 361 /* Reset the line as if we had not done anything. */ 362 input_line_pointer = start; 363 return false; 364 } 365 366 static bool 367 r_register_name (expressionS *expressionP) 368 { 369 return get_register_name (expressionP, r_registers, ARRAY_SIZE (r_registers)); 370 } 371 372 373 static bool 374 xr_register_name (expressionS *expressionP) 375 { 376 return get_register_name (expressionP, xr_registers, ARRAY_SIZE (xr_registers)); 377 } 378 379 static bool 380 data_register_name (expressionS *expressionP) 381 { 382 return get_register_name (expressionP, data_registers, ARRAY_SIZE (data_registers)); 383 } 384 385 static bool 386 address_register_name (expressionS *expressionP) 387 { 388 return get_register_name (expressionP, address_registers, ARRAY_SIZE (address_registers)); 389 } 390 391 static bool 392 float_register_name (expressionS *expressionP) 393 { 394 return get_register_name (expressionP, float_registers, ARRAY_SIZE (float_registers)); 395 } 396 397 static bool 398 double_register_name (expressionS *expressionP) 399 { 400 return get_register_name (expressionP, double_registers, ARRAY_SIZE (double_registers)); 401 } 402 403 static bool 404 other_register_name (expressionS *expressionP) 405 { 406 int reg_number; 407 char *name; 408 char *start; 409 char c; 410 411 /* Find the spelling of the operand. */ 412 start = input_line_pointer; 413 414 c = get_symbol_name (&name); 415 reg_number = reg_name_search (other_registers, ARRAY_SIZE (other_registers), name); 416 417 /* Put back the delimiting char. */ 418 (void) restore_line_pointer (c); 419 420 /* Look to see if it's in the register table. */ 421 if (reg_number == 0 422 || (reg_number == AM33 && HAVE_AM33)) 423 { 424 expressionP->X_op = O_register; 425 expressionP->X_add_number = 0; 426 427 /* Make the rest nice. */ 428 expressionP->X_add_symbol = NULL; 429 expressionP->X_op_symbol = NULL; 430 431 return true; 432 } 433 434 /* Reset the line as if we had not done anything. */ 435 input_line_pointer = start; 436 return false; 437 } 438 439 void 440 md_show_usage (FILE *stream) 441 { 442 fprintf (stream, _("MN10300 assembler options:\n\ 443 none yet\n")); 444 } 445 446 int 447 md_parse_option (int c ATTRIBUTE_UNUSED, const char *arg ATTRIBUTE_UNUSED) 448 { 449 return 0; 450 } 451 452 symbolS * 453 md_undefined_symbol (char *name ATTRIBUTE_UNUSED) 454 { 455 return 0; 456 } 457 458 const char * 459 md_atof (int type, char *litp, int *sizep) 460 { 461 return ieee_md_atof (type, litp, sizep, false); 462 } 463 464 void 465 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, 466 asection *sec, 467 fragS *fragP) 468 { 469 static unsigned long label_count = 0; 470 char buf[40]; 471 472 subseg_change (sec, 0); 473 if (fragP->fr_subtype == 0) 474 { 475 fix_new (fragP, fragP->fr_fix + 1, 1, fragP->fr_symbol, 476 fragP->fr_offset + 1, 1, BFD_RELOC_8_PCREL); 477 fragP->fr_var = 0; 478 fragP->fr_fix += 2; 479 } 480 else if (fragP->fr_subtype == 1) 481 { 482 /* Reverse the condition of the first branch. */ 483 int offset = fragP->fr_fix; 484 int opcode = fragP->fr_literal[offset] & 0xff; 485 486 switch (opcode) 487 { 488 case 0xc8: 489 opcode = 0xc9; 490 break; 491 case 0xc9: 492 opcode = 0xc8; 493 break; 494 case 0xc0: 495 opcode = 0xc2; 496 break; 497 case 0xc2: 498 opcode = 0xc0; 499 break; 500 case 0xc3: 501 opcode = 0xc1; 502 break; 503 case 0xc1: 504 opcode = 0xc3; 505 break; 506 case 0xc4: 507 opcode = 0xc6; 508 break; 509 case 0xc6: 510 opcode = 0xc4; 511 break; 512 case 0xc7: 513 opcode = 0xc5; 514 break; 515 case 0xc5: 516 opcode = 0xc7; 517 break; 518 default: 519 abort (); 520 } 521 fragP->fr_literal[offset] = opcode; 522 523 /* Create a fixup for the reversed conditional branch. */ 524 sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++); 525 fix_new (fragP, fragP->fr_fix + 1, 1, 526 symbol_new (buf, sec, fragP->fr_next, 0), 527 fragP->fr_offset + 1, 1, BFD_RELOC_8_PCREL); 528 529 /* Now create the unconditional branch + fixup to the 530 final target. */ 531 fragP->fr_literal[offset + 2] = 0xcc; 532 fix_new (fragP, fragP->fr_fix + 3, 2, fragP->fr_symbol, 533 fragP->fr_offset + 1, 1, BFD_RELOC_16_PCREL); 534 fragP->fr_var = 0; 535 fragP->fr_fix += 5; 536 } 537 else if (fragP->fr_subtype == 2) 538 { 539 /* Reverse the condition of the first branch. */ 540 int offset = fragP->fr_fix; 541 int opcode = fragP->fr_literal[offset] & 0xff; 542 543 switch (opcode) 544 { 545 case 0xc8: 546 opcode = 0xc9; 547 break; 548 case 0xc9: 549 opcode = 0xc8; 550 break; 551 case 0xc0: 552 opcode = 0xc2; 553 break; 554 case 0xc2: 555 opcode = 0xc0; 556 break; 557 case 0xc3: 558 opcode = 0xc1; 559 break; 560 case 0xc1: 561 opcode = 0xc3; 562 break; 563 case 0xc4: 564 opcode = 0xc6; 565 break; 566 case 0xc6: 567 opcode = 0xc4; 568 break; 569 case 0xc7: 570 opcode = 0xc5; 571 break; 572 case 0xc5: 573 opcode = 0xc7; 574 break; 575 default: 576 abort (); 577 } 578 fragP->fr_literal[offset] = opcode; 579 580 /* Create a fixup for the reversed conditional branch. */ 581 sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++); 582 fix_new (fragP, fragP->fr_fix + 1, 1, 583 symbol_new (buf, sec, fragP->fr_next, 0), 584 fragP->fr_offset + 1, 1, BFD_RELOC_8_PCREL); 585 586 /* Now create the unconditional branch + fixup to the 587 final target. */ 588 fragP->fr_literal[offset + 2] = 0xdc; 589 fix_new (fragP, fragP->fr_fix + 3, 4, fragP->fr_symbol, 590 fragP->fr_offset + 1, 1, BFD_RELOC_32_PCREL); 591 fragP->fr_var = 0; 592 fragP->fr_fix += 7; 593 } 594 else if (fragP->fr_subtype == 3) 595 { 596 fix_new (fragP, fragP->fr_fix + 2, 1, fragP->fr_symbol, 597 fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL); 598 fragP->fr_var = 0; 599 fragP->fr_fix += 3; 600 } 601 else if (fragP->fr_subtype == 4) 602 { 603 /* Reverse the condition of the first branch. */ 604 int offset = fragP->fr_fix; 605 int opcode = fragP->fr_literal[offset + 1] & 0xff; 606 607 switch (opcode) 608 { 609 case 0xe8: 610 opcode = 0xe9; 611 break; 612 case 0xe9: 613 opcode = 0xe8; 614 break; 615 case 0xea: 616 opcode = 0xeb; 617 break; 618 case 0xeb: 619 opcode = 0xea; 620 break; 621 default: 622 abort (); 623 } 624 fragP->fr_literal[offset + 1] = opcode; 625 626 /* Create a fixup for the reversed conditional branch. */ 627 sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++); 628 fix_new (fragP, fragP->fr_fix + 2, 1, 629 symbol_new (buf, sec, fragP->fr_next, 0), 630 fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL); 631 632 /* Now create the unconditional branch + fixup to the 633 final target. */ 634 fragP->fr_literal[offset + 3] = 0xcc; 635 fix_new (fragP, fragP->fr_fix + 4, 2, fragP->fr_symbol, 636 fragP->fr_offset + 1, 1, BFD_RELOC_16_PCREL); 637 fragP->fr_var = 0; 638 fragP->fr_fix += 6; 639 } 640 else if (fragP->fr_subtype == 5) 641 { 642 /* Reverse the condition of the first branch. */ 643 int offset = fragP->fr_fix; 644 int opcode = fragP->fr_literal[offset + 1] & 0xff; 645 646 switch (opcode) 647 { 648 case 0xe8: 649 opcode = 0xe9; 650 break; 651 case 0xea: 652 opcode = 0xeb; 653 break; 654 case 0xeb: 655 opcode = 0xea; 656 break; 657 default: 658 abort (); 659 } 660 fragP->fr_literal[offset + 1] = opcode; 661 662 /* Create a fixup for the reversed conditional branch. */ 663 sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++); 664 fix_new (fragP, fragP->fr_fix + 2, 1, 665 symbol_new (buf, sec, fragP->fr_next, 0), 666 fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL); 667 668 /* Now create the unconditional branch + fixup to the 669 final target. */ 670 fragP->fr_literal[offset + 3] = 0xdc; 671 fix_new (fragP, fragP->fr_fix + 4, 4, fragP->fr_symbol, 672 fragP->fr_offset + 1, 1, BFD_RELOC_32_PCREL); 673 fragP->fr_var = 0; 674 fragP->fr_fix += 8; 675 } 676 else if (fragP->fr_subtype == 6) 677 { 678 int offset = fragP->fr_fix; 679 680 fragP->fr_literal[offset] = 0xcd; 681 fix_new (fragP, fragP->fr_fix + 1, 2, fragP->fr_symbol, 682 fragP->fr_offset + 1, 1, BFD_RELOC_16_PCREL); 683 fragP->fr_var = 0; 684 fragP->fr_fix += 5; 685 } 686 else if (fragP->fr_subtype == 7) 687 { 688 int offset = fragP->fr_fix; 689 690 fragP->fr_literal[offset] = 0xdd; 691 fragP->fr_literal[offset + 5] = fragP->fr_literal[offset + 3]; 692 fragP->fr_literal[offset + 6] = fragP->fr_literal[offset + 4]; 693 fragP->fr_literal[offset + 3] = 0; 694 fragP->fr_literal[offset + 4] = 0; 695 696 fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol, 697 fragP->fr_offset + 1, 1, BFD_RELOC_32_PCREL); 698 fragP->fr_var = 0; 699 fragP->fr_fix += 7; 700 } 701 else if (fragP->fr_subtype == 8) 702 { 703 int offset = fragP->fr_fix; 704 705 fragP->fr_literal[offset] = 0xfa; 706 fragP->fr_literal[offset + 1] = 0xff; 707 fix_new (fragP, fragP->fr_fix + 2, 2, fragP->fr_symbol, 708 fragP->fr_offset + 2, 1, BFD_RELOC_16_PCREL); 709 fragP->fr_var = 0; 710 fragP->fr_fix += 4; 711 } 712 else if (fragP->fr_subtype == 9) 713 { 714 int offset = fragP->fr_fix; 715 716 fragP->fr_literal[offset] = 0xfc; 717 fragP->fr_literal[offset + 1] = 0xff; 718 719 fix_new (fragP, fragP->fr_fix + 2, 4, fragP->fr_symbol, 720 fragP->fr_offset + 2, 1, BFD_RELOC_32_PCREL); 721 fragP->fr_var = 0; 722 fragP->fr_fix += 6; 723 } 724 else if (fragP->fr_subtype == 10) 725 { 726 fragP->fr_literal[fragP->fr_fix] = 0xca; 727 fix_new (fragP, fragP->fr_fix + 1, 1, fragP->fr_symbol, 728 fragP->fr_offset + 1, 1, BFD_RELOC_8_PCREL); 729 fragP->fr_var = 0; 730 fragP->fr_fix += 2; 731 } 732 else if (fragP->fr_subtype == 11) 733 { 734 int offset = fragP->fr_fix; 735 736 fragP->fr_literal[offset] = 0xcc; 737 738 fix_new (fragP, fragP->fr_fix + 1, 2, fragP->fr_symbol, 739 fragP->fr_offset + 1, 1, BFD_RELOC_16_PCREL); 740 fragP->fr_var = 0; 741 fragP->fr_fix += 3; 742 } 743 else if (fragP->fr_subtype == 12) 744 { 745 int offset = fragP->fr_fix; 746 747 fragP->fr_literal[offset] = 0xdc; 748 749 fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol, 750 fragP->fr_offset + 1, 1, BFD_RELOC_32_PCREL); 751 fragP->fr_var = 0; 752 fragP->fr_fix += 5; 753 } 754 else if (fragP->fr_subtype == 13) 755 { 756 fix_new (fragP, fragP->fr_fix + 2, 1, fragP->fr_symbol, 757 fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL); 758 fragP->fr_var = 0; 759 fragP->fr_fix += 3; 760 } 761 else if (fragP->fr_subtype == 14) 762 { 763 /* Reverse the condition of the first branch. */ 764 int offset = fragP->fr_fix; 765 int opcode = fragP->fr_literal[offset + 1] & 0xff; 766 767 switch (opcode) 768 { 769 case 0xd0: 770 opcode = 0xd1; 771 break; 772 case 0xd1: 773 opcode = 0xd0; 774 break; 775 case 0xd2: 776 opcode = 0xdc; 777 break; 778 case 0xd3: 779 opcode = 0xdb; 780 break; 781 case 0xd4: 782 opcode = 0xda; 783 break; 784 case 0xd5: 785 opcode = 0xd9; 786 break; 787 case 0xd6: 788 opcode = 0xd8; 789 break; 790 case 0xd7: 791 opcode = 0xdd; 792 break; 793 case 0xd8: 794 opcode = 0xd6; 795 break; 796 case 0xd9: 797 opcode = 0xd5; 798 break; 799 case 0xda: 800 opcode = 0xd4; 801 break; 802 case 0xdb: 803 opcode = 0xd3; 804 break; 805 case 0xdc: 806 opcode = 0xd2; 807 break; 808 case 0xdd: 809 opcode = 0xd7; 810 break; 811 default: 812 abort (); 813 } 814 fragP->fr_literal[offset + 1] = opcode; 815 816 /* Create a fixup for the reversed conditional branch. */ 817 sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++); 818 fix_new (fragP, fragP->fr_fix + 2, 1, 819 symbol_new (buf, sec, fragP->fr_next, 0), 820 fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL); 821 822 /* Now create the unconditional branch + fixup to the 823 final target. */ 824 fragP->fr_literal[offset + 3] = 0xcc; 825 fix_new (fragP, fragP->fr_fix + 4, 2, fragP->fr_symbol, 826 fragP->fr_offset + 1, 1, BFD_RELOC_16_PCREL); 827 fragP->fr_var = 0; 828 fragP->fr_fix += 6; 829 } 830 else if (fragP->fr_subtype == 15) 831 { 832 /* Reverse the condition of the first branch. */ 833 int offset = fragP->fr_fix; 834 int opcode = fragP->fr_literal[offset + 1] & 0xff; 835 836 switch (opcode) 837 { 838 case 0xd0: 839 opcode = 0xd1; 840 break; 841 case 0xd1: 842 opcode = 0xd0; 843 break; 844 case 0xd2: 845 opcode = 0xdc; 846 break; 847 case 0xd3: 848 opcode = 0xdb; 849 break; 850 case 0xd4: 851 opcode = 0xda; 852 break; 853 case 0xd5: 854 opcode = 0xd9; 855 break; 856 case 0xd6: 857 opcode = 0xd8; 858 break; 859 case 0xd7: 860 opcode = 0xdd; 861 break; 862 case 0xd8: 863 opcode = 0xd6; 864 break; 865 case 0xd9: 866 opcode = 0xd5; 867 break; 868 case 0xda: 869 opcode = 0xd4; 870 break; 871 case 0xdb: 872 opcode = 0xd3; 873 break; 874 case 0xdc: 875 opcode = 0xd2; 876 break; 877 case 0xdd: 878 opcode = 0xd7; 879 break; 880 default: 881 abort (); 882 } 883 fragP->fr_literal[offset + 1] = opcode; 884 885 /* Create a fixup for the reversed conditional branch. */ 886 sprintf (buf, ".%s_%ld", FAKE_LABEL_NAME, label_count++); 887 fix_new (fragP, fragP->fr_fix + 2, 1, 888 symbol_new (buf, sec, fragP->fr_next, 0), 889 fragP->fr_offset + 2, 1, BFD_RELOC_8_PCREL); 890 891 /* Now create the unconditional branch + fixup to the 892 final target. */ 893 fragP->fr_literal[offset + 3] = 0xdc; 894 fix_new (fragP, fragP->fr_fix + 4, 4, fragP->fr_symbol, 895 fragP->fr_offset + 1, 1, BFD_RELOC_32_PCREL); 896 fragP->fr_var = 0; 897 fragP->fr_fix += 8; 898 } 899 else 900 abort (); 901 } 902 903 valueT 904 md_section_align (asection *seg, valueT addr) 905 { 906 int align = bfd_section_alignment (seg); 907 908 return ((addr + (1 << align) - 1) & -(1 << align)); 909 } 910 911 void 912 md_begin (void) 913 { 914 const char *prev_name = ""; 915 const struct mn10300_opcode *op; 916 917 mn10300_hash = str_htab_create (); 918 919 /* Insert unique names into hash table. The MN10300 instruction set 920 has many identical opcode names that have different opcodes based 921 on the operands. This hash table then provides a quick index to 922 the first opcode with a particular name in the opcode table. */ 923 924 op = mn10300_opcodes; 925 while (op->name) 926 { 927 if (strcmp (prev_name, op->name)) 928 { 929 prev_name = (char *) op->name; 930 str_hash_insert (mn10300_hash, op->name, op, 0); 931 } 932 op++; 933 } 934 935 /* Set the default machine type. */ 936 #ifdef TE_LINUX 937 if (!bfd_set_arch_mach (stdoutput, bfd_arch_mn10300, AM33_2)) 938 as_warn (_("could not set architecture and machine")); 939 940 current_machine = AM33_2; 941 #else 942 if (!bfd_set_arch_mach (stdoutput, bfd_arch_mn10300, MN103)) 943 as_warn (_("could not set architecture and machine")); 944 945 current_machine = MN103; 946 #endif 947 948 /* Set linkrelax here to avoid fixups in most sections. */ 949 linkrelax = 1; 950 } 951 952 static symbolS *GOT_symbol; 953 954 static inline int 955 mn10300_PIC_related_p (symbolS *sym) 956 { 957 expressionS *exp; 958 959 if (! sym) 960 return 0; 961 962 if (sym == GOT_symbol) 963 return 1; 964 965 exp = symbol_get_value_expression (sym); 966 967 return (exp->X_op == O_PIC_reloc 968 || mn10300_PIC_related_p (exp->X_add_symbol) 969 || mn10300_PIC_related_p (exp->X_op_symbol)); 970 } 971 972 static inline int 973 mn10300_check_fixup (struct mn10300_fixup *fixup) 974 { 975 expressionS *exp = &fixup->exp; 976 977 repeat: 978 switch (exp->X_op) 979 { 980 case O_add: 981 case O_subtract: /* If we're sufficiently unlucky that the label 982 and the expression that references it happen 983 to end up in different frags, the subtract 984 won't be simplified within expression(). */ 985 /* The PIC-related operand must be the first operand of a sum. */ 986 if (exp != &fixup->exp || mn10300_PIC_related_p (exp->X_op_symbol)) 987 return 1; 988 989 if (exp->X_add_symbol && exp->X_add_symbol == GOT_symbol) 990 fixup->reloc = BFD_RELOC_32_GOT_PCREL; 991 992 exp = symbol_get_value_expression (exp->X_add_symbol); 993 goto repeat; 994 995 case O_symbol: 996 if (exp->X_add_symbol && exp->X_add_symbol == GOT_symbol) 997 fixup->reloc = BFD_RELOC_32_GOT_PCREL; 998 break; 999 1000 case O_PIC_reloc: 1001 fixup->reloc = exp->X_md; 1002 exp->X_op = O_symbol; 1003 if (fixup->reloc == BFD_RELOC_32_PLT_PCREL 1004 && fixup->opindex >= 0 1005 && (mn10300_operands[fixup->opindex].flags 1006 & MN10300_OPERAND_RELAX)) 1007 return 1; 1008 break; 1009 1010 default: 1011 return (mn10300_PIC_related_p (exp->X_add_symbol) 1012 || mn10300_PIC_related_p (exp->X_op_symbol)); 1013 } 1014 1015 return 0; 1016 } 1017 1018 void 1019 mn10300_cons_fix_new (fragS *frag, int off, int size, expressionS *exp, 1020 bfd_reloc_code_real_type r ATTRIBUTE_UNUSED) 1021 { 1022 struct mn10300_fixup fixup; 1023 1024 fixup.opindex = -1; 1025 fixup.exp = *exp; 1026 fixup.reloc = BFD_RELOC_UNUSED; 1027 1028 mn10300_check_fixup (&fixup); 1029 1030 if (fixup.reloc == BFD_RELOC_MN10300_GOT32) 1031 switch (size) 1032 { 1033 case 2: 1034 fixup.reloc = BFD_RELOC_MN10300_GOT16; 1035 break; 1036 1037 case 3: 1038 fixup.reloc = BFD_RELOC_MN10300_GOT24; 1039 break; 1040 1041 case 4: 1042 break; 1043 1044 default: 1045 goto error; 1046 } 1047 else if (fixup.reloc == BFD_RELOC_UNUSED) 1048 switch (size) 1049 { 1050 case 1: 1051 fixup.reloc = BFD_RELOC_8; 1052 break; 1053 1054 case 2: 1055 fixup.reloc = BFD_RELOC_16; 1056 break; 1057 1058 case 3: 1059 fixup.reloc = BFD_RELOC_24; 1060 break; 1061 1062 case 4: 1063 fixup.reloc = BFD_RELOC_32; 1064 break; 1065 1066 default: 1067 goto error; 1068 } 1069 else if (size != 4) 1070 { 1071 error: 1072 as_bad (_("unsupported BFD relocation size %u"), size); 1073 fixup.reloc = BFD_RELOC_UNUSED; 1074 } 1075 1076 fix_new_exp (frag, off, size, &fixup.exp, 0, fixup.reloc); 1077 } 1078 1079 static bool 1080 check_operand (const struct mn10300_operand *operand, 1081 offsetT val) 1082 { 1083 /* No need to check 32bit operands for a bit. Note that 1084 MN10300_OPERAND_SPLIT is an implicit 32bit operand. */ 1085 if (operand->bits != 32 1086 && (operand->flags & MN10300_OPERAND_SPLIT) == 0) 1087 { 1088 long min, max; 1089 offsetT test; 1090 int bits; 1091 1092 bits = operand->bits; 1093 if (operand->flags & MN10300_OPERAND_24BIT) 1094 bits = 24; 1095 1096 if ((operand->flags & MN10300_OPERAND_SIGNED) != 0) 1097 { 1098 max = (1 << (bits - 1)) - 1; 1099 min = - (1 << (bits - 1)); 1100 } 1101 else 1102 { 1103 max = (1 << bits) - 1; 1104 min = 0; 1105 } 1106 1107 test = val; 1108 1109 if (test < (offsetT) min || test > (offsetT) max) 1110 return false; 1111 } 1112 return true; 1113 } 1114 1115 /* Insert an operand value into an instruction. */ 1116 1117 static void 1118 mn10300_insert_operand (unsigned long *insnp, 1119 unsigned long *extensionp, 1120 const struct mn10300_operand *operand, 1121 offsetT val, 1122 char *file, 1123 unsigned int line, 1124 unsigned int shift) 1125 { 1126 /* No need to check 32bit operands for a bit. Note that 1127 MN10300_OPERAND_SPLIT is an implicit 32bit operand. */ 1128 if (operand->bits != 32 1129 && (operand->flags & MN10300_OPERAND_SPLIT) == 0) 1130 { 1131 long min, max; 1132 offsetT test; 1133 int bits; 1134 1135 bits = operand->bits; 1136 if (operand->flags & MN10300_OPERAND_24BIT) 1137 bits = 24; 1138 1139 if ((operand->flags & MN10300_OPERAND_SIGNED) != 0) 1140 { 1141 max = (1 << (bits - 1)) - 1; 1142 min = - (1 << (bits - 1)); 1143 } 1144 else 1145 { 1146 max = (1 << bits) - 1; 1147 min = 0; 1148 } 1149 1150 test = val; 1151 1152 if (test < (offsetT) min || test > (offsetT) max) 1153 as_warn_value_out_of_range (_("operand"), test, (offsetT) min, (offsetT) max, file, line); 1154 } 1155 1156 if ((operand->flags & MN10300_OPERAND_SPLIT) != 0) 1157 { 1158 *insnp |= (val >> (32 - operand->bits)) & ((1 << operand->bits) - 1); 1159 *extensionp |= ((val & ((1 << (32 - operand->bits)) - 1)) 1160 << operand->shift); 1161 } 1162 else if ((operand->flags & MN10300_OPERAND_24BIT) != 0) 1163 { 1164 *insnp |= (val >> (24 - operand->bits)) & ((1 << operand->bits) - 1); 1165 *extensionp |= ((val & ((1 << (24 - operand->bits)) - 1)) 1166 << operand->shift); 1167 } 1168 else if ((operand->flags & (MN10300_OPERAND_FSREG | MN10300_OPERAND_FDREG))) 1169 { 1170 /* See devo/opcodes/m10300-opc.c just before #define FSM0 for an 1171 explanation of these variables. Note that FMT-implied shifts 1172 are not taken into account for FP registers. */ 1173 unsigned long mask_low, mask_high; 1174 int shl_low, shr_high, shl_high; 1175 1176 switch (operand->bits) 1177 { 1178 case 5: 1179 /* Handle regular FP registers. */ 1180 if (operand->shift >= 0) 1181 { 1182 /* This is an `m' register. */ 1183 shl_low = operand->shift; 1184 shl_high = 8 + (8 & shl_low) + (shl_low & 4) / 4; 1185 } 1186 else 1187 { 1188 /* This is an `n' register. */ 1189 shl_low = -operand->shift; 1190 shl_high = shl_low / 4; 1191 } 1192 1193 mask_low = 0x0f; 1194 mask_high = 0x10; 1195 shr_high = 4; 1196 break; 1197 1198 case 3: 1199 /* Handle accumulators. */ 1200 shl_low = -operand->shift; 1201 shl_high = 0; 1202 mask_low = 0x03; 1203 mask_high = 0x04; 1204 shr_high = 2; 1205 break; 1206 1207 default: 1208 abort (); 1209 } 1210 *insnp |= ((((val & mask_high) >> shr_high) << shl_high) 1211 | ((val & mask_low) << shl_low)); 1212 } 1213 else if ((operand->flags & MN10300_OPERAND_EXTENDED) == 0) 1214 { 1215 *insnp |= (((long) val & ((1 << operand->bits) - 1)) 1216 << (operand->shift + shift)); 1217 1218 if ((operand->flags & MN10300_OPERAND_REPEATED) != 0) 1219 *insnp |= (((long) val & ((1 << operand->bits) - 1)) 1220 << (operand->shift + shift + operand->bits)); 1221 } 1222 else 1223 { 1224 *extensionp |= (((long) val & ((1 << operand->bits) - 1)) 1225 << (operand->shift + shift)); 1226 1227 if ((operand->flags & MN10300_OPERAND_REPEATED) != 0) 1228 *extensionp |= (((long) val & ((1 << operand->bits) - 1)) 1229 << (operand->shift + shift + operand->bits)); 1230 } 1231 } 1232 1233 void 1234 md_assemble (char *str) 1235 { 1236 char *s; 1237 struct mn10300_opcode *opcode; 1238 struct mn10300_opcode *next_opcode; 1239 const unsigned char *opindex_ptr; 1240 int next_opindex, relaxable; 1241 unsigned long insn, extension, size = 0; 1242 char *f; 1243 int i; 1244 int match; 1245 1246 /* Get the opcode. */ 1247 for (s = str; *s != '\0' && !ISSPACE (*s); s++) 1248 ; 1249 if (*s != '\0') 1250 *s++ = '\0'; 1251 1252 /* Find the first opcode with the proper name. */ 1253 opcode = (struct mn10300_opcode *) str_hash_find (mn10300_hash, str); 1254 if (opcode == NULL) 1255 { 1256 as_bad (_("Unrecognized opcode: `%s'"), str); 1257 return; 1258 } 1259 1260 str = s; 1261 while (ISSPACE (*str)) 1262 ++str; 1263 1264 input_line_pointer = str; 1265 1266 for (;;) 1267 { 1268 const char *errmsg; 1269 int op_idx; 1270 char *hold; 1271 int extra_shift = 0; 1272 1273 errmsg = _("Invalid opcode/operands"); 1274 1275 /* Reset the array of register operands. */ 1276 memset (mn10300_reg_operands, -1, sizeof (mn10300_reg_operands)); 1277 1278 relaxable = 0; 1279 fc = 0; 1280 match = 0; 1281 next_opindex = 0; 1282 insn = opcode->opcode; 1283 extension = 0; 1284 1285 /* If the instruction is not available on the current machine 1286 then it can not possibly match. */ 1287 if (opcode->machine 1288 && !(opcode->machine == AM33_2 && HAVE_AM33_2) 1289 && !(opcode->machine == AM33 && HAVE_AM33) 1290 && !(opcode->machine == AM30 && HAVE_AM30)) 1291 goto error; 1292 1293 for (op_idx = 1, opindex_ptr = opcode->operands; 1294 *opindex_ptr != 0; 1295 opindex_ptr++, op_idx++) 1296 { 1297 const struct mn10300_operand *operand; 1298 expressionS ex; 1299 1300 if (next_opindex == 0) 1301 { 1302 operand = &mn10300_operands[*opindex_ptr]; 1303 } 1304 else 1305 { 1306 operand = &mn10300_operands[next_opindex]; 1307 next_opindex = 0; 1308 } 1309 1310 while (*str == ' ' || *str == ',') 1311 ++str; 1312 1313 if (operand->flags & MN10300_OPERAND_RELAX) 1314 relaxable = 1; 1315 1316 /* Gather the operand. */ 1317 hold = input_line_pointer; 1318 input_line_pointer = str; 1319 1320 if (operand->flags & MN10300_OPERAND_PAREN) 1321 { 1322 if (*input_line_pointer != ')' && *input_line_pointer != '(') 1323 { 1324 input_line_pointer = hold; 1325 str = hold; 1326 goto error; 1327 } 1328 input_line_pointer++; 1329 goto keep_going; 1330 } 1331 /* See if we can match the operands. */ 1332 else if (operand->flags & MN10300_OPERAND_DREG) 1333 { 1334 if (!data_register_name (&ex)) 1335 { 1336 input_line_pointer = hold; 1337 str = hold; 1338 goto error; 1339 } 1340 } 1341 else if (operand->flags & MN10300_OPERAND_AREG) 1342 { 1343 if (!address_register_name (&ex)) 1344 { 1345 input_line_pointer = hold; 1346 str = hold; 1347 goto error; 1348 } 1349 } 1350 else if (operand->flags & MN10300_OPERAND_SP) 1351 { 1352 char *start; 1353 char c = get_symbol_name (&start); 1354 1355 if (strcasecmp (start, "sp") != 0) 1356 { 1357 (void) restore_line_pointer (c); 1358 input_line_pointer = hold; 1359 str = hold; 1360 goto error; 1361 } 1362 (void) restore_line_pointer (c); 1363 goto keep_going; 1364 } 1365 else if (operand->flags & MN10300_OPERAND_RREG) 1366 { 1367 if (!r_register_name (&ex)) 1368 { 1369 input_line_pointer = hold; 1370 str = hold; 1371 goto error; 1372 } 1373 } 1374 else if (operand->flags & MN10300_OPERAND_XRREG) 1375 { 1376 if (!xr_register_name (&ex)) 1377 { 1378 input_line_pointer = hold; 1379 str = hold; 1380 goto error; 1381 } 1382 } 1383 else if (operand->flags & MN10300_OPERAND_FSREG) 1384 { 1385 if (!float_register_name (&ex)) 1386 { 1387 input_line_pointer = hold; 1388 str = hold; 1389 goto error; 1390 } 1391 } 1392 else if (operand->flags & MN10300_OPERAND_FDREG) 1393 { 1394 if (!double_register_name (&ex)) 1395 { 1396 input_line_pointer = hold; 1397 str = hold; 1398 goto error; 1399 } 1400 } 1401 else if (operand->flags & MN10300_OPERAND_FPCR) 1402 { 1403 char *start; 1404 char c = get_symbol_name (&start); 1405 1406 if (strcasecmp (start, "fpcr") != 0) 1407 { 1408 (void) restore_line_pointer (c); 1409 input_line_pointer = hold; 1410 str = hold; 1411 goto error; 1412 } 1413 (void) restore_line_pointer (c); 1414 goto keep_going; 1415 } 1416 else if (operand->flags & MN10300_OPERAND_USP) 1417 { 1418 char *start; 1419 char c = get_symbol_name (&start); 1420 1421 if (strcasecmp (start, "usp") != 0) 1422 { 1423 (void) restore_line_pointer (c); 1424 input_line_pointer = hold; 1425 str = hold; 1426 goto error; 1427 } 1428 (void) restore_line_pointer (c); 1429 goto keep_going; 1430 } 1431 else if (operand->flags & MN10300_OPERAND_SSP) 1432 { 1433 char *start; 1434 char c = get_symbol_name (&start); 1435 1436 if (strcasecmp (start, "ssp") != 0) 1437 { 1438 (void) restore_line_pointer (c); 1439 input_line_pointer = hold; 1440 str = hold; 1441 goto error; 1442 } 1443 (void) restore_line_pointer (c); 1444 goto keep_going; 1445 } 1446 else if (operand->flags & MN10300_OPERAND_MSP) 1447 { 1448 char *start; 1449 char c = get_symbol_name (&start); 1450 1451 if (strcasecmp (start, "msp") != 0) 1452 { 1453 (void) restore_line_pointer (c); 1454 input_line_pointer = hold; 1455 str = hold; 1456 goto error; 1457 } 1458 (void) restore_line_pointer (c); 1459 goto keep_going; 1460 } 1461 else if (operand->flags & MN10300_OPERAND_PC) 1462 { 1463 char *start; 1464 char c = get_symbol_name (&start); 1465 1466 if (strcasecmp (start, "pc") != 0) 1467 { 1468 (void) restore_line_pointer (c); 1469 input_line_pointer = hold; 1470 str = hold; 1471 goto error; 1472 } 1473 (void) restore_line_pointer (c); 1474 goto keep_going; 1475 } 1476 else if (operand->flags & MN10300_OPERAND_EPSW) 1477 { 1478 char *start; 1479 char c = get_symbol_name (&start); 1480 1481 if (strcasecmp (start, "epsw") != 0) 1482 { 1483 (void) restore_line_pointer (c); 1484 input_line_pointer = hold; 1485 str = hold; 1486 goto error; 1487 } 1488 (void) restore_line_pointer (c); 1489 goto keep_going; 1490 } 1491 else if (operand->flags & MN10300_OPERAND_PLUS) 1492 { 1493 if (*input_line_pointer != '+') 1494 { 1495 input_line_pointer = hold; 1496 str = hold; 1497 goto error; 1498 } 1499 input_line_pointer++; 1500 goto keep_going; 1501 } 1502 else if (operand->flags & MN10300_OPERAND_PSW) 1503 { 1504 char *start; 1505 char c = get_symbol_name (&start); 1506 1507 if (strcasecmp (start, "psw") != 0) 1508 { 1509 (void) restore_line_pointer (c); 1510 input_line_pointer = hold; 1511 str = hold; 1512 goto error; 1513 } 1514 (void) restore_line_pointer (c); 1515 goto keep_going; 1516 } 1517 else if (operand->flags & MN10300_OPERAND_MDR) 1518 { 1519 char *start; 1520 char c = get_symbol_name (&start); 1521 1522 if (strcasecmp (start, "mdr") != 0) 1523 { 1524 (void) restore_line_pointer (c); 1525 input_line_pointer = hold; 1526 str = hold; 1527 goto error; 1528 } 1529 (void) restore_line_pointer (c); 1530 goto keep_going; 1531 } 1532 else if (operand->flags & MN10300_OPERAND_REG_LIST) 1533 { 1534 unsigned int value = 0; 1535 if (*input_line_pointer != '[') 1536 { 1537 input_line_pointer = hold; 1538 str = hold; 1539 goto error; 1540 } 1541 1542 /* Eat the '['. */ 1543 input_line_pointer++; 1544 1545 /* We used to reject a null register list here; however, 1546 we accept it now so the compiler can emit "call" 1547 instructions for all calls to named functions. 1548 1549 The linker can then fill in the appropriate bits for the 1550 register list and stack size or change the instruction 1551 into a "calls" if using "call" is not profitable. */ 1552 while (*input_line_pointer != ']') 1553 { 1554 char *start; 1555 char c; 1556 1557 if (*input_line_pointer == ',') 1558 input_line_pointer++; 1559 1560 c = get_symbol_name (&start); 1561 1562 if (strcasecmp (start, "d2") == 0) 1563 { 1564 value |= 0x80; 1565 (void) restore_line_pointer (c); 1566 } 1567 else if (strcasecmp (start, "d3") == 0) 1568 { 1569 value |= 0x40; 1570 (void) restore_line_pointer (c); 1571 } 1572 else if (strcasecmp (start, "a2") == 0) 1573 { 1574 value |= 0x20; 1575 (void) restore_line_pointer (c); 1576 } 1577 else if (strcasecmp (start, "a3") == 0) 1578 { 1579 value |= 0x10; 1580 (void) restore_line_pointer (c); 1581 } 1582 else if (strcasecmp (start, "other") == 0) 1583 { 1584 value |= 0x08; 1585 (void) restore_line_pointer (c); 1586 } 1587 else if (HAVE_AM33 1588 && strcasecmp (start, "exreg0") == 0) 1589 { 1590 value |= 0x04; 1591 (void) restore_line_pointer (c); 1592 } 1593 else if (HAVE_AM33 1594 && strcasecmp (start, "exreg1") == 0) 1595 { 1596 value |= 0x02; 1597 (void) restore_line_pointer (c); 1598 } 1599 else if (HAVE_AM33 1600 && strcasecmp (start, "exother") == 0) 1601 { 1602 value |= 0x01; 1603 (void) restore_line_pointer (c); 1604 } 1605 else if (HAVE_AM33 1606 && strcasecmp (start, "all") == 0) 1607 { 1608 value |= 0xff; 1609 (void) restore_line_pointer (c); 1610 } 1611 else 1612 { 1613 input_line_pointer = hold; 1614 str = hold; 1615 goto error; 1616 } 1617 } 1618 input_line_pointer++; 1619 mn10300_insert_operand (& insn, & extension, operand, 1620 value, NULL, 0, 0); 1621 goto keep_going; 1622 1623 } 1624 else if (data_register_name (&ex)) 1625 { 1626 input_line_pointer = hold; 1627 str = hold; 1628 goto error; 1629 } 1630 else if (address_register_name (&ex)) 1631 { 1632 input_line_pointer = hold; 1633 str = hold; 1634 goto error; 1635 } 1636 else if (other_register_name (&ex)) 1637 { 1638 input_line_pointer = hold; 1639 str = hold; 1640 goto error; 1641 } 1642 else if (HAVE_AM33 && r_register_name (&ex)) 1643 { 1644 input_line_pointer = hold; 1645 str = hold; 1646 goto error; 1647 } 1648 else if (HAVE_AM33 && xr_register_name (&ex)) 1649 { 1650 input_line_pointer = hold; 1651 str = hold; 1652 goto error; 1653 } 1654 else if (HAVE_AM33_2 && float_register_name (&ex)) 1655 { 1656 input_line_pointer = hold; 1657 str = hold; 1658 goto error; 1659 } 1660 else if (HAVE_AM33_2 && double_register_name (&ex)) 1661 { 1662 input_line_pointer = hold; 1663 str = hold; 1664 goto error; 1665 } 1666 else if (*str == ')' || *str == '(') 1667 { 1668 input_line_pointer = hold; 1669 str = hold; 1670 goto error; 1671 } 1672 else 1673 { 1674 expression (&ex); 1675 resolve_register (&ex); 1676 } 1677 1678 switch (ex.X_op) 1679 { 1680 case O_illegal: 1681 errmsg = _("illegal operand"); 1682 goto error; 1683 case O_absent: 1684 errmsg = _("missing operand"); 1685 goto error; 1686 case O_register: 1687 { 1688 int mask; 1689 1690 mask = MN10300_OPERAND_DREG | MN10300_OPERAND_AREG; 1691 if (HAVE_AM33) 1692 mask |= MN10300_OPERAND_RREG | MN10300_OPERAND_XRREG; 1693 if (HAVE_AM33_2) 1694 mask |= MN10300_OPERAND_FSREG | MN10300_OPERAND_FDREG; 1695 if ((operand->flags & mask) == 0) 1696 { 1697 input_line_pointer = hold; 1698 str = hold; 1699 goto error; 1700 } 1701 1702 if (opcode->format == FMT_D1 || opcode->format == FMT_S1) 1703 extra_shift = 8; 1704 else if (opcode->format == FMT_D2 1705 || opcode->format == FMT_D4 1706 || opcode->format == FMT_S2 1707 || opcode->format == FMT_S4 1708 || opcode->format == FMT_S6 1709 || opcode->format == FMT_D5) 1710 extra_shift = 16; 1711 else if (opcode->format == FMT_D7) 1712 extra_shift = 8; 1713 else if (opcode->format == FMT_D8 || opcode->format == FMT_D9) 1714 extra_shift = 8; 1715 else 1716 extra_shift = 0; 1717 1718 mn10300_insert_operand (& insn, & extension, operand, 1719 ex.X_add_number, NULL, 1720 0, extra_shift); 1721 1722 /* And note the register number in the register array. */ 1723 mn10300_reg_operands[op_idx - 1] = ex.X_add_number; 1724 break; 1725 } 1726 1727 case O_constant: 1728 /* If this operand can be promoted, and it doesn't 1729 fit into the allocated bitfield for this insn, 1730 then promote it (ie this opcode does not match). */ 1731 if (operand->flags 1732 & (MN10300_OPERAND_PROMOTE | MN10300_OPERAND_RELAX) 1733 && !check_operand (operand, ex.X_add_number)) 1734 { 1735 input_line_pointer = hold; 1736 str = hold; 1737 goto error; 1738 } 1739 1740 mn10300_insert_operand (& insn, & extension, operand, 1741 ex.X_add_number, NULL, 0, 0); 1742 break; 1743 1744 default: 1745 /* If this operand can be promoted, then this opcode didn't 1746 match since we can't know if it needed promotion! */ 1747 if (operand->flags & MN10300_OPERAND_PROMOTE) 1748 { 1749 input_line_pointer = hold; 1750 str = hold; 1751 goto error; 1752 } 1753 1754 /* We need to generate a fixup for this expression. */ 1755 if (fc >= MAX_INSN_FIXUPS) 1756 as_fatal (_("too many fixups")); 1757 fixups[fc].exp = ex; 1758 fixups[fc].opindex = *opindex_ptr; 1759 fixups[fc].reloc = BFD_RELOC_UNUSED; 1760 if (mn10300_check_fixup (& fixups[fc])) 1761 goto error; 1762 ++fc; 1763 break; 1764 } 1765 1766 keep_going: 1767 str = input_line_pointer; 1768 input_line_pointer = hold; 1769 1770 while (*str == ' ' || *str == ',') 1771 ++str; 1772 } 1773 1774 /* Make sure we used all the operands! */ 1775 if (*str != ',') 1776 match = 1; 1777 1778 /* If this instruction has registers that must not match, verify 1779 that they do indeed not match. */ 1780 if (opcode->no_match_operands) 1781 { 1782 /* Look at each operand to see if it's marked. */ 1783 for (i = 0; i < MN10300_MAX_OPERANDS; i++) 1784 { 1785 if ((1 << i) & opcode->no_match_operands) 1786 { 1787 int j; 1788 1789 /* operand I is marked. Check that it does not match any 1790 operands > I which are marked. */ 1791 for (j = i + 1; j < MN10300_MAX_OPERANDS; j++) 1792 { 1793 if (((1 << j) & opcode->no_match_operands) 1794 && mn10300_reg_operands[i] == mn10300_reg_operands[j]) 1795 { 1796 errmsg = _("Invalid register specification."); 1797 match = 0; 1798 goto error; 1799 } 1800 } 1801 } 1802 } 1803 } 1804 1805 error: 1806 if (match == 0) 1807 { 1808 next_opcode = opcode + 1; 1809 if (!strcmp (next_opcode->name, opcode->name)) 1810 { 1811 opcode = next_opcode; 1812 continue; 1813 } 1814 1815 as_bad ("%s", errmsg); 1816 return; 1817 } 1818 break; 1819 } 1820 1821 while (ISSPACE (*str)) 1822 ++str; 1823 1824 if (*str != '\0') 1825 as_bad (_("junk at end of line: `%s'"), str); 1826 1827 input_line_pointer = str; 1828 1829 /* Determine the size of the instruction. */ 1830 if (opcode->format == FMT_S0) 1831 size = 1; 1832 1833 if (opcode->format == FMT_S1 || opcode->format == FMT_D0) 1834 size = 2; 1835 1836 if (opcode->format == FMT_S2 || opcode->format == FMT_D1) 1837 size = 3; 1838 1839 if (opcode->format == FMT_D6) 1840 size = 3; 1841 1842 if (opcode->format == FMT_D7 || opcode->format == FMT_D10) 1843 size = 4; 1844 1845 if (opcode->format == FMT_D8) 1846 size = 6; 1847 1848 if (opcode->format == FMT_D9) 1849 size = 7; 1850 1851 if (opcode->format == FMT_S4) 1852 size = 5; 1853 1854 if (opcode->format == FMT_S6 || opcode->format == FMT_D5) 1855 size = 7; 1856 1857 if (opcode->format == FMT_D2) 1858 size = 4; 1859 1860 if (opcode->format == FMT_D3) 1861 size = 5; 1862 1863 if (opcode->format == FMT_D4) 1864 size = 6; 1865 1866 if (relaxable && fc > 0) 1867 { 1868 /* On a 64-bit host the size of an 'int' is not the same 1869 as the size of a pointer, so we need a union to convert 1870 the opindex field of the fr_cgen structure into a char * 1871 so that it can be stored in the frag. We do not have 1872 to worry about losing accuracy as we are not going to 1873 be even close to the 32bit limit of the int. */ 1874 union 1875 { 1876 int opindex; 1877 char * ptr; 1878 } 1879 opindex_converter; 1880 int type; 1881 1882 /* We want to anchor the line info to the previous frag (if 1883 there isn't one, create it), so that, when the insn is 1884 resized, we still get the right address for the beginning of 1885 the region. */ 1886 f = frag_more (0); 1887 dwarf2_emit_insn (0); 1888 1889 /* bCC */ 1890 if (size == 2) 1891 { 1892 /* Handle bra specially. Basically treat it like jmp so 1893 that we automatically handle 8, 16 and 32 bit offsets 1894 correctly as well as jumps to an undefined address. 1895 1896 It is also important to not treat it like other bCC 1897 instructions since the long forms of bra is different 1898 from other bCC instructions. */ 1899 if (opcode->opcode == 0xca00) 1900 type = 10; 1901 else 1902 type = 0; 1903 } 1904 /* call */ 1905 else if (size == 5) 1906 type = 6; 1907 /* calls */ 1908 else if (size == 4) 1909 type = 8; 1910 /* jmp */ 1911 else if (size == 3 && opcode->opcode == 0xcc0000) 1912 type = 10; 1913 else if (size == 3 && (opcode->opcode & 0xfff000) == 0xf8d000) 1914 type = 13; 1915 /* bCC (uncommon cases) */ 1916 else 1917 type = 3; 1918 1919 opindex_converter.opindex = fixups[0].opindex; 1920 f = frag_var (rs_machine_dependent, 8, 8 - size, type, 1921 fixups[0].exp.X_add_symbol, 1922 fixups[0].exp.X_add_number, 1923 opindex_converter.ptr); 1924 1925 /* This is pretty hokey. We basically just care about the 1926 opcode, so we have to write out the first word big endian. 1927 1928 The exception is "call", which has two operands that we 1929 care about. 1930 1931 The first operand (the register list) happens to be in the 1932 first instruction word, and will be in the right place if 1933 we output the first word in big endian mode. 1934 1935 The second operand (stack size) is in the extension word, 1936 and we want it to appear as the first character in the extension 1937 word (as it appears in memory). Luckily, writing the extension 1938 word in big endian format will do what we want. */ 1939 number_to_chars_bigendian (f, insn, size > 4 ? 4 : size); 1940 if (size > 8) 1941 { 1942 number_to_chars_bigendian (f + 4, extension, 4); 1943 number_to_chars_bigendian (f + 8, 0, size - 8); 1944 } 1945 else if (size > 4) 1946 number_to_chars_bigendian (f + 4, extension, size - 4); 1947 } 1948 else 1949 { 1950 /* Allocate space for the instruction. */ 1951 f = frag_more (size); 1952 1953 /* Fill in bytes for the instruction. Note that opcode fields 1954 are written big-endian, 16 & 32bit immediates are written 1955 little endian. Egad. */ 1956 if (opcode->format == FMT_S0 1957 || opcode->format == FMT_S1 1958 || opcode->format == FMT_D0 1959 || opcode->format == FMT_D6 1960 || opcode->format == FMT_D7 1961 || opcode->format == FMT_D10 1962 || opcode->format == FMT_D1) 1963 { 1964 number_to_chars_bigendian (f, insn, size); 1965 } 1966 else if (opcode->format == FMT_S2 1967 && opcode->opcode != 0xdf0000 1968 && opcode->opcode != 0xde0000) 1969 { 1970 /* A format S2 instruction that is _not_ "ret" and "retf". */ 1971 number_to_chars_bigendian (f, (insn >> 16) & 0xff, 1); 1972 number_to_chars_littleendian (f + 1, insn & 0xffff, 2); 1973 } 1974 else if (opcode->format == FMT_S2) 1975 { 1976 /* This must be a ret or retf, which is written entirely in 1977 big-endian format. */ 1978 number_to_chars_bigendian (f, insn, 3); 1979 } 1980 else if (opcode->format == FMT_S4 1981 && opcode->opcode != 0xdc000000) 1982 { 1983 /* This must be a format S4 "call" instruction. What a pain. */ 1984 unsigned long temp = (insn >> 8) & 0xffff; 1985 number_to_chars_bigendian (f, (insn >> 24) & 0xff, 1); 1986 number_to_chars_littleendian (f + 1, temp, 2); 1987 number_to_chars_bigendian (f + 3, insn & 0xff, 1); 1988 number_to_chars_bigendian (f + 4, extension & 0xff, 1); 1989 } 1990 else if (opcode->format == FMT_S4) 1991 { 1992 /* This must be a format S4 "jmp" instruction. */ 1993 unsigned long temp = ((insn & 0xffffff) << 8) | (extension & 0xff); 1994 number_to_chars_bigendian (f, (insn >> 24) & 0xff, 1); 1995 number_to_chars_littleendian (f + 1, temp, 4); 1996 } 1997 else if (opcode->format == FMT_S6) 1998 { 1999 unsigned long temp = ((insn & 0xffffff) << 8) 2000 | ((extension >> 16) & 0xff); 2001 number_to_chars_bigendian (f, (insn >> 24) & 0xff, 1); 2002 number_to_chars_littleendian (f + 1, temp, 4); 2003 number_to_chars_bigendian (f + 5, (extension >> 8) & 0xff, 1); 2004 number_to_chars_bigendian (f + 6, extension & 0xff, 1); 2005 } 2006 else if (opcode->format == FMT_D2 2007 && opcode->opcode != 0xfaf80000 2008 && opcode->opcode != 0xfaf00000 2009 && opcode->opcode != 0xfaf40000) 2010 { 2011 /* A format D2 instruction where the 16bit immediate is 2012 really a single 16bit value, not two 8bit values. */ 2013 number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2); 2014 number_to_chars_littleendian (f + 2, insn & 0xffff, 2); 2015 } 2016 else if (opcode->format == FMT_D2) 2017 { 2018 /* A format D2 instruction where the 16bit immediate 2019 is really two 8bit immediates. */ 2020 number_to_chars_bigendian (f, insn, 4); 2021 } 2022 else if (opcode->format == FMT_D3) 2023 { 2024 number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2); 2025 number_to_chars_littleendian (f + 2, insn & 0xffff, 2); 2026 number_to_chars_bigendian (f + 4, extension & 0xff, 1); 2027 } 2028 else if (opcode->format == FMT_D4) 2029 { 2030 unsigned long temp = ((insn & 0xffff) << 16) | (extension & 0xffff); 2031 2032 number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2); 2033 number_to_chars_littleendian (f + 2, temp, 4); 2034 } 2035 else if (opcode->format == FMT_D5) 2036 { 2037 unsigned long temp = (((insn & 0xffff) << 16) 2038 | ((extension >> 8) & 0xffff)); 2039 2040 number_to_chars_bigendian (f, (insn >> 16) & 0xffff, 2); 2041 number_to_chars_littleendian (f + 2, temp, 4); 2042 number_to_chars_bigendian (f + 6, extension & 0xff, 1); 2043 } 2044 else if (opcode->format == FMT_D8) 2045 { 2046 unsigned long temp = ((insn & 0xff) << 16) | (extension & 0xffff); 2047 2048 number_to_chars_bigendian (f, (insn >> 8) & 0xffffff, 3); 2049 number_to_chars_bigendian (f + 3, (temp & 0xff), 1); 2050 number_to_chars_littleendian (f + 4, temp >> 8, 2); 2051 } 2052 else if (opcode->format == FMT_D9) 2053 { 2054 unsigned long temp = ((insn & 0xff) << 24) | (extension & 0xffffff); 2055 2056 number_to_chars_bigendian (f, (insn >> 8) & 0xffffff, 3); 2057 number_to_chars_littleendian (f + 3, temp, 4); 2058 } 2059 2060 /* Create any fixups. */ 2061 for (i = 0; i < fc; i++) 2062 { 2063 const struct mn10300_operand *operand; 2064 int reloc_size; 2065 2066 operand = &mn10300_operands[fixups[i].opindex]; 2067 if (fixups[i].reloc != BFD_RELOC_UNUSED 2068 && fixups[i].reloc != BFD_RELOC_32_GOT_PCREL 2069 && fixups[i].reloc != BFD_RELOC_32_GOTOFF 2070 && fixups[i].reloc != BFD_RELOC_32_PLT_PCREL 2071 && fixups[i].reloc != BFD_RELOC_MN10300_TLS_GD 2072 && fixups[i].reloc != BFD_RELOC_MN10300_TLS_LD 2073 && fixups[i].reloc != BFD_RELOC_MN10300_TLS_LDO 2074 && fixups[i].reloc != BFD_RELOC_MN10300_TLS_GOTIE 2075 && fixups[i].reloc != BFD_RELOC_MN10300_TLS_IE 2076 && fixups[i].reloc != BFD_RELOC_MN10300_TLS_LE 2077 && fixups[i].reloc != BFD_RELOC_MN10300_GOT32) 2078 { 2079 reloc_howto_type *reloc_howto; 2080 int offset; 2081 2082 reloc_howto = bfd_reloc_type_lookup (stdoutput, 2083 fixups[i].reloc); 2084 2085 if (!reloc_howto) 2086 abort (); 2087 2088 reloc_size = bfd_get_reloc_size (reloc_howto); 2089 2090 if (reloc_size < 1 || reloc_size > 4) 2091 abort (); 2092 2093 offset = 4 - size; 2094 fix_new_exp (frag_now, f - frag_now->fr_literal + offset, 2095 reloc_size, &fixups[i].exp, 2096 reloc_howto->pc_relative, 2097 fixups[i].reloc); 2098 } 2099 else 2100 { 2101 int reloc, pcrel, offset; 2102 fixS *fixP; 2103 2104 reloc = BFD_RELOC_NONE; 2105 if (fixups[i].reloc != BFD_RELOC_UNUSED) 2106 reloc = fixups[i].reloc; 2107 /* How big is the reloc? Remember SPLIT relocs are 2108 implicitly 32bits. */ 2109 if ((operand->flags & MN10300_OPERAND_SPLIT) != 0) 2110 reloc_size = 32; 2111 else if ((operand->flags & MN10300_OPERAND_24BIT) != 0) 2112 reloc_size = 24; 2113 else 2114 reloc_size = operand->bits; 2115 2116 /* Is the reloc pc-relative? */ 2117 pcrel = (operand->flags & MN10300_OPERAND_PCREL) != 0; 2118 if (reloc != BFD_RELOC_NONE) 2119 pcrel = bfd_reloc_type_lookup (stdoutput, reloc)->pc_relative; 2120 2121 offset = size - (reloc_size + operand->shift) / 8; 2122 2123 /* Choose a proper BFD relocation type. */ 2124 if (reloc != BFD_RELOC_NONE) 2125 ; 2126 else if (pcrel) 2127 { 2128 if (reloc_size == 32) 2129 reloc = BFD_RELOC_32_PCREL; 2130 else if (reloc_size == 16) 2131 reloc = BFD_RELOC_16_PCREL; 2132 else if (reloc_size == 8) 2133 reloc = BFD_RELOC_8_PCREL; 2134 else 2135 abort (); 2136 } 2137 else 2138 { 2139 if (reloc_size == 32) 2140 reloc = BFD_RELOC_32; 2141 else if (reloc_size == 16) 2142 reloc = BFD_RELOC_16; 2143 else if (reloc_size == 8) 2144 reloc = BFD_RELOC_8; 2145 else 2146 abort (); 2147 } 2148 2149 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset, 2150 reloc_size / 8, &fixups[i].exp, pcrel, 2151 ((bfd_reloc_code_real_type) reloc)); 2152 2153 if (pcrel) 2154 fixP->fx_offset += offset; 2155 } 2156 } 2157 2158 dwarf2_emit_insn (size); 2159 } 2160 2161 /* Label this frag as one that contains instructions. */ 2162 frag_now->tc_frag_data = true; 2163 } 2164 2165 /* If while processing a fixup, a reloc really needs to be created 2166 then it is done here. */ 2167 2168 arelent ** 2169 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp) 2170 { 2171 static arelent * no_relocs = NULL; 2172 static arelent * relocs[MAX_RELOC_EXPANSION + 1]; 2173 arelent *reloc; 2174 2175 reloc = XNEW (arelent); 2176 2177 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type); 2178 if (reloc->howto == NULL) 2179 { 2180 as_bad_where (fixp->fx_file, fixp->fx_line, 2181 _("reloc %d not supported by object file format"), 2182 (int) fixp->fx_r_type); 2183 free (reloc); 2184 return & no_relocs; 2185 } 2186 2187 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; 2188 relocs[0] = reloc; 2189 relocs[1] = NULL; 2190 2191 if (fixp->fx_subsy 2192 && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section) 2193 { 2194 fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy); 2195 fixp->fx_subsy = NULL; 2196 } 2197 2198 if (fixp->fx_addsy && fixp->fx_subsy) 2199 { 2200 asection *asec, *ssec; 2201 2202 asec = S_GET_SEGMENT (fixp->fx_addsy); 2203 ssec = S_GET_SEGMENT (fixp->fx_subsy); 2204 2205 /* If we have a difference between two (non-absolute) symbols we must 2206 generate two relocs (one for each symbol) and allow the linker to 2207 resolve them - relaxation may change the distances between symbols, 2208 even local symbols defined in the same section. */ 2209 if (ssec != absolute_section || asec != absolute_section) 2210 { 2211 arelent * reloc2 = XNEW (arelent); 2212 2213 relocs[0] = reloc2; 2214 relocs[1] = reloc; 2215 2216 reloc2->address = reloc->address; 2217 reloc2->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_MN10300_SYM_DIFF); 2218 reloc2->addend = - S_GET_VALUE (fixp->fx_subsy); 2219 reloc2->sym_ptr_ptr = XNEW (asymbol *); 2220 *reloc2->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_subsy); 2221 2222 reloc->addend = fixp->fx_offset; 2223 if (asec == absolute_section) 2224 { 2225 reloc->addend += S_GET_VALUE (fixp->fx_addsy); 2226 reloc->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 2227 } 2228 else 2229 { 2230 reloc->sym_ptr_ptr = XNEW (asymbol *); 2231 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); 2232 } 2233 2234 fixp->fx_pcrel = 0; 2235 fixp->fx_done = 1; 2236 return relocs; 2237 } 2238 else 2239 { 2240 char *fixpos = fixp->fx_where + fixp->fx_frag->fr_literal; 2241 2242 reloc->addend = (S_GET_VALUE (fixp->fx_addsy) 2243 - S_GET_VALUE (fixp->fx_subsy) + fixp->fx_offset); 2244 2245 switch (fixp->fx_r_type) 2246 { 2247 case BFD_RELOC_8: 2248 md_number_to_chars (fixpos, reloc->addend, 1); 2249 break; 2250 2251 case BFD_RELOC_16: 2252 md_number_to_chars (fixpos, reloc->addend, 2); 2253 break; 2254 2255 case BFD_RELOC_24: 2256 md_number_to_chars (fixpos, reloc->addend, 3); 2257 break; 2258 2259 case BFD_RELOC_32: 2260 md_number_to_chars (fixpos, reloc->addend, 4); 2261 break; 2262 2263 default: 2264 reloc->sym_ptr_ptr 2265 = (asymbol **) bfd_abs_section_ptr->symbol_ptr_ptr; 2266 return relocs; 2267 } 2268 2269 free (reloc); 2270 return & no_relocs; 2271 } 2272 } 2273 else 2274 { 2275 reloc->sym_ptr_ptr = XNEW (asymbol *); 2276 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); 2277 reloc->addend = fixp->fx_offset; 2278 } 2279 return relocs; 2280 } 2281 2282 /* Returns true iff the symbol attached to the frag is at a known location 2283 in the given section, (and hence the relocation to it can be relaxed by 2284 the assembler). */ 2285 static inline bool 2286 has_known_symbol_location (fragS * fragp, asection * sec) 2287 { 2288 symbolS * sym = fragp->fr_symbol; 2289 2290 return sym != NULL 2291 && S_IS_DEFINED (sym) 2292 && ! S_IS_WEAK (sym) 2293 && S_GET_SEGMENT (sym) == sec; 2294 } 2295 2296 int 2297 md_estimate_size_before_relax (fragS *fragp, asection *seg) 2298 { 2299 if (fragp->fr_subtype == 6 2300 && ! has_known_symbol_location (fragp, seg)) 2301 fragp->fr_subtype = 7; 2302 else if (fragp->fr_subtype == 8 2303 && ! has_known_symbol_location (fragp, seg)) 2304 fragp->fr_subtype = 9; 2305 else if (fragp->fr_subtype == 10 2306 && ! has_known_symbol_location (fragp, seg)) 2307 fragp->fr_subtype = 12; 2308 2309 if (fragp->fr_subtype == 13) 2310 return 3; 2311 2312 if (fragp->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0])) 2313 abort (); 2314 2315 return md_relax_table[fragp->fr_subtype].rlx_length; 2316 } 2317 2318 long 2319 md_pcrel_from (fixS *fixp) 2320 { 2321 if (fixp->fx_addsy != (symbolS *) NULL 2322 && (!S_IS_DEFINED (fixp->fx_addsy) || S_IS_WEAK (fixp->fx_addsy))) 2323 /* The symbol is undefined or weak. Let the linker figure it out. */ 2324 return 0; 2325 2326 return fixp->fx_frag->fr_address + fixp->fx_where; 2327 } 2328 2329 void 2330 md_apply_fix (fixS * fixP, valueT * valP, segT seg) 2331 { 2332 char * fixpos = fixP->fx_where + fixP->fx_frag->fr_literal; 2333 int size = 0; 2334 int value = (int) * valP; 2335 2336 gas_assert (fixP->fx_r_type < BFD_RELOC_UNUSED); 2337 2338 /* This should never happen. */ 2339 if (seg->flags & SEC_ALLOC) 2340 abort (); 2341 2342 /* The value we are passed in *valuep includes the symbol values. 2343 If we are doing this relocation the code in write.c is going to 2344 call bfd_install_relocation, which is also going to use the symbol 2345 value. That means that if the reloc is fully resolved we want to 2346 use *valuep since bfd_install_relocation is not being used. 2347 2348 However, if the reloc is not fully resolved we do not want to use 2349 *valuep, and must use fx_offset instead. However, if the reloc 2350 is PC relative, we do want to use *valuep since it includes the 2351 result of md_pcrel_from. */ 2352 if (fixP->fx_addsy != NULL && ! fixP->fx_pcrel) 2353 value = fixP->fx_offset; 2354 2355 /* If the fix is relative to a symbol which is not defined, or not 2356 in the same segment as the fix, we cannot resolve it here. */ 2357 if (fixP->fx_addsy != NULL 2358 && (! S_IS_DEFINED (fixP->fx_addsy) 2359 || (S_GET_SEGMENT (fixP->fx_addsy) != seg))) 2360 { 2361 fixP->fx_done = 0; 2362 return; 2363 } 2364 2365 switch (fixP->fx_r_type) 2366 { 2367 case BFD_RELOC_8: 2368 case BFD_RELOC_8_PCREL: 2369 size = 1; 2370 break; 2371 2372 case BFD_RELOC_16: 2373 case BFD_RELOC_16_PCREL: 2374 size = 2; 2375 break; 2376 2377 case BFD_RELOC_32: 2378 case BFD_RELOC_32_PCREL: 2379 size = 4; 2380 break; 2381 2382 case BFD_RELOC_VTABLE_INHERIT: 2383 case BFD_RELOC_VTABLE_ENTRY: 2384 fixP->fx_done = 0; 2385 return; 2386 2387 case BFD_RELOC_MN10300_ALIGN: 2388 fixP->fx_done = 1; 2389 return; 2390 2391 case BFD_RELOC_NONE: 2392 default: 2393 as_bad_where (fixP->fx_file, fixP->fx_line, 2394 _("Bad relocation fixup type (%d)"), fixP->fx_r_type); 2395 } 2396 2397 md_number_to_chars (fixpos, value, size); 2398 2399 /* If a symbol remains, pass the fixup, as a reloc, onto the linker. */ 2400 if (fixP->fx_addsy == NULL) 2401 fixP->fx_done = 1; 2402 } 2403 2404 /* Return zero if the fixup in fixp should be left alone and not 2405 adjusted. */ 2406 2407 bool 2408 mn10300_fix_adjustable (struct fix *fixp) 2409 { 2410 if (fixp->fx_pcrel) 2411 { 2412 if (TC_FORCE_RELOCATION_LOCAL (fixp)) 2413 return false; 2414 } 2415 /* Non-relative relocs can (and must) be adjusted if they do 2416 not meet the criteria below, or the generic criteria. */ 2417 else if (TC_FORCE_RELOCATION (fixp)) 2418 return false; 2419 2420 /* Do not adjust relocations involving symbols in code sections, 2421 because it breaks linker relaxations. This could be fixed in the 2422 linker, but this fix is simpler, and it pretty much only affects 2423 object size a little bit. */ 2424 if (S_GET_SEGMENT (fixp->fx_addsy)->flags & SEC_CODE) 2425 return false; 2426 2427 /* Likewise, do not adjust symbols that won't be merged, or debug 2428 symbols, because they too break relaxation. We do want to adjust 2429 other mergeable symbols, like .rodata, because code relaxations 2430 need section-relative symbols to properly relax them. */ 2431 if (! (S_GET_SEGMENT (fixp->fx_addsy)->flags & SEC_MERGE)) 2432 return false; 2433 2434 if (startswith (S_GET_SEGMENT (fixp->fx_addsy)->name, ".debug")) 2435 return false; 2436 2437 return true; 2438 } 2439 2440 static void 2441 set_arch_mach (int mach) 2442 { 2443 if (!bfd_set_arch_mach (stdoutput, bfd_arch_mn10300, mach)) 2444 as_warn (_("could not set architecture and machine")); 2445 2446 current_machine = mach; 2447 } 2448 2449 static inline char * 2450 mn10300_end_of_match (char *cont, const char *what) 2451 { 2452 int len = strlen (what); 2453 2454 if (startswith (cont, what) 2455 && ! is_part_of_name (cont[len])) 2456 return cont + len; 2457 2458 return NULL; 2459 } 2460 2461 int 2462 mn10300_parse_name (char const *name, 2463 expressionS *exprP, 2464 enum expr_mode mode, 2465 char *nextcharP) 2466 { 2467 char *next = input_line_pointer; 2468 char *next_end; 2469 int reloc_type; 2470 segT segment; 2471 2472 exprP->X_op_symbol = NULL; 2473 2474 if (strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0) 2475 { 2476 if (! GOT_symbol) 2477 GOT_symbol = symbol_find_or_make (name); 2478 2479 exprP->X_add_symbol = GOT_symbol; 2480 no_suffix: 2481 /* If we have an absolute symbol or a reg, 2482 then we know its value now. */ 2483 segment = S_GET_SEGMENT (exprP->X_add_symbol); 2484 if (mode != expr_defer && segment == absolute_section) 2485 { 2486 exprP->X_op = O_constant; 2487 exprP->X_add_number = S_GET_VALUE (exprP->X_add_symbol); 2488 exprP->X_add_symbol = NULL; 2489 } 2490 else if (mode != expr_defer && segment == reg_section) 2491 { 2492 exprP->X_op = O_register; 2493 exprP->X_add_number = S_GET_VALUE (exprP->X_add_symbol); 2494 exprP->X_add_symbol = NULL; 2495 } 2496 else 2497 { 2498 exprP->X_op = O_symbol; 2499 exprP->X_add_number = 0; 2500 } 2501 2502 return 1; 2503 } 2504 2505 exprP->X_add_symbol = symbol_find_or_make (name); 2506 2507 if (*nextcharP != '@') 2508 goto no_suffix; 2509 else if ((next_end = mn10300_end_of_match (next + 1, "GOTOFF"))) 2510 reloc_type = BFD_RELOC_32_GOTOFF; 2511 else if ((next_end = mn10300_end_of_match (next + 1, "GOT"))) 2512 reloc_type = BFD_RELOC_MN10300_GOT32; 2513 else if ((next_end = mn10300_end_of_match (next + 1, "PLT"))) 2514 reloc_type = BFD_RELOC_32_PLT_PCREL; 2515 else if ((next_end = mn10300_end_of_match (next + 1, "tlsgd"))) 2516 reloc_type = BFD_RELOC_MN10300_TLS_GD; 2517 else if ((next_end = mn10300_end_of_match (next + 1, "tlsldm"))) 2518 reloc_type = BFD_RELOC_MN10300_TLS_LD; 2519 else if ((next_end = mn10300_end_of_match (next + 1, "dtpoff"))) 2520 reloc_type = BFD_RELOC_MN10300_TLS_LDO; 2521 else if ((next_end = mn10300_end_of_match (next + 1, "gotntpoff"))) 2522 reloc_type = BFD_RELOC_MN10300_TLS_GOTIE; 2523 else if ((next_end = mn10300_end_of_match (next + 1, "indntpoff"))) 2524 reloc_type = BFD_RELOC_MN10300_TLS_IE; 2525 else if ((next_end = mn10300_end_of_match (next + 1, "tpoff"))) 2526 reloc_type = BFD_RELOC_MN10300_TLS_LE; 2527 else 2528 goto no_suffix; 2529 2530 *input_line_pointer = *nextcharP; 2531 input_line_pointer = next_end; 2532 *nextcharP = *input_line_pointer; 2533 *input_line_pointer = '\0'; 2534 2535 exprP->X_op = O_PIC_reloc; 2536 exprP->X_add_number = 0; 2537 exprP->X_md = reloc_type; 2538 2539 return 1; 2540 } 2541 2542 /* The target specific pseudo-ops which we support. */ 2543 const pseudo_typeS md_pseudo_table[] = 2544 { 2545 { "am30", set_arch_mach, AM30 }, 2546 { "am33", set_arch_mach, AM33 }, 2547 { "am33_2", set_arch_mach, AM33_2 }, 2548 { "mn10300", set_arch_mach, MN103 }, 2549 {NULL, 0, 0} 2550 }; 2551 2552 /* Returns FALSE if there is some mn10300 specific reason why the 2553 subtraction of two same-section symbols cannot be computed by 2554 the assembler. */ 2555 2556 bool 2557 mn10300_allow_local_subtract (expressionS * left, expressionS * right, segT section) 2558 { 2559 bool result; 2560 fragS * left_frag; 2561 fragS * right_frag; 2562 fragS * frag; 2563 2564 /* If we are not performing linker relaxation then we have nothing 2565 to worry about. */ 2566 if (linkrelax == 0) 2567 return true; 2568 2569 /* If the symbols are not in a code section then they are OK. */ 2570 if ((section->flags & SEC_CODE) == 0) 2571 return true; 2572 2573 /* Otherwise we have to scan the fragments between the two symbols. 2574 If any instructions are found then we have to assume that linker 2575 relaxation may change their size and so we must delay resolving 2576 the subtraction until the final link. */ 2577 left_frag = symbol_get_frag (left->X_add_symbol); 2578 right_frag = symbol_get_frag (right->X_add_symbol); 2579 2580 if (left_frag == right_frag) 2581 return ! left_frag->tc_frag_data; 2582 2583 result = true; 2584 for (frag = left_frag; frag != NULL; frag = frag->fr_next) 2585 { 2586 if (frag->tc_frag_data) 2587 result = false; 2588 if (frag == right_frag) 2589 break; 2590 } 2591 2592 if (frag == NULL) 2593 for (frag = right_frag; frag != NULL; frag = frag->fr_next) 2594 { 2595 if (frag->tc_frag_data) 2596 result = false; 2597 if (frag == left_frag) 2598 break; 2599 } 2600 2601 if (frag == NULL) 2602 /* The two symbols are on disjoint fragment chains 2603 - we cannot possibly compute their difference. */ 2604 return false; 2605 2606 return result; 2607 } 2608 2609 /* When relaxing, we need to output a reloc for any .align directive 2610 that requests alignment to a two byte boundary or larger. */ 2611 2612 void 2613 mn10300_handle_align (fragS *frag) 2614 { 2615 if (linkrelax 2616 && (frag->fr_type == rs_align 2617 || frag->fr_type == rs_align_code) 2618 && frag->fr_address + frag->fr_fix > 0 2619 && frag->fr_offset > 1 2620 && now_seg != bss_section 2621 /* Do not create relocs for the merging sections - such 2622 relocs will prevent the contents from being merged. */ 2623 && (bfd_section_flags (now_seg) & SEC_MERGE) == 0) 2624 /* Create a new fixup to record the alignment request. The symbol is 2625 irrelevant but must be present so we use the absolute section symbol. 2626 The offset from the symbol is used to record the power-of-two alignment 2627 value. The size is set to 0 because the frag may already be aligned, 2628 thus causing cvt_frag_to_fill to reduce the size of the frag to zero. */ 2629 fix_new (frag, frag->fr_fix, 0, & abs_symbol, frag->fr_offset, false, 2630 BFD_RELOC_MN10300_ALIGN); 2631 } 2632 2633 bool 2634 mn10300_force_relocation (struct fix * fixp) 2635 { 2636 if (linkrelax 2637 && (fixp->fx_pcrel 2638 || fixp->fx_r_type == BFD_RELOC_MN10300_ALIGN)) 2639 return true; 2640 2641 return generic_force_reloc (fixp); 2642 } 2643
Indexes created Fri Aug 21 00:24:51 UTC 2026