1/* tc-arc.c -- Assembler for the ARC 2 Copyright 1994, 1995, 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 3 2006 Free Software Foundation, Inc. 4 Contributed by Doug Evans (dje@cygnus.com). 5 6 This file is part of GAS, the GNU Assembler. 7 8 GAS is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2, or (at your option) 11 any later version. 12 13 GAS is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GAS; see the file COPYING. If not, write to the Free 20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 21 02110-1301, USA. */ 22 23#include "as.h" 24#include "struc-symbol.h" 25#include "safe-ctype.h" 26#include "subsegs.h" 27#include "opcode/arc.h" 28#include "../opcodes/arc-ext.h" 29#include "elf/arc.h" 30#include "dwarf2dbg.h" 31 32const struct suffix_classes 33{ 34 char *name; 35 int len; 36} suffixclass[] = 37{ 38 { "SUFFIX_COND|SUFFIX_FLAG",23 }, 39 { "SUFFIX_FLAG", 11 }, 40 { "SUFFIX_COND", 11 }, 41 { "SUFFIX_NONE", 11 } 42}; 43 44#define MAXSUFFIXCLASS (sizeof (suffixclass) / sizeof (struct suffix_classes)) 45 46const struct syntax_classes 47{ 48 char *name; 49 int len; 50 int class; 51} syntaxclass[] = 52{ 53 { "SYNTAX_3OP|OP1_MUST_BE_IMM", 26, SYNTAX_3OP|OP1_MUST_BE_IMM|SYNTAX_VALID }, 54 { "OP1_MUST_BE_IMM|SYNTAX_3OP", 26, OP1_MUST_BE_IMM|SYNTAX_3OP|SYNTAX_VALID }, 55 { "SYNTAX_2OP|OP1_IMM_IMPLIED", 26, SYNTAX_2OP|OP1_IMM_IMPLIED|SYNTAX_VALID }, 56 { "OP1_IMM_IMPLIED|SYNTAX_2OP", 26, OP1_IMM_IMPLIED|SYNTAX_2OP|SYNTAX_VALID }, 57 { "SYNTAX_3OP", 10, SYNTAX_3OP|SYNTAX_VALID }, 58 { "SYNTAX_2OP", 10, SYNTAX_2OP|SYNTAX_VALID } 59}; 60 61#define MAXSYNTAXCLASS (sizeof (syntaxclass) / sizeof (struct syntax_classes)) 62 63/* This array holds the chars that always start a comment. If the 64 pre-processor is disabled, these aren't very useful. */ 65const char comment_chars[] = "#;"; 66 67/* This array holds the chars that only start a comment at the beginning of 68 a line. If the line seems to have the form '# 123 filename' 69 .line and .file directives will appear in the pre-processed output */ 70/* Note that input_file.c hand checks for '#' at the beginning of the 71 first line of the input file. This is because the compiler outputs 72 #NO_APP at the beginning of its output. */ 73/* Also note that comments started like this one will always 74 work if '/' isn't otherwise defined. */ 75const char line_comment_chars[] = "#"; 76 77const char line_separator_chars[] = ""; 78 79/* Chars that can be used to separate mant from exp in floating point nums. */ 80const char EXP_CHARS[] = "eE"; 81 82/* Chars that mean this number is a floating point constant 83 As in 0f12.456 or 0d1.2345e12. */ 84const char FLT_CHARS[] = "rRsSfFdD"; 85 86/* Byte order. */ 87extern int target_big_endian; 88const char *arc_target_format = DEFAULT_TARGET_FORMAT; 89static int byte_order = DEFAULT_BYTE_ORDER; 90 91static segT arcext_section; 92 93/* One of bfd_mach_arc_n. */ 94static int arc_mach_type = bfd_mach_arc_6; 95 96/* Non-zero if the cpu type has been explicitly specified. */ 97static int mach_type_specified_p = 0; 98 99/* Non-zero if opcode tables have been initialized. 100 A .option command must appear before any instructions. */ 101static int cpu_tables_init_p = 0; 102 103static struct hash_control *arc_suffix_hash = NULL; 104 105const char *md_shortopts = ""; 106 107enum options 108{ 109 OPTION_EB = OPTION_MD_BASE, 110 OPTION_EL, 111 OPTION_ARC5, 112 OPTION_ARC6, 113 OPTION_ARC7, 114 OPTION_ARC8, 115 OPTION_ARC 116}; 117 118struct option md_longopts[] = 119{ 120 { "EB", no_argument, NULL, OPTION_EB }, 121 { "EL", no_argument, NULL, OPTION_EL }, 122 { "marc5", no_argument, NULL, OPTION_ARC5 }, 123 { "pre-v6", no_argument, NULL, OPTION_ARC5 }, 124 { "marc6", no_argument, NULL, OPTION_ARC6 }, 125 { "marc7", no_argument, NULL, OPTION_ARC7 }, 126 { "marc8", no_argument, NULL, OPTION_ARC8 }, 127 { "marc", no_argument, NULL, OPTION_ARC }, 128 { NULL, no_argument, NULL, 0 } 129}; 130size_t md_longopts_size = sizeof (md_longopts); 131 132#define IS_SYMBOL_OPERAND(o) \ 133 ((o) == 'b' || (o) == 'c' || (o) == 's' || (o) == 'o' || (o) == 'O') 134 135struct arc_operand_value *get_ext_suffix (char *s); 136 137/* Invocation line includes a switch not recognized by the base assembler. 138 See if it's a processor-specific option. */ 139 140int 141md_parse_option (int c, char *arg ATTRIBUTE_UNUSED) 142{ 143 switch (c) 144 { 145 case OPTION_ARC5: 146 arc_mach_type = bfd_mach_arc_5; 147 break; 148 case OPTION_ARC: 149 case OPTION_ARC6: 150 arc_mach_type = bfd_mach_arc_6; 151 break; 152 case OPTION_ARC7: 153 arc_mach_type = bfd_mach_arc_7; 154 break; 155 case OPTION_ARC8: 156 arc_mach_type = bfd_mach_arc_8; 157 break; 158 case OPTION_EB: 159 byte_order = BIG_ENDIAN; 160 arc_target_format = "elf32-bigarc"; 161 break; 162 case OPTION_EL: 163 byte_order = LITTLE_ENDIAN; 164 arc_target_format = "elf32-littlearc"; 165 break; 166 default: 167 return 0; 168 } 169 return 1; 170} 171 172void 173md_show_usage (FILE *stream) 174{ 175 fprintf (stream, "\ 176ARC Options:\n\ 177 -marc[5|6|7|8] select processor variant (default arc%d)\n\ 178 -EB assemble code for a big endian cpu\n\ 179 -EL assemble code for a little endian cpu\n", arc_mach_type + 5); 180} 181 182/* This function is called once, at assembler startup time. It should 183 set up all the tables, etc. that the MD part of the assembler will need. 184 Opcode selection is deferred until later because we might see a .option 185 command. */ 186 187void 188md_begin (void) 189{ 190 /* The endianness can be chosen "at the factory". */ 191 target_big_endian = byte_order == BIG_ENDIAN; 192 193 if (!bfd_set_arch_mach (stdoutput, bfd_arch_arc, arc_mach_type)) 194 as_warn ("could not set architecture and machine"); 195 196 /* This call is necessary because we need to initialize `arc_operand_map' 197 which may be needed before we see the first insn. */ 198 arc_opcode_init_tables (arc_get_opcode_mach (arc_mach_type, 199 target_big_endian)); 200} 201 202/* Initialize the various opcode and operand tables. 203 MACH is one of bfd_mach_arc_xxx. */ 204 205static void 206init_opcode_tables (int mach) 207{ 208 int i; 209 char *last; 210 211 if ((arc_suffix_hash = hash_new ()) == NULL) 212 as_fatal ("virtual memory exhausted"); 213 214 if (!bfd_set_arch_mach (stdoutput, bfd_arch_arc, mach)) 215 as_warn ("could not set architecture and machine"); 216 217 /* This initializes a few things in arc-opc.c that we need. 218 This must be called before the various arc_xxx_supported fns. */ 219 arc_opcode_init_tables (arc_get_opcode_mach (mach, target_big_endian)); 220 221 /* Only put the first entry of each equivalently named suffix in the 222 table. */ 223 last = ""; 224 for (i = 0; i < arc_suffixes_count; i++) 225 { 226 if (strcmp (arc_suffixes[i].name, last) != 0) 227 hash_insert (arc_suffix_hash, arc_suffixes[i].name, (void *) (arc_suffixes + i)); 228 last = arc_suffixes[i].name; 229 } 230 231 /* Since registers don't have a prefix, we put them in the symbol table so 232 they can't be used as symbols. This also simplifies argument parsing as 233 we can let gas parse registers for us. The recorded register number is 234 the address of the register's entry in arc_reg_names. 235 236 If the register name is already in the table, then the existing 237 definition is assumed to be from an .ExtCoreRegister pseudo-op. */ 238 239 for (i = 0; i < arc_reg_names_count; i++) 240 { 241 if (symbol_find (arc_reg_names[i].name)) 242 continue; 243 /* Use symbol_create here instead of symbol_new so we don't try to 244 output registers into the object file's symbol table. */ 245 symbol_table_insert (symbol_create (arc_reg_names[i].name, 246 reg_section, 247 (valueT) &arc_reg_names[i], 248 &zero_address_frag)); 249 } 250 251 /* Tell `.option' it's too late. */ 252 cpu_tables_init_p = 1; 253} 254 255/* Insert an operand value into an instruction. 256 If REG is non-NULL, it is a register number and ignore VAL. */ 257 258static arc_insn 259arc_insert_operand (arc_insn insn, 260 const struct arc_operand *operand, 261 int mods, 262 const struct arc_operand_value *reg, 263 offsetT val, 264 char *file, 265 unsigned int line) 266{ 267 if (operand->bits != 32) 268 { 269 long min, max; 270 offsetT test; 271 272 if ((operand->flags & ARC_OPERAND_SIGNED) != 0) 273 { 274 if ((operand->flags & ARC_OPERAND_SIGNOPT) != 0) 275 max = (1 << operand->bits) - 1; 276 else 277 max = (1 << (operand->bits - 1)) - 1; 278 min = - (1 << (operand->bits - 1)); 279 } 280 else 281 { 282 max = (1 << operand->bits) - 1; 283 min = 0; 284 } 285 286 if ((operand->flags & ARC_OPERAND_NEGATIVE) != 0) 287 test = - val; 288 else 289 test = val; 290 291 if (test < (offsetT) min || test > (offsetT) max) 292 as_warn_value_out_of_range (_("operand"), test, (offsetT) min, (offsetT) max, file, line); 293 } 294 295 if (operand->insert) 296 { 297 const char *errmsg; 298 299 errmsg = NULL; 300 insn = (*operand->insert) (insn, operand, mods, reg, (long) val, &errmsg); 301 if (errmsg != (const char *) NULL) 302 as_warn (errmsg); 303 } 304 else 305 insn |= (((long) val & ((1 << operand->bits) - 1)) 306 << operand->shift); 307 308 return insn; 309} 310 311/* We need to keep a list of fixups. We can't simply generate them as 312 we go, because that would require us to first create the frag, and 313 that would screw up references to ``.''. */ 314 315struct arc_fixup 316{ 317 /* index into `arc_operands' */ 318 int opindex; 319 expressionS exp; 320}; 321 322#define MAX_FIXUPS 5 323 324#define MAX_SUFFIXES 5 325 326/* Compute the reloc type of an expression. 327 The possibly modified expression is stored in EXPNEW. 328 329 This is used to convert the expressions generated by the %-op's into 330 the appropriate operand type. It is called for both data in instructions 331 (operands) and data outside instructions (variables, debugging info, etc.). 332 333 Currently supported %-ops: 334 335 %st(symbol): represented as "symbol >> 2" 336 "st" is short for STatus as in the status register (pc) 337 338 DEFAULT_TYPE is the type to use if no special processing is required. 339 340 DATA_P is non-zero for data or limm values, zero for insn operands. 341 Remember that the opcode "insertion fns" cannot be used on data, they're 342 only for inserting operands into insns. They also can't be used for limm 343 values as the insertion routines don't handle limm values. When called for 344 insns we return fudged reloc types (real_value - BFD_RELOC_UNUSED). When 345 called for data or limm values we use real reloc types. */ 346 347static int 348get_arc_exp_reloc_type (int data_p, 349 int default_type, 350 expressionS *exp, 351 expressionS *expnew) 352{ 353 /* If the expression is "symbol >> 2" we must change it to just "symbol", 354 as fix_new_exp can't handle it. Similarly for (symbol - symbol) >> 2. 355 That's ok though. What's really going on here is that we're using 356 ">> 2" as a special syntax for specifying BFD_RELOC_ARC_B26. */ 357 358 if (exp->X_op == O_right_shift 359 && exp->X_op_symbol != NULL 360 && exp->X_op_symbol->sy_value.X_op == O_constant 361 && exp->X_op_symbol->sy_value.X_add_number == 2 362 && exp->X_add_number == 0) 363 { 364 if (exp->X_add_symbol != NULL 365 && (exp->X_add_symbol->sy_value.X_op == O_constant 366 || exp->X_add_symbol->sy_value.X_op == O_symbol)) 367 { 368 *expnew = *exp; 369 expnew->X_op = O_symbol; 370 expnew->X_op_symbol = NULL; 371 return data_p ? BFD_RELOC_ARC_B26 : arc_operand_map['J']; 372 } 373 else if (exp->X_add_symbol != NULL 374 && exp->X_add_symbol->sy_value.X_op == O_subtract) 375 { 376 *expnew = exp->X_add_symbol->sy_value; 377 return data_p ? BFD_RELOC_ARC_B26 : arc_operand_map['J']; 378 } 379 } 380 381 *expnew = *exp; 382 return default_type; 383} 384 385static int 386arc_set_ext_seg (void) 387{ 388 if (!arcext_section) 389 { 390 arcext_section = subseg_new (".arcextmap", 0); 391 bfd_set_section_flags (stdoutput, arcext_section, 392 SEC_READONLY | SEC_HAS_CONTENTS); 393 } 394 else 395 subseg_set (arcext_section, 0); 396 return 1; 397} 398 399static void 400arc_extoper (int opertype) 401{ 402 char *name; 403 char *mode; 404 char c; 405 char *p; 406 int imode = 0; 407 int number; 408 struct arc_ext_operand_value *ext_oper; 409 symbolS *symbolP; 410 411 segT old_sec; 412 int old_subsec; 413 414 name = input_line_pointer; 415 c = get_symbol_end (); 416 name = xstrdup (name); 417 418 p = name; 419 while (*p) 420 { 421 *p = TOLOWER (*p); 422 p++; 423 } 424 425 /* just after name is now '\0' */ 426 p = input_line_pointer; 427 *p = c; 428 SKIP_WHITESPACE (); 429 430 if (*input_line_pointer != ',') 431 { 432 as_bad ("expected comma after operand name"); 433 ignore_rest_of_line (); 434 free (name); 435 return; 436 } 437 438 input_line_pointer++; /* skip ',' */ 439 number = get_absolute_expression (); 440 441 if (number < 0) 442 { 443 as_bad ("negative operand number %d", number); 444 ignore_rest_of_line (); 445 free (name); 446 return; 447 } 448 449 if (opertype) 450 { 451 SKIP_WHITESPACE (); 452 453 if (*input_line_pointer != ',') 454 { 455 as_bad ("expected comma after register-number"); 456 ignore_rest_of_line (); 457 free (name); 458 return; 459 } 460 461 input_line_pointer++; /* skip ',' */ 462 mode = input_line_pointer; 463 464 if (!strncmp (mode, "r|w", 3)) 465 { 466 imode = 0; 467 input_line_pointer += 3; 468 } 469 else 470 { 471 if (!strncmp (mode, "r", 1)) 472 { 473 imode = ARC_REGISTER_READONLY; 474 input_line_pointer += 1; 475 } 476 else 477 { 478 if (strncmp (mode, "w", 1)) 479 { 480 as_bad ("invalid mode"); 481 ignore_rest_of_line (); 482 free (name); 483 return; 484 } 485 else 486 { 487 imode = ARC_REGISTER_WRITEONLY; 488 input_line_pointer += 1; 489 } 490 } 491 } 492 SKIP_WHITESPACE (); 493 if (1 == opertype) 494 { 495 if (*input_line_pointer != ',') 496 { 497 as_bad ("expected comma after register-mode"); 498 ignore_rest_of_line (); 499 free (name); 500 return; 501 } 502 503 input_line_pointer++; /* skip ',' */ 504 505 if (!strncmp (input_line_pointer, "cannot_shortcut", 15)) 506 { 507 imode |= arc_get_noshortcut_flag (); 508 input_line_pointer += 15; 509 } 510 else 511 { 512 if (strncmp (input_line_pointer, "can_shortcut", 12)) 513 { 514 as_bad ("shortcut designator invalid"); 515 ignore_rest_of_line (); 516 free (name); 517 return; 518 } 519 else 520 { 521 input_line_pointer += 12; 522 } 523 } 524 } 525 } 526 527 if ((opertype == 1) && number > 60) 528 { 529 as_bad ("core register value (%d) too large", number); 530 ignore_rest_of_line (); 531 free (name); 532 return; 533 } 534 535 if ((opertype == 0) && number > 31) 536 { 537 as_bad ("condition code value (%d) too large", number); 538 ignore_rest_of_line (); 539 free (name); 540 return; 541 } 542 543 ext_oper = xmalloc (sizeof (struct arc_ext_operand_value)); 544 545 if (opertype) 546 { 547 /* If the symbol already exists, point it at the new definition. */ 548 if ((symbolP = symbol_find (name))) 549 { 550 if (S_GET_SEGMENT (symbolP) == reg_section) 551 S_SET_VALUE (symbolP, (valueT) &ext_oper->operand); 552 else 553 { 554 as_bad ("attempt to override symbol: %s", name); 555 ignore_rest_of_line (); 556 free (name); 557 free (ext_oper); 558 return; 559 } 560 } 561 else 562 { 563 /* If its not there, add it. */ 564 symbol_table_insert (symbol_create (name, reg_section, 565 (valueT) &ext_oper->operand, 566 &zero_address_frag)); 567 } 568 } 569 570 ext_oper->operand.name = name; 571 ext_oper->operand.value = number; 572 ext_oper->operand.type = arc_operand_type (opertype); 573 ext_oper->operand.flags = imode; 574 575 ext_oper->next = arc_ext_operands; 576 arc_ext_operands = ext_oper; 577 578 /* OK, now that we know what this operand is, put a description in 579 the arc extension section of the output file. */ 580 581 old_sec = now_seg; 582 old_subsec = now_subseg; 583 584 arc_set_ext_seg (); 585 586 switch (opertype) 587 { 588 case 0: 589 p = frag_more (1); 590 *p = 3 + strlen (name) + 1; 591 p = frag_more (1); 592 *p = EXT_COND_CODE; 593 p = frag_more (1); 594 *p = number; 595 p = frag_more (strlen (name) + 1); 596 strcpy (p, name); 597 break; 598 case 1: 599 p = frag_more (1); 600 *p = 3 + strlen (name) + 1; 601 p = frag_more (1); 602 *p = EXT_CORE_REGISTER; 603 p = frag_more (1); 604 *p = number; 605 p = frag_more (strlen (name) + 1); 606 strcpy (p, name); 607 break; 608 case 2: 609 p = frag_more (1); 610 *p = 6 + strlen (name) + 1; 611 p = frag_more (1); 612 *p = EXT_AUX_REGISTER; 613 p = frag_more (1); 614 *p = number >> 24 & 0xff; 615 p = frag_more (1); 616 *p = number >> 16 & 0xff; 617 p = frag_more (1); 618 *p = number >> 8 & 0xff; 619 p = frag_more (1); 620 *p = number & 0xff; 621 p = frag_more (strlen (name) + 1); 622 strcpy (p, name); 623 break; 624 default: 625 as_bad ("invalid opertype"); 626 ignore_rest_of_line (); 627 free (name); 628 return; 629 break; 630 } 631 632 subseg_set (old_sec, old_subsec); 633 634 /* Enter all registers into the symbol table. */ 635 636 demand_empty_rest_of_line (); 637} 638 639static void 640arc_extinst (int ignore ATTRIBUTE_UNUSED) 641{ 642 char syntax[129]; 643 char *name; 644 char *p; 645 char c; 646 int suffixcode = -1; 647 int opcode, subopcode; 648 int i; 649 int class = 0; 650 int name_len; 651 struct arc_opcode *ext_op; 652 653 segT old_sec; 654 int old_subsec; 655 656 name = input_line_pointer; 657 c = get_symbol_end (); 658 name = xstrdup (name); 659 strcpy (syntax, name); 660 name_len = strlen (name); 661 662 /* just after name is now '\0' */ 663 p = input_line_pointer; 664 *p = c; 665 666 SKIP_WHITESPACE (); 667 668 if (*input_line_pointer != ',') 669 { 670 as_bad ("expected comma after operand name"); 671 ignore_rest_of_line (); 672 return; 673 } 674 675 input_line_pointer++; /* skip ',' */ 676 opcode = get_absolute_expression (); 677 678 SKIP_WHITESPACE (); 679 680 if (*input_line_pointer != ',') 681 { 682 as_bad ("expected comma after opcode"); 683 ignore_rest_of_line (); 684 return; 685 } 686 687 input_line_pointer++; /* skip ',' */ 688 subopcode = get_absolute_expression (); 689 690 if (subopcode < 0) 691 { 692 as_bad ("negative subopcode %d", subopcode); 693 ignore_rest_of_line (); 694 return; 695 } 696 697 if (subopcode) 698 { 699 if (3 != opcode) 700 { 701 as_bad ("subcode value found when opcode not equal 0x03"); 702 ignore_rest_of_line (); 703 return; 704 } 705 else 706 { 707 if (subopcode < 0x09 || subopcode == 0x3f) 708 { 709 as_bad ("invalid subopcode %d", subopcode); 710 ignore_rest_of_line (); 711 return; 712 } 713 } 714 } 715 716 SKIP_WHITESPACE (); 717 718 if (*input_line_pointer != ',') 719 { 720 as_bad ("expected comma after subopcode"); 721 ignore_rest_of_line (); 722 return; 723 } 724 725 input_line_pointer++; /* skip ',' */ 726 727 for (i = 0; i < (int) MAXSUFFIXCLASS; i++) 728 { 729 if (!strncmp (suffixclass[i].name,input_line_pointer, suffixclass[i].len)) 730 { 731 suffixcode = i; 732 input_line_pointer += suffixclass[i].len; 733 break; 734 } 735 } 736 737 if (-1 == suffixcode) 738 { 739 as_bad ("invalid suffix class"); 740 ignore_rest_of_line (); 741 return; 742 } 743 744 SKIP_WHITESPACE (); 745 746 if (*input_line_pointer != ',') 747 { 748 as_bad ("expected comma after suffix class"); 749 ignore_rest_of_line (); 750 return; 751 } 752 753 input_line_pointer++; /* skip ',' */ 754 755 for (i = 0; i < (int) MAXSYNTAXCLASS; i++) 756 { 757 if (!strncmp (syntaxclass[i].name,input_line_pointer, syntaxclass[i].len)) 758 { 759 class = syntaxclass[i].class; 760 input_line_pointer += syntaxclass[i].len; 761 break; 762 } 763 } 764 765 if (0 == (SYNTAX_VALID & class)) 766 { 767 as_bad ("invalid syntax class"); 768 ignore_rest_of_line (); 769 return; 770 } 771 772 if ((0x3 == opcode) & (class & SYNTAX_3OP)) 773 { 774 as_bad ("opcode 0x3 and SYNTAX_3OP invalid"); 775 ignore_rest_of_line (); 776 return; 777 } 778 779 switch (suffixcode) 780 { 781 case 0: 782 strcat (syntax, "%.q%.f "); 783 break; 784 case 1: 785 strcat (syntax, "%.f "); 786 break; 787 case 2: 788 strcat (syntax, "%.q "); 789 break; 790 case 3: 791 strcat (syntax, " "); 792 break; 793 default: 794 as_bad ("unknown suffix class"); 795 ignore_rest_of_line (); 796 return; 797 break; 798 }; 799 800 strcat (syntax, ((opcode == 0x3) ? "%a,%b" : ((class & SYNTAX_3OP) ? "%a,%b,%c" : "%b,%c"))); 801 if (suffixcode < 2) 802 strcat (syntax, "%F"); 803 strcat (syntax, "%S%L"); 804 805 ext_op = xmalloc (sizeof (struct arc_opcode)); 806 ext_op->syntax = xstrdup (syntax); 807 808 ext_op->mask = I (-1) | ((0x3 == opcode) ? C (-1) : 0); 809 ext_op->value = I (opcode) | ((0x3 == opcode) ? C (subopcode) : 0); 810 ext_op->flags = class; 811 ext_op->next_asm = arc_ext_opcodes; 812 ext_op->next_dis = arc_ext_opcodes; 813 arc_ext_opcodes = ext_op; 814 815 /* OK, now that we know what this inst is, put a description in the 816 arc extension section of the output file. */ 817 818 old_sec = now_seg; 819 old_subsec = now_subseg; 820 821 arc_set_ext_seg (); 822 823 p = frag_more (1); 824 *p = 5 + name_len + 1; 825 p = frag_more (1); 826 *p = EXT_INSTRUCTION; 827 p = frag_more (1); 828 *p = opcode; 829 p = frag_more (1); 830 *p = subopcode; 831 p = frag_more (1); 832 *p = (class & (OP1_MUST_BE_IMM | OP1_IMM_IMPLIED) ? IGNORE_FIRST_OPD : 0); 833 p = frag_more (name_len); 834 strncpy (p, syntax, name_len); 835 p = frag_more (1); 836 *p = '\0'; 837 838 subseg_set (old_sec, old_subsec); 839 840 demand_empty_rest_of_line (); 841} 842 843static void 844arc_common (int localScope) 845{ 846 char *name; 847 char c; 848 char *p; 849 int align, size; 850 symbolS *symbolP; 851 852 name = input_line_pointer; 853 c = get_symbol_end (); 854 /* just after name is now '\0' */ 855 p = input_line_pointer; 856 *p = c; 857 SKIP_WHITESPACE (); 858 859 if (*input_line_pointer != ',') 860 { 861 as_bad ("expected comma after symbol name"); 862 ignore_rest_of_line (); 863 return; 864 } 865 866 input_line_pointer++; /* skip ',' */ 867 size = get_absolute_expression (); 868 869 if (size < 0) 870 { 871 as_bad ("negative symbol length"); 872 ignore_rest_of_line (); 873 return; 874 } 875 876 *p = 0; 877 symbolP = symbol_find_or_make (name); 878 *p = c; 879 880 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP)) 881 { 882 as_bad ("ignoring attempt to re-define symbol"); 883 ignore_rest_of_line (); 884 return; 885 } 886 if (((int) S_GET_VALUE (symbolP) != 0) \ 887 && ((int) S_GET_VALUE (symbolP) != size)) 888 { 889 as_warn ("length of symbol \"%s\" already %ld, ignoring %d", 890 S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size); 891 } 892 assert (symbolP->sy_frag == &zero_address_frag); 893 894 /* Now parse the alignment field. This field is optional for 895 local and global symbols. Default alignment is zero. */ 896 if (*input_line_pointer == ',') 897 { 898 input_line_pointer++; 899 align = get_absolute_expression (); 900 if (align < 0) 901 { 902 align = 0; 903 as_warn ("assuming symbol alignment of zero"); 904 } 905 } 906 else 907 align = 0; 908 909 if (localScope != 0) 910 { 911 segT old_sec; 912 int old_subsec; 913 char *pfrag; 914 915 old_sec = now_seg; 916 old_subsec = now_subseg; 917 record_alignment (bss_section, align); 918 subseg_set (bss_section, 0); /* ??? subseg_set (bss_section, 1); ??? */ 919 920 if (align) 921 /* Do alignment. */ 922 frag_align (align, 0, 0); 923 924 /* Detach from old frag. */ 925 if (S_GET_SEGMENT (symbolP) == bss_section) 926 symbolP->sy_frag->fr_symbol = NULL; 927 928 symbolP->sy_frag = frag_now; 929 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, 930 (offsetT) size, (char *) 0); 931 *pfrag = 0; 932 933 S_SET_SIZE (symbolP, size); 934 S_SET_SEGMENT (symbolP, bss_section); 935 S_CLEAR_EXTERNAL (symbolP); 936 symbolP->local = 1; 937 subseg_set (old_sec, old_subsec); 938 } 939 else 940 { 941 S_SET_VALUE (symbolP, (valueT) size); 942 S_SET_ALIGN (symbolP, align); 943 S_SET_EXTERNAL (symbolP); 944 S_SET_SEGMENT (symbolP, bfd_com_section_ptr); 945 } 946 947 symbolP->bsym->flags |= BSF_OBJECT; 948 949 demand_empty_rest_of_line (); 950} 951 952/* Select the cpu we're assembling for. */ 953 954static void 955arc_option (int ignore ATTRIBUTE_UNUSED) 956{ 957 extern int arc_get_mach (char *); 958 int mach; 959 char c; 960 char *cpu; 961 962 cpu = input_line_pointer; 963 c = get_symbol_end (); 964 mach = arc_get_mach (cpu); 965 *input_line_pointer = c; 966 967 /* If an instruction has already been seen, it's too late. */ 968 if (cpu_tables_init_p) 969 { 970 as_bad ("\".option\" directive must appear before any instructions"); 971 ignore_rest_of_line (); 972 return; 973 } 974 975 if (mach == -1) 976 goto bad_cpu; 977 978 if (mach_type_specified_p && mach != arc_mach_type) 979 { 980 as_bad ("\".option\" directive conflicts with initial definition"); 981 ignore_rest_of_line (); 982 return; 983 } 984 else 985 { 986 /* The cpu may have been selected on the command line. */ 987 if (mach != arc_mach_type) 988 as_warn ("\".option\" directive overrides command-line (default) value"); 989 arc_mach_type = mach; 990 if (!bfd_set_arch_mach (stdoutput, bfd_arch_arc, mach)) 991 as_fatal ("could not set architecture and machine"); 992 mach_type_specified_p = 1; 993 } 994 demand_empty_rest_of_line (); 995 return; 996 997 bad_cpu: 998 as_bad ("invalid identifier for \".option\""); 999 ignore_rest_of_line (); 1000} 1001 1002/* Turn a string in input_line_pointer into a floating point constant 1003 of type TYPE, and store the appropriate bytes in *LITP. The number 1004 of LITTLENUMS emitted is stored in *SIZEP. An error message is 1005 returned, or NULL on OK. */ 1006 1007/* Equal to MAX_PRECISION in atof-ieee.c */ 1008#define MAX_LITTLENUMS 6 1009 1010char * 1011md_atof (int type, char *litP, int *sizeP) 1012{ 1013 int prec; 1014 LITTLENUM_TYPE words[MAX_LITTLENUMS]; 1015 LITTLENUM_TYPE *wordP; 1016 char *t; 1017 1018 switch (type) 1019 { 1020 case 'f': 1021 case 'F': 1022 prec = 2; 1023 break; 1024 1025 case 'd': 1026 case 'D': 1027 prec = 4; 1028 break; 1029 1030 default: 1031 *sizeP = 0; 1032 return "bad call to md_atof"; 1033 } 1034 1035 t = atof_ieee (input_line_pointer, type, words); 1036 if (t) 1037 input_line_pointer = t; 1038 *sizeP = prec * sizeof (LITTLENUM_TYPE); 1039 for (wordP = words; prec--;) 1040 { 1041 md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE)); 1042 litP += sizeof (LITTLENUM_TYPE); 1043 } 1044 1045 return NULL; 1046} 1047 1048/* Write a value out to the object file, using the appropriate 1049 endianness. */ 1050 1051void 1052md_number_to_chars (char *buf, valueT val, int n) 1053{ 1054 if (target_big_endian) 1055 number_to_chars_bigendian (buf, val, n); 1056 else 1057 number_to_chars_littleendian (buf, val, n); 1058} 1059 1060/* Round up a section size to the appropriate boundary. */ 1061 1062valueT 1063md_section_align (segT segment, valueT size) 1064{ 1065 int align = bfd_get_section_alignment (stdoutput, segment); 1066 1067 return ((size + (1 << align) - 1) & (-1 << align)); 1068} 1069 1070/* We don't have any form of relaxing. */ 1071 1072int 1073md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED, 1074 asection *seg ATTRIBUTE_UNUSED) 1075{ 1076 as_fatal (_("md_estimate_size_before_relax\n")); 1077 return 1; 1078} 1079 1080/* Convert a machine dependent frag. We never generate these. */ 1081 1082void 1083md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, 1084 asection *sec ATTRIBUTE_UNUSED, 1085 fragS *fragp ATTRIBUTE_UNUSED) 1086{ 1087 as_fatal (_("md_convert_frag\n")); 1088} 1089 1090static void 1091arc_code_symbol (expressionS *expressionP) 1092{ 1093 if (expressionP->X_op == O_symbol && expressionP->X_add_number == 0) 1094 { 1095 expressionS two; 1096 1097 expressionP->X_op = O_right_shift; 1098 expressionP->X_add_symbol->sy_value.X_op = O_constant; 1099 two.X_op = O_constant; 1100 two.X_add_symbol = two.X_op_symbol = NULL; 1101 two.X_add_number = 2; 1102 expressionP->X_op_symbol = make_expr_symbol (&two); 1103 } 1104 /* Allow %st(sym1-sym2) */ 1105 else if (expressionP->X_op == O_subtract 1106 && expressionP->X_add_symbol != NULL 1107 && expressionP->X_op_symbol != NULL 1108 && expressionP->X_add_number == 0) 1109 { 1110 expressionS two; 1111 1112 expressionP->X_add_symbol = make_expr_symbol (expressionP); 1113 expressionP->X_op = O_right_shift; 1114 two.X_op = O_constant; 1115 two.X_add_symbol = two.X_op_symbol = NULL; 1116 two.X_add_number = 2; 1117 expressionP->X_op_symbol = make_expr_symbol (&two); 1118 } 1119 else 1120 as_bad ("expression too complex code symbol"); 1121} 1122 1123/* Parse an operand that is machine-specific. 1124 1125 The ARC has a special %-op to adjust addresses so they're usable in 1126 branches. The "st" is short for the STatus register. 1127 ??? Later expand this to take a flags value too. 1128 1129 ??? We can't create new expression types so we map the %-op's onto the 1130 existing syntax. This means that the user could use the chosen syntax 1131 to achieve the same effect. */ 1132 1133void 1134md_operand (expressionS *expressionP) 1135{ 1136 char *p = input_line_pointer; 1137 1138 if (*p != '%') 1139 return; 1140 1141 if (strncmp (p, "%st(", 4) == 0) 1142 { 1143 input_line_pointer += 4; 1144 expression (expressionP); 1145 if (*input_line_pointer != ')') 1146 { 1147 as_bad ("missing ')' in %%-op"); 1148 return; 1149 } 1150 ++input_line_pointer; 1151 arc_code_symbol (expressionP); 1152 } 1153 else 1154 { 1155 /* It could be a register. */ 1156 int i, l; 1157 struct arc_ext_operand_value *ext_oper = arc_ext_operands; 1158 p++; 1159 1160 while (ext_oper) 1161 { 1162 l = strlen (ext_oper->operand.name); 1163 if (!strncmp (p, ext_oper->operand.name, l) && !ISALNUM (*(p + l))) 1164 { 1165 input_line_pointer += l + 1; 1166 expressionP->X_op = O_register; 1167 expressionP->X_add_number = (offsetT) &ext_oper->operand; 1168 return; 1169 } 1170 ext_oper = ext_oper->next; 1171 } 1172 for (i = 0; i < arc_reg_names_count; i++) 1173 { 1174 l = strlen (arc_reg_names[i].name); 1175 if (!strncmp (p, arc_reg_names[i].name, l) && !ISALNUM (*(p + l))) 1176 { 1177 input_line_pointer += l + 1; 1178 expressionP->X_op = O_register; 1179 expressionP->X_add_number = (offsetT) &arc_reg_names[i]; 1180 break; 1181 } 1182 } 1183 } 1184} 1185 1186/* We have no need to default values of symbols. 1187 We could catch register names here, but that is handled by inserting 1188 them all in the symbol table to begin with. */ 1189 1190symbolS * 1191md_undefined_symbol (char *name ATTRIBUTE_UNUSED) 1192{ 1193 return 0; 1194} 1195 1196/* Functions concerning expressions. */ 1197 1198/* Parse a .byte, .word, etc. expression. 1199 1200 Values for the status register are specified with %st(label). 1201 `label' will be right shifted by 2. */ 1202 1203void 1204arc_parse_cons_expression (expressionS *exp, 1205 unsigned int nbytes ATTRIBUTE_UNUSED) 1206{ 1207 char *p = input_line_pointer; 1208 int code_symbol_fix = 0; 1209 1210 for (; ! is_end_of_line[(unsigned char) *p]; p++) 1211 if (*p == '@' && !strncmp (p, "@h30", 4)) 1212 { 1213 code_symbol_fix = 1; 1214 strcpy (p, "; "); 1215 } 1216 expression_and_evaluate (exp); 1217 if (code_symbol_fix) 1218 { 1219 arc_code_symbol (exp); 1220 input_line_pointer = p; 1221 } 1222} 1223 1224/* Record a fixup for a cons expression. */ 1225 1226void 1227arc_cons_fix_new (fragS *frag, 1228 int where, 1229 int nbytes, 1230 expressionS *exp) 1231{ 1232 if (nbytes == 4) 1233 { 1234 int reloc_type; 1235 expressionS exptmp; 1236 1237 /* This may be a special ARC reloc (eg: %st()). */ 1238 reloc_type = get_arc_exp_reloc_type (1, BFD_RELOC_32, exp, &exptmp); 1239 fix_new_exp (frag, where, nbytes, &exptmp, 0, reloc_type); 1240 } 1241 else 1242 { 1243 fix_new_exp (frag, where, nbytes, exp, 0, 1244 nbytes == 2 ? BFD_RELOC_16 1245 : nbytes == 8 ? BFD_RELOC_64 1246 : BFD_RELOC_32); 1247 } 1248} 1249 1250/* Functions concerning relocs. */ 1251 1252/* The location from which a PC relative jump should be calculated, 1253 given a PC relative reloc. */ 1254 1255long 1256md_pcrel_from (fixS *fixP) 1257{ 1258 /* Return the address of the delay slot. */ 1259 return fixP->fx_frag->fr_address + fixP->fx_where + fixP->fx_size; 1260} 1261 1262/* Apply a fixup to the object code. This is called for all the 1263 fixups we generated by the call to fix_new_exp, above. In the call 1264 above we used a reloc code which was the largest legal reloc code 1265 plus the operand index. Here we undo that to recover the operand 1266 index. At this point all symbol values should be fully resolved, 1267 and we attempt to completely resolve the reloc. If we can not do 1268 that, we determine the correct reloc code and put it back in the fixup. */ 1269 1270void 1271md_apply_fix (fixS *fixP, valueT * valP, segT seg) 1272{ 1273 valueT value = * valP; 1274 1275 if (fixP->fx_addsy == (symbolS *) NULL) 1276 fixP->fx_done = 1; 1277 1278 else if (fixP->fx_pcrel) 1279 { 1280 /* Hack around bfd_install_relocation brain damage. */ 1281 if (S_GET_SEGMENT (fixP->fx_addsy) != seg) 1282 value += md_pcrel_from (fixP); 1283 } 1284 1285 /* We can't actually support subtracting a symbol. */ 1286 if (fixP->fx_subsy != NULL) 1287 as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex")); 1288 1289 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED) 1290 { 1291 int opindex; 1292 const struct arc_operand *operand; 1293 char *where; 1294 arc_insn insn; 1295 1296 opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED; 1297 1298 operand = &arc_operands[opindex]; 1299 1300 /* Fetch the instruction, insert the fully resolved operand 1301 value, and stuff the instruction back again. */ 1302 where = fixP->fx_frag->fr_literal + fixP->fx_where; 1303 if (target_big_endian) 1304 insn = bfd_getb32 ((unsigned char *) where); 1305 else 1306 insn = bfd_getl32 ((unsigned char *) where); 1307 insn = arc_insert_operand (insn, operand, -1, NULL, (offsetT) value, 1308 fixP->fx_file, fixP->fx_line); 1309 if (target_big_endian) 1310 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where); 1311 else 1312 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where); 1313 1314 if (fixP->fx_done) 1315 /* Nothing else to do here. */ 1316 return; 1317 1318 /* Determine a BFD reloc value based on the operand information. 1319 We are only prepared to turn a few of the operands into relocs. 1320 !!! Note that we can't handle limm values here. Since we're using 1321 implicit addends the addend must be inserted into the instruction, 1322 however, the opcode insertion routines currently do nothing with 1323 limm values. */ 1324 if (operand->fmt == 'B') 1325 { 1326 assert ((operand->flags & ARC_OPERAND_RELATIVE_BRANCH) != 0 1327 && operand->bits == 20 1328 && operand->shift == 7); 1329 fixP->fx_r_type = BFD_RELOC_ARC_B22_PCREL; 1330 } 1331 else if (operand->fmt == 'J') 1332 { 1333 assert ((operand->flags & ARC_OPERAND_ABSOLUTE_BRANCH) != 0 1334 && operand->bits == 24 1335 && operand->shift == 32); 1336 fixP->fx_r_type = BFD_RELOC_ARC_B26; 1337 } 1338 else if (operand->fmt == 'L') 1339 { 1340 assert ((operand->flags & ARC_OPERAND_LIMM) != 0 1341 && operand->bits == 32 1342 && operand->shift == 32); 1343 fixP->fx_r_type = BFD_RELOC_32; 1344 } 1345 else 1346 { 1347 as_bad_where (fixP->fx_file, fixP->fx_line, 1348 "unresolved expression that must be resolved"); 1349 fixP->fx_done = 1; 1350 return; 1351 } 1352 } 1353 else 1354 { 1355 switch (fixP->fx_r_type) 1356 { 1357 case BFD_RELOC_8: 1358 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where, 1359 value, 1); 1360 break; 1361 case BFD_RELOC_16: 1362 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where, 1363 value, 2); 1364 break; 1365 case BFD_RELOC_32: 1366 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where, 1367 value, 4); 1368 break; 1369 case BFD_RELOC_ARC_B26: 1370 /* If !fixP->fx_done then `value' is an implicit addend. 1371 We must shift it right by 2 in this case as well because the 1372 linker performs the relocation and then adds this in (as opposed 1373 to adding this in and then shifting right by 2). */ 1374 value >>= 2; 1375 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where, 1376 value, 4); 1377 break; 1378 default: 1379 abort (); 1380 } 1381 } 1382} 1383 1384/* Translate internal representation of relocation info to BFD target 1385 format. */ 1386 1387arelent * 1388tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, 1389 fixS *fixP) 1390{ 1391 arelent *reloc; 1392 1393 reloc = xmalloc (sizeof (arelent)); 1394 reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *)); 1395 1396 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy); 1397 reloc->address = fixP->fx_frag->fr_address + fixP->fx_where; 1398 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type); 1399 if (reloc->howto == (reloc_howto_type *) NULL) 1400 { 1401 as_bad_where (fixP->fx_file, fixP->fx_line, 1402 "internal error: can't export reloc type %d (`%s')", 1403 fixP->fx_r_type, 1404 bfd_get_reloc_code_name (fixP->fx_r_type)); 1405 return NULL; 1406 } 1407 1408 assert (!fixP->fx_pcrel == !reloc->howto->pc_relative); 1409 1410 /* Set addend to account for PC being advanced one insn before the 1411 target address is computed. */ 1412 1413 reloc->addend = (fixP->fx_pcrel ? -4 : 0); 1414 1415 return reloc; 1416} 1417 1418const pseudo_typeS md_pseudo_table[] = 1419{ 1420 { "align", s_align_bytes, 0 }, /* Defaulting is invalid (0). */ 1421 { "comm", arc_common, 0 }, 1422 { "common", arc_common, 0 }, 1423 { "lcomm", arc_common, 1 }, 1424 { "lcommon", arc_common, 1 }, 1425 { "2byte", cons, 2 }, 1426 { "half", cons, 2 }, 1427 { "short", cons, 2 }, 1428 { "3byte", cons, 3 }, 1429 { "4byte", cons, 4 }, 1430 { "word", cons, 4 }, 1431 { "option", arc_option, 0 }, 1432 { "cpu", arc_option, 0 }, 1433 { "block", s_space, 0 }, 1434 { "extcondcode", arc_extoper, 0 }, 1435 { "extcoreregister", arc_extoper, 1 }, 1436 { "extauxregister", arc_extoper, 2 }, 1437 { "extinstruction", arc_extinst, 0 }, 1438 { NULL, 0, 0 }, 1439}; 1440 1441/* This routine is called for each instruction to be assembled. */ 1442 1443void 1444md_assemble (char *str) 1445{ 1446 const struct arc_opcode *opcode; 1447 const struct arc_opcode *std_opcode; 1448 struct arc_opcode *ext_opcode; 1449 char *start; 1450 const char *last_errmsg = 0; 1451 arc_insn insn; 1452 static int init_tables_p = 0; 1453 1454 /* Opcode table initialization is deferred until here because we have to 1455 wait for a possible .option command. */ 1456 if (!init_tables_p) 1457 { 1458 init_opcode_tables (arc_mach_type); 1459 init_tables_p = 1; 1460 } 1461 1462 /* Skip leading white space. */ 1463 while (ISSPACE (*str)) 1464 str++; 1465 1466 /* The instructions are stored in lists hashed by the first letter (though 1467 we needn't care how they're hashed). Get the first in the list. */ 1468 1469 ext_opcode = arc_ext_opcodes; 1470 std_opcode = arc_opcode_lookup_asm (str); 1471 1472 /* Keep looking until we find a match. */ 1473 start = str; 1474 for (opcode = (ext_opcode ? ext_opcode : std_opcode); 1475 opcode != NULL; 1476 opcode = (ARC_OPCODE_NEXT_ASM (opcode) 1477 ? ARC_OPCODE_NEXT_ASM (opcode) 1478 : (ext_opcode ? ext_opcode = NULL, std_opcode : NULL))) 1479 { 1480 int past_opcode_p, fc, num_suffixes; 1481 int fix_up_at = 0; 1482 char *syn; 1483 struct arc_fixup fixups[MAX_FIXUPS]; 1484 /* Used as a sanity check. If we need a limm reloc, make sure we ask 1485 for an extra 4 bytes from frag_more. */ 1486 int limm_reloc_p; 1487 int ext_suffix_p; 1488 const struct arc_operand_value *insn_suffixes[MAX_SUFFIXES]; 1489 1490 /* Is this opcode supported by the selected cpu? */ 1491 if (! arc_opcode_supported (opcode)) 1492 continue; 1493 1494 /* Scan the syntax string. If it doesn't match, try the next one. */ 1495 arc_opcode_init_insert (); 1496 insn = opcode->value; 1497 fc = 0; 1498 past_opcode_p = 0; 1499 num_suffixes = 0; 1500 limm_reloc_p = 0; 1501 ext_suffix_p = 0; 1502 1503 /* We don't check for (*str != '\0') here because we want to parse 1504 any trailing fake arguments in the syntax string. */ 1505 for (str = start, syn = opcode->syntax; *syn != '\0';) 1506 { 1507 int mods; 1508 const struct arc_operand *operand; 1509 1510 /* Non operand chars must match exactly. */ 1511 if (*syn != '%' || *++syn == '%') 1512 { 1513 if (*str == *syn) 1514 { 1515 if (*syn == ' ') 1516 past_opcode_p = 1; 1517 ++syn; 1518 ++str; 1519 } 1520 else 1521 break; 1522 continue; 1523 } 1524 1525 /* We have an operand. Pick out any modifiers. */ 1526 mods = 0; 1527 while (ARC_MOD_P (arc_operands[arc_operand_map[(int) *syn]].flags)) 1528 { 1529 mods |= arc_operands[arc_operand_map[(int) *syn]].flags & ARC_MOD_BITS; 1530 ++syn; 1531 } 1532 operand = arc_operands + arc_operand_map[(int) *syn]; 1533 if (operand->fmt == 0) 1534 as_fatal ("unknown syntax format character `%c'", *syn); 1535 1536 if (operand->flags & ARC_OPERAND_FAKE) 1537 { 1538 const char *errmsg = NULL; 1539 if (operand->insert) 1540 { 1541 insn = (*operand->insert) (insn, operand, mods, NULL, 0, &errmsg); 1542 if (errmsg != (const char *) NULL) 1543 { 1544 last_errmsg = errmsg; 1545 if (operand->flags & ARC_OPERAND_ERROR) 1546 { 1547 as_bad (errmsg); 1548 return; 1549 } 1550 else if (operand->flags & ARC_OPERAND_WARN) 1551 as_warn (errmsg); 1552 break; 1553 } 1554 if (limm_reloc_p 1555 && (operand->flags && operand->flags & ARC_OPERAND_LIMM) 1556 && (operand->flags & 1557 (ARC_OPERAND_ABSOLUTE_BRANCH | ARC_OPERAND_ADDRESS))) 1558 { 1559 fixups[fix_up_at].opindex = arc_operand_map[operand->fmt]; 1560 } 1561 } 1562 ++syn; 1563 } 1564 /* Are we finished with suffixes? */ 1565 else if (!past_opcode_p) 1566 { 1567 int found; 1568 char c; 1569 char *s, *t; 1570 const struct arc_operand_value *suf, *suffix_end; 1571 const struct arc_operand_value *suffix = NULL; 1572 1573 if (!(operand->flags & ARC_OPERAND_SUFFIX)) 1574 abort (); 1575 1576 /* If we're at a space in the input string, we want to skip the 1577 remaining suffixes. There may be some fake ones though, so 1578 just go on to try the next one. */ 1579 if (*str == ' ') 1580 { 1581 ++syn; 1582 continue; 1583 } 1584 1585 s = str; 1586 if (mods & ARC_MOD_DOT) 1587 { 1588 if (*s != '.') 1589 break; 1590 ++s; 1591 } 1592 else 1593 { 1594 /* This can happen in "b.nd foo" and we're currently looking 1595 for "%q" (ie: a condition code suffix). */ 1596 if (*s == '.') 1597 { 1598 ++syn; 1599 continue; 1600 } 1601 } 1602 1603 /* Pick the suffix out and look it up via the hash table. */ 1604 for (t = s; *t && ISALNUM (*t); ++t) 1605 continue; 1606 c = *t; 1607 *t = '\0'; 1608 if ((suf = get_ext_suffix (s))) 1609 ext_suffix_p = 1; 1610 else 1611 suf = hash_find (arc_suffix_hash, s); 1612 if (!suf) 1613 { 1614 /* This can happen in "blle foo" and we're currently using 1615 the template "b%q%.n %j". The "bl" insn occurs later in 1616 the table so "lle" isn't an illegal suffix. */ 1617 *t = c; 1618 break; 1619 } 1620 1621 /* Is it the right type? Note that the same character is used 1622 several times, so we have to examine all of them. This is 1623 relatively efficient as equivalent entries are kept 1624 together. If it's not the right type, don't increment `str' 1625 so we try the next one in the series. */ 1626 found = 0; 1627 if (ext_suffix_p && arc_operands[suf->type].fmt == *syn) 1628 { 1629 /* Insert the suffix's value into the insn. */ 1630 *t = c; 1631 if (operand->insert) 1632 insn = (*operand->insert) (insn, operand, 1633 mods, NULL, suf->value, 1634 NULL); 1635 else 1636 insn |= suf->value << operand->shift; 1637 suffix = suf; 1638 str = t; 1639 found = 1; 1640 } 1641 else 1642 { 1643 *t = c; 1644 suffix_end = arc_suffixes + arc_suffixes_count; 1645 for (suffix = suf; 1646 suffix < suffix_end && strcmp (suffix->name, suf->name) == 0; 1647 ++suffix) 1648 { 1649 if (arc_operands[suffix->type].fmt == *syn) 1650 { 1651 /* Insert the suffix's value into the insn. */ 1652 if (operand->insert) 1653 insn = (*operand->insert) (insn, operand, 1654 mods, NULL, suffix->value, 1655 NULL); 1656 else 1657 insn |= suffix->value << operand->shift; 1658 1659 str = t; 1660 found = 1; 1661 break; 1662 } 1663 } 1664 } 1665 ++syn; 1666 if (!found) 1667 /* Wrong type. Just go on to try next insn entry. */ 1668 ; 1669 else 1670 { 1671 if (num_suffixes == MAX_SUFFIXES) 1672 as_bad ("too many suffixes"); 1673 else 1674 insn_suffixes[num_suffixes++] = suffix; 1675 } 1676 } 1677 else 1678 /* This is either a register or an expression of some kind. */ 1679 { 1680 char *hold; 1681 const struct arc_operand_value *reg = NULL; 1682 long value = 0; 1683 expressionS exp; 1684 1685 if (operand->flags & ARC_OPERAND_SUFFIX) 1686 abort (); 1687 1688 /* Is there anything left to parse? 1689 We don't check for this at the top because we want to parse 1690 any trailing fake arguments in the syntax string. */ 1691 if (is_end_of_line[(unsigned char) *str]) 1692 break; 1693 1694 /* Parse the operand. */ 1695 hold = input_line_pointer; 1696 input_line_pointer = str; 1697 expression (&exp); 1698 str = input_line_pointer; 1699 input_line_pointer = hold; 1700 1701 if (exp.X_op == O_illegal) 1702 as_bad ("illegal operand"); 1703 else if (exp.X_op == O_absent) 1704 as_bad ("missing operand"); 1705 else if (exp.X_op == O_constant) 1706 value = exp.X_add_number; 1707 else if (exp.X_op == O_register) 1708 reg = (struct arc_operand_value *) exp.X_add_number; 1709#define IS_REG_DEST_OPERAND(o) ((o) == 'a') 1710 else if (IS_REG_DEST_OPERAND (*syn)) 1711 as_bad ("symbol as destination register"); 1712 else 1713 { 1714 if (!strncmp (str, "@h30", 4)) 1715 { 1716 arc_code_symbol (&exp); 1717 str += 4; 1718 } 1719 /* We need to generate a fixup for this expression. */ 1720 if (fc >= MAX_FIXUPS) 1721 as_fatal ("too many fixups"); 1722 fixups[fc].exp = exp; 1723 /* We don't support shimm relocs. break here to force 1724 the assembler to output a limm. */ 1725#define IS_REG_SHIMM_OFFSET(o) ((o) == 'd') 1726 if (IS_REG_SHIMM_OFFSET (*syn)) 1727 break; 1728 /* If this is a register constant (IE: one whose 1729 register value gets stored as 61-63) then this 1730 must be a limm. */ 1731 /* ??? This bit could use some cleaning up. 1732 Referencing the format chars like this goes 1733 against style. */ 1734 if (IS_SYMBOL_OPERAND (*syn)) 1735 { 1736 const char *junk; 1737 limm_reloc_p = 1; 1738 /* Save this, we don't yet know what reloc to use. */ 1739 fix_up_at = fc; 1740 /* Tell insert_reg we need a limm. This is 1741 needed because the value at this point is 1742 zero, a shimm. */ 1743 /* ??? We need a cleaner interface than this. */ 1744 (*arc_operands[arc_operand_map['Q']].insert) 1745 (insn, operand, mods, reg, 0L, &junk); 1746 } 1747 else 1748 fixups[fc].opindex = arc_operand_map[(int) *syn]; 1749 ++fc; 1750 value = 0; 1751 } 1752 1753 /* Insert the register or expression into the instruction. */ 1754 if (operand->insert) 1755 { 1756 const char *errmsg = NULL; 1757 insn = (*operand->insert) (insn, operand, mods, 1758 reg, (long) value, &errmsg); 1759 if (errmsg != (const char *) NULL) 1760 { 1761 last_errmsg = errmsg; 1762 if (operand->flags & ARC_OPERAND_ERROR) 1763 { 1764 as_bad (errmsg); 1765 return; 1766 } 1767 else if (operand->flags & ARC_OPERAND_WARN) 1768 as_warn (errmsg); 1769 break; 1770 } 1771 } 1772 else 1773 insn |= (value & ((1 << operand->bits) - 1)) << operand->shift; 1774 1775 ++syn; 1776 } 1777 } 1778 1779 /* If we're at the end of the syntax string, we're done. */ 1780 /* FIXME: try to move this to a separate function. */ 1781 if (*syn == '\0') 1782 { 1783 int i; 1784 char *f; 1785 long limm, limm_p; 1786 1787 /* For the moment we assume a valid `str' can only contain blanks 1788 now. IE: We needn't try again with a longer version of the 1789 insn and it is assumed that longer versions of insns appear 1790 before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */ 1791 1792 while (ISSPACE (*str)) 1793 ++str; 1794 1795 if (!is_end_of_line[(unsigned char) *str]) 1796 as_bad ("junk at end of line: `%s'", str); 1797 1798 /* Is there a limm value? */ 1799 limm_p = arc_opcode_limm_p (&limm); 1800 1801 /* Perform various error and warning tests. */ 1802 1803 { 1804 static int in_delay_slot_p = 0; 1805 static int prev_insn_needs_cc_nop_p = 0; 1806 /* delay slot type seen */ 1807 int delay_slot_type = ARC_DELAY_NONE; 1808 /* conditional execution flag seen */ 1809 int conditional = 0; 1810 /* 1 if condition codes are being set */ 1811 int cc_set_p = 0; 1812 /* 1 if conditional branch, including `b' "branch always" */ 1813 int cond_branch_p = opcode->flags & ARC_OPCODE_COND_BRANCH; 1814 1815 for (i = 0; i < num_suffixes; ++i) 1816 { 1817 switch (arc_operands[insn_suffixes[i]->type].fmt) 1818 { 1819 case 'n': 1820 delay_slot_type = insn_suffixes[i]->value; 1821 break; 1822 case 'q': 1823 conditional = insn_suffixes[i]->value; 1824 break; 1825 case 'f': 1826 cc_set_p = 1; 1827 break; 1828 } 1829 } 1830 1831 /* Putting an insn with a limm value in a delay slot is supposed to 1832 be legal, but let's warn the user anyway. Ditto for 8 byte 1833 jumps with delay slots. */ 1834 if (in_delay_slot_p && limm_p) 1835 as_warn ("8 byte instruction in delay slot"); 1836 if (delay_slot_type != ARC_DELAY_NONE 1837 && limm_p && arc_insn_not_jl (insn)) /* except for jl addr */ 1838 as_warn ("8 byte jump instruction with delay slot"); 1839 in_delay_slot_p = (delay_slot_type != ARC_DELAY_NONE) && !limm_p; 1840 1841 /* Warn when a conditional branch immediately follows a set of 1842 the condition codes. Note that this needn't be done if the 1843 insn that sets the condition codes uses a limm. */ 1844 if (cond_branch_p && conditional != 0 /* 0 = "always" */ 1845 && prev_insn_needs_cc_nop_p && arc_mach_type == bfd_mach_arc_5) 1846 as_warn ("conditional branch follows set of flags"); 1847 prev_insn_needs_cc_nop_p = 1848 /* FIXME: ??? not required: 1849 (delay_slot_type != ARC_DELAY_NONE) && */ 1850 cc_set_p && !limm_p; 1851 } 1852 1853 /* Write out the instruction. 1854 It is important to fetch enough space in one call to `frag_more'. 1855 We use (f - frag_now->fr_literal) to compute where we are and we 1856 don't want frag_now to change between calls. */ 1857 if (limm_p) 1858 { 1859 f = frag_more (8); 1860 md_number_to_chars (f, insn, 4); 1861 md_number_to_chars (f + 4, limm, 4); 1862 dwarf2_emit_insn (8); 1863 } 1864 else if (limm_reloc_p) 1865 /* We need a limm reloc, but the tables think we don't. */ 1866 abort (); 1867 else 1868 { 1869 f = frag_more (4); 1870 md_number_to_chars (f, insn, 4); 1871 dwarf2_emit_insn (4); 1872 } 1873 1874 /* Create any fixups. */ 1875 for (i = 0; i < fc; ++i) 1876 { 1877 int op_type, reloc_type; 1878 expressionS exptmp; 1879 const struct arc_operand *operand; 1880 1881 /* Create a fixup for this operand. 1882 At this point we do not use a bfd_reloc_code_real_type for 1883 operands residing in the insn, but instead just use the 1884 operand index. This lets us easily handle fixups for any 1885 operand type, although that is admittedly not a very exciting 1886 feature. We pick a BFD reloc type in md_apply_fix. 1887 1888 Limm values (4 byte immediate "constants") must be treated 1889 normally because they're not part of the actual insn word 1890 and thus the insertion routines don't handle them. */ 1891 1892 if (arc_operands[fixups[i].opindex].flags & ARC_OPERAND_LIMM) 1893 { 1894 /* Modify the fixup addend as required by the cpu. */ 1895 fixups[i].exp.X_add_number += arc_limm_fixup_adjust (insn); 1896 op_type = fixups[i].opindex; 1897 /* FIXME: can we add this data to the operand table? */ 1898 if (op_type == arc_operand_map['L'] 1899 || op_type == arc_operand_map['s'] 1900 || op_type == arc_operand_map['o'] 1901 || op_type == arc_operand_map['O']) 1902 reloc_type = BFD_RELOC_32; 1903 else if (op_type == arc_operand_map['J']) 1904 reloc_type = BFD_RELOC_ARC_B26; 1905 else 1906 abort (); 1907 reloc_type = get_arc_exp_reloc_type (1, reloc_type, 1908 &fixups[i].exp, 1909 &exptmp); 1910 } 1911 else 1912 { 1913 op_type = get_arc_exp_reloc_type (0, fixups[i].opindex, 1914 &fixups[i].exp, &exptmp); 1915 reloc_type = op_type + (int) BFD_RELOC_UNUSED; 1916 } 1917 operand = &arc_operands[op_type]; 1918 fix_new_exp (frag_now, 1919 ((f - frag_now->fr_literal) 1920 + (operand->flags & ARC_OPERAND_LIMM ? 4 : 0)), 4, 1921 &exptmp, 1922 (operand->flags & ARC_OPERAND_RELATIVE_BRANCH) != 0, 1923 (bfd_reloc_code_real_type) reloc_type); 1924 } 1925 return; 1926 } 1927 } 1928 1929 if (NULL == last_errmsg) 1930 as_bad ("bad instruction `%s'", start); 1931 else 1932 as_bad (last_errmsg); 1933} 1934