1 /* expr.c -operands, expressions-
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* This is really a branch office of as-read.c. I split it out to clearly
24 distinguish the world of expressions from the world of statements.
25 (It also gives smaller files to re-compile.)
26 Here, "operand"s are of expressions, not instructions. */
28 #define min(a, b) ((a) < (b) ? (a) : (b))
31 #include "safe-ctype.h"
41 static void floating_constant (expressionS
* expressionP
);
42 static valueT
generic_bignum_to_int32 (void);
44 static valueT
generic_bignum_to_int64 (void);
46 static void integer_constant (int radix
, expressionS
* expressionP
);
47 static void mri_char_constant (expressionS
*);
48 static void current_location (expressionS
*);
49 static void clean_up_expression (expressionS
* expressionP
);
50 static segT
operand (expressionS
*, enum expr_mode
);
51 static operatorT
operator (int *);
53 extern const char EXP_CHARS
[], FLT_CHARS
[];
55 /* We keep a mapping of expression symbols to file positions, so that
56 we can provide better error messages. */
58 struct expr_symbol_line
{
59 struct expr_symbol_line
*next
;
65 static struct expr_symbol_line
*expr_symbol_lines
;
67 /* Build a dummy symbol to hold a complex expression. This is how we
68 build expressions up out of other expressions. The symbol is put
69 into the fake section expr_section. */
72 make_expr_symbol (expressionS
*expressionP
)
76 struct expr_symbol_line
*n
;
78 if (expressionP
->X_op
== O_symbol
79 && expressionP
->X_add_number
== 0)
80 return expressionP
->X_add_symbol
;
82 if (expressionP
->X_op
== O_big
)
84 /* This won't work, because the actual value is stored in
85 generic_floating_point_number or generic_bignum, and we are
86 going to lose it if we haven't already. */
87 if (expressionP
->X_add_number
> 0)
88 as_bad (_("bignum invalid"));
90 as_bad (_("floating point number invalid"));
91 zero
.X_op
= O_constant
;
92 zero
.X_add_number
= 0;
94 clean_up_expression (&zero
);
98 /* Putting constant symbols in absolute_section rather than
99 expr_section is convenient for the old a.out code, for which
100 S_GET_SEGMENT does not always retrieve the value put in by
102 symbolP
= symbol_create (FAKE_LABEL_NAME
,
103 (expressionP
->X_op
== O_constant
105 : expressionP
->X_op
== O_register
108 0, &zero_address_frag
);
109 symbol_set_value_expression (symbolP
, expressionP
);
111 if (expressionP
->X_op
== O_constant
)
112 resolve_symbol_value (symbolP
);
114 n
= (struct expr_symbol_line
*) xmalloc (sizeof *n
);
116 as_where (&n
->file
, &n
->line
);
117 n
->next
= expr_symbol_lines
;
118 expr_symbol_lines
= n
;
123 /* Return the file and line number for an expr symbol. Return
124 non-zero if something was found, 0 if no information is known for
128 expr_symbol_where (symbolS
*sym
, char **pfile
, unsigned int *pline
)
130 register struct expr_symbol_line
*l
;
132 for (l
= expr_symbol_lines
; l
!= NULL
; l
= l
->next
)
145 /* Utilities for building expressions.
146 Since complex expressions are recorded as symbols for use in other
147 expressions these return a symbolS * and not an expressionS *.
148 These explicitly do not take an "add_number" argument. */
149 /* ??? For completeness' sake one might want expr_build_symbol.
150 It would just return its argument. */
152 /* Build an expression for an unsigned constant.
153 The corresponding one for signed constants is missing because
154 there's currently no need for it. One could add an unsigned_p flag
155 but that seems more clumsy. */
158 expr_build_uconstant (offsetT value
)
163 e
.X_add_number
= value
;
165 return make_expr_symbol (&e
);
168 /* Build an expression for the current location ('.'). */
171 expr_build_dot (void)
175 current_location (&e
);
176 return make_expr_symbol (&e
);
179 /* Build any floating-point literal here.
180 Also build any bignum literal here. */
182 /* Seems atof_machine can backscan through generic_bignum and hit whatever
183 happens to be loaded before it in memory. And its way too complicated
184 for me to fix right. Thus a hack. JF: Just make generic_bignum bigger,
185 and never write into the early words, thus they'll always be zero.
186 I hate Dean's floating-point code. Bleh. */
187 LITTLENUM_TYPE generic_bignum
[SIZE_OF_LARGE_NUMBER
+ 6];
189 FLONUM_TYPE generic_floating_point_number
= {
190 &generic_bignum
[6], /* low. (JF: Was 0) */
191 &generic_bignum
[SIZE_OF_LARGE_NUMBER
+ 6 - 1], /* high. JF: (added +6) */
199 floating_constant (expressionS
*expressionP
)
201 /* input_line_pointer -> floating-point constant. */
204 error_code
= atof_generic (&input_line_pointer
, ".", EXP_CHARS
,
205 &generic_floating_point_number
);
209 if (error_code
== ERROR_EXPONENT_OVERFLOW
)
211 as_bad (_("bad floating-point constant: exponent overflow"));
215 as_bad (_("bad floating-point constant: unknown error code=%d"),
219 expressionP
->X_op
= O_big
;
220 /* input_line_pointer -> just after constant, which may point to
222 expressionP
->X_add_number
= -1;
226 generic_bignum_to_int32 (void)
229 ((generic_bignum
[1] & LITTLENUM_MASK
) << LITTLENUM_NUMBER_OF_BITS
)
230 | (generic_bignum
[0] & LITTLENUM_MASK
);
231 number
&= 0xffffffff;
237 generic_bignum_to_int64 (void)
240 ((((((((valueT
) generic_bignum
[3] & LITTLENUM_MASK
)
241 << LITTLENUM_NUMBER_OF_BITS
)
242 | ((valueT
) generic_bignum
[2] & LITTLENUM_MASK
))
243 << LITTLENUM_NUMBER_OF_BITS
)
244 | ((valueT
) generic_bignum
[1] & LITTLENUM_MASK
))
245 << LITTLENUM_NUMBER_OF_BITS
)
246 | ((valueT
) generic_bignum
[0] & LITTLENUM_MASK
));
252 integer_constant (int radix
, expressionS
*expressionP
)
254 char *start
; /* Start of number. */
257 valueT number
; /* Offset or (absolute) value. */
258 short int digit
; /* Value of next digit in current radix. */
259 short int maxdig
= 0; /* Highest permitted digit value. */
260 int too_many_digits
= 0; /* If we see >= this number of. */
261 char *name
; /* Points to name of symbol. */
262 symbolS
*symbolP
; /* Points to symbol. */
264 int small
; /* True if fits in 32 bits. */
266 /* May be bignum, or may fit in 32 bits. */
267 /* Most numbers fit into 32 bits, and we want this case to be fast.
268 so we pretend it will fit into 32 bits. If, after making up a 32
269 bit number, we realise that we have scanned more digits than
270 comfortably fit into 32 bits, we re-scan the digits coding them
271 into a bignum. For decimal and octal numbers we are
272 conservative: Some numbers may be assumed bignums when in fact
273 they do fit into 32 bits. Numbers of any radix can have excess
274 leading zeros: We strive to recognise this and cast them back
275 into 32 bits. We must check that the bignum really is more than
276 32 bits, and change it back to a 32-bit number if it fits. The
277 number we are looking for is expected to be positive, but if it
278 fits into 32 bits as an unsigned number, we let it be a 32-bit
279 number. The cavalier approach is for speed in ordinary cases. */
280 /* This has been extended for 64 bits. We blindly assume that if
281 you're compiling in 64-bit mode, the target is a 64-bit machine.
282 This should be cleaned up. */
286 #else /* includes non-bfd case, mostly */
290 if ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
) && radix
== 0)
294 /* In MRI mode, the number may have a suffix indicating the
295 radix. For that matter, it might actually be a floating
297 for (suffix
= input_line_pointer
; ISALNUM (*suffix
); suffix
++)
299 if (*suffix
== 'e' || *suffix
== 'E')
303 if (suffix
== input_line_pointer
)
312 /* If we have both NUMBERS_WITH_SUFFIX and LOCAL_LABELS_FB,
313 we distinguish between 'B' and 'b'. This is the case for
315 if ((NUMBERS_WITH_SUFFIX
&& LOCAL_LABELS_FB
? *suffix
: c
) == 'B')
319 else if (c
== 'O' || c
== 'Q')
323 else if (suffix
[1] == '.' || c
== 'E' || flt
)
325 floating_constant (expressionP
);
340 too_many_digits
= valuesize
+ 1;
344 too_many_digits
= (valuesize
+ 2) / 3 + 1;
348 too_many_digits
= (valuesize
+ 3) / 4 + 1;
352 too_many_digits
= (valuesize
+ 11) / 4; /* Very rough. */
355 start
= input_line_pointer
;
356 c
= *input_line_pointer
++;
358 (digit
= hex_value (c
)) < maxdig
;
359 c
= *input_line_pointer
++)
361 number
= number
* radix
+ digit
;
363 /* c contains character after number. */
364 /* input_line_pointer->char after c. */
365 small
= (input_line_pointer
- start
- 1) < too_many_digits
;
367 if (radix
== 16 && c
== '_')
369 /* This is literal of the form 0x333_0_12345678_1.
370 This example is equivalent to 0x00000333000000001234567800000001. */
372 int num_little_digits
= 0;
374 input_line_pointer
= start
; /* -> 1st digit. */
376 know (LITTLENUM_NUMBER_OF_BITS
== 16);
378 for (c
= '_'; c
== '_'; num_little_digits
+= 2)
381 /* Convert one 64-bit word. */
384 for (c
= *input_line_pointer
++;
385 (digit
= hex_value (c
)) < maxdig
;
386 c
= *(input_line_pointer
++))
388 number
= number
* radix
+ digit
;
392 /* Check for 8 digit per word max. */
394 as_bad (_("a bignum with underscores may not have more than 8 hex digits in any word"));
396 /* Add this chunk to the bignum.
397 Shift things down 2 little digits. */
398 know (LITTLENUM_NUMBER_OF_BITS
== 16);
399 for (i
= min (num_little_digits
+ 1, SIZE_OF_LARGE_NUMBER
- 1);
402 generic_bignum
[i
] = generic_bignum
[i
- 2];
404 /* Add the new digits as the least significant new ones. */
405 generic_bignum
[0] = number
& 0xffffffff;
406 generic_bignum
[1] = number
>> 16;
409 /* Again, c is char after number, input_line_pointer->after c. */
411 if (num_little_digits
> SIZE_OF_LARGE_NUMBER
- 1)
412 num_little_digits
= SIZE_OF_LARGE_NUMBER
- 1;
414 assert (num_little_digits
>= 4);
416 if (num_little_digits
!= 8)
417 as_bad (_("a bignum with underscores must have exactly 4 words"));
419 /* We might have some leading zeros. These can be trimmed to give
420 us a change to fit this constant into a small number. */
421 while (generic_bignum
[num_little_digits
- 1] == 0
422 && num_little_digits
> 1)
425 if (num_little_digits
<= 2)
427 /* will fit into 32 bits. */
428 number
= generic_bignum_to_int32 ();
432 else if (num_little_digits
<= 4)
434 /* Will fit into 64 bits. */
435 number
= generic_bignum_to_int64 ();
443 /* Number of littlenums in the bignum. */
444 number
= num_little_digits
;
449 /* We saw a lot of digits. manufacture a bignum the hard way. */
450 LITTLENUM_TYPE
*leader
; /* -> high order littlenum of the bignum. */
451 LITTLENUM_TYPE
*pointer
; /* -> littlenum we are frobbing now. */
454 leader
= generic_bignum
;
455 generic_bignum
[0] = 0;
456 generic_bignum
[1] = 0;
457 generic_bignum
[2] = 0;
458 generic_bignum
[3] = 0;
459 input_line_pointer
= start
; /* -> 1st digit. */
460 c
= *input_line_pointer
++;
461 for (; (carry
= hex_value (c
)) < maxdig
; c
= *input_line_pointer
++)
463 for (pointer
= generic_bignum
; pointer
<= leader
; pointer
++)
467 work
= carry
+ radix
* *pointer
;
468 *pointer
= work
& LITTLENUM_MASK
;
469 carry
= work
>> LITTLENUM_NUMBER_OF_BITS
;
473 if (leader
< generic_bignum
+ SIZE_OF_LARGE_NUMBER
- 1)
475 /* Room to grow a longer bignum. */
480 /* Again, c is char after number. */
481 /* input_line_pointer -> after c. */
482 know (LITTLENUM_NUMBER_OF_BITS
== 16);
483 if (leader
< generic_bignum
+ 2)
485 /* Will fit into 32 bits. */
486 number
= generic_bignum_to_int32 ();
490 else if (leader
< generic_bignum
+ 4)
492 /* Will fit into 64 bits. */
493 number
= generic_bignum_to_int64 ();
499 /* Number of littlenums in the bignum. */
500 number
= leader
- generic_bignum
+ 1;
504 if ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
506 && input_line_pointer
- 1 == suffix
)
507 c
= *input_line_pointer
++;
511 /* Here with number, in correct radix. c is the next char.
512 Note that unlike un*x, we allow "011f" "0x9f" to both mean
513 the same as the (conventional) "9f".
514 This is simply easier than checking for strict canonical
517 if (LOCAL_LABELS_FB
&& c
== 'b')
519 /* Backward ref to local label.
520 Because it is backward, expect it to be defined. */
521 /* Construct a local label. */
522 name
= fb_label_name ((int) number
, 0);
524 /* Seen before, or symbol is defined: OK. */
525 symbolP
= symbol_find (name
);
526 if ((symbolP
!= NULL
) && (S_IS_DEFINED (symbolP
)))
528 /* Local labels are never absolute. Don't waste time
529 checking absoluteness. */
530 know (SEG_NORMAL (S_GET_SEGMENT (symbolP
)));
532 expressionP
->X_op
= O_symbol
;
533 expressionP
->X_add_symbol
= symbolP
;
537 /* Either not seen or not defined. */
538 /* @@ Should print out the original string instead of
539 the parsed number. */
540 as_bad (_("backward ref to unknown label \"%d:\""),
542 expressionP
->X_op
= O_constant
;
545 expressionP
->X_add_number
= 0;
547 else if (LOCAL_LABELS_FB
&& c
== 'f')
549 /* Forward reference. Expect symbol to be undefined or
550 unknown. undefined: seen it before. unknown: never seen
553 Construct a local label name, then an undefined symbol.
554 Don't create a xseg frag for it: caller may do that.
555 Just return it as never seen before. */
556 name
= fb_label_name ((int) number
, 1);
557 symbolP
= symbol_find_or_make (name
);
558 /* We have no need to check symbol properties. */
559 #ifndef many_segments
560 /* Since "know" puts its arg into a "string", we
561 can't have newlines in the argument. */
562 know (S_GET_SEGMENT (symbolP
) == undefined_section
|| S_GET_SEGMENT (symbolP
) == text_section
|| S_GET_SEGMENT (symbolP
) == data_section
);
564 expressionP
->X_op
= O_symbol
;
565 expressionP
->X_add_symbol
= symbolP
;
566 expressionP
->X_add_number
= 0;
568 else if (LOCAL_LABELS_DOLLAR
&& c
== '$')
570 /* If the dollar label is *currently* defined, then this is just
571 another reference to it. If it is not *currently* defined,
572 then this is a fresh instantiation of that number, so create
575 if (dollar_label_defined ((long) number
))
577 name
= dollar_label_name ((long) number
, 0);
578 symbolP
= symbol_find (name
);
579 know (symbolP
!= NULL
);
583 name
= dollar_label_name ((long) number
, 1);
584 symbolP
= symbol_find_or_make (name
);
587 expressionP
->X_op
= O_symbol
;
588 expressionP
->X_add_symbol
= symbolP
;
589 expressionP
->X_add_number
= 0;
593 expressionP
->X_op
= O_constant
;
594 expressionP
->X_add_number
= number
;
595 input_line_pointer
--; /* Restore following character. */
596 } /* Really just a number. */
600 /* Not a small number. */
601 expressionP
->X_op
= O_big
;
602 expressionP
->X_add_number
= number
; /* Number of littlenums. */
603 input_line_pointer
--; /* -> char following number. */
607 /* Parse an MRI multi character constant. */
610 mri_char_constant (expressionS
*expressionP
)
614 if (*input_line_pointer
== '\''
615 && input_line_pointer
[1] != '\'')
617 expressionP
->X_op
= O_constant
;
618 expressionP
->X_add_number
= 0;
622 /* In order to get the correct byte ordering, we must build the
623 number in reverse. */
624 for (i
= SIZE_OF_LARGE_NUMBER
- 1; i
>= 0; i
--)
628 generic_bignum
[i
] = 0;
629 for (j
= 0; j
< CHARS_PER_LITTLENUM
; j
++)
631 if (*input_line_pointer
== '\'')
633 if (input_line_pointer
[1] != '\'')
635 ++input_line_pointer
;
637 generic_bignum
[i
] <<= 8;
638 generic_bignum
[i
] += *input_line_pointer
;
639 ++input_line_pointer
;
642 if (i
< SIZE_OF_LARGE_NUMBER
- 1)
644 /* If there is more than one littlenum, left justify the
645 last one to make it match the earlier ones. If there is
646 only one, we can just use the value directly. */
647 for (; j
< CHARS_PER_LITTLENUM
; j
++)
648 generic_bignum
[i
] <<= 8;
651 if (*input_line_pointer
== '\''
652 && input_line_pointer
[1] != '\'')
658 as_bad (_("character constant too large"));
667 c
= SIZE_OF_LARGE_NUMBER
- i
;
668 for (j
= 0; j
< c
; j
++)
669 generic_bignum
[j
] = generic_bignum
[i
+ j
];
673 know (LITTLENUM_NUMBER_OF_BITS
== 16);
676 expressionP
->X_op
= O_big
;
677 expressionP
->X_add_number
= i
;
681 expressionP
->X_op
= O_constant
;
683 expressionP
->X_add_number
= generic_bignum
[0] & LITTLENUM_MASK
;
685 expressionP
->X_add_number
=
686 (((generic_bignum
[1] & LITTLENUM_MASK
)
687 << LITTLENUM_NUMBER_OF_BITS
)
688 | (generic_bignum
[0] & LITTLENUM_MASK
));
691 /* Skip the final closing quote. */
692 ++input_line_pointer
;
695 /* Return an expression representing the current location. This
696 handles the magic symbol `.'. */
699 current_location (expressionS
*expressionp
)
701 if (now_seg
== absolute_section
)
703 expressionp
->X_op
= O_constant
;
704 expressionp
->X_add_number
= abs_section_offset
;
708 expressionp
->X_op
= O_symbol
;
709 expressionp
->X_add_symbol
= symbol_temp_new_now ();
710 expressionp
->X_add_number
= 0;
714 /* In: Input_line_pointer points to 1st char of operand, which may
718 The operand may have been empty: in this case X_op == O_absent.
719 Input_line_pointer->(next non-blank) char after operand. */
722 operand (expressionS
*expressionP
, enum expr_mode mode
)
725 symbolS
*symbolP
; /* Points to symbol. */
726 char *name
; /* Points to name of symbol. */
729 /* All integers are regarded as unsigned unless they are negated.
730 This is because the only thing which cares whether a number is
731 unsigned is the code in emit_expr which extends constants into
732 bignums. It should only sign extend negative numbers, so that
733 something like ``.quad 0x80000000'' is not sign extended even
734 though it appears negative if valueT is 32 bits. */
735 expressionP
->X_unsigned
= 1;
737 /* Digits, assume it is a bignum. */
739 SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
740 c
= *input_line_pointer
++; /* input_line_pointer -> past char in c. */
742 if (is_end_of_line
[(unsigned char) c
])
756 input_line_pointer
--;
758 integer_constant ((NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
763 #ifdef LITERAL_PREFIXDOLLAR_HEX
765 /* $L is the start of a local label, not a hex constant. */
766 if (* input_line_pointer
== 'L')
768 integer_constant (16, expressionP
);
772 #ifdef LITERAL_PREFIXPERCENT_BIN
774 integer_constant (2, expressionP
);
779 /* Non-decimal radix. */
781 if (NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
785 /* Check for a hex or float constant. */
786 for (s
= input_line_pointer
; hex_p (*s
); s
++)
788 if (*s
== 'h' || *s
== 'H' || *input_line_pointer
== '.')
790 --input_line_pointer
;
791 integer_constant (0, expressionP
);
795 c
= *input_line_pointer
;
804 if (NUMBERS_WITH_SUFFIX
|| flag_m68k_mri
)
806 integer_constant (0, expressionP
);
812 if (c
&& strchr (FLT_CHARS
, c
))
814 input_line_pointer
++;
815 floating_constant (expressionP
);
816 expressionP
->X_add_number
= - TOLOWER (c
);
820 /* The string was only zero. */
821 expressionP
->X_op
= O_constant
;
822 expressionP
->X_add_number
= 0;
831 input_line_pointer
++;
832 integer_constant (16, expressionP
);
836 if (LOCAL_LABELS_FB
&& ! (flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
))
838 /* This code used to check for '+' and '-' here, and, in
839 some conditions, fall through to call
840 integer_constant. However, that didn't make sense,
841 as integer_constant only accepts digits. */
842 /* Some of our code elsewhere does permit digits greater
843 than the expected base; for consistency, do the same
845 if (input_line_pointer
[1] < '0'
846 || input_line_pointer
[1] > '9')
848 /* Parse this as a back reference to label 0. */
849 input_line_pointer
--;
850 integer_constant (10, expressionP
);
853 /* Otherwise, parse this as a binary number. */
857 input_line_pointer
++;
858 if (flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
860 integer_constant (2, expressionP
);
871 integer_constant ((flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
879 /* If it says "0f" and it could possibly be a floating point
880 number, make it one. Otherwise, make it a local label,
881 and try to deal with parsing the rest later. */
882 if (!input_line_pointer
[1]
883 || (is_end_of_line
[0xff & input_line_pointer
[1]])
884 || strchr (FLT_CHARS
, 'f') == NULL
)
887 char *cp
= input_line_pointer
+ 1;
888 int r
= atof_generic (&cp
, ".", EXP_CHARS
,
889 &generic_floating_point_number
);
893 case ERROR_EXPONENT_OVERFLOW
:
894 if (*cp
== 'f' || *cp
== 'b')
895 /* Looks like a difference expression. */
897 else if (cp
== input_line_pointer
+ 1)
898 /* No characters has been accepted -- looks like
904 as_fatal (_("expr.c(operand): bad atof_generic return val %d"),
909 /* Okay, now we've sorted it out. We resume at one of these
910 two labels, depending on what we've decided we're probably
913 input_line_pointer
--;
914 integer_constant (10, expressionP
);
924 if (flag_m68k_mri
|| NUMBERS_WITH_SUFFIX
)
926 integer_constant (0, expressionP
);
936 input_line_pointer
++;
937 floating_constant (expressionP
);
938 expressionP
->X_add_number
= - TOLOWER (c
);
942 if (LOCAL_LABELS_DOLLAR
)
944 integer_constant (10, expressionP
);
954 #ifndef NEED_INDEX_OPERATOR
957 /* Didn't begin with digit & not a name. */
958 if (mode
!= expr_defer
)
959 segment
= expression (expressionP
);
961 segment
= deferred_expression (expressionP
);
962 /* expression () will pass trailing whitespace. */
963 if ((c
== '(' && *input_line_pointer
!= ')')
964 || (c
== '[' && *input_line_pointer
!= ']'))
965 as_bad (_("missing '%c'"), c
== '(' ? ')' : ']');
967 input_line_pointer
++;
969 /* Here with input_line_pointer -> char after "(...)". */
974 if (! flag_m68k_mri
|| *input_line_pointer
!= '\'')
976 as_bad (_("EBCDIC constants are not supported"));
979 if (! flag_m68k_mri
|| *input_line_pointer
!= '\'')
981 ++input_line_pointer
;
987 /* Warning: to conform to other people's assemblers NO
988 ESCAPEMENT is permitted for a single quote. The next
989 character, parity errors and all, is taken as the value
990 of the operand. VERY KINKY. */
991 expressionP
->X_op
= O_constant
;
992 expressionP
->X_add_number
= *input_line_pointer
++;
996 mri_char_constant (expressionP
);
1001 /* Double quote is the bitwise not operator in MRI mode. */
1002 if (! flag_m68k_mri
)
1007 /* '~' is permitted to start a label on the Delta. */
1008 if (is_name_beginner (c
))
1014 operand (expressionP
, mode
);
1015 if (expressionP
->X_op
== O_constant
)
1017 /* input_line_pointer -> char after operand. */
1020 expressionP
->X_add_number
= - expressionP
->X_add_number
;
1021 /* Notice: '-' may overflow: no warning is given.
1022 This is compatible with other people's
1023 assemblers. Sigh. */
1024 expressionP
->X_unsigned
= 0;
1026 else if (c
== '~' || c
== '"')
1027 expressionP
->X_add_number
= ~ expressionP
->X_add_number
;
1029 expressionP
->X_add_number
= ! expressionP
->X_add_number
;
1031 else if (expressionP
->X_op
== O_big
1032 && expressionP
->X_add_number
<= 0
1034 && (generic_floating_point_number
.sign
== '+'
1035 || generic_floating_point_number
.sign
== 'P'))
1037 /* Negative flonum (eg, -1.000e0). */
1038 if (generic_floating_point_number
.sign
== '+')
1039 generic_floating_point_number
.sign
= '-';
1041 generic_floating_point_number
.sign
= 'N';
1043 else if (expressionP
->X_op
== O_big
1044 && expressionP
->X_add_number
> 0)
1048 if (c
== '~' || c
== '-')
1050 for (i
= 0; i
< expressionP
->X_add_number
; ++i
)
1051 generic_bignum
[i
] = ~generic_bignum
[i
];
1053 for (i
= 0; i
< expressionP
->X_add_number
; ++i
)
1055 generic_bignum
[i
] += 1;
1056 if (generic_bignum
[i
])
1063 for (i
= 0; i
< expressionP
->X_add_number
; ++i
)
1065 if (generic_bignum
[i
])
1067 generic_bignum
[i
] = 0;
1069 generic_bignum
[0] = nonzero
;
1072 else if (expressionP
->X_op
!= O_illegal
1073 && expressionP
->X_op
!= O_absent
)
1077 expressionP
->X_add_symbol
= make_expr_symbol (expressionP
);
1079 expressionP
->X_op
= O_uminus
;
1080 else if (c
== '~' || c
== '"')
1081 expressionP
->X_op
= O_bit_not
;
1083 expressionP
->X_op
= O_logical_not
;
1084 expressionP
->X_add_number
= 0;
1088 as_warn (_("Unary operator %c ignored because bad operand follows"),
1093 #if defined (DOLLAR_DOT) || defined (TC_M68K)
1095 /* '$' is the program counter when in MRI mode, or when
1096 DOLLAR_DOT is defined. */
1098 if (! flag_m68k_mri
)
1101 if (DOLLAR_AMBIGU
&& hex_p (*input_line_pointer
))
1103 /* In MRI mode and on Z80, '$' is also used as the prefix
1104 for a hexadecimal constant. */
1105 integer_constant (16, expressionP
);
1109 if (is_part_of_name (*input_line_pointer
))
1112 current_location (expressionP
);
1117 if (!is_part_of_name (*input_line_pointer
))
1119 current_location (expressionP
);
1122 else if ((strncasecmp (input_line_pointer
, "startof.", 8) == 0
1123 && ! is_part_of_name (input_line_pointer
[8]))
1124 || (strncasecmp (input_line_pointer
, "sizeof.", 7) == 0
1125 && ! is_part_of_name (input_line_pointer
[7])))
1129 start
= (input_line_pointer
[1] == 't'
1130 || input_line_pointer
[1] == 'T');
1131 input_line_pointer
+= start
? 8 : 7;
1133 if (*input_line_pointer
!= '(')
1134 as_bad (_("syntax error in .startof. or .sizeof."));
1139 ++input_line_pointer
;
1141 name
= input_line_pointer
;
1142 c
= get_symbol_end ();
1144 buf
= (char *) xmalloc (strlen (name
) + 10);
1146 sprintf (buf
, ".startof.%s", name
);
1148 sprintf (buf
, ".sizeof.%s", name
);
1149 symbolP
= symbol_make (buf
);
1152 expressionP
->X_op
= O_symbol
;
1153 expressionP
->X_add_symbol
= symbolP
;
1154 expressionP
->X_add_number
= 0;
1156 *input_line_pointer
= c
;
1158 if (*input_line_pointer
!= ')')
1159 as_bad (_("syntax error in .startof. or .sizeof."));
1161 ++input_line_pointer
;
1172 /* Can't imagine any other kind of operand. */
1173 expressionP
->X_op
= O_absent
;
1174 input_line_pointer
--;
1179 if (! flag_m68k_mri
)
1181 integer_constant (2, expressionP
);
1185 if (! flag_m68k_mri
)
1187 integer_constant (8, expressionP
);
1191 if (! flag_m68k_mri
)
1194 /* In MRI mode, this is a floating point constant represented
1195 using hexadecimal digits. */
1197 ++input_line_pointer
;
1198 integer_constant (16, expressionP
);
1202 if (! flag_m68k_mri
|| is_part_of_name (*input_line_pointer
))
1205 current_location (expressionP
);
1213 if (is_name_beginner (c
)) /* Here if did not begin with a digit. */
1215 /* Identifier begins here.
1216 This is kludged for speed, so code is repeated. */
1218 name
= --input_line_pointer
;
1219 c
= get_symbol_end ();
1221 #ifdef md_parse_name
1222 /* This is a hook for the backend to parse certain names
1223 specially in certain contexts. If a name always has a
1224 specific value, it can often be handled by simply
1225 entering it in the symbol table. */
1226 if (md_parse_name (name
, expressionP
, mode
, &c
))
1228 *input_line_pointer
= c
;
1234 /* The MRI i960 assembler permits
1236 FIXME: This should use md_parse_name. */
1238 && (strcasecmp (name
, "sizeof") == 0
1239 || strcasecmp (name
, "startof") == 0))
1244 start
= (name
[1] == 't'
1247 *input_line_pointer
= c
;
1250 name
= input_line_pointer
;
1251 c
= get_symbol_end ();
1253 buf
= (char *) xmalloc (strlen (name
) + 10);
1255 sprintf (buf
, ".startof.%s", name
);
1257 sprintf (buf
, ".sizeof.%s", name
);
1258 symbolP
= symbol_make (buf
);
1261 expressionP
->X_op
= O_symbol
;
1262 expressionP
->X_add_symbol
= symbolP
;
1263 expressionP
->X_add_number
= 0;
1265 *input_line_pointer
= c
;
1272 symbolP
= symbol_find_or_make (name
);
1274 /* If we have an absolute symbol or a reg, then we know its
1276 segment
= S_GET_SEGMENT (symbolP
);
1277 if (mode
!= expr_defer
&& segment
== absolute_section
)
1279 expressionP
->X_op
= O_constant
;
1280 expressionP
->X_add_number
= S_GET_VALUE (symbolP
);
1282 else if (mode
!= expr_defer
&& segment
== reg_section
)
1284 expressionP
->X_op
= O_register
;
1285 expressionP
->X_add_number
= S_GET_VALUE (symbolP
);
1289 expressionP
->X_op
= O_symbol
;
1290 expressionP
->X_add_symbol
= symbolP
;
1291 expressionP
->X_add_number
= 0;
1293 *input_line_pointer
= c
;
1297 /* Let the target try to parse it. Success is indicated by changing
1298 the X_op field to something other than O_absent and pointing
1299 input_line_pointer past the expression. If it can't parse the
1300 expression, X_op and input_line_pointer should be unchanged. */
1301 expressionP
->X_op
= O_absent
;
1302 --input_line_pointer
;
1303 md_operand (expressionP
);
1304 if (expressionP
->X_op
== O_absent
)
1306 ++input_line_pointer
;
1307 as_bad (_("bad expression"));
1308 expressionP
->X_op
= O_constant
;
1309 expressionP
->X_add_number
= 0;
1315 /* It is more 'efficient' to clean up the expressionS when they are
1316 created. Doing it here saves lines of code. */
1317 clean_up_expression (expressionP
);
1318 SKIP_WHITESPACE (); /* -> 1st char after operand. */
1319 know (*input_line_pointer
!= ' ');
1321 /* The PA port needs this information. */
1322 if (expressionP
->X_add_symbol
)
1323 symbol_mark_used (expressionP
->X_add_symbol
);
1325 expressionP
->X_add_symbol
= symbol_clone_if_forward_ref (expressionP
->X_add_symbol
);
1326 expressionP
->X_op_symbol
= symbol_clone_if_forward_ref (expressionP
->X_op_symbol
);
1328 switch (expressionP
->X_op
)
1331 return absolute_section
;
1333 return S_GET_SEGMENT (expressionP
->X_add_symbol
);
1339 /* Internal. Simplify a struct expression for use by expr (). */
1341 /* In: address of an expressionS.
1342 The X_op field of the expressionS may only take certain values.
1343 Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
1345 Out: expressionS may have been modified:
1346 Unused fields zeroed to help expr (). */
1349 clean_up_expression (expressionS
*expressionP
)
1351 switch (expressionP
->X_op
)
1355 expressionP
->X_add_number
= 0;
1360 expressionP
->X_add_symbol
= NULL
;
1365 expressionP
->X_op_symbol
= NULL
;
1372 /* Expression parser. */
1374 /* We allow an empty expression, and just assume (absolute,0) silently.
1375 Unary operators and parenthetical expressions are treated as operands.
1376 As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
1378 We used to do an aho/ullman shift-reduce parser, but the logic got so
1379 warped that I flushed it and wrote a recursive-descent parser instead.
1380 Now things are stable, would anybody like to write a fast parser?
1381 Most expressions are either register (which does not even reach here)
1382 or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
1383 So I guess it doesn't really matter how inefficient more complex expressions
1386 After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
1387 Also, we have consumed any leading or trailing spaces (operand does that)
1388 and done all intervening operators.
1390 This returns the segment of the result, which will be
1391 absolute_section or the segment of a symbol. */
1394 #define __ O_illegal
1396 #define O_SINGLE_EQ O_illegal
1399 /* Maps ASCII -> operators. */
1400 static const operatorT op_encoding
[256] = {
1401 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1402 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1404 __
, O_bit_or_not
, __
, __
, __
, O_modulus
, O_bit_and
, __
,
1405 __
, __
, O_multiply
, O_add
, __
, O_subtract
, __
, O_divide
,
1406 __
, __
, __
, __
, __
, __
, __
, __
,
1407 __
, __
, __
, __
, O_lt
, O_SINGLE_EQ
, O_gt
, __
,
1408 __
, __
, __
, __
, __
, __
, __
, __
,
1409 __
, __
, __
, __
, __
, __
, __
, __
,
1410 __
, __
, __
, __
, __
, __
, __
, __
,
1412 #ifdef NEED_INDEX_OPERATOR
1417 __
, __
, O_bit_exclusive_or
, __
,
1418 __
, __
, __
, __
, __
, __
, __
, __
,
1419 __
, __
, __
, __
, __
, __
, __
, __
,
1420 __
, __
, __
, __
, __
, __
, __
, __
,
1421 __
, __
, __
, __
, O_bit_inclusive_or
, __
, __
, __
,
1423 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1424 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1425 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1426 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1427 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1428 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1429 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
1430 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
1434 0 operand, (expression)
1439 5 used for * / % in MRI mode
1444 static operator_rankT op_rank
[] = {
1449 0, /* O_symbol_rva */
1454 9, /* O_logical_not */
1458 8, /* O_left_shift */
1459 8, /* O_right_shift */
1460 7, /* O_bit_inclusive_or */
1461 7, /* O_bit_or_not */
1462 7, /* O_bit_exclusive_or */
1472 3, /* O_logical_and */
1473 2, /* O_logical_or */
1493 /* Unfortunately, in MRI mode for the m68k, multiplication and
1494 division have lower precedence than the bit wise operators. This
1495 function sets the operator precedences correctly for the current
1496 mode. Also, MRI uses a different bit_not operator, and this fixes
1499 #define STANDARD_MUL_PRECEDENCE 8
1500 #define MRI_MUL_PRECEDENCE 6
1503 expr_set_precedence (void)
1507 op_rank
[O_multiply
] = MRI_MUL_PRECEDENCE
;
1508 op_rank
[O_divide
] = MRI_MUL_PRECEDENCE
;
1509 op_rank
[O_modulus
] = MRI_MUL_PRECEDENCE
;
1513 op_rank
[O_multiply
] = STANDARD_MUL_PRECEDENCE
;
1514 op_rank
[O_divide
] = STANDARD_MUL_PRECEDENCE
;
1515 op_rank
[O_modulus
] = STANDARD_MUL_PRECEDENCE
;
1519 /* Initialize the expression parser. */
1524 expr_set_precedence ();
1526 /* Verify that X_op field is wide enough. */
1530 assert (e
.X_op
== O_max
);
1534 /* Return the encoding for the operator at INPUT_LINE_POINTER, and
1535 sets NUM_CHARS to the number of characters in the operator.
1536 Does not advance INPUT_LINE_POINTER. */
1538 static inline operatorT
1539 operator (int *num_chars
)
1544 c
= *input_line_pointer
& 0xff;
1547 if (is_end_of_line
[c
])
1553 return op_encoding
[c
];
1557 return op_encoding
[c
];
1560 switch (input_line_pointer
[1])
1563 return op_encoding
[c
];
1578 if (input_line_pointer
[1] != '=')
1579 return op_encoding
[c
];
1585 switch (input_line_pointer
[1])
1588 return op_encoding
[c
];
1590 ret
= O_right_shift
;
1600 switch (input_line_pointer
[1])
1603 /* We accept !! as equivalent to ^ for MRI compatibility. */
1605 return O_bit_exclusive_or
;
1607 /* We accept != as equivalent to <>. */
1612 return O_bit_inclusive_or
;
1613 return op_encoding
[c
];
1617 if (input_line_pointer
[1] != '|')
1618 return op_encoding
[c
];
1621 return O_logical_or
;
1624 if (input_line_pointer
[1] != '&')
1625 return op_encoding
[c
];
1628 return O_logical_and
;
1634 /* Parse an expression. */
1637 expr (int rankarg
, /* Larger # is higher rank. */
1638 expressionS
*resultP
, /* Deliver result here. */
1639 enum expr_mode mode
/* Controls behavior. */)
1641 operator_rankT rank
= (operator_rankT
) rankarg
;
1648 know (rankarg
>= 0);
1650 /* Save the value of dot for the fixup code. */
1652 dot_value
= frag_now_fix ();
1654 retval
= operand (resultP
, mode
);
1656 /* operand () gobbles spaces. */
1657 know (*input_line_pointer
!= ' ');
1659 op_left
= operator (&op_chars
);
1660 while (op_left
!= O_illegal
&& op_rank
[(int) op_left
] > rank
)
1665 input_line_pointer
+= op_chars
; /* -> after operator. */
1667 rightseg
= expr (op_rank
[(int) op_left
], &right
, mode
);
1668 if (right
.X_op
== O_absent
)
1670 as_warn (_("missing operand; zero assumed"));
1671 right
.X_op
= O_constant
;
1672 right
.X_add_number
= 0;
1673 right
.X_add_symbol
= NULL
;
1674 right
.X_op_symbol
= NULL
;
1677 know (*input_line_pointer
!= ' ');
1679 if (op_left
== O_index
)
1681 if (*input_line_pointer
!= ']')
1682 as_bad ("missing right bracket");
1685 ++input_line_pointer
;
1690 op_right
= operator (&op_chars
);
1692 know (op_right
== O_illegal
1693 || op_rank
[(int) op_right
] <= op_rank
[(int) op_left
]);
1694 know ((int) op_left
>= (int) O_multiply
1695 && (int) op_left
<= (int) O_index
);
1697 /* input_line_pointer->after right-hand quantity. */
1698 /* left-hand quantity in resultP. */
1699 /* right-hand quantity in right. */
1700 /* operator in op_left. */
1702 if (resultP
->X_op
== O_big
)
1704 if (resultP
->X_add_number
> 0)
1705 as_warn (_("left operand is a bignum; integer 0 assumed"));
1707 as_warn (_("left operand is a float; integer 0 assumed"));
1708 resultP
->X_op
= O_constant
;
1709 resultP
->X_add_number
= 0;
1710 resultP
->X_add_symbol
= NULL
;
1711 resultP
->X_op_symbol
= NULL
;
1713 if (right
.X_op
== O_big
)
1715 if (right
.X_add_number
> 0)
1716 as_warn (_("right operand is a bignum; integer 0 assumed"));
1718 as_warn (_("right operand is a float; integer 0 assumed"));
1719 right
.X_op
= O_constant
;
1720 right
.X_add_number
= 0;
1721 right
.X_add_symbol
= NULL
;
1722 right
.X_op_symbol
= NULL
;
1725 /* Optimize common cases. */
1726 #ifdef md_optimize_expr
1727 if (md_optimize_expr (resultP
, op_left
, &right
))
1734 #ifndef md_register_arithmetic
1735 # define md_register_arithmetic 1
1737 if (op_left
== O_add
&& right
.X_op
== O_constant
1738 && (md_register_arithmetic
|| resultP
->X_op
!= O_register
))
1741 resultP
->X_add_number
+= right
.X_add_number
;
1743 /* This case comes up in PIC code. */
1744 else if (op_left
== O_subtract
1745 && right
.X_op
== O_symbol
1746 && resultP
->X_op
== O_symbol
1747 && retval
== rightseg
1748 #ifdef md_allow_local_subtract
1749 && md_allow_local_subtract (resultP
, & right
, rightseg
)
1751 && (SEG_NORMAL (rightseg
)
1752 || right
.X_add_symbol
== resultP
->X_add_symbol
)
1753 && frag_offset_fixed_p (symbol_get_frag (resultP
->X_add_symbol
),
1754 symbol_get_frag (right
.X_add_symbol
),
1757 resultP
->X_add_number
-= right
.X_add_number
;
1758 resultP
->X_add_number
-= frag_off
/ OCTETS_PER_BYTE
;
1759 resultP
->X_add_number
+= (S_GET_VALUE (resultP
->X_add_symbol
)
1760 - S_GET_VALUE (right
.X_add_symbol
));
1761 resultP
->X_op
= O_constant
;
1762 resultP
->X_add_symbol
= 0;
1764 else if (op_left
== O_subtract
&& right
.X_op
== O_constant
1765 && (md_register_arithmetic
|| resultP
->X_op
!= O_register
))
1768 resultP
->X_add_number
-= right
.X_add_number
;
1770 else if (op_left
== O_add
&& resultP
->X_op
== O_constant
1771 && (md_register_arithmetic
|| right
.X_op
!= O_register
))
1774 resultP
->X_op
= right
.X_op
;
1775 resultP
->X_add_symbol
= right
.X_add_symbol
;
1776 resultP
->X_op_symbol
= right
.X_op_symbol
;
1777 resultP
->X_add_number
+= right
.X_add_number
;
1780 else if (resultP
->X_op
== O_constant
&& right
.X_op
== O_constant
)
1782 /* Constant OP constant. */
1783 offsetT v
= right
.X_add_number
;
1784 if (v
== 0 && (op_left
== O_divide
|| op_left
== O_modulus
))
1786 as_warn (_("division by zero"));
1789 if ((valueT
) v
>= sizeof(valueT
) * CHAR_BIT
1790 && (op_left
== O_left_shift
|| op_left
== O_right_shift
))
1792 as_warn_value_out_of_range (_("shift count"), v
, 0,
1793 sizeof(valueT
) * CHAR_BIT
- 1,
1795 resultP
->X_add_number
= v
= 0;
1800 case O_multiply
: resultP
->X_add_number
*= v
; break;
1801 case O_divide
: resultP
->X_add_number
/= v
; break;
1802 case O_modulus
: resultP
->X_add_number
%= v
; break;
1803 case O_left_shift
: resultP
->X_add_number
<<= v
; break;
1805 /* We always use unsigned shifts, to avoid relying on
1806 characteristics of the compiler used to compile gas. */
1807 resultP
->X_add_number
=
1808 (offsetT
) ((valueT
) resultP
->X_add_number
>> (valueT
) v
);
1810 case O_bit_inclusive_or
: resultP
->X_add_number
|= v
; break;
1811 case O_bit_or_not
: resultP
->X_add_number
|= ~v
; break;
1812 case O_bit_exclusive_or
: resultP
->X_add_number
^= v
; break;
1813 case O_bit_and
: resultP
->X_add_number
&= v
; break;
1814 /* Constant + constant (O_add) is handled by the
1815 previous if statement for constant + X, so is omitted
1817 case O_subtract
: resultP
->X_add_number
-= v
; break;
1819 resultP
->X_add_number
=
1820 resultP
->X_add_number
== v
? ~ (offsetT
) 0 : 0;
1823 resultP
->X_add_number
=
1824 resultP
->X_add_number
!= v
? ~ (offsetT
) 0 : 0;
1827 resultP
->X_add_number
=
1828 resultP
->X_add_number
< v
? ~ (offsetT
) 0 : 0;
1831 resultP
->X_add_number
=
1832 resultP
->X_add_number
<= v
? ~ (offsetT
) 0 : 0;
1835 resultP
->X_add_number
=
1836 resultP
->X_add_number
>= v
? ~ (offsetT
) 0 : 0;
1839 resultP
->X_add_number
=
1840 resultP
->X_add_number
> v
? ~ (offsetT
) 0 : 0;
1843 resultP
->X_add_number
= resultP
->X_add_number
&& v
;
1846 resultP
->X_add_number
= resultP
->X_add_number
|| v
;
1850 else if (resultP
->X_op
== O_symbol
1851 && right
.X_op
== O_symbol
1852 && (op_left
== O_add
1853 || op_left
== O_subtract
1854 || (resultP
->X_add_number
== 0
1855 && right
.X_add_number
== 0)))
1857 /* Symbol OP symbol. */
1858 resultP
->X_op
= op_left
;
1859 resultP
->X_op_symbol
= right
.X_add_symbol
;
1860 if (op_left
== O_add
)
1861 resultP
->X_add_number
+= right
.X_add_number
;
1862 else if (op_left
== O_subtract
)
1864 resultP
->X_add_number
-= right
.X_add_number
;
1865 if (retval
== rightseg
&& SEG_NORMAL (retval
))
1867 retval
= absolute_section
;
1868 rightseg
= absolute_section
;
1874 /* The general case. */
1875 resultP
->X_add_symbol
= make_expr_symbol (resultP
);
1876 resultP
->X_op_symbol
= make_expr_symbol (&right
);
1877 resultP
->X_op
= op_left
;
1878 resultP
->X_add_number
= 0;
1879 resultP
->X_unsigned
= 1;
1882 if (retval
!= rightseg
)
1884 if (! SEG_NORMAL (retval
))
1886 if (retval
!= undefined_section
|| SEG_NORMAL (rightseg
))
1889 else if (SEG_NORMAL (rightseg
)
1891 && op_left
!= O_subtract
1894 as_bad (_("operation combines symbols in different segments"));
1898 } /* While next operator is >= this rank. */
1900 /* The PA port needs this information. */
1901 if (resultP
->X_add_symbol
)
1902 symbol_mark_used (resultP
->X_add_symbol
);
1904 if (rank
== 0 && mode
== expr_evaluate
)
1905 resolve_expression (resultP
);
1907 return resultP
->X_op
== O_constant
? absolute_section
: retval
;
1910 /* Resolve an expression without changing any symbols/sub-expressions
1914 resolve_expression (expressionS
*expressionP
)
1916 /* Help out with CSE. */
1917 valueT final_val
= expressionP
->X_add_number
;
1918 symbolS
*add_symbol
= expressionP
->X_add_symbol
;
1919 symbolS
*op_symbol
= expressionP
->X_op_symbol
;
1920 operatorT op
= expressionP
->X_op
;
1922 segT seg_left
, seg_right
;
1923 fragS
*frag_left
, *frag_right
;
1938 if (!snapshot_symbol (&add_symbol
, &left
, &seg_left
, &frag_left
))
1946 if (!snapshot_symbol (&add_symbol
, &left
, &seg_left
, &frag_left
))
1949 if (seg_left
!= absolute_section
)
1952 if (op
== O_logical_not
)
1954 else if (op
== O_uminus
)
1966 case O_bit_inclusive_or
:
1968 case O_bit_exclusive_or
:
1980 if (!snapshot_symbol (&add_symbol
, &left
, &seg_left
, &frag_left
)
1981 || !snapshot_symbol (&op_symbol
, &right
, &seg_right
, &frag_right
))
1984 /* Simplify addition or subtraction of a constant by folding the
1985 constant into X_add_number. */
1988 if (seg_right
== absolute_section
)
1994 else if (seg_left
== absolute_section
)
1998 seg_left
= seg_right
;
1999 add_symbol
= op_symbol
;
2004 else if (op
== O_subtract
)
2006 if (seg_right
== absolute_section
)
2014 /* Equality and non-equality tests are permitted on anything.
2015 Subtraction, and other comparison operators are permitted if
2016 both operands are in the same section.
2017 Shifts by constant zero are permitted on anything.
2018 Multiplies, bit-ors, and bit-ands with constant zero are
2019 permitted on anything.
2020 Multiplies and divides by constant one are permitted on
2022 Binary operations with both operands being the same register
2023 or undefined symbol are permitted if the result doesn't depend
2025 Otherwise, both operands must be absolute. We already handled
2026 the case of addition or subtraction of a constant above. */
2028 if (!(seg_left
== absolute_section
2029 && seg_right
== absolute_section
)
2030 && !(op
== O_eq
|| op
== O_ne
)
2031 && !((op
== O_subtract
2032 || op
== O_lt
|| op
== O_le
|| op
== O_ge
|| op
== O_gt
)
2033 && seg_left
== seg_right
2035 || frag_offset_fixed_p (frag_left
, frag_right
, &frag_off
))
2036 && (seg_left
!= reg_section
|| left
== right
)
2037 && (seg_left
!= undefined_section
|| add_symbol
== op_symbol
)))
2039 if ((seg_left
== absolute_section
&& left
== 0)
2040 || (seg_right
== absolute_section
&& right
== 0))
2042 if (op
== O_bit_exclusive_or
|| op
== O_bit_inclusive_or
)
2044 if (seg_right
!= absolute_section
|| right
!= 0)
2046 seg_left
= seg_right
;
2048 add_symbol
= op_symbol
;
2053 else if (op
== O_left_shift
|| op
== O_right_shift
)
2055 if (seg_left
!= absolute_section
|| left
!= 0)
2061 else if (op
!= O_multiply
2062 && op
!= O_bit_or_not
&& op
!= O_bit_and
)
2065 else if (op
== O_multiply
2066 && seg_left
== absolute_section
&& left
== 1)
2068 seg_left
= seg_right
;
2070 add_symbol
= op_symbol
;
2074 else if ((op
== O_multiply
|| op
== O_divide
)
2075 && seg_right
== absolute_section
&& right
== 1)
2080 else if (left
!= right
2081 || ((seg_left
!= reg_section
|| seg_right
!= reg_section
)
2082 && (seg_left
!= undefined_section
2083 || seg_right
!= undefined_section
2084 || add_symbol
!= op_symbol
)))
2086 else if (op
== O_bit_and
|| op
== O_bit_inclusive_or
)
2091 else if (op
!= O_bit_exclusive_or
&& op
!= O_bit_or_not
)
2095 right
+= frag_off
/ OCTETS_PER_BYTE
;
2098 case O_add
: left
+= right
; break;
2099 case O_subtract
: left
-= right
; break;
2100 case O_multiply
: left
*= right
; break;
2104 left
= (offsetT
) left
/ (offsetT
) right
;
2109 left
= (offsetT
) left
% (offsetT
) right
;
2111 case O_left_shift
: left
<<= right
; break;
2112 case O_right_shift
: left
>>= right
; break;
2113 case O_bit_inclusive_or
: left
|= right
; break;
2114 case O_bit_or_not
: left
|= ~right
; break;
2115 case O_bit_exclusive_or
: left
^= right
; break;
2116 case O_bit_and
: left
&= right
; break;
2119 left
= (left
== right
2120 && seg_left
== seg_right
2121 && (finalize_syms
|| frag_left
== frag_right
)
2122 && (seg_left
!= undefined_section
2123 || add_symbol
== op_symbol
)
2124 ? ~ (valueT
) 0 : 0);
2129 left
= (offsetT
) left
< (offsetT
) right
? ~ (valueT
) 0 : 0;
2132 left
= (offsetT
) left
<= (offsetT
) right
? ~ (valueT
) 0 : 0;
2135 left
= (offsetT
) left
>= (offsetT
) right
? ~ (valueT
) 0 : 0;
2138 left
= (offsetT
) left
> (offsetT
) right
? ~ (valueT
) 0 : 0;
2140 case O_logical_and
: left
= left
&& right
; break;
2141 case O_logical_or
: left
= left
|| right
; break;
2151 if (seg_left
== absolute_section
)
2153 else if (seg_left
== reg_section
&& final_val
== 0)
2155 else if (add_symbol
!= expressionP
->X_add_symbol
)
2157 expressionP
->X_add_symbol
= add_symbol
;
2159 expressionP
->X_op
= op
;
2161 if (op
== O_constant
|| op
== O_register
)
2163 expressionP
->X_add_number
= final_val
;
2168 /* This lives here because it belongs equally in expr.c & read.c.
2169 expr.c is just a branch office read.c anyway, and putting it
2170 here lessens the crowd at read.c.
2172 Assume input_line_pointer is at start of symbol name.
2173 Advance input_line_pointer past symbol name.
2174 Turn that character into a '\0', returning its former value.
2175 This allows a string compare (RMS wants symbol names to be strings)
2177 There will always be a char following symbol name, because all good
2178 lines end in end-of-line. */
2181 get_symbol_end (void)
2185 /* We accept \001 in a name in case this is being called with a
2186 constructed string. */
2187 if (is_name_beginner (c
= *input_line_pointer
++) || c
== '\001')
2189 while (is_part_of_name (c
= *input_line_pointer
++)
2192 if (is_name_ender (c
))
2193 c
= *input_line_pointer
++;
2195 *--input_line_pointer
= 0;
2200 get_single_number (void)
2203 operand (&exp
, expr_normal
);
2204 return exp
.X_add_number
;