OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [gas/] [expr.c] - Blame information for rev 818

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.