1 /* expr.c -operands, expressions-
2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
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)
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.
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
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. */
26 #define min(a, b) ((a) < (b) ? (a) : (b))
29 #include "safe-ctype.h"
38 static void floating_constant (expressionS * expressionP);
39 static valueT generic_bignum_to_int32 (void);
41 static valueT generic_bignum_to_int64 (void);
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 *);
49 /* We keep a mapping of expression symbols to file positions, so that
50 we can provide better error messages. */
52 struct expr_symbol_line {
53 struct expr_symbol_line *next;
59 static struct expr_symbol_line *expr_symbol_lines;
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. */
66 make_expr_symbol (expressionS *expressionP)
70 struct expr_symbol_line *n;
72 if (expressionP->X_op == O_symbol
73 && expressionP->X_add_number == 0)
74 return expressionP->X_add_symbol;
76 if (expressionP->X_op == O_big)
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"));
84 as_bad (_("floating point number invalid"));
85 zero.X_op = O_constant;
86 zero.X_add_number = 0;
89 clean_up_expression (&zero);
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
97 symbolP = symbol_create (FAKE_LABEL_NAME,
98 (expressionP->X_op == O_constant
100 : expressionP->X_op == O_register
103 0, &zero_address_frag);
104 symbol_set_value_expression (symbolP, expressionP);
106 if (expressionP->X_op == O_constant)
107 resolve_symbol_value (symbolP);
109 n = XNEW (struct expr_symbol_line);
111 n->file = as_where (&n->line);
112 n->next = expr_symbol_lines;
113 expr_symbol_lines = n;
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
123 expr_symbol_where (symbolS *sym, const char **pfile, unsigned int *pline)
125 struct expr_symbol_line *l;
127 for (l = expr_symbol_lines; l != NULL; l = l->next)
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. */
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. */
153 expr_build_uconstant (offsetT value)
158 e.X_add_number = value;
161 return make_expr_symbol (&e);
164 /* Build an expression for the current location ('.'). */
167 expr_build_dot (void)
171 current_location (&e);
172 return symbol_clone_if_forward_ref (make_expr_symbol (&e));
175 /* Build any floating-point literal here.
176 Also build any bignum literal here. */
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];
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) */
195 floating_constant (expressionS *expressionP)
197 /* input_line_pointer -> floating-point constant. */
200 error_code = atof_generic (&input_line_pointer, ".", EXP_CHARS,
201 &generic_floating_point_number);
205 if (error_code == ERROR_EXPONENT_OVERFLOW)
207 as_bad (_("bad floating-point constant: exponent overflow"));
211 as_bad (_("bad floating-point constant: unknown error code=%d"),
215 expressionP->X_op = O_big;
216 /* input_line_pointer -> just after constant, which may point to
218 expressionP->X_add_number = -1;
222 generic_bignum_to_int32 (void)
225 ((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
226 | (generic_bignum[0] & LITTLENUM_MASK);
227 number &= 0xffffffff;
233 generic_bignum_to_int64 (void)
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));
248 integer_constant (int radix, expressionS *expressionP)
250 char *start; /* Start of number. */
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. */
260 int small; /* True if fits in 32 bits. */
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. */
282 #else /* includes non-bfd case, mostly */
286 if (is_end_of_line[(unsigned char) *input_line_pointer])
288 expressionP->X_op = O_absent;
292 if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri) && radix == 0)
296 /* In MRI mode, the number may have a suffix indicating the
297 radix. For that matter, it might actually be a floating
299 for (suffix = input_line_pointer; ISALNUM (*suffix); suffix++)
301 if (*suffix == 'e' || *suffix == 'E')
305 if (suffix == input_line_pointer)
314 /* If we have both NUMBERS_WITH_SUFFIX and LOCAL_LABELS_FB,
315 we distinguish between 'B' and 'b'. This is the case for
317 if ((NUMBERS_WITH_SUFFIX && LOCAL_LABELS_FB ? *suffix : c) == 'B')
321 else if (c == 'O' || c == 'Q')
325 else if (suffix[1] == '.' || c == 'E' || flt)
327 floating_constant (expressionP);
342 too_many_digits = valuesize + 1;
346 too_many_digits = (valuesize + 2) / 3 + 1;
350 too_many_digits = (valuesize + 3) / 4 + 1;
354 too_many_digits = (valuesize + 11) / 4; /* Very rough. */
357 start = input_line_pointer;
358 c = *input_line_pointer++;
360 (digit = hex_value (c)) < maxdig;
361 c = *input_line_pointer++)
363 number = number * radix + digit;
365 /* c contains character after number. */
366 /* input_line_pointer->char after c. */
367 small = (input_line_pointer - start - 1) < too_many_digits;
369 if (radix == 16 && c == '_')
371 /* This is literal of the form 0x333_0_12345678_1.
372 This example is equivalent to 0x00000333000000001234567800000001. */
374 int num_little_digits = 0;
376 input_line_pointer = start; /* -> 1st digit. */
378 know (LITTLENUM_NUMBER_OF_BITS == 16);
380 for (c = '_'; c == '_'; num_little_digits += 2)
383 /* Convert one 64-bit word. */
386 for (c = *input_line_pointer++;
387 (digit = hex_value (c)) < maxdig;
388 c = *(input_line_pointer++))
390 number = number * radix + digit;
394 /* Check for 8 digit per word max. */
396 as_bad (_("a bignum with underscores may not have more than 8 hex digits in any word"));
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);
404 generic_bignum[i] = generic_bignum[i - 2];
406 /* Add the new digits as the least significant new ones. */
407 generic_bignum[0] = number & 0xffffffff;
408 generic_bignum[1] = number >> 16;
411 /* Again, c is char after number, input_line_pointer->after c. */
413 if (num_little_digits > SIZE_OF_LARGE_NUMBER - 1)
414 num_little_digits = SIZE_OF_LARGE_NUMBER - 1;
416 gas_assert (num_little_digits >= 4);
418 if (num_little_digits != 8)
419 as_bad (_("a bignum with underscores must have exactly 4 words"));
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)
427 if (num_little_digits <= 2)
429 /* will fit into 32 bits. */
430 number = generic_bignum_to_int32 ();
434 else if (num_little_digits <= 4)
436 /* Will fit into 64 bits. */
437 number = generic_bignum_to_int64 ();
445 /* Number of littlenums in the bignum. */
446 number = num_little_digits;
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. */
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++)
465 for (pointer = generic_bignum; pointer <= leader; pointer++)
469 work = carry + radix * *pointer;
470 *pointer = work & LITTLENUM_MASK;
471 carry = work >> LITTLENUM_NUMBER_OF_BITS;
475 if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1)
477 /* Room to grow a longer bignum. */
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)
487 /* Will fit into 32 bits. */
488 number = generic_bignum_to_int32 ();
492 else if (leader < generic_bignum + 4)
494 /* Will fit into 64 bits. */
495 number = generic_bignum_to_int64 ();
501 /* Number of littlenums in the bignum. */
502 number = leader - generic_bignum + 1;
506 if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
508 && input_line_pointer - 1 == suffix)
509 c = *input_line_pointer++;
513 /* Here with number, in correct radix. c is the next char.
514 Note that unlike un*x, we allow "011f" "0x9f" to both mean
515 the same as the (conventional) "9f".
516 This is simply easier than checking for strict canonical
519 if (LOCAL_LABELS_FB && c == 'b')
521 /* Backward ref to local label.
522 Because it is backward, expect it to be defined. */
523 /* Construct a local label. */
524 name = fb_label_name ((int) number, 0);
526 /* Seen before, or symbol is defined: OK. */
527 symbolP = symbol_find (name);
528 if ((symbolP != NULL) && (S_IS_DEFINED (symbolP)))
530 /* Local labels are never absolute. Don't waste time
531 checking absoluteness. */
532 know (SEG_NORMAL (S_GET_SEGMENT (symbolP)));
534 expressionP->X_op = O_symbol;
535 expressionP->X_add_symbol = symbolP;
539 /* Either not seen or not defined. */
540 /* @@ Should print out the original string instead of
541 the parsed number. */
542 as_bad (_("backward ref to unknown label \"%d:\""),
544 expressionP->X_op = O_constant;
547 expressionP->X_add_number = 0;
549 else if (LOCAL_LABELS_FB && c == 'f')
551 /* Forward reference. Expect symbol to be undefined or
552 unknown. undefined: seen it before. unknown: never seen
555 Construct a local label name, then an undefined symbol.
556 Don't create a xseg frag for it: caller may do that.
557 Just return it as never seen before. */
558 name = fb_label_name ((int) number, 1);
559 symbolP = symbol_find_or_make (name);
560 /* We have no need to check symbol properties. */
561 #ifndef many_segments
562 /* Since "know" puts its arg into a "string", we
563 can't have newlines in the argument. */
564 know (S_GET_SEGMENT (symbolP) == undefined_section || S_GET_SEGMENT (symbolP) == text_section || S_GET_SEGMENT (symbolP) == data_section);
566 expressionP->X_op = O_symbol;
567 expressionP->X_add_symbol = symbolP;
568 expressionP->X_add_number = 0;
570 else if (LOCAL_LABELS_DOLLAR && c == '$')
572 /* If the dollar label is *currently* defined, then this is just
573 another reference to it. If it is not *currently* defined,
574 then this is a fresh instantiation of that number, so create
577 if (dollar_label_defined ((long) number))
579 name = dollar_label_name ((long) number, 0);
580 symbolP = symbol_find (name);
581 know (symbolP != NULL);
585 name = dollar_label_name ((long) number, 1);
586 symbolP = symbol_find_or_make (name);
589 expressionP->X_op = O_symbol;
590 expressionP->X_add_symbol = symbolP;
591 expressionP->X_add_number = 0;
595 expressionP->X_op = O_constant;
596 expressionP->X_add_number = number;
597 input_line_pointer--; /* Restore following character. */
598 } /* Really just a number. */
602 /* Not a small number. */
603 expressionP->X_op = O_big;
604 expressionP->X_add_number = number; /* Number of littlenums. */
605 input_line_pointer--; /* -> char following number. */
609 /* Parse an MRI multi character constant. */
612 mri_char_constant (expressionS *expressionP)
616 if (*input_line_pointer == '\''
617 && input_line_pointer[1] != '\'')
619 expressionP->X_op = O_constant;
620 expressionP->X_add_number = 0;
624 /* In order to get the correct byte ordering, we must build the
625 number in reverse. */
626 for (i = SIZE_OF_LARGE_NUMBER - 1; i >= 0; i--)
630 generic_bignum[i] = 0;
631 for (j = 0; j < CHARS_PER_LITTLENUM; j++)
633 if (*input_line_pointer == '\'')
635 if (input_line_pointer[1] != '\'')
637 ++input_line_pointer;
639 generic_bignum[i] <<= 8;
640 generic_bignum[i] += *input_line_pointer;
641 ++input_line_pointer;
644 if (i < SIZE_OF_LARGE_NUMBER - 1)
646 /* If there is more than one littlenum, left justify the
647 last one to make it match the earlier ones. If there is
648 only one, we can just use the value directly. */
649 for (; j < CHARS_PER_LITTLENUM; j++)
650 generic_bignum[i] <<= 8;
653 if (*input_line_pointer == '\''
654 && input_line_pointer[1] != '\'')
660 as_bad (_("character constant too large"));
669 c = SIZE_OF_LARGE_NUMBER - i;
670 for (j = 0; j < c; j++)
671 generic_bignum[j] = generic_bignum[i + j];
675 know (LITTLENUM_NUMBER_OF_BITS == 16);
678 expressionP->X_op = O_big;
679 expressionP->X_add_number = i;
683 expressionP->X_op = O_constant;
685 expressionP->X_add_number = generic_bignum[0] & LITTLENUM_MASK;
687 expressionP->X_add_number =
688 (((generic_bignum[1] & LITTLENUM_MASK)
689 << LITTLENUM_NUMBER_OF_BITS)
690 | (generic_bignum[0] & LITTLENUM_MASK));
693 /* Skip the final closing quote. */
694 ++input_line_pointer;
697 /* Return an expression representing the current location. This
698 handles the magic symbol `.'. */
701 current_location (expressionS *expressionp)
703 if (now_seg == absolute_section)
705 expressionp->X_op = O_constant;
706 expressionp->X_add_number = abs_section_offset;
710 expressionp->X_op = O_symbol;
711 expressionp->X_add_symbol = &dot_symbol;
712 expressionp->X_add_number = 0;
716 /* In: Input_line_pointer points to 1st char of operand, which may
720 The operand may have been empty: in this case X_op == O_absent.
721 Input_line_pointer->(next non-blank) char after operand. */
724 operand (expressionS *expressionP, enum expr_mode mode)
727 symbolS *symbolP; /* Points to symbol. */
728 char *name; /* Points to name of symbol. */
731 /* All integers are regarded as unsigned unless they are negated.
732 This is because the only thing which cares whether a number is
733 unsigned is the code in emit_expr which extends constants into
734 bignums. It should only sign extend negative numbers, so that
735 something like ``.quad 0x80000000'' is not sign extended even
736 though it appears negative if valueT is 32 bits. */
737 expressionP->X_unsigned = 1;
738 expressionP->X_extrabit = 0;
740 /* Digits, assume it is a bignum. */
742 SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
743 c = *input_line_pointer++; /* input_line_pointer -> past char in c. */
745 if (is_end_of_line[(unsigned char) c])
759 input_line_pointer--;
761 integer_constant ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
766 #ifdef LITERAL_PREFIXDOLLAR_HEX
768 /* $L is the start of a local label, not a hex constant. */
769 if (* input_line_pointer == 'L')
771 integer_constant (16, expressionP);
775 #ifdef LITERAL_PREFIXPERCENT_BIN
777 integer_constant (2, expressionP);
782 /* Non-decimal radix. */
784 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
788 /* Check for a hex or float constant. */
789 for (s = input_line_pointer; hex_p (*s); s++)
791 if (*s == 'h' || *s == 'H' || *input_line_pointer == '.')
793 --input_line_pointer;
794 integer_constant (0, expressionP);
798 c = *input_line_pointer;
807 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
809 integer_constant (0, expressionP);
815 if (c && strchr (FLT_CHARS, c))
817 input_line_pointer++;
818 floating_constant (expressionP);
819 expressionP->X_add_number = - TOLOWER (c);
823 /* The string was only zero. */
824 expressionP->X_op = O_constant;
825 expressionP->X_add_number = 0;
834 input_line_pointer++;
835 integer_constant (16, expressionP);
839 if (LOCAL_LABELS_FB && !flag_m68k_mri
840 && input_line_pointer[1] != '0'
841 && input_line_pointer[1] != '1')
843 /* Parse this as a back reference to label 0. */
844 input_line_pointer--;
845 integer_constant (10, expressionP);
848 /* Otherwise, parse this as a binary number. */
851 if (input_line_pointer[1] == '0'
852 || input_line_pointer[1] == '1')
854 input_line_pointer++;
855 integer_constant (2, expressionP);
858 if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
859 input_line_pointer++;
870 integer_constant ((flag_m68k_mri || NUMBERS_WITH_SUFFIX)
880 /* If it says "0f" and it could possibly be a floating point
881 number, make it one. Otherwise, make it a local label,
882 and try to deal with parsing the rest later. */
883 if (!is_end_of_line[(unsigned char) input_line_pointer[1]]
884 && strchr (FLT_CHARS, 'f') != NULL)
886 char *cp = input_line_pointer + 1;
888 atof_generic (&cp, ".", EXP_CHARS,
889 &generic_floating_point_number);
891 /* Was nothing parsed, or does it look like an
893 is_label = (cp == input_line_pointer + 1
894 || (cp == input_line_pointer + 2
895 && (cp[-1] == '-' || cp[-1] == '+'))
901 input_line_pointer--;
902 integer_constant (10, expressionP);
910 if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
912 integer_constant (0, expressionP);
922 input_line_pointer++;
923 floating_constant (expressionP);
924 expressionP->X_add_number = - TOLOWER (c);
928 if (LOCAL_LABELS_DOLLAR)
930 integer_constant (10, expressionP);
939 #ifndef NEED_INDEX_OPERATOR
941 # ifdef md_need_index_operator
942 if (md_need_index_operator())
948 /* Didn't begin with digit & not a name. */
949 segment = expr (0, expressionP, mode);
950 /* expression () will pass trailing whitespace. */
951 if ((c == '(' && *input_line_pointer != ')')
952 || (c == '[' && *input_line_pointer != ']'))
953 as_bad (_("missing '%c'"), c == '(' ? ')' : ']');
955 input_line_pointer++;
957 /* Here with input_line_pointer -> char after "(...)". */
962 if (! flag_m68k_mri || *input_line_pointer != '\'')
964 as_bad (_("EBCDIC constants are not supported"));
967 if (! flag_m68k_mri || *input_line_pointer != '\'')
969 ++input_line_pointer;
975 /* Warning: to conform to other people's assemblers NO
976 ESCAPEMENT is permitted for a single quote. The next
977 character, parity errors and all, is taken as the value
978 of the operand. VERY KINKY. */
979 expressionP->X_op = O_constant;
980 expressionP->X_add_number = *input_line_pointer++;
984 mri_char_constant (expressionP);
989 /* Double quote is the bitwise not operator in MRI mode. */
995 /* '~' is permitted to start a label on the Delta. */
996 if (is_name_beginner (c))
1005 operand (expressionP, mode);
1006 if (expressionP->X_op == O_constant)
1008 /* input_line_pointer -> char after operand. */
1011 expressionP->X_add_number
1012 = - (addressT) expressionP->X_add_number;
1013 /* Notice: '-' may overflow: no warning is given.
1014 This is compatible with other people's
1015 assemblers. Sigh. */
1016 expressionP->X_unsigned = 0;
1017 if (expressionP->X_add_number)
1018 expressionP->X_extrabit ^= 1;
1020 else if (c == '~' || c == '"')
1021 expressionP->X_add_number = ~ expressionP->X_add_number;
1023 expressionP->X_add_number = ! expressionP->X_add_number;
1025 else if (expressionP->X_op == O_big
1026 && expressionP->X_add_number <= 0
1028 && (generic_floating_point_number.sign == '+'
1029 || generic_floating_point_number.sign == 'P'))
1031 /* Negative flonum (eg, -1.000e0). */
1032 if (generic_floating_point_number.sign == '+')
1033 generic_floating_point_number.sign = '-';
1035 generic_floating_point_number.sign = 'N';
1037 else if (expressionP->X_op == O_big
1038 && expressionP->X_add_number > 0)
1042 if (c == '~' || c == '-')
1044 for (i = 0; i < expressionP->X_add_number; ++i)
1045 generic_bignum[i] = ~generic_bignum[i];
1047 /* Extend the bignum to at least the size of .octa. */
1048 if (expressionP->X_add_number < SIZE_OF_LARGE_NUMBER)
1050 expressionP->X_add_number = SIZE_OF_LARGE_NUMBER;
1051 for (; i < expressionP->X_add_number; ++i)
1052 generic_bignum[i] = ~(LITTLENUM_TYPE) 0;
1056 for (i = 0; i < expressionP->X_add_number; ++i)
1058 generic_bignum[i] += 1;
1059 if (generic_bignum[i])
1065 for (i = 0; i < expressionP->X_add_number; ++i)
1066 if (generic_bignum[i] != 0)
1068 expressionP->X_add_number = i >= expressionP->X_add_number;
1069 expressionP->X_op = O_constant;
1070 expressionP->X_unsigned = 1;
1071 expressionP->X_extrabit = 0;
1074 else if (expressionP->X_op != O_illegal
1075 && expressionP->X_op != O_absent)
1079 expressionP->X_add_symbol = make_expr_symbol (expressionP);
1081 expressionP->X_op = O_uminus;
1082 else if (c == '~' || c == '"')
1083 expressionP->X_op = O_bit_not;
1085 expressionP->X_op = O_logical_not;
1086 expressionP->X_add_number = 0;
1090 as_warn (_("Unary operator %c ignored because bad operand follows"),
1095 #if defined (DOLLAR_DOT) || defined (TC_M68K)
1097 /* '$' is the program counter when in MRI mode, or when
1098 DOLLAR_DOT is defined. */
1100 if (! flag_m68k_mri)
1103 if (DOLLAR_AMBIGU && hex_p (*input_line_pointer))
1105 /* In MRI mode and on Z80, '$' is also used as the prefix
1106 for a hexadecimal constant. */
1107 integer_constant (16, expressionP);
1111 if (is_part_of_name (*input_line_pointer))
1114 current_location (expressionP);
1119 if (!is_part_of_name (*input_line_pointer))
1121 current_location (expressionP);
1124 else if ((strncasecmp (input_line_pointer, "startof.", 8) == 0
1125 && ! is_part_of_name (input_line_pointer[8]))
1126 || (strncasecmp (input_line_pointer, "sizeof.", 7) == 0
1127 && ! is_part_of_name (input_line_pointer[7])))
1131 start = (input_line_pointer[1] == 't'
1132 || input_line_pointer[1] == 'T');
1133 input_line_pointer += start ? 8 : 7;
1135 if (*input_line_pointer != '(')
1136 as_bad (_("syntax error in .startof. or .sizeof."));
1141 ++input_line_pointer;
1143 c = get_symbol_name (& name);
1145 buf = (char *) xmalloc (strlen (name) + 10);
1147 sprintf (buf, ".startof.%s", name);
1149 sprintf (buf, ".sizeof.%s", name);
1150 symbolP = symbol_make (buf);
1153 expressionP->X_op = O_symbol;
1154 expressionP->X_add_symbol = symbolP;
1155 expressionP->X_add_number = 0;
1157 *input_line_pointer = c;
1158 SKIP_WHITESPACE_AFTER_NAME ();
1159 if (*input_line_pointer != ')')
1160 as_bad (_("syntax error in .startof. or .sizeof."));
1162 ++input_line_pointer;
1173 /* Can't imagine any other kind of operand. */
1174 expressionP->X_op = O_absent;
1175 input_line_pointer--;
1180 if (! flag_m68k_mri)
1182 integer_constant (2, expressionP);
1186 if (! flag_m68k_mri)
1188 integer_constant (8, expressionP);
1192 if (! flag_m68k_mri)
1195 /* In MRI mode, this is a floating point constant represented
1196 using hexadecimal digits. */
1198 ++input_line_pointer;
1199 integer_constant (16, expressionP);
1203 if (! flag_m68k_mri || is_part_of_name (*input_line_pointer))
1206 current_location (expressionP);
1211 #if defined(md_need_index_operator) || defined(TC_M68K)
1214 if (is_name_beginner (c) || c == '"') /* Here if did not begin with a digit. */
1216 /* Identifier begins here.
1217 This is kludged for speed, so code is repeated. */
1219 -- input_line_pointer;
1220 c = get_symbol_name (&name);
1224 operatorT op = md_operator (name, 1, &c);
1229 restore_line_pointer (c);
1233 restore_line_pointer (c);
1237 restore_line_pointer (c);
1241 as_bad (_("invalid use of operator \"%s\""), name);
1247 if (op != O_absent && op != O_illegal)
1249 restore_line_pointer (c);
1250 expr (9, expressionP, mode);
1251 expressionP->X_add_symbol = make_expr_symbol (expressionP);
1252 expressionP->X_op_symbol = NULL;
1253 expressionP->X_add_number = 0;
1254 expressionP->X_op = op;
1260 #ifdef md_parse_name
1261 /* This is a hook for the backend to parse certain names
1262 specially in certain contexts. If a name always has a
1263 specific value, it can often be handled by simply
1264 entering it in the symbol table. */
1265 if (md_parse_name (name, expressionP, mode, &c))
1267 restore_line_pointer (c);
1273 /* The MRI i960 assembler permits
1275 FIXME: This should use md_parse_name. */
1277 && (strcasecmp (name, "sizeof") == 0
1278 || strcasecmp (name, "startof") == 0))
1283 start = (name[1] == 't'
1286 *input_line_pointer = c;
1287 SKIP_WHITESPACE_AFTER_NAME ();
1289 c = get_symbol_name (& name);
1291 buf = (char *) xmalloc (strlen (name) + 10);
1293 sprintf (buf, ".startof.%s", name);
1295 sprintf (buf, ".sizeof.%s", name);
1296 symbolP = symbol_make (buf);
1299 expressionP->X_op = O_symbol;
1300 expressionP->X_add_symbol = symbolP;
1301 expressionP->X_add_number = 0;
1303 *input_line_pointer = c;
1304 SKIP_WHITESPACE_AFTER_NAME ();
1309 symbolP = symbol_find_or_make (name);
1311 /* If we have an absolute symbol or a reg, then we know its
1313 segment = S_GET_SEGMENT (symbolP);
1314 if (mode != expr_defer
1315 && segment == absolute_section
1316 && !S_FORCE_RELOC (symbolP, 0))
1318 expressionP->X_op = O_constant;
1319 expressionP->X_add_number = S_GET_VALUE (symbolP);
1321 else if (mode != expr_defer && segment == reg_section)
1323 expressionP->X_op = O_register;
1324 expressionP->X_add_number = S_GET_VALUE (symbolP);
1328 expressionP->X_op = O_symbol;
1329 expressionP->X_add_symbol = symbolP;
1330 expressionP->X_add_number = 0;
1333 restore_line_pointer (c);
1337 /* Let the target try to parse it. Success is indicated by changing
1338 the X_op field to something other than O_absent and pointing
1339 input_line_pointer past the expression. If it can't parse the
1340 expression, X_op and input_line_pointer should be unchanged. */
1341 expressionP->X_op = O_absent;
1342 --input_line_pointer;
1343 md_operand (expressionP);
1344 if (expressionP->X_op == O_absent)
1346 ++input_line_pointer;
1347 as_bad (_("bad expression"));
1348 expressionP->X_op = O_constant;
1349 expressionP->X_add_number = 0;
1355 /* It is more 'efficient' to clean up the expressionS when they are
1356 created. Doing it here saves lines of code. */
1357 clean_up_expression (expressionP);
1358 SKIP_WHITESPACE (); /* -> 1st char after operand. */
1359 know (*input_line_pointer != ' ');
1361 /* The PA port needs this information. */
1362 if (expressionP->X_add_symbol)
1363 symbol_mark_used (expressionP->X_add_symbol);
1365 if (mode != expr_defer)
1367 expressionP->X_add_symbol
1368 = symbol_clone_if_forward_ref (expressionP->X_add_symbol);
1369 expressionP->X_op_symbol
1370 = symbol_clone_if_forward_ref (expressionP->X_op_symbol);
1373 switch (expressionP->X_op)
1376 return absolute_section;
1378 return S_GET_SEGMENT (expressionP->X_add_symbol);
1384 /* Internal. Simplify a struct expression for use by expr (). */
1386 /* In: address of an expressionS.
1387 The X_op field of the expressionS may only take certain values.
1388 Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
1390 Out: expressionS may have been modified:
1391 Unused fields zeroed to help expr (). */
1394 clean_up_expression (expressionS *expressionP)
1396 switch (expressionP->X_op)
1400 expressionP->X_add_number = 0;
1405 expressionP->X_add_symbol = NULL;
1410 expressionP->X_op_symbol = NULL;
1417 /* Expression parser. */
1419 /* We allow an empty expression, and just assume (absolute,0) silently.
1420 Unary operators and parenthetical expressions are treated as operands.
1421 As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
1423 We used to do an aho/ullman shift-reduce parser, but the logic got so
1424 warped that I flushed it and wrote a recursive-descent parser instead.
1425 Now things are stable, would anybody like to write a fast parser?
1426 Most expressions are either register (which does not even reach here)
1427 or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
1428 So I guess it doesn't really matter how inefficient more complex expressions
1431 After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
1432 Also, we have consumed any leading or trailing spaces (operand does that)
1433 and done all intervening operators.
1435 This returns the segment of the result, which will be
1436 absolute_section or the segment of a symbol. */
1439 #define __ O_illegal
1441 #define O_SINGLE_EQ O_illegal
1444 /* Maps ASCII -> operators. */
1445 static const operatorT op_encoding[256] = {
1446 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1447 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1449 __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __,
1450 __, __, O_multiply, O_add, __, O_subtract, __, O_divide,
1451 __, __, __, __, __, __, __, __,
1452 __, __, __, __, O_lt, O_SINGLE_EQ, O_gt, __,
1453 __, __, __, __, __, __, __, __,
1454 __, __, __, __, __, __, __, __,
1455 __, __, __, __, __, __, __, __,
1457 #ifdef NEED_INDEX_OPERATOR
1462 __, __, O_bit_exclusive_or, __,
1463 __, __, __, __, __, __, __, __,
1464 __, __, __, __, __, __, __, __,
1465 __, __, __, __, __, __, __, __,
1466 __, __, __, __, O_bit_inclusive_or, __, __, __,
1468 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1469 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1470 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1471 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1472 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1473 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1474 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1475 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
1479 0 operand, (expression)
1484 5 used for * / % in MRI mode
1489 static operator_rankT op_rank[O_max] = {
1494 0, /* O_symbol_rva */
1499 9, /* O_logical_not */
1503 8, /* O_left_shift */
1504 8, /* O_right_shift */
1505 7, /* O_bit_inclusive_or */
1506 7, /* O_bit_or_not */
1507 7, /* O_bit_exclusive_or */
1517 3, /* O_logical_and */
1518 2, /* O_logical_or */
1522 /* Unfortunately, in MRI mode for the m68k, multiplication and
1523 division have lower precedence than the bit wise operators. This
1524 function sets the operator precedences correctly for the current
1525 mode. Also, MRI uses a different bit_not operator, and this fixes
1528 #define STANDARD_MUL_PRECEDENCE 8
1529 #define MRI_MUL_PRECEDENCE 6
1532 expr_set_precedence (void)
1536 op_rank[O_multiply] = MRI_MUL_PRECEDENCE;
1537 op_rank[O_divide] = MRI_MUL_PRECEDENCE;
1538 op_rank[O_modulus] = MRI_MUL_PRECEDENCE;
1542 op_rank[O_multiply] = STANDARD_MUL_PRECEDENCE;
1543 op_rank[O_divide] = STANDARD_MUL_PRECEDENCE;
1544 op_rank[O_modulus] = STANDARD_MUL_PRECEDENCE;
1549 expr_set_rank (operatorT op, operator_rankT rank)
1551 gas_assert (op >= O_md1 && op < ARRAY_SIZE (op_rank));
1555 /* Initialize the expression parser. */
1560 expr_set_precedence ();
1562 /* Verify that X_op field is wide enough. */
1566 gas_assert (e.X_op == O_max);
1570 /* Return the encoding for the operator at INPUT_LINE_POINTER, and
1571 sets NUM_CHARS to the number of characters in the operator.
1572 Does not advance INPUT_LINE_POINTER. */
1574 static inline operatorT
1575 operatorf (int *num_chars)
1580 c = *input_line_pointer & 0xff;
1583 if (is_end_of_line[c])
1587 if (is_name_beginner (c))
1590 char ec = get_symbol_name (& name);
1592 ret = md_operator (name, 2, &ec);
1596 *input_line_pointer = ec;
1597 input_line_pointer = name;
1602 as_bad (_("invalid use of operator \"%s\""), name);
1606 *input_line_pointer = ec;
1607 *num_chars = input_line_pointer - name;
1608 input_line_pointer = name;
1617 ret = op_encoding[c];
1619 if (ret == O_illegal)
1621 char *start = input_line_pointer;
1623 ret = md_operator (NULL, 2, NULL);
1624 if (ret != O_illegal)
1625 *num_chars = input_line_pointer - start;
1626 input_line_pointer = start;
1633 return op_encoding[c];
1636 switch (input_line_pointer[1])
1639 return op_encoding[c];
1654 if (input_line_pointer[1] != '=')
1655 return op_encoding[c];
1661 switch (input_line_pointer[1])
1664 return op_encoding[c];
1666 ret = O_right_shift;
1676 switch (input_line_pointer[1])
1679 /* We accept !! as equivalent to ^ for MRI compatibility. */
1681 return O_bit_exclusive_or;
1683 /* We accept != as equivalent to <>. */
1688 return O_bit_inclusive_or;
1689 return op_encoding[c];
1693 if (input_line_pointer[1] != '|')
1694 return op_encoding[c];
1697 return O_logical_or;
1700 if (input_line_pointer[1] != '&')
1701 return op_encoding[c];
1704 return O_logical_and;
1710 /* Implement "word-size + 1 bit" addition for
1711 {resultP->X_extrabit:resultP->X_add_number} + {rhs_highbit:amount}. This
1712 is used so that the full range of unsigned word values and the full range of
1713 signed word values can be represented in an O_constant expression, which is
1714 useful e.g. for .sleb128 directives. */
1717 add_to_result (expressionS *resultP, offsetT amount, int rhs_highbit)
1719 valueT ures = resultP->X_add_number;
1720 valueT uamount = amount;
1722 resultP->X_add_number += amount;
1724 resultP->X_extrabit ^= rhs_highbit;
1726 if (ures + uamount < ures)
1727 resultP->X_extrabit ^= 1;
1730 /* Similarly, for subtraction. */
1733 subtract_from_result (expressionS *resultP, offsetT amount, int rhs_highbit)
1735 valueT ures = resultP->X_add_number;
1736 valueT uamount = amount;
1738 resultP->X_add_number -= amount;
1740 resultP->X_extrabit ^= rhs_highbit;
1743 resultP->X_extrabit ^= 1;
1746 /* Parse an expression. */
1749 expr (int rankarg, /* Larger # is higher rank. */
1750 expressionS *resultP, /* Deliver result here. */
1751 enum expr_mode mode /* Controls behavior. */)
1753 operator_rankT rank = (operator_rankT) rankarg;
1760 know (rankarg >= 0);
1762 /* Save the value of dot for the fixup code. */
1765 dot_value = frag_now_fix ();
1766 dot_frag = frag_now;
1769 retval = operand (resultP, mode);
1771 /* operand () gobbles spaces. */
1772 know (*input_line_pointer != ' ');
1774 op_left = operatorf (&op_chars);
1775 while (op_left != O_illegal && op_rank[(int) op_left] > rank)
1780 input_line_pointer += op_chars; /* -> after operator. */
1783 rightseg = expr (op_rank[(int) op_left], &right, mode);
1784 if (right.X_op == O_absent)
1786 as_warn (_("missing operand; zero assumed"));
1787 right.X_op = O_constant;
1788 right.X_add_number = 0;
1789 right.X_add_symbol = NULL;
1790 right.X_op_symbol = NULL;
1793 know (*input_line_pointer != ' ');
1795 if (op_left == O_index)
1797 if (*input_line_pointer != ']')
1798 as_bad ("missing right bracket");
1801 ++input_line_pointer;
1806 op_right = operatorf (&op_chars);
1808 know (op_right == O_illegal || op_left == O_index
1809 || op_rank[(int) op_right] <= op_rank[(int) op_left]);
1810 know ((int) op_left >= (int) O_multiply);
1812 know ((int) op_left <= (int) O_index);
1814 know ((int) op_left < (int) O_max);
1817 /* input_line_pointer->after right-hand quantity. */
1818 /* left-hand quantity in resultP. */
1819 /* right-hand quantity in right. */
1820 /* operator in op_left. */
1822 if (resultP->X_op == O_big)
1824 if (resultP->X_add_number > 0)
1825 as_warn (_("left operand is a bignum; integer 0 assumed"));
1827 as_warn (_("left operand is a float; integer 0 assumed"));
1828 resultP->X_op = O_constant;
1829 resultP->X_add_number = 0;
1830 resultP->X_add_symbol = NULL;
1831 resultP->X_op_symbol = NULL;
1833 if (right.X_op == O_big)
1835 if (right.X_add_number > 0)
1836 as_warn (_("right operand is a bignum; integer 0 assumed"));
1838 as_warn (_("right operand is a float; integer 0 assumed"));
1839 right.X_op = O_constant;
1840 right.X_add_number = 0;
1841 right.X_add_symbol = NULL;
1842 right.X_op_symbol = NULL;
1845 /* Optimize common cases. */
1846 #ifdef md_optimize_expr
1847 if (md_optimize_expr (resultP, op_left, &right))
1854 #ifndef md_register_arithmetic
1855 # define md_register_arithmetic 1
1857 if (op_left == O_add && right.X_op == O_constant
1858 && (md_register_arithmetic || resultP->X_op != O_register))
1861 add_to_result (resultP, right.X_add_number, right.X_extrabit);
1863 /* This case comes up in PIC code. */
1864 else if (op_left == O_subtract
1865 && right.X_op == O_symbol
1866 && resultP->X_op == O_symbol
1867 && retval == rightseg
1868 #ifdef md_allow_local_subtract
1869 && md_allow_local_subtract (resultP, & right, rightseg)
1871 && ((SEG_NORMAL (rightseg)
1872 && !S_FORCE_RELOC (resultP->X_add_symbol, 0)
1873 && !S_FORCE_RELOC (right.X_add_symbol, 0))
1874 || right.X_add_symbol == resultP->X_add_symbol)
1875 && frag_offset_fixed_p (symbol_get_frag (resultP->X_add_symbol),
1876 symbol_get_frag (right.X_add_symbol),
1879 offsetT symval_diff = S_GET_VALUE (resultP->X_add_symbol)
1880 - S_GET_VALUE (right.X_add_symbol);
1881 subtract_from_result (resultP, right.X_add_number, right.X_extrabit);
1882 subtract_from_result (resultP, frag_off / OCTETS_PER_BYTE, 0);
1883 add_to_result (resultP, symval_diff, symval_diff < 0);
1884 resultP->X_op = O_constant;
1885 resultP->X_add_symbol = 0;
1887 else if (op_left == O_subtract && right.X_op == O_constant
1888 && (md_register_arithmetic || resultP->X_op != O_register))
1891 subtract_from_result (resultP, right.X_add_number, right.X_extrabit);
1893 else if (op_left == O_add && resultP->X_op == O_constant
1894 && (md_register_arithmetic || right.X_op != O_register))
1897 resultP->X_op = right.X_op;
1898 resultP->X_add_symbol = right.X_add_symbol;
1899 resultP->X_op_symbol = right.X_op_symbol;
1900 add_to_result (resultP, right.X_add_number, right.X_extrabit);
1903 else if (resultP->X_op == O_constant && right.X_op == O_constant)
1905 /* Constant OP constant. */
1906 offsetT v = right.X_add_number;
1907 if (v == 0 && (op_left == O_divide || op_left == O_modulus))
1909 as_warn (_("division by zero"));
1912 if ((valueT) v >= sizeof(valueT) * CHAR_BIT
1913 && (op_left == O_left_shift || op_left == O_right_shift))
1915 as_warn_value_out_of_range (_("shift count"), v, 0,
1916 sizeof(valueT) * CHAR_BIT - 1,
1918 resultP->X_add_number = v = 0;
1922 default: goto general;
1923 case O_multiply: resultP->X_add_number *= v; break;
1924 case O_divide: resultP->X_add_number /= v; break;
1925 case O_modulus: resultP->X_add_number %= v; break;
1926 case O_left_shift: resultP->X_add_number <<= v; break;
1928 /* We always use unsigned shifts, to avoid relying on
1929 characteristics of the compiler used to compile gas. */
1930 resultP->X_add_number =
1931 (offsetT) ((valueT) resultP->X_add_number >> (valueT) v);
1933 case O_bit_inclusive_or: resultP->X_add_number |= v; break;
1934 case O_bit_or_not: resultP->X_add_number |= ~v; break;
1935 case O_bit_exclusive_or: resultP->X_add_number ^= v; break;
1936 case O_bit_and: resultP->X_add_number &= v; break;
1937 /* Constant + constant (O_add) is handled by the
1938 previous if statement for constant + X, so is omitted
1941 subtract_from_result (resultP, v, 0);
1944 resultP->X_add_number =
1945 resultP->X_add_number == v ? ~ (offsetT) 0 : 0;
1948 resultP->X_add_number =
1949 resultP->X_add_number != v ? ~ (offsetT) 0 : 0;
1952 resultP->X_add_number =
1953 resultP->X_add_number < v ? ~ (offsetT) 0 : 0;
1956 resultP->X_add_number =
1957 resultP->X_add_number <= v ? ~ (offsetT) 0 : 0;
1960 resultP->X_add_number =
1961 resultP->X_add_number >= v ? ~ (offsetT) 0 : 0;
1964 resultP->X_add_number =
1965 resultP->X_add_number > v ? ~ (offsetT) 0 : 0;
1968 resultP->X_add_number = resultP->X_add_number && v;
1971 resultP->X_add_number = resultP->X_add_number || v;
1975 else if (resultP->X_op == O_symbol
1976 && right.X_op == O_symbol
1977 && (op_left == O_add
1978 || op_left == O_subtract
1979 || (resultP->X_add_number == 0
1980 && right.X_add_number == 0)))
1982 /* Symbol OP symbol. */
1983 resultP->X_op = op_left;
1984 resultP->X_op_symbol = right.X_add_symbol;
1985 if (op_left == O_add)
1986 add_to_result (resultP, right.X_add_number, right.X_extrabit);
1987 else if (op_left == O_subtract)
1989 subtract_from_result (resultP, right.X_add_number,
1991 if (retval == rightseg
1992 && SEG_NORMAL (retval)
1993 && !S_FORCE_RELOC (resultP->X_add_symbol, 0)
1994 && !S_FORCE_RELOC (right.X_add_symbol, 0))
1996 retval = absolute_section;
1997 rightseg = absolute_section;
2004 /* The general case. */
2005 resultP->X_add_symbol = make_expr_symbol (resultP);
2006 resultP->X_op_symbol = make_expr_symbol (&right);
2007 resultP->X_op = op_left;
2008 resultP->X_add_number = 0;
2009 resultP->X_unsigned = 1;
2010 resultP->X_extrabit = 0;
2013 if (retval != rightseg)
2015 if (retval == undefined_section)
2017 else if (rightseg == undefined_section)
2019 else if (retval == expr_section)
2021 else if (rightseg == expr_section)
2023 else if (retval == reg_section)
2025 else if (rightseg == reg_section)
2027 else if (rightseg == absolute_section)
2029 else if (retval == absolute_section)
2032 else if (op_left == O_subtract)
2036 as_bad (_("operation combines symbols in different segments"));
2040 } /* While next operator is >= this rank. */
2042 /* The PA port needs this information. */
2043 if (resultP->X_add_symbol)
2044 symbol_mark_used (resultP->X_add_symbol);
2046 if (rank == 0 && mode == expr_evaluate)
2047 resolve_expression (resultP);
2049 return resultP->X_op == O_constant ? absolute_section : retval;
2052 /* Resolve an expression without changing any symbols/sub-expressions
2056 resolve_expression (expressionS *expressionP)
2058 /* Help out with CSE. */
2059 valueT final_val = expressionP->X_add_number;
2060 symbolS *add_symbol = expressionP->X_add_symbol;
2061 symbolS *orig_add_symbol = add_symbol;
2062 symbolS *op_symbol = expressionP->X_op_symbol;
2063 operatorT op = expressionP->X_op;
2065 segT seg_left, seg_right;
2066 fragS *frag_left, *frag_right;
2081 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left))
2089 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left))
2092 if (seg_left != absolute_section)
2095 if (op == O_logical_not)
2097 else if (op == O_uminus)
2109 case O_bit_inclusive_or:
2111 case O_bit_exclusive_or:
2123 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left)
2124 || !snapshot_symbol (&op_symbol, &right, &seg_right, &frag_right))
2127 /* Simplify addition or subtraction of a constant by folding the
2128 constant into X_add_number. */
2131 if (seg_right == absolute_section)
2137 else if (seg_left == absolute_section)
2141 seg_left = seg_right;
2142 add_symbol = op_symbol;
2143 orig_add_symbol = expressionP->X_op_symbol;
2148 else if (op == O_subtract)
2150 if (seg_right == absolute_section)
2158 /* Equality and non-equality tests are permitted on anything.
2159 Subtraction, and other comparison operators are permitted if
2160 both operands are in the same section.
2161 Shifts by constant zero are permitted on anything.
2162 Multiplies, bit-ors, and bit-ands with constant zero are
2163 permitted on anything.
2164 Multiplies and divides by constant one are permitted on
2166 Binary operations with both operands being the same register
2167 or undefined symbol are permitted if the result doesn't depend
2169 Otherwise, both operands must be absolute. We already handled
2170 the case of addition or subtraction of a constant above. */
2172 if (!(seg_left == absolute_section
2173 && seg_right == absolute_section)
2174 && !(op == O_eq || op == O_ne)
2175 && !((op == O_subtract
2176 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
2177 && seg_left == seg_right
2179 || frag_offset_fixed_p (frag_left, frag_right, &frag_off))
2180 && (seg_left != reg_section || left == right)
2181 && (seg_left != undefined_section || add_symbol == op_symbol)))
2183 if ((seg_left == absolute_section && left == 0)
2184 || (seg_right == absolute_section && right == 0))
2186 if (op == O_bit_exclusive_or || op == O_bit_inclusive_or)
2188 if (!(seg_right == absolute_section && right == 0))
2190 seg_left = seg_right;
2192 add_symbol = op_symbol;
2193 orig_add_symbol = expressionP->X_op_symbol;
2198 else if (op == O_left_shift || op == O_right_shift)
2200 if (!(seg_left == absolute_section && left == 0))
2206 else if (op != O_multiply
2207 && op != O_bit_or_not && op != O_bit_and)
2210 else if (op == O_multiply
2211 && seg_left == absolute_section && left == 1)
2213 seg_left = seg_right;
2215 add_symbol = op_symbol;
2216 orig_add_symbol = expressionP->X_op_symbol;
2220 else if ((op == O_multiply || op == O_divide)
2221 && seg_right == absolute_section && right == 1)
2226 else if (!(left == right
2227 && ((seg_left == reg_section && seg_right == reg_section)
2228 || (seg_left == undefined_section
2229 && seg_right == undefined_section
2230 && add_symbol == op_symbol))))
2232 else if (op == O_bit_and || op == O_bit_inclusive_or)
2237 else if (op != O_bit_exclusive_or && op != O_bit_or_not)
2241 right += frag_off / OCTETS_PER_BYTE;
2244 case O_add: left += right; break;
2245 case O_subtract: left -= right; break;
2246 case O_multiply: left *= right; break;
2250 left = (offsetT) left / (offsetT) right;
2255 left = (offsetT) left % (offsetT) right;
2257 case O_left_shift: left <<= right; break;
2258 case O_right_shift: left >>= right; break;
2259 case O_bit_inclusive_or: left |= right; break;
2260 case O_bit_or_not: left |= ~right; break;
2261 case O_bit_exclusive_or: left ^= right; break;
2262 case O_bit_and: left &= right; break;
2265 left = (left == right
2266 && seg_left == seg_right
2267 && (finalize_syms || frag_left == frag_right)
2268 && (seg_left != undefined_section
2269 || add_symbol == op_symbol)
2270 ? ~ (valueT) 0 : 0);
2275 left = (offsetT) left < (offsetT) right ? ~ (valueT) 0 : 0;
2278 left = (offsetT) left <= (offsetT) right ? ~ (valueT) 0 : 0;
2281 left = (offsetT) left >= (offsetT) right ? ~ (valueT) 0 : 0;
2284 left = (offsetT) left > (offsetT) right ? ~ (valueT) 0 : 0;
2286 case O_logical_and: left = left && right; break;
2287 case O_logical_or: left = left || right; break;
2297 if (seg_left == absolute_section)
2299 else if (seg_left == reg_section && final_val == 0)
2301 else if (!symbol_same_p (add_symbol, orig_add_symbol))
2303 expressionP->X_add_symbol = add_symbol;
2305 expressionP->X_op = op;
2307 if (op == O_constant || op == O_register)
2309 expressionP->X_add_number = final_val;
2314 /* This lives here because it belongs equally in expr.c & read.c.
2315 expr.c is just a branch office read.c anyway, and putting it
2316 here lessens the crowd at read.c.
2318 Assume input_line_pointer is at start of symbol name, or the
2319 start of a double quote enclosed symbol name.
2320 Advance input_line_pointer past symbol name.
2321 Turn that character into a '\0', returning its former value,
2322 which may be the closing double quote.
2323 This allows a string compare (RMS wants symbol names to be strings)
2325 There will always be a char following symbol name, because all good
2326 lines end in end-of-line. */
2329 get_symbol_name (char ** ilp_return)
2333 * ilp_return = input_line_pointer;
2334 /* We accept \001 in a name in case this is being called with a
2335 constructed string. */
2336 if (is_name_beginner (c = *input_line_pointer++) || c == '\001')
2338 while (is_part_of_name (c = *input_line_pointer++)
2341 if (is_name_ender (c))
2342 c = *input_line_pointer++;
2346 bfd_boolean backslash_seen;
2348 * ilp_return = input_line_pointer;
2351 backslash_seen = c == '\\';
2352 c = * input_line_pointer ++;
2354 while (c != 0 && (c != '"' || backslash_seen));
2357 as_warn (_("missing closing '\"'"));
2359 *--input_line_pointer = 0;
2363 /* Replace the NUL character pointed to by input_line_pointer
2364 with C. If C is \" then advance past it. Return the character
2365 now pointed to by input_line_pointer. */
2368 restore_line_pointer (char c)
2370 * input_line_pointer = c;
2372 c = * ++ input_line_pointer;
2377 get_single_number (void)
2380 operand (&exp, expr_normal);
2381 return exp.X_add_number;