1 /* expr.c -operands, expressions-
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
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 2, or (at your option)
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, 59 Temple Place - Suite 330, Boston, MA
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. */
29 #define min(a, b) ((a) < (b) ? (a) : (b))
32 #include "safe-ctype.h"
35 static void floating_constant (expressionS
* expressionP
);
36 static valueT
generic_bignum_to_int32 (void);
38 static valueT
generic_bignum_to_int64 (void);
40 static void integer_constant (int radix
, expressionS
* expressionP
);
41 static void mri_char_constant (expressionS
*);
42 static void current_location (expressionS
*);
43 static void clean_up_expression (expressionS
* expressionP
);
44 static segT
operand (expressionS
*);
45 static operatorT
operator (int *);
47 extern const char EXP_CHARS
[], FLT_CHARS
[];
49 /* We keep a mapping of expression symbols to file positions, so that
50 we can provide better error messages. */
52 struct expr_symbol_line
{
53 struct expr_symbol_line
*next
;
59 static struct expr_symbol_line
*expr_symbol_lines
;
61 /* Build a dummy symbol to hold a complex expression. This is how we
62 build expressions up out of other expressions. The symbol is put
63 into the fake section expr_section. */
66 make_expr_symbol (expressionS
*expressionP
)
70 struct expr_symbol_line
*n
;
72 if (expressionP
->X_op
== O_symbol
73 && expressionP
->X_add_number
== 0)
74 return expressionP
->X_add_symbol
;
76 if (expressionP
->X_op
== O_big
)
78 /* This won't work, because the actual value is stored in
79 generic_floating_point_number or generic_bignum, and we are
80 going to lose it if we haven't already. */
81 if (expressionP
->X_add_number
> 0)
82 as_bad (_("bignum invalid"));
84 as_bad (_("floating point number invalid"));
85 zero
.X_op
= O_constant
;
86 zero
.X_add_number
= 0;
88 clean_up_expression (&zero
);
92 /* Putting constant symbols in absolute_section rather than
93 expr_section is convenient for the old a.out code, for which
94 S_GET_SEGMENT does not always retrieve the value put in by
96 symbolP
= symbol_create (FAKE_LABEL_NAME
,
97 (expressionP
->X_op
== O_constant
100 0, &zero_address_frag
);
101 symbol_set_value_expression (symbolP
, expressionP
);
103 if (expressionP
->X_op
== O_constant
)
104 resolve_symbol_value (symbolP
);
106 n
= (struct expr_symbol_line
*) xmalloc (sizeof *n
);
108 as_where (&n
->file
, &n
->line
);
109 n
->next
= expr_symbol_lines
;
110 expr_symbol_lines
= n
;
115 /* Return the file and line number for an expr symbol. Return
116 non-zero if something was found, 0 if no information is known for
120 expr_symbol_where (symbolS
*sym
, char **pfile
, unsigned int *pline
)
122 register struct expr_symbol_line
*l
;
124 for (l
= expr_symbol_lines
; l
!= NULL
; l
= l
->next
)
137 /* Utilities for building expressions.
138 Since complex expressions are recorded as symbols for use in other
139 expressions these return a symbolS * and not an expressionS *.
140 These explicitly do not take an "add_number" argument. */
141 /* ??? For completeness' sake one might want expr_build_symbol.
142 It would just return its argument. */
144 /* Build an expression for an unsigned constant.
145 The corresponding one for signed constants is missing because
146 there's currently no need for it. One could add an unsigned_p flag
147 but that seems more clumsy. */
150 expr_build_uconstant (offsetT value
)
155 e
.X_add_number
= value
;
157 return make_expr_symbol (&e
);
160 /* Build an expression for OP s1. */
163 expr_build_unary (operatorT op
, symbolS
*s1
)
170 return make_expr_symbol (&e
);
173 /* Build an expression for s1 OP s2. */
176 expr_build_binary (operatorT op
, symbolS
*s1
, symbolS
*s2
)
184 return make_expr_symbol (&e
);
187 /* Build an expression for the current location ('.'). */
190 expr_build_dot (void)
194 current_location (&e
);
195 return make_expr_symbol (&e
);
198 /* Build any floating-point literal here.
199 Also build any bignum literal here. */
201 /* Seems atof_machine can backscan through generic_bignum and hit whatever
202 happens to be loaded before it in memory. And its way too complicated
203 for me to fix right. Thus a hack. JF: Just make generic_bignum bigger,
204 and never write into the early words, thus they'll always be zero.
205 I hate Dean's floating-point code. Bleh. */
206 LITTLENUM_TYPE generic_bignum
[SIZE_OF_LARGE_NUMBER
+ 6];
208 FLONUM_TYPE generic_floating_point_number
= {
209 &generic_bignum
[6], /* low. (JF: Was 0) */
210 &generic_bignum
[SIZE_OF_LARGE_NUMBER
+ 6 - 1], /* high. JF: (added +6) */
216 /* If nonzero, we've been asked to assemble nan, +inf or -inf. */
217 int generic_floating_point_magic
;
220 floating_constant (expressionS
*expressionP
)
222 /* input_line_pointer -> floating-point constant. */
225 error_code
= atof_generic (&input_line_pointer
, ".", EXP_CHARS
,
226 &generic_floating_point_number
);
230 if (error_code
== ERROR_EXPONENT_OVERFLOW
)
232 as_bad (_("bad floating-point constant: exponent overflow"));
236 as_bad (_("bad floating-point constant: unknown error code=%d"),
240 expressionP
->X_op
= O_big
;
241 /* input_line_pointer -> just after constant, which may point to
243 expressionP
->X_add_number
= -1;
247 generic_bignum_to_int32 (void)
250 ((generic_bignum
[1] & LITTLENUM_MASK
) << LITTLENUM_NUMBER_OF_BITS
)
251 | (generic_bignum
[0] & LITTLENUM_MASK
);
252 number
&= 0xffffffff;
258 generic_bignum_to_int64 (void)
261 ((((((((valueT
) generic_bignum
[3] & LITTLENUM_MASK
)
262 << LITTLENUM_NUMBER_OF_BITS
)
263 | ((valueT
) generic_bignum
[2] & LITTLENUM_MASK
))
264 << LITTLENUM_NUMBER_OF_BITS
)
265 | ((valueT
) generic_bignum
[1] & LITTLENUM_MASK
))
266 << LITTLENUM_NUMBER_OF_BITS
)
267 | ((valueT
) generic_bignum
[0] & LITTLENUM_MASK
));
273 integer_constant (int radix
, expressionS
*expressionP
)
275 char *start
; /* Start of number. */
278 valueT number
; /* Offset or (absolute) value. */
279 short int digit
; /* Value of next digit in current radix. */
280 short int maxdig
= 0; /* Highest permitted digit value. */
281 int too_many_digits
= 0; /* If we see >= this number of. */
282 char *name
; /* Points to name of symbol. */
283 symbolS
*symbolP
; /* Points to symbol. */
285 int small
; /* True if fits in 32 bits. */
287 /* May be bignum, or may fit in 32 bits. */
288 /* Most numbers fit into 32 bits, and we want this case to be fast.
289 so we pretend it will fit into 32 bits. If, after making up a 32
290 bit number, we realise that we have scanned more digits than
291 comfortably fit into 32 bits, we re-scan the digits coding them
292 into a bignum. For decimal and octal numbers we are
293 conservative: Some numbers may be assumed bignums when in fact
294 they do fit into 32 bits. Numbers of any radix can have excess
295 leading zeros: We strive to recognise this and cast them back
296 into 32 bits. We must check that the bignum really is more than
297 32 bits, and change it back to a 32-bit number if it fits. The
298 number we are looking for is expected to be positive, but if it
299 fits into 32 bits as an unsigned number, we let it be a 32-bit
300 number. The cavalier approach is for speed in ordinary cases. */
301 /* This has been extended for 64 bits. We blindly assume that if
302 you're compiling in 64-bit mode, the target is a 64-bit machine.
303 This should be cleaned up. */
307 #else /* includes non-bfd case, mostly */
311 if ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
) && radix
== 0)
315 /* In MRI mode, the number may have a suffix indicating the
316 radix. For that matter, it might actually be a floating
318 for (suffix
= input_line_pointer
; ISALNUM (*suffix
); suffix
++)
320 if (*suffix
== 'e' || *suffix
== 'E')
324 if (suffix
== input_line_pointer
)
337 else if (c
== 'O' || c
== 'Q')
341 else if (suffix
[1] == '.' || c
== 'E' || flt
)
343 floating_constant (expressionP
);
358 too_many_digits
= valuesize
+ 1;
362 too_many_digits
= (valuesize
+ 2) / 3 + 1;
366 too_many_digits
= (valuesize
+ 3) / 4 + 1;
370 too_many_digits
= (valuesize
+ 11) / 4; /* Very rough. */
373 start
= input_line_pointer
;
374 c
= *input_line_pointer
++;
376 (digit
= hex_value (c
)) < maxdig
;
377 c
= *input_line_pointer
++)
379 number
= number
* radix
+ digit
;
381 /* c contains character after number. */
382 /* input_line_pointer->char after c. */
383 small
= (input_line_pointer
- start
- 1) < too_many_digits
;
385 if (radix
== 16 && c
== '_')
387 /* This is literal of the form 0x333_0_12345678_1.
388 This example is equivalent to 0x00000333000000001234567800000001. */
390 int num_little_digits
= 0;
392 input_line_pointer
= start
; /* -> 1st digit. */
394 know (LITTLENUM_NUMBER_OF_BITS
== 16);
396 for (c
= '_'; c
== '_'; num_little_digits
+= 2)
399 /* Convert one 64-bit word. */
402 for (c
= *input_line_pointer
++;
403 (digit
= hex_value (c
)) < maxdig
;
404 c
= *(input_line_pointer
++))
406 number
= number
* radix
+ digit
;
410 /* Check for 8 digit per word max. */
412 as_bad (_("a bignum with underscores may not have more than 8 hex digits in any word"));
414 /* Add this chunk to the bignum.
415 Shift things down 2 little digits. */
416 know (LITTLENUM_NUMBER_OF_BITS
== 16);
417 for (i
= min (num_little_digits
+ 1, SIZE_OF_LARGE_NUMBER
- 1);
420 generic_bignum
[i
] = generic_bignum
[i
- 2];
422 /* Add the new digits as the least significant new ones. */
423 generic_bignum
[0] = number
& 0xffffffff;
424 generic_bignum
[1] = number
>> 16;
427 /* Again, c is char after number, input_line_pointer->after c. */
429 if (num_little_digits
> SIZE_OF_LARGE_NUMBER
- 1)
430 num_little_digits
= SIZE_OF_LARGE_NUMBER
- 1;
432 assert (num_little_digits
>= 4);
434 if (num_little_digits
!= 8)
435 as_bad (_("a bignum with underscores must have exactly 4 words"));
437 /* We might have some leading zeros. These can be trimmed to give
438 us a change to fit this constant into a small number. */
439 while (generic_bignum
[num_little_digits
- 1] == 0
440 && num_little_digits
> 1)
443 if (num_little_digits
<= 2)
445 /* will fit into 32 bits. */
446 number
= generic_bignum_to_int32 ();
450 else if (num_little_digits
<= 4)
452 /* Will fit into 64 bits. */
453 number
= generic_bignum_to_int64 ();
461 /* Number of littlenums in the bignum. */
462 number
= num_little_digits
;
467 /* We saw a lot of digits. manufacture a bignum the hard way. */
468 LITTLENUM_TYPE
*leader
; /* -> high order littlenum of the bignum. */
469 LITTLENUM_TYPE
*pointer
; /* -> littlenum we are frobbing now. */
472 leader
= generic_bignum
;
473 generic_bignum
[0] = 0;
474 generic_bignum
[1] = 0;
475 generic_bignum
[2] = 0;
476 generic_bignum
[3] = 0;
477 input_line_pointer
= start
; /* -> 1st digit. */
478 c
= *input_line_pointer
++;
479 for (; (carry
= hex_value (c
)) < maxdig
; c
= *input_line_pointer
++)
481 for (pointer
= generic_bignum
; pointer
<= leader
; pointer
++)
485 work
= carry
+ radix
* *pointer
;
486 *pointer
= work
& LITTLENUM_MASK
;
487 carry
= work
>> LITTLENUM_NUMBER_OF_BITS
;
491 if (leader
< generic_bignum
+ SIZE_OF_LARGE_NUMBER
- 1)
493 /* Room to grow a longer bignum. */
498 /* Again, c is char after number. */
499 /* input_line_pointer -> after c. */
500 know (LITTLENUM_NUMBER_OF_BITS
== 16);
501 if (leader
< generic_bignum
+ 2)
503 /* Will fit into 32 bits. */
504 number
= generic_bignum_to_int32 ();
508 else if (leader
< generic_bignum
+ 4)
510 /* Will fit into 64 bits. */
511 number
= generic_bignum_to_int64 ();
517 /* Number of littlenums in the bignum. */
518 number
= leader
- generic_bignum
+ 1;
522 if ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
524 && input_line_pointer
- 1 == suffix
)
525 c
= *input_line_pointer
++;
529 /* Here with number, in correct radix. c is the next char.
530 Note that unlike un*x, we allow "011f" "0x9f" to both mean
531 the same as the (conventional) "9f".
532 This is simply easier than checking for strict canonical
535 if (LOCAL_LABELS_FB
&& c
== 'b')
537 /* Backward ref to local label.
538 Because it is backward, expect it to be defined. */
539 /* Construct a local label. */
540 name
= fb_label_name ((int) number
, 0);
542 /* Seen before, or symbol is defined: OK. */
543 symbolP
= symbol_find (name
);
544 if ((symbolP
!= NULL
) && (S_IS_DEFINED (symbolP
)))
546 /* Local labels are never absolute. Don't waste time
547 checking absoluteness. */
548 know (SEG_NORMAL (S_GET_SEGMENT (symbolP
)));
550 expressionP
->X_op
= O_symbol
;
551 expressionP
->X_add_symbol
= symbolP
;
555 /* Either not seen or not defined. */
556 /* @@ Should print out the original string instead of
557 the parsed number. */
558 as_bad (_("backward ref to unknown label \"%d:\""),
560 expressionP
->X_op
= O_constant
;
563 expressionP
->X_add_number
= 0;
565 else if (LOCAL_LABELS_FB
&& c
== 'f')
567 /* Forward reference. Expect symbol to be undefined or
568 unknown. undefined: seen it before. unknown: never seen
571 Construct a local label name, then an undefined symbol.
572 Don't create a xseg frag for it: caller may do that.
573 Just return it as never seen before. */
574 name
= fb_label_name ((int) number
, 1);
575 symbolP
= symbol_find_or_make (name
);
576 /* We have no need to check symbol properties. */
577 #ifndef many_segments
578 /* Since "know" puts its arg into a "string", we
579 can't have newlines in the argument. */
580 know (S_GET_SEGMENT (symbolP
) == undefined_section
|| S_GET_SEGMENT (symbolP
) == text_section
|| S_GET_SEGMENT (symbolP
) == data_section
);
582 expressionP
->X_op
= O_symbol
;
583 expressionP
->X_add_symbol
= symbolP
;
584 expressionP
->X_add_number
= 0;
586 else if (LOCAL_LABELS_DOLLAR
&& c
== '$')
588 /* If the dollar label is *currently* defined, then this is just
589 another reference to it. If it is not *currently* defined,
590 then this is a fresh instantiation of that number, so create
593 if (dollar_label_defined ((long) number
))
595 name
= dollar_label_name ((long) number
, 0);
596 symbolP
= symbol_find (name
);
597 know (symbolP
!= NULL
);
601 name
= dollar_label_name ((long) number
, 1);
602 symbolP
= symbol_find_or_make (name
);
605 expressionP
->X_op
= O_symbol
;
606 expressionP
->X_add_symbol
= symbolP
;
607 expressionP
->X_add_number
= 0;
611 expressionP
->X_op
= O_constant
;
612 #ifdef TARGET_WORD_SIZE
613 /* Sign extend NUMBER. */
614 number
|= (-(number
>> (TARGET_WORD_SIZE
- 1))) << (TARGET_WORD_SIZE
- 1);
616 expressionP
->X_add_number
= number
;
617 input_line_pointer
--; /* Restore following character. */
618 } /* Really just a number. */
622 /* Not a small number. */
623 expressionP
->X_op
= O_big
;
624 expressionP
->X_add_number
= number
; /* Number of littlenums. */
625 input_line_pointer
--; /* -> char following number. */
629 /* Parse an MRI multi character constant. */
632 mri_char_constant (expressionS
*expressionP
)
636 if (*input_line_pointer
== '\''
637 && input_line_pointer
[1] != '\'')
639 expressionP
->X_op
= O_constant
;
640 expressionP
->X_add_number
= 0;
644 /* In order to get the correct byte ordering, we must build the
645 number in reverse. */
646 for (i
= SIZE_OF_LARGE_NUMBER
- 1; i
>= 0; i
--)
650 generic_bignum
[i
] = 0;
651 for (j
= 0; j
< CHARS_PER_LITTLENUM
; j
++)
653 if (*input_line_pointer
== '\'')
655 if (input_line_pointer
[1] != '\'')
657 ++input_line_pointer
;
659 generic_bignum
[i
] <<= 8;
660 generic_bignum
[i
] += *input_line_pointer
;
661 ++input_line_pointer
;
664 if (i
< SIZE_OF_LARGE_NUMBER
- 1)
666 /* If there is more than one littlenum, left justify the
667 last one to make it match the earlier ones. If there is
668 only one, we can just use the value directly. */
669 for (; j
< CHARS_PER_LITTLENUM
; j
++)
670 generic_bignum
[i
] <<= 8;
673 if (*input_line_pointer
== '\''
674 && input_line_pointer
[1] != '\'')
680 as_bad (_("character constant too large"));
689 c
= SIZE_OF_LARGE_NUMBER
- i
;
690 for (j
= 0; j
< c
; j
++)
691 generic_bignum
[j
] = generic_bignum
[i
+ j
];
695 know (LITTLENUM_NUMBER_OF_BITS
== 16);
698 expressionP
->X_op
= O_big
;
699 expressionP
->X_add_number
= i
;
703 expressionP
->X_op
= O_constant
;
705 expressionP
->X_add_number
= generic_bignum
[0] & LITTLENUM_MASK
;
707 expressionP
->X_add_number
=
708 (((generic_bignum
[1] & LITTLENUM_MASK
)
709 << LITTLENUM_NUMBER_OF_BITS
)
710 | (generic_bignum
[0] & LITTLENUM_MASK
));
713 /* Skip the final closing quote. */
714 ++input_line_pointer
;
717 /* Return an expression representing the current location. This
718 handles the magic symbol `.'. */
721 current_location (expressionS
*expressionp
)
723 if (now_seg
== absolute_section
)
725 expressionp
->X_op
= O_constant
;
726 expressionp
->X_add_number
= abs_section_offset
;
730 expressionp
->X_op
= O_symbol
;
731 expressionp
->X_add_symbol
= symbol_temp_new_now ();
732 expressionp
->X_add_number
= 0;
736 /* In: Input_line_pointer points to 1st char of operand, which may
740 The operand may have been empty: in this case X_op == O_absent.
741 Input_line_pointer->(next non-blank) char after operand. */
744 operand (expressionS
*expressionP
)
747 symbolS
*symbolP
; /* Points to symbol. */
748 char *name
; /* Points to name of symbol. */
751 /* All integers are regarded as unsigned unless they are negated.
752 This is because the only thing which cares whether a number is
753 unsigned is the code in emit_expr which extends constants into
754 bignums. It should only sign extend negative numbers, so that
755 something like ``.quad 0x80000000'' is not sign extended even
756 though it appears negative if valueT is 32 bits. */
757 expressionP
->X_unsigned
= 1;
759 /* Digits, assume it is a bignum. */
761 SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
762 c
= *input_line_pointer
++; /* input_line_pointer -> past char in c. */
764 if (is_end_of_line
[(unsigned char) c
])
778 input_line_pointer
--;
780 integer_constant ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
785 #ifdef LITERAL_PREFIXDOLLAR_HEX
787 /* $L is the start of a local label, not a hex constant. */
788 if (* input_line_pointer
== 'L')
790 integer_constant (16, expressionP
);
794 #ifdef LITERAL_PREFIXPERCENT_BIN
796 integer_constant (2, expressionP
);
801 /* Non-decimal radix. */
803 if (NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
807 /* Check for a hex or float constant. */
808 for (s
= input_line_pointer
; hex_p (*s
); s
++)
810 if (*s
== 'h' || *s
== 'H' || *input_line_pointer
== '.')
812 --input_line_pointer
;
813 integer_constant (0, expressionP
);
817 c
= *input_line_pointer
;
826 if (NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
828 integer_constant (0, expressionP
);
834 if (c
&& strchr (FLT_CHARS
, c
))
836 input_line_pointer
++;
837 floating_constant (expressionP
);
838 expressionP
->X_add_number
= - TOLOWER (c
);
842 /* The string was only zero. */
843 expressionP
->X_op
= O_constant
;
844 expressionP
->X_add_number
= 0;
853 input_line_pointer
++;
854 integer_constant (16, expressionP
);
858 if (LOCAL_LABELS_FB
&& ! (flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
))
860 /* This code used to check for '+' and '-' here, and, in
861 some conditions, fall through to call
862 integer_constant. However, that didn't make sense,
863 as integer_constant only accepts digits. */
864 /* Some of our code elsewhere does permit digits greater
865 than the expected base; for consistency, do the same
867 if (input_line_pointer
[1] < '0'
868 || input_line_pointer
[1] > '9')
870 /* Parse this as a back reference to label 0. */
871 input_line_pointer
--;
872 integer_constant (10, expressionP
);
875 /* Otherwise, parse this as a binary number. */
879 input_line_pointer
++;
880 if (flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
882 integer_constant (2, expressionP
);
893 integer_constant ((flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
901 /* If it says "0f" and it could possibly be a floating point
902 number, make it one. Otherwise, make it a local label,
903 and try to deal with parsing the rest later. */
904 if (!input_line_pointer
[1]
905 || (is_end_of_line
[0xff & input_line_pointer
[1]])
906 || strchr (FLT_CHARS
, 'f') == NULL
)
909 char *cp
= input_line_pointer
+ 1;
910 int r
= atof_generic (&cp
, ".", EXP_CHARS
,
911 &generic_floating_point_number
);
915 case ERROR_EXPONENT_OVERFLOW
:
916 if (*cp
== 'f' || *cp
== 'b')
917 /* Looks like a difference expression. */
919 else if (cp
== input_line_pointer
+ 1)
920 /* No characters has been accepted -- looks like
926 as_fatal (_("expr.c(operand): bad atof_generic return val %d"),
931 /* Okay, now we've sorted it out. We resume at one of these
932 two labels, depending on what we've decided we're probably
935 input_line_pointer
--;
936 integer_constant (10, expressionP
);
946 if (flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
948 integer_constant (0, expressionP
);
958 input_line_pointer
++;
959 floating_constant (expressionP
);
960 expressionP
->X_add_number
= - TOLOWER (c
);
964 if (LOCAL_LABELS_DOLLAR
)
966 integer_constant (10, expressionP
);
976 #ifndef NEED_INDEX_OPERATOR
979 /* Didn't begin with digit & not a name. */
980 segment
= expression (expressionP
);
981 /* expression () will pass trailing whitespace. */
982 if ((c
== '(' && *input_line_pointer
!= ')')
983 || (c
== '[' && *input_line_pointer
!= ']'))
985 #ifdef RELAX_PAREN_GROUPING
988 as_bad (_("missing '%c'"), c
== '(' ? ')' : ']');
991 input_line_pointer
++;
993 /* Here with input_line_pointer -> char after "(...)". */
998 if (! flag_m68k_mri
|| *input_line_pointer
!= '\'')
1000 as_bad (_("EBCDIC constants are not supported"));
1003 if (! flag_m68k_mri
|| *input_line_pointer
!= '\'')
1005 ++input_line_pointer
;
1009 if (! flag_m68k_mri
)
1011 /* Warning: to conform to other people's assemblers NO
1012 ESCAPEMENT is permitted for a single quote. The next
1013 character, parity errors and all, is taken as the value
1014 of the operand. VERY KINKY. */
1015 expressionP
->X_op
= O_constant
;
1016 expressionP
->X_add_number
= *input_line_pointer
++;
1020 mri_char_constant (expressionP
);
1024 /* Do not accept ++e as +(+e) */
1025 if (*input_line_pointer
== '+')
1027 (void) operand (expressionP
);
1032 /* Double quote is the bitwise not operator in MRI mode. */
1033 if (! flag_m68k_mri
)
1038 /* '~' is permitted to start a label on the Delta. */
1039 if (is_name_beginner (c
))
1044 /* Do not accept --e as -(-e) */
1045 if (c
== '-' && *input_line_pointer
== '-')
1048 operand (expressionP
);
1049 if (expressionP
->X_op
== O_constant
)
1051 /* input_line_pointer -> char after operand. */
1054 expressionP
->X_add_number
= - expressionP
->X_add_number
;
1055 /* Notice: '-' may overflow: no warning is given.
1056 This is compatible with other people's
1057 assemblers. Sigh. */
1058 expressionP
->X_unsigned
= 0;
1060 else if (c
== '~' || c
== '"')
1061 expressionP
->X_add_number
= ~ expressionP
->X_add_number
;
1063 expressionP
->X_add_number
= ! expressionP
->X_add_number
;
1065 else if (expressionP
->X_op
== O_big
1066 && expressionP
->X_add_number
<= 0
1068 && (generic_floating_point_number
.sign
== '+'
1069 || generic_floating_point_number
.sign
== 'P'))
1071 /* Negative flonum (eg, -1.000e0). */
1072 if (generic_floating_point_number
.sign
== '+')
1073 generic_floating_point_number
.sign
= '-';
1075 generic_floating_point_number
.sign
= 'N';
1077 else if (expressionP
->X_op
!= O_illegal
1078 && expressionP
->X_op
!= O_absent
)
1080 expressionP
->X_add_symbol
= make_expr_symbol (expressionP
);
1082 expressionP
->X_op
= O_uminus
;
1083 else if (c
== '~' || c
== '"')
1084 expressionP
->X_op
= O_bit_not
;
1086 expressionP
->X_op
= O_logical_not
;
1087 expressionP
->X_add_number
= 0;
1090 as_warn (_("Unary operator %c ignored because bad operand follows"),
1095 #if defined (DOLLAR_DOT) || defined (TC_M68K)
1097 /* '$' is the program counter when in MRI mode, or when
1098 DOLLAR_DOT is defined. */
1100 if (! flag_m68k_mri
)
1103 if (flag_m68k_mri
&& hex_p (*input_line_pointer
))
1105 /* In MRI mode, '$' is also used as the prefix for a
1106 hexadecimal constant. */
1107 integer_constant (16, expressionP
);
1111 if (is_part_of_name (*input_line_pointer
))
1114 current_location (expressionP
);
1119 if (!is_part_of_name (*input_line_pointer
))
1121 current_location (expressionP
);
1124 else if ((strncasecmp (input_line_pointer
, "startof.", 8) == 0
1125 && ! is_part_of_name (input_line_pointer
[8]))
1126 || (strncasecmp (input_line_pointer
, "sizeof.", 7) == 0
1127 && ! is_part_of_name (input_line_pointer
[7])))
1131 start
= (input_line_pointer
[1] == 't'
1132 || input_line_pointer
[1] == 'T');
1133 input_line_pointer
+= start
? 8 : 7;
1135 if (*input_line_pointer
!= '(')
1136 as_bad (_("syntax error in .startof. or .sizeof."));
1141 ++input_line_pointer
;
1143 name
= input_line_pointer
;
1144 c
= get_symbol_end ();
1146 buf
= (char *) xmalloc (strlen (name
) + 10);
1148 sprintf (buf
, ".startof.%s", name
);
1150 sprintf (buf
, ".sizeof.%s", name
);
1151 symbolP
= symbol_make (buf
);
1154 expressionP
->X_op
= O_symbol
;
1155 expressionP
->X_add_symbol
= symbolP
;
1156 expressionP
->X_add_number
= 0;
1158 *input_line_pointer
= c
;
1160 if (*input_line_pointer
!= ')')
1161 as_bad (_("syntax error in .startof. or .sizeof."));
1163 ++input_line_pointer
;
1174 /* Can't imagine any other kind of operand. */
1175 expressionP
->X_op
= O_absent
;
1176 input_line_pointer
--;
1181 if (! flag_m68k_mri
)
1183 integer_constant (2, expressionP
);
1187 if (! flag_m68k_mri
)
1189 integer_constant (8, expressionP
);
1193 if (! flag_m68k_mri
)
1196 /* In MRI mode, this is a floating point constant represented
1197 using hexadecimal digits. */
1199 ++input_line_pointer
;
1200 integer_constant (16, expressionP
);
1204 if (! flag_m68k_mri
|| is_part_of_name (*input_line_pointer
))
1207 current_location (expressionP
);
1215 if (is_name_beginner (c
)) /* Here if did not begin with a digit. */
1217 /* Identifier begins here.
1218 This is kludged for speed, so code is repeated. */
1220 name
= --input_line_pointer
;
1221 c
= get_symbol_end ();
1223 #ifdef md_parse_name
1224 /* This is a hook for the backend to parse certain names
1225 specially in certain contexts. If a name always has a
1226 specific value, it can often be handled by simply
1227 entering it in the symbol table. */
1228 if (md_parse_name (name
, expressionP
, &c
))
1230 *input_line_pointer
= c
;
1236 /* The MRI i960 assembler permits
1238 FIXME: This should use md_parse_name. */
1240 && (strcasecmp (name
, "sizeof") == 0
1241 || strcasecmp (name
, "startof") == 0))
1246 start
= (name
[1] == 't'
1249 *input_line_pointer
= c
;
1252 name
= input_line_pointer
;
1253 c
= get_symbol_end ();
1255 buf
= (char *) xmalloc (strlen (name
) + 10);
1257 sprintf (buf
, ".startof.%s", name
);
1259 sprintf (buf
, ".sizeof.%s", name
);
1260 symbolP
= symbol_make (buf
);
1263 expressionP
->X_op
= O_symbol
;
1264 expressionP
->X_add_symbol
= symbolP
;
1265 expressionP
->X_add_number
= 0;
1267 *input_line_pointer
= c
;
1274 symbolP
= symbol_find_or_make (name
);
1276 /* If we have an absolute symbol or a reg, then we know its
1278 segment
= S_GET_SEGMENT (symbolP
);
1279 if (segment
== absolute_section
)
1281 expressionP
->X_op
= O_constant
;
1282 expressionP
->X_add_number
= S_GET_VALUE (symbolP
);
1284 else if (segment
== reg_section
)
1286 expressionP
->X_op
= O_register
;
1287 expressionP
->X_add_number
= S_GET_VALUE (symbolP
);
1291 expressionP
->X_op
= O_symbol
;
1292 expressionP
->X_add_symbol
= symbolP
;
1293 expressionP
->X_add_number
= 0;
1295 *input_line_pointer
= c
;
1300 /* Let the target try to parse it. Success is indicated by changing
1301 the X_op field to something other than O_absent and pointing
1302 input_line_pointer past the expression. If it can't parse the
1303 expression, X_op and input_line_pointer should be unchanged. */
1304 expressionP
->X_op
= O_absent
;
1305 --input_line_pointer
;
1306 md_operand (expressionP
);
1307 if (expressionP
->X_op
== O_absent
)
1309 ++input_line_pointer
;
1310 as_bad (_("bad expression"));
1311 expressionP
->X_op
= O_constant
;
1312 expressionP
->X_add_number
= 0;
1318 /* It is more 'efficient' to clean up the expressionS when they are
1319 created. Doing it here saves lines of code. */
1320 clean_up_expression (expressionP
);
1321 SKIP_WHITESPACE (); /* -> 1st char after operand. */
1322 know (*input_line_pointer
!= ' ');
1324 /* The PA port needs this information. */
1325 if (expressionP
->X_add_symbol
)
1326 symbol_mark_used (expressionP
->X_add_symbol
);
1328 switch (expressionP
->X_op
)
1331 return absolute_section
;
1333 return S_GET_SEGMENT (expressionP
->X_add_symbol
);
1339 /* Internal. Simplify a struct expression for use by expr (). */
1341 /* In: address of an expressionS.
1342 The X_op field of the expressionS may only take certain values.
1343 Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
1345 Out: expressionS may have been modified:
1346 Unused fields zeroed to help expr (). */
1349 clean_up_expression (expressionS
*expressionP
)
1351 switch (expressionP
->X_op
)
1355 expressionP
->X_add_number
= 0;
1360 expressionP
->X_add_symbol
= NULL
;
1365 expressionP
->X_op_symbol
= NULL
;
1372 /* Expression parser. */
1374 /* We allow an empty expression, and just assume (absolute,0) silently.
1375 Unary operators and parenthetical expressions are treated as operands.
1376 As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
1378 We used to do an aho/ullman shift-reduce parser, but the logic got so
1379 warped that I flushed it and wrote a recursive-descent parser instead.
1380 Now things are stable, would anybody like to write a fast parser?
1381 Most expressions are either register (which does not even reach here)
1382 or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
1383 So I guess it doesn't really matter how inefficient more complex expressions
1386 After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
1387 Also, we have consumed any leading or trailing spaces (operand does that)
1388 and done all intervening operators.
1390 This returns the segment of the result, which will be
1391 absolute_section or the segment of a symbol. */
1394 #define __ O_illegal
1396 /* Maps ASCII -> operators. */
1397 static const operatorT op_encoding
[256] = {
1398 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1399 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1401 __
, O_bit_or_not
, __
, __
, __
, O_modulus
, O_bit_and
, __
,
1402 __
, __
, O_multiply
, O_add
, __
, O_subtract
, __
, O_divide
,
1403 __
, __
, __
, __
, __
, __
, __
, __
,
1404 __
, __
, __
, __
, O_lt
, __
, O_gt
, __
,
1405 __
, __
, __
, __
, __
, __
, __
, __
,
1406 __
, __
, __
, __
, __
, __
, __
, __
,
1407 __
, __
, __
, __
, __
, __
, __
, __
,
1409 #ifdef NEED_INDEX_OPERATOR
1414 __
, __
, O_bit_exclusive_or
, __
,
1415 __
, __
, __
, __
, __
, __
, __
, __
,
1416 __
, __
, __
, __
, __
, __
, __
, __
,
1417 __
, __
, __
, __
, __
, __
, __
, __
,
1418 __
, __
, __
, __
, O_bit_inclusive_or
, __
, __
, __
,
1420 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1421 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1422 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1423 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1424 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1425 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1426 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1427 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
1431 0 operand, (expression)
1436 5 used for * / % in MRI mode
1441 static operator_rankT op_rank
[] = {
1446 0, /* O_symbol_rva */
1451 9, /* O_logical_not */
1455 8, /* O_left_shift */
1456 8, /* O_right_shift */
1457 7, /* O_bit_inclusive_or */
1458 7, /* O_bit_or_not */
1459 7, /* O_bit_exclusive_or */
1469 3, /* O_logical_and */
1470 2, /* O_logical_or */
1490 /* Unfortunately, in MRI mode for the m68k, multiplication and
1491 division have lower precedence than the bit wise operators. This
1492 function sets the operator precedences correctly for the current
1493 mode. Also, MRI uses a different bit_not operator, and this fixes
1496 #define STANDARD_MUL_PRECEDENCE 8
1497 #define MRI_MUL_PRECEDENCE 6
1500 expr_set_precedence (void)
1504 op_rank
[O_multiply
] = MRI_MUL_PRECEDENCE
;
1505 op_rank
[O_divide
] = MRI_MUL_PRECEDENCE
;
1506 op_rank
[O_modulus
] = MRI_MUL_PRECEDENCE
;
1510 op_rank
[O_multiply
] = STANDARD_MUL_PRECEDENCE
;
1511 op_rank
[O_divide
] = STANDARD_MUL_PRECEDENCE
;
1512 op_rank
[O_modulus
] = STANDARD_MUL_PRECEDENCE
;
1516 /* Initialize the expression parser. */
1521 expr_set_precedence ();
1523 /* Verify that X_op field is wide enough. */
1527 assert (e
.X_op
== O_max
);
1531 /* Return the encoding for the operator at INPUT_LINE_POINTER, and
1532 sets NUM_CHARS to the number of characters in the operator.
1533 Does not advance INPUT_LINE_POINTER. */
1535 static inline operatorT
1536 operator (int *num_chars
)
1541 c
= *input_line_pointer
& 0xff;
1544 if (is_end_of_line
[c
])
1550 return op_encoding
[c
];
1554 /* Do not allow a++b and a--b to be a + (+b) and a - (-b) */
1555 if (input_line_pointer
[1] != c
)
1556 return op_encoding
[c
];
1560 switch (input_line_pointer
[1])
1563 return op_encoding
[c
];
1578 if (input_line_pointer
[1] != '=')
1579 return op_encoding
[c
];
1585 switch (input_line_pointer
[1])
1588 return op_encoding
[c
];
1590 ret
= O_right_shift
;
1600 /* We accept !! as equivalent to ^ for MRI compatibility. */
1601 if (input_line_pointer
[1] != '!')
1604 return O_bit_inclusive_or
;
1605 return op_encoding
[c
];
1608 return O_bit_exclusive_or
;
1611 if (input_line_pointer
[1] != '|')
1612 return op_encoding
[c
];
1615 return O_logical_or
;
1618 if (input_line_pointer
[1] != '&')
1619 return op_encoding
[c
];
1622 return O_logical_and
;
1628 /* Parse an expression. */
1631 expr (int rankarg
, /* Larger # is higher rank. */
1632 expressionS
*resultP
/* Deliver result here. */)
1634 operator_rankT rank
= (operator_rankT
) rankarg
;
1643 /* Save the value of dot for the fixup code. */
1645 dot_value
= frag_now_fix ();
1647 retval
= operand (resultP
);
1649 /* operand () gobbles spaces. */
1650 know (*input_line_pointer
!= ' ');
1652 op_left
= operator (&op_chars
);
1653 while (op_left
!= O_illegal
&& op_rank
[(int) op_left
] > rank
)
1657 input_line_pointer
+= op_chars
; /* -> after operator. */
1659 rightseg
= expr (op_rank
[(int) op_left
], &right
);
1660 if (right
.X_op
== O_absent
)
1662 as_warn (_("missing operand; zero assumed"));
1663 right
.X_op
= O_constant
;
1664 right
.X_add_number
= 0;
1665 right
.X_add_symbol
= NULL
;
1666 right
.X_op_symbol
= NULL
;
1669 know (*input_line_pointer
!= ' ');
1671 if (op_left
== O_index
)
1673 if (*input_line_pointer
!= ']')
1674 as_bad ("missing right bracket");
1677 ++input_line_pointer
;
1682 op_right
= operator (&op_chars
);
1684 know (op_right
== O_illegal
1685 || op_rank
[(int) op_right
] <= op_rank
[(int) op_left
]);
1686 know ((int) op_left
>= (int) O_multiply
1687 && (int) op_left
<= (int) O_logical_or
);
1689 /* input_line_pointer->after right-hand quantity. */
1690 /* left-hand quantity in resultP. */
1691 /* right-hand quantity in right. */
1692 /* operator in op_left. */
1694 if (resultP
->X_op
== O_big
)
1696 if (resultP
->X_add_number
> 0)
1697 as_warn (_("left operand is a bignum; integer 0 assumed"));
1699 as_warn (_("left operand is a float; integer 0 assumed"));
1700 resultP
->X_op
= O_constant
;
1701 resultP
->X_add_number
= 0;
1702 resultP
->X_add_symbol
= NULL
;
1703 resultP
->X_op_symbol
= NULL
;
1705 if (right
.X_op
== O_big
)
1707 if (right
.X_add_number
> 0)
1708 as_warn (_("right operand is a bignum; integer 0 assumed"));
1710 as_warn (_("right operand is a float; integer 0 assumed"));
1711 right
.X_op
= O_constant
;
1712 right
.X_add_number
= 0;
1713 right
.X_add_symbol
= NULL
;
1714 right
.X_op_symbol
= NULL
;
1717 /* Optimize common cases. */
1718 #ifdef md_optimize_expr
1719 if (md_optimize_expr (resultP
, op_left
, &right
))
1726 if (op_left
== O_add
&& right
.X_op
== O_constant
)
1729 resultP
->X_add_number
+= right
.X_add_number
;
1731 /* This case comes up in PIC code. */
1732 else if (op_left
== O_subtract
1733 && right
.X_op
== O_symbol
1734 && resultP
->X_op
== O_symbol
1735 && (symbol_get_frag (right
.X_add_symbol
)
1736 == symbol_get_frag (resultP
->X_add_symbol
))
1737 && (SEG_NORMAL (rightseg
)
1738 || right
.X_add_symbol
== resultP
->X_add_symbol
))
1740 resultP
->X_add_number
-= right
.X_add_number
;
1741 resultP
->X_add_number
+= (S_GET_VALUE (resultP
->X_add_symbol
)
1742 - S_GET_VALUE (right
.X_add_symbol
));
1743 resultP
->X_op
= O_constant
;
1744 resultP
->X_add_symbol
= 0;
1746 else if (op_left
== O_subtract
&& right
.X_op
== O_constant
)
1749 resultP
->X_add_number
-= right
.X_add_number
;
1751 else if (op_left
== O_add
&& resultP
->X_op
== O_constant
)
1754 resultP
->X_op
= right
.X_op
;
1755 resultP
->X_add_symbol
= right
.X_add_symbol
;
1756 resultP
->X_op_symbol
= right
.X_op_symbol
;
1757 resultP
->X_add_number
+= right
.X_add_number
;
1760 else if (resultP
->X_op
== O_constant
&& right
.X_op
== O_constant
)
1762 /* Constant OP constant. */
1763 offsetT v
= right
.X_add_number
;
1764 if (v
== 0 && (op_left
== O_divide
|| op_left
== O_modulus
))
1766 as_warn (_("division by zero"));
1772 case O_multiply
: resultP
->X_add_number
*= v
; break;
1773 case O_divide
: resultP
->X_add_number
/= v
; break;
1774 case O_modulus
: resultP
->X_add_number
%= v
; break;
1775 case O_left_shift
: resultP
->X_add_number
<<= v
; break;
1777 /* We always use unsigned shifts, to avoid relying on
1778 characteristics of the compiler used to compile gas. */
1779 resultP
->X_add_number
=
1780 (offsetT
) ((valueT
) resultP
->X_add_number
>> (valueT
) v
);
1782 case O_bit_inclusive_or
: resultP
->X_add_number
|= v
; break;
1783 case O_bit_or_not
: resultP
->X_add_number
|= ~v
; break;
1784 case O_bit_exclusive_or
: resultP
->X_add_number
^= v
; break;
1785 case O_bit_and
: resultP
->X_add_number
&= v
; break;
1786 case O_add
: resultP
->X_add_number
+= v
; break;
1787 case O_subtract
: resultP
->X_add_number
-= v
; break;
1789 resultP
->X_add_number
=
1790 resultP
->X_add_number
== v
? ~ (offsetT
) 0 : 0;
1793 resultP
->X_add_number
=
1794 resultP
->X_add_number
!= v
? ~ (offsetT
) 0 : 0;
1797 resultP
->X_add_number
=
1798 resultP
->X_add_number
< v
? ~ (offsetT
) 0 : 0;
1801 resultP
->X_add_number
=
1802 resultP
->X_add_number
<= v
? ~ (offsetT
) 0 : 0;
1805 resultP
->X_add_number
=
1806 resultP
->X_add_number
>= v
? ~ (offsetT
) 0 : 0;
1809 resultP
->X_add_number
=
1810 resultP
->X_add_number
> v
? ~ (offsetT
) 0 : 0;
1813 resultP
->X_add_number
= resultP
->X_add_number
&& v
;
1816 resultP
->X_add_number
= resultP
->X_add_number
|| v
;
1820 else if (resultP
->X_op
== O_symbol
1821 && right
.X_op
== O_symbol
1822 && (op_left
== O_add
1823 || op_left
== O_subtract
1824 || (resultP
->X_add_number
== 0
1825 && right
.X_add_number
== 0)))
1827 /* Symbol OP symbol. */
1828 resultP
->X_op
= op_left
;
1829 resultP
->X_op_symbol
= right
.X_add_symbol
;
1830 if (op_left
== O_add
)
1831 resultP
->X_add_number
+= right
.X_add_number
;
1832 else if (op_left
== O_subtract
)
1834 resultP
->X_add_number
-= right
.X_add_number
;
1835 if (retval
== rightseg
&& SEG_NORMAL (retval
))
1837 retval
= absolute_section
;
1838 rightseg
= absolute_section
;
1844 /* The general case. */
1845 resultP
->X_add_symbol
= make_expr_symbol (resultP
);
1846 resultP
->X_op_symbol
= make_expr_symbol (&right
);
1847 resultP
->X_op
= op_left
;
1848 resultP
->X_add_number
= 0;
1849 resultP
->X_unsigned
= 1;
1852 if (retval
!= rightseg
)
1854 if (! SEG_NORMAL (retval
))
1856 if (retval
!= undefined_section
|| SEG_NORMAL (rightseg
))
1859 else if (SEG_NORMAL (rightseg
)
1861 && op_left
!= O_subtract
1864 as_bad (_("operation combines symbols in different segments"));
1868 } /* While next operator is >= this rank. */
1870 /* The PA port needs this information. */
1871 if (resultP
->X_add_symbol
)
1872 symbol_mark_used (resultP
->X_add_symbol
);
1874 return resultP
->X_op
== O_constant
? absolute_section
: retval
;
1877 /* This lives here because it belongs equally in expr.c & read.c.
1878 expr.c is just a branch office read.c anyway, and putting it
1879 here lessens the crowd at read.c.
1881 Assume input_line_pointer is at start of symbol name.
1882 Advance input_line_pointer past symbol name.
1883 Turn that character into a '\0', returning its former value.
1884 This allows a string compare (RMS wants symbol names to be strings)
1886 There will always be a char following symbol name, because all good
1887 lines end in end-of-line. */
1890 get_symbol_end (void)
1894 /* We accept \001 in a name in case this is being called with a
1895 constructed string. */
1896 if (is_name_beginner (c
= *input_line_pointer
++) || c
== '\001')
1898 while (is_part_of_name (c
= *input_line_pointer
++)
1901 if (is_name_ender (c
))
1902 c
= *input_line_pointer
++;
1904 *--input_line_pointer
= 0;
1909 get_single_number (void)
1913 return exp
.X_add_number
;