* elf32-spu.c (build_stub): Fix malloc under-allocation.
[binutils.git] / gas / expr.c
blob0563b5b4219ff79517939f071628d9caa08fe54d
1 /* expr.c -operands, expressions-
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 /* This is really a branch office of as-read.c. I split it out to clearly
24 distinguish the world of expressions from the world of statements.
25 (It also gives smaller files to re-compile.)
26 Here, "operand"s are of expressions, not instructions. */
28 #define min(a, b) ((a) < (b) ? (a) : (b))
30 #include "as.h"
31 #include "safe-ctype.h"
32 #include "obstack.h"
34 #ifdef HAVE_LIMITS_H
35 #include <limits.h>
36 #endif
37 #ifndef CHAR_BIT
38 #define CHAR_BIT 8
39 #endif
41 static void floating_constant (expressionS * expressionP);
42 static valueT generic_bignum_to_int32 (void);
43 #ifdef BFD64
44 static valueT generic_bignum_to_int64 (void);
45 #endif
46 static void integer_constant (int radix, expressionS * expressionP);
47 static void mri_char_constant (expressionS *);
48 static void clean_up_expression (expressionS * expressionP);
49 static segT operand (expressionS *, enum expr_mode);
50 static operatorT operatorf (int *);
52 extern const char EXP_CHARS[], FLT_CHARS[];
54 /* We keep a mapping of expression symbols to file positions, so that
55 we can provide better error messages. */
57 struct expr_symbol_line {
58 struct expr_symbol_line *next;
59 symbolS *sym;
60 char *file;
61 unsigned int line;
64 static struct expr_symbol_line *expr_symbol_lines;
66 /* Build a dummy symbol to hold a complex expression. This is how we
67 build expressions up out of other expressions. The symbol is put
68 into the fake section expr_section. */
70 symbolS *
71 make_expr_symbol (expressionS *expressionP)
73 expressionS zero;
74 symbolS *symbolP;
75 struct expr_symbol_line *n;
77 if (expressionP->X_op == O_symbol
78 && expressionP->X_add_number == 0)
79 return expressionP->X_add_symbol;
81 if (expressionP->X_op == O_big)
83 /* This won't work, because the actual value is stored in
84 generic_floating_point_number or generic_bignum, and we are
85 going to lose it if we haven't already. */
86 if (expressionP->X_add_number > 0)
87 as_bad (_("bignum invalid"));
88 else
89 as_bad (_("floating point number invalid"));
90 zero.X_op = O_constant;
91 zero.X_add_number = 0;
92 zero.X_unsigned = 0;
93 clean_up_expression (&zero);
94 expressionP = &zero;
97 /* Putting constant symbols in absolute_section rather than
98 expr_section is convenient for the old a.out code, for which
99 S_GET_SEGMENT does not always retrieve the value put in by
100 S_SET_SEGMENT. */
101 symbolP = symbol_create (FAKE_LABEL_NAME,
102 (expressionP->X_op == O_constant
103 ? absolute_section
104 : expressionP->X_op == O_register
105 ? reg_section
106 : expr_section),
107 0, &zero_address_frag);
108 symbol_set_value_expression (symbolP, expressionP);
110 if (expressionP->X_op == O_constant)
111 resolve_symbol_value (symbolP);
113 n = (struct expr_symbol_line *) xmalloc (sizeof *n);
114 n->sym = symbolP;
115 as_where (&n->file, &n->line);
116 n->next = expr_symbol_lines;
117 expr_symbol_lines = n;
119 return symbolP;
122 /* Return the file and line number for an expr symbol. Return
123 non-zero if something was found, 0 if no information is known for
124 the symbol. */
127 expr_symbol_where (symbolS *sym, char **pfile, unsigned int *pline)
129 register struct expr_symbol_line *l;
131 for (l = expr_symbol_lines; l != NULL; l = l->next)
133 if (l->sym == sym)
135 *pfile = l->file;
136 *pline = l->line;
137 return 1;
141 return 0;
144 /* Utilities for building expressions.
145 Since complex expressions are recorded as symbols for use in other
146 expressions these return a symbolS * and not an expressionS *.
147 These explicitly do not take an "add_number" argument. */
148 /* ??? For completeness' sake one might want expr_build_symbol.
149 It would just return its argument. */
151 /* Build an expression for an unsigned constant.
152 The corresponding one for signed constants is missing because
153 there's currently no need for it. One could add an unsigned_p flag
154 but that seems more clumsy. */
156 symbolS *
157 expr_build_uconstant (offsetT value)
159 expressionS e;
161 e.X_op = O_constant;
162 e.X_add_number = value;
163 e.X_unsigned = 1;
164 return make_expr_symbol (&e);
167 /* Build an expression for the current location ('.'). */
169 symbolS *
170 expr_build_dot (void)
172 expressionS e;
174 current_location (&e);
175 return symbol_clone_if_forward_ref (make_expr_symbol (&e));
178 /* Build any floating-point literal here.
179 Also build any bignum literal here. */
181 /* Seems atof_machine can backscan through generic_bignum and hit whatever
182 happens to be loaded before it in memory. And its way too complicated
183 for me to fix right. Thus a hack. JF: Just make generic_bignum bigger,
184 and never write into the early words, thus they'll always be zero.
185 I hate Dean's floating-point code. Bleh. */
186 LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6];
188 FLONUM_TYPE generic_floating_point_number = {
189 &generic_bignum[6], /* low. (JF: Was 0) */
190 &generic_bignum[SIZE_OF_LARGE_NUMBER + 6 - 1], /* high. JF: (added +6) */
191 0, /* leader. */
192 0, /* exponent. */
193 0 /* sign. */
197 static void
198 floating_constant (expressionS *expressionP)
200 /* input_line_pointer -> floating-point constant. */
201 int error_code;
203 error_code = atof_generic (&input_line_pointer, ".", EXP_CHARS,
204 &generic_floating_point_number);
206 if (error_code)
208 if (error_code == ERROR_EXPONENT_OVERFLOW)
210 as_bad (_("bad floating-point constant: exponent overflow"));
212 else
214 as_bad (_("bad floating-point constant: unknown error code=%d"),
215 error_code);
218 expressionP->X_op = O_big;
219 /* input_line_pointer -> just after constant, which may point to
220 whitespace. */
221 expressionP->X_add_number = -1;
224 static valueT
225 generic_bignum_to_int32 (void)
227 valueT number =
228 ((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
229 | (generic_bignum[0] & LITTLENUM_MASK);
230 number &= 0xffffffff;
231 return number;
234 #ifdef BFD64
235 static valueT
236 generic_bignum_to_int64 (void)
238 valueT number =
239 ((((((((valueT) generic_bignum[3] & LITTLENUM_MASK)
240 << LITTLENUM_NUMBER_OF_BITS)
241 | ((valueT) generic_bignum[2] & LITTLENUM_MASK))
242 << LITTLENUM_NUMBER_OF_BITS)
243 | ((valueT) generic_bignum[1] & LITTLENUM_MASK))
244 << LITTLENUM_NUMBER_OF_BITS)
245 | ((valueT) generic_bignum[0] & LITTLENUM_MASK));
246 return number;
248 #endif
250 static void
251 integer_constant (int radix, expressionS *expressionP)
253 char *start; /* Start of number. */
254 char *suffix = NULL;
255 char c;
256 valueT number; /* Offset or (absolute) value. */
257 short int digit; /* Value of next digit in current radix. */
258 short int maxdig = 0; /* Highest permitted digit value. */
259 int too_many_digits = 0; /* If we see >= this number of. */
260 char *name; /* Points to name of symbol. */
261 symbolS *symbolP; /* Points to symbol. */
263 int small; /* True if fits in 32 bits. */
265 /* May be bignum, or may fit in 32 bits. */
266 /* Most numbers fit into 32 bits, and we want this case to be fast.
267 so we pretend it will fit into 32 bits. If, after making up a 32
268 bit number, we realise that we have scanned more digits than
269 comfortably fit into 32 bits, we re-scan the digits coding them
270 into a bignum. For decimal and octal numbers we are
271 conservative: Some numbers may be assumed bignums when in fact
272 they do fit into 32 bits. Numbers of any radix can have excess
273 leading zeros: We strive to recognise this and cast them back
274 into 32 bits. We must check that the bignum really is more than
275 32 bits, and change it back to a 32-bit number if it fits. The
276 number we are looking for is expected to be positive, but if it
277 fits into 32 bits as an unsigned number, we let it be a 32-bit
278 number. The cavalier approach is for speed in ordinary cases. */
279 /* This has been extended for 64 bits. We blindly assume that if
280 you're compiling in 64-bit mode, the target is a 64-bit machine.
281 This should be cleaned up. */
283 #ifdef BFD64
284 #define valuesize 64
285 #else /* includes non-bfd case, mostly */
286 #define valuesize 32
287 #endif
289 if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri) && radix == 0)
291 int flt = 0;
293 /* In MRI mode, the number may have a suffix indicating the
294 radix. For that matter, it might actually be a floating
295 point constant. */
296 for (suffix = input_line_pointer; ISALNUM (*suffix); suffix++)
298 if (*suffix == 'e' || *suffix == 'E')
299 flt = 1;
302 if (suffix == input_line_pointer)
304 radix = 10;
305 suffix = NULL;
307 else
309 c = *--suffix;
310 c = TOUPPER (c);
311 /* If we have both NUMBERS_WITH_SUFFIX and LOCAL_LABELS_FB,
312 we distinguish between 'B' and 'b'. This is the case for
313 Z80. */
314 if ((NUMBERS_WITH_SUFFIX && LOCAL_LABELS_FB ? *suffix : c) == 'B')
315 radix = 2;
316 else if (c == 'D')
317 radix = 10;
318 else if (c == 'O' || c == 'Q')
319 radix = 8;
320 else if (c == 'H')
321 radix = 16;
322 else if (suffix[1] == '.' || c == 'E' || flt)
324 floating_constant (expressionP);
325 return;
327 else
329 radix = 10;
330 suffix = NULL;
335 switch (radix)
337 case 2:
338 maxdig = 2;
339 too_many_digits = valuesize + 1;
340 break;
341 case 8:
342 maxdig = radix = 8;
343 too_many_digits = (valuesize + 2) / 3 + 1;
344 break;
345 case 16:
346 maxdig = radix = 16;
347 too_many_digits = (valuesize + 3) / 4 + 1;
348 break;
349 case 10:
350 maxdig = radix = 10;
351 too_many_digits = (valuesize + 11) / 4; /* Very rough. */
353 #undef valuesize
354 start = input_line_pointer;
355 c = *input_line_pointer++;
356 for (number = 0;
357 (digit = hex_value (c)) < maxdig;
358 c = *input_line_pointer++)
360 number = number * radix + digit;
362 /* c contains character after number. */
363 /* input_line_pointer->char after c. */
364 small = (input_line_pointer - start - 1) < too_many_digits;
366 if (radix == 16 && c == '_')
368 /* This is literal of the form 0x333_0_12345678_1.
369 This example is equivalent to 0x00000333000000001234567800000001. */
371 int num_little_digits = 0;
372 int i;
373 input_line_pointer = start; /* -> 1st digit. */
375 know (LITTLENUM_NUMBER_OF_BITS == 16);
377 for (c = '_'; c == '_'; num_little_digits += 2)
380 /* Convert one 64-bit word. */
381 int ndigit = 0;
382 number = 0;
383 for (c = *input_line_pointer++;
384 (digit = hex_value (c)) < maxdig;
385 c = *(input_line_pointer++))
387 number = number * radix + digit;
388 ndigit++;
391 /* Check for 8 digit per word max. */
392 if (ndigit > 8)
393 as_bad (_("a bignum with underscores may not have more than 8 hex digits in any word"));
395 /* Add this chunk to the bignum.
396 Shift things down 2 little digits. */
397 know (LITTLENUM_NUMBER_OF_BITS == 16);
398 for (i = min (num_little_digits + 1, SIZE_OF_LARGE_NUMBER - 1);
399 i >= 2;
400 i--)
401 generic_bignum[i] = generic_bignum[i - 2];
403 /* Add the new digits as the least significant new ones. */
404 generic_bignum[0] = number & 0xffffffff;
405 generic_bignum[1] = number >> 16;
408 /* Again, c is char after number, input_line_pointer->after c. */
410 if (num_little_digits > SIZE_OF_LARGE_NUMBER - 1)
411 num_little_digits = SIZE_OF_LARGE_NUMBER - 1;
413 gas_assert (num_little_digits >= 4);
415 if (num_little_digits != 8)
416 as_bad (_("a bignum with underscores must have exactly 4 words"));
418 /* We might have some leading zeros. These can be trimmed to give
419 us a change to fit this constant into a small number. */
420 while (generic_bignum[num_little_digits - 1] == 0
421 && num_little_digits > 1)
422 num_little_digits--;
424 if (num_little_digits <= 2)
426 /* will fit into 32 bits. */
427 number = generic_bignum_to_int32 ();
428 small = 1;
430 #ifdef BFD64
431 else if (num_little_digits <= 4)
433 /* Will fit into 64 bits. */
434 number = generic_bignum_to_int64 ();
435 small = 1;
437 #endif
438 else
440 small = 0;
442 /* Number of littlenums in the bignum. */
443 number = num_little_digits;
446 else if (!small)
448 /* We saw a lot of digits. manufacture a bignum the hard way. */
449 LITTLENUM_TYPE *leader; /* -> high order littlenum of the bignum. */
450 LITTLENUM_TYPE *pointer; /* -> littlenum we are frobbing now. */
451 long carry;
453 leader = generic_bignum;
454 generic_bignum[0] = 0;
455 generic_bignum[1] = 0;
456 generic_bignum[2] = 0;
457 generic_bignum[3] = 0;
458 input_line_pointer = start; /* -> 1st digit. */
459 c = *input_line_pointer++;
460 for (; (carry = hex_value (c)) < maxdig; c = *input_line_pointer++)
462 for (pointer = generic_bignum; pointer <= leader; pointer++)
464 long work;
466 work = carry + radix * *pointer;
467 *pointer = work & LITTLENUM_MASK;
468 carry = work >> LITTLENUM_NUMBER_OF_BITS;
470 if (carry)
472 if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1)
474 /* Room to grow a longer bignum. */
475 *++leader = carry;
479 /* Again, c is char after number. */
480 /* input_line_pointer -> after c. */
481 know (LITTLENUM_NUMBER_OF_BITS == 16);
482 if (leader < generic_bignum + 2)
484 /* Will fit into 32 bits. */
485 number = generic_bignum_to_int32 ();
486 small = 1;
488 #ifdef BFD64
489 else if (leader < generic_bignum + 4)
491 /* Will fit into 64 bits. */
492 number = generic_bignum_to_int64 ();
493 small = 1;
495 #endif
496 else
498 /* Number of littlenums in the bignum. */
499 number = leader - generic_bignum + 1;
503 if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
504 && suffix != NULL
505 && input_line_pointer - 1 == suffix)
506 c = *input_line_pointer++;
508 if (small)
510 /* Here with number, in correct radix. c is the next char.
511 Note that unlike un*x, we allow "011f" "0x9f" to both mean
512 the same as the (conventional) "9f".
513 This is simply easier than checking for strict canonical
514 form. Syntax sux! */
516 if (LOCAL_LABELS_FB && c == 'b')
518 /* Backward ref to local label.
519 Because it is backward, expect it to be defined. */
520 /* Construct a local label. */
521 name = fb_label_name ((int) number, 0);
523 /* Seen before, or symbol is defined: OK. */
524 symbolP = symbol_find (name);
525 if ((symbolP != NULL) && (S_IS_DEFINED (symbolP)))
527 /* Local labels are never absolute. Don't waste time
528 checking absoluteness. */
529 know (SEG_NORMAL (S_GET_SEGMENT (symbolP)));
531 expressionP->X_op = O_symbol;
532 expressionP->X_add_symbol = symbolP;
534 else
536 /* Either not seen or not defined. */
537 /* @@ Should print out the original string instead of
538 the parsed number. */
539 as_bad (_("backward ref to unknown label \"%d:\""),
540 (int) number);
541 expressionP->X_op = O_constant;
544 expressionP->X_add_number = 0;
545 } /* case 'b' */
546 else if (LOCAL_LABELS_FB && c == 'f')
548 /* Forward reference. Expect symbol to be undefined or
549 unknown. undefined: seen it before. unknown: never seen
550 it before.
552 Construct a local label name, then an undefined symbol.
553 Don't create a xseg frag for it: caller may do that.
554 Just return it as never seen before. */
555 name = fb_label_name ((int) number, 1);
556 symbolP = symbol_find_or_make (name);
557 /* We have no need to check symbol properties. */
558 #ifndef many_segments
559 /* Since "know" puts its arg into a "string", we
560 can't have newlines in the argument. */
561 know (S_GET_SEGMENT (symbolP) == undefined_section || S_GET_SEGMENT (symbolP) == text_section || S_GET_SEGMENT (symbolP) == data_section);
562 #endif
563 expressionP->X_op = O_symbol;
564 expressionP->X_add_symbol = symbolP;
565 expressionP->X_add_number = 0;
566 } /* case 'f' */
567 else if (LOCAL_LABELS_DOLLAR && c == '$')
569 /* If the dollar label is *currently* defined, then this is just
570 another reference to it. If it is not *currently* defined,
571 then this is a fresh instantiation of that number, so create
572 it. */
574 if (dollar_label_defined ((long) number))
576 name = dollar_label_name ((long) number, 0);
577 symbolP = symbol_find (name);
578 know (symbolP != NULL);
580 else
582 name = dollar_label_name ((long) number, 1);
583 symbolP = symbol_find_or_make (name);
586 expressionP->X_op = O_symbol;
587 expressionP->X_add_symbol = symbolP;
588 expressionP->X_add_number = 0;
589 } /* case '$' */
590 else
592 expressionP->X_op = O_constant;
593 expressionP->X_add_number = number;
594 input_line_pointer--; /* Restore following character. */
595 } /* Really just a number. */
597 else
599 /* Not a small number. */
600 expressionP->X_op = O_big;
601 expressionP->X_add_number = number; /* Number of littlenums. */
602 input_line_pointer--; /* -> char following number. */
606 /* Parse an MRI multi character constant. */
608 static void
609 mri_char_constant (expressionS *expressionP)
611 int i;
613 if (*input_line_pointer == '\''
614 && input_line_pointer[1] != '\'')
616 expressionP->X_op = O_constant;
617 expressionP->X_add_number = 0;
618 return;
621 /* In order to get the correct byte ordering, we must build the
622 number in reverse. */
623 for (i = SIZE_OF_LARGE_NUMBER - 1; i >= 0; i--)
625 int j;
627 generic_bignum[i] = 0;
628 for (j = 0; j < CHARS_PER_LITTLENUM; j++)
630 if (*input_line_pointer == '\'')
632 if (input_line_pointer[1] != '\'')
633 break;
634 ++input_line_pointer;
636 generic_bignum[i] <<= 8;
637 generic_bignum[i] += *input_line_pointer;
638 ++input_line_pointer;
641 if (i < SIZE_OF_LARGE_NUMBER - 1)
643 /* If there is more than one littlenum, left justify the
644 last one to make it match the earlier ones. If there is
645 only one, we can just use the value directly. */
646 for (; j < CHARS_PER_LITTLENUM; j++)
647 generic_bignum[i] <<= 8;
650 if (*input_line_pointer == '\''
651 && input_line_pointer[1] != '\'')
652 break;
655 if (i < 0)
657 as_bad (_("character constant too large"));
658 i = 0;
661 if (i > 0)
663 int c;
664 int j;
666 c = SIZE_OF_LARGE_NUMBER - i;
667 for (j = 0; j < c; j++)
668 generic_bignum[j] = generic_bignum[i + j];
669 i = c;
672 know (LITTLENUM_NUMBER_OF_BITS == 16);
673 if (i > 2)
675 expressionP->X_op = O_big;
676 expressionP->X_add_number = i;
678 else
680 expressionP->X_op = O_constant;
681 if (i < 2)
682 expressionP->X_add_number = generic_bignum[0] & LITTLENUM_MASK;
683 else
684 expressionP->X_add_number =
685 (((generic_bignum[1] & LITTLENUM_MASK)
686 << LITTLENUM_NUMBER_OF_BITS)
687 | (generic_bignum[0] & LITTLENUM_MASK));
690 /* Skip the final closing quote. */
691 ++input_line_pointer;
694 /* Return an expression representing the current location. This
695 handles the magic symbol `.'. */
697 void
698 current_location (expressionS *expressionp)
700 if (now_seg == absolute_section)
702 expressionp->X_op = O_constant;
703 expressionp->X_add_number = abs_section_offset;
705 else
707 expressionp->X_op = O_symbol;
708 expressionp->X_add_symbol = &dot_symbol;
709 expressionp->X_add_number = 0;
713 /* In: Input_line_pointer points to 1st char of operand, which may
714 be a space.
716 Out: An expressionS.
717 The operand may have been empty: in this case X_op == O_absent.
718 Input_line_pointer->(next non-blank) char after operand. */
720 static segT
721 operand (expressionS *expressionP, enum expr_mode mode)
723 char c;
724 symbolS *symbolP; /* Points to symbol. */
725 char *name; /* Points to name of symbol. */
726 segT segment;
728 /* All integers are regarded as unsigned unless they are negated.
729 This is because the only thing which cares whether a number is
730 unsigned is the code in emit_expr which extends constants into
731 bignums. It should only sign extend negative numbers, so that
732 something like ``.quad 0x80000000'' is not sign extended even
733 though it appears negative if valueT is 32 bits. */
734 expressionP->X_unsigned = 1;
736 /* Digits, assume it is a bignum. */
738 SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
739 c = *input_line_pointer++; /* input_line_pointer -> past char in c. */
741 if (is_end_of_line[(unsigned char) c])
742 goto eol;
744 switch (c)
746 case '1':
747 case '2':
748 case '3':
749 case '4':
750 case '5':
751 case '6':
752 case '7':
753 case '8':
754 case '9':
755 input_line_pointer--;
757 integer_constant ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
758 ? 0 : 10,
759 expressionP);
760 break;
762 #ifdef LITERAL_PREFIXDOLLAR_HEX
763 case '$':
764 /* $L is the start of a local label, not a hex constant. */
765 if (* input_line_pointer == 'L')
766 goto isname;
767 integer_constant (16, expressionP);
768 break;
769 #endif
771 #ifdef LITERAL_PREFIXPERCENT_BIN
772 case '%':
773 integer_constant (2, expressionP);
774 break;
775 #endif
777 case '0':
778 /* Non-decimal radix. */
780 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
782 char *s;
784 /* Check for a hex or float constant. */
785 for (s = input_line_pointer; hex_p (*s); s++)
787 if (*s == 'h' || *s == 'H' || *input_line_pointer == '.')
789 --input_line_pointer;
790 integer_constant (0, expressionP);
791 break;
794 c = *input_line_pointer;
795 switch (c)
797 case 'o':
798 case 'O':
799 case 'q':
800 case 'Q':
801 case '8':
802 case '9':
803 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
805 integer_constant (0, expressionP);
806 break;
808 /* Fall through. */
809 default:
810 default_case:
811 if (c && strchr (FLT_CHARS, c))
813 input_line_pointer++;
814 floating_constant (expressionP);
815 expressionP->X_add_number = - TOLOWER (c);
817 else
819 /* The string was only zero. */
820 expressionP->X_op = O_constant;
821 expressionP->X_add_number = 0;
824 break;
826 case 'x':
827 case 'X':
828 if (flag_m68k_mri)
829 goto default_case;
830 input_line_pointer++;
831 integer_constant (16, expressionP);
832 break;
834 case 'b':
835 if (LOCAL_LABELS_FB && ! (flag_m68k_mri || NUMBERS_WITH_SUFFIX))
837 /* This code used to check for '+' and '-' here, and, in
838 some conditions, fall through to call
839 integer_constant. However, that didn't make sense,
840 as integer_constant only accepts digits. */
841 /* Some of our code elsewhere does permit digits greater
842 than the expected base; for consistency, do the same
843 here. */
844 if (input_line_pointer[1] < '0'
845 || input_line_pointer[1] > '9')
847 /* Parse this as a back reference to label 0. */
848 input_line_pointer--;
849 integer_constant (10, expressionP);
850 break;
852 /* Otherwise, parse this as a binary number. */
854 /* Fall through. */
855 case 'B':
856 input_line_pointer++;
857 if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
858 goto default_case;
859 integer_constant (2, expressionP);
860 break;
862 case '0':
863 case '1':
864 case '2':
865 case '3':
866 case '4':
867 case '5':
868 case '6':
869 case '7':
870 integer_constant ((flag_m68k_mri || NUMBERS_WITH_SUFFIX)
871 ? 0 : 8,
872 expressionP);
873 break;
875 case 'f':
876 if (LOCAL_LABELS_FB)
878 /* If it says "0f" and it could possibly be a floating point
879 number, make it one. Otherwise, make it a local label,
880 and try to deal with parsing the rest later. */
881 if (!input_line_pointer[1]
882 || (is_end_of_line[0xff & input_line_pointer[1]])
883 || strchr (FLT_CHARS, 'f') == NULL)
884 goto is_0f_label;
886 char *cp = input_line_pointer + 1;
887 int r = atof_generic (&cp, ".", EXP_CHARS,
888 &generic_floating_point_number);
889 switch (r)
891 case 0:
892 case ERROR_EXPONENT_OVERFLOW:
893 if (*cp == 'f' || *cp == 'b')
894 /* Looks like a difference expression. */
895 goto is_0f_label;
896 else if (cp == input_line_pointer + 1)
897 /* No characters has been accepted -- looks like
898 end of operand. */
899 goto is_0f_label;
900 else
901 goto is_0f_float;
902 default:
903 as_fatal (_("expr.c(operand): bad atof_generic return val %d"),
908 /* Okay, now we've sorted it out. We resume at one of these
909 two labels, depending on what we've decided we're probably
910 looking at. */
911 is_0f_label:
912 input_line_pointer--;
913 integer_constant (10, expressionP);
914 break;
916 is_0f_float:
917 /* Fall through. */
921 case 'd':
922 case 'D':
923 if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
925 integer_constant (0, expressionP);
926 break;
928 /* Fall through. */
929 case 'F':
930 case 'r':
931 case 'e':
932 case 'E':
933 case 'g':
934 case 'G':
935 input_line_pointer++;
936 floating_constant (expressionP);
937 expressionP->X_add_number = - TOLOWER (c);
938 break;
940 case '$':
941 if (LOCAL_LABELS_DOLLAR)
943 integer_constant (10, expressionP);
944 break;
946 else
947 goto default_case;
950 break;
952 #ifndef NEED_INDEX_OPERATOR
953 case '[':
954 # ifdef md_need_index_operator
955 if (md_need_index_operator())
956 goto de_fault;
957 # endif
958 /* FALLTHROUGH */
959 #endif
960 case '(':
961 /* Didn't begin with digit & not a name. */
962 segment = expr (0, expressionP, mode);
963 /* expression () will pass trailing whitespace. */
964 if ((c == '(' && *input_line_pointer != ')')
965 || (c == '[' && *input_line_pointer != ']'))
966 as_bad (_("missing '%c'"), c == '(' ? ')' : ']');
967 else
968 input_line_pointer++;
969 SKIP_WHITESPACE ();
970 /* Here with input_line_pointer -> char after "(...)". */
971 return segment;
973 #ifdef TC_M68K
974 case 'E':
975 if (! flag_m68k_mri || *input_line_pointer != '\'')
976 goto de_fault;
977 as_bad (_("EBCDIC constants are not supported"));
978 /* Fall through. */
979 case 'A':
980 if (! flag_m68k_mri || *input_line_pointer != '\'')
981 goto de_fault;
982 ++input_line_pointer;
983 /* Fall through. */
984 #endif
985 case '\'':
986 if (! flag_m68k_mri)
988 /* Warning: to conform to other people's assemblers NO
989 ESCAPEMENT is permitted for a single quote. The next
990 character, parity errors and all, is taken as the value
991 of the operand. VERY KINKY. */
992 expressionP->X_op = O_constant;
993 expressionP->X_add_number = *input_line_pointer++;
994 break;
997 mri_char_constant (expressionP);
998 break;
1000 #ifdef TC_M68K
1001 case '"':
1002 /* Double quote is the bitwise not operator in MRI mode. */
1003 if (! flag_m68k_mri)
1004 goto de_fault;
1005 /* Fall through. */
1006 #endif
1007 case '~':
1008 /* '~' is permitted to start a label on the Delta. */
1009 if (is_name_beginner (c))
1010 goto isname;
1011 case '!':
1012 case '-':
1013 case '+':
1015 #ifdef md_operator
1016 unary:
1017 #endif
1018 operand (expressionP, mode);
1019 if (expressionP->X_op == O_constant)
1021 /* input_line_pointer -> char after operand. */
1022 if (c == '-')
1024 expressionP->X_add_number = - expressionP->X_add_number;
1025 /* Notice: '-' may overflow: no warning is given.
1026 This is compatible with other people's
1027 assemblers. Sigh. */
1028 expressionP->X_unsigned = 0;
1030 else if (c == '~' || c == '"')
1031 expressionP->X_add_number = ~ expressionP->X_add_number;
1032 else if (c == '!')
1033 expressionP->X_add_number = ! expressionP->X_add_number;
1035 else if (expressionP->X_op == O_big
1036 && expressionP->X_add_number <= 0
1037 && c == '-'
1038 && (generic_floating_point_number.sign == '+'
1039 || generic_floating_point_number.sign == 'P'))
1041 /* Negative flonum (eg, -1.000e0). */
1042 if (generic_floating_point_number.sign == '+')
1043 generic_floating_point_number.sign = '-';
1044 else
1045 generic_floating_point_number.sign = 'N';
1047 else if (expressionP->X_op == O_big
1048 && expressionP->X_add_number > 0)
1050 int i;
1052 if (c == '~' || c == '-')
1054 for (i = 0; i < expressionP->X_add_number; ++i)
1055 generic_bignum[i] = ~generic_bignum[i];
1057 /* Extend the bignum to at least the size of .octa. */
1058 if (expressionP->X_add_number < SIZE_OF_LARGE_NUMBER)
1060 expressionP->X_add_number = SIZE_OF_LARGE_NUMBER;
1061 for (; i < expressionP->X_add_number; ++i)
1062 generic_bignum[i] = ~(LITTLENUM_TYPE) 0;
1065 if (c == '-')
1066 for (i = 0; i < expressionP->X_add_number; ++i)
1068 generic_bignum[i] += 1;
1069 if (generic_bignum[i])
1070 break;
1073 else if (c == '!')
1075 for (i = 0; i < expressionP->X_add_number; ++i)
1076 if (generic_bignum[i] != 0)
1077 break;
1078 expressionP->X_add_number = i >= expressionP->X_add_number;
1079 expressionP->X_op = O_constant;
1080 expressionP->X_unsigned = 1;
1083 else if (expressionP->X_op != O_illegal
1084 && expressionP->X_op != O_absent)
1086 if (c != '+')
1088 expressionP->X_add_symbol = make_expr_symbol (expressionP);
1089 if (c == '-')
1090 expressionP->X_op = O_uminus;
1091 else if (c == '~' || c == '"')
1092 expressionP->X_op = O_bit_not;
1093 else
1094 expressionP->X_op = O_logical_not;
1095 expressionP->X_add_number = 0;
1098 else
1099 as_warn (_("Unary operator %c ignored because bad operand follows"),
1102 break;
1104 #if defined (DOLLAR_DOT) || defined (TC_M68K)
1105 case '$':
1106 /* '$' is the program counter when in MRI mode, or when
1107 DOLLAR_DOT is defined. */
1108 #ifndef DOLLAR_DOT
1109 if (! flag_m68k_mri)
1110 goto de_fault;
1111 #endif
1112 if (DOLLAR_AMBIGU && hex_p (*input_line_pointer))
1114 /* In MRI mode and on Z80, '$' is also used as the prefix
1115 for a hexadecimal constant. */
1116 integer_constant (16, expressionP);
1117 break;
1120 if (is_part_of_name (*input_line_pointer))
1121 goto isname;
1123 current_location (expressionP);
1124 break;
1125 #endif
1127 case '.':
1128 if (!is_part_of_name (*input_line_pointer))
1130 current_location (expressionP);
1131 break;
1133 else if ((strncasecmp (input_line_pointer, "startof.", 8) == 0
1134 && ! is_part_of_name (input_line_pointer[8]))
1135 || (strncasecmp (input_line_pointer, "sizeof.", 7) == 0
1136 && ! is_part_of_name (input_line_pointer[7])))
1138 int start;
1140 start = (input_line_pointer[1] == 't'
1141 || input_line_pointer[1] == 'T');
1142 input_line_pointer += start ? 8 : 7;
1143 SKIP_WHITESPACE ();
1144 if (*input_line_pointer != '(')
1145 as_bad (_("syntax error in .startof. or .sizeof."));
1146 else
1148 char *buf;
1150 ++input_line_pointer;
1151 SKIP_WHITESPACE ();
1152 name = input_line_pointer;
1153 c = get_symbol_end ();
1155 buf = (char *) xmalloc (strlen (name) + 10);
1156 if (start)
1157 sprintf (buf, ".startof.%s", name);
1158 else
1159 sprintf (buf, ".sizeof.%s", name);
1160 symbolP = symbol_make (buf);
1161 free (buf);
1163 expressionP->X_op = O_symbol;
1164 expressionP->X_add_symbol = symbolP;
1165 expressionP->X_add_number = 0;
1167 *input_line_pointer = c;
1168 SKIP_WHITESPACE ();
1169 if (*input_line_pointer != ')')
1170 as_bad (_("syntax error in .startof. or .sizeof."));
1171 else
1172 ++input_line_pointer;
1174 break;
1176 else
1178 goto isname;
1181 case ',':
1182 eol:
1183 /* Can't imagine any other kind of operand. */
1184 expressionP->X_op = O_absent;
1185 input_line_pointer--;
1186 break;
1188 #ifdef TC_M68K
1189 case '%':
1190 if (! flag_m68k_mri)
1191 goto de_fault;
1192 integer_constant (2, expressionP);
1193 break;
1195 case '@':
1196 if (! flag_m68k_mri)
1197 goto de_fault;
1198 integer_constant (8, expressionP);
1199 break;
1201 case ':':
1202 if (! flag_m68k_mri)
1203 goto de_fault;
1205 /* In MRI mode, this is a floating point constant represented
1206 using hexadecimal digits. */
1208 ++input_line_pointer;
1209 integer_constant (16, expressionP);
1210 break;
1212 case '*':
1213 if (! flag_m68k_mri || is_part_of_name (*input_line_pointer))
1214 goto de_fault;
1216 current_location (expressionP);
1217 break;
1218 #endif
1220 default:
1221 #if defined(md_need_index_operator) || defined(TC_M68K)
1222 de_fault:
1223 #endif
1224 if (is_name_beginner (c)) /* Here if did not begin with a digit. */
1226 /* Identifier begins here.
1227 This is kludged for speed, so code is repeated. */
1228 isname:
1229 name = --input_line_pointer;
1230 c = get_symbol_end ();
1232 #ifdef md_operator
1234 operatorT op = md_operator (name, 1, &c);
1236 switch (op)
1238 case O_uminus:
1239 *input_line_pointer = c;
1240 c = '-';
1241 goto unary;
1242 case O_bit_not:
1243 *input_line_pointer = c;
1244 c = '~';
1245 goto unary;
1246 case O_logical_not:
1247 *input_line_pointer = c;
1248 c = '!';
1249 goto unary;
1250 case O_illegal:
1251 as_bad (_("invalid use of operator \"%s\""), name);
1252 break;
1253 default:
1254 break;
1256 if (op != O_absent && op != O_illegal)
1258 *input_line_pointer = c;
1259 expr (9, expressionP, mode);
1260 expressionP->X_add_symbol = make_expr_symbol (expressionP);
1261 expressionP->X_op_symbol = NULL;
1262 expressionP->X_add_number = 0;
1263 expressionP->X_op = op;
1264 break;
1267 #endif
1269 #ifdef md_parse_name
1270 /* This is a hook for the backend to parse certain names
1271 specially in certain contexts. If a name always has a
1272 specific value, it can often be handled by simply
1273 entering it in the symbol table. */
1274 if (md_parse_name (name, expressionP, mode, &c))
1276 *input_line_pointer = c;
1277 break;
1279 #endif
1281 #ifdef TC_I960
1282 /* The MRI i960 assembler permits
1283 lda sizeof code,g13
1284 FIXME: This should use md_parse_name. */
1285 if (flag_mri
1286 && (strcasecmp (name, "sizeof") == 0
1287 || strcasecmp (name, "startof") == 0))
1289 int start;
1290 char *buf;
1292 start = (name[1] == 't'
1293 || name[1] == 'T');
1295 *input_line_pointer = c;
1296 SKIP_WHITESPACE ();
1298 name = input_line_pointer;
1299 c = get_symbol_end ();
1301 buf = (char *) xmalloc (strlen (name) + 10);
1302 if (start)
1303 sprintf (buf, ".startof.%s", name);
1304 else
1305 sprintf (buf, ".sizeof.%s", name);
1306 symbolP = symbol_make (buf);
1307 free (buf);
1309 expressionP->X_op = O_symbol;
1310 expressionP->X_add_symbol = symbolP;
1311 expressionP->X_add_number = 0;
1313 *input_line_pointer = c;
1314 SKIP_WHITESPACE ();
1316 break;
1318 #endif
1320 symbolP = symbol_find_or_make (name);
1322 /* If we have an absolute symbol or a reg, then we know its
1323 value now. */
1324 segment = S_GET_SEGMENT (symbolP);
1325 if (mode != expr_defer
1326 && segment == absolute_section
1327 && !S_FORCE_RELOC (symbolP, 0))
1329 expressionP->X_op = O_constant;
1330 expressionP->X_add_number = S_GET_VALUE (symbolP);
1332 else if (mode != expr_defer && segment == reg_section)
1334 expressionP->X_op = O_register;
1335 expressionP->X_add_number = S_GET_VALUE (symbolP);
1337 else
1339 expressionP->X_op = O_symbol;
1340 expressionP->X_add_symbol = symbolP;
1341 expressionP->X_add_number = 0;
1343 *input_line_pointer = c;
1345 else
1347 /* Let the target try to parse it. Success is indicated by changing
1348 the X_op field to something other than O_absent and pointing
1349 input_line_pointer past the expression. If it can't parse the
1350 expression, X_op and input_line_pointer should be unchanged. */
1351 expressionP->X_op = O_absent;
1352 --input_line_pointer;
1353 md_operand (expressionP);
1354 if (expressionP->X_op == O_absent)
1356 ++input_line_pointer;
1357 as_bad (_("bad expression"));
1358 expressionP->X_op = O_constant;
1359 expressionP->X_add_number = 0;
1362 break;
1365 /* It is more 'efficient' to clean up the expressionS when they are
1366 created. Doing it here saves lines of code. */
1367 clean_up_expression (expressionP);
1368 SKIP_WHITESPACE (); /* -> 1st char after operand. */
1369 know (*input_line_pointer != ' ');
1371 /* The PA port needs this information. */
1372 if (expressionP->X_add_symbol)
1373 symbol_mark_used (expressionP->X_add_symbol);
1375 if (mode != expr_defer)
1377 expressionP->X_add_symbol
1378 = symbol_clone_if_forward_ref (expressionP->X_add_symbol);
1379 expressionP->X_op_symbol
1380 = symbol_clone_if_forward_ref (expressionP->X_op_symbol);
1383 switch (expressionP->X_op)
1385 default:
1386 return absolute_section;
1387 case O_symbol:
1388 return S_GET_SEGMENT (expressionP->X_add_symbol);
1389 case O_register:
1390 return reg_section;
1394 /* Internal. Simplify a struct expression for use by expr (). */
1396 /* In: address of an expressionS.
1397 The X_op field of the expressionS may only take certain values.
1398 Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
1400 Out: expressionS may have been modified:
1401 Unused fields zeroed to help expr (). */
1403 static void
1404 clean_up_expression (expressionS *expressionP)
1406 switch (expressionP->X_op)
1408 case O_illegal:
1409 case O_absent:
1410 expressionP->X_add_number = 0;
1411 /* Fall through. */
1412 case O_big:
1413 case O_constant:
1414 case O_register:
1415 expressionP->X_add_symbol = NULL;
1416 /* Fall through. */
1417 case O_symbol:
1418 case O_uminus:
1419 case O_bit_not:
1420 expressionP->X_op_symbol = NULL;
1421 break;
1422 default:
1423 break;
1427 /* Expression parser. */
1429 /* We allow an empty expression, and just assume (absolute,0) silently.
1430 Unary operators and parenthetical expressions are treated as operands.
1431 As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
1433 We used to do an aho/ullman shift-reduce parser, but the logic got so
1434 warped that I flushed it and wrote a recursive-descent parser instead.
1435 Now things are stable, would anybody like to write a fast parser?
1436 Most expressions are either register (which does not even reach here)
1437 or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
1438 So I guess it doesn't really matter how inefficient more complex expressions
1439 are parsed.
1441 After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
1442 Also, we have consumed any leading or trailing spaces (operand does that)
1443 and done all intervening operators.
1445 This returns the segment of the result, which will be
1446 absolute_section or the segment of a symbol. */
1448 #undef __
1449 #define __ O_illegal
1450 #ifndef O_SINGLE_EQ
1451 #define O_SINGLE_EQ O_illegal
1452 #endif
1454 /* Maps ASCII -> operators. */
1455 static const operatorT op_encoding[256] = {
1456 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1457 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1459 __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __,
1460 __, __, O_multiply, O_add, __, O_subtract, __, O_divide,
1461 __, __, __, __, __, __, __, __,
1462 __, __, __, __, O_lt, O_SINGLE_EQ, O_gt, __,
1463 __, __, __, __, __, __, __, __,
1464 __, __, __, __, __, __, __, __,
1465 __, __, __, __, __, __, __, __,
1466 __, __, __,
1467 #ifdef NEED_INDEX_OPERATOR
1468 O_index,
1469 #else
1471 #endif
1472 __, __, O_bit_exclusive_or, __,
1473 __, __, __, __, __, __, __, __,
1474 __, __, __, __, __, __, __, __,
1475 __, __, __, __, __, __, __, __,
1476 __, __, __, __, O_bit_inclusive_or, __, __, __,
1478 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1479 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1480 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1481 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1482 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1483 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1484 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1485 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
1488 /* Rank Examples
1489 0 operand, (expression)
1490 1 ||
1491 2 &&
1492 3 == <> < <= >= >
1493 4 + -
1494 5 used for * / % in MRI mode
1495 6 & ^ ! |
1496 7 * / % << >>
1497 8 unary - unary ~
1499 static operator_rankT op_rank[O_max] = {
1500 0, /* O_illegal */
1501 0, /* O_absent */
1502 0, /* O_constant */
1503 0, /* O_symbol */
1504 0, /* O_symbol_rva */
1505 0, /* O_register */
1506 0, /* O_big */
1507 9, /* O_uminus */
1508 9, /* O_bit_not */
1509 9, /* O_logical_not */
1510 8, /* O_multiply */
1511 8, /* O_divide */
1512 8, /* O_modulus */
1513 8, /* O_left_shift */
1514 8, /* O_right_shift */
1515 7, /* O_bit_inclusive_or */
1516 7, /* O_bit_or_not */
1517 7, /* O_bit_exclusive_or */
1518 7, /* O_bit_and */
1519 5, /* O_add */
1520 5, /* O_subtract */
1521 4, /* O_eq */
1522 4, /* O_ne */
1523 4, /* O_lt */
1524 4, /* O_le */
1525 4, /* O_ge */
1526 4, /* O_gt */
1527 3, /* O_logical_and */
1528 2, /* O_logical_or */
1529 1, /* O_index */
1532 /* Unfortunately, in MRI mode for the m68k, multiplication and
1533 division have lower precedence than the bit wise operators. This
1534 function sets the operator precedences correctly for the current
1535 mode. Also, MRI uses a different bit_not operator, and this fixes
1536 that as well. */
1538 #define STANDARD_MUL_PRECEDENCE 8
1539 #define MRI_MUL_PRECEDENCE 6
1541 void
1542 expr_set_precedence (void)
1544 if (flag_m68k_mri)
1546 op_rank[O_multiply] = MRI_MUL_PRECEDENCE;
1547 op_rank[O_divide] = MRI_MUL_PRECEDENCE;
1548 op_rank[O_modulus] = MRI_MUL_PRECEDENCE;
1550 else
1552 op_rank[O_multiply] = STANDARD_MUL_PRECEDENCE;
1553 op_rank[O_divide] = STANDARD_MUL_PRECEDENCE;
1554 op_rank[O_modulus] = STANDARD_MUL_PRECEDENCE;
1558 void
1559 expr_set_rank (operatorT op, operator_rankT rank)
1561 gas_assert (op >= O_md1 && op < ARRAY_SIZE (op_rank));
1562 op_rank[op] = rank;
1565 /* Initialize the expression parser. */
1567 void
1568 expr_begin (void)
1570 expr_set_precedence ();
1572 /* Verify that X_op field is wide enough. */
1574 expressionS e;
1575 e.X_op = O_max;
1576 gas_assert (e.X_op == O_max);
1580 /* Return the encoding for the operator at INPUT_LINE_POINTER, and
1581 sets NUM_CHARS to the number of characters in the operator.
1582 Does not advance INPUT_LINE_POINTER. */
1584 static inline operatorT
1585 operatorf (int *num_chars)
1587 int c;
1588 operatorT ret;
1590 c = *input_line_pointer & 0xff;
1591 *num_chars = 1;
1593 if (is_end_of_line[c])
1594 return O_illegal;
1596 #ifdef md_operator
1597 if (is_name_beginner (c))
1599 char *name = input_line_pointer;
1600 char ec = get_symbol_end ();
1602 ret = md_operator (name, 2, &ec);
1603 switch (ret)
1605 case O_absent:
1606 *input_line_pointer = ec;
1607 input_line_pointer = name;
1608 break;
1609 case O_uminus:
1610 case O_bit_not:
1611 case O_logical_not:
1612 as_bad (_("invalid use of operator \"%s\""), name);
1613 ret = O_illegal;
1614 /* FALLTHROUGH */
1615 default:
1616 *input_line_pointer = ec;
1617 *num_chars = input_line_pointer - name;
1618 input_line_pointer = name;
1619 return ret;
1622 #endif
1624 switch (c)
1626 default:
1627 ret = op_encoding[c];
1628 #ifdef md_operator
1629 if (ret == O_illegal)
1631 char *start = input_line_pointer;
1633 ret = md_operator (NULL, 2, NULL);
1634 if (ret != O_illegal)
1635 *num_chars = input_line_pointer - start;
1636 input_line_pointer = start;
1638 #endif
1639 return ret;
1641 case '+':
1642 case '-':
1643 return op_encoding[c];
1645 case '<':
1646 switch (input_line_pointer[1])
1648 default:
1649 return op_encoding[c];
1650 case '<':
1651 ret = O_left_shift;
1652 break;
1653 case '>':
1654 ret = O_ne;
1655 break;
1656 case '=':
1657 ret = O_le;
1658 break;
1660 *num_chars = 2;
1661 return ret;
1663 case '=':
1664 if (input_line_pointer[1] != '=')
1665 return op_encoding[c];
1667 *num_chars = 2;
1668 return O_eq;
1670 case '>':
1671 switch (input_line_pointer[1])
1673 default:
1674 return op_encoding[c];
1675 case '>':
1676 ret = O_right_shift;
1677 break;
1678 case '=':
1679 ret = O_ge;
1680 break;
1682 *num_chars = 2;
1683 return ret;
1685 case '!':
1686 switch (input_line_pointer[1])
1688 case '!':
1689 /* We accept !! as equivalent to ^ for MRI compatibility. */
1690 *num_chars = 2;
1691 return O_bit_exclusive_or;
1692 case '=':
1693 /* We accept != as equivalent to <>. */
1694 *num_chars = 2;
1695 return O_ne;
1696 default:
1697 if (flag_m68k_mri)
1698 return O_bit_inclusive_or;
1699 return op_encoding[c];
1702 case '|':
1703 if (input_line_pointer[1] != '|')
1704 return op_encoding[c];
1706 *num_chars = 2;
1707 return O_logical_or;
1709 case '&':
1710 if (input_line_pointer[1] != '&')
1711 return op_encoding[c];
1713 *num_chars = 2;
1714 return O_logical_and;
1717 /* NOTREACHED */
1720 /* Parse an expression. */
1722 segT
1723 expr (int rankarg, /* Larger # is higher rank. */
1724 expressionS *resultP, /* Deliver result here. */
1725 enum expr_mode mode /* Controls behavior. */)
1727 operator_rankT rank = (operator_rankT) rankarg;
1728 segT retval;
1729 expressionS right;
1730 operatorT op_left;
1731 operatorT op_right;
1732 int op_chars;
1734 know (rankarg >= 0);
1736 /* Save the value of dot for the fixup code. */
1737 if (rank == 0)
1738 dot_value = frag_now_fix ();
1740 retval = operand (resultP, mode);
1742 /* operand () gobbles spaces. */
1743 know (*input_line_pointer != ' ');
1745 op_left = operatorf (&op_chars);
1746 while (op_left != O_illegal && op_rank[(int) op_left] > rank)
1748 segT rightseg;
1749 bfd_vma frag_off;
1751 input_line_pointer += op_chars; /* -> after operator. */
1753 right.X_md = 0;
1754 rightseg = expr (op_rank[(int) op_left], &right, mode);
1755 if (right.X_op == O_absent)
1757 as_warn (_("missing operand; zero assumed"));
1758 right.X_op = O_constant;
1759 right.X_add_number = 0;
1760 right.X_add_symbol = NULL;
1761 right.X_op_symbol = NULL;
1764 know (*input_line_pointer != ' ');
1766 if (op_left == O_index)
1768 if (*input_line_pointer != ']')
1769 as_bad ("missing right bracket");
1770 else
1772 ++input_line_pointer;
1773 SKIP_WHITESPACE ();
1777 op_right = operatorf (&op_chars);
1779 know (op_right == O_illegal || op_left == O_index
1780 || op_rank[(int) op_right] <= op_rank[(int) op_left]);
1781 know ((int) op_left >= (int) O_multiply);
1782 #ifndef md_operator
1783 know ((int) op_left <= (int) O_index);
1784 #else
1785 know ((int) op_left < (int) O_max);
1786 #endif
1788 /* input_line_pointer->after right-hand quantity. */
1789 /* left-hand quantity in resultP. */
1790 /* right-hand quantity in right. */
1791 /* operator in op_left. */
1793 if (resultP->X_op == O_big)
1795 if (resultP->X_add_number > 0)
1796 as_warn (_("left operand is a bignum; integer 0 assumed"));
1797 else
1798 as_warn (_("left operand is a float; integer 0 assumed"));
1799 resultP->X_op = O_constant;
1800 resultP->X_add_number = 0;
1801 resultP->X_add_symbol = NULL;
1802 resultP->X_op_symbol = NULL;
1804 if (right.X_op == O_big)
1806 if (right.X_add_number > 0)
1807 as_warn (_("right operand is a bignum; integer 0 assumed"));
1808 else
1809 as_warn (_("right operand is a float; integer 0 assumed"));
1810 right.X_op = O_constant;
1811 right.X_add_number = 0;
1812 right.X_add_symbol = NULL;
1813 right.X_op_symbol = NULL;
1816 /* Optimize common cases. */
1817 #ifdef md_optimize_expr
1818 if (md_optimize_expr (resultP, op_left, &right))
1820 /* Skip. */
1823 else
1824 #endif
1825 #ifndef md_register_arithmetic
1826 # define md_register_arithmetic 1
1827 #endif
1828 if (op_left == O_add && right.X_op == O_constant
1829 && (md_register_arithmetic || resultP->X_op != O_register))
1831 /* X + constant. */
1832 resultP->X_add_number += right.X_add_number;
1834 /* This case comes up in PIC code. */
1835 else if (op_left == O_subtract
1836 && right.X_op == O_symbol
1837 && resultP->X_op == O_symbol
1838 && retval == rightseg
1839 #ifdef md_allow_local_subtract
1840 && md_allow_local_subtract (resultP, & right, rightseg)
1841 #endif
1842 && ((SEG_NORMAL (rightseg)
1843 && !S_FORCE_RELOC (resultP->X_add_symbol, 0)
1844 && !S_FORCE_RELOC (right.X_add_symbol, 0))
1845 || right.X_add_symbol == resultP->X_add_symbol)
1846 && frag_offset_fixed_p (symbol_get_frag (resultP->X_add_symbol),
1847 symbol_get_frag (right.X_add_symbol),
1848 &frag_off))
1850 resultP->X_add_number -= right.X_add_number;
1851 resultP->X_add_number -= frag_off / OCTETS_PER_BYTE;
1852 resultP->X_add_number += (S_GET_VALUE (resultP->X_add_symbol)
1853 - S_GET_VALUE (right.X_add_symbol));
1854 resultP->X_op = O_constant;
1855 resultP->X_add_symbol = 0;
1857 else if (op_left == O_subtract && right.X_op == O_constant
1858 && (md_register_arithmetic || resultP->X_op != O_register))
1860 /* X - constant. */
1861 resultP->X_add_number -= right.X_add_number;
1863 else if (op_left == O_add && resultP->X_op == O_constant
1864 && (md_register_arithmetic || right.X_op != O_register))
1866 /* Constant + X. */
1867 resultP->X_op = right.X_op;
1868 resultP->X_add_symbol = right.X_add_symbol;
1869 resultP->X_op_symbol = right.X_op_symbol;
1870 resultP->X_add_number += right.X_add_number;
1871 retval = rightseg;
1873 else if (resultP->X_op == O_constant && right.X_op == O_constant)
1875 /* Constant OP constant. */
1876 offsetT v = right.X_add_number;
1877 if (v == 0 && (op_left == O_divide || op_left == O_modulus))
1879 as_warn (_("division by zero"));
1880 v = 1;
1882 if ((valueT) v >= sizeof(valueT) * CHAR_BIT
1883 && (op_left == O_left_shift || op_left == O_right_shift))
1885 as_warn_value_out_of_range (_("shift count"), v, 0,
1886 sizeof(valueT) * CHAR_BIT - 1,
1887 NULL, 0);
1888 resultP->X_add_number = v = 0;
1890 switch (op_left)
1892 default: goto general;
1893 case O_multiply: resultP->X_add_number *= v; break;
1894 case O_divide: resultP->X_add_number /= v; break;
1895 case O_modulus: resultP->X_add_number %= v; break;
1896 case O_left_shift: resultP->X_add_number <<= v; break;
1897 case O_right_shift:
1898 /* We always use unsigned shifts, to avoid relying on
1899 characteristics of the compiler used to compile gas. */
1900 resultP->X_add_number =
1901 (offsetT) ((valueT) resultP->X_add_number >> (valueT) v);
1902 break;
1903 case O_bit_inclusive_or: resultP->X_add_number |= v; break;
1904 case O_bit_or_not: resultP->X_add_number |= ~v; break;
1905 case O_bit_exclusive_or: resultP->X_add_number ^= v; break;
1906 case O_bit_and: resultP->X_add_number &= v; break;
1907 /* Constant + constant (O_add) is handled by the
1908 previous if statement for constant + X, so is omitted
1909 here. */
1910 case O_subtract: resultP->X_add_number -= v; break;
1911 case O_eq:
1912 resultP->X_add_number =
1913 resultP->X_add_number == v ? ~ (offsetT) 0 : 0;
1914 break;
1915 case O_ne:
1916 resultP->X_add_number =
1917 resultP->X_add_number != v ? ~ (offsetT) 0 : 0;
1918 break;
1919 case O_lt:
1920 resultP->X_add_number =
1921 resultP->X_add_number < v ? ~ (offsetT) 0 : 0;
1922 break;
1923 case O_le:
1924 resultP->X_add_number =
1925 resultP->X_add_number <= v ? ~ (offsetT) 0 : 0;
1926 break;
1927 case O_ge:
1928 resultP->X_add_number =
1929 resultP->X_add_number >= v ? ~ (offsetT) 0 : 0;
1930 break;
1931 case O_gt:
1932 resultP->X_add_number =
1933 resultP->X_add_number > v ? ~ (offsetT) 0 : 0;
1934 break;
1935 case O_logical_and:
1936 resultP->X_add_number = resultP->X_add_number && v;
1937 break;
1938 case O_logical_or:
1939 resultP->X_add_number = resultP->X_add_number || v;
1940 break;
1943 else if (resultP->X_op == O_symbol
1944 && right.X_op == O_symbol
1945 && (op_left == O_add
1946 || op_left == O_subtract
1947 || (resultP->X_add_number == 0
1948 && right.X_add_number == 0)))
1950 /* Symbol OP symbol. */
1951 resultP->X_op = op_left;
1952 resultP->X_op_symbol = right.X_add_symbol;
1953 if (op_left == O_add)
1954 resultP->X_add_number += right.X_add_number;
1955 else if (op_left == O_subtract)
1957 resultP->X_add_number -= right.X_add_number;
1958 if (retval == rightseg
1959 && SEG_NORMAL (retval)
1960 && !S_FORCE_RELOC (resultP->X_add_symbol, 0)
1961 && !S_FORCE_RELOC (right.X_add_symbol, 0))
1963 retval = absolute_section;
1964 rightseg = absolute_section;
1968 else
1970 general:
1971 /* The general case. */
1972 resultP->X_add_symbol = make_expr_symbol (resultP);
1973 resultP->X_op_symbol = make_expr_symbol (&right);
1974 resultP->X_op = op_left;
1975 resultP->X_add_number = 0;
1976 resultP->X_unsigned = 1;
1979 if (retval != rightseg)
1981 if (retval == undefined_section)
1983 else if (rightseg == undefined_section)
1984 retval = rightseg;
1985 else if (retval == expr_section)
1987 else if (rightseg == expr_section)
1988 retval = rightseg;
1989 else if (retval == reg_section)
1991 else if (rightseg == reg_section)
1992 retval = rightseg;
1993 else if (rightseg == absolute_section)
1995 else if (retval == absolute_section)
1996 retval = rightseg;
1997 #ifdef DIFF_EXPR_OK
1998 else if (op_left == O_subtract)
2000 #endif
2001 else
2002 as_bad (_("operation combines symbols in different segments"));
2005 op_left = op_right;
2006 } /* While next operator is >= this rank. */
2008 /* The PA port needs this information. */
2009 if (resultP->X_add_symbol)
2010 symbol_mark_used (resultP->X_add_symbol);
2012 if (rank == 0 && mode == expr_evaluate)
2013 resolve_expression (resultP);
2015 return resultP->X_op == O_constant ? absolute_section : retval;
2018 /* Resolve an expression without changing any symbols/sub-expressions
2019 used. */
2022 resolve_expression (expressionS *expressionP)
2024 /* Help out with CSE. */
2025 valueT final_val = expressionP->X_add_number;
2026 symbolS *add_symbol = expressionP->X_add_symbol;
2027 symbolS *orig_add_symbol = add_symbol;
2028 symbolS *op_symbol = expressionP->X_op_symbol;
2029 operatorT op = expressionP->X_op;
2030 valueT left, right;
2031 segT seg_left, seg_right;
2032 fragS *frag_left, *frag_right;
2033 bfd_vma frag_off;
2035 switch (op)
2037 default:
2038 return 0;
2040 case O_constant:
2041 case O_register:
2042 left = 0;
2043 break;
2045 case O_symbol:
2046 case O_symbol_rva:
2047 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left))
2048 return 0;
2050 break;
2052 case O_uminus:
2053 case O_bit_not:
2054 case O_logical_not:
2055 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left))
2056 return 0;
2058 if (seg_left != absolute_section)
2059 return 0;
2061 if (op == O_logical_not)
2062 left = !left;
2063 else if (op == O_uminus)
2064 left = -left;
2065 else
2066 left = ~left;
2067 op = O_constant;
2068 break;
2070 case O_multiply:
2071 case O_divide:
2072 case O_modulus:
2073 case O_left_shift:
2074 case O_right_shift:
2075 case O_bit_inclusive_or:
2076 case O_bit_or_not:
2077 case O_bit_exclusive_or:
2078 case O_bit_and:
2079 case O_add:
2080 case O_subtract:
2081 case O_eq:
2082 case O_ne:
2083 case O_lt:
2084 case O_le:
2085 case O_ge:
2086 case O_gt:
2087 case O_logical_and:
2088 case O_logical_or:
2089 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left)
2090 || !snapshot_symbol (&op_symbol, &right, &seg_right, &frag_right))
2091 return 0;
2093 /* Simplify addition or subtraction of a constant by folding the
2094 constant into X_add_number. */
2095 if (op == O_add)
2097 if (seg_right == absolute_section)
2099 final_val += right;
2100 op = O_symbol;
2101 break;
2103 else if (seg_left == absolute_section)
2105 final_val += left;
2106 left = right;
2107 seg_left = seg_right;
2108 add_symbol = op_symbol;
2109 orig_add_symbol = expressionP->X_op_symbol;
2110 op = O_symbol;
2111 break;
2114 else if (op == O_subtract)
2116 if (seg_right == absolute_section)
2118 final_val -= right;
2119 op = O_symbol;
2120 break;
2124 /* Equality and non-equality tests are permitted on anything.
2125 Subtraction, and other comparison operators are permitted if
2126 both operands are in the same section.
2127 Shifts by constant zero are permitted on anything.
2128 Multiplies, bit-ors, and bit-ands with constant zero are
2129 permitted on anything.
2130 Multiplies and divides by constant one are permitted on
2131 anything.
2132 Binary operations with both operands being the same register
2133 or undefined symbol are permitted if the result doesn't depend
2134 on the input value.
2135 Otherwise, both operands must be absolute. We already handled
2136 the case of addition or subtraction of a constant above. */
2137 frag_off = 0;
2138 if (!(seg_left == absolute_section
2139 && seg_right == absolute_section)
2140 && !(op == O_eq || op == O_ne)
2141 && !((op == O_subtract
2142 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
2143 && seg_left == seg_right
2144 && (finalize_syms
2145 || frag_offset_fixed_p (frag_left, frag_right, &frag_off))
2146 && (seg_left != reg_section || left == right)
2147 && (seg_left != undefined_section || add_symbol == op_symbol)))
2149 if ((seg_left == absolute_section && left == 0)
2150 || (seg_right == absolute_section && right == 0))
2152 if (op == O_bit_exclusive_or || op == O_bit_inclusive_or)
2154 if (!(seg_right == absolute_section && right == 0))
2156 seg_left = seg_right;
2157 left = right;
2158 add_symbol = op_symbol;
2159 orig_add_symbol = expressionP->X_op_symbol;
2161 op = O_symbol;
2162 break;
2164 else if (op == O_left_shift || op == O_right_shift)
2166 if (!(seg_left == absolute_section && left == 0))
2168 op = O_symbol;
2169 break;
2172 else if (op != O_multiply
2173 && op != O_bit_or_not && op != O_bit_and)
2174 return 0;
2176 else if (op == O_multiply
2177 && seg_left == absolute_section && left == 1)
2179 seg_left = seg_right;
2180 left = right;
2181 add_symbol = op_symbol;
2182 orig_add_symbol = expressionP->X_op_symbol;
2183 op = O_symbol;
2184 break;
2186 else if ((op == O_multiply || op == O_divide)
2187 && seg_right == absolute_section && right == 1)
2189 op = O_symbol;
2190 break;
2192 else if (!(left == right
2193 && ((seg_left == reg_section && seg_right == reg_section)
2194 || (seg_left == undefined_section
2195 && seg_right == undefined_section
2196 && add_symbol == op_symbol))))
2197 return 0;
2198 else if (op == O_bit_and || op == O_bit_inclusive_or)
2200 op = O_symbol;
2201 break;
2203 else if (op != O_bit_exclusive_or && op != O_bit_or_not)
2204 return 0;
2207 right += frag_off / OCTETS_PER_BYTE;
2208 switch (op)
2210 case O_add: left += right; break;
2211 case O_subtract: left -= right; break;
2212 case O_multiply: left *= right; break;
2213 case O_divide:
2214 if (right == 0)
2215 return 0;
2216 left = (offsetT) left / (offsetT) right;
2217 break;
2218 case O_modulus:
2219 if (right == 0)
2220 return 0;
2221 left = (offsetT) left % (offsetT) right;
2222 break;
2223 case O_left_shift: left <<= right; break;
2224 case O_right_shift: left >>= right; break;
2225 case O_bit_inclusive_or: left |= right; break;
2226 case O_bit_or_not: left |= ~right; break;
2227 case O_bit_exclusive_or: left ^= right; break;
2228 case O_bit_and: left &= right; break;
2229 case O_eq:
2230 case O_ne:
2231 left = (left == right
2232 && seg_left == seg_right
2233 && (finalize_syms || frag_left == frag_right)
2234 && (seg_left != undefined_section
2235 || add_symbol == op_symbol)
2236 ? ~ (valueT) 0 : 0);
2237 if (op == O_ne)
2238 left = ~left;
2239 break;
2240 case O_lt:
2241 left = (offsetT) left < (offsetT) right ? ~ (valueT) 0 : 0;
2242 break;
2243 case O_le:
2244 left = (offsetT) left <= (offsetT) right ? ~ (valueT) 0 : 0;
2245 break;
2246 case O_ge:
2247 left = (offsetT) left >= (offsetT) right ? ~ (valueT) 0 : 0;
2248 break;
2249 case O_gt:
2250 left = (offsetT) left > (offsetT) right ? ~ (valueT) 0 : 0;
2251 break;
2252 case O_logical_and: left = left && right; break;
2253 case O_logical_or: left = left || right; break;
2254 default: abort ();
2257 op = O_constant;
2258 break;
2261 if (op == O_symbol)
2263 if (seg_left == absolute_section)
2264 op = O_constant;
2265 else if (seg_left == reg_section && final_val == 0)
2266 op = O_register;
2267 else if (!symbol_same_p (add_symbol, orig_add_symbol))
2268 final_val += left;
2269 expressionP->X_add_symbol = add_symbol;
2271 expressionP->X_op = op;
2273 if (op == O_constant || op == O_register)
2274 final_val += left;
2275 expressionP->X_add_number = final_val;
2277 return 1;
2280 /* This lives here because it belongs equally in expr.c & read.c.
2281 expr.c is just a branch office read.c anyway, and putting it
2282 here lessens the crowd at read.c.
2284 Assume input_line_pointer is at start of symbol name.
2285 Advance input_line_pointer past symbol name.
2286 Turn that character into a '\0', returning its former value.
2287 This allows a string compare (RMS wants symbol names to be strings)
2288 of the symbol name.
2289 There will always be a char following symbol name, because all good
2290 lines end in end-of-line. */
2292 char
2293 get_symbol_end (void)
2295 char c;
2297 /* We accept \001 in a name in case this is being called with a
2298 constructed string. */
2299 if (is_name_beginner (c = *input_line_pointer++) || c == '\001')
2301 while (is_part_of_name (c = *input_line_pointer++)
2302 || c == '\001')
2304 if (is_name_ender (c))
2305 c = *input_line_pointer++;
2307 *--input_line_pointer = 0;
2308 return (c);
2311 unsigned int
2312 get_single_number (void)
2314 expressionS exp;
2315 operand (&exp, expr_normal);
2316 return exp.X_add_number;