* elf-m10300.c (mn10300_elf_relax_section): Allow for the
[deliverable/binutils-gdb.git] / gdb / ax-gdb.c
index 2a4201ab154bcd95b55999f98d51fdf282710b14..5e04b07f5208fcaddb92246e6f025cdd40da57f3 100644 (file)
@@ -1,6 +1,6 @@
 /* GDB-specific functions for operating on agent expressions.
 
-   Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007
+   Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007, 2008, 2009
    Free Software Foundation, Inc.
 
    This file is part of GDB.
@@ -33,6 +33,8 @@
 #include "gdb_string.h"
 #include "block.h"
 #include "regcache.h"
+#include "user-regs.h"
+#include "language.h"
 
 /* To make sense of this file, you should read doc/agentexpr.texi.
    Then look at the types and enums in ax-gdb.h.  For the code itself,
@@ -71,11 +73,11 @@ static void gen_fetch (struct agent_expr *, struct type *);
 static void gen_left_shift (struct agent_expr *, int);
 
 
-static void gen_frame_args_address (struct agent_expr *);
-static void gen_frame_locals_address (struct agent_expr *);
+static void gen_frame_args_address (struct gdbarch *, struct agent_expr *);
+static void gen_frame_locals_address (struct gdbarch *, struct agent_expr *);
 static void gen_offset (struct agent_expr *ax, int offset);
 static void gen_sym_offset (struct agent_expr *, struct symbol *);
-static void gen_var_ref (struct agent_expr *ax,
+static void gen_var_ref (struct gdbarch *, struct agent_expr *ax,
                         struct axs_value *value, struct symbol *var);
 
 
@@ -85,51 +87,56 @@ static void gen_int_literal (struct agent_expr *ax,
 
 
 static void require_rvalue (struct agent_expr *ax, struct axs_value *value);
-static void gen_usual_unary (struct agent_expr *ax, struct axs_value *value);
+static void gen_usual_unary (struct expression *exp, 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 agent_expr *ax,
+static void gen_usual_arithmetic (struct expression *exp,
+                                 struct agent_expr *ax,
                                  struct axs_value *value1,
                                  struct axs_value *value2);
-static void gen_integral_promotions (struct agent_expr *ax,
+static void gen_integral_promotions (struct expression *exp,
+                                    struct agent_expr *ax,
                                     struct axs_value *value);
 static void gen_cast (struct agent_expr *ax,
                      struct axs_value *value, struct type *type);
 static void gen_scale (struct agent_expr *ax,
                       enum agent_op op, struct type *type);
-static void gen_add (struct agent_expr *ax,
-                    struct axs_value *value,
-                    struct axs_value *value1,
-                    struct axs_value *value2, char *name);
-static void gen_sub (struct agent_expr *ax,
-                    struct axs_value *value,
-                    struct axs_value *value1, struct axs_value *value2);
+static void gen_ptradd (struct agent_expr *ax, struct axs_value *value,
+                       struct axs_value *value1, struct axs_value *value2);
+static void gen_ptrsub (struct agent_expr *ax, struct axs_value *value,
+                       struct axs_value *value1, struct axs_value *value2);
+static void gen_ptrdiff (struct agent_expr *ax, struct axs_value *value,
+                        struct axs_value *value1, struct axs_value *value2,
+                        struct type *result_type);
 static void gen_binop (struct agent_expr *ax,
                       struct axs_value *value,
                       struct axs_value *value1,
                       struct axs_value *value2,
                       enum agent_op op,
                       enum agent_op op_unsigned, int may_carry, char *name);
-static void gen_logical_not (struct agent_expr *ax, struct axs_value *value);
+static void gen_logical_not (struct agent_expr *ax, struct axs_value *value,
+                            struct type *result_type);
 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 int find_field (struct type *type, char *name);
-static void gen_bitfield_ref (struct agent_expr *ax,
+static void gen_bitfield_ref (struct expression *exp, struct agent_expr *ax,
                              struct axs_value *value,
                              struct type *type, int start, int end);
-static void gen_struct_ref (struct agent_expr *ax,
+static void gen_struct_ref (struct expression *exp, struct agent_expr *ax,
                            struct axs_value *value,
                            char *field,
                            char *operator_name, char *operand_name);
-static void gen_repeat (union exp_element **pc,
+static void gen_repeat (struct expression *exp, union exp_element **pc,
                        struct agent_expr *ax, struct axs_value *value);
-static void gen_sizeof (union exp_element **pc,
-                       struct agent_expr *ax, struct axs_value *value);
-static void gen_expr (union exp_element **pc,
+static void gen_sizeof (struct expression *exp, union exp_element **pc,
+                       struct agent_expr *ax, struct axs_value *value,
+                       struct type *size_type);
+static void gen_expr (struct expression *exp, union exp_element **pc,
                      struct agent_expr *ax, struct axs_value *value);
 
 static void agent_command (char *exp, int from_tty);
@@ -454,12 +461,12 @@ gen_left_shift (struct agent_expr *ax, int distance)
 /* Generate code to push the base address of the argument portion of
    the top stack frame.  */
 static void
-gen_frame_args_address (struct agent_expr *ax)
+gen_frame_args_address (struct gdbarch *gdbarch, struct agent_expr *ax)
 {
   int frame_reg;
   LONGEST frame_offset;
 
-  gdbarch_virtual_frame_pointer (current_gdbarch,
+  gdbarch_virtual_frame_pointer (gdbarch,
                                 ax->scope, &frame_reg, &frame_offset);
   ax_reg (ax, frame_reg);
   gen_offset (ax, frame_offset);
@@ -469,12 +476,12 @@ gen_frame_args_address (struct agent_expr *ax)
 /* Generate code to push the base address of the locals portion of the
    top stack frame.  */
 static void
-gen_frame_locals_address (struct agent_expr *ax)
+gen_frame_locals_address (struct gdbarch *gdbarch, struct agent_expr *ax)
 {
   int frame_reg;
   LONGEST frame_offset;
 
-  gdbarch_virtual_frame_pointer (current_gdbarch,
+  gdbarch_virtual_frame_pointer (gdbarch,
                                 ax->scope, &frame_reg, &frame_offset);
   ax_reg (ax, frame_reg);
   gen_offset (ax, frame_offset);
@@ -519,7 +526,8 @@ gen_sym_offset (struct agent_expr *ax, struct symbol *var)
    symbol VAR.  Set VALUE to describe the result.  */
 
 static void
-gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
+gen_var_ref (struct gdbarch *gdbarch, struct agent_expr *ax,
+            struct axs_value *value, struct symbol *var)
 {
   /* Dereference any typedefs. */
   value->type = check_typedef (SYMBOL_TYPE (var));
@@ -549,30 +557,22 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
       break;
 
     case LOC_ARG:              /* var lives in argument area of frame */
-      gen_frame_args_address (ax);
+      gen_frame_args_address (gdbarch, ax);
       gen_sym_offset (ax, var);
       value->kind = axs_lvalue_memory;
       break;
 
     case LOC_REF_ARG:          /* As above, but the frame slot really
                                   holds the address of the variable.  */
-      gen_frame_args_address (ax);
+      gen_frame_args_address (gdbarch, ax);
       gen_sym_offset (ax, var);
       /* Don't assume any particular pointer size.  */
-      gen_fetch (ax, lookup_pointer_type (builtin_type_void));
+      gen_fetch (ax, builtin_type (gdbarch)->builtin_data_ptr);
       value->kind = axs_lvalue_memory;
       break;
 
     case LOC_LOCAL:            /* var lives in locals area of frame */
-    case LOC_LOCAL_ARG:
-      gen_frame_locals_address (ax);
-      gen_sym_offset (ax, var);
-      value->kind = axs_lvalue_memory;
-      break;
-
-    case LOC_BASEREG:          /* relative to some base register */
-    case LOC_BASEREG_ARG:
-      ax_reg (ax, SYMBOL_BASEREG (var));
+      gen_frame_locals_address (gdbarch, ax);
       gen_sym_offset (ax, var);
       value->kind = axs_lvalue_memory;
       break;
@@ -588,27 +588,26 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
       break;
 
     case LOC_REGISTER:
-    case LOC_REGPARM:
       /* Don't generate any code at all; in the process of treating
          this as an lvalue or rvalue, the caller will generate the
          right code.  */
       value->kind = axs_lvalue_register;
-      value->u.reg = SYMBOL_VALUE (var);
+      value->u.reg = SYMBOL_REGISTER_OPS (var)->register_number (var, gdbarch);
       break;
 
       /* A lot like LOC_REF_ARG, but the pointer lives directly in a
-         register, not on the stack.  Simpler than LOC_REGISTER and
-         LOC_REGPARM, because it's just like any other case where the
-         thing has a real address.  */
+         register, not on the stack.  Simpler than LOC_REGISTER
+         because it's just like any other case where the thing
+        has a real address.  */
     case LOC_REGPARM_ADDR:
-      ax_reg (ax, SYMBOL_VALUE (var));
+      ax_reg (ax, SYMBOL_REGISTER_OPS (var)->register_number (var, gdbarch));
       value->kind = axs_lvalue_memory;
       break;
 
     case LOC_UNRESOLVED:
       {
        struct minimal_symbol *msym
-       = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
+         = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
        if (!msym)
          error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));
 
@@ -619,13 +618,12 @@ gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)
       break;
 
     case LOC_COMPUTED:
-    case LOC_COMPUTED_ARG:
       /* FIXME: cagney/2004-01-26: It should be possible to
-        unconditionally call the SYMBOL_OPS method when available.
+        unconditionally call the SYMBOL_COMPUTED_OPS method when available.
         Unfortunately DWARF 2 stores the frame-base (instead of the
         function) location in a function's symbol.  Oops!  For the
         moment enable this when/where applicable.  */
-      SYMBOL_OPS (var)->tracepoint_var_ref (var, ax, value);
+      SYMBOL_COMPUTED_OPS (var)->tracepoint_var_ref (var, gdbarch, ax, value);
       break;
 
     case LOC_OPTIMIZED_OUT:
@@ -706,7 +704,8 @@ require_rvalue (struct agent_expr *ax, struct axs_value *value)
    lvalue through unchanged, and let `+' raise an error.  */
 
 static void
-gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
+gen_usual_unary (struct expression *exp, 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
@@ -741,7 +740,7 @@ gen_usual_unary (struct agent_expr *ax, struct axs_value *value)
 
       /* If the value is an enum, call it an integer.  */
     case TYPE_CODE_ENUM:
-      value->type = builtin_type_int;
+      value->type = builtin_type (exp->gdbarch)->builtin_int;
       break;
     }
 
@@ -826,8 +825,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 agent_expr *ax, struct axs_value *value1,
-                     struct axs_value *value2)
+gen_usual_arithmetic (struct expression *exp, 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
@@ -838,7 +837,7 @@ gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1,
          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_int,
+      struct type *target = max_type (builtin_type (exp->gdbarch)->builtin_int,
                                      max_type (value1->type, value2->type));
 
       /* Deal with value2, on the top of the stack.  */
@@ -863,17 +862,20 @@ gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1,
    the value on the top of the stack, as described by VALUE.  Assume
    the value has integral type.  */
 static void
-gen_integral_promotions (struct agent_expr *ax, struct axs_value *value)
+gen_integral_promotions (struct expression *exp, struct agent_expr *ax,
+                        struct axs_value *value)
 {
-  if (!type_wider_than (value->type, builtin_type_int))
+  const struct builtin_type *builtin = builtin_type (exp->gdbarch);
+
+  if (!type_wider_than (value->type, builtin->builtin_int))
     {
-      gen_conversion (ax, value->type, builtin_type_int);
-      value->type = builtin_type_int;
+      gen_conversion (ax, value->type, builtin->builtin_int);
+      value->type = builtin->builtin_int;
     }
-  else if (!type_wider_than (value->type, builtin_type_unsigned_int))
+  else if (!type_wider_than (value->type, builtin->builtin_unsigned_int))
     {
-      gen_conversion (ax, value->type, builtin_type_unsigned_int);
-      value->type = builtin_type_unsigned_int;
+      gen_conversion (ax, value->type, builtin->builtin_unsigned_int);
+      value->type = builtin->builtin_unsigned_int;
     }
 }
 
@@ -946,105 +948,60 @@ gen_scale (struct agent_expr *ax, enum agent_op op, struct type *type)
 }
 
 
-/* Generate code for an addition; non-trivial because we deal with
-   pointer arithmetic.  We set VALUE to describe the result value; we
-   assume VALUE1 and VALUE2 describe the two operands, and that
-   they've undergone the usual binary conversions.  Used by both
-   BINOP_ADD and BINOP_SUBSCRIPT.  NAME is used in error messages.  */
+/* Generate code for pointer arithmetic PTR + INT.  */
 static void
-gen_add (struct agent_expr *ax, struct axs_value *value,
-        struct axs_value *value1, struct axs_value *value2, char *name)
+gen_ptradd (struct agent_expr *ax, struct axs_value *value,
+           struct axs_value *value1, struct axs_value *value2)
 {
-  /* Is it INT+PTR?  */
-  if (TYPE_CODE (value1->type) == TYPE_CODE_INT
-      && TYPE_CODE (value2->type) == TYPE_CODE_PTR)
-    {
-      /* Swap the values and proceed normally.  */
-      ax_simple (ax, aop_swap);
-      gen_scale (ax, aop_mul, value2->type);
-      ax_simple (ax, aop_add);
-      gen_extend (ax, value2->type);   /* Catch overflow.  */
-      value->type = value2->type;
-    }
+  gdb_assert (TYPE_CODE (value1->type) == TYPE_CODE_PTR);
+  gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
 
-  /* Is it PTR+INT?  */
-  else if (TYPE_CODE (value1->type) == TYPE_CODE_PTR
-          && TYPE_CODE (value2->type) == TYPE_CODE_INT)
-    {
-      gen_scale (ax, aop_mul, value1->type);
-      ax_simple (ax, aop_add);
-      gen_extend (ax, value1->type);   /* Catch overflow.  */
-      value->type = value1->type;
-    }
+  gen_scale (ax, aop_mul, value1->type);
+  ax_simple (ax, aop_add);
+  gen_extend (ax, value1->type);       /* Catch overflow.  */
+  value->type = value1->type;
+  value->kind = axs_rvalue;
+}
 
-  /* Must be number + number; the usual binary conversions will have
-     brought them both to the same width.  */
-  else if (TYPE_CODE (value1->type) == TYPE_CODE_INT
-          && TYPE_CODE (value2->type) == TYPE_CODE_INT)
-    {
-      ax_simple (ax, aop_add);
-      gen_extend (ax, value1->type);   /* Catch overflow.  */
-      value->type = value1->type;
-    }
 
-  else
-    error (_("Invalid combination of types in %s."), name);
+/* Generate code for pointer arithmetic PTR - INT.  */
+static void
+gen_ptrsub (struct agent_expr *ax, struct axs_value *value,
+           struct axs_value *value1, struct axs_value *value2)
+{
+  gdb_assert (TYPE_CODE (value1->type) == TYPE_CODE_PTR);
+  gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
 
+  gen_scale (ax, aop_mul, value1->type);
+  ax_simple (ax, aop_sub);
+  gen_extend (ax, value1->type);       /* Catch overflow.  */
+  value->type = value1->type;
   value->kind = axs_rvalue;
 }
 
 
-/* Generate code for an addition; non-trivial because we have to deal
-   with pointer arithmetic.  We set VALUE to describe the result
-   value; we assume VALUE1 and VALUE2 describe the two operands, and
-   that they've undergone the usual binary conversions.  */
+/* Generate code for pointer arithmetic PTR - PTR.  */
 static void
-gen_sub (struct agent_expr *ax, struct axs_value *value,
-        struct axs_value *value1, struct axs_value *value2)
+gen_ptrdiff (struct agent_expr *ax, struct axs_value *value,
+            struct axs_value *value1, struct axs_value *value2,
+            struct type *result_type)
 {
-  if (TYPE_CODE (value1->type) == TYPE_CODE_PTR)
-    {
-      /* Is it PTR - INT?  */
-      if (TYPE_CODE (value2->type) == TYPE_CODE_INT)
-       {
-         gen_scale (ax, aop_mul, value1->type);
-         ax_simple (ax, aop_sub);
-         gen_extend (ax, value1->type);        /* Catch overflow.  */
-         value->type = value1->type;
-       }
+  gdb_assert (TYPE_CODE (value1->type) == TYPE_CODE_PTR);
+  gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_PTR);
 
-      /* Is it PTR - PTR?  Strictly speaking, the types ought to
-         match, but this is what the normal GDB expression evaluator
-         tests for.  */
-      else if (TYPE_CODE (value2->type) == TYPE_CODE_PTR
-              && (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
-                  == TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type))))
-       {
-         ax_simple (ax, aop_sub);
-         gen_scale (ax, aop_div_unsigned, value1->type);
-         value->type = builtin_type_long;      /* FIXME --- should be ptrdiff_t */
-       }
-      else
-       error (_("\
+  if (TYPE_LENGTH (TYPE_TARGET_TYPE (value1->type))
+      != TYPE_LENGTH (TYPE_TARGET_TYPE (value2->type)))
+    error (_("\
 First argument of `-' is a pointer, but second argument is neither\n\
 an integer nor a pointer of the same type."));
-    }
-
-  /* Must be number + number.  */
-  else if (TYPE_CODE (value1->type) == TYPE_CODE_INT
-          && TYPE_CODE (value2->type) == TYPE_CODE_INT)
-    {
-      ax_simple (ax, aop_sub);
-      gen_extend (ax, value1->type);   /* Catch overflow.  */
-      value->type = value1->type;
-    }
-
-  else
-    error (_("Invalid combination of types in subtraction."));
 
+  ax_simple (ax, aop_sub);
+  gen_scale (ax, aop_div_unsigned, value1->type);
+  value->type = result_type;
   value->kind = axs_rvalue;
 }
 
+
 /* Generate code for a binary operator that doesn't do pointer magic.
    We set VALUE to describe the result value; we assume VALUE1 and
    VALUE2 describe the two operands, and that they've undergone the
@@ -1071,15 +1028,15 @@ gen_binop (struct agent_expr *ax, struct axs_value *value,
 
 
 static void
-gen_logical_not (struct agent_expr *ax, struct axs_value *value)
+gen_logical_not (struct agent_expr *ax, struct axs_value *value,
+                struct type *result_type)
 {
   if (TYPE_CODE (value->type) != TYPE_CODE_INT
       && TYPE_CODE (value->type) != TYPE_CODE_PTR)
     error (_("Invalid type of operand to `!'."));
 
-  gen_usual_unary (ax, value);
   ax_simple (ax, aop_log_not);
-  value->type = builtin_type_int;
+  value->type = result_type;
 }
 
 
@@ -1089,8 +1046,6 @@ gen_complement (struct agent_expr *ax, struct axs_value *value)
   if (TYPE_CODE (value->type) != TYPE_CODE_INT)
     error (_("Invalid type of operand to `~'."));
 
-  gen_usual_unary (ax, value);
-  gen_integral_promotions (ax, value);
   ax_simple (ax, aop_bit_not);
   gen_extend (ax, value->type);
 }
@@ -1192,8 +1147,9 @@ find_field (struct type *type, char *name)
    starting and one-past-ending *bit* numbers of the field within the
    structure.  */
 static void
-gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
-                 struct type *type, int start, int end)
+gen_bitfield_ref (struct expression *exp, 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[]
@@ -1319,7 +1275,7 @@ gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
             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 (current_gdbarch) == BFD_ENDIAN_BIG)
+         if (gdbarch_byte_order (exp->gdbarch) == BFD_ENDIAN_BIG)
            gen_left_shift (ax, end - (offset + op_size));
          else
            gen_left_shift (ax, offset - start);
@@ -1353,7 +1309,8 @@ gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value,
    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 agent_expr *ax, struct axs_value *value, char *field,
+gen_struct_ref (struct expression *exp, struct agent_expr *ax,
+               struct axs_value *value, char *field,
                char *operator_name, char *operand_name)
 {
   struct type *type;
@@ -1364,7 +1321,7 @@ gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field,
      should at least be consistent.  */
   while (TYPE_CODE (value->type) == TYPE_CODE_PTR)
     {
-      gen_usual_unary (ax, value);
+      require_rvalue (ax, value);
       gen_deref (ax, value);
     }
   type = check_typedef (value->type);
@@ -1384,7 +1341,7 @@ gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field,
 
   /* Is this a bitfield?  */
   if (TYPE_FIELD_PACKED (type, i))
-    gen_bitfield_ref (ax, value, TYPE_FIELD_TYPE (type, i),
+    gen_bitfield_ref (exp, ax, value, TYPE_FIELD_TYPE (type, i),
                      TYPE_FIELD_BITPOS (type, i),
                      (TYPE_FIELD_BITPOS (type, i)
                       + TYPE_FIELD_BITSIZE (type, i)));
@@ -1409,13 +1366,13 @@ gen_struct_ref (struct agent_expr *ax, struct axs_value *value, char *field,
    stack slots, doing weird things with sizeof, etc.  So we require
    the right operand to be a constant expression.  */
 static void
-gen_repeat (union exp_element **pc, struct agent_expr *ax,
-           struct axs_value *value)
+gen_repeat (struct expression *exp, union exp_element **pc,
+           struct agent_expr *ax, struct axs_value *value)
 {
   struct axs_value value1;
   /* We don't want to turn this into an rvalue, so no conversions
      here.  */
-  gen_expr (pc, ax, &value1);
+  gen_expr (exp, pc, ax, &value1);
   if (value1.kind != axs_lvalue_memory)
     error (_("Left operand of `@' must be an object in memory."));
 
@@ -1438,7 +1395,7 @@ gen_repeat (union exp_element **pc, struct agent_expr *ax,
       /* FIXME-type-allocation: need a way to free this type when we are
          done with it.  */
       struct type *range
-      = create_range_type (0, builtin_type_int, 0, length - 1);
+      = create_range_type (0, builtin_type_int32, 0, length - 1);
       struct type *array = create_array_type (0, value1.type, range);
 
       value->kind = axs_lvalue_memory;
@@ -1452,8 +1409,9 @@ gen_repeat (union exp_element **pc, struct agent_expr *ax,
    *PC should point at the start of the operand expression; we advance it
    to the first instruction after the operand.  */
 static void
-gen_sizeof (union exp_element **pc, struct agent_expr *ax,
-           struct axs_value *value)
+gen_sizeof (struct expression *exp, union exp_element **pc,
+           struct agent_expr *ax, struct axs_value *value,
+           struct type *size_type)
 {
   /* We don't care about the value of the operand expression; we only
      care about its type.  However, in the current arrangement, the
@@ -1461,14 +1419,14 @@ gen_sizeof (union exp_element **pc, struct agent_expr *ax,
      So we generate code for the operand, and then throw it away,
      replacing it with code that simply pushes its size.  */
   int start = ax->len;
-  gen_expr (pc, ax, value);
+  gen_expr (exp, pc, ax, value);
 
   /* Throw away the code we just generated.  */
   ax->len = start;
 
   ax_const_l (ax, TYPE_LENGTH (value->type));
   value->kind = axs_rvalue;
-  value->type = builtin_type_int;
+  value->type = size_type;
 }
 \f
 
@@ -1478,8 +1436,8 @@ gen_sizeof (union exp_element **pc, struct agent_expr *ax,
 /* A gen_expr function written by a Gen-X'er guy.
    Append code for the subexpression of EXPR starting at *POS_P to AX.  */
 static void
-gen_expr (union exp_element **pc, struct agent_expr *ax,
-         struct axs_value *value)
+gen_expr (struct expression *exp, union exp_element **pc,
+         struct agent_expr *ax, struct axs_value *value)
 {
   /* Used to hold the descriptions of operand expressions.  */
   struct axs_value value1, value2;
@@ -1512,18 +1470,40 @@ gen_expr (union exp_element **pc, struct agent_expr *ax,
     case BINOP_BITWISE_IOR:
     case BINOP_BITWISE_XOR:
       (*pc)++;
-      gen_expr (pc, ax, &value1);
-      gen_usual_unary (ax, &value1);
-      gen_expr (pc, ax, &value2);
-      gen_usual_unary (ax, &value2);
-      gen_usual_arithmetic (ax, &value1, &value2);
+      gen_expr (exp, pc, ax, &value1);
+      gen_usual_unary (exp, ax, &value1);
+      gen_expr (exp, pc, ax, &value2);
+      gen_usual_unary (exp, ax, &value2);
+      gen_usual_arithmetic (exp, ax, &value1, &value2);
       switch (op)
        {
        case BINOP_ADD:
-         gen_add (ax, value, &value1, &value2, "addition");
+         if (TYPE_CODE (value1.type) == TYPE_CODE_INT
+             && TYPE_CODE (value2.type) == TYPE_CODE_PTR)
+           {
+             /* Swap the values and proceed normally.  */
+             ax_simple (ax, aop_swap);
+             gen_ptradd (ax, value, &value2, &value1);
+           }
+         else if (TYPE_CODE (value1.type) == TYPE_CODE_PTR
+                  && TYPE_CODE (value2.type) == TYPE_CODE_INT)
+           gen_ptradd (ax, value, &value1, &value2);
+         else
+           gen_binop (ax, value, &value1, &value2,
+                      aop_add, aop_add, 1, "addition");
          break;
        case BINOP_SUB:
-         gen_sub (ax, value, &value1, &value2);
+         if (TYPE_CODE (value1.type) == TYPE_CODE_PTR
+             && TYPE_CODE (value2.type) == TYPE_CODE_INT)
+           gen_ptrsub (ax,value, &value1, &value2);
+         else if (TYPE_CODE (value1.type) == TYPE_CODE_PTR
+                  && TYPE_CODE (value2.type) == TYPE_CODE_PTR)
+           /* FIXME --- result type should be ptrdiff_t */
+           gen_ptrdiff (ax, value, &value1, &value2,
+                        builtin_type (exp->gdbarch)->builtin_long);
+         else
+           gen_binop (ax, value, &value1, &value2,
+                      aop_sub, aop_sub, 1, "subtraction");
          break;
        case BINOP_MUL:
          gen_binop (ax, value, &value1, &value2,
@@ -1538,7 +1518,7 @@ gen_expr (union exp_element **pc, struct agent_expr *ax,
                     aop_rem_signed, aop_rem_unsigned, 1, "remainder");
          break;
        case BINOP_SUBSCRIPT:
-         gen_add (ax, value, &value1, &value2, "array subscripting");
+         gen_ptradd (ax, value, &value1, &value2);
          if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
            error (_("Invalid combination of types in array subscripting."));
          gen_deref (ax, value);
@@ -1574,12 +1554,12 @@ gen_expr (union exp_element **pc, struct agent_expr *ax,
          variables it mentions get traced.  */
     case BINOP_COMMA:
       (*pc)++;
-      gen_expr (pc, ax, &value1);
+      gen_expr (exp, pc, ax, &value1);
       /* 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 (ax, &value1);
-      gen_expr (pc, ax, value);
+      gen_expr (exp, pc, ax, value);
       /* It's the consumer's responsibility to trace the right operand.  */
       break;
 
@@ -1593,7 +1573,7 @@ gen_expr (union exp_element **pc, struct agent_expr *ax,
       break;
 
     case OP_VAR_VALUE:
-      gen_var_ref (ax, value, (*pc)[2].symbol);
+      gen_var_ref (exp->gdbarch, ax, value, (*pc)[2].symbol);
       (*pc) += 4;
       break;
 
@@ -1602,14 +1582,17 @@ gen_expr (union exp_element **pc, struct agent_expr *ax,
        const char *name = &(*pc)[2].string;
        int reg;
        (*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1);
-       reg = frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
-                                       name, strlen (name));
+       reg = user_reg_map_name_to_regnum (exp->gdbarch, name, strlen (name));
        if (reg == -1)
          internal_error (__FILE__, __LINE__,
                          _("Register $%s not available"), name);
+       if (reg >= gdbarch_num_regs (exp->gdbarch))
+         error (_("'%s' is a pseudo-register; "
+                  "GDB cannot yet trace pseudoregister contents."),
+                name);
        value->kind = axs_lvalue_register;
        value->u.reg = reg;
-       value->type = register_type (current_gdbarch, reg);
+       value->type = register_type (exp->gdbarch, reg);
       }
       break;
 
@@ -1620,14 +1603,14 @@ gen_expr (union exp_element **pc, struct agent_expr *ax,
     case BINOP_REPEAT:
       /* Note that gen_repeat handles its own argument evaluation.  */
       (*pc)++;
-      gen_repeat (pc, ax, value);
+      gen_repeat (exp, pc, ax, value);
       break;
 
     case UNOP_CAST:
       {
        struct type *type = (*pc)[1].type;
        (*pc) += 3;
-       gen_expr (pc, ax, value);
+       gen_expr (exp, pc, ax, value);
        gen_cast (ax, value, type);
       }
       break;
@@ -1636,7 +1619,7 @@ gen_expr (union exp_element **pc, struct agent_expr *ax,
       {
        struct type *type = check_typedef ((*pc)[1].type);
        (*pc) += 3;
-       gen_expr (pc, ax, value);
+       gen_expr (exp, pc, ax, value);
        /* I'm not sure I understand UNOP_MEMVAL entirely.  I think
           it's just a hack for dealing with minsyms; you take some
           integer constant, pretend it's the address of an lvalue of
@@ -1653,37 +1636,41 @@ gen_expr (union exp_element **pc, struct agent_expr *ax,
     case UNOP_PLUS:
       (*pc)++;
       /* + FOO is equivalent to 0 + FOO, which can be optimized. */
-      gen_expr (pc, ax, value);
-      gen_usual_unary (ax, value);
+      gen_expr (exp, pc, ax, value);
+      gen_usual_unary (exp, ax, value);
       break;
       
     case UNOP_NEG:
       (*pc)++;
       /* -FOO is equivalent to 0 - FOO.  */
-      gen_int_literal (ax, &value1, (LONGEST) 0, builtin_type_int);
-      gen_usual_unary (ax, &value1);   /* shouldn't do much */
-      gen_expr (pc, ax, &value2);
-      gen_usual_unary (ax, &value2);
-      gen_usual_arithmetic (ax, &value1, &value2);
-      gen_sub (ax, value, &value1, &value2);
+      gen_int_literal (ax, &value1, (LONGEST) 0, builtin_type_int8);
+      gen_usual_unary (exp, 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_binop (ax, value, &value1, &value2, aop_sub, aop_sub, 1, "negation");
       break;
 
     case UNOP_LOGICAL_NOT:
       (*pc)++;
-      gen_expr (pc, ax, value);
-      gen_logical_not (ax, value);
+      gen_expr (exp, pc, ax, value);
+      gen_usual_unary (exp, ax, value);
+      gen_logical_not (ax, value,
+                      language_bool_type (exp->language_defn, exp->gdbarch));
       break;
 
     case UNOP_COMPLEMENT:
       (*pc)++;
-      gen_expr (pc, ax, value);
+      gen_expr (exp, pc, ax, value);
+      gen_usual_unary (exp, ax, value);
+      gen_integral_promotions (exp, ax, value);
       gen_complement (ax, value);
       break;
 
     case UNOP_IND:
       (*pc)++;
-      gen_expr (pc, ax, value);
-      gen_usual_unary (ax, value);
+      gen_expr (exp, pc, ax, value);
+      gen_usual_unary (exp, ax, value);
       if (TYPE_CODE (value->type) != TYPE_CODE_PTR)
        error (_("Argument of unary `*' is not a pointer."));
       gen_deref (ax, value);
@@ -1691,7 +1678,7 @@ gen_expr (union exp_element **pc, struct agent_expr *ax,
 
     case UNOP_ADDR:
       (*pc)++;
-      gen_expr (pc, ax, value);
+      gen_expr (exp, pc, ax, value);
       gen_address_of (ax, value);
       break;
 
@@ -1700,7 +1687,8 @@ gen_expr (union exp_element **pc, struct agent_expr *ax,
       /* Notice that gen_sizeof handles its own operand, unlike most
          of the other unary operator functions.  This is because we
          have to throw away the code we generate.  */
-      gen_sizeof (pc, ax, value);
+      gen_sizeof (exp, pc, ax, value,
+                 builtin_type (exp->gdbarch)->builtin_int);
       break;
 
     case STRUCTOP_STRUCT:
@@ -1710,11 +1698,11 @@ gen_expr (union exp_element **pc, struct agent_expr *ax,
        char *name = &(*pc)[2].string;
 
        (*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1);
-       gen_expr (pc, ax, value);
+       gen_expr (exp, pc, ax, value);
        if (op == STRUCTOP_STRUCT)
-         gen_struct_ref (ax, value, name, ".", "structure or union");
+         gen_struct_ref (exp, ax, value, name, ".", "structure or union");
        else if (op == STRUCTOP_PTR)
-         gen_struct_ref (ax, value, name, "->",
+         gen_struct_ref (exp, ax, value, name, "->",
                          "pointer to a structure or union");
        else
          /* If this `if' chain doesn't handle it, then the case list
@@ -1753,7 +1741,7 @@ gen_trace_for_expr (CORE_ADDR scope, struct expression *expr)
 
   pc = expr->elts;
   trace_kludge = 1;
-  gen_expr (&pc, ax, &value);
+  gen_expr (expr, &pc, ax, &value);
 
   /* Make sure we record the final object, and get rid of it.  */
   gen_traced_pop (ax, &value);
This page took 0.04048 seconds and 4 git commands to generate.