1 /* tc-mcore.c -- Assemble code for M*Core 2 Copyright 1999, 2000, 2001 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 2, 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, 59 Temple Place - Suite 330, Boston, MA 19 02111-1307, USA. */ 20 21 #include <stdio.h> 22 #include "as.h" 23 #include "bfd.h" 24 #include "subsegs.h" 25 #define DEFINE_TABLE 26 #include "../opcodes/mcore-opc.h" 27 #include <ctype.h> 28 #include <string.h> 29 30 #ifdef OBJ_ELF 31 #include "elf/mcore.h" 32 #endif 33 34 #ifndef streq 35 #define streq(a,b) (strcmp (a, b) == 0) 36 #endif 37 38 /* Forward declarations for dumb compilers. */ 39 static void mcore_s_literals PARAMS ((int)); 40 static void mcore_cons PARAMS ((int)); 41 static void mcore_float_cons PARAMS ((int)); 42 static void mcore_stringer PARAMS ((int)); 43 static void mcore_fill PARAMS ((int)); 44 static int log2 PARAMS ((unsigned int)); 45 static char * parse_reg PARAMS ((char *, unsigned *)); 46 static char * parse_creg PARAMS ((char *, unsigned *)); 47 static char * parse_exp PARAMS ((char *, expressionS *)); 48 static char * parse_rt PARAMS ((char *, char **, int, expressionS *)); 49 static char * parse_imm PARAMS ((char *, unsigned *, unsigned, unsigned)); 50 static char * parse_mem PARAMS ((char *, unsigned *, unsigned *, unsigned)); 51 static char * parse_psrmod PARAMS ((char *, unsigned *)); 52 static void make_name PARAMS ((char *, char *, int)); 53 static int enter_literal PARAMS ((expressionS *, int)); 54 static void dump_literals PARAMS ((int)); 55 static void check_literals PARAMS ((int, int)); 56 static void mcore_s_text PARAMS ((int)); 57 static void mcore_s_data PARAMS ((int)); 58 static void mcore_s_section PARAMS ((int)); 59 static void mcore_s_bss PARAMS ((int)); 60 #ifdef OBJ_ELF 61 static void mcore_s_comm PARAMS ((int)); 62 #endif 63 64 /* Several places in this file insert raw instructions into the 65 object. They should use MCORE_INST_XXX macros to get the opcodes 66 and then use these two macros to crack the MCORE_INST value into 67 the appropriate byte values. */ 68 #define INST_BYTE0(x) (target_big_endian ? (((x) >> 8) & 0xFF) : ((x) & 0xFF)) 69 #define INST_BYTE1(x) (target_big_endian ? ((x) & 0xFF) : (((x) >> 8) & 0xFF)) 70 71 const char comment_chars[] = "#/"; 72 const char line_separator_chars[] = ";"; 73 const char line_comment_chars[] = "#/"; 74 75 const int md_reloc_size = 8; 76 77 static int do_jsri2bsr = 0; /* Change here from 1 by Cruess 19 August 97. */ 78 static int sifilter_mode = 0; 79 80 const char EXP_CHARS[] = "eE"; 81 82 /* Chars that mean this number is a floating point constant 83 As in 0f12.456 84 or 0d1.2345e12 */ 85 const char FLT_CHARS[] = "rRsSfFdDxXpP"; 86 87 #define C(what,length) (((what) << 2) + (length)) 88 #define GET_WHAT(x) ((x >> 2)) 89 90 /* These are the two types of relaxable instruction */ 91 #define COND_JUMP 1 92 #define UNCD_JUMP 2 93 94 #define UNDEF_DISP 0 95 #define DISP12 1 96 #define DISP32 2 97 #define UNDEF_WORD_DISP 3 98 99 #define C12_LEN 2 100 #define C32_LEN 10 /* allow for align */ 101 #define U12_LEN 2 102 #define U32_LEN 8 /* allow for align */ 103 104 typedef enum 105 { 106 M210, 107 M340 108 } 109 cpu_type; 110 111 cpu_type cpu = M340; 112 113 /* Initialize the relax table. */ 114 const relax_typeS md_relax_table[] = { 115 { 0, 0, 0, 0 }, 116 { 0, 0, 0, 0 }, 117 { 0, 0, 0, 0 }, 118 { 0, 0, 0, 0 }, 119 120 /* COND_JUMP */ 121 { 0, 0, 0, 0 }, /* UNDEF_DISP */ 122 { 2048, -2046, C12_LEN, C(COND_JUMP, DISP32) }, /* DISP12 */ 123 { 0, 0, C32_LEN, 0 }, /* DISP32 */ 124 { 0, 0, C32_LEN, 0 }, /* UNDEF_WORD_DISP */ 125 126 /* UNCD_JUMP */ 127 { 0, 0, 0, 0 }, /* UNDEF_DISP */ 128 { 2048, -2046, U12_LEN, C(UNCD_JUMP, DISP32) }, /* DISP12 */ 129 { 0, 0, U32_LEN, 0 }, /* DISP32 */ 130 { 0, 0, U32_LEN, 0 } /* UNDEF_WORD_DISP */ 131 132 }; 133 134 /* Literal pool data structures. */ 135 struct literal 136 { 137 unsigned short refcnt; 138 unsigned char ispcrel; 139 unsigned char unused; 140 expressionS e; 141 }; 142 143 #define MAX_POOL_SIZE (1024/4) 144 static struct literal litpool [MAX_POOL_SIZE]; 145 static unsigned poolsize; 146 static unsigned poolnumber; 147 static unsigned long poolspan; 148 149 /* SPANPANIC: the point at which we get too scared and force a dump 150 of the literal pool, and perhaps put a branch in place. 151 Calculated as: 152 1024 span of lrw/jmpi/jsri insn (actually span+1) 153 -2 possible alignment at the insn. 154 -2 possible alignment to get the table aligned. 155 -2 an inserted branch around the table. 156 == 1018 157 at 1018, we might be in trouble. 158 -- so we have to be smaller than 1018 and since we deal with 2-byte 159 instructions, the next good choice is 1016. 160 -- Note we have a test case that fails when we've got 1018 here. */ 161 #define SPANPANIC (1016) /* 1024 - 1 entry - 2 byte rounding. */ 162 #define SPANCLOSE (900) 163 #define SPANEXIT (600) 164 static symbolS * poolsym; /* label for current pool. */ 165 static char poolname[8]; 166 static struct hash_control * opcode_hash_control; /* Opcode mnemonics. */ 167 168 /* This table describes all the machine specific pseudo-ops the assembler 169 has to support. The fields are: 170 Pseudo-op name without dot 171 Function to call to execute this pseudo-op 172 Integer arg to pass to the function. */ 173 const pseudo_typeS md_pseudo_table[] = 174 { 175 { "export", s_globl, 0 }, 176 { "import", s_ignore, 0 }, 177 { "literals", mcore_s_literals, 0 }, 178 { "page", listing_eject, 0 }, 179 180 /* The following are to intercept the placement of data into the text 181 section (eg addresses for a switch table), so that the space they 182 occupy can be taken into account when deciding whether or not to 183 dump the current literal pool. 184 XXX - currently we do not cope with the .space and .dcb.d directives. */ 185 { "ascii", mcore_stringer, 0 }, 186 { "asciz", mcore_stringer, 1 }, 187 { "byte", mcore_cons, 1 }, 188 { "dc", mcore_cons, 2 }, 189 { "dc.b", mcore_cons, 1 }, 190 { "dc.d", mcore_float_cons, 'd'}, 191 { "dc.l", mcore_cons, 4 }, 192 { "dc.s", mcore_float_cons, 'f'}, 193 { "dc.w", mcore_cons, 2 }, 194 { "dc.x", mcore_float_cons, 'x'}, 195 { "double", mcore_float_cons, 'd'}, 196 { "float", mcore_float_cons, 'f'}, 197 { "hword", mcore_cons, 2 }, 198 { "int", mcore_cons, 4 }, 199 { "long", mcore_cons, 4 }, 200 { "octa", mcore_cons, 16 }, 201 { "quad", mcore_cons, 8 }, 202 { "short", mcore_cons, 2 }, 203 { "single", mcore_float_cons, 'f'}, 204 { "string", mcore_stringer, 1 }, 205 { "word", mcore_cons, 2 }, 206 { "fill", mcore_fill, 0 }, 207 208 /* Allow for the effect of section changes. */ 209 { "text", mcore_s_text, 0 }, 210 { "data", mcore_s_data, 0 }, 211 { "bss", mcore_s_bss, 1 }, 212 #ifdef OBJ_EF 213 { "comm", mcore_s_comm, 0 }, 214 #endif 215 { "section", mcore_s_section, 0 }, 216 { "section.s", mcore_s_section, 0 }, 217 { "sect", mcore_s_section, 0 }, 218 { "sect.s", mcore_s_section, 0 }, 219 220 { 0, 0, 0 } 221 }; 222 223 static void 224 mcore_s_literals (ignore) 225 int ignore; 226 { 227 dump_literals (0); 228 demand_empty_rest_of_line (); 229 } 230 231 static void 232 mcore_cons (nbytes) 233 int nbytes; 234 { 235 if (now_seg == text_section) 236 { 237 char * ptr = input_line_pointer; 238 int commas = 1; 239 240 /* Count the number of commas on the line. */ 241 while (! is_end_of_line [(unsigned char) * ptr]) 242 commas += * ptr ++ == ','; 243 244 poolspan += nbytes * commas; 245 } 246 247 cons (nbytes); 248 249 /* In theory we ought to call check_literals (2,0) here in case 250 we need to dump the literal table. We cannot do this however, 251 as the directives that we are intercepting may be being used 252 to build a switch table, and we must not interfere with its 253 contents. Instead we cross our fingers and pray... */ 254 } 255 256 static void 257 mcore_float_cons (float_type) 258 int float_type; 259 { 260 if (now_seg == text_section) 261 { 262 char * ptr = input_line_pointer; 263 int commas = 1; 264 265 #ifdef REPEAT_CONS_EXPRESSIONS 266 #error REPEAT_CONS_EXPRESSIONS not handled 267 #endif 268 269 /* Count the number of commas on the line. */ 270 while (! is_end_of_line [(unsigned char) * ptr]) 271 commas += * ptr ++ == ','; 272 273 /* We would like to compute "hex_float (float_type) * commas" 274 but hex_float is not exported from read.c */ 275 float_type == 'f' ? 4 : (float_type == 'd' ? 8 : 12); 276 poolspan += float_type * commas; 277 } 278 279 float_cons (float_type); 280 281 /* See the comment in mcore_cons () about calling check_literals. 282 It is unlikely that a switch table will be constructed using 283 floating point values, but it is still likely that an indexed 284 table of floating point constants is being created by these 285 directives, so again we must not interfere with their placement. */ 286 } 287 288 static void 289 mcore_stringer (append_zero) 290 int append_zero; 291 { 292 if (now_seg == text_section) 293 { 294 char * ptr = input_line_pointer; 295 296 /* In theory we should compute how many bytes are going to 297 be occupied by the string(s) and add this to the poolspan. 298 To keep things simple however, we just add the number of 299 bytes left on the current line. This will be an over- 300 estimate, which is OK, and automatically allows for the 301 appending a zero byte, since the real string(s) is/are 302 required to be enclosed in double quotes. */ 303 while (! is_end_of_line [(unsigned char) * ptr]) 304 ptr ++; 305 306 poolspan += ptr - input_line_pointer; 307 } 308 309 stringer (append_zero); 310 311 /* We call check_literals here in case a large number of strings are 312 being placed into the text section with a sequence of stringer 313 directives. In theory we could be upsetting something if these 314 strings are actually in an indexed table instead of referenced by 315 individual labels. Let us hope that that never happens. */ 316 check_literals (2, 0); 317 } 318 319 static void 320 mcore_fill (unused) 321 int unused; 322 { 323 if (now_seg == text_section) 324 { 325 char * str = input_line_pointer; 326 int size = 1; 327 int repeat; 328 329 repeat = atoi (str); 330 331 /* Look to see if a size has been specified. */ 332 while (*str != '\n' && *str != 0 && *str != ',') 333 ++ str; 334 335 if (* str == ',') 336 { 337 size = atoi (str + 1); 338 339 if (size > 8) 340 size = 8; 341 else if (size < 0) 342 size = 0; 343 } 344 345 poolspan += size * repeat; 346 } 347 348 s_fill (unused); 349 350 check_literals (2, 0); 351 } 352 353 /* Handle the section changing pseudo-ops. These call through to the 354 normal implementations, but they dump the literal pool first. */ 355 static void 356 mcore_s_text (ignore) 357 int ignore; 358 { 359 dump_literals (0); 360 361 #ifdef OBJ_ELF 362 obj_elf_text (ignore); 363 #else 364 s_text (ignore); 365 #endif 366 } 367 368 static void 369 mcore_s_data (ignore) 370 int ignore; 371 { 372 dump_literals (0); 373 374 #ifdef OBJ_ELF 375 obj_elf_data (ignore); 376 #else 377 s_data (ignore); 378 #endif 379 } 380 381 static void 382 mcore_s_section (ignore) 383 int ignore; 384 { 385 /* Scan forwards to find the name of the section. If the section 386 being switched to is ".line" then this is a DWARF1 debug section 387 which is arbitarily placed inside generated code. In this case 388 do not dump the literal pool because it is a) inefficient and 389 b) would require the generation of extra code to jump around the 390 pool. */ 391 char * ilp = input_line_pointer; 392 393 while (*ilp != 0 && isspace(*ilp)) 394 ++ ilp; 395 396 if (strncmp (ilp, ".line", 5) == 0 397 && (isspace (ilp[5]) || *ilp == '\n' || *ilp == '\r')) 398 ; 399 else 400 dump_literals (0); 401 402 #ifdef OBJ_ELF 403 obj_elf_section (ignore); 404 #endif 405 #ifdef OBJ_COFF 406 obj_coff_section (ignore); 407 #endif 408 } 409 410 static void 411 mcore_s_bss (needs_align) 412 int needs_align; 413 { 414 dump_literals (0); 415 416 s_lcomm_bytes (needs_align); 417 } 418 419 #ifdef OBJ_ELF 420 static void 421 mcore_s_comm (needs_align) 422 int needs_align; 423 { 424 dump_literals (0); 425 426 obj_elf_common (needs_align); 427 } 428 #endif 429 430 /* This function is called once, at assembler startup time. This should 431 set up all the tables, etc that the MD part of the assembler needs. */ 432 void 433 md_begin () 434 { 435 mcore_opcode_info * opcode; 436 char * prev_name = ""; 437 438 opcode_hash_control = hash_new (); 439 440 /* Insert unique names into hash table */ 441 for (opcode = mcore_table; opcode->name; opcode ++) 442 { 443 if (streq (prev_name, opcode->name)) 444 { 445 /* Make all the opcodes with the same name point to the same 446 string. */ 447 opcode->name = prev_name; 448 } 449 else 450 { 451 prev_name = opcode->name; 452 hash_insert (opcode_hash_control, opcode->name, (char *) opcode); 453 } 454 } 455 } 456 457 static int reg_m; 458 static int reg_n; 459 static expressionS immediate; /* absolute expression */ 460 461 /* Get a log2(val). */ 462 static int 463 log2 (val) 464 unsigned int val; 465 { 466 int log = -1; 467 while (val != 0) 468 { 469 log ++; 470 val >>= 1; 471 } 472 473 return log; 474 } 475 476 /* Try to parse a reg name. */ 477 static char * 478 parse_reg (s, reg) 479 char * s; 480 unsigned * reg; 481 { 482 /* Strip leading whitespace. */ 483 while (isspace (* s)) 484 ++ s; 485 486 if (tolower (s[0]) == 'r') 487 { 488 if (s[1] == '1' && s[2] >= '0' && s[2] <= '5') 489 { 490 *reg = 10 + s[2] - '0'; 491 return s + 3; 492 } 493 494 if (s[1] >= '0' && s[1] <= '9') 495 { 496 *reg = s[1] - '0'; 497 return s + 2; 498 } 499 } 500 else if ( tolower (s[0]) == 's' 501 && tolower (s[1]) == 'p' 502 && ! isalnum (s[2])) 503 { 504 * reg = 0; 505 return s + 2; 506 } 507 508 as_bad (_("register expected, but saw '%.6s'"), s); 509 return s; 510 } 511 512 static struct Cregs 513 { 514 char * name; 515 unsigned int crnum; 516 } 517 cregs[] = 518 { 519 { "psr", 0}, 520 { "vbr", 1}, 521 { "epsr", 2}, 522 { "fpsr", 3}, 523 { "epc", 4}, 524 { "fpc", 5}, 525 { "ss0", 6}, 526 { "ss1", 7}, 527 { "ss2", 8}, 528 { "ss3", 9}, 529 { "ss4", 10}, 530 { "gcr", 11}, 531 { "gsr", 12}, 532 { "", 0} 533 }; 534 535 static char * 536 parse_creg (s, reg) 537 char * s; 538 unsigned * reg; 539 { 540 int i; 541 542 /* Strip leading whitespace. */ 543 while (isspace (* s)) 544 ++s; 545 546 if ((tolower (s[0]) == 'c' && tolower (s[1]) == 'r')) 547 { 548 if (s[2] == '3' && s[3] >= '0' && s[3] <= '1') 549 { 550 *reg = 30 + s[3] - '0'; 551 return s + 4; 552 } 553 554 if (s[2] == '2' && s[3] >= '0' && s[3] <= '9') 555 { 556 *reg = 20 + s[3] - '0'; 557 return s + 4; 558 } 559 560 if (s[2] == '1' && s[3] >= '0' && s[3] <= '9') 561 { 562 *reg = 10 + s[3] - '0'; 563 return s + 4; 564 } 565 566 if (s[2] >= '0' && s[2] <= '9') 567 { 568 *reg = s[2] - '0'; 569 return s + 3; 570 } 571 } 572 573 /* Look at alternate creg names before giving error. */ 574 for (i = 0; cregs[i].name[0] != '\0'; i++) 575 { 576 char buf [10]; 577 int length; 578 int j; 579 580 length = strlen (cregs[i].name); 581 582 for (j = 0; j < length; j++) 583 buf[j] = tolower (s[j]); 584 585 if (strncmp (cregs[i].name, buf, length) == 0) 586 { 587 *reg = cregs[i].crnum; 588 return s + length; 589 } 590 } 591 592 as_bad (_("control register expected, but saw '%.6s'"), s); 593 594 return s; 595 } 596 597 static char * 598 parse_psrmod (s, reg) 599 char * s; 600 unsigned * reg; 601 { 602 int i; 603 char buf[10]; 604 static struct psrmods 605 { 606 char * name; 607 unsigned int value; 608 } 609 psrmods[] = 610 { 611 { "ie", 1 }, 612 { "fe", 2 }, 613 { "ee", 4 }, 614 { "af", 8 } /* Really 0 and non-combinable. */ 615 }; 616 617 for (i = 0; i < 2; i++) 618 buf[i] = isascii (s[i]) ? tolower (s[i]) : 0; 619 620 for (i = sizeof (psrmods) / sizeof (psrmods[0]); i--;) 621 { 622 if (! strncmp (psrmods[i].name, buf, 2)) 623 { 624 * reg = psrmods[i].value; 625 626 return s + 2; 627 } 628 } 629 630 as_bad (_("bad/missing psr specifier")); 631 632 * reg = 0; 633 634 return s; 635 } 636 637 static char * 638 parse_exp (s, e) 639 char * s; 640 expressionS * e; 641 { 642 char * save; 643 char * new; 644 645 /* Skip whitespace. */ 646 while (isspace (* s)) 647 ++ s; 648 649 save = input_line_pointer; 650 input_line_pointer = s; 651 652 expression (e); 653 654 if (e->X_op == O_absent) 655 as_bad (_("missing operand")); 656 657 new = input_line_pointer; 658 input_line_pointer = save; 659 660 return new; 661 } 662 663 static void 664 make_name (s, p, n) 665 char * s; 666 char * p; 667 int n; 668 { 669 static const char hex[] = "0123456789ABCDEF"; 670 671 s[0] = p[0]; 672 s[1] = p[1]; 673 s[2] = p[2]; 674 s[3] = hex[(n >> 12) & 0xF]; 675 s[4] = hex[(n >> 8) & 0xF]; 676 s[5] = hex[(n >> 4) & 0xF]; 677 s[6] = hex[(n) & 0xF]; 678 s[7] = 0; 679 } 680 681 #define POOL_END_LABEL ".LE" 682 #define POOL_START_LABEL ".LS" 683 684 static void 685 dump_literals (isforce) 686 int isforce; 687 { 688 int i; 689 struct literal * p; 690 symbolS * brarsym; 691 692 if (poolsize == 0) 693 return; 694 695 /* Must we branch around the literal table? */ 696 if (isforce) 697 { 698 char * output; 699 char brarname[8]; 700 701 make_name (brarname, POOL_END_LABEL, poolnumber); 702 703 brarsym = symbol_make (brarname); 704 705 symbol_table_insert (brarsym); 706 707 output = frag_var (rs_machine_dependent, 708 md_relax_table[C (UNCD_JUMP, DISP32)].rlx_length, 709 md_relax_table[C (UNCD_JUMP, DISP12)].rlx_length, 710 C (UNCD_JUMP, 0), brarsym, 0, 0); 711 output[0] = INST_BYTE0 (MCORE_INST_BR); /* br .+xxx */ 712 output[1] = INST_BYTE1 (MCORE_INST_BR); 713 } 714 715 /* Make sure that the section is sufficiently aligned and that 716 the literal table is aligned within it. */ 717 record_alignment (now_seg, 2); 718 frag_align (2, 0, 0); 719 720 colon (S_GET_NAME (poolsym)); 721 722 for (i = 0, p = litpool; i < poolsize; i++, p++) 723 emit_expr (& p->e, 4); 724 725 if (isforce) 726 colon (S_GET_NAME (brarsym)); 727 728 poolsize = 0; 729 } 730 731 static void 732 check_literals (kind, offset) 733 int kind; 734 int offset; 735 { 736 poolspan += offset; 737 738 /* SPANCLOSE and SPANEXIT are smaller numbers than SPANPANIC. 739 SPANPANIC means that we must dump now. 740 kind == 0 is any old instruction. 741 kind > 0 means we just had a control transfer instruction. 742 kind == 1 means within a function 743 kind == 2 means we just left a function 744 745 The dump_literals (1) call inserts a branch around the table, so 746 we first look to see if its a situation where we won't have to 747 insert a branch (e.g., the previous instruction was an unconditional 748 branch). 749 750 SPANPANIC is the point where we must dump a single-entry pool. 751 it accounts for alignments and an inserted branch. 752 the 'poolsize*2' accounts for the scenario where we do: 753 lrw r1,lit1; lrw r2,lit2; lrw r3,lit3 754 Note that the 'lit2' reference is 2 bytes further along 755 but the literal it references will be 4 bytes further along, 756 so we must consider the poolsize into this equation. 757 This is slightly over-cautious, but guarantees that we won't 758 panic because a relocation is too distant. */ 759 760 if (poolspan > SPANCLOSE && kind > 0) 761 dump_literals (0); 762 else if (poolspan > SPANEXIT && kind > 1) 763 dump_literals (0); 764 else if (poolspan >= (SPANPANIC - poolsize * 2)) 765 dump_literals (1); 766 } 767 768 static int 769 enter_literal (e, ispcrel) 770 expressionS * e; 771 int ispcrel; 772 { 773 int i; 774 struct literal * p; 775 776 if (poolsize >= MAX_POOL_SIZE - 2) 777 { 778 /* The literal pool is as full as we can handle. We have 779 to be 2 entries shy of the 1024/4=256 entries because we 780 have to allow for the branch (2 bytes) and the alignment 781 (2 bytes before the first insn referencing the pool and 782 2 bytes before the pool itself) == 6 bytes, rounds up 783 to 2 entries. */ 784 dump_literals (1); 785 } 786 787 if (poolsize == 0) 788 { 789 /* Create new literal pool. */ 790 if (++ poolnumber > 0xFFFF) 791 as_fatal (_("more than 65K literal pools")); 792 793 make_name (poolname, POOL_START_LABEL, poolnumber); 794 poolsym = symbol_make (poolname); 795 symbol_table_insert (poolsym); 796 poolspan = 0; 797 } 798 799 /* Search pool for value so we don't have duplicates. */ 800 for (p = litpool, i = 0; i < poolsize; i++, p++) 801 { 802 if (e->X_op == p->e.X_op 803 && e->X_add_symbol == p->e.X_add_symbol 804 && e->X_add_number == p->e.X_add_number 805 && ispcrel == p->ispcrel) 806 { 807 p->refcnt ++; 808 return i; 809 } 810 } 811 812 p->refcnt = 1; 813 p->ispcrel = ispcrel; 814 p->e = * e; 815 816 poolsize ++; 817 818 return i; 819 } 820 821 /* Parse a literal specification. -- either new or old syntax. 822 old syntax: the user supplies the label and places the literal. 823 new syntax: we put it into the literal pool. */ 824 static char * 825 parse_rt (s, outputp, ispcrel, ep) 826 char * s; 827 char ** outputp; 828 int ispcrel; 829 expressionS * ep; 830 { 831 expressionS e; 832 int n; 833 834 if (ep) 835 /* Indicate nothing there. */ 836 ep->X_op = O_absent; 837 838 if (*s == '[') 839 { 840 s = parse_exp (s + 1, & e); 841 842 if (*s == ']') 843 s++; 844 else 845 as_bad (_("missing ']'")); 846 } 847 else 848 { 849 s = parse_exp (s, & e); 850 851 n = enter_literal (& e, ispcrel); 852 853 if (ep) 854 *ep = e; 855 856 /* Create a reference to pool entry. */ 857 e.X_op = O_symbol; 858 e.X_add_symbol = poolsym; 859 e.X_add_number = n << 2; 860 } 861 862 * outputp = frag_more (2); 863 864 fix_new_exp (frag_now, (*outputp) - frag_now->fr_literal, 2, & e, 1, 865 BFD_RELOC_MCORE_PCREL_IMM8BY4); 866 867 return s; 868 } 869 870 static char * 871 parse_imm (s, val, min, max) 872 char * s; 873 unsigned * val; 874 unsigned min; 875 unsigned max; 876 { 877 char * new; 878 expressionS e; 879 880 new = parse_exp (s, & e); 881 882 if (e.X_op == O_absent) 883 ; /* An error message has already been emitted. */ 884 else if (e.X_op != O_constant) 885 as_bad (_("operand must be a constant")); 886 else if (e.X_add_number < min || e.X_add_number > max) 887 as_bad (_("operand must be absolute in range %d..%d, not %d"), 888 min, max, e.X_add_number); 889 890 * val = e.X_add_number; 891 892 return new; 893 } 894 895 static char * 896 parse_mem (s, reg, off, siz) 897 char * s; 898 unsigned * reg; 899 unsigned * off; 900 unsigned siz; 901 { 902 char * new; 903 904 * off = 0; 905 906 while (isspace (* s)) 907 ++ s; 908 909 if (* s == '(') 910 { 911 s = parse_reg (s + 1, reg); 912 913 while (isspace (* s)) 914 ++ s; 915 916 if (* s == ',') 917 { 918 s = parse_imm (s + 1, off, 0, 63); 919 920 if (siz > 1) 921 { 922 if (siz > 2) 923 { 924 if (* off & 0x3) 925 as_bad (_("operand must be a multiple of 4")); 926 927 * off >>= 2; 928 } 929 else 930 { 931 if (* off & 0x1) 932 as_bad (_("operand must be a multiple of 2")); 933 934 * off >>= 1; 935 } 936 } 937 } 938 939 while (isspace (* s)) 940 ++ s; 941 942 if (* s == ')') 943 s ++; 944 } 945 else 946 as_bad (_("base register expected")); 947 948 return s; 949 } 950 951 /* This is the guts of the machine-dependent assembler. STR points to a 952 machine dependent instruction. This function is supposed to emit 953 the frags/bytes it assembles to. */ 954 955 void 956 md_assemble (str) 957 char * str; 958 { 959 char * op_start; 960 char * op_end; 961 mcore_opcode_info * opcode; 962 char * output; 963 int nlen = 0; 964 unsigned short inst; 965 unsigned reg; 966 unsigned off; 967 unsigned isize; 968 expressionS e; 969 char name[20]; 970 971 /* Drop leading whitespace. */ 972 while (isspace (* str)) 973 str ++; 974 975 /* Find the op code end. */ 976 for (op_start = op_end = str; 977 nlen < 20 && !is_end_of_line [(unsigned char) *op_end] && *op_end != ' '; 978 op_end++) 979 { 980 name[nlen] = op_start[nlen]; 981 nlen++; 982 } 983 984 name [nlen] = 0; 985 986 if (nlen == 0) 987 { 988 as_bad (_("can't find opcode ")); 989 return; 990 } 991 992 opcode = (mcore_opcode_info *) hash_find (opcode_hash_control, name); 993 if (opcode == NULL) 994 { 995 as_bad (_("unknown opcode \"%s\""), name); 996 return; 997 } 998 999 inst = opcode->inst; 1000 isize = 2; 1001 1002 switch (opcode->opclass) 1003 { 1004 case O0: 1005 output = frag_more (2); 1006 break; 1007 1008 case OT: 1009 op_end = parse_imm (op_end + 1, & reg, 0, 3); 1010 inst |= reg; 1011 output = frag_more (2); 1012 break; 1013 1014 case O1: 1015 op_end = parse_reg (op_end + 1, & reg); 1016 inst |= reg; 1017 output = frag_more (2); 1018 break; 1019 1020 case JMP: 1021 op_end = parse_reg (op_end + 1, & reg); 1022 inst |= reg; 1023 output = frag_more (2); 1024 /* In a sifilter mode, we emit this insn 2 times, 1025 fixes problem of an interrupt during a jmp.. */ 1026 if (sifilter_mode) 1027 { 1028 output[0] = INST_BYTE0 (inst); 1029 output[1] = INST_BYTE1 (inst); 1030 output = frag_more (2); 1031 } 1032 break; 1033 1034 case JSR: 1035 op_end = parse_reg (op_end + 1, & reg); 1036 1037 if (reg == 15) 1038 as_bad (_("invalid register: r15 illegal")); 1039 1040 inst |= reg; 1041 output = frag_more (2); 1042 1043 if (sifilter_mode) 1044 { 1045 /* Replace with: bsr .+2 ; addi r15,6; jmp rx ; jmp rx */ 1046 inst = MCORE_INST_BSR; /* with 0 displacement */ 1047 output[0] = INST_BYTE0 (inst); 1048 output[1] = INST_BYTE1 (inst); 1049 1050 output = frag_more (2); 1051 inst = MCORE_INST_ADDI; 1052 inst |= 15; /* addi r15,6 */ 1053 inst |= (6 - 1) << 4; /* over the jmp's */ 1054 output[0] = INST_BYTE0 (inst); 1055 output[1] = INST_BYTE1 (inst); 1056 1057 output = frag_more (2); 1058 inst = MCORE_INST_JMP | reg; 1059 output[0] = INST_BYTE0 (inst); 1060 output[1] = INST_BYTE1 (inst); 1061 1062 output = frag_more (2); /* 2nd emitted in fallthru */ 1063 } 1064 break; 1065 1066 case OC: 1067 op_end = parse_reg (op_end + 1, & reg); 1068 inst |= reg; 1069 1070 /* Skip whitespace. */ 1071 while (isspace (* op_end)) 1072 ++ op_end; 1073 1074 if (*op_end == ',') 1075 { 1076 op_end = parse_creg (op_end + 1, & reg); 1077 inst |= reg << 4; 1078 } 1079 1080 output = frag_more (2); 1081 break; 1082 1083 case MULSH: 1084 if (cpu == M210) 1085 { 1086 as_bad (_("M340 specific opcode used when assembling for M210")); 1087 break; 1088 } 1089 /* drop through... */ 1090 case O2: 1091 op_end = parse_reg (op_end + 1, & reg); 1092 inst |= reg; 1093 1094 /* Skip whitespace. */ 1095 while (isspace (* op_end)) 1096 ++ op_end; 1097 1098 if (* op_end == ',') 1099 { 1100 op_end = parse_reg (op_end + 1, & reg); 1101 inst |= reg << 4; 1102 } 1103 else 1104 as_bad (_("second operand missing")); 1105 1106 output = frag_more (2); 1107 break; 1108 1109 case X1: /* Handle both syntax-> xtrb- r1,rx OR xtrb- rx */ 1110 op_end = parse_reg (op_end + 1, & reg); 1111 1112 /* Skip whitespace. */ 1113 while (isspace (* op_end)) 1114 ++ op_end; 1115 1116 if (* op_end == ',') /* xtrb- r1,rx */ 1117 { 1118 if (reg != 1) 1119 as_bad (_("destination register must be r1")); 1120 1121 op_end = parse_reg (op_end + 1, & reg); 1122 } 1123 1124 inst |= reg; 1125 output = frag_more (2); 1126 break; 1127 1128 case O1R1: /* div- rx,r1 */ 1129 op_end = parse_reg (op_end + 1, & reg); 1130 inst |= reg; 1131 1132 /* Skip whitespace. */ 1133 while (isspace (* op_end)) 1134 ++ op_end; 1135 1136 if (* op_end == ',') 1137 { 1138 op_end = parse_reg (op_end + 1, & reg); 1139 if (reg != 1) 1140 as_bad (_("source register must be r1")); 1141 } 1142 else 1143 as_bad (_("second operand missing")); 1144 1145 output = frag_more (2); 1146 break; 1147 1148 case OI: 1149 op_end = parse_reg (op_end + 1, & reg); 1150 inst |= reg; 1151 1152 /* Skip whitespace. */ 1153 while (isspace (* op_end)) 1154 ++ op_end; 1155 1156 if (* op_end == ',') 1157 { 1158 op_end = parse_imm (op_end + 1, & reg, 1, 32); 1159 inst |= (reg - 1) << 4; 1160 } 1161 else 1162 as_bad (_("second operand missing")); 1163 1164 output = frag_more (2); 1165 break; 1166 1167 case OB: 1168 op_end = parse_reg (op_end + 1, & reg); 1169 inst |= reg; 1170 1171 /* Skip whitespace. */ 1172 while (isspace (* op_end)) 1173 ++ op_end; 1174 1175 if (* op_end == ',') 1176 { 1177 op_end = parse_imm (op_end + 1, & reg, 0, 31); 1178 inst |= reg << 4; 1179 } 1180 else 1181 as_bad (_("second operand missing")); 1182 1183 output = frag_more (2); 1184 break; 1185 1186 case OB2: /* like OB, but arg is 2^n instead of n */ 1187 op_end = parse_reg (op_end + 1, & reg); 1188 inst |= reg; 1189 1190 /* Skip whitespace. */ 1191 while (isspace (* op_end)) 1192 ++ op_end; 1193 1194 if (* op_end == ',') 1195 { 1196 op_end = parse_imm (op_end + 1, & reg, 1, 1 << 31); 1197 /* Further restrict the immediate to a power of two. */ 1198 if ((reg & (reg - 1)) == 0) 1199 reg = log2 (reg); 1200 else 1201 { 1202 reg = 0; 1203 as_bad (_("immediate is not a power of two")); 1204 } 1205 inst |= (reg) << 4; 1206 } 1207 else 1208 as_bad (_("second operand missing")); 1209 1210 output = frag_more (2); 1211 break; 1212 1213 case OBRa: /* Specific for bgeni: imm of 0->6 translate to movi. */ 1214 case OBRb: 1215 case OBRc: 1216 op_end = parse_reg (op_end + 1, & reg); 1217 inst |= reg; 1218 1219 /* Skip whitespace. */ 1220 while (isspace (* op_end)) 1221 ++ op_end; 1222 1223 if (* op_end == ',') 1224 { 1225 op_end = parse_imm (op_end + 1, & reg, 0, 31); 1226 /* immediate values of 0 -> 6 translate to movi */ 1227 if (reg <= 6) 1228 { 1229 inst = (inst & 0xF) | MCORE_INST_BGENI_ALT; 1230 reg = 0x1 << reg; 1231 as_warn (_("translating bgeni to movi")); 1232 } 1233 inst &= ~ 0x01f0; 1234 inst |= reg << 4; 1235 } 1236 else 1237 as_bad (_("second operand missing")); 1238 1239 output = frag_more (2); 1240 break; 1241 1242 case OBR2: /* like OBR, but arg is 2^n instead of n */ 1243 op_end = parse_reg (op_end + 1, & reg); 1244 inst |= reg; 1245 1246 /* Skip whitespace. */ 1247 while (isspace (* op_end)) 1248 ++ op_end; 1249 1250 if (* op_end == ',') 1251 { 1252 op_end = parse_imm (op_end + 1, & reg, 1, 1 << 31); 1253 1254 /* Further restrict the immediate to a power of two. */ 1255 if ((reg & (reg - 1)) == 0) 1256 reg = log2 (reg); 1257 else 1258 { 1259 reg = 0; 1260 as_bad (_("immediate is not a power of two")); 1261 } 1262 1263 /* Immediate values of 0 -> 6 translate to movi. */ 1264 if (reg <= 6) 1265 { 1266 inst = (inst & 0xF) | MCORE_INST_BGENI_ALT; 1267 reg = 0x1 << reg; 1268 as_warn (_("translating mgeni to movi")); 1269 } 1270 1271 inst |= reg << 4; 1272 } 1273 else 1274 as_bad (_("second operand missing")); 1275 1276 output = frag_more (2); 1277 break; 1278 1279 case OMa: /* Specific for bmaski: imm 1->7 translate to movi. */ 1280 case OMb: 1281 case OMc: 1282 op_end = parse_reg (op_end + 1, & reg); 1283 inst |= reg; 1284 1285 /* Skip whitespace. */ 1286 while (isspace (* op_end)) 1287 ++ op_end; 1288 1289 if (* op_end == ',') 1290 { 1291 op_end = parse_imm (op_end + 1, & reg, 1, 32); 1292 1293 /* Immediate values of 1 -> 7 translate to movi. */ 1294 if (reg <= 7) 1295 { 1296 inst = (inst & 0xF) | MCORE_INST_BMASKI_ALT; 1297 reg = (0x1 << reg) - 1; 1298 inst |= reg << 4; 1299 1300 as_warn (_("translating bmaski to movi")); 1301 } 1302 else 1303 { 1304 inst &= ~ 0x01F0; 1305 inst |= (reg & 0x1F) << 4; 1306 } 1307 } 1308 else 1309 as_bad (_("second operand missing")); 1310 1311 output = frag_more (2); 1312 break; 1313 1314 case SI: 1315 op_end = parse_reg (op_end + 1, & reg); 1316 inst |= reg; 1317 1318 /* Skip whitespace. */ 1319 while (isspace (* op_end)) 1320 ++ op_end; 1321 1322 if (* op_end == ',') 1323 { 1324 op_end = parse_imm (op_end + 1, & reg, 1, 31); 1325 inst |= reg << 4; 1326 } 1327 else 1328 as_bad (_("second operand missing")); 1329 1330 output = frag_more (2); 1331 break; 1332 1333 case I7: 1334 op_end = parse_reg (op_end + 1, & reg); 1335 inst |= reg; 1336 1337 /* Skip whitespace. */ 1338 while (isspace (* op_end)) 1339 ++ op_end; 1340 1341 if (* op_end == ',') 1342 { 1343 op_end = parse_imm (op_end + 1, & reg, 0, 0x7F); 1344 inst |= reg << 4; 1345 } 1346 else 1347 as_bad (_("second operand missing")); 1348 1349 output = frag_more (2); 1350 break; 1351 1352 case LS: 1353 op_end = parse_reg (op_end + 1, & reg); 1354 inst |= reg << 8; 1355 1356 /* Skip whitespace. */ 1357 while (isspace (* op_end)) 1358 ++ op_end; 1359 1360 if (* op_end == ',') 1361 { 1362 int size; 1363 1364 if ((inst & 0x6000) == 0) 1365 size = 4; 1366 else if ((inst & 0x6000) == 0x4000) 1367 size = 2; 1368 else if ((inst & 0x6000) == 0x2000) 1369 size = 1; 1370 1371 op_end = parse_mem (op_end + 1, & reg, & off, size); 1372 1373 if (off > 16) 1374 as_bad (_("displacement too large (%d)"), off); 1375 else 1376 inst |= (reg) | (off << 4); 1377 } 1378 else 1379 as_bad (_("second operand missing")); 1380 1381 output = frag_more (2); 1382 break; 1383 1384 case LR: 1385 op_end = parse_reg (op_end + 1, & reg); 1386 1387 if (reg == 0 || reg == 15) 1388 as_bad (_("Invalid register: r0 and r15 illegal")); 1389 1390 inst |= (reg << 8); 1391 1392 /* Skip whitespace. */ 1393 while (isspace (* op_end)) 1394 ++ op_end; 1395 1396 if (* op_end == ',') 1397 { 1398 /* parse_rt calls frag_more() for us. */ 1399 input_line_pointer = parse_rt (op_end + 1, & output, 0, 0); 1400 op_end = input_line_pointer; 1401 } 1402 else 1403 { 1404 as_bad (_("second operand missing")); 1405 output = frag_more (2); /* save its space */ 1406 } 1407 break; 1408 1409 case LJ: 1410 input_line_pointer = parse_rt (op_end + 1, & output, 1, 0); 1411 /* parse_rt() calls frag_more() for us. */ 1412 op_end = input_line_pointer; 1413 break; 1414 1415 case RM: 1416 op_end = parse_reg (op_end + 1, & reg); 1417 1418 if (reg == 0 || reg == 15) 1419 as_bad (_("bad starting register: r0 and r15 invalid")); 1420 1421 inst |= reg; 1422 1423 /* Skip whitespace. */ 1424 while (isspace (* op_end)) 1425 ++ op_end; 1426 1427 if (* op_end == '-') 1428 { 1429 op_end = parse_reg (op_end + 1, & reg); 1430 1431 if (reg != 15) 1432 as_bad (_("ending register must be r15")); 1433 1434 /* Skip whitespace. */ 1435 while (isspace (* op_end)) 1436 ++ op_end; 1437 } 1438 1439 if (* op_end == ',') 1440 { 1441 op_end ++; 1442 1443 /* Skip whitespace. */ 1444 while (isspace (* op_end)) 1445 ++ op_end; 1446 1447 if (* op_end == '(') 1448 { 1449 op_end = parse_reg (op_end + 1, & reg); 1450 1451 if (reg != 0) 1452 as_bad (_("bad base register: must be r0")); 1453 1454 if (* op_end == ')') 1455 op_end ++; 1456 } 1457 else 1458 as_bad (_("base register expected")); 1459 } 1460 else 1461 as_bad (_("second operand missing")); 1462 1463 output = frag_more (2); 1464 break; 1465 1466 case RQ: 1467 op_end = parse_reg (op_end + 1, & reg); 1468 1469 if (reg != 4) 1470 as_fatal (_("first register must be r4")); 1471 1472 /* Skip whitespace. */ 1473 while (isspace (* op_end)) 1474 ++ op_end; 1475 1476 if (* op_end == '-') 1477 { 1478 op_end = parse_reg (op_end + 1, & reg); 1479 1480 if (reg != 7) 1481 as_fatal (_("last register must be r7")); 1482 1483 /* Skip whitespace. */ 1484 while (isspace (* op_end)) 1485 ++ op_end; 1486 1487 if (* op_end == ',') 1488 { 1489 op_end ++; 1490 1491 /* Skip whitespace. */ 1492 while (isspace (* op_end)) 1493 ++ op_end; 1494 1495 if (* op_end == '(') 1496 { 1497 op_end = parse_reg (op_end + 1, & reg); 1498 1499 if (reg >= 4 && reg <= 7) 1500 as_fatal ("base register cannot be r4, r5, r6, or r7"); 1501 1502 inst |= reg; 1503 1504 /* Skip whitespace. */ 1505 while (isspace (* op_end)) 1506 ++ op_end; 1507 1508 if (* op_end == ')') 1509 op_end ++; 1510 } 1511 else 1512 as_bad (_("base register expected")); 1513 } 1514 else 1515 as_bad (_("second operand missing")); 1516 } 1517 else 1518 as_bad (_("reg-reg expected")); 1519 1520 output = frag_more (2); 1521 break; 1522 1523 case BR: 1524 input_line_pointer = parse_exp (op_end + 1, & e); 1525 op_end = input_line_pointer; 1526 1527 output = frag_more (2); 1528 1529 fix_new_exp (frag_now, output-frag_now->fr_literal, 1530 2, & e, 1, BFD_RELOC_MCORE_PCREL_IMM11BY2); 1531 break; 1532 1533 case BL: 1534 op_end = parse_reg (op_end + 1, & reg); 1535 inst |= reg << 4; 1536 1537 /* Skip whitespace. */ 1538 while (isspace (* op_end)) 1539 ++ op_end; 1540 1541 if (* op_end == ',') 1542 { 1543 op_end = parse_exp (op_end + 1, & e); 1544 output = frag_more (2); 1545 1546 fix_new_exp (frag_now, output-frag_now->fr_literal, 1547 2, & e, 1, BFD_RELOC_MCORE_PCREL_IMM4BY2); 1548 } 1549 else 1550 { 1551 as_bad (_("second operand missing")); 1552 output = frag_more (2); 1553 } 1554 break; 1555 1556 case JC: 1557 input_line_pointer = parse_exp (op_end + 1, & e); 1558 op_end = input_line_pointer; 1559 1560 output = frag_var (rs_machine_dependent, 1561 md_relax_table[C (COND_JUMP, DISP32)].rlx_length, 1562 md_relax_table[C (COND_JUMP, DISP12)].rlx_length, 1563 C (COND_JUMP, 0), e.X_add_symbol, e.X_add_number, 0); 1564 isize = C32_LEN; 1565 break; 1566 1567 case JU: 1568 input_line_pointer = parse_exp (op_end + 1, & e); 1569 op_end = input_line_pointer; 1570 1571 output = frag_var (rs_machine_dependent, 1572 md_relax_table[C (UNCD_JUMP, DISP32)].rlx_length, 1573 md_relax_table[C (UNCD_JUMP, DISP12)].rlx_length, 1574 C (UNCD_JUMP, 0), e.X_add_symbol, e.X_add_number, 0); 1575 isize = U32_LEN; 1576 break; 1577 1578 case JL: 1579 inst = MCORE_INST_JSRI; /* jsri */ 1580 input_line_pointer = parse_rt (op_end + 1, & output, 1, & e); 1581 /* parse_rt() calls frag_more for us. */ 1582 op_end = input_line_pointer; 1583 1584 /* Only do this if we know how to do it ... */ 1585 if (e.X_op != O_absent && do_jsri2bsr) 1586 { 1587 /* Look at adding the R_PCREL_JSRIMM11BY2. */ 1588 fix_new_exp (frag_now, output-frag_now->fr_literal, 1589 2, & e, 1, BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2); 1590 } 1591 break; 1592 1593 case RSI: /* SI, but imm becomes 32-imm */ 1594 op_end = parse_reg (op_end + 1, & reg); 1595 inst |= reg; 1596 1597 /* Skip whitespace. */ 1598 while (isspace (* op_end)) 1599 ++ op_end; 1600 1601 if (* op_end == ',') 1602 { 1603 op_end = parse_imm (op_end + 1, & reg, 1, 31); 1604 1605 reg = 32 - reg; 1606 inst |= reg << 4; 1607 } 1608 else 1609 as_bad (_("second operand missing")); 1610 1611 output = frag_more (2); 1612 break; 1613 1614 case DO21: /* O2, dup rd, lit must be 1 */ 1615 op_end = parse_reg (op_end + 1, & reg); 1616 inst |= reg; 1617 inst |= reg << 4; 1618 1619 /* Skip whitespace. */ 1620 while (isspace (* op_end)) 1621 ++ op_end; 1622 1623 if (* op_end == ',') 1624 { 1625 op_end = parse_imm (op_end + 1, & reg, 1, 31); 1626 1627 if (reg != 1) 1628 as_bad (_("second operand must be 1")); 1629 } 1630 else 1631 as_bad (_("second operand missing")); 1632 1633 output = frag_more (2); 1634 break; 1635 1636 case SIa: 1637 op_end = parse_reg (op_end + 1, & reg); 1638 inst |= reg; 1639 1640 /* Skip whitespace. */ 1641 while (isspace (* op_end)) 1642 ++ op_end; 1643 1644 if (* op_end == ',') 1645 { 1646 op_end = parse_imm (op_end + 1, & reg, 1, 31); 1647 1648 if (reg == 0) 1649 as_bad (_("zero used as immediate value")); 1650 1651 inst |= reg << 4; 1652 } 1653 else 1654 as_bad (_("second operand missing")); 1655 1656 output = frag_more (2); 1657 break; 1658 1659 case OPSR: 1660 if (cpu == M210) 1661 { 1662 as_bad (_("M340 specific opcode used when assembling for M210")); 1663 break; 1664 } 1665 1666 op_end = parse_psrmod (op_end + 1, & reg); 1667 1668 /* Look for further selectors. */ 1669 while (* op_end == ',') 1670 { 1671 unsigned value; 1672 1673 op_end = parse_psrmod (op_end + 1, & value); 1674 1675 if (value & reg) 1676 as_bad (_("duplicated psr bit specifier")); 1677 1678 reg |= value; 1679 } 1680 1681 if (reg > 8) 1682 as_bad (_("`af' must appear alone")); 1683 1684 inst |= (reg & 0x7); 1685 output = frag_more (2); 1686 break; 1687 1688 default: 1689 as_bad (_("unimplemented opcode \"%s\""), name); 1690 } 1691 1692 /* Drop whitespace after all the operands have been parsed. */ 1693 while (isspace (* op_end)) 1694 op_end ++; 1695 1696 /* Give warning message if the insn has more operands than required. */ 1697 if (strcmp (op_end, opcode->name) && strcmp (op_end, "")) 1698 as_warn (_("ignoring operands: %s "), op_end); 1699 1700 output[0] = INST_BYTE0 (inst); 1701 output[1] = INST_BYTE1 (inst); 1702 1703 check_literals (opcode->transfer, isize); 1704 } 1705 1706 symbolS * 1707 md_undefined_symbol (name) 1708 char * name; 1709 { 1710 return 0; 1711 } 1712 1713 void 1714 md_mcore_end () 1715 { 1716 dump_literals (0); 1717 subseg_set (text_section, 0); 1718 } 1719 1720 /* Various routines to kill one day. */ 1721 /* Equal to MAX_PRECISION in atof-ieee.c */ 1722 #define MAX_LITTLENUMS 6 1723 1724 /* Turn a string in input_line_pointer into a floating point constant of type 1725 type, and store the appropriate bytes in *litP. The number of LITTLENUMS 1726 emitted is stored in *sizeP. An error message is returned, or NULL on OK.*/ 1727 char * 1728 md_atof (type, litP, sizeP) 1729 int type; 1730 char * litP; 1731 int * sizeP; 1732 { 1733 int prec; 1734 LITTLENUM_TYPE words[MAX_LITTLENUMS]; 1735 int i; 1736 char * t; 1737 char * atof_ieee (); 1738 1739 switch (type) 1740 { 1741 case 'f': 1742 case 'F': 1743 case 's': 1744 case 'S': 1745 prec = 2; 1746 break; 1747 1748 case 'd': 1749 case 'D': 1750 case 'r': 1751 case 'R': 1752 prec = 4; 1753 break; 1754 1755 case 'x': 1756 case 'X': 1757 prec = 6; 1758 break; 1759 1760 case 'p': 1761 case 'P': 1762 prec = 6; 1763 break; 1764 1765 default: 1766 *sizeP = 0; 1767 return _("Bad call to MD_NTOF()"); 1768 } 1769 1770 t = atof_ieee (input_line_pointer, type, words); 1771 1772 if (t) 1773 input_line_pointer = t; 1774 1775 *sizeP = prec * sizeof (LITTLENUM_TYPE); 1776 1777 if (! target_big_endian) 1778 { 1779 for (i = prec - 1; i >= 0; i--) 1780 { 1781 md_number_to_chars (litP, (valueT) words[i], 1782 sizeof (LITTLENUM_TYPE)); 1783 litP += sizeof (LITTLENUM_TYPE); 1784 } 1785 } 1786 else 1787 for (i = 0; i < prec; i++) 1788 { 1789 md_number_to_chars (litP, (valueT) words[i], 1790 sizeof (LITTLENUM_TYPE)); 1791 litP += sizeof (LITTLENUM_TYPE); 1792 } 1793 1794 return 0; 1795 } 1796 1797 CONST char * md_shortopts = ""; 1798 1799 #define OPTION_JSRI2BSR_ON (OPTION_MD_BASE + 0) 1800 #define OPTION_JSRI2BSR_OFF (OPTION_MD_BASE + 1) 1801 #define OPTION_SIFILTER_ON (OPTION_MD_BASE + 2) 1802 #define OPTION_SIFILTER_OFF (OPTION_MD_BASE + 3) 1803 #define OPTION_CPU (OPTION_MD_BASE + 4) 1804 #define OPTION_EB (OPTION_MD_BASE + 5) 1805 #define OPTION_EL (OPTION_MD_BASE + 6) 1806 1807 struct option md_longopts[] = 1808 { 1809 { "no-jsri2bsr", no_argument, NULL, OPTION_JSRI2BSR_OFF}, 1810 { "jsri2bsr", no_argument, NULL, OPTION_JSRI2BSR_ON}, 1811 { "sifilter", no_argument, NULL, OPTION_SIFILTER_ON}, 1812 { "no-sifilter", no_argument, NULL, OPTION_SIFILTER_OFF}, 1813 { "cpu", required_argument, NULL, OPTION_CPU}, 1814 { "EB", no_argument, NULL, OPTION_EB}, 1815 { "EL", no_argument, NULL, OPTION_EL}, 1816 { NULL, no_argument, NULL, 0} 1817 }; 1818 1819 size_t md_longopts_size = sizeof (md_longopts); 1820 1821 int 1822 md_parse_option (c, arg) 1823 int c; 1824 char * arg; 1825 { 1826 int i; 1827 char * p; 1828 1829 switch (c) 1830 { 1831 case OPTION_CPU: 1832 if (streq (arg, "210")) 1833 { 1834 cpu = M210; 1835 target_big_endian = 1; 1836 } 1837 else if (streq (arg, "340")) 1838 cpu = M340; 1839 else 1840 as_warn (_("unrecognised cpu type '%s'"), arg); 1841 break; 1842 1843 case OPTION_EB: target_big_endian = 1; break; 1844 case OPTION_EL: target_big_endian = 0; cpu = M340; break; 1845 case OPTION_JSRI2BSR_ON: do_jsri2bsr = 1; break; 1846 case OPTION_JSRI2BSR_OFF: do_jsri2bsr = 0; break; 1847 case OPTION_SIFILTER_ON: sifilter_mode = 1; break; 1848 case OPTION_SIFILTER_OFF: sifilter_mode = 0; break; 1849 default: return 0; 1850 } 1851 1852 return 1; 1853 } 1854 1855 void 1856 md_show_usage (stream) 1857 FILE * stream; 1858 { 1859 fprintf (stream, _("\ 1860 MCORE specific options:\n\ 1861 -{no-}jsri2bsr {dis}able jsri to bsr transformation (def: dis)\n\ 1862 -{no-}sifilter {dis}able silicon filter behavior (def: dis)\n\ 1863 -cpu=[210|340] select CPU type\n\ 1864 -EB assemble for a big endian system (default)\n\ 1865 -EL assemble for a little endian system\n")); 1866 } 1867 1868 int md_short_jump_size; 1869 1870 void 1871 md_create_short_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol) 1872 char * ptr; 1873 addressT from_Nddr; 1874 addressT to_Nddr; 1875 fragS * frag; 1876 symbolS * to_symbol; 1877 { 1878 as_fatal (_("failed sanity check: short_jump")); 1879 } 1880 1881 void 1882 md_create_long_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol) 1883 char * ptr; 1884 addressT from_Nddr; 1885 addressT to_Nddr; 1886 fragS * frag; 1887 symbolS * to_symbol; 1888 { 1889 as_fatal (_("failed sanity check: long_jump")); 1890 } 1891 1892 /* Called after relaxing, change the frags so they know how big they are. */ 1893 void 1894 md_convert_frag (abfd, sec, fragP) 1895 bfd * abfd; 1896 segT sec; 1897 register fragS * fragP; 1898 { 1899 unsigned char * buffer; 1900 int targ_addr = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset; 1901 1902 buffer = (unsigned char *) (fragP->fr_fix + fragP->fr_literal); 1903 targ_addr += symbol_get_frag (fragP->fr_symbol)->fr_address; 1904 1905 switch (fragP->fr_subtype) 1906 { 1907 case C (COND_JUMP, DISP12): 1908 case C (UNCD_JUMP, DISP12): 1909 { 1910 /* Get the address of the end of the instruction. */ 1911 int next_inst = fragP->fr_fix + fragP->fr_address + 2; 1912 unsigned char t0; 1913 int disp = targ_addr - next_inst; 1914 1915 if (disp & 1) 1916 as_bad (_("odd displacement at %x"), next_inst - 2); 1917 1918 disp >>= 1; 1919 1920 if (! target_big_endian) 1921 { 1922 t0 = buffer[1] & 0xF8; 1923 1924 md_number_to_chars (buffer, disp, 2); 1925 1926 buffer[1] = (buffer[1] & 0x07) | t0; 1927 } 1928 else 1929 { 1930 t0 = buffer[0] & 0xF8; 1931 1932 md_number_to_chars (buffer, disp, 2); 1933 1934 buffer[0] = (buffer[0] & 0x07) | t0; 1935 } 1936 1937 fragP->fr_fix += 2; 1938 } 1939 break; 1940 1941 case C (COND_JUMP, DISP32): 1942 case C (COND_JUMP, UNDEF_WORD_DISP): 1943 { 1944 /* A conditional branch wont fit into 12 bits so: 1945 * b!cond 1f 1946 * jmpi 0f 1947 * .align 2 1948 * 0: .long disp 1949 * 1: 1950 * 1951 * if the b!cond is 4 byte aligned, the literal which would 1952 * go at x+4 will also be aligned. 1953 */ 1954 int first_inst = fragP->fr_fix + fragP->fr_address; 1955 int needpad = (first_inst & 3); 1956 1957 if (! target_big_endian) 1958 buffer[1] ^= 0x08; 1959 else 1960 buffer[0] ^= 0x08; /* Toggle T/F bit */ 1961 1962 buffer[2] = INST_BYTE0 (MCORE_INST_JMPI); /* Build jmpi */ 1963 buffer[3] = INST_BYTE1 (MCORE_INST_JMPI); 1964 1965 if (needpad) 1966 { 1967 if (! target_big_endian) 1968 { 1969 buffer[0] = 4; /* branch over jmpi, pad, and ptr */ 1970 buffer[2] = 1; /* jmpi offset of 1 gets the pointer */ 1971 } 1972 else 1973 { 1974 buffer[1] = 4; /* branch over jmpi, pad, and ptr */ 1975 buffer[3] = 1; /* jmpi offset of 1 gets the pointer */ 1976 } 1977 1978 buffer[4] = 0; /* alignment/pad */ 1979 buffer[5] = 0; 1980 buffer[6] = 0; /* space for 32 bit address */ 1981 buffer[7] = 0; 1982 buffer[8] = 0; 1983 buffer[9] = 0; 1984 1985 /* Make reloc for the long disp */ 1986 fix_new (fragP, fragP->fr_fix + 6, 4, 1987 fragP->fr_symbol, fragP->fr_offset, 0, BFD_RELOC_32); 1988 1989 fragP->fr_fix += C32_LEN; 1990 } 1991 else 1992 { 1993 /* See comment below about this given gas' limitations for 1994 shrinking the fragment. '3' is the amount of code that 1995 we inserted here, but '4' is right for the space we reserved 1996 for this fragment. */ 1997 if (! target_big_endian) 1998 { 1999 buffer[0] = 3; /* branch over jmpi, and ptr */ 2000 buffer[2] = 0; /* jmpi offset of 0 gets the pointer */ 2001 } 2002 else 2003 { 2004 buffer[1] = 3; /* branch over jmpi, and ptr */ 2005 buffer[3] = 0; /* jmpi offset of 0 gets the pointer */ 2006 } 2007 2008 buffer[4] = 0; /* space for 32 bit address */ 2009 buffer[5] = 0; 2010 buffer[6] = 0; 2011 buffer[7] = 0; 2012 2013 /* Make reloc for the long disp. */ 2014 fix_new (fragP, fragP->fr_fix + 4, 4, 2015 fragP->fr_symbol, fragP->fr_offset, 0, BFD_RELOC_32); 2016 fragP->fr_fix += C32_LEN; 2017 2018 /* Frag is actually shorter (see the other side of this ifdef) 2019 but gas isn't prepared for that. We have to re-adjust 2020 the branch displacement so that it goes beyond the 2021 full length of the fragment, not just what we actually 2022 filled in. */ 2023 if (! target_big_endian) 2024 buffer[0] = 4; /* jmpi, ptr, and the 'tail pad' */ 2025 else 2026 buffer[1] = 4; /* jmpi, ptr, and the 'tail pad' */ 2027 } 2028 } 2029 break; 2030 2031 case C (UNCD_JUMP, DISP32): 2032 case C (UNCD_JUMP, UNDEF_WORD_DISP): 2033 { 2034 /* An unconditional branch will not fit in 12 bits, make code which 2035 looks like: 2036 jmpi 0f 2037 .align 2 2038 0: .long disp 2039 we need a pad if "first_inst" is 4 byte aligned. 2040 [because the natural literal place is x + 2] */ 2041 int first_inst = fragP->fr_fix + fragP->fr_address; 2042 int needpad = !(first_inst & 3); 2043 2044 buffer[0] = INST_BYTE0 (MCORE_INST_JMPI); /* Build jmpi */ 2045 buffer[1] = INST_BYTE1 (MCORE_INST_JMPI); 2046 2047 if (needpad) 2048 { 2049 if (! target_big_endian) 2050 buffer[0] = 1; /* jmpi offset of 1 since padded */ 2051 else 2052 buffer[1] = 1; /* jmpi offset of 1 since padded */ 2053 buffer[2] = 0; /* alignment */ 2054 buffer[3] = 0; 2055 buffer[4] = 0; /* space for 32 bit address */ 2056 buffer[5] = 0; 2057 buffer[6] = 0; 2058 buffer[7] = 0; 2059 2060 /* Make reloc for the long disp. */ 2061 fix_new (fragP, fragP->fr_fix + 4, 4, 2062 fragP->fr_symbol, fragP->fr_offset, 0, BFD_RELOC_32); 2063 2064 fragP->fr_fix += U32_LEN; 2065 } 2066 else 2067 { 2068 if (! target_big_endian) 2069 buffer[0] = 0; /* jmpi offset of 0 if no pad */ 2070 else 2071 buffer[1] = 0; /* jmpi offset of 0 if no pad */ 2072 buffer[2] = 0; /* space for 32 bit address */ 2073 buffer[3] = 0; 2074 buffer[4] = 0; 2075 buffer[5] = 0; 2076 2077 /* Make reloc for the long disp. */ 2078 fix_new (fragP, fragP->fr_fix + 2, 4, 2079 fragP->fr_symbol, fragP->fr_offset, 0, BFD_RELOC_32); 2080 fragP->fr_fix += U32_LEN; 2081 } 2082 } 2083 break; 2084 2085 default: 2086 abort (); 2087 } 2088 } 2089 2090 /* Applies the desired value to the specified location. 2091 Also sets up addends for 'rela' type relocations. */ 2092 int 2093 md_apply_fix3 (fixP, valp, segment) 2094 fixS * fixP; 2095 valueT * valp; 2096 segT segment; 2097 { 2098 char * buf = fixP->fx_where + fixP->fx_frag->fr_literal; 2099 char * file = fixP->fx_file ? fixP->fx_file : _("unknown"); 2100 const char * symname; 2101 /* Note: use offsetT because it is signed, valueT is unsigned. */ 2102 offsetT val = (offsetT) * valp; 2103 2104 symname = fixP->fx_addsy ? S_GET_NAME (fixP->fx_addsy) : _("<unknown>"); 2105 /* Save this for the addend in the relocation record. */ 2106 fixP->fx_addnumber = val; 2107 2108 /* If the fix is relative to a symbol which is not defined, or not 2109 in the same segment as the fix, we cannot resolve it here. */ 2110 if (fixP->fx_addsy != NULL 2111 && ( ! S_IS_DEFINED (fixP->fx_addsy) 2112 || (S_GET_SEGMENT (fixP->fx_addsy) != segment))) 2113 { 2114 fixP->fx_done = 0; 2115 #ifdef OBJ_ELF 2116 /* For ELF we can just return and let the reloc that will be generated 2117 take care of everything. For COFF we still have to insert 'val' 2118 into the insn since the addend field will be ignored. */ 2119 return 0; 2120 #endif 2121 } 2122 else 2123 fixP->fx_done = 1; 2124 2125 switch (fixP->fx_r_type) 2126 { 2127 case BFD_RELOC_MCORE_PCREL_IMM11BY2: /* second byte of 2 byte opcode */ 2128 if ((val & 1) != 0) 2129 as_bad_where (file, fixP->fx_line, 2130 _("odd distance branch (0x%x bytes)"), val); 2131 val /= 2; 2132 if (((val & ~0x3ff) != 0) && ((val | 0x3ff) != -1)) 2133 as_bad_where (file, fixP->fx_line, 2134 _("pcrel for branch to %s too far (0x%x)"), 2135 symname, val); 2136 if (target_big_endian) 2137 { 2138 buf[0] |= ((val >> 8) & 0x7); 2139 buf[1] |= (val & 0xff); 2140 } 2141 else 2142 { 2143 buf[1] |= ((val >> 8) & 0x7); 2144 buf[0] |= (val & 0xff); 2145 } 2146 break; 2147 2148 case BFD_RELOC_MCORE_PCREL_IMM8BY4: /* lower 8 bits of 2 byte opcode */ 2149 val += 3; 2150 val /= 4; 2151 if (val & ~0xff) 2152 as_bad_where (file, fixP->fx_line, 2153 _("pcrel for lrw/jmpi/jsri to %s too far (0x%x)"), 2154 symname, val); 2155 else if (! target_big_endian) 2156 buf[0] |= (val & 0xff); 2157 else 2158 buf[1] |= (val & 0xff); 2159 break; 2160 2161 case BFD_RELOC_MCORE_PCREL_IMM4BY2: /* loopt instruction */ 2162 if ((val < -32) || (val > -2)) 2163 as_bad_where (file, fixP->fx_line, 2164 _("pcrel for loopt too far (0x%x)"), val); 2165 val /= 2; 2166 if (! target_big_endian) 2167 buf[0] |= (val & 0xf); 2168 else 2169 buf[1] |= (val & 0xf); 2170 break; 2171 2172 case BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2: 2173 /* Conditional linker map jsri to bsr. */ 2174 /* If its a local target and close enough, fix it. 2175 NB: >= -2k for backwards bsr; < 2k for forwards... */ 2176 if (fixP->fx_addsy == 0 && val >= -2048 && val < 2048) 2177 { 2178 long nval = (val / 2) & 0x7ff; 2179 nval |= MCORE_INST_BSR; 2180 2181 /* REPLACE the instruction, don't just modify it. */ 2182 buf[0] = INST_BYTE0 (nval); 2183 buf[1] = INST_BYTE1 (nval); 2184 } 2185 else 2186 fixP->fx_done = 0; 2187 break; 2188 2189 case BFD_RELOC_MCORE_PCREL_32: 2190 case BFD_RELOC_VTABLE_INHERIT: 2191 case BFD_RELOC_VTABLE_ENTRY: 2192 fixP->fx_done = 0; 2193 break; 2194 2195 default: 2196 if (fixP->fx_addsy != NULL) 2197 { 2198 /* If the fix is an absolute reloc based on a symbol's 2199 address, then it cannot be resolved until the final link. */ 2200 fixP->fx_done = 0; 2201 } 2202 #ifdef OBJ_ELF 2203 else 2204 #endif 2205 { 2206 if (fixP->fx_size == 4) 2207 ; 2208 else if (fixP->fx_size == 2 && val >= -32768 && val <= 32767) 2209 ; 2210 else if (fixP->fx_size == 1 && val >= -256 && val <= 255) 2211 ; 2212 else 2213 abort (); 2214 md_number_to_chars (buf, val, fixP->fx_size); 2215 } 2216 break; 2217 } 2218 2219 return 0; /* Return value is ignored. */ 2220 } 2221 2222 void 2223 md_operand (expressionP) 2224 expressionS * expressionP; 2225 { 2226 /* Ignore leading hash symbol, if poresent. */ 2227 if (* input_line_pointer == '#') 2228 { 2229 input_line_pointer ++; 2230 expression (expressionP); 2231 } 2232 } 2233 2234 int md_long_jump_size; 2235 2236 /* Called just before address relaxation, return the length 2237 by which a fragment must grow to reach it's destination. */ 2238 int 2239 md_estimate_size_before_relax (fragP, segment_type) 2240 register fragS * fragP; 2241 register segT segment_type; 2242 { 2243 switch (fragP->fr_subtype) 2244 { 2245 default: 2246 abort (); 2247 2248 case C (UNCD_JUMP, UNDEF_DISP): 2249 /* Used to be a branch to somewhere which was unknown. */ 2250 if (!fragP->fr_symbol) 2251 { 2252 fragP->fr_subtype = C (UNCD_JUMP, DISP12); 2253 } 2254 else if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type) 2255 { 2256 fragP->fr_subtype = C (UNCD_JUMP, DISP12); 2257 } 2258 else 2259 { 2260 fragP->fr_subtype = C (UNCD_JUMP, UNDEF_WORD_DISP); 2261 } 2262 break; 2263 2264 case C (COND_JUMP, UNDEF_DISP): 2265 /* Used to be a branch to somewhere which was unknown. */ 2266 if (fragP->fr_symbol 2267 && S_GET_SEGMENT (fragP->fr_symbol) == segment_type) 2268 { 2269 /* Got a symbol and it's defined in this segment, become byte 2270 sized - maybe it will fix up */ 2271 fragP->fr_subtype = C (COND_JUMP, DISP12); 2272 } 2273 else if (fragP->fr_symbol) 2274 { 2275 /* Its got a segment, but its not ours, so it will always be long. */ 2276 fragP->fr_subtype = C (COND_JUMP, UNDEF_WORD_DISP); 2277 } 2278 else 2279 { 2280 /* We know the abs value. */ 2281 fragP->fr_subtype = C (COND_JUMP, DISP12); 2282 } 2283 break; 2284 2285 case C (UNCD_JUMP, DISP12): 2286 case C (UNCD_JUMP, DISP32): 2287 case C (UNCD_JUMP, UNDEF_WORD_DISP): 2288 case C (COND_JUMP, DISP12): 2289 case C (COND_JUMP, DISP32): 2290 case C (COND_JUMP, UNDEF_WORD_DISP): 2291 /* When relaxing a section for the second time, we don't need to 2292 do anything besides return the current size. */ 2293 break; 2294 } 2295 2296 return md_relax_table[fragP->fr_subtype].rlx_length; 2297 } 2298 2299 /* Put number into target byte order. */ 2300 void 2301 md_number_to_chars (ptr, use, nbytes) 2302 char * ptr; 2303 valueT use; 2304 int nbytes; 2305 { 2306 if (! target_big_endian) 2307 switch (nbytes) 2308 { 2309 case 4: ptr[3] = (use >> 24) & 0xff; /* fall through */ 2310 case 3: ptr[2] = (use >> 16) & 0xff; /* fall through */ 2311 case 2: ptr[1] = (use >> 8) & 0xff; /* fall through */ 2312 case 1: ptr[0] = (use >> 0) & 0xff; break; 2313 default: abort (); 2314 } 2315 else 2316 switch (nbytes) 2317 { 2318 case 4: *ptr++ = (use >> 24) & 0xff; /* fall through */ 2319 case 3: *ptr++ = (use >> 16) & 0xff; /* fall through */ 2320 case 2: *ptr++ = (use >> 8) & 0xff; /* fall through */ 2321 case 1: *ptr++ = (use >> 0) & 0xff; break; 2322 default: abort (); 2323 } 2324 } 2325 2326 /* Round up a section size to the appropriate boundary. */ 2327 valueT 2328 md_section_align (segment, size) 2329 segT segment; 2330 valueT size; 2331 { 2332 return size; /* Byte alignment is fine */ 2333 } 2334 2335 /* The location from which a PC relative jump should be calculated, 2336 given a PC relative reloc. */ 2337 long 2338 md_pcrel_from_section (fixp, sec) 2339 fixS * fixp; 2340 segT sec; 2341 { 2342 #ifdef OBJ_ELF 2343 /* If the symbol is undefined or defined in another section 2344 we leave the add number alone for the linker to fix it later. 2345 Only account for the PC pre-bump (which is 2 bytes on the MCore). */ 2346 if (fixp->fx_addsy != (symbolS *) NULL 2347 && (! S_IS_DEFINED (fixp->fx_addsy) 2348 || (S_GET_SEGMENT (fixp->fx_addsy) != sec))) 2349 2350 { 2351 assert (fixp->fx_size == 2); /* must be an insn */ 2352 return fixp->fx_size; 2353 } 2354 #endif 2355 2356 /* The case where we are going to resolve things... */ 2357 return fixp->fx_size + fixp->fx_where + fixp->fx_frag->fr_address; 2358 } 2359 2360 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL)) 2361 #define MAP(SZ,PCREL,TYPE) case F (SZ, PCREL): code = (TYPE); break 2362 2363 arelent * 2364 tc_gen_reloc (section, fixp) 2365 asection * section; 2366 fixS * fixp; 2367 { 2368 arelent * rel; 2369 bfd_reloc_code_real_type code; 2370 int handled = 0; 2371 2372 switch (fixp->fx_r_type) 2373 { 2374 /* These confuse the size/pcrel macro approach. */ 2375 case BFD_RELOC_VTABLE_INHERIT: 2376 case BFD_RELOC_VTABLE_ENTRY: 2377 case BFD_RELOC_MCORE_PCREL_IMM4BY2: 2378 case BFD_RELOC_MCORE_PCREL_IMM8BY4: 2379 case BFD_RELOC_MCORE_PCREL_IMM11BY2: 2380 case BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2: 2381 case BFD_RELOC_RVA: 2382 code = fixp->fx_r_type; 2383 break; 2384 2385 default: 2386 switch (F (fixp->fx_size, fixp->fx_pcrel)) 2387 { 2388 MAP (1, 0, BFD_RELOC_8); 2389 MAP (2, 0, BFD_RELOC_16); 2390 MAP (4, 0, BFD_RELOC_32); 2391 MAP (1, 1, BFD_RELOC_8_PCREL); 2392 MAP (2, 1, BFD_RELOC_16_PCREL); 2393 MAP (4, 1, BFD_RELOC_32_PCREL); 2394 default: 2395 code = fixp->fx_r_type; 2396 as_bad (_("Can not do %d byte %srelocation"), 2397 fixp->fx_size, 2398 fixp->fx_pcrel ? _("pc-relative") : ""); 2399 } 2400 break; 2401 } 2402 2403 rel = (arelent *) xmalloc (sizeof (arelent)); 2404 rel->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); 2405 *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); 2406 rel->address = fixp->fx_frag->fr_address + fixp->fx_where; 2407 /* Always pass the addend along! */ 2408 rel->addend = fixp->fx_addnumber; 2409 2410 rel->howto = bfd_reloc_type_lookup (stdoutput, code); 2411 2412 if (rel->howto == NULL) 2413 { 2414 as_bad_where (fixp->fx_file, fixp->fx_line, 2415 _("Cannot represent relocation type %s"), 2416 bfd_get_reloc_code_name (code)); 2417 2418 /* Set howto to a garbage value so that we can keep going. */ 2419 rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32); 2420 assert (rel->howto != NULL); 2421 } 2422 2423 return rel; 2424 } 2425 2426 #ifdef OBJ_ELF 2427 /* See whether we need to force a relocation into the output file. 2428 This is used to force out switch and PC relative relocations when 2429 relaxing. */ 2430 int 2431 mcore_force_relocation (fix) 2432 fixS * fix; 2433 { 2434 if ( fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT 2435 || fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY 2436 || fix->fx_r_type == BFD_RELOC_RVA) 2437 return 1; 2438 2439 return 0; 2440 } 2441 2442 /* Return true if the fix can be handled by GAS, false if it must 2443 be passed through to the linker. */ 2444 boolean 2445 mcore_fix_adjustable (fixP) 2446 fixS * fixP; 2447 { 2448 if (fixP->fx_addsy == NULL) 2449 return 1; 2450 2451 /* We need the symbol name for the VTABLE entries. */ 2452 if ( fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT 2453 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY) 2454 return 0; 2455 2456 return 1; 2457 } 2458 #endif /* OBJ_ELF */ 2459