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