1 /* expr.c -operands, expressions-
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* This is really a branch office of as-read.c. I split it out to clearly
22 distinguish the world of expressions from the world of statements.
23 (It also gives smaller files to re-compile.)
24 Here, "operand"s are of expressions, not instructions. */
26 #define min(a, b) ((a) < (b) ? (a) : (b))
29 #include "safe-ctype.h"
38 static void floating_constant (expressionS
* expressionP
);
39 static valueT
generic_bignum_to_int32 (void);
41 static valueT
generic_bignum_to_int64 (void);
43 static void integer_constant (int radix
, expressionS
* expressionP
);
44 static void mri_char_constant (expressionS
*);
45 static void clean_up_expression (expressionS
* expressionP
);
46 static segT
operand (expressionS
*, enum expr_mode
);
47 static operatorT
operatorf (int *);
49 extern const char EXP_CHARS
[], FLT_CHARS
[];
51 /* We keep a mapping of expression symbols to file positions, so that
52 we can provide better error messages. */
54 struct expr_symbol_line
{
55 struct expr_symbol_line
*next
;
61 static struct expr_symbol_line
*expr_symbol_lines
;
63 /* Build a dummy symbol to hold a complex expression. This is how we
64 build expressions up out of other expressions. The symbol is put
65 into the fake section expr_section. */
68 make_expr_symbol (expressionS
*expressionP
)
72 struct expr_symbol_line
*n
;
74 if (expressionP
->X_op
== O_symbol
75 && expressionP
->X_add_number
== 0)
76 return expressionP
->X_add_symbol
;
78 if (expressionP
->X_op
== O_big
)
80 /* This won't work, because the actual value is stored in
81 generic_floating_point_number or generic_bignum, and we are
82 going to lose it if we haven't already. */
83 if (expressionP
->X_add_number
> 0)
84 as_bad (_("bignum invalid"));
86 as_bad (_("floating point number invalid"));
87 zero
.X_op
= O_constant
;
88 zero
.X_add_number
= 0;
91 clean_up_expression (&zero
);
95 /* Putting constant symbols in absolute_section rather than
96 expr_section is convenient for the old a.out code, for which
97 S_GET_SEGMENT does not always retrieve the value put in by
99 symbolP
= symbol_create (FAKE_LABEL_NAME
,
100 (expressionP
->X_op
== O_constant
102 : expressionP
->X_op
== O_register
105 0, &zero_address_frag
);
106 symbol_set_value_expression (symbolP
, expressionP
);
108 if (expressionP
->X_op
== O_constant
)
109 resolve_symbol_value (symbolP
);
111 n
= (struct expr_symbol_line
*) xmalloc (sizeof *n
);
113 as_where (&n
->file
, &n
->line
);
114 n
->next
= expr_symbol_lines
;
115 expr_symbol_lines
= n
;
120 /* Return the file and line number for an expr symbol. Return
121 non-zero if something was found, 0 if no information is known for
125 expr_symbol_where (symbolS
*sym
, char **pfile
, unsigned int *pline
)
127 struct expr_symbol_line
*l
;
129 for (l
= expr_symbol_lines
; l
!= NULL
; l
= l
->next
)
142 /* Utilities for building expressions.
143 Since complex expressions are recorded as symbols for use in other
144 expressions these return a symbolS * and not an expressionS *.
145 These explicitly do not take an "add_number" argument. */
146 /* ??? For completeness' sake one might want expr_build_symbol.
147 It would just return its argument. */
149 /* Build an expression for an unsigned constant.
150 The corresponding one for signed constants is missing because
151 there's currently no need for it. One could add an unsigned_p flag
152 but that seems more clumsy. */
155 expr_build_uconstant (offsetT value
)
160 e
.X_add_number
= value
;
163 return make_expr_symbol (&e
);
166 /* Build an expression for the current location ('.'). */
169 expr_build_dot (void)
173 current_location (&e
);
174 return symbol_clone_if_forward_ref (make_expr_symbol (&e
));
177 /* Build any floating-point literal here.
178 Also build any bignum literal here. */
180 /* Seems atof_machine can backscan through generic_bignum and hit whatever
181 happens to be loaded before it in memory. And its way too complicated
182 for me to fix right. Thus a hack. JF: Just make generic_bignum bigger,
183 and never write into the early words, thus they'll always be zero.
184 I hate Dean's floating-point code. Bleh. */
185 LITTLENUM_TYPE generic_bignum
[SIZE_OF_LARGE_NUMBER
+ 6];
187 FLONUM_TYPE generic_floating_point_number
= {
188 &generic_bignum
[6], /* low. (JF: Was 0) */
189 &generic_bignum
[SIZE_OF_LARGE_NUMBER
+ 6 - 1], /* high. JF: (added +6) */
197 floating_constant (expressionS
*expressionP
)
199 /* input_line_pointer -> floating-point constant. */
202 error_code
= atof_generic (&input_line_pointer
, ".", EXP_CHARS
,
203 &generic_floating_point_number
);
207 if (error_code
== ERROR_EXPONENT_OVERFLOW
)
209 as_bad (_("bad floating-point constant: exponent overflow"));
213 as_bad (_("bad floating-point constant: unknown error code=%d"),
217 expressionP
->X_op
= O_big
;
218 /* input_line_pointer -> just after constant, which may point to
220 expressionP
->X_add_number
= -1;
224 generic_bignum_to_int32 (void)
227 ((generic_bignum
[1] & LITTLENUM_MASK
) << LITTLENUM_NUMBER_OF_BITS
)
228 | (generic_bignum
[0] & LITTLENUM_MASK
);
229 number
&= 0xffffffff;
235 generic_bignum_to_int64 (void)
238 ((((((((valueT
) generic_bignum
[3] & LITTLENUM_MASK
)
239 << LITTLENUM_NUMBER_OF_BITS
)
240 | ((valueT
) generic_bignum
[2] & LITTLENUM_MASK
))
241 << LITTLENUM_NUMBER_OF_BITS
)
242 | ((valueT
) generic_bignum
[1] & LITTLENUM_MASK
))
243 << LITTLENUM_NUMBER_OF_BITS
)
244 | ((valueT
) generic_bignum
[0] & LITTLENUM_MASK
));
250 integer_constant (int radix
, expressionS
*expressionP
)
252 char *start
; /* Start of number. */
255 valueT number
; /* Offset or (absolute) value. */
256 short int digit
; /* Value of next digit in current radix. */
257 short int maxdig
= 0; /* Highest permitted digit value. */
258 int too_many_digits
= 0; /* If we see >= this number of. */
259 char *name
; /* Points to name of symbol. */
260 symbolS
*symbolP
; /* Points to symbol. */
262 int small
; /* True if fits in 32 bits. */
264 /* May be bignum, or may fit in 32 bits. */
265 /* Most numbers fit into 32 bits, and we want this case to be fast.
266 so we pretend it will fit into 32 bits. If, after making up a 32
267 bit number, we realise that we have scanned more digits than
268 comfortably fit into 32 bits, we re-scan the digits coding them
269 into a bignum. For decimal and octal numbers we are
270 conservative: Some numbers may be assumed bignums when in fact
271 they do fit into 32 bits. Numbers of any radix can have excess
272 leading zeros: We strive to recognise this and cast them back
273 into 32 bits. We must check that the bignum really is more than
274 32 bits, and change it back to a 32-bit number if it fits. The
275 number we are looking for is expected to be positive, but if it
276 fits into 32 bits as an unsigned number, we let it be a 32-bit
277 number. The cavalier approach is for speed in ordinary cases. */
278 /* This has been extended for 64 bits. We blindly assume that if
279 you're compiling in 64-bit mode, the target is a 64-bit machine.
280 This should be cleaned up. */
284 #else /* includes non-bfd case, mostly */
288 if (is_end_of_line
[(unsigned char) *input_line_pointer
])
290 expressionP
->X_op
= O_absent
;
294 if ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
) && radix
== 0)
298 /* In MRI mode, the number may have a suffix indicating the
299 radix. For that matter, it might actually be a floating
301 for (suffix
= input_line_pointer
; ISALNUM (*suffix
); suffix
++)
303 if (*suffix
== 'e' || *suffix
== 'E')
307 if (suffix
== input_line_pointer
)
316 /* If we have both NUMBERS_WITH_SUFFIX and LOCAL_LABELS_FB,
317 we distinguish between 'B' and 'b'. This is the case for
319 if ((NUMBERS_WITH_SUFFIX
&& LOCAL_LABELS_FB
? *suffix
: c
) == 'B')
323 else if (c
== 'O' || c
== 'Q')
327 else if (suffix
[1] == '.' || c
== 'E' || flt
)
329 floating_constant (expressionP
);
344 too_many_digits
= valuesize
+ 1;
348 too_many_digits
= (valuesize
+ 2) / 3 + 1;
352 too_many_digits
= (valuesize
+ 3) / 4 + 1;
356 too_many_digits
= (valuesize
+ 11) / 4; /* Very rough. */
359 start
= input_line_pointer
;
360 c
= *input_line_pointer
++;
362 (digit
= hex_value (c
)) < maxdig
;
363 c
= *input_line_pointer
++)
365 number
= number
* radix
+ digit
;
367 /* c contains character after number. */
368 /* input_line_pointer->char after c. */
369 small
= (input_line_pointer
- start
- 1) < too_many_digits
;
371 if (radix
== 16 && c
== '_')
373 /* This is literal of the form 0x333_0_12345678_1.
374 This example is equivalent to 0x00000333000000001234567800000001. */
376 int num_little_digits
= 0;
378 input_line_pointer
= start
; /* -> 1st digit. */
380 know (LITTLENUM_NUMBER_OF_BITS
== 16);
382 for (c
= '_'; c
== '_'; num_little_digits
+= 2)
385 /* Convert one 64-bit word. */
388 for (c
= *input_line_pointer
++;
389 (digit
= hex_value (c
)) < maxdig
;
390 c
= *(input_line_pointer
++))
392 number
= number
* radix
+ digit
;
396 /* Check for 8 digit per word max. */
398 as_bad (_("a bignum with underscores may not have more than 8 hex digits in any word"));
400 /* Add this chunk to the bignum.
401 Shift things down 2 little digits. */
402 know (LITTLENUM_NUMBER_OF_BITS
== 16);
403 for (i
= min (num_little_digits
+ 1, SIZE_OF_LARGE_NUMBER
- 1);
406 generic_bignum
[i
] = generic_bignum
[i
- 2];
408 /* Add the new digits as the least significant new ones. */
409 generic_bignum
[0] = number
& 0xffffffff;
410 generic_bignum
[1] = number
>> 16;
413 /* Again, c is char after number, input_line_pointer->after c. */
415 if (num_little_digits
> SIZE_OF_LARGE_NUMBER
- 1)
416 num_little_digits
= SIZE_OF_LARGE_NUMBER
- 1;
418 gas_assert (num_little_digits
>= 4);
420 if (num_little_digits
!= 8)
421 as_bad (_("a bignum with underscores must have exactly 4 words"));
423 /* We might have some leading zeros. These can be trimmed to give
424 us a change to fit this constant into a small number. */
425 while (generic_bignum
[num_little_digits
- 1] == 0
426 && num_little_digits
> 1)
429 if (num_little_digits
<= 2)
431 /* will fit into 32 bits. */
432 number
= generic_bignum_to_int32 ();
436 else if (num_little_digits
<= 4)
438 /* Will fit into 64 bits. */
439 number
= generic_bignum_to_int64 ();
447 /* Number of littlenums in the bignum. */
448 number
= num_little_digits
;
453 /* We saw a lot of digits. manufacture a bignum the hard way. */
454 LITTLENUM_TYPE
*leader
; /* -> high order littlenum of the bignum. */
455 LITTLENUM_TYPE
*pointer
; /* -> littlenum we are frobbing now. */
458 leader
= generic_bignum
;
459 generic_bignum
[0] = 0;
460 generic_bignum
[1] = 0;
461 generic_bignum
[2] = 0;
462 generic_bignum
[3] = 0;
463 input_line_pointer
= start
; /* -> 1st digit. */
464 c
= *input_line_pointer
++;
465 for (; (carry
= hex_value (c
)) < maxdig
; c
= *input_line_pointer
++)
467 for (pointer
= generic_bignum
; pointer
<= leader
; pointer
++)
471 work
= carry
+ radix
* *pointer
;
472 *pointer
= work
& LITTLENUM_MASK
;
473 carry
= work
>> LITTLENUM_NUMBER_OF_BITS
;
477 if (leader
< generic_bignum
+ SIZE_OF_LARGE_NUMBER
- 1)
479 /* Room to grow a longer bignum. */
484 /* Again, c is char after number. */
485 /* input_line_pointer -> after c. */
486 know (LITTLENUM_NUMBER_OF_BITS
== 16);
487 if (leader
< generic_bignum
+ 2)
489 /* Will fit into 32 bits. */
490 number
= generic_bignum_to_int32 ();
494 else if (leader
< generic_bignum
+ 4)
496 /* Will fit into 64 bits. */
497 number
= generic_bignum_to_int64 ();
503 /* Number of littlenums in the bignum. */
504 number
= leader
- generic_bignum
+ 1;
508 if ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
510 && input_line_pointer
- 1 == suffix
)
511 c
= *input_line_pointer
++;
515 /* Here with number, in correct radix. c is the next char.
516 Note that unlike un*x, we allow "011f" "0x9f" to both mean
517 the same as the (conventional) "9f".
518 This is simply easier than checking for strict canonical
521 if (LOCAL_LABELS_FB
&& c
== 'b')
523 /* Backward ref to local label.
524 Because it is backward, expect it to be defined. */
525 /* Construct a local label. */
526 name
= fb_label_name ((int) number
, 0);
528 /* Seen before, or symbol is defined: OK. */
529 symbolP
= symbol_find (name
);
530 if ((symbolP
!= NULL
) && (S_IS_DEFINED (symbolP
)))
532 /* Local labels are never absolute. Don't waste time
533 checking absoluteness. */
534 know (SEG_NORMAL (S_GET_SEGMENT (symbolP
)));
536 expressionP
->X_op
= O_symbol
;
537 expressionP
->X_add_symbol
= symbolP
;
541 /* Either not seen or not defined. */
542 /* @@ Should print out the original string instead of
543 the parsed number. */
544 as_bad (_("backward ref to unknown label \"%d:\""),
546 expressionP
->X_op
= O_constant
;
549 expressionP
->X_add_number
= 0;
551 else if (LOCAL_LABELS_FB
&& c
== 'f')
553 /* Forward reference. Expect symbol to be undefined or
554 unknown. undefined: seen it before. unknown: never seen
557 Construct a local label name, then an undefined symbol.
558 Don't create a xseg frag for it: caller may do that.
559 Just return it as never seen before. */
560 name
= fb_label_name ((int) number
, 1);
561 symbolP
= symbol_find_or_make (name
);
562 /* We have no need to check symbol properties. */
563 #ifndef many_segments
564 /* Since "know" puts its arg into a "string", we
565 can't have newlines in the argument. */
566 know (S_GET_SEGMENT (symbolP
) == undefined_section
|| S_GET_SEGMENT (symbolP
) == text_section
|| S_GET_SEGMENT (symbolP
) == data_section
);
568 expressionP
->X_op
= O_symbol
;
569 expressionP
->X_add_symbol
= symbolP
;
570 expressionP
->X_add_number
= 0;
572 else if (LOCAL_LABELS_DOLLAR
&& c
== '$')
574 /* If the dollar label is *currently* defined, then this is just
575 another reference to it. If it is not *currently* defined,
576 then this is a fresh instantiation of that number, so create
579 if (dollar_label_defined ((long) number
))
581 name
= dollar_label_name ((long) number
, 0);
582 symbolP
= symbol_find (name
);
583 know (symbolP
!= NULL
);
587 name
= dollar_label_name ((long) number
, 1);
588 symbolP
= symbol_find_or_make (name
);
591 expressionP
->X_op
= O_symbol
;
592 expressionP
->X_add_symbol
= symbolP
;
593 expressionP
->X_add_number
= 0;
597 expressionP
->X_op
= O_constant
;
598 expressionP
->X_add_number
= number
;
599 input_line_pointer
--; /* Restore following character. */
600 } /* Really just a number. */
604 /* Not a small number. */
605 expressionP
->X_op
= O_big
;
606 expressionP
->X_add_number
= number
; /* Number of littlenums. */
607 input_line_pointer
--; /* -> char following number. */
611 /* Parse an MRI multi character constant. */
614 mri_char_constant (expressionS
*expressionP
)
618 if (*input_line_pointer
== '\''
619 && input_line_pointer
[1] != '\'')
621 expressionP
->X_op
= O_constant
;
622 expressionP
->X_add_number
= 0;
626 /* In order to get the correct byte ordering, we must build the
627 number in reverse. */
628 for (i
= SIZE_OF_LARGE_NUMBER
- 1; i
>= 0; i
--)
632 generic_bignum
[i
] = 0;
633 for (j
= 0; j
< CHARS_PER_LITTLENUM
; j
++)
635 if (*input_line_pointer
== '\'')
637 if (input_line_pointer
[1] != '\'')
639 ++input_line_pointer
;
641 generic_bignum
[i
] <<= 8;
642 generic_bignum
[i
] += *input_line_pointer
;
643 ++input_line_pointer
;
646 if (i
< SIZE_OF_LARGE_NUMBER
- 1)
648 /* If there is more than one littlenum, left justify the
649 last one to make it match the earlier ones. If there is
650 only one, we can just use the value directly. */
651 for (; j
< CHARS_PER_LITTLENUM
; j
++)
652 generic_bignum
[i
] <<= 8;
655 if (*input_line_pointer
== '\''
656 && input_line_pointer
[1] != '\'')
662 as_bad (_("character constant too large"));
671 c
= SIZE_OF_LARGE_NUMBER
- i
;
672 for (j
= 0; j
< c
; j
++)
673 generic_bignum
[j
] = generic_bignum
[i
+ j
];
677 know (LITTLENUM_NUMBER_OF_BITS
== 16);
680 expressionP
->X_op
= O_big
;
681 expressionP
->X_add_number
= i
;
685 expressionP
->X_op
= O_constant
;
687 expressionP
->X_add_number
= generic_bignum
[0] & LITTLENUM_MASK
;
689 expressionP
->X_add_number
=
690 (((generic_bignum
[1] & LITTLENUM_MASK
)
691 << LITTLENUM_NUMBER_OF_BITS
)
692 | (generic_bignum
[0] & LITTLENUM_MASK
));
695 /* Skip the final closing quote. */
696 ++input_line_pointer
;
699 /* Return an expression representing the current location. This
700 handles the magic symbol `.'. */
703 current_location (expressionS
*expressionp
)
705 if (now_seg
== absolute_section
)
707 expressionp
->X_op
= O_constant
;
708 expressionp
->X_add_number
= abs_section_offset
;
712 expressionp
->X_op
= O_symbol
;
713 expressionp
->X_add_symbol
= &dot_symbol
;
714 expressionp
->X_add_number
= 0;
718 /* In: Input_line_pointer points to 1st char of operand, which may
722 The operand may have been empty: in this case X_op == O_absent.
723 Input_line_pointer->(next non-blank) char after operand. */
726 operand (expressionS
*expressionP
, enum expr_mode mode
)
729 symbolS
*symbolP
; /* Points to symbol. */
730 char *name
; /* Points to name of symbol. */
733 /* All integers are regarded as unsigned unless they are negated.
734 This is because the only thing which cares whether a number is
735 unsigned is the code in emit_expr which extends constants into
736 bignums. It should only sign extend negative numbers, so that
737 something like ``.quad 0x80000000'' is not sign extended even
738 though it appears negative if valueT is 32 bits. */
739 expressionP
->X_unsigned
= 1;
740 expressionP
->X_extrabit
= 0;
742 /* Digits, assume it is a bignum. */
744 SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
745 c
= *input_line_pointer
++; /* input_line_pointer -> past char in c. */
747 if (is_end_of_line
[(unsigned char) c
])
761 input_line_pointer
--;
763 integer_constant ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
768 #ifdef LITERAL_PREFIXDOLLAR_HEX
770 /* $L is the start of a local label, not a hex constant. */
771 if (* input_line_pointer
== 'L')
773 integer_constant (16, expressionP
);
777 #ifdef LITERAL_PREFIXPERCENT_BIN
779 integer_constant (2, expressionP
);
784 /* Non-decimal radix. */
786 if (NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
790 /* Check for a hex or float constant. */
791 for (s
= input_line_pointer
; hex_p (*s
); s
++)
793 if (*s
== 'h' || *s
== 'H' || *input_line_pointer
== '.')
795 --input_line_pointer
;
796 integer_constant (0, expressionP
);
800 c
= *input_line_pointer
;
809 if (NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
811 integer_constant (0, expressionP
);
817 if (c
&& strchr (FLT_CHARS
, c
))
819 input_line_pointer
++;
820 floating_constant (expressionP
);
821 expressionP
->X_add_number
= - TOLOWER (c
);
825 /* The string was only zero. */
826 expressionP
->X_op
= O_constant
;
827 expressionP
->X_add_number
= 0;
836 input_line_pointer
++;
837 integer_constant (16, expressionP
);
841 if (LOCAL_LABELS_FB
&& !flag_m68k_mri
842 && input_line_pointer
[1] != '0'
843 && input_line_pointer
[1] != '1')
845 /* Parse this as a back reference to label 0. */
846 input_line_pointer
--;
847 integer_constant (10, expressionP
);
850 /* Otherwise, parse this as a binary number. */
853 if (input_line_pointer
[1] == '0'
854 || input_line_pointer
[1] == '1')
856 input_line_pointer
++;
857 integer_constant (2, expressionP
);
860 if (flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
861 input_line_pointer
++;
872 integer_constant ((flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
882 /* If it says "0f" and it could possibly be a floating point
883 number, make it one. Otherwise, make it a local label,
884 and try to deal with parsing the rest later. */
885 if (!is_end_of_line
[(unsigned char) input_line_pointer
[1]]
886 && strchr (FLT_CHARS
, 'f') != NULL
)
888 char *cp
= input_line_pointer
+ 1;
890 atof_generic (&cp
, ".", EXP_CHARS
,
891 &generic_floating_point_number
);
893 /* Was nothing parsed, or does it look like an
895 is_label
= (cp
== input_line_pointer
+ 1
896 || (cp
== input_line_pointer
+ 2
897 && (cp
[-1] == '-' || cp
[-1] == '+'))
903 input_line_pointer
--;
904 integer_constant (10, expressionP
);
912 if (flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
914 integer_constant (0, expressionP
);
924 input_line_pointer
++;
925 floating_constant (expressionP
);
926 expressionP
->X_add_number
= - TOLOWER (c
);
930 if (LOCAL_LABELS_DOLLAR
)
932 integer_constant (10, expressionP
);
941 #ifndef NEED_INDEX_OPERATOR
943 # ifdef md_need_index_operator
944 if (md_need_index_operator())
950 /* Didn't begin with digit & not a name. */
951 segment
= expr (0, expressionP
, mode
);
952 /* expression () will pass trailing whitespace. */
953 if ((c
== '(' && *input_line_pointer
!= ')')
954 || (c
== '[' && *input_line_pointer
!= ']'))
955 as_bad (_("missing '%c'"), c
== '(' ? ')' : ']');
957 input_line_pointer
++;
959 /* Here with input_line_pointer -> char after "(...)". */
964 if (! flag_m68k_mri
|| *input_line_pointer
!= '\'')
966 as_bad (_("EBCDIC constants are not supported"));
969 if (! flag_m68k_mri
|| *input_line_pointer
!= '\'')
971 ++input_line_pointer
;
977 /* Warning: to conform to other people's assemblers NO
978 ESCAPEMENT is permitted for a single quote. The next
979 character, parity errors and all, is taken as the value
980 of the operand. VERY KINKY. */
981 expressionP
->X_op
= O_constant
;
982 expressionP
->X_add_number
= *input_line_pointer
++;
986 mri_char_constant (expressionP
);
991 /* Double quote is the bitwise not operator in MRI mode. */
997 /* '~' is permitted to start a label on the Delta. */
998 if (is_name_beginner (c
))
1007 operand (expressionP
, mode
);
1008 if (expressionP
->X_op
== O_constant
)
1010 /* input_line_pointer -> char after operand. */
1013 expressionP
->X_add_number
1014 = - (addressT
) expressionP
->X_add_number
;
1015 /* Notice: '-' may overflow: no warning is given.
1016 This is compatible with other people's
1017 assemblers. Sigh. */
1018 expressionP
->X_unsigned
= 0;
1019 if (expressionP
->X_add_number
)
1020 expressionP
->X_extrabit
^= 1;
1022 else if (c
== '~' || c
== '"')
1023 expressionP
->X_add_number
= ~ expressionP
->X_add_number
;
1025 expressionP
->X_add_number
= ! expressionP
->X_add_number
;
1027 else if (expressionP
->X_op
== O_big
1028 && expressionP
->X_add_number
<= 0
1030 && (generic_floating_point_number
.sign
== '+'
1031 || generic_floating_point_number
.sign
== 'P'))
1033 /* Negative flonum (eg, -1.000e0). */
1034 if (generic_floating_point_number
.sign
== '+')
1035 generic_floating_point_number
.sign
= '-';
1037 generic_floating_point_number
.sign
= 'N';
1039 else if (expressionP
->X_op
== O_big
1040 && expressionP
->X_add_number
> 0)
1044 if (c
== '~' || c
== '-')
1046 for (i
= 0; i
< expressionP
->X_add_number
; ++i
)
1047 generic_bignum
[i
] = ~generic_bignum
[i
];
1049 /* Extend the bignum to at least the size of .octa. */
1050 if (expressionP
->X_add_number
< SIZE_OF_LARGE_NUMBER
)
1052 expressionP
->X_add_number
= SIZE_OF_LARGE_NUMBER
;
1053 for (; i
< expressionP
->X_add_number
; ++i
)
1054 generic_bignum
[i
] = ~(LITTLENUM_TYPE
) 0;
1058 for (i
= 0; i
< expressionP
->X_add_number
; ++i
)
1060 generic_bignum
[i
] += 1;
1061 if (generic_bignum
[i
])
1067 for (i
= 0; i
< expressionP
->X_add_number
; ++i
)
1068 if (generic_bignum
[i
] != 0)
1070 expressionP
->X_add_number
= i
>= expressionP
->X_add_number
;
1071 expressionP
->X_op
= O_constant
;
1072 expressionP
->X_unsigned
= 1;
1073 expressionP
->X_extrabit
= 0;
1076 else if (expressionP
->X_op
!= O_illegal
1077 && expressionP
->X_op
!= O_absent
)
1081 expressionP
->X_add_symbol
= make_expr_symbol (expressionP
);
1083 expressionP
->X_op
= O_uminus
;
1084 else if (c
== '~' || c
== '"')
1085 expressionP
->X_op
= O_bit_not
;
1087 expressionP
->X_op
= O_logical_not
;
1088 expressionP
->X_add_number
= 0;
1092 as_warn (_("Unary operator %c ignored because bad operand follows"),
1097 #if defined (DOLLAR_DOT) || defined (TC_M68K)
1099 /* '$' is the program counter when in MRI mode, or when
1100 DOLLAR_DOT is defined. */
1102 if (! flag_m68k_mri
)
1105 if (DOLLAR_AMBIGU
&& hex_p (*input_line_pointer
))
1107 /* In MRI mode and on Z80, '$' is also used as the prefix
1108 for a hexadecimal constant. */
1109 integer_constant (16, expressionP
);
1113 if (is_part_of_name (*input_line_pointer
))
1116 current_location (expressionP
);
1121 if (!is_part_of_name (*input_line_pointer
))
1123 current_location (expressionP
);
1126 else if ((strncasecmp (input_line_pointer
, "startof.", 8) == 0
1127 && ! is_part_of_name (input_line_pointer
[8]))
1128 || (strncasecmp (input_line_pointer
, "sizeof.", 7) == 0
1129 && ! is_part_of_name (input_line_pointer
[7])))
1133 start
= (input_line_pointer
[1] == 't'
1134 || input_line_pointer
[1] == 'T');
1135 input_line_pointer
+= start
? 8 : 7;
1137 if (*input_line_pointer
!= '(')
1138 as_bad (_("syntax error in .startof. or .sizeof."));
1143 ++input_line_pointer
;
1145 name
= input_line_pointer
;
1146 c
= get_symbol_end ();
1148 buf
= (char *) xmalloc (strlen (name
) + 10);
1150 sprintf (buf
, ".startof.%s", name
);
1152 sprintf (buf
, ".sizeof.%s", name
);
1153 symbolP
= symbol_make (buf
);
1156 expressionP
->X_op
= O_symbol
;
1157 expressionP
->X_add_symbol
= symbolP
;
1158 expressionP
->X_add_number
= 0;
1160 *input_line_pointer
= c
;
1162 if (*input_line_pointer
!= ')')
1163 as_bad (_("syntax error in .startof. or .sizeof."));
1165 ++input_line_pointer
;
1176 /* Can't imagine any other kind of operand. */
1177 expressionP
->X_op
= O_absent
;
1178 input_line_pointer
--;
1183 if (! flag_m68k_mri
)
1185 integer_constant (2, expressionP
);
1189 if (! flag_m68k_mri
)
1191 integer_constant (8, expressionP
);
1195 if (! flag_m68k_mri
)
1198 /* In MRI mode, this is a floating point constant represented
1199 using hexadecimal digits. */
1201 ++input_line_pointer
;
1202 integer_constant (16, expressionP
);
1206 if (! flag_m68k_mri
|| is_part_of_name (*input_line_pointer
))
1209 current_location (expressionP
);
1214 #if defined(md_need_index_operator) || defined(TC_M68K)
1217 if (is_name_beginner (c
)) /* Here if did not begin with a digit. */
1219 /* Identifier begins here.
1220 This is kludged for speed, so code is repeated. */
1222 name
= --input_line_pointer
;
1223 c
= get_symbol_end ();
1227 operatorT op
= md_operator (name
, 1, &c
);
1232 *input_line_pointer
= c
;
1236 *input_line_pointer
= c
;
1240 *input_line_pointer
= c
;
1244 as_bad (_("invalid use of operator \"%s\""), name
);
1249 if (op
!= O_absent
&& op
!= O_illegal
)
1251 *input_line_pointer
= c
;
1252 expr (9, expressionP
, mode
);
1253 expressionP
->X_add_symbol
= make_expr_symbol (expressionP
);
1254 expressionP
->X_op_symbol
= NULL
;
1255 expressionP
->X_add_number
= 0;
1256 expressionP
->X_op
= op
;
1262 #ifdef md_parse_name
1263 /* This is a hook for the backend to parse certain names
1264 specially in certain contexts. If a name always has a
1265 specific value, it can often be handled by simply
1266 entering it in the symbol table. */
1267 if (md_parse_name (name
, expressionP
, mode
, &c
))
1269 *input_line_pointer
= c
;
1275 /* The MRI i960 assembler permits
1277 FIXME: This should use md_parse_name. */
1279 && (strcasecmp (name
, "sizeof") == 0
1280 || strcasecmp (name
, "startof") == 0))
1285 start
= (name
[1] == 't'
1288 *input_line_pointer
= c
;
1291 name
= input_line_pointer
;
1292 c
= get_symbol_end ();
1294 buf
= (char *) xmalloc (strlen (name
) + 10);
1296 sprintf (buf
, ".startof.%s", name
);
1298 sprintf (buf
, ".sizeof.%s", name
);
1299 symbolP
= symbol_make (buf
);
1302 expressionP
->X_op
= O_symbol
;
1303 expressionP
->X_add_symbol
= symbolP
;
1304 expressionP
->X_add_number
= 0;
1306 *input_line_pointer
= c
;
1313 symbolP
= symbol_find_or_make (name
);
1315 /* If we have an absolute symbol or a reg, then we know its
1317 segment
= S_GET_SEGMENT (symbolP
);
1318 if (mode
!= expr_defer
1319 && segment
== absolute_section
1320 && !S_FORCE_RELOC (symbolP
, 0))
1322 expressionP
->X_op
= O_constant
;
1323 expressionP
->X_add_number
= S_GET_VALUE (symbolP
);
1325 else if (mode
!= expr_defer
&& segment
== reg_section
)
1327 expressionP
->X_op
= O_register
;
1328 expressionP
->X_add_number
= S_GET_VALUE (symbolP
);
1332 expressionP
->X_op
= O_symbol
;
1333 expressionP
->X_add_symbol
= symbolP
;
1334 expressionP
->X_add_number
= 0;
1336 *input_line_pointer
= c
;
1340 /* Let the target try to parse it. Success is indicated by changing
1341 the X_op field to something other than O_absent and pointing
1342 input_line_pointer past the expression. If it can't parse the
1343 expression, X_op and input_line_pointer should be unchanged. */
1344 expressionP
->X_op
= O_absent
;
1345 --input_line_pointer
;
1346 md_operand (expressionP
);
1347 if (expressionP
->X_op
== O_absent
)
1349 ++input_line_pointer
;
1350 as_bad (_("bad expression"));
1351 expressionP
->X_op
= O_constant
;
1352 expressionP
->X_add_number
= 0;
1358 /* It is more 'efficient' to clean up the expressionS when they are
1359 created. Doing it here saves lines of code. */
1360 clean_up_expression (expressionP
);
1361 SKIP_WHITESPACE (); /* -> 1st char after operand. */
1362 know (*input_line_pointer
!= ' ');
1364 /* The PA port needs this information. */
1365 if (expressionP
->X_add_symbol
)
1366 symbol_mark_used (expressionP
->X_add_symbol
);
1368 if (mode
!= expr_defer
)
1370 expressionP
->X_add_symbol
1371 = symbol_clone_if_forward_ref (expressionP
->X_add_symbol
);
1372 expressionP
->X_op_symbol
1373 = symbol_clone_if_forward_ref (expressionP
->X_op_symbol
);
1376 switch (expressionP
->X_op
)
1379 return absolute_section
;
1381 return S_GET_SEGMENT (expressionP
->X_add_symbol
);
1387 /* Internal. Simplify a struct expression for use by expr (). */
1389 /* In: address of an expressionS.
1390 The X_op field of the expressionS may only take certain values.
1391 Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
1393 Out: expressionS may have been modified:
1394 Unused fields zeroed to help expr (). */
1397 clean_up_expression (expressionS
*expressionP
)
1399 switch (expressionP
->X_op
)
1403 expressionP
->X_add_number
= 0;
1408 expressionP
->X_add_symbol
= NULL
;
1413 expressionP
->X_op_symbol
= NULL
;
1420 /* Expression parser. */
1422 /* We allow an empty expression, and just assume (absolute,0) silently.
1423 Unary operators and parenthetical expressions are treated as operands.
1424 As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
1426 We used to do an aho/ullman shift-reduce parser, but the logic got so
1427 warped that I flushed it and wrote a recursive-descent parser instead.
1428 Now things are stable, would anybody like to write a fast parser?
1429 Most expressions are either register (which does not even reach here)
1430 or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
1431 So I guess it doesn't really matter how inefficient more complex expressions
1434 After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
1435 Also, we have consumed any leading or trailing spaces (operand does that)
1436 and done all intervening operators.
1438 This returns the segment of the result, which will be
1439 absolute_section or the segment of a symbol. */
1442 #define __ O_illegal
1444 #define O_SINGLE_EQ O_illegal
1447 /* Maps ASCII -> operators. */
1448 static const operatorT op_encoding
[256] = {
1449 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1450 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1452 __
, O_bit_or_not
, __
, __
, __
, O_modulus
, O_bit_and
, __
,
1453 __
, __
, O_multiply
, O_add
, __
, O_subtract
, __
, O_divide
,
1454 __
, __
, __
, __
, __
, __
, __
, __
,
1455 __
, __
, __
, __
, O_lt
, O_SINGLE_EQ
, O_gt
, __
,
1456 __
, __
, __
, __
, __
, __
, __
, __
,
1457 __
, __
, __
, __
, __
, __
, __
, __
,
1458 __
, __
, __
, __
, __
, __
, __
, __
,
1460 #ifdef NEED_INDEX_OPERATOR
1465 __
, __
, O_bit_exclusive_or
, __
,
1466 __
, __
, __
, __
, __
, __
, __
, __
,
1467 __
, __
, __
, __
, __
, __
, __
, __
,
1468 __
, __
, __
, __
, __
, __
, __
, __
,
1469 __
, __
, __
, __
, O_bit_inclusive_or
, __
, __
, __
,
1471 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1472 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1473 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1474 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1475 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1476 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1477 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1478 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
1482 0 operand, (expression)
1487 5 used for * / % in MRI mode
1492 static operator_rankT op_rank
[O_max
] = {
1497 0, /* O_symbol_rva */
1502 9, /* O_logical_not */
1506 8, /* O_left_shift */
1507 8, /* O_right_shift */
1508 7, /* O_bit_inclusive_or */
1509 7, /* O_bit_or_not */
1510 7, /* O_bit_exclusive_or */
1520 3, /* O_logical_and */
1521 2, /* O_logical_or */
1525 /* Unfortunately, in MRI mode for the m68k, multiplication and
1526 division have lower precedence than the bit wise operators. This
1527 function sets the operator precedences correctly for the current
1528 mode. Also, MRI uses a different bit_not operator, and this fixes
1531 #define STANDARD_MUL_PRECEDENCE 8
1532 #define MRI_MUL_PRECEDENCE 6
1535 expr_set_precedence (void)
1539 op_rank
[O_multiply
] = MRI_MUL_PRECEDENCE
;
1540 op_rank
[O_divide
] = MRI_MUL_PRECEDENCE
;
1541 op_rank
[O_modulus
] = MRI_MUL_PRECEDENCE
;
1545 op_rank
[O_multiply
] = STANDARD_MUL_PRECEDENCE
;
1546 op_rank
[O_divide
] = STANDARD_MUL_PRECEDENCE
;
1547 op_rank
[O_modulus
] = STANDARD_MUL_PRECEDENCE
;
1552 expr_set_rank (operatorT op
, operator_rankT rank
)
1554 gas_assert (op
>= O_md1
&& op
< ARRAY_SIZE (op_rank
));
1558 /* Initialize the expression parser. */
1563 expr_set_precedence ();
1565 /* Verify that X_op field is wide enough. */
1569 gas_assert (e
.X_op
== O_max
);
1573 /* Return the encoding for the operator at INPUT_LINE_POINTER, and
1574 sets NUM_CHARS to the number of characters in the operator.
1575 Does not advance INPUT_LINE_POINTER. */
1577 static inline operatorT
1578 operatorf (int *num_chars
)
1583 c
= *input_line_pointer
& 0xff;
1586 if (is_end_of_line
[c
])
1590 if (is_name_beginner (c
))
1592 char *name
= input_line_pointer
;
1593 char ec
= get_symbol_end ();
1595 ret
= md_operator (name
, 2, &ec
);
1599 *input_line_pointer
= ec
;
1600 input_line_pointer
= name
;
1605 as_bad (_("invalid use of operator \"%s\""), name
);
1609 *input_line_pointer
= ec
;
1610 *num_chars
= input_line_pointer
- name
;
1611 input_line_pointer
= name
;
1620 ret
= op_encoding
[c
];
1622 if (ret
== O_illegal
)
1624 char *start
= input_line_pointer
;
1626 ret
= md_operator (NULL
, 2, NULL
);
1627 if (ret
!= O_illegal
)
1628 *num_chars
= input_line_pointer
- start
;
1629 input_line_pointer
= start
;
1636 return op_encoding
[c
];
1639 switch (input_line_pointer
[1])
1642 return op_encoding
[c
];
1657 if (input_line_pointer
[1] != '=')
1658 return op_encoding
[c
];
1664 switch (input_line_pointer
[1])
1667 return op_encoding
[c
];
1669 ret
= O_right_shift
;
1679 switch (input_line_pointer
[1])
1682 /* We accept !! as equivalent to ^ for MRI compatibility. */
1684 return O_bit_exclusive_or
;
1686 /* We accept != as equivalent to <>. */
1691 return O_bit_inclusive_or
;
1692 return op_encoding
[c
];
1696 if (input_line_pointer
[1] != '|')
1697 return op_encoding
[c
];
1700 return O_logical_or
;
1703 if (input_line_pointer
[1] != '&')
1704 return op_encoding
[c
];
1707 return O_logical_and
;
1713 /* Implement "word-size + 1 bit" addition for
1714 {resultP->X_extrabit:resultP->X_add_number} + {rhs_highbit:amount}. This
1715 is used so that the full range of unsigned word values and the full range of
1716 signed word values can be represented in an O_constant expression, which is
1717 useful e.g. for .sleb128 directives. */
1720 add_to_result (expressionS
*resultP
, offsetT amount
, int rhs_highbit
)
1722 valueT ures
= resultP
->X_add_number
;
1723 valueT uamount
= amount
;
1725 resultP
->X_add_number
+= amount
;
1727 resultP
->X_extrabit
^= rhs_highbit
;
1729 if (ures
+ uamount
< ures
)
1730 resultP
->X_extrabit
^= 1;
1733 /* Similarly, for subtraction. */
1736 subtract_from_result (expressionS
*resultP
, offsetT amount
, int rhs_highbit
)
1738 valueT ures
= resultP
->X_add_number
;
1739 valueT uamount
= amount
;
1741 resultP
->X_add_number
-= amount
;
1743 resultP
->X_extrabit
^= rhs_highbit
;
1746 resultP
->X_extrabit
^= 1;
1749 /* Parse an expression. */
1752 expr (int rankarg
, /* Larger # is higher rank. */
1753 expressionS
*resultP
, /* Deliver result here. */
1754 enum expr_mode mode
/* Controls behavior. */)
1756 operator_rankT rank
= (operator_rankT
) rankarg
;
1763 know (rankarg
>= 0);
1765 /* Save the value of dot for the fixup code. */
1768 dot_value
= frag_now_fix ();
1769 dot_frag
= frag_now
;
1772 retval
= operand (resultP
, mode
);
1774 /* operand () gobbles spaces. */
1775 know (*input_line_pointer
!= ' ');
1777 op_left
= operatorf (&op_chars
);
1778 while (op_left
!= O_illegal
&& op_rank
[(int) op_left
] > rank
)
1783 input_line_pointer
+= op_chars
; /* -> after operator. */
1786 rightseg
= expr (op_rank
[(int) op_left
], &right
, mode
);
1787 if (right
.X_op
== O_absent
)
1789 as_warn (_("missing operand; zero assumed"));
1790 right
.X_op
= O_constant
;
1791 right
.X_add_number
= 0;
1792 right
.X_add_symbol
= NULL
;
1793 right
.X_op_symbol
= NULL
;
1796 know (*input_line_pointer
!= ' ');
1798 if (op_left
== O_index
)
1800 if (*input_line_pointer
!= ']')
1801 as_bad ("missing right bracket");
1804 ++input_line_pointer
;
1809 op_right
= operatorf (&op_chars
);
1811 know (op_right
== O_illegal
|| op_left
== O_index
1812 || op_rank
[(int) op_right
] <= op_rank
[(int) op_left
]);
1813 know ((int) op_left
>= (int) O_multiply
);
1815 know ((int) op_left
<= (int) O_index
);
1817 know ((int) op_left
< (int) O_max
);
1820 /* input_line_pointer->after right-hand quantity. */
1821 /* left-hand quantity in resultP. */
1822 /* right-hand quantity in right. */
1823 /* operator in op_left. */
1825 if (resultP
->X_op
== O_big
)
1827 if (resultP
->X_add_number
> 0)
1828 as_warn (_("left operand is a bignum; integer 0 assumed"));
1830 as_warn (_("left operand is a float; integer 0 assumed"));
1831 resultP
->X_op
= O_constant
;
1832 resultP
->X_add_number
= 0;
1833 resultP
->X_add_symbol
= NULL
;
1834 resultP
->X_op_symbol
= NULL
;
1836 if (right
.X_op
== O_big
)
1838 if (right
.X_add_number
> 0)
1839 as_warn (_("right operand is a bignum; integer 0 assumed"));
1841 as_warn (_("right operand is a float; integer 0 assumed"));
1842 right
.X_op
= O_constant
;
1843 right
.X_add_number
= 0;
1844 right
.X_add_symbol
= NULL
;
1845 right
.X_op_symbol
= NULL
;
1848 /* Optimize common cases. */
1849 #ifdef md_optimize_expr
1850 if (md_optimize_expr (resultP
, op_left
, &right
))
1857 #ifndef md_register_arithmetic
1858 # define md_register_arithmetic 1
1860 if (op_left
== O_add
&& right
.X_op
== O_constant
1861 && (md_register_arithmetic
|| resultP
->X_op
!= O_register
))
1864 add_to_result (resultP
, right
.X_add_number
, right
.X_extrabit
);
1866 /* This case comes up in PIC code. */
1867 else if (op_left
== O_subtract
1868 && right
.X_op
== O_symbol
1869 && resultP
->X_op
== O_symbol
1870 && retval
== rightseg
1871 #ifdef md_allow_local_subtract
1872 && md_allow_local_subtract (resultP
, & right
, rightseg
)
1874 && ((SEG_NORMAL (rightseg
)
1875 && !S_FORCE_RELOC (resultP
->X_add_symbol
, 0)
1876 && !S_FORCE_RELOC (right
.X_add_symbol
, 0))
1877 || right
.X_add_symbol
== resultP
->X_add_symbol
)
1878 && frag_offset_fixed_p (symbol_get_frag (resultP
->X_add_symbol
),
1879 symbol_get_frag (right
.X_add_symbol
),
1882 offsetT symval_diff
= S_GET_VALUE (resultP
->X_add_symbol
)
1883 - S_GET_VALUE (right
.X_add_symbol
);
1884 subtract_from_result (resultP
, right
.X_add_number
, right
.X_extrabit
);
1885 subtract_from_result (resultP
, frag_off
/ OCTETS_PER_BYTE
, 0);
1886 add_to_result (resultP
, symval_diff
, symval_diff
< 0);
1887 resultP
->X_op
= O_constant
;
1888 resultP
->X_add_symbol
= 0;
1890 else if (op_left
== O_subtract
&& right
.X_op
== O_constant
1891 && (md_register_arithmetic
|| resultP
->X_op
!= O_register
))
1894 subtract_from_result (resultP
, right
.X_add_number
, right
.X_extrabit
);
1896 else if (op_left
== O_add
&& resultP
->X_op
== O_constant
1897 && (md_register_arithmetic
|| right
.X_op
!= O_register
))
1900 resultP
->X_op
= right
.X_op
;
1901 resultP
->X_add_symbol
= right
.X_add_symbol
;
1902 resultP
->X_op_symbol
= right
.X_op_symbol
;
1903 add_to_result (resultP
, right
.X_add_number
, right
.X_extrabit
);
1906 else if (resultP
->X_op
== O_constant
&& right
.X_op
== O_constant
)
1908 /* Constant OP constant. */
1909 offsetT v
= right
.X_add_number
;
1910 if (v
== 0 && (op_left
== O_divide
|| op_left
== O_modulus
))
1912 as_warn (_("division by zero"));
1915 if ((valueT
) v
>= sizeof(valueT
) * CHAR_BIT
1916 && (op_left
== O_left_shift
|| op_left
== O_right_shift
))
1918 as_warn_value_out_of_range (_("shift count"), v
, 0,
1919 sizeof(valueT
) * CHAR_BIT
- 1,
1921 resultP
->X_add_number
= v
= 0;
1925 default: goto general
;
1926 case O_multiply
: resultP
->X_add_number
*= v
; break;
1927 case O_divide
: resultP
->X_add_number
/= v
; break;
1928 case O_modulus
: resultP
->X_add_number
%= v
; break;
1929 case O_left_shift
: resultP
->X_add_number
<<= v
; break;
1931 /* We always use unsigned shifts, to avoid relying on
1932 characteristics of the compiler used to compile gas. */
1933 resultP
->X_add_number
=
1934 (offsetT
) ((valueT
) resultP
->X_add_number
>> (valueT
) v
);
1936 case O_bit_inclusive_or
: resultP
->X_add_number
|= v
; break;
1937 case O_bit_or_not
: resultP
->X_add_number
|= ~v
; break;
1938 case O_bit_exclusive_or
: resultP
->X_add_number
^= v
; break;
1939 case O_bit_and
: resultP
->X_add_number
&= v
; break;
1940 /* Constant + constant (O_add) is handled by the
1941 previous if statement for constant + X, so is omitted
1944 subtract_from_result (resultP
, v
, 0);
1947 resultP
->X_add_number
=
1948 resultP
->X_add_number
== v
? ~ (offsetT
) 0 : 0;
1951 resultP
->X_add_number
=
1952 resultP
->X_add_number
!= v
? ~ (offsetT
) 0 : 0;
1955 resultP
->X_add_number
=
1956 resultP
->X_add_number
< v
? ~ (offsetT
) 0 : 0;
1959 resultP
->X_add_number
=
1960 resultP
->X_add_number
<= v
? ~ (offsetT
) 0 : 0;
1963 resultP
->X_add_number
=
1964 resultP
->X_add_number
>= v
? ~ (offsetT
) 0 : 0;
1967 resultP
->X_add_number
=
1968 resultP
->X_add_number
> v
? ~ (offsetT
) 0 : 0;
1971 resultP
->X_add_number
= resultP
->X_add_number
&& v
;
1974 resultP
->X_add_number
= resultP
->X_add_number
|| v
;
1978 else if (resultP
->X_op
== O_symbol
1979 && right
.X_op
== O_symbol
1980 && (op_left
== O_add
1981 || op_left
== O_subtract
1982 || (resultP
->X_add_number
== 0
1983 && right
.X_add_number
== 0)))
1985 /* Symbol OP symbol. */
1986 resultP
->X_op
= op_left
;
1987 resultP
->X_op_symbol
= right
.X_add_symbol
;
1988 if (op_left
== O_add
)
1989 add_to_result (resultP
, right
.X_add_number
, right
.X_extrabit
);
1990 else if (op_left
== O_subtract
)
1992 subtract_from_result (resultP
, right
.X_add_number
,
1994 if (retval
== rightseg
1995 && SEG_NORMAL (retval
)
1996 && !S_FORCE_RELOC (resultP
->X_add_symbol
, 0)
1997 && !S_FORCE_RELOC (right
.X_add_symbol
, 0))
1999 retval
= absolute_section
;
2000 rightseg
= absolute_section
;
2007 /* The general case. */
2008 resultP
->X_add_symbol
= make_expr_symbol (resultP
);
2009 resultP
->X_op_symbol
= make_expr_symbol (&right
);
2010 resultP
->X_op
= op_left
;
2011 resultP
->X_add_number
= 0;
2012 resultP
->X_unsigned
= 1;
2013 resultP
->X_extrabit
= 0;
2016 if (retval
!= rightseg
)
2018 if (retval
== undefined_section
)
2020 else if (rightseg
== undefined_section
)
2022 else if (retval
== expr_section
)
2024 else if (rightseg
== expr_section
)
2026 else if (retval
== reg_section
)
2028 else if (rightseg
== reg_section
)
2030 else if (rightseg
== absolute_section
)
2032 else if (retval
== absolute_section
)
2035 else if (op_left
== O_subtract
)
2039 as_bad (_("operation combines symbols in different segments"));
2043 } /* While next operator is >= this rank. */
2045 /* The PA port needs this information. */
2046 if (resultP
->X_add_symbol
)
2047 symbol_mark_used (resultP
->X_add_symbol
);
2049 if (rank
== 0 && mode
== expr_evaluate
)
2050 resolve_expression (resultP
);
2052 return resultP
->X_op
== O_constant
? absolute_section
: retval
;
2055 /* Resolve an expression without changing any symbols/sub-expressions
2059 resolve_expression (expressionS
*expressionP
)
2061 /* Help out with CSE. */
2062 valueT final_val
= expressionP
->X_add_number
;
2063 symbolS
*add_symbol
= expressionP
->X_add_symbol
;
2064 symbolS
*orig_add_symbol
= add_symbol
;
2065 symbolS
*op_symbol
= expressionP
->X_op_symbol
;
2066 operatorT op
= expressionP
->X_op
;
2068 segT seg_left
, seg_right
;
2069 fragS
*frag_left
, *frag_right
;
2084 if (!snapshot_symbol (&add_symbol
, &left
, &seg_left
, &frag_left
))
2092 if (!snapshot_symbol (&add_symbol
, &left
, &seg_left
, &frag_left
))
2095 if (seg_left
!= absolute_section
)
2098 if (op
== O_logical_not
)
2100 else if (op
== O_uminus
)
2112 case O_bit_inclusive_or
:
2114 case O_bit_exclusive_or
:
2126 if (!snapshot_symbol (&add_symbol
, &left
, &seg_left
, &frag_left
)
2127 || !snapshot_symbol (&op_symbol
, &right
, &seg_right
, &frag_right
))
2130 /* Simplify addition or subtraction of a constant by folding the
2131 constant into X_add_number. */
2134 if (seg_right
== absolute_section
)
2140 else if (seg_left
== absolute_section
)
2144 seg_left
= seg_right
;
2145 add_symbol
= op_symbol
;
2146 orig_add_symbol
= expressionP
->X_op_symbol
;
2151 else if (op
== O_subtract
)
2153 if (seg_right
== absolute_section
)
2161 /* Equality and non-equality tests are permitted on anything.
2162 Subtraction, and other comparison operators are permitted if
2163 both operands are in the same section.
2164 Shifts by constant zero are permitted on anything.
2165 Multiplies, bit-ors, and bit-ands with constant zero are
2166 permitted on anything.
2167 Multiplies and divides by constant one are permitted on
2169 Binary operations with both operands being the same register
2170 or undefined symbol are permitted if the result doesn't depend
2172 Otherwise, both operands must be absolute. We already handled
2173 the case of addition or subtraction of a constant above. */
2175 if (!(seg_left
== absolute_section
2176 && seg_right
== absolute_section
)
2177 && !(op
== O_eq
|| op
== O_ne
)
2178 && !((op
== O_subtract
2179 || op
== O_lt
|| op
== O_le
|| op
== O_ge
|| op
== O_gt
)
2180 && seg_left
== seg_right
2182 || frag_offset_fixed_p (frag_left
, frag_right
, &frag_off
))
2183 && (seg_left
!= reg_section
|| left
== right
)
2184 && (seg_left
!= undefined_section
|| add_symbol
== op_symbol
)))
2186 if ((seg_left
== absolute_section
&& left
== 0)
2187 || (seg_right
== absolute_section
&& right
== 0))
2189 if (op
== O_bit_exclusive_or
|| op
== O_bit_inclusive_or
)
2191 if (!(seg_right
== absolute_section
&& right
== 0))
2193 seg_left
= seg_right
;
2195 add_symbol
= op_symbol
;
2196 orig_add_symbol
= expressionP
->X_op_symbol
;
2201 else if (op
== O_left_shift
|| op
== O_right_shift
)
2203 if (!(seg_left
== absolute_section
&& left
== 0))
2209 else if (op
!= O_multiply
2210 && op
!= O_bit_or_not
&& op
!= O_bit_and
)
2213 else if (op
== O_multiply
2214 && seg_left
== absolute_section
&& left
== 1)
2216 seg_left
= seg_right
;
2218 add_symbol
= op_symbol
;
2219 orig_add_symbol
= expressionP
->X_op_symbol
;
2223 else if ((op
== O_multiply
|| op
== O_divide
)
2224 && seg_right
== absolute_section
&& right
== 1)
2229 else if (!(left
== right
2230 && ((seg_left
== reg_section
&& seg_right
== reg_section
)
2231 || (seg_left
== undefined_section
2232 && seg_right
== undefined_section
2233 && add_symbol
== op_symbol
))))
2235 else if (op
== O_bit_and
|| op
== O_bit_inclusive_or
)
2240 else if (op
!= O_bit_exclusive_or
&& op
!= O_bit_or_not
)
2244 right
+= frag_off
/ OCTETS_PER_BYTE
;
2247 case O_add
: left
+= right
; break;
2248 case O_subtract
: left
-= right
; break;
2249 case O_multiply
: left
*= right
; break;
2253 left
= (offsetT
) left
/ (offsetT
) right
;
2258 left
= (offsetT
) left
% (offsetT
) right
;
2260 case O_left_shift
: left
<<= right
; break;
2261 case O_right_shift
: left
>>= right
; break;
2262 case O_bit_inclusive_or
: left
|= right
; break;
2263 case O_bit_or_not
: left
|= ~right
; break;
2264 case O_bit_exclusive_or
: left
^= right
; break;
2265 case O_bit_and
: left
&= right
; break;
2268 left
= (left
== right
2269 && seg_left
== seg_right
2270 && (finalize_syms
|| frag_left
== frag_right
)
2271 && (seg_left
!= undefined_section
2272 || add_symbol
== op_symbol
)
2273 ? ~ (valueT
) 0 : 0);
2278 left
= (offsetT
) left
< (offsetT
) right
? ~ (valueT
) 0 : 0;
2281 left
= (offsetT
) left
<= (offsetT
) right
? ~ (valueT
) 0 : 0;
2284 left
= (offsetT
) left
>= (offsetT
) right
? ~ (valueT
) 0 : 0;
2287 left
= (offsetT
) left
> (offsetT
) right
? ~ (valueT
) 0 : 0;
2289 case O_logical_and
: left
= left
&& right
; break;
2290 case O_logical_or
: left
= left
|| right
; break;
2300 if (seg_left
== absolute_section
)
2302 else if (seg_left
== reg_section
&& final_val
== 0)
2304 else if (!symbol_same_p (add_symbol
, orig_add_symbol
))
2306 expressionP
->X_add_symbol
= add_symbol
;
2308 expressionP
->X_op
= op
;
2310 if (op
== O_constant
|| op
== O_register
)
2312 expressionP
->X_add_number
= final_val
;
2317 /* This lives here because it belongs equally in expr.c & read.c.
2318 expr.c is just a branch office read.c anyway, and putting it
2319 here lessens the crowd at read.c.
2321 Assume input_line_pointer is at start of symbol name.
2322 Advance input_line_pointer past symbol name.
2323 Turn that character into a '\0', returning its former value.
2324 This allows a string compare (RMS wants symbol names to be strings)
2326 There will always be a char following symbol name, because all good
2327 lines end in end-of-line. */
2330 get_symbol_end (void)
2334 /* We accept \001 in a name in case this is being called with a
2335 constructed string. */
2336 if (is_name_beginner (c
= *input_line_pointer
++) || c
== '\001')
2338 while (is_part_of_name (c
= *input_line_pointer
++)
2341 if (is_name_ender (c
))
2342 c
= *input_line_pointer
++;
2344 *--input_line_pointer
= 0;
2349 get_single_number (void)
2352 operand (&exp
, expr_normal
);
2353 return exp
.X_add_number
;