gas: equates of registers

There are two problems: symbol_equated_p() doesn't recognize equates of
registers, and S_CAN_BE_REDEFINED() goes by section rather than by
expression type. Both together undermine .eqv and .equiv clearly meaning
to guard the involved symbols against re-definition (both ways).

To compensate pseudo_set() now using O_symbol and S_CAN_BE_REDEFINED()
now checking for O_register,
- for targets creating register symbols through symbol_{new,create}() ->
  symbol_init() -> S_SET_VALUE() (alpha, arc, dlx, ia64, m68k, mips,
  mmix, tic4x, tic54x, plus anything using cgen or itbl-ops), have
  symbol_init() set their expressions to O_register,
- x86'es parse_register() also can't go by section anymore when
  trying to "look through" equates; probably symbol_equated_p() should
  have been used there from the beginning, if only that had worked for
  equates of registers,
- various targets need to "look through" equates when parsing insn
  operands (which also helps transitive forward equates); perhaps even
  more ought to, but many don't look to consider the possibility of
  register equates in the first place.

This was uncovered by code reported in PR gas/30274 (duplicating
PR gas/30272), except that there .eqv was used when really .equ was
meant. Therefore that bug report is addressed here only in so far as
gas wouldn't crash anymore; the code there still won't assemble
successfully, just that now the issues there are properly diagnosed.

diff --git a/gas/cgen.c b/gas/cgen.c
index cbac7452a3ce6744f0fcaecdf016f9ff641c8dd1..bf8791fef8655fcf1cd207da79974a404af1ef88 100644 (file)
--- a/gas/cgen.c
+++ b/gas/cgen.c
@@ -385,6 +385,8 @@ gas_cgen_parse_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
 
   /* FIXME: Need to check `want'.  */
 
+  resolve_register (&exp);
+
   switch (exp.X_op)
     {
     case O_illegal:

diff --git a/gas/config/tc-alpha.c b/gas/config/tc-alpha.c
index a3c62b2dada1e7bc696f785f4f5992b055a54564..9ae091725c71eef48017bef4d7e6707e57a32dc0 100644 (file)
--- a/gas/config/tc-alpha.c
+++ b/gas/config/tc-alpha.c
@@ -987,6 +987,7 @@ tokenize_arguments (char *str,
 
            /* First try for parenthesized register ...  */
            expression (tok);
+           resolve_register (tok);
            if (*input_line_pointer == ')' && tok->X_op == O_register)
              {
                tok->X_op = (saw_comma ? O_cpregister : O_pregister);
@@ -1010,6 +1011,8 @@ tokenize_arguments (char *str,
          if (tok->X_op == O_illegal || tok->X_op == O_absent)
            goto err;
 
+         resolve_register (tok);
+
          saw_comma = 0;
          saw_arg = 1;
          ++tok;

diff --git a/gas/config/tc-arc.c b/gas/config/tc-arc.c
index 455f5488316418cfee7d237c35af5d6835c9e9a1..8d16cb5708813b9b4558b3c91653e8633943267f 100644 (file)
--- a/gas/config/tc-arc.c
+++ b/gas/config/tc-arc.c
@@ -1312,6 +1312,8 @@ tokenize_arguments (char *str,
             relocation type as well.  */
          if (*input_line_pointer == '@')
            parse_reloc_symbol (tok);
+         else
+           resolve_register (tok);
 
          debug_exp (tok);
 

diff --git a/gas/config/tc-dlx.c b/gas/config/tc-dlx.c
index af5633e4abbe8f0700a637a788eb12765c5b5578..9058cc21e3b261e03262d66b479b5ec05eebce10 100644 (file)
--- a/gas/config/tc-dlx.c
+++ b/gas/config/tc-dlx.c
@@ -632,6 +632,7 @@ parse_operand (char *s, expressionS *operandp)
       /* Normal operand parsing.  */
       input_line_pointer = s;
       (void) expression (operandp);
+      resolve_register (operandp);
     }
 
   new_pos = input_line_pointer;

diff --git a/gas/config/tc-i386.c b/gas/config/tc-i386.c
index 29b7734b1ac11f29c9f7b4c9f14c2cd660654d92..8856ccc495cc979b473bc3de9a0cb3df6dc45f7c 100644 (file)
--- a/gas/config/tc-i386.c
+++ b/gas/config/tc-i386.c
@@ -13830,11 +13830,11 @@ parse_register (const char *reg_string, char **end_op)
       input_line_pointer = buf;
       get_symbol_name (&name);
       symbolP = symbol_find (name);
-      while (symbolP && S_GET_SEGMENT (symbolP) != reg_section)
+      while (symbolP && symbol_equated_p (symbolP))
        {
          const expressionS *e = symbol_get_value_expression(symbolP);
 
-         if (e->X_op != O_symbol || e->X_add_number)
+         if (e->X_add_number)
            break;
          symbolP = e->X_add_symbol;
        }

diff --git a/gas/config/tc-ia64.c b/gas/config/tc-ia64.c
index 66b0680c1243991552d4ea41d7773c4e2ddd27b3..0b97986f10baef753bde61223f8f016d9ca51007 100644 (file)
--- a/gas/config/tc-ia64.c
+++ b/gas/config/tc-ia64.c
@@ -5987,6 +5987,7 @@ parse_operand (expressionS *e, int more)
   e->X_op = O_absent;
   SKIP_WHITESPACE ();
   expression (e);
+  resolve_register (e);
   sep = *input_line_pointer;
   if (more && (sep == ',' || sep == more))
     ++input_line_pointer;

diff --git a/gas/config/tc-mmix.c b/gas/config/tc-mmix.c
index 1e358abf400c2b1ce491a7607cfa9be444cb377e..881534509b39bdfb597fe7493150d09ea8a4fbb7 100644 (file)
--- a/gas/config/tc-mmix.c
+++ b/gas/config/tc-mmix.c
@@ -624,6 +624,8 @@ get_putget_operands (struct mmix_opcode *insn, char *operands,
   regno = get_spec_regno (sregp);
   *sregend = c;
 
+  resolve_register (expp_reg);
+
   /* Let the caller issue errors; we've made sure the operands are
      invalid.  */
   if (expp_reg->X_op != O_illegal

diff --git a/gas/config/tc-mn10200.c b/gas/config/tc-mn10200.c
index bab79040711d0dd63f38c735e489c1c2de4bec88..c0cf9e5d9f4b6b83857c6ae3e38f3712a29ab802 100644 (file)
--- a/gas/config/tc-mn10200.c
+++ b/gas/config/tc-mn10200.c
@@ -1025,6 +1025,7 @@ md_assemble (char *str)
          else
            {
              expression (&ex);
+             resolve_register (&ex);
            }
 
          switch (ex.X_op)

diff --git a/gas/config/tc-mn10300.c b/gas/config/tc-mn10300.c
index eea903bf3e2cdaff304f467753661745b22006fa..a983c1554c332013b0f3aad7601e04334852dc6d 100644 (file)
--- a/gas/config/tc-mn10300.c
+++ b/gas/config/tc-mn10300.c
@@ -1669,6 +1669,7 @@ md_assemble (char *str)
          else
            {
              expression (&ex);
+             resolve_register (&ex);
            }
 
          switch (ex.X_op)

diff --git a/gas/config/tc-msp430.c b/gas/config/tc-msp430.c
index d6fedd8fcfde46271ddf3567c5e98486057ba5d0..c1604517f67a7605d7fced68459590b11fcba32c 100644 (file)
--- a/gas/config/tc-msp430.c
+++ b/gas/config/tc-msp430.c
@@ -415,6 +415,8 @@ parse_exp (char * s, expressionS * op)
   expression (op);
   if (op->X_op == O_absent)
     as_bad (_("missing operand"));
+  else
+    resolve_register (op);
 
   /* Our caller is likely to check that the entire expression was parsed.
      If we have found a hex constant with an 'h' suffix, ilp will be left

diff --git a/gas/config/tc-nds32.c b/gas/config/tc-nds32.c
index d8248e2bd0343abc34d3ca41c48872caaa5b0cd8..d576c426d76377d369da0c22097c607415ce3ee0 100644 (file)
--- a/gas/config/tc-nds32.c
+++ b/gas/config/tc-nds32.c
@@ -2519,6 +2519,7 @@ parse_expression (char *str, expressionS *exp)
   tmp = input_line_pointer;    /* Save line pointer.  */
   input_line_pointer = str;
   expression (exp);
+  resolve_register (exp);
   s = input_line_pointer;
   input_line_pointer = tmp;    /* Restore line pointer.  */
 
@@ -4571,6 +4572,7 @@ nds32_asm_parse_operand (struct nds32_asm_desc *pdesc ATTRIBUTE_UNUSED,
   hold = input_line_pointer;
   input_line_pointer = *pstr;
   expression (pexp);
+  resolve_register (pexp);
   *pstr = input_line_pointer;
   input_line_pointer = hold;
 

diff --git a/gas/config/tc-ppc.c b/gas/config/tc-ppc.c
index ae14fae44bdb758bff7b70d2a72b1e87156b7954..8b1d995da6d0fc3df88b14b8fab3778f0ff001c0 100644 (file)
--- a/gas/config/tc-ppc.c
+++ b/gas/config/tc-ppc.c
@@ -3475,6 +3475,8 @@ md_assemble (char *str)
       str = input_line_pointer;
       input_line_pointer = hold;
 
+      resolve_register (&ex);
+
       if (ex.X_op == O_illegal)
        as_bad (_("illegal operand"));
       else if (ex.X_op == O_absent)

diff --git a/gas/config/tc-s390.c b/gas/config/tc-s390.c
index f6bcb9e855ed66390f0fa51340e323ac885ad999..955851946f9c1a0335f9bd548ffc38d816fc881b 100644 (file)
--- a/gas/config/tc-s390.c
+++ b/gas/config/tc-s390.c
@@ -1308,7 +1308,10 @@ md_gather_operands (char *str,
 
       /* Parse the operand.  */
       if (! register_name (&ex))
-       expression (&ex);
+       {
+         expression (&ex);
+         resolve_register (&ex);
+       }
 
       str = input_line_pointer;
       input_line_pointer = hold;

diff --git a/gas/config/tc-spu.c b/gas/config/tc-spu.c
index 96d03b7b5b44271c00547ec515b50ee4fbda0f05..9c1a23c4f5e7da9fede004618e3713cf464e12ec 100644 (file)
--- a/gas/config/tc-spu.c
+++ b/gas/config/tc-spu.c
@@ -573,6 +573,7 @@ get_reg (const char *param, struct spu_insn *insn, int arg, int accept_expr)
       expression (&ex);
       param = input_line_pointer;
       input_line_pointer = save_ptr;
+      resolve_register (&ex);
       if (ex.X_op == O_register || ex.X_op == O_constant)
        {
          insn->opcode |= ex.X_add_number << arg_encode[arg].pos;

diff --git a/gas/config/tc-tic4x.c b/gas/config/tc-tic4x.c
index 72c50068fcf30f584fde2215739dc008f65ca9d8..7dd5e4b6de9726a3fb48ac17040ae406577d2959 100644 (file)
--- a/gas/config/tc-tic4x.c
+++ b/gas/config/tc-tic4x.c
@@ -649,6 +649,7 @@ tic4x_expression (char *str, expressionS *exp)
   t = input_line_pointer;      /* Save line pointer.  */
   input_line_pointer = str;
   expression (exp);
+  resolve_register (exp);
   s = input_line_pointer;
   input_line_pointer = t;      /* Restore line pointer.  */
   return s;                    /* Return pointer to where parsing stopped.  */

diff --git a/gas/config/tc-v850.c b/gas/config/tc-v850.c
index 56726e54de944077ca7575da6564693b59590bd2..565f4edb558be7c2bfe1d15064c20d398b89a85f 100644 (file)
--- a/gas/config/tc-v850.c
+++ b/gas/config/tc-v850.c
@@ -2909,6 +2909,7 @@ md_assemble (char *str)
              else
                {
                  expression (&ex);
+                 resolve_register (&ex);
 
                  if ((operand->flags & V850_NOT_IMM0)
                      && ex.X_op == O_constant

diff --git a/gas/config/tc-xgate.c b/gas/config/tc-xgate.c
index 5ad6e1b07750b00fd3f5026d52208ef420c551a6..f311ed422e8245480fe5ba97174e910c7964a469 100644 (file)
--- a/gas/config/tc-xgate.c
+++ b/gas/config/tc-xgate.c
@@ -893,6 +893,8 @@ xgate_parse_exp (char *s, expressionS * op)
   expression (op);
   if (op->X_op == O_absent)
     as_bad (_("missing operand"));
+  else
+    resolve_register (op);
   return input_line_pointer;
 }
 

diff --git a/gas/config/tc-z80.c b/gas/config/tc-z80.c
index 9e989fb3df521f238bcae7f53250adc9720dc062..577c58479dad7b60a39e447ed0aeae062c51035b 100644 (file)
--- a/gas/config/tc-z80.c
+++ b/gas/config/tc-z80.c
@@ -926,6 +926,7 @@ parse_exp_not_indexed (const char *s, expressionS *op)
     }
   input_line_pointer = (char*) s ;
   expression (op);
+  resolve_register (op);
   switch (op->X_op)
     {
     case O_absent:

diff --git a/gas/expr.c b/gas/expr.c
index 05b210ba98b486e60a840faf26959996941e9fc9..055745f4b06dee68363e3782477cdc3fc89ed17e 100644 (file)
--- a/gas/expr.c
+++ b/gas/expr.c
@@ -2382,6 +2382,31 @@ resolve_expression (expressionS *expressionP)
 
   return 1;
 }
+
+/* "Look through" register equates.  */
+void resolve_register (expressionS *expP)
+{
+  symbolS *sym;
+  offsetT acc = 0;
+  const expressionS *e = expP;
+
+  if (expP->X_op != O_symbol)
+    return;
+
+  do
+    {
+      sym = e->X_add_symbol;
+      acc += e->X_add_number;
+      e = symbol_get_value_expression (sym);
+    }
+  while (symbol_equated_p (sym));
+
+  if (e->X_op == O_register)
+    {
+      *expP = *e;
+      expP->X_add_number += acc;
+    }
+}
 \f
 /* This lives here because it belongs equally in expr.c & read.c.
    expr.c is just a branch office read.c anyway, and putting it

diff --git a/gas/expr.h b/gas/expr.h
index 52574bd01155815894d43707e8b8e5f912374f1d..73bc398a80e72d95171893015fce24271fcad021 100644 (file)
--- a/gas/expr.h
+++ b/gas/expr.h
@@ -190,5 +190,6 @@ extern symbolS *expr_build_dot (void);
 extern uint32_t generic_bignum_to_int32 (void);
 extern uint64_t generic_bignum_to_int64 (void);
 extern int resolve_expression (expressionS *);
+extern void resolve_register (expressionS *);
 
 extern bool literal_prefix_dollar_hex;

diff --git a/gas/read.c b/gas/read.c
index ac39fc9582ebb1cdfef70a1181355869b0671ac8..b4b628f2e5c4170b38f3e6783165a453d8c710fd 100644 (file)
--- a/gas/read.c
+++ b/gas/read.c
@@ -4000,6 +4000,10 @@ pseudo_set (symbolS *symbolP)
          return;
        }
 #endif
+      /* Make sure symbol_equated_p() recognizes the symbol as an equate.  */
+      exp.X_add_symbol = make_expr_symbol (&exp);
+      exp.X_add_number = 0;
+      exp.X_op = O_symbol;
       symbol_set_value_expression (symbolP, &exp);
       S_SET_SEGMENT (symbolP, reg_section);
       set_zero_frag (symbolP);

diff --git a/gas/symbols.c b/gas/symbols.c
index 308150908c1409a52c964d3c9d764a506631e433..a335c3169031565110d9b3a17b18cbd639c21975 100644 (file)
--- a/gas/symbols.c
+++ b/gas/symbols.c
@@ -387,6 +387,8 @@ symbol_init (symbolS *symbolP, const char *name, asection *sec,
     }
 
   S_SET_VALUE (symbolP, valu);
+  if (sec == reg_section)
+    symbolP->x->value.X_op = O_register;
 
   symbol_clear_list_pointers (symbolP);
 
@@ -2463,7 +2465,7 @@ S_CAN_BE_REDEFINED (const symbolS *s)
     return (((struct local_symbol *) s)->frag
            == &predefined_address_frag);
   /* Permit register names to be redefined.  */
-  return s->bsym->section == reg_section;
+  return s->x->value.X_op == O_register;
 }
 
 int