* Extensive changes to permit symbols to contain any expression

	type and to delay the computation of the expression until the
	value is actually needed.  This permits setting symbols to values
	calculated based on object code size.  Expressions were changed to
	no longer be in a section, to stop the overloading of segment and
	expression type that previously occurred.

	* as.c (big_section, pass1_section, diff_section, absent_section):
	Removed.
	(expr_section): Added (used for dummy symbols which hold
	intermediate expression values).
	(perform_an_assembly_pass): Create expr_section, do not create the
	sections now removed.
	* as.h (segT): Removed SEG_ABSENT, SEG_PASS1, SEG_BIG, and
	SEG_DIFFERENCE.  Added SEG_EXPR.
	(SEG_NORMAL): Corresponding changes.
	* subsegs.c (seg_name, subsegs_begin): Changed accordingly.
	* write.c (write_object_file): Ditto.
	* config/obj-aout.c (seg_N_TYPE): Ditto.
	* config/obj-bout.c (seg_N_TYPE): Ditto.
	* config/obj-coff.c (seg_N_TYPE): Ditto.
	* config/obj-coffbfd.c (seg_N_TYPE): Ditto.
	* config/obj-vms.c (seg_N_TYPE): Ditto.

	* expr.h (operatorT): Moved in from expr.c, added some values.
	(expressionS): Added X_op field, removed X_seg field; renamed
	X_subtract_symbol to X_op_symbol.
	* expr.c: Extensive changes to assign expression types rather than
	sections and to simplify the parsing.
	* write.c (fix_new_internal): New static function.
	(fix_new): Removed sub_symbol argument.
	(fix_new_exp): New function, takes expression argument.
	* write.h: Prototype changes for fix_new and fix_new_exp.
	* cond.c (s_if): Changed accordingly.
	* read.c (s_lsym, pseudo_set, emit_expr, parse_bitfield_cons,
	parse_repeat_cons, get_segmented_expression,
	get_known_segmented_expression, get_absolute_expression): Ditto.
	* symbols.c (resolve_symbol_value, S_GET_VALUE, S_SET_VALUE):
	Ditto.
	* write.c (write_object_file): Ditto.
	* config/obj-coff.c (obj_coff_def, obj_coff_val): Ditto.
	* config/obj-coffbfd.c (obj_coff_def, obj_coff_val,
	obj_coff_endef, yank_symbols): Ditto.
	* config/obj-elf.c (obj_elf_stab_generic, obj_elf_size): Ditto.
	* config/tc-a29k.c (md_assemble, parse_operand, machine_ip,
	print_insn, md_operand): Ditto.
	* config/tc-h8300.c (parse_exp, colonmod24, check_operand,
	do_a_fix_imm, build_bytes): Ditto.
	* config/tc-h8500.c (parse_exp, skip_colonthing, parse_reglist,
	get_specific, check, insert, md_convert_frag): Ditto.
	* config/tc-hppa.c (the_insn, fix_new_hppa, cons_fix_new_hppa,
	md_assemble, pa_ip, getExpression, getAbsoluteExpression,
	evaluateAbsolute, pa_build_unwind_subspace, pa_entry,
	process_exit): Ditto.
	* config/tc-hppa.h (STAB_FIXUP, is_DP_relative, is_PC_relative,
	is_complex): Ditto.
	* config/tc-i386.c (pe, md_assemble, i386_operand,
	md_estimate_size_before_relax, md_create_long_jump): Ditto.
	* config/tc-i860.c (md_assemble, getExpression, print_insn):
	Ditto.
	* config/tc-i960.c (parse_expr, subs, segs, md_convert_frag,
	get_cdisp, mem_fmt, parse_ldconst, relax_cobr, s_sysproc,
	i960_handle_align): Ditto.
	* config/tc-m68k.c (struct m68k_exp, struct m68k_it, seg, op,
	subs, add_fix, isvar, m68k_ip, md_assemble, md_convert_frag_1,
	md_estimate_size_before_relax, md_create_long_jump, get_num):
	Ditto.
	* config/tc-m88k.c (md_assemble, get_imm16, get_pcr,
	md_create_short_jump, md_create_long_jump): Ditto.
	* config/tc-mips.c (md_assemble, append_insn, gp_reference,
	macro_build, macro, my_getExpression): Ditto.  Also removed
	get_optional_absolute_expression; just use get_absolute_expression
	instead.
	* config/tc-ns32k.c (get_addr_mode, evaluate_expr, convert_iif,
	fix_new_ns32k, fix_new_ns32k_exp, cons_fix_new_ns32k): Ditto.
	* config/tc-ns32k.h (fix_new_ns32k prototype): Ditto.
	* config/tc-sh.c (parse_exp, check, insert, md_convert_frag):
	Ditto.
	* config/tc-sparc.c (md_assemble, sparc_ip, getExpression,
	print_insn): Ditto.
	* config/tc-tahoe.c (struct top, md_estimate_size_before_relax,
	tip_op, md_assemble): Ditto.
	* config/tc-vax.c (seg_of_operand, md_assemble,
	md_estimate_size_before_relax, md_create_long_jump): Ditto.
	* config/tc-z8k.c (parse_exp, check_operand, newfix): Ditto.

1 files changed, 264 insertions, 430 deletions

diff --git a/gas/expr.c b/gas/expr.c
index aa1b66d..a88780b 100644
--- a/gas/expr.c
+++ b/gas/expr.c
@@ -32,8 +32,41 @@
 #include "obstack.h"
 
 static void clean_up_expression PARAMS ((expressionS * expressionP));
+static symbolS *make_expr_symbol PARAMS ((expressionS * expressionP));
+
 extern const char EXP_CHARS[], FLT_CHARS[];
+
+/* Build a dummy symbol to hold a complex expression.  This is how we
+   build expressions up out of other expressions.  The symbol is put
+   into the fake section expr_section.  */
+
+static symbolS *
+make_expr_symbol (expressionP)
+     expressionS *expressionP;
+{
+  const char *fake;
+  symbolS *symbolP;
 
+  /* FIXME: This should be something which decode_local_label_name
+     will handle.  */
+#ifdef DOT_LABEL_PREFIX
+  fake = ".L0\001";
+#else
+  fake = "L0\001";
+#endif
+  /* Putting constant symbols in absolute_section rather than
+     expr_section is convenient for the old a.out code, for which
+     S_GET_SEGMENT does not always retrieve the value put in by
+     S_SET_SEGMENT.  */
+  symbolP = symbol_new (fake,
+			(expressionP->X_op == O_constant
+			 ? absolute_section
+			 : expr_section),
+			0, &zero_address_frag);
+  symbolP->sy_value = *expressionP;
+  return symbolP;
+}
+
 /*
  * Build any floating-point literal here.
  * Also build any bignum literal here.
@@ -79,13 +112,12 @@ floating_constant (expressionP)
 	  as_bad ("bad floating-point constant: unknown error code=%d.", error_code);
 	}
     }
-  expressionP->X_seg = big_section;
+  expressionP->X_op = O_big;
   /* input_line_pointer->just after constant, */
   /* which may point to whitespace. */
   expressionP->X_add_number = -1;
 }
 
-
 void
 integer_constant (radix, expressionP)
      int radix;
@@ -233,8 +265,8 @@ integer_constant (radix, expressionP)
 		   checking absoluteness. */
 		know (SEG_NORMAL (S_GET_SEGMENT (symbolP)));
 
+		expressionP->X_op = O_symbol;
 		expressionP->X_add_symbol = symbolP;
-		expressionP->X_seg = S_GET_SEGMENT (symbolP);
 
 	      }
 	    else
@@ -244,7 +276,7 @@ integer_constant (radix, expressionP)
 		   the parsed number.  */
 		as_bad ("backw. ref to unknown label \"%d:\", 0 assumed.",
 			(int) number);
-		expressionP->X_seg = absolute_section;
+		expressionP->X_op = O_constant;
 	      }
 
 	    expressionP->X_add_number = 0;
@@ -269,9 +301,8 @@ integer_constant (radix, expressionP)
 	       can't have newlines in the argument.  */
 	    know (S_GET_SEGMENT (symbolP) == undefined_section || S_GET_SEGMENT (symbolP) == text_section || S_GET_SEGMENT (symbolP) == data_section);
 #endif
+	    expressionP->X_op = O_symbol;
 	    expressionP->X_add_symbol = symbolP;
-	    expressionP->X_seg = undefined_section;
-	    expressionP->X_subtract_symbol = NULL;
 	    expressionP->X_add_number = 0;
 
 	    break;
@@ -301,9 +332,9 @@ integer_constant (radix, expressionP)
 		symbolP = symbol_find_or_make (name);
 	      }
 
+	    expressionP->X_op = O_symbol;
 	    expressionP->X_add_symbol = symbolP;
 	    expressionP->X_add_number = 0;
-	    expressionP->X_seg = S_GET_SEGMENT (symbolP);
 
 	    break;
 	  }			/* case '$' */
@@ -312,8 +343,8 @@ integer_constant (radix, expressionP)
 
 	default:
 	  {
+	    expressionP->X_op = O_constant;
 	    expressionP->X_add_number = number;
-	    expressionP->X_seg = absolute_section;
 	    input_line_pointer--;	/* restore following character. */
 	    break;
 	  }			/* really just a number */
@@ -325,8 +356,8 @@ integer_constant (radix, expressionP)
   else
     {
       /* not a small number */
+      expressionP->X_op = O_big;
       expressionP->X_add_number = number;
-      expressionP->X_seg = big_section;
       input_line_pointer--;	/*->char following number. */
     }
 }				/* integer_constant() */
@@ -338,14 +369,10 @@ integer_constant (radix, expressionP)
  * in:	Input_line_pointer points to 1st char of operand, which may
  *	be a space.
  *
- * out:	A expressionS. X_seg determines how to understand the rest of the
- *	expressionS.
- *	The operand may have been empty: in this case X_seg == SEG_ABSENT.
+ * out:	A expressionS.
+ *	The operand may have been empty: in this case X_op == O_absent.
  *	Input_line_pointer->(next non-blank) char after operand.
- *
  */
-
-
 
 static segT
 operand (expressionP)
@@ -354,6 +381,7 @@ operand (expressionP)
   char c;
   symbolS *symbolP;	/* points to symbol */
   char *name;		/* points to name of symbol */
+  segT retval = absolute_section;
 
   /* digits, assume it is a bignum. */
 
@@ -390,7 +418,6 @@ operand (expressionP)
     case '0':
       /* non-decimal radix */
 
-
       c = *input_line_pointer;
       switch (c)
 	{
@@ -404,9 +431,8 @@ operand (expressionP)
 	  else
 	    {
 	      /* The string was only zero */
-	      expressionP->X_add_symbol = 0;
+	      expressionP->X_op = O_constant;
 	      expressionP->X_add_number = 0;
-	      expressionP->X_seg = absolute_section;
 	    }
 
 	  break;
@@ -419,6 +445,9 @@ operand (expressionP)
 
 	case 'b':
 #ifdef LOCAL_LABELS_FB
+	  /* FIXME: This seems to be nonsense.  At this point we know
+	     for sure that *input_line_pointer is 'b'.  So why are we
+	     checking it?  What is this code supposed to do?  */
 	  if (!*input_line_pointer
 	      || (!strchr ("+-.0123456789", *input_line_pointer)
 		  && !strchr (EXP_CHARS, *input_line_pointer)))
@@ -449,6 +478,9 @@ operand (expressionP)
 	  /* if it says '0f' and the line ends or it doesn't look like
 	     a floating point #, its a local label ref.  dtrt */
 	  /* likewise for the b's.  xoxorich. */
+	  /* FIXME: As in the 'b' case, we know that the
+	     *input_line_pointer is 'f'.  What is this code really
+	     trying to do?  */
 	  if (c == 'f'
 	      && (!*input_line_pointer ||
 		  (!strchr ("+-.0123456789", *input_line_pointer) &&
@@ -482,78 +514,70 @@ operand (expressionP)
 	}
 
       break;
+
     case '(':
       /* didn't begin with digit & not a name */
-      {
-	(void) expression (expressionP);
-	/* Expression() will pass trailing whitespace */
-	if (*input_line_pointer++ != ')')
-	  {
-	    as_bad ("Missing ')' assumed");
-	    input_line_pointer--;
-	  }
-	/* here with input_line_pointer->char after "(...)" */
-      }
-      return expressionP->X_seg;
-
+      retval = expression (expressionP);
+      /* Expression() will pass trailing whitespace */
+      if (*input_line_pointer++ != ')')
+	{
+	  as_bad ("Missing ')' assumed");
+	  input_line_pointer--;
+	}
+      /* here with input_line_pointer->char after "(...)" */
+      return retval;
 
     case '\'':
       /* Warning: to conform to other people's assemblers NO ESCAPEMENT is
 	 permitted for a single quote. The next character, parity errors and
 	 all, is taken as the value of the operand. VERY KINKY.  */
+      expressionP->X_op = O_constant;
       expressionP->X_add_number = *input_line_pointer++;
-      expressionP->X_seg = absolute_section;
       break;
 
     case '+':
-      operand (expressionP);
+      retval = operand (expressionP);
       break;
 
     case '~':
     case '-':
       {
-	/* unary operator: hope for SEG_ABSOLUTE */
-	segT opseg = operand (expressionP);
-	if (opseg == absolute_section)
+	/* When computing - foo, ignore the segment of foo.  It has
+	   nothing to do with the segment of the result, which is
+	   ill-defined.  */
+	operand (expressionP);
+	if (expressionP->X_op == O_constant)
 	  {
 	    /* input_line_pointer -> char after operand */
 	    if (c == '-')
 	      {
-		expressionP->X_add_number = -expressionP->X_add_number;
+		expressionP->X_add_number = - expressionP->X_add_number;
 		/* Notice: '-' may overflow: no warning is given. This is
 		   compatible with other people's assemblers. Sigh.  */
 	      }
 	    else
-	      {
-		expressionP->X_add_number = ~expressionP->X_add_number;
-	      }
+	      expressionP->X_add_number = ~ expressionP->X_add_number;
 	  }
-	else if (opseg == text_section
-		 || opseg == data_section
-		 || opseg == bss_section
-		 || opseg == pass1_section
-		 || opseg == undefined_section)
+	else if (expressionP->X_op != O_illegal
+		 && expressionP->X_op != O_absent)
 	  {
+	    expressionP->X_add_symbol = make_expr_symbol (expressionP);
 	    if (c == '-')
-	      {
-		expressionP->X_subtract_symbol = expressionP->X_add_symbol;
-		expressionP->X_add_symbol = 0;
-		expressionP->X_seg = diff_section;
-	      }
+	      expressionP->X_op = O_uminus;
 	    else
-	      as_warn ("Unary operator %c ignored because bad operand follows",
-		       c);
+	      expressionP->X_op = O_bit_not;
+	    expressionP->X_add_number = 0;
 	  }
 	else
-	  as_warn ("Unary operator %c ignored because bad operand follows", c);
+	  as_warn ("Unary operator %c ignored because bad operand follows",
+		   c);
       }
       break;
 
     case '.':
       if (!is_part_of_name (*input_line_pointer))
 	{
-	  char *fake;
-	  extern struct obstack frags;
+	  const char *fake;
 
 	  /* JF: '.' is pseudo symbol with value of current location
 	     in current segment.  */
@@ -564,27 +588,25 @@ operand (expressionP)
 #endif
 	  symbolP = symbol_new (fake,
 				now_seg,
-	       (valueT) ((char*)obstack_next_free (&frags) - frag_now->fr_literal),
+				(valueT) frag_now_fix (),
 				frag_now);
 
-	  expressionP->X_add_number = 0;
+	  expressionP->X_op = O_symbol;
 	  expressionP->X_add_symbol = symbolP;
-	  expressionP->X_seg = now_seg;
+	  expressionP->X_add_number = 0;
+	  retval = now_seg;
 	  break;
-
 	}
       else
 	{
 	  goto isname;
-
-
 	}
     case ',':
     case '\n':
     case '\0':
     eol:
       /* can't imagine any other kind of operand */
-      expressionP->X_seg = absent_section;
+      expressionP->X_op = O_absent;
       input_line_pointer--;
       md_operand (expressionP);
       break;
@@ -602,25 +624,33 @@ operand (expressionP)
 	  name = --input_line_pointer;
 	  c = get_symbol_end ();
 	  symbolP = symbol_find_or_make (name);
-	  /* If we have an absolute symbol or a reg, then we know its value
-	     now.  */
-	  expressionP->X_seg = S_GET_SEGMENT (symbolP);
-	  if (expressionP->X_seg == absolute_section
-	      || expressionP->X_seg == reg_section)
-	    expressionP->X_add_number = S_GET_VALUE (symbolP);
+
+	  /* If we have an absolute symbol or a reg, then we know its
+	     value now.  */
+	  retval = S_GET_SEGMENT (symbolP);
+	  if (retval == absolute_section)
+	    {
+	      expressionP->X_op = O_constant;
+	      expressionP->X_add_number = S_GET_VALUE (symbolP);
+	    }
+	  else if (retval == reg_section)
+	    {
+	      expressionP->X_op = O_register;
+	      expressionP->X_add_number = S_GET_VALUE (symbolP);
+	    }
 	  else
 	    {
-	      expressionP->X_add_number = 0;
+	      expressionP->X_op = O_symbol;
 	      expressionP->X_add_symbol = symbolP;
+	      expressionP->X_add_number = 0;
 	    }
 	  *input_line_pointer = c;
-	  expressionP->X_subtract_symbol = NULL;
 	}
       else
 	{
 	  as_bad ("Bad expression");
+	  expressionP->X_op = O_constant;
 	  expressionP->X_add_number = 0;
-	  expressionP->X_seg = absolute_section;
 	}
     }
 
@@ -631,20 +661,18 @@ operand (expressionP)
   clean_up_expression (expressionP);
   SKIP_WHITESPACE ();		/*->1st char after operand. */
   know (*input_line_pointer != ' ');
-  return (expressionP->X_seg);
+  return expressionP->X_op == O_constant ? absolute_section : retval;
 }				/* operand() */
 
-
 /* Internal. Simplify a struct expression for use by expr() */
 
 /*
  * In:	address of a expressionS.
- *	The X_seg field of the expressionS may only take certain values.
- *	Now, we permit SEG_PASS1 to make code smaller & faster.
+ *	The X_op field of the expressionS may only take certain values.
  *	Elsewise we waste time special-case testing. Sigh. Ditto SEG_ABSENT.
  * Out:	expressionS may have been modified:
  *	'foo-foo' symbol references cancelled to 0,
- *		which changes X_seg from SEG_DIFFERENCE to SEG_ABSOLUTE;
+ *		which changes X_op from O_subtract to O_constant.
  *	Unused fields zeroed to help expr().
  */
 
@@ -652,158 +680,38 @@ static void
 clean_up_expression (expressionP)
      expressionS *expressionP;
 {
-  segT s = expressionP->X_seg;
-  if (s == absent_section
-      || s == pass1_section)
+  switch (expressionP->X_op)
     {
-      expressionP->X_add_symbol = NULL;
-      expressionP->X_subtract_symbol = NULL;
+    case O_illegal:
+    case O_absent:
       expressionP->X_add_number = 0;
-    }
-  else if (s == big_section
-	   || s == absolute_section)
-    {
-      expressionP->X_subtract_symbol = NULL;
+      /* Fall through.  */
+    case O_big:
+    case O_constant:
+    case O_register:
       expressionP->X_add_symbol = NULL;
-    }
-  else if (s == undefined_section)
-    expressionP->X_subtract_symbol = NULL;
-  else if (s == diff_section)
-    {
-      /*
-       * It does not hurt to 'cancel' NULL==NULL
-       * when comparing symbols for 'eq'ness.
-       * It is faster to re-cancel them to NULL
-       * than to check for this special case.
-       */
-      if (expressionP->X_subtract_symbol == expressionP->X_add_symbol
-	  || (expressionP->X_subtract_symbol
-	      && expressionP->X_add_symbol
-	      && (expressionP->X_subtract_symbol->sy_frag
-		  == expressionP->X_add_symbol->sy_frag)
+      /* Fall through.  */
+    case O_symbol:
+    case O_uminus:
+    case O_bit_not:
+      expressionP->X_op_symbol = NULL;
+      break;
+    case O_subtract:
+      if (expressionP->X_op_symbol == expressionP->X_add_symbol
+	  || ((expressionP->X_op_symbol->sy_frag
+	       == expressionP->X_add_symbol->sy_frag)
 	      && SEG_NORMAL (S_GET_SEGMENT (expressionP->X_add_symbol))
-	      && (S_GET_VALUE (expressionP->X_subtract_symbol)
+	      && (S_GET_VALUE (expressionP->X_op_symbol)
 		  == S_GET_VALUE (expressionP->X_add_symbol))))
 	{
-	  expressionP->X_subtract_symbol = NULL;
+	  expressionP->X_op = O_constant;
 	  expressionP->X_add_symbol = NULL;
-	  expressionP->X_seg = absolute_section;
-	}
-    }
-  else if (s == reg_section)
-    {
-      expressionP->X_add_symbol = NULL;
-      expressionP->X_subtract_symbol = NULL;
-    }
-  else
-    {
-      if (SEG_NORMAL (expressionP->X_seg))
-	{
-	  expressionP->X_subtract_symbol = NULL;
-	}
-      else
-	{
-	  BAD_CASE (expressionP->X_seg);
-	}
-    }
-}
-
-/*
- *			expr_part ()
- *
- * Internal. Made a function because this code is used in 2 places.
- * Generate error or correct X_?????_symbol of expressionS.
- */
-
-/*
- * symbol_1 += symbol_2 ... well ... sort of.
- */
-
-static segT
-expr_part (symbol_1_PP, symbol_2_P)
-     symbolS **symbol_1_PP;
-     symbolS *symbol_2_P;
-{
-  segT return_value;
-
-#if !defined (BFD_ASSEMBLER) && (defined (OBJ_AOUT) || defined (OBJ_BOUT))
-  int test = ((*symbol_1_PP) == NULL
-	      || (S_GET_SEGMENT (*symbol_1_PP) == text_section)
-	      || (S_GET_SEGMENT (*symbol_1_PP) == data_section)
-	      || (S_GET_SEGMENT (*symbol_1_PP) == bss_section)
-	      || (!S_IS_DEFINED (*symbol_1_PP)));
-  assert (test);
-  test = (symbol_2_P == NULL
-	  || (S_GET_SEGMENT (symbol_2_P) == text_section)
-	  || (S_GET_SEGMENT (symbol_2_P) == data_section)
-	  || (S_GET_SEGMENT (symbol_2_P) == bss_section)
-	  || (!S_IS_DEFINED (symbol_2_P)));
-  assert (test);
-#endif
-  if (*symbol_1_PP)
-    {
-      if (!S_IS_DEFINED (*symbol_1_PP))
-	{
-	  if (symbol_2_P)
-	    {
-	      return_value = pass1_section;
-	      *symbol_1_PP = NULL;
-	    }
-	  else
-	    {
-	      know (!S_IS_DEFINED (*symbol_1_PP));
-	      return_value = undefined_section;
-	    }
-	}
-      else
-	{
-	  if (symbol_2_P)
-	    {
-	      if (!S_IS_DEFINED (symbol_2_P))
-		{
-		  *symbol_1_PP = NULL;
-		  return_value = pass1_section;
-		}
-	      else
-		{
-		  /* {seg1} - {seg2} */
-		  as_bad ("Expression too complex, 2 symbolS forgotten: \"%s\" \"%s\"",
-			S_GET_NAME (*symbol_1_PP), S_GET_NAME (symbol_2_P));
-		  *symbol_1_PP = NULL;
-		  return_value = absolute_section;
-		}
-	    }
-	  else
-	    {
-	      return_value = S_GET_SEGMENT (*symbol_1_PP);
-	    }
-	}
-    }
-  else
-    {				/* (* symbol_1_PP) == NULL */
-      if (symbol_2_P)
-	{
-	  *symbol_1_PP = symbol_2_P;
-	  return_value = S_GET_SEGMENT (symbol_2_P);
-	}
-      else
-	{
-	  *symbol_1_PP = NULL;
-	  return_value = absolute_section;
+	  expressionP->X_op_symbol = NULL;
 	}
+      break;
+    default:
+      break;
     }
-#if defined (OBJ_AOUT) && !defined (BFD_ASSEMBLER)
-  test = (return_value == absolute_section
-	  || return_value == text_section
-	  || return_value == data_section
-	  || return_value == bss_section
-	  || return_value == undefined_section
-	  || return_value == pass1_section);
-  assert (test);
-#endif
-  know ((*symbol_1_PP) == NULL
-	|| (S_GET_SEGMENT (*symbol_1_PP) == return_value));
-  return (return_value);
 }
 
 /* Expression parser. */
@@ -824,27 +732,11 @@ expr_part (symbol_1_PP, symbol_2_P)
  * After expr(RANK,resultP) input_line_pointer->operator of rank <= RANK.
  * Also, we have consumed any leading or trailing spaces (operand does that)
  * and done all intervening operators.
+ *
+ * This returns the segment of the result, which will be
+ * absolute_section or the segment of a symbol.
  */
 
-typedef enum
-{
-  O_illegal,			/* (0)  what we get for illegal op */
-
-  O_multiply,			/* (1)  * */
-  O_divide,			/* (2)  / */
-  O_modulus,			/* (3)  % */
-  O_left_shift,			/* (4)  < */
-  O_right_shift,		/* (5)  > */
-  O_bit_inclusive_or,		/* (6)  | */
-  O_bit_or_not,			/* (7)  ! */
-  O_bit_exclusive_or,		/* (8)  ^ */
-  O_bit_and,			/* (9)  & */
-  O_add,			/* (10) + */
-  O_subtract			/* (11) - */
-}
-
-operatorT;
-
 #undef __
 #define __ O_illegal
 
@@ -884,17 +776,37 @@ static const operatorT op_encoding[256] =
  *	1	+ -
  *	2	& ^ ! |
  *	3	* / % << >>
+ *	4	unary - unary ~
  */
-static const operator_rankT
-  op_rank[] =
-{0, 3, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1};
+static const operator_rankT op_rank[] =
+{
+  0,	/* O_illegal */
+  0,	/* O_absent */
+  0,	/* O_constant */
+  0,	/* O_symbol */
+  0,	/* O_register */
+  0,	/* O_bit */
+  4,	/* O_uminus */
+  4,	/* O_bit_now */
+  3,	/* O_multiply */
+  3,	/* O_divide */
+  3,	/* O_modulus */
+  3,	/* O_left_shift */
+  3,	/* O_right_shift */
+  2,	/* O_bit_inclusive_or */
+  2,	/* O_bit_or_not */
+  2,	/* O_bit_exclusive_or */
+  2,	/* O_bit_and */
+  1,	/* O_add */
+  1,	/* O_subtract */
+};
 
-/* Return resultP->X_seg. */
-segT 
+segT
 expr (rank, resultP)
      operator_rankT rank;	/* Larger # is higher rank. */
      expressionS *resultP;	/* Deliver result here. */
 {
+  segT retval;
   expressionS right;
   operatorT op_left;
   char c_left;		/* 1st operator character. */
@@ -902,223 +814,145 @@ expr (rank, resultP)
   char c_right;
 
   know (rank >= 0);
-  (void) operand (resultP);
+
+  retval = operand (resultP);
+
   know (*input_line_pointer != ' ');	/* Operand() gobbles spaces. */
+
   c_left = *input_line_pointer;	/* Potential operator character. */
   op_left = op_encoding[c_left];
   while (op_left != O_illegal && op_rank[(int) op_left] > rank)
     {
+      segT rightseg;
+
       input_line_pointer++;	/*->after 1st character of operator. */
       /* Operators "<<" and ">>" have 2 characters. */
       if (*input_line_pointer == c_left && (c_left == '<' || c_left == '>'))
+	++input_line_pointer;
+
+      rightseg = expr (op_rank[(int) op_left], &right);
+      if (right.X_op == O_absent)
 	{
-	  input_line_pointer++;
-	}			/*->after operator. */
-      if (absent_section == expr (op_rank[(int) op_left], &right))
-	{
-	  as_warn ("Missing operand value assumed absolute 0.");
-	  resultP->X_add_number = 0;
-	  resultP->X_subtract_symbol = NULL;
+	  as_warn ("missing operand; zero assumed");
+	  right.X_op = O_constant;
+	  right.X_add_number = 0;
 	  resultP->X_add_symbol = NULL;
-	  resultP->X_seg = absolute_section;
+	  resultP->X_op_symbol = NULL;
 	}
+
       know (*input_line_pointer != ' ');
+
+      if (! SEG_NORMAL (retval))
+	retval = rightseg;
+      else if (SEG_NORMAL (rightseg)
+	       && retval != rightseg)
+	as_bad ("operation combines symbols in different segments");
+
       c_right = *input_line_pointer;
       op_right = op_encoding[c_right];
       if (*input_line_pointer == c_right && (c_right == '<' || c_right == '>'))
-	{
-	  input_line_pointer++;
-	}			/*->after operator. */
-      know ((int) op_right == 0 || op_rank[(int) op_right] <= op_rank[(int) op_left]);
+	++input_line_pointer;
+
+      know (op_right == O_illegal || op_rank[(int) op_right] <= op_rank[(int) op_left]);
+      know ((int) op_left >= (int) O_multiply && (int) op_left <= (int) O_subtract);
+
       /* input_line_pointer->after right-hand quantity. */
       /* left-hand quantity in resultP */
       /* right-hand quantity in right. */
       /* operator in op_left. */
-      if (resultP->X_seg == pass1_section || right.X_seg == pass1_section)
+
+      if (resultP->X_op == O_big)
 	{
-	  resultP->X_seg = pass1_section;
+	  as_warn ("left operand of %c is a %s; integer 0 assumed",
+		   c_left, resultP->X_add_number > 0 ? "bignum" : "float");
+	  resultP->X_op = O_constant;
+	  resultP->X_add_number = 0;
+	  resultP->X_add_symbol = NULL;
+	  resultP->X_op_symbol = NULL;
 	}
-      else
+      if (right.X_op == O_big)
 	{
-	  if (resultP->X_seg == big_section)
-	    {
-	      as_warn ("Left operand of %c is a %s.  Integer 0 assumed.",
-		    c_left, resultP->X_add_number > 0 ? "bignum" : "float");
-	      resultP->X_seg = absolute_section;
-	      resultP->X_add_symbol = 0;
-	      resultP->X_subtract_symbol = 0;
-	      resultP->X_add_number = 0;
-	    }
-	  if (right.X_seg == big_section)
+	  as_warn ("right operand of %c is a %s; integer 0 assumed",
+		   c_left, right.X_add_number > 0 ? "bignum" : "float");
+	  right.X_op = O_constant;
+	  right.X_add_number = 0;
+	  right.X_add_symbol = NULL;
+	  right.X_op_symbol = NULL;
+	}
+
+      /* Optimize common cases.  */
+      if (op_left == O_add && right.X_op == O_constant)
+	{
+	  /* X + constant.  */
+	  resultP->X_add_number += right.X_add_number;
+	}
+      else if (op_left == O_subtract && right.X_op == O_constant)
+	{
+	  /* X - constant.  */
+	  resultP->X_add_number -= right.X_add_number;
+	}
+      else if (op_left == O_add && resultP->X_op == O_constant)
+	{
+	  /* Constant + X.  */
+	  resultP->X_op = right.X_op;
+	  resultP->X_add_symbol = right.X_add_symbol;
+	  resultP->X_op_symbol = right.X_op_symbol;
+	  resultP->X_add_number += right.X_add_number;
+	  retval = rightseg;
+	}
+      else if (resultP->X_op == O_constant && right.X_op == O_constant)
+	{
+	  /* Constant OP constant.  */
+	  offsetT v = right.X_add_number;
+	  if (v == 0 && (op_left == O_divide || op_left == O_modulus))
 	    {
-	      as_warn ("Right operand of %c is a %s.  Integer 0 assumed.",
-		       c_left, right.X_add_number > 0 ? "bignum" : "float");
-	      right.X_seg = absolute_section;
-	      right.X_add_symbol = 0;
-	      right.X_subtract_symbol = 0;
-	      right.X_add_number = 0;
+	      as_warn ("division by zero");
+	      v = 1;
 	    }
-	  if (op_left == O_subtract)
+	  switch (op_left)
 	    {
-	      /*
-	       * Convert - into + by exchanging symbolS and negating number.
-	       * I know -infinity can't be negated in 2's complement:
-	       * but then it can't be subtracted either. This trick
-	       * does not cause any further inaccuracy.
-	       */
-
-	      symbolS *symbolP;
-
-	      right.X_add_number = -right.X_add_number;
-	      symbolP = right.X_add_symbol;
-	      right.X_add_symbol = right.X_subtract_symbol;
-	      right.X_subtract_symbol = symbolP;
-	      if (symbolP)
-		{
-		  right.X_seg = diff_section;
-		}
-	      op_left = O_add;
+	    case O_multiply:		resultP->X_add_number *= v; break;
+	    case O_divide:		resultP->X_add_number /= v; break;
+	    case O_modulus:		resultP->X_add_number %= v; break;
+	    case O_left_shift:		resultP->X_add_number <<= v; break;
+	    case O_right_shift:		resultP->X_add_number >>= v; break;
+	    case O_bit_inclusive_or:	resultP->X_add_number |= v; break;
+	    case O_bit_or_not:		resultP->X_add_number |= ~v; break;
+	    case O_bit_exclusive_or:	resultP->X_add_number ^= v; break;
+	    case O_bit_and:		resultP->X_add_number &= v; break;
+	    case O_add:			resultP->X_add_number += v; break;
+	    case O_subtract:		resultP->X_add_number -= v; break;
+	    default:			abort ();
 	    }
-
+	}
+      else if (resultP->X_op == O_symbol
+	       && right.X_op == O_symbol
+	       && (op_left == O_add
+		   || op_left == O_subtract
+		   || (resultP->X_add_number == 0
+		       && right.X_add_number == 0)))
+	{
+	  /* Symbol OP symbol.  */
+	  resultP->X_op = op_left;
+	  resultP->X_op_symbol = right.X_add_symbol;
 	  if (op_left == O_add)
-	    {
-	      segT seg1;
-	      segT seg2;
-#if 0 /* @@ This rejects stuff in common sections too.  Figure out some
-	 reasonable test, and make it clean...  */
-#if !defined (MANY_SEGMENTS) && !defined (OBJ_ECOFF)
-	      know (resultP->X_seg == data_section || resultP->X_seg == text_section || resultP->X_seg == bss_section || resultP->X_seg == undefined_section || resultP->X_seg == diff_section || resultP->X_seg == absolute_section || resultP->X_seg == pass1_section || resultP->X_seg == reg_section);
-
-	      know (right.X_seg == data_section || right.X_seg == text_section || right.X_seg == bss_section || right.X_seg == undefined_section || right.X_seg == diff_section || right.X_seg == absolute_section || right.X_seg == pass1_section);
-#endif
-#endif /* 0 */
-	      clean_up_expression (&right);
-	      clean_up_expression (resultP);
-
-	      seg1 = expr_part (&resultP->X_add_symbol, right.X_add_symbol);
-	      seg2 = expr_part (&resultP->X_subtract_symbol, right.X_subtract_symbol);
-	      if (seg1 == pass1_section || seg2 == pass1_section)
-		{
-		  need_pass_2 = 1;
-		  resultP->X_seg = pass1_section;
-		}
-	      else if (seg2 == absolute_section)
-		resultP->X_seg = seg1;
-	      else if (seg1 != undefined_section
-		       && seg1 != absolute_section
-		       && seg2 != undefined_section
-		       && seg1 != seg2)
-		{
-		  know (seg2 != absolute_section);
-		  know (resultP->X_subtract_symbol);
-#ifndef MANY_SEGMENTS
-#ifndef OBJ_ECOFF
-		  know (seg1 == text_section || seg1 == data_section || seg1 == bss_section);
-		  know (seg2 == text_section || seg2 == data_section || seg2 == bss_section);
-#endif
-#endif
-		  know (resultP->X_add_symbol);
-		  know (resultP->X_subtract_symbol);
-		  as_bad ("Expression too complex: forgetting %s - %s",
-			  S_GET_NAME (resultP->X_add_symbol),
-			  S_GET_NAME (resultP->X_subtract_symbol));
-		  resultP->X_seg = absolute_section;
-		  /* Clean_up_expression() will do the rest. */
-		}
-	      else
-		resultP->X_seg = diff_section;
-
-	      resultP->X_add_number += right.X_add_number;
-	      clean_up_expression (resultP);
-	    }
-	  else
-	    {			/* Not +. */
-	      if (resultP->X_seg == undefined_section || right.X_seg == undefined_section)
-		{
-		  resultP->X_seg = pass1_section;
-		  need_pass_2 = 1;
-		}
-	      else
-		{
-		  resultP->X_subtract_symbol = NULL;
-		  resultP->X_add_symbol = NULL;
-		  /* Will be absolute_section. */
-		  if (resultP->X_seg != absolute_section || right.X_seg != absolute_section)
-		    {
-		      as_bad ("Relocation error: Symbolic expressions may only involve");
-		      as_bad ("  addition and subtraction. Absolute 0 assumed.");
-		      resultP->X_seg = absolute_section;
-		      resultP->X_add_number = 0;
-		    }
-		  else
-		    {
-		      switch (op_left)
-			{
-			case O_bit_inclusive_or:
-			  resultP->X_add_number |= right.X_add_number;
-			  break;
-
-			case O_modulus:
-			  if (right.X_add_number)
-			    {
-			      resultP->X_add_number %= right.X_add_number;
-			    }
-			  else
-			    {
-			      as_warn ("Division by 0.  Result of 0 substituted.");
-			      resultP->X_add_number = 0;
-			    }
-			  break;
-
-			case O_bit_and:
-			  resultP->X_add_number &= right.X_add_number;
-			  break;
-
-			case O_multiply:
-			  resultP->X_add_number *= right.X_add_number;
-			  break;
-
-			case O_divide:
-			  if (right.X_add_number)
-			    {
-			      resultP->X_add_number /= right.X_add_number;
-			    }
-			  else
-			    {
-			      as_warn ("Division by 0. 0 assumed.");
-			      resultP->X_add_number = 0;
-			    }
-			  break;
-
-			case O_left_shift:
-			  resultP->X_add_number <<= right.X_add_number;
-			  break;
-
-			case O_right_shift:
-			  /* @@ We should distinguish signed versus
-			     unsigned here somehow.  */
-			  resultP->X_add_number >>= right.X_add_number;
-			  break;
-
-			case O_bit_exclusive_or:
-			  resultP->X_add_number ^= right.X_add_number;
-			  break;
-
-			case O_bit_or_not:
-			  resultP->X_add_number |= ~right.X_add_number;
-			  break;
-
-			default:
-			  BAD_CASE (op_left);
-			  break;
-			}	/* switch(operator) */
-		    }
-		}		/* If we have to force need_pass_2. */
-	    }			/* If operator was +. */
-	}			/* If we didn't set need_pass_2. */
+	    resultP->X_add_number += right.X_add_number;
+	  else if (op_left == O_subtract)
+	    resultP->X_add_number -= right.X_add_number;
+	}
+      else
+	{
+	  /* The general case.  */
+	  resultP->X_add_symbol = make_expr_symbol (resultP);
+	  resultP->X_op_symbol = make_expr_symbol (&right);
+	  resultP->X_op = op_left;
+	  resultP->X_add_number = 0;
+	}
+	  
       op_left = op_right;
     }				/* While next operator is >= this rank. */
-  return (resultP->X_seg);
+
+  return resultP->X_op == O_constant ? absolute_section : retval;
 }
 
 /*