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