1 /* expr.c -operands, expressions-
2 Copyright (C) 1987-2017 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* This is really a branch office of as-read.c. I split it out to clearly
22 distinguish the world of expressions from the world of statements.
23 (It also gives smaller files to re-compile.)
24 Here, "operand"s are of expressions, not instructions. */
26 #define min(a, b) ((a) < (b) ? (a) : (b))
29 #include "safe-ctype.h"
38 static void floating_constant (expressionS
* expressionP
);
39 static valueT
generic_bignum_to_int32 (void);
41 static valueT
generic_bignum_to_int64 (void);
43 static void integer_constant (int radix
, expressionS
* expressionP
);
44 static void mri_char_constant (expressionS
*);
45 static void clean_up_expression (expressionS
* expressionP
);
46 static segT
operand (expressionS
*, enum expr_mode
);
47 static operatorT
operatorf (int *);
49 /* We keep a mapping of expression symbols to file positions, so that
50 we can provide better error messages. */
52 struct expr_symbol_line
{
53 struct expr_symbol_line
*next
;
59 static struct expr_symbol_line
*expr_symbol_lines
;
61 /* Build a dummy symbol to hold a complex expression. This is how we
62 build expressions up out of other expressions. The symbol is put
63 into the fake section expr_section. */
66 make_expr_symbol (expressionS
*expressionP
)
70 struct expr_symbol_line
*n
;
72 if (expressionP
->X_op
== O_symbol
73 && expressionP
->X_add_number
== 0)
74 return expressionP
->X_add_symbol
;
76 if (expressionP
->X_op
== O_big
)
78 /* This won't work, because the actual value is stored in
79 generic_floating_point_number or generic_bignum, and we are
80 going to lose it if we haven't already. */
81 if (expressionP
->X_add_number
> 0)
82 as_bad (_("bignum invalid"));
84 as_bad (_("floating point number invalid"));
85 zero
.X_op
= O_constant
;
86 zero
.X_add_number
= 0;
89 clean_up_expression (&zero
);
93 /* Putting constant symbols in absolute_section rather than
94 expr_section is convenient for the old a.out code, for which
95 S_GET_SEGMENT does not always retrieve the value put in by
97 symbolP
= symbol_create (FAKE_LABEL_NAME
,
98 (expressionP
->X_op
== O_constant
100 : expressionP
->X_op
== O_register
103 0, &zero_address_frag
);
104 symbol_set_value_expression (symbolP
, expressionP
);
106 if (expressionP
->X_op
== O_constant
)
107 resolve_symbol_value (symbolP
);
109 n
= XNEW (struct expr_symbol_line
);
111 n
->file
= as_where (&n
->line
);
112 n
->next
= expr_symbol_lines
;
113 expr_symbol_lines
= n
;
118 /* Return the file and line number for an expr symbol. Return
119 non-zero if something was found, 0 if no information is known for
123 expr_symbol_where (symbolS
*sym
, const char **pfile
, unsigned int *pline
)
125 struct expr_symbol_line
*l
;
127 for (l
= expr_symbol_lines
; l
!= NULL
; l
= l
->next
)
140 /* Utilities for building expressions.
141 Since complex expressions are recorded as symbols for use in other
142 expressions these return a symbolS * and not an expressionS *.
143 These explicitly do not take an "add_number" argument. */
144 /* ??? For completeness' sake one might want expr_build_symbol.
145 It would just return its argument. */
147 /* Build an expression for an unsigned constant.
148 The corresponding one for signed constants is missing because
149 there's currently no need for it. One could add an unsigned_p flag
150 but that seems more clumsy. */
153 expr_build_uconstant (offsetT value
)
158 e
.X_add_number
= value
;
161 return make_expr_symbol (&e
);
164 /* Build an expression for the current location ('.'). */
167 expr_build_dot (void)
171 current_location (&e
);
172 return symbol_clone_if_forward_ref (make_expr_symbol (&e
));
175 /* Build any floating-point literal here.
176 Also build any bignum literal here. */
178 /* Seems atof_machine can backscan through generic_bignum and hit whatever
179 happens to be loaded before it in memory. And its way too complicated
180 for me to fix right. Thus a hack. JF: Just make generic_bignum bigger,
181 and never write into the early words, thus they'll always be zero.
182 I hate Dean's floating-point code. Bleh. */
183 LITTLENUM_TYPE generic_bignum
[SIZE_OF_LARGE_NUMBER
+ 6];
185 FLONUM_TYPE generic_floating_point_number
= {
186 &generic_bignum
[6], /* low. (JF: Was 0) */
187 &generic_bignum
[SIZE_OF_LARGE_NUMBER
+ 6 - 1], /* high. JF: (added +6) */
195 floating_constant (expressionS
*expressionP
)
197 /* input_line_pointer -> floating-point constant. */
200 error_code
= atof_generic (&input_line_pointer
, ".", EXP_CHARS
,
201 &generic_floating_point_number
);
205 if (error_code
== ERROR_EXPONENT_OVERFLOW
)
207 as_bad (_("bad floating-point constant: exponent overflow"));
211 as_bad (_("bad floating-point constant: unknown error code=%d"),
215 expressionP
->X_op
= O_big
;
216 /* input_line_pointer -> just after constant, which may point to
218 expressionP
->X_add_number
= -1;
222 generic_bignum_to_int32 (void)
225 ((generic_bignum
[1] & LITTLENUM_MASK
) << LITTLENUM_NUMBER_OF_BITS
)
226 | (generic_bignum
[0] & LITTLENUM_MASK
);
227 number
&= 0xffffffff;
233 generic_bignum_to_int64 (void)
236 ((((((((valueT
) generic_bignum
[3] & LITTLENUM_MASK
)
237 << LITTLENUM_NUMBER_OF_BITS
)
238 | ((valueT
) generic_bignum
[2] & LITTLENUM_MASK
))
239 << LITTLENUM_NUMBER_OF_BITS
)
240 | ((valueT
) generic_bignum
[1] & LITTLENUM_MASK
))
241 << LITTLENUM_NUMBER_OF_BITS
)
242 | ((valueT
) generic_bignum
[0] & LITTLENUM_MASK
));
248 integer_constant (int radix
, expressionS
*expressionP
)
250 char *start
; /* Start of number. */
253 valueT number
; /* Offset or (absolute) value. */
254 short int digit
; /* Value of next digit in current radix. */
255 short int maxdig
= 0; /* Highest permitted digit value. */
256 int too_many_digits
= 0; /* If we see >= this number of. */
257 char *name
; /* Points to name of symbol. */
258 symbolS
*symbolP
; /* Points to symbol. */
260 int small
; /* True if fits in 32 bits. */
262 /* May be bignum, or may fit in 32 bits. */
263 /* Most numbers fit into 32 bits, and we want this case to be fast.
264 so we pretend it will fit into 32 bits. If, after making up a 32
265 bit number, we realise that we have scanned more digits than
266 comfortably fit into 32 bits, we re-scan the digits coding them
267 into a bignum. For decimal and octal numbers we are
268 conservative: Some numbers may be assumed bignums when in fact
269 they do fit into 32 bits. Numbers of any radix can have excess
270 leading zeros: We strive to recognise this and cast them back
271 into 32 bits. We must check that the bignum really is more than
272 32 bits, and change it back to a 32-bit number if it fits. The
273 number we are looking for is expected to be positive, but if it
274 fits into 32 bits as an unsigned number, we let it be a 32-bit
275 number. The cavalier approach is for speed in ordinary cases. */
276 /* This has been extended for 64 bits. We blindly assume that if
277 you're compiling in 64-bit mode, the target is a 64-bit machine.
278 This should be cleaned up. */
282 #else /* includes non-bfd case, mostly */
286 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
288 expressionP
->X_op
= O_absent
;
292 if ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
) && radix
== 0)
296 /* In MRI mode, the number may have a suffix indicating the
297 radix. For that matter, it might actually be a floating
299 for (suffix
= input_line_pointer
; ISALNUM (*suffix
); suffix
++)
301 if (*suffix
== 'e' || *suffix
== 'E')
305 if (suffix
== input_line_pointer
)
314 /* If we have both NUMBERS_WITH_SUFFIX and LOCAL_LABELS_FB,
315 we distinguish between 'B' and 'b'. This is the case for
317 if ((NUMBERS_WITH_SUFFIX
&& LOCAL_LABELS_FB
? *suffix
: c
) == 'B')
321 else if (c
== 'O' || c
== 'Q')
325 else if (suffix
[1] == '.' || c
== 'E' || flt
)
327 floating_constant (expressionP
);
342 too_many_digits
= valuesize
+ 1;
346 too_many_digits
= (valuesize
+ 2) / 3 + 1;
350 too_many_digits
= (valuesize
+ 3) / 4 + 1;
354 too_many_digits
= (valuesize
+ 11) / 4; /* Very rough. */
357 start
= input_line_pointer
;
358 c
= *input_line_pointer
++;
360 (digit
= hex_value (c
)) < maxdig
;
361 c
= *input_line_pointer
++)
363 number
= number
* radix
+ digit
;
365 /* c contains character after number. */
366 /* input_line_pointer->char after c. */
367 small
= (input_line_pointer
- start
- 1) < too_many_digits
;
369 if (radix
== 16 && c
== '_')
371 /* This is literal of the form 0x333_0_12345678_1.
372 This example is equivalent to 0x00000333000000001234567800000001. */
374 int num_little_digits
= 0;
376 input_line_pointer
= start
; /* -> 1st digit. */
378 know (LITTLENUM_NUMBER_OF_BITS
== 16);
380 for (c
= '_'; c
== '_'; num_little_digits
+= 2)
383 /* Convert one 64-bit word. */
386 for (c
= *input_line_pointer
++;
387 (digit
= hex_value (c
)) < maxdig
;
388 c
= *(input_line_pointer
++))
390 number
= number
* radix
+ digit
;
394 /* Check for 8 digit per word max. */
396 as_bad (_("a bignum with underscores may not have more than 8 hex digits in any word"));
398 /* Add this chunk to the bignum.
399 Shift things down 2 little digits. */
400 know (LITTLENUM_NUMBER_OF_BITS
== 16);
401 for (i
= min (num_little_digits
+ 1, SIZE_OF_LARGE_NUMBER
- 1);
404 generic_bignum
[i
] = generic_bignum
[i
- 2];
406 /* Add the new digits as the least significant new ones. */
407 generic_bignum
[0] = number
& 0xffffffff;
408 generic_bignum
[1] = number
>> 16;
411 /* Again, c is char after number, input_line_pointer->after c. */
413 if (num_little_digits
> SIZE_OF_LARGE_NUMBER
- 1)
414 num_little_digits
= SIZE_OF_LARGE_NUMBER
- 1;
416 gas_assert (num_little_digits
>= 4);
418 if (num_little_digits
!= 8)
419 as_bad (_("a bignum with underscores must have exactly 4 words"));
421 /* We might have some leading zeros. These can be trimmed to give
422 us a change to fit this constant into a small number. */
423 while (generic_bignum
[num_little_digits
- 1] == 0
424 && num_little_digits
> 1)
427 if (num_little_digits
<= 2)
429 /* will fit into 32 bits. */
430 number
= generic_bignum_to_int32 ();
434 else if (num_little_digits
<= 4)
436 /* Will fit into 64 bits. */
437 number
= generic_bignum_to_int64 ();
445 /* Number of littlenums in the bignum. */
446 number
= num_little_digits
;
451 /* We saw a lot of digits. manufacture a bignum the hard way. */
452 LITTLENUM_TYPE
*leader
; /* -> high order littlenum of the bignum. */
453 LITTLENUM_TYPE
*pointer
; /* -> littlenum we are frobbing now. */
456 leader
= generic_bignum
;
457 generic_bignum
[0] = 0;
458 generic_bignum
[1] = 0;
459 generic_bignum
[2] = 0;
460 generic_bignum
[3] = 0;
461 input_line_pointer
= start
; /* -> 1st digit. */
462 c
= *input_line_pointer
++;
463 for (; (carry
= hex_value (c
)) < maxdig
; c
= *input_line_pointer
++)
465 for (pointer
= generic_bignum
; pointer
<= leader
; pointer
++)
469 work
= carry
+ radix
* *pointer
;
470 *pointer
= work
& LITTLENUM_MASK
;
471 carry
= work
>> LITTLENUM_NUMBER_OF_BITS
;
475 if (leader
< generic_bignum
+ SIZE_OF_LARGE_NUMBER
- 1)
477 /* Room to grow a longer bignum. */
482 /* Again, c is char after number. */
483 /* input_line_pointer -> after c. */
484 know (LITTLENUM_NUMBER_OF_BITS
== 16);
485 if (leader
< generic_bignum
+ 2)
487 /* Will fit into 32 bits. */
488 number
= generic_bignum_to_int32 ();
492 else if (leader
< generic_bignum
+ 4)
494 /* Will fit into 64 bits. */
495 number
= generic_bignum_to_int64 ();
501 /* Number of littlenums in the bignum. */
502 number
= leader
- generic_bignum
+ 1;
506 if ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
508 && input_line_pointer
- 1 == suffix
)
509 c
= *input_line_pointer
++;
511 #ifndef tc_allow_U_suffix
512 #define tc_allow_U_suffix 1
514 /* PR 19910: Look for, and ignore, a U suffix to the number. */
515 if (tc_allow_U_suffix
&& (c
== 'U' || c
== 'u'))
516 c
= * input_line_pointer
++;
518 #ifndef tc_allow_L_suffix
519 #define tc_allow_L_suffix 1
521 /* PR 20732: Look for, and ignore, a L or LL suffix to the number. */
522 if (tc_allow_L_suffix
)
523 while (c
== 'L' || c
== 'l')
524 c
= * input_line_pointer
++;
528 /* Here with number, in correct radix. c is the next char.
529 Note that unlike un*x, we allow "011f" "0x9f" to both mean
530 the same as the (conventional) "9f".
531 This is simply easier than checking for strict canonical
534 if (LOCAL_LABELS_FB
&& c
== 'b')
536 /* Backward ref to local label.
537 Because it is backward, expect it to be defined. */
538 /* Construct a local label. */
539 name
= fb_label_name ((int) number
, 0);
541 /* Seen before, or symbol is defined: OK. */
542 symbolP
= symbol_find (name
);
543 if ((symbolP
!= NULL
) && (S_IS_DEFINED (symbolP
)))
545 /* Local labels are never absolute. Don't waste time
546 checking absoluteness. */
547 know (SEG_NORMAL (S_GET_SEGMENT (symbolP
)));
549 expressionP
->X_op
= O_symbol
;
550 expressionP
->X_add_symbol
= symbolP
;
554 /* Either not seen or not defined. */
555 /* @@ Should print out the original string instead of
556 the parsed number. */
557 as_bad (_("backward ref to unknown label \"%d:\""),
559 expressionP
->X_op
= O_constant
;
562 expressionP
->X_add_number
= 0;
564 else if (LOCAL_LABELS_FB
&& c
== 'f')
566 /* Forward reference. Expect symbol to be undefined or
567 unknown. undefined: seen it before. unknown: never seen
570 Construct a local label name, then an undefined symbol.
571 Don't create a xseg frag for it: caller may do that.
572 Just return it as never seen before. */
573 name
= fb_label_name ((int) number
, 1);
574 symbolP
= symbol_find_or_make (name
);
575 /* We have no need to check symbol properties. */
576 #ifndef many_segments
577 /* Since "know" puts its arg into a "string", we
578 can't have newlines in the argument. */
579 know (S_GET_SEGMENT (symbolP
) == undefined_section
|| S_GET_SEGMENT (symbolP
) == text_section
|| S_GET_SEGMENT (symbolP
) == data_section
);
581 expressionP
->X_op
= O_symbol
;
582 expressionP
->X_add_symbol
= symbolP
;
583 expressionP
->X_add_number
= 0;
585 else if (LOCAL_LABELS_DOLLAR
&& c
== '$')
587 /* If the dollar label is *currently* defined, then this is just
588 another reference to it. If it is not *currently* defined,
589 then this is a fresh instantiation of that number, so create
592 if (dollar_label_defined ((long) number
))
594 name
= dollar_label_name ((long) number
, 0);
595 symbolP
= symbol_find (name
);
596 know (symbolP
!= NULL
);
600 name
= dollar_label_name ((long) number
, 1);
601 symbolP
= symbol_find_or_make (name
);
604 expressionP
->X_op
= O_symbol
;
605 expressionP
->X_add_symbol
= symbolP
;
606 expressionP
->X_add_number
= 0;
610 expressionP
->X_op
= O_constant
;
611 expressionP
->X_add_number
= number
;
612 input_line_pointer
--; /* Restore following character. */
613 } /* Really just a number. */
617 /* Not a small number. */
618 expressionP
->X_op
= O_big
;
619 expressionP
->X_add_number
= number
; /* Number of littlenums. */
620 input_line_pointer
--; /* -> char following number. */
624 /* Parse an MRI multi character constant. */
627 mri_char_constant (expressionS
*expressionP
)
631 if (*input_line_pointer
== '\''
632 && input_line_pointer
[1] != '\'')
634 expressionP
->X_op
= O_constant
;
635 expressionP
->X_add_number
= 0;
639 /* In order to get the correct byte ordering, we must build the
640 number in reverse. */
641 for (i
= SIZE_OF_LARGE_NUMBER
- 1; i
>= 0; i
--)
645 generic_bignum
[i
] = 0;
646 for (j
= 0; j
< CHARS_PER_LITTLENUM
; j
++)
648 if (*input_line_pointer
== '\'')
650 if (input_line_pointer
[1] != '\'')
652 ++input_line_pointer
;
654 generic_bignum
[i
] <<= 8;
655 generic_bignum
[i
] += *input_line_pointer
;
656 ++input_line_pointer
;
659 if (i
< SIZE_OF_LARGE_NUMBER
- 1)
661 /* If there is more than one littlenum, left justify the
662 last one to make it match the earlier ones. If there is
663 only one, we can just use the value directly. */
664 for (; j
< CHARS_PER_LITTLENUM
; j
++)
665 generic_bignum
[i
] <<= 8;
668 if (*input_line_pointer
== '\''
669 && input_line_pointer
[1] != '\'')
675 as_bad (_("character constant too large"));
684 c
= SIZE_OF_LARGE_NUMBER
- i
;
685 for (j
= 0; j
< c
; j
++)
686 generic_bignum
[j
] = generic_bignum
[i
+ j
];
690 know (LITTLENUM_NUMBER_OF_BITS
== 16);
693 expressionP
->X_op
= O_big
;
694 expressionP
->X_add_number
= i
;
698 expressionP
->X_op
= O_constant
;
700 expressionP
->X_add_number
= generic_bignum
[0] & LITTLENUM_MASK
;
702 expressionP
->X_add_number
=
703 (((generic_bignum
[1] & LITTLENUM_MASK
)
704 << LITTLENUM_NUMBER_OF_BITS
)
705 | (generic_bignum
[0] & LITTLENUM_MASK
));
708 /* Skip the final closing quote. */
709 ++input_line_pointer
;
712 /* Return an expression representing the current location. This
713 handles the magic symbol `.'. */
716 current_location (expressionS
*expressionp
)
718 if (now_seg
== absolute_section
)
720 expressionp
->X_op
= O_constant
;
721 expressionp
->X_add_number
= abs_section_offset
;
725 expressionp
->X_op
= O_symbol
;
726 expressionp
->X_add_symbol
= &dot_symbol
;
727 expressionp
->X_add_number
= 0;
731 /* In: Input_line_pointer points to 1st char of operand, which may
735 The operand may have been empty: in this case X_op == O_absent.
736 Input_line_pointer->(next non-blank) char after operand. */
739 operand (expressionS
*expressionP
, enum expr_mode mode
)
742 symbolS
*symbolP
; /* Points to symbol. */
743 char *name
; /* Points to name of symbol. */
746 /* All integers are regarded as unsigned unless they are negated.
747 This is because the only thing which cares whether a number is
748 unsigned is the code in emit_expr which extends constants into
749 bignums. It should only sign extend negative numbers, so that
750 something like ``.quad 0x80000000'' is not sign extended even
751 though it appears negative if valueT is 32 bits. */
752 expressionP
->X_unsigned
= 1;
753 expressionP
->X_extrabit
= 0;
755 /* Digits, assume it is a bignum. */
757 SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
758 c
= *input_line_pointer
++; /* input_line_pointer -> past char in c. */
760 if (is_end_of_line
[(unsigned char) c
])
774 input_line_pointer
--;
776 integer_constant ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
781 #ifdef LITERAL_PREFIXDOLLAR_HEX
783 /* $L is the start of a local label, not a hex constant. */
784 if (* input_line_pointer
== 'L')
786 integer_constant (16, expressionP
);
790 #ifdef LITERAL_PREFIXPERCENT_BIN
792 integer_constant (2, expressionP
);
797 /* Non-decimal radix. */
799 if (NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
803 /* Check for a hex or float constant. */
804 for (s
= input_line_pointer
; hex_p (*s
); s
++)
806 if (*s
== 'h' || *s
== 'H' || *input_line_pointer
== '.')
808 --input_line_pointer
;
809 integer_constant (0, expressionP
);
813 c
= *input_line_pointer
;
822 if (NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
824 integer_constant (0, expressionP
);
830 if (c
&& strchr (FLT_CHARS
, c
))
832 input_line_pointer
++;
833 floating_constant (expressionP
);
834 expressionP
->X_add_number
= - TOLOWER (c
);
838 /* The string was only zero. */
839 expressionP
->X_op
= O_constant
;
840 expressionP
->X_add_number
= 0;
849 input_line_pointer
++;
850 integer_constant (16, expressionP
);
854 if (LOCAL_LABELS_FB
&& !flag_m68k_mri
855 && input_line_pointer
[1] != '0'
856 && input_line_pointer
[1] != '1')
858 /* Parse this as a back reference to label 0. */
859 input_line_pointer
--;
860 integer_constant (10, expressionP
);
863 /* Otherwise, parse this as a binary number. */
866 if (input_line_pointer
[1] == '0'
867 || input_line_pointer
[1] == '1')
869 input_line_pointer
++;
870 integer_constant (2, expressionP
);
873 if (flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
874 input_line_pointer
++;
885 integer_constant ((flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
895 /* If it says "0f" and it could possibly be a floating point
896 number, make it one. Otherwise, make it a local label,
897 and try to deal with parsing the rest later. */
898 if (!is_end_of_line
[(unsigned char) input_line_pointer
[1]]
899 && strchr (FLT_CHARS
, 'f') != NULL
)
901 char *cp
= input_line_pointer
+ 1;
903 atof_generic (&cp
, ".", EXP_CHARS
,
904 &generic_floating_point_number
);
906 /* Was nothing parsed, or does it look like an
908 is_label
= (cp
== input_line_pointer
+ 1
909 || (cp
== input_line_pointer
+ 2
910 && (cp
[-1] == '-' || cp
[-1] == '+'))
916 input_line_pointer
--;
917 integer_constant (10, expressionP
);
925 if (flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
927 integer_constant (0, expressionP
);
937 input_line_pointer
++;
938 floating_constant (expressionP
);
939 expressionP
->X_add_number
= - TOLOWER (c
);
943 if (LOCAL_LABELS_DOLLAR
)
945 integer_constant (10, expressionP
);
954 #ifndef NEED_INDEX_OPERATOR
956 # ifdef md_need_index_operator
957 if (md_need_index_operator())
963 /* Didn't begin with digit & not a name. */
964 segment
= expr (0, expressionP
, mode
);
965 /* expression () will pass trailing whitespace. */
966 if ((c
== '(' && *input_line_pointer
!= ')')
967 || (c
== '[' && *input_line_pointer
!= ']'))
969 if (* input_line_pointer
)
970 as_bad (_("found '%c', expected: '%c'"),
971 * input_line_pointer
, c
== '(' ? ')' : ']');
973 as_bad (_("missing '%c'"), c
== '(' ? ')' : ']');
976 input_line_pointer
++;
978 /* Here with input_line_pointer -> char after "(...)". */
983 if (! flag_m68k_mri
|| *input_line_pointer
!= '\'')
985 as_bad (_("EBCDIC constants are not supported"));
988 if (! flag_m68k_mri
|| *input_line_pointer
!= '\'')
990 ++input_line_pointer
;
996 /* Warning: to conform to other people's assemblers NO
997 ESCAPEMENT is permitted for a single quote. The next
998 character, parity errors and all, is taken as the value
999 of the operand. VERY KINKY. */
1000 expressionP
->X_op
= O_constant
;
1001 expressionP
->X_add_number
= *input_line_pointer
++;
1005 mri_char_constant (expressionP
);
1010 /* Double quote is the bitwise not operator in MRI mode. */
1011 if (! flag_m68k_mri
)
1016 /* '~' is permitted to start a label on the Delta. */
1017 if (is_name_beginner (c
))
1027 operand (expressionP
, mode
);
1028 if (expressionP
->X_op
== O_constant
)
1030 /* input_line_pointer -> char after operand. */
1033 expressionP
->X_add_number
1034 = - (addressT
) expressionP
->X_add_number
;
1035 /* Notice: '-' may overflow: no warning is given.
1036 This is compatible with other people's
1037 assemblers. Sigh. */
1038 expressionP
->X_unsigned
= 0;
1039 if (expressionP
->X_add_number
)
1040 expressionP
->X_extrabit
^= 1;
1042 else if (c
== '~' || c
== '"')
1043 expressionP
->X_add_number
= ~ expressionP
->X_add_number
;
1045 expressionP
->X_add_number
= ! expressionP
->X_add_number
;
1047 else if (expressionP
->X_op
== O_big
1048 && expressionP
->X_add_number
<= 0
1050 && (generic_floating_point_number
.sign
== '+'
1051 || generic_floating_point_number
.sign
== 'P'))
1053 /* Negative flonum (eg, -1.000e0). */
1054 if (generic_floating_point_number
.sign
== '+')
1055 generic_floating_point_number
.sign
= '-';
1057 generic_floating_point_number
.sign
= 'N';
1059 else if (expressionP
->X_op
== O_big
1060 && expressionP
->X_add_number
> 0)
1064 if (c
== '~' || c
== '-')
1066 for (i
= 0; i
< expressionP
->X_add_number
; ++i
)
1067 generic_bignum
[i
] = ~generic_bignum
[i
];
1069 /* Extend the bignum to at least the size of .octa. */
1070 if (expressionP
->X_add_number
< SIZE_OF_LARGE_NUMBER
)
1072 expressionP
->X_add_number
= SIZE_OF_LARGE_NUMBER
;
1073 for (; i
< expressionP
->X_add_number
; ++i
)
1074 generic_bignum
[i
] = ~(LITTLENUM_TYPE
) 0;
1078 for (i
= 0; i
< expressionP
->X_add_number
; ++i
)
1080 generic_bignum
[i
] += 1;
1081 if (generic_bignum
[i
])
1087 for (i
= 0; i
< expressionP
->X_add_number
; ++i
)
1088 if (generic_bignum
[i
] != 0)
1090 expressionP
->X_add_number
= i
>= expressionP
->X_add_number
;
1091 expressionP
->X_op
= O_constant
;
1092 expressionP
->X_unsigned
= 1;
1093 expressionP
->X_extrabit
= 0;
1096 else if (expressionP
->X_op
!= O_illegal
1097 && expressionP
->X_op
!= O_absent
)
1101 expressionP
->X_add_symbol
= make_expr_symbol (expressionP
);
1103 expressionP
->X_op
= O_uminus
;
1104 else if (c
== '~' || c
== '"')
1105 expressionP
->X_op
= O_bit_not
;
1107 expressionP
->X_op
= O_logical_not
;
1108 expressionP
->X_add_number
= 0;
1112 as_warn (_("Unary operator %c ignored because bad operand follows"),
1117 #if defined (DOLLAR_DOT) || defined (TC_M68K)
1119 /* '$' is the program counter when in MRI mode, or when
1120 DOLLAR_DOT is defined. */
1122 if (! flag_m68k_mri
)
1125 if (DOLLAR_AMBIGU
&& hex_p (*input_line_pointer
))
1127 /* In MRI mode and on Z80, '$' is also used as the prefix
1128 for a hexadecimal constant. */
1129 integer_constant (16, expressionP
);
1133 if (is_part_of_name (*input_line_pointer
))
1136 current_location (expressionP
);
1141 if (!is_part_of_name (*input_line_pointer
))
1143 current_location (expressionP
);
1146 else if ((strncasecmp (input_line_pointer
, "startof.", 8) == 0
1147 && ! is_part_of_name (input_line_pointer
[8]))
1148 || (strncasecmp (input_line_pointer
, "sizeof.", 7) == 0
1149 && ! is_part_of_name (input_line_pointer
[7])))
1153 start
= (input_line_pointer
[1] == 't'
1154 || input_line_pointer
[1] == 'T');
1155 input_line_pointer
+= start
? 8 : 7;
1157 if (*input_line_pointer
!= '(')
1158 as_bad (_("syntax error in .startof. or .sizeof."));
1163 ++input_line_pointer
;
1165 c
= get_symbol_name (& name
);
1167 buf
= concat (start
? ".startof." : ".sizeof.", name
,
1169 symbolP
= symbol_make (buf
);
1172 expressionP
->X_op
= O_symbol
;
1173 expressionP
->X_add_symbol
= symbolP
;
1174 expressionP
->X_add_number
= 0;
1176 *input_line_pointer
= c
;
1177 SKIP_WHITESPACE_AFTER_NAME ();
1178 if (*input_line_pointer
!= ')')
1179 as_bad (_("syntax error in .startof. or .sizeof."));
1181 ++input_line_pointer
;
1192 /* Can't imagine any other kind of operand. */
1193 expressionP
->X_op
= O_absent
;
1194 input_line_pointer
--;
1199 if (! flag_m68k_mri
)
1201 integer_constant (2, expressionP
);
1205 if (! flag_m68k_mri
)
1207 integer_constant (8, expressionP
);
1211 if (! flag_m68k_mri
)
1214 /* In MRI mode, this is a floating point constant represented
1215 using hexadecimal digits. */
1217 ++input_line_pointer
;
1218 integer_constant (16, expressionP
);
1222 if (! flag_m68k_mri
|| is_part_of_name (*input_line_pointer
))
1225 current_location (expressionP
);
1230 #if defined(md_need_index_operator) || defined(TC_M68K)
1233 if (is_name_beginner (c
) || c
== '"') /* Here if did not begin with a digit. */
1235 /* Identifier begins here.
1236 This is kludged for speed, so code is repeated. */
1238 -- input_line_pointer
;
1239 c
= get_symbol_name (&name
);
1243 operatorT op
= md_operator (name
, 1, &c
);
1248 restore_line_pointer (c
);
1252 restore_line_pointer (c
);
1256 restore_line_pointer (c
);
1260 as_bad (_("invalid use of operator \"%s\""), name
);
1266 if (op
!= O_absent
&& op
!= O_illegal
)
1268 restore_line_pointer (c
);
1269 expr (9, expressionP
, mode
);
1270 expressionP
->X_add_symbol
= make_expr_symbol (expressionP
);
1271 expressionP
->X_op_symbol
= NULL
;
1272 expressionP
->X_add_number
= 0;
1273 expressionP
->X_op
= op
;
1279 #ifdef md_parse_name
1280 /* This is a hook for the backend to parse certain names
1281 specially in certain contexts. If a name always has a
1282 specific value, it can often be handled by simply
1283 entering it in the symbol table. */
1284 if (md_parse_name (name
, expressionP
, mode
, &c
))
1286 restore_line_pointer (c
);
1292 /* The MRI i960 assembler permits
1294 FIXME: This should use md_parse_name. */
1296 && (strcasecmp (name
, "sizeof") == 0
1297 || strcasecmp (name
, "startof") == 0))
1302 start
= (name
[1] == 't'
1305 *input_line_pointer
= c
;
1306 SKIP_WHITESPACE_AFTER_NAME ();
1308 c
= get_symbol_name (& name
);
1310 buf
= concat (start
? ".startof." : ".sizeof.", name
,
1312 symbolP
= symbol_make (buf
);
1315 expressionP
->X_op
= O_symbol
;
1316 expressionP
->X_add_symbol
= symbolP
;
1317 expressionP
->X_add_number
= 0;
1319 *input_line_pointer
= c
;
1320 SKIP_WHITESPACE_AFTER_NAME ();
1325 symbolP
= symbol_find_or_make (name
);
1327 /* If we have an absolute symbol or a reg, then we know its
1329 segment
= S_GET_SEGMENT (symbolP
);
1330 if (mode
!= expr_defer
1331 && segment
== absolute_section
1332 && !S_FORCE_RELOC (symbolP
, 0))
1334 expressionP
->X_op
= O_constant
;
1335 expressionP
->X_add_number
= S_GET_VALUE (symbolP
);
1337 else if (mode
!= expr_defer
&& segment
== reg_section
)
1339 expressionP
->X_op
= O_register
;
1340 expressionP
->X_add_number
= S_GET_VALUE (symbolP
);
1344 expressionP
->X_op
= O_symbol
;
1345 expressionP
->X_add_symbol
= symbolP
;
1346 expressionP
->X_add_number
= 0;
1349 restore_line_pointer (c
);
1353 /* Let the target try to parse it. Success is indicated by changing
1354 the X_op field to something other than O_absent and pointing
1355 input_line_pointer past the expression. If it can't parse the
1356 expression, X_op and input_line_pointer should be unchanged. */
1357 expressionP
->X_op
= O_absent
;
1358 --input_line_pointer
;
1359 md_operand (expressionP
);
1360 if (expressionP
->X_op
== O_absent
)
1362 ++input_line_pointer
;
1363 as_bad (_("bad expression"));
1364 expressionP
->X_op
= O_constant
;
1365 expressionP
->X_add_number
= 0;
1371 /* It is more 'efficient' to clean up the expressionS when they are
1372 created. Doing it here saves lines of code. */
1373 clean_up_expression (expressionP
);
1374 SKIP_ALL_WHITESPACE (); /* -> 1st char after operand. */
1375 know (*input_line_pointer
!= ' ');
1377 /* The PA port needs this information. */
1378 if (expressionP
->X_add_symbol
)
1379 symbol_mark_used (expressionP
->X_add_symbol
);
1381 if (mode
!= expr_defer
)
1383 expressionP
->X_add_symbol
1384 = symbol_clone_if_forward_ref (expressionP
->X_add_symbol
);
1385 expressionP
->X_op_symbol
1386 = symbol_clone_if_forward_ref (expressionP
->X_op_symbol
);
1389 switch (expressionP
->X_op
)
1392 return absolute_section
;
1394 return S_GET_SEGMENT (expressionP
->X_add_symbol
);
1400 /* Internal. Simplify a struct expression for use by expr (). */
1402 /* In: address of an expressionS.
1403 The X_op field of the expressionS may only take certain values.
1404 Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
1406 Out: expressionS may have been modified:
1407 Unused fields zeroed to help expr (). */
1410 clean_up_expression (expressionS
*expressionP
)
1412 switch (expressionP
->X_op
)
1416 expressionP
->X_add_number
= 0;
1421 expressionP
->X_add_symbol
= NULL
;
1426 expressionP
->X_op_symbol
= NULL
;
1433 /* Expression parser. */
1435 /* We allow an empty expression, and just assume (absolute,0) silently.
1436 Unary operators and parenthetical expressions are treated as operands.
1437 As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
1439 We used to do an aho/ullman shift-reduce parser, but the logic got so
1440 warped that I flushed it and wrote a recursive-descent parser instead.
1441 Now things are stable, would anybody like to write a fast parser?
1442 Most expressions are either register (which does not even reach here)
1443 or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
1444 So I guess it doesn't really matter how inefficient more complex expressions
1447 After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
1448 Also, we have consumed any leading or trailing spaces (operand does that)
1449 and done all intervening operators.
1451 This returns the segment of the result, which will be
1452 absolute_section or the segment of a symbol. */
1455 #define __ O_illegal
1457 #define O_SINGLE_EQ O_illegal
1460 /* Maps ASCII -> operators. */
1461 static const operatorT op_encoding
[256] = {
1462 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1463 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1465 __
, O_bit_or_not
, __
, __
, __
, O_modulus
, O_bit_and
, __
,
1466 __
, __
, O_multiply
, O_add
, __
, O_subtract
, __
, O_divide
,
1467 __
, __
, __
, __
, __
, __
, __
, __
,
1468 __
, __
, __
, __
, O_lt
, O_SINGLE_EQ
, O_gt
, __
,
1469 __
, __
, __
, __
, __
, __
, __
, __
,
1470 __
, __
, __
, __
, __
, __
, __
, __
,
1471 __
, __
, __
, __
, __
, __
, __
, __
,
1473 #ifdef NEED_INDEX_OPERATOR
1478 __
, __
, O_bit_exclusive_or
, __
,
1479 __
, __
, __
, __
, __
, __
, __
, __
,
1480 __
, __
, __
, __
, __
, __
, __
, __
,
1481 __
, __
, __
, __
, __
, __
, __
, __
,
1482 __
, __
, __
, __
, O_bit_inclusive_or
, __
, __
, __
,
1484 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1485 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1486 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1487 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1488 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1489 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1490 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1491 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
1495 0 operand, (expression)
1500 5 used for * / % in MRI mode
1505 static operator_rankT op_rank
[O_max
] = {
1510 0, /* O_symbol_rva */
1515 9, /* O_logical_not */
1519 8, /* O_left_shift */
1520 8, /* O_right_shift */
1521 7, /* O_bit_inclusive_or */
1522 7, /* O_bit_or_not */
1523 7, /* O_bit_exclusive_or */
1533 3, /* O_logical_and */
1534 2, /* O_logical_or */
1538 /* Unfortunately, in MRI mode for the m68k, multiplication and
1539 division have lower precedence than the bit wise operators. This
1540 function sets the operator precedences correctly for the current
1541 mode. Also, MRI uses a different bit_not operator, and this fixes
1544 #define STANDARD_MUL_PRECEDENCE 8
1545 #define MRI_MUL_PRECEDENCE 6
1548 expr_set_precedence (void)
1552 op_rank
[O_multiply
] = MRI_MUL_PRECEDENCE
;
1553 op_rank
[O_divide
] = MRI_MUL_PRECEDENCE
;
1554 op_rank
[O_modulus
] = MRI_MUL_PRECEDENCE
;
1558 op_rank
[O_multiply
] = STANDARD_MUL_PRECEDENCE
;
1559 op_rank
[O_divide
] = STANDARD_MUL_PRECEDENCE
;
1560 op_rank
[O_modulus
] = STANDARD_MUL_PRECEDENCE
;
1565 expr_set_rank (operatorT op
, operator_rankT rank
)
1567 gas_assert (op
>= O_md1
&& op
< ARRAY_SIZE (op_rank
));
1571 /* Initialize the expression parser. */
1576 expr_set_precedence ();
1578 /* Verify that X_op field is wide enough. */
1582 gas_assert (e
.X_op
== O_max
);
1586 /* Return the encoding for the operator at INPUT_LINE_POINTER, and
1587 sets NUM_CHARS to the number of characters in the operator.
1588 Does not advance INPUT_LINE_POINTER. */
1590 static inline operatorT
1591 operatorf (int *num_chars
)
1596 c
= *input_line_pointer
& 0xff;
1599 if (is_end_of_line
[c
])
1603 if (is_name_beginner (c
))
1606 char ec
= get_symbol_name (& name
);
1608 ret
= md_operator (name
, 2, &ec
);
1612 *input_line_pointer
= ec
;
1613 input_line_pointer
= name
;
1618 as_bad (_("invalid use of operator \"%s\""), name
);
1622 *input_line_pointer
= ec
;
1623 *num_chars
= input_line_pointer
- name
;
1624 input_line_pointer
= name
;
1633 ret
= op_encoding
[c
];
1635 if (ret
== O_illegal
)
1637 char *start
= input_line_pointer
;
1639 ret
= md_operator (NULL
, 2, NULL
);
1640 if (ret
!= O_illegal
)
1641 *num_chars
= input_line_pointer
- start
;
1642 input_line_pointer
= start
;
1649 return op_encoding
[c
];
1652 switch (input_line_pointer
[1])
1655 return op_encoding
[c
];
1670 if (input_line_pointer
[1] != '=')
1671 return op_encoding
[c
];
1677 switch (input_line_pointer
[1])
1680 return op_encoding
[c
];
1682 ret
= O_right_shift
;
1692 switch (input_line_pointer
[1])
1695 /* We accept !! as equivalent to ^ for MRI compatibility. */
1697 return O_bit_exclusive_or
;
1699 /* We accept != as equivalent to <>. */
1704 return O_bit_inclusive_or
;
1705 return op_encoding
[c
];
1709 if (input_line_pointer
[1] != '|')
1710 return op_encoding
[c
];
1713 return O_logical_or
;
1716 if (input_line_pointer
[1] != '&')
1717 return op_encoding
[c
];
1720 return O_logical_and
;
1726 /* Implement "word-size + 1 bit" addition for
1727 {resultP->X_extrabit:resultP->X_add_number} + {rhs_highbit:amount}. This
1728 is used so that the full range of unsigned word values and the full range of
1729 signed word values can be represented in an O_constant expression, which is
1730 useful e.g. for .sleb128 directives. */
1733 add_to_result (expressionS
*resultP
, offsetT amount
, int rhs_highbit
)
1735 valueT ures
= resultP
->X_add_number
;
1736 valueT uamount
= amount
;
1738 resultP
->X_add_number
+= amount
;
1740 resultP
->X_extrabit
^= rhs_highbit
;
1742 if (ures
+ uamount
< ures
)
1743 resultP
->X_extrabit
^= 1;
1746 /* Similarly, for subtraction. */
1749 subtract_from_result (expressionS
*resultP
, offsetT amount
, int rhs_highbit
)
1751 valueT ures
= resultP
->X_add_number
;
1752 valueT uamount
= amount
;
1754 resultP
->X_add_number
-= amount
;
1756 resultP
->X_extrabit
^= rhs_highbit
;
1759 resultP
->X_extrabit
^= 1;
1762 /* Parse an expression. */
1765 expr (int rankarg
, /* Larger # is higher rank. */
1766 expressionS
*resultP
, /* Deliver result here. */
1767 enum expr_mode mode
/* Controls behavior. */)
1769 operator_rankT rank
= (operator_rankT
) rankarg
;
1776 know (rankarg
>= 0);
1778 /* Save the value of dot for the fixup code. */
1781 dot_value
= frag_now_fix ();
1782 dot_frag
= frag_now
;
1785 retval
= operand (resultP
, mode
);
1787 /* operand () gobbles spaces. */
1788 know (*input_line_pointer
!= ' ');
1790 op_left
= operatorf (&op_chars
);
1791 while (op_left
!= O_illegal
&& op_rank
[(int) op_left
] > rank
)
1796 input_line_pointer
+= op_chars
; /* -> after operator. */
1799 rightseg
= expr (op_rank
[(int) op_left
], &right
, mode
);
1800 if (right
.X_op
== O_absent
)
1802 as_warn (_("missing operand; zero assumed"));
1803 right
.X_op
= O_constant
;
1804 right
.X_add_number
= 0;
1805 right
.X_add_symbol
= NULL
;
1806 right
.X_op_symbol
= NULL
;
1809 know (*input_line_pointer
!= ' ');
1811 if (op_left
== O_index
)
1813 if (*input_line_pointer
!= ']')
1814 as_bad ("missing right bracket");
1817 ++input_line_pointer
;
1822 op_right
= operatorf (&op_chars
);
1824 know (op_right
== O_illegal
|| op_left
== O_index
1825 || op_rank
[(int) op_right
] <= op_rank
[(int) op_left
]);
1826 know ((int) op_left
>= (int) O_multiply
);
1828 know ((int) op_left
<= (int) O_index
);
1830 know ((int) op_left
< (int) O_max
);
1833 /* input_line_pointer->after right-hand quantity. */
1834 /* left-hand quantity in resultP. */
1835 /* right-hand quantity in right. */
1836 /* operator in op_left. */
1838 if (resultP
->X_op
== O_big
)
1840 if (resultP
->X_add_number
> 0)
1841 as_warn (_("left operand is a bignum; integer 0 assumed"));
1843 as_warn (_("left operand is a float; integer 0 assumed"));
1844 resultP
->X_op
= O_constant
;
1845 resultP
->X_add_number
= 0;
1846 resultP
->X_add_symbol
= NULL
;
1847 resultP
->X_op_symbol
= NULL
;
1849 if (right
.X_op
== O_big
)
1851 if (right
.X_add_number
> 0)
1852 as_warn (_("right operand is a bignum; integer 0 assumed"));
1854 as_warn (_("right operand is a float; integer 0 assumed"));
1855 right
.X_op
= O_constant
;
1856 right
.X_add_number
= 0;
1857 right
.X_add_symbol
= NULL
;
1858 right
.X_op_symbol
= NULL
;
1861 /* Optimize common cases. */
1862 #ifdef md_optimize_expr
1863 if (md_optimize_expr (resultP
, op_left
, &right
))
1870 #ifndef md_register_arithmetic
1871 # define md_register_arithmetic 1
1873 if (op_left
== O_add
&& right
.X_op
== O_constant
1874 && (md_register_arithmetic
|| resultP
->X_op
!= O_register
))
1877 add_to_result (resultP
, right
.X_add_number
, right
.X_extrabit
);
1879 /* This case comes up in PIC code. */
1880 else if (op_left
== O_subtract
1881 && right
.X_op
== O_symbol
1882 && resultP
->X_op
== O_symbol
1883 && retval
== rightseg
1884 #ifdef md_allow_local_subtract
1885 && md_allow_local_subtract (resultP
, & right
, rightseg
)
1887 && ((SEG_NORMAL (rightseg
)
1888 && !S_FORCE_RELOC (resultP
->X_add_symbol
, 0)
1889 && !S_FORCE_RELOC (right
.X_add_symbol
, 0))
1890 || right
.X_add_symbol
== resultP
->X_add_symbol
)
1891 && frag_offset_fixed_p (symbol_get_frag (resultP
->X_add_symbol
),
1892 symbol_get_frag (right
.X_add_symbol
),
1895 offsetT symval_diff
= S_GET_VALUE (resultP
->X_add_symbol
)
1896 - S_GET_VALUE (right
.X_add_symbol
);
1897 subtract_from_result (resultP
, right
.X_add_number
, right
.X_extrabit
);
1898 subtract_from_result (resultP
, frag_off
/ OCTETS_PER_BYTE
, 0);
1899 add_to_result (resultP
, symval_diff
, symval_diff
< 0);
1900 resultP
->X_op
= O_constant
;
1901 resultP
->X_add_symbol
= 0;
1903 else if (op_left
== O_subtract
&& right
.X_op
== O_constant
1904 && (md_register_arithmetic
|| resultP
->X_op
!= O_register
))
1907 subtract_from_result (resultP
, right
.X_add_number
, right
.X_extrabit
);
1909 else if (op_left
== O_add
&& resultP
->X_op
== O_constant
1910 && (md_register_arithmetic
|| right
.X_op
!= O_register
))
1913 resultP
->X_op
= right
.X_op
;
1914 resultP
->X_add_symbol
= right
.X_add_symbol
;
1915 resultP
->X_op_symbol
= right
.X_op_symbol
;
1916 add_to_result (resultP
, right
.X_add_number
, right
.X_extrabit
);
1919 else if (resultP
->X_op
== O_constant
&& right
.X_op
== O_constant
)
1921 /* Constant OP constant. */
1922 offsetT v
= right
.X_add_number
;
1923 if (v
== 0 && (op_left
== O_divide
|| op_left
== O_modulus
))
1925 as_warn (_("division by zero"));
1928 if ((valueT
) v
>= sizeof(valueT
) * CHAR_BIT
1929 && (op_left
== O_left_shift
|| op_left
== O_right_shift
))
1931 as_warn_value_out_of_range (_("shift count"), v
, 0,
1932 sizeof(valueT
) * CHAR_BIT
- 1,
1934 resultP
->X_add_number
= v
= 0;
1938 default: goto general
;
1939 case O_multiply
: resultP
->X_add_number
*= v
; break;
1940 case O_divide
: resultP
->X_add_number
/= v
; break;
1941 case O_modulus
: resultP
->X_add_number
%= v
; break;
1942 case O_left_shift
: resultP
->X_add_number
<<= v
; break;
1944 /* We always use unsigned shifts, to avoid relying on
1945 characteristics of the compiler used to compile gas. */
1946 resultP
->X_add_number
=
1947 (offsetT
) ((valueT
) resultP
->X_add_number
>> (valueT
) v
);
1949 case O_bit_inclusive_or
: resultP
->X_add_number
|= v
; break;
1950 case O_bit_or_not
: resultP
->X_add_number
|= ~v
; break;
1951 case O_bit_exclusive_or
: resultP
->X_add_number
^= v
; break;
1952 case O_bit_and
: resultP
->X_add_number
&= v
; break;
1953 /* Constant + constant (O_add) is handled by the
1954 previous if statement for constant + X, so is omitted
1957 subtract_from_result (resultP
, v
, 0);
1960 resultP
->X_add_number
=
1961 resultP
->X_add_number
== v
? ~ (offsetT
) 0 : 0;
1964 resultP
->X_add_number
=
1965 resultP
->X_add_number
!= v
? ~ (offsetT
) 0 : 0;
1968 resultP
->X_add_number
=
1969 resultP
->X_add_number
< v
? ~ (offsetT
) 0 : 0;
1972 resultP
->X_add_number
=
1973 resultP
->X_add_number
<= v
? ~ (offsetT
) 0 : 0;
1976 resultP
->X_add_number
=
1977 resultP
->X_add_number
>= v
? ~ (offsetT
) 0 : 0;
1980 resultP
->X_add_number
=
1981 resultP
->X_add_number
> v
? ~ (offsetT
) 0 : 0;
1984 resultP
->X_add_number
= resultP
->X_add_number
&& v
;
1987 resultP
->X_add_number
= resultP
->X_add_number
|| v
;
1991 else if (resultP
->X_op
== O_symbol
1992 && right
.X_op
== O_symbol
1993 && (op_left
== O_add
1994 || op_left
== O_subtract
1995 || (resultP
->X_add_number
== 0
1996 && right
.X_add_number
== 0)))
1998 /* Symbol OP symbol. */
1999 resultP
->X_op
= op_left
;
2000 resultP
->X_op_symbol
= right
.X_add_symbol
;
2001 if (op_left
== O_add
)
2002 add_to_result (resultP
, right
.X_add_number
, right
.X_extrabit
);
2003 else if (op_left
== O_subtract
)
2005 subtract_from_result (resultP
, right
.X_add_number
,
2007 if (retval
== rightseg
2008 && SEG_NORMAL (retval
)
2009 && !S_FORCE_RELOC (resultP
->X_add_symbol
, 0)
2010 && !S_FORCE_RELOC (right
.X_add_symbol
, 0))
2012 retval
= absolute_section
;
2013 rightseg
= absolute_section
;
2020 /* The general case. */
2021 resultP
->X_add_symbol
= make_expr_symbol (resultP
);
2022 resultP
->X_op_symbol
= make_expr_symbol (&right
);
2023 resultP
->X_op
= op_left
;
2024 resultP
->X_add_number
= 0;
2025 resultP
->X_unsigned
= 1;
2026 resultP
->X_extrabit
= 0;
2029 if (retval
!= rightseg
)
2031 if (retval
== undefined_section
)
2033 else if (rightseg
== undefined_section
)
2035 else if (retval
== expr_section
)
2037 else if (rightseg
== expr_section
)
2039 else if (retval
== reg_section
)
2041 else if (rightseg
== reg_section
)
2043 else if (rightseg
== absolute_section
)
2045 else if (retval
== absolute_section
)
2048 else if (op_left
== O_subtract
)
2052 as_bad (_("operation combines symbols in different segments"));
2056 } /* While next operator is >= this rank. */
2058 /* The PA port needs this information. */
2059 if (resultP
->X_add_symbol
)
2060 symbol_mark_used (resultP
->X_add_symbol
);
2062 if (rank
== 0 && mode
== expr_evaluate
)
2063 resolve_expression (resultP
);
2065 return resultP
->X_op
== O_constant
? absolute_section
: retval
;
2068 /* Resolve an expression without changing any symbols/sub-expressions
2072 resolve_expression (expressionS
*expressionP
)
2074 /* Help out with CSE. */
2075 valueT final_val
= expressionP
->X_add_number
;
2076 symbolS
*add_symbol
= expressionP
->X_add_symbol
;
2077 symbolS
*orig_add_symbol
= add_symbol
;
2078 symbolS
*op_symbol
= expressionP
->X_op_symbol
;
2079 operatorT op
= expressionP
->X_op
;
2081 segT seg_left
, seg_right
;
2082 fragS
*frag_left
, *frag_right
;
2097 if (!snapshot_symbol (&add_symbol
, &left
, &seg_left
, &frag_left
))
2105 if (!snapshot_symbol (&add_symbol
, &left
, &seg_left
, &frag_left
))
2108 if (seg_left
!= absolute_section
)
2111 if (op
== O_logical_not
)
2113 else if (op
== O_uminus
)
2125 case O_bit_inclusive_or
:
2127 case O_bit_exclusive_or
:
2139 if (!snapshot_symbol (&add_symbol
, &left
, &seg_left
, &frag_left
)
2140 || !snapshot_symbol (&op_symbol
, &right
, &seg_right
, &frag_right
))
2143 /* Simplify addition or subtraction of a constant by folding the
2144 constant into X_add_number. */
2147 if (seg_right
== absolute_section
)
2153 else if (seg_left
== absolute_section
)
2157 seg_left
= seg_right
;
2158 add_symbol
= op_symbol
;
2159 orig_add_symbol
= expressionP
->X_op_symbol
;
2164 else if (op
== O_subtract
)
2166 if (seg_right
== absolute_section
)
2174 /* Equality and non-equality tests are permitted on anything.
2175 Subtraction, and other comparison operators are permitted if
2176 both operands are in the same section.
2177 Shifts by constant zero are permitted on anything.
2178 Multiplies, bit-ors, and bit-ands with constant zero are
2179 permitted on anything.
2180 Multiplies and divides by constant one are permitted on
2182 Binary operations with both operands being the same register
2183 or undefined symbol are permitted if the result doesn't depend
2185 Otherwise, both operands must be absolute. We already handled
2186 the case of addition or subtraction of a constant above. */
2188 if (!(seg_left
== absolute_section
2189 && seg_right
== absolute_section
)
2190 && !(op
== O_eq
|| op
== O_ne
)
2191 && !((op
== O_subtract
2192 || op
== O_lt
|| op
== O_le
|| op
== O_ge
|| op
== O_gt
)
2193 && seg_left
== seg_right
2195 || frag_offset_fixed_p (frag_left
, frag_right
, &frag_off
))
2196 && (seg_left
!= reg_section
|| left
== right
)
2197 && (seg_left
!= undefined_section
|| add_symbol
== op_symbol
)))
2199 if ((seg_left
== absolute_section
&& left
== 0)
2200 || (seg_right
== absolute_section
&& right
== 0))
2202 if (op
== O_bit_exclusive_or
|| op
== O_bit_inclusive_or
)
2204 if (!(seg_right
== absolute_section
&& right
== 0))
2206 seg_left
= seg_right
;
2208 add_symbol
= op_symbol
;
2209 orig_add_symbol
= expressionP
->X_op_symbol
;
2214 else if (op
== O_left_shift
|| op
== O_right_shift
)
2216 if (!(seg_left
== absolute_section
&& left
== 0))
2222 else if (op
!= O_multiply
2223 && op
!= O_bit_or_not
&& op
!= O_bit_and
)
2226 else if (op
== O_multiply
2227 && seg_left
== absolute_section
&& left
== 1)
2229 seg_left
= seg_right
;
2231 add_symbol
= op_symbol
;
2232 orig_add_symbol
= expressionP
->X_op_symbol
;
2236 else if ((op
== O_multiply
|| op
== O_divide
)
2237 && seg_right
== absolute_section
&& right
== 1)
2242 else if (!(left
== right
2243 && ((seg_left
== reg_section
&& seg_right
== reg_section
)
2244 || (seg_left
== undefined_section
2245 && seg_right
== undefined_section
2246 && add_symbol
== op_symbol
))))
2248 else if (op
== O_bit_and
|| op
== O_bit_inclusive_or
)
2253 else if (op
!= O_bit_exclusive_or
&& op
!= O_bit_or_not
)
2257 right
+= frag_off
/ OCTETS_PER_BYTE
;
2260 case O_add
: left
+= right
; break;
2261 case O_subtract
: left
-= right
; break;
2262 case O_multiply
: left
*= right
; break;
2266 left
= (offsetT
) left
/ (offsetT
) right
;
2271 left
= (offsetT
) left
% (offsetT
) right
;
2273 case O_left_shift
: left
<<= right
; break;
2274 case O_right_shift
: left
>>= right
; break;
2275 case O_bit_inclusive_or
: left
|= right
; break;
2276 case O_bit_or_not
: left
|= ~right
; break;
2277 case O_bit_exclusive_or
: left
^= right
; break;
2278 case O_bit_and
: left
&= right
; break;
2281 left
= (left
== right
2282 && seg_left
== seg_right
2283 && (finalize_syms
|| frag_left
== frag_right
)
2284 && (seg_left
!= undefined_section
2285 || add_symbol
== op_symbol
)
2286 ? ~ (valueT
) 0 : 0);
2291 left
= (offsetT
) left
< (offsetT
) right
? ~ (valueT
) 0 : 0;
2294 left
= (offsetT
) left
<= (offsetT
) right
? ~ (valueT
) 0 : 0;
2297 left
= (offsetT
) left
>= (offsetT
) right
? ~ (valueT
) 0 : 0;
2300 left
= (offsetT
) left
> (offsetT
) right
? ~ (valueT
) 0 : 0;
2302 case O_logical_and
: left
= left
&& right
; break;
2303 case O_logical_or
: left
= left
|| right
; break;
2313 if (seg_left
== absolute_section
)
2315 else if (seg_left
== reg_section
&& final_val
== 0)
2317 else if (!symbol_same_p (add_symbol
, orig_add_symbol
))
2319 expressionP
->X_add_symbol
= add_symbol
;
2321 expressionP
->X_op
= op
;
2323 if (op
== O_constant
|| op
== O_register
)
2325 expressionP
->X_add_number
= final_val
;
2330 /* This lives here because it belongs equally in expr.c & read.c.
2331 expr.c is just a branch office read.c anyway, and putting it
2332 here lessens the crowd at read.c.
2334 Assume input_line_pointer is at start of symbol name, or the
2335 start of a double quote enclosed symbol name.
2336 Advance input_line_pointer past symbol name.
2337 Turn that character into a '\0', returning its former value,
2338 which may be the closing double quote.
2339 This allows a string compare (RMS wants symbol names to be strings)
2341 There will always be a char following symbol name, because all good
2342 lines end in end-of-line. */
2345 get_symbol_name (char ** ilp_return
)
2349 * ilp_return
= input_line_pointer
;
2350 /* We accept \001 in a name in case this is being called with a
2351 constructed string. */
2352 if (is_name_beginner (c
= *input_line_pointer
++) || c
== '\001')
2354 while (is_part_of_name (c
= *input_line_pointer
++)
2357 if (is_name_ender (c
))
2358 c
= *input_line_pointer
++;
2362 bfd_boolean backslash_seen
;
2364 * ilp_return
= input_line_pointer
;
2367 backslash_seen
= c
== '\\';
2368 c
= * input_line_pointer
++;
2370 while (c
!= 0 && (c
!= '"' || backslash_seen
));
2373 as_warn (_("missing closing '\"'"));
2375 *--input_line_pointer
= 0;
2379 /* Replace the NUL character pointed to by input_line_pointer
2380 with C. If C is \" then advance past it. Return the character
2381 now pointed to by input_line_pointer. */
2384 restore_line_pointer (char c
)
2386 * input_line_pointer
= c
;
2388 c
= * ++ input_line_pointer
;
2393 get_single_number (void)
2396 operand (&exp
, expr_normal
);
2397 return exp
.X_add_number
;