ax-gdb: Use ax->gdbarch instead of exp->gdbarch, remove unused parameters

In many ax generation functions, the "expression *exp" parameter is only
used to access the gdbarch.  The same value can be found in the
"agent_expr *ax" parameter, which needs to be passed in any case.  By
using ax->gdbarch instead of exp->gdbarch, we can avoid passing exp in
many of these functions.

gdb/ChangeLog:

	* ax-gdb.c (gen_usual_unary): Remove exp parameter, get gdbarch
	from ax, update calls.
	(gen_usual_arithmetic): Likewise.
	(gen_integral_promotions): Likewise.
	(gen_bitfield_ref): Likewise.
	(gen_primitive_field): Likewise.
	(gen_struct_ref_recursive): Likewise.
	(gen_struct_ref): Likewise.
	(gen_maybe_namespace_elt): Likewise.
	(gen_struct_elt_for_reference): Likewise.
	(gen_namespace_elt): Likewise.
	(gen_aggregate_elt_ref): Likewise.
	(gen_expr): Get gdbarch from ax, update calls.
	(gen_expr_binop_rest): Likewise.

2 files changed, 90 insertions, 91 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 3210957528a..56217896d3b 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,20 @@
+2017-07-14  Simon Marchi  <simon.marchi@ericsson.com>
+
+	* ax-gdb.c (gen_usual_unary): Remove exp parameter, get gdbarch
+	from ax, update calls.
+	(gen_usual_arithmetic): Likewise.
+	(gen_integral_promotions): Likewise.
+	(gen_bitfield_ref): Likewise.
+	(gen_primitive_field): Likewise.
+	(gen_struct_ref_recursive): Likewise.
+	(gen_struct_ref): Likewise.
+	(gen_maybe_namespace_elt): Likewise.
+	(gen_struct_elt_for_reference): Likewise.
+	(gen_namespace_elt): Likewise.
+	(gen_aggregate_elt_ref): Likewise.
+	(gen_expr): Get gdbarch from ax, update calls.
+	(gen_expr_binop_rest): Likewise.
+
 2017-07-13  Pedro Alves  <palves@redhat.com>
 
 	* amd64-darwin-tdep.c (x86_darwin_init_abi_64): Pass tdesc_amd64
diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index fae2e2d4836..3ec87af07eb 100644
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -98,19 +98,16 @@ static void gen_int_literal (struct agent_expr *ax,
 			     struct axs_value *value,
 			     LONGEST k, struct type *type);
 
-static void gen_usual_unary (struct expression *exp, struct agent_expr *ax,
-			     struct axs_value *value);
+static void gen_usual_unary (struct agent_expr *ax, struct axs_value *value);
 static int type_wider_than (struct type *type1, struct type *type2);
 static struct type *max_type (struct type *type1, struct type *type2);
 static void gen_conversion (struct agent_expr *ax,
 			    struct type *from, struct type *to);
 static int is_nontrivial_conversion (struct type *from, struct type *to);
-static void gen_usual_arithmetic (struct expression *exp,
-				  struct agent_expr *ax,
+static void gen_usual_arithmetic (struct agent_expr *ax,
 				  struct axs_value *value1,
 				  struct axs_value *value2);
-static void gen_integral_promotions (struct expression *exp,
-				     struct agent_expr *ax,
+static void gen_integral_promotions (struct agent_expr *ax,
 				     struct axs_value *value);
 static void gen_cast (struct agent_expr *ax,
 		      struct axs_value *value, struct type *type);
@@ -135,19 +132,16 @@ static void gen_logical_not (struct agent_expr *ax, struct axs_value *value,
 static void gen_complement (struct agent_expr *ax, struct axs_value *value);
 static void gen_deref (struct agent_expr *, struct axs_value *);
 static void gen_address_of (struct agent_expr *, struct axs_value *);
-static void gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
-			      struct axs_value *value,
+static void gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
 			      struct type *type, int start, int end);
-static void gen_primitive_field (struct expression *exp,
-				 struct agent_expr *ax,
+static void gen_primitive_field (struct agent_expr *ax,
 				 struct axs_value *value,
 				 int offset, int fieldno, struct type *type);
-static int gen_struct_ref_recursive (struct expression *exp,
-				     struct agent_expr *ax,
+static int gen_struct_ref_recursive (struct agent_expr *ax,
 				     struct axs_value *value,
 				     const char *field, int offset,
 				     struct type *type);
-static void gen_struct_ref (struct expression *exp, struct agent_expr *ax,
+static void gen_struct_ref (struct agent_expr *ax,
 			    struct axs_value *value,
 			    const char *field,
 			    const char *operator_name,
@@ -818,8 +812,7 @@ require_rvalue (struct agent_expr *ax, struct axs_value *value)
    lvalue through unchanged, and let `+' raise an error.  */
 
 static void
-gen_usual_unary (struct expression *exp, struct agent_expr *ax,
-		 struct axs_value *value)
+gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
 {
   /* We don't have to generate any code for the usual integral
      conversions, since values are always represented as full-width on
@@ -934,8 +927,8 @@ is_nontrivial_conversion (struct type *from, struct type *to)
    and promotes each argument to that type.  *VALUE1 and *VALUE2
    describe the values as they are passed in, and as they are left.  */
 static void
-gen_usual_arithmetic (struct expression *exp, struct agent_expr *ax,
-		      struct axs_value *value1, struct axs_value *value2)
+gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1,
+		      struct axs_value *value2)
 {
   /* Do the usual binary conversions.  */
   if (TYPE_CODE (value1->type) == TYPE_CODE_INT
@@ -946,7 +939,7 @@ gen_usual_arithmetic (struct expression *exp, struct agent_expr *ax,
          unsigned type is considered "wider" than an n-bit signed
          type.  Promote to the "wider" of the two types, and always
          promote at least to int.  */
-      struct type *target = max_type (builtin_type (exp->gdbarch)->builtin_int,
+      struct type *target = max_type (builtin_type (ax->gdbarch)->builtin_int,
 				      max_type (value1->type, value2->type));
 
       /* Deal with value2, on the top of the stack.  */
@@ -971,10 +964,9 @@ gen_usual_arithmetic (struct expression *exp, struct agent_expr *ax,
    the value on the top of the stack, as described by VALUE.  Assume
    the value has integral type.  */
 static void
-gen_integral_promotions (struct expression *exp, struct agent_expr *ax,
-			 struct axs_value *value)
+gen_integral_promotions (struct agent_expr *ax, struct axs_value *value)
 {
-  const struct builtin_type *builtin = builtin_type (exp->gdbarch);
+  const struct builtin_type *builtin = builtin_type (ax->gdbarch);
 
   if (!type_wider_than (value->type, builtin->builtin_int))
     {
@@ -1249,9 +1241,8 @@ gen_address_of (struct agent_expr *ax, struct axs_value *value)
    starting and one-past-ending *bit* numbers of the field within the
    structure.  */
 static void
-gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
-		  struct axs_value *value, struct type *type,
-		  int start, int end)
+gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
+		  struct type *type, int start, int end)
 {
   /* Note that ops[i] fetches 8 << i bits.  */
   static enum agent_op ops[]
@@ -1376,7 +1367,7 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
 	     the sign/zero extension will wipe them out.
 	     - If we're in the interior of the word, then there is no garbage
 	     on either end, because the ref operators zero-extend.  */
-	  if (gdbarch_byte_order (exp->gdbarch) == BFD_ENDIAN_BIG)
+	  if (gdbarch_byte_order (ax->gdbarch) == BFD_ENDIAN_BIG)
 	    gen_left_shift (ax, end - (offset + op_size));
 	  else
 	    gen_left_shift (ax, offset - start);
@@ -1409,13 +1400,12 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
    generally follow value_primitive_field.  */
 
 static void
-gen_primitive_field (struct expression *exp,
-		     struct agent_expr *ax, struct axs_value *value,
+gen_primitive_field (struct agent_expr *ax, struct axs_value *value,
 		     int offset, int fieldno, struct type *type)
 {
   /* Is this a bitfield?  */
   if (TYPE_FIELD_PACKED (type, fieldno))
-    gen_bitfield_ref (exp, ax, value, TYPE_FIELD_TYPE (type, fieldno),
+    gen_bitfield_ref (ax, value, TYPE_FIELD_TYPE (type, fieldno),
 		      (offset * TARGET_CHAR_BIT
 		       + TYPE_FIELD_BITPOS (type, fieldno)),
 		      (offset * TARGET_CHAR_BIT
@@ -1434,8 +1424,7 @@ gen_primitive_field (struct expression *exp,
    base classes.  Return 1 if found, 0 if not.  */
 
 static int
-gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
-			  struct axs_value *value,
+gen_struct_ref_recursive (struct agent_expr *ax, struct axs_value *value,
 			  const char *field, int offset, struct type *type)
 {
   int i, rslt;
@@ -1457,7 +1446,7 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
 		 being handled as a global.  */
 	      if (field_is_static (&TYPE_FIELD (type, i)))
 		{
-		  gen_static_field (exp->gdbarch, ax, value, type, i);
+		  gen_static_field (ax->gdbarch, ax, value, type, i);
 		  if (value->optimized_out)
 		    error (_("static field `%s' has been "
 			     "optimized out, cannot use"),
@@ -1465,7 +1454,7 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
 		  return 1;
 		}
 
-	      gen_primitive_field (exp, ax, value, offset, i, type);
+	      gen_primitive_field (ax, value, offset, i, type);
 	      return 1;
 	    }
 #if 0 /* is this right? */
@@ -1481,7 +1470,7 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
     {
       struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
 
-      rslt = gen_struct_ref_recursive (exp, ax, value, field,
+      rslt = gen_struct_ref_recursive (ax, value, field,
 				       offset + TYPE_BASECLASS_BITPOS (type, i)
 				       / TARGET_CHAR_BIT,
 				       basetype);
@@ -1499,9 +1488,9 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax,
    the operator being compiled, and OPERAND_NAME is the kind of thing
    it operates on; we use them in error messages.  */
 static void
-gen_struct_ref (struct expression *exp, struct agent_expr *ax,
-		struct axs_value *value, const char *field,
-		const char *operator_name, const char *operand_name)
+gen_struct_ref (struct agent_expr *ax, struct axs_value *value,
+		const char *field, const char *operator_name,
+		const char *operand_name)
 {
   struct type *type;
   int found;
@@ -1528,7 +1517,7 @@ gen_struct_ref (struct expression *exp, struct agent_expr *ax,
     error (_("Structure does not live in memory."));
 
   /* Search through fields and base classes recursively.  */
-  found = gen_struct_ref_recursive (exp, ax, value, field, 0, type);
+  found = gen_struct_ref_recursive (ax, value, field, 0, type);
   
   if (!found)
     error (_("Couldn't find member named `%s' in struct/union/class `%s'"),
@@ -1536,12 +1525,10 @@ gen_struct_ref (struct expression *exp, struct agent_expr *ax,
 }
 
 static int
-gen_namespace_elt (struct expression *exp,
-		   struct agent_expr *ax, struct axs_value *value,
+gen_namespace_elt (struct agent_expr *ax, struct axs_value *value,
 		   const struct type *curtype, char *name);
 static int
-gen_maybe_namespace_elt (struct expression *exp,
-			 struct agent_expr *ax, struct axs_value *value,
+gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value,
 			 const struct type *curtype, char *name);
 
 static void
@@ -1579,8 +1566,7 @@ gen_static_field (struct gdbarch *gdbarch,
 }
 
 static int
-gen_struct_elt_for_reference (struct expression *exp,
-			      struct agent_expr *ax, struct axs_value *value,
+gen_struct_elt_for_reference (struct agent_expr *ax, struct axs_value *value,
 			      struct type *type, char *fieldname)
 {
   struct type *t = type;
@@ -1599,7 +1585,7 @@ gen_struct_elt_for_reference (struct expression *exp,
 	{
 	  if (field_is_static (&TYPE_FIELD (t, i)))
 	    {
-	      gen_static_field (exp->gdbarch, ax, value, t, i);
+	      gen_static_field (ax->gdbarch, ax, value, t, i);
 	      if (value->optimized_out)
 		error (_("static field `%s' has been "
 			 "optimized out, cannot use"),
@@ -1618,18 +1604,17 @@ gen_struct_elt_for_reference (struct expression *exp,
   /* FIXME add other scoped-reference cases here */
 
   /* Do a last-ditch lookup.  */
-  return gen_maybe_namespace_elt (exp, ax, value, type, fieldname);
+  return gen_maybe_namespace_elt (ax, value, type, fieldname);
 }
 
 /* C++: Return the member NAME of the namespace given by the type
    CURTYPE.  */
 
 static int
-gen_namespace_elt (struct expression *exp,
-		   struct agent_expr *ax, struct axs_value *value,
+gen_namespace_elt (struct agent_expr *ax, struct axs_value *value,
 		   const struct type *curtype, char *name)
 {
-  int found = gen_maybe_namespace_elt (exp, ax, value, curtype, name);
+  int found = gen_maybe_namespace_elt (ax, value, curtype, name);
 
   if (!found)
     error (_("No symbol \"%s\" in namespace \"%s\"."), 
@@ -1645,8 +1630,7 @@ gen_namespace_elt (struct expression *exp,
    to, say, some base class of CURTYPE).  */
 
 static int
-gen_maybe_namespace_elt (struct expression *exp,
-			 struct agent_expr *ax, struct axs_value *value,
+gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value,
 			 const struct type *curtype, char *name)
 {
   const char *namespace_name = TYPE_TAG_NAME (curtype);
@@ -1659,7 +1643,7 @@ gen_maybe_namespace_elt (struct expression *exp,
   if (sym.symbol == NULL)
     return 0;
 
-  gen_var_ref (exp->gdbarch, ax, value, sym.symbol);
+  gen_var_ref (ax->gdbarch, ax, value, sym.symbol);
 
   if (value->optimized_out)
     error (_("`%s' has been optimized out, cannot use"),
@@ -1670,8 +1654,7 @@ gen_maybe_namespace_elt (struct expression *exp,
 
 
 static int
-gen_aggregate_elt_ref (struct expression *exp,
-		       struct agent_expr *ax, struct axs_value *value,
+gen_aggregate_elt_ref (struct agent_expr *ax, struct axs_value *value,
 		       struct type *type, char *field,
 		       const char *operator_name,
 		       const char *operand_name)
@@ -1680,10 +1663,10 @@ gen_aggregate_elt_ref (struct expression *exp,
     {
     case TYPE_CODE_STRUCT:
     case TYPE_CODE_UNION:
-      return gen_struct_elt_for_reference (exp, ax, value, type, field);
+      return gen_struct_elt_for_reference (ax, value, type, field);
       break;
     case TYPE_CODE_NAMESPACE:
-      return gen_namespace_elt (exp, ax, value, type, field);
+      return gen_namespace_elt (ax, value, type, field);
       break;
     default:
       internal_error (__FILE__, __LINE__,
@@ -1784,7 +1767,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
   struct axs_value value1, value2, value3;
   enum exp_opcode op = (*pc)[0].opcode, op2;
   int if1, go1, if2, go2, end;
-  struct type *int_type = builtin_type (exp->gdbarch)->builtin_int;
+  struct type *int_type = builtin_type (ax->gdbarch)->builtin_int;
 
   /* If we're looking at a constant expression, just push its value.  */
   {
@@ -1822,7 +1805,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
     case BINOP_GEQ:
       (*pc)++;
       gen_expr (exp, pc, ax, &value1);
-      gen_usual_unary (exp, ax, &value1);
+      gen_usual_unary (ax, &value1);
       gen_expr_binop_rest (exp, op, pc, ax, value, &value1, &value2);
       break;
 
@@ -1830,12 +1813,12 @@ gen_expr (struct expression *exp, union exp_element **pc,
       (*pc)++;
       /* Generate the obvious sequence of tests and jumps.  */
       gen_expr (exp, pc, ax, &value1);
-      gen_usual_unary (exp, ax, &value1);
+      gen_usual_unary (ax, &value1);
       if1 = ax_goto (ax, aop_if_goto);
       go1 = ax_goto (ax, aop_goto);
       ax_label (ax, if1, ax->len);
       gen_expr (exp, pc, ax, &value2);
-      gen_usual_unary (exp, ax, &value2);
+      gen_usual_unary (ax, &value2);
       if2 = ax_goto (ax, aop_if_goto);
       go2 = ax_goto (ax, aop_goto);
       ax_label (ax, if2, ax->len);
@@ -1853,10 +1836,10 @@ gen_expr (struct expression *exp, union exp_element **pc,
       (*pc)++;
       /* Generate the obvious sequence of tests and jumps.  */
       gen_expr (exp, pc, ax, &value1);
-      gen_usual_unary (exp, ax, &value1);
+      gen_usual_unary (ax, &value1);
       if1 = ax_goto (ax, aop_if_goto);
       gen_expr (exp, pc, ax, &value2);
-      gen_usual_unary (exp, ax, &value2);
+      gen_usual_unary (ax, &value2);
       if2 = ax_goto (ax, aop_if_goto);
       ax_const_l (ax, 0);
       end = ax_goto (ax, aop_goto);
@@ -1871,7 +1854,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
     case TERNOP_COND:
       (*pc)++;
       gen_expr (exp, pc, ax, &value1);
-      gen_usual_unary (exp, ax, &value1);
+      gen_usual_unary (ax, &value1);
       /* For (A ? B : C), it's easiest to generate subexpression
 	 bytecodes in order, but if_goto jumps on true, so we invert
 	 the sense of A.  Then we can do B by dropping through, and
@@ -1879,11 +1862,11 @@ gen_expr (struct expression *exp, union exp_element **pc,
       gen_logical_not (ax, &value1, int_type);
       if1 = ax_goto (ax, aop_if_goto);
       gen_expr (exp, pc, ax, &value2);
-      gen_usual_unary (exp, ax, &value2);
+      gen_usual_unary (ax, &value2);
       end = ax_goto (ax, aop_goto);
       ax_label (ax, if1, ax->len);
       gen_expr (exp, pc, ax, &value3);
-      gen_usual_unary (exp, ax, &value3);
+      gen_usual_unary (ax, &value3);
       ax_label (ax, end, ax->len);
       /* This is arbitary - what if B and C are incompatible types? */
       value->type = value2.type;
@@ -1934,7 +1917,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
 		ax_tsv (ax, aop_tracev, tsv->number);
 	      /* Trace state variables are always 64-bit integers.  */
 	      value1.kind = axs_rvalue;
-	      value1.type = builtin_type (exp->gdbarch)->builtin_long_long;
+	      value1.type = builtin_type (ax->gdbarch)->builtin_long_long;
 	      /* Now do right half of expression.  */
 	      gen_expr_binop_rest (exp, op2, pc, ax, value, &value1, &value2);
 	      /* We have a result of the binary op, set the tsv.  */
@@ -1962,7 +1945,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
       /* Don't just dispose of the left operand.  We might be tracing,
          in which case we want to emit code to trace it if it's an
          lvalue.  */
-      gen_traced_pop (exp->gdbarch, ax, &value1);
+      gen_traced_pop (ax->gdbarch, ax, &value1);
       gen_expr (exp, pc, ax, value);
       /* It's the consumer's responsibility to trace the right operand.  */
       break;
@@ -1978,7 +1961,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
       break;
 
     case OP_VAR_VALUE:
-      gen_var_ref (exp->gdbarch, ax, value, (*pc)[2].symbol);
+      gen_var_ref (ax->gdbarch, ax, value, (*pc)[2].symbol);
 
       if (value->optimized_out)
 	error (_("`%s' has been optimized out, cannot use"),
@@ -1993,19 +1976,19 @@ gen_expr (struct expression *exp, union exp_element **pc,
 	int reg;
 
 	(*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
-	reg = user_reg_map_name_to_regnum (exp->gdbarch, name, strlen (name));
+	reg = user_reg_map_name_to_regnum (ax->gdbarch, name, strlen (name));
 	if (reg == -1)
 	  internal_error (__FILE__, __LINE__,
 			  _("Register $%s not available"), name);
 	/* No support for tracing user registers yet.  */
-	if (reg >= gdbarch_num_regs (exp->gdbarch)
-	    + gdbarch_num_pseudo_regs (exp->gdbarch))
+	if (reg >= gdbarch_num_regs (ax->gdbarch)
+	    + gdbarch_num_pseudo_regs (ax->gdbarch))
 	  error (_("'%s' is a user-register; "
 		   "GDB cannot yet trace user-register contents."),
 		 name);
 	value->kind = axs_lvalue_register;
 	value->u.reg = reg;
-	value->type = register_type (exp->gdbarch, reg);
+	value->type = register_type (ax->gdbarch, reg);
       }
       break;
 
@@ -2024,7 +2007,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
 	      ax_tsv (ax, aop_tracev, tsv->number);
 	    /* Trace state variables are always 64-bit integers.  */
 	    value->kind = axs_rvalue;
-	    value->type = builtin_type (exp->gdbarch)->builtin_long_long;
+	    value->type = builtin_type (ax->gdbarch)->builtin_long_long;
 	  }
 	else if (! compile_internalvar_to_ax (var, ax, value))
 	  error (_("$%s is not a trace state variable; GDB agent "
@@ -2113,40 +2096,40 @@ gen_expr (struct expression *exp, union exp_element **pc,
       (*pc)++;
       /* + FOO is equivalent to 0 + FOO, which can be optimized.  */
       gen_expr (exp, pc, ax, value);
-      gen_usual_unary (exp, ax, value);
+      gen_usual_unary (ax, value);
       break;
       
     case UNOP_NEG:
       (*pc)++;
       /* -FOO is equivalent to 0 - FOO.  */
       gen_int_literal (ax, &value1, 0,
-		       builtin_type (exp->gdbarch)->builtin_int);
-      gen_usual_unary (exp, ax, &value1);	/* shouldn't do much */
+		       builtin_type (ax->gdbarch)->builtin_int);
+      gen_usual_unary (ax, &value1);	/* shouldn't do much */
       gen_expr (exp, pc, ax, &value2);
-      gen_usual_unary (exp, ax, &value2);
-      gen_usual_arithmetic (exp, ax, &value1, &value2);
+      gen_usual_unary (ax, &value2);
+      gen_usual_arithmetic (ax, &value1, &value2);
       gen_binop (ax, value, &value1, &value2, aop_sub, aop_sub, 1, "negation");
       break;
 
     case UNOP_LOGICAL_NOT:
       (*pc)++;
       gen_expr (exp, pc, ax, value);
-      gen_usual_unary (exp, ax, value);
+      gen_usual_unary (ax, value);
       gen_logical_not (ax, value, int_type);
       break;
 
     case UNOP_COMPLEMENT:
       (*pc)++;
       gen_expr (exp, pc, ax, value);
-      gen_usual_unary (exp, ax, value);
-      gen_integral_promotions (exp, ax, value);
+      gen_usual_unary (ax, value);
+      gen_integral_promotions (ax, value);
       gen_complement (ax, value);
       break;
 
     case UNOP_IND:
       (*pc)++;
       gen_expr (exp, pc, ax, value);
-      gen_usual_unary (exp, ax, value);
+      gen_usual_unary (ax, value);
       if (!pointer_type (value->type))
 	error (_("Argument of unary `*' is not a pointer."));
       gen_deref (ax, value);
@@ -2164,7 +2147,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
          of the other unary operator functions.  This is because we
          have to throw away the code we generate.  */
       gen_sizeof (exp, pc, ax, value,
-		  builtin_type (exp->gdbarch)->builtin_int);
+		  builtin_type (ax->gdbarch)->builtin_int);
       break;
 
     case STRUCTOP_STRUCT:
@@ -2176,9 +2159,9 @@ gen_expr (struct expression *exp, union exp_element **pc,
 	(*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1);
 	gen_expr (exp, pc, ax, value);
 	if (op == STRUCTOP_STRUCT)
-	  gen_struct_ref (exp, ax, value, name, ".", "structure or union");
+	  gen_struct_ref (ax, value, name, ".", "structure or union");
 	else if (op == STRUCTOP_PTR)
-	  gen_struct_ref (exp, ax, value, name, "->",
+	  gen_struct_ref (ax, value, name, "->",
 			  "pointer to a structure or union");
 	else
 	  /* If this `if' chain doesn't handle it, then the case list
@@ -2202,7 +2185,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
 	if (!sym)
 	  error (_("no `%s' found"), lang->la_name_of_this);
 
-	gen_var_ref (exp->gdbarch, ax, value, sym);
+	gen_var_ref (ax->gdbarch, ax, value, sym);
 
 	if (value->optimized_out)
 	  error (_("`%s' has been optimized out, cannot use"),
@@ -2219,8 +2202,7 @@ gen_expr (struct expression *exp, union exp_element **pc,
 	char *name = &(*pc)[3].string;
 	int found;
 
-	found = gen_aggregate_elt_ref (exp, ax, value, type, name,
-				       "?", "??");
+	found = gen_aggregate_elt_ref (ax, value, type, name, "?", "??");
 	if (!found)
 	  error (_("There is no field named %s"), name);
 	(*pc) += 5 + BYTES_TO_EXP_ELEM (length + 1);
@@ -2248,11 +2230,11 @@ gen_expr_binop_rest (struct expression *exp,
 		     struct agent_expr *ax, struct axs_value *value,
 		     struct axs_value *value1, struct axs_value *value2)
 {
-  struct type *int_type = builtin_type (exp->gdbarch)->builtin_int;
+  struct type *int_type = builtin_type (ax->gdbarch)->builtin_int;
 
   gen_expr (exp, pc, ax, value2);
-  gen_usual_unary (exp, ax, value2);
-  gen_usual_arithmetic (exp, ax, value1, value2);
+  gen_usual_unary (ax, value2);
+  gen_usual_arithmetic (ax, value1, value2);
   switch (op)
     {
     case BINOP_ADD:
@@ -2278,7 +2260,7 @@ gen_expr_binop_rest (struct expression *exp,
 	       && pointer_type (value2->type))
 	/* FIXME --- result type should be ptrdiff_t */
 	gen_ptrdiff (ax, value, value1, value2,
-		     builtin_type (exp->gdbarch)->builtin_long);
+		     builtin_type (ax->gdbarch)->builtin_long);
       else
 	gen_binop (ax, value, value1, value2,
 		   aop_sub, aop_sub, 1, "subtraction");