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 symbolP = symbol_find_or_make (name); 1306 1307 /* If we have an absolute symbol or a reg, then we know its 1308 value now. */ 1309 segment = S_GET_SEGMENT (symbolP); 1310 if (mode != expr_defer 1311 && segment == absolute_section 1312 && !S_FORCE_RELOC (symbolP, 0)) 1313 { 1314 expressionP->X_op = O_constant; 1315 expressionP->X_add_number = S_GET_VALUE (symbolP); 1316 } 1317 else if (mode != expr_defer && segment == reg_section) 1318 { 1319 expressionP->X_op = O_register; 1320 expressionP->X_add_number = S_GET_VALUE (symbolP); 1321 } 1322 else 1323 { 1324 expressionP->X_op = O_symbol; 1325 expressionP->X_add_symbol = symbolP; 1326 expressionP->X_add_number = 0; 1327 } 1328 1329 restore_line_pointer (c); 1330 } 1331 else 1332 { 1333 /* Let the target try to parse it. Success is indicated by changing 1334 the X_op field to something other than O_absent and pointing 1335 input_line_pointer past the expression. If it can't parse the 1336 expression, X_op and input_line_pointer should be unchanged. */ 1337 expressionP->X_op = O_absent; 1338 --input_line_pointer; 1339 md_operand (expressionP); 1340 if (expressionP->X_op == O_absent) 1341 { 1342 ++input_line_pointer; 1343 as_bad (_("bad expression")); 1344 expressionP->X_op = O_constant; 1345 expressionP->X_add_number = 0; 1346 } 1347 } 1348 break; 1349 } 1350 1351 /* It is more 'efficient' to clean up the expressionS when they are 1352 created. Doing it here saves lines of code. */ 1353 clean_up_expression (expressionP); 1354 SKIP_ALL_WHITESPACE (); /* -> 1st char after operand. */ 1355 know (*input_line_pointer != ' '); 1356 1357 /* The PA port needs this information. */ 1358 if (expressionP->X_add_symbol) 1359 symbol_mark_used (expressionP->X_add_symbol); 1360 1361 if (mode != expr_defer) 1362 { 1363 expressionP->X_add_symbol 1364 = symbol_clone_if_forward_ref (expressionP->X_add_symbol); 1365 expressionP->X_op_symbol 1366 = symbol_clone_if_forward_ref (expressionP->X_op_symbol); 1367 } 1368 1369 switch (expressionP->X_op) 1370 { 1371 default: 1372 return absolute_section; 1373 case O_symbol: 1374 return S_GET_SEGMENT (expressionP->X_add_symbol); 1375 case O_register: 1376 return reg_section; 1377 } 1378 } 1379 1380 /* Internal. Simplify a struct expression for use by expr (). */ 1381 1382 /* In: address of an expressionS. 1383 The X_op field of the expressionS may only take certain values. 1384 Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT. 1385 1386 Out: expressionS may have been modified: 1387 Unused fields zeroed to help expr (). */ 1388 1389 static void 1390 clean_up_expression (expressionS *expressionP) 1391 { 1392 switch (expressionP->X_op) 1393 { 1394 case O_illegal: 1395 case O_absent: 1396 expressionP->X_add_number = 0; 1397 /* Fall through. */ 1398 case O_big: 1399 case O_constant: 1400 case O_register: 1401 expressionP->X_add_symbol = NULL; 1402 /* Fall through. */ 1403 case O_symbol: 1404 case O_uminus: 1405 case O_bit_not: 1406 expressionP->X_op_symbol = NULL; 1407 break; 1408 default: 1409 break; 1410 } 1411 } 1412 1413 /* Expression parser. */ 1414 1415 /* We allow an empty expression, and just assume (absolute,0) silently. 1416 Unary operators and parenthetical expressions are treated as operands. 1417 As usual, Q==quantity==operand, O==operator, X==expression mnemonics. 1418 1419 We used to do an aho/ullman shift-reduce parser, but the logic got so 1420 warped that I flushed it and wrote a recursive-descent parser instead. 1421 Now things are stable, would anybody like to write a fast parser? 1422 Most expressions are either register (which does not even reach here) 1423 or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common. 1424 So I guess it doesn't really matter how inefficient more complex expressions 1425 are parsed. 1426 1427 After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK. 1428 Also, we have consumed any leading or trailing spaces (operand does that) 1429 and done all intervening operators. 1430 1431 This returns the segment of the result, which will be 1432 absolute_section or the segment of a symbol. */ 1433 1434 #undef __ 1435 #define __ O_illegal 1436 #ifndef O_SINGLE_EQ 1437 #define O_SINGLE_EQ O_illegal 1438 #endif 1439 1440 /* Maps ASCII -> operators. */ 1441 static const operatorT op_encoding[256] = { 1442 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1443 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1444 1445 __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __, 1446 __, __, O_multiply, O_add, __, O_subtract, __, O_divide, 1447 __, __, __, __, __, __, __, __, 1448 __, __, __, __, O_lt, O_SINGLE_EQ, O_gt, __, 1449 __, __, __, __, __, __, __, __, 1450 __, __, __, __, __, __, __, __, 1451 __, __, __, __, __, __, __, __, 1452 __, __, __, 1453 #ifdef NEED_INDEX_OPERATOR 1454 O_index, 1455 #else 1456 __, 1457 #endif 1458 __, __, O_bit_exclusive_or, __, 1459 __, __, __, __, __, __, __, __, 1460 __, __, __, __, __, __, __, __, 1461 __, __, __, __, __, __, __, __, 1462 __, __, __, __, O_bit_inclusive_or, __, __, __, 1463 1464 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1465 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1466 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1467 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1468 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1469 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1470 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, 1471 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __ 1472 }; 1473 1474 /* Rank Examples 1475 0 operand, (expression) 1476 1 || 1477 2 && 1478 3 == <> < <= >= > 1479 4 + - 1480 5 used for * / % in MRI mode 1481 6 & ^ ! | 1482 7 * / % << >> 1483 8 unary - unary ~ 1484 */ 1485 static operator_rankT op_rank[O_max] = { 1486 0, /* O_illegal */ 1487 0, /* O_absent */ 1488 0, /* O_constant */ 1489 0, /* O_symbol */ 1490 0, /* O_symbol_rva */ 1491 0, /* O_register */ 1492 0, /* O_big */ 1493 9, /* O_uminus */ 1494 9, /* O_bit_not */ 1495 9, /* O_logical_not */ 1496 8, /* O_multiply */ 1497 8, /* O_divide */ 1498 8, /* O_modulus */ 1499 8, /* O_left_shift */ 1500 8, /* O_right_shift */ 1501 7, /* O_bit_inclusive_or */ 1502 7, /* O_bit_or_not */ 1503 7, /* O_bit_exclusive_or */ 1504 7, /* O_bit_and */ 1505 5, /* O_add */ 1506 5, /* O_subtract */ 1507 4, /* O_eq */ 1508 4, /* O_ne */ 1509 4, /* O_lt */ 1510 4, /* O_le */ 1511 4, /* O_ge */ 1512 4, /* O_gt */ 1513 3, /* O_logical_and */ 1514 2, /* O_logical_or */ 1515 1, /* O_index */ 1516 }; 1517 1518 /* Unfortunately, in MRI mode for the m68k, multiplication and 1519 division have lower precedence than the bit wise operators. This 1520 function sets the operator precedences correctly for the current 1521 mode. Also, MRI uses a different bit_not operator, and this fixes 1522 that as well. */ 1523 1524 #define STANDARD_MUL_PRECEDENCE 8 1525 #define MRI_MUL_PRECEDENCE 6 1526 1527 void 1528 expr_set_precedence (void) 1529 { 1530 if (flag_m68k_mri) 1531 { 1532 op_rank[O_multiply] = MRI_MUL_PRECEDENCE; 1533 op_rank[O_divide] = MRI_MUL_PRECEDENCE; 1534 op_rank[O_modulus] = MRI_MUL_PRECEDENCE; 1535 } 1536 else 1537 { 1538 op_rank[O_multiply] = STANDARD_MUL_PRECEDENCE; 1539 op_rank[O_divide] = STANDARD_MUL_PRECEDENCE; 1540 op_rank[O_modulus] = STANDARD_MUL_PRECEDENCE; 1541 } 1542 } 1543 1544 void 1545 expr_set_rank (operatorT op, operator_rankT rank) 1546 { 1547 gas_assert (op >= O_md1 && op < ARRAY_SIZE (op_rank)); 1548 op_rank[op] = rank; 1549 } 1550 1551 /* Initialize the expression parser. */ 1552 1553 void 1554 expr_begin (void) 1555 { 1556 expr_set_precedence (); 1557 1558 /* Verify that X_op field is wide enough. */ 1559 { 1560 expressionS e; 1561 e.X_op = O_max; 1562 gas_assert (e.X_op == O_max); 1563 } 1564 } 1565 1566 /* Return the encoding for the operator at INPUT_LINE_POINTER, and 1567 sets NUM_CHARS to the number of characters in the operator. 1568 Does not advance INPUT_LINE_POINTER. */ 1569 1570 static inline operatorT 1571 operatorf (int *num_chars) 1572 { 1573 int c; 1574 operatorT ret; 1575 1576 c = *input_line_pointer & 0xff; 1577 *num_chars = 1; 1578 1579 if (is_end_of_line[c]) 1580 return O_illegal; 1581 1582 #ifdef md_operator 1583 if (is_name_beginner (c)) 1584 { 1585 char *name; 1586 char ec = get_symbol_name (& name); 1587 1588 ret = md_operator (name, 2, &ec); 1589 switch (ret) 1590 { 1591 case O_absent: 1592 *input_line_pointer = ec; 1593 input_line_pointer = name; 1594 break; 1595 case O_uminus: 1596 case O_bit_not: 1597 case O_logical_not: 1598 as_bad (_("invalid use of operator \"%s\""), name); 1599 ret = O_illegal; 1600 /* FALLTHROUGH */ 1601 default: 1602 *input_line_pointer = ec; 1603 *num_chars = input_line_pointer - name; 1604 input_line_pointer = name; 1605 return ret; 1606 } 1607 } 1608 #endif 1609 1610 switch (c) 1611 { 1612 default: 1613 ret = op_encoding[c]; 1614 #ifdef md_operator 1615 if (ret == O_illegal) 1616 { 1617 char *start = input_line_pointer; 1618 1619 ret = md_operator (NULL, 2, NULL); 1620 if (ret != O_illegal) 1621 *num_chars = input_line_pointer - start; 1622 input_line_pointer = start; 1623 } 1624 #endif 1625 return ret; 1626 1627 case '+': 1628 case '-': 1629 return op_encoding[c]; 1630 1631 case '<': 1632 switch (input_line_pointer[1]) 1633 { 1634 default: 1635 return op_encoding[c]; 1636 case '<': 1637 ret = O_left_shift; 1638 break; 1639 case '>': 1640 ret = O_ne; 1641 break; 1642 case '=': 1643 ret = O_le; 1644 break; 1645 } 1646 *num_chars = 2; 1647 return ret; 1648 1649 case '=': 1650 if (input_line_pointer[1] != '=') 1651 return op_encoding[c]; 1652 1653 *num_chars = 2; 1654 return O_eq; 1655 1656 case '>': 1657 switch (input_line_pointer[1]) 1658 { 1659 default: 1660 return op_encoding[c]; 1661 case '>': 1662 ret = O_right_shift; 1663 break; 1664 case '=': 1665 ret = O_ge; 1666 break; 1667 } 1668 *num_chars = 2; 1669 return ret; 1670 1671 case '!': 1672 switch (input_line_pointer[1]) 1673 { 1674 case '!': 1675 /* We accept !! as equivalent to ^ for MRI compatibility. */ 1676 *num_chars = 2; 1677 return O_bit_exclusive_or; 1678 case '=': 1679 /* We accept != as equivalent to <>. */ 1680 *num_chars = 2; 1681 return O_ne; 1682 default: 1683 if (flag_m68k_mri) 1684 return O_bit_inclusive_or; 1685 return op_encoding[c]; 1686 } 1687 1688 case '|': 1689 if (input_line_pointer[1] != '|') 1690 return op_encoding[c]; 1691 1692 *num_chars = 2; 1693 return O_logical_or; 1694 1695 case '&': 1696 if (input_line_pointer[1] != '&') 1697 return op_encoding[c]; 1698 1699 *num_chars = 2; 1700 return O_logical_and; 1701 } 1702 1703 /* NOTREACHED */ 1704 } 1705 1706 /* Implement "word-size + 1 bit" addition for 1707 {resultP->X_extrabit:resultP->X_add_number} + {rhs_highbit:amount}. This 1708 is used so that the full range of unsigned word values and the full range of 1709 signed word values can be represented in an O_constant expression, which is 1710 useful e.g. for .sleb128 directives. */ 1711 1712 void 1713 add_to_result (expressionS *resultP, offsetT amount, int rhs_highbit) 1714 { 1715 valueT ures = resultP->X_add_number; 1716 valueT uamount = amount; 1717 1718 resultP->X_add_number += amount; 1719 1720 resultP->X_extrabit ^= rhs_highbit; 1721 1722 if (ures + uamount < ures) 1723 resultP->X_extrabit ^= 1; 1724 } 1725 1726 /* Similarly, for subtraction. */ 1727 1728 void 1729 subtract_from_result (expressionS *resultP, offsetT amount, int rhs_highbit) 1730 { 1731 valueT ures = resultP->X_add_number; 1732 valueT uamount = amount; 1733 1734 resultP->X_add_number -= amount; 1735 1736 resultP->X_extrabit ^= rhs_highbit; 1737 1738 if (ures < uamount) 1739 resultP->X_extrabit ^= 1; 1740 } 1741 1742 /* Parse an expression. */ 1743 1744 segT 1745 expr (int rankarg, /* Larger # is higher rank. */ 1746 expressionS *resultP, /* Deliver result here. */ 1747 enum expr_mode mode /* Controls behavior. */) 1748 { 1749 operator_rankT rank = (operator_rankT) rankarg; 1750 segT retval; 1751 expressionS right; 1752 operatorT op_left; 1753 operatorT op_right; 1754 int op_chars; 1755 1756 know (rankarg >= 0); 1757 1758 /* Save the value of dot for the fixup code. */ 1759 if (rank == 0) 1760 { 1761 dot_value = frag_now_fix (); 1762 dot_frag = frag_now; 1763 } 1764 1765 retval = operand (resultP, mode); 1766 1767 /* operand () gobbles spaces. */ 1768 know (*input_line_pointer != ' '); 1769 1770 op_left = operatorf (&op_chars); 1771 while (op_left != O_illegal && op_rank[(int) op_left] > rank) 1772 { 1773 segT rightseg; 1774 offsetT frag_off; 1775 1776 input_line_pointer += op_chars; /* -> after operator. */ 1777 1778 right.X_md = 0; 1779 rightseg = expr (op_rank[(int) op_left], &right, mode); 1780 if (right.X_op == O_absent) 1781 { 1782 as_warn (_("missing operand; zero assumed")); 1783 right.X_op = O_constant; 1784 right.X_add_number = 0; 1785 right.X_add_symbol = NULL; 1786 right.X_op_symbol = NULL; 1787 } 1788 1789 know (*input_line_pointer != ' '); 1790 1791 if (op_left == O_index) 1792 { 1793 if (*input_line_pointer != ']') 1794 as_bad ("missing right bracket"); 1795 else 1796 { 1797 ++input_line_pointer; 1798 SKIP_WHITESPACE (); 1799 } 1800 } 1801 1802 op_right = operatorf (&op_chars); 1803 1804 know (op_right == O_illegal || op_left == O_index 1805 || op_rank[(int) op_right] <= op_rank[(int) op_left]); 1806 know ((int) op_left >= (int) O_multiply); 1807 #ifndef md_operator 1808 know ((int) op_left <= (int) O_index); 1809 #else 1810 know ((int) op_left < (int) O_max); 1811 #endif 1812 1813 /* input_line_pointer->after right-hand quantity. */ 1814 /* left-hand quantity in resultP. */ 1815 /* right-hand quantity in right. */ 1816 /* operator in op_left. */ 1817 1818 if (resultP->X_op == O_big) 1819 { 1820 if (resultP->X_add_number > 0) 1821 as_warn (_("left operand is a bignum; integer 0 assumed")); 1822 else 1823 as_warn (_("left operand is a float; integer 0 assumed")); 1824 resultP->X_op = O_constant; 1825 resultP->X_add_number = 0; 1826 resultP->X_add_symbol = NULL; 1827 resultP->X_op_symbol = NULL; 1828 } 1829 if (right.X_op == O_big) 1830 { 1831 if (right.X_add_number > 0) 1832 as_warn (_("right operand is a bignum; integer 0 assumed")); 1833 else 1834 as_warn (_("right operand is a float; integer 0 assumed")); 1835 right.X_op = O_constant; 1836 right.X_add_number = 0; 1837 right.X_add_symbol = NULL; 1838 right.X_op_symbol = NULL; 1839 } 1840 1841 /* Optimize common cases. */ 1842 #ifdef md_optimize_expr 1843 if (md_optimize_expr (resultP, op_left, &right)) 1844 { 1845 /* Skip. */ 1846 ; 1847 } 1848 else 1849 #endif 1850 #ifndef md_register_arithmetic 1851 # define md_register_arithmetic 1 1852 #endif 1853 if (op_left == O_add && right.X_op == O_constant 1854 && (md_register_arithmetic || resultP->X_op != O_register)) 1855 { 1856 /* X + constant. */ 1857 add_to_result (resultP, right.X_add_number, right.X_extrabit); 1858 } 1859 /* This case comes up in PIC code. */ 1860 else if (op_left == O_subtract 1861 && right.X_op == O_symbol 1862 && resultP->X_op == O_symbol 1863 && retval == rightseg 1864 #ifdef md_allow_local_subtract 1865 && md_allow_local_subtract (resultP, & right, rightseg) 1866 #endif 1867 && ((SEG_NORMAL (rightseg) 1868 && !S_FORCE_RELOC (resultP->X_add_symbol, 0) 1869 && !S_FORCE_RELOC (right.X_add_symbol, 0)) 1870 || right.X_add_symbol == resultP->X_add_symbol) 1871 && frag_offset_fixed_p (symbol_get_frag (resultP->X_add_symbol), 1872 symbol_get_frag (right.X_add_symbol), 1873 &frag_off)) 1874 { 1875 offsetT symval_diff = S_GET_VALUE (resultP->X_add_symbol) 1876 - S_GET_VALUE (right.X_add_symbol); 1877 subtract_from_result (resultP, right.X_add_number, right.X_extrabit); 1878 subtract_from_result (resultP, frag_off / OCTETS_PER_BYTE, 0); 1879 add_to_result (resultP, symval_diff, symval_diff < 0); 1880 resultP->X_op = O_constant; 1881 resultP->X_add_symbol = 0; 1882 } 1883 else if (op_left == O_subtract && right.X_op == O_constant 1884 && (md_register_arithmetic || resultP->X_op != O_register)) 1885 { 1886 /* X - constant. */ 1887 subtract_from_result (resultP, right.X_add_number, right.X_extrabit); 1888 } 1889 else if (op_left == O_add && resultP->X_op == O_constant 1890 && (md_register_arithmetic || right.X_op != O_register)) 1891 { 1892 /* Constant + X. */ 1893 resultP->X_op = right.X_op; 1894 resultP->X_add_symbol = right.X_add_symbol; 1895 resultP->X_op_symbol = right.X_op_symbol; 1896 add_to_result (resultP, right.X_add_number, right.X_extrabit); 1897 retval = rightseg; 1898 } 1899 else if (resultP->X_op == O_constant && right.X_op == O_constant) 1900 { 1901 /* Constant OP constant. */ 1902 offsetT v = right.X_add_number; 1903 if (v == 0 && (op_left == O_divide || op_left == O_modulus)) 1904 { 1905 as_warn (_("division by zero")); 1906 v = 1; 1907 } 1908 if ((valueT) v >= sizeof(valueT) * CHAR_BIT 1909 && (op_left == O_left_shift || op_left == O_right_shift)) 1910 { 1911 as_warn_value_out_of_range (_("shift count"), v, 0, 1912 sizeof(valueT) * CHAR_BIT - 1, 1913 NULL, 0); 1914 resultP->X_add_number = v = 0; 1915 } 1916 switch (op_left) 1917 { 1918 default: goto general; 1919 case O_multiply: resultP->X_add_number *= v; break; 1920 case O_divide: resultP->X_add_number /= v; break; 1921 case O_modulus: resultP->X_add_number %= v; break; 1922 case O_left_shift: resultP->X_add_number <<= v; break; 1923 case O_right_shift: 1924 /* We always use unsigned shifts, to avoid relying on 1925 characteristics of the compiler used to compile gas. */ 1926 resultP->X_add_number = 1927 (offsetT) ((valueT) resultP->X_add_number >> (valueT) v); 1928 break; 1929 case O_bit_inclusive_or: resultP->X_add_number |= v; break; 1930 case O_bit_or_not: resultP->X_add_number |= ~v; break; 1931 case O_bit_exclusive_or: resultP->X_add_number ^= v; break; 1932 case O_bit_and: resultP->X_add_number &= v; break; 1933 /* Constant + constant (O_add) is handled by the 1934 previous if statement for constant + X, so is omitted 1935 here. */ 1936 case O_subtract: 1937 subtract_from_result (resultP, v, 0); 1938 break; 1939 case O_eq: 1940 resultP->X_add_number = 1941 resultP->X_add_number == v ? ~ (offsetT) 0 : 0; 1942 break; 1943 case O_ne: 1944 resultP->X_add_number = 1945 resultP->X_add_number != v ? ~ (offsetT) 0 : 0; 1946 break; 1947 case O_lt: 1948 resultP->X_add_number = 1949 resultP->X_add_number < v ? ~ (offsetT) 0 : 0; 1950 break; 1951 case O_le: 1952 resultP->X_add_number = 1953 resultP->X_add_number <= v ? ~ (offsetT) 0 : 0; 1954 break; 1955 case O_ge: 1956 resultP->X_add_number = 1957 resultP->X_add_number >= v ? ~ (offsetT) 0 : 0; 1958 break; 1959 case O_gt: 1960 resultP->X_add_number = 1961 resultP->X_add_number > v ? ~ (offsetT) 0 : 0; 1962 break; 1963 case O_logical_and: 1964 resultP->X_add_number = resultP->X_add_number && v; 1965 break; 1966 case O_logical_or: 1967 resultP->X_add_number = resultP->X_add_number || v; 1968 break; 1969 } 1970 } 1971 else if (resultP->X_op == O_symbol 1972 && right.X_op == O_symbol 1973 && (op_left == O_add 1974 || op_left == O_subtract 1975 || (resultP->X_add_number == 0 1976 && right.X_add_number == 0))) 1977 { 1978 /* Symbol OP symbol. */ 1979 resultP->X_op = op_left; 1980 resultP->X_op_symbol = right.X_add_symbol; 1981 if (op_left == O_add) 1982 add_to_result (resultP, right.X_add_number, right.X_extrabit); 1983 else if (op_left == O_subtract) 1984 { 1985 subtract_from_result (resultP, right.X_add_number, 1986 right.X_extrabit); 1987 if (retval == rightseg 1988 && SEG_NORMAL (retval) 1989 && !S_FORCE_RELOC (resultP->X_add_symbol, 0) 1990 && !S_FORCE_RELOC (right.X_add_symbol, 0)) 1991 { 1992 retval = absolute_section; 1993 rightseg = absolute_section; 1994 } 1995 } 1996 } 1997 else 1998 { 1999 general: 2000 /* The general case. */ 2001 resultP->X_add_symbol = make_expr_symbol (resultP); 2002 resultP->X_op_symbol = make_expr_symbol (&right); 2003 resultP->X_op = op_left; 2004 resultP->X_add_number = 0; 2005 resultP->X_unsigned = 1; 2006 resultP->X_extrabit = 0; 2007 } 2008 2009 if (retval != rightseg) 2010 { 2011 if (retval == undefined_section) 2012 ; 2013 else if (rightseg == undefined_section) 2014 retval = rightseg; 2015 else if (retval == expr_section) 2016 ; 2017 else if (rightseg == expr_section) 2018 retval = rightseg; 2019 else if (retval == reg_section) 2020 ; 2021 else if (rightseg == reg_section) 2022 retval = rightseg; 2023 else if (rightseg == absolute_section) 2024 ; 2025 else if (retval == absolute_section) 2026 retval = rightseg; 2027 #ifdef DIFF_EXPR_OK 2028 else if (op_left == O_subtract) 2029 ; 2030 #endif 2031 else 2032 as_bad (_("operation combines symbols in different segments")); 2033 } 2034 2035 op_left = op_right; 2036 } /* While next operator is >= this rank. */ 2037 2038 /* The PA port needs this information. */ 2039 if (resultP->X_add_symbol) 2040 symbol_mark_used (resultP->X_add_symbol); 2041 2042 if (rank == 0 && mode == expr_evaluate) 2043 resolve_expression (resultP); 2044 2045 return resultP->X_op == O_constant ? absolute_section : retval; 2046 } 2047 2048 /* Resolve an expression without changing any symbols/sub-expressions 2049 used. */ 2050 2051 int 2052 resolve_expression (expressionS *expressionP) 2053 { 2054 /* Help out with CSE. */ 2055 valueT final_val = expressionP->X_add_number; 2056 symbolS *add_symbol = expressionP->X_add_symbol; 2057 symbolS *orig_add_symbol = add_symbol; 2058 symbolS *op_symbol = expressionP->X_op_symbol; 2059 operatorT op = expressionP->X_op; 2060 valueT left, right; 2061 segT seg_left, seg_right; 2062 fragS *frag_left, *frag_right; 2063 offsetT frag_off; 2064 2065 switch (op) 2066 { 2067 default: 2068 return 0; 2069 2070 case O_constant: 2071 case O_register: 2072 left = 0; 2073 break; 2074 2075 case O_symbol: 2076 case O_symbol_rva: 2077 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left)) 2078 return 0; 2079 2080 break; 2081 2082 case O_uminus: 2083 case O_bit_not: 2084 case O_logical_not: 2085 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left)) 2086 return 0; 2087 2088 if (seg_left != absolute_section) 2089 return 0; 2090 2091 if (op == O_logical_not) 2092 left = !left; 2093 else if (op == O_uminus) 2094 left = -left; 2095 else 2096 left = ~left; 2097 op = O_constant; 2098 break; 2099 2100 case O_multiply: 2101 case O_divide: 2102 case O_modulus: 2103 case O_left_shift: 2104 case O_right_shift: 2105 case O_bit_inclusive_or: 2106 case O_bit_or_not: 2107 case O_bit_exclusive_or: 2108 case O_bit_and: 2109 case O_add: 2110 case O_subtract: 2111 case O_eq: 2112 case O_ne: 2113 case O_lt: 2114 case O_le: 2115 case O_ge: 2116 case O_gt: 2117 case O_logical_and: 2118 case O_logical_or: 2119 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left) 2120 || !snapshot_symbol (&op_symbol, &right, &seg_right, &frag_right)) 2121 return 0; 2122 2123 /* Simplify addition or subtraction of a constant by folding the 2124 constant into X_add_number. */ 2125 if (op == O_add) 2126 { 2127 if (seg_right == absolute_section) 2128 { 2129 final_val += right; 2130 op = O_symbol; 2131 break; 2132 } 2133 else if (seg_left == absolute_section) 2134 { 2135 final_val += left; 2136 left = right; 2137 seg_left = seg_right; 2138 add_symbol = op_symbol; 2139 orig_add_symbol = expressionP->X_op_symbol; 2140 op = O_symbol; 2141 break; 2142 } 2143 } 2144 else if (op == O_subtract) 2145 { 2146 if (seg_right == absolute_section) 2147 { 2148 final_val -= right; 2149 op = O_symbol; 2150 break; 2151 } 2152 } 2153 2154 /* Equality and non-equality tests are permitted on anything. 2155 Subtraction, and other comparison operators are permitted if 2156 both operands are in the same section. 2157 Shifts by constant zero are permitted on anything. 2158 Multiplies, bit-ors, and bit-ands with constant zero are 2159 permitted on anything. 2160 Multiplies and divides by constant one are permitted on 2161 anything. 2162 Binary operations with both operands being the same register 2163 or undefined symbol are permitted if the result doesn't depend 2164 on the input value. 2165 Otherwise, both operands must be absolute. We already handled 2166 the case of addition or subtraction of a constant above. */ 2167 frag_off = 0; 2168 if (!(seg_left == absolute_section 2169 && seg_right == absolute_section) 2170 && !(op == O_eq || op == O_ne) 2171 && !((op == O_subtract 2172 || op == O_lt || op == O_le || op == O_ge || op == O_gt) 2173 && seg_left == seg_right 2174 && (finalize_syms 2175 || frag_offset_fixed_p (frag_left, frag_right, &frag_off)) 2176 && (seg_left != reg_section || left == right) 2177 && (seg_left != undefined_section || add_symbol == op_symbol))) 2178 { 2179 if ((seg_left == absolute_section && left == 0) 2180 || (seg_right == absolute_section && right == 0)) 2181 { 2182 if (op == O_bit_exclusive_or || op == O_bit_inclusive_or) 2183 { 2184 if (!(seg_right == absolute_section && right == 0)) 2185 { 2186 seg_left = seg_right; 2187 left = right; 2188 add_symbol = op_symbol; 2189 orig_add_symbol = expressionP->X_op_symbol; 2190 } 2191 op = O_symbol; 2192 break; 2193 } 2194 else if (op == O_left_shift || op == O_right_shift) 2195 { 2196 if (!(seg_left == absolute_section && left == 0)) 2197 { 2198 op = O_symbol; 2199 break; 2200 } 2201 } 2202 else if (op != O_multiply 2203 && op != O_bit_or_not && op != O_bit_and) 2204 return 0; 2205 } 2206 else if (op == O_multiply 2207 && seg_left == absolute_section && left == 1) 2208 { 2209 seg_left = seg_right; 2210 left = right; 2211 add_symbol = op_symbol; 2212 orig_add_symbol = expressionP->X_op_symbol; 2213 op = O_symbol; 2214 break; 2215 } 2216 else if ((op == O_multiply || op == O_divide) 2217 && seg_right == absolute_section && right == 1) 2218 { 2219 op = O_symbol; 2220 break; 2221 } 2222 else if (!(left == right 2223 && ((seg_left == reg_section && seg_right == reg_section) 2224 || (seg_left == undefined_section 2225 && seg_right == undefined_section 2226 && add_symbol == op_symbol)))) 2227 return 0; 2228 else if (op == O_bit_and || op == O_bit_inclusive_or) 2229 { 2230 op = O_symbol; 2231 break; 2232 } 2233 else if (op != O_bit_exclusive_or && op != O_bit_or_not) 2234 return 0; 2235 } 2236 2237 right += frag_off / OCTETS_PER_BYTE; 2238 switch (op) 2239 { 2240 case O_add: left += right; break; 2241 case O_subtract: left -= right; break; 2242 case O_multiply: left *= right; break; 2243 case O_divide: 2244 if (right == 0) 2245 return 0; 2246 left = (offsetT) left / (offsetT) right; 2247 break; 2248 case O_modulus: 2249 if (right == 0) 2250 return 0; 2251 left = (offsetT) left % (offsetT) right; 2252 break; 2253 case O_left_shift: left <<= right; break; 2254 case O_right_shift: left >>= right; break; 2255 case O_bit_inclusive_or: left |= right; break; 2256 case O_bit_or_not: left |= ~right; break; 2257 case O_bit_exclusive_or: left ^= right; break; 2258 case O_bit_and: left &= right; break; 2259 case O_eq: 2260 case O_ne: 2261 left = (left == right 2262 && seg_left == seg_right 2263 && (finalize_syms || frag_left == frag_right) 2264 && (seg_left != undefined_section 2265 || add_symbol == op_symbol) 2266 ? ~ (valueT) 0 : 0); 2267 if (op == O_ne) 2268 left = ~left; 2269 break; 2270 case O_lt: 2271 left = (offsetT) left < (offsetT) right ? ~ (valueT) 0 : 0; 2272 break; 2273 case O_le: 2274 left = (offsetT) left <= (offsetT) right ? ~ (valueT) 0 : 0; 2275 break; 2276 case O_ge: 2277 left = (offsetT) left >= (offsetT) right ? ~ (valueT) 0 : 0; 2278 break; 2279 case O_gt: 2280 left = (offsetT) left > (offsetT) right ? ~ (valueT) 0 : 0; 2281 break; 2282 case O_logical_and: left = left && right; break; 2283 case O_logical_or: left = left || right; break; 2284 default: abort (); 2285 } 2286 2287 op = O_constant; 2288 break; 2289 } 2290 2291 if (op == O_symbol) 2292 { 2293 if (seg_left == absolute_section) 2294 op = O_constant; 2295 else if (seg_left == reg_section && final_val == 0) 2296 op = O_register; 2297 else if (!symbol_same_p (add_symbol, orig_add_symbol)) 2298 final_val += left; 2299 expressionP->X_add_symbol = add_symbol; 2300 } 2301 expressionP->X_op = op; 2302 2303 if (op == O_constant || op == O_register) 2304 final_val += left; 2305 expressionP->X_add_number = final_val; 2306 2307 return 1; 2308 } 2309 2310 /* This lives here because it belongs equally in expr.c & read.c. 2311 expr.c is just a branch office read.c anyway, and putting it 2312 here lessens the crowd at read.c. 2313 2314 Assume input_line_pointer is at start of symbol name, or the 2315 start of a double quote enclosed symbol name. 2316 Advance input_line_pointer past symbol name. 2317 Turn that character into a '\0', returning its former value, 2318 which may be the closing double quote. 2319 This allows a string compare (RMS wants symbol names to be strings) 2320 of the symbol name. 2321 There will always be a char following symbol name, because all good 2322 lines end in end-of-line. */ 2323 2324 char 2325 get_symbol_name (char ** ilp_return) 2326 { 2327 char c; 2328 2329 * ilp_return = input_line_pointer; 2330 /* We accept FAKE_LABEL_CHAR in a name in case this is being called with a 2331 constructed string. */ 2332 if (is_name_beginner (c = *input_line_pointer++) 2333 || (input_from_string && c == FAKE_LABEL_CHAR)) 2334 { 2335 while (is_part_of_name (c = *input_line_pointer++) 2336 || (input_from_string && c == FAKE_LABEL_CHAR)) 2337 ; 2338 if (is_name_ender (c)) 2339 c = *input_line_pointer++; 2340 } 2341 else if (c == '"') 2342 { 2343 bfd_boolean backslash_seen; 2344 2345 * ilp_return = input_line_pointer; 2346 do 2347 { 2348 backslash_seen = c == '\\'; 2349 c = * input_line_pointer ++; 2350 } 2351 while (c != 0 && (c != '"' || backslash_seen)); 2352 2353 if (c == 0) 2354 as_warn (_("missing closing '\"'")); 2355 } 2356 *--input_line_pointer = 0; 2357 return c; 2358 } 2359 2360 /* Replace the NUL character pointed to by input_line_pointer 2361 with C. If C is \" then advance past it. Return the character 2362 now pointed to by input_line_pointer. */ 2363 2364 char 2365 restore_line_pointer (char c) 2366 { 2367 * input_line_pointer = c; 2368 if (c == '"') 2369 c = * ++ input_line_pointer; 2370 return c; 2371 } 2372 2373 unsigned int 2374 get_single_number (void) 2375 { 2376 expressionS exp; 2377 operand (&exp, expr_normal); 2378 return exp.X_add_number; 2379 } 2380