diff options
Diffstat (limited to 'gas')
| -rw-r--r-- | gas/ChangeLog | 4 | ||||
| -rw-r--r-- | gas/symbols.c | 294 |
2 files changed, 176 insertions, 122 deletions
diff --git a/gas/ChangeLog b/gas/ChangeLog index c7449eb..91d143b 100644 --- a/gas/ChangeLog +++ b/gas/ChangeLog @@ -1,5 +1,9 @@ Mon Aug 25 14:25:48 1997 Ian Lance Taylor <ian@cygnus.com> + * symbols.c (resolve_symbol_value): Store the value back into the + symbol expression, to handle add or subtract simplification + correctly. Handle O_symbol_rva. Add default case. + * config/tc-ppc.c (ppc_change_csect): Temporarily lower the chunksize while creating the new subsection. * as.c (chunksize): Initialize to zero. diff --git a/gas/symbols.c b/gas/symbols.c index 161f83b..d6dc8a4 100644 --- a/gas/symbols.c +++ b/gas/symbols.c @@ -236,7 +236,7 @@ colon (sym_name) /* just seen "x:" - rattle symbols & frags */ /* * Now check for undefined symbols */ - if (!S_IS_DEFINED (symbolP)) + if (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)) { if (S_GET_VALUE (symbolP) == 0) { @@ -265,7 +265,7 @@ colon (sym_name) /* just seen "x:" - rattle symbols & frags */ */ if (((!S_IS_DEBUG (symbolP) - && !S_IS_DEFINED (symbolP) + && (!S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)) && S_IS_EXTERNAL (symbolP)) || S_GET_SEGMENT (symbolP) == bss_section) && (now_seg == data_section @@ -353,6 +353,9 @@ colon (sym_name) /* just seen "x:" - rattle symbols & frags */ #ifdef tc_frob_label tc_frob_label (symbolP); #endif +#ifdef obj_frob_label + obj_frob_label (symbolP); +#endif return symbolP; } @@ -633,87 +636,81 @@ verify_symbol_chain_2 (sym) pass over the symbol table to resolve any symbols with complex values. */ -void -resolve_symbol_value (symp) +valueT +resolve_symbol_value (symp, finalize) symbolS *symp; + int finalize; { int resolved; + valueT final_val; + segT final_seg; if (symp->sy_resolved) - return; + { + if (symp->sy_value.X_op == O_constant) + return (valueT) symp->sy_value.X_add_number; + else + return 0; + } resolved = 0; + final_seg = S_GET_SEGMENT (symp); if (symp->sy_resolving) { - as_bad ("Symbol definition loop encountered at %s", - S_GET_NAME (symp)); - S_SET_VALUE (symp, (valueT) 0); + if (finalize) + as_bad ("Symbol definition loop encountered at %s", S_GET_NAME (symp)); + final_val = 0; resolved = 1; } else { - offsetT left, right, val; + symbolS *add_symbol, *op_symbol; + offsetT left, right; segT seg_left, seg_right; + operatorT op; symp->sy_resolving = 1; - /* Simplify addition or subtraction of a constant by folding the - constant into X_add_number. */ - if (symp->sy_value.X_op == O_add - || symp->sy_value.X_op == O_subtract) - { - resolve_symbol_value (symp->sy_value.X_add_symbol); - resolve_symbol_value (symp->sy_value.X_op_symbol); - if (S_GET_SEGMENT (symp->sy_value.X_op_symbol) == absolute_section) - { - right = S_GET_VALUE (symp->sy_value.X_op_symbol); - if (symp->sy_value.X_op == O_add) - symp->sy_value.X_add_number += right; - else - symp->sy_value.X_add_number -= right; - symp->sy_value.X_op = O_symbol; - symp->sy_value.X_op_symbol = NULL; - } - else if ((S_GET_SEGMENT (symp->sy_value.X_add_symbol) - == absolute_section) - && symp->sy_value.X_op == O_add) - { - left = S_GET_VALUE (symp->sy_value.X_add_symbol); - symp->sy_value.X_add_symbol = symp->sy_value.X_op_symbol; - symp->sy_value.X_add_number += left; - symp->sy_value.X_op = O_symbol; - symp->sy_value.X_op_symbol = NULL; - } - } + /* Help out with CSE. */ + add_symbol = symp->sy_value.X_add_symbol; + op_symbol = symp->sy_value.X_op_symbol; + final_val = symp->sy_value.X_add_number; + op = symp->sy_value.X_op; - switch (symp->sy_value.X_op) + switch (op) { + default: + BAD_CASE (op); + break; + case O_absent: - S_SET_VALUE (symp, 0); + final_val = 0; /* Fall through. */ + case O_constant: - S_SET_VALUE (symp, S_GET_VALUE (symp) + symp->sy_frag->fr_address); - if (S_GET_SEGMENT (symp) == expr_section) - S_SET_SEGMENT (symp, absolute_section); + final_val += symp->sy_frag->fr_address; + if (final_seg == expr_section) + final_seg = absolute_section; resolved = 1; break; case O_symbol: - resolve_symbol_value (symp->sy_value.X_add_symbol); + case O_symbol_rva: + left = resolve_symbol_value (add_symbol, finalize); + do_symbol: if (symp->sy_mri_common) { /* This is a symbol inside an MRI common section. The relocation routines are going to handle it specially. Don't change the value. */ - S_SET_VALUE (symp, symp->sy_value.X_add_number); - resolved = symp->sy_value.X_add_symbol->sy_resolved; + resolved = add_symbol->sy_resolved; break; } - if (symp->sy_value.X_add_number == 0) - copy_symbol_attributes (symp, symp->sy_value.X_add_symbol); + if (finalize && final_val == 0) + copy_symbol_attributes (symp, add_symbol); /* If we have equated this symbol to an undefined symbol, we keep X_op set to O_symbol, and we don't change @@ -721,46 +718,45 @@ resolve_symbol_value (symp) relocation to detect this case, and convert the relocation to be against the symbol to which this symbol is equated. */ - if (! S_IS_DEFINED (symp->sy_value.X_add_symbol) - || S_IS_COMMON (symp->sy_value.X_add_symbol)) + if (! S_IS_DEFINED (add_symbol) || S_IS_COMMON (add_symbol)) { - symp->sy_value.X_op = O_symbol; - S_SET_SEGMENT (symp, - S_GET_SEGMENT (symp->sy_value.X_add_symbol)); + if (finalize) + { + symp->sy_value.X_op = O_symbol; + S_SET_SEGMENT (symp, S_GET_SEGMENT (add_symbol)); + } + symp->sy_value.X_add_number = final_val; + final_val = 0; + resolved = add_symbol->sy_resolved; + goto exit_dont_set_value; } else { - S_SET_VALUE (symp, - (symp->sy_value.X_add_number - + symp->sy_frag->fr_address - + S_GET_VALUE (symp->sy_value.X_add_symbol))); - if (S_GET_SEGMENT (symp) == expr_section - || S_GET_SEGMENT (symp) == undefined_section) - S_SET_SEGMENT (symp, - S_GET_SEGMENT (symp->sy_value.X_add_symbol)); + final_val += symp->sy_frag->fr_address + left; + if (final_seg == expr_section || final_seg == undefined_section) + final_seg = S_GET_SEGMENT (add_symbol); } - resolved = symp->sy_value.X_add_symbol->sy_resolved; + resolved = add_symbol->sy_resolved; break; case O_uminus: case O_bit_not: case O_logical_not: - resolve_symbol_value (symp->sy_value.X_add_symbol); - if (symp->sy_value.X_op == O_uminus) - val = - S_GET_VALUE (symp->sy_value.X_add_symbol); - else if (symp->sy_value.X_op == O_logical_not) - val = ! S_GET_VALUE (symp->sy_value.X_add_symbol); + left = resolve_symbol_value (add_symbol, finalize); + + if (op == O_uminus) + left = -left; + else if (op == O_logical_not) + left = !left; else - val = ~ S_GET_VALUE (symp->sy_value.X_add_symbol); - S_SET_VALUE (symp, - (val - + symp->sy_value.X_add_number - + symp->sy_frag->fr_address)); - if (S_GET_SEGMENT (symp) == expr_section - || S_GET_SEGMENT (symp) == undefined_section) - S_SET_SEGMENT (symp, absolute_section); - resolved = symp->sy_value.X_add_symbol->sy_resolved; + left = ~left; + + final_val += left + symp->sy_frag->fr_address; + if (final_seg == expr_section || final_seg == undefined_section) + final_seg = absolute_section; + + resolved = add_symbol->sy_resolved; break; case O_multiply: @@ -782,12 +778,35 @@ resolve_symbol_value (symp) case O_gt: case O_logical_and: case O_logical_or: - resolve_symbol_value (symp->sy_value.X_add_symbol); - resolve_symbol_value (symp->sy_value.X_op_symbol); - seg_left = S_GET_SEGMENT (symp->sy_value.X_add_symbol); - seg_right = S_GET_SEGMENT (symp->sy_value.X_op_symbol); - left = S_GET_VALUE (symp->sy_value.X_add_symbol); - right = S_GET_VALUE (symp->sy_value.X_op_symbol); + left = resolve_symbol_value (add_symbol, finalize); + right = resolve_symbol_value (op_symbol, finalize); + seg_left = S_GET_SEGMENT (add_symbol); + seg_right = S_GET_SEGMENT (op_symbol); + + /* Simplify addition or subtraction of a constant by folding the + constant into X_add_number. */ + if (op == O_add || op == O_subtract) + { + if (seg_right == absolute_section) + { + if (op == O_add) + final_val += right; + else + final_val -= right; + op = O_symbol; + op_symbol = NULL; + goto do_symbol; + } + else if (seg_left == absolute_section && op == O_add) + { + op = O_symbol; + final_val += left; + add_symbol = op_symbol; + left = right; + op_symbol = NULL; + goto do_symbol; + } + } /* Subtraction is permitted if both operands are in the same section. Otherwise, both operands must be absolute. We @@ -795,10 +814,11 @@ resolve_symbol_value (symp) constant above. This will probably need to be changed for an object file format which supports arbitrary expressions, such as IEEE-695. */ - if ((seg_left != absolute_section - || seg_right != absolute_section) - && (symp->sy_value.X_op != O_subtract - || seg_left != seg_right)) + /* Don't emit messages unless we're finalizing the symbol value, + otherwise we may get the same message multiple times. */ + if ((seg_left != absolute_section || seg_right != absolute_section) + && (op != O_subtract || seg_left != seg_right) + && finalize) { char *file; unsigned int line; @@ -834,38 +854,54 @@ resolve_symbol_value (symp) } } + /* Check for division by zero. */ + if ((op == O_divide || op == O_modulus) && right == 0) + { + /* If seg_right is not absolute_section, then we've + already issued a warning about using a bad symbol. */ + if (seg_right == absolute_section && finalize) + { + char *file; + unsigned int line; + + if (expr_symbol_where (symp, &file, &line)) + as_bad_where (file, line, "division by zero"); + else + as_bad ("division by zero when setting %s", + S_GET_NAME (symp)); + } + + right = 1; + } + switch (symp->sy_value.X_op) { - case O_multiply: val = left * right; break; - case O_divide: val = left / right; break; - case O_modulus: val = left % right; break; - case O_left_shift: val = left << right; break; - case O_right_shift: val = left >> right; break; - case O_bit_inclusive_or: val = left | right; break; - case O_bit_or_not: val = left |~ right; break; - case O_bit_exclusive_or: val = left ^ right; break; - case O_bit_and: val = left & right; break; - case O_add: val = left + right; break; - case O_subtract: val = left - right; break; - case O_eq: val = left == right ? ~ (offsetT) 0 : 0; - case O_ne: val = left != right ? ~ (offsetT) 0 : 0; - case O_lt: val = left < right ? ~ (offsetT) 0 : 0; - case O_le: val = left <= right ? ~ (offsetT) 0 : 0; - case O_ge: val = left >= right ? ~ (offsetT) 0 : 0; - case O_gt: val = left > right ? ~ (offsetT) 0 : 0; - case O_logical_and: val = left && right; break; - case O_logical_or: val = left || right; break; - default: abort (); + case O_multiply: left *= right; break; + case O_divide: left /= right; break; + case O_modulus: left %= right; break; + case O_left_shift: left <<= right; break; + case O_right_shift: left >>= right; break; + case O_bit_inclusive_or: left |= right; break; + case O_bit_or_not: left |= ~right; break; + case O_bit_exclusive_or: left ^= right; break; + case O_bit_and: left &= right; break; + case O_add: left += right; break; + case O_subtract: left -= right; break; + case O_eq: left = left == right ? ~ (offsetT) 0 : 0; + case O_ne: left = left != right ? ~ (offsetT) 0 : 0; + case O_lt: left = left < right ? ~ (offsetT) 0 : 0; + case O_le: left = left <= right ? ~ (offsetT) 0 : 0; + case O_ge: left = left >= right ? ~ (offsetT) 0 : 0; + case O_gt: left = left > right ? ~ (offsetT) 0 : 0; + case O_logical_and: left = left && right; break; + case O_logical_or: left = left || right; break; + default: abort (); } - S_SET_VALUE (symp, - (symp->sy_value.X_add_number - + symp->sy_frag->fr_address - + val)); - if (S_GET_SEGMENT (symp) == expr_section - || S_GET_SEGMENT (symp) == undefined_section) - S_SET_SEGMENT (symp, absolute_section); - resolved = (symp->sy_value.X_add_symbol->sy_resolved - && symp->sy_value.X_op_symbol->sy_resolved); + + final_val += symp->sy_frag->fr_address + left; + if (final_seg == expr_section || final_seg == undefined_section) + final_seg = absolute_section; + resolved = (add_symbol->sy_resolved && op_symbol->sy_resolved); break; case O_register: @@ -878,16 +914,30 @@ resolve_symbol_value (symp) anything. */ break; } + + symp->sy_resolving = 0; } + if (finalize) + { + S_SET_VALUE (symp, final_val); + S_SET_SEGMENT (symp, final_seg); + } + +exit_dont_set_value: /* Don't worry if we can't resolve an expr_section symbol. */ - if (resolved) - symp->sy_resolved = 1; - else if (S_GET_SEGMENT (symp) != expr_section) + if (finalize) { - as_bad ("can't resolve value for symbol \"%s\"", S_GET_NAME (symp)); - symp->sy_resolved = 1; + if (resolved) + symp->sy_resolved = 1; + else if (S_GET_SEGMENT (symp) != expr_section) + { + as_bad ("can't resolve value for symbol \"%s\"", S_GET_NAME (symp)); + symp->sy_resolved = 1; + } } + + return final_val; } /* Dollar labels look like a number followed by a dollar sign. Eg, "42$". @@ -1255,8 +1305,8 @@ valueT S_GET_VALUE (s) symbolS *s; { - if (!s->sy_resolved && !s->sy_resolving && s->sy_value.X_op != O_constant) - resolve_symbol_value (s); + if (!s->sy_resolved && s->sy_value.X_op != O_constant) + resolve_symbol_value (s, 1); if (s->sy_value.X_op != O_constant) { static symbolS *recur; @@ -1296,7 +1346,7 @@ copy_symbol_attributes (dest, src) #ifdef BFD_ASSEMBLER /* In an expression, transfer the settings of these flags. The user can override later, of course. */ -#define COPIED_SYMFLAGS (BSF_FUNCTION) +#define COPIED_SYMFLAGS (BSF_FUNCTION | BSF_OBJECT) dest->bsym->flags |= src->bsym->flags & COPIED_SYMFLAGS; #endif |