1/* tc-mmix.c -- Assembler for Don Knuth's MMIX. 2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 3 Free Software Foundation. 4 5 This file is part of GAS, the GNU Assembler. 6 7 GAS is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GAS is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GAS; see the file COPYING. If not, write to 19 the Free Software Foundation, 51 Franklin Street - Fifth Floor, 20 Boston, MA 02110-1301, USA. */ 21 22/* Knuth's assembler mmixal does not provide a relocatable format; mmo is 23 to be considered a final link-format. In the final link, we make mmo, 24 but for relocatable files, we use ELF. 25 26 One goal is to provide a superset of what mmixal does, including 27 compatible syntax, but the main purpose is to serve GCC. */ 28 29 30#include <limits.h> 31#include "as.h" 32#include "subsegs.h" 33#include "elf/mmix.h" 34#include "opcode/mmix.h" 35#include "safe-ctype.h" 36#include "dwarf2dbg.h" 37#include "obstack.h" 38 39/* Something to describe what we need to do with a fixup before output, 40 for example assert something of what it became or make a relocation. */ 41 42enum mmix_fixup_action 43 { 44 mmix_fixup_byte, 45 mmix_fixup_register, 46 mmix_fixup_register_or_adjust_for_byte 47 }; 48 49static int get_spec_regno (char *); 50static int get_operands (int, char *, expressionS *); 51static int get_putget_operands (struct mmix_opcode *, char *, expressionS *); 52static void s_prefix (int); 53static void s_greg (int); 54static void s_loc (int); 55static void s_bspec (int); 56static void s_espec (int); 57static void mmix_s_local (int); 58static void mmix_greg_internal (char *); 59static void mmix_set_geta_branch_offset (char *, offsetT); 60static void mmix_set_jmp_offset (char *, offsetT); 61static void mmix_fill_nops (char *, int); 62static int cmp_greg_symbol_fixes (const void *, const void *); 63static int cmp_greg_val_greg_symbol_fixes (const void *, const void *); 64static void mmix_handle_rest_of_empty_line (void); 65static void mmix_discard_rest_of_line (void); 66static void mmix_byte (void); 67static void mmix_cons (int); 68 69/* Continue the tradition of symbols.c; use control characters to enforce 70 magic. These are used when replacing e.g. 8F and 8B so we can handle 71 such labels correctly with the common parser hooks. */ 72#define MAGIC_FB_BACKWARD_CHAR '\003' 73#define MAGIC_FB_FORWARD_CHAR '\004' 74 75/* Copy the location of a frag to a fix. */ 76#define COPY_FR_WHERE_TO_FX(FRAG, FIX) \ 77 do \ 78 { \ 79 (FIX)->fx_file = (FRAG)->fr_file; \ 80 (FIX)->fx_line = (FRAG)->fr_line; \ 81 } \ 82 while (0) 83 84const char *md_shortopts = "x"; 85static int current_fb_label = -1; 86static char *pending_label = NULL; 87 88static bfd_vma lowest_text_loc = (bfd_vma) -1; 89static int text_has_contents = 0; 90 91/* The alignment of the previous instruction, and a boolean for whether we 92 want to avoid aligning the next WYDE, TETRA, OCTA or insn. */ 93static int last_alignment = 0; 94static int want_unaligned = 0; 95 96static bfd_vma lowest_data_loc = (bfd_vma) -1; 97static int data_has_contents = 0; 98 99/* The fragS of the instruction being assembled. Only valid from within 100 md_assemble. */ 101fragS *mmix_opcode_frag = NULL; 102 103/* Raw GREGs as appearing in input. These may be fewer than the number 104 after relaxing. */ 105static int n_of_raw_gregs = 0; 106static struct 107 { 108 char *label; 109 expressionS exp; 110 } mmix_raw_gregs[MAX_GREGS]; 111 112/* Fixups for all unique GREG registers. We store the fixups here in 113 md_convert_frag, then we use the array to convert 114 BFD_RELOC_MMIX_BASE_PLUS_OFFSET fixups in tc_gen_reloc. The index is 115 just a running number and is not supposed to be correlated to a 116 register number. */ 117static fixS *mmix_gregs[MAX_GREGS]; 118static int n_of_cooked_gregs = 0; 119 120/* Pointing to the register section we use for output. */ 121static asection *real_reg_section; 122 123/* For each symbol; unknown or section symbol, we keep a list of GREG 124 definitions sorted on increasing offset. It seems no use keeping count 125 to allocate less room than the maximum number of gregs when we've found 126 one for a section or symbol. */ 127struct mmix_symbol_gregs 128 { 129 int n_gregs; 130 struct mmix_symbol_greg_fixes 131 { 132 fixS *fix; 133 134 /* A signed type, since we may have GREGs pointing slightly before the 135 contents of a section. */ 136 offsetT offs; 137 } greg_fixes[MAX_GREGS]; 138 }; 139 140/* Should read insert a colon on something that starts in column 0 on 141 this line? */ 142static int label_without_colon_this_line = 1; 143 144/* Should we automatically expand instructions into multiple insns in 145 order to generate working code? */ 146static int expand_op = 1; 147 148/* Should we warn when expanding operands? FIXME: test-cases for when -x 149 is absent. */ 150static int warn_on_expansion = 1; 151 152/* Should we merge non-zero GREG register definitions? */ 153static int merge_gregs = 1; 154 155/* Should we pass on undefined BFD_RELOC_MMIX_BASE_PLUS_OFFSET relocs 156 (missing suitable GREG definitions) to the linker? */ 157static int allocate_undefined_gregs_in_linker = 0; 158 159/* Should we emit built-in symbols? */ 160static int predefined_syms = 1; 161 162/* Should we allow anything but the listed special register name 163 (e.g. equated symbols)? */ 164static int equated_spec_regs = 1; 165 166/* Do we require standard GNU syntax? */ 167int mmix_gnu_syntax = 0; 168 169/* Do we globalize all symbols? */ 170int mmix_globalize_symbols = 0; 171 172/* When expanding insns, do we want to expand PUSHJ as a call to a stub 173 (or else as a series of insns)? */ 174int pushj_stubs = 1; 175 176/* Do we know that the next semicolon is at the end of the operands field 177 (in mmixal mode; constant 1 in GNU mode)? */ 178int mmix_next_semicolon_is_eoln = 1; 179 180/* Do we have a BSPEC in progress? */ 181static int doing_bspec = 0; 182static char *bspec_file; 183static unsigned int bspec_line; 184 185struct option md_longopts[] = 186 { 187#define OPTION_RELAX (OPTION_MD_BASE) 188#define OPTION_NOEXPAND (OPTION_RELAX + 1) 189#define OPTION_NOMERGEGREG (OPTION_NOEXPAND + 1) 190#define OPTION_NOSYMS (OPTION_NOMERGEGREG + 1) 191#define OPTION_GNU_SYNTAX (OPTION_NOSYMS + 1) 192#define OPTION_GLOBALIZE_SYMBOLS (OPTION_GNU_SYNTAX + 1) 193#define OPTION_FIXED_SPEC_REGS (OPTION_GLOBALIZE_SYMBOLS + 1) 194#define OPTION_LINKER_ALLOCATED_GREGS (OPTION_FIXED_SPEC_REGS + 1) 195#define OPTION_NOPUSHJSTUBS (OPTION_LINKER_ALLOCATED_GREGS + 1) 196 {"linkrelax", no_argument, NULL, OPTION_RELAX}, 197 {"no-expand", no_argument, NULL, OPTION_NOEXPAND}, 198 {"no-merge-gregs", no_argument, NULL, OPTION_NOMERGEGREG}, 199 {"no-predefined-syms", no_argument, NULL, OPTION_NOSYMS}, 200 {"gnu-syntax", no_argument, NULL, OPTION_GNU_SYNTAX}, 201 {"globalize-symbols", no_argument, NULL, OPTION_GLOBALIZE_SYMBOLS}, 202 {"fixed-special-register-names", no_argument, NULL, 203 OPTION_FIXED_SPEC_REGS}, 204 {"linker-allocated-gregs", no_argument, NULL, 205 OPTION_LINKER_ALLOCATED_GREGS}, 206 {"no-pushj-stubs", no_argument, NULL, OPTION_NOPUSHJSTUBS}, 207 {"no-stubs", no_argument, NULL, OPTION_NOPUSHJSTUBS}, 208 {NULL, no_argument, NULL, 0} 209 }; 210 211size_t md_longopts_size = sizeof (md_longopts); 212 213static struct hash_control *mmix_opcode_hash; 214 215/* We use these when implementing the PREFIX pseudo. */ 216char *mmix_current_prefix; 217struct obstack mmix_sym_obstack; 218 219 220/* For MMIX, we encode the relax_substateT:s (in e.g. fr_substate) as one 221 bit length, and the relax-type shifted on top of that. There seems to 222 be no point in making the relaxation more fine-grained; the linker does 223 that better and we might interfere by changing non-optimal relaxations 224 into other insns that cannot be relaxed as easily. 225 226 Groups for MMIX relaxing: 227 228 1. GETA 229 extra length: zero or three insns. 230 231 2. Bcc 232 extra length: zero or five insns. 233 234 3. PUSHJ 235 extra length: zero or four insns. 236 Special handling to deal with transition to PUSHJSTUB. 237 238 4. JMP 239 extra length: zero or four insns. 240 241 5. GREG 242 special handling, allocates a named global register unless another 243 is within reach for all uses. 244 245 6. PUSHJSTUB 246 special handling (mostly) for external references; assumes the 247 linker will generate a stub if target is no longer than 256k from 248 the end of the section plus max size of previous stubs. Zero or 249 four insns. */ 250 251#define STATE_GETA (1) 252#define STATE_BCC (2) 253#define STATE_PUSHJ (3) 254#define STATE_JMP (4) 255#define STATE_GREG (5) 256#define STATE_PUSHJSTUB (6) 257 258/* No fine-grainedness here. */ 259#define STATE_LENGTH_MASK (1) 260 261#define STATE_ZERO (0) 262#define STATE_MAX (1) 263 264/* More descriptive name for convenience. */ 265/* FIXME: We should start on something different, not MAX. */ 266#define STATE_UNDF STATE_MAX 267 268/* FIXME: For GREG, we must have other definitions; UNDF == MAX isn't 269 appropriate; we need it the other way round. This value together with 270 fragP->tc_frag_data shows what state the frag is in: tc_frag_data 271 non-NULL means 0, NULL means 8 bytes. */ 272#define STATE_GREG_UNDF ENCODE_RELAX (STATE_GREG, STATE_ZERO) 273#define STATE_GREG_DEF ENCODE_RELAX (STATE_GREG, STATE_MAX) 274 275/* These displacements are relative to the address following the opcode 276 word of the instruction. The catch-all states have zero for "reach" 277 and "next" entries. */ 278 279#define GETA_0F (65536 * 4 - 8) 280#define GETA_0B (-65536 * 4 - 4) 281 282#define GETA_MAX_LEN 4 * 4 283#define GETA_3F 0 284#define GETA_3B 0 285 286#define BCC_0F GETA_0F 287#define BCC_0B GETA_0B 288 289#define BCC_MAX_LEN 6 * 4 290#define BCC_5F GETA_3F 291#define BCC_5B GETA_3B 292 293#define PUSHJ_0F GETA_0F 294#define PUSHJ_0B GETA_0B 295 296#define PUSHJ_MAX_LEN 5 * 4 297#define PUSHJ_4F GETA_3F 298#define PUSHJ_4B GETA_3B 299 300/* We'll very rarely have sections longer than LONG_MAX, but we'll make a 301 feeble attempt at getting 64-bit values. */ 302#define PUSHJSTUB_MAX ((offsetT) (((addressT) -1) >> 1)) 303#define PUSHJSTUB_MIN (-PUSHJSTUB_MAX - 1) 304 305#define JMP_0F (65536 * 256 * 4 - 8) 306#define JMP_0B (-65536 * 256 * 4 - 4) 307 308#define JMP_MAX_LEN 5 * 4 309#define JMP_4F 0 310#define JMP_4B 0 311 312#define RELAX_ENCODE_SHIFT 1 313#define ENCODE_RELAX(what, length) (((what) << RELAX_ENCODE_SHIFT) + (length)) 314 315const relax_typeS mmix_relax_table[] = 316 { 317 /* Error sentinel (0, 0). */ 318 {1, 1, 0, 0}, 319 320 /* Unused (0, 1). */ 321 {1, 1, 0, 0}, 322 323 /* GETA (1, 0). */ 324 {GETA_0F, GETA_0B, 0, ENCODE_RELAX (STATE_GETA, STATE_MAX)}, 325 326 /* GETA (1, 1). */ 327 {GETA_3F, GETA_3B, 328 GETA_MAX_LEN - 4, 0}, 329 330 /* BCC (2, 0). */ 331 {BCC_0F, BCC_0B, 0, ENCODE_RELAX (STATE_BCC, STATE_MAX)}, 332 333 /* BCC (2, 1). */ 334 {BCC_5F, BCC_5B, 335 BCC_MAX_LEN - 4, 0}, 336 337 /* PUSHJ (3, 0). Next state is actually PUSHJSTUB (6, 0). */ 338 {PUSHJ_0F, PUSHJ_0B, 0, ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO)}, 339 340 /* PUSHJ (3, 1). */ 341 {PUSHJ_4F, PUSHJ_4B, 342 PUSHJ_MAX_LEN - 4, 0}, 343 344 /* JMP (4, 0). */ 345 {JMP_0F, JMP_0B, 0, ENCODE_RELAX (STATE_JMP, STATE_MAX)}, 346 347 /* JMP (4, 1). */ 348 {JMP_4F, JMP_4B, 349 JMP_MAX_LEN - 4, 0}, 350 351 /* GREG (5, 0), (5, 1), though the table entry isn't used. */ 352 {0, 0, 0, 0}, {0, 0, 0, 0}, 353 354 /* PUSHJSTUB (6, 0). PUSHJ (3, 0) uses the range, so we set it to infinite. */ 355 {PUSHJSTUB_MAX, PUSHJSTUB_MIN, 356 0, ENCODE_RELAX (STATE_PUSHJ, STATE_MAX)}, 357 /* PUSHJSTUB (6, 1) isn't used. */ 358 {0, 0, PUSHJ_MAX_LEN, 0} 359}; 360 361const pseudo_typeS md_pseudo_table[] = 362 { 363 /* Support " .greg sym,expr" syntax. */ 364 {"greg", s_greg, 0}, 365 366 /* Support " .bspec expr" syntax. */ 367 {"bspec", s_bspec, 1}, 368 369 /* Support " .espec" syntax. */ 370 {"espec", s_espec, 1}, 371 372 /* Support " .local $45" syntax. */ 373 {"local", mmix_s_local, 1}, 374 375 {NULL, 0, 0} 376 }; 377 378const char mmix_comment_chars[] = "%!"; 379 380/* A ':' is a valid symbol character in mmixal. It's the prefix 381 delimiter, but other than that, it works like a symbol character, 382 except that we strip one off at the beginning of symbols. An '@' is a 383 symbol by itself (for the current location); space around it must not 384 be stripped. */ 385const char mmix_symbol_chars[] = ":@"; 386 387const char line_comment_chars[] = "*#"; 388 389const char line_separator_chars[] = ";"; 390 391const char mmix_exp_chars[] = "eE"; 392 393const char mmix_flt_chars[] = "rf"; 394 395 396/* Fill in the offset-related part of GETA or Bcc. */ 397 398static void 399mmix_set_geta_branch_offset (char *opcodep, offsetT value) 400{ 401 if (value < 0) 402 { 403 value += 65536 * 4; 404 opcodep[0] |= 1; 405 } 406 407 value /= 4; 408 md_number_to_chars (opcodep + 2, value, 2); 409} 410 411/* Fill in the offset-related part of JMP. */ 412 413static void 414mmix_set_jmp_offset (char *opcodep, offsetT value) 415{ 416 if (value < 0) 417 { 418 value += 65536 * 256 * 4; 419 opcodep[0] |= 1; 420 } 421 422 value /= 4; 423 md_number_to_chars (opcodep + 1, value, 3); 424} 425 426/* Fill in NOP:s for the expanded part of GETA/JMP/Bcc/PUSHJ. */ 427 428static void 429mmix_fill_nops (char *opcodep, int n) 430{ 431 int i; 432 433 for (i = 0; i < n; i++) 434 md_number_to_chars (opcodep + i * 4, SWYM_INSN_BYTE << 24, 4); 435} 436 437/* See macro md_parse_name in tc-mmix.h. */ 438 439int 440mmix_current_location (void (*fn) (expressionS *), expressionS *exp) 441{ 442 (*fn) (exp); 443 444 return 1; 445} 446 447/* Get up to three operands, filling them into the exp array. 448 General idea and code stolen from the tic80 port. */ 449 450static int 451get_operands (int max_operands, char *s, expressionS *exp) 452{ 453 char *p = s; 454 int numexp = 0; 455 int nextchar = ','; 456 457 while (nextchar == ',') 458 { 459 /* Skip leading whitespace */ 460 while (*p == ' ' || *p == '\t') 461 p++; 462 463 /* Check to see if we have any operands left to parse */ 464 if (*p == 0 || *p == '\n' || *p == '\r') 465 { 466 break; 467 } 468 else if (numexp == max_operands) 469 { 470 /* This seems more sane than saying "too many operands". We'll 471 get here only if the trailing trash starts with a comma. */ 472 as_bad (_("invalid operands")); 473 mmix_discard_rest_of_line (); 474 return 0; 475 } 476 477 /* Begin operand parsing at the current scan point. */ 478 479 input_line_pointer = p; 480 expression (&exp[numexp]); 481 482 if (exp[numexp].X_op == O_illegal) 483 { 484 as_bad (_("invalid operands")); 485 } 486 else if (exp[numexp].X_op == O_absent) 487 { 488 as_bad (_("missing operand")); 489 } 490 491 numexp++; 492 p = input_line_pointer; 493 494 /* Skip leading whitespace */ 495 while (*p == ' ' || *p == '\t') 496 p++; 497 nextchar = *p++; 498 } 499 500 /* If we allow "naked" comments, ignore the rest of the line. */ 501 if (nextchar != ',') 502 { 503 mmix_handle_rest_of_empty_line (); 504 input_line_pointer--; 505 } 506 507 /* Mark the end of the valid operands with an illegal expression. */ 508 exp[numexp].X_op = O_illegal; 509 510 return (numexp); 511} 512 513/* Get the value of a special register, or -1 if the name does not match 514 one. NAME is a null-terminated string. */ 515 516static int 517get_spec_regno (char *name) 518{ 519 int i; 520 521 if (name == NULL) 522 return -1; 523 524 if (*name == ':') 525 name++; 526 527 /* Well, it's a short array and we'll most often just match the first 528 entry, rJ. */ 529 for (i = 0; mmix_spec_regs[i].name != NULL; i++) 530 if (strcmp (name, mmix_spec_regs[i].name) == 0) 531 return mmix_spec_regs[i].number; 532 533 return -1; 534} 535 536/* For GET and PUT, parse the register names "manually", so we don't use 537 user labels. */ 538static int 539get_putget_operands (struct mmix_opcode *insn, char *operands, 540 expressionS *exp) 541{ 542 expressionS *expp_reg; 543 expressionS *expp_sreg; 544 char *sregp = NULL; 545 char *sregend = operands; 546 char *p = operands; 547 char c = *sregend; 548 int regno; 549 550 /* Skip leading whitespace */ 551 while (*p == ' ' || *p == '\t') 552 p++; 553 554 input_line_pointer = p; 555 556 /* Initialize both possible operands to error state, in case we never 557 get further. */ 558 exp[0].X_op = O_illegal; 559 exp[1].X_op = O_illegal; 560 561 if (insn->operands == mmix_operands_get) 562 { 563 expp_reg = &exp[0]; 564 expp_sreg = &exp[1]; 565 566 expression (expp_reg); 567 568 p = input_line_pointer; 569 570 /* Skip whitespace */ 571 while (*p == ' ' || *p == '\t') 572 p++; 573 574 if (*p == ',') 575 { 576 p++; 577 578 /* Skip whitespace */ 579 while (*p == ' ' || *p == '\t') 580 p++; 581 sregp = p; 582 input_line_pointer = sregp; 583 c = get_symbol_end (); 584 sregend = input_line_pointer; 585 } 586 } 587 else 588 { 589 expp_sreg = &exp[0]; 590 expp_reg = &exp[1]; 591 592 sregp = p; 593 c = get_symbol_end (); 594 sregend = p = input_line_pointer; 595 *p = c; 596 597 /* Skip whitespace */ 598 while (*p == ' ' || *p == '\t') 599 p++; 600 601 if (*p == ',') 602 { 603 p++; 604 605 /* Skip whitespace */ 606 while (*p == ' ' || *p == '\t') 607 p++; 608 609 input_line_pointer = p; 610 expression (expp_reg); 611 } 612 *sregend = 0; 613 } 614 615 regno = get_spec_regno (sregp); 616 *sregend = c; 617 618 /* Let the caller issue errors; we've made sure the operands are 619 invalid. */ 620 if (expp_reg->X_op != O_illegal 621 && expp_reg->X_op != O_absent 622 && regno != -1) 623 { 624 expp_sreg->X_op = O_register; 625 expp_sreg->X_add_number = regno + 256; 626 } 627 628 return 2; 629} 630 631/* Handle MMIX-specific option. */ 632 633int 634md_parse_option (int c, char *arg ATTRIBUTE_UNUSED) 635{ 636 switch (c) 637 { 638 case 'x': 639 warn_on_expansion = 0; 640 allocate_undefined_gregs_in_linker = 1; 641 break; 642 643 case OPTION_RELAX: 644 linkrelax = 1; 645 break; 646 647 case OPTION_NOEXPAND: 648 expand_op = 0; 649 break; 650 651 case OPTION_NOMERGEGREG: 652 merge_gregs = 0; 653 break; 654 655 case OPTION_NOSYMS: 656 predefined_syms = 0; 657 equated_spec_regs = 0; 658 break; 659 660 case OPTION_GNU_SYNTAX: 661 mmix_gnu_syntax = 1; 662 label_without_colon_this_line = 0; 663 break; 664 665 case OPTION_GLOBALIZE_SYMBOLS: 666 mmix_globalize_symbols = 1; 667 break; 668 669 case OPTION_FIXED_SPEC_REGS: 670 equated_spec_regs = 0; 671 break; 672 673 case OPTION_LINKER_ALLOCATED_GREGS: 674 allocate_undefined_gregs_in_linker = 1; 675 break; 676 677 case OPTION_NOPUSHJSTUBS: 678 pushj_stubs = 0; 679 break; 680 681 default: 682 return 0; 683 } 684 685 return 1; 686} 687 688/* Display MMIX-specific help text. */ 689 690void 691md_show_usage (FILE * stream) 692{ 693 fprintf (stream, _(" MMIX-specific command line options:\n")); 694 fprintf (stream, _("\ 695 -fixed-special-register-names\n\ 696 Allow only the original special register names.\n")); 697 fprintf (stream, _("\ 698 -globalize-symbols Make all symbols global.\n")); 699 fprintf (stream, _("\ 700 -gnu-syntax Turn off mmixal syntax compatibility.\n")); 701 fprintf (stream, _("\ 702 -relax Create linker relaxable code.\n")); 703 fprintf (stream, _("\ 704 -no-predefined-syms Do not provide mmixal built-in constants.\n\ 705 Implies -fixed-special-register-names.\n")); 706 fprintf (stream, _("\ 707 -no-expand Do not expand GETA, branches, PUSHJ or JUMP\n\ 708 into multiple instructions.\n")); 709 fprintf (stream, _("\ 710 -no-merge-gregs Do not merge GREG definitions with nearby values.\n")); 711 fprintf (stream, _("\ 712 -linker-allocated-gregs If there's no suitable GREG definition for the\ 713 operands of an instruction, let the linker resolve.\n")); 714 fprintf (stream, _("\ 715 -x Do not warn when an operand to GETA, a branch,\n\ 716 PUSHJ or JUMP is not known to be within range.\n\ 717 The linker will catch any errors. Implies\n\ 718 -linker-allocated-gregs.")); 719} 720 721/* Step to end of line, but don't step over the end of the line. */ 722 723static void 724mmix_discard_rest_of_line (void) 725{ 726 while (*input_line_pointer 727 && (! is_end_of_line[(unsigned char) *input_line_pointer] 728 || TC_EOL_IN_INSN (input_line_pointer))) 729 input_line_pointer++; 730} 731 732/* Act as demand_empty_rest_of_line if we're in strict GNU syntax mode, 733 otherwise just ignore the rest of the line (and skip the end-of-line 734 delimiter). */ 735 736static void 737mmix_handle_rest_of_empty_line (void) 738{ 739 if (mmix_gnu_syntax) 740 demand_empty_rest_of_line (); 741 else 742 { 743 mmix_discard_rest_of_line (); 744 input_line_pointer++; 745 } 746} 747 748/* Initialize GAS MMIX specifics. */ 749 750void 751mmix_md_begin (void) 752{ 753 int i; 754 const struct mmix_opcode *opcode; 755 756 /* We assume nobody will use this, so don't allocate any room. */ 757 obstack_begin (&mmix_sym_obstack, 0); 758 759 /* This will break the day the "lex" thingy changes. For now, it's the 760 only way to make ':' part of a name, and a name beginner. */ 761 lex_type[':'] = (LEX_NAME | LEX_BEGIN_NAME); 762 763 mmix_opcode_hash = hash_new (); 764 765 real_reg_section 766 = bfd_make_section_old_way (stdoutput, MMIX_REG_SECTION_NAME); 767 768 for (opcode = mmix_opcodes; opcode->name; opcode++) 769 hash_insert (mmix_opcode_hash, opcode->name, (char *) opcode); 770 771 /* We always insert the ordinary registers 0..255 as registers. */ 772 for (i = 0; i < 256; i++) 773 { 774 char buf[5]; 775 776 /* Alternatively, we could diddle with '$' and the following number, 777 but keeping the registers as symbols helps keep parsing simple. */ 778 sprintf (buf, "$%d", i); 779 symbol_table_insert (symbol_new (buf, reg_section, i, 780 &zero_address_frag)); 781 } 782 783 /* Insert mmixal built-in names if allowed. */ 784 if (predefined_syms) 785 { 786 for (i = 0; mmix_spec_regs[i].name != NULL; i++) 787 symbol_table_insert (symbol_new (mmix_spec_regs[i].name, 788 reg_section, 789 mmix_spec_regs[i].number + 256, 790 &zero_address_frag)); 791 792 /* FIXME: Perhaps these should be recognized as specials; as field 793 names for those instructions. */ 794 symbol_table_insert (symbol_new ("ROUND_CURRENT", reg_section, 512, 795 &zero_address_frag)); 796 symbol_table_insert (symbol_new ("ROUND_OFF", reg_section, 512 + 1, 797 &zero_address_frag)); 798 symbol_table_insert (symbol_new ("ROUND_UP", reg_section, 512 + 2, 799 &zero_address_frag)); 800 symbol_table_insert (symbol_new ("ROUND_DOWN", reg_section, 512 + 3, 801 &zero_address_frag)); 802 symbol_table_insert (symbol_new ("ROUND_NEAR", reg_section, 512 + 4, 803 &zero_address_frag)); 804 } 805} 806 807/* Assemble one insn in STR. */ 808 809void 810md_assemble (char *str) 811{ 812 char *operands = str; 813 char modified_char = 0; 814 struct mmix_opcode *instruction; 815 fragS *opc_fragP = NULL; 816 int max_operands = 3; 817 818 /* Note that the struct frag member fr_literal in frags.h is char[], so 819 I have to make this a plain char *. */ 820 /* unsigned */ char *opcodep = NULL; 821 822 expressionS exp[4]; 823 int n_operands = 0; 824 825 /* Move to end of opcode. */ 826 for (operands = str; 827 is_part_of_name (*operands); 828 ++operands) 829 ; 830 831 if (ISSPACE (*operands)) 832 { 833 modified_char = *operands; 834 *operands++ = '\0'; 835 } 836 837 instruction = (struct mmix_opcode *) hash_find (mmix_opcode_hash, str); 838 if (instruction == NULL) 839 { 840 as_bad (_("unknown opcode: `%s'"), str); 841 842 /* Avoid "unhandled label" errors. */ 843 pending_label = NULL; 844 return; 845 } 846 847 /* Put back the character after the opcode. */ 848 if (modified_char != 0) 849 operands[-1] = modified_char; 850 851 input_line_pointer = operands; 852 853 /* Is this a mmixal pseudodirective? */ 854 if (instruction->type == mmix_type_pseudo) 855 { 856 /* For mmixal compatibility, a label for an instruction (and 857 emitting pseudo) refers to the _aligned_ address. We emit the 858 label here for the pseudos that don't handle it themselves. When 859 having an fb-label, emit it here, and increment the counter after 860 the pseudo. */ 861 switch (instruction->operands) 862 { 863 case mmix_operands_loc: 864 case mmix_operands_byte: 865 case mmix_operands_prefix: 866 case mmix_operands_local: 867 case mmix_operands_bspec: 868 case mmix_operands_espec: 869 if (current_fb_label >= 0) 870 colon (fb_label_name (current_fb_label, 1)); 871 else if (pending_label != NULL) 872 { 873 colon (pending_label); 874 pending_label = NULL; 875 } 876 break; 877 878 default: 879 break; 880 } 881 882 /* Some of the pseudos emit contents, others don't. Set a 883 contents-emitted flag when we emit something into .text */ 884 switch (instruction->operands) 885 { 886 case mmix_operands_loc: 887 /* LOC */ 888 s_loc (0); 889 break; 890 891 case mmix_operands_byte: 892 /* BYTE */ 893 mmix_byte (); 894 break; 895 896 case mmix_operands_wyde: 897 /* WYDE */ 898 mmix_cons (2); 899 break; 900 901 case mmix_operands_tetra: 902 /* TETRA */ 903 mmix_cons (4); 904 break; 905 906 case mmix_operands_octa: 907 /* OCTA */ 908 mmix_cons (8); 909 break; 910 911 case mmix_operands_prefix: 912 /* PREFIX */ 913 s_prefix (0); 914 break; 915 916 case mmix_operands_local: 917 /* LOCAL */ 918 mmix_s_local (0); 919 break; 920 921 case mmix_operands_bspec: 922 /* BSPEC */ 923 s_bspec (0); 924 break; 925 926 case mmix_operands_espec: 927 /* ESPEC */ 928 s_espec (0); 929 break; 930 931 default: 932 BAD_CASE (instruction->operands); 933 } 934 935 /* These are all working like the pseudo functions in read.c:s_..., 936 in that they step over the end-of-line marker at the end of the 937 line. We don't want that here. */ 938 input_line_pointer--; 939 940 /* Step up the fb-label counter if there was a definition on this 941 line. */ 942 if (current_fb_label >= 0) 943 { 944 fb_label_instance_inc (current_fb_label); 945 current_fb_label = -1; 946 } 947 948 /* Reset any don't-align-next-datum request, unless this was a LOC 949 directive. */ 950 if (instruction->operands != mmix_operands_loc) 951 want_unaligned = 0; 952 953 return; 954 } 955 956 /* Not a pseudo; we *will* emit contents. */ 957 if (now_seg == data_section) 958 { 959 if (lowest_data_loc != (bfd_vma) -1 && (lowest_data_loc & 3) != 0) 960 { 961 if (data_has_contents) 962 as_bad (_("specified location wasn't TETRA-aligned")); 963 else if (want_unaligned) 964 as_bad (_("unaligned data at an absolute location is not supported")); 965 966 lowest_data_loc &= ~(bfd_vma) 3; 967 lowest_data_loc += 4; 968 } 969 970 data_has_contents = 1; 971 } 972 else if (now_seg == text_section) 973 { 974 if (lowest_text_loc != (bfd_vma) -1 && (lowest_text_loc & 3) != 0) 975 { 976 if (text_has_contents) 977 as_bad (_("specified location wasn't TETRA-aligned")); 978 else if (want_unaligned) 979 as_bad (_("unaligned data at an absolute location is not supported")); 980 981 lowest_text_loc &= ~(bfd_vma) 3; 982 lowest_text_loc += 4; 983 } 984 985 text_has_contents = 1; 986 } 987 988 /* After a sequence of BYTEs or WYDEs, we need to get to instruction 989 alignment. For other pseudos, a ".p2align 2" is supposed to be 990 inserted by the user. */ 991 if (last_alignment < 2 && ! want_unaligned) 992 { 993 frag_align (2, 0, 0); 994 record_alignment (now_seg, 2); 995 last_alignment = 2; 996 } 997 else 998 /* Reset any don't-align-next-datum request. */ 999 want_unaligned = 0; 1000 1001 /* For mmixal compatibility, a label for an instruction (and emitting 1002 pseudo) refers to the _aligned_ address. So we have to emit the 1003 label here. */ 1004 if (pending_label != NULL) 1005 { 1006 colon (pending_label); 1007 pending_label = NULL; 1008 } 1009 1010 /* We assume that mmix_opcodes keeps having unique mnemonics for each 1011 opcode, so we don't have to iterate over more than one opcode; if the 1012 syntax does not match, then there's a syntax error. */ 1013 1014 /* Operands have little or no context and are all comma-separated; it is 1015 easier to parse each expression first. */ 1016 switch (instruction->operands) 1017 { 1018 case mmix_operands_reg_yz: 1019 case mmix_operands_pop: 1020 case mmix_operands_regaddr: 1021 case mmix_operands_pushj: 1022 case mmix_operands_get: 1023 case mmix_operands_put: 1024 case mmix_operands_set: 1025 case mmix_operands_save: 1026 case mmix_operands_unsave: 1027 max_operands = 2; 1028 break; 1029 1030 case mmix_operands_sync: 1031 case mmix_operands_jmp: 1032 case mmix_operands_resume: 1033 max_operands = 1; 1034 break; 1035 1036 /* The original 3 is fine for the rest. */ 1037 default: 1038 break; 1039 } 1040 1041 /* If this is GET or PUT, and we don't do allow those names to be 1042 equated, we need to parse the names ourselves, so we don't pick up a 1043 user label instead of the special register. */ 1044 if (! equated_spec_regs 1045 && (instruction->operands == mmix_operands_get 1046 || instruction->operands == mmix_operands_put)) 1047 n_operands = get_putget_operands (instruction, operands, exp); 1048 else 1049 n_operands = get_operands (max_operands, operands, exp); 1050 1051 /* If there's a fb-label on the current line, set that label. This must 1052 be done *after* evaluating expressions of operands, since neither a 1053 "1B" nor a "1F" refers to "1H" on the same line. */ 1054 if (current_fb_label >= 0) 1055 { 1056 fb_label_instance_inc (current_fb_label); 1057 colon (fb_label_name (current_fb_label, 0)); 1058 current_fb_label = -1; 1059 } 1060 1061 /* We also assume that the length of the instruction is at least 4, the 1062 size of an unexpanded instruction. We need a self-contained frag 1063 since we want the relocation to point to the instruction, not the 1064 variant part. */ 1065 1066 opcodep = frag_more (4); 1067 mmix_opcode_frag = opc_fragP = frag_now; 1068 frag_now->fr_opcode = opcodep; 1069 1070 /* Mark start of insn for DWARF2 debug features. */ 1071 if (OUTPUT_FLAVOR == bfd_target_elf_flavour) 1072 dwarf2_emit_insn (4); 1073 1074 md_number_to_chars (opcodep, instruction->match, 4); 1075 1076 switch (instruction->operands) 1077 { 1078 case mmix_operands_jmp: 1079 if (n_operands == 0 && ! mmix_gnu_syntax) 1080 /* Zeros are in place - nothing needs to be done when we have no 1081 operands. */ 1082 break; 1083 1084 /* Add a frag for a JMP relaxation; we need room for max four 1085 extra instructions. We don't do any work around here to check if 1086 we can determine the offset right away. */ 1087 if (n_operands != 1 || exp[0].X_op == O_register) 1088 { 1089 as_bad (_("invalid operand to opcode %s: `%s'"), 1090 instruction->name, operands); 1091 return; 1092 } 1093 1094 if (expand_op) 1095 frag_var (rs_machine_dependent, 4 * 4, 0, 1096 ENCODE_RELAX (STATE_JMP, STATE_UNDF), 1097 exp[0].X_add_symbol, 1098 exp[0].X_add_number, 1099 opcodep); 1100 else 1101 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal, 4, 1102 exp + 0, 1, BFD_RELOC_MMIX_ADDR27); 1103 break; 1104 1105 case mmix_operands_pushj: 1106 /* We take care of PUSHJ in full here. */ 1107 if (n_operands != 2 1108 || ((exp[0].X_op == O_constant || exp[0].X_op == O_register) 1109 && (exp[0].X_add_number > 255 || exp[0].X_add_number < 0))) 1110 { 1111 as_bad (_("invalid operands to opcode %s: `%s'"), 1112 instruction->name, operands); 1113 return; 1114 } 1115 1116 if (exp[0].X_op == O_register || exp[0].X_op == O_constant) 1117 opcodep[1] = exp[0].X_add_number; 1118 else 1119 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1, 1120 1, exp + 0, 0, BFD_RELOC_MMIX_REG_OR_BYTE); 1121 1122 if (expand_op) 1123 frag_var (rs_machine_dependent, PUSHJ_MAX_LEN - 4, 0, 1124 ENCODE_RELAX (STATE_PUSHJ, STATE_UNDF), 1125 exp[1].X_add_symbol, 1126 exp[1].X_add_number, 1127 opcodep); 1128 else 1129 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal, 4, 1130 exp + 1, 1, BFD_RELOC_MMIX_ADDR19); 1131 break; 1132 1133 case mmix_operands_regaddr: 1134 /* GETA/branch: Add a frag for relaxation. We don't do any work 1135 around here to check if we can determine the offset right away. */ 1136 if (n_operands != 2 || exp[1].X_op == O_register) 1137 { 1138 as_bad (_("invalid operands to opcode %s: `%s'"), 1139 instruction->name, operands); 1140 return; 1141 } 1142 1143 if (! expand_op) 1144 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal, 4, 1145 exp + 1, 1, BFD_RELOC_MMIX_ADDR19); 1146 else if (instruction->type == mmix_type_condbranch) 1147 frag_var (rs_machine_dependent, BCC_MAX_LEN - 4, 0, 1148 ENCODE_RELAX (STATE_BCC, STATE_UNDF), 1149 exp[1].X_add_symbol, 1150 exp[1].X_add_number, 1151 opcodep); 1152 else 1153 frag_var (rs_machine_dependent, GETA_MAX_LEN - 4, 0, 1154 ENCODE_RELAX (STATE_GETA, STATE_UNDF), 1155 exp[1].X_add_symbol, 1156 exp[1].X_add_number, 1157 opcodep); 1158 break; 1159 1160 default: 1161 break; 1162 } 1163 1164 switch (instruction->operands) 1165 { 1166 case mmix_operands_regs: 1167 /* We check the number of operands here, since we're in a 1168 FALLTHROUGH sequence in the next switch. */ 1169 if (n_operands != 3 || exp[2].X_op == O_constant) 1170 { 1171 as_bad (_("invalid operands to opcode %s: `%s'"), 1172 instruction->name, operands); 1173 return; 1174 } 1175 /* FALLTHROUGH. */ 1176 case mmix_operands_regs_z: 1177 if (n_operands != 3) 1178 { 1179 as_bad (_("invalid operands to opcode %s: `%s'"), 1180 instruction->name, operands); 1181 return; 1182 } 1183 /* FALLTHROUGH. */ 1184 case mmix_operands_reg_yz: 1185 case mmix_operands_roundregs_z: 1186 case mmix_operands_roundregs: 1187 case mmix_operands_regs_z_opt: 1188 case mmix_operands_neg: 1189 case mmix_operands_regaddr: 1190 case mmix_operands_get: 1191 case mmix_operands_set: 1192 case mmix_operands_save: 1193 if (n_operands < 1 1194 || (exp[0].X_op == O_register && exp[0].X_add_number > 255)) 1195 { 1196 as_bad (_("invalid operands to opcode %s: `%s'"), 1197 instruction->name, operands); 1198 return; 1199 } 1200 1201 if (exp[0].X_op == O_register) 1202 opcodep[1] = exp[0].X_add_number; 1203 else 1204 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1, 1205 1, exp + 0, 0, BFD_RELOC_MMIX_REG); 1206 break; 1207 1208 default: 1209 ; 1210 } 1211 1212 /* A corresponding once-over for those who take an 8-bit constant as 1213 their first operand. */ 1214 switch (instruction->operands) 1215 { 1216 case mmix_operands_pushgo: 1217 /* PUSHGO: X is a constant, but can be expressed as a register. 1218 We handle X here and use the common machinery of T,X,3,$ for 1219 the rest of the operands. */ 1220 if (n_operands < 2 1221 || ((exp[0].X_op == O_constant || exp[0].X_op == O_register) 1222 && (exp[0].X_add_number > 255 || exp[0].X_add_number < 0))) 1223 { 1224 as_bad (_("invalid operands to opcode %s: `%s'"), 1225 instruction->name, operands); 1226 return; 1227 } 1228 else if (exp[0].X_op == O_constant || exp[0].X_op == O_register) 1229 opcodep[1] = exp[0].X_add_number; 1230 else 1231 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1, 1232 1, exp + 0, 0, BFD_RELOC_MMIX_REG_OR_BYTE); 1233 break; 1234 1235 case mmix_operands_pop: 1236 if ((n_operands == 0 || n_operands == 1) && ! mmix_gnu_syntax) 1237 break; 1238 /* FALLTHROUGH. */ 1239 case mmix_operands_x_regs_z: 1240 if (n_operands < 1 1241 || (exp[0].X_op == O_constant 1242 && (exp[0].X_add_number > 255 1243 || exp[0].X_add_number < 0))) 1244 { 1245 as_bad (_("invalid operands to opcode %s: `%s'"), 1246 instruction->name, operands); 1247 return; 1248 } 1249 1250 if (exp[0].X_op == O_constant) 1251 opcodep[1] = exp[0].X_add_number; 1252 else 1253 /* FIXME: This doesn't bring us unsignedness checking. */ 1254 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1, 1255 1, exp + 0, 0, BFD_RELOC_8); 1256 default: 1257 ; 1258 } 1259 1260 /* Handle the rest. */ 1261 switch (instruction->operands) 1262 { 1263 case mmix_operands_set: 1264 /* SET: Either two registers, "$X,$Y", with Z field as zero, or 1265 "$X,YZ", meaning change the opcode to SETL. */ 1266 if (n_operands != 2 1267 || (exp[1].X_op == O_constant 1268 && (exp[1].X_add_number > 0xffff || exp[1].X_add_number < 0))) 1269 { 1270 as_bad (_("invalid operands to opcode %s: `%s'"), 1271 instruction->name, operands); 1272 return; 1273 } 1274 1275 if (exp[1].X_op == O_constant) 1276 { 1277 /* There's an ambiguity with "SET $0,Y" when Y isn't defined 1278 yet. To keep things simple, we assume that Y is then a 1279 register, and only change the opcode if Y is defined at this 1280 point. 1281 1282 There's no compatibility problem with mmixal, since it emits 1283 errors if the field is not defined at this point. */ 1284 md_number_to_chars (opcodep, SETL_INSN_BYTE, 1); 1285 1286 opcodep[2] = (exp[1].X_add_number >> 8) & 255; 1287 opcodep[3] = exp[1].X_add_number & 255; 1288 break; 1289 } 1290 /* FALLTHROUGH. */ 1291 case mmix_operands_x_regs_z: 1292 /* SYNCD: "X,$Y,$Z|Z". */ 1293 /* FALLTHROUGH. */ 1294 case mmix_operands_regs: 1295 /* Three registers, $X,$Y,$Z. */ 1296 /* FALLTHROUGH. */ 1297 case mmix_operands_regs_z: 1298 /* Operands "$X,$Y,$Z|Z", number of arguments checked above. */ 1299 /* FALLTHROUGH. */ 1300 case mmix_operands_pushgo: 1301 /* Operands "$X|X,$Y,$Z|Z", optional Z. */ 1302 /* FALLTHROUGH. */ 1303 case mmix_operands_regs_z_opt: 1304 /* Operands "$X,$Y,$Z|Z", with $Z|Z being optional, default 0. Any 1305 operands not completely decided yet are postponed to later in 1306 assembly (but not until link-time yet). */ 1307 1308 if ((n_operands != 2 && n_operands != 3) 1309 || (exp[1].X_op == O_register && exp[1].X_add_number > 255) 1310 || (n_operands == 3 1311 && ((exp[2].X_op == O_register 1312 && exp[2].X_add_number > 255 1313 && mmix_gnu_syntax) 1314 || (exp[2].X_op == O_constant 1315 && (exp[2].X_add_number > 255 1316 || exp[2].X_add_number < 0))))) 1317 { 1318 as_bad (_("invalid operands to opcode %s: `%s'"), 1319 instruction->name, operands); 1320 return; 1321 } 1322 1323 if (n_operands == 2) 1324 { 1325 symbolS *sym; 1326 1327 /* The last operand is immediate whenever we see just two 1328 operands. */ 1329 opcodep[0] |= IMM_OFFSET_BIT; 1330 1331 /* Now, we could either have an implied "0" as the Z operand, or 1332 it could be the constant of a "base address plus offset". It 1333 depends on whether it is allowed; only memory operations, as 1334 signified by instruction->type and "T" and "X" operand types, 1335 and it depends on whether we find a register in the second 1336 operand, exp[1]. */ 1337 if (exp[1].X_op == O_register && exp[1].X_add_number <= 255) 1338 { 1339 /* A zero then; all done. */ 1340 opcodep[2] = exp[1].X_add_number; 1341 break; 1342 } 1343 1344 /* Not known as a register. Is base address plus offset 1345 allowed, or can we assume that it is a register anyway? */ 1346 if ((instruction->operands != mmix_operands_regs_z_opt 1347 && instruction->operands != mmix_operands_x_regs_z 1348 && instruction->operands != mmix_operands_pushgo) 1349 || (instruction->type != mmix_type_memaccess_octa 1350 && instruction->type != mmix_type_memaccess_tetra 1351 && instruction->type != mmix_type_memaccess_wyde 1352 && instruction->type != mmix_type_memaccess_byte 1353 && instruction->type != mmix_type_memaccess_block 1354 && instruction->type != mmix_type_jsr 1355 && instruction->type != mmix_type_branch)) 1356 { 1357 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2, 1358 1, exp + 1, 0, BFD_RELOC_MMIX_REG); 1359 break; 1360 } 1361 1362 /* To avoid getting a NULL add_symbol for constants and then 1363 catching a SEGV in write_relocs since it doesn't handle 1364 constants well for relocs other than PC-relative, we need to 1365 pass expressions as symbols and use fix_new, not fix_new_exp. */ 1366 sym = make_expr_symbol (exp + 1); 1367 1368 /* Mark the symbol as being OK for a reloc. */ 1369 symbol_get_bfdsym (sym)->flags |= BSF_KEEP; 1370 1371 /* Now we know it can be a "base address plus offset". Add 1372 proper fixup types so we can handle this later, when we've 1373 parsed everything. */ 1374 fix_new (opc_fragP, opcodep - opc_fragP->fr_literal + 2, 1375 8, sym, 0, 0, BFD_RELOC_MMIX_BASE_PLUS_OFFSET); 1376 break; 1377 } 1378 1379 if (exp[1].X_op == O_register) 1380 opcodep[2] = exp[1].X_add_number; 1381 else 1382 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2, 1383 1, exp + 1, 0, BFD_RELOC_MMIX_REG); 1384 1385 /* In mmixal compatibility mode, we allow special registers as 1386 constants for the Z operand. They have 256 added to their 1387 register numbers, so the right thing will happen if we just treat 1388 those as constants. */ 1389 if (exp[2].X_op == O_register && exp[2].X_add_number <= 255) 1390 opcodep[3] = exp[2].X_add_number; 1391 else if (exp[2].X_op == O_constant 1392 || (exp[2].X_op == O_register && exp[2].X_add_number > 255)) 1393 { 1394 opcodep[3] = exp[2].X_add_number; 1395 opcodep[0] |= IMM_OFFSET_BIT; 1396 } 1397 else 1398 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3, 1399 1, exp + 2, 0, 1400 (instruction->operands == mmix_operands_set 1401 || instruction->operands == mmix_operands_regs) 1402 ? BFD_RELOC_MMIX_REG : BFD_RELOC_MMIX_REG_OR_BYTE); 1403 break; 1404 1405 case mmix_operands_pop: 1406 /* POP, one eight and one 16-bit operand. */ 1407 if (n_operands == 0 && ! mmix_gnu_syntax) 1408 break; 1409 if (n_operands == 1 && ! mmix_gnu_syntax) 1410 goto a_single_24_bit_number_operand; 1411 /* FALLTHROUGH. */ 1412 case mmix_operands_reg_yz: 1413 /* A register and a 16-bit unsigned number. */ 1414 if (n_operands != 2 1415 || exp[1].X_op == O_register 1416 || (exp[1].X_op == O_constant 1417 && (exp[1].X_add_number > 0xffff || exp[1].X_add_number < 0))) 1418 { 1419 as_bad (_("invalid operands to opcode %s: `%s'"), 1420 instruction->name, operands); 1421 return; 1422 } 1423 1424 if (exp[1].X_op == O_constant) 1425 { 1426 opcodep[2] = (exp[1].X_add_number >> 8) & 255; 1427 opcodep[3] = exp[1].X_add_number & 255; 1428 } 1429 else 1430 /* FIXME: This doesn't bring us unsignedness checking. */ 1431 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2, 1432 2, exp + 1, 0, BFD_RELOC_16); 1433 break; 1434 1435 case mmix_operands_jmp: 1436 /* A JMP. Everything is already done. */ 1437 break; 1438 1439 case mmix_operands_roundregs: 1440 /* Two registers with optional rounding mode or constant in between. */ 1441 if ((n_operands == 3 && exp[2].X_op == O_constant) 1442 || (n_operands == 2 && exp[1].X_op == O_constant)) 1443 { 1444 as_bad (_("invalid operands to opcode %s: `%s'"), 1445 instruction->name, operands); 1446 return; 1447 } 1448 /* FALLTHROUGH. */ 1449 case mmix_operands_roundregs_z: 1450 /* Like FLOT, "$X,ROUND_MODE,$Z|Z", but the rounding mode is 1451 optional and can be the corresponding constant. */ 1452 { 1453 /* Which exp index holds the second operand (not the rounding 1454 mode). */ 1455 int op2no = n_operands - 1; 1456 1457 if ((n_operands != 2 && n_operands != 3) 1458 || ((exp[op2no].X_op == O_register 1459 && exp[op2no].X_add_number > 255) 1460 || (exp[op2no].X_op == O_constant 1461 && (exp[op2no].X_add_number > 255 1462 || exp[op2no].X_add_number < 0))) 1463 || (n_operands == 3 1464 /* We don't allow for the rounding mode to be deferred; it 1465 must be determined in the "first pass". It cannot be a 1466 symbol equated to a rounding mode, but defined after 1467 the first use. */ 1468 && ((exp[1].X_op == O_register 1469 && exp[1].X_add_number < 512) 1470 || (exp[1].X_op == O_constant 1471 && exp[1].X_add_number < 0 1472 && exp[1].X_add_number > 4) 1473 || (exp[1].X_op != O_register 1474 && exp[1].X_op != O_constant)))) 1475 { 1476 as_bad (_("invalid operands to opcode %s: `%s'"), 1477 instruction->name, operands); 1478 return; 1479 } 1480 1481 /* Add rounding mode if present. */ 1482 if (n_operands == 3) 1483 opcodep[2] = exp[1].X_add_number & 255; 1484 1485 if (exp[op2no].X_op == O_register) 1486 opcodep[3] = exp[op2no].X_add_number; 1487 else if (exp[op2no].X_op == O_constant) 1488 { 1489 opcodep[3] = exp[op2no].X_add_number; 1490 opcodep[0] |= IMM_OFFSET_BIT; 1491 } 1492 else 1493 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3, 1494 1, exp + op2no, 0, 1495 instruction->operands == mmix_operands_roundregs 1496 ? BFD_RELOC_MMIX_REG 1497 : BFD_RELOC_MMIX_REG_OR_BYTE); 1498 break; 1499 } 1500 1501 case mmix_operands_sync: 1502 a_single_24_bit_number_operand: 1503 if (n_operands != 1 1504 || exp[0].X_op == O_register 1505 || (exp[0].X_op == O_constant 1506 && (exp[0].X_add_number > 0xffffff || exp[0].X_add_number < 0))) 1507 { 1508 as_bad (_("invalid operands to opcode %s: `%s'"), 1509 instruction->name, operands); 1510 return; 1511 } 1512 1513 if (exp[0].X_op == O_constant) 1514 { 1515 opcodep[1] = (exp[0].X_add_number >> 16) & 255; 1516 opcodep[2] = (exp[0].X_add_number >> 8) & 255; 1517 opcodep[3] = exp[0].X_add_number & 255; 1518 } 1519 else 1520 /* FIXME: This doesn't bring us unsignedness checking. */ 1521 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1, 1522 3, exp + 0, 0, BFD_RELOC_24); 1523 break; 1524 1525 case mmix_operands_neg: 1526 /* Operands "$X,Y,$Z|Z"; NEG or NEGU. Y is optional, 0 is default. */ 1527 1528 if ((n_operands != 3 && n_operands != 2) 1529 || (n_operands == 3 && exp[1].X_op == O_register) 1530 || ((exp[1].X_op == O_constant || exp[1].X_op == O_register) 1531 && (exp[1].X_add_number > 255 || exp[1].X_add_number < 0)) 1532 || (n_operands == 3 1533 && ((exp[2].X_op == O_register && exp[2].X_add_number > 255) 1534 || (exp[2].X_op == O_constant 1535 && (exp[2].X_add_number > 255 1536 || exp[2].X_add_number < 0))))) 1537 { 1538 as_bad (_("invalid operands to opcode %s: `%s'"), 1539 instruction->name, operands); 1540 return; 1541 } 1542 1543 if (n_operands == 2) 1544 { 1545 if (exp[1].X_op == O_register) 1546 opcodep[3] = exp[1].X_add_number; 1547 else if (exp[1].X_op == O_constant) 1548 { 1549 opcodep[3] = exp[1].X_add_number; 1550 opcodep[0] |= IMM_OFFSET_BIT; 1551 } 1552 else 1553 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3, 1554 1, exp + 1, 0, BFD_RELOC_MMIX_REG_OR_BYTE); 1555 break; 1556 } 1557 1558 if (exp[1].X_op == O_constant) 1559 opcodep[2] = exp[1].X_add_number; 1560 else 1561 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2, 1562 1, exp + 1, 0, BFD_RELOC_8); 1563 1564 if (exp[2].X_op == O_register) 1565 opcodep[3] = exp[2].X_add_number; 1566 else if (exp[2].X_op == O_constant) 1567 { 1568 opcodep[3] = exp[2].X_add_number; 1569 opcodep[0] |= IMM_OFFSET_BIT; 1570 } 1571 else 1572 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3, 1573 1, exp + 2, 0, BFD_RELOC_MMIX_REG_OR_BYTE); 1574 break; 1575 1576 case mmix_operands_regaddr: 1577 /* A GETA/branch-type. */ 1578 break; 1579 1580 case mmix_operands_get: 1581 /* "$X,spec_reg"; GET. 1582 Like with rounding modes, we demand that the special register or 1583 symbol is already defined when we get here at the point of use. */ 1584 if (n_operands != 2 1585 || (exp[1].X_op == O_register 1586 && (exp[1].X_add_number < 256 || exp[1].X_add_number >= 512)) 1587 || (exp[1].X_op == O_constant 1588 && (exp[1].X_add_number < 0 || exp[1].X_add_number > 256)) 1589 || (exp[1].X_op != O_constant && exp[1].X_op != O_register)) 1590 { 1591 as_bad (_("invalid operands to opcode %s: `%s'"), 1592 instruction->name, operands); 1593 return; 1594 } 1595 1596 opcodep[3] = exp[1].X_add_number - 256; 1597 break; 1598 1599 case mmix_operands_put: 1600 /* "spec_reg,$Z|Z"; PUT. */ 1601 if (n_operands != 2 1602 || (exp[0].X_op == O_register 1603 && (exp[0].X_add_number < 256 || exp[0].X_add_number >= 512)) 1604 || (exp[0].X_op == O_constant 1605 && (exp[0].X_add_number < 0 || exp[0].X_add_number > 256)) 1606 || (exp[0].X_op != O_constant && exp[0].X_op != O_register)) 1607 { 1608 as_bad (_("invalid operands to opcode %s: `%s'"), 1609 instruction->name, operands); 1610 return; 1611 } 1612 1613 opcodep[1] = exp[0].X_add_number - 256; 1614 1615 /* Note that the Y field is zero. */ 1616 1617 if (exp[1].X_op == O_register) 1618 opcodep[3] = exp[1].X_add_number; 1619 else if (exp[1].X_op == O_constant) 1620 { 1621 opcodep[3] = exp[1].X_add_number; 1622 opcodep[0] |= IMM_OFFSET_BIT; 1623 } 1624 else 1625 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3, 1626 1, exp + 1, 0, BFD_RELOC_MMIX_REG_OR_BYTE); 1627 break; 1628 1629 case mmix_operands_save: 1630 /* "$X,0"; SAVE. */ 1631 if (n_operands != 2 1632 || exp[1].X_op != O_constant 1633 || exp[1].X_add_number != 0) 1634 { 1635 as_bad (_("invalid operands to opcode %s: `%s'"), 1636 instruction->name, operands); 1637 return; 1638 } 1639 break; 1640 1641 case mmix_operands_unsave: 1642 if (n_operands < 2 && ! mmix_gnu_syntax) 1643 { 1644 if (n_operands == 1) 1645 { 1646 if (exp[0].X_op == O_register) 1647 opcodep[3] = exp[0].X_add_number; 1648 else 1649 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3, 1650 1, exp, 0, BFD_RELOC_MMIX_REG); 1651 } 1652 break; 1653 } 1654 1655 /* "0,$Z"; UNSAVE. */ 1656 if (n_operands != 2 1657 || exp[0].X_op != O_constant 1658 || exp[0].X_add_number != 0 1659 || exp[1].X_op == O_constant 1660 || (exp[1].X_op == O_register 1661 && exp[1].X_add_number > 255)) 1662 { 1663 as_bad (_("invalid operands to opcode %s: `%s'"), 1664 instruction->name, operands); 1665 return; 1666 } 1667 1668 if (exp[1].X_op == O_register) 1669 opcodep[3] = exp[1].X_add_number; 1670 else 1671 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3, 1672 1, exp + 1, 0, BFD_RELOC_MMIX_REG); 1673 break; 1674 1675 case mmix_operands_xyz_opt: 1676 /* SWYM, TRIP, TRAP: zero, one, two or three operands. It's 1677 unspecified whether operands are registers or constants, but 1678 when we find register syntax, we require operands to be literal and 1679 within 0..255. */ 1680 if (n_operands == 0 && ! mmix_gnu_syntax) 1681 /* Zeros are in place - nothing needs to be done for zero 1682 operands. We don't allow this in GNU syntax mode, because it 1683 was believed that the risk of missing to supply an operand is 1684 higher than the benefit of not having to specify a zero. */ 1685 ; 1686 else if (n_operands == 1 && exp[0].X_op != O_register) 1687 { 1688 if (exp[0].X_op == O_constant) 1689 { 1690 if (exp[0].X_add_number > 255*256*256 1691 || exp[0].X_add_number < 0) 1692 { 1693 as_bad (_("invalid operands to opcode %s: `%s'"), 1694 instruction->name, operands); 1695 return; 1696 } 1697 else 1698 { 1699 opcodep[1] = (exp[0].X_add_number >> 16) & 255; 1700 opcodep[2] = (exp[0].X_add_number >> 8) & 255; 1701 opcodep[3] = exp[0].X_add_number & 255; 1702 } 1703 } 1704 else 1705 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1, 1706 3, exp, 0, BFD_RELOC_24); 1707 } 1708 else if (n_operands == 2 1709 && exp[0].X_op != O_register 1710 && exp[1].X_op != O_register) 1711 { 1712 /* Two operands. */ 1713 1714 if (exp[0].X_op == O_constant) 1715 { 1716 if (exp[0].X_add_number > 255 1717 || exp[0].X_add_number < 0) 1718 { 1719 as_bad (_("invalid operands to opcode %s: `%s'"), 1720 instruction->name, operands); 1721 return; 1722 } 1723 else 1724 opcodep[1] = exp[0].X_add_number & 255; 1725 } 1726 else 1727 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1, 1728 1, exp, 0, BFD_RELOC_8); 1729 1730 if (exp[1].X_op == O_constant) 1731 { 1732 if (exp[1].X_add_number > 255*256 1733 || exp[1].X_add_number < 0) 1734 { 1735 as_bad (_("invalid operands to opcode %s: `%s'"), 1736 instruction->name, operands); 1737 return; 1738 } 1739 else 1740 { 1741 opcodep[2] = (exp[1].X_add_number >> 8) & 255; 1742 opcodep[3] = exp[1].X_add_number & 255; 1743 } 1744 } 1745 else 1746 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2, 1747 2, exp + 1, 0, BFD_RELOC_16); 1748 } 1749 else if (n_operands == 3 1750 && exp[0].X_op != O_register 1751 && exp[1].X_op != O_register 1752 && exp[2].X_op != O_register) 1753 { 1754 /* Three operands. */ 1755 1756 if (exp[0].X_op == O_constant) 1757 { 1758 if (exp[0].X_add_number > 255 1759 || exp[0].X_add_number < 0) 1760 { 1761 as_bad (_("invalid operands to opcode %s: `%s'"), 1762 instruction->name, operands); 1763 return; 1764 } 1765 else 1766 opcodep[1] = exp[0].X_add_number & 255; 1767 } 1768 else 1769 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1, 1770 1, exp, 0, BFD_RELOC_8); 1771 1772 if (exp[1].X_op == O_constant) 1773 { 1774 if (exp[1].X_add_number > 255 1775 || exp[1].X_add_number < 0) 1776 { 1777 as_bad (_("invalid operands to opcode %s: `%s'"), 1778 instruction->name, operands); 1779 return; 1780 } 1781 else 1782 opcodep[2] = exp[1].X_add_number & 255; 1783 } 1784 else 1785 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2, 1786 1, exp + 1, 0, BFD_RELOC_8); 1787 1788 if (exp[2].X_op == O_constant) 1789 { 1790 if (exp[2].X_add_number > 255 1791 || exp[2].X_add_number < 0) 1792 { 1793 as_bad (_("invalid operands to opcode %s: `%s'"), 1794 instruction->name, operands); 1795 return; 1796 } 1797 else 1798 opcodep[3] = exp[2].X_add_number & 255; 1799 } 1800 else 1801 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3, 1802 1, exp + 2, 0, BFD_RELOC_8); 1803 } 1804 else 1805 { 1806 /* We can't get here for other cases. */ 1807 gas_assert (n_operands <= 3); 1808 1809 /* The meaning of operands to TRIP and TRAP is not defined (and 1810 SWYM operands aren't enforced in mmixal, so let's avoid 1811 that). We add combinations not handled above here as we find 1812 them and as they're reported. */ 1813 if (n_operands == 3) 1814 { 1815 /* Don't require non-register operands. Always generate 1816 fixups, so we don't have to copy lots of code and create 1817 maintenance problems. TRIP is supposed to be a rare 1818 instruction, so the overhead should not matter. We 1819 aren't allowed to fix_new_exp for an expression which is 1820 an O_register at this point, however. 1821 1822 Don't use BFD_RELOC_MMIX_REG_OR_BYTE as that modifies 1823 the insn for a register in the Z field and we want 1824 consistency. */ 1825 if (exp[0].X_op == O_register) 1826 opcodep[1] = exp[0].X_add_number; 1827 else 1828 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1, 1829 1, exp, 0, BFD_RELOC_8); 1830 if (exp[1].X_op == O_register) 1831 opcodep[2] = exp[1].X_add_number; 1832 else 1833 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2, 1834 1, exp + 1, 0, BFD_RELOC_8); 1835 if (exp[2].X_op == O_register) 1836 opcodep[3] = exp[2].X_add_number; 1837 else 1838 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3, 1839 1, exp + 2, 0, BFD_RELOC_8); 1840 } 1841 else if (n_operands == 2) 1842 { 1843 if (exp[0].X_op == O_register) 1844 opcodep[1] = exp[0].X_add_number; 1845 else 1846 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1, 1847 1, exp, 0, BFD_RELOC_8); 1848 if (exp[1].X_op == O_register) 1849 opcodep[3] = exp[1].X_add_number; 1850 else 1851 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2, 1852 2, exp + 1, 0, BFD_RELOC_16); 1853 } 1854 else 1855 { 1856 /* We can't get here for other cases. */ 1857 gas_assert (n_operands == 1 && exp[0].X_op == O_register); 1858 1859 opcodep[3] = exp[0].X_add_number; 1860 } 1861 } 1862 break; 1863 1864 case mmix_operands_resume: 1865 if (n_operands == 0 && ! mmix_gnu_syntax) 1866 break; 1867 1868 if (n_operands != 1 1869 || exp[0].X_op == O_register 1870 || (exp[0].X_op == O_constant 1871 && (exp[0].X_add_number < 0 1872 || exp[0].X_add_number > 255))) 1873 { 1874 as_bad (_("invalid operands to opcode %s: `%s'"), 1875 instruction->name, operands); 1876 return; 1877 } 1878 1879 if (exp[0].X_op == O_constant) 1880 opcodep[3] = exp[0].X_add_number; 1881 else 1882 fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3, 1883 1, exp + 0, 0, BFD_RELOC_8); 1884 break; 1885 1886 case mmix_operands_pushj: 1887 /* All is done for PUSHJ already. */ 1888 break; 1889 1890 default: 1891 BAD_CASE (instruction->operands); 1892 } 1893} 1894 1895/* For the benefit of insns that start with a digit, we assemble by way of 1896 tc_unrecognized_line too, through this function. */ 1897 1898int 1899mmix_assemble_return_nonzero (char *str) 1900{ 1901 int last_error_count = had_errors (); 1902 char *s2 = str; 1903 char c; 1904 1905 /* Normal instruction handling downcases, so we must too. */ 1906 while (ISALNUM (*s2)) 1907 { 1908 if (ISUPPER ((unsigned char) *s2)) 1909 *s2 = TOLOWER (*s2); 1910 s2++; 1911 } 1912 1913 /* Cut the line for sake of the assembly. */ 1914 for (s2 = str; *s2 && *s2 != '\n'; s2++) 1915 ; 1916 1917 c = *s2; 1918 *s2 = 0; 1919 md_assemble (str); 1920 *s2 = c; 1921 1922 return had_errors () == last_error_count; 1923} 1924 1925/* The PREFIX pseudo. */ 1926 1927static void 1928s_prefix (int unused ATTRIBUTE_UNUSED) 1929{ 1930 char *p; 1931 int c; 1932 1933 SKIP_WHITESPACE (); 1934 1935 p = input_line_pointer; 1936 1937 c = get_symbol_end (); 1938 1939 /* Reseting prefix? */ 1940 if (*p == ':' && p[1] == 0) 1941 mmix_current_prefix = NULL; 1942 else 1943 { 1944 /* Put this prefix on the mmix symbols obstack. We could malloc and 1945 free it separately, but then we'd have to worry about that. 1946 People using up memory on prefixes have other problems. */ 1947 obstack_grow (&mmix_sym_obstack, p, strlen (p) + 1); 1948 p = obstack_finish (&mmix_sym_obstack); 1949 1950 /* Accumulate prefixes, and strip a leading ':'. */ 1951 if (mmix_current_prefix != NULL || *p == ':') 1952 p = mmix_prefix_name (p); 1953 1954 mmix_current_prefix = p; 1955 } 1956 1957 *input_line_pointer = c; 1958 1959 mmix_handle_rest_of_empty_line (); 1960} 1961 1962/* We implement prefixes by using the tc_canonicalize_symbol_name hook, 1963 and store each prefixed name on a (separate) obstack. This means that 1964 the name is on the "notes" obstack in non-prefixed form and on the 1965 mmix_sym_obstack in prefixed form, but currently it is not worth 1966 rewriting the whole GAS symbol handling to improve "hooking" to avoid 1967 that. (It might be worth a rewrite for other reasons, though). */ 1968 1969char * 1970mmix_prefix_name (char *shortname) 1971{ 1972 if (*shortname == ':') 1973 return shortname + 1; 1974 1975 if (mmix_current_prefix == NULL) 1976 as_fatal (_("internal: mmix_prefix_name but empty prefix")); 1977 1978 if (*shortname == '$') 1979 return shortname; 1980 1981 obstack_grow (&mmix_sym_obstack, mmix_current_prefix, 1982 strlen (mmix_current_prefix)); 1983 obstack_grow (&mmix_sym_obstack, shortname, strlen (shortname) + 1); 1984 return obstack_finish (&mmix_sym_obstack); 1985} 1986 1987/* The GREG pseudo. At LABEL, we have the name of a symbol that we 1988 want to make a register symbol, and which should be initialized with 1989 the value in the expression at INPUT_LINE_POINTER (defaulting to 0). 1990 Either and (perhaps less meaningful) both may be missing. LABEL must 1991 be persistent, perhaps allocated on an obstack. */ 1992 1993static void 1994mmix_greg_internal (char *label) 1995{ 1996 expressionS *expP = &mmix_raw_gregs[n_of_raw_gregs].exp; 1997 1998 /* Don't set the section to register contents section before the 1999 expression has been parsed; it may refer to the current position. */ 2000 expression (expP); 2001 2002 /* FIXME: Check that no expression refers to the register contents 2003 section. May need to be done in elf64-mmix.c. */ 2004 if (expP->X_op == O_absent) 2005 { 2006 /* Default to zero if the expression was absent. */ 2007 expP->X_op = O_constant; 2008 expP->X_add_number = 0; 2009 expP->X_unsigned = 0; 2010 expP->X_add_symbol = NULL; 2011 expP->X_op_symbol = NULL; 2012 } 2013 2014 /* We must handle prefixes here, as we save the labels and expressions 2015 to be output later. */ 2016 mmix_raw_gregs[n_of_raw_gregs].label 2017 = mmix_current_prefix == NULL ? label : mmix_prefix_name (label); 2018 2019 if (n_of_raw_gregs == MAX_GREGS - 1) 2020 as_bad (_("too many GREG registers allocated (max %d)"), MAX_GREGS); 2021 else 2022 n_of_raw_gregs++; 2023 2024 mmix_handle_rest_of_empty_line (); 2025} 2026 2027/* The ".greg label,expr" worker. */ 2028 2029static void 2030s_greg (int unused ATTRIBUTE_UNUSED) 2031{ 2032 char *p; 2033 char c; 2034 p = input_line_pointer; 2035 2036 /* This will skip over what can be a symbol and zero out the next 2037 character, which we assume is a ',' or other meaningful delimiter. 2038 What comes after that is the initializer expression for the 2039 register. */ 2040 c = get_symbol_end (); 2041 2042 if (! is_end_of_line[(unsigned char) c]) 2043 input_line_pointer++; 2044 2045 if (*p) 2046 { 2047 /* The label must be persistent; it's not used until after all input 2048 has been seen. */ 2049 obstack_grow (&mmix_sym_obstack, p, strlen (p) + 1); 2050 mmix_greg_internal (obstack_finish (&mmix_sym_obstack)); 2051 } 2052 else 2053 mmix_greg_internal (NULL); 2054} 2055 2056/* The "BSPEC expr" worker. */ 2057 2058static void 2059s_bspec (int unused ATTRIBUTE_UNUSED) 2060{ 2061 asection *expsec; 2062 asection *sec; 2063 char secname[sizeof (MMIX_OTHER_SPEC_SECTION_PREFIX) + 20] 2064 = MMIX_OTHER_SPEC_SECTION_PREFIX; 2065 expressionS exp; 2066 int n; 2067 2068 /* Get a constant expression which we can evaluate *now*. Supporting 2069 more complex (though assembly-time computable) expressions is 2070 feasible but Too Much Work for something of unknown usefulness like 2071 BSPEC-ESPEC. */ 2072 expsec = expression (&exp); 2073 mmix_handle_rest_of_empty_line (); 2074 2075 /* Check that we don't have another BSPEC in progress. */ 2076 if (doing_bspec) 2077 { 2078 as_bad (_("BSPEC already active. Nesting is not supported.")); 2079 return; 2080 } 2081 2082 if (exp.X_op != O_constant 2083 || expsec != absolute_section 2084 || exp.X_add_number < 0 2085 || exp.X_add_number > 65535) 2086 { 2087 as_bad (_("invalid BSPEC expression")); 2088 exp.X_add_number = 0; 2089 } 2090 2091 n = (int) exp.X_add_number; 2092 2093 sprintf (secname + strlen (MMIX_OTHER_SPEC_SECTION_PREFIX), "%d", n); 2094 sec = bfd_get_section_by_name (stdoutput, secname); 2095 if (sec == NULL) 2096 { 2097 /* We need a non-volatile name as it will be stored in the section 2098 struct. */ 2099 char *newsecname = xstrdup (secname); 2100 sec = bfd_make_section (stdoutput, newsecname); 2101 2102 if (sec == NULL) 2103 as_fatal (_("can't create section %s"), newsecname); 2104 2105 if (!bfd_set_section_flags (stdoutput, sec, 2106 bfd_get_section_flags (stdoutput, sec) 2107 | SEC_READONLY)) 2108 as_fatal (_("can't set section flags for section %s"), newsecname); 2109 } 2110 2111 /* Tell ELF about the pending section change. */ 2112 obj_elf_section_change_hook (); 2113 subseg_set (sec, 0); 2114 2115 /* Save position for missing ESPEC. */ 2116 as_where (&bspec_file, &bspec_line); 2117 2118 doing_bspec = 1; 2119} 2120 2121/* The "ESPEC" worker. */ 2122 2123static void 2124s_espec (int unused ATTRIBUTE_UNUSED) 2125{ 2126 /* First, check that we *do* have a BSPEC in progress. */ 2127 if (! doing_bspec) 2128 { 2129 as_bad (_("ESPEC without preceding BSPEC")); 2130 return; 2131 } 2132 2133 mmix_handle_rest_of_empty_line (); 2134 doing_bspec = 0; 2135 2136 /* When we told ELF about the section change in s_bspec, it stored the 2137 previous section for us so we can get at it with the equivalent of a 2138 .previous pseudo. */ 2139 obj_elf_previous (0); 2140} 2141 2142/* The " .local expr" and " local expr" worker. We make a BFD_MMIX_LOCAL 2143 relocation against the current position against the expression. 2144 Implementing this by means of contents in a section lost. */ 2145 2146static void 2147mmix_s_local (int unused ATTRIBUTE_UNUSED) 2148{ 2149 expressionS exp; 2150 2151 /* Don't set the section to register contents section before the 2152 expression has been parsed; it may refer to the current position in 2153 some contorted way. */ 2154 expression (&exp); 2155 2156 if (exp.X_op == O_absent) 2157 { 2158 as_bad (_("missing local expression")); 2159 return; 2160 } 2161 else if (exp.X_op == O_register) 2162 { 2163 /* fix_new_exp doesn't like O_register. Should be configurable. 2164 We're fine with a constant here, though. */ 2165 exp.X_op = O_constant; 2166 } 2167 2168 fix_new_exp (frag_now, 0, 0, &exp, 0, BFD_RELOC_MMIX_LOCAL); 2169 mmix_handle_rest_of_empty_line (); 2170} 2171 2172/* Set fragP->fr_var to the initial guess of the size of a relaxable insn 2173 and return it. Sizes of other instructions are not known. This 2174 function may be called multiple times. */ 2175 2176int 2177md_estimate_size_before_relax (fragS *fragP, segT segment) 2178{ 2179 int length; 2180 2181#define HANDLE_RELAXABLE(state) \ 2182 case ENCODE_RELAX (state, STATE_UNDF): \ 2183 if (fragP->fr_symbol != NULL \ 2184 && S_GET_SEGMENT (fragP->fr_symbol) == segment \ 2185 && !S_IS_WEAK (fragP->fr_symbol)) \ 2186 { \ 2187 /* The symbol lies in the same segment - a relaxable case. */ \ 2188 fragP->fr_subtype \ 2189 = ENCODE_RELAX (state, STATE_ZERO); \ 2190 } \ 2191 break; 2192 2193 switch (fragP->fr_subtype) 2194 { 2195 HANDLE_RELAXABLE (STATE_GETA); 2196 HANDLE_RELAXABLE (STATE_BCC); 2197 HANDLE_RELAXABLE (STATE_JMP); 2198 2199 case ENCODE_RELAX (STATE_PUSHJ, STATE_UNDF): 2200 if (fragP->fr_symbol != NULL 2201 && S_GET_SEGMENT (fragP->fr_symbol) == segment 2202 && !S_IS_WEAK (fragP->fr_symbol)) 2203 /* The symbol lies in the same segment - a relaxable case. */ 2204 fragP->fr_subtype = ENCODE_RELAX (STATE_PUSHJ, STATE_ZERO); 2205 else if (pushj_stubs) 2206 /* If we're to generate stubs, assume we can reach a stub after 2207 the section. */ 2208 fragP->fr_subtype = ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO); 2209 /* FALLTHROUGH. */ 2210 case ENCODE_RELAX (STATE_PUSHJ, STATE_ZERO): 2211 case ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO): 2212 /* We need to distinguish different relaxation rounds. */ 2213 seg_info (segment)->tc_segment_info_data.last_stubfrag = fragP; 2214 break; 2215 2216 case ENCODE_RELAX (STATE_GETA, STATE_ZERO): 2217 case ENCODE_RELAX (STATE_BCC, STATE_ZERO): 2218 case ENCODE_RELAX (STATE_JMP, STATE_ZERO): 2219 /* When relaxing a section for the second time, we don't need to do 2220 anything except making sure that fr_var is set right. */ 2221 break; 2222 2223 case STATE_GREG_DEF: 2224 length = fragP->tc_frag_data != NULL ? 0 : 8; 2225 fragP->fr_var = length; 2226 2227 /* Don't consult the relax_table; it isn't valid for this 2228 relaxation. */ 2229 return length; 2230 break; 2231 2232 default: 2233 BAD_CASE (fragP->fr_subtype); 2234 } 2235 2236 length = mmix_relax_table[fragP->fr_subtype].rlx_length; 2237 fragP->fr_var = length; 2238 2239 return length; 2240} 2241 2242/* Turn a string in input_line_pointer into a floating point constant of type 2243 type, and store the appropriate bytes in *litP. The number of LITTLENUMS 2244 emitted is stored in *sizeP . An error message is returned, or NULL on 2245 OK. */ 2246 2247char * 2248md_atof (int type, char *litP, int *sizeP) 2249{ 2250 if (type == 'r') 2251 type = 'f'; 2252 /* FIXME: Having 'f' in mmix_flt_chars (and here) makes it 2253 problematic to also have a forward reference in an expression. 2254 The testsuite wants it, and it's customary. 2255 We'll deal with the real problems when they come; we share the 2256 problem with most other ports. */ 2257 return ieee_md_atof (type, litP, sizeP, TRUE); 2258} 2259 2260/* Convert variable-sized frags into one or more fixups. */ 2261 2262void 2263md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED, 2264 fragS *fragP) 2265{ 2266 /* Pointer to first byte in variable-sized part of the frag. */ 2267 char *var_partp; 2268 2269 /* Pointer to first opcode byte in frag. */ 2270 char *opcodep; 2271 2272 /* Size in bytes of variable-sized part of frag. */ 2273 int var_part_size = 0; 2274 2275 /* This is part of *fragP. It contains all information about addresses 2276 and offsets to varying parts. */ 2277 symbolS *symbolP; 2278 unsigned long var_part_offset; 2279 2280 /* This is the frag for the opcode. It, rather than fragP, must be used 2281 when emitting a frag for the opcode. */ 2282 fragS *opc_fragP = fragP->tc_frag_data; 2283 fixS *tmpfixP; 2284 2285 /* Where, in file space, does addr point? */ 2286 bfd_vma target_address; 2287 bfd_vma opcode_address; 2288 2289 know (fragP->fr_type == rs_machine_dependent); 2290 2291 var_part_offset = fragP->fr_fix; 2292 var_partp = fragP->fr_literal + var_part_offset; 2293 opcodep = fragP->fr_opcode; 2294 2295 symbolP = fragP->fr_symbol; 2296 2297 target_address 2298 = ((symbolP ? S_GET_VALUE (symbolP) : 0) + fragP->fr_offset); 2299 2300 /* The opcode that would be extended is the last four "fixed" bytes. */ 2301 opcode_address = fragP->fr_address + fragP->fr_fix - 4; 2302 2303 switch (fragP->fr_subtype) 2304 { 2305 case ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO): 2306 /* Setting the unknown bits to 0 seems the most appropriate. */ 2307 mmix_set_geta_branch_offset (opcodep, 0); 2308 tmpfixP = fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 8, 2309 fragP->fr_symbol, fragP->fr_offset, 1, 2310 BFD_RELOC_MMIX_PUSHJ_STUBBABLE); 2311 COPY_FR_WHERE_TO_FX (fragP, tmpfixP); 2312 var_part_size = 0; 2313 break; 2314 2315 case ENCODE_RELAX (STATE_GETA, STATE_ZERO): 2316 case ENCODE_RELAX (STATE_BCC, STATE_ZERO): 2317 case ENCODE_RELAX (STATE_PUSHJ, STATE_ZERO): 2318 mmix_set_geta_branch_offset (opcodep, target_address - opcode_address); 2319 if (linkrelax) 2320 { 2321 tmpfixP 2322 = fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4, 2323 fragP->fr_symbol, fragP->fr_offset, 1, 2324 BFD_RELOC_MMIX_ADDR19); 2325 COPY_FR_WHERE_TO_FX (fragP, tmpfixP); 2326 } 2327 var_part_size = 0; 2328 break; 2329 2330 case ENCODE_RELAX (STATE_JMP, STATE_ZERO): 2331 mmix_set_jmp_offset (opcodep, target_address - opcode_address); 2332 if (linkrelax) 2333 { 2334 tmpfixP 2335 = fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4, 2336 fragP->fr_symbol, fragP->fr_offset, 1, 2337 BFD_RELOC_MMIX_ADDR27); 2338 COPY_FR_WHERE_TO_FX (fragP, tmpfixP); 2339 } 2340 var_part_size = 0; 2341 break; 2342 2343 case STATE_GREG_DEF: 2344 if (fragP->tc_frag_data == NULL) 2345 { 2346 /* We must initialize data that's supposed to be "fixed up" to 2347 avoid emitting garbage, because md_apply_fix won't do 2348 anything for undefined symbols. */ 2349 md_number_to_chars (var_partp, 0, 8); 2350 tmpfixP 2351 = fix_new (fragP, var_partp - fragP->fr_literal, 8, 2352 fragP->fr_symbol, fragP->fr_offset, 0, BFD_RELOC_64); 2353 COPY_FR_WHERE_TO_FX (fragP, tmpfixP); 2354 mmix_gregs[n_of_cooked_gregs++] = tmpfixP; 2355 var_part_size = 8; 2356 } 2357 else 2358 var_part_size = 0; 2359 break; 2360 2361#define HANDLE_MAX_RELOC(state, reloc) \ 2362 case ENCODE_RELAX (state, STATE_MAX): \ 2363 var_part_size \ 2364 = mmix_relax_table[ENCODE_RELAX (state, STATE_MAX)].rlx_length; \ 2365 mmix_fill_nops (var_partp, var_part_size / 4); \ 2366 if (warn_on_expansion) \ 2367 as_warn_where (fragP->fr_file, fragP->fr_line, \ 2368 _("operand out of range, instruction expanded")); \ 2369 tmpfixP = fix_new (fragP, var_partp - fragP->fr_literal - 4, 8, \ 2370 fragP->fr_symbol, fragP->fr_offset, 1, reloc); \ 2371 COPY_FR_WHERE_TO_FX (fragP, tmpfixP); \ 2372 break 2373 2374 HANDLE_MAX_RELOC (STATE_GETA, BFD_RELOC_MMIX_GETA); 2375 HANDLE_MAX_RELOC (STATE_BCC, BFD_RELOC_MMIX_CBRANCH); 2376 HANDLE_MAX_RELOC (STATE_PUSHJ, BFD_RELOC_MMIX_PUSHJ); 2377 HANDLE_MAX_RELOC (STATE_JMP, BFD_RELOC_MMIX_JMP); 2378 2379 default: 2380 BAD_CASE (fragP->fr_subtype); 2381 break; 2382 } 2383 2384 fragP->fr_fix += var_part_size; 2385 fragP->fr_var = 0; 2386} 2387 2388/* Applies the desired value to the specified location. 2389 Also sets up addends for RELA type relocations. 2390 Stolen from tc-mcore.c. 2391 2392 Note that this function isn't called when linkrelax != 0. */ 2393 2394void 2395md_apply_fix (fixS *fixP, valueT *valP, segT segment) 2396{ 2397 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal; 2398 /* Note: use offsetT because it is signed, valueT is unsigned. */ 2399 offsetT val = (offsetT) * valP; 2400 segT symsec 2401 = (fixP->fx_addsy == NULL 2402 ? absolute_section : S_GET_SEGMENT (fixP->fx_addsy)); 2403 2404 /* If the fix is relative to a symbol which is not defined, or, (if 2405 pcrel), not in the same segment as the fix, we cannot resolve it 2406 here. */ 2407 if (fixP->fx_addsy != NULL 2408 && (! S_IS_DEFINED (fixP->fx_addsy) 2409 || S_IS_WEAK (fixP->fx_addsy) 2410 || (fixP->fx_pcrel && symsec != segment) 2411 || (! fixP->fx_pcrel 2412 && symsec != absolute_section 2413 && ((fixP->fx_r_type != BFD_RELOC_MMIX_REG 2414 && fixP->fx_r_type != BFD_RELOC_MMIX_REG_OR_BYTE) 2415 || symsec != reg_section)))) 2416 { 2417 fixP->fx_done = 0; 2418 return; 2419 } 2420 else if (fixP->fx_r_type == BFD_RELOC_MMIX_LOCAL 2421 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT 2422 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY) 2423 { 2424 /* These are never "fixed". */ 2425 fixP->fx_done = 0; 2426 return; 2427 } 2428 else 2429 /* We assume every other relocation is "fixed". */ 2430 fixP->fx_done = 1; 2431 2432 switch (fixP->fx_r_type) 2433 { 2434 case BFD_RELOC_64: 2435 case BFD_RELOC_32: 2436 case BFD_RELOC_24: 2437 case BFD_RELOC_16: 2438 case BFD_RELOC_8: 2439 case BFD_RELOC_64_PCREL: 2440 case BFD_RELOC_32_PCREL: 2441 case BFD_RELOC_24_PCREL: 2442 case BFD_RELOC_16_PCREL: 2443 case BFD_RELOC_8_PCREL: 2444 md_number_to_chars (buf, val, fixP->fx_size); 2445 break; 2446 2447 case BFD_RELOC_MMIX_ADDR19: 2448 if (expand_op) 2449 { 2450 /* This shouldn't happen. */ 2451 BAD_CASE (fixP->fx_r_type); 2452 break; 2453 } 2454 /* FALLTHROUGH. */ 2455 case BFD_RELOC_MMIX_GETA: 2456 case BFD_RELOC_MMIX_CBRANCH: 2457 case BFD_RELOC_MMIX_PUSHJ: 2458 case BFD_RELOC_MMIX_PUSHJ_STUBBABLE: 2459 /* If this fixup is out of range, punt to the linker to emit an 2460 error. This should only happen with -no-expand. */ 2461 if (val < -(((offsetT) 1 << 19)/2) 2462 || val >= ((offsetT) 1 << 19)/2 - 1 2463 || (val & 3) != 0) 2464 { 2465 if (warn_on_expansion) 2466 as_warn_where (fixP->fx_file, fixP->fx_line, 2467 _("operand out of range")); 2468 fixP->fx_done = 0; 2469 val = 0; 2470 } 2471 mmix_set_geta_branch_offset (buf, val); 2472 break; 2473 2474 case BFD_RELOC_MMIX_ADDR27: 2475 if (expand_op) 2476 { 2477 /* This shouldn't happen. */ 2478 BAD_CASE (fixP->fx_r_type); 2479 break; 2480 } 2481 /* FALLTHROUGH. */ 2482 case BFD_RELOC_MMIX_JMP: 2483 /* If this fixup is out of range, punt to the linker to emit an 2484 error. This should only happen with -no-expand. */ 2485 if (val < -(((offsetT) 1 << 27)/2) 2486 || val >= ((offsetT) 1 << 27)/2 - 1 2487 || (val & 3) != 0) 2488 { 2489 if (warn_on_expansion) 2490 as_warn_where (fixP->fx_file, fixP->fx_line, 2491 _("operand out of range")); 2492 fixP->fx_done = 0; 2493 val = 0; 2494 } 2495 mmix_set_jmp_offset (buf, val); 2496 break; 2497 2498 case BFD_RELOC_MMIX_REG_OR_BYTE: 2499 if (fixP->fx_addsy != NULL 2500 && (S_GET_SEGMENT (fixP->fx_addsy) != reg_section 2501 || S_GET_VALUE (fixP->fx_addsy) > 255) 2502 && S_GET_SEGMENT (fixP->fx_addsy) != absolute_section) 2503 { 2504 as_bad_where (fixP->fx_file, fixP->fx_line, 2505 _("invalid operands")); 2506 /* We don't want this "symbol" appearing in output, because 2507 that will fail. */ 2508 fixP->fx_done = 1; 2509 } 2510 2511 buf[0] = val; 2512 2513 /* If this reloc is for a Z field, we need to adjust 2514 the opcode if we got a constant here. 2515 FIXME: Can we make this more robust? */ 2516 2517 if ((fixP->fx_where & 3) == 3 2518 && (fixP->fx_addsy == NULL 2519 || S_GET_SEGMENT (fixP->fx_addsy) == absolute_section)) 2520 buf[-3] |= IMM_OFFSET_BIT; 2521 break; 2522 2523 case BFD_RELOC_MMIX_REG: 2524 if (fixP->fx_addsy == NULL 2525 || S_GET_SEGMENT (fixP->fx_addsy) != reg_section 2526 || S_GET_VALUE (fixP->fx_addsy) > 255) 2527 { 2528 as_bad_where (fixP->fx_file, fixP->fx_line, 2529 _("invalid operands")); 2530 fixP->fx_done = 1; 2531 } 2532 2533 *buf = val; 2534 break; 2535 2536 case BFD_RELOC_MMIX_BASE_PLUS_OFFSET: 2537 /* These are never "fixed". */ 2538 fixP->fx_done = 0; 2539 return; 2540 2541 case BFD_RELOC_MMIX_PUSHJ_1: 2542 case BFD_RELOC_MMIX_PUSHJ_2: 2543 case BFD_RELOC_MMIX_PUSHJ_3: 2544 case BFD_RELOC_MMIX_CBRANCH_J: 2545 case BFD_RELOC_MMIX_CBRANCH_1: 2546 case BFD_RELOC_MMIX_CBRANCH_2: 2547 case BFD_RELOC_MMIX_CBRANCH_3: 2548 case BFD_RELOC_MMIX_GETA_1: 2549 case BFD_RELOC_MMIX_GETA_2: 2550 case BFD_RELOC_MMIX_GETA_3: 2551 case BFD_RELOC_MMIX_JMP_1: 2552 case BFD_RELOC_MMIX_JMP_2: 2553 case BFD_RELOC_MMIX_JMP_3: 2554 default: 2555 BAD_CASE (fixP->fx_r_type); 2556 break; 2557 } 2558 2559 if (fixP->fx_done) 2560 /* Make sure that for completed fixups we have the value around for 2561 use by e.g. mmix_frob_file. */ 2562 fixP->fx_offset = val; 2563} 2564 2565/* A bsearch function for looking up a value against offsets for GREG 2566 definitions. */ 2567 2568static int 2569cmp_greg_val_greg_symbol_fixes (const void *p1, const void *p2) 2570{ 2571 offsetT val1 = *(offsetT *) p1; 2572 offsetT val2 = ((struct mmix_symbol_greg_fixes *) p2)->offs; 2573 2574 if (val1 >= val2 && val1 < val2 + 255) 2575 return 0; 2576 2577 if (val1 > val2) 2578 return 1; 2579 2580 return -1; 2581} 2582 2583/* Generate a machine-dependent relocation. */ 2584 2585arelent * 2586tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixP) 2587{ 2588 bfd_signed_vma val 2589 = fixP->fx_offset 2590 + (fixP->fx_addsy != NULL 2591 && !S_IS_WEAK (fixP->fx_addsy) 2592 && !S_IS_COMMON (fixP->fx_addsy) 2593 ? S_GET_VALUE (fixP->fx_addsy) : 0); 2594 arelent *relP; 2595 bfd_reloc_code_real_type code = BFD_RELOC_NONE; 2596 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal; 2597 symbolS *addsy = fixP->fx_addsy; 2598 asection *addsec = addsy == NULL ? NULL : S_GET_SEGMENT (addsy); 2599 asymbol *baddsy = addsy != NULL ? symbol_get_bfdsym (addsy) : NULL; 2600 bfd_vma addend 2601 = val - (baddsy == NULL || S_IS_COMMON (addsy) || S_IS_WEAK (addsy) 2602 ? 0 : bfd_asymbol_value (baddsy)); 2603 2604 /* A single " LOCAL expression" in the wrong section will not work when 2605 linking to MMO; relocations for zero-content sections are then 2606 ignored. Normally, relocations would modify section contents, and 2607 you'd never think or be able to do something like that. The 2608 relocation resulting from a LOCAL directive doesn't have an obvious 2609 and mandatory location. I can't figure out a way to do this better 2610 than just helping the user around this limitation here; hopefully the 2611 code using the local expression is around. Putting the LOCAL 2612 semantics in a relocation still seems right; a section didn't do. */ 2613 if (bfd_section_size (section->owner, section) == 0) 2614 as_bad_where 2615 (fixP->fx_file, fixP->fx_line, 2616 fixP->fx_r_type == BFD_RELOC_MMIX_LOCAL 2617 /* The BFD_RELOC_MMIX_LOCAL-specific message is supposed to be 2618 user-friendly, though a little bit non-substantial. */ 2619 ? _("directive LOCAL must be placed in code or data") 2620 : _("internal confusion: relocation in a section without contents")); 2621 2622 /* FIXME: Range tests for all these. */ 2623 switch (fixP->fx_r_type) 2624 { 2625 case BFD_RELOC_64: 2626 case BFD_RELOC_32: 2627 case BFD_RELOC_24: 2628 case BFD_RELOC_16: 2629 case BFD_RELOC_8: 2630 code = fixP->fx_r_type; 2631 2632 if (addsy == NULL || bfd_is_abs_section (addsec)) 2633 { 2634 /* Resolve this reloc now, as md_apply_fix would have done (not 2635 called if -linkrelax). There is no point in keeping a reloc 2636 to an absolute symbol. No reloc that is subject to 2637 relaxation must be to an absolute symbol; difference 2638 involving symbols in a specific section must be signalled as 2639 an error if the relaxing cannot be expressed; having a reloc 2640 to the resolved (now absolute) value does not help. */ 2641 md_number_to_chars (buf, val, fixP->fx_size); 2642 return NULL; 2643 } 2644 break; 2645 2646 case BFD_RELOC_64_PCREL: 2647 case BFD_RELOC_32_PCREL: 2648 case BFD_RELOC_24_PCREL: 2649 case BFD_RELOC_16_PCREL: 2650 case BFD_RELOC_8_PCREL: 2651 case BFD_RELOC_MMIX_LOCAL: 2652 case BFD_RELOC_VTABLE_INHERIT: 2653 case BFD_RELOC_VTABLE_ENTRY: 2654 case BFD_RELOC_MMIX_GETA: 2655 case BFD_RELOC_MMIX_GETA_1: 2656 case BFD_RELOC_MMIX_GETA_2: 2657 case BFD_RELOC_MMIX_GETA_3: 2658 case BFD_RELOC_MMIX_CBRANCH: 2659 case BFD_RELOC_MMIX_CBRANCH_J: 2660 case BFD_RELOC_MMIX_CBRANCH_1: 2661 case BFD_RELOC_MMIX_CBRANCH_2: 2662 case BFD_RELOC_MMIX_CBRANCH_3: 2663 case BFD_RELOC_MMIX_PUSHJ: 2664 case BFD_RELOC_MMIX_PUSHJ_1: 2665 case BFD_RELOC_MMIX_PUSHJ_2: 2666 case BFD_RELOC_MMIX_PUSHJ_3: 2667 case BFD_RELOC_MMIX_PUSHJ_STUBBABLE: 2668 case BFD_RELOC_MMIX_JMP: 2669 case BFD_RELOC_MMIX_JMP_1: 2670 case BFD_RELOC_MMIX_JMP_2: 2671 case BFD_RELOC_MMIX_JMP_3: 2672 case BFD_RELOC_MMIX_ADDR19: 2673 case BFD_RELOC_MMIX_ADDR27: 2674 code = fixP->fx_r_type; 2675 break; 2676 2677 case BFD_RELOC_MMIX_REG_OR_BYTE: 2678 /* If we have this kind of relocation to an unknown symbol or to the 2679 register contents section (that is, to a register), then we can't 2680 resolve the relocation here. */ 2681 if (addsy != NULL 2682 && (bfd_is_und_section (addsec) 2683 || strcmp (bfd_get_section_name (addsec->owner, addsec), 2684 MMIX_REG_CONTENTS_SECTION_NAME) == 0)) 2685 { 2686 code = fixP->fx_r_type; 2687 break; 2688 } 2689 2690 /* If the relocation is not to the register section or to the 2691 absolute section (a numeric value), then we have an error. */ 2692 if (addsy != NULL 2693 && (S_GET_SEGMENT (addsy) != real_reg_section 2694 || val > 255 2695 || val < 0) 2696 && ! bfd_is_abs_section (addsec)) 2697 goto badop; 2698 2699 /* Set the "immediate" bit of the insn if this relocation is to Z 2700 field when the value is a numeric value, i.e. not a register. */ 2701 if ((fixP->fx_where & 3) == 3 2702 && (addsy == NULL || bfd_is_abs_section (addsec))) 2703 buf[-3] |= IMM_OFFSET_BIT; 2704 2705 buf[0] = val; 2706 return NULL; 2707 2708 case BFD_RELOC_MMIX_BASE_PLUS_OFFSET: 2709 if (addsy != NULL 2710 && strcmp (bfd_get_section_name (addsec->owner, addsec), 2711 MMIX_REG_CONTENTS_SECTION_NAME) == 0) 2712 { 2713 /* This changed into a register; the relocation is for the 2714 register-contents section. The constant part remains zero. */ 2715 code = BFD_RELOC_MMIX_REG; 2716 break; 2717 } 2718 2719 /* If we've found out that this was indeed a register, then replace 2720 with the register number. The constant part is already zero. 2721 2722 If we encounter any other defined symbol, then we must find a 2723 suitable register and emit a reloc. */ 2724 if (addsy == NULL || addsec != real_reg_section) 2725 { 2726 struct mmix_symbol_gregs *gregs; 2727 struct mmix_symbol_greg_fixes *fix; 2728 2729 if (S_IS_DEFINED (addsy) 2730 && !bfd_is_com_section (addsec) 2731 && !S_IS_WEAK (addsy)) 2732 { 2733 if (! symbol_section_p (addsy) && ! bfd_is_abs_section (addsec)) 2734 as_fatal (_("internal: BFD_RELOC_MMIX_BASE_PLUS_OFFSET not resolved to section")); 2735 2736 /* If this is an absolute symbol sufficiently near 2737 lowest_data_loc, then we canonicalize on the data 2738 section. Note that val is signed here; we may subtract 2739 lowest_data_loc which is unsigned. Careful with those 2740 comparisons. */ 2741 if (lowest_data_loc != (bfd_vma) -1 2742 && (bfd_vma) val + 256 > lowest_data_loc 2743 && bfd_is_abs_section (addsec)) 2744 { 2745 val -= (offsetT) lowest_data_loc; 2746 addsy = section_symbol (data_section); 2747 } 2748 /* Likewise text section. */ 2749 else if (lowest_text_loc != (bfd_vma) -1 2750 && (bfd_vma) val + 256 > lowest_text_loc 2751 && bfd_is_abs_section (addsec)) 2752 { 2753 val -= (offsetT) lowest_text_loc; 2754 addsy = section_symbol (text_section); 2755 } 2756 } 2757 2758 gregs = *symbol_get_tc (addsy); 2759 2760 /* If that symbol does not have any associated GREG definitions, 2761 we can't do anything. */ 2762 if (gregs == NULL 2763 || (fix = bsearch (&val, gregs->greg_fixes, gregs->n_gregs, 2764 sizeof (gregs->greg_fixes[0]), 2765 cmp_greg_val_greg_symbol_fixes)) == NULL 2766 /* The register must not point *after* the address we want. */ 2767 || fix->offs > val 2768 /* Neither must the register point more than 255 bytes 2769 before the address we want. */ 2770 || fix->offs + 255 < val) 2771 { 2772 /* We can either let the linker allocate GREGs 2773 automatically, or emit an error. */ 2774 if (allocate_undefined_gregs_in_linker) 2775 { 2776 /* The values in baddsy and addend are right. */ 2777 code = fixP->fx_r_type; 2778 break; 2779 } 2780 else 2781 as_bad_where (fixP->fx_file, fixP->fx_line, 2782 _("no suitable GREG definition for operands")); 2783 return NULL; 2784 } 2785 else 2786 { 2787 /* Transform the base-plus-offset reloc for the actual area 2788 to a reloc for the register with the address of the area. 2789 Put addend for register in Z operand. */ 2790 buf[1] = val - fix->offs; 2791 code = BFD_RELOC_MMIX_REG; 2792 baddsy 2793 = (bfd_get_section_by_name (stdoutput, 2794 MMIX_REG_CONTENTS_SECTION_NAME) 2795 ->symbol); 2796 2797 addend = fix->fix->fx_frag->fr_address + fix->fix->fx_where; 2798 } 2799 } 2800 else if (S_GET_VALUE (addsy) > 255) 2801 as_bad_where (fixP->fx_file, fixP->fx_line, 2802 _("invalid operands")); 2803 else 2804 { 2805 *buf = val; 2806 return NULL; 2807 } 2808 break; 2809 2810 case BFD_RELOC_MMIX_REG: 2811 if (addsy != NULL 2812 && (bfd_is_und_section (addsec) 2813 || strcmp (bfd_get_section_name (addsec->owner, addsec), 2814 MMIX_REG_CONTENTS_SECTION_NAME) == 0)) 2815 { 2816 code = fixP->fx_r_type; 2817 break; 2818 } 2819 2820 if (addsy != NULL 2821 && (addsec != real_reg_section 2822 || val > 255 2823 || val < 0) 2824 && ! bfd_is_und_section (addsec)) 2825 /* Drop through to error message. */ 2826 ; 2827 else 2828 { 2829 buf[0] = val; 2830 return NULL; 2831 } 2832 /* FALLTHROUGH. */ 2833 2834 /* The others are supposed to be handled by md_apply_fix. 2835 FIXME: ... which isn't called when -linkrelax. Move over 2836 md_apply_fix code here for everything reasonable. */ 2837 badop: 2838 default: 2839 as_bad_where 2840 (fixP->fx_file, fixP->fx_line, 2841 _("operands were not reducible at assembly-time")); 2842 2843 /* Unmark this symbol as used in a reloc, so we don't bump into a BFD 2844 assert when trying to output reg_section. FIXME: A gas bug. */ 2845 fixP->fx_addsy = NULL; 2846 return NULL; 2847 } 2848 2849 relP = (arelent *) xmalloc (sizeof (arelent)); 2850 gas_assert (relP != 0); 2851 relP->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); 2852 *relP->sym_ptr_ptr = baddsy; 2853 relP->address = fixP->fx_frag->fr_address + fixP->fx_where; 2854 2855 relP->addend = addend; 2856 2857 /* If this had been a.out, we would have had a kludge for weak symbols 2858 here. */ 2859 2860 relP->howto = bfd_reloc_type_lookup (stdoutput, code); 2861 if (! relP->howto) 2862 { 2863 const char *name; 2864 2865 name = S_GET_NAME (addsy); 2866 if (name == NULL) 2867 name = _("<unknown>"); 2868 as_fatal (_("cannot generate relocation type for symbol %s, code %s"), 2869 name, bfd_get_reloc_code_name (code)); 2870 } 2871 2872 return relP; 2873} 2874 2875/* Do some reformatting of a line. FIXME: We could transform a mmixal 2876 line into traditional (GNU?) format, unless #NO_APP, and get rid of all 2877 ugly labels_without_colons etc. */ 2878 2879void 2880mmix_handle_mmixal (void) 2881{ 2882 char *insn; 2883 char *s = input_line_pointer; 2884 char *label = NULL; 2885 char c; 2886 2887 if (pending_label != NULL) 2888 as_fatal (_("internal: unhandled label %s"), pending_label); 2889 2890 if (mmix_gnu_syntax) 2891 return; 2892 2893 /* If we're on a line with a label, check if it's a mmixal fb-label. 2894 Save an indicator and skip the label; it must be set only after all 2895 fb-labels of expressions are evaluated. */ 2896 if (ISDIGIT (s[0]) && s[1] == 'H' && ISSPACE (s[2])) 2897 { 2898 current_fb_label = s[0] - '0'; 2899 2900 /* We have to skip the label, but also preserve the newlineness of 2901 the previous character, since the caller checks that. It's a 2902 mess we blame on the caller. */ 2903 s[1] = s[-1]; 2904 s += 2; 2905 input_line_pointer = s; 2906 2907 while (*s && ISSPACE (*s) && ! is_end_of_line[(unsigned int) *s]) 2908 s++; 2909 2910 /* For errors emitted here, the book-keeping is off by one; the 2911 caller is about to bump the counters. Adjust the error messages. */ 2912 if (is_end_of_line[(unsigned int) *s]) 2913 { 2914 char *name; 2915 unsigned int line; 2916 as_where (&name, &line); 2917 as_bad_where (name, line + 1, 2918 _("[0-9]H labels may not appear alone on a line")); 2919 current_fb_label = -1; 2920 } 2921 if (*s == '.') 2922 { 2923 char *name; 2924 unsigned int line; 2925 as_where (&name, &line); 2926 as_bad_where (name, line + 1, 2927 _("[0-9]H labels do not mix with dot-pseudos")); 2928 current_fb_label = -1; 2929 } 2930 2931 /* Back off to the last space before the opcode so we don't handle 2932 the opcode as a label. */ 2933 s--; 2934 } 2935 else 2936 current_fb_label = -1; 2937 2938 if (*s == '.') 2939 { 2940 /* If the first character is a '.', then it's a pseudodirective, not a 2941 label. Make GAS not handle label-without-colon on this line. We 2942 also don't do mmixal-specific stuff on this line. */ 2943 label_without_colon_this_line = 0; 2944 return; 2945 } 2946 2947 if (*s == 0 || is_end_of_line[(unsigned int) *s]) 2948 /* We avoid handling empty lines here. */ 2949 return; 2950 2951 if (is_name_beginner (*s)) 2952 label = s; 2953 2954 /* If there is a label, skip over it. */ 2955 while (*s && is_part_of_name (*s)) 2956 s++; 2957 2958 /* Find the start of the instruction or pseudo following the label, 2959 if there is one. */ 2960 for (insn = s; 2961 *insn && ISSPACE (*insn) && ! is_end_of_line[(unsigned int) *insn]; 2962 insn++) 2963 /* Empty */ 2964 ; 2965 2966 /* Remove a trailing ":" off labels, as they'd otherwise be considered 2967 part of the name. But don't do this for local labels. */ 2968 if (s != input_line_pointer && s[-1] == ':' 2969 && (s - 2 != input_line_pointer 2970 || ! ISDIGIT (s[-2]))) 2971 s[-1] = ' '; 2972 else if (label != NULL 2973 /* For a lone label on a line, we don't attach it to the next 2974 instruction or MMIXAL-pseudo (getting its alignment). Thus 2975 is acts like a "normal" :-ended label. Ditto if it's 2976 followed by a non-MMIXAL pseudo. */ 2977 && !is_end_of_line[(unsigned int) *insn] 2978 && *insn != '.') 2979 { 2980 /* For labels that don't end in ":", we save it so we can later give 2981 it the same alignment and address as the associated instruction. */ 2982 2983 /* Make room for the label including the ending nul. */ 2984 int len_0 = s - label + 1; 2985 2986 /* Save this label on the MMIX symbol obstack. Saving it on an 2987 obstack is needless for "IS"-pseudos, but it's harmless and we 2988 avoid a little code-cluttering. */ 2989 obstack_grow (&mmix_sym_obstack, label, len_0); 2990 pending_label = obstack_finish (&mmix_sym_obstack); 2991 pending_label[len_0 - 1] = 0; 2992 } 2993 2994 /* If we have a non-MMIXAL pseudo, we have not business with the rest of 2995 the line. */ 2996 if (*insn == '.') 2997 return; 2998 2999 /* Find local labels of operands. Look for "[0-9][FB]" where the 3000 characters before and after are not part of words. Break if a single 3001 or double quote is seen anywhere. It means we can't have local 3002 labels as part of list with mixed quoted and unquoted members for 3003 mmixal compatibility but we can't have it all. For the moment. 3004 Replace the '<N>B' or '<N>F' with MAGIC_FB_BACKWARD_CHAR<N> and 3005 MAGIC_FB_FORWARD_CHAR<N> respectively. */ 3006 3007 /* First make sure we don't have any of the magic characters on the line 3008 appearing as input. */ 3009 while (*s) 3010 { 3011 c = *s++; 3012 if (is_end_of_line[(unsigned int) c]) 3013 break; 3014 if (c == MAGIC_FB_BACKWARD_CHAR || c == MAGIC_FB_FORWARD_CHAR) 3015 as_bad (_("invalid characters in input")); 3016 } 3017 3018 /* Scan again, this time looking for ';' after operands. */ 3019 s = insn; 3020 3021 /* Skip the insn. */ 3022 while (*s 3023 && ! ISSPACE (*s) 3024 && *s != ';' 3025 && ! is_end_of_line[(unsigned int) *s]) 3026 s++; 3027 3028 /* Skip the spaces after the insn. */ 3029 while (*s 3030 && ISSPACE (*s) 3031 && *s != ';' 3032 && ! is_end_of_line[(unsigned int) *s]) 3033 s++; 3034 3035 /* Skip the operands. While doing this, replace [0-9][BF] with 3036 (MAGIC_FB_BACKWARD_CHAR|MAGIC_FB_FORWARD_CHAR)[0-9]. */ 3037 while ((c = *s) != 0 3038 && ! ISSPACE (c) 3039 && c != ';' 3040 && ! is_end_of_line[(unsigned int) c]) 3041 { 3042 if (c == '"') 3043 { 3044 s++; 3045 3046 /* FIXME: Test-case for semi-colon in string. */ 3047 while (*s 3048 && *s != '"' 3049 && (! is_end_of_line[(unsigned int) *s] || *s == ';')) 3050 s++; 3051 3052 if (*s == '"') 3053 s++; 3054 } 3055 else if (ISDIGIT (c)) 3056 { 3057 if ((s[1] != 'B' && s[1] != 'F') 3058 || is_part_of_name (s[-1]) 3059 || is_part_of_name (s[2]) 3060 /* Don't treat e.g. #1F as a local-label reference. */ 3061 || (s != input_line_pointer && s[-1] == '#')) 3062 s++; 3063 else 3064 { 3065 s[0] = (s[1] == 'B' 3066 ? MAGIC_FB_BACKWARD_CHAR : MAGIC_FB_FORWARD_CHAR); 3067 s[1] = c; 3068 } 3069 } 3070 else 3071 s++; 3072 } 3073 3074 /* Skip any spaces after the operands. */ 3075 while (*s 3076 && ISSPACE (*s) 3077 && *s != ';' 3078 && !is_end_of_line[(unsigned int) *s]) 3079 s++; 3080 3081 /* If we're now looking at a semi-colon, then it's an end-of-line 3082 delimiter. */ 3083 mmix_next_semicolon_is_eoln = (*s == ';'); 3084 3085 /* Make IS into an EQU by replacing it with "= ". Only match upper-case 3086 though; let lower-case be a syntax error. */ 3087 s = insn; 3088 if (s[0] == 'I' && s[1] == 'S' && ISSPACE (s[2])) 3089 { 3090 *s = '='; 3091 s[1] = ' '; 3092 3093 /* Since labels can start without ":", we have to handle "X IS 42" 3094 in full here, or "X" will be parsed as a label to be set at ".". */ 3095 input_line_pointer = s; 3096 3097 /* Right after this function ends, line numbers will be bumped if 3098 input_line_pointer[-1] = '\n'. We want accurate line numbers for 3099 the equals call, so we bump them before the call, and make sure 3100 they aren't bumped afterwards. */ 3101 bump_line_counters (); 3102 3103 /* A fb-label is valid as an IS-label. */ 3104 if (current_fb_label >= 0) 3105 { 3106 char *fb_name; 3107 3108 /* We need to save this name on our symbol obstack, since the 3109 string we got in fb_label_name is volatile and will change 3110 with every call to fb_label_name, like those resulting from 3111 parsing the IS-operand. */ 3112 fb_name = fb_label_name (current_fb_label, 1); 3113 obstack_grow (&mmix_sym_obstack, fb_name, strlen (fb_name) + 1); 3114 equals (obstack_finish (&mmix_sym_obstack), 0); 3115 fb_label_instance_inc (current_fb_label); 3116 current_fb_label = -1; 3117 } 3118 else 3119 { 3120 if (pending_label == NULL) 3121 as_bad (_("empty label field for IS")); 3122 else 3123 equals (pending_label, 0); 3124 pending_label = NULL; 3125 } 3126 3127 /* For mmixal, we can have comments without a comment-start 3128 character. */ 3129 mmix_handle_rest_of_empty_line (); 3130 input_line_pointer--; 3131 3132 input_line_pointer[-1] = ' '; 3133 } 3134 else if (s[0] == 'G' 3135 && s[1] == 'R' 3136 && strncmp (s, "GREG", 4) == 0 3137 && (ISSPACE (s[4]) || is_end_of_line[(unsigned char) s[4]])) 3138 { 3139 input_line_pointer = s + 4; 3140 3141 /* Right after this function ends, line numbers will be bumped if 3142 input_line_pointer[-1] = '\n'. We want accurate line numbers for 3143 the s_greg call, so we bump them before the call, and make sure 3144 they aren't bumped afterwards. */ 3145 bump_line_counters (); 3146 3147 /* A fb-label is valid as a GREG-label. */ 3148 if (current_fb_label >= 0) 3149 { 3150 char *fb_name; 3151 3152 /* We need to save this name on our symbol obstack, since the 3153 string we got in fb_label_name is volatile and will change 3154 with every call to fb_label_name, like those resulting from 3155 parsing the IS-operand. */ 3156 fb_name = fb_label_name (current_fb_label, 1); 3157 3158 /* Make sure we save the canonical name and don't get bitten by 3159 prefixes. */ 3160 obstack_1grow (&mmix_sym_obstack, ':'); 3161 obstack_grow (&mmix_sym_obstack, fb_name, strlen (fb_name) + 1); 3162 mmix_greg_internal (obstack_finish (&mmix_sym_obstack)); 3163 fb_label_instance_inc (current_fb_label); 3164 current_fb_label = -1; 3165 } 3166 else 3167 mmix_greg_internal (pending_label); 3168 3169 /* Back up before the end-of-line marker that was skipped in 3170 mmix_greg_internal. */ 3171 input_line_pointer--; 3172 input_line_pointer[-1] = ' '; 3173 3174 pending_label = NULL; 3175 } 3176 else if (pending_label != NULL) 3177 { 3178 input_line_pointer += strlen (pending_label); 3179 3180 /* See comment above about getting line numbers bumped. */ 3181 input_line_pointer[-1] = '\n'; 3182 } 3183} 3184 3185/* Give the value of an fb-label rewritten as in mmix_handle_mmixal, when 3186 parsing an expression. 3187 3188 On valid calls, input_line_pointer points at a MAGIC_FB_BACKWARD_CHAR 3189 or MAGIC_FB_BACKWARD_CHAR, followed by an ascii digit for the label. 3190 We fill in the label as an expression. */ 3191 3192void 3193mmix_fb_label (expressionS *expP) 3194{ 3195 symbolS *sym; 3196 char *fb_internal_name; 3197 3198 /* This doesn't happen when not using mmixal syntax. */ 3199 if (mmix_gnu_syntax 3200 || (input_line_pointer[0] != MAGIC_FB_BACKWARD_CHAR 3201 && input_line_pointer[0] != MAGIC_FB_FORWARD_CHAR)) 3202 return; 3203 3204 /* The current backward reference has augmentation 0. A forward 3205 reference has augmentation 1, unless it's the same as a fb-label on 3206 _this_ line, in which case we add one more so we don't refer to it. 3207 This is the semantics of mmixal; it differs to that of common 3208 fb-labels which refer to a here-label on the current line as a 3209 backward reference. */ 3210 fb_internal_name 3211 = fb_label_name (input_line_pointer[1] - '0', 3212 (input_line_pointer[0] == MAGIC_FB_FORWARD_CHAR ? 1 : 0) 3213 + ((input_line_pointer[1] - '0' == current_fb_label 3214 && input_line_pointer[0] == MAGIC_FB_FORWARD_CHAR) 3215 ? 1 : 0)); 3216 3217 input_line_pointer += 2; 3218 sym = symbol_find_or_make (fb_internal_name); 3219 3220 /* We don't have to clean up unrelated fields here; we just do what the 3221 expr machinery does, but *not* just what it does for [0-9][fb], since 3222 we need to treat those as ordinary symbols sometimes; see testcases 3223 err-byte2.s and fb-2.s. */ 3224 if (S_GET_SEGMENT (sym) == absolute_section) 3225 { 3226 expP->X_op = O_constant; 3227 expP->X_add_number = S_GET_VALUE (sym); 3228 } 3229 else 3230 { 3231 expP->X_op = O_symbol; 3232 expP->X_add_symbol = sym; 3233 expP->X_add_number = 0; 3234 } 3235} 3236 3237/* See whether we need to force a relocation into the output file. 3238 This is used to force out switch and PC relative relocations when 3239 relaxing. */ 3240 3241int 3242mmix_force_relocation (fixS *fixP) 3243{ 3244 if (fixP->fx_r_type == BFD_RELOC_MMIX_LOCAL 3245 || fixP->fx_r_type == BFD_RELOC_MMIX_BASE_PLUS_OFFSET) 3246 return 1; 3247 3248 if (linkrelax) 3249 return 1; 3250 3251 /* All our pcrel relocations are must-keep. Note that md_apply_fix is 3252 called *after* this, and will handle getting rid of the presumed 3253 reloc; a relocation isn't *forced* other than to be handled by 3254 md_apply_fix (or tc_gen_reloc if linkrelax). */ 3255 if (fixP->fx_pcrel) 3256 return 1; 3257 3258 return generic_force_reloc (fixP); 3259} 3260 3261/* The location from which a PC relative jump should be calculated, 3262 given a PC relative reloc. */ 3263 3264long 3265md_pcrel_from_section (fixS *fixP, segT sec) 3266{ 3267 if (fixP->fx_addsy != (symbolS *) NULL 3268 && (! S_IS_DEFINED (fixP->fx_addsy) 3269 || S_GET_SEGMENT (fixP->fx_addsy) != sec)) 3270 { 3271 /* The symbol is undefined (or is defined but not in this section). 3272 Let the linker figure it out. */ 3273 return 0; 3274 } 3275 3276 return (fixP->fx_frag->fr_address + fixP->fx_where); 3277} 3278 3279/* Adjust the symbol table. We make reg_section relative to the real 3280 register section. */ 3281 3282void 3283mmix_adjust_symtab (void) 3284{ 3285 symbolS *sym; 3286 symbolS *regsec = section_symbol (reg_section); 3287 3288 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym)) 3289 if (S_GET_SEGMENT (sym) == reg_section) 3290 { 3291 if (sym == regsec) 3292 { 3293 if (S_IS_EXTERNAL (sym) || symbol_used_in_reloc_p (sym)) 3294 abort (); 3295 symbol_remove (sym, &symbol_rootP, &symbol_lastP); 3296 } 3297 else 3298 /* Change section to the *real* register section, so it gets 3299 proper treatment when writing it out. Only do this for 3300 global symbols. This also means we don't have to check for 3301 $0..$255. */ 3302 S_SET_SEGMENT (sym, real_reg_section); 3303 } 3304} 3305 3306/* This is the expansion of LABELS_WITHOUT_COLONS. 3307 We let md_start_line_hook tweak label_without_colon_this_line, and then 3308 this function returns the tweaked value, and sets it to 1 for the next 3309 line. FIXME: Very, very brittle. Not sure it works the way I 3310 thought at the time I first wrote this. */ 3311 3312int 3313mmix_label_without_colon_this_line (void) 3314{ 3315 int retval = label_without_colon_this_line; 3316 3317 if (! mmix_gnu_syntax) 3318 label_without_colon_this_line = 1; 3319 3320 return retval; 3321} 3322 3323/* This is the expansion of md_relax_frag. We go through the ordinary 3324 relax table function except when the frag is for a GREG. Then we have 3325 to check whether there's another GREG by the same value that we can 3326 join with. */ 3327 3328long 3329mmix_md_relax_frag (segT seg, fragS *fragP, long stretch) 3330{ 3331 switch (fragP->fr_subtype) 3332 { 3333 /* Growth for this type has been handled by mmix_md_end and 3334 correctly estimated, so there's nothing more to do here. */ 3335 case STATE_GREG_DEF: 3336 return 0; 3337 3338 case ENCODE_RELAX (STATE_PUSHJ, STATE_ZERO): 3339 { 3340 /* We need to handle relaxation type ourselves, since relax_frag 3341 doesn't update fr_subtype if there's no size increase in the 3342 current section; when going from plain PUSHJ to a stub. This 3343 is otherwise functionally the same as relax_frag in write.c, 3344 simplified for this case. */ 3345 offsetT aim; 3346 addressT target; 3347 addressT address; 3348 symbolS *symbolP; 3349 target = fragP->fr_offset; 3350 address = fragP->fr_address; 3351 symbolP = fragP->fr_symbol; 3352 3353 if (symbolP) 3354 { 3355 fragS *sym_frag; 3356 3357 sym_frag = symbol_get_frag (symbolP); 3358 know (S_GET_SEGMENT (symbolP) != absolute_section 3359 || sym_frag == &zero_address_frag); 3360 target += S_GET_VALUE (symbolP); 3361 3362 /* If frag has yet to be reached on this pass, assume it will 3363 move by STRETCH just as we did. If this is not so, it will 3364 be because some frag between grows, and that will force 3365 another pass. */ 3366 3367 if (stretch != 0 3368 && sym_frag->relax_marker != fragP->relax_marker 3369 && S_GET_SEGMENT (symbolP) == seg) 3370 target += stretch; 3371 } 3372 3373 aim = target - address - fragP->fr_fix; 3374 if (aim >= PUSHJ_0B && aim <= PUSHJ_0F) 3375 { 3376 /* Target is reachable with a PUSHJ. */ 3377 segment_info_type *seginfo = seg_info (seg); 3378 3379 /* If we're at the end of a relaxation round, clear the stub 3380 counter as initialization for the next round. */ 3381 if (fragP == seginfo->tc_segment_info_data.last_stubfrag) 3382 seginfo->tc_segment_info_data.nstubs = 0; 3383 return 0; 3384 } 3385 3386 /* Not reachable. Try a stub. */ 3387 fragP->fr_subtype = ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO); 3388 } 3389 /* FALLTHROUGH. */ 3390 3391 /* See if this PUSHJ is redirectable to a stub. */ 3392 case ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO): 3393 { 3394 segment_info_type *seginfo = seg_info (seg); 3395 fragS *lastfrag = seginfo->frchainP->frch_last; 3396 relax_substateT prev_type = fragP->fr_subtype; 3397 3398 /* The last frag is always an empty frag, so it suffices to look 3399 at its address to know the ending address of this section. */ 3400 know (lastfrag->fr_type == rs_fill 3401 && lastfrag->fr_fix == 0 3402 && lastfrag->fr_var == 0); 3403 3404 /* For this PUSHJ to be relaxable into a call to a stub, the 3405 distance must be no longer than 256k bytes from the PUSHJ to 3406 the end of the section plus the maximum size of stubs so far. */ 3407 if ((lastfrag->fr_address 3408 + stretch 3409 + PUSHJ_MAX_LEN * seginfo->tc_segment_info_data.nstubs) 3410 - (fragP->fr_address + fragP->fr_fix) 3411 > GETA_0F 3412 || !pushj_stubs) 3413 fragP->fr_subtype = mmix_relax_table[prev_type].rlx_more; 3414 else 3415 seginfo->tc_segment_info_data.nstubs++; 3416 3417 /* If we're at the end of a relaxation round, clear the stub 3418 counter as initialization for the next round. */ 3419 if (fragP == seginfo->tc_segment_info_data.last_stubfrag) 3420 seginfo->tc_segment_info_data.nstubs = 0; 3421 3422 return 3423 (mmix_relax_table[fragP->fr_subtype].rlx_length 3424 - mmix_relax_table[prev_type].rlx_length); 3425 } 3426 3427 case ENCODE_RELAX (STATE_PUSHJ, STATE_MAX): 3428 { 3429 segment_info_type *seginfo = seg_info (seg); 3430 3431 /* Need to cover all STATE_PUSHJ states to act on the last stub 3432 frag (the end of this relax round; initialization for the 3433 next). */ 3434 if (fragP == seginfo->tc_segment_info_data.last_stubfrag) 3435 seginfo->tc_segment_info_data.nstubs = 0; 3436 3437 return 0; 3438 } 3439 3440 default: 3441 return relax_frag (seg, fragP, stretch); 3442 3443 case STATE_GREG_UNDF: 3444 BAD_CASE (fragP->fr_subtype); 3445 } 3446 3447 as_fatal (_("internal: unexpected relax type %d:%d"), 3448 fragP->fr_type, fragP->fr_subtype); 3449 return 0; 3450} 3451 3452/* Various things we punt until all input is seen. */ 3453 3454void 3455mmix_md_end (void) 3456{ 3457 fragS *fragP; 3458 symbolS *mainsym; 3459 asection *regsec; 3460 int i; 3461 3462 /* The first frag of GREG:s going into the register contents section. */ 3463 fragS *mmix_reg_contents_frags = NULL; 3464 3465 /* Reset prefix. All labels reachable at this point must be 3466 canonicalized. */ 3467 mmix_current_prefix = NULL; 3468 3469 if (doing_bspec) 3470 as_bad_where (bspec_file, bspec_line, _("BSPEC without ESPEC.")); 3471 3472 /* Emit the low LOC setting of .text. */ 3473 if (text_has_contents && lowest_text_loc != (bfd_vma) -1) 3474 { 3475 symbolS *symbolP; 3476 char locsymbol[sizeof (":") - 1 3477 + sizeof (MMIX_LOC_SECTION_START_SYMBOL_PREFIX) - 1 3478 + sizeof (".text")]; 3479 3480 /* An exercise in non-ISO-C-ness, this one. */ 3481 sprintf (locsymbol, ":%s%s", MMIX_LOC_SECTION_START_SYMBOL_PREFIX, 3482 ".text"); 3483 symbolP 3484 = symbol_new (locsymbol, absolute_section, lowest_text_loc, 3485 &zero_address_frag); 3486 S_SET_EXTERNAL (symbolP); 3487 } 3488 3489 /* Ditto .data. */ 3490 if (data_has_contents && lowest_data_loc != (bfd_vma) -1) 3491 { 3492 symbolS *symbolP; 3493 char locsymbol[sizeof (":") - 1 3494 + sizeof (MMIX_LOC_SECTION_START_SYMBOL_PREFIX) - 1 3495 + sizeof (".data")]; 3496 3497 sprintf (locsymbol, ":%s%s", MMIX_LOC_SECTION_START_SYMBOL_PREFIX, 3498 ".data"); 3499 symbolP 3500 = symbol_new (locsymbol, absolute_section, lowest_data_loc, 3501 &zero_address_frag); 3502 S_SET_EXTERNAL (symbolP); 3503 } 3504 3505 /* Unless GNU syntax mode, set "Main" to be a function, so the 3506 disassembler doesn't get confused when we write truly 3507 mmixal-compatible code (and don't use .type). Similarly set it 3508 global (regardless of -globalize-symbols), so the linker sees it as 3509 the start symbol in ELF mode. */ 3510 mainsym = symbol_find (MMIX_START_SYMBOL_NAME); 3511 if (mainsym != NULL && ! mmix_gnu_syntax) 3512 { 3513 symbol_get_bfdsym (mainsym)->flags |= BSF_FUNCTION; 3514 S_SET_EXTERNAL (mainsym); 3515 } 3516 3517 if (n_of_raw_gregs != 0) 3518 { 3519 /* Emit GREGs. They are collected in order of appearance, but must 3520 be emitted in opposite order to both have section address regno*8 3521 and the same allocation order (within a file) as mmixal. */ 3522 segT this_segment = now_seg; 3523 subsegT this_subsegment = now_subseg; 3524 3525 regsec = bfd_make_section_old_way (stdoutput, 3526 MMIX_REG_CONTENTS_SECTION_NAME); 3527 subseg_set (regsec, 0); 3528 3529 /* Finally emit the initialization-value. Emit a variable frag, which 3530 we'll fix in md_estimate_size_before_relax. We set the initializer 3531 for the tc_frag_data field to NULL, so we can use that field for 3532 relaxation purposes. */ 3533 mmix_opcode_frag = NULL; 3534 3535 frag_grow (0); 3536 mmix_reg_contents_frags = frag_now; 3537 3538 for (i = n_of_raw_gregs - 1; i >= 0; i--) 3539 { 3540 if (mmix_raw_gregs[i].label != NULL) 3541 /* There's a symbol. Let it refer to this location in the 3542 register contents section. The symbol must be globalized 3543 separately. */ 3544 colon (mmix_raw_gregs[i].label); 3545 3546 frag_var (rs_machine_dependent, 8, 0, STATE_GREG_UNDF, 3547 make_expr_symbol (&mmix_raw_gregs[i].exp), 0, NULL); 3548 } 3549 3550 subseg_set (this_segment, this_subsegment); 3551 } 3552 3553 regsec = bfd_get_section_by_name (stdoutput, MMIX_REG_CONTENTS_SECTION_NAME); 3554 /* Mark the section symbol as being OK for a reloc. */ 3555 if (regsec != NULL) 3556 regsec->symbol->flags |= BSF_KEEP; 3557 3558 /* Iterate over frags resulting from GREGs and move those that evidently 3559 have the same value together and point one to another. 3560 3561 This works in time O(N^2) but since the upper bound for non-error use 3562 is 223, it's best to keep this simpler algorithm. */ 3563 for (fragP = mmix_reg_contents_frags; fragP != NULL; fragP = fragP->fr_next) 3564 { 3565 fragS **fpp; 3566 fragS *fp = NULL; 3567 fragS *osymfrag; 3568 offsetT osymval; 3569 expressionS *oexpP; 3570 symbolS *symbolP = fragP->fr_symbol; 3571 3572 if (fragP->fr_type != rs_machine_dependent 3573 || fragP->fr_subtype != STATE_GREG_UNDF) 3574 continue; 3575 3576 /* Whatever the outcome, we will have this GREG judged merged or 3577 non-merged. Since the tc_frag_data is NULL at this point, we 3578 default to non-merged. */ 3579 fragP->fr_subtype = STATE_GREG_DEF; 3580 3581 /* If we're not supposed to merge GREG definitions, then just don't 3582 look for equivalents. */ 3583 if (! merge_gregs) 3584 continue; 3585 3586 osymval = (offsetT) S_GET_VALUE (symbolP); 3587 osymfrag = symbol_get_frag (symbolP); 3588 3589 /* If the symbol isn't defined, we can't say that another symbol 3590 equals this frag, then. FIXME: We can look at the "deepest" 3591 defined name; if a = c and b = c then obviously a == b. */ 3592 if (! S_IS_DEFINED (symbolP)) 3593 continue; 3594 3595 oexpP = symbol_get_value_expression (fragP->fr_symbol); 3596 3597 /* If the initialization value is zero, then we must not merge them. */ 3598 if (oexpP->X_op == O_constant && osymval == 0) 3599 continue; 3600 3601 /* Iterate through the frags downward this one. If we find one that 3602 has the same non-zero value, move it to after this one and point 3603 to it as the equivalent. */ 3604 for (fpp = &fragP->fr_next; *fpp != NULL; fpp = &fpp[0]->fr_next) 3605 { 3606 fp = *fpp; 3607 3608 if (fp->fr_type != rs_machine_dependent 3609 || fp->fr_subtype != STATE_GREG_UNDF) 3610 continue; 3611 3612 /* Calling S_GET_VALUE may simplify the symbol, changing from 3613 expr_section etc. so call it first. */ 3614 if ((offsetT) S_GET_VALUE (fp->fr_symbol) == osymval 3615 && symbol_get_frag (fp->fr_symbol) == osymfrag) 3616 { 3617 /* Move the frag links so the one we found equivalent comes 3618 after the current one, carefully considering that 3619 sometimes fpp == &fragP->fr_next and the moves must be a 3620 NOP then. */ 3621 *fpp = fp->fr_next; 3622 fp->fr_next = fragP->fr_next; 3623 fragP->fr_next = fp; 3624 break; 3625 } 3626 } 3627 3628 if (*fpp != NULL) 3629 fragP->tc_frag_data = fp; 3630 } 3631} 3632 3633/* qsort function for mmix_symbol_gregs. */ 3634 3635static int 3636cmp_greg_symbol_fixes (const void *parg, const void *qarg) 3637{ 3638 const struct mmix_symbol_greg_fixes *p 3639 = (const struct mmix_symbol_greg_fixes *) parg; 3640 const struct mmix_symbol_greg_fixes *q 3641 = (const struct mmix_symbol_greg_fixes *) qarg; 3642 3643 return p->offs > q->offs ? 1 : p->offs < q->offs ? -1 : 0; 3644} 3645 3646/* Collect GREG definitions from mmix_gregs and hang them as lists sorted 3647 on increasing offsets onto each section symbol or undefined symbol. 3648 3649 Also, remove the register convenience section so it doesn't get output 3650 as an ELF section. */ 3651 3652void 3653mmix_frob_file (void) 3654{ 3655 int i; 3656 struct mmix_symbol_gregs *all_greg_symbols[MAX_GREGS]; 3657 int n_greg_symbols = 0; 3658 3659 /* Collect all greg fixups and decorate each corresponding symbol with 3660 the greg fixups for it. */ 3661 for (i = 0; i < n_of_cooked_gregs; i++) 3662 { 3663 offsetT offs; 3664 symbolS *sym; 3665 struct mmix_symbol_gregs *gregs; 3666 fixS *fixP; 3667 3668 fixP = mmix_gregs[i]; 3669 know (fixP->fx_r_type == BFD_RELOC_64); 3670 3671 /* This case isn't doable in general anyway, methinks. */ 3672 if (fixP->fx_subsy != NULL) 3673 { 3674 as_bad_where (fixP->fx_file, fixP->fx_line, 3675 _("GREG expression too complicated")); 3676 continue; 3677 } 3678 3679 sym = fixP->fx_addsy; 3680 offs = (offsetT) fixP->fx_offset; 3681 3682 /* If the symbol is defined, then it must be resolved to a section 3683 symbol at this time, or else we don't know how to handle it. */ 3684 if (S_IS_DEFINED (sym) 3685 && !bfd_is_com_section (S_GET_SEGMENT (sym)) 3686 && !S_IS_WEAK (sym)) 3687 { 3688 if (! symbol_section_p (sym) 3689 && ! bfd_is_abs_section (S_GET_SEGMENT (sym))) 3690 as_fatal (_("internal: GREG expression not resolved to section")); 3691 3692 offs += S_GET_VALUE (sym); 3693 } 3694 3695 /* If this is an absolute symbol sufficiently near lowest_data_loc, 3696 then we canonicalize on the data section. Note that offs is 3697 signed here; we may subtract lowest_data_loc which is unsigned. 3698 Careful with those comparisons. */ 3699 if (lowest_data_loc != (bfd_vma) -1 3700 && (bfd_vma) offs + 256 > lowest_data_loc 3701 && bfd_is_abs_section (S_GET_SEGMENT (sym))) 3702 { 3703 offs -= (offsetT) lowest_data_loc; 3704 sym = section_symbol (data_section); 3705 } 3706 /* Likewise text section. */ 3707 else if (lowest_text_loc != (bfd_vma) -1 3708 && (bfd_vma) offs + 256 > lowest_text_loc 3709 && bfd_is_abs_section (S_GET_SEGMENT (sym))) 3710 { 3711 offs -= (offsetT) lowest_text_loc; 3712 sym = section_symbol (text_section); 3713 } 3714 3715 gregs = *symbol_get_tc (sym); 3716 3717 if (gregs == NULL) 3718 { 3719 gregs = xmalloc (sizeof (*gregs)); 3720 gregs->n_gregs = 0; 3721 symbol_set_tc (sym, &gregs); 3722 all_greg_symbols[n_greg_symbols++] = gregs; 3723 } 3724 3725 gregs->greg_fixes[gregs->n_gregs].fix = fixP; 3726 gregs->greg_fixes[gregs->n_gregs++].offs = offs; 3727 } 3728 3729 /* For each symbol having a GREG definition, sort those definitions on 3730 offset. */ 3731 for (i = 0; i < n_greg_symbols; i++) 3732 qsort (all_greg_symbols[i]->greg_fixes, all_greg_symbols[i]->n_gregs, 3733 sizeof (all_greg_symbols[i]->greg_fixes[0]), cmp_greg_symbol_fixes); 3734 3735 if (real_reg_section != NULL) 3736 { 3737 /* FIXME: Pass error state gracefully. */ 3738 if (bfd_get_section_flags (stdoutput, real_reg_section) & SEC_HAS_CONTENTS) 3739 as_fatal (_("register section has contents\n")); 3740 3741 bfd_section_list_remove (stdoutput, real_reg_section); 3742 --stdoutput->section_count; 3743 } 3744 3745} 3746 3747/* Provide an expression for a built-in name provided when-used. 3748 Either a symbol that is a handler; living in 0x10*[1..8] and having 3749 name [DVWIOUZX]_Handler, or a mmixal built-in symbol. 3750 3751 If the name isn't a built-in name and parsed into *EXPP, return zero. */ 3752 3753int 3754mmix_parse_predefined_name (char *name, expressionS *expP) 3755{ 3756 char *canon_name; 3757 char *handler_charp; 3758 const char handler_chars[] = "DVWIOUZX"; 3759 symbolS *symp; 3760 3761 if (! predefined_syms) 3762 return 0; 3763 3764 canon_name = tc_canonicalize_symbol_name (name); 3765 3766 if (canon_name[1] == '_' 3767 && strcmp (canon_name + 2, "Handler") == 0 3768 && (handler_charp = strchr (handler_chars, *canon_name)) != NULL) 3769 { 3770 /* If the symbol doesn't exist, provide one relative to the .text 3771 section. 3772 3773 FIXME: We should provide separate sections, mapped in the linker 3774 script. */ 3775 symp = symbol_find (name); 3776 if (symp == NULL) 3777 symp = symbol_new (name, text_section, 3778 0x10 * (handler_charp + 1 - handler_chars), 3779 &zero_address_frag); 3780 } 3781 else 3782 { 3783 /* These symbols appear when referenced; needed for 3784 mmixal-compatible programs. */ 3785 unsigned int i; 3786 3787 static const struct 3788 { 3789 const char *name; 3790 valueT val; 3791 } predefined_abs_syms[] = 3792 { 3793 {"Data_Segment", (valueT) 0x20 << 56}, 3794 {"Pool_Segment", (valueT) 0x40 << 56}, 3795 {"Stack_Segment", (valueT) 0x60 << 56}, 3796 {"StdIn", 0}, 3797 {"StdOut", 1}, 3798 {"StdErr", 2}, 3799 {"TextRead", 0}, 3800 {"TextWrite", 1}, 3801 {"BinaryRead", 2}, 3802 {"BinaryWrite", 3}, 3803 {"BinaryReadWrite", 4}, 3804 {"Halt", 0}, 3805 {"Fopen", 1}, 3806 {"Fclose", 2}, 3807 {"Fread", 3}, 3808 {"Fgets", 4}, 3809 {"Fgetws", 5}, 3810 {"Fwrite", 6}, 3811 {"Fputs", 7}, 3812 {"Fputws", 8}, 3813 {"Fseek", 9}, 3814 {"Ftell", 10}, 3815 {"D_BIT", 0x80}, 3816 {"V_BIT", 0x40}, 3817 {"W_BIT", 0x20}, 3818 {"I_BIT", 0x10}, 3819 {"O_BIT", 0x08}, 3820 {"U_BIT", 0x04}, 3821 {"Z_BIT", 0x02}, 3822 {"X_BIT", 0x01}, 3823 {"Inf", 0x7ff00000} 3824 }; 3825 3826 /* If it's already in the symbol table, we shouldn't do anything. */ 3827 symp = symbol_find (name); 3828 if (symp != NULL) 3829 return 0; 3830 3831 for (i = 0; 3832 i < sizeof (predefined_abs_syms) / sizeof (predefined_abs_syms[0]); 3833 i++) 3834 if (strcmp (canon_name, predefined_abs_syms[i].name) == 0) 3835 { 3836 symbol_table_insert (symbol_new (predefined_abs_syms[i].name, 3837 absolute_section, 3838 predefined_abs_syms[i].val, 3839 &zero_address_frag)); 3840 3841 /* Let gas find the symbol we just created, through its 3842 ordinary lookup. */ 3843 return 0; 3844 } 3845 3846 /* Not one of those symbols. Let gas handle it. */ 3847 return 0; 3848 } 3849 3850 expP->X_op = O_symbol; 3851 expP->X_add_number = 0; 3852 expP->X_add_symbol = symp; 3853 expP->X_op_symbol = NULL; 3854 3855 return 1; 3856} 3857 3858/* Just check that we don't have a BSPEC/ESPEC pair active when changing 3859 sections "normally", and get knowledge about alignment from the new 3860 section. */ 3861 3862void 3863mmix_md_elf_section_change_hook (void) 3864{ 3865 if (doing_bspec) 3866 as_bad (_("section change from within a BSPEC/ESPEC pair is not supported")); 3867 3868 last_alignment = bfd_get_section_alignment (now_seg->owner, now_seg); 3869 want_unaligned = 0; 3870} 3871 3872/* The LOC worker. This is like s_org, but we have to support changing 3873 section too. */ 3874 3875static void 3876s_loc (int ignore ATTRIBUTE_UNUSED) 3877{ 3878 segT section; 3879 expressionS exp; 3880 char *p; 3881 symbolS *sym; 3882 offsetT off; 3883 3884 /* Must not have a BSPEC in progress. */ 3885 if (doing_bspec) 3886 { 3887 as_bad (_("directive LOC from within a BSPEC/ESPEC pair is not supported")); 3888 return; 3889 } 3890 3891 section = expression (&exp); 3892 3893 if (exp.X_op == O_illegal 3894 || exp.X_op == O_absent 3895 || exp.X_op == O_big 3896 || section == undefined_section) 3897 { 3898 as_bad (_("invalid LOC expression")); 3899 return; 3900 } 3901 3902 if (section == absolute_section) 3903 { 3904 /* Translate a constant into a suitable section. */ 3905 3906 if (exp.X_add_number < ((offsetT) 0x20 << 56)) 3907 { 3908 /* Lower than Data_Segment or in the reserved area (the 3909 segment number is >= 0x80, appearing negative) - assume 3910 it's .text. */ 3911 section = text_section; 3912 3913 /* Save the lowest seen location, so we can pass on this 3914 information to the linker. We don't actually org to this 3915 location here, we just pass on information to the linker so 3916 it can put the code there for us. */ 3917 3918 /* If there was already a loc (that has to be set lower than 3919 this one), we org at (this - lower). There's an implicit 3920 "LOC 0" before any entered code. FIXME: handled by spurious 3921 settings of text_has_contents. */ 3922 if (lowest_text_loc != (bfd_vma) -1 3923 && (bfd_vma) exp.X_add_number < lowest_text_loc) 3924 { 3925 as_bad (_("LOC expression stepping backwards is not supported")); 3926 exp.X_op = O_absent; 3927 } 3928 else 3929 { 3930 if (text_has_contents && lowest_text_loc == (bfd_vma) -1) 3931 lowest_text_loc = 0; 3932 3933 if (lowest_text_loc == (bfd_vma) -1) 3934 { 3935 lowest_text_loc = exp.X_add_number; 3936 3937 /* We want only to change the section, not set an offset. */ 3938 exp.X_op = O_absent; 3939 } 3940 else 3941 exp.X_add_number -= lowest_text_loc; 3942 } 3943 } 3944 else 3945 { 3946 /* Do the same for the .data section, except we don't have 3947 to worry about exp.X_add_number carrying a sign. */ 3948 section = data_section; 3949 3950 if (exp.X_add_number < (offsetT) lowest_data_loc) 3951 { 3952 as_bad (_("LOC expression stepping backwards is not supported")); 3953 exp.X_op = O_absent; 3954 } 3955 else 3956 { 3957 if (data_has_contents && lowest_data_loc == (bfd_vma) -1) 3958 lowest_data_loc = (bfd_vma) 0x20 << 56; 3959 3960 if (lowest_data_loc == (bfd_vma) -1) 3961 { 3962 lowest_data_loc = exp.X_add_number; 3963 3964 /* We want only to change the section, not set an offset. */ 3965 exp.X_op = O_absent; 3966 } 3967 else 3968 exp.X_add_number -= lowest_data_loc; 3969 } 3970 } 3971 } 3972 3973 if (section != now_seg) 3974 { 3975 obj_elf_section_change_hook (); 3976 subseg_set (section, 0); 3977 3978 /* Call our section change hooks using the official hook. */ 3979 md_elf_section_change_hook (); 3980 } 3981 3982 if (exp.X_op != O_absent) 3983 { 3984 if (exp.X_op != O_constant && exp.X_op != O_symbol) 3985 { 3986 /* Handle complex expressions. */ 3987 sym = make_expr_symbol (&exp); 3988 off = 0; 3989 } 3990 else 3991 { 3992 sym = exp.X_add_symbol; 3993 off = exp.X_add_number; 3994 } 3995 3996 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0); 3997 *p = 0; 3998 } 3999 4000 mmix_handle_rest_of_empty_line (); 4001} 4002 4003/* The BYTE worker. We have to support sequences of mixed "strings", 4004 numbers and other constant "first-pass" reducible expressions separated 4005 by comma. */ 4006 4007static void 4008mmix_byte (void) 4009{ 4010 unsigned int c; 4011 4012 if (now_seg == text_section) 4013 text_has_contents = 1; 4014 else if (now_seg == data_section) 4015 data_has_contents = 1; 4016 4017 do 4018 { 4019 SKIP_WHITESPACE (); 4020 switch (*input_line_pointer) 4021 { 4022 case '\"': 4023 ++input_line_pointer; 4024 while (is_a_char (c = next_char_of_string ())) 4025 { 4026 FRAG_APPEND_1_CHAR (c); 4027 } 4028 4029 if (input_line_pointer[-1] != '\"') 4030 { 4031 /* We will only get here in rare cases involving #NO_APP, 4032 where the unterminated string is not recognized by the 4033 preformatting pass. */ 4034 as_bad (_("unterminated string")); 4035 mmix_discard_rest_of_line (); 4036 return; 4037 } 4038 break; 4039 4040 default: 4041 { 4042 expressionS exp; 4043 segT expseg = expression (&exp); 4044 4045 /* We have to allow special register names as constant numbers. */ 4046 if ((expseg != absolute_section && expseg != reg_section) 4047 || (exp.X_op != O_constant 4048 && (exp.X_op != O_register 4049 || exp.X_add_number <= 255))) 4050 { 4051 as_bad (_("BYTE expression not a pure number")); 4052 mmix_discard_rest_of_line (); 4053 return; 4054 } 4055 else if ((exp.X_add_number > 255 && exp.X_op != O_register) 4056 || exp.X_add_number < 0) 4057 { 4058 /* Note that mmixal does not allow negative numbers in 4059 BYTE sequences, so neither should we. */ 4060 as_bad (_("BYTE expression not in the range 0..255")); 4061 mmix_discard_rest_of_line (); 4062 return; 4063 } 4064 4065 FRAG_APPEND_1_CHAR (exp.X_add_number); 4066 } 4067 break; 4068 } 4069 4070 SKIP_WHITESPACE (); 4071 c = *input_line_pointer++; 4072 } 4073 while (c == ','); 4074 4075 input_line_pointer--; 4076 4077 if (mmix_gnu_syntax) 4078 demand_empty_rest_of_line (); 4079 else 4080 { 4081 mmix_discard_rest_of_line (); 4082 /* Do like demand_empty_rest_of_line and step over the end-of-line 4083 boundary. */ 4084 input_line_pointer++; 4085 } 4086 4087 /* Make sure we align for the next instruction. */ 4088 last_alignment = 0; 4089} 4090 4091/* Like cons_worker, but we have to ignore "naked comments", not barf on 4092 them. Implements WYDE, TETRA and OCTA. We're a little bit more 4093 lenient than mmix_byte but FIXME: they should eventually merge. */ 4094 4095static void 4096mmix_cons (int nbytes) 4097{ 4098 expressionS exp; 4099 4100 /* If we don't have any contents, then it's ok to have a specified start 4101 address that is not a multiple of the max data size. We will then 4102 align it as necessary when we get here. Otherwise, it's a fatal sin. */ 4103 if (now_seg == text_section) 4104 { 4105 if (lowest_text_loc != (bfd_vma) -1 4106 && (lowest_text_loc & (nbytes - 1)) != 0) 4107 { 4108 if (text_has_contents) 4109 as_bad (_("data item with alignment larger than location")); 4110 else if (want_unaligned) 4111 as_bad (_("unaligned data at an absolute location is not supported")); 4112 4113 lowest_text_loc &= ~((bfd_vma) nbytes - 1); 4114 lowest_text_loc += (bfd_vma) nbytes; 4115 } 4116 4117 text_has_contents = 1; 4118 } 4119 else if (now_seg == data_section) 4120 { 4121 if (lowest_data_loc != (bfd_vma) -1 4122 && (lowest_data_loc & (nbytes - 1)) != 0) 4123 { 4124 if (data_has_contents) 4125 as_bad (_("data item with alignment larger than location")); 4126 else if (want_unaligned) 4127 as_bad (_("unaligned data at an absolute location is not supported")); 4128 4129 lowest_data_loc &= ~((bfd_vma) nbytes - 1); 4130 lowest_data_loc += (bfd_vma) nbytes; 4131 } 4132 4133 data_has_contents = 1; 4134 } 4135 4136 /* Always align these unless asked not to (valid for the current pseudo). */ 4137 if (! want_unaligned) 4138 { 4139 last_alignment = nbytes == 2 ? 1 : (nbytes == 4 ? 2 : 3); 4140 frag_align (last_alignment, 0, 0); 4141 record_alignment (now_seg, last_alignment); 4142 } 4143 4144 /* For mmixal compatibility, a label for an instruction (and emitting 4145 pseudo) refers to the _aligned_ address. So we have to emit the 4146 label here. */ 4147 if (current_fb_label >= 0) 4148 colon (fb_label_name (current_fb_label, 1)); 4149 else if (pending_label != NULL) 4150 { 4151 colon (pending_label); 4152 pending_label = NULL; 4153 } 4154 4155 SKIP_WHITESPACE (); 4156 4157 if (is_end_of_line[(unsigned int) *input_line_pointer]) 4158 { 4159 /* Default to zero if the expression was absent. */ 4160 4161 exp.X_op = O_constant; 4162 exp.X_add_number = 0; 4163 exp.X_unsigned = 0; 4164 exp.X_add_symbol = NULL; 4165 exp.X_op_symbol = NULL; 4166 emit_expr (&exp, (unsigned int) nbytes); 4167 } 4168 else 4169 do 4170 { 4171 unsigned int c; 4172 4173 switch (*input_line_pointer) 4174 { 4175 /* We support strings here too; each character takes up nbytes 4176 bytes. */ 4177 case '\"': 4178 ++input_line_pointer; 4179 while (is_a_char (c = next_char_of_string ())) 4180 { 4181 exp.X_op = O_constant; 4182 exp.X_add_number = c; 4183 exp.X_unsigned = 1; 4184 emit_expr (&exp, (unsigned int) nbytes); 4185 } 4186 4187 if (input_line_pointer[-1] != '\"') 4188 { 4189 /* We will only get here in rare cases involving #NO_APP, 4190 where the unterminated string is not recognized by the 4191 preformatting pass. */ 4192 as_bad (_("unterminated string")); 4193 mmix_discard_rest_of_line (); 4194 return; 4195 } 4196 break; 4197 4198 default: 4199 { 4200 expression (&exp); 4201 emit_expr (&exp, (unsigned int) nbytes); 4202 SKIP_WHITESPACE (); 4203 } 4204 break; 4205 } 4206 } 4207 while (*input_line_pointer++ == ','); 4208 4209 input_line_pointer--; /* Put terminator back into stream. */ 4210 4211 mmix_handle_rest_of_empty_line (); 4212 4213 /* We don't need to step up the counter for the current_fb_label here; 4214 that's handled by the caller. */ 4215} 4216 4217/* The md_do_align worker. At present, we just record an alignment to 4218 nullify the automatic alignment we do for WYDE, TETRA and OCTA, as gcc 4219 does not use the unaligned macros when attribute packed is used. 4220 Arguably this is a GCC bug. */ 4221 4222void 4223mmix_md_do_align (int n, char *fill ATTRIBUTE_UNUSED, 4224 int len ATTRIBUTE_UNUSED, int max ATTRIBUTE_UNUSED) 4225{ 4226 last_alignment = n; 4227 want_unaligned = n == 0; 4228} 4229