1 /* expr.c -operands, expressions- 2 Copyright (C) 1987-2016 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 if (small) 519 { 520 /* Here with number, in correct radix. c is the next char. 521 Note that unlike un*x, we allow "011f" "0x9f" to both mean 522 the same as the (conventional) "9f". 523 This is simply easier than checking for strict canonical 524 form. Syntax sux! */ 525 526 if (LOCAL_LABELS_FB && c == 'b') 527 { 528 /* Backward ref to local label. 529 Because it is backward, expect it to be defined. */ 530 /* Construct a local label. */ 531 name = fb_label_name ((int) number, 0); 532 533 /* Seen before, or symbol is defined: OK. */ 534 symbolP = symbol_find (name); 535 if ((symbolP != NULL) && (S_IS_DEFINED (symbolP))) 536 { 537 /* Local labels are never absolute. Don't waste time 538 checking absoluteness. */ 539 know (SEG_NORMAL (S_GET_SEGMENT (symbolP))); 540 541 expressionP->X_op = O_symbol; 542 expressionP->X_add_symbol = symbolP; 543 } 544 else 545 { 546 /* Either not seen or not defined. */ 547 /* @@ Should print out the original string instead of 548 the parsed number. */ 549 as_bad (_("backward ref to unknown label \"%d:\""), 550 (int) number); 551 expressionP->X_op = O_constant; 552 } 553 554 expressionP->X_add_number = 0; 555 } /* case 'b' */ 556 else if (LOCAL_LABELS_FB && c == 'f') 557 { 558 /* Forward reference. Expect symbol to be undefined or 559 unknown. undefined: seen it before. unknown: never seen 560 it before. 561 562 Construct a local label name, then an undefined symbol. 563 Don't create a xseg frag for it: caller may do that. 564 Just return it as never seen before. */ 565 name = fb_label_name ((int) number, 1); 566 symbolP = symbol_find_or_make (name); 567 /* We have no need to check symbol properties. */ 568 #ifndef many_segments 569 /* Since "know" puts its arg into a "string", we 570 can't have newlines in the argument. */ 571 know (S_GET_SEGMENT (symbolP) == undefined_section || S_GET_SEGMENT (symbolP) == text_section || S_GET_SEGMENT (symbolP) == data_section); 572 #endif 573 expressionP->X_op = O_symbol; 574 expressionP->X_add_symbol = symbolP; 575 expressionP->X_add_number = 0; 576 } /* case 'f' */ 577 else if (LOCAL_LABELS_DOLLAR && c == '$') 578 { 579 /* If the dollar label is *currently* defined, then this is just 580 another reference to it. If it is not *currently* defined, 581 then this is a fresh instantiation of that number, so create 582 it. */ 583 584 if (dollar_label_defined ((long) number)) 585 { 586 name = dollar_label_name ((long) number, 0); 587 symbolP = symbol_find (name); 588 know (symbolP != NULL); 589 } 590 else 591 { 592 name = dollar_label_name ((long) number, 1); 593 symbolP = symbol_find_or_make (name); 594 } 595 596 expressionP->X_op = O_symbol; 597 expressionP->X_add_symbol = symbolP; 598 expressionP->X_add_number = 0; 599 } /* case '$' */ 600 else 601 { 602 expressionP->X_op = O_constant; 603 expressionP->X_add_number = number; 604 input_line_pointer--; /* Restore following character. */ 605 } /* Really just a number. */ 606 } 607 else 608 { 609 /* Not a small number. */ 610 expressionP->X_op = O_big; 611 expressionP->X_add_number = number; /* Number of littlenums. */ 612 input_line_pointer--; /* -> char following number. */ 613 } 614 } 615 616 /* Parse an MRI multi character constant. */ 617 618 static void 619 mri_char_constant (expressionS *expressionP) 620 { 621 int i; 622 623 if (*input_line_pointer == '\'' 624 && input_line_pointer[1] != '\'') 625 { 626 expressionP->X_op = O_constant; 627 expressionP->X_add_number = 0; 628 return; 629 } 630 631 /* In order to get the correct byte ordering, we must build the 632 number in reverse. */ 633 for (i = SIZE_OF_LARGE_NUMBER - 1; i >= 0; i--) 634 { 635 int j; 636 637 generic_bignum[i] = 0; 638 for (j = 0; j < CHARS_PER_LITTLENUM; j++) 639 { 640 if (*input_line_pointer == '\'') 641 { 642 if (input_line_pointer[1] != '\'') 643 break; 644 ++input_line_pointer; 645 } 646 generic_bignum[i] <<= 8; 647 generic_bignum[i] += *input_line_pointer; 648 ++input_line_pointer; 649 } 650 651 if (i < SIZE_OF_LARGE_NUMBER - 1) 652 { 653 /* If there is more than one littlenum, left justify the 654 last one to make it match the earlier ones. If there is 655 only one, we can just use the value directly. */ 656 for (; j < CHARS_PER_LITTLENUM; j++) 657 generic_bignum[i] <<= 8; 658 } 659 660 if (*input_line_pointer == '\'' 661 && input_line_pointer[1] != '\'') 662 break; 663 } 664 665 if (i < 0) 666 { 667 as_bad (_("character constant too large")); 668 i = 0; 669 } 670 671 if (i > 0) 672 { 673 int c; 674 int j; 675 676 c = SIZE_OF_LARGE_NUMBER - i; 677 for (j = 0; j < c; j++) 678 generic_bignum[j] = generic_bignum[i + j]; 679 i = c; 680 } 681 682 know (LITTLENUM_NUMBER_OF_BITS == 16); 683 if (i > 2) 684 { 685 expressionP->X_op = O_big; 686 expressionP->X_add_number = i; 687 } 688 else 689 { 690 expressionP->X_op = O_constant; 691 if (i < 2) 692 expressionP->X_add_number = generic_bignum[0] & LITTLENUM_MASK; 693 else 694 expressionP->X_add_number = 695 (((generic_bignum[1] & LITTLENUM_MASK) 696 << LITTLENUM_NUMBER_OF_BITS) 697 | (generic_bignum[0] & LITTLENUM_MASK)); 698 } 699 700 /* Skip the final closing quote. */ 701 ++input_line_pointer; 702 } 703 704 /* Return an expression representing the current location. This 705 handles the magic symbol `.'. */ 706 707 void 708 current_location (expressionS *expressionp) 709 { 710 if (now_seg == absolute_section) 711 { 712 expressionp->X_op = O_constant; 713 expressionp->X_add_number = abs_section_offset; 714 } 715 else 716 { 717 expressionp->X_op = O_symbol; 718 expressionp->X_add_symbol = &dot_symbol; 719 expressionp->X_add_number = 0; 720 } 721 } 722 723 /* In: Input_line_pointer points to 1st char of operand, which may 724 be a space. 725 726 Out: An expressionS. 727 The operand may have been empty: in this case X_op == O_absent. 728 Input_line_pointer->(next non-blank) char after operand. */ 729 730 static segT 731 operand (expressionS *expressionP, enum expr_mode mode) 732 { 733 char c; 734 symbolS *symbolP; /* Points to symbol. */ 735 char *name; /* Points to name of symbol. */ 736 segT segment; 737 738 /* All integers are regarded as unsigned unless they are negated. 739 This is because the only thing which cares whether a number is 740 unsigned is the code in emit_expr which extends constants into 741 bignums. It should only sign extend negative numbers, so that 742 something like ``.quad 0x80000000'' is not sign extended even 743 though it appears negative if valueT is 32 bits. */ 744 expressionP->X_unsigned = 1; 745 expressionP->X_extrabit = 0; 746 747 /* Digits, assume it is a bignum. */ 748 749 SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */ 750 c = *input_line_pointer++; /* input_line_pointer -> past char in c. */ 751 752 if (is_end_of_line[(unsigned char) c]) 753 goto eol; 754 755 switch (c) 756 { 757 case '1': 758 case '2': 759 case '3': 760 case '4': 761 case '5': 762 case '6': 763 case '7': 764 case '8': 765 case '9': 766 input_line_pointer--; 767 768 integer_constant ((NUMBERS_WITH_SUFFIX || flag_m68k_mri) 769 ? 0 : 10, 770 expressionP); 771 break; 772 773 #ifdef LITERAL_PREFIXDOLLAR_HEX 774 case '$': 775 /* $L is the start of a local label, not a hex constant. */ 776 if (* input_line_pointer == 'L') 777 goto isname; 778 integer_constant (16, expressionP); 779 break; 780 #endif 781 782 #ifdef LITERAL_PREFIXPERCENT_BIN 783 case '%': 784 integer_constant (2, expressionP); 785 break; 786 #endif 787 788 case '0': 789 /* Non-decimal radix. */ 790 791 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri) 792 { 793 char *s; 794 795 /* Check for a hex or float constant. */ 796 for (s = input_line_pointer; hex_p (*s); s++) 797 ; 798 if (*s == 'h' || *s == 'H' || *input_line_pointer == '.') 799 { 800 --input_line_pointer; 801 integer_constant (0, expressionP); 802 break; 803 } 804 } 805 c = *input_line_pointer; 806 switch (c) 807 { 808 case 'o': 809 case 'O': 810 case 'q': 811 case 'Q': 812 case '8': 813 case '9': 814 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri) 815 { 816 integer_constant (0, expressionP); 817 break; 818 } 819 /* Fall through. */ 820 default: 821 default_case: 822 if (c && strchr (FLT_CHARS, c)) 823 { 824 input_line_pointer++; 825 floating_constant (expressionP); 826 expressionP->X_add_number = - TOLOWER (c); 827 } 828 else 829 { 830 /* The string was only zero. */ 831 expressionP->X_op = O_constant; 832 expressionP->X_add_number = 0; 833 } 834 835 break; 836 837 case 'x': 838 case 'X': 839 if (flag_m68k_mri) 840 goto default_case; 841 input_line_pointer++; 842 integer_constant (16, expressionP); 843 break; 844 845 case 'b': 846 if (LOCAL_LABELS_FB && !flag_m68k_mri 847 && input_line_pointer[1] != '0' 848 && input_line_pointer[1] != '1') 849 { 850 /* Parse this as a back reference to label 0. */ 851 input_line_pointer--; 852 integer_constant (10, expressionP); 853 break; 854 } 855 /* Otherwise, parse this as a binary number. */ 856 /* Fall through. */ 857 case 'B': 858 if (input_line_pointer[1] == '0' 859 || input_line_pointer[1] == '1') 860 { 861 input_line_pointer++; 862 integer_constant (2, expressionP); 863 break; 864 } 865 if (flag_m68k_mri || NUMBERS_WITH_SUFFIX) 866 input_line_pointer++; 867 goto default_case; 868 869 case '0': 870 case '1': 871 case '2': 872 case '3': 873 case '4': 874 case '5': 875 case '6': 876 case '7': 877 integer_constant ((flag_m68k_mri || NUMBERS_WITH_SUFFIX) 878 ? 0 : 8, 879 expressionP); 880 break; 881 882 case 'f': 883 if (LOCAL_LABELS_FB) 884 { 885 int is_label = 1; 886 887 /* If it says "0f" and it could possibly be a floating point 888 number, make it one. Otherwise, make it a local label, 889 and try to deal with parsing the rest later. */ 890 if (!is_end_of_line[(unsigned char) input_line_pointer[1]] 891 && strchr (FLT_CHARS, 'f') != NULL) 892 { 893 char *cp = input_line_pointer + 1; 894 895 atof_generic (&cp, ".", EXP_CHARS, 896 &generic_floating_point_number); 897 898 /* Was nothing parsed, or does it look like an 899 expression? */ 900 is_label = (cp == input_line_pointer + 1 901 || (cp == input_line_pointer + 2 902 && (cp[-1] == '-' || cp[-1] == '+')) 903 || *cp == 'f' 904 || *cp == 'b'); 905 } 906 if (is_label) 907 { 908 input_line_pointer--; 909 integer_constant (10, expressionP); 910 break; 911 } 912 } 913 /* Fall through. */ 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 #ifndef NEED_INDEX_OPERATOR 947 case '[': 948 # ifdef md_need_index_operator 949 if (md_need_index_operator()) 950 goto de_fault; 951 # endif 952 /* FALLTHROUGH */ 953 #endif 954 case '(': 955 /* Didn't begin with digit & not a name. */ 956 segment = expr (0, expressionP, mode); 957 /* expression () will pass trailing whitespace. */ 958 if ((c == '(' && *input_line_pointer != ')') 959 || (c == '[' && *input_line_pointer != ']')) 960 { 961 if (* input_line_pointer) 962 as_bad (_("found '%c', expected: '%c'"), 963 * input_line_pointer, c == '(' ? ')' : ']'); 964 else 965 as_bad (_("missing '%c'"), c == '(' ? ')' : ']'); 966 } 967 else 968 input_line_pointer++; 969 SKIP_WHITESPACE (); 970 /* Here with input_line_pointer -> char after "(...)". */ 971 return segment; 972 973 #ifdef TC_M68K 974 case 'E': 975 if (! flag_m68k_mri || *input_line_pointer != '\'') 976 goto de_fault; 977 as_bad (_("EBCDIC constants are not supported")); 978 /* Fall through. */ 979 case 'A': 980 if (! flag_m68k_mri || *input_line_pointer != '\'') 981 goto de_fault; 982 ++input_line_pointer; 983 /* Fall through. */ 984 #endif 985 case '\'': 986 if (! flag_m68k_mri) 987 { 988 /* Warning: to conform to other people's assemblers NO 989 ESCAPEMENT is permitted for a single quote. The next 990 character, parity errors and all, is taken as the value 991 of the operand. VERY KINKY. */ 992 expressionP->X_op = O_constant; 993 expressionP->X_add_number = *input_line_pointer++; 994 break; 995 } 996 997 mri_char_constant (expressionP); 998 break; 999 1000 #ifdef TC_M68K 1001 case '"': 1002 /* Double quote is the bitwise not operator in MRI mode. */ 1003 if (! flag_m68k_mri) 1004 goto de_fault; 1005 /* Fall through. */ 1006 #endif 1007 case '~': 1008 /* '~' is permitted to start a label on the Delta. */ 1009 if (is_name_beginner (c)) 1010 goto isname; 1011 case '!': 1012 case '-': 1013 case '+': 1014 { 1015 #ifdef md_operator 1016 unary: 1017 #endif 1018 operand (expressionP, mode); 1019 if (expressionP->X_op == O_constant) 1020 { 1021 /* input_line_pointer -> char after operand. */ 1022 if (c == '-') 1023 { 1024 expressionP->X_add_number 1025 = - (addressT) expressionP->X_add_number; 1026 /* Notice: '-' may overflow: no warning is given. 1027 This is compatible with other people's 1028 assemblers. Sigh. */ 1029 expressionP->X_unsigned = 0; 1030 if (expressionP->X_add_number) 1031 expressionP->X_extrabit ^= 1; 1032 } 1033 else if (c == '~' || c == '"') 1034 expressionP->X_add_number = ~ expressionP->X_add_number; 1035 else if (c == '!') 1036 expressionP->X_add_number = ! expressionP->X_add_number; 1037 } 1038 else if (expressionP->X_op == O_big 1039 && expressionP->X_add_number <= 0 1040 && c == '-' 1041 && (generic_floating_point_number.sign == '+' 1042 || generic_floating_point_number.sign == 'P')) 1043 { 1044 /* Negative flonum (eg, -1.000e0). */ 1045 if (generic_floating_point_number.sign == '+') 1046 generic_floating_point_number.sign = '-'; 1047 else 1048 generic_floating_point_number.sign = 'N'; 1049 } 1050 else if (expressionP->X_op == O_big 1051 && expressionP->X_add_number > 0) 1052 { 1053 int i; 1054 1055 if (c == '~' || c == '-') 1056 { 1057 for (i = 0; i < expressionP->X_add_number; ++i) 1058 generic_bignum[i] = ~generic_bignum[i]; 1059 1060 /* Extend the bignum to at least the size of .octa. */ 1061 if (expressionP->X_add_number < SIZE_OF_LARGE_NUMBER) 1062 { 1063 expressionP->X_add_number = SIZE_OF_LARGE_NUMBER; 1064 for (; i < expressionP->X_add_number; ++i) 1065 generic_bignum[i] = ~(LITTLENUM_TYPE) 0; 1066 } 1067 1068 if (c == '-') 1069 for (i = 0; i < expressionP->X_add_number; ++i) 1070 { 1071 generic_bignum[i] += 1; 1072 if (generic_bignum[i]) 1073 break; 1074 } 1075 } 1076 else if (c == '!') 1077 { 1078 for (i = 0; i < expressionP->X_add_number; ++i) 1079 if (generic_bignum[i] != 0) 1080 break; 1081 expressionP->X_add_number = i >= expressionP->X_add_number; 1082 expressionP->X_op = O_constant; 1083 expressionP->X_unsigned = 1; 1084 expressionP->X_extrabit = 0; 1085 } 1086 } 1087 else if (expressionP->X_op != O_illegal 1088 && expressionP->X_op != O_absent) 1089 { 1090 if (c != '+') 1091 { 1092 expressionP->X_add_symbol = make_expr_symbol (expressionP); 1093 if (c == '-') 1094 expressionP->X_op = O_uminus; 1095 else if (c == '~' || c == '"') 1096 expressionP->X_op = O_bit_not; 1097 else 1098 expressionP->X_op = O_logical_not; 1099 expressionP->X_add_number = 0; 1100 } 1101 } 1102 else 1103 as_warn (_("Unary operator %c ignored because bad operand follows"), 1104 c); 1105 } 1106 break; 1107 1108 #if defined (DOLLAR_DOT) || defined (TC_M68K) 1109 case '$': 1110 /* '$' is the program counter when in MRI mode, or when 1111 DOLLAR_DOT is defined. */ 1112 #ifndef DOLLAR_DOT 1113 if (! flag_m68k_mri) 1114 goto de_fault; 1115 #endif 1116 if (DOLLAR_AMBIGU && hex_p (*input_line_pointer)) 1117 { 1118 /* In MRI mode and on Z80, '$' is also used as the prefix 1119 for a hexadecimal constant. */ 1120 integer_constant (16, expressionP); 1121 break; 1122 } 1123 1124 if (is_part_of_name (*input_line_pointer)) 1125 goto isname; 1126 1127 current_location (expressionP); 1128 break; 1129 #endif 1130 1131 case '.': 1132 if (!is_part_of_name (*input_line_pointer)) 1133 { 1134 current_location (expressionP); 1135 break; 1136 } 1137 else if ((strncasecmp (input_line_pointer, "startof.", 8) == 0 1138 && ! is_part_of_name (input_line_pointer[8])) 1139 || (strncasecmp (input_line_pointer, "sizeof.", 7) == 0 1140 && ! is_part_of_name (input_line_pointer[7]))) 1141 { 1142 int start; 1143 1144 start = (input_line_pointer[1] == 't' 1145 || input_line_pointer[1] == 'T'); 1146 input_line_pointer += start ? 8 : 7; 1147 SKIP_WHITESPACE (); 1148 if (*input_line_pointer != '(') 1149 as_bad (_("syntax error in .startof. or .sizeof.")); 1150 else 1151 { 1152 char *buf; 1153 1154 ++input_line_pointer; 1155 SKIP_WHITESPACE (); 1156 c = get_symbol_name (& name); 1157 1158 buf = concat (start ? ".startof." : ".sizeof.", name, 1159 (char *) NULL); 1160 symbolP = symbol_make (buf); 1161 free (buf); 1162 1163 expressionP->X_op = O_symbol; 1164 expressionP->X_add_symbol = symbolP; 1165 expressionP->X_add_number = 0; 1166 1167 *input_line_pointer = c; 1168 SKIP_WHITESPACE_AFTER_NAME (); 1169 if (*input_line_pointer != ')') 1170 as_bad (_("syntax error in .startof. or .sizeof.")); 1171 else 1172 ++input_line_pointer; 1173 } 1174 break; 1175 } 1176 else 1177 { 1178 goto isname; 1179 } 1180 1181 case ',': 1182 eol: 1183 /* Can't imagine any other kind of operand. */ 1184 expressionP->X_op = O_absent; 1185 input_line_pointer--; 1186 break; 1187 1188 #ifdef TC_M68K 1189 case '%': 1190 if (! flag_m68k_mri) 1191 goto de_fault; 1192 integer_constant (2, expressionP); 1193 break; 1194 1195 case '@': 1196 if (! flag_m68k_mri) 1197 goto de_fault; 1198 integer_constant (8, expressionP); 1199 break; 1200 1201 case ':': 1202 if (! flag_m68k_mri) 1203 goto de_fault; 1204 1205 /* In MRI mode, this is a floating point constant represented 1206 using hexadecimal digits. */ 1207 1208 ++input_line_pointer; 1209 integer_constant (16, expressionP); 1210 break; 1211 1212 case '*': 1213 if (! flag_m68k_mri || is_part_of_name (*input_line_pointer)) 1214 goto de_fault; 1215 1216 current_location (expressionP); 1217 break; 1218 #endif 1219 1220 default: 1221 #if defined(md_need_index_operator) || defined(TC_M68K) 1222 de_fault: 1223 #endif 1224 if (is_name_beginner (c) || c == '"') /* Here if did not begin with a digit. */ 1225 { 1226 /* Identifier begins here. 1227 This is kludged for speed, so code is repeated. */ 1228 isname: 1229 -- input_line_pointer; 1230 c = get_symbol_name (&name); 1231 1232 #ifdef md_operator 1233 { 1234 operatorT op = md_operator (name, 1, &c); 1235 1236 switch (op) 1237 { 1238 case O_uminus: 1239 restore_line_pointer (c); 1240 c = '-'; 1241 goto unary; 1242 case O_bit_not: 1243 restore_line_pointer (c); 1244 c = '~'; 1245 goto unary; 1246 case O_logical_not: 1247 restore_line_pointer (c); 1248 c = '!'; 1249 goto unary; 1250 case O_illegal: 1251 as_bad (_("invalid use of operator \"%s\""), name); 1252 break; 1253 default: 1254 break; 1255 } 1256 1257 if (op != O_absent && op != O_illegal) 1258 { 1259 restore_line_pointer (c); 1260 expr (9, expressionP, mode); 1261 expressionP->X_add_symbol = make_expr_symbol (expressionP); 1262 expressionP->X_op_symbol = NULL; 1263 expressionP->X_add_number = 0; 1264 expressionP->X_op = op; 1265 break; 1266 } 1267 } 1268 #endif 1269 1270 #ifdef md_parse_name 1271 /* This is a hook for the backend to parse certain names 1272 specially in certain contexts. If a name always has a 1273 specific value, it can often be handled by simply 1274 entering it in the symbol table. */ 1275 if (md_parse_name (name, expressionP, mode, &c)) 1276 { 1277 restore_line_pointer (c); 1278 break; 1279 } 1280 #endif 1281 1282 #ifdef TC_I960 1283 /* The MRI i960 assembler permits 1284 lda sizeof code,g13 1285 FIXME: This should use md_parse_name. */ 1286 if (flag_mri 1287 && (strcasecmp (name, "sizeof") == 0 1288 || strcasecmp (name, "startof") == 0)) 1289 { 1290 int start; 1291 char *buf; 1292 1293 start = (name[1] == 't' 1294 || name[1] == 'T'); 1295 1296 *input_line_pointer = c; 1297 SKIP_WHITESPACE_AFTER_NAME (); 1298 1299 c = get_symbol_name (& name); 1300 1301 buf = concat (start ? ".startof." : ".sizeof.", name, 1302 (char *) NULL); 1303 symbolP = symbol_make (buf); 1304 free (buf); 1305 1306 expressionP->X_op = O_symbol; 1307 expressionP->X_add_symbol = symbolP; 1308 expressionP->X_add_number = 0; 1309 1310 *input_line_pointer = c; 1311 SKIP_WHITESPACE_AFTER_NAME (); 1312 break; 1313 } 1314 #endif 1315 1316 symbolP = symbol_find_or_make (name); 1317 1318 /* If we have an absolute symbol or a reg, then we know its 1319 value now. */ 1320 segment = S_GET_SEGMENT (symbolP); 1321 if (mode != expr_defer 1322 && segment == absolute_section 1323 && !S_FORCE_RELOC (symbolP, 0)) 1324 { 1325 expressionP->X_op = O_constant; 1326 expressionP->X_add_number = S_GET_VALUE (symbolP); 1327 } 1328 else if (mode != expr_defer && segment == reg_section) 1329 { 1330 expressionP->X_op = O_register; 1331 expressionP->X_add_number = S_GET_VALUE (symbolP); 1332 } 1333 else 1334 { 1335 expressionP->X_op = O_symbol; 1336 expressionP->X_add_symbol = symbolP; 1337 expressionP->X_add_number = 0; 1338 } 1339 1340 restore_line_pointer (c); 1341 } 1342 else 1343 { 1344 /* Let the target try to parse it. Success is indicated by changing 1345 the X_op field to something other than O_absent and pointing 1346 input_line_pointer past the expression. If it can't parse the 1347 expression, X_op and input_line_pointer should be unchanged. */ 1348 expressionP->X_op = O_absent; 1349 --input_line_pointer; 1350 md_operand (expressionP); 1351 if (expressionP->X_op == O_absent) 1352 { 1353 ++input_line_pointer; 1354 as_bad (_("bad expression")); 1355 expressionP->X_op = O_constant; 1356 expressionP->X_add_number = 0; 1357 } 1358 } 1359 break; 1360 } 1361 1362 /* It is more 'efficient' to clean up the expressionS when they are 1363 created. Doing it here saves lines of code. */ 1364 clean_up_expression (expressionP); 1365 SKIP_WHITESPACE (); /* -> 1st char after operand. */ 1366 know (*input_line_pointer != ' '); 1367 1368 /* The PA port needs this information. */ 1369 if (expressionP->X_add_symbol) 1370 symbol_mark_used (expressionP->X_add_symbol); 1371 1372 if (mode != expr_defer) 1373 { 1374 expressionP->X_add_symbol 1375 = symbol_clone_if_forward_ref (expressionP->X_add_symbol); 1376 expressionP->X_op_symbol 1377 = symbol_clone_if_forward_ref (expressionP->X_op_symbol); 1378 } 1379 1380 switch (expressionP->X_op) 1381 { 1382 default: 1383 return absolute_section; 1384 case O_symbol: 1385 return S_GET_SEGMENT (expressionP->X_add_symbol); 1386 case O_register: 1387 return reg_section; 1388 } 1389 } 1390 1391 /* Internal. Simplify a struct expression for use by expr (). */ 1392 1393 /* In: address of an expressionS. 1394 The X_op field of the expressionS may only take certain values. 1395 Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT. 1396 1397 Out: expressionS may have been modified: 1398 Unused fields zeroed to help expr (). */ 1399 1400 static void 1401 clean_up_expression (expressionS *expressionP) 1402 { 1403 switch (expressionP->X_op) 1404 { 1405 case O_illegal: 1406 case O_absent: 1407 expressionP->X_add_number = 0; 1408 /* Fall through. */ 1409 case O_big: 1410 case O_constant: 1411 case O_register: 1412 expressionP->X_add_symbol = NULL; 1413 /* Fall through. */ 1414 case O_symbol: 1415 case O_uminus: 1416 case O_bit_not: 1417 expressionP->X_op_symbol = NULL; 1418 break; 1419 default: 1420 break; 1421 } 1422 } 1423 1424 /* Expression parser. */ 1425 1426 /* We allow an empty expression, and just assume (absolute,0) silently. 1427 Unary operators and parenthetical expressions are treated as operands. 1428 As usual, Q==quantity==operand, O==operator, X==expression mnemonics. 1429 1430 We used to do an aho/ullman shift-reduce parser, but the logic got so 1431 warped that I flushed it and wrote a recursive-descent parser instead. 1432 Now things are stable, would anybody like to write a fast parser? 1433 Most expressions are either register (which does not even reach here) 1434 or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common. 1435 So I guess it doesn't really matter how inefficient more complex expressions 1436 are parsed. 1437 1438 After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK. 1439 Also, we have consumed any leading or trailing spaces (operand does that) 1440 and done all intervening operators. 1441 1442 This returns the segment of the result, which will be 1443 absolute_section or the segment of a symbol. */ 1444 1445 #undef __ 1446 #define __ O_illegal 1447 #ifndef O_SINGLE_EQ 1448 #define O_SINGLE_EQ O_illegal 1449 #endif 1450 1451 /* Maps ASCII -> operators. */ 1452 static const operatorT op_encoding[256] = { 1453 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1454 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1455 1456 __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __, 1457 __, __, O_multiply, O_add, __, O_subtract, __, O_divide, 1458 __, __, __, __, __, __, __, __, 1459 __, __, __, __, O_lt, O_SINGLE_EQ, O_gt, __, 1460 __, __, __, __, __, __, __, __, 1461 __, __, __, __, __, __, __, __, 1462 __, __, __, __, __, __, __, __, 1463 __, __, __, 1464 #ifdef NEED_INDEX_OPERATOR 1465 O_index, 1466 #else 1467 __, 1468 #endif 1469 __, __, O_bit_exclusive_or, __, 1470 __, __, __, __, __, __, __, __, 1471 __, __, __, __, __, __, __, __, 1472 __, __, __, __, __, __, __, __, 1473 __, __, __, __, O_bit_inclusive_or, __, __, __, 1474 1475 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1476 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1477 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1478 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1479 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1480 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1481 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1482 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __ 1483 }; 1484 1485 /* Rank Examples 1486 0 operand, (expression) 1487 1 || 1488 2 && 1489 3 == <> < <= >= > 1490 4 + - 1491 5 used for * / % in MRI mode 1492 6 & ^ ! | 1493 7 * / % << >> 1494 8 unary - unary ~ 1495 */ 1496 static operator_rankT op_rank[O_max] = { 1497 0, /* O_illegal */ 1498 0, /* O_absent */ 1499 0, /* O_constant */ 1500 0, /* O_symbol */ 1501 0, /* O_symbol_rva */ 1502 0, /* O_register */ 1503 0, /* O_big */ 1504 9, /* O_uminus */ 1505 9, /* O_bit_not */ 1506 9, /* O_logical_not */ 1507 8, /* O_multiply */ 1508 8, /* O_divide */ 1509 8, /* O_modulus */ 1510 8, /* O_left_shift */ 1511 8, /* O_right_shift */ 1512 7, /* O_bit_inclusive_or */ 1513 7, /* O_bit_or_not */ 1514 7, /* O_bit_exclusive_or */ 1515 7, /* O_bit_and */ 1516 5, /* O_add */ 1517 5, /* O_subtract */ 1518 4, /* O_eq */ 1519 4, /* O_ne */ 1520 4, /* O_lt */ 1521 4, /* O_le */ 1522 4, /* O_ge */ 1523 4, /* O_gt */ 1524 3, /* O_logical_and */ 1525 2, /* O_logical_or */ 1526 1, /* O_index */ 1527 }; 1528 1529 /* Unfortunately, in MRI mode for the m68k, multiplication and 1530 division have lower precedence than the bit wise operators. This 1531 function sets the operator precedences correctly for the current 1532 mode. Also, MRI uses a different bit_not operator, and this fixes 1533 that as well. */ 1534 1535 #define STANDARD_MUL_PRECEDENCE 8 1536 #define MRI_MUL_PRECEDENCE 6 1537 1538 void 1539 expr_set_precedence (void) 1540 { 1541 if (flag_m68k_mri) 1542 { 1543 op_rank[O_multiply] = MRI_MUL_PRECEDENCE; 1544 op_rank[O_divide] = MRI_MUL_PRECEDENCE; 1545 op_rank[O_modulus] = MRI_MUL_PRECEDENCE; 1546 } 1547 else 1548 { 1549 op_rank[O_multiply] = STANDARD_MUL_PRECEDENCE; 1550 op_rank[O_divide] = STANDARD_MUL_PRECEDENCE; 1551 op_rank[O_modulus] = STANDARD_MUL_PRECEDENCE; 1552 } 1553 } 1554 1555 void 1556 expr_set_rank (operatorT op, operator_rankT rank) 1557 { 1558 gas_assert (op >= O_md1 && op < ARRAY_SIZE (op_rank)); 1559 op_rank[op] = rank; 1560 } 1561 1562 /* Initialize the expression parser. */ 1563 1564 void 1565 expr_begin (void) 1566 { 1567 expr_set_precedence (); 1568 1569 /* Verify that X_op field is wide enough. */ 1570 { 1571 expressionS e; 1572 e.X_op = O_max; 1573 gas_assert (e.X_op == O_max); 1574 } 1575 } 1576 1577 /* Return the encoding for the operator at INPUT_LINE_POINTER, and 1578 sets NUM_CHARS to the number of characters in the operator. 1579 Does not advance INPUT_LINE_POINTER. */ 1580 1581 static inline operatorT 1582 operatorf (int *num_chars) 1583 { 1584 int c; 1585 operatorT ret; 1586 1587 c = *input_line_pointer & 0xff; 1588 *num_chars = 1; 1589 1590 if (is_end_of_line[c]) 1591 return O_illegal; 1592 1593 #ifdef md_operator 1594 if (is_name_beginner (c)) 1595 { 1596 char *name; 1597 char ec = get_symbol_name (& name); 1598 1599 ret = md_operator (name, 2, &ec); 1600 switch (ret) 1601 { 1602 case O_absent: 1603 *input_line_pointer = ec; 1604 input_line_pointer = name; 1605 break; 1606 case O_uminus: 1607 case O_bit_not: 1608 case O_logical_not: 1609 as_bad (_("invalid use of operator \"%s\""), name); 1610 ret = O_illegal; 1611 /* FALLTHROUGH */ 1612 default: 1613 *input_line_pointer = ec; 1614 *num_chars = input_line_pointer - name; 1615 input_line_pointer = name; 1616 return ret; 1617 } 1618 } 1619 #endif 1620 1621 switch (c) 1622 { 1623 default: 1624 ret = op_encoding[c]; 1625 #ifdef md_operator 1626 if (ret == O_illegal) 1627 { 1628 char *start = input_line_pointer; 1629 1630 ret = md_operator (NULL, 2, NULL); 1631 if (ret != O_illegal) 1632 *num_chars = input_line_pointer - start; 1633 input_line_pointer = start; 1634 } 1635 #endif 1636 return ret; 1637 1638 case '+': 1639 case '-': 1640 return op_encoding[c]; 1641 1642 case '<': 1643 switch (input_line_pointer[1]) 1644 { 1645 default: 1646 return op_encoding[c]; 1647 case '<': 1648 ret = O_left_shift; 1649 break; 1650 case '>': 1651 ret = O_ne; 1652 break; 1653 case '=': 1654 ret = O_le; 1655 break; 1656 } 1657 *num_chars = 2; 1658 return ret; 1659 1660 case '=': 1661 if (input_line_pointer[1] != '=') 1662 return op_encoding[c]; 1663 1664 *num_chars = 2; 1665 return O_eq; 1666 1667 case '>': 1668 switch (input_line_pointer[1]) 1669 { 1670 default: 1671 return op_encoding[c]; 1672 case '>': 1673 ret = O_right_shift; 1674 break; 1675 case '=': 1676 ret = O_ge; 1677 break; 1678 } 1679 *num_chars = 2; 1680 return ret; 1681 1682 case '!': 1683 switch (input_line_pointer[1]) 1684 { 1685 case '!': 1686 /* We accept !! as equivalent to ^ for MRI compatibility. */ 1687 *num_chars = 2; 1688 return O_bit_exclusive_or; 1689 case '=': 1690 /* We accept != as equivalent to <>. */ 1691 *num_chars = 2; 1692 return O_ne; 1693 default: 1694 if (flag_m68k_mri) 1695 return O_bit_inclusive_or; 1696 return op_encoding[c]; 1697 } 1698 1699 case '|': 1700 if (input_line_pointer[1] != '|') 1701 return op_encoding[c]; 1702 1703 *num_chars = 2; 1704 return O_logical_or; 1705 1706 case '&': 1707 if (input_line_pointer[1] != '&') 1708 return op_encoding[c]; 1709 1710 *num_chars = 2; 1711 return O_logical_and; 1712 } 1713 1714 /* NOTREACHED */ 1715 } 1716 1717 /* Implement "word-size + 1 bit" addition for 1718 {resultP->X_extrabit:resultP->X_add_number} + {rhs_highbit:amount}. This 1719 is used so that the full range of unsigned word values and the full range of 1720 signed word values can be represented in an O_constant expression, which is 1721 useful e.g. for .sleb128 directives. */ 1722 1723 void 1724 add_to_result (expressionS *resultP, offsetT amount, int rhs_highbit) 1725 { 1726 valueT ures = resultP->X_add_number; 1727 valueT uamount = amount; 1728 1729 resultP->X_add_number += amount; 1730 1731 resultP->X_extrabit ^= rhs_highbit; 1732 1733 if (ures + uamount < ures) 1734 resultP->X_extrabit ^= 1; 1735 } 1736 1737 /* Similarly, for subtraction. */ 1738 1739 void 1740 subtract_from_result (expressionS *resultP, offsetT amount, int rhs_highbit) 1741 { 1742 valueT ures = resultP->X_add_number; 1743 valueT uamount = amount; 1744 1745 resultP->X_add_number -= amount; 1746 1747 resultP->X_extrabit ^= rhs_highbit; 1748 1749 if (ures < uamount) 1750 resultP->X_extrabit ^= 1; 1751 } 1752 1753 /* Parse an expression. */ 1754 1755 segT 1756 expr (int rankarg, /* Larger # is higher rank. */ 1757 expressionS *resultP, /* Deliver result here. */ 1758 enum expr_mode mode /* Controls behavior. */) 1759 { 1760 operator_rankT rank = (operator_rankT) rankarg; 1761 segT retval; 1762 expressionS right; 1763 operatorT op_left; 1764 operatorT op_right; 1765 int op_chars; 1766 1767 know (rankarg >= 0); 1768 1769 /* Save the value of dot for the fixup code. */ 1770 if (rank == 0) 1771 { 1772 dot_value = frag_now_fix (); 1773 dot_frag = frag_now; 1774 } 1775 1776 retval = operand (resultP, mode); 1777 1778 /* operand () gobbles spaces. */ 1779 know (*input_line_pointer != ' '); 1780 1781 op_left = operatorf (&op_chars); 1782 while (op_left != O_illegal && op_rank[(int) op_left] > rank) 1783 { 1784 segT rightseg; 1785 offsetT frag_off; 1786 1787 input_line_pointer += op_chars; /* -> after operator. */ 1788 1789 right.X_md = 0; 1790 rightseg = expr (op_rank[(int) op_left], &right, mode); 1791 if (right.X_op == O_absent) 1792 { 1793 as_warn (_("missing operand; zero assumed")); 1794 right.X_op = O_constant; 1795 right.X_add_number = 0; 1796 right.X_add_symbol = NULL; 1797 right.X_op_symbol = NULL; 1798 } 1799 1800 know (*input_line_pointer != ' '); 1801 1802 if (op_left == O_index) 1803 { 1804 if (*input_line_pointer != ']') 1805 as_bad ("missing right bracket"); 1806 else 1807 { 1808 ++input_line_pointer; 1809 SKIP_WHITESPACE (); 1810 } 1811 } 1812 1813 op_right = operatorf (&op_chars); 1814 1815 know (op_right == O_illegal || op_left == O_index 1816 || op_rank[(int) op_right] <= op_rank[(int) op_left]); 1817 know ((int) op_left >= (int) O_multiply); 1818 #ifndef md_operator 1819 know ((int) op_left <= (int) O_index); 1820 #else 1821 know ((int) op_left < (int) O_max); 1822 #endif 1823 1824 /* input_line_pointer->after right-hand quantity. */ 1825 /* left-hand quantity in resultP. */ 1826 /* right-hand quantity in right. */ 1827 /* operator in op_left. */ 1828 1829 if (resultP->X_op == O_big) 1830 { 1831 if (resultP->X_add_number > 0) 1832 as_warn (_("left operand is a bignum; integer 0 assumed")); 1833 else 1834 as_warn (_("left operand is a float; integer 0 assumed")); 1835 resultP->X_op = O_constant; 1836 resultP->X_add_number = 0; 1837 resultP->X_add_symbol = NULL; 1838 resultP->X_op_symbol = NULL; 1839 } 1840 if (right.X_op == O_big) 1841 { 1842 if (right.X_add_number > 0) 1843 as_warn (_("right operand is a bignum; integer 0 assumed")); 1844 else 1845 as_warn (_("right operand is a float; integer 0 assumed")); 1846 right.X_op = O_constant; 1847 right.X_add_number = 0; 1848 right.X_add_symbol = NULL; 1849 right.X_op_symbol = NULL; 1850 } 1851 1852 /* Optimize common cases. */ 1853 #ifdef md_optimize_expr 1854 if (md_optimize_expr (resultP, op_left, &right)) 1855 { 1856 /* Skip. */ 1857 ; 1858 } 1859 else 1860 #endif 1861 #ifndef md_register_arithmetic 1862 # define md_register_arithmetic 1 1863 #endif 1864 if (op_left == O_add && right.X_op == O_constant 1865 && (md_register_arithmetic || resultP->X_op != O_register)) 1866 { 1867 /* X + constant. */ 1868 add_to_result (resultP, right.X_add_number, right.X_extrabit); 1869 } 1870 /* This case comes up in PIC code. */ 1871 else if (op_left == O_subtract 1872 && right.X_op == O_symbol 1873 && resultP->X_op == O_symbol 1874 && retval == rightseg 1875 #ifdef md_allow_local_subtract 1876 && md_allow_local_subtract (resultP, & right, rightseg) 1877 #endif 1878 && ((SEG_NORMAL (rightseg) 1879 && !S_FORCE_RELOC (resultP->X_add_symbol, 0) 1880 && !S_FORCE_RELOC (right.X_add_symbol, 0)) 1881 || right.X_add_symbol == resultP->X_add_symbol) 1882 && frag_offset_fixed_p (symbol_get_frag (resultP->X_add_symbol), 1883 symbol_get_frag (right.X_add_symbol), 1884 &frag_off)) 1885 { 1886 offsetT symval_diff = S_GET_VALUE (resultP->X_add_symbol) 1887 - S_GET_VALUE (right.X_add_symbol); 1888 subtract_from_result (resultP, right.X_add_number, right.X_extrabit); 1889 subtract_from_result (resultP, frag_off / OCTETS_PER_BYTE, 0); 1890 add_to_result (resultP, symval_diff, symval_diff < 0); 1891 resultP->X_op = O_constant; 1892 resultP->X_add_symbol = 0; 1893 } 1894 else if (op_left == O_subtract && right.X_op == O_constant 1895 && (md_register_arithmetic || resultP->X_op != O_register)) 1896 { 1897 /* X - constant. */ 1898 subtract_from_result (resultP, right.X_add_number, right.X_extrabit); 1899 } 1900 else if (op_left == O_add && resultP->X_op == O_constant 1901 && (md_register_arithmetic || right.X_op != O_register)) 1902 { 1903 /* Constant + X. */ 1904 resultP->X_op = right.X_op; 1905 resultP->X_add_symbol = right.X_add_symbol; 1906 resultP->X_op_symbol = right.X_op_symbol; 1907 add_to_result (resultP, right.X_add_number, right.X_extrabit); 1908 retval = rightseg; 1909 } 1910 else if (resultP->X_op == O_constant && right.X_op == O_constant) 1911 { 1912 /* Constant OP constant. */ 1913 offsetT v = right.X_add_number; 1914 if (v == 0 && (op_left == O_divide || op_left == O_modulus)) 1915 { 1916 as_warn (_("division by zero")); 1917 v = 1; 1918 } 1919 if ((valueT) v >= sizeof(valueT) * CHAR_BIT 1920 && (op_left == O_left_shift || op_left == O_right_shift)) 1921 { 1922 as_warn_value_out_of_range (_("shift count"), v, 0, 1923 sizeof(valueT) * CHAR_BIT - 1, 1924 NULL, 0); 1925 resultP->X_add_number = v = 0; 1926 } 1927 switch (op_left) 1928 { 1929 default: goto general; 1930 case O_multiply: resultP->X_add_number *= v; break; 1931 case O_divide: resultP->X_add_number /= v; break; 1932 case O_modulus: resultP->X_add_number %= v; break; 1933 case O_left_shift: resultP->X_add_number <<= v; break; 1934 case O_right_shift: 1935 /* We always use unsigned shifts, to avoid relying on 1936 characteristics of the compiler used to compile gas. */ 1937 resultP->X_add_number = 1938 (offsetT) ((valueT) resultP->X_add_number >> (valueT) v); 1939 break; 1940 case O_bit_inclusive_or: resultP->X_add_number |= v; break; 1941 case O_bit_or_not: resultP->X_add_number |= ~v; break; 1942 case O_bit_exclusive_or: resultP->X_add_number ^= v; break; 1943 case O_bit_and: resultP->X_add_number &= v; break; 1944 /* Constant + constant (O_add) is handled by the 1945 previous if statement for constant + X, so is omitted 1946 here. */ 1947 case O_subtract: 1948 subtract_from_result (resultP, v, 0); 1949 break; 1950 case O_eq: 1951 resultP->X_add_number = 1952 resultP->X_add_number == v ? ~ (offsetT) 0 : 0; 1953 break; 1954 case O_ne: 1955 resultP->X_add_number = 1956 resultP->X_add_number != v ? ~ (offsetT) 0 : 0; 1957 break; 1958 case O_lt: 1959 resultP->X_add_number = 1960 resultP->X_add_number < v ? ~ (offsetT) 0 : 0; 1961 break; 1962 case O_le: 1963 resultP->X_add_number = 1964 resultP->X_add_number <= v ? ~ (offsetT) 0 : 0; 1965 break; 1966 case O_ge: 1967 resultP->X_add_number = 1968 resultP->X_add_number >= v ? ~ (offsetT) 0 : 0; 1969 break; 1970 case O_gt: 1971 resultP->X_add_number = 1972 resultP->X_add_number > v ? ~ (offsetT) 0 : 0; 1973 break; 1974 case O_logical_and: 1975 resultP->X_add_number = resultP->X_add_number && v; 1976 break; 1977 case O_logical_or: 1978 resultP->X_add_number = resultP->X_add_number || v; 1979 break; 1980 } 1981 } 1982 else if (resultP->X_op == O_symbol 1983 && right.X_op == O_symbol 1984 && (op_left == O_add 1985 || op_left == O_subtract 1986 || (resultP->X_add_number == 0 1987 && right.X_add_number == 0))) 1988 { 1989 /* Symbol OP symbol. */ 1990 resultP->X_op = op_left; 1991 resultP->X_op_symbol = right.X_add_symbol; 1992 if (op_left == O_add) 1993 add_to_result (resultP, right.X_add_number, right.X_extrabit); 1994 else if (op_left == O_subtract) 1995 { 1996 subtract_from_result (resultP, right.X_add_number, 1997 right.X_extrabit); 1998 if (retval == rightseg 1999 && SEG_NORMAL (retval) 2000 && !S_FORCE_RELOC (resultP->X_add_symbol, 0) 2001 && !S_FORCE_RELOC (right.X_add_symbol, 0)) 2002 { 2003 retval = absolute_section; 2004 rightseg = absolute_section; 2005 } 2006 } 2007 } 2008 else 2009 { 2010 general: 2011 /* The general case. */ 2012 resultP->X_add_symbol = make_expr_symbol (resultP); 2013 resultP->X_op_symbol = make_expr_symbol (&right); 2014 resultP->X_op = op_left; 2015 resultP->X_add_number = 0; 2016 resultP->X_unsigned = 1; 2017 resultP->X_extrabit = 0; 2018 } 2019 2020 if (retval != rightseg) 2021 { 2022 if (retval == undefined_section) 2023 ; 2024 else if (rightseg == undefined_section) 2025 retval = rightseg; 2026 else if (retval == expr_section) 2027 ; 2028 else if (rightseg == expr_section) 2029 retval = rightseg; 2030 else if (retval == reg_section) 2031 ; 2032 else if (rightseg == reg_section) 2033 retval = rightseg; 2034 else if (rightseg == absolute_section) 2035 ; 2036 else if (retval == absolute_section) 2037 retval = rightseg; 2038 #ifdef DIFF_EXPR_OK 2039 else if (op_left == O_subtract) 2040 ; 2041 #endif 2042 else 2043 as_bad (_("operation combines symbols in different segments")); 2044 } 2045 2046 op_left = op_right; 2047 } /* While next operator is >= this rank. */ 2048 2049 /* The PA port needs this information. */ 2050 if (resultP->X_add_symbol) 2051 symbol_mark_used (resultP->X_add_symbol); 2052 2053 if (rank == 0 && mode == expr_evaluate) 2054 resolve_expression (resultP); 2055 2056 return resultP->X_op == O_constant ? absolute_section : retval; 2057 } 2058 2059 /* Resolve an expression without changing any symbols/sub-expressions 2060 used. */ 2061 2062 int 2063 resolve_expression (expressionS *expressionP) 2064 { 2065 /* Help out with CSE. */ 2066 valueT final_val = expressionP->X_add_number; 2067 symbolS *add_symbol = expressionP->X_add_symbol; 2068 symbolS *orig_add_symbol = add_symbol; 2069 symbolS *op_symbol = expressionP->X_op_symbol; 2070 operatorT op = expressionP->X_op; 2071 valueT left, right; 2072 segT seg_left, seg_right; 2073 fragS *frag_left, *frag_right; 2074 offsetT frag_off; 2075 2076 switch (op) 2077 { 2078 default: 2079 return 0; 2080 2081 case O_constant: 2082 case O_register: 2083 left = 0; 2084 break; 2085 2086 case O_symbol: 2087 case O_symbol_rva: 2088 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left)) 2089 return 0; 2090 2091 break; 2092 2093 case O_uminus: 2094 case O_bit_not: 2095 case O_logical_not: 2096 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left)) 2097 return 0; 2098 2099 if (seg_left != absolute_section) 2100 return 0; 2101 2102 if (op == O_logical_not) 2103 left = !left; 2104 else if (op == O_uminus) 2105 left = -left; 2106 else 2107 left = ~left; 2108 op = O_constant; 2109 break; 2110 2111 case O_multiply: 2112 case O_divide: 2113 case O_modulus: 2114 case O_left_shift: 2115 case O_right_shift: 2116 case O_bit_inclusive_or: 2117 case O_bit_or_not: 2118 case O_bit_exclusive_or: 2119 case O_bit_and: 2120 case O_add: 2121 case O_subtract: 2122 case O_eq: 2123 case O_ne: 2124 case O_lt: 2125 case O_le: 2126 case O_ge: 2127 case O_gt: 2128 case O_logical_and: 2129 case O_logical_or: 2130 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left) 2131 || !snapshot_symbol (&op_symbol, &right, &seg_right, &frag_right)) 2132 return 0; 2133 2134 /* Simplify addition or subtraction of a constant by folding the 2135 constant into X_add_number. */ 2136 if (op == O_add) 2137 { 2138 if (seg_right == absolute_section) 2139 { 2140 final_val += right; 2141 op = O_symbol; 2142 break; 2143 } 2144 else if (seg_left == absolute_section) 2145 { 2146 final_val += left; 2147 left = right; 2148 seg_left = seg_right; 2149 add_symbol = op_symbol; 2150 orig_add_symbol = expressionP->X_op_symbol; 2151 op = O_symbol; 2152 break; 2153 } 2154 } 2155 else if (op == O_subtract) 2156 { 2157 if (seg_right == absolute_section) 2158 { 2159 final_val -= right; 2160 op = O_symbol; 2161 break; 2162 } 2163 } 2164 2165 /* Equality and non-equality tests are permitted on anything. 2166 Subtraction, and other comparison operators are permitted if 2167 both operands are in the same section. 2168 Shifts by constant zero are permitted on anything. 2169 Multiplies, bit-ors, and bit-ands with constant zero are 2170 permitted on anything. 2171 Multiplies and divides by constant one are permitted on 2172 anything. 2173 Binary operations with both operands being the same register 2174 or undefined symbol are permitted if the result doesn't depend 2175 on the input value. 2176 Otherwise, both operands must be absolute. We already handled 2177 the case of addition or subtraction of a constant above. */ 2178 frag_off = 0; 2179 if (!(seg_left == absolute_section 2180 && seg_right == absolute_section) 2181 && !(op == O_eq || op == O_ne) 2182 && !((op == O_subtract 2183 || op == O_lt || op == O_le || op == O_ge || op == O_gt) 2184 && seg_left == seg_right 2185 && (finalize_syms 2186 || frag_offset_fixed_p (frag_left, frag_right, &frag_off)) 2187 && (seg_left != reg_section || left == right) 2188 && (seg_left != undefined_section || add_symbol == op_symbol))) 2189 { 2190 if ((seg_left == absolute_section && left == 0) 2191 || (seg_right == absolute_section && right == 0)) 2192 { 2193 if (op == O_bit_exclusive_or || op == O_bit_inclusive_or) 2194 { 2195 if (!(seg_right == absolute_section && right == 0)) 2196 { 2197 seg_left = seg_right; 2198 left = right; 2199 add_symbol = op_symbol; 2200 orig_add_symbol = expressionP->X_op_symbol; 2201 } 2202 op = O_symbol; 2203 break; 2204 } 2205 else if (op == O_left_shift || op == O_right_shift) 2206 { 2207 if (!(seg_left == absolute_section && left == 0)) 2208 { 2209 op = O_symbol; 2210 break; 2211 } 2212 } 2213 else if (op != O_multiply 2214 && op != O_bit_or_not && op != O_bit_and) 2215 return 0; 2216 } 2217 else if (op == O_multiply 2218 && seg_left == absolute_section && left == 1) 2219 { 2220 seg_left = seg_right; 2221 left = right; 2222 add_symbol = op_symbol; 2223 orig_add_symbol = expressionP->X_op_symbol; 2224 op = O_symbol; 2225 break; 2226 } 2227 else if ((op == O_multiply || op == O_divide) 2228 && seg_right == absolute_section && right == 1) 2229 { 2230 op = O_symbol; 2231 break; 2232 } 2233 else if (!(left == right 2234 && ((seg_left == reg_section && seg_right == reg_section) 2235 || (seg_left == undefined_section 2236 && seg_right == undefined_section 2237 && add_symbol == op_symbol)))) 2238 return 0; 2239 else if (op == O_bit_and || op == O_bit_inclusive_or) 2240 { 2241 op = O_symbol; 2242 break; 2243 } 2244 else if (op != O_bit_exclusive_or && op != O_bit_or_not) 2245 return 0; 2246 } 2247 2248 right += frag_off / OCTETS_PER_BYTE; 2249 switch (op) 2250 { 2251 case O_add: left += right; break; 2252 case O_subtract: left -= right; break; 2253 case O_multiply: left *= right; break; 2254 case O_divide: 2255 if (right == 0) 2256 return 0; 2257 left = (offsetT) left / (offsetT) right; 2258 break; 2259 case O_modulus: 2260 if (right == 0) 2261 return 0; 2262 left = (offsetT) left % (offsetT) right; 2263 break; 2264 case O_left_shift: left <<= right; break; 2265 case O_right_shift: left >>= right; break; 2266 case O_bit_inclusive_or: left |= right; break; 2267 case O_bit_or_not: left |= ~right; break; 2268 case O_bit_exclusive_or: left ^= right; break; 2269 case O_bit_and: left &= right; break; 2270 case O_eq: 2271 case O_ne: 2272 left = (left == right 2273 && seg_left == seg_right 2274 && (finalize_syms || frag_left == frag_right) 2275 && (seg_left != undefined_section 2276 || add_symbol == op_symbol) 2277 ? ~ (valueT) 0 : 0); 2278 if (op == O_ne) 2279 left = ~left; 2280 break; 2281 case O_lt: 2282 left = (offsetT) left < (offsetT) right ? ~ (valueT) 0 : 0; 2283 break; 2284 case O_le: 2285 left = (offsetT) left <= (offsetT) right ? ~ (valueT) 0 : 0; 2286 break; 2287 case O_ge: 2288 left = (offsetT) left >= (offsetT) right ? ~ (valueT) 0 : 0; 2289 break; 2290 case O_gt: 2291 left = (offsetT) left > (offsetT) right ? ~ (valueT) 0 : 0; 2292 break; 2293 case O_logical_and: left = left && right; break; 2294 case O_logical_or: left = left || right; break; 2295 default: abort (); 2296 } 2297 2298 op = O_constant; 2299 break; 2300 } 2301 2302 if (op == O_symbol) 2303 { 2304 if (seg_left == absolute_section) 2305 op = O_constant; 2306 else if (seg_left == reg_section && final_val == 0) 2307 op = O_register; 2308 else if (!symbol_same_p (add_symbol, orig_add_symbol)) 2309 final_val += left; 2310 expressionP->X_add_symbol = add_symbol; 2311 } 2312 expressionP->X_op = op; 2313 2314 if (op == O_constant || op == O_register) 2315 final_val += left; 2316 expressionP->X_add_number = final_val; 2317 2318 return 1; 2319 } 2320 2321 /* This lives here because it belongs equally in expr.c & read.c. 2322 expr.c is just a branch office read.c anyway, and putting it 2323 here lessens the crowd at read.c. 2324 2325 Assume input_line_pointer is at start of symbol name, or the 2326 start of a double quote enclosed symbol name. 2327 Advance input_line_pointer past symbol name. 2328 Turn that character into a '\0', returning its former value, 2329 which may be the closing double quote. 2330 This allows a string compare (RMS wants symbol names to be strings) 2331 of the symbol name. 2332 There will always be a char following symbol name, because all good 2333 lines end in end-of-line. */ 2334 2335 char 2336 get_symbol_name (char ** ilp_return) 2337 { 2338 char c; 2339 2340 * ilp_return = input_line_pointer; 2341 /* We accept \001 in a name in case this is being called with a 2342 constructed string. */ 2343 if (is_name_beginner (c = *input_line_pointer++) || c == '\001') 2344 { 2345 while (is_part_of_name (c = *input_line_pointer++) 2346 || c == '\001') 2347 ; 2348 if (is_name_ender (c)) 2349 c = *input_line_pointer++; 2350 } 2351 else if (c == '"') 2352 { 2353 bfd_boolean backslash_seen; 2354 2355 * ilp_return = input_line_pointer; 2356 do 2357 { 2358 backslash_seen = c == '\\'; 2359 c = * input_line_pointer ++; 2360 } 2361 while (c != 0 && (c != '"' || backslash_seen)); 2362 2363 if (c == 0) 2364 as_warn (_("missing closing '\"'")); 2365 } 2366 *--input_line_pointer = 0; 2367 return c; 2368 } 2369 2370 /* Replace the NUL character pointed to by input_line_pointer 2371 with C. If C is \" then advance past it. Return the character 2372 now pointed to by input_line_pointer. */ 2373 2374 char 2375 restore_line_pointer (char c) 2376 { 2377 * input_line_pointer = c; 2378 if (c == '"') 2379 c = * ++ input_line_pointer; 2380 return c; 2381 } 2382 2383 unsigned int 2384 get_single_number (void) 2385 { 2386 expressionS exp; 2387 operand (&exp, expr_normal); 2388 return exp.X_add_number; 2389 } 2390