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, 2009, 2010, 2011,
4
2012 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 clean_up_expression (expressionS * expressionP);
49
static segT operand (expressionS *, enum expr_mode);
50
static operatorT operatorf (int *);
52
extern const char EXP_CHARS[], FLT_CHARS[];
54
/* We keep a mapping of expression symbols to file positions, so that
55
we can provide better error messages. */
57
struct expr_symbol_line {
58
struct expr_symbol_line *next;
64
static struct expr_symbol_line *expr_symbol_lines;
66
/* Build a dummy symbol to hold a complex expression. This is how we
67
build expressions up out of other expressions. The symbol is put
68
into the fake section expr_section. */
71
make_expr_symbol (expressionS *expressionP)
75
struct expr_symbol_line *n;
77
if (expressionP->X_op == O_symbol
78
&& expressionP->X_add_number == 0)
79
return expressionP->X_add_symbol;
81
if (expressionP->X_op == O_big)
83
/* This won't work, because the actual value is stored in
84
generic_floating_point_number or generic_bignum, and we are
85
going to lose it if we haven't already. */
86
if (expressionP->X_add_number > 0)
87
as_bad (_("bignum invalid"));
89
as_bad (_("floating point number invalid"));
90
zero.X_op = O_constant;
91
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;
166
return make_expr_symbol (&e);
169
/* Build an expression for the current location ('.'). */
172
expr_build_dot (void)
176
current_location (&e);
177
return symbol_clone_if_forward_ref (make_expr_symbol (&e));
180
/* Build any floating-point literal here.
181
Also build any bignum literal here. */
183
/* Seems atof_machine can backscan through generic_bignum and hit whatever
184
happens to be loaded before it in memory. And its way too complicated
185
for me to fix right. Thus a hack. JF: Just make generic_bignum bigger,
186
and never write into the early words, thus they'll always be zero.
187
I hate Dean's floating-point code. Bleh. */
188
LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6];
190
FLONUM_TYPE generic_floating_point_number = {
191
&generic_bignum[6], /* low. (JF: Was 0) */
192
&generic_bignum[SIZE_OF_LARGE_NUMBER + 6 - 1], /* high. JF: (added +6) */
200
floating_constant (expressionS *expressionP)
202
/* input_line_pointer -> floating-point constant. */
205
error_code = atof_generic (&input_line_pointer, ".", EXP_CHARS,
206
&generic_floating_point_number);
210
if (error_code == ERROR_EXPONENT_OVERFLOW)
212
as_bad (_("bad floating-point constant: exponent overflow"));
216
as_bad (_("bad floating-point constant: unknown error code=%d"),
220
expressionP->X_op = O_big;
221
/* input_line_pointer -> just after constant, which may point to
223
expressionP->X_add_number = -1;
227
generic_bignum_to_int32 (void)
230
((generic_bignum[1] & LITTLENUM_MASK) << LITTLENUM_NUMBER_OF_BITS)
231
| (generic_bignum[0] & LITTLENUM_MASK);
232
number &= 0xffffffff;
238
generic_bignum_to_int64 (void)
241
((((((((valueT) generic_bignum[3] & LITTLENUM_MASK)
242
<< LITTLENUM_NUMBER_OF_BITS)
243
| ((valueT) generic_bignum[2] & LITTLENUM_MASK))
244
<< LITTLENUM_NUMBER_OF_BITS)
245
| ((valueT) generic_bignum[1] & LITTLENUM_MASK))
246
<< LITTLENUM_NUMBER_OF_BITS)
247
| ((valueT) generic_bignum[0] & LITTLENUM_MASK));
253
integer_constant (int radix, expressionS *expressionP)
255
char *start; /* Start of number. */
258
valueT number; /* Offset or (absolute) value. */
259
short int digit; /* Value of next digit in current radix. */
260
short int maxdig = 0; /* Highest permitted digit value. */
261
int too_many_digits = 0; /* If we see >= this number of. */
262
char *name; /* Points to name of symbol. */
263
symbolS *symbolP; /* Points to symbol. */
265
int small; /* True if fits in 32 bits. */
267
/* May be bignum, or may fit in 32 bits. */
268
/* Most numbers fit into 32 bits, and we want this case to be fast.
269
so we pretend it will fit into 32 bits. If, after making up a 32
270
bit number, we realise that we have scanned more digits than
271
comfortably fit into 32 bits, we re-scan the digits coding them
272
into a bignum. For decimal and octal numbers we are
273
conservative: Some numbers may be assumed bignums when in fact
274
they do fit into 32 bits. Numbers of any radix can have excess
275
leading zeros: We strive to recognise this and cast them back
276
into 32 bits. We must check that the bignum really is more than
277
32 bits, and change it back to a 32-bit number if it fits. The
278
number we are looking for is expected to be positive, but if it
279
fits into 32 bits as an unsigned number, we let it be a 32-bit
280
number. The cavalier approach is for speed in ordinary cases. */
281
/* This has been extended for 64 bits. We blindly assume that if
282
you're compiling in 64-bit mode, the target is a 64-bit machine.
283
This should be cleaned up. */
287
#else /* includes non-bfd case, mostly */
291
if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri) && radix == 0)
295
/* In MRI mode, the number may have a suffix indicating the
296
radix. For that matter, it might actually be a floating
298
for (suffix = input_line_pointer; ISALNUM (*suffix); suffix++)
300
if (*suffix == 'e' || *suffix == 'E')
304
if (suffix == input_line_pointer)
313
/* If we have both NUMBERS_WITH_SUFFIX and LOCAL_LABELS_FB,
314
we distinguish between 'B' and 'b'. This is the case for
316
if ((NUMBERS_WITH_SUFFIX && LOCAL_LABELS_FB ? *suffix : c) == 'B')
320
else if (c == 'O' || c == 'Q')
324
else if (suffix[1] == '.' || c == 'E' || flt)
326
floating_constant (expressionP);
341
too_many_digits = valuesize + 1;
345
too_many_digits = (valuesize + 2) / 3 + 1;
349
too_many_digits = (valuesize + 3) / 4 + 1;
353
too_many_digits = (valuesize + 11) / 4; /* Very rough. */
356
start = input_line_pointer;
357
c = *input_line_pointer++;
359
(digit = hex_value (c)) < maxdig;
360
c = *input_line_pointer++)
362
number = number * radix + digit;
364
/* c contains character after number. */
365
/* input_line_pointer->char after c. */
366
small = (input_line_pointer - start - 1) < too_many_digits;
368
if (radix == 16 && c == '_')
370
/* This is literal of the form 0x333_0_12345678_1.
371
This example is equivalent to 0x00000333000000001234567800000001. */
373
int num_little_digits = 0;
375
input_line_pointer = start; /* -> 1st digit. */
377
know (LITTLENUM_NUMBER_OF_BITS == 16);
379
for (c = '_'; c == '_'; num_little_digits += 2)
382
/* Convert one 64-bit word. */
385
for (c = *input_line_pointer++;
386
(digit = hex_value (c)) < maxdig;
387
c = *(input_line_pointer++))
389
number = number * radix + digit;
393
/* Check for 8 digit per word max. */
395
as_bad (_("a bignum with underscores may not have more than 8 hex digits in any word"));
397
/* Add this chunk to the bignum.
398
Shift things down 2 little digits. */
399
know (LITTLENUM_NUMBER_OF_BITS == 16);
400
for (i = min (num_little_digits + 1, SIZE_OF_LARGE_NUMBER - 1);
403
generic_bignum[i] = generic_bignum[i - 2];
405
/* Add the new digits as the least significant new ones. */
406
generic_bignum[0] = number & 0xffffffff;
407
generic_bignum[1] = number >> 16;
410
/* Again, c is char after number, input_line_pointer->after c. */
412
if (num_little_digits > SIZE_OF_LARGE_NUMBER - 1)
413
num_little_digits = SIZE_OF_LARGE_NUMBER - 1;
415
gas_assert (num_little_digits >= 4);
417
if (num_little_digits != 8)
418
as_bad (_("a bignum with underscores must have exactly 4 words"));
420
/* We might have some leading zeros. These can be trimmed to give
421
us a change to fit this constant into a small number. */
422
while (generic_bignum[num_little_digits - 1] == 0
423
&& num_little_digits > 1)
426
if (num_little_digits <= 2)
428
/* will fit into 32 bits. */
429
number = generic_bignum_to_int32 ();
433
else if (num_little_digits <= 4)
435
/* Will fit into 64 bits. */
436
number = generic_bignum_to_int64 ();
444
/* Number of littlenums in the bignum. */
445
number = num_little_digits;
450
/* We saw a lot of digits. manufacture a bignum the hard way. */
451
LITTLENUM_TYPE *leader; /* -> high order littlenum of the bignum. */
452
LITTLENUM_TYPE *pointer; /* -> littlenum we are frobbing now. */
455
leader = generic_bignum;
456
generic_bignum[0] = 0;
457
generic_bignum[1] = 0;
458
generic_bignum[2] = 0;
459
generic_bignum[3] = 0;
460
input_line_pointer = start; /* -> 1st digit. */
461
c = *input_line_pointer++;
462
for (; (carry = hex_value (c)) < maxdig; c = *input_line_pointer++)
464
for (pointer = generic_bignum; pointer <= leader; pointer++)
468
work = carry + radix * *pointer;
469
*pointer = work & LITTLENUM_MASK;
470
carry = work >> LITTLENUM_NUMBER_OF_BITS;
474
if (leader < generic_bignum + SIZE_OF_LARGE_NUMBER - 1)
476
/* Room to grow a longer bignum. */
481
/* Again, c is char after number. */
482
/* input_line_pointer -> after c. */
483
know (LITTLENUM_NUMBER_OF_BITS == 16);
484
if (leader < generic_bignum + 2)
486
/* Will fit into 32 bits. */
487
number = generic_bignum_to_int32 ();
491
else if (leader < generic_bignum + 4)
493
/* Will fit into 64 bits. */
494
number = generic_bignum_to_int64 ();
500
/* Number of littlenums in the bignum. */
501
number = leader - generic_bignum + 1;
505
if ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
507
&& input_line_pointer - 1 == suffix)
508
c = *input_line_pointer++;
512
/* Here with number, in correct radix. c is the next char.
513
Note that unlike un*x, we allow "011f" "0x9f" to both mean
514
the same as the (conventional) "9f".
515
This is simply easier than checking for strict canonical
518
if (LOCAL_LABELS_FB && c == 'b')
520
/* Backward ref to local label.
521
Because it is backward, expect it to be defined. */
522
/* Construct a local label. */
523
name = fb_label_name ((int) number, 0);
525
/* Seen before, or symbol is defined: OK. */
526
symbolP = symbol_find (name);
527
if ((symbolP != NULL) && (S_IS_DEFINED (symbolP)))
529
/* Local labels are never absolute. Don't waste time
530
checking absoluteness. */
531
know (SEG_NORMAL (S_GET_SEGMENT (symbolP)));
533
expressionP->X_op = O_symbol;
534
expressionP->X_add_symbol = symbolP;
538
/* Either not seen or not defined. */
539
/* @@ Should print out the original string instead of
540
the parsed number. */
541
as_bad (_("backward ref to unknown label \"%d:\""),
543
expressionP->X_op = O_constant;
546
expressionP->X_add_number = 0;
548
else if (LOCAL_LABELS_FB && c == 'f')
550
/* Forward reference. Expect symbol to be undefined or
551
unknown. undefined: seen it before. unknown: never seen
554
Construct a local label name, then an undefined symbol.
555
Don't create a xseg frag for it: caller may do that.
556
Just return it as never seen before. */
557
name = fb_label_name ((int) number, 1);
558
symbolP = symbol_find_or_make (name);
559
/* We have no need to check symbol properties. */
560
#ifndef many_segments
561
/* Since "know" puts its arg into a "string", we
562
can't have newlines in the argument. */
563
know (S_GET_SEGMENT (symbolP) == undefined_section || S_GET_SEGMENT (symbolP) == text_section || S_GET_SEGMENT (symbolP) == data_section);
565
expressionP->X_op = O_symbol;
566
expressionP->X_add_symbol = symbolP;
567
expressionP->X_add_number = 0;
569
else if (LOCAL_LABELS_DOLLAR && c == '$')
571
/* If the dollar label is *currently* defined, then this is just
572
another reference to it. If it is not *currently* defined,
573
then this is a fresh instantiation of that number, so create
576
if (dollar_label_defined ((long) number))
578
name = dollar_label_name ((long) number, 0);
579
symbolP = symbol_find (name);
580
know (symbolP != NULL);
584
name = dollar_label_name ((long) number, 1);
585
symbolP = symbol_find_or_make (name);
588
expressionP->X_op = O_symbol;
589
expressionP->X_add_symbol = symbolP;
590
expressionP->X_add_number = 0;
594
expressionP->X_op = O_constant;
595
expressionP->X_add_number = number;
596
input_line_pointer--; /* Restore following character. */
597
} /* Really just a number. */
601
/* Not a small number. */
602
expressionP->X_op = O_big;
603
expressionP->X_add_number = number; /* Number of littlenums. */
604
input_line_pointer--; /* -> char following number. */
608
/* Parse an MRI multi character constant. */
611
mri_char_constant (expressionS *expressionP)
615
if (*input_line_pointer == '\''
616
&& input_line_pointer[1] != '\'')
618
expressionP->X_op = O_constant;
619
expressionP->X_add_number = 0;
623
/* In order to get the correct byte ordering, we must build the
624
number in reverse. */
625
for (i = SIZE_OF_LARGE_NUMBER - 1; i >= 0; i--)
629
generic_bignum[i] = 0;
630
for (j = 0; j < CHARS_PER_LITTLENUM; j++)
632
if (*input_line_pointer == '\'')
634
if (input_line_pointer[1] != '\'')
636
++input_line_pointer;
638
generic_bignum[i] <<= 8;
639
generic_bignum[i] += *input_line_pointer;
640
++input_line_pointer;
643
if (i < SIZE_OF_LARGE_NUMBER - 1)
645
/* If there is more than one littlenum, left justify the
646
last one to make it match the earlier ones. If there is
647
only one, we can just use the value directly. */
648
for (; j < CHARS_PER_LITTLENUM; j++)
649
generic_bignum[i] <<= 8;
652
if (*input_line_pointer == '\''
653
&& input_line_pointer[1] != '\'')
659
as_bad (_("character constant too large"));
668
c = SIZE_OF_LARGE_NUMBER - i;
669
for (j = 0; j < c; j++)
670
generic_bignum[j] = generic_bignum[i + j];
674
know (LITTLENUM_NUMBER_OF_BITS == 16);
677
expressionP->X_op = O_big;
678
expressionP->X_add_number = i;
682
expressionP->X_op = O_constant;
684
expressionP->X_add_number = generic_bignum[0] & LITTLENUM_MASK;
686
expressionP->X_add_number =
687
(((generic_bignum[1] & LITTLENUM_MASK)
688
<< LITTLENUM_NUMBER_OF_BITS)
689
| (generic_bignum[0] & LITTLENUM_MASK));
692
/* Skip the final closing quote. */
693
++input_line_pointer;
696
/* Return an expression representing the current location. This
697
handles the magic symbol `.'. */
700
current_location (expressionS *expressionp)
702
if (now_seg == absolute_section)
704
expressionp->X_op = O_constant;
705
expressionp->X_add_number = abs_section_offset;
709
expressionp->X_op = O_symbol;
710
expressionp->X_add_symbol = &dot_symbol;
711
expressionp->X_add_number = 0;
715
/* In: Input_line_pointer points to 1st char of operand, which may
719
The operand may have been empty: in this case X_op == O_absent.
720
Input_line_pointer->(next non-blank) char after operand. */
723
operand (expressionS *expressionP, enum expr_mode mode)
726
symbolS *symbolP; /* Points to symbol. */
727
char *name; /* Points to name of symbol. */
730
/* All integers are regarded as unsigned unless they are negated.
731
This is because the only thing which cares whether a number is
732
unsigned is the code in emit_expr which extends constants into
733
bignums. It should only sign extend negative numbers, so that
734
something like ``.quad 0x80000000'' is not sign extended even
735
though it appears negative if valueT is 32 bits. */
736
expressionP->X_unsigned = 1;
737
expressionP->X_extrabit = 0;
739
/* Digits, assume it is a bignum. */
741
SKIP_WHITESPACE (); /* Leading whitespace is part of operand. */
742
c = *input_line_pointer++; /* input_line_pointer -> past char in c. */
744
if (is_end_of_line[(unsigned char) c])
758
input_line_pointer--;
760
integer_constant ((NUMBERS_WITH_SUFFIX || flag_m68k_mri)
765
#ifdef LITERAL_PREFIXDOLLAR_HEX
767
/* $L is the start of a local label, not a hex constant. */
768
if (* input_line_pointer == 'L')
770
integer_constant (16, expressionP);
774
#ifdef LITERAL_PREFIXPERCENT_BIN
776
integer_constant (2, expressionP);
781
/* Non-decimal radix. */
783
if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
787
/* Check for a hex or float constant. */
788
for (s = input_line_pointer; hex_p (*s); s++)
790
if (*s == 'h' || *s == 'H' || *input_line_pointer == '.')
792
--input_line_pointer;
793
integer_constant (0, expressionP);
797
c = *input_line_pointer;
806
if (NUMBERS_WITH_SUFFIX || flag_m68k_mri)
808
integer_constant (0, expressionP);
814
if (c && strchr (FLT_CHARS, c))
816
input_line_pointer++;
817
floating_constant (expressionP);
818
expressionP->X_add_number = - TOLOWER (c);
822
/* The string was only zero. */
823
expressionP->X_op = O_constant;
824
expressionP->X_add_number = 0;
833
input_line_pointer++;
834
integer_constant (16, expressionP);
838
if (LOCAL_LABELS_FB && ! (flag_m68k_mri || NUMBERS_WITH_SUFFIX))
840
/* This code used to check for '+' and '-' here, and, in
841
some conditions, fall through to call
842
integer_constant. However, that didn't make sense,
843
as integer_constant only accepts digits. */
844
/* Some of our code elsewhere does permit digits greater
845
than the expected base; for consistency, do the same
847
if (input_line_pointer[1] < '0'
848
|| input_line_pointer[1] > '9')
850
/* Parse this as a back reference to label 0. */
851
input_line_pointer--;
852
integer_constant (10, expressionP);
855
/* Otherwise, parse this as a binary number. */
859
input_line_pointer++;
860
if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
862
integer_constant (2, expressionP);
873
integer_constant ((flag_m68k_mri || NUMBERS_WITH_SUFFIX)
881
/* If it says "0f" and it could possibly be a floating point
882
number, make it one. Otherwise, make it a local label,
883
and try to deal with parsing the rest later. */
884
if (!input_line_pointer[1]
885
|| (is_end_of_line[0xff & input_line_pointer[1]])
886
|| strchr (FLT_CHARS, 'f') == NULL)
889
char *cp = input_line_pointer + 1;
890
int r = atof_generic (&cp, ".", EXP_CHARS,
891
&generic_floating_point_number);
895
case ERROR_EXPONENT_OVERFLOW:
896
if (*cp == 'f' || *cp == 'b')
897
/* Looks like a difference expression. */
899
else if (cp == input_line_pointer + 1)
900
/* No characters has been accepted -- looks like
906
as_fatal (_("expr.c(operand): bad atof_generic return val %d"),
911
/* Okay, now we've sorted it out. We resume at one of these
912
two labels, depending on what we've decided we're probably
915
input_line_pointer--;
916
integer_constant (10, expressionP);
926
if (flag_m68k_mri || NUMBERS_WITH_SUFFIX)
928
integer_constant (0, expressionP);
938
input_line_pointer++;
939
floating_constant (expressionP);
940
expressionP->X_add_number = - TOLOWER (c);
944
if (LOCAL_LABELS_DOLLAR)
946
integer_constant (10, expressionP);
955
#ifndef NEED_INDEX_OPERATOR
957
# ifdef md_need_index_operator
958
if (md_need_index_operator())
964
/* Didn't begin with digit & not a name. */
965
segment = expr (0, expressionP, mode);
966
/* expression () will pass trailing whitespace. */
967
if ((c == '(' && *input_line_pointer != ')')
968
|| (c == '[' && *input_line_pointer != ']'))
969
as_bad (_("missing '%c'"), c == '(' ? ')' : ']');
971
input_line_pointer++;
973
/* Here with input_line_pointer -> char after "(...)". */
978
if (! flag_m68k_mri || *input_line_pointer != '\'')
980
as_bad (_("EBCDIC constants are not supported"));
983
if (! flag_m68k_mri || *input_line_pointer != '\'')
985
++input_line_pointer;
991
/* Warning: to conform to other people's assemblers NO
992
ESCAPEMENT is permitted for a single quote. The next
993
character, parity errors and all, is taken as the value
994
of the operand. VERY KINKY. */
995
expressionP->X_op = O_constant;
996
expressionP->X_add_number = *input_line_pointer++;
1000
mri_char_constant (expressionP);
1005
/* Double quote is the bitwise not operator in MRI mode. */
1006
if (! flag_m68k_mri)
1011
/* '~' is permitted to start a label on the Delta. */
1012
if (is_name_beginner (c))
1021
operand (expressionP, mode);
1022
if (expressionP->X_op == O_constant)
1024
/* input_line_pointer -> char after operand. */
1027
expressionP->X_add_number = - expressionP->X_add_number;
1028
/* Notice: '-' may overflow: no warning is given.
1029
This is compatible with other people's
1030
assemblers. Sigh. */
1031
expressionP->X_unsigned = 0;
1032
if (expressionP->X_add_number)
1033
expressionP->X_extrabit ^= 1;
1035
else if (c == '~' || c == '"')
1036
expressionP->X_add_number = ~ expressionP->X_add_number;
1038
expressionP->X_add_number = ! expressionP->X_add_number;
1040
else if (expressionP->X_op == O_big
1041
&& expressionP->X_add_number <= 0
1043
&& (generic_floating_point_number.sign == '+'
1044
|| generic_floating_point_number.sign == 'P'))
1046
/* Negative flonum (eg, -1.000e0). */
1047
if (generic_floating_point_number.sign == '+')
1048
generic_floating_point_number.sign = '-';
1050
generic_floating_point_number.sign = 'N';
1052
else if (expressionP->X_op == O_big
1053
&& expressionP->X_add_number > 0)
1057
if (c == '~' || c == '-')
1059
for (i = 0; i < expressionP->X_add_number; ++i)
1060
generic_bignum[i] = ~generic_bignum[i];
1062
/* Extend the bignum to at least the size of .octa. */
1063
if (expressionP->X_add_number < SIZE_OF_LARGE_NUMBER)
1065
expressionP->X_add_number = SIZE_OF_LARGE_NUMBER;
1066
for (; i < expressionP->X_add_number; ++i)
1067
generic_bignum[i] = ~(LITTLENUM_TYPE) 0;
1071
for (i = 0; i < expressionP->X_add_number; ++i)
1073
generic_bignum[i] += 1;
1074
if (generic_bignum[i])
1080
for (i = 0; i < expressionP->X_add_number; ++i)
1081
if (generic_bignum[i] != 0)
1083
expressionP->X_add_number = i >= expressionP->X_add_number;
1084
expressionP->X_op = O_constant;
1085
expressionP->X_unsigned = 1;
1086
expressionP->X_extrabit = 0;
1089
else if (expressionP->X_op != O_illegal
1090
&& expressionP->X_op != O_absent)
1094
expressionP->X_add_symbol = make_expr_symbol (expressionP);
1096
expressionP->X_op = O_uminus;
1097
else if (c == '~' || c == '"')
1098
expressionP->X_op = O_bit_not;
1100
expressionP->X_op = O_logical_not;
1101
expressionP->X_add_number = 0;
1105
as_warn (_("Unary operator %c ignored because bad operand follows"),
1110
#if defined (DOLLAR_DOT) || defined (TC_M68K)
1112
/* '$' is the program counter when in MRI mode, or when
1113
DOLLAR_DOT is defined. */
1115
if (! flag_m68k_mri)
1118
if (DOLLAR_AMBIGU && hex_p (*input_line_pointer))
1120
/* In MRI mode and on Z80, '$' is also used as the prefix
1121
for a hexadecimal constant. */
1122
integer_constant (16, expressionP);
1126
if (is_part_of_name (*input_line_pointer))
1129
current_location (expressionP);
1134
if (!is_part_of_name (*input_line_pointer))
1136
current_location (expressionP);
1139
else if ((strncasecmp (input_line_pointer, "startof.", 8) == 0
1140
&& ! is_part_of_name (input_line_pointer[8]))
1141
|| (strncasecmp (input_line_pointer, "sizeof.", 7) == 0
1142
&& ! is_part_of_name (input_line_pointer[7])))
1146
start = (input_line_pointer[1] == 't'
1147
|| input_line_pointer[1] == 'T');
1148
input_line_pointer += start ? 8 : 7;
1150
if (*input_line_pointer != '(')
1151
as_bad (_("syntax error in .startof. or .sizeof."));
1156
++input_line_pointer;
1158
name = input_line_pointer;
1159
c = get_symbol_end ();
1161
buf = (char *) xmalloc (strlen (name) + 10);
1163
sprintf (buf, ".startof.%s", name);
1165
sprintf (buf, ".sizeof.%s", name);
1166
symbolP = symbol_make (buf);
1169
expressionP->X_op = O_symbol;
1170
expressionP->X_add_symbol = symbolP;
1171
expressionP->X_add_number = 0;
1173
*input_line_pointer = c;
1175
if (*input_line_pointer != ')')
1176
as_bad (_("syntax error in .startof. or .sizeof."));
1178
++input_line_pointer;
1189
/* Can't imagine any other kind of operand. */
1190
expressionP->X_op = O_absent;
1191
input_line_pointer--;
1196
if (! flag_m68k_mri)
1198
integer_constant (2, expressionP);
1202
if (! flag_m68k_mri)
1204
integer_constant (8, expressionP);
1208
if (! flag_m68k_mri)
1211
/* In MRI mode, this is a floating point constant represented
1212
using hexadecimal digits. */
1214
++input_line_pointer;
1215
integer_constant (16, expressionP);
1219
if (! flag_m68k_mri || is_part_of_name (*input_line_pointer))
1222
current_location (expressionP);
1227
#if defined(md_need_index_operator) || defined(TC_M68K)
1230
if (is_name_beginner (c)) /* Here if did not begin with a digit. */
1232
/* Identifier begins here.
1233
This is kludged for speed, so code is repeated. */
1235
name = --input_line_pointer;
1236
c = get_symbol_end ();
1240
operatorT op = md_operator (name, 1, &c);
1245
*input_line_pointer = c;
1249
*input_line_pointer = c;
1253
*input_line_pointer = c;
1257
as_bad (_("invalid use of operator \"%s\""), name);
1262
if (op != O_absent && op != O_illegal)
1264
*input_line_pointer = c;
1265
expr (9, expressionP, mode);
1266
expressionP->X_add_symbol = make_expr_symbol (expressionP);
1267
expressionP->X_op_symbol = NULL;
1268
expressionP->X_add_number = 0;
1269
expressionP->X_op = op;
1275
#ifdef md_parse_name
1276
/* This is a hook for the backend to parse certain names
1277
specially in certain contexts. If a name always has a
1278
specific value, it can often be handled by simply
1279
entering it in the symbol table. */
1280
if (md_parse_name (name, expressionP, mode, &c))
1282
*input_line_pointer = c;
1288
/* The MRI i960 assembler permits
1290
FIXME: This should use md_parse_name. */
1292
&& (strcasecmp (name, "sizeof") == 0
1293
|| strcasecmp (name, "startof") == 0))
1298
start = (name[1] == 't'
1301
*input_line_pointer = c;
1304
name = input_line_pointer;
1305
c = get_symbol_end ();
1307
buf = (char *) xmalloc (strlen (name) + 10);
1309
sprintf (buf, ".startof.%s", name);
1311
sprintf (buf, ".sizeof.%s", name);
1312
symbolP = symbol_make (buf);
1315
expressionP->X_op = O_symbol;
1316
expressionP->X_add_symbol = symbolP;
1317
expressionP->X_add_number = 0;
1319
*input_line_pointer = c;
1326
symbolP = symbol_find_or_make (name);
1328
/* If we have an absolute symbol or a reg, then we know its
1330
segment = S_GET_SEGMENT (symbolP);
1331
if (mode != expr_defer
1332
&& segment == absolute_section
1333
&& !S_FORCE_RELOC (symbolP, 0))
1335
expressionP->X_op = O_constant;
1336
expressionP->X_add_number = S_GET_VALUE (symbolP);
1338
else if (mode != expr_defer && segment == reg_section)
1340
expressionP->X_op = O_register;
1341
expressionP->X_add_number = S_GET_VALUE (symbolP);
1345
expressionP->X_op = O_symbol;
1346
expressionP->X_add_symbol = symbolP;
1347
expressionP->X_add_number = 0;
1349
*input_line_pointer = c;
1353
/* Let the target try to parse it. Success is indicated by changing
1354
the X_op field to something other than O_absent and pointing
1355
input_line_pointer past the expression. If it can't parse the
1356
expression, X_op and input_line_pointer should be unchanged. */
1357
expressionP->X_op = O_absent;
1358
--input_line_pointer;
1359
md_operand (expressionP);
1360
if (expressionP->X_op == O_absent)
1362
++input_line_pointer;
1363
as_bad (_("bad expression"));
1364
expressionP->X_op = O_constant;
1365
expressionP->X_add_number = 0;
1371
/* It is more 'efficient' to clean up the expressionS when they are
1372
created. Doing it here saves lines of code. */
1373
clean_up_expression (expressionP);
1374
SKIP_WHITESPACE (); /* -> 1st char after operand. */
1375
know (*input_line_pointer != ' ');
1377
/* The PA port needs this information. */
1378
if (expressionP->X_add_symbol)
1379
symbol_mark_used (expressionP->X_add_symbol);
1381
if (mode != expr_defer)
1383
expressionP->X_add_symbol
1384
= symbol_clone_if_forward_ref (expressionP->X_add_symbol);
1385
expressionP->X_op_symbol
1386
= symbol_clone_if_forward_ref (expressionP->X_op_symbol);
1389
switch (expressionP->X_op)
1392
return absolute_section;
1394
return S_GET_SEGMENT (expressionP->X_add_symbol);
1400
/* Internal. Simplify a struct expression for use by expr (). */
1402
/* In: address of an expressionS.
1403
The X_op field of the expressionS may only take certain values.
1404
Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
1406
Out: expressionS may have been modified:
1407
Unused fields zeroed to help expr (). */
1410
clean_up_expression (expressionS *expressionP)
1412
switch (expressionP->X_op)
1416
expressionP->X_add_number = 0;
1421
expressionP->X_add_symbol = NULL;
1426
expressionP->X_op_symbol = NULL;
1433
/* Expression parser. */
1435
/* We allow an empty expression, and just assume (absolute,0) silently.
1436
Unary operators and parenthetical expressions are treated as operands.
1437
As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
1439
We used to do an aho/ullman shift-reduce parser, but the logic got so
1440
warped that I flushed it and wrote a recursive-descent parser instead.
1441
Now things are stable, would anybody like to write a fast parser?
1442
Most expressions are either register (which does not even reach here)
1443
or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
1444
So I guess it doesn't really matter how inefficient more complex expressions
1447
After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
1448
Also, we have consumed any leading or trailing spaces (operand does that)
1449
and done all intervening operators.
1451
This returns the segment of the result, which will be
1452
absolute_section or the segment of a symbol. */
1455
#define __ O_illegal
1457
#define O_SINGLE_EQ O_illegal
1460
/* Maps ASCII -> operators. */
1461
static const operatorT op_encoding[256] = {
1462
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1463
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1465
__, O_bit_or_not, __, __, __, O_modulus, O_bit_and, __,
1466
__, __, O_multiply, O_add, __, O_subtract, __, O_divide,
1467
__, __, __, __, __, __, __, __,
1468
__, __, __, __, O_lt, O_SINGLE_EQ, O_gt, __,
1469
__, __, __, __, __, __, __, __,
1470
__, __, __, __, __, __, __, __,
1471
__, __, __, __, __, __, __, __,
1473
#ifdef NEED_INDEX_OPERATOR
1478
__, __, O_bit_exclusive_or, __,
1479
__, __, __, __, __, __, __, __,
1480
__, __, __, __, __, __, __, __,
1481
__, __, __, __, __, __, __, __,
1482
__, __, __, __, O_bit_inclusive_or, __, __, __,
1484
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1485
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1486
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1487
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1488
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1489
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1490
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
1491
__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
1495
0 operand, (expression)
1500
5 used for * / % in MRI mode
1505
static operator_rankT op_rank[O_max] = {
1510
0, /* O_symbol_rva */
1515
9, /* O_logical_not */
1519
8, /* O_left_shift */
1520
8, /* O_right_shift */
1521
7, /* O_bit_inclusive_or */
1522
7, /* O_bit_or_not */
1523
7, /* O_bit_exclusive_or */
1533
3, /* O_logical_and */
1534
2, /* O_logical_or */
1538
/* Unfortunately, in MRI mode for the m68k, multiplication and
1539
division have lower precedence than the bit wise operators. This
1540
function sets the operator precedences correctly for the current
1541
mode. Also, MRI uses a different bit_not operator, and this fixes
1544
#define STANDARD_MUL_PRECEDENCE 8
1545
#define MRI_MUL_PRECEDENCE 6
1548
expr_set_precedence (void)
1552
op_rank[O_multiply] = MRI_MUL_PRECEDENCE;
1553
op_rank[O_divide] = MRI_MUL_PRECEDENCE;
1554
op_rank[O_modulus] = MRI_MUL_PRECEDENCE;
1558
op_rank[O_multiply] = STANDARD_MUL_PRECEDENCE;
1559
op_rank[O_divide] = STANDARD_MUL_PRECEDENCE;
1560
op_rank[O_modulus] = STANDARD_MUL_PRECEDENCE;
1565
expr_set_rank (operatorT op, operator_rankT rank)
1567
gas_assert (op >= O_md1 && op < ARRAY_SIZE (op_rank));
1571
/* Initialize the expression parser. */
1576
expr_set_precedence ();
1578
/* Verify that X_op field is wide enough. */
1582
gas_assert (e.X_op == O_max);
1586
/* Return the encoding for the operator at INPUT_LINE_POINTER, and
1587
sets NUM_CHARS to the number of characters in the operator.
1588
Does not advance INPUT_LINE_POINTER. */
1590
static inline operatorT
1591
operatorf (int *num_chars)
1596
c = *input_line_pointer & 0xff;
1599
if (is_end_of_line[c])
1603
if (is_name_beginner (c))
1605
char *name = input_line_pointer;
1606
char ec = get_symbol_end ();
1608
ret = md_operator (name, 2, &ec);
1612
*input_line_pointer = ec;
1613
input_line_pointer = name;
1618
as_bad (_("invalid use of operator \"%s\""), name);
1622
*input_line_pointer = ec;
1623
*num_chars = input_line_pointer - name;
1624
input_line_pointer = name;
1633
ret = op_encoding[c];
1635
if (ret == O_illegal)
1637
char *start = input_line_pointer;
1639
ret = md_operator (NULL, 2, NULL);
1640
if (ret != O_illegal)
1641
*num_chars = input_line_pointer - start;
1642
input_line_pointer = start;
1649
return op_encoding[c];
1652
switch (input_line_pointer[1])
1655
return op_encoding[c];
1670
if (input_line_pointer[1] != '=')
1671
return op_encoding[c];
1677
switch (input_line_pointer[1])
1680
return op_encoding[c];
1682
ret = O_right_shift;
1692
switch (input_line_pointer[1])
1695
/* We accept !! as equivalent to ^ for MRI compatibility. */
1697
return O_bit_exclusive_or;
1699
/* We accept != as equivalent to <>. */
1704
return O_bit_inclusive_or;
1705
return op_encoding[c];
1709
if (input_line_pointer[1] != '|')
1710
return op_encoding[c];
1713
return O_logical_or;
1716
if (input_line_pointer[1] != '&')
1717
return op_encoding[c];
1720
return O_logical_and;
1726
/* Implement "word-size + 1 bit" addition for
1727
{resultP->X_extrabit:resultP->X_add_number} + {rhs_highbit:amount}. This
1728
is used so that the full range of unsigned word values and the full range of
1729
signed word values can be represented in an O_constant expression, which is
1730
useful e.g. for .sleb128 directives. */
1733
add_to_result (expressionS *resultP, offsetT amount, int rhs_highbit)
1735
valueT ures = resultP->X_add_number;
1736
valueT uamount = amount;
1738
resultP->X_add_number += amount;
1740
resultP->X_extrabit ^= rhs_highbit;
1742
if (ures + uamount < ures)
1743
resultP->X_extrabit ^= 1;
1746
/* Similarly, for subtraction. */
1749
subtract_from_result (expressionS *resultP, offsetT amount, int rhs_highbit)
1751
valueT ures = resultP->X_add_number;
1752
valueT uamount = amount;
1754
resultP->X_add_number -= amount;
1756
resultP->X_extrabit ^= rhs_highbit;
1759
resultP->X_extrabit ^= 1;
1762
/* Parse an expression. */
1765
expr (int rankarg, /* Larger # is higher rank. */
1766
expressionS *resultP, /* Deliver result here. */
1767
enum expr_mode mode /* Controls behavior. */)
1769
operator_rankT rank = (operator_rankT) rankarg;
1776
know (rankarg >= 0);
1778
/* Save the value of dot for the fixup code. */
1781
dot_value = frag_now_fix ();
1782
dot_frag = frag_now;
1785
retval = operand (resultP, mode);
1787
/* operand () gobbles spaces. */
1788
know (*input_line_pointer != ' ');
1790
op_left = operatorf (&op_chars);
1791
while (op_left != O_illegal && op_rank[(int) op_left] > rank)
1796
input_line_pointer += op_chars; /* -> after operator. */
1799
rightseg = expr (op_rank[(int) op_left], &right, mode);
1800
if (right.X_op == O_absent)
1802
as_warn (_("missing operand; zero assumed"));
1803
right.X_op = O_constant;
1804
right.X_add_number = 0;
1805
right.X_add_symbol = NULL;
1806
right.X_op_symbol = NULL;
1809
know (*input_line_pointer != ' ');
1811
if (op_left == O_index)
1813
if (*input_line_pointer != ']')
1814
as_bad ("missing right bracket");
1817
++input_line_pointer;
1822
op_right = operatorf (&op_chars);
1824
know (op_right == O_illegal || op_left == O_index
1825
|| op_rank[(int) op_right] <= op_rank[(int) op_left]);
1826
know ((int) op_left >= (int) O_multiply);
1828
know ((int) op_left <= (int) O_index);
1830
know ((int) op_left < (int) O_max);
1833
/* input_line_pointer->after right-hand quantity. */
1834
/* left-hand quantity in resultP. */
1835
/* right-hand quantity in right. */
1836
/* operator in op_left. */
1838
if (resultP->X_op == O_big)
1840
if (resultP->X_add_number > 0)
1841
as_warn (_("left operand is a bignum; integer 0 assumed"));
1843
as_warn (_("left operand is a float; integer 0 assumed"));
1844
resultP->X_op = O_constant;
1845
resultP->X_add_number = 0;
1846
resultP->X_add_symbol = NULL;
1847
resultP->X_op_symbol = NULL;
1849
if (right.X_op == O_big)
1851
if (right.X_add_number > 0)
1852
as_warn (_("right operand is a bignum; integer 0 assumed"));
1854
as_warn (_("right operand is a float; integer 0 assumed"));
1855
right.X_op = O_constant;
1856
right.X_add_number = 0;
1857
right.X_add_symbol = NULL;
1858
right.X_op_symbol = NULL;
1861
/* Optimize common cases. */
1862
#ifdef md_optimize_expr
1863
if (md_optimize_expr (resultP, op_left, &right))
1870
#ifndef md_register_arithmetic
1871
# define md_register_arithmetic 1
1873
if (op_left == O_add && right.X_op == O_constant
1874
&& (md_register_arithmetic || resultP->X_op != O_register))
1877
add_to_result (resultP, right.X_add_number, right.X_extrabit);
1879
/* This case comes up in PIC code. */
1880
else if (op_left == O_subtract
1881
&& right.X_op == O_symbol
1882
&& resultP->X_op == O_symbol
1883
&& retval == rightseg
1884
#ifdef md_allow_local_subtract
1885
&& md_allow_local_subtract (resultP, & right, rightseg)
1887
&& ((SEG_NORMAL (rightseg)
1888
&& !S_FORCE_RELOC (resultP->X_add_symbol, 0)
1889
&& !S_FORCE_RELOC (right.X_add_symbol, 0))
1890
|| right.X_add_symbol == resultP->X_add_symbol)
1891
&& frag_offset_fixed_p (symbol_get_frag (resultP->X_add_symbol),
1892
symbol_get_frag (right.X_add_symbol),
1895
offsetT symval_diff = S_GET_VALUE (resultP->X_add_symbol)
1896
- S_GET_VALUE (right.X_add_symbol);
1897
subtract_from_result (resultP, right.X_add_number, right.X_extrabit);
1898
subtract_from_result (resultP, frag_off / OCTETS_PER_BYTE, 0);
1899
add_to_result (resultP, symval_diff, symval_diff < 0);
1900
resultP->X_op = O_constant;
1901
resultP->X_add_symbol = 0;
1903
else if (op_left == O_subtract && right.X_op == O_constant
1904
&& (md_register_arithmetic || resultP->X_op != O_register))
1907
subtract_from_result (resultP, right.X_add_number, right.X_extrabit);
1909
else if (op_left == O_add && resultP->X_op == O_constant
1910
&& (md_register_arithmetic || right.X_op != O_register))
1913
resultP->X_op = right.X_op;
1914
resultP->X_add_symbol = right.X_add_symbol;
1915
resultP->X_op_symbol = right.X_op_symbol;
1916
add_to_result (resultP, right.X_add_number, right.X_extrabit);
1919
else if (resultP->X_op == O_constant && right.X_op == O_constant)
1921
/* Constant OP constant. */
1922
offsetT v = right.X_add_number;
1923
if (v == 0 && (op_left == O_divide || op_left == O_modulus))
1925
as_warn (_("division by zero"));
1928
if ((valueT) v >= sizeof(valueT) * CHAR_BIT
1929
&& (op_left == O_left_shift || op_left == O_right_shift))
1931
as_warn_value_out_of_range (_("shift count"), v, 0,
1932
sizeof(valueT) * CHAR_BIT - 1,
1934
resultP->X_add_number = v = 0;
1938
default: goto general;
1939
case O_multiply: resultP->X_add_number *= v; break;
1940
case O_divide: resultP->X_add_number /= v; break;
1941
case O_modulus: resultP->X_add_number %= v; break;
1942
case O_left_shift: resultP->X_add_number <<= v; break;
1944
/* We always use unsigned shifts, to avoid relying on
1945
characteristics of the compiler used to compile gas. */
1946
resultP->X_add_number =
1947
(offsetT) ((valueT) resultP->X_add_number >> (valueT) v);
1949
case O_bit_inclusive_or: resultP->X_add_number |= v; break;
1950
case O_bit_or_not: resultP->X_add_number |= ~v; break;
1951
case O_bit_exclusive_or: resultP->X_add_number ^= v; break;
1952
case O_bit_and: resultP->X_add_number &= v; break;
1953
/* Constant + constant (O_add) is handled by the
1954
previous if statement for constant + X, so is omitted
1957
subtract_from_result (resultP, v, 0);
1960
resultP->X_add_number =
1961
resultP->X_add_number == v ? ~ (offsetT) 0 : 0;
1964
resultP->X_add_number =
1965
resultP->X_add_number != v ? ~ (offsetT) 0 : 0;
1968
resultP->X_add_number =
1969
resultP->X_add_number < v ? ~ (offsetT) 0 : 0;
1972
resultP->X_add_number =
1973
resultP->X_add_number <= v ? ~ (offsetT) 0 : 0;
1976
resultP->X_add_number =
1977
resultP->X_add_number >= v ? ~ (offsetT) 0 : 0;
1980
resultP->X_add_number =
1981
resultP->X_add_number > v ? ~ (offsetT) 0 : 0;
1984
resultP->X_add_number = resultP->X_add_number && v;
1987
resultP->X_add_number = resultP->X_add_number || v;
1991
else if (resultP->X_op == O_symbol
1992
&& right.X_op == O_symbol
1993
&& (op_left == O_add
1994
|| op_left == O_subtract
1995
|| (resultP->X_add_number == 0
1996
&& right.X_add_number == 0)))
1998
/* Symbol OP symbol. */
1999
resultP->X_op = op_left;
2000
resultP->X_op_symbol = right.X_add_symbol;
2001
if (op_left == O_add)
2002
add_to_result (resultP, right.X_add_number, right.X_extrabit);
2003
else if (op_left == O_subtract)
2005
subtract_from_result (resultP, right.X_add_number,
2007
if (retval == rightseg
2008
&& SEG_NORMAL (retval)
2009
&& !S_FORCE_RELOC (resultP->X_add_symbol, 0)
2010
&& !S_FORCE_RELOC (right.X_add_symbol, 0))
2012
retval = absolute_section;
2013
rightseg = absolute_section;
2020
/* The general case. */
2021
resultP->X_add_symbol = make_expr_symbol (resultP);
2022
resultP->X_op_symbol = make_expr_symbol (&right);
2023
resultP->X_op = op_left;
2024
resultP->X_add_number = 0;
2025
resultP->X_unsigned = 1;
2026
resultP->X_extrabit = 0;
2029
if (retval != rightseg)
2031
if (retval == undefined_section)
2033
else if (rightseg == undefined_section)
2035
else if (retval == expr_section)
2037
else if (rightseg == expr_section)
2039
else if (retval == reg_section)
2041
else if (rightseg == reg_section)
2043
else if (rightseg == absolute_section)
2045
else if (retval == absolute_section)
2048
else if (op_left == O_subtract)
2052
as_bad (_("operation combines symbols in different segments"));
2056
} /* While next operator is >= this rank. */
2058
/* The PA port needs this information. */
2059
if (resultP->X_add_symbol)
2060
symbol_mark_used (resultP->X_add_symbol);
2062
if (rank == 0 && mode == expr_evaluate)
2063
resolve_expression (resultP);
2065
return resultP->X_op == O_constant ? absolute_section : retval;
2068
/* Resolve an expression without changing any symbols/sub-expressions
2072
resolve_expression (expressionS *expressionP)
2074
/* Help out with CSE. */
2075
valueT final_val = expressionP->X_add_number;
2076
symbolS *add_symbol = expressionP->X_add_symbol;
2077
symbolS *orig_add_symbol = add_symbol;
2078
symbolS *op_symbol = expressionP->X_op_symbol;
2079
operatorT op = expressionP->X_op;
2081
segT seg_left, seg_right;
2082
fragS *frag_left, *frag_right;
2097
if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left))
2105
if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left))
2108
if (seg_left != absolute_section)
2111
if (op == O_logical_not)
2113
else if (op == O_uminus)
2125
case O_bit_inclusive_or:
2127
case O_bit_exclusive_or:
2139
if (!snapshot_symbol (&add_symbol, &left, &seg_left, &frag_left)
2140
|| !snapshot_symbol (&op_symbol, &right, &seg_right, &frag_right))
2143
/* Simplify addition or subtraction of a constant by folding the
2144
constant into X_add_number. */
2147
if (seg_right == absolute_section)
2153
else if (seg_left == absolute_section)
2157
seg_left = seg_right;
2158
add_symbol = op_symbol;
2159
orig_add_symbol = expressionP->X_op_symbol;
2164
else if (op == O_subtract)
2166
if (seg_right == absolute_section)
2174
/* Equality and non-equality tests are permitted on anything.
2175
Subtraction, and other comparison operators are permitted if
2176
both operands are in the same section.
2177
Shifts by constant zero are permitted on anything.
2178
Multiplies, bit-ors, and bit-ands with constant zero are
2179
permitted on anything.
2180
Multiplies and divides by constant one are permitted on
2182
Binary operations with both operands being the same register
2183
or undefined symbol are permitted if the result doesn't depend
2185
Otherwise, both operands must be absolute. We already handled
2186
the case of addition or subtraction of a constant above. */
2188
if (!(seg_left == absolute_section
2189
&& seg_right == absolute_section)
2190
&& !(op == O_eq || op == O_ne)
2191
&& !((op == O_subtract
2192
|| op == O_lt || op == O_le || op == O_ge || op == O_gt)
2193
&& seg_left == seg_right
2195
|| frag_offset_fixed_p (frag_left, frag_right, &frag_off))
2196
&& (seg_left != reg_section || left == right)
2197
&& (seg_left != undefined_section || add_symbol == op_symbol)))
2199
if ((seg_left == absolute_section && left == 0)
2200
|| (seg_right == absolute_section && right == 0))
2202
if (op == O_bit_exclusive_or || op == O_bit_inclusive_or)
2204
if (!(seg_right == absolute_section && right == 0))
2206
seg_left = seg_right;
2208
add_symbol = op_symbol;
2209
orig_add_symbol = expressionP->X_op_symbol;
2214
else if (op == O_left_shift || op == O_right_shift)
2216
if (!(seg_left == absolute_section && left == 0))
2222
else if (op != O_multiply
2223
&& op != O_bit_or_not && op != O_bit_and)
2226
else if (op == O_multiply
2227
&& seg_left == absolute_section && left == 1)
2229
seg_left = seg_right;
2231
add_symbol = op_symbol;
2232
orig_add_symbol = expressionP->X_op_symbol;
2236
else if ((op == O_multiply || op == O_divide)
2237
&& seg_right == absolute_section && right == 1)
2242
else if (!(left == right
2243
&& ((seg_left == reg_section && seg_right == reg_section)
2244
|| (seg_left == undefined_section
2245
&& seg_right == undefined_section
2246
&& add_symbol == op_symbol))))
2248
else if (op == O_bit_and || op == O_bit_inclusive_or)
2253
else if (op != O_bit_exclusive_or && op != O_bit_or_not)
2257
right += frag_off / OCTETS_PER_BYTE;
2260
case O_add: left += right; break;
2261
case O_subtract: left -= right; break;
2262
case O_multiply: left *= right; break;
2266
left = (offsetT) left / (offsetT) right;
2271
left = (offsetT) left % (offsetT) right;
2273
case O_left_shift: left <<= right; break;
2274
case O_right_shift: left >>= right; break;
2275
case O_bit_inclusive_or: left |= right; break;
2276
case O_bit_or_not: left |= ~right; break;
2277
case O_bit_exclusive_or: left ^= right; break;
2278
case O_bit_and: left &= right; break;
2281
left = (left == right
2282
&& seg_left == seg_right
2283
&& (finalize_syms || frag_left == frag_right)
2284
&& (seg_left != undefined_section
2285
|| add_symbol == op_symbol)
2286
? ~ (valueT) 0 : 0);
2291
left = (offsetT) left < (offsetT) right ? ~ (valueT) 0 : 0;
2294
left = (offsetT) left <= (offsetT) right ? ~ (valueT) 0 : 0;
2297
left = (offsetT) left >= (offsetT) right ? ~ (valueT) 0 : 0;
2300
left = (offsetT) left > (offsetT) right ? ~ (valueT) 0 : 0;
2302
case O_logical_and: left = left && right; break;
2303
case O_logical_or: left = left || right; break;
2313
if (seg_left == absolute_section)
2315
else if (seg_left == reg_section && final_val == 0)
2317
else if (!symbol_same_p (add_symbol, orig_add_symbol))
2319
expressionP->X_add_symbol = add_symbol;
2321
expressionP->X_op = op;
2323
if (op == O_constant || op == O_register)
2325
expressionP->X_add_number = final_val;
2330
/* This lives here because it belongs equally in expr.c & read.c.
2331
expr.c is just a branch office read.c anyway, and putting it
2332
here lessens the crowd at read.c.
2334
Assume input_line_pointer is at start of symbol name.
2335
Advance input_line_pointer past symbol name.
2336
Turn that character into a '\0', returning its former value.
2337
This allows a string compare (RMS wants symbol names to be strings)
2339
There will always be a char following symbol name, because all good
2340
lines end in end-of-line. */
2343
get_symbol_end (void)
2347
/* We accept \001 in a name in case this is being called with a
2348
constructed string. */
2349
if (is_name_beginner (c = *input_line_pointer++) || c == '\001')
2351
while (is_part_of_name (c = *input_line_pointer++)
2354
if (is_name_ender (c))
2355
c = *input_line_pointer++;
2357
*--input_line_pointer = 0;
2362
get_single_number (void)
2365
operand (&exp, expr_normal);
2366
return exp.X_add_number;
added
removed
binutils-2.23.52.20130611/gas/expr.c
