![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cctools / as|
Return to expr.c CVS log | Up to [Apple XNU] / GNUtools / cctools / as |
1.1 root 1: /* expr.c -operands, expressions-
2: Copyright (C) 1987 Free Software Foundation, Inc.
3:
4: This file is part of GAS, the GNU Assembler.
5:
6: GAS is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 1, or (at your option)
9: any later version.
10:
11: GAS is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GAS; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: /*
21: * This is really a branch office of as-read.c. I split it out to clearly
22: * distinguish the world of expressions from the world of statements.
23: * (It also gives smaller files to re-compile.)
24: * Here, "operand"s are of expressions, not instructions.
25: */
26:
27: #include <ctype.h>
28: #include <string.h>
29: #include "stuff/round.h"
30: #include "as.h"
31: #include "flonum.h"
32: #include "struc-symbol.h"
33: #include "expr.h"
34: #include "read.h"
35: #include "obstack.h"
36: #include "symbols.h"
37: #include "hex_value.h"
38: #include "md.h"
39: #include "messages.h"
40: #include "sections.h"
41:
42: char *seg_name[] = {
43: "absolute",
44: "section",
45: "difference",
46: "unknown",
47: "absent",
48: "bignum/flonum",
49: };
50:
51: #ifdef SUSPECT
52: static int seg_N_TYPE[] = {
53: N_ABS, /* absolute */
54: N_SECT, /* section */
55: -1, /* difference */
56: N_UNDF, /* unknown */
57: -1, /* absent */
58: -1 /* bignum/flonum */
59: };
60: #endif
61:
62: segT N_TYPE_seg[] =
63: {
64: /* N_UNDF == 0, N_ABS == 2 */
65: SEG_UNKNOWN, -1, SEG_ABSOLUTE, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
66: /* N_SECT == 0xe */
67: SEG_SECT, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
68: };
69:
70: /*
71: * SEG_BIG expressions encode either a floating point number or an integer
72: * larger than 32 bits in this manner:
73: * For a floating point number:
74: * X_add_number is < 0
75: * The result is in the global variable generic_floating_point_number.
76: * The value in X_add_number is -'c' where c is the character that
77: * introduced the constant. e.g. "0f6.9" will have -'f' as a
78: * X_add_number value.
79: * For an integer larger than 32 bits:
80: * X_add_number > 0
81: * The result is in the global variable generic_bignum.
82: * The value in X_add_number is a count of how many littlenums it
83: * took to represent the bignum.
84: */
85:
86: /* LITTLENUM_TYPE generic_buffer [6]; JF this is a hack */
87: /* Seems atof_machine can backscan through generic_bignum and hit whatever
88: happens to be loaded before it in memory. And its way too complicated
89: for me to fix right. Thus a hack. JF: Just make generic_bignum bigger,
90: and never write into the early words, thus they'll always be zero.
91: I hate Dean's floating-point code. Bleh.
92: */
93: LITTLENUM_TYPE generic_bignum[SIZE_OF_LARGE_NUMBER + 6] = { 0 };
94:
95: FLONUM_TYPE generic_floating_point_number = {
96: &generic_bignum[6], /* low (JF: Was 0) */
97: &generic_bignum[SIZE_OF_LARGE_NUMBER + 6 - 1],/* high JF: (added +6) */
98: 0, /* leader */
99: 0, /* exponent */
100: 0 /* sign */
101: };
102:
103: /*
104: * The type operatorT is for the types of operators in expressions.
105: */
106: typedef enum {
107: O_illegal, /* (0) what we get for illegal op */
108:
109: O_multiply, /* (1) * Ordered by rank*/
110: O_divide, /* (2) / */
111: O_modulus, /* (3) % */
112:
113: O_add, /* (4) + */
114: O_subtract, /* (5) - */
115:
116: O_right_shift, /* (6) >> */
117: O_left_shift, /* (7) << */
118:
119: O_less_than, /* (8) < */
120: O_greater_than, /* (9) > */
121: O_less_than_or_equal, /* (10) <= */
122: O_greater_than_or_equal, /* (11) >= */
123:
124: O_equal, /* (12) == */
125: O_not_equal, /* (13) != */ /* or <> */
126:
127: O_bit_and, /* (14) & */
128:
129: O_bit_exclusive_or, /* (15) ^ */
130:
131: O_bit_inclusive_or, /* (16) | */
132: O_bit_or_not, /* (17) ! */
133: two_char_operator /* (18) encoding for two char operator */
134: } operatorT;
135:
136: /*
137: * op_size is indexed by an operatorT and tells the size of the operator
138: * which is used to advance the input_line_pointer over the operator.
139: */
140: static int op_size [] =
141: { 0, 1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1 };
142:
143: /*
144: * op_rank is indexed by an operatorT and tells the rank of the operator.
145: *
146: * Rank Examples
147: * 8 * / %
148: * 7 + -
149: * 6 >> <<
150: * 5 < > <= >=
151: * 4 == !=
152: * 3 &
153: * 2 ^
154: * 1 | !
155: * 0 operand, (expression)
156: */
157: typedef char operator_rankT;
158: static operator_rankT op_rank [] =
159: { 0, 8, 8, 8, 7, 7, 6, 6, 5, 5, 5, 5, 4, 4, 3, 2, 1, 1 };
160:
161: /*
162: * op_encoding is indexed by a an ASCII character and maps it to an operator.
163: */
164: #define __ O_illegal
165: static const operatorT op_encoding [256] = {
166: __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
167: __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
168:
169: __, two_char_operator, __, __, __, O_modulus, O_bit_and, __,
170: __, __, O_multiply, O_add, __, O_subtract, __, O_divide,
171: __, __, __, __, __, __, __, __,
172: __, __, __, __, two_char_operator, two_char_operator, two_char_operator, __,
173: __, __, __, __, __, __, __, __,
174: __, __, __, __, __, __, __, __,
175: __, __, __, __, __, __, __, __,
176: __, __, __, __, __, __, O_bit_exclusive_or, __,
177: __, __, __, __, __, __, __, __,
178: __, __, __, __, __, __, __, __,
179: __, __, __, __, __, __, __, __,
180: __, __, __, __, O_bit_inclusive_or, __, __, __,
181:
182: __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
183: __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
184: __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
185: __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
186: __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
187: __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
188: __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
189: __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __
190: };
191:
192: static segT expr(
193: operator_rankT rank,
194: expressionS *resultP);
195:
196: static segT operand(
197: expressionS *expressionP);
198:
199: static void clean_up_expression(
200: expressionS *expressionP);
201:
202: static segT expr_part(
203: struct symbol **symbol_1_PP,
204: struct symbol *symbol_2_P);
205:
206: static operatorT two_char_op_encoding(
207: char first_op_char);
208:
209: segT /* Return resultP -> X_seg */
210: expression(
211: expressionS *resultP) /* deliver result here */
212: {
213: segT segment;
214:
215: segment = expr(0, resultP);
216:
217: /* what about caller's that just want to ignore this and print the're own
218: error message? ok I guess */
219: if(segment == SEG_DIFFSECT &&
220: resultP->X_add_symbol == NULL &&
221: (resultP->X_subtract_symbol->sy_type & N_TYPE) != N_UNDF){
222: as_warn("Subtracting symbol \"%s\"(segment\"%s\") is too "
223: "hard. Absolute segment assumed.",
224: resultP->X_subtract_symbol->sy_name,
225: seg_name[(int)N_TYPE_seg[
226: resultP->X_subtract_symbol->sy_type & N_TYPE]]);
227: segment = SEG_ABSOLUTE;
228: /* Leave exp .X_add_number alone. */
229: }
230: return(segment);
231: }
232:
233: /* Expression parser. */
234:
235: /*
236: * We allow an empty expression, and just assume (absolute,0) silently.
237: * Unary operators and parenthetical expressions are treated as operands.
238: * As usual, Q==quantity==operand, O==operator, X==expression mnemonics.
239: *
240: * Most expressions are either register (which does not even reach here)
241: * or 1 symbol. Then "symbol+constant" and "symbol-symbol" are common.
242: *
243: * After expr(RANK,resultP) input_line_pointer -> operator of rank <= RANK.
244: * Also, we have consumed any leading or trailing spaces (operand does that)
245: * and done all intervening operators.
246: */
247: static
248: segT /* Return resultP -> X_seg */
249: expr(
250: operator_rankT rank, /* larger # is higher rank */
251: expressionS *resultP) /* deliver result here */
252: {
253: expressionS right;
254: operatorT op_left;
255: char c_left; /* 1st operator character. */
256: operatorT op_right;
257: char c_right;
258:
259: know(rank >= 0);
260:
261: (void)operand(resultP);
262: know(*input_line_pointer != ' '); /* Operand() gobbles spaces. */
263:
264: c_left = *input_line_pointer; /* Potential operator character. */
265: op_left = (operatorT)op_encoding[(int)c_left];
266: if(op_left == two_char_operator)
267: op_left = two_char_op_encoding(c_left);
268:
269: while(op_left != O_illegal && op_rank[op_left] > rank){
270:
271: input_line_pointer += op_size[op_left];
272: /* -> after 1st character of operator. */
273:
274: if(SEG_NONE == expr(op_rank[op_left], &right)){
275: as_warn("Missing operand value assumed absolute 0.");
276: resultP->X_add_number = 0;
277: resultP->X_subtract_symbol = NULL;
278: resultP->X_add_symbol = NULL;
279: resultP->X_seg = SEG_ABSOLUTE;
280: }
281: know(*input_line_pointer != ' ');
282:
283: c_right = *input_line_pointer;
284: op_right = (operatorT)op_encoding[(int)c_right];
285: if(op_right == two_char_operator)
286: op_right = two_char_op_encoding(c_right);
287:
288: /* -> after 1st character of operator. */
289: know(op_right == 0 || op_rank [op_right] <= op_rank[op_left]);
290:
291: /* input_line_pointer -> after right-hand quantity. */
292: /* left-hand quantity in resultP */
293: /* right-hand quantity in right. */
294: /* operator in op_left. */
295:
296: /*
297: * Operations are not supported on bignums or floating-point
298: * operands.
299: */
300: if(resultP->X_seg == SEG_BIG){
301: as_warn("Left operand of %c is a %s integer 0 assumed",
302: c_left, resultP->X_add_number > 0 ? "bignum" :
303: "float");
304: resultP->X_seg = SEG_ABSOLUTE;
305: resultP->X_add_symbol = 0;
306: resultP->X_subtract_symbol = 0;
307: resultP->X_add_number = 0;
308: }
309: if(right.X_seg == SEG_BIG){
310: as_warn("Right operand of %c is a %s integer 0 assumed",
311: c_left, right.X_add_number > 0 ? "bignum" :
312: "float");
313: right.X_seg = SEG_ABSOLUTE;
314: right.X_add_symbol = 0;
315: right.X_subtract_symbol = 0;
316: right.X_add_number = 0;
317: }
318: if(op_left == O_subtract){
319: /*
320: * Convert - into + by exchanging symbols and negating
321: * number. I know -infinity can't be negated in 2's
322: * complement: but then it can't be subtracted either.
323: * This trick does not cause any further inaccuracy.
324: */
325: struct symbol *symbolP;
326:
327: right.X_add_number = - right.X_add_number;
328: symbolP = right.X_add_symbol;
329: right.X_add_symbol = right.X_subtract_symbol;
330: right.X_subtract_symbol = symbolP;
331: if(symbolP){
332: /* This is not used, as it drops in to the next if */
333: right.X_seg = SEG_DIFFSECT;
334: }
335: op_left = O_add;
336: }
337: if(op_left == O_add){
338: segT seg1;
339: segT seg2;
340:
341: /* not SEG_NONE and not SEG_BIG */
342: know(resultP->X_seg == SEG_SECT ||
343: resultP->X_seg == SEG_UNKNOWN ||
344: resultP->X_seg == SEG_DIFFSECT ||
345: resultP->X_seg == SEG_ABSOLUTE);
346: /* not SEG_NONE and not SEG_BIG */
347: know(right.X_seg == SEG_SECT ||
348: right.X_seg == SEG_UNKNOWN ||
349: right.X_seg == SEG_DIFFSECT ||
350: right.X_seg == SEG_ABSOLUTE);
351:
352: clean_up_expression(&right);
353: clean_up_expression(resultP);
354:
355: /* could this just return -1 instead of SEG_PASS1? and tested in the below if
356: statement */
357: seg1 = expr_part(&resultP->X_add_symbol,
358: right.X_add_symbol);
359: seg2 = expr_part(&resultP->X_subtract_symbol,
360: right.X_subtract_symbol);
361: if(seg1 == -1 || seg2 == -1){
362: as_warn("Can't relocate expression. Absolute 0 assumed.");
363: resultP->X_seg = SEG_ABSOLUTE;
364: resultP->X_add_number = 0;
365: }
366: else{
367: if(seg2 == SEG_ABSOLUTE){
368: resultP->X_seg = seg1;
369: }
370: else{
371: /* also know seg2 != -1 (SEG_PASS1) */
372: know(seg2 != SEG_ABSOLUTE);
373: /* seg2 is for the subtract symbols, since seg2 != SEG_ABSOLUTE as would be
374: returned when there is no subtract symbols then expr_part() must have
375: combined a symbol into resultP->X_subtract_symbol that is either undefined
376: or defined in a section. */
377: know(resultP->X_subtract_symbol);
378: /*
379: * If we are not to use the new incompatible features
380: * then "symbol1 - symbol2" must both be in the same
381: * section and will turn out as absolute.
382: */
383: if(!flagseen['k']){
384: if(seg1 != SEG_UNKNOWN &&
385: seg1 != SEG_ABSOLUTE &&
386: seg2 != SEG_UNKNOWN &&
387: seg1 != seg2 &&
388: resultP->X_add_symbol->sy_other !=
389: resultP->X_subtract_symbol->sy_other){
390: know(seg1 == SEG_SECT);
391: know(seg2 == SEG_SECT);
392: know(resultP->X_add_symbol);
393: know(resultP->X_subtract_symbol);
394: as_warn("Expression too complex: "
395: "forgetting %s - %s",
396: resultP->X_add_symbol->sy_name,
397: resultP->X_subtract_symbol->sy_name);
398: resultP->X_seg = SEG_ABSOLUTE;
399: /* Clean_up_expression() will do the rest */
400: }
401: else{
402: /* this can result in returning an expression that is NULL - symbol and the
403: caller must deal with this being illegal. maybe this should be put in
404: expression() routine (not a macro). Note the code in cons() */
405: resultP->X_seg = SEG_DIFFSECT;
406: } /* If relocation too complex. */
407: }
408: else{
409: resultP->X_seg = SEG_DIFFSECT;
410: }
411:
412: } /* If seg2 == SEG_ABSOLUTE. */
413: } /* If need pass 2. */
414: resultP->X_add_number += right.X_add_number;
415: clean_up_expression(resultP);
416: }
417: else{ /* Not +. */
418: if(resultP->X_seg == SEG_UNKNOWN ||
419: right.X_seg == SEG_UNKNOWN){
420: as_warn("Can't relocate expression. Absolute 0 assumed.");
421: resultP->X_seg = SEG_ABSOLUTE;
422: resultP->X_add_number = 0;
423: }
424: else{
425: /*
426: * Will be SEG_ABSOLUTE. (or error)
427: */
428: try_to_make_absolute(resultP);
429: try_to_make_absolute(&right);
430: resultP->X_subtract_symbol = NULL;
431: resultP->X_add_symbol = NULL;
432: if(resultP->X_seg != SEG_ABSOLUTE ||
433: right.X_seg != SEG_ABSOLUTE){
434: as_warn("Relocation error. Absolute 0 assumed");
435: resultP->X_seg = SEG_ABSOLUTE;
436: resultP->X_add_number = 0;
437: }
438: else{
439: /*
440: * Both are absolute so perform the operation
441: * on the constants.
442: */
443: switch(op_left){
444: case O_bit_inclusive_or:
445: resultP->X_add_number |= right.X_add_number;
446: break;
447:
448: case O_modulus:
449: if(right.X_add_number){
450: resultP->X_add_number %=
451: right.X_add_number;
452: }
453: else{
454: as_warn("Division by 0. 0 assumed.");
455: resultP->X_add_number = 0;
456: }
457: break;
458:
459: case O_bit_and:
460: resultP->X_add_number &= right.X_add_number;
461: break;
462:
463: case O_multiply:
464: resultP->X_add_number *= right.X_add_number;
465: break;
466:
467: case O_divide:
468: if(right.X_add_number){
469: resultP->X_add_number /=
470: right.X_add_number;
471: }
472: else{
473: as_warn("Division by 0. 0 assumed.");
474: resultP->X_add_number = 0;
475: }
476: break;
477:
478: case O_left_shift:
479: resultP->X_add_number <<=
480: right.X_add_number;
481: break;
482:
483: case O_right_shift:
484: resultP->X_add_number >>=
485: right.X_add_number;
486: break;
487:
488: case O_bit_exclusive_or:
489: resultP->X_add_number ^= right.X_add_number;
490: break;
491:
492: case O_bit_or_not:
493: resultP->X_add_number |=
494: ~right.X_add_number;
495: break;
496:
497: case O_less_than:
498: resultP->X_add_number =
499: (resultP->X_add_number <
500: right.X_add_number);
501: break;
502:
503: case O_greater_than:
504: resultP->X_add_number =
505: (resultP->X_add_number >
506: right.X_add_number);
507: break;
508:
509: case O_less_than_or_equal:
510: resultP->X_add_number =
511: (resultP->X_add_number <=
512: right.X_add_number);
513: break;
514:
515: case O_greater_than_or_equal:
516: resultP->X_add_number =
517: (resultP->X_add_number >=
518: right.X_add_number);
519: break;
520:
521: case O_equal:
522: resultP->X_add_number =
523: (resultP->X_add_number ==
524: right.X_add_number);
525: break;
526:
527: case O_not_equal:
528: resultP->X_add_number =
529: (resultP->X_add_number !=
530: right.X_add_number);
531: break;
532:
533: default:
534: BAD_CASE( op_left );
535: break;
536: } /* switch(op_left) */
537: }
538: } /* If we have to force need_pass_2 */
539: } /* If operator was + */
540: op_left = op_right;
541: } /* While next operator is >= this rank */
542: return(resultP->X_seg);
543: }
544:
545: /*
546: * Summary of operand().
547: *
548: * in: Input_line_pointer points to 1st char of operand, which may
549: * be a space.
550: *
551: * out: A expressionS. X_seg determines how to understand the rest of the
552: * expressionS.
553: * The operand may have been empty: in this case X_seg == SEG_NONE.
554: * Input_line_pointer -> (next non-blank) char after operand.
555: *
556: */
557: static
558: segT
559: operand(
560: expressionS *expressionP)
561: {
562: char c, q;
563: char *name; /* points to name of symbol */
564: struct symbol *symbolP; /* Points to symbol */
565:
566:
567: SKIP_WHITESPACE(); /* Leading whitespace is part of operand. */
568: c = *input_line_pointer++;/* Input_line_pointer -> past char in c. */
569:
570: if(isdigit(c)){
571: valueT number; /* offset or (absolute) value */
572: int digit; /* value of next digit in current radix */
573: /* invented for humans only, hope */
574: /* optimising compiler flushes it! */
575: int radix; /* 8, 10 or 16 */
576: /* 0 means we saw start of a floating- */
577: /* point constant. */
578: int maxdig; /* Highest permitted digit value. */
579: int too_many_digits;/* If we see >= this number of */
580: /* digits, assume it is a bignum. */
581: char *digit_2; /* -> 2nd digit of number. */
582: int small; /* TRUE if fits in 32 bits. */
583: int force_bignum; /* TRUE if number is 0xb... */
584:
585: force_bignum = FALSE;
586: /*
587: * These two initiaizations are to shut up compiler warning as the
588: * may be used with out being set. There used only if radix != 0
589: * when the number is not a floating-point number.
590: */
591: maxdig = 0;
592: too_many_digits = 0;
593:
594: if(c == '0'){ /* non-decimal radix */
595: c = *input_line_pointer++;
596: if(c == 'x' || c=='X'){
597: c = *input_line_pointer++; /* read past "0x" or "0X" */
598: maxdig = 16;
599: radix = 16;
600: too_many_digits = 9;
601: }
602: /*
603: * If we have "0b" and some hex digits then treat it as a hex
604: * number and return a bignum. This is for hex immediate
605: * bit-patterns for floating-point immediate constants.
606: */
607: else if((c == 'b' || c == 'B') &&
608: (*input_line_pointer != '\0') &&
609: strchr("0123456789abcdefABCDEF",
610: *input_line_pointer) != NULL){
611: force_bignum = TRUE;
612: c = *input_line_pointer++; /* read past "0b" or "0B" */
613: maxdig = 16;
614: radix = 16;
615: too_many_digits = 9;
616: }
617: else{
618: /*
619: * If it says '0f' and the line ends or it DOESN'T look like
620: * a floating point #, its a local label ref.
621: */
622: if(c == 'f' &&
623: (*input_line_pointer == '\0' ||
624: (strchr("+-.0123456789", *input_line_pointer) == NULL &&
625: strchr(md_EXP_CHARS, *input_line_pointer) == NULL) )){
626: maxdig = 10;
627: radix = 10;
628: too_many_digits = 11;
629: c = '0';
630: input_line_pointer -= 2;
631: }
632: else if(c != '\0' && strchr(md_FLT_CHARS, c) != NULL){
633: radix = 0;/* Start of floating-point constant. */
634: /* input_line_pointer -> 1st char of number */
635: expressionP->X_add_number =
636: - (isupper(c) ? tolower(c) : c);
637: }
638: else{ /* By elimination, assume octal radix. */
639: radix = 8;
640: maxdig = 10; /* Un*x sux. Compatibility. */
641: too_many_digits = 11;
642: }
643: }
644: /* c == char after "0" or "0x" or "0X" or "0e" etc.*/
645: }
646: else{
647: maxdig = 10;
648: radix = 10;
649: too_many_digits = 11;
650: }
651: if(radix != 0){ /* Fixed-point integer constant. */
652: /* May be bignum, or may fit in 32 bits. */
653: /*
654: * Most numbers fit into 32 bits, and we want this case to be
655: * fast. So we pretend it will fit into 32 bits. If, after
656: * making up a 32 bit number, we realize that we have scanned
657: * more digits than comfortably fit into 32 bits, we re-scan the
658: * digits coding them into a bignum. For decimal and octal
659: * numbers we are conservative: some numbers may be assumed
660: * bignums when in fact they do fit into 32 bits. Numbers of
661: * any radix can have excess leading zeros: we strive to
662: * recognise this and cast them back into 32 bits. We must
663: * check that the bignum really is more than 32 bits, and
664: * change it back to a 32-bit number if it fits. The number we
665: * are looking for is expected to be positive, but if it fits
666: * into 32 bits as an unsigned number, we let it be a 32-bit
667: * number. The cavalier approach is for speed in ordinary cases.
668: */
669: digit_2 = input_line_pointer;
670: for(number = 0;
671: (digit = hex_value[(int)c]) < maxdig;
672: c = *input_line_pointer++){
673: number = number * radix + digit;
674: }
675: /* c contains character after number. */
676: /* Input_line_pointer -> char after c. */
677: small = input_line_pointer - digit_2 < too_many_digits;
678: if(force_bignum == TRUE)
679: small = FALSE;
680: if(small == FALSE){
681: /*
682: * Manufacture a bignum.
683: */
684: /* -> high order littlenum of the bignum. */
685: LITTLENUM_TYPE *leader;
686: /* -> littlenum we are frobbing now. */
687: LITTLENUM_TYPE *pointer;
688: long carry;
689:
690: leader = generic_bignum;
691: generic_bignum [0] = 0;
692: /* We could just use digit_2, but lets be mnemonic. */
693: input_line_pointer = --digit_2; /* -> 1st digit. */
694: c = *input_line_pointer++;
695: for( ;
696: (carry = hex_value[(int)c]) < maxdig;
697: c = * input_line_pointer++){
698: for(pointer = generic_bignum;
699: pointer <= leader;
700: pointer++){
701: long work;
702:
703: work = carry + radix * *pointer;
704: *pointer = work & LITTLENUM_MASK;
705: carry = work >> LITTLENUM_NUMBER_OF_BITS;
706: }
707: if(carry){
708: if(leader < generic_bignum +
709: SIZE_OF_LARGE_NUMBER - 1){
710: /* Room to grow a longer bignum. */
711: *++leader = carry;
712: }
713: }
714: }
715: /* Again, C is char after number, */
716: /* input_line_pointer -> after C. */
717: /* know(BITS_PER_INT == 32); */
718: know(LITTLENUM_NUMBER_OF_BITS == 16);
719: /* Hence the constant "2" in the next line. */
720: if(leader < generic_bignum + 2 && force_bignum == FALSE)
721: { /* Will fit into 32 bits. */
722: number = ((generic_bignum[1] & LITTLENUM_MASK) <<
723: LITTLENUM_NUMBER_OF_BITS) |
724: (generic_bignum[0] & LITTLENUM_MASK);
725: small = TRUE;
726: }
727: else{
728: /* Number of littlenums in the bignum. */
729: number = leader - generic_bignum + 1;
730: }
731: }
732: if(small){
733: /*
734: * Here with number, in correct radix. c is the next char.
735: * Note that unlike Un*x, we allow "011f" "0x9f" to both
736: * mean the same as the (conventional) "9f". This is simply
737: * easier than checking for strict canonical form.
738: */
739: if(number < 10){
740: if(c == 'b'){
741: /*
742: * Backward ref to local label.
743: * Because it is backward, expect it to be DEFINED.
744: */
745: /*
746: * Construct a local label.
747: */
748: name = local_label_name((int)number, 0);
749: symbolP = symbol_table_lookup(name);
750: if((symbolP != NULL) &&
751: (symbolP->sy_type & N_TYPE) != N_UNDF){
752: /* Expected path: symbol defined. */
753: /* Local labels are never absolute. Don't waste
754: time checking absoluteness. */
755: know((symbolP->sy_type & N_TYPE) == N_SECT);
756: expressionP->X_add_symbol = symbolP;
757: expressionP->X_add_number = 0;
758: expressionP->X_seg = SEG_SECT;
759: }
760: else{ /* Either not seen or not defined. */
761: as_warn("Backw. ref to unknown label \"%d:\", 0"
762: " assumed.", number);
763: expressionP->X_add_number = 0;
764: expressionP->X_seg = SEG_ABSOLUTE;
765: }
766: }
767: else if(c == 'f'){
768: /*
769: * Forward reference. Expect symbol to be
770: * undefined or unknown. Undefined: seen it
771: * before. Unknown: never seen it in this pass.
772: * Construct a local label name, then an
773: * undefined symbol. Don't create a XSEG frag
774: * for it: caller may do that.
775: * Just return it as never seen before.
776: */
777: name = local_label_name((int)number, 1);
778: symbolP = symbol_table_lookup(name);
779: if(symbolP != NULL){
780: /* We have no need to check symbol
781: properties. */
782: know((symbolP->sy_type & N_TYPE) == N_UNDF ||
783: (symbolP->sy_type & N_TYPE) == N_SECT);
784: }
785: else{
786: symbolP = symbol_new(name, N_UNDF, 0,0,0,
787: &zero_address_frag);
788: symbol_table_insert(symbolP);
789: }
790: expressionP->X_add_symbol = symbolP;
791: expressionP->X_seg = SEG_UNKNOWN;
792: expressionP->X_subtract_symbol = NULL;
793: expressionP->X_add_number = 0;
794: }
795: else{ /* Really a number, not a local label. */
796: expressionP->X_add_number = number;
797: expressionP->X_seg = SEG_ABSOLUTE;
798: input_line_pointer--; /* restore following char */
799: }
800: }
801: else{ /* a number >= 10 */
802: expressionP->X_add_number = number;
803: expressionP->X_seg = SEG_ABSOLUTE;
804: input_line_pointer--; /* restore following char */
805: }
806: } /* not a small number encode returning a bignum */
807: else{
808: expressionP->X_add_number = number;
809: expressionP->X_seg = SEG_BIG;
810: input_line_pointer--; /* -> char following number. */
811: } /* if (small) */
812: } /* (If integer constant) */
813: else{ /* input_line_pointer -> floating-point constant. */
814:
815: int error_code;
816:
817: error_code = atof_generic(&input_line_pointer, ".", md_EXP_CHARS,
818: &generic_floating_point_number);
819:
820: if(error_code){
821: if(error_code == ERROR_EXPONENT_OVERFLOW){
822: as_warn("Bad floating-point constant: exponent "
823: "overflow, probably assembling junk" );
824: }
825: else{
826: as_warn("Bad floating-point constant: unknown error "
827: "code=%d.", error_code);
828: }
829: }
830: expressionP->X_seg = SEG_BIG;
831: /* input_line_pointer -> just after constant, */
832: /* which may point to whitespace. */
833: know(expressionP->X_add_number < 0);
834: /* < 0 means "floating point". */
835: } /* if (not floating-point constant) */
836: }
837: else if(c == '.' && !is_part_of_name(*input_line_pointer)){
838: /*
839: JF: '.' is pseudo symbol with value of current location in current
840: segment. . .
841: */
842: symbolP = symbol_new("L0\001",
843: N_SECT,
844: frchain_now->frch_nsect,
845: 0,
846: (valueT)(obstack_next_free(&frags) -
847: frag_now->fr_literal),
848: frag_now);
849: expressionP->X_add_number = 0;
850: expressionP->X_add_symbol = symbolP;
851: expressionP->X_seg = SEG_SECT;
852: }
853: /* here if did not begin with a digit */
854: else if(is_name_beginner(c) || c == '"'){
855: /*
856: * Identifier begins here.
857: * This is kludged for speed, so code is repeated.
858: */
859: q = c;
860: if(q == '"')
861: name = input_line_pointer-- ;
862: else
863: name = -- input_line_pointer;
864: c = get_symbol_end();
865: symbolP = symbol_table_lookup(name);
866: if(symbolP != NULL){
867: /*
868: * If we have an absolute symbol, then we know it's value now.
869: */
870: segT seg;
871:
872: seg = N_TYPE_seg[(int)symbolP->sy_type & N_TYPE];
873: expressionP->X_seg = seg;
874: if(seg == SEG_ABSOLUTE){
875: expressionP->X_add_number = symbolP->sy_value;
876: }
877: else{
878: expressionP->X_add_number = 0;
879: expressionP->X_add_symbol = symbolP;
880: }
881: }
882: else{
883: symbolP = symbol_new(name, N_UNDF, 0,0,0, &zero_address_frag);
884: expressionP->X_add_symbol = symbolP;
885: expressionP->X_add_number = 0;
886: expressionP->X_seg = SEG_UNKNOWN;
887: symbol_table_insert(symbolP);
888: }
889: *input_line_pointer = c;
890: if(q == '"')
891: input_line_pointer[-1] = '"';
892: expressionP->X_subtract_symbol = NULL;
893: }
894: /* didn't begin with digit & not a name */
895: else if (c == '('){
896: (void)expression(expressionP);
897: /* Expression() will pass trailing whitespace */
898: if(*input_line_pointer++ != ')'){
899: as_warn("Missing ')' assumed");
900: input_line_pointer--;
901: }
902: /* here with input_line_pointer -> char after "(...)" */
903: }
904: /* unary operator: hope for SEG_ABSOLUTE */
905: else if(c == '~' || c == '-' || c == '!'){
906: switch(operand(expressionP)){
907: case SEG_ABSOLUTE:
908: /* input_line_pointer -> char after operand */
909: if(c == '-' ){
910: /*
911: * Notice: '-' may overflow: no warning is given. This is
912: * compatible with other people's assemblers.
913: */
914: expressionP->X_add_number = - expressionP->X_add_number;
915: }
916: else if(c == '!'){
917: expressionP->X_add_number = ! expressionP->X_add_number;
918: }
919: else{
920: expressionP->X_add_number = ~ expressionP->X_add_number;
921: }
922: break;
923: case SEG_SECT:
924: case SEG_UNKNOWN:
925: if(c == '-'){ /* JF I hope this hack works */
926: expressionP->X_subtract_symbol = expressionP->X_add_symbol;
927: expressionP->X_add_symbol = 0;
928: expressionP->X_seg = SEG_DIFFSECT;
929: break;
930: }
931: default: /* unary on non-absolute is unsuported */
932: as_warn("Unary operator %c ignored because bad operand follows",
933: c);
934: break;
935: /* Expression undisturbed from operand(). */
936: }
937: }
938: /*
939: * Warning: to conform to other people's assemblers NO ESCAPEMENT is
940: * permitted for a single quote. The next character, parity errors and
941: * all, is taken as the value of the operand. VERY KINKY.
942: */
943: else if(c == '\''){
944: expressionP->X_add_number = *input_line_pointer++;
945: expressionP->X_seg = SEG_ABSOLUTE;
946: }
947: /* can't imagine any other kind of operand */
948: else{
949: expressionP->X_seg = SEG_NONE;
950: input_line_pointer--;
951: }
952: /*
953: * It is more 'efficient' to clean up the expressions when they are
954: * created. Doing it here saves lines of code.
955: */
956: clean_up_expression(expressionP);
957: SKIP_WHITESPACE(); /* -> 1st char after operand. */
958: know(*input_line_pointer != ' ');
959: return(expressionP->X_seg);
960: }
961:
962: /* Internal. Simplify a struct expression for use by expr() */
963:
964: /*
965: * In: address of a expressionS.
966: * The X_seg field of the expressionS may only take certain values.
967: * Now, we permit SEG_NONE to make code smaller & faster.
968: * Elsewise we waste time special-case testing. Sigh.
969: * Out: expressionS may have been modified:
970: * 'foo-foo' symbol references cancelled to 0,
971: * which changes X_seg from SEG_DIFFSECT to SEG_ABSOLUTE;
972: * Unused fields zeroed to help expr().
973: */
974: static
975: void
976: clean_up_expression(
977: expressionS *expressionP)
978: {
979: switch(expressionP->X_seg){
980: case SEG_NONE:
981: expressionP->X_add_symbol = NULL;
982: expressionP->X_subtract_symbol = NULL;
983: expressionP->X_add_number = 0;
984: break;
985:
986: case SEG_BIG:
987: case SEG_ABSOLUTE:
988: expressionP->X_subtract_symbol = NULL;
989: expressionP->X_add_symbol = NULL;
990: break;
991:
992: case SEG_SECT:
993: case SEG_UNKNOWN:
994: expressionP->X_subtract_symbol = NULL;
995: break;
996:
997: case SEG_DIFFSECT:
998: /*
999: * It does not hurt to 'cancel' NULL==NULL
1000: * when comparing symbols for 'eq'ness.
1001: * It is faster to re-cancel them to NULL
1002: * than to check for this special case.
1003: */
1004: if(expressionP->X_subtract_symbol == expressionP->X_add_symbol){
1005: expressionP->X_subtract_symbol = NULL;
1006: expressionP->X_add_symbol = NULL;
1007: expressionP->X_seg = SEG_ABSOLUTE;
1008: }
1009: break;
1010:
1011: default:
1012: BAD_CASE(expressionP->X_seg);
1013: break;
1014: }
1015: }
1016:
1017: /*
1018: * expr_part ()
1019: *
1020: * Internal. Made a function because this code is used in 2 places.
1021: * Generate error or correct X_?????_symbol of expressionS.
1022: */
1023:
1024: /*
1025: Combine and subsume symbol2 into symbol1 where the symbols come from
1026: expression's add or subtract symbols.
1027: The combining always occurs even if it would be an error.
1028: Either symbol maybe NULL which means there is no symbol.
1029: In that case symbol1 is set to the non NULL symbol.
1030: If both are NULL then SEG_ABSOLUTE is returned.
1031: Either symbol maybe undefined.
1032: The only combinations that are not errors are when one symbol does not exist.
1033: if one symbol is undefined and the other doesn't exist SEG_UNKNOWN is
1034: returned.
1035: For errant combinations symbol1 is set to NULL and SEG_ABSOLUTE (or -1
1036: (SEG_PASS1) when one of the symbols is undefined and the other exists)
1037:
1038: * symbol_1 += symbol_2 ... well ... sort of.
1039: * symbol_1 -= symbol_2 ... well ... sort of.
1040: */
1041:
1042: static
1043: segT
1044: expr_part(
1045: struct symbol **symbol_1_PP,
1046: struct symbol *symbol_2_P)
1047: {
1048: segT return_value;
1049:
1050: /* The symbols can't be N_ABS as they are in expressions and whould just have
1051: their value copied into the X_add_number part. */
1052: know( (*symbol_1_PP) == NULL ||
1053: ((*symbol_1_PP)->sy_type & N_TYPE) == N_SECT ||
1054: ((*symbol_1_PP)->sy_type & N_TYPE) == N_UNDF);
1055:
1056: know( symbol_2_P == NULL ||
1057: (symbol_2_P->sy_type & N_TYPE) == N_SECT ||
1058: (symbol_2_P->sy_type & N_TYPE) == N_UNDF);
1059:
1060: /* check to see if there is a symbol1 */
1061: if(*symbol_1_PP != NULL){
1062: /* there is a symbol1 */
1063:
1064: /* check to see if symbol1 is undefined */
1065: if(((*symbol_1_PP)->sy_type & N_TYPE) == N_UNDF){
1066: /* symbol1 is undefined */
1067:
1068: /* check to see if there is a symbol2 */
1069: if(symbol_2_P != NULL){
1070: /* symbol1 is undefined and there is a symbol2 */
1071: *symbol_1_PP = NULL;
1072: return_value = -1;
1073: }
1074: else{
1075: /* symbol1 is undefined and there is no symbol2 */
1076: return_value = SEG_UNKNOWN;
1077: }
1078: }
1079: else{
1080: /* there is a defined symbol1 */
1081:
1082: /* check to see if there is a symbol2 */
1083: if(symbol_2_P != NULL){
1084: /* there is a symbol2 */
1085:
1086: /* check to see if symbol2 is undefined */
1087: if((symbol_2_P->sy_type & N_TYPE) == N_UNDF){
1088: /* symbol2 is undefined and symbol1 is defined */
1089: *symbol_1_PP = NULL;
1090: return_value = -1;
1091: }
1092: else{
1093: /* symbol1 is defined and symbol2 is defined */
1094: /* + {symbol1} + {symbol2} or */
1095: /* - {symbol1} - {symbol2} */
1096: as_warn("Expression too complex, 2 symbols forgotten: "
1097: "\"%s\" \"%s\"", (*symbol_1_PP)->sy_name,
1098: symbol_2_P->sy_name);
1099: *symbol_1_PP = NULL;
1100: return_value = SEG_ABSOLUTE;
1101: }
1102: }
1103: else{
1104: /* symbol1 is defined and there is no symbol2 */
1105: return_value = N_TYPE_seg[(*symbol_1_PP)->sy_type & N_TYPE];
1106: }
1107: }
1108: }
1109: else{
1110: /* there is no symbol1 */
1111:
1112: /* check to see if there is a symbol2 */
1113: if(symbol_2_P != NULL){
1114: /* symbol2 is defined and there is no symbol1 */
1115: *symbol_1_PP = symbol_2_P;
1116: return_value = N_TYPE_seg[(symbol_2_P)->sy_type & N_TYPE];
1117: }
1118: else{
1119: /* there is no symbol1 or symbol2 */
1120: /* ??? why not SEG_UNKNOWN or SEG_NONE */
1121: return_value = SEG_ABSOLUTE;
1122: }
1123: }
1124:
1125: know(return_value == SEG_ABSOLUTE ||
1126: return_value == SEG_SECT ||
1127: return_value == SEG_UNKNOWN ||
1128: return_value == -1);
1129: know((*symbol_1_PP) == NULL ||
1130: ((*symbol_1_PP)->sy_type & N_TYPE) ==
1131: seg_N_TYPE[(int)return_value]);
1132:
1133: return(return_value);
1134: }
1135:
1136: /*
1137: * DJA -- Here we make a last ditch effort to turn expressions into
1138: * absolutes. This is particularly useful for doing arithemtic
1139: * on already declared labels, for example in going through the
1140: * following table the moveq can really be evaluated.
1141: *
1142: * start: .word 1
1143: * .word 2
1144: * .word 3
1145: * end:
1146: * lea start,a0
1147: * moveq #((end-start) / 2) + 1,d0
1148: * loop: cmpw d1,a0@+
1149: * dbra d0,loop
1150: */
1151: segT /* Return expressionP->X_seg. */
1152: try_to_make_absolute(
1153: expressionS *expressionP) /* Deliver result here. */
1154: {
1155: symbolS *add_symbol;
1156: symbolS *subtract_symbol;
1157:
1158: if(expressionP->X_seg == SEG_DIFFSECT){
1159:
1160: add_symbol = expressionP->X_add_symbol;
1161: if(add_symbol == NULL)
1162: goto giveup;
1163: if((add_symbol->sy_type & N_TYPE) != N_SECT)
1164: goto giveup;
1165:
1166: subtract_symbol = expressionP->X_subtract_symbol;
1167: if(subtract_symbol == NULL)
1168: goto giveup;
1169: if((subtract_symbol->sy_type & N_TYPE) != N_SECT)
1170: goto giveup;
1171:
1172: if(add_symbol->sy_frag == subtract_symbol->sy_frag){
1173: if(add_symbol->sy_frag != NULL &&
1174: expressionP->X_add_number +
1175: (int)add_symbol->sy_value -
1176: (int)subtract_symbol->sy_value >= 0){
1177: expressionP->X_add_number += add_symbol->sy_value -
1178: subtract_symbol->sy_value;
1179: expressionP->X_seg = SEG_ABSOLUTE;
1180: expressionP->X_add_symbol = NULL;
1181: expressionP->X_subtract_symbol = NULL;
1182:
1183: }
1184: }
1185: else{
1186: /*
1187: * This logic works only if the chain of frags can't later be
1188: * separated by scattered loading. To make sure that this can't
1189: * happen we would have to make sure all symbols associated with
1190: * frags in the chain are of the Lx form and the -L flag is not
1191: * see so they will not appear in the output (if they are not in
1192: * the output then the link editor can't separate the chain of
1193: * frags by scattered loading). Since this code does not make
1194: * sure of this it is broken. But this is a known bug in the
1195: * NeXT 3.2 and earilier releases so this code is if'ed
1196: * !flagseen['k'] which will make it compatable with 3.2 and
1197: * previous releases.
1198: */
1199: if(!flagseen['k']){
1200: /*
1201: * Try to see if the chain of frags between the subtract
1202: * symbol and the add symbol is made up of only rs_fill and
1203: * rs_align frags and then calculate the difference. This
1204: * will always work on RISC machines since they won't have
1205: * any machine dependent frags of variable length in the
1206: * chain.
1207: */
1208: unsigned long size, fail;
1209: struct frag *frag;
1210:
1211: if(add_symbol->sy_frag != NULL &&
1212: subtract_symbol->sy_frag != NULL){
1213: fail = 0;
1214: size = 0;
1215: frag = subtract_symbol->sy_frag;
1216: while(!fail && frag != NULL &&
1217: frag != add_symbol->sy_frag){
1218: if(frag->fr_type == rs_align)
1219: size = round(size + frag->fr_fix,
1220: 1 << frag->fr_offset);
1221: else if(frag->fr_type == rs_fill)
1222: size += frag->fr_fix +
1223: frag->fr_var * frag->fr_offset;
1224: else
1225: fail = 1;
1226: frag = frag->fr_next;
1227: }
1228:
1229: if(!fail && frag == add_symbol->sy_frag){
1230: expressionP->X_add_number = size +
1231: add_symbol->sy_value -
1232: subtract_symbol->sy_value;
1233: expressionP->X_seg = SEG_ABSOLUTE;
1234: expressionP->X_add_symbol = NULL;
1235: expressionP->X_subtract_symbol = NULL;
1236: }
1237: }
1238: }
1239: }
1240: }
1241: giveup:
1242:
1243: return(expressionP->X_seg);
1244: }
1245:
1246: /*
1247: * two_char_op_encoding() return the operator type for two character operators.
1248: * The first_op_char is part of a two character operator and this routine is
1249: * then used to determine the operator type looking at the second character.
1250: */
1251: static
1252: operatorT
1253: two_char_op_encoding(
1254: char first_op_char)
1255: {
1256: char second_op_char;
1257:
1258: second_op_char = input_line_pointer[1];
1259: switch(first_op_char){
1260: case '<':
1261: if(second_op_char == '<')
1262: return(O_left_shift);
1263: if(second_op_char == '=')
1264: return(O_less_than_or_equal);
1265: if(second_op_char == '>')
1266: return(O_not_equal);
1267: return(O_less_than);
1268: case '>':
1269: if(second_op_char == '>')
1270: return(O_right_shift);
1271: if(second_op_char == '=')
1272: return(O_greater_than_or_equal);
1273: return(O_greater_than);
1274: case '=':
1275: if(second_op_char == '=')
1276: return(O_equal);
1277: return(O_illegal);
1278: case '!':
1279: if(second_op_char == '=')
1280: return(O_not_equal);
1281: return O_not_equal;
1282: default:
1283: BAD_CASE(first_op_char);
1284: return O_illegal;
1285: }
1286: }
1287:
1288: /*
1289: * get_symbol_end()
1290: *
1291: * This lives here because it belongs equally in expr.c & read.c.
1292: * Expr.c is just a branch office read.c anyway, and putting it
1293: * here lessens the crowd at read.c.
1294: *
1295: * Assume input_line_pointer is at start of symbol name.
1296: * Advance input_line_pointer past symbol name.
1297: * Turn that character into a '\0', returning its former value.
1298: * This allows a string compare (RMS wants symbol names to be strings)
1299: * of the symbol name.
1300: * There will always be a char following symbol name, because all good
1301: * lines end in end-of-line.
1302: */
1303: char
1304: get_symbol_end(
1305: void)
1306: {
1307: register char c;
1308:
1309: /*
1310: * Symbol names are allowed to have surrounding ""s so that names can
1311: * have any characters in them (including spacesi, colons, etc). This
1312: * is done so names like "[Foo bar:fuz:]" can be used as symbol names.
1313: */
1314: if(*input_line_pointer == '"'){
1315: input_line_pointer++;
1316: do{
1317: c = *input_line_pointer++ ;
1318: }while(c != '"' && c != '\0' && c != '\n');
1319: if(c == '"'){
1320: *(input_line_pointer - 1) = 0;
1321: c = *input_line_pointer++;
1322: }
1323: }
1324: else{
1325: while(is_part_of_name(c = *input_line_pointer++))
1326: ;
1327: }
1328: *--input_line_pointer = 0;
1329: return(c);
1330: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.