Add MN10300 linker relaxation support for symbol differences
[deliverable/binutils-gdb.git] / gas / expr.c
CommitLineData
252b5132 1/* expr.c -operands, expressions-
f7e42eb4 2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
db557034 3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
252b5132
RH
4 Free Software Foundation, Inc.
5
6 This file is part of GAS, the GNU Assembler.
7
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
ec2655a6 10 the Free Software Foundation; either version 3, or (at your option)
252b5132
RH
11 any later version.
12
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.
17
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
4b4da160
NC
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
252b5132 22
929b12bc
KH
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. */
252b5132 27
252b5132
RH
28#define min(a, b) ((a) < (b) ? (a) : (b))
29
30#include "as.h"
3882b010 31#include "safe-ctype.h"
252b5132
RH
32#include "obstack.h"
33
dd625418
KH
34static void floating_constant (expressionS * expressionP);
35static valueT generic_bignum_to_int32 (void);
6d4d30bb 36#ifdef BFD64
dd625418 37static valueT generic_bignum_to_int64 (void);
6d4d30bb 38#endif
dd625418
KH
39static void integer_constant (int radix, expressionS * expressionP);
40static void mri_char_constant (expressionS *);
41static void current_location (expressionS *);
42static void clean_up_expression (expressionS * expressionP);
9497f5ac 43static segT operand (expressionS *, enum expr_mode);
dd625418 44static operatorT operator (int *);
252b5132
RH
45
46extern const char EXP_CHARS[], FLT_CHARS[];
47
48/* We keep a mapping of expression symbols to file positions, so that
49 we can provide better error messages. */
50
e6c774b4 51struct expr_symbol_line {
252b5132
RH
52 struct expr_symbol_line *next;
53 symbolS *sym;
54 char *file;
55 unsigned int line;
56};
57
58static struct expr_symbol_line *expr_symbol_lines;
59\f
60/* Build a dummy symbol to hold a complex expression. This is how we
61 build expressions up out of other expressions. The symbol is put
62 into the fake section expr_section. */
63
64symbolS *
dd625418 65make_expr_symbol (expressionS *expressionP)
252b5132
RH
66{
67 expressionS zero;
252b5132
RH
68 symbolS *symbolP;
69 struct expr_symbol_line *n;
70
71 if (expressionP->X_op == O_symbol
72 && expressionP->X_add_number == 0)
73 return expressionP->X_add_symbol;
74
75 if (expressionP->X_op == O_big)
76 {
77 /* This won't work, because the actual value is stored in
02000999
AM
78 generic_floating_point_number or generic_bignum, and we are
79 going to lose it if we haven't already. */
252b5132 80 if (expressionP->X_add_number > 0)
0e389e77 81 as_bad (_("bignum invalid"));
252b5132 82 else
0e389e77 83 as_bad (_("floating point number invalid"));
252b5132
RH
84 zero.X_op = O_constant;
85 zero.X_add_number = 0;
86 zero.X_unsigned = 0;
87 clean_up_expression (&zero);
88 expressionP = &zero;
89 }
90
252b5132
RH
91 /* Putting constant symbols in absolute_section rather than
92 expr_section is convenient for the old a.out code, for which
93 S_GET_SEGMENT does not always retrieve the value put in by
94 S_SET_SEGMENT. */
756d1d01 95 symbolP = symbol_create (FAKE_LABEL_NAME,
252b5132
RH
96 (expressionP->X_op == O_constant
97 ? absolute_section
5a918ce7
JB
98 : expressionP->X_op == O_register
99 ? reg_section
100 : expr_section),
252b5132 101 0, &zero_address_frag);
49309057 102 symbol_set_value_expression (symbolP, expressionP);
252b5132
RH
103
104 if (expressionP->X_op == O_constant)
6386f3a7 105 resolve_symbol_value (symbolP);
252b5132
RH
106
107 n = (struct expr_symbol_line *) xmalloc (sizeof *n);
108 n->sym = symbolP;
109 as_where (&n->file, &n->line);
110 n->next = expr_symbol_lines;
111 expr_symbol_lines = n;
112
113 return symbolP;
114}
115
116/* Return the file and line number for an expr symbol. Return
117 non-zero if something was found, 0 if no information is known for
118 the symbol. */
119
120int
dd625418 121expr_symbol_where (symbolS *sym, char **pfile, unsigned int *pline)
252b5132
RH
122{
123 register struct expr_symbol_line *l;
124
125 for (l = expr_symbol_lines; l != NULL; l = l->next)
126 {
127 if (l->sym == sym)
128 {
129 *pfile = l->file;
130 *pline = l->line;
131 return 1;
132 }
133 }
134
135 return 0;
136}
137\f
138/* Utilities for building expressions.
139 Since complex expressions are recorded as symbols for use in other
140 expressions these return a symbolS * and not an expressionS *.
141 These explicitly do not take an "add_number" argument. */
142/* ??? For completeness' sake one might want expr_build_symbol.
143 It would just return its argument. */
144
145/* Build an expression for an unsigned constant.
146 The corresponding one for signed constants is missing because
147 there's currently no need for it. One could add an unsigned_p flag
148 but that seems more clumsy. */
149
150symbolS *
dd625418 151expr_build_uconstant (offsetT value)
252b5132
RH
152{
153 expressionS e;
154
155 e.X_op = O_constant;
156 e.X_add_number = value;
157 e.X_unsigned = 1;
158 return make_expr_symbol (&e);
159}
160
252b5132
RH
161/* Build an expression for the current location ('.'). */
162
163symbolS *
dd625418 164expr_build_dot (void)
252b5132
RH
165{
166 expressionS e;
167
168 current_location (&e);
169 return make_expr_symbol (&e);
170}
171\f
929b12bc
KH
172/* Build any floating-point literal here.
173 Also build any bignum literal here. */
252b5132
RH
174
175/* Seems atof_machine can backscan through generic_bignum and hit whatever
176 happens to be loaded before it in memory. And its way too complicated
177 for me to fix right. Thus a hack. JF: Just make generic_bignum bigger,
178 and never write into the early words, thus they'll always be zero.
179 I hate Dean's floating-point code. Bleh. */
180LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6];
e6c774b4
KH
181
182FLONUM_TYPE generic_floating_point_number = {
bc4466dc
KH
183 &generic_bignum[6], /* low. (JF: Was 0) */
184 &generic_bignum[SIZE_OF_LARGE_NUMBER + 6 - 1], /* high. JF: (added +6) */
185 0, /* leader. */
186 0, /* exponent. */
187 0 /* sign. */
252b5132 188};
929b12bc 189
252b5132
RH
190\f
191static void
dd625418 192floating_constant (expressionS *expressionP)
252b5132 193{
929b12bc 194 /* input_line_pointer -> floating-point constant. */
252b5132
RH
195 int error_code;
196
197 error_code = atof_generic (&input_line_pointer, ".", EXP_CHARS,
198 &generic_floating_point_number);
199
200 if (error_code)
201 {
202 if (error_code == ERROR_EXPONENT_OVERFLOW)
203 {
0e389e77 204 as_bad (_("bad floating-point constant: exponent overflow"));
252b5132
RH
205 }
206 else
207 {
0e389e77
AM
208 as_bad (_("bad floating-point constant: unknown error code=%d"),
209 error_code);
252b5132
RH
210 }
211 }
212 expressionP->X_op = O_big;
929b12bc
KH
213 /* input_line_pointer -> just after constant, which may point to
214 whitespace. */
252b5132
RH
215 expressionP->X_add_number = -1;
216}
217
929b12bc 218static valueT
dd625418 219generic_bignum_to_int32 (void)
252b5132
RH
220{
221 valueT number =
222 ((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
223 | (generic_bignum[0] & LITTLENUM_MASK);
224 number &= 0xffffffff;
225 return number;
226}
227
228#ifdef BFD64
929b12bc 229static valueT
dd625418 230generic_bignum_to_int64 (void)
252b5132 231{
929b12bc
KH
232 valueT number =
233 ((((((((valueT) generic_bignum[3] & LITTLENUM_MASK)
234 << LITTLENUM_NUMBER_OF_BITS)
235 | ((valueT) generic_bignum[2] & LITTLENUM_MASK))
236 << LITTLENUM_NUMBER_OF_BITS)
237 | ((valueT) generic_bignum[1] & LITTLENUM_MASK))
238 << LITTLENUM_NUMBER_OF_BITS)
239 | ((valueT) generic_bignum[0] & LITTLENUM_MASK));
252b5132
RH
240 return number;
241}
242#endif
243
244static void
dd625418 245integer_constant (int radix, expressionS *expressionP)
252b5132 246{
929b12bc 247 char *start; /* Start of number. */
252b5132
RH
248 char *suffix = NULL;
249 char c;
929b12bc
KH
250 valueT number; /* Offset or (absolute) value. */
251 short int digit; /* Value of next digit in current radix. */
252 short int maxdig = 0; /* Highest permitted digit value. */
253 int too_many_digits = 0; /* If we see >= this number of. */
254 char *name; /* Points to name of symbol. */
255 symbolS *symbolP; /* Points to symbol. */
252b5132 256
929b12bc 257 int small; /* True if fits in 32 bits. */
252b5132 258
929b12bc 259 /* May be bignum, or may fit in 32 bits. */
252b5132
RH
260 /* Most numbers fit into 32 bits, and we want this case to be fast.
261 so we pretend it will fit into 32 bits. If, after making up a 32
262 bit number, we realise that we have scanned more digits than
263 comfortably fit into 32 bits, we re-scan the digits coding them
264 into a bignum. For decimal and octal numbers we are
265 conservative: Some numbers may be assumed bignums when in fact
266 they do fit into 32 bits. Numbers of any radix can have excess
267 leading zeros: We strive to recognise this and cast them back
268 into 32 bits. We must check that the bignum really is more than
269 32 bits, and change it back to a 32-bit number if it fits. The
270 number we are looking for is expected to be positive, but if it
271 fits into 32 bits as an unsigned number, we let it be a 32-bit
929b12bc 272 number. The cavalier approach is for speed in ordinary cases. */
252b5132
RH
273 /* This has been extended for 64 bits. We blindly assume that if
274 you're compiling in 64-bit mode, the target is a 64-bit machine.
275 This should be cleaned up. */
276
277#ifdef BFD64
278#define valuesize 64
279#else /* includes non-bfd case, mostly */
280#define valuesize 32
281#endif
282
f805106c 283 if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri) && radix == 0)
252b5132
RH
284 {
285 int flt = 0;
286
287 /* In MRI mode, the number may have a suffix indicating the
02000999
AM
288 radix. For that matter, it might actually be a floating
289 point constant. */
3882b010 290 for (suffix = input_line_pointer; ISALNUM (*suffix); suffix++)
252b5132
RH
291 {
292 if (*suffix == 'e' || *suffix == 'E')
293 flt = 1;
294 }
295
296 if (suffix == input_line_pointer)
297 {
298 radix = 10;
299 suffix = NULL;
300 }
301 else
302 {
303 c = *--suffix;
3882b010 304 c = TOUPPER (c);
fee9cbc7
AM
305 /* If we have both NUMBERS_WITH_SUFFIX and LOCAL_LABELS_FB,
306 we distinguish between 'B' and 'b'. This is the case for
307 Z80. */
308 if ((NUMBERS_WITH_SUFFIX && LOCAL_LABELS_FB ? *suffix : c) == 'B')
252b5132
RH
309 radix = 2;
310 else if (c == 'D')
311 radix = 10;
312 else if (c == 'O' || c == 'Q')
313 radix = 8;
314 else if (c == 'H')
315 radix = 16;
316 else if (suffix[1] == '.' || c == 'E' || flt)
317 {
318 floating_constant (expressionP);
319 return;
320 }
321 else
322 {
323 radix = 10;
324 suffix = NULL;
325 }
326 }
327 }
328
329 switch (radix)
330 {
331 case 2:
332 maxdig = 2;
333 too_many_digits = valuesize + 1;
334 break;
335 case 8:
336 maxdig = radix = 8;
337 too_many_digits = (valuesize + 2) / 3 + 1;
338 break;
339 case 16:
340 maxdig = radix = 16;
341 too_many_digits = (valuesize + 3) / 4 + 1;
342 break;
343 case 10:
344 maxdig = radix = 10;
929b12bc 345 too_many_digits = (valuesize + 11) / 4; /* Very rough. */
252b5132
RH
346 }
347#undef valuesize
348 start = input_line_pointer;
349 c = *input_line_pointer++;
350 for (number = 0;
351 (digit = hex_value (c)) < maxdig;
352 c = *input_line_pointer++)
353 {
354 number = number * radix + digit;
355 }
929b12bc
KH
356 /* c contains character after number. */
357 /* input_line_pointer->char after c. */
252b5132
RH
358 small = (input_line_pointer - start - 1) < too_many_digits;
359
929b12bc 360 if (radix == 16 && c == '_')
252b5132
RH
361 {
362 /* This is literal of the form 0x333_0_12345678_1.
02000999 363 This example is equivalent to 0x00000333000000001234567800000001. */
252b5132
RH
364
365 int num_little_digits = 0;
366 int i;
929b12bc 367 input_line_pointer = start; /* -> 1st digit. */
252b5132
RH
368
369 know (LITTLENUM_NUMBER_OF_BITS == 16);
370
929b12bc 371 for (c = '_'; c == '_'; num_little_digits += 2)
252b5132
RH
372 {
373
929b12bc
KH
374 /* Convert one 64-bit word. */
375 int ndigit = 0;
252b5132
RH
376 number = 0;
377 for (c = *input_line_pointer++;
378 (digit = hex_value (c)) < maxdig;
379 c = *(input_line_pointer++))
380 {
381 number = number * radix + digit;
382 ndigit++;
383 }
384
385 /* Check for 8 digit per word max. */
929b12bc 386 if (ndigit > 8)
0e389e77 387 as_bad (_("a bignum with underscores may not have more than 8 hex digits in any word"));
252b5132 388
929b12bc
KH
389 /* Add this chunk to the bignum.
390 Shift things down 2 little digits. */
252b5132 391 know (LITTLENUM_NUMBER_OF_BITS == 16);
929b12bc
KH
392 for (i = min (num_little_digits + 1, SIZE_OF_LARGE_NUMBER - 1);
393 i >= 2;
394 i--)
395 generic_bignum[i] = generic_bignum[i - 2];
252b5132 396
929b12bc 397 /* Add the new digits as the least significant new ones. */
252b5132
RH
398 generic_bignum[0] = number & 0xffffffff;
399 generic_bignum[1] = number >> 16;
400 }
401
929b12bc 402 /* Again, c is char after number, input_line_pointer->after c. */
252b5132
RH
403
404 if (num_little_digits > SIZE_OF_LARGE_NUMBER - 1)
405 num_little_digits = SIZE_OF_LARGE_NUMBER - 1;
406
407 assert (num_little_digits >= 4);
408
409 if (num_little_digits != 8)
0e389e77 410 as_bad (_("a bignum with underscores must have exactly 4 words"));
252b5132
RH
411
412 /* We might have some leading zeros. These can be trimmed to give
929b12bc
KH
413 us a change to fit this constant into a small number. */
414 while (generic_bignum[num_little_digits - 1] == 0
415 && num_little_digits > 1)
252b5132 416 num_little_digits--;
929b12bc 417
252b5132
RH
418 if (num_little_digits <= 2)
419 {
929b12bc 420 /* will fit into 32 bits. */
252b5132
RH
421 number = generic_bignum_to_int32 ();
422 small = 1;
423 }
424#ifdef BFD64
425 else if (num_little_digits <= 4)
426 {
427 /* Will fit into 64 bits. */
428 number = generic_bignum_to_int64 ();
429 small = 1;
430 }
431#endif
432 else
433 {
434 small = 0;
929b12bc
KH
435
436 /* Number of littlenums in the bignum. */
437 number = num_little_digits;
252b5132
RH
438 }
439 }
440 else if (!small)
441 {
929b12bc
KH
442 /* We saw a lot of digits. manufacture a bignum the hard way. */
443 LITTLENUM_TYPE *leader; /* -> high order littlenum of the bignum. */
444 LITTLENUM_TYPE *pointer; /* -> littlenum we are frobbing now. */
252b5132
RH
445 long carry;
446
447 leader = generic_bignum;
448 generic_bignum[0] = 0;
449 generic_bignum[1] = 0;
450 generic_bignum[2] = 0;
451 generic_bignum[3] = 0;
929b12bc 452 input_line_pointer = start; /* -> 1st digit. */
252b5132 453 c = *input_line_pointer++;
929b12bc 454 for (; (carry = hex_value (c)) < maxdig; c = *input_line_pointer++)
252b5132 455 {
929b12bc 456 for (pointer = generic_bignum; pointer <= leader; pointer++)
252b5132
RH
457 {
458 long work;
459
460 work = carry + radix * *pointer;
461 *pointer = work & LITTLENUM_MASK;
462 carry = work >> LITTLENUM_NUMBER_OF_BITS;
463 }
464 if (carry)
465 {
466 if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1)
467 {
929b12bc 468 /* Room to grow a longer bignum. */
252b5132
RH
469 *++leader = carry;
470 }
471 }
472 }
929b12bc
KH
473 /* Again, c is char after number. */
474 /* input_line_pointer -> after c. */
252b5132
RH
475 know (LITTLENUM_NUMBER_OF_BITS == 16);
476 if (leader < generic_bignum + 2)
477 {
929b12bc 478 /* Will fit into 32 bits. */
252b5132
RH
479 number = generic_bignum_to_int32 ();
480 small = 1;
481 }
482#ifdef BFD64
483 else if (leader < generic_bignum + 4)
484 {
485 /* Will fit into 64 bits. */
486 number = generic_bignum_to_int64 ();
487 small = 1;
488 }
489#endif
490 else
491 {
929b12bc
KH
492 /* Number of littlenums in the bignum. */
493 number = leader - generic_bignum + 1;
252b5132
RH
494 }
495 }
496
60bcf0fa
NC
497 if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
498 && suffix != NULL
f805106c 499 && input_line_pointer - 1 == suffix)
252b5132
RH
500 c = *input_line_pointer++;
501
502 if (small)
503 {
929b12bc
KH
504 /* Here with number, in correct radix. c is the next char.
505 Note that unlike un*x, we allow "011f" "0x9f" to both mean
506 the same as the (conventional) "9f".
507 This is simply easier than checking for strict canonical
508 form. Syntax sux! */
252b5132
RH
509
510 if (LOCAL_LABELS_FB && c == 'b')
511 {
929b12bc
KH
512 /* Backward ref to local label.
513 Because it is backward, expect it to be defined. */
252b5132
RH
514 /* Construct a local label. */
515 name = fb_label_name ((int) number, 0);
516
929b12bc 517 /* Seen before, or symbol is defined: OK. */
252b5132
RH
518 symbolP = symbol_find (name);
519 if ((symbolP != NULL) && (S_IS_DEFINED (symbolP)))
520 {
929b12bc
KH
521 /* Local labels are never absolute. Don't waste time
522 checking absoluteness. */
252b5132
RH
523 know (SEG_NORMAL (S_GET_SEGMENT (symbolP)));
524
525 expressionP->X_op = O_symbol;
526 expressionP->X_add_symbol = symbolP;
527 }
528 else
529 {
929b12bc 530 /* Either not seen or not defined. */
252b5132
RH
531 /* @@ Should print out the original string instead of
532 the parsed number. */
0e389e77 533 as_bad (_("backward ref to unknown label \"%d:\""),
252b5132
RH
534 (int) number);
535 expressionP->X_op = O_constant;
536 }
537
538 expressionP->X_add_number = 0;
539 } /* case 'b' */
540 else if (LOCAL_LABELS_FB && c == 'f')
541 {
929b12bc
KH
542 /* Forward reference. Expect symbol to be undefined or
543 unknown. undefined: seen it before. unknown: never seen
544 it before.
545
546 Construct a local label name, then an undefined symbol.
547 Don't create a xseg frag for it: caller may do that.
548 Just return it as never seen before. */
252b5132
RH
549 name = fb_label_name ((int) number, 1);
550 symbolP = symbol_find_or_make (name);
929b12bc 551 /* We have no need to check symbol properties. */
252b5132 552#ifndef many_segments
929b12bc 553 /* Since "know" puts its arg into a "string", we
252b5132
RH
554 can't have newlines in the argument. */
555 know (S_GET_SEGMENT (symbolP) == undefined_section || S_GET_SEGMENT (symbolP) == text_section || S_GET_SEGMENT (symbolP) == data_section);
556#endif
557 expressionP->X_op = O_symbol;
558 expressionP->X_add_symbol = symbolP;
559 expressionP->X_add_number = 0;
560 } /* case 'f' */
561 else if (LOCAL_LABELS_DOLLAR && c == '$')
562 {
563 /* If the dollar label is *currently* defined, then this is just
564 another reference to it. If it is not *currently* defined,
565 then this is a fresh instantiation of that number, so create
566 it. */
567
568 if (dollar_label_defined ((long) number))
569 {
570 name = dollar_label_name ((long) number, 0);
571 symbolP = symbol_find (name);
572 know (symbolP != NULL);
573 }
574 else
575 {
576 name = dollar_label_name ((long) number, 1);
577 symbolP = symbol_find_or_make (name);
578 }
579
580 expressionP->X_op = O_symbol;
581 expressionP->X_add_symbol = symbolP;
582 expressionP->X_add_number = 0;
583 } /* case '$' */
584 else
585 {
586 expressionP->X_op = O_constant;
252b5132 587 expressionP->X_add_number = number;
bc4466dc 588 input_line_pointer--; /* Restore following character. */
929b12bc 589 } /* Really just a number. */
252b5132
RH
590 }
591 else
592 {
bc4466dc 593 /* Not a small number. */
252b5132 594 expressionP->X_op = O_big;
929b12bc
KH
595 expressionP->X_add_number = number; /* Number of littlenums. */
596 input_line_pointer--; /* -> char following number. */
252b5132
RH
597 }
598}
599
600/* Parse an MRI multi character constant. */
601
602static void
dd625418 603mri_char_constant (expressionS *expressionP)
252b5132
RH
604{
605 int i;
606
607 if (*input_line_pointer == '\''
608 && input_line_pointer[1] != '\'')
609 {
610 expressionP->X_op = O_constant;
611 expressionP->X_add_number = 0;
612 return;
613 }
614
615 /* In order to get the correct byte ordering, we must build the
616 number in reverse. */
617 for (i = SIZE_OF_LARGE_NUMBER - 1; i >= 0; i--)
618 {
619 int j;
620
621 generic_bignum[i] = 0;
622 for (j = 0; j < CHARS_PER_LITTLENUM; j++)
623 {
624 if (*input_line_pointer == '\'')
625 {
626 if (input_line_pointer[1] != '\'')
627 break;
628 ++input_line_pointer;
629 }
630 generic_bignum[i] <<= 8;
631 generic_bignum[i] += *input_line_pointer;
632 ++input_line_pointer;
633 }
634
635 if (i < SIZE_OF_LARGE_NUMBER - 1)
636 {
637 /* If there is more than one littlenum, left justify the
02000999
AM
638 last one to make it match the earlier ones. If there is
639 only one, we can just use the value directly. */
252b5132
RH
640 for (; j < CHARS_PER_LITTLENUM; j++)
641 generic_bignum[i] <<= 8;
642 }
643
644 if (*input_line_pointer == '\''
645 && input_line_pointer[1] != '\'')
646 break;
647 }
648
649 if (i < 0)
650 {
0e389e77 651 as_bad (_("character constant too large"));
252b5132
RH
652 i = 0;
653 }
654
655 if (i > 0)
656 {
657 int c;
658 int j;
659
660 c = SIZE_OF_LARGE_NUMBER - i;
661 for (j = 0; j < c; j++)
662 generic_bignum[j] = generic_bignum[i + j];
663 i = c;
664 }
665
666 know (LITTLENUM_NUMBER_OF_BITS == 16);
667 if (i > 2)
668 {
669 expressionP->X_op = O_big;
670 expressionP->X_add_number = i;
671 }
672 else
673 {
674 expressionP->X_op = O_constant;
675 if (i < 2)
676 expressionP->X_add_number = generic_bignum[0] & LITTLENUM_MASK;
677 else
678 expressionP->X_add_number =
679 (((generic_bignum[1] & LITTLENUM_MASK)
680 << LITTLENUM_NUMBER_OF_BITS)
681 | (generic_bignum[0] & LITTLENUM_MASK));
682 }
683
684 /* Skip the final closing quote. */
685 ++input_line_pointer;
686}
687
688/* Return an expression representing the current location. This
689 handles the magic symbol `.'. */
690
691static void
dd625418 692current_location (expressionS *expressionp)
252b5132
RH
693{
694 if (now_seg == absolute_section)
695 {
696 expressionp->X_op = O_constant;
697 expressionp->X_add_number = abs_section_offset;
698 }
699 else
700 {
252b5132 701 expressionp->X_op = O_symbol;
756d1d01 702 expressionp->X_add_symbol = symbol_temp_new_now ();
252b5132
RH
703 expressionp->X_add_number = 0;
704 }
705}
706
929b12bc
KH
707/* In: Input_line_pointer points to 1st char of operand, which may
708 be a space.
709
3b37fd66 710 Out: An expressionS.
929b12bc
KH
711 The operand may have been empty: in this case X_op == O_absent.
712 Input_line_pointer->(next non-blank) char after operand. */
252b5132
RH
713
714static segT
9497f5ac 715operand (expressionS *expressionP, enum expr_mode mode)
252b5132
RH
716{
717 char c;
929b12bc
KH
718 symbolS *symbolP; /* Points to symbol. */
719 char *name; /* Points to name of symbol. */
252b5132
RH
720 segT segment;
721
722 /* All integers are regarded as unsigned unless they are negated.
723 This is because the only thing which cares whether a number is
724 unsigned is the code in emit_expr which extends constants into
725 bignums. It should only sign extend negative numbers, so that
726 something like ``.quad 0x80000000'' is not sign extended even
727 though it appears negative if valueT is 32 bits. */
728 expressionP->X_unsigned = 1;
729
929b12bc 730 /* Digits, assume it is a bignum. */
252b5132 731
929b12bc 732 SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
bc4466dc 733 c = *input_line_pointer++; /* input_line_pointer -> past char in c. */
252b5132 734
b75c0c92
AM
735 if (is_end_of_line[(unsigned char) c])
736 goto eol;
737
252b5132
RH
738 switch (c)
739 {
740 case '1':
741 case '2':
742 case '3':
743 case '4':
744 case '5':
745 case '6':
746 case '7':
747 case '8':
748 case '9':
749 input_line_pointer--;
750
60bcf0fa 751 integer_constant ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
929b12bc 752 ? 0 : 10,
411863a4 753 expressionP);
252b5132
RH
754 break;
755
ed6d6fd3
FCE
756#ifdef LITERAL_PREFIXDOLLAR_HEX
757 case '$':
c68012fb
JJ
758 /* $L is the start of a local label, not a hex constant. */
759 if (* input_line_pointer == 'L')
760 goto isname;
ed6d6fd3
FCE
761 integer_constant (16, expressionP);
762 break;
763#endif
764
977e771a
FCE
765#ifdef LITERAL_PREFIXPERCENT_BIN
766 case '%':
767 integer_constant (2, expressionP);
768 break;
769#endif
770
252b5132 771 case '0':
929b12bc 772 /* Non-decimal radix. */
252b5132 773
f805106c 774 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
252b5132
RH
775 {
776 char *s;
777
02000999 778 /* Check for a hex or float constant. */
252b5132
RH
779 for (s = input_line_pointer; hex_p (*s); s++)
780 ;
02000999 781 if (*s == 'h' || *s == 'H' || *input_line_pointer == '.')
252b5132
RH
782 {
783 --input_line_pointer;
784 integer_constant (0, expressionP);
785 break;
786 }
929b12bc 787 }
252b5132
RH
788 c = *input_line_pointer;
789 switch (c)
790 {
791 case 'o':
792 case 'O':
793 case 'q':
794 case 'Q':
795 case '8':
796 case '9':
f805106c 797 if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
252b5132
RH
798 {
799 integer_constant (0, expressionP);
800 break;
801 }
802 /* Fall through. */
803 default:
804 default_case:
805 if (c && strchr (FLT_CHARS, c))
806 {
807 input_line_pointer++;
808 floating_constant (expressionP);
3882b010 809 expressionP->X_add_number = - TOLOWER (c);
252b5132
RH
810 }
811 else
812 {
929b12bc 813 /* The string was only zero. */
252b5132
RH
814 expressionP->X_op = O_constant;
815 expressionP->X_add_number = 0;
816 }
817
818 break;
819
820 case 'x':
821 case 'X':
ab266a97 822 if (flag_m68k_mri)
252b5132
RH
823 goto default_case;
824 input_line_pointer++;
825 integer_constant (16, expressionP);
826 break;
827
828 case 'b':
6dc19fc4 829 if (LOCAL_LABELS_FB && ! (flag_m68k_mri || NUMBERS_WITH_SUFFIX))
252b5132
RH
830 {
831 /* This code used to check for '+' and '-' here, and, in
832 some conditions, fall through to call
833 integer_constant. However, that didn't make sense,
834 as integer_constant only accepts digits. */
835 /* Some of our code elsewhere does permit digits greater
836 than the expected base; for consistency, do the same
837 here. */
838 if (input_line_pointer[1] < '0'
839 || input_line_pointer[1] > '9')
840 {
841 /* Parse this as a back reference to label 0. */
842 input_line_pointer--;
843 integer_constant (10, expressionP);
844 break;
845 }
846 /* Otherwise, parse this as a binary number. */
847 }
848 /* Fall through. */
849 case 'B':
850 input_line_pointer++;
6dc19fc4 851 if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
252b5132
RH
852 goto default_case;
853 integer_constant (2, expressionP);
854 break;
855
856 case '0':
857 case '1':
858 case '2':
859 case '3':
860 case '4':
861 case '5':
862 case '6':
863 case '7':
6dc19fc4 864 integer_constant ((flag_m68k_mri || NUMBERS_WITH_SUFFIX)
929b12bc
KH
865 ? 0 : 8,
866 expressionP);
252b5132
RH
867 break;
868
869 case 'f':
870 if (LOCAL_LABELS_FB)
871 {
872 /* If it says "0f" and it could possibly be a floating point
873 number, make it one. Otherwise, make it a local label,
874 and try to deal with parsing the rest later. */
875 if (!input_line_pointer[1]
271bb601
HPN
876 || (is_end_of_line[0xff & input_line_pointer[1]])
877 || strchr (FLT_CHARS, 'f') == NULL)
252b5132
RH
878 goto is_0f_label;
879 {
880 char *cp = input_line_pointer + 1;
881 int r = atof_generic (&cp, ".", EXP_CHARS,
882 &generic_floating_point_number);
883 switch (r)
884 {
885 case 0:
886 case ERROR_EXPONENT_OVERFLOW:
887 if (*cp == 'f' || *cp == 'b')
929b12bc 888 /* Looks like a difference expression. */
252b5132
RH
889 goto is_0f_label;
890 else if (cp == input_line_pointer + 1)
891 /* No characters has been accepted -- looks like
929b12bc 892 end of operand. */
252b5132
RH
893 goto is_0f_label;
894 else
895 goto is_0f_float;
896 default:
897 as_fatal (_("expr.c(operand): bad atof_generic return val %d"),
898 r);
899 }
900 }
901
902 /* Okay, now we've sorted it out. We resume at one of these
903 two labels, depending on what we've decided we're probably
904 looking at. */
905 is_0f_label:
906 input_line_pointer--;
907 integer_constant (10, expressionP);
908 break;
909
910 is_0f_float:
929b12bc 911 /* Fall through. */
252b5132
RH
912 ;
913 }
914
915 case 'd':
916 case 'D':
6dc19fc4 917 if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
252b5132
RH
918 {
919 integer_constant (0, expressionP);
920 break;
921 }
922 /* Fall through. */
923 case 'F':
924 case 'r':
925 case 'e':
926 case 'E':
927 case 'g':
928 case 'G':
929 input_line_pointer++;
930 floating_constant (expressionP);
3882b010 931 expressionP->X_add_number = - TOLOWER (c);
252b5132
RH
932 break;
933
934 case '$':
935 if (LOCAL_LABELS_DOLLAR)
936 {
937 integer_constant (10, expressionP);
938 break;
939 }
940 else
941 goto default_case;
942 }
943
944 break;
945
946 case '(':
b585bc2c 947#ifndef NEED_INDEX_OPERATOR
252b5132 948 case '[':
b585bc2c 949#endif
929b12bc 950 /* Didn't begin with digit & not a name. */
9497f5ac
NC
951 if (mode != expr_defer)
952 segment = expression (expressionP);
953 else
954 segment = deferred_expression (expressionP);
929b12bc 955 /* expression () will pass trailing whitespace. */
f7c88872
AM
956 if ((c == '(' && *input_line_pointer != ')')
957 || (c == '[' && *input_line_pointer != ']'))
fbacee5b 958 as_bad (_("missing '%c'"), c == '(' ? ')' : ']');
f7c88872 959 else
929b12bc 960 input_line_pointer++;
252b5132 961 SKIP_WHITESPACE ();
929b12bc 962 /* Here with input_line_pointer -> char after "(...)". */
252b5132
RH
963 return segment;
964
abd63a32 965#ifdef TC_M68K
252b5132
RH
966 case 'E':
967 if (! flag_m68k_mri || *input_line_pointer != '\'')
968 goto de_fault;
969 as_bad (_("EBCDIC constants are not supported"));
970 /* Fall through. */
971 case 'A':
972 if (! flag_m68k_mri || *input_line_pointer != '\'')
973 goto de_fault;
974 ++input_line_pointer;
975 /* Fall through. */
abd63a32 976#endif
252b5132
RH
977 case '\'':
978 if (! flag_m68k_mri)
979 {
980 /* Warning: to conform to other people's assemblers NO
929b12bc 981 ESCAPEMENT is permitted for a single quote. The next
252b5132 982 character, parity errors and all, is taken as the value
929b12bc 983 of the operand. VERY KINKY. */
252b5132
RH
984 expressionP->X_op = O_constant;
985 expressionP->X_add_number = *input_line_pointer++;
986 break;
987 }
988
989 mri_char_constant (expressionP);
990 break;
991
abd63a32 992#ifdef TC_M68K
252b5132
RH
993 case '"':
994 /* Double quote is the bitwise not operator in MRI mode. */
995 if (! flag_m68k_mri)
996 goto de_fault;
997 /* Fall through. */
abd63a32 998#endif
252b5132 999 case '~':
929b12bc 1000 /* '~' is permitted to start a label on the Delta. */
252b5132
RH
1001 if (is_name_beginner (c))
1002 goto isname;
1003 case '!':
1004 case '-':
43c3ab55 1005 case '+':
252b5132 1006 {
9497f5ac 1007 operand (expressionP, mode);
252b5132
RH
1008 if (expressionP->X_op == O_constant)
1009 {
929b12bc 1010 /* input_line_pointer -> char after operand. */
252b5132
RH
1011 if (c == '-')
1012 {
958b5f01 1013 expressionP->X_add_number = - expressionP->X_add_number;
929b12bc
KH
1014 /* Notice: '-' may overflow: no warning is given.
1015 This is compatible with other people's
1016 assemblers. Sigh. */
252b5132
RH
1017 expressionP->X_unsigned = 0;
1018 }
1019 else if (c == '~' || c == '"')
1020 expressionP->X_add_number = ~ expressionP->X_add_number;
43c3ab55 1021 else if (c == '!')
252b5132
RH
1022 expressionP->X_add_number = ! expressionP->X_add_number;
1023 }
02000999
AM
1024 else if (expressionP->X_op == O_big
1025 && expressionP->X_add_number <= 0
1026 && c == '-'
1027 && (generic_floating_point_number.sign == '+'
1028 || generic_floating_point_number.sign == 'P'))
1029 {
1030 /* Negative flonum (eg, -1.000e0). */
1031 if (generic_floating_point_number.sign == '+')
1032 generic_floating_point_number.sign = '-';
1033 else
1034 generic_floating_point_number.sign = 'N';
1035 }
b2221023
MM
1036 else if (expressionP->X_op == O_big
1037 && expressionP->X_add_number > 0)
1038 {
1039 int i;
1040
1041 if (c == '~' || c == '-')
1042 {
1043 for (i = 0; i < expressionP->X_add_number; ++i)
1044 generic_bignum[i] = ~generic_bignum[i];
1045 if (c == '-')
1046 for (i = 0; i < expressionP->X_add_number; ++i)
1047 {
1048 generic_bignum[i] += 1;
1049 if (generic_bignum[i])
1050 break;
1051 }
1052 }
1053 else if (c == '!')
1054 {
1055 int nonzero = 0;
1056 for (i = 0; i < expressionP->X_add_number; ++i)
1057 {
1058 if (generic_bignum[i])
1059 nonzero = 1;
1060 generic_bignum[i] = 0;
1061 }
1062 generic_bignum[0] = nonzero;
1063 }
1064 }
252b5132
RH
1065 else if (expressionP->X_op != O_illegal
1066 && expressionP->X_op != O_absent)
1067 {
43c3ab55
JB
1068 if (c != '+')
1069 {
1070 expressionP->X_add_symbol = make_expr_symbol (expressionP);
1071 if (c == '-')
1072 expressionP->X_op = O_uminus;
1073 else if (c == '~' || c == '"')
1074 expressionP->X_op = O_bit_not;
1075 else
1076 expressionP->X_op = O_logical_not;
1077 expressionP->X_add_number = 0;
1078 }
252b5132
RH
1079 }
1080 else
1081 as_warn (_("Unary operator %c ignored because bad operand follows"),
1082 c);
1083 }
1084 break;
1085
abd63a32 1086#if defined (DOLLAR_DOT) || defined (TC_M68K)
252b5132 1087 case '$':
929b12bc 1088 /* '$' is the program counter when in MRI mode, or when
02000999 1089 DOLLAR_DOT is defined. */
252b5132
RH
1090#ifndef DOLLAR_DOT
1091 if (! flag_m68k_mri)
1092 goto de_fault;
1093#endif
4fa6945e 1094 if (DOLLAR_AMBIGU && hex_p (*input_line_pointer))
252b5132 1095 {
4fa6945e
NC
1096 /* In MRI mode and on Z80, '$' is also used as the prefix
1097 for a hexadecimal constant. */
252b5132
RH
1098 integer_constant (16, expressionP);
1099 break;
1100 }
1101
1102 if (is_part_of_name (*input_line_pointer))
1103 goto isname;
1104
1105 current_location (expressionP);
1106 break;
abd63a32 1107#endif
252b5132
RH
1108
1109 case '.':
1110 if (!is_part_of_name (*input_line_pointer))
1111 {
1112 current_location (expressionP);
1113 break;
1114 }
1115 else if ((strncasecmp (input_line_pointer, "startof.", 8) == 0
1116 && ! is_part_of_name (input_line_pointer[8]))
1117 || (strncasecmp (input_line_pointer, "sizeof.", 7) == 0
1118 && ! is_part_of_name (input_line_pointer[7])))
1119 {
1120 int start;
1121
1122 start = (input_line_pointer[1] == 't'
1123 || input_line_pointer[1] == 'T');
1124 input_line_pointer += start ? 8 : 7;
1125 SKIP_WHITESPACE ();
1126 if (*input_line_pointer != '(')
1127 as_bad (_("syntax error in .startof. or .sizeof."));
1128 else
1129 {
1130 char *buf;
1131
1132 ++input_line_pointer;
1133 SKIP_WHITESPACE ();
1134 name = input_line_pointer;
1135 c = get_symbol_end ();
1136
1137 buf = (char *) xmalloc (strlen (name) + 10);
1138 if (start)
1139 sprintf (buf, ".startof.%s", name);
1140 else
1141 sprintf (buf, ".sizeof.%s", name);
1142 symbolP = symbol_make (buf);
1143 free (buf);
1144
1145 expressionP->X_op = O_symbol;
1146 expressionP->X_add_symbol = symbolP;
1147 expressionP->X_add_number = 0;
1148
1149 *input_line_pointer = c;
1150 SKIP_WHITESPACE ();
1151 if (*input_line_pointer != ')')
1152 as_bad (_("syntax error in .startof. or .sizeof."));
1153 else
1154 ++input_line_pointer;
1155 }
1156 break;
1157 }
1158 else
1159 {
1160 goto isname;
1161 }
b75c0c92 1162
252b5132 1163 case ',':
252b5132 1164 eol:
929b12bc 1165 /* Can't imagine any other kind of operand. */
252b5132
RH
1166 expressionP->X_op = O_absent;
1167 input_line_pointer--;
1168 break;
1169
abd63a32 1170#ifdef TC_M68K
252b5132
RH
1171 case '%':
1172 if (! flag_m68k_mri)
1173 goto de_fault;
1174 integer_constant (2, expressionP);
1175 break;
1176
1177 case '@':
1178 if (! flag_m68k_mri)
1179 goto de_fault;
1180 integer_constant (8, expressionP);
1181 break;
1182
1183 case ':':
1184 if (! flag_m68k_mri)
1185 goto de_fault;
1186
1187 /* In MRI mode, this is a floating point constant represented
02000999 1188 using hexadecimal digits. */
252b5132
RH
1189
1190 ++input_line_pointer;
1191 integer_constant (16, expressionP);
1192 break;
1193
1194 case '*':
1195 if (! flag_m68k_mri || is_part_of_name (*input_line_pointer))
1196 goto de_fault;
1197
1198 current_location (expressionP);
1199 break;
abd63a32 1200#endif
252b5132
RH
1201
1202 default:
abd63a32 1203#ifdef TC_M68K
252b5132 1204 de_fault:
abd63a32 1205#endif
929b12bc 1206 if (is_name_beginner (c)) /* Here if did not begin with a digit. */
252b5132 1207 {
929b12bc
KH
1208 /* Identifier begins here.
1209 This is kludged for speed, so code is repeated. */
252b5132
RH
1210 isname:
1211 name = --input_line_pointer;
1212 c = get_symbol_end ();
1213
1214#ifdef md_parse_name
1215 /* This is a hook for the backend to parse certain names
02000999
AM
1216 specially in certain contexts. If a name always has a
1217 specific value, it can often be handled by simply
1218 entering it in the symbol table. */
9497f5ac 1219 if (md_parse_name (name, expressionP, mode, &c))
252b5132
RH
1220 {
1221 *input_line_pointer = c;
1222 break;
1223 }
1224#endif
1225
1226#ifdef TC_I960
1227 /* The MRI i960 assembler permits
1228 lda sizeof code,g13
1229 FIXME: This should use md_parse_name. */
1230 if (flag_mri
1231 && (strcasecmp (name, "sizeof") == 0
1232 || strcasecmp (name, "startof") == 0))
1233 {
1234 int start;
1235 char *buf;
1236
1237 start = (name[1] == 't'
1238 || name[1] == 'T');
1239
1240 *input_line_pointer = c;
1241 SKIP_WHITESPACE ();
1242
1243 name = input_line_pointer;
1244 c = get_symbol_end ();
1245
1246 buf = (char *) xmalloc (strlen (name) + 10);
1247 if (start)
1248 sprintf (buf, ".startof.%s", name);
1249 else
1250 sprintf (buf, ".sizeof.%s", name);
1251 symbolP = symbol_make (buf);
1252 free (buf);
1253
1254 expressionP->X_op = O_symbol;
1255 expressionP->X_add_symbol = symbolP;
1256 expressionP->X_add_number = 0;
1257
1258 *input_line_pointer = c;
1259 SKIP_WHITESPACE ();
1260
1261 break;
929b12bc 1262 }
252b5132
RH
1263#endif
1264
1265 symbolP = symbol_find_or_make (name);
1266
1267 /* If we have an absolute symbol or a reg, then we know its
1268 value now. */
1269 segment = S_GET_SEGMENT (symbolP);
9497f5ac 1270 if (mode != expr_defer && segment == absolute_section)
252b5132
RH
1271 {
1272 expressionP->X_op = O_constant;
1273 expressionP->X_add_number = S_GET_VALUE (symbolP);
1274 }
9497f5ac 1275 else if (mode != expr_defer && segment == reg_section)
252b5132
RH
1276 {
1277 expressionP->X_op = O_register;
1278 expressionP->X_add_number = S_GET_VALUE (symbolP);
1279 }
1280 else
1281 {
1282 expressionP->X_op = O_symbol;
1283 expressionP->X_add_symbol = symbolP;
1284 expressionP->X_add_number = 0;
1285 }
1286 *input_line_pointer = c;
1287 }
1288 else
1289 {
1290 /* Let the target try to parse it. Success is indicated by changing
1291 the X_op field to something other than O_absent and pointing
927781e2 1292 input_line_pointer past the expression. If it can't parse the
252b5132
RH
1293 expression, X_op and input_line_pointer should be unchanged. */
1294 expressionP->X_op = O_absent;
1295 --input_line_pointer;
1296 md_operand (expressionP);
1297 if (expressionP->X_op == O_absent)
1298 {
1299 ++input_line_pointer;
0e389e77 1300 as_bad (_("bad expression"));
252b5132
RH
1301 expressionP->X_op = O_constant;
1302 expressionP->X_add_number = 0;
1303 }
1304 }
1305 break;
1306 }
1307
929b12bc
KH
1308 /* It is more 'efficient' to clean up the expressionS when they are
1309 created. Doing it here saves lines of code. */
252b5132 1310 clean_up_expression (expressionP);
929b12bc 1311 SKIP_WHITESPACE (); /* -> 1st char after operand. */
252b5132
RH
1312 know (*input_line_pointer != ' ');
1313
1314 /* The PA port needs this information. */
1315 if (expressionP->X_add_symbol)
49309057 1316 symbol_mark_used (expressionP->X_add_symbol);
252b5132 1317
9497f5ac
NC
1318 expressionP->X_add_symbol = symbol_clone_if_forward_ref (expressionP->X_add_symbol);
1319 expressionP->X_op_symbol = symbol_clone_if_forward_ref (expressionP->X_op_symbol);
1320
252b5132
RH
1321 switch (expressionP->X_op)
1322 {
1323 default:
1324 return absolute_section;
1325 case O_symbol:
1326 return S_GET_SEGMENT (expressionP->X_add_symbol);
1327 case O_register:
1328 return reg_section;
1329 }
929b12bc 1330}
252b5132 1331\f
929b12bc
KH
1332/* Internal. Simplify a struct expression for use by expr (). */
1333
3b37fd66 1334/* In: address of an expressionS.
929b12bc
KH
1335 The X_op field of the expressionS may only take certain values.
1336 Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
1337
1338 Out: expressionS may have been modified:
929b12bc 1339 Unused fields zeroed to help expr (). */
252b5132
RH
1340
1341static void
dd625418 1342clean_up_expression (expressionS *expressionP)
252b5132
RH
1343{
1344 switch (expressionP->X_op)
1345 {
1346 case O_illegal:
1347 case O_absent:
1348 expressionP->X_add_number = 0;
1349 /* Fall through. */
1350 case O_big:
1351 case O_constant:
1352 case O_register:
1353 expressionP->X_add_symbol = NULL;
1354 /* Fall through. */
1355 case O_symbol:
1356 case O_uminus:
1357 case O_bit_not:
1358 expressionP->X_op_symbol = NULL;
1359 break;
252b5132
RH
1360 default:
1361 break;
1362 }
1363}
1364\f
929b12bc
KH
1365/* Expression parser. */
1366
1367/* We allow an empty expression, and just assume (absolute,0) silently.
1368 Unary operators and parenthetical expressions are treated as operands.
1369 As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
1370
3b37fd66 1371 We used to do an aho/ullman shift-reduce parser, but the logic got so
929b12bc
KH
1372 warped that I flushed it and wrote a recursive-descent parser instead.
1373 Now things are stable, would anybody like to write a fast parser?
1374 Most expressions are either register (which does not even reach here)
1375 or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
1376 So I guess it doesn't really matter how inefficient more complex expressions
1377 are parsed.
1378
1379 After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
1380 Also, we have consumed any leading or trailing spaces (operand does that)
1381 and done all intervening operators.
1382
1383 This returns the segment of the result, which will be
1384 absolute_section or the segment of a symbol. */
252b5132
RH
1385
1386#undef __
1387#define __ O_illegal
fb7ccfc1
AM
1388#ifndef O_SINGLE_EQ
1389#define O_SINGLE_EQ O_illegal
1390#endif
252b5132 1391
b041f888
KH
1392/* Maps ASCII -> operators. */
1393static const operatorT op_encoding[256] = {
252b5132
RH
1394 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1395 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1396
1397 __, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __,
1398 __, __, O_multiply, O_add, __, O_subtract, __, O_divide,
1399 __, __, __, __, __, __, __, __,
fb7ccfc1 1400 __, __, __, __, O_lt, O_SINGLE_EQ, O_gt, __,
252b5132
RH
1401 __, __, __, __, __, __, __, __,
1402 __, __, __, __, __, __, __, __,
1403 __, __, __, __, __, __, __, __,
b585bc2c
RH
1404 __, __, __,
1405#ifdef NEED_INDEX_OPERATOR
1406 O_index,
1407#else
1408 __,
1409#endif
1410 __, __, O_bit_exclusive_or, __,
252b5132
RH
1411 __, __, __, __, __, __, __, __,
1412 __, __, __, __, __, __, __, __,
1413 __, __, __, __, __, __, __, __,
1414 __, __, __, __, O_bit_inclusive_or, __, __, __,
1415
1416 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1417 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1418 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1419 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1420 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1421 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1422 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1423 __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
1424};
1425
929b12bc
KH
1426/* Rank Examples
1427 0 operand, (expression)
1428 1 ||
1429 2 &&
07a7a145 1430 3 == <> < <= >= >
929b12bc
KH
1431 4 + -
1432 5 used for * / % in MRI mode
1433 6 & ^ ! |
1434 7 * / % << >>
1435 8 unary - unary ~
1436*/
e6c774b4 1437static operator_rankT op_rank[] = {
252b5132
RH
1438 0, /* O_illegal */
1439 0, /* O_absent */
1440 0, /* O_constant */
1441 0, /* O_symbol */
1442 0, /* O_symbol_rva */
1443 0, /* O_register */
16887944 1444 0, /* O_big */
b585bc2c
RH
1445 9, /* O_uminus */
1446 9, /* O_bit_not */
1447 9, /* O_logical_not */
1448 8, /* O_multiply */
1449 8, /* O_divide */
1450 8, /* O_modulus */
1451 8, /* O_left_shift */
1452 8, /* O_right_shift */
1453 7, /* O_bit_inclusive_or */
1454 7, /* O_bit_or_not */
1455 7, /* O_bit_exclusive_or */
1456 7, /* O_bit_and */
1457 5, /* O_add */
1458 5, /* O_subtract */
1459 4, /* O_eq */
1460 4, /* O_ne */
1461 4, /* O_lt */
1462 4, /* O_le */
1463 4, /* O_ge */
1464 4, /* O_gt */
1465 3, /* O_logical_and */
1466 2, /* O_logical_or */
1467 1, /* O_index */
446a06c9
MM
1468 0, /* O_md1 */
1469 0, /* O_md2 */
1470 0, /* O_md3 */
1471 0, /* O_md4 */
1472 0, /* O_md5 */
1473 0, /* O_md6 */
1474 0, /* O_md7 */
1475 0, /* O_md8 */
dd33dc0f
MM
1476 0, /* O_md9 */
1477 0, /* O_md10 */
1478 0, /* O_md11 */
1479 0, /* O_md12 */
1480 0, /* O_md13 */
1481 0, /* O_md14 */
1482 0, /* O_md15 */
1483 0, /* O_md16 */
252b5132
RH
1484};
1485
1486/* Unfortunately, in MRI mode for the m68k, multiplication and
1487 division have lower precedence than the bit wise operators. This
1488 function sets the operator precedences correctly for the current
1489 mode. Also, MRI uses a different bit_not operator, and this fixes
1490 that as well. */
1491
16887944
AM
1492#define STANDARD_MUL_PRECEDENCE 8
1493#define MRI_MUL_PRECEDENCE 6
252b5132
RH
1494
1495void
dd625418 1496expr_set_precedence (void)
252b5132
RH
1497{
1498 if (flag_m68k_mri)
1499 {
1500 op_rank[O_multiply] = MRI_MUL_PRECEDENCE;
1501 op_rank[O_divide] = MRI_MUL_PRECEDENCE;
1502 op_rank[O_modulus] = MRI_MUL_PRECEDENCE;
1503 }
1504 else
1505 {
1506 op_rank[O_multiply] = STANDARD_MUL_PRECEDENCE;
1507 op_rank[O_divide] = STANDARD_MUL_PRECEDENCE;
1508 op_rank[O_modulus] = STANDARD_MUL_PRECEDENCE;
1509 }
1510}
1511
1512/* Initialize the expression parser. */
1513
1514void
dd625418 1515expr_begin (void)
252b5132
RH
1516{
1517 expr_set_precedence ();
1518
1519 /* Verify that X_op field is wide enough. */
1520 {
1521 expressionS e;
1522 e.X_op = O_max;
1523 assert (e.X_op == O_max);
1524 }
1525}
1526\f
6fad6acb
AM
1527/* Return the encoding for the operator at INPUT_LINE_POINTER, and
1528 sets NUM_CHARS to the number of characters in the operator.
1529 Does not advance INPUT_LINE_POINTER. */
252b5132
RH
1530
1531static inline operatorT
dd625418 1532operator (int *num_chars)
252b5132
RH
1533{
1534 int c;
1535 operatorT ret;
1536
1537 c = *input_line_pointer & 0xff;
6fad6acb 1538 *num_chars = 1;
252b5132 1539
b75c0c92
AM
1540 if (is_end_of_line[c])
1541 return O_illegal;
1542
252b5132
RH
1543 switch (c)
1544 {
1545 default:
1546 return op_encoding[c];
1547
3e4caed2
NS
1548 case '+':
1549 case '-':
8c9f705e 1550 return op_encoding[c];
3e4caed2 1551
252b5132
RH
1552 case '<':
1553 switch (input_line_pointer[1])
1554 {
1555 default:
1556 return op_encoding[c];
1557 case '<':
1558 ret = O_left_shift;
1559 break;
1560 case '>':
1561 ret = O_ne;
1562 break;
1563 case '=':
1564 ret = O_le;
1565 break;
1566 }
6fad6acb 1567 *num_chars = 2;
252b5132
RH
1568 return ret;
1569
1570 case '=':
1571 if (input_line_pointer[1] != '=')
1572 return op_encoding[c];
1573
6fad6acb 1574 *num_chars = 2;
252b5132
RH
1575 return O_eq;
1576
1577 case '>':
1578 switch (input_line_pointer[1])
1579 {
1580 default:
1581 return op_encoding[c];
1582 case '>':
1583 ret = O_right_shift;
1584 break;
1585 case '=':
1586 ret = O_ge;
1587 break;
1588 }
6fad6acb 1589 *num_chars = 2;
252b5132
RH
1590 return ret;
1591
1592 case '!':
723a8472 1593 switch (input_line_pointer[1])
252b5132 1594 {
723a8472
NC
1595 case '!':
1596 /* We accept !! as equivalent to ^ for MRI compatibility. */
1597 *num_chars = 2;
1598 return O_bit_exclusive_or;
1599 case '=':
1600 /* We accept != as equivalent to <>. */
1601 *num_chars = 2;
1602 return O_ne;
1603 default:
252b5132
RH
1604 if (flag_m68k_mri)
1605 return O_bit_inclusive_or;
1606 return op_encoding[c];
1607 }
252b5132
RH
1608
1609 case '|':
1610 if (input_line_pointer[1] != '|')
1611 return op_encoding[c];
1612
6fad6acb 1613 *num_chars = 2;
252b5132
RH
1614 return O_logical_or;
1615
1616 case '&':
1617 if (input_line_pointer[1] != '&')
1618 return op_encoding[c];
1619
6fad6acb 1620 *num_chars = 2;
252b5132
RH
1621 return O_logical_and;
1622 }
1623
929b12bc 1624 /* NOTREACHED */
252b5132
RH
1625}
1626
1627/* Parse an expression. */
1628
1629segT
dd625418 1630expr (int rankarg, /* Larger # is higher rank. */
9497f5ac
NC
1631 expressionS *resultP, /* Deliver result here. */
1632 enum expr_mode mode /* Controls behavior. */)
252b5132 1633{
0561a208 1634 operator_rankT rank = (operator_rankT) rankarg;
252b5132
RH
1635 segT retval;
1636 expressionS right;
1637 operatorT op_left;
1638 operatorT op_right;
6fad6acb 1639 int op_chars;
252b5132 1640
db557034 1641 know (rankarg >= 0);
252b5132 1642
26346241
AM
1643 /* Save the value of dot for the fixup code. */
1644 if (rank == 0)
1645 dot_value = frag_now_fix ();
1646
9497f5ac 1647 retval = operand (resultP, mode);
252b5132 1648
929b12bc
KH
1649 /* operand () gobbles spaces. */
1650 know (*input_line_pointer != ' ');
252b5132 1651
6fad6acb 1652 op_left = operator (&op_chars);
252b5132
RH
1653 while (op_left != O_illegal && op_rank[(int) op_left] > rank)
1654 {
1655 segT rightseg;
99630778 1656 bfd_vma frag_off;
252b5132 1657
6fad6acb 1658 input_line_pointer += op_chars; /* -> after operator. */
252b5132 1659
9497f5ac 1660 rightseg = expr (op_rank[(int) op_left], &right, mode);
252b5132
RH
1661 if (right.X_op == O_absent)
1662 {
1663 as_warn (_("missing operand; zero assumed"));
1664 right.X_op = O_constant;
1665 right.X_add_number = 0;
1666 right.X_add_symbol = NULL;
1667 right.X_op_symbol = NULL;
1668 }
1669
1670 know (*input_line_pointer != ' ');
1671
b585bc2c
RH
1672 if (op_left == O_index)
1673 {
1674 if (*input_line_pointer != ']')
1675 as_bad ("missing right bracket");
1676 else
1677 {
1678 ++input_line_pointer;
1679 SKIP_WHITESPACE ();
1680 }
1681 }
1682
6fad6acb 1683 op_right = operator (&op_chars);
252b5132 1684
929b12bc
KH
1685 know (op_right == O_illegal
1686 || op_rank[(int) op_right] <= op_rank[(int) op_left]);
252b5132 1687 know ((int) op_left >= (int) O_multiply
c9dea48b 1688 && (int) op_left <= (int) O_index);
252b5132 1689
929b12bc
KH
1690 /* input_line_pointer->after right-hand quantity. */
1691 /* left-hand quantity in resultP. */
1692 /* right-hand quantity in right. */
1693 /* operator in op_left. */
252b5132
RH
1694
1695 if (resultP->X_op == O_big)
1696 {
1697 if (resultP->X_add_number > 0)
1698 as_warn (_("left operand is a bignum; integer 0 assumed"));
1699 else
1700 as_warn (_("left operand is a float; integer 0 assumed"));
1701 resultP->X_op = O_constant;
1702 resultP->X_add_number = 0;
1703 resultP->X_add_symbol = NULL;
1704 resultP->X_op_symbol = NULL;
1705 }
1706 if (right.X_op == O_big)
1707 {
1708 if (right.X_add_number > 0)
1709 as_warn (_("right operand is a bignum; integer 0 assumed"));
1710 else
1711 as_warn (_("right operand is a float; integer 0 assumed"));
1712 right.X_op = O_constant;
1713 right.X_add_number = 0;
1714 right.X_add_symbol = NULL;
1715 right.X_op_symbol = NULL;
1716 }
1717
1718 /* Optimize common cases. */
800eeca4
JW
1719#ifdef md_optimize_expr
1720 if (md_optimize_expr (resultP, op_left, &right))
1721 {
929b12bc
KH
1722 /* Skip. */
1723 ;
800eeca4
JW
1724 }
1725 else
1726#endif
5a918ce7
JB
1727#ifndef md_register_arithmetic
1728# define md_register_arithmetic 1
1729#endif
1730 if (op_left == O_add && right.X_op == O_constant
1731 && (md_register_arithmetic || resultP->X_op != O_register))
252b5132
RH
1732 {
1733 /* X + constant. */
1734 resultP->X_add_number += right.X_add_number;
1735 }
1736 /* This case comes up in PIC code. */
1737 else if (op_left == O_subtract
1738 && right.X_op == O_symbol
1739 && resultP->X_op == O_symbol
99630778 1740 && retval == rightseg
bfff1642
NC
1741#ifdef md_allow_local_subtract
1742 && md_allow_local_subtract (resultP, & right, rightseg)
1743#endif
f6cf69d7 1744 && (SEG_NORMAL (rightseg)
99630778
AM
1745 || right.X_add_symbol == resultP->X_add_symbol)
1746 && frag_offset_fixed_p (symbol_get_frag (resultP->X_add_symbol),
1747 symbol_get_frag (right.X_add_symbol),
1748 &frag_off))
252b5132
RH
1749 {
1750 resultP->X_add_number -= right.X_add_number;
99630778 1751 resultP->X_add_number -= frag_off / OCTETS_PER_BYTE;
252b5132
RH
1752 resultP->X_add_number += (S_GET_VALUE (resultP->X_add_symbol)
1753 - S_GET_VALUE (right.X_add_symbol));
1754 resultP->X_op = O_constant;
1755 resultP->X_add_symbol = 0;
1756 }
5a918ce7
JB
1757 else if (op_left == O_subtract && right.X_op == O_constant
1758 && (md_register_arithmetic || resultP->X_op != O_register))
252b5132
RH
1759 {
1760 /* X - constant. */
1761 resultP->X_add_number -= right.X_add_number;
1762 }
5a918ce7
JB
1763 else if (op_left == O_add && resultP->X_op == O_constant
1764 && (md_register_arithmetic || right.X_op != O_register))
252b5132
RH
1765 {
1766 /* Constant + X. */
1767 resultP->X_op = right.X_op;
1768 resultP->X_add_symbol = right.X_add_symbol;
1769 resultP->X_op_symbol = right.X_op_symbol;
1770 resultP->X_add_number += right.X_add_number;
1771 retval = rightseg;
1772 }
1773 else if (resultP->X_op == O_constant && right.X_op == O_constant)
1774 {
1775 /* Constant OP constant. */
1776 offsetT v = right.X_add_number;
1777 if (v == 0 && (op_left == O_divide || op_left == O_modulus))
1778 {
1779 as_warn (_("division by zero"));
1780 v = 1;
1781 }
1782 switch (op_left)
1783 {
1784 default: abort ();
1785 case O_multiply: resultP->X_add_number *= v; break;
1786 case O_divide: resultP->X_add_number /= v; break;
1787 case O_modulus: resultP->X_add_number %= v; break;
1788 case O_left_shift: resultP->X_add_number <<= v; break;
1789 case O_right_shift:
1790 /* We always use unsigned shifts, to avoid relying on
02000999 1791 characteristics of the compiler used to compile gas. */
252b5132
RH
1792 resultP->X_add_number =
1793 (offsetT) ((valueT) resultP->X_add_number >> (valueT) v);
1794 break;
1795 case O_bit_inclusive_or: resultP->X_add_number |= v; break;
1796 case O_bit_or_not: resultP->X_add_number |= ~v; break;
1797 case O_bit_exclusive_or: resultP->X_add_number ^= v; break;
1798 case O_bit_and: resultP->X_add_number &= v; break;
7b383517
BE
1799 /* Constant + constant (O_add) is handled by the
1800 previous if statement for constant + X, so is omitted
1801 here. */
252b5132
RH
1802 case O_subtract: resultP->X_add_number -= v; break;
1803 case O_eq:
1804 resultP->X_add_number =
958b5f01 1805 resultP->X_add_number == v ? ~ (offsetT) 0 : 0;
252b5132
RH
1806 break;
1807 case O_ne:
1808 resultP->X_add_number =
958b5f01 1809 resultP->X_add_number != v ? ~ (offsetT) 0 : 0;
252b5132
RH
1810 break;
1811 case O_lt:
1812 resultP->X_add_number =
958b5f01 1813 resultP->X_add_number < v ? ~ (offsetT) 0 : 0;
252b5132
RH
1814 break;
1815 case O_le:
1816 resultP->X_add_number =
958b5f01 1817 resultP->X_add_number <= v ? ~ (offsetT) 0 : 0;
252b5132
RH
1818 break;
1819 case O_ge:
1820 resultP->X_add_number =
958b5f01 1821 resultP->X_add_number >= v ? ~ (offsetT) 0 : 0;
252b5132
RH
1822 break;
1823 case O_gt:
1824 resultP->X_add_number =
958b5f01 1825 resultP->X_add_number > v ? ~ (offsetT) 0 : 0;
252b5132
RH
1826 break;
1827 case O_logical_and:
1828 resultP->X_add_number = resultP->X_add_number && v;
1829 break;
1830 case O_logical_or:
1831 resultP->X_add_number = resultP->X_add_number || v;
1832 break;
1833 }
1834 }
1835 else if (resultP->X_op == O_symbol
1836 && right.X_op == O_symbol
1837 && (op_left == O_add
1838 || op_left == O_subtract
1839 || (resultP->X_add_number == 0
1840 && right.X_add_number == 0)))
1841 {
1842 /* Symbol OP symbol. */
1843 resultP->X_op = op_left;
1844 resultP->X_op_symbol = right.X_add_symbol;
1845 if (op_left == O_add)
1846 resultP->X_add_number += right.X_add_number;
1847 else if (op_left == O_subtract)
e0890092
AM
1848 {
1849 resultP->X_add_number -= right.X_add_number;
1850 if (retval == rightseg && SEG_NORMAL (retval))
1851 {
1852 retval = absolute_section;
1853 rightseg = absolute_section;
1854 }
1855 }
252b5132
RH
1856 }
1857 else
1858 {
1859 /* The general case. */
1860 resultP->X_add_symbol = make_expr_symbol (resultP);
1861 resultP->X_op_symbol = make_expr_symbol (&right);
1862 resultP->X_op = op_left;
1863 resultP->X_add_number = 0;
1864 resultP->X_unsigned = 1;
1865 }
1866
e0890092
AM
1867 if (retval != rightseg)
1868 {
1869 if (! SEG_NORMAL (retval))
1870 {
1871 if (retval != undefined_section || SEG_NORMAL (rightseg))
1872 retval = rightseg;
1873 }
1874 else if (SEG_NORMAL (rightseg)
1875#ifdef DIFF_EXPR_OK
1876 && op_left != O_subtract
1877#endif
1878 )
1879 as_bad (_("operation combines symbols in different segments"));
1880 }
1881
252b5132 1882 op_left = op_right;
929b12bc 1883 } /* While next operator is >= this rank. */
252b5132
RH
1884
1885 /* The PA port needs this information. */
1886 if (resultP->X_add_symbol)
49309057 1887 symbol_mark_used (resultP->X_add_symbol);
252b5132 1888
9497f5ac
NC
1889 if (rank == 0 && mode == expr_evaluate)
1890 resolve_expression (resultP);
1891
252b5132
RH
1892 return resultP->X_op == O_constant ? absolute_section : retval;
1893}
9497f5ac
NC
1894
1895/* Resolve an expression without changing any symbols/sub-expressions
1896 used. */
1897
1898int
1899resolve_expression (expressionS *expressionP)
1900{
1901 /* Help out with CSE. */
1902 valueT final_val = expressionP->X_add_number;
1903 symbolS *add_symbol = expressionP->X_add_symbol;
1904 symbolS *op_symbol = expressionP->X_op_symbol;
1905 operatorT op = expressionP->X_op;
1906 valueT left, right;
1907 segT seg_left, seg_right;
1908 fragS *frag_left, *frag_right;
99630778 1909 bfd_vma frag_off;
9497f5ac
NC
1910
1911 switch (op)
1912 {
1913 default:
1914 return 0;
1915
1916 case O_constant:
1917 case O_register:
1918 left = 0;
1919 break;
1920
1921 case O_symbol:
1922 case O_symbol_rva:
2e1e12b1 1923 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left))
9497f5ac
NC
1924 return 0;
1925
1926 break;
1927
1928 case O_uminus:
1929 case O_bit_not:
1930 case O_logical_not:
2e1e12b1 1931 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left))
9497f5ac
NC
1932 return 0;
1933
1934 if (seg_left != absolute_section)
1935 return 0;
1936
1937 if (op == O_logical_not)
1938 left = !left;
1939 else if (op == O_uminus)
1940 left = -left;
1941 else
1942 left = ~left;
1943 op = O_constant;
1944 break;
1945
1946 case O_multiply:
1947 case O_divide:
1948 case O_modulus:
1949 case O_left_shift:
1950 case O_right_shift:
1951 case O_bit_inclusive_or:
1952 case O_bit_or_not:
1953 case O_bit_exclusive_or:
1954 case O_bit_and:
1955 case O_add:
1956 case O_subtract:
1957 case O_eq:
1958 case O_ne:
1959 case O_lt:
1960 case O_le:
1961 case O_ge:
1962 case O_gt:
1963 case O_logical_and:
1964 case O_logical_or:
2e1e12b1
JB
1965 if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left)
1966 || !snapshot_symbol (&op_symbol, &right, &seg_right, &frag_right))
9497f5ac
NC
1967 return 0;
1968
1969 /* Simplify addition or subtraction of a constant by folding the
1970 constant into X_add_number. */
1971 if (op == O_add)
1972 {
1973 if (seg_right == absolute_section)
1974 {
1975 final_val += right;
1976 op = O_symbol;
1977 break;
1978 }
1979 else if (seg_left == absolute_section)
1980 {
1981 final_val += left;
1982 left = right;
1983 seg_left = seg_right;
2e1e12b1 1984 add_symbol = op_symbol;
9497f5ac
NC
1985 op = O_symbol;
1986 break;
1987 }
1988 }
1989 else if (op == O_subtract)
1990 {
1991 if (seg_right == absolute_section)
1992 {
1993 final_val -= right;
1994 op = O_symbol;
1995 break;
1996 }
1997 }
1998
1999 /* Equality and non-equality tests are permitted on anything.
2000 Subtraction, and other comparison operators are permitted if
2e1e12b1
JB
2001 both operands are in the same section.
2002 Shifts by constant zero are permitted on anything.
2003 Multiplies, bit-ors, and bit-ands with constant zero are
2004 permitted on anything.
2005 Multiplies and divides by constant one are permitted on
2006 anything.
2007 Binary operations with both operands being the same register
2008 or undefined symbol are permitted if the result doesn't depend
2009 on the input value.
2010 Otherwise, both operands must be absolute. We already handled
2011 the case of addition or subtraction of a constant above. */
99630778 2012 frag_off = 0;
9497f5ac
NC
2013 if (!(seg_left == absolute_section
2014 && seg_right == absolute_section)
2015 && !(op == O_eq || op == O_ne)
2016 && !((op == O_subtract
2017 || op == O_lt || op == O_le || op == O_ge || op == O_gt)
2018 && seg_left == seg_right
99630778
AM
2019 && (finalize_syms
2020 || frag_offset_fixed_p (frag_left, frag_right, &frag_off))
2e1e12b1
JB
2021 && (seg_left != reg_section || left == right)
2022 && (seg_left != undefined_section || add_symbol == op_symbol)))
2023 {
2024 if ((seg_left == absolute_section && left == 0)
2025 || (seg_right == absolute_section && right == 0))
2026 {
2027 if (op == O_bit_exclusive_or || op == O_bit_inclusive_or)
2028 {
2029 if (seg_right != absolute_section || right != 0)
2030 {
2031 seg_left = seg_right;
2032 left = right;
2033 add_symbol = op_symbol;
2034 }
2035 op = O_symbol;
2036 break;
2037 }
2038 else if (op == O_left_shift || op == O_right_shift)
2039 {
2040 if (seg_left != absolute_section || left != 0)
2041 {
2042 op = O_symbol;
2043 break;
2044 }
2045 }
2046 else if (op != O_multiply
2047 && op != O_bit_or_not && op != O_bit_and)
2048 return 0;
2049 }
2050 else if (op == O_multiply
2051 && seg_left == absolute_section && left == 1)
2052 {
2053 seg_left = seg_right;
2054 left = right;
2055 add_symbol = op_symbol;
2056 op = O_symbol;
2057 break;
2058 }
2059 else if ((op == O_multiply || op == O_divide)
2060 && seg_right == absolute_section && right == 1)
2061 {
2062 op = O_symbol;
2063 break;
2064 }
2065 else if (left != right
2066 || ((seg_left != reg_section || seg_right != reg_section)
2067 && (seg_left != undefined_section
2068 || seg_right != undefined_section
2069 || add_symbol != op_symbol)))
2070 return 0;
2071 else if (op == O_bit_and || op == O_bit_inclusive_or)
2072 {
2073 op = O_symbol;
2074 break;
2075 }
2076 else if (op != O_bit_exclusive_or && op != O_bit_or_not)
2077 return 0;
2078 }
9497f5ac 2079
99630778 2080 right += frag_off / OCTETS_PER_BYTE;
9497f5ac
NC
2081 switch (op)
2082 {
2083 case O_add: left += right; break;
2084 case O_subtract: left -= right; break;
2085 case O_multiply: left *= right; break;
2086 case O_divide:
2087 if (right == 0)
2088 return 0;
2089 left = (offsetT) left / (offsetT) right;
2090 break;
2091 case O_modulus:
2092 if (right == 0)
2093 return 0;
2094 left = (offsetT) left % (offsetT) right;
2095 break;
2096 case O_left_shift: left <<= right; break;
2097 case O_right_shift: left >>= right; break;
2098 case O_bit_inclusive_or: left |= right; break;
2099 case O_bit_or_not: left |= ~right; break;
2100 case O_bit_exclusive_or: left ^= right; break;
2101 case O_bit_and: left &= right; break;
2102 case O_eq:
2103 case O_ne:
2104 left = (left == right
2105 && seg_left == seg_right
2106 && (finalize_syms || frag_left == frag_right)
2e1e12b1 2107 && (seg_left != undefined_section
9497f5ac
NC
2108 || add_symbol == op_symbol)
2109 ? ~ (valueT) 0 : 0);
2110 if (op == O_ne)
2111 left = ~left;
2112 break;
2113 case O_lt:
2114 left = (offsetT) left < (offsetT) right ? ~ (valueT) 0 : 0;
2115 break;
2116 case O_le:
2117 left = (offsetT) left <= (offsetT) right ? ~ (valueT) 0 : 0;
2118 break;
2119 case O_ge:
2120 left = (offsetT) left >= (offsetT) right ? ~ (valueT) 0 : 0;
2121 break;
2122 case O_gt:
2123 left = (offsetT) left > (offsetT) right ? ~ (valueT) 0 : 0;
2124 break;
2125 case O_logical_and: left = left && right; break;
2126 case O_logical_or: left = left || right; break;
2127 default: abort ();
2128 }
2129
2130 op = O_constant;
2131 break;
2132 }
2133
2134 if (op == O_symbol)
2135 {
2136 if (seg_left == absolute_section)
2137 op = O_constant;
2138 else if (seg_left == reg_section && final_val == 0)
2139 op = O_register;
2e1e12b1
JB
2140 else if (add_symbol != expressionP->X_add_symbol)
2141 final_val += left;
2142 expressionP->X_add_symbol = add_symbol;
9497f5ac
NC
2143 }
2144 expressionP->X_op = op;
2145
2146 if (op == O_constant || op == O_register)
2147 final_val += left;
2148 expressionP->X_add_number = final_val;
2149
2150 return 1;
2151}
252b5132 2152\f
929b12bc
KH
2153/* This lives here because it belongs equally in expr.c & read.c.
2154 expr.c is just a branch office read.c anyway, and putting it
2155 here lessens the crowd at read.c.
2156
2157 Assume input_line_pointer is at start of symbol name.
2158 Advance input_line_pointer past symbol name.
2159 Turn that character into a '\0', returning its former value.
2160 This allows a string compare (RMS wants symbol names to be strings)
2161 of the symbol name.
2162 There will always be a char following symbol name, because all good
2163 lines end in end-of-line. */
2164
252b5132 2165char
dd625418 2166get_symbol_end (void)
252b5132
RH
2167{
2168 char c;
2169
2170 /* We accept \001 in a name in case this is being called with a
2171 constructed string. */
2172 if (is_name_beginner (c = *input_line_pointer++) || c == '\001')
58b5739a
RH
2173 {
2174 while (is_part_of_name (c = *input_line_pointer++)
2175 || c == '\001')
2176 ;
2177 if (is_name_ender (c))
2178 c = *input_line_pointer++;
2179 }
252b5132
RH
2180 *--input_line_pointer = 0;
2181 return (c);
2182}
2183
252b5132 2184unsigned int
dd625418 2185get_single_number (void)
252b5132
RH
2186{
2187 expressionS exp;
9497f5ac 2188 operand (&exp, expr_normal);
252b5132 2189 return exp.X_add_number;
252b5132 2190}
This page took 0.651224 seconds and 4 git commands to generate.