1 /* expr.c -operands, expressions-
2 Copyright (C) 1987, 1990, 1991, 1992, 1993 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 2, 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
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
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.
34 static void clean_up_expression
PARAMS ((expressionS
* expressionP
));
35 static symbolS
*make_expr_symbol
PARAMS ((expressionS
* expressionP
));
37 extern const char EXP_CHARS
[], FLT_CHARS
[];
39 /* Build a dummy symbol to hold a complex expression. This is how we
40 build expressions up out of other expressions. The symbol is put
41 into the fake section expr_section. */
44 make_expr_symbol (expressionP
)
45 expressionS
*expressionP
;
50 /* FIXME: This should be something which decode_local_label_name
52 #ifdef DOT_LABEL_PREFIX
57 /* Putting constant symbols in absolute_section rather than
58 expr_section is convenient for the old a.out code, for which
59 S_GET_SEGMENT does not always retrieve the value put in by
61 symbolP
= symbol_new (fake
,
62 (expressionP
->X_op
== O_constant
65 0, &zero_address_frag
);
66 symbolP
->sy_value
= *expressionP
;
71 * Build any floating-point literal here.
72 * Also build any bignum literal here.
75 /* Seems atof_machine can backscan through generic_bignum and hit whatever
76 happens to be loaded before it in memory. And its way too complicated
77 for me to fix right. Thus a hack. JF: Just make generic_bignum bigger,
78 and never write into the early words, thus they'll always be zero.
79 I hate Dean's floating-point code. Bleh. */
80 LITTLENUM_TYPE generic_bignum
[SIZE_OF_LARGE_NUMBER
+ 6];
81 FLONUM_TYPE generic_floating_point_number
=
83 &generic_bignum
[6], /* low (JF: Was 0) */
84 &generic_bignum
[SIZE_OF_LARGE_NUMBER
+ 6 - 1], /* high JF: (added +6) */
89 /* If nonzero, we've been asked to assemble nan, +inf or -inf */
90 int generic_floating_point_magic
;
93 floating_constant (expressionP
)
94 expressionS
*expressionP
;
96 /* input_line_pointer->*/
97 /* floating-point constant. */
100 error_code
= atof_generic
101 (&input_line_pointer
, ".", EXP_CHARS
,
102 &generic_floating_point_number
);
106 if (error_code
== ERROR_EXPONENT_OVERFLOW
)
108 as_bad ("bad floating-point constant: exponent overflow, probably assembling junk");
112 as_bad ("bad floating-point constant: unknown error code=%d.", error_code
);
115 expressionP
->X_op
= O_big
;
116 /* input_line_pointer->just after constant, */
117 /* which may point to whitespace. */
118 expressionP
->X_add_number
= -1;
122 integer_constant (radix
, expressionP
)
124 expressionS
*expressionP
;
126 char *digit_2
; /*->2nd digit of number. */
129 valueT number
; /* offset or (absolute) value */
130 short int digit
; /* value of next digit in current radix */
131 short int maxdig
= 0;/* highest permitted digit value. */
132 int too_many_digits
= 0; /* if we see >= this number of */
133 char *name
; /* points to name of symbol */
134 symbolS
*symbolP
; /* points to symbol */
136 int small
; /* true if fits in 32 bits. */
137 extern const char hex_value
[]; /* in hex_value.c */
139 /* May be bignum, or may fit in 32 bits. */
140 /* Most numbers fit into 32 bits, and we want this case to be fast.
141 so we pretend it will fit into 32 bits. If, after making up a 32
142 bit number, we realise that we have scanned more digits than
143 comfortably fit into 32 bits, we re-scan the digits coding them
144 into a bignum. For decimal and octal numbers we are
145 conservative: Some numbers may be assumed bignums when in fact
146 they do fit into 32 bits. Numbers of any radix can have excess
147 leading zeros: We strive to recognise this and cast them back
148 into 32 bits. We must check that the bignum really is more than
149 32 bits, and change it back to a 32-bit number if it fits. The
150 number we are looking for is expected to be positive, but if it
151 fits into 32 bits as an unsigned number, we let it be a 32-bit
152 number. The cavalier approach is for speed in ordinary cases. */
153 /* This has been extended for 64 bits. We blindly assume that if
154 you're compiling in 64-bit mode, the target is a 64-bit machine.
155 This should be cleaned up. */
159 #else /* includes non-bfd case, mostly */
167 too_many_digits
= valuesize
+ 1;
171 too_many_digits
= (valuesize
+ 2) / 3;
175 too_many_digits
= (valuesize
+ 3) / 4;
179 too_many_digits
= (valuesize
+ 12) / 4; /* very rough */
182 c
= *input_line_pointer
;
183 input_line_pointer
++;
184 digit_2
= input_line_pointer
;
186 (digit
= hex_value
[(unsigned char) c
]) < maxdig
;
187 c
= *input_line_pointer
++)
189 number
= number
* radix
+ digit
;
191 /* c contains character after number. */
192 /* input_line_pointer->char after c. */
193 small
= input_line_pointer
- digit_2
< too_many_digits
;
197 * we saw a lot of digits. manufacture a bignum the hard way.
199 LITTLENUM_TYPE
*leader
; /*->high order littlenum of the bignum. */
200 LITTLENUM_TYPE
*pointer
; /*->littlenum we are frobbing now. */
203 leader
= generic_bignum
;
204 generic_bignum
[0] = 0;
205 generic_bignum
[1] = 0;
206 /* we could just use digit_2, but lets be mnemonic. */
207 input_line_pointer
= --digit_2
; /*->1st digit. */
208 c
= *input_line_pointer
++;
210 (carry
= hex_value
[(unsigned char) c
]) < maxdig
;
211 c
= *input_line_pointer
++)
213 for (pointer
= generic_bignum
;
219 work
= carry
+ radix
* *pointer
;
220 *pointer
= work
& LITTLENUM_MASK
;
221 carry
= work
>> LITTLENUM_NUMBER_OF_BITS
;
225 if (leader
< generic_bignum
+ SIZE_OF_LARGE_NUMBER
- 1)
226 { /* room to grow a longer bignum. */
231 /* again, c is char after number, */
232 /* input_line_pointer->after c. */
233 know (sizeof (int) * 8 == 32);
234 know (LITTLENUM_NUMBER_OF_BITS
== 16);
235 /* hence the constant "2" in the next line. */
236 if (leader
< generic_bignum
+ 2)
237 { /* will fit into 32 bits. */
239 ((generic_bignum
[1] & LITTLENUM_MASK
) << LITTLENUM_NUMBER_OF_BITS
)
240 | (generic_bignum
[0] & LITTLENUM_MASK
);
245 number
= leader
- generic_bignum
+ 1; /* number of littlenums in the bignum. */
251 * here with number, in correct radix. c is the next char.
252 * note that unlike un*x, we allow "011f" "0x9f" to
253 * both mean the same as the (conventional) "9f". this is simply easier
254 * than checking for strict canonical form. syntax sux!
260 #ifdef LOCAL_LABELS_FB
264 * backward ref to local label.
265 * because it is backward, expect it to be defined.
267 /* Construct a local label. */
268 name
= fb_label_name ((int) number
, 0);
270 /* seen before, or symbol is defined: ok */
271 symbolP
= symbol_find (name
);
272 if ((symbolP
!= NULL
) && (S_IS_DEFINED (symbolP
)))
275 /* local labels are never absolute. don't waste time
276 checking absoluteness. */
277 know (SEG_NORMAL (S_GET_SEGMENT (symbolP
)));
279 expressionP
->X_op
= O_symbol
;
280 expressionP
->X_add_symbol
= symbolP
;
285 /* either not seen or not defined. */
286 /* @@ Should print out the original string instead of
287 the parsed number. */
288 as_bad ("backw. ref to unknown label \"%d:\", 0 assumed.",
290 expressionP
->X_op
= O_constant
;
293 expressionP
->X_add_number
= 0;
300 * forward reference. expect symbol to be undefined or
301 * unknown. undefined: seen it before. unknown: never seen
303 * construct a local label name, then an undefined symbol.
304 * don't create a xseg frag for it: caller may do that.
305 * just return it as never seen before.
307 name
= fb_label_name ((int) number
, 1);
308 symbolP
= symbol_find_or_make (name
);
309 /* we have no need to check symbol properties. */
310 #ifndef many_segments
311 /* since "know" puts its arg into a "string", we
312 can't have newlines in the argument. */
313 know (S_GET_SEGMENT (symbolP
) == undefined_section
|| S_GET_SEGMENT (symbolP
) == text_section
|| S_GET_SEGMENT (symbolP
) == data_section
);
315 expressionP
->X_op
= O_symbol
;
316 expressionP
->X_add_symbol
= symbolP
;
317 expressionP
->X_add_number
= 0;
322 #endif /* LOCAL_LABELS_FB */
324 #ifdef LOCAL_LABELS_DOLLAR
329 /* If the dollar label is *currently* defined, then this is just
330 another reference to it. If it is not *currently* defined,
331 then this is a fresh instantiation of that number, so create
334 if (dollar_label_defined (number
))
336 name
= dollar_label_name (number
, 0);
337 symbolP
= symbol_find (name
);
338 know (symbolP
!= NULL
);
342 name
= dollar_label_name (number
, 1);
343 symbolP
= symbol_find_or_make (name
);
346 expressionP
->X_op
= O_symbol
;
347 expressionP
->X_add_symbol
= symbolP
;
348 expressionP
->X_add_number
= 0;
353 #endif /* LOCAL_LABELS_DOLLAR */
357 expressionP
->X_op
= O_constant
;
358 expressionP
->X_add_number
= number
;
359 input_line_pointer
--; /* restore following character. */
361 } /* really just a number */
363 } /* switch on char following the number */
369 /* not a small number */
370 expressionP
->X_op
= O_big
;
371 expressionP
->X_add_number
= number
;
372 input_line_pointer
--; /*->char following number. */
374 } /* integer_constant() */
378 * Summary of operand().
380 * in: Input_line_pointer points to 1st char of operand, which may
383 * out: A expressionS.
384 * The operand may have been empty: in this case X_op == O_absent.
385 * Input_line_pointer->(next non-blank) char after operand.
389 operand (expressionP
)
390 expressionS
*expressionP
;
393 symbolS
*symbolP
; /* points to symbol */
394 char *name
; /* points to name of symbol */
397 /* digits, assume it is a bignum. */
399 SKIP_WHITESPACE (); /* leading whitespace is part of operand. */
400 c
= *input_line_pointer
++; /* input_line_pointer->past char in c. */
406 integer_constant (2, expressionP
);
409 integer_constant (8, expressionP
);
412 integer_constant (16, expressionP
);
424 input_line_pointer
--;
426 integer_constant (10, expressionP
);
430 /* non-decimal radix */
432 c
= *input_line_pointer
;
437 if (c
&& strchr (FLT_CHARS
, c
))
439 input_line_pointer
++;
440 floating_constant (expressionP
);
444 /* The string was only zero */
445 expressionP
->X_op
= O_constant
;
446 expressionP
->X_add_number
= 0;
453 input_line_pointer
++;
454 integer_constant (16, expressionP
);
458 #ifdef LOCAL_LABELS_FB
459 /* FIXME: This seems to be nonsense. At this point we know
460 for sure that *input_line_pointer is 'b'. So why are we
461 checking it? What is this code supposed to do? */
462 if (!*input_line_pointer
463 || (!strchr ("+-.0123456789", *input_line_pointer
)
464 && !strchr (EXP_CHARS
, *input_line_pointer
)))
466 input_line_pointer
--;
467 integer_constant (10, expressionP
);
472 input_line_pointer
++;
473 integer_constant (2, expressionP
);
484 integer_constant (8, expressionP
);
488 #ifdef LOCAL_LABELS_FB
489 /* if it says '0f' and the line ends or it doesn't look like
490 a floating point #, its a local label ref. dtrt */
491 /* likewise for the b's. xoxorich. */
492 /* FIXME: As in the 'b' case, we know that the
493 *input_line_pointer is 'f'. What is this code really
496 && (!*input_line_pointer
||
497 (!strchr ("+-.0123456789", *input_line_pointer
) &&
498 !strchr (EXP_CHARS
, *input_line_pointer
))))
500 input_line_pointer
-= 1;
501 integer_constant (10, expressionP
);
515 input_line_pointer
++;
516 floating_constant (expressionP
);
517 expressionP
->X_add_number
= -(isupper (c
) ? tolower (c
) : c
);
520 #ifdef LOCAL_LABELS_DOLLAR
522 integer_constant (10, expressionP
);
530 /* didn't begin with digit & not a name */
531 segment
= expression (expressionP
);
532 /* Expression() will pass trailing whitespace */
533 if (*input_line_pointer
++ != ')')
535 as_bad ("Missing ')' assumed");
536 input_line_pointer
--;
538 /* here with input_line_pointer->char after "(...)" */
542 /* Warning: to conform to other people's assemblers NO ESCAPEMENT is
543 permitted for a single quote. The next character, parity errors and
544 all, is taken as the value of the operand. VERY KINKY. */
545 expressionP
->X_op
= O_constant
;
546 expressionP
->X_add_number
= *input_line_pointer
++;
550 (void) operand (expressionP
);
556 operand (expressionP
);
557 if (expressionP
->X_op
== O_constant
)
559 /* input_line_pointer -> char after operand */
562 expressionP
->X_add_number
= - expressionP
->X_add_number
;
563 /* Notice: '-' may overflow: no warning is given. This is
564 compatible with other people's assemblers. Sigh. */
567 expressionP
->X_add_number
= ~ expressionP
->X_add_number
;
569 else if (expressionP
->X_op
!= O_illegal
570 && expressionP
->X_op
!= O_absent
)
572 expressionP
->X_add_symbol
= make_expr_symbol (expressionP
);
574 expressionP
->X_op
= O_uminus
;
576 expressionP
->X_op
= O_bit_not
;
577 expressionP
->X_add_number
= 0;
580 as_warn ("Unary operator %c ignored because bad operand follows",
586 if (!is_part_of_name (*input_line_pointer
))
590 /* JF: '.' is pseudo symbol with value of current location
591 in current segment. */
592 #ifdef DOT_LABEL_PREFIX
597 symbolP
= symbol_new (fake
,
599 (valueT
) frag_now_fix (),
602 expressionP
->X_op
= O_symbol
;
603 expressionP
->X_add_symbol
= symbolP
;
604 expressionP
->X_add_number
= 0;
615 /* can't imagine any other kind of operand */
616 expressionP
->X_op
= O_absent
;
617 input_line_pointer
--;
618 md_operand (expressionP
);
622 if (is_end_of_line
[(unsigned char) c
])
624 if (is_name_beginner (c
)) /* here if did not begin with a digit */
627 * Identifier begins here.
628 * This is kludged for speed, so code is repeated.
631 name
= --input_line_pointer
;
632 c
= get_symbol_end ();
633 symbolP
= symbol_find_or_make (name
);
635 /* If we have an absolute symbol or a reg, then we know its
637 segment
= S_GET_SEGMENT (symbolP
);
638 if (segment
== absolute_section
)
640 expressionP
->X_op
= O_constant
;
641 expressionP
->X_add_number
= S_GET_VALUE (symbolP
);
643 else if (segment
== reg_section
)
645 expressionP
->X_op
= O_register
;
646 expressionP
->X_add_number
= S_GET_VALUE (symbolP
);
650 expressionP
->X_op
= O_symbol
;
651 expressionP
->X_add_symbol
= symbolP
;
652 expressionP
->X_add_number
= 0;
654 *input_line_pointer
= c
;
658 as_bad ("Bad expression");
659 expressionP
->X_op
= O_constant
;
660 expressionP
->X_add_number
= 0;
665 * It is more 'efficient' to clean up the expressionS when they are created.
666 * Doing it here saves lines of code.
668 clean_up_expression (expressionP
);
669 SKIP_WHITESPACE (); /*->1st char after operand. */
670 know (*input_line_pointer
!= ' ');
672 switch (expressionP
->X_op
)
675 return absolute_section
;
677 return S_GET_SEGMENT (expressionP
->X_add_symbol
);
683 /* Internal. Simplify a struct expression for use by expr() */
686 * In: address of a expressionS.
687 * The X_op field of the expressionS may only take certain values.
688 * Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
689 * Out: expressionS may have been modified:
690 * 'foo-foo' symbol references cancelled to 0,
691 * which changes X_op from O_subtract to O_constant.
692 * Unused fields zeroed to help expr().
696 clean_up_expression (expressionP
)
697 expressionS
*expressionP
;
699 switch (expressionP
->X_op
)
703 expressionP
->X_add_number
= 0;
708 expressionP
->X_add_symbol
= NULL
;
713 expressionP
->X_op_symbol
= NULL
;
716 if (expressionP
->X_op_symbol
== expressionP
->X_add_symbol
717 || ((expressionP
->X_op_symbol
->sy_frag
718 == expressionP
->X_add_symbol
->sy_frag
)
719 && SEG_NORMAL (S_GET_SEGMENT (expressionP
->X_add_symbol
))
720 && (S_GET_VALUE (expressionP
->X_op_symbol
)
721 == S_GET_VALUE (expressionP
->X_add_symbol
))))
723 expressionP
->X_op
= O_constant
;
724 expressionP
->X_add_symbol
= NULL
;
725 expressionP
->X_op_symbol
= NULL
;
733 /* Expression parser. */
736 * We allow an empty expression, and just assume (absolute,0) silently.
737 * Unary operators and parenthetical expressions are treated as operands.
738 * As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
740 * We used to do a aho/ullman shift-reduce parser, but the logic got so
741 * warped that I flushed it and wrote a recursive-descent parser instead.
742 * Now things are stable, would anybody like to write a fast parser?
743 * Most expressions are either register (which does not even reach here)
744 * or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
745 * So I guess it doesn't really matter how inefficient more complex expressions
748 * After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
749 * Also, we have consumed any leading or trailing spaces (operand does that)
750 * and done all intervening operators.
752 * This returns the segment of the result, which will be
753 * absolute_section or the segment of a symbol.
759 static const operatorT op_encoding
[256] =
760 { /* maps ASCII->operators */
762 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
763 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
765 __
, O_bit_or_not
, __
, __
, __
, O_modulus
, O_bit_and
, __
,
766 __
, __
, O_multiply
, O_add
, __
, O_subtract
, __
, O_divide
,
767 __
, __
, __
, __
, __
, __
, __
, __
,
768 __
, __
, __
, __
, O_left_shift
, __
, O_right_shift
, __
,
769 __
, __
, __
, __
, __
, __
, __
, __
,
770 __
, __
, __
, __
, __
, __
, __
, __
,
771 __
, __
, __
, __
, __
, __
, __
, __
,
772 __
, __
, __
, __
, __
, __
, O_bit_exclusive_or
, __
,
773 __
, __
, __
, __
, __
, __
, __
, __
,
774 __
, __
, __
, __
, __
, __
, __
, __
,
775 __
, __
, __
, __
, __
, __
, __
, __
,
776 __
, __
, __
, __
, O_bit_inclusive_or
, __
, __
, __
,
778 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
779 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
780 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
781 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
782 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
783 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
784 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
,
785 __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
, __
791 * 0 operand, (expression)
797 static const operator_rankT op_rank
[] =
810 3, /* O_left_shift */
811 3, /* O_right_shift */
812 2, /* O_bit_inclusive_or */
813 2, /* O_bit_or_not */
814 2, /* O_bit_exclusive_or */
822 operator_rankT rank
; /* Larger # is higher rank. */
823 expressionS
*resultP
; /* Deliver result here. */
828 char c_left
; /* 1st operator character. */
834 retval
= operand (resultP
);
836 know (*input_line_pointer
!= ' '); /* Operand() gobbles spaces. */
838 c_left
= *input_line_pointer
; /* Potential operator character. */
839 op_left
= op_encoding
[(unsigned char) c_left
];
840 while (op_left
!= O_illegal
&& op_rank
[(int) op_left
] > rank
)
844 input_line_pointer
++; /*->after 1st character of operator. */
845 /* Operators "<<" and ">>" have 2 characters. */
846 if (*input_line_pointer
== c_left
&& (c_left
== '<' || c_left
== '>'))
847 ++input_line_pointer
;
849 rightseg
= expr (op_rank
[(int) op_left
], &right
);
850 if (right
.X_op
== O_absent
)
852 as_warn ("missing operand; zero assumed");
853 right
.X_op
= O_constant
;
854 right
.X_add_number
= 0;
855 resultP
->X_add_symbol
= NULL
;
856 resultP
->X_op_symbol
= NULL
;
859 know (*input_line_pointer
!= ' ');
861 if (retval
== undefined_section
)
863 if (SEG_NORMAL (rightseg
))
866 else if (! SEG_NORMAL (retval
))
868 else if (SEG_NORMAL (rightseg
)
869 && retval
!= rightseg
)
870 as_bad ("operation combines symbols in different segments");
872 c_right
= *input_line_pointer
;
873 op_right
= op_encoding
[(unsigned char) c_right
];
874 if (*input_line_pointer
== c_right
&& (c_right
== '<' || c_right
== '>'))
875 ++input_line_pointer
;
877 know (op_right
== O_illegal
|| op_rank
[(int) op_right
] <= op_rank
[(int) op_left
]);
878 know ((int) op_left
>= (int) O_multiply
&& (int) op_left
<= (int) O_subtract
);
880 /* input_line_pointer->after right-hand quantity. */
881 /* left-hand quantity in resultP */
882 /* right-hand quantity in right. */
883 /* operator in op_left. */
885 if (resultP
->X_op
== O_big
)
887 as_warn ("left operand of %c is a %s; integer 0 assumed",
888 c_left
, resultP
->X_add_number
> 0 ? "bignum" : "float");
889 resultP
->X_op
= O_constant
;
890 resultP
->X_add_number
= 0;
891 resultP
->X_add_symbol
= NULL
;
892 resultP
->X_op_symbol
= NULL
;
894 if (right
.X_op
== O_big
)
896 as_warn ("right operand of %c is a %s; integer 0 assumed",
897 c_left
, right
.X_add_number
> 0 ? "bignum" : "float");
898 right
.X_op
= O_constant
;
899 right
.X_add_number
= 0;
900 right
.X_add_symbol
= NULL
;
901 right
.X_op_symbol
= NULL
;
904 /* Optimize common cases. */
905 if (op_left
== O_add
&& right
.X_op
== O_constant
)
908 resultP
->X_add_number
+= right
.X_add_number
;
910 else if (op_left
== O_subtract
&& right
.X_op
== O_constant
)
913 resultP
->X_add_number
-= right
.X_add_number
;
915 else if (op_left
== O_add
&& resultP
->X_op
== O_constant
)
918 resultP
->X_op
= right
.X_op
;
919 resultP
->X_add_symbol
= right
.X_add_symbol
;
920 resultP
->X_op_symbol
= right
.X_op_symbol
;
921 resultP
->X_add_number
+= right
.X_add_number
;
924 else if (resultP
->X_op
== O_constant
&& right
.X_op
== O_constant
)
926 /* Constant OP constant. */
927 offsetT v
= right
.X_add_number
;
928 if (v
== 0 && (op_left
== O_divide
|| op_left
== O_modulus
))
930 as_warn ("division by zero");
935 case O_multiply
: resultP
->X_add_number
*= v
; break;
936 case O_divide
: resultP
->X_add_number
/= v
; break;
937 case O_modulus
: resultP
->X_add_number
%= v
; break;
938 case O_left_shift
: resultP
->X_add_number
<<= v
; break;
939 case O_right_shift
: resultP
->X_add_number
>>= v
; break;
940 case O_bit_inclusive_or
: resultP
->X_add_number
|= v
; break;
941 case O_bit_or_not
: resultP
->X_add_number
|= ~v
; break;
942 case O_bit_exclusive_or
: resultP
->X_add_number
^= v
; break;
943 case O_bit_and
: resultP
->X_add_number
&= v
; break;
944 case O_add
: resultP
->X_add_number
+= v
; break;
945 case O_subtract
: resultP
->X_add_number
-= v
; break;
949 else if (resultP
->X_op
== O_symbol
950 && right
.X_op
== O_symbol
952 || op_left
== O_subtract
953 || (resultP
->X_add_number
== 0
954 && right
.X_add_number
== 0)))
956 /* Symbol OP symbol. */
957 resultP
->X_op
= op_left
;
958 resultP
->X_op_symbol
= right
.X_add_symbol
;
959 if (op_left
== O_add
)
960 resultP
->X_add_number
+= right
.X_add_number
;
961 else if (op_left
== O_subtract
)
962 resultP
->X_add_number
-= right
.X_add_number
;
966 /* The general case. */
967 resultP
->X_add_symbol
= make_expr_symbol (resultP
);
968 resultP
->X_op_symbol
= make_expr_symbol (&right
);
969 resultP
->X_op
= op_left
;
970 resultP
->X_add_number
= 0;
974 } /* While next operator is >= this rank. */
976 return resultP
->X_op
== O_constant
? absolute_section
: retval
;
982 * This lives here because it belongs equally in expr.c & read.c.
983 * Expr.c is just a branch office read.c anyway, and putting it
984 * here lessens the crowd at read.c.
986 * Assume input_line_pointer is at start of symbol name.
987 * Advance input_line_pointer past symbol name.
988 * Turn that character into a '\0', returning its former value.
989 * This allows a string compare (RMS wants symbol names to be strings)
990 * of the symbol name.
991 * There will always be a char following symbol name, because all good
992 * lines end in end-of-line.
999 while (is_part_of_name (c
= *input_line_pointer
++))
1001 *--input_line_pointer
= 0;
1007 get_single_number ()
1011 return exp
.X_add_number
;