1 /* expr.c -operands, expressions-
2 Copyright (C) 1987-2015 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 extern const char EXP_CHARS[], FLT_CHARS[];
51 /* We keep a mapping of expression symbols to file positions, so that
52 we can provide better error messages. */
54 struct expr_symbol_line {
55 struct expr_symbol_line *next;
61 static struct expr_symbol_line *expr_symbol_lines;
63 /* Build a dummy symbol to hold a complex expression. This is how we
64 build expressions up out of other expressions. The symbol is put
65 into the fake section expr_section. */
68 make_expr_symbol (expressionS *expressionP)
72 struct expr_symbol_line *n;
74 if (expressionP->X_op == O_symbol
75 && expressionP->X_add_number == 0)
76 return expressionP->X_add_symbol;
78 if (expressionP->X_op == O_big)
80 /* This won't work, because the actual value is stored in
81 generic_floating_point_number or generic_bignum, and we are
82 going to lose it if we haven't already. */
83 if (expressionP->X_add_number > 0)
84 as_bad (_("bignum invalid"));
86 as_bad (_("floating point number invalid"));
87 zero.X_op = O_constant;
88 zero.X_add_number = 0;
91 clean_up_expression (&zero);
95 /* Putting constant symbols in absolute_section rather than
96 expr_section is convenient for the old a.out code, for which
97 S_GET_SEGMENT does not always retrieve the value put in by
99 symbolP = symbol_create (FAKE_LABEL_NAME,
100 (expressionP->X_op == O_constant
102 : expressionP->X_op == O_register
105 0, &zero_address_frag);
106 symbol_set_value_expression (symbolP, expressionP);
108 if (expressionP->X_op == O_constant)
109 resolve_symbol_value (symbolP);
111 n = (struct expr_symbol_line *) xmalloc (sizeof *n);
113 as_where (&n->file, &n->line);
114 n->next = expr_symbol_lines;
115 expr_symbol_lines = n;
120 /* Return the file and line number for an expr symbol. Return
121 non-zero if something was found, 0 if no information is known for
125 expr_symbol_where (symbolS *sym, char **pfile, unsigned int *pline)
127 struct expr_symbol_line *l;
129 for (l = expr_symbol_lines; l != NULL; l = l->next)
142 /* Utilities for building expressions.
143 Since complex expressions are recorded as symbols for use in other
144 expressions these return a symbolS * and not an expressionS *.
145 These explicitly do not take an "add_number" argument. */
146 /* ??? For completeness' sake one might want expr_build_symbol.
147 It would just return its argument. */
149 /* Build an expression for an unsigned constant.
150 The corresponding one for signed constants is missing because
151 there's currently no need for it. One could add an unsigned_p flag
152 but that seems more clumsy. */
155 expr_build_uconstant (offsetT value)
160 e.X_add_number = value;
163 return make_expr_symbol (&e);
166 /* Build an expression for the current location ('.'). */
169 expr_build_dot (void)
173 current_location (&e);
174 return symbol_clone_if_forward_ref (make_expr_symbol (&e));
177 /* Build any floating-point literal here.
178 Also build any bignum literal here. */
180 /* Seems atof_machine can backscan through generic_bignum and hit whatever
181 happens to be loaded before it in memory. And its way too complicated
182 for me to fix right. Thus a hack. JF: Just make generic_bignum bigger,
183 and never write into the early words, thus they'll always be zero.
184 I hate Dean's floating-point code. Bleh. */
185 LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6];
187 FLONUM_TYPE generic_floating_point_number = {
188 &generic_bignum[6], /* low. (JF: Was 0) */
189 &generic_bignum[SIZE_OF_LARGE_NUMBER + 6 - 1], /* high. JF: (added +6) */
197 floating_constant (expressionS *expressionP)
199 /* input_line_pointer -> floating-point constant. */
202 error_code = atof_generic (&input_line_pointer, ".", EXP_CHARS,
203 &generic_floating_point_number);
207 if (error_code == ERROR_EXPONENT_OVERFLOW)
209 as_bad (_("bad floating-point constant: exponent overflow"));
213 as_bad (_("bad floating-point constant: unknown error code=%d"),
217 expressionP->X_op = O_big;
218 /* input_line_pointer -> just after constant, which may point to
220 expressionP->X_add_number = -1;
224 generic_bignum_to_int32 (void)
227 ((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
228 | (generic_bignum[0] & LITTLENUM_MASK);
229 number &= 0xffffffff;
235 generic_bignum_to_int64 (void)
238 ((((((((valueT) generic_bignum[3] & LITTLENUM_MASK)
239 << LITTLENUM_NUMBER_OF_BITS)
240 | ((valueT) generic_bignum[2] & LITTLENUM_MASK))
241 << LITTLENUM_NUMBER_OF_BITS)
242 | ((valueT) generic_bignum[1] & LITTLENUM_MASK))
243 << LITTLENUM_NUMBER_OF_BITS)
244 | ((valueT) generic_bignum[0] & LITTLENUM_MASK));
250 integer_constant (int radix, expressionS *expressionP)
252 char *start; /* Start of number. */
255 valueT number; /* Offset or (absolute) value. */
256 short int digit; /* Value of next digit in current radix. */
257 short int maxdig = 0; /* Highest permitted digit value. */
258 int too_many_digits = 0; /* If we see >= this number of. */
259 char *name; /* Points to name of symbol. */
260 symbolS *symbolP; /* Points to symbol. */
262 int small; /* True if fits in 32 bits. */
264 /* May be bignum, or may fit in 32 bits. */
265 /* Most numbers fit into 32 bits, and we want this case to be fast.
266 so we pretend it will fit into 32 bits. If, after making up a 32
267 bit number, we realise that we have scanned more digits than
268 comfortably fit into 32 bits, we re-scan the digits coding them
269 into a bignum. For decimal and octal numbers we are
270 conservative: Some numbers may be assumed bignums when in fact
271 they do fit into 32 bits. Numbers of any radix can have excess
272 leading zeros: We strive to recognise this and cast them back
273 into 32 bits. We must check that the bignum really is more than
274 32 bits, and change it back to a 32-bit number if it fits. The
275 number we are looking for is expected to be positive, but if it
276 fits into 32 bits as an unsigned number, we let it be a 32-bit
277 number. The cavalier approach is for speed in ordinary cases. */
278 /* This has been extended for 64 bits. We blindly assume that if
279 you're compiling in 64-bit mode, the target is a 64-bit machine.
280 This should be cleaned up. */
284 #else /* includes non-bfd case, mostly */
288 if (is_end_of_line[(unsigned char) *input_line_pointer])
290 expressionP->X_op = O_absent;
294 if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri) && radix == 0)
298 /* In MRI mode, the number may have a suffix indicating the
299 radix. For that matter, it might actually be a floating
301 for (suffix = input_line_pointer; ISALNUM (*suffix); suffix++)
303 if (*suffix == 'e' || *suffix == 'E')
307 if (suffix == input_line_pointer)
316 /* If we have both NUMBERS_WITH_SUFFIX and LOCAL_LABELS_FB,
317 we distinguish between 'B' and 'b'. This is the case for
319 if ((NUMBERS_WITH_SUFFIX && LOCAL_LABELS_FB ? *suffix : c) == 'B')
323 else if (c == 'O' || c == 'Q')
327 else if (suffix[1] == '.' || c == 'E' || flt)
329 floating_constant (expressionP);
344 too_many_digits = valuesize + 1;
348 too_many_digits = (valuesize + 2) / 3 + 1;
352 too_many_digits = (valuesize + 3) / 4 + 1;
356 too_many_digits = (valuesize + 11) / 4; /* Very rough. */
359 start = input_line_pointer;
360 c = *input_line_pointer++;
362 (digit = hex_value (c)) < maxdig;
363 c = *input_line_pointer++)
365 number = number * radix + digit;
367 /* c contains character after number. */
368 /* input_line_pointer->char after c. */
369 small = (input_line_pointer - start - 1) < too_many_digits;
371 if (radix == 16 && c == '_')
373 /* This is literal of the form 0x333_0_12345678_1.
374 This example is equivalent to 0x00000333000000001234567800000001. */
376 int num_little_digits = 0;
378 input_line_pointer = start; /* -> 1st digit. */
380 know (LITTLENUM_NUMBER_OF_BITS == 16);
382 for (c = '_'; c == '_'; num_little_digits += 2)
385 /* Convert one 64-bit word. */
388 for (c = *input_line_pointer++;
389 (digit = hex_value (c)) < maxdig;
390 c = *(input_line_pointer++))
392 number = number * radix + digit;
396 /* Check for 8 digit per word max. */
398 as_bad (_("a bignum with underscores may not have more than 8 hex digits in any word"));
400 /* Add this chunk to the bignum.
401 Shift things down 2 little digits. */
402 know (LITTLENUM_NUMBER_OF_BITS == 16);
403 for (i = min (num_little_digits + 1, SIZE_OF_LARGE_NUMBER - 1);
406 generic_bignum[i] = generic_bignum[i - 2];
408 /* Add the new digits as the least significant new ones. */
409 generic_bignum[0] = number & 0xffffffff;
410 generic_bignum[1] = number >> 16;
413 /* Again, c is char after number, input_line_pointer->after c. */
415 if (num_little_digits > SIZE_OF_LARGE_NUMBER - 1)
416 num_little_digits = SIZE_OF_LARGE_NUMBER - 1;
418 gas_assert (num_little_digits >= 4);
420 if (num_little_digits != 8)
421 as_bad (_("a bignum with underscores must have exactly 4 words"));
423 /* We might have some leading zeros. These can be trimmed to give
424 us a change to fit this constant into a small number. */
425 while (generic_bignum[num_little_digits - 1] == 0
426 && num_little_digits > 1)
429 if (num_little_digits <= 2)
431 /* will fit into 32 bits. */
432 number = generic_bignum_to_int32 ();
436 else if (num_little_digits <= 4)
438 /* Will fit into 64 bits. */
439 number = generic_bignum_to_int64 ();
447 /* Number of littlenums in the bignum. */
448 number = num_little_digits;
453 /* We saw a lot of digits. manufacture a bignum the hard way. */
454 LITTLENUM_TYPE *leader; /* -> high order littlenum of the bignum. */
455 LITTLENUM_TYPE *pointer; /* -> littlenum we are frobbing now. */
458 leader = generic_bignum;
459 generic_bignum[0] = 0;
460 generic_bignum[1] = 0;
461 generic_bignum[2] = 0;
462 generic_bignum[3] = 0;
463 input_line_pointer = start; /* -> 1st digit. */
464 c = *input_line_pointer++;
465 for (; (carry = hex_value (c)) < maxdig; c = *input_line_pointer++)
467 for (pointer = generic_bignum; pointer <= leader; pointer++)
471 work = carry + radix * *pointer;
472 *pointer = work & LITTLENUM_MASK;
473 carry = work >> LITTLENUM_NUMBER_OF_BITS;
477 if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1)
479 /* Room to grow a longer bignum. */
484 /* Again, c is char after number. */
485 /* input_line_pointer -> after c. */
486 know (LITTLENUM_NUMBER_OF_BITS == 16);
487 if (leader < generic_bignum + 2)
489 /* Will fit into 32 bits. */
490 number = generic_bignum_to_int32 ();
494 else if (leader < generic_bignum + 4)
496 /* Will fit into 64 bits. */
497 number = generic_bignum_to_int64 ();
503 /* Number of littlenums in the bignum. */
504 number = leader - generic_bignum + 1;
508 if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
510 && input_line_pointer - 1 == suffix)
511 c = *input_line_pointer++;
515 /* Here with number, in correct radix. c is the next char.
516 Note that unlike un*x, we allow "011f" "0x9f" to both mean
517 the same as the (conventional) "9f".
518 This is simply easier than checking for strict canonical
521 if (LOCAL_LABELS_FB && c == 'b')
523 /* Backward ref to local label.
524 Because it is backward, expect it to be defined. */
525 /* Construct a local label. */
526 name = fb_label_name ((int) number, 0);
528 /* Seen before, or symbol is defined: OK. */
529 symbolP = symbol_find (name);
530 if ((symbolP != NULL) && (S_IS_DEFINED (symbolP)))
532 /* Local labels are never absolute. Don't waste time
533 checking absoluteness. */
534 know (SEG_NORMAL (S_GET_SEGMENT (symbolP)));
536 expressionP->X_op = O_symbol;
537 expressionP->X_add_symbol = symbolP;
541 /* Either not seen or not defined. */
542 /* @@ Should print out the original string instead of
543 the parsed number. */
544 as_bad (_("backward ref to unknown label \"%d:\""),
546 expressionP->X_op = O_constant;
549 expressionP->X_add_number = 0;
551 else if (LOCAL_LABELS_FB && c == 'f')
553 /* Forward reference. Expect symbol to be undefined or
554 unknown. undefined: seen it before. unknown: never seen
557 Construct a local label name, then an undefined symbol.
558 Don't create a xseg frag for it: caller may do that.
559 Just return it as never seen before. */
560 name = fb_label_name ((int) number, 1);
561 symbolP = symbol_find_or_make (name);
562 /* We have no need to check symbol properties. */
563 #ifndef many_segments
564 /* Since "know" puts its arg into a "string", we
565 can't have newlines in the argument. */
566 know (S_GET_SEGMENT (symbolP) == undefined_section || S_GET_SEGMENT (symbolP) == text_section || S_GET_SEGMENT (symbolP) == data_section);
568 expressionP->X_op = O_symbol;
569 expressionP->X_add_symbol = symbolP;
570 expressionP->X_add_number = 0;
572 else if (LOCAL_LABELS_DOLLAR && c == '$')
574 /* If the dollar label is *currently* defined, then this is just
575 another reference to it. If it is not *currently* defined,
576 then this is a fresh instantiation of that number, so create
579 if (dollar_label_defined ((long) number))
581 name = dollar_label_name ((long) number, 0);
582 symbolP = symbol_find (name);
583 know (symbolP != NULL);
587 name = dollar_label_name ((long) number, 1);
588 symbolP = symbol_find_or_make (name);
591 expressionP->X_op = O_symbol;
592 expressionP->X_add_symbol = symbolP;
593 expressionP->X_add_number = 0;
597 expressionP->X_op = O_constant;
598 expressionP->X_add_number = number;
599 input_line_pointer--; /* Restore following character. */
600 } /* Really just a number. */
604 /* Not a small number. */
605 expressionP->X_op = O_big;
606 expressionP->X_add_number = number; /* Number of littlenums. */
607 input_line_pointer--; /* -> char following number. */
611 /* Parse an MRI multi character constant. */
614 mri_char_constant (expressionS *expressionP)
618 if (*input_line_pointer == '\''
619 && input_line_pointer[1] != '\'')
621 expressionP->X_op = O_constant;
622 expressionP->X_add_number = 0;
626 /* In order to get the correct byte ordering, we must build the
627 number in reverse. */
628 for (i = SIZE_OF_LARGE_NUMBER - 1; i >= 0; i--)
632 generic_bignum[i] = 0;
633 for (j = 0; j < CHARS_PER_LITTLENUM; j++)
635 if (*input_line_pointer == '\'')
637 if (input_line_pointer[1] != '\'')
639 ++input_line_pointer;
641 generic_bignum[i] <<= 8;
642 generic_bignum[i] += *input_line_pointer;
643 ++input_line_pointer;
646 if (i < SIZE_OF_LARGE_NUMBER - 1)
648 /* If there is more than one littlenum, left justify the
649 last one to make it match the earlier ones. If there is
650 only one, we can just use the value directly. */
651 for (; j < CHARS_PER_LITTLENUM; j++)
652 generic_bignum[i] <<= 8;
655 if (*input_line_pointer == '\''
656 && input_line_pointer[1] != '\'')
662 as_bad (_("character constant too large"));
671 c = SIZE_OF_LARGE_NUMBER - i;
672 for (j = 0; j < c; j++)
673 generic_bignum[j] = generic_bignum[i + j];
677 know (LITTLENUM_NUMBER_OF_BITS == 16);
680 expressionP->X_op = O_big;
681 expressionP->X_add_number = i;
685 expressionP->X_op = O_constant;
687 expressionP->X_add_number = generic_bignum[0] & LITTLENUM_MASK;
689 expressionP->X_add_number =
690 (((generic_bignum[1] & LITTLENUM_MASK)
691 << LITTLENUM_NUMBER_OF_BITS)
692 | (generic_bignum[0] & LITTLENUM_MASK));
695 /* Skip the final closing quote. */
696 ++input_line_pointer;
699 /* Return an expression representing the current location. This
700 handles the magic symbol `.'. */
703 current_location (expressionS *expressionp)
705 if (now_seg == absolute_section)
707 expressionp->X_op = O_constant;
708 expressionp->X_add_number = abs_section_offset;
712 expressionp->X_op = O_symbol;
713 expressionp->X_add_symbol = &dot_symbol;
714 expressionp->X_add_number = 0;
718 /* In: Input_line_pointer points to 1st char of operand, which may
722 The operand may have been empty: in this case X_op == O_absent.
723 Input_line_pointer->(next non-blank) char after operand. */
726 operand (expressionS *expressionP, enum expr_mode mode)
729 symbolS *symbolP; /* Points to symbol. */
730 char *name; /* Points to name of symbol. */
733 /* All integers are regarded as unsigned unless they are negated.
734 This is because the only thing which cares whether a number is
735 unsigned is the code in emit_expr which extends constants into
736 bignums. It should only sign extend negative numbers, so that
737 something like ``.quad 0x80000000'' is not sign extended even
738 though it appears negative if valueT is 32 bits. */
739 expressionP->X_unsigned = 1;
740 expressionP->X_extrabit = 0;
742 /* Digits, assume it is a bignum. */
744 SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
745 c = *input_line_pointer++; /* input_line_pointer -> past char in c. */
747 if (is_end_of_line[(unsigned char) c])
761 input_line_pointer--;
763 integer_constant ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
768 #ifdef LITERAL_PREFIXDOLLAR_HEX
770 /* $L is the start of a local label, not a hex constant. */
771 if (* input_line_pointer == 'L')
773 integer_constant (16, expressionP);
777 #ifdef LITERAL_PREFIXPERCENT_BIN
779 integer_constant (2, expressionP);
784 /* Non-decimal radix. */
786 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
790 /* Check for a hex or float constant. */
791 for (s = input_line_pointer; hex_p (*s); s++)
793 if (*s == 'h' || *s == 'H' || *input_line_pointer == '.')
795 --input_line_pointer;
796 integer_constant (0, expressionP);
800 c = *input_line_pointer;
809 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
811 integer_constant (0, expressionP);
817 if (c && strchr (FLT_CHARS, c))
819 input_line_pointer++;
820 floating_constant (expressionP);
821 expressionP->X_add_number = - TOLOWER (c);
825 /* The string was only zero. */
826 expressionP->X_op = O_constant;
827 expressionP->X_add_number = 0;
836 input_line_pointer++;
837 integer_constant (16, expressionP);
841 if (LOCAL_LABELS_FB && !flag_m68k_mri
842 && input_line_pointer[1] != '0'
843 && input_line_pointer[1] != '1')
845 /* Parse this as a back reference to label 0. */
846 input_line_pointer--;
847 integer_constant (10, expressionP);
850 /* Otherwise, parse this as a binary number. */
853 if (input_line_pointer[1] == '0'
854 || input_line_pointer[1] == '1')
856 input_line_pointer++;
857 integer_constant (2, expressionP);
860 if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
861 input_line_pointer++;
872 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 (!input_line_pointer[1]
884 || (is_end_of_line[0xff & input_line_pointer[1]])
885 || strchr (FLT_CHARS, 'f') == NULL)
888 char *cp = input_line_pointer + 1;
889 int r = atof_generic (&cp, ".", EXP_CHARS,
890 &generic_floating_point_number);
894 case ERROR_EXPONENT_OVERFLOW:
895 if (*cp == 'f' || *cp == 'b')
896 /* Looks like a difference expression. */
898 else if (cp == input_line_pointer + 1)
899 /* No characters has been accepted -- looks like
905 as_fatal (_("expr.c(operand): bad atof_generic return val %d"),
910 /* Okay, now we've sorted it out. We resume at one of these
911 two labels, depending on what we've decided we're probably
914 input_line_pointer--;
915 integer_constant (10, expressionP);
925 if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
927 integer_constant (0, expressionP);
937 input_line_pointer++;
938 floating_constant (expressionP);
939 expressionP->X_add_number = - TOLOWER (c);
943 if (LOCAL_LABELS_DOLLAR)
945 integer_constant (10, expressionP);
954 #ifndef NEED_INDEX_OPERATOR
956 # ifdef md_need_index_operator
957 if (md_need_index_operator())
963 /* Didn't begin with digit & not a name. */
964 segment = expr (0, expressionP, mode);
965 /* expression () will pass trailing whitespace. */
966 if ((c == '(' && *input_line_pointer != ')')
967 || (c == '[' && *input_line_pointer != ']'))
968 as_bad (_("missing '%c'"), c == '(' ? ')' : ']');
970 input_line_pointer++;
972 /* Here with input_line_pointer -> char after "(...)". */
977 if (! flag_m68k_mri || *input_line_pointer != '\'')
979 as_bad (_("EBCDIC constants are not supported"));
982 if (! flag_m68k_mri || *input_line_pointer != '\'')
984 ++input_line_pointer;
990 /* Warning: to conform to other people's assemblers NO
991 ESCAPEMENT is permitted for a single quote. The next
992 character, parity errors and all, is taken as the value
993 of the operand. VERY KINKY. */
994 expressionP->X_op = O_constant;
995 expressionP->X_add_number = *input_line_pointer++;
999 mri_char_constant (expressionP);
1004 /* Double quote is the bitwise not operator in MRI mode. */
1005 if (! flag_m68k_mri)
1010 /* '~' is permitted to start a label on the Delta. */
1011 if (is_name_beginner (c))
1020 operand (expressionP, mode);
1021 if (expressionP->X_op == O_constant)
1023 /* input_line_pointer -> char after operand. */
1026 expressionP->X_add_number
1027 = - (addressT) expressionP->X_add_number;
1028 /* Notice: '-' may overflow: no warning is given.
1029 This is compatible with other people's
1030 assemblers. Sigh. */
1031 expressionP->X_unsigned = 0;
1032 if (expressionP->X_add_number)
1033 expressionP->X_extrabit ^= 1;
1035 else if (c == '~' || c == '"')
1036 expressionP->X_add_number = ~ expressionP->X_add_number;
1038 expressionP->X_add_number = ! expressionP->X_add_number;
1040 else if (expressionP->X_op == O_big
1041 && expressionP->X_add_number <= 0
1043 && (generic_floating_point_number.sign == '+'
1044 || generic_floating_point_number.sign == 'P'))
1046 /* Negative flonum (eg, -1.000e0). */
1047 if (generic_floating_point_number.sign == '+')
1048 generic_floating_point_number.sign = '-';
1050 generic_floating_point_number.sign = 'N';
1052 else if (expressionP->X_op == O_big
1053 && expressionP->X_add_number > 0)
1057 if (c == '~' || c == '-')
1059 for (i = 0; i < expressionP->X_add_number; ++i)
1060 generic_bignum[i] = ~generic_bignum[i];
1062 /* Extend the bignum to at least the size of .octa. */
1063 if (expressionP->X_add_number < SIZE_OF_LARGE_NUMBER)
1065 expressionP->X_add_number = SIZE_OF_LARGE_NUMBER;
1066 for (; i < expressionP->X_add_number; ++i)
1067 generic_bignum[i] = ~(LITTLENUM_TYPE) 0;
1071 for (i = 0; i < expressionP->X_add_number; ++i)
1073 generic_bignum[i] += 1;
1074 if (generic_bignum[i])
1080 for (i = 0; i < expressionP->X_add_number; ++i)
1081 if (generic_bignum[i] != 0)
1083 expressionP->X_add_number = i >= expressionP->X_add_number;
1084 expressionP->X_op = O_constant;
1085 expressionP->X_unsigned = 1;
1086 expressionP->X_extrabit = 0;
1089 else if (expressionP->X_op != O_illegal
1090 && expressionP->X_op != O_absent)
1094 expressionP->X_add_symbol = make_expr_symbol (expressionP);
1096 expressionP->X_op = O_uminus;
1097 else if (c == '~' || c == '"')
1098 expressionP->X_op = O_bit_not;
1100 expressionP->X_op = O_logical_not;
1101 expressionP->X_add_number = 0;
1105 as_warn (_("Unary operator %c ignored because bad operand follows"),
1110 #if defined (DOLLAR_DOT) || defined (TC_M68K)
1112 /* '$' is the program counter when in MRI mode, or when
1113 DOLLAR_DOT is defined. */
1115 if (! flag_m68k_mri)
1118 if (DOLLAR_AMBIGU && hex_p (*input_line_pointer))
1120 /* In MRI mode and on Z80, '$' is also used as the prefix
1121 for a hexadecimal constant. */
1122 integer_constant (16, expressionP);
1126 if (is_part_of_name (*input_line_pointer))
1129 current_location (expressionP);
1134 if (!is_part_of_name (*input_line_pointer))
1136 current_location (expressionP);
1139 else if ((strncasecmp (input_line_pointer, "startof.", 8) == 0
1140 && ! is_part_of_name (input_line_pointer[8]))
1141 || (strncasecmp (input_line_pointer, "sizeof.", 7) == 0
1142 && ! is_part_of_name (input_line_pointer[7])))
1146 start = (input_line_pointer[1] == 't'
1147 || input_line_pointer[1] == 'T');
1148 input_line_pointer += start ? 8 : 7;
1150 if (*input_line_pointer != '(')
1151 as_bad (_("syntax error in .startof. or .sizeof."));
1156 ++input_line_pointer;
1158 name = input_line_pointer;
1159 c = get_symbol_end ();
1161 buf = (char *) xmalloc (strlen (name) + 10);
1163 sprintf (buf, ".startof.%s", name);
1165 sprintf (buf, ".sizeof.%s", name);
1166 symbolP = symbol_make (buf);
1169 expressionP->X_op = O_symbol;
1170 expressionP->X_add_symbol = symbolP;
1171 expressionP->X_add_number = 0;
1173 *input_line_pointer = c;
1175 if (*input_line_pointer != ')')
1176 as_bad (_("syntax error in .startof. or .sizeof."));
1178 ++input_line_pointer;
1189 /* Can't imagine any other kind of operand. */
1190 expressionP->X_op = O_absent;
1191 input_line_pointer--;
1196 if (! flag_m68k_mri)
1198 integer_constant (2, expressionP);
1202 if (! flag_m68k_mri)
1204 integer_constant (8, expressionP);
1208 if (! flag_m68k_mri)
1211 /* In MRI mode, this is a floating point constant represented
1212 using hexadecimal digits. */
1214 ++input_line_pointer;
1215 integer_constant (16, expressionP);
1219 if (! flag_m68k_mri || is_part_of_name (*input_line_pointer))
1222 current_location (expressionP);
1227 #if defined(md_need_index_operator) || defined(TC_M68K)
1230 if (is_name_beginner (c)) /* Here if did not begin with a digit. */
1232 /* Identifier begins here.
1233 This is kludged for speed, so code is repeated. */
1235 name = --input_line_pointer;
1236 c = get_symbol_end ();
1240 operatorT op = md_operator (name, 1, &c);
1245 *input_line_pointer = c;
1249 *input_line_pointer = c;
1253 *input_line_pointer = c;
1257 as_bad (_("invalid use of operator \"%s\""), name);
1262 if (op != O_absent && op != O_illegal)
1264 *input_line_pointer = c;
1265 expr (9, expressionP, mode);
1266 expressionP->X_add_symbol = make_expr_symbol (expressionP);
1267 expressionP->X_op_symbol = NULL;
1268 expressionP->X_add_number = 0;
1269 expressionP->X_op = op;
1275 #ifdef md_parse_name
1276 /* This is a hook for the backend to parse certain names
1277 specially in certain contexts. If a name always has a
1278 specific value, it can often be handled by simply
1279 entering it in the symbol table. */
1280 if (md_parse_name (name, expressionP, mode, &c))
1282 *input_line_pointer = c;
1288 /* The MRI i960 assembler permits
1290 FIXME: This should use md_parse_name. */
1292 && (strcasecmp (name, "sizeof") == 0
1293 || strcasecmp (name, "startof") == 0))
1298 start = (name[1] == 't'
1301 *input_line_pointer = c;
1304 name = input_line_pointer;
1305 c = get_symbol_end ();
1307 buf = (char *) xmalloc (strlen (name) + 10);
1309 sprintf (buf, ".startof.%s", name);
1311 sprintf (buf, ".sizeof.%s", name);
1312 symbolP = symbol_make (buf);
1315 expressionP->X_op = O_symbol;
1316 expressionP->X_add_symbol = symbolP;
1317 expressionP->X_add_number = 0;
1319 *input_line_pointer = c;
1326 symbolP = symbol_find_or_make (name);
1328 /* If we have an absolute symbol or a reg, then we know its
1330 segment = S_GET_SEGMENT (symbolP);
1331 if (mode != expr_defer
1332 && segment == absolute_section
1333 && !S_FORCE_RELOC (symbolP, 0))
1335 expressionP->X_op = O_constant;
1336 expressionP->X_add_number = S_GET_VALUE (symbolP);
1338 else if (mode != expr_defer && segment == reg_section)
1340 expressionP->X_op = O_register;
1341 expressionP->X_add_number = S_GET_VALUE (symbolP);
1345 expressionP->X_op = O_symbol;
1346 expressionP->X_add_symbol = symbolP;
1347 expressionP->X_add_number = 0;
1349 *input_line_pointer = c;
1353 /* Let the target try to parse it. Success is indicated by changing
1354 the X_op field to something other than O_absent and pointing
1355 input_line_pointer past the expression. If it can't parse the
1356 expression, X_op and input_line_pointer should be unchanged. */
1357 expressionP->X_op = O_absent;
1358 --input_line_pointer;
1359 md_operand (expressionP);
1360 if (expressionP->X_op == O_absent)
1362 ++input_line_pointer;
1363 as_bad (_("bad expression"));
1364 expressionP->X_op = O_constant;
1365 expressionP->X_add_number = 0;
1371 /* It is more 'efficient' to clean up the expressionS when they are
1372 created. Doing it here saves lines of code. */
1373 clean_up_expression (expressionP);
1374 SKIP_WHITESPACE (); /* -> 1st char after operand. */
1375 know (*input_line_pointer != ' ');
1377 /* The PA port needs this information. */
1378 if (expressionP->X_add_symbol)
1379 symbol_mark_used (expressionP->X_add_symbol);
1381 if (mode != expr_defer)
1383 expressionP->X_add_symbol
1384 = symbol_clone_if_forward_ref (expressionP->X_add_symbol);
1385 expressionP->X_op_symbol
1386 = symbol_clone_if_forward_ref (expressionP->X_op_symbol);
1389 switch (expressionP->X_op)
1392 return absolute_section;
1394 return S_GET_SEGMENT (expressionP->X_add_symbol);
1400 /* Internal. Simplify a struct expression for use by expr (). */
1402 /* In: address of an expressionS.
1403 The X_op field of the expressionS may only take certain values.
1404 Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
1406 Out: expressionS may have been modified:
1407 Unused fields zeroed to help expr (). */
1410 clean_up_expression (expressionS *expressionP)
1412 switch (expressionP->X_op)
1416 expressionP->X_add_number = 0;
1421 expressionP->X_add_symbol = NULL;
1426 expressionP->X_op_symbol = NULL;
1433 /* Expression parser. */
1435 /* We allow an empty expression, and just assume (absolute,0) silently.
1436 Unary operators and parenthetical expressions are treated as operands.
1437 As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
1439 We used to do an aho/ullman shift-reduce parser, but the logic got so
1440 warped that I flushed it and wrote a recursive-descent parser instead.
1441 Now things are stable, would anybody like to write a fast parser?
1442 Most expressions are either register (which does not even reach here)
1443 or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
1444 So I guess it doesn't really matter how inefficient more complex expressions
1447 After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
1448 Also, we have consumed any leading or trailing spaces (operand does that)
1449 and done all intervening operators.
1451 This returns the segment of the result, which will be
1452 absolute_section or the segment of a symbol. */
1455 #define __ O_illegal
1457 #define O_SINGLE_EQ O_illegal
1460 /* Maps ASCII -> operators. */
1461 static const operatorT op_encoding[256] = {
1462 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1463 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1465 __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __,
1466 __, __, O_multiply, O_add, __, O_subtract, __, O_divide,
1467 __, __, __, __, __, __, __, __,
1468 __, __, __, __, O_lt, O_SINGLE_EQ, O_gt, __,
1469 __, __, __, __, __, __, __, __,
1470 __, __, __, __, __, __, __, __,
1471 __, __, __, __, __, __, __, __,
1473 #ifdef NEED_INDEX_OPERATOR
1478 __, __, O_bit_exclusive_or, __,
1479 __, __, __, __, __, __, __, __,
1480 __, __, __, __, __, __, __, __,
1481 __, __, __, __, __, __, __, __,
1482 __, __, __, __, O_bit_inclusive_or, __, __, __,
1484 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1485 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1486 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1487 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1488 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1489 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1490 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1491 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
1495 0 operand, (expression)
1500 5 used for * / % in MRI mode
1505 static operator_rankT op_rank[O_max] = {
1510 0, /* O_symbol_rva */
1515 9, /* O_logical_not */
1519 8, /* O_left_shift */
1520 8, /* O_right_shift */
1521 7, /* O_bit_inclusive_or */
1522 7, /* O_bit_or_not */
1523 7, /* O_bit_exclusive_or */
1533 3, /* O_logical_and */
1534 2, /* O_logical_or */
1538 /* Unfortunately, in MRI mode for the m68k, multiplication and
1539 division have lower precedence than the bit wise operators. This
1540 function sets the operator precedences correctly for the current
1541 mode. Also, MRI uses a different bit_not operator, and this fixes
1544 #define STANDARD_MUL_PRECEDENCE 8
1545 #define MRI_MUL_PRECEDENCE 6
1548 expr_set_precedence (void)
1552 op_rank[O_multiply] = MRI_MUL_PRECEDENCE;
1553 op_rank[O_divide] = MRI_MUL_PRECEDENCE;
1554 op_rank[O_modulus] = MRI_MUL_PRECEDENCE;
1558 op_rank[O_multiply] = STANDARD_MUL_PRECEDENCE;
1559 op_rank[O_divide] = STANDARD_MUL_PRECEDENCE;
1560 op_rank[O_modulus] = STANDARD_MUL_PRECEDENCE;
1565 expr_set_rank (operatorT op, operator_rankT rank)
1567 gas_assert (op >= O_md1 && op < ARRAY_SIZE (op_rank));
1571 /* Initialize the expression parser. */
1576 expr_set_precedence ();
1578 /* Verify that X_op field is wide enough. */
1582 gas_assert (e.X_op == O_max);
1586 /* Return the encoding for the operator at INPUT_LINE_POINTER, and
1587 sets NUM_CHARS to the number of characters in the operator.
1588 Does not advance INPUT_LINE_POINTER. */
1590 static inline operatorT
1591 operatorf (int *num_chars)
1596 c = *input_line_pointer & 0xff;
1599 if (is_end_of_line[c])
1603 if (is_name_beginner (c))
1605 char *name = input_line_pointer;
1606 char ec = get_symbol_end ();
1608 ret = md_operator (name, 2, &ec);
1612 *input_line_pointer = ec;
1613 input_line_pointer = name;
1618 as_bad (_("invalid use of operator \"%s\""), name);
1622 *input_line_pointer = ec;
1623 *num_chars = input_line_pointer - name;
1624 input_line_pointer = name;
1633 ret = op_encoding[c];
1635 if (ret == O_illegal)
1637 char *start = input_line_pointer;
1639 ret = md_operator (NULL, 2, NULL);
1640 if (ret != O_illegal)
1641 *num_chars = input_line_pointer - start;
1642 input_line_pointer = start;
1649 return op_encoding[c];
1652 switch (input_line_pointer[1])
1655 return op_encoding[c];
1670 if (input_line_pointer[1] != '=')
1671 return op_encoding[c];
1677 switch (input_line_pointer[1])
1680 return op_encoding[c];
1682 ret = O_right_shift;
1692 switch (input_line_pointer[1])
1695 /* We accept !! as equivalent to ^ for MRI compatibility. */
1697 return O_bit_exclusive_or;
1699 /* We accept != as equivalent to <>. */
1704 return O_bit_inclusive_or;
1705 return op_encoding[c];
1709 if (input_line_pointer[1] != '|')
1710 return op_encoding[c];
1713 return O_logical_or;
1716 if (input_line_pointer[1] != '&')
1717 return op_encoding[c];
1720 return O_logical_and;
1726 /* Implement "word-size + 1 bit" addition for
1727 {resultP->X_extrabit:resultP->X_add_number} + {rhs_highbit:amount}. This
1728 is used so that the full range of unsigned word values and the full range of
1729 signed word values can be represented in an O_constant expression, which is
1730 useful e.g. for .sleb128 directives. */
1733 add_to_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;
1742 if (ures + uamount < ures)
1743 resultP->X_extrabit ^= 1;
1746 /* Similarly, for subtraction. */
1749 subtract_from_result (expressionS *resultP, offsetT amount, int rhs_highbit)
1751 valueT ures = resultP->X_add_number;
1752 valueT uamount = amount;
1754 resultP->X_add_number -= amount;
1756 resultP->X_extrabit ^= rhs_highbit;
1759 resultP->X_extrabit ^= 1;
1762 /* Parse an expression. */
1765 expr (int rankarg, /* Larger # is higher rank. */
1766 expressionS *resultP, /* Deliver result here. */
1767 enum expr_mode mode /* Controls behavior. */)
1769 operator_rankT rank = (operator_rankT) rankarg;
1776 know (rankarg >= 0);
1778 /* Save the value of dot for the fixup code. */
1781 dot_value = frag_now_fix ();
1782 dot_frag = frag_now;
1785 retval = operand (resultP, mode);
1787 /* operand () gobbles spaces. */
1788 know (*input_line_pointer != ' ');
1790 op_left = operatorf (&op_chars);
1791 while (op_left != O_illegal && op_rank[(int) op_left] > rank)
1796 input_line_pointer += op_chars; /* -> after operator. */
1799 rightseg = expr (op_rank[(int) op_left], &right, mode);
1800 if (right.X_op == O_absent)
1802 as_warn (_("missing operand; zero assumed"));
1803 right.X_op = O_constant;
1804 right.X_add_number = 0;
1805 right.X_add_symbol = NULL;
1806 right.X_op_symbol = NULL;
1809 know (*input_line_pointer != ' ');
1811 if (op_left == O_index)
1813 if (*input_line_pointer != ']')
1814 as_bad ("missing right bracket");
1817 ++input_line_pointer;
1822 op_right = operatorf (&op_chars);
1824 know (op_right == O_illegal || op_left == O_index
1825 || op_rank[(int) op_right] <= op_rank[(int) op_left]);
1826 know ((int) op_left >= (int) O_multiply);
1828 know ((int) op_left <= (int) O_index);
1830 know ((int) op_left < (int) O_max);
1833 /* input_line_pointer->after right-hand quantity. */
1834 /* left-hand quantity in resultP. */
1835 /* right-hand quantity in right. */
1836 /* operator in op_left. */
1838 if (resultP->X_op == O_big)
1840 if (resultP->X_add_number > 0)
1841 as_warn (_("left operand is a bignum; integer 0 assumed"));
1843 as_warn (_("left operand is a float; integer 0 assumed"));
1844 resultP->X_op = O_constant;
1845 resultP->X_add_number = 0;
1846 resultP->X_add_symbol = NULL;
1847 resultP->X_op_symbol = NULL;
1849 if (right.X_op == O_big)
1851 if (right.X_add_number > 0)
1852 as_warn (_("right operand is a bignum; integer 0 assumed"));
1854 as_warn (_("right operand is a float; integer 0 assumed"));
1855 right.X_op = O_constant;
1856 right.X_add_number = 0;
1857 right.X_add_symbol = NULL;
1858 right.X_op_symbol = NULL;
1861 /* Optimize common cases. */
1862 #ifdef md_optimize_expr
1863 if (md_optimize_expr (resultP, op_left, &right))
1870 #ifndef md_register_arithmetic
1871 # define md_register_arithmetic 1
1873 if (op_left == O_add && right.X_op == O_constant
1874 && (md_register_arithmetic || resultP->X_op != O_register))
1877 add_to_result (resultP, right.X_add_number, right.X_extrabit);
1879 /* This case comes up in PIC code. */
1880 else if (op_left == O_subtract
1881 && right.X_op == O_symbol
1882 && resultP->X_op == O_symbol
1883 && retval == rightseg
1884 #ifdef md_allow_local_subtract
1885 && md_allow_local_subtract (resultP, & right, rightseg)
1887 && ((SEG_NORMAL (rightseg)
1888 && !S_FORCE_RELOC (resultP->X_add_symbol, 0)
1889 && !S_FORCE_RELOC (right.X_add_symbol, 0))
1890 || right.X_add_symbol == resultP->X_add_symbol)
1891 && frag_offset_fixed_p (symbol_get_frag (resultP->X_add_symbol),
1892 symbol_get_frag (right.X_add_symbol),
1895 offsetT symval_diff = S_GET_VALUE (resultP->X_add_symbol)
1896 - S_GET_VALUE (right.X_add_symbol);
1897 subtract_from_result (resultP, right.X_add_number, right.X_extrabit);
1898 subtract_from_result (resultP, frag_off / OCTETS_PER_BYTE, 0);
1899 add_to_result (resultP, symval_diff, symval_diff < 0);
1900 resultP->X_op = O_constant;
1901 resultP->X_add_symbol = 0;
1903 else if (op_left == O_subtract && right.X_op == O_constant
1904 && (md_register_arithmetic || resultP->X_op != O_register))
1907 subtract_from_result (resultP, right.X_add_number, right.X_extrabit);
1909 else if (op_left == O_add && resultP->X_op == O_constant
1910 && (md_register_arithmetic || right.X_op != O_register))
1913 resultP->X_op = right.X_op;
1914 resultP->X_add_symbol = right.X_add_symbol;
1915 resultP->X_op_symbol = right.X_op_symbol;
1916 add_to_result (resultP, right.X_add_number, right.X_extrabit);
1919 else if (resultP->X_op == O_constant && right.X_op == O_constant)
1921 /* Constant OP constant. */
1922 offsetT v = right.X_add_number;
1923 if (v == 0 && (op_left == O_divide || op_left == O_modulus))
1925 as_warn (_("division by zero"));
1928 if ((valueT) v >= sizeof(valueT) * CHAR_BIT
1929 && (op_left == O_left_shift || op_left == O_right_shift))
1931 as_warn_value_out_of_range (_("shift count"), v, 0,
1932 sizeof(valueT) * CHAR_BIT - 1,
1934 resultP->X_add_number = v = 0;
1938 default: goto general;
1939 case O_multiply: resultP->X_add_number *= v; break;
1940 case O_divide: resultP->X_add_number /= v; break;
1941 case O_modulus: resultP->X_add_number %= v; break;
1942 case O_left_shift: resultP->X_add_number <<= v; break;
1944 /* We always use unsigned shifts, to avoid relying on
1945 characteristics of the compiler used to compile gas. */
1946 resultP->X_add_number =
1947 (offsetT) ((valueT) resultP->X_add_number >> (valueT) v);
1949 case O_bit_inclusive_or: resultP->X_add_number |= v; break;
1950 case O_bit_or_not: resultP->X_add_number |= ~v; break;
1951 case O_bit_exclusive_or: resultP->X_add_number ^= v; break;
1952 case O_bit_and: resultP->X_add_number &= v; break;
1953 /* Constant + constant (O_add) is handled by the
1954 previous if statement for constant + X, so is omitted
1957 subtract_from_result (resultP, v, 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 =
1969 resultP->X_add_number < v ? ~ (offsetT) 0 : 0;
1972 resultP->X_add_number =
1973 resultP->X_add_number <= v ? ~ (offsetT) 0 : 0;
1976 resultP->X_add_number =
1977 resultP->X_add_number >= v ? ~ (offsetT) 0 : 0;
1980 resultP->X_add_number =
1981 resultP->X_add_number > v ? ~ (offsetT) 0 : 0;
1984 resultP->X_add_number = resultP->X_add_number && v;
1987 resultP->X_add_number = resultP->X_add_number || v;
1991 else if (resultP->X_op == O_symbol
1992 && right.X_op == O_symbol
1993 && (op_left == O_add
1994 || op_left == O_subtract
1995 || (resultP->X_add_number == 0
1996 && right.X_add_number == 0)))
1998 /* Symbol OP symbol. */
1999 resultP->X_op = op_left;
2000 resultP->X_op_symbol = right.X_add_symbol;
2001 if (op_left == O_add)
2002 add_to_result (resultP, right.X_add_number, right.X_extrabit);
2003 else if (op_left == O_subtract)
2005 subtract_from_result (resultP, right.X_add_number,
2007 if (retval == rightseg
2008 && SEG_NORMAL (retval)
2009 && !S_FORCE_RELOC (resultP->X_add_symbol, 0)
2010 && !S_FORCE_RELOC (right.X_add_symbol, 0))
2012 retval = absolute_section;
2013 rightseg = absolute_section;
2020 /* The general case. */
2021 resultP->X_add_symbol = make_expr_symbol (resultP);
2022 resultP->X_op_symbol = make_expr_symbol (&right);
2023 resultP->X_op = op_left;
2024 resultP->X_add_number = 0;
2025 resultP->X_unsigned = 1;
2026 resultP->X_extrabit = 0;
2029 if (retval != rightseg)
2031 if (retval == undefined_section)
2033 else if (rightseg == undefined_section)
2035 else if (retval == expr_section)
2037 else if (rightseg == expr_section)
2039 else if (retval == reg_section)
2041 else if (rightseg == reg_section)
2043 else if (rightseg == absolute_section)
2045 else if (retval == absolute_section)
2048 else if (op_left == O_subtract)
2052 as_bad (_("operation combines symbols in different segments"));
2056 } /* While next operator is >= this rank. */
2058 /* The PA port needs this information. */
2059 if (resultP->X_add_symbol)
2060 symbol_mark_used (resultP->X_add_symbol);
2062 if (rank == 0 && mode == expr_evaluate)
2063 resolve_expression (resultP);
2065 return resultP->X_op == O_constant ? absolute_section : retval;
2068 /* Resolve an expression without changing any symbols/sub-expressions
2072 resolve_expression (expressionS *expressionP)
2074 /* Help out with CSE. */
2075 valueT final_val = expressionP->X_add_number;
2076 symbolS *add_symbol = expressionP->X_add_symbol;
2077 symbolS *orig_add_symbol = add_symbol;
2078 symbolS *op_symbol = expressionP->X_op_symbol;
2079 operatorT op = expressionP->X_op;
2081 segT seg_left, seg_right;
2082 fragS *frag_left, *frag_right;
2097 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left))
2105 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left))
2108 if (seg_left != absolute_section)
2111 if (op == O_logical_not)
2113 else if (op == O_uminus)
2125 case O_bit_inclusive_or:
2127 case O_bit_exclusive_or:
2139 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left)
2140 || !snapshot_symbol (&op_symbol, &right, &seg_right, &frag_right))
2143 /* Simplify addition or subtraction of a constant by folding the
2144 constant into X_add_number. */
2147 if (seg_right == absolute_section)
2153 else if (seg_left == absolute_section)
2157 seg_left = seg_right;
2158 add_symbol = op_symbol;
2159 orig_add_symbol = expressionP->X_op_symbol;
2164 else if (op == O_subtract)
2166 if (seg_right == absolute_section)
2174 /* Equality and non-equality tests are permitted on anything.
2175 Subtraction, and other comparison operators are permitted if
2176 both operands are in the same section.
2177 Shifts by constant zero are permitted on anything.
2178 Multiplies, bit-ors, and bit-ands with constant zero are
2179 permitted on anything.
2180 Multiplies and divides by constant one are permitted on
2182 Binary operations with both operands being the same register
2183 or undefined symbol are permitted if the result doesn't depend
2185 Otherwise, both operands must be absolute. We already handled
2186 the case of addition or subtraction of a constant above. */
2188 if (!(seg_left == absolute_section
2189 && seg_right == absolute_section)
2190 && !(op == O_eq || op == O_ne)
2191 && !((op == O_subtract
2192 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
2193 && seg_left == seg_right
2195 || frag_offset_fixed_p (frag_left, frag_right, &frag_off))
2196 && (seg_left != reg_section || left == right)
2197 && (seg_left != undefined_section || add_symbol == op_symbol)))
2199 if ((seg_left == absolute_section && left == 0)
2200 || (seg_right == absolute_section && right == 0))
2202 if (op == O_bit_exclusive_or || op == O_bit_inclusive_or)
2204 if (!(seg_right == absolute_section && right == 0))
2206 seg_left = seg_right;
2208 add_symbol = op_symbol;
2209 orig_add_symbol = expressionP->X_op_symbol;
2214 else if (op == O_left_shift || op == O_right_shift)
2216 if (!(seg_left == absolute_section && left == 0))
2222 else if (op != O_multiply
2223 && op != O_bit_or_not && op != O_bit_and)
2226 else if (op == O_multiply
2227 && seg_left == absolute_section && left == 1)
2229 seg_left = seg_right;
2231 add_symbol = op_symbol;
2232 orig_add_symbol = expressionP->X_op_symbol;
2236 else if ((op == O_multiply || op == O_divide)
2237 && seg_right == absolute_section && right == 1)
2242 else if (!(left == right
2243 && ((seg_left == reg_section && seg_right == reg_section)
2244 || (seg_left == undefined_section
2245 && seg_right == undefined_section
2246 && add_symbol == op_symbol))))
2248 else if (op == O_bit_and || op == O_bit_inclusive_or)
2253 else if (op != O_bit_exclusive_or && op != O_bit_or_not)
2257 right += frag_off / OCTETS_PER_BYTE;
2260 case O_add: left += right; break;
2261 case O_subtract: left -= right; break;
2262 case O_multiply: left *= right; break;
2266 left = (offsetT) left / (offsetT) right;
2271 left = (offsetT) left % (offsetT) right;
2273 case O_left_shift: left <<= right; break;
2274 case O_right_shift: left >>= right; break;
2275 case O_bit_inclusive_or: left |= right; break;
2276 case O_bit_or_not: left |= ~right; break;
2277 case O_bit_exclusive_or: left ^= right; break;
2278 case O_bit_and: left &= right; break;
2281 left = (left == right
2282 && seg_left == seg_right
2283 && (finalize_syms || frag_left == frag_right)
2284 && (seg_left != undefined_section
2285 || add_symbol == op_symbol)
2286 ? ~ (valueT) 0 : 0);
2291 left = (offsetT) left < (offsetT) right ? ~ (valueT) 0 : 0;
2294 left = (offsetT) left <= (offsetT) right ? ~ (valueT) 0 : 0;
2297 left = (offsetT) left >= (offsetT) right ? ~ (valueT) 0 : 0;
2300 left = (offsetT) left > (offsetT) right ? ~ (valueT) 0 : 0;
2302 case O_logical_and: left = left && right; break;
2303 case O_logical_or: left = left || right; break;
2313 if (seg_left == absolute_section)
2315 else if (seg_left == reg_section && final_val == 0)
2317 else if (!symbol_same_p (add_symbol, orig_add_symbol))
2319 expressionP->X_add_symbol = add_symbol;
2321 expressionP->X_op = op;
2323 if (op == O_constant || op == O_register)
2325 expressionP->X_add_number = final_val;
2330 /* This lives here because it belongs equally in expr.c & read.c.
2331 expr.c is just a branch office read.c anyway, and putting it
2332 here lessens the crowd at read.c.
2334 Assume input_line_pointer is at start of symbol name.
2335 Advance input_line_pointer past symbol name.
2336 Turn that character into a '\0', returning its former value.
2337 This allows a string compare (RMS wants symbol names to be strings)
2339 There will always be a char following symbol name, because all good
2340 lines end in end-of-line. */
2343 get_symbol_end (void)
2347 /* We accept \001 in a name in case this is being called with a
2348 constructed string. */
2349 if (is_name_beginner (c = *input_line_pointer++) || c == '\001')
2351 while (is_part_of_name (c = *input_line_pointer++)
2354 if (is_name_ender (c))
2355 c = *input_line_pointer++;
2357 *--input_line_pointer = 0;
2362 get_single_number (void)
2365 operand (&exp, expr_normal);
2366 return exp.X_add_number;