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