Subversion Repositories openrisc_2011-10-31

/* GDB-specific functions for operating on agent expressions.

   Copyright (C) 1998, 1999, 2000, 2001, 2003, 2007, 2008

   Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include "symtab.h"

#include "symfile.h"

#include "gdbtypes.h"

#include "value.h"

#include "expression.h"

#include "command.h"

#include "gdbcmd.h"

#include "frame.h"

#include "target.h"

#include "ax.h"

#include "ax-gdb.h"

#include "gdb_string.h"

#include "block.h"

#include "regcache.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,

   look at gen_expr, towards the bottom; that's the main function that

   looks at the GDB expressions and calls everything else to generate

   code.

   I'm beginning to wonder whether it wouldn't be nicer to internally

   generate trees, with types, and then spit out the bytecode in

   linear form afterwards; we could generate fewer `swap', `ext', and

   `zero_ext' bytecodes that way; it would make good constant folding

   easier, too.  But at the moment, I think we should be willing to

   pay for the simplicity of this code with less-than-optimal bytecode

   strings.

   Remember, "GBD" stands for "Great Britain, Dammit!"  So be careful.  */

/* Prototypes for local functions. */

/* There's a standard order to the arguments of these functions:

   union exp_element ** --- pointer into expression

   struct agent_expr * --- agent expression buffer to generate code into

   struct axs_value * --- describes value left on top of stack  */

static struct value *const_var_ref (struct symbol *var);

static struct value *const_expr (union exp_element **pc);

static struct value *maybe_const_expr (union exp_element **pc);

static void gen_traced_pop (struct agent_expr *, struct axs_value *);

static void gen_sign_extend (struct agent_expr *, struct type *);

static void gen_extend (struct agent_expr *, struct type *);

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_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,

                         struct axs_value *value, struct symbol *var);

static void gen_int_literal (struct agent_expr *ax,

                             struct axs_value *value,

                             LONGEST k, struct type *type);

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 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,

                                  struct axs_value *value1,

                                  struct axs_value *value2);

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);

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_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_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,

                              struct axs_value *value,

                              struct type *type, int start, int end);

static void gen_struct_ref (struct agent_expr *ax,

                            struct axs_value *value,

                            char *field,

                            char *operator_name, char *operand_name);

static void gen_repeat (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,

                      struct agent_expr *ax, struct axs_value *value);

static void agent_command (char *exp, int from_tty);

/* Detecting constant expressions.  */

/* If the variable reference at *PC is a constant, return its value.

   Otherwise, return zero.

   Hey, Wally!  How can a variable reference be a constant?

   Well, Beav, this function really handles the OP_VAR_VALUE operator,

   not specifically variable references.  GDB uses OP_VAR_VALUE to

   refer to any kind of symbolic reference: function names, enum

   elements, and goto labels are all handled through the OP_VAR_VALUE

   operator, even though they're constants.  It makes sense given the

   situation.

   Gee, Wally, don'cha wonder sometimes if data representations that

   subvert commonly accepted definitions of terms in favor of heavily

   context-specific interpretations are really just a tool of the

   programming hegemony to preserve their power and exclude the

   proletariat?  */

static struct value *

const_var_ref (struct symbol *var)

{

  struct type *type = SYMBOL_TYPE (var);

  switch (SYMBOL_CLASS (var))

    {

    case LOC_CONST:

      return value_from_longest (type, (LONGEST) SYMBOL_VALUE (var));

    case LOC_LABEL:

      return value_from_pointer (type, (CORE_ADDR) SYMBOL_VALUE_ADDRESS (var));

    default:

      return 0;

    }

}

/* If the expression starting at *PC has a constant value, return it.

   Otherwise, return zero.  If we return a value, then *PC will be

   advanced to the end of it.  If we return zero, *PC could be

   anywhere.  */

static struct value *

const_expr (union exp_element **pc)

{

  enum exp_opcode op = (*pc)->opcode;

  struct value *v1;

  switch (op)

    {

    case OP_LONG:

      {

        struct type *type = (*pc)[1].type;

        LONGEST k = (*pc)[2].longconst;

        (*pc) += 4;

        return value_from_longest (type, k);

      }

    case OP_VAR_VALUE:

      {

        struct value *v = const_var_ref ((*pc)[2].symbol);

        (*pc) += 4;

        return v;

      }

      /* We could add more operators in here.  */

    case UNOP_NEG:

      (*pc)++;

      v1 = const_expr (pc);

      if (v1)

        return value_neg (v1);

      else

        return 0;

    default:

      return 0;

    }

}

/* Like const_expr, but guarantee also that *PC is undisturbed if the

   expression is not constant.  */

static struct value *

maybe_const_expr (union exp_element **pc)

{

  union exp_element *tentative_pc = *pc;

  struct value *v = const_expr (&tentative_pc);

  /* If we got a value, then update the real PC.  */

  if (v)

    *pc = tentative_pc;

  return v;

}

/* Generating bytecode from GDB expressions: general assumptions */

/* Here are a few general assumptions made throughout the code; if you

   want to make a change that contradicts one of these, then you'd

   better scan things pretty thoroughly.

   - We assume that all values occupy one stack element.  For example,

   sometimes we'll swap to get at the left argument to a binary

   operator.  If we decide that void values should occupy no stack

   elements, or that synthetic arrays (whose size is determined at

   run time, created by the `@' operator) should occupy two stack

   elements (address and length), then this will cause trouble.

   - We assume the stack elements are infinitely wide, and that we

   don't have to worry what happens if the user requests an

   operation that is wider than the actual interpreter's stack.

   That is, it's up to the interpreter to handle directly all the

   integer widths the user has access to.  (Woe betide the language

   with bignums!)

   - We don't support side effects.  Thus, we don't have to worry about

   GCC's generalized lvalues, function calls, etc.

   - We don't support floating point.  Many places where we switch on

   some type don't bother to include cases for floating point; there

   may be even more subtle ways this assumption exists.  For

   example, the arguments to % must be integers.

   - We assume all subexpressions have a static, unchanging type.  If

   we tried to support convenience variables, this would be a

   problem.

   - All values on the stack should always be fully zero- or

   sign-extended.

   (I wasn't sure whether to choose this or its opposite --- that

   only addresses are assumed extended --- but it turns out that

   neither convention completely eliminates spurious extend

   operations (if everything is always extended, then you have to

   extend after add, because it could overflow; if nothing is

   extended, then you end up producing extends whenever you change

   sizes), and this is simpler.)  */

/* Generating bytecode from GDB expressions: the `trace' kludge  */

/* The compiler in this file is a general-purpose mechanism for

   translating GDB expressions into bytecode.  One ought to be able to

   find a million and one uses for it.

   However, at the moment it is HOPELESSLY BRAIN-DAMAGED for the sake

   of expediency.  Let he who is without sin cast the first stone.

   For the data tracing facility, we need to insert `trace' bytecodes

   before each data fetch; this records all the memory that the

   expression touches in the course of evaluation, so that memory will

   be available when the user later tries to evaluate the expression

   in GDB.

   This should be done (I think) in a post-processing pass, that walks

   an arbitrary agent expression and inserts `trace' operations at the

   appropriate points.  But it's much faster to just hack them

   directly into the code.  And since we're in a crunch, that's what

   I've done.

   Setting the flag trace_kludge to non-zero enables the code that

   emits the trace bytecodes at the appropriate points.  */

static int trace_kludge;

/* Trace the lvalue on the stack, if it needs it.  In either case, pop

   the value.  Useful on the left side of a comma, and at the end of

   an expression being used for tracing.  */

static void

gen_traced_pop (struct agent_expr *ax, struct axs_value *value)

{

  if (trace_kludge)

    switch (value->kind)

      {

      case axs_rvalue:

        /* We don't trace rvalues, just the lvalues necessary to

           produce them.  So just dispose of this value.  */

        ax_simple (ax, aop_pop);

        break;

      case axs_lvalue_memory:

        {

          int length = TYPE_LENGTH (check_typedef (value->type));

          /* There's no point in trying to use a trace_quick bytecode

             here, since "trace_quick SIZE pop" is three bytes, whereas

             "const8 SIZE trace" is also three bytes, does the same

             thing, and the simplest code which generates that will also

             work correctly for objects with large sizes.  */

          ax_const_l (ax, length);

          ax_simple (ax, aop_trace);

        }

        break;

      case axs_lvalue_register:

        /* We need to mention the register somewhere in the bytecode,

           so ax_reqs will pick it up and add it to the mask of

           registers used.  */

        ax_reg (ax, value->u.reg);

        ax_simple (ax, aop_pop);

        break;

      }

  else

    /* If we're not tracing, just pop the value.  */

    ax_simple (ax, aop_pop);

}

/* Generating bytecode from GDB expressions: helper functions */

/* Assume that the lower bits of the top of the stack is a value of

   type TYPE, and the upper bits are zero.  Sign-extend if necessary.  */

static void

gen_sign_extend (struct agent_expr *ax, struct type *type)

{

  /* Do we need to sign-extend this?  */

  if (!TYPE_UNSIGNED (type))

    ax_ext (ax, TYPE_LENGTH (type) * TARGET_CHAR_BIT);

}

/* Assume the lower bits of the top of the stack hold a value of type

   TYPE, and the upper bits are garbage.  Sign-extend or truncate as

   needed.  */

static void

gen_extend (struct agent_expr *ax, struct type *type)

{

  int bits = TYPE_LENGTH (type) * TARGET_CHAR_BIT;

  /* I just had to.  */

  ((TYPE_UNSIGNED (type) ? ax_zero_ext : ax_ext) (ax, bits));

}

/* Assume that the top of the stack contains a value of type "pointer

   to TYPE"; generate code to fetch its value.  Note that TYPE is the

   target type, not the pointer type.  */

static void

gen_fetch (struct agent_expr *ax, struct type *type)

{

  if (trace_kludge)

    {

      /* Record the area of memory we're about to fetch.  */

      ax_trace_quick (ax, TYPE_LENGTH (type));

    }

  switch (TYPE_CODE (type))

    {

    case TYPE_CODE_PTR:

    case TYPE_CODE_ENUM:

    case TYPE_CODE_INT:

    case TYPE_CODE_CHAR:

      /* It's a scalar value, so we know how to dereference it.  How

         many bytes long is it?  */

      switch (TYPE_LENGTH (type))

        {

        case 8 / TARGET_CHAR_BIT:

          ax_simple (ax, aop_ref8);

          break;

        case 16 / TARGET_CHAR_BIT:

          ax_simple (ax, aop_ref16);

          break;

        case 32 / TARGET_CHAR_BIT:

          ax_simple (ax, aop_ref32);

          break;

        case 64 / TARGET_CHAR_BIT:

          ax_simple (ax, aop_ref64);

          break;

          /* Either our caller shouldn't have asked us to dereference

             that pointer (other code's fault), or we're not

             implementing something we should be (this code's fault).

             In any case, it's a bug the user shouldn't see.  */

        default:

          internal_error (__FILE__, __LINE__,

                          _("gen_fetch: strange size"));

        }

      gen_sign_extend (ax, type);

      break;

    default:

      /* Either our caller shouldn't have asked us to dereference that

         pointer (other code's fault), or we're not implementing

         something we should be (this code's fault).  In any case,

         it's a bug the user shouldn't see.  */

      internal_error (__FILE__, __LINE__,

                      _("gen_fetch: bad type code"));

    }

}

/* Generate code to left shift the top of the stack by DISTANCE bits, or

   right shift it by -DISTANCE bits if DISTANCE < 0.  This generates

   unsigned (logical) right shifts.  */

static void

gen_left_shift (struct agent_expr *ax, int distance)

{

  if (distance > 0)

    {

      ax_const_l (ax, distance);

      ax_simple (ax, aop_lsh);

    }

  else if (distance < 0)

    {

      ax_const_l (ax, -distance);

      ax_simple (ax, aop_rsh_unsigned);

    }

}

/* Generating bytecode from GDB expressions: symbol references */

/* 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)

{

  int frame_reg;

  LONGEST frame_offset;

  gdbarch_virtual_frame_pointer (current_gdbarch,

                                 ax->scope, &frame_reg, &frame_offset);

  ax_reg (ax, frame_reg);

  gen_offset (ax, frame_offset);

}

/* 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)

{

  int frame_reg;

  LONGEST frame_offset;

  gdbarch_virtual_frame_pointer (current_gdbarch,

                                 ax->scope, &frame_reg, &frame_offset);

  ax_reg (ax, frame_reg);

  gen_offset (ax, frame_offset);

}

/* Generate code to add OFFSET to the top of the stack.  Try to

   generate short and readable code.  We use this for getting to

   variables on the stack, and structure members.  If we were

   programming in ML, it would be clearer why these are the same

   thing.  */

static void

gen_offset (struct agent_expr *ax, int offset)

{

  /* It would suffice to simply push the offset and add it, but this

     makes it easier to read positive and negative offsets in the

     bytecode.  */

  if (offset > 0)

    {

      ax_const_l (ax, offset);

      ax_simple (ax, aop_add);

    }

  else if (offset < 0)

    {

      ax_const_l (ax, -offset);

      ax_simple (ax, aop_sub);

    }

}

/* In many cases, a symbol's value is the offset from some other

   address (stack frame, base register, etc.)  Generate code to add

   VAR's value to the top of the stack.  */

static void

gen_sym_offset (struct agent_expr *ax, struct symbol *var)

{

  gen_offset (ax, SYMBOL_VALUE (var));

}

/* Generate code for a variable reference to AX.  The variable is the

   symbol VAR.  Set VALUE to describe the result.  */

static void

gen_var_ref (struct agent_expr *ax, struct axs_value *value, struct symbol *var)

{

  /* Dereference any typedefs. */

  value->type = check_typedef (SYMBOL_TYPE (var));

  /* I'm imitating the code in read_var_value.  */

  switch (SYMBOL_CLASS (var))

    {

    case LOC_CONST:             /* A constant, like an enum value.  */

      ax_const_l (ax, (LONGEST) SYMBOL_VALUE (var));

      value->kind = axs_rvalue;

      break;

    case LOC_LABEL:             /* A goto label, being used as a value.  */

      ax_const_l (ax, (LONGEST) SYMBOL_VALUE_ADDRESS (var));

      value->kind = axs_rvalue;

      break;

    case LOC_CONST_BYTES:

      internal_error (__FILE__, __LINE__,

                      _("gen_var_ref: LOC_CONST_BYTES symbols are not supported"));

      /* Variable at a fixed location in memory.  Easy.  */

    case LOC_STATIC:

      /* Push the address of the variable.  */

      ax_const_l (ax, SYMBOL_VALUE_ADDRESS (var));

      value->kind = axs_lvalue_memory;

      break;

    case LOC_ARG:               /* var lives in argument area of frame */

      gen_frame_args_address (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_sym_offset (ax, var);

      /* Don't assume any particular pointer size.  */

      gen_fetch (ax, lookup_pointer_type (builtin_type_void));

      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_sym_offset (ax, var);

      value->kind = axs_lvalue_memory;

      break;

    case LOC_TYPEDEF:

      error (_("Cannot compute value of typedef `%s'."),

             SYMBOL_PRINT_NAME (var));

      break;

    case LOC_BLOCK:

      ax_const_l (ax, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));

      value->kind = axs_rvalue;

      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);

      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.  */

    case LOC_REGPARM_ADDR:

      ax_reg (ax, SYMBOL_VALUE (var));

      value->kind = axs_lvalue_memory;

      break;

    case LOC_UNRESOLVED:

      {

        struct minimal_symbol *msym

        = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);

        if (!msym)

          error (_("Couldn't resolve symbol `%s'."), SYMBOL_PRINT_NAME (var));

        /* Push the address of the variable.  */

        ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym));

        value->kind = axs_lvalue_memory;

      }

      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.

         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);

      break;

    case LOC_OPTIMIZED_OUT:

      error (_("The variable `%s' has been optimized out."),

             SYMBOL_PRINT_NAME (var));

      break;

    default:

      error (_("Cannot find value of botched symbol `%s'."),

             SYMBOL_PRINT_NAME (var));

      break;

    }

}

/* Generating bytecode from GDB expressions: literals */

static void

gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k,

                 struct type *type)

{

  ax_const_l (ax, k);

  value->kind = axs_rvalue;

  value->type = check_typedef (type);

}

/* Generating bytecode from GDB expressions: unary conversions, casts */

/* Take what's on the top of the stack (as described by VALUE), and

   try to make an rvalue out of it.  Signal an error if we can't do

   that.  */

static void

require_rvalue (struct agent_expr *ax, struct axs_value *value)

{

  switch (value->kind)

    {

    case axs_rvalue:

      /* It's already an rvalue.  */

      break;

    case axs_lvalue_memory:

      /* The top of stack is the address of the object.  Dereference.  */

      gen_fetch (ax, value->type);

      break;

    case axs_lvalue_register:

      /* There's nothing on the stack, but value->u.reg is the

         register number containing the value.

         When we add floating-point support, this is going to have to

         change.  What about SPARC register pairs, for example?  */

      ax_reg (ax, value->u.reg);

      gen_extend (ax, value->type);

      break;

    }

  value->kind = axs_rvalue;

}

/* Assume the top of the stack is described by VALUE, and perform the

   usual unary conversions.  This is motivated by ANSI 6.2.2, but of

   course GDB expressions are not ANSI; they're the mishmash union of

   a bunch of languages.  Rah.

   NOTE!  This function promises to produce an rvalue only when the

   incoming value is of an appropriate type.  In other words, the

   consumer of the value this function produces may assume the value

   is an rvalue only after checking its type.

   The immediate issue is that if the user tries to use a structure or

   union as an operand of, say, the `+' operator, we don't want to try

   to convert that structure to an rvalue; require_rvalue will bomb on

   structs and unions.  Rather, we want to simply pass the struct

   lvalue through unchanged, and let `+' raise an error.  */

static void

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

     the stack.  Should we tweak the type?  */

  /* Some types require special handling.  */

  switch (TYPE_CODE (value->type))

    {

      /* Functions get converted to a pointer to the function.  */

    case TYPE_CODE_FUNC:

      value->type = lookup_pointer_type (value->type);

      value->kind = axs_rvalue; /* Should always be true, but just in case.  */

      break;

      /* Arrays get converted to a pointer to their first element, and

         are no longer an lvalue.  */

    case TYPE_CODE_ARRAY:

      {