1 /* expr.c -operands, expressions- 2 Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000 3 Free Software Foundation, Inc. 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 2, 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 the Free 19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 20 02111-1307, USA. */ 21 22 /* 23 * This is really a branch office of as-read.c. I split it out to clearly 24 * distinguish the world of expressions from the world of statements. 25 * (It also gives smaller files to re-compile.) 26 * Here, "operand"s are of expressions, not instructions. 27 */ 28 29 #include <ctype.h> 30 #include <string.h> 31 #define min(a, b) ((a) < (b) ? (a) : (b)) 32 33 #include "as.h" 34 #include "obstack.h" 35 36 static void floating_constant PARAMS ((expressionS * expressionP)); 37 static valueT generic_bignum_to_int32 PARAMS ((void)); 38 #ifdef BFD64 39 static valueT generic_bignum_to_int64 PARAMS ((void)); 40 #endif 41 static void integer_constant PARAMS ((int radix, expressionS * expressionP)); 42 static void mri_char_constant PARAMS ((expressionS *)); 43 static void current_location PARAMS ((expressionS *)); 44 static void clean_up_expression PARAMS ((expressionS * expressionP)); 45 static segT operand PARAMS ((expressionS *)); 46 static operatorT operator PARAMS ((void)); 47 48 extern const char EXP_CHARS[], FLT_CHARS[]; 49 50 /* We keep a mapping of expression symbols to file positions, so that 51 we can provide better error messages. */ 52 53 struct expr_symbol_line 54 { 55 struct expr_symbol_line *next; 56 symbolS *sym; 57 char *file; 58 unsigned int line; 59 }; 60 61 static struct expr_symbol_line *expr_symbol_lines; 62 63 /* Build a dummy symbol to hold a complex expression. This is how we 64 build expressions up out of other expressions. The symbol is put 65 into the fake section expr_section. */ 66 67 symbolS * 68 make_expr_symbol (expressionP) 69 expressionS *expressionP; 70 { 71 expressionS zero; 72 const char *fake; 73 symbolS *symbolP; 74 struct expr_symbol_line *n; 75 76 if (expressionP->X_op == O_symbol 77 && expressionP->X_add_number == 0) 78 return expressionP->X_add_symbol; 79 80 if (expressionP->X_op == O_big) 81 { 82 /* This won't work, because the actual value is stored in 83 generic_floating_point_number or generic_bignum, and we are 84 going to lose it if we haven't already. */ 85 if (expressionP->X_add_number > 0) 86 as_bad (_("bignum invalid; zero assumed")); 87 else 88 as_bad (_("floating point number invalid; zero assumed")); 89 zero.X_op = O_constant; 90 zero.X_add_number = 0; 91 zero.X_unsigned = 0; 92 clean_up_expression (&zero); 93 expressionP = &zero; 94 } 95 96 fake = FAKE_LABEL_NAME; 97 98 /* Putting constant symbols in absolute_section rather than 99 expr_section is convenient for the old a.out code, for which 100 S_GET_SEGMENT does not always retrieve the value put in by 101 S_SET_SEGMENT. */ 102 symbolP = symbol_create (fake, 103 (expressionP->X_op == O_constant 104 ? absolute_section 105 : expr_section), 106 0, &zero_address_frag); 107 symbol_set_value_expression (symbolP, expressionP); 108 109 if (expressionP->X_op == O_constant) 110 resolve_symbol_value (symbolP, 1); 111 112 n = (struct expr_symbol_line *) xmalloc (sizeof *n); 113 n->sym = symbolP; 114 as_where (&n->file, &n->line); 115 n->next = expr_symbol_lines; 116 expr_symbol_lines = n; 117 118 return symbolP; 119 } 120 121 /* Return the file and line number for an expr symbol. Return 122 non-zero if something was found, 0 if no information is known for 123 the symbol. */ 124 125 int 126 expr_symbol_where (sym, pfile, pline) 127 symbolS *sym; 128 char **pfile; 129 unsigned int *pline; 130 { 131 register struct expr_symbol_line *l; 132 133 for (l = expr_symbol_lines; l != NULL; l = l->next) 134 { 135 if (l->sym == sym) 136 { 137 *pfile = l->file; 138 *pline = l->line; 139 return 1; 140 } 141 } 142 143 return 0; 144 } 145 146 /* Utilities for building expressions. 147 Since complex expressions are recorded as symbols for use in other 148 expressions these return a symbolS * and not an expressionS *. 149 These explicitly do not take an "add_number" argument. */ 150 /* ??? For completeness' sake one might want expr_build_symbol. 151 It would just return its argument. */ 152 153 /* Build an expression for an unsigned constant. 154 The corresponding one for signed constants is missing because 155 there's currently no need for it. One could add an unsigned_p flag 156 but that seems more clumsy. */ 157 158 symbolS * 159 expr_build_uconstant (value) 160 offsetT value; 161 { 162 expressionS e; 163 164 e.X_op = O_constant; 165 e.X_add_number = value; 166 e.X_unsigned = 1; 167 return make_expr_symbol (&e); 168 } 169 170 /* Build an expression for OP s1. */ 171 172 symbolS * 173 expr_build_unary (op, s1) 174 operatorT op; 175 symbolS *s1; 176 { 177 expressionS e; 178 179 e.X_op = op; 180 e.X_add_symbol = s1; 181 e.X_add_number = 0; 182 return make_expr_symbol (&e); 183 } 184 185 /* Build an expression for s1 OP s2. */ 186 187 symbolS * 188 expr_build_binary (op, s1, s2) 189 operatorT op; 190 symbolS *s1; 191 symbolS *s2; 192 { 193 expressionS e; 194 195 e.X_op = op; 196 e.X_add_symbol = s1; 197 e.X_op_symbol = s2; 198 e.X_add_number = 0; 199 return make_expr_symbol (&e); 200 } 201 202 /* Build an expression for the current location ('.'). */ 203 204 symbolS * 205 expr_build_dot () 206 { 207 expressionS e; 208 209 current_location (&e); 210 return make_expr_symbol (&e); 211 } 212 213 /* 214 * Build any floating-point literal here. 215 * Also build any bignum literal here. 216 */ 217 218 /* Seems atof_machine can backscan through generic_bignum and hit whatever 219 happens to be loaded before it in memory. And its way too complicated 220 for me to fix right. Thus a hack. JF: Just make generic_bignum bigger, 221 and never write into the early words, thus they'll always be zero. 222 I hate Dean's floating-point code. Bleh. */ 223 LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6]; 224 FLONUM_TYPE generic_floating_point_number = 225 { 226 &generic_bignum[6], /* low (JF: Was 0) */ 227 &generic_bignum[SIZE_OF_LARGE_NUMBER + 6 - 1], /* high JF: (added +6) */ 228 0, /* leader */ 229 0, /* exponent */ 230 0 /* sign */ 231 }; 232 /* If nonzero, we've been asked to assemble nan, +inf or -inf */ 233 int generic_floating_point_magic; 234 235 static void 236 floating_constant (expressionP) 237 expressionS *expressionP; 238 { 239 /* input_line_pointer->*/ 240 /* floating-point constant. */ 241 int error_code; 242 243 error_code = atof_generic (&input_line_pointer, ".", EXP_CHARS, 244 &generic_floating_point_number); 245 246 if (error_code) 247 { 248 if (error_code == ERROR_EXPONENT_OVERFLOW) 249 { 250 as_bad (_("bad floating-point constant: exponent overflow, probably assembling junk")); 251 } 252 else 253 { 254 as_bad (_("bad floating-point constant: unknown error code=%d."), error_code); 255 } 256 } 257 expressionP->X_op = O_big; 258 /* input_line_pointer->just after constant, */ 259 /* which may point to whitespace. */ 260 expressionP->X_add_number = -1; 261 } 262 263 static valueT 264 generic_bignum_to_int32 () 265 { 266 valueT number = 267 ((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS) 268 | (generic_bignum[0] & LITTLENUM_MASK); 269 number &= 0xffffffff; 270 return number; 271 } 272 273 #ifdef BFD64 274 static valueT 275 generic_bignum_to_int64 () 276 { 277 valueT number = 278 ((((((((valueT) generic_bignum[3] & LITTLENUM_MASK) 279 << LITTLENUM_NUMBER_OF_BITS) 280 | ((valueT) generic_bignum[2] & LITTLENUM_MASK)) 281 << LITTLENUM_NUMBER_OF_BITS) 282 | ((valueT) generic_bignum[1] & LITTLENUM_MASK)) 283 << LITTLENUM_NUMBER_OF_BITS) 284 | ((valueT) generic_bignum[0] & LITTLENUM_MASK)); 285 return number; 286 } 287 #endif 288 289 static void 290 integer_constant (radix, expressionP) 291 int radix; 292 expressionS *expressionP; 293 { 294 char *start; /* start of number. */ 295 char *suffix = NULL; 296 char c; 297 valueT number; /* offset or (absolute) value */ 298 short int digit; /* value of next digit in current radix */ 299 short int maxdig = 0;/* highest permitted digit value. */ 300 int too_many_digits = 0; /* if we see >= this number of */ 301 char *name; /* points to name of symbol */ 302 symbolS *symbolP; /* points to symbol */ 303 304 int small; /* true if fits in 32 bits. */ 305 306 /* May be bignum, or may fit in 32 bits. */ 307 /* Most numbers fit into 32 bits, and we want this case to be fast. 308 so we pretend it will fit into 32 bits. If, after making up a 32 309 bit number, we realise that we have scanned more digits than 310 comfortably fit into 32 bits, we re-scan the digits coding them 311 into a bignum. For decimal and octal numbers we are 312 conservative: Some numbers may be assumed bignums when in fact 313 they do fit into 32 bits. Numbers of any radix can have excess 314 leading zeros: We strive to recognise this and cast them back 315 into 32 bits. We must check that the bignum really is more than 316 32 bits, and change it back to a 32-bit number if it fits. The 317 number we are looking for is expected to be positive, but if it 318 fits into 32 bits as an unsigned number, we let it be a 32-bit 319 number. The cavalier approach is for speed in ordinary cases. */ 320 /* This has been extended for 64 bits. We blindly assume that if 321 you're compiling in 64-bit mode, the target is a 64-bit machine. 322 This should be cleaned up. */ 323 324 #ifdef BFD64 325 #define valuesize 64 326 #else /* includes non-bfd case, mostly */ 327 #define valuesize 32 328 #endif 329 330 if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri) && radix == 0) 331 { 332 int flt = 0; 333 334 /* In MRI mode, the number may have a suffix indicating the 335 radix. For that matter, it might actually be a floating 336 point constant. */ 337 for (suffix = input_line_pointer; 338 isalnum ((unsigned char) *suffix); 339 suffix++) 340 { 341 if (*suffix == 'e' || *suffix == 'E') 342 flt = 1; 343 } 344 345 if (suffix == input_line_pointer) 346 { 347 radix = 10; 348 suffix = NULL; 349 } 350 else 351 { 352 c = *--suffix; 353 if (islower ((unsigned char) c)) 354 c = toupper (c); 355 if (c == 'B') 356 radix = 2; 357 else if (c == 'D') 358 radix = 10; 359 else if (c == 'O' || c == 'Q') 360 radix = 8; 361 else if (c == 'H') 362 radix = 16; 363 else if (suffix[1] == '.' || c == 'E' || flt) 364 { 365 floating_constant (expressionP); 366 return; 367 } 368 else 369 { 370 radix = 10; 371 suffix = NULL; 372 } 373 } 374 } 375 376 switch (radix) 377 { 378 case 2: 379 maxdig = 2; 380 too_many_digits = valuesize + 1; 381 break; 382 case 8: 383 maxdig = radix = 8; 384 too_many_digits = (valuesize + 2) / 3 + 1; 385 break; 386 case 16: 387 maxdig = radix = 16; 388 too_many_digits = (valuesize + 3) / 4 + 1; 389 break; 390 case 10: 391 maxdig = radix = 10; 392 too_many_digits = (valuesize + 11) / 4; /* very rough */ 393 } 394 #undef valuesize 395 start = input_line_pointer; 396 c = *input_line_pointer++; 397 for (number = 0; 398 (digit = hex_value (c)) < maxdig; 399 c = *input_line_pointer++) 400 { 401 number = number * radix + digit; 402 } 403 /* c contains character after number. */ 404 /* input_line_pointer->char after c. */ 405 small = (input_line_pointer - start - 1) < too_many_digits; 406 407 if (radix == 16 && c == '_') 408 { 409 /* This is literal of the form 0x333_0_12345678_1. 410 This example is equivalent to 0x00000333000000001234567800000001. */ 411 412 int num_little_digits = 0; 413 int i; 414 input_line_pointer = start; /*->1st digit. */ 415 416 know (LITTLENUM_NUMBER_OF_BITS == 16); 417 418 for (c = '_'; c == '_'; num_little_digits+=2) 419 { 420 421 /* Convert one 64-bit word. */ 422 int ndigit = 0; 423 number = 0; 424 for (c = *input_line_pointer++; 425 (digit = hex_value (c)) < maxdig; 426 c = *(input_line_pointer++)) 427 { 428 number = number * radix + digit; 429 ndigit++; 430 } 431 432 /* Check for 8 digit per word max. */ 433 if (ndigit > 8) 434 as_bad (_("A bignum with underscores may not have more than 8 hex digits in any word.")); 435 436 /* Add this chunk to the bignum. Shift things down 2 little digits.*/ 437 know (LITTLENUM_NUMBER_OF_BITS == 16); 438 for (i = min (num_little_digits + 1, SIZE_OF_LARGE_NUMBER - 1); i >= 2; i--) 439 generic_bignum[i] = generic_bignum[i-2]; 440 441 /* Add the new digits as the least significant new ones. */ 442 generic_bignum[0] = number & 0xffffffff; 443 generic_bignum[1] = number >> 16; 444 } 445 446 /* Again, c is char after number, input_line_pointer->after c. */ 447 448 if (num_little_digits > SIZE_OF_LARGE_NUMBER - 1) 449 num_little_digits = SIZE_OF_LARGE_NUMBER - 1; 450 451 assert (num_little_digits >= 4); 452 453 if (num_little_digits != 8) 454 as_bad (_("A bignum with underscores must have exactly 4 words.")); 455 456 /* We might have some leading zeros. These can be trimmed to give 457 * us a change to fit this constant into a small number. 458 */ 459 while (generic_bignum[num_little_digits-1] == 0 && num_little_digits > 1) 460 num_little_digits--; 461 462 if (num_little_digits <= 2) 463 { 464 /* will fit into 32 bits. */ 465 number = generic_bignum_to_int32 (); 466 small = 1; 467 } 468 #ifdef BFD64 469 else if (num_little_digits <= 4) 470 { 471 /* Will fit into 64 bits. */ 472 number = generic_bignum_to_int64 (); 473 small = 1; 474 } 475 #endif 476 else 477 { 478 small = 0; 479 number = num_little_digits; /* number of littlenums in the bignum. */ 480 } 481 } 482 else if (!small) 483 { 484 /* 485 * we saw a lot of digits. manufacture a bignum the hard way. 486 */ 487 LITTLENUM_TYPE *leader; /*->high order littlenum of the bignum. */ 488 LITTLENUM_TYPE *pointer; /*->littlenum we are frobbing now. */ 489 long carry; 490 491 leader = generic_bignum; 492 generic_bignum[0] = 0; 493 generic_bignum[1] = 0; 494 generic_bignum[2] = 0; 495 generic_bignum[3] = 0; 496 input_line_pointer = start; /*->1st digit. */ 497 c = *input_line_pointer++; 498 for (; 499 (carry = hex_value (c)) < maxdig; 500 c = *input_line_pointer++) 501 { 502 for (pointer = generic_bignum; 503 pointer <= leader; 504 pointer++) 505 { 506 long work; 507 508 work = carry + radix * *pointer; 509 *pointer = work & LITTLENUM_MASK; 510 carry = work >> LITTLENUM_NUMBER_OF_BITS; 511 } 512 if (carry) 513 { 514 if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1) 515 { 516 /* room to grow a longer bignum. */ 517 *++leader = carry; 518 } 519 } 520 } 521 /* again, c is char after number, */ 522 /* input_line_pointer->after c. */ 523 know (LITTLENUM_NUMBER_OF_BITS == 16); 524 if (leader < generic_bignum + 2) 525 { 526 /* will fit into 32 bits. */ 527 number = generic_bignum_to_int32 (); 528 small = 1; 529 } 530 #ifdef BFD64 531 else if (leader < generic_bignum + 4) 532 { 533 /* Will fit into 64 bits. */ 534 number = generic_bignum_to_int64 (); 535 small = 1; 536 } 537 #endif 538 else 539 { 540 number = leader - generic_bignum + 1; /* number of littlenums in the bignum. */ 541 } 542 } 543 544 if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri) 545 && suffix != NULL 546 && input_line_pointer - 1 == suffix) 547 c = *input_line_pointer++; 548 549 if (small) 550 { 551 /* 552 * here with number, in correct radix. c is the next char. 553 * note that unlike un*x, we allow "011f" "0x9f" to 554 * both mean the same as the (conventional) "9f". this is simply easier 555 * than checking for strict canonical form. syntax sux! 556 */ 557 558 if (LOCAL_LABELS_FB && c == 'b') 559 { 560 /* 561 * backward ref to local label. 562 * because it is backward, expect it to be defined. 563 */ 564 /* Construct a local label. */ 565 name = fb_label_name ((int) number, 0); 566 567 /* seen before, or symbol is defined: ok */ 568 symbolP = symbol_find (name); 569 if ((symbolP != NULL) && (S_IS_DEFINED (symbolP))) 570 { 571 /* local labels are never absolute. don't waste time 572 checking absoluteness. */ 573 know (SEG_NORMAL (S_GET_SEGMENT (symbolP))); 574 575 expressionP->X_op = O_symbol; 576 expressionP->X_add_symbol = symbolP; 577 } 578 else 579 { 580 /* either not seen or not defined. */ 581 /* @@ Should print out the original string instead of 582 the parsed number. */ 583 as_bad (_("backw. ref to unknown label \"%d:\", 0 assumed."), 584 (int) number); 585 expressionP->X_op = O_constant; 586 } 587 588 expressionP->X_add_number = 0; 589 } /* case 'b' */ 590 else if (LOCAL_LABELS_FB && c == 'f') 591 { 592 /* 593 * forward reference. expect symbol to be undefined or 594 * unknown. undefined: seen it before. unknown: never seen 595 * it before. 596 * construct a local label name, then an undefined symbol. 597 * don't create a xseg frag for it: caller may do that. 598 * just return it as never seen before. 599 */ 600 name = fb_label_name ((int) number, 1); 601 symbolP = symbol_find_or_make (name); 602 /* we have no need to check symbol properties. */ 603 #ifndef many_segments 604 /* since "know" puts its arg into a "string", we 605 can't have newlines in the argument. */ 606 know (S_GET_SEGMENT (symbolP) == undefined_section || S_GET_SEGMENT (symbolP) == text_section || S_GET_SEGMENT (symbolP) == data_section); 607 #endif 608 expressionP->X_op = O_symbol; 609 expressionP->X_add_symbol = symbolP; 610 expressionP->X_add_number = 0; 611 } /* case 'f' */ 612 else if (LOCAL_LABELS_DOLLAR && c == '$') 613 { 614 /* If the dollar label is *currently* defined, then this is just 615 another reference to it. If it is not *currently* defined, 616 then this is a fresh instantiation of that number, so create 617 it. */ 618 619 if (dollar_label_defined ((long) number)) 620 { 621 name = dollar_label_name ((long) number, 0); 622 symbolP = symbol_find (name); 623 know (symbolP != NULL); 624 } 625 else 626 { 627 name = dollar_label_name ((long) number, 1); 628 symbolP = symbol_find_or_make (name); 629 } 630 631 expressionP->X_op = O_symbol; 632 expressionP->X_add_symbol = symbolP; 633 expressionP->X_add_number = 0; 634 } /* case '$' */ 635 else 636 { 637 expressionP->X_op = O_constant; 638 #ifdef TARGET_WORD_SIZE 639 /* Sign extend NUMBER. */ 640 number |= (-(number >> (TARGET_WORD_SIZE - 1))) << (TARGET_WORD_SIZE - 1); 641 #endif 642 expressionP->X_add_number = number; 643 input_line_pointer--; /* restore following character. */ 644 } /* really just a number */ 645 } 646 else 647 { 648 /* not a small number */ 649 expressionP->X_op = O_big; 650 expressionP->X_add_number = number; /* number of littlenums */ 651 input_line_pointer--; /*->char following number. */ 652 } 653 } 654 655 /* Parse an MRI multi character constant. */ 656 657 static void 658 mri_char_constant (expressionP) 659 expressionS *expressionP; 660 { 661 int i; 662 663 if (*input_line_pointer == '\'' 664 && input_line_pointer[1] != '\'') 665 { 666 expressionP->X_op = O_constant; 667 expressionP->X_add_number = 0; 668 return; 669 } 670 671 /* In order to get the correct byte ordering, we must build the 672 number in reverse. */ 673 for (i = SIZE_OF_LARGE_NUMBER - 1; i >= 0; i--) 674 { 675 int j; 676 677 generic_bignum[i] = 0; 678 for (j = 0; j < CHARS_PER_LITTLENUM; j++) 679 { 680 if (*input_line_pointer == '\'') 681 { 682 if (input_line_pointer[1] != '\'') 683 break; 684 ++input_line_pointer; 685 } 686 generic_bignum[i] <<= 8; 687 generic_bignum[i] += *input_line_pointer; 688 ++input_line_pointer; 689 } 690 691 if (i < SIZE_OF_LARGE_NUMBER - 1) 692 { 693 /* If there is more than one littlenum, left justify the 694 last one to make it match the earlier ones. If there is 695 only one, we can just use the value directly. */ 696 for (; j < CHARS_PER_LITTLENUM; j++) 697 generic_bignum[i] <<= 8; 698 } 699 700 if (*input_line_pointer == '\'' 701 && input_line_pointer[1] != '\'') 702 break; 703 } 704 705 if (i < 0) 706 { 707 as_bad (_("Character constant too large")); 708 i = 0; 709 } 710 711 if (i > 0) 712 { 713 int c; 714 int j; 715 716 c = SIZE_OF_LARGE_NUMBER - i; 717 for (j = 0; j < c; j++) 718 generic_bignum[j] = generic_bignum[i + j]; 719 i = c; 720 } 721 722 know (LITTLENUM_NUMBER_OF_BITS == 16); 723 if (i > 2) 724 { 725 expressionP->X_op = O_big; 726 expressionP->X_add_number = i; 727 } 728 else 729 { 730 expressionP->X_op = O_constant; 731 if (i < 2) 732 expressionP->X_add_number = generic_bignum[0] & LITTLENUM_MASK; 733 else 734 expressionP->X_add_number = 735 (((generic_bignum[1] & LITTLENUM_MASK) 736 << LITTLENUM_NUMBER_OF_BITS) 737 | (generic_bignum[0] & LITTLENUM_MASK)); 738 } 739 740 /* Skip the final closing quote. */ 741 ++input_line_pointer; 742 } 743 744 /* Return an expression representing the current location. This 745 handles the magic symbol `.'. */ 746 747 static void 748 current_location (expressionp) 749 expressionS *expressionp; 750 { 751 if (now_seg == absolute_section) 752 { 753 expressionp->X_op = O_constant; 754 expressionp->X_add_number = abs_section_offset; 755 } 756 else 757 { 758 symbolS *symbolp; 759 760 symbolp = symbol_new (FAKE_LABEL_NAME, now_seg, 761 (valueT) frag_now_fix (), 762 frag_now); 763 expressionp->X_op = O_symbol; 764 expressionp->X_add_symbol = symbolp; 765 expressionp->X_add_number = 0; 766 } 767 } 768 769 /* 770 * Summary of operand(). 771 * 772 * in: Input_line_pointer points to 1st char of operand, which may 773 * be a space. 774 * 775 * out: A expressionS. 776 * The operand may have been empty: in this case X_op == O_absent. 777 * Input_line_pointer->(next non-blank) char after operand. 778 */ 779 780 static segT 781 operand (expressionP) 782 expressionS *expressionP; 783 { 784 char c; 785 symbolS *symbolP; /* points to symbol */ 786 char *name; /* points to name of symbol */ 787 segT segment; 788 789 /* All integers are regarded as unsigned unless they are negated. 790 This is because the only thing which cares whether a number is 791 unsigned is the code in emit_expr which extends constants into 792 bignums. It should only sign extend negative numbers, so that 793 something like ``.quad 0x80000000'' is not sign extended even 794 though it appears negative if valueT is 32 bits. */ 795 expressionP->X_unsigned = 1; 796 797 /* digits, assume it is a bignum. */ 798 799 SKIP_WHITESPACE (); /* leading whitespace is part of operand. */ 800 c = *input_line_pointer++; /* input_line_pointer->past char in c. */ 801 802 switch (c) 803 { 804 case '1': 805 case '2': 806 case '3': 807 case '4': 808 case '5': 809 case '6': 810 case '7': 811 case '8': 812 case '9': 813 input_line_pointer--; 814 815 integer_constant ((NUMBERS_WITH_SUFFIX || flag_m68k_mri) 816 ? 0 : 10, 817 expressionP); 818 break; 819 820 case '0': 821 /* non-decimal radix */ 822 823 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri) 824 { 825 char *s; 826 827 /* Check for a hex constant. */ 828 for (s = input_line_pointer; hex_p (*s); s++) 829 ; 830 if (*s == 'h' || *s == 'H') 831 { 832 --input_line_pointer; 833 integer_constant (0, expressionP); 834 break; 835 } 836 } 837 c = *input_line_pointer; 838 switch (c) 839 { 840 case 'o': 841 case 'O': 842 case 'q': 843 case 'Q': 844 case '8': 845 case '9': 846 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri) 847 { 848 integer_constant (0, expressionP); 849 break; 850 } 851 /* Fall through. */ 852 default: 853 default_case: 854 if (c && strchr (FLT_CHARS, c)) 855 { 856 input_line_pointer++; 857 floating_constant (expressionP); 858 expressionP->X_add_number = 859 - (isupper ((unsigned char) c) ? tolower (c) : c); 860 } 861 else 862 { 863 /* The string was only zero */ 864 expressionP->X_op = O_constant; 865 expressionP->X_add_number = 0; 866 } 867 868 break; 869 870 case 'x': 871 case 'X': 872 if (flag_m68k_mri) 873 goto default_case; 874 input_line_pointer++; 875 integer_constant (16, expressionP); 876 break; 877 878 case 'b': 879 if (LOCAL_LABELS_FB && ! (flag_m68k_mri || NUMBERS_WITH_SUFFIX)) 880 { 881 /* This code used to check for '+' and '-' here, and, in 882 some conditions, fall through to call 883 integer_constant. However, that didn't make sense, 884 as integer_constant only accepts digits. */ 885 /* Some of our code elsewhere does permit digits greater 886 than the expected base; for consistency, do the same 887 here. */ 888 if (input_line_pointer[1] < '0' 889 || input_line_pointer[1] > '9') 890 { 891 /* Parse this as a back reference to label 0. */ 892 input_line_pointer--; 893 integer_constant (10, expressionP); 894 break; 895 } 896 /* Otherwise, parse this as a binary number. */ 897 } 898 /* Fall through. */ 899 case 'B': 900 input_line_pointer++; 901 if (flag_m68k_mri || NUMBERS_WITH_SUFFIX) 902 goto default_case; 903 integer_constant (2, expressionP); 904 break; 905 906 case '0': 907 case '1': 908 case '2': 909 case '3': 910 case '4': 911 case '5': 912 case '6': 913 case '7': 914 integer_constant ((flag_m68k_mri || NUMBERS_WITH_SUFFIX) 915 ? 0 : 8, 916 expressionP); 917 break; 918 919 case 'f': 920 if (LOCAL_LABELS_FB) 921 { 922 /* If it says "0f" and it could possibly be a floating point 923 number, make it one. Otherwise, make it a local label, 924 and try to deal with parsing the rest later. */ 925 if (!input_line_pointer[1] 926 || (is_end_of_line[0xff & input_line_pointer[1]]) 927 || strchr (FLT_CHARS, 'f') == NULL) 928 goto is_0f_label; 929 { 930 char *cp = input_line_pointer + 1; 931 int r = atof_generic (&cp, ".", EXP_CHARS, 932 &generic_floating_point_number); 933 switch (r) 934 { 935 case 0: 936 case ERROR_EXPONENT_OVERFLOW: 937 if (*cp == 'f' || *cp == 'b') 938 /* looks like a difference expression */ 939 goto is_0f_label; 940 else if (cp == input_line_pointer + 1) 941 /* No characters has been accepted -- looks like 942 end of operand. */ 943 goto is_0f_label; 944 else 945 goto is_0f_float; 946 default: 947 as_fatal (_("expr.c(operand): bad atof_generic return val %d"), 948 r); 949 } 950 } 951 952 /* Okay, now we've sorted it out. We resume at one of these 953 two labels, depending on what we've decided we're probably 954 looking at. */ 955 is_0f_label: 956 input_line_pointer--; 957 integer_constant (10, expressionP); 958 break; 959 960 is_0f_float: 961 /* fall through */ 962 ; 963 } 964 965 case 'd': 966 case 'D': 967 if (flag_m68k_mri || NUMBERS_WITH_SUFFIX) 968 { 969 integer_constant (0, expressionP); 970 break; 971 } 972 /* Fall through. */ 973 case 'F': 974 case 'r': 975 case 'e': 976 case 'E': 977 case 'g': 978 case 'G': 979 input_line_pointer++; 980 floating_constant (expressionP); 981 expressionP->X_add_number = 982 - (isupper ((unsigned char) c) ? tolower (c) : c); 983 break; 984 985 case '$': 986 if (LOCAL_LABELS_DOLLAR) 987 { 988 integer_constant (10, expressionP); 989 break; 990 } 991 else 992 goto default_case; 993 } 994 995 break; 996 997 case '(': 998 #ifndef NEED_INDEX_OPERATOR 999 case '[': 1000 #endif 1001 /* didn't begin with digit & not a name */ 1002 segment = expression (expressionP); 1003 /* Expression() will pass trailing whitespace */ 1004 if ((c == '(' && *input_line_pointer++ != ')') 1005 || (c == '[' && *input_line_pointer++ != ']')) 1006 { 1007 as_bad (_("Missing ')' assumed")); 1008 input_line_pointer--; 1009 } 1010 SKIP_WHITESPACE (); 1011 /* here with input_line_pointer->char after "(...)" */ 1012 return segment; 1013 1014 #ifdef TC_M68K 1015 case 'E': 1016 if (! flag_m68k_mri || *input_line_pointer != '\'') 1017 goto de_fault; 1018 as_bad (_("EBCDIC constants are not supported")); 1019 /* Fall through. */ 1020 case 'A': 1021 if (! flag_m68k_mri || *input_line_pointer != '\'') 1022 goto de_fault; 1023 ++input_line_pointer; 1024 /* Fall through. */ 1025 #endif 1026 case '\'': 1027 if (! flag_m68k_mri) 1028 { 1029 /* Warning: to conform to other people's assemblers NO 1030 ESCAPEMENT is permitted for a single quote. The next 1031 character, parity errors and all, is taken as the value 1032 of the operand. VERY KINKY. */ 1033 expressionP->X_op = O_constant; 1034 expressionP->X_add_number = *input_line_pointer++; 1035 break; 1036 } 1037 1038 mri_char_constant (expressionP); 1039 break; 1040 1041 case '+': 1042 (void) operand (expressionP); 1043 break; 1044 1045 #ifdef TC_M68K 1046 case '"': 1047 /* Double quote is the bitwise not operator in MRI mode. */ 1048 if (! flag_m68k_mri) 1049 goto de_fault; 1050 /* Fall through. */ 1051 #endif 1052 case '~': 1053 /* ~ is permitted to start a label on the Delta. */ 1054 if (is_name_beginner (c)) 1055 goto isname; 1056 case '!': 1057 case '-': 1058 { 1059 operand (expressionP); 1060 if (expressionP->X_op == O_constant) 1061 { 1062 /* input_line_pointer -> char after operand */ 1063 if (c == '-') 1064 { 1065 expressionP->X_add_number = - expressionP->X_add_number; 1066 /* Notice: '-' may overflow: no warning is given. This is 1067 compatible with other people's assemblers. Sigh. */ 1068 expressionP->X_unsigned = 0; 1069 } 1070 else if (c == '~' || c == '"') 1071 expressionP->X_add_number = ~ expressionP->X_add_number; 1072 else 1073 expressionP->X_add_number = ! expressionP->X_add_number; 1074 } 1075 else if (expressionP->X_op != O_illegal 1076 && expressionP->X_op != O_absent) 1077 { 1078 expressionP->X_add_symbol = make_expr_symbol (expressionP); 1079 if (c == '-') 1080 expressionP->X_op = O_uminus; 1081 else if (c == '~' || c == '"') 1082 expressionP->X_op = O_bit_not; 1083 else 1084 expressionP->X_op = O_logical_not; 1085 expressionP->X_add_number = 0; 1086 } 1087 else 1088 as_warn (_("Unary operator %c ignored because bad operand follows"), 1089 c); 1090 } 1091 break; 1092 1093 #if defined (DOLLAR_DOT) || defined (TC_M68K) 1094 case '$': 1095 /* $ is the program counter when in MRI mode, or when DOLLAR_DOT 1096 is defined. */ 1097 #ifndef DOLLAR_DOT 1098 if (! flag_m68k_mri) 1099 goto de_fault; 1100 #endif 1101 if (flag_m68k_mri && hex_p (*input_line_pointer)) 1102 { 1103 /* In MRI mode, $ is also used as the prefix for a 1104 hexadecimal constant. */ 1105 integer_constant (16, expressionP); 1106 break; 1107 } 1108 1109 if (is_part_of_name (*input_line_pointer)) 1110 goto isname; 1111 1112 current_location (expressionP); 1113 break; 1114 #endif 1115 1116 case '.': 1117 if (!is_part_of_name (*input_line_pointer)) 1118 { 1119 current_location (expressionP); 1120 break; 1121 } 1122 else if ((strncasecmp (input_line_pointer, "startof.", 8) == 0 1123 && ! is_part_of_name (input_line_pointer[8])) 1124 || (strncasecmp (input_line_pointer, "sizeof.", 7) == 0 1125 && ! is_part_of_name (input_line_pointer[7]))) 1126 { 1127 int start; 1128 1129 start = (input_line_pointer[1] == 't' 1130 || input_line_pointer[1] == 'T'); 1131 input_line_pointer += start ? 8 : 7; 1132 SKIP_WHITESPACE (); 1133 if (*input_line_pointer != '(') 1134 as_bad (_("syntax error in .startof. or .sizeof.")); 1135 else 1136 { 1137 char *buf; 1138 1139 ++input_line_pointer; 1140 SKIP_WHITESPACE (); 1141 name = input_line_pointer; 1142 c = get_symbol_end (); 1143 1144 buf = (char *) xmalloc (strlen (name) + 10); 1145 if (start) 1146 sprintf (buf, ".startof.%s", name); 1147 else 1148 sprintf (buf, ".sizeof.%s", name); 1149 symbolP = symbol_make (buf); 1150 free (buf); 1151 1152 expressionP->X_op = O_symbol; 1153 expressionP->X_add_symbol = symbolP; 1154 expressionP->X_add_number = 0; 1155 1156 *input_line_pointer = c; 1157 SKIP_WHITESPACE (); 1158 if (*input_line_pointer != ')') 1159 as_bad (_("syntax error in .startof. or .sizeof.")); 1160 else 1161 ++input_line_pointer; 1162 } 1163 break; 1164 } 1165 else 1166 { 1167 goto isname; 1168 } 1169 case ',': 1170 case '\n': 1171 case '\0': 1172 eol: 1173 /* can't imagine any other kind of operand */ 1174 expressionP->X_op = O_absent; 1175 input_line_pointer--; 1176 break; 1177 1178 #ifdef TC_M68K 1179 case '%': 1180 if (! flag_m68k_mri) 1181 goto de_fault; 1182 integer_constant (2, expressionP); 1183 break; 1184 1185 case '@': 1186 if (! flag_m68k_mri) 1187 goto de_fault; 1188 integer_constant (8, expressionP); 1189 break; 1190 1191 case ':': 1192 if (! flag_m68k_mri) 1193 goto de_fault; 1194 1195 /* In MRI mode, this is a floating point constant represented 1196 using hexadecimal digits. */ 1197 1198 ++input_line_pointer; 1199 integer_constant (16, expressionP); 1200 break; 1201 1202 case '*': 1203 if (! flag_m68k_mri || is_part_of_name (*input_line_pointer)) 1204 goto de_fault; 1205 1206 current_location (expressionP); 1207 break; 1208 #endif 1209 1210 default: 1211 #ifdef TC_M68K 1212 de_fault: 1213 #endif 1214 if (is_end_of_line[(unsigned char) c]) 1215 goto eol; 1216 if (is_name_beginner (c)) /* here if did not begin with a digit */ 1217 { 1218 /* 1219 * Identifier begins here. 1220 * This is kludged for speed, so code is repeated. 1221 */ 1222 isname: 1223 name = --input_line_pointer; 1224 c = get_symbol_end (); 1225 1226 #ifdef md_parse_name 1227 /* This is a hook for the backend to parse certain names 1228 specially in certain contexts. If a name always has a 1229 specific value, it can often be handled by simply 1230 entering it in the symbol table. */ 1231 if (md_parse_name (name, expressionP)) 1232 { 1233 *input_line_pointer = c; 1234 break; 1235 } 1236 #endif 1237 1238 #ifdef TC_I960 1239 /* The MRI i960 assembler permits 1240 lda sizeof code,g13 1241 FIXME: This should use md_parse_name. */ 1242 if (flag_mri 1243 && (strcasecmp (name, "sizeof") == 0 1244 || strcasecmp (name, "startof") == 0)) 1245 { 1246 int start; 1247 char *buf; 1248 1249 start = (name[1] == 't' 1250 || name[1] == 'T'); 1251 1252 *input_line_pointer = c; 1253 SKIP_WHITESPACE (); 1254 1255 name = input_line_pointer; 1256 c = get_symbol_end (); 1257 1258 buf = (char *) xmalloc (strlen (name) + 10); 1259 if (start) 1260 sprintf (buf, ".startof.%s", name); 1261 else 1262 sprintf (buf, ".sizeof.%s", name); 1263 symbolP = symbol_make (buf); 1264 free (buf); 1265 1266 expressionP->X_op = O_symbol; 1267 expressionP->X_add_symbol = symbolP; 1268 expressionP->X_add_number = 0; 1269 1270 *input_line_pointer = c; 1271 SKIP_WHITESPACE (); 1272 1273 break; 1274 } 1275 #endif 1276 1277 symbolP = symbol_find_or_make (name); 1278 1279 /* If we have an absolute symbol or a reg, then we know its 1280 value now. */ 1281 segment = S_GET_SEGMENT (symbolP); 1282 if (segment == absolute_section) 1283 { 1284 expressionP->X_op = O_constant; 1285 expressionP->X_add_number = S_GET_VALUE (symbolP); 1286 } 1287 else if (segment == reg_section) 1288 { 1289 expressionP->X_op = O_register; 1290 expressionP->X_add_number = S_GET_VALUE (symbolP); 1291 } 1292 else 1293 { 1294 expressionP->X_op = O_symbol; 1295 expressionP->X_add_symbol = symbolP; 1296 expressionP->X_add_number = 0; 1297 } 1298 *input_line_pointer = c; 1299 } 1300 else 1301 { 1302 /* Let the target try to parse it. Success is indicated by changing 1303 the X_op field to something other than O_absent and pointing 1304 input_line_pointer passed the expression. If it can't parse the 1305 expression, X_op and input_line_pointer should be unchanged. */ 1306 expressionP->X_op = O_absent; 1307 --input_line_pointer; 1308 md_operand (expressionP); 1309 if (expressionP->X_op == O_absent) 1310 { 1311 ++input_line_pointer; 1312 as_bad (_("Bad expression")); 1313 expressionP->X_op = O_constant; 1314 expressionP->X_add_number = 0; 1315 } 1316 } 1317 break; 1318 } 1319 1320 /* 1321 * It is more 'efficient' to clean up the expressionS when they are created. 1322 * Doing it here saves lines of code. 1323 */ 1324 clean_up_expression (expressionP); 1325 SKIP_WHITESPACE (); /*->1st char after operand. */ 1326 know (*input_line_pointer != ' '); 1327 1328 /* The PA port needs this information. */ 1329 if (expressionP->X_add_symbol) 1330 symbol_mark_used (expressionP->X_add_symbol); 1331 1332 switch (expressionP->X_op) 1333 { 1334 default: 1335 return absolute_section; 1336 case O_symbol: 1337 return S_GET_SEGMENT (expressionP->X_add_symbol); 1338 case O_register: 1339 return reg_section; 1340 } 1341 } /* operand() */ 1342 1343 /* Internal. Simplify a struct expression for use by expr() */ 1344 1345 /* 1346 * In: address of a expressionS. 1347 * The X_op field of the expressionS may only take certain values. 1348 * Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT. 1349 * Out: expressionS may have been modified: 1350 * 'foo-foo' symbol references cancelled to 0, 1351 * which changes X_op from O_subtract to O_constant. 1352 * Unused fields zeroed to help expr(). 1353 */ 1354 1355 static void 1356 clean_up_expression (expressionP) 1357 expressionS *expressionP; 1358 { 1359 switch (expressionP->X_op) 1360 { 1361 case O_illegal: 1362 case O_absent: 1363 expressionP->X_add_number = 0; 1364 /* Fall through. */ 1365 case O_big: 1366 case O_constant: 1367 case O_register: 1368 expressionP->X_add_symbol = NULL; 1369 /* Fall through. */ 1370 case O_symbol: 1371 case O_uminus: 1372 case O_bit_not: 1373 expressionP->X_op_symbol = NULL; 1374 break; 1375 case O_subtract: 1376 if (expressionP->X_op_symbol == expressionP->X_add_symbol 1377 || ((symbol_get_frag (expressionP->X_op_symbol) 1378 == symbol_get_frag (expressionP->X_add_symbol)) 1379 && SEG_NORMAL (S_GET_SEGMENT (expressionP->X_add_symbol)) 1380 && (S_GET_VALUE (expressionP->X_op_symbol) 1381 == S_GET_VALUE (expressionP->X_add_symbol)))) 1382 { 1383 addressT diff = (S_GET_VALUE (expressionP->X_add_symbol) 1384 - S_GET_VALUE (expressionP->X_op_symbol)); 1385 1386 expressionP->X_op = O_constant; 1387 expressionP->X_add_symbol = NULL; 1388 expressionP->X_op_symbol = NULL; 1389 expressionP->X_add_number += diff; 1390 } 1391 break; 1392 default: 1393 break; 1394 } 1395 } 1396 1397 /* Expression parser. */ 1398 1399 /* 1400 * We allow an empty expression, and just assume (absolute,0) silently. 1401 * Unary operators and parenthetical expressions are treated as operands. 1402 * As usual, Q==quantity==operand, O==operator, X==expression mnemonics. 1403 * 1404 * We used to do a aho/ullman shift-reduce parser, but the logic got so 1405 * warped that I flushed it and wrote a recursive-descent parser instead. 1406 * Now things are stable, would anybody like to write a fast parser? 1407 * Most expressions are either register (which does not even reach here) 1408 * or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common. 1409 * So I guess it doesn't really matter how inefficient more complex expressions 1410 * are parsed. 1411 * 1412 * After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK. 1413 * Also, we have consumed any leading or trailing spaces (operand does that) 1414 * and done all intervening operators. 1415 * 1416 * This returns the segment of the result, which will be 1417 * absolute_section or the segment of a symbol. 1418 */ 1419 1420 #undef __ 1421 #define __ O_illegal 1422 1423 static const operatorT op_encoding[256] = 1424 { /* maps ASCII->operators */ 1425 1426 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1427 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1428 1429 __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __, 1430 __, __, O_multiply, O_add, __, O_subtract, __, O_divide, 1431 __, __, __, __, __, __, __, __, 1432 __, __, __, __, O_lt, __, O_gt, __, 1433 __, __, __, __, __, __, __, __, 1434 __, __, __, __, __, __, __, __, 1435 __, __, __, __, __, __, __, __, 1436 __, __, __, 1437 #ifdef NEED_INDEX_OPERATOR 1438 O_index, 1439 #else 1440 __, 1441 #endif 1442 __, __, O_bit_exclusive_or, __, 1443 __, __, __, __, __, __, __, __, 1444 __, __, __, __, __, __, __, __, 1445 __, __, __, __, __, __, __, __, 1446 __, __, __, __, O_bit_inclusive_or, __, __, __, 1447 1448 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1449 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1450 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1451 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1452 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1453 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1454 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1455 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __ 1456 }; 1457 1458 1459 /* 1460 * Rank Examples 1461 * 0 operand, (expression) 1462 * 1 || 1463 * 2 && 1464 * 3 = <> < <= >= > 1465 * 4 + - 1466 * 5 used for * / % in MRI mode 1467 * 6 & ^ ! | 1468 * 7 * / % << >> 1469 * 8 unary - unary ~ 1470 */ 1471 static operator_rankT op_rank[] = 1472 { 1473 0, /* O_illegal */ 1474 0, /* O_absent */ 1475 0, /* O_constant */ 1476 0, /* O_symbol */ 1477 0, /* O_symbol_rva */ 1478 0, /* O_register */ 1479 0, /* O_bit */ 1480 9, /* O_uminus */ 1481 9, /* O_bit_not */ 1482 9, /* O_logical_not */ 1483 8, /* O_multiply */ 1484 8, /* O_divide */ 1485 8, /* O_modulus */ 1486 8, /* O_left_shift */ 1487 8, /* O_right_shift */ 1488 7, /* O_bit_inclusive_or */ 1489 7, /* O_bit_or_not */ 1490 7, /* O_bit_exclusive_or */ 1491 7, /* O_bit_and */ 1492 5, /* O_add */ 1493 5, /* O_subtract */ 1494 4, /* O_eq */ 1495 4, /* O_ne */ 1496 4, /* O_lt */ 1497 4, /* O_le */ 1498 4, /* O_ge */ 1499 4, /* O_gt */ 1500 3, /* O_logical_and */ 1501 2, /* O_logical_or */ 1502 1, /* O_index */ 1503 0, /* O_md1 */ 1504 0, /* O_md2 */ 1505 0, /* O_md3 */ 1506 0, /* O_md4 */ 1507 0, /* O_md5 */ 1508 0, /* O_md6 */ 1509 0, /* O_md7 */ 1510 0, /* O_md8 */ 1511 0, /* O_md9 */ 1512 0, /* O_md10 */ 1513 0, /* O_md11 */ 1514 0, /* O_md12 */ 1515 0, /* O_md13 */ 1516 0, /* O_md14 */ 1517 0, /* O_md15 */ 1518 0, /* O_md16 */ 1519 }; 1520 1521 /* Unfortunately, in MRI mode for the m68k, multiplication and 1522 division have lower precedence than the bit wise operators. This 1523 function sets the operator precedences correctly for the current 1524 mode. Also, MRI uses a different bit_not operator, and this fixes 1525 that as well. */ 1526 1527 #define STANDARD_MUL_PRECEDENCE (7) 1528 #define MRI_MUL_PRECEDENCE (5) 1529 1530 void 1531 expr_set_precedence () 1532 { 1533 if (flag_m68k_mri) 1534 { 1535 op_rank[O_multiply] = MRI_MUL_PRECEDENCE; 1536 op_rank[O_divide] = MRI_MUL_PRECEDENCE; 1537 op_rank[O_modulus] = MRI_MUL_PRECEDENCE; 1538 } 1539 else 1540 { 1541 op_rank[O_multiply] = STANDARD_MUL_PRECEDENCE; 1542 op_rank[O_divide] = STANDARD_MUL_PRECEDENCE; 1543 op_rank[O_modulus] = STANDARD_MUL_PRECEDENCE; 1544 } 1545 } 1546 1547 /* Initialize the expression parser. */ 1548 1549 void 1550 expr_begin () 1551 { 1552 expr_set_precedence (); 1553 1554 /* Verify that X_op field is wide enough. */ 1555 { 1556 expressionS e; 1557 e.X_op = O_max; 1558 assert (e.X_op == O_max); 1559 } 1560 } 1561 1562 /* Return the encoding for the operator at INPUT_LINE_POINTER. 1563 Advance INPUT_LINE_POINTER to the last character in the operator 1564 (i.e., don't change it for a single character operator). */ 1565 1566 static inline operatorT 1567 operator () 1568 { 1569 int c; 1570 operatorT ret; 1571 1572 c = *input_line_pointer & 0xff; 1573 1574 switch (c) 1575 { 1576 default: 1577 return op_encoding[c]; 1578 1579 case '<': 1580 switch (input_line_pointer[1]) 1581 { 1582 default: 1583 return op_encoding[c]; 1584 case '<': 1585 ret = O_left_shift; 1586 break; 1587 case '>': 1588 ret = O_ne; 1589 break; 1590 case '=': 1591 ret = O_le; 1592 break; 1593 } 1594 ++input_line_pointer; 1595 return ret; 1596 1597 case '=': 1598 if (input_line_pointer[1] != '=') 1599 return op_encoding[c]; 1600 1601 ++input_line_pointer; 1602 return O_eq; 1603 1604 case '>': 1605 switch (input_line_pointer[1]) 1606 { 1607 default: 1608 return op_encoding[c]; 1609 case '>': 1610 ret = O_right_shift; 1611 break; 1612 case '=': 1613 ret = O_ge; 1614 break; 1615 } 1616 ++input_line_pointer; 1617 return ret; 1618 1619 case '!': 1620 /* We accept !! as equivalent to ^ for MRI compatibility. */ 1621 if (input_line_pointer[1] != '!') 1622 { 1623 if (flag_m68k_mri) 1624 return O_bit_inclusive_or; 1625 return op_encoding[c]; 1626 } 1627 ++input_line_pointer; 1628 return O_bit_exclusive_or; 1629 1630 case '|': 1631 if (input_line_pointer[1] != '|') 1632 return op_encoding[c]; 1633 1634 ++input_line_pointer; 1635 return O_logical_or; 1636 1637 case '&': 1638 if (input_line_pointer[1] != '&') 1639 return op_encoding[c]; 1640 1641 ++input_line_pointer; 1642 return O_logical_and; 1643 } 1644 1645 /*NOTREACHED*/ 1646 } 1647 1648 /* Parse an expression. */ 1649 1650 segT 1651 expr (rankarg, resultP) 1652 int rankarg; /* Larger # is higher rank. */ 1653 expressionS *resultP; /* Deliver result here. */ 1654 { 1655 operator_rankT rank = (operator_rankT) rankarg; 1656 segT retval; 1657 expressionS right; 1658 operatorT op_left; 1659 operatorT op_right; 1660 1661 know (rank >= 0); 1662 1663 retval = operand (resultP); 1664 1665 know (*input_line_pointer != ' '); /* Operand() gobbles spaces. */ 1666 1667 op_left = operator (); 1668 while (op_left != O_illegal && op_rank[(int) op_left] > rank) 1669 { 1670 segT rightseg; 1671 1672 input_line_pointer++; /*->after 1st character of operator. */ 1673 1674 rightseg = expr (op_rank[(int) op_left], &right); 1675 if (right.X_op == O_absent) 1676 { 1677 as_warn (_("missing operand; zero assumed")); 1678 right.X_op = O_constant; 1679 right.X_add_number = 0; 1680 right.X_add_symbol = NULL; 1681 right.X_op_symbol = NULL; 1682 } 1683 1684 know (*input_line_pointer != ' '); 1685 1686 if (op_left == O_index) 1687 { 1688 if (*input_line_pointer != ']') 1689 as_bad ("missing right bracket"); 1690 else 1691 { 1692 ++input_line_pointer; 1693 SKIP_WHITESPACE (); 1694 } 1695 } 1696 1697 if (retval == undefined_section) 1698 { 1699 if (SEG_NORMAL (rightseg)) 1700 retval = rightseg; 1701 } 1702 else if (! SEG_NORMAL (retval)) 1703 retval = rightseg; 1704 else if (SEG_NORMAL (rightseg) 1705 && retval != rightseg 1706 #ifdef DIFF_EXPR_OK 1707 && op_left != O_subtract 1708 #endif 1709 ) 1710 as_bad (_("operation combines symbols in different segments")); 1711 1712 op_right = operator (); 1713 1714 know (op_right == O_illegal || op_rank[(int) op_right] <= op_rank[(int) op_left]); 1715 know ((int) op_left >= (int) O_multiply 1716 && (int) op_left <= (int) O_logical_or); 1717 1718 /* input_line_pointer->after right-hand quantity. */ 1719 /* left-hand quantity in resultP */ 1720 /* right-hand quantity in right. */ 1721 /* operator in op_left. */ 1722 1723 if (resultP->X_op == O_big) 1724 { 1725 if (resultP->X_add_number > 0) 1726 as_warn (_("left operand is a bignum; integer 0 assumed")); 1727 else 1728 as_warn (_("left operand is a float; integer 0 assumed")); 1729 resultP->X_op = O_constant; 1730 resultP->X_add_number = 0; 1731 resultP->X_add_symbol = NULL; 1732 resultP->X_op_symbol = NULL; 1733 } 1734 if (right.X_op == O_big) 1735 { 1736 if (right.X_add_number > 0) 1737 as_warn (_("right operand is a bignum; integer 0 assumed")); 1738 else 1739 as_warn (_("right operand is a float; integer 0 assumed")); 1740 right.X_op = O_constant; 1741 right.X_add_number = 0; 1742 right.X_add_symbol = NULL; 1743 right.X_op_symbol = NULL; 1744 } 1745 1746 /* Optimize common cases. */ 1747 if (op_left == O_add && right.X_op == O_constant) 1748 { 1749 /* X + constant. */ 1750 resultP->X_add_number += right.X_add_number; 1751 } 1752 /* This case comes up in PIC code. */ 1753 else if (op_left == O_subtract 1754 && right.X_op == O_symbol 1755 && resultP->X_op == O_symbol 1756 && (symbol_get_frag (right.X_add_symbol) 1757 == symbol_get_frag (resultP->X_add_symbol)) 1758 && SEG_NORMAL (S_GET_SEGMENT (right.X_add_symbol))) 1759 1760 { 1761 resultP->X_add_number -= right.X_add_number; 1762 resultP->X_add_number += (S_GET_VALUE (resultP->X_add_symbol) 1763 - S_GET_VALUE (right.X_add_symbol)); 1764 resultP->X_op = O_constant; 1765 resultP->X_add_symbol = 0; 1766 } 1767 else if (op_left == O_subtract && right.X_op == O_constant) 1768 { 1769 /* X - constant. */ 1770 resultP->X_add_number -= right.X_add_number; 1771 } 1772 else if (op_left == O_add && resultP->X_op == O_constant) 1773 { 1774 /* Constant + X. */ 1775 resultP->X_op = right.X_op; 1776 resultP->X_add_symbol = right.X_add_symbol; 1777 resultP->X_op_symbol = right.X_op_symbol; 1778 resultP->X_add_number += right.X_add_number; 1779 retval = rightseg; 1780 } 1781 else if (resultP->X_op == O_constant && right.X_op == O_constant) 1782 { 1783 /* Constant OP constant. */ 1784 offsetT v = right.X_add_number; 1785 if (v == 0 && (op_left == O_divide || op_left == O_modulus)) 1786 { 1787 as_warn (_("division by zero")); 1788 v = 1; 1789 } 1790 switch (op_left) 1791 { 1792 default: abort (); 1793 case O_multiply: resultP->X_add_number *= v; break; 1794 case O_divide: resultP->X_add_number /= v; break; 1795 case O_modulus: resultP->X_add_number %= v; break; 1796 case O_left_shift: resultP->X_add_number <<= v; break; 1797 case O_right_shift: 1798 /* We always use unsigned shifts, to avoid relying on 1799 characteristics of the compiler used to compile gas. */ 1800 resultP->X_add_number = 1801 (offsetT) ((valueT) resultP->X_add_number >> (valueT) v); 1802 break; 1803 case O_bit_inclusive_or: resultP->X_add_number |= v; break; 1804 case O_bit_or_not: resultP->X_add_number |= ~v; break; 1805 case O_bit_exclusive_or: resultP->X_add_number ^= v; break; 1806 case O_bit_and: resultP->X_add_number &= v; break; 1807 case O_add: resultP->X_add_number += v; break; 1808 case O_subtract: resultP->X_add_number -= v; break; 1809 case O_eq: 1810 resultP->X_add_number = 1811 resultP->X_add_number == v ? ~ (offsetT) 0 : 0; 1812 break; 1813 case O_ne: 1814 resultP->X_add_number = 1815 resultP->X_add_number != v ? ~ (offsetT) 0 : 0; 1816 break; 1817 case O_lt: 1818 resultP->X_add_number = 1819 resultP->X_add_number < v ? ~ (offsetT) 0 : 0; 1820 break; 1821 case O_le: 1822 resultP->X_add_number = 1823 resultP->X_add_number <= v ? ~ (offsetT) 0 : 0; 1824 break; 1825 case O_ge: 1826 resultP->X_add_number = 1827 resultP->X_add_number >= v ? ~ (offsetT) 0 : 0; 1828 break; 1829 case O_gt: 1830 resultP->X_add_number = 1831 resultP->X_add_number > v ? ~ (offsetT) 0 : 0; 1832 break; 1833 case O_logical_and: 1834 resultP->X_add_number = resultP->X_add_number && v; 1835 break; 1836 case O_logical_or: 1837 resultP->X_add_number = resultP->X_add_number || v; 1838 break; 1839 } 1840 } 1841 else if (resultP->X_op == O_symbol 1842 && right.X_op == O_symbol 1843 && (op_left == O_add 1844 || op_left == O_subtract 1845 || (resultP->X_add_number == 0 1846 && right.X_add_number == 0))) 1847 { 1848 /* Symbol OP symbol. */ 1849 resultP->X_op = op_left; 1850 resultP->X_op_symbol = right.X_add_symbol; 1851 if (op_left == O_add) 1852 resultP->X_add_number += right.X_add_number; 1853 else if (op_left == O_subtract) 1854 resultP->X_add_number -= right.X_add_number; 1855 } 1856 else 1857 { 1858 /* The general case. */ 1859 resultP->X_add_symbol = make_expr_symbol (resultP); 1860 resultP->X_op_symbol = make_expr_symbol (&right); 1861 resultP->X_op = op_left; 1862 resultP->X_add_number = 0; 1863 resultP->X_unsigned = 1; 1864 } 1865 1866 op_left = op_right; 1867 } /* While next operator is >= this rank. */ 1868 1869 /* The PA port needs this information. */ 1870 if (resultP->X_add_symbol) 1871 symbol_mark_used (resultP->X_add_symbol); 1872 1873 return resultP->X_op == O_constant ? absolute_section : retval; 1874 } 1875 1876 /* 1877 * get_symbol_end() 1878 * 1879 * This lives here because it belongs equally in expr.c & read.c. 1880 * Expr.c is just a branch office read.c anyway, and putting it 1881 * here lessens the crowd at read.c. 1882 * 1883 * Assume input_line_pointer is at start of symbol name. 1884 * Advance input_line_pointer past symbol name. 1885 * Turn that character into a '\0', returning its former value. 1886 * This allows a string compare (RMS wants symbol names to be strings) 1887 * of the symbol name. 1888 * There will always be a char following symbol name, because all good 1889 * lines end in end-of-line. 1890 */ 1891 char 1892 get_symbol_end () 1893 { 1894 char c; 1895 1896 /* We accept \001 in a name in case this is being called with a 1897 constructed string. */ 1898 if (is_name_beginner (c = *input_line_pointer++) || c == '\001') 1899 { 1900 while (is_part_of_name (c = *input_line_pointer++) 1901 || c == '\001') 1902 ; 1903 if (is_name_ender (c)) 1904 c = *input_line_pointer++; 1905 } 1906 *--input_line_pointer = 0; 1907 return (c); 1908 } 1909 1910 1911 unsigned int 1912 get_single_number () 1913 { 1914 expressionS exp; 1915 operand (&exp); 1916 return exp.X_add_number; 1917 1918 } 1919 1920 /* end of expr.c */ 1921