[deliverable/binutils-gdb.git] / gdb / dwarf2expr.c

/* DWARF 2 Expression Evaluator.

   Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.

   Contributed by Daniel Berlin (dan@dberlin.org)

   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 2 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, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

#include "defs.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "value.h"
#include "gdbcore.h"
#include "elf/dwarf2.h"
#include "dwarf2expr.h"

/* Local prototypes.  */

static void execute_stack_op (struct dwarf_expr_context *,
			      gdb_byte *, gdb_byte *);

/* Create a new context for the expression evaluator.  */

struct dwarf_expr_context *
new_dwarf_expr_context (void)
{
  struct dwarf_expr_context *retval;
  retval = xcalloc (1, sizeof (struct dwarf_expr_context));
  retval->stack_len = 0;
  retval->stack_allocated = 10;
  retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR));
  retval->num_pieces = 0;
  retval->pieces = 0;
  return retval;
}

/* Release the memory allocated to CTX.  */

void
free_dwarf_expr_context (struct dwarf_expr_context *ctx)
{
  xfree (ctx->stack);
  xfree (ctx->pieces);
  xfree (ctx);
}

/* Expand the memory allocated to CTX's stack to contain at least
   NEED more elements than are currently used.  */

static void
dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
{
  if (ctx->stack_len + need > ctx->stack_allocated)
    {
      size_t newlen = ctx->stack_len + need + 10;
      ctx->stack = xrealloc (ctx->stack,
			     newlen * sizeof (CORE_ADDR));
      ctx->stack_allocated = newlen;
    }
}

/* Push VALUE onto CTX's stack.  */

void
dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
{
  dwarf_expr_grow_stack (ctx, 1);
  ctx->stack[ctx->stack_len++] = value;
}

/* Pop the top item off of CTX's stack.  */

void
dwarf_expr_pop (struct dwarf_expr_context *ctx)
{
  if (ctx->stack_len <= 0)
    error (_("dwarf expression stack underflow"));
  ctx->stack_len--;
}

/* Retrieve the N'th item on CTX's stack.  */

CORE_ADDR
dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
{
  if (ctx->stack_len <= n)
     error (_("Asked for position %d of stack, stack only has %d elements on it."),
	    n, ctx->stack_len);
  return ctx->stack[ctx->stack_len - (1 + n)];

}

/* Add a new piece to CTX's piece list.  */
static void
add_piece (struct dwarf_expr_context *ctx,
           int in_reg, CORE_ADDR value, ULONGEST size)
{
  struct dwarf_expr_piece *p;

  ctx->num_pieces++;

  if (ctx->pieces)
    ctx->pieces = xrealloc (ctx->pieces,
                            (ctx->num_pieces
                             * sizeof (struct dwarf_expr_piece)));
  else
    ctx->pieces = xmalloc (ctx->num_pieces
                           * sizeof (struct dwarf_expr_piece));

  p = &ctx->pieces[ctx->num_pieces - 1];
  p->in_reg = in_reg;
  p->value = value;
  p->size = size;
}

/* Evaluate the expression at ADDR (LEN bytes long) using the context
   CTX.  */

void
dwarf_expr_eval (struct dwarf_expr_context *ctx, gdb_byte *addr, size_t len)
{
  execute_stack_op (ctx, addr, addr + len);
}

/* Decode the unsigned LEB128 constant at BUF into the variable pointed to
   by R, and return the new value of BUF.  Verify that it doesn't extend
   past BUF_END.  */

gdb_byte *
read_uleb128 (gdb_byte *buf, gdb_byte *buf_end, ULONGEST * r)
{
  unsigned shift = 0;
  ULONGEST result = 0;
  gdb_byte byte;

  while (1)
    {
      if (buf >= buf_end)
	error (_("read_uleb128: Corrupted DWARF expression."));

      byte = *buf++;
      result |= (byte & 0x7f) << shift;
      if ((byte & 0x80) == 0)
	break;
      shift += 7;
    }
  *r = result;
  return buf;
}

/* Decode the signed LEB128 constant at BUF into the variable pointed to
   by R, and return the new value of BUF.  Verify that it doesn't extend
   past BUF_END.  */

gdb_byte *
read_sleb128 (gdb_byte *buf, gdb_byte *buf_end, LONGEST * r)
{
  unsigned shift = 0;
  LONGEST result = 0;
  gdb_byte byte;

  while (1)
    {
      if (buf >= buf_end)
	error (_("read_sleb128: Corrupted DWARF expression."));

      byte = *buf++;
      result |= (byte & 0x7f) << shift;
      shift += 7;
      if ((byte & 0x80) == 0)
	break;
    }
  if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
    result |= -(1 << shift);

  *r = result;
  return buf;
}

/* Read an address from BUF, and verify that it doesn't extend past
   BUF_END.  The address is returned, and *BYTES_READ is set to the
   number of bytes read from BUF.  */

CORE_ADDR
dwarf2_read_address (gdb_byte *buf, gdb_byte *buf_end, int *bytes_read)
{
  CORE_ADDR result;

  if (buf_end - buf < TARGET_ADDR_BIT / TARGET_CHAR_BIT)
    error (_("dwarf2_read_address: Corrupted DWARF expression."));

  *bytes_read = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
  /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
     address is always unsigned.  That may or may not be true.  */
  result = extract_unsigned_integer (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT);
  return result;
}

/* Return the type of an address, for unsigned arithmetic.  */

static struct type *
unsigned_address_type (void)
{
  switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
    {
    case 2:
      return builtin_type_uint16;
    case 4:
      return builtin_type_uint32;
    case 8:
      return builtin_type_uint64;
    default:
      internal_error (__FILE__, __LINE__,
		      _("Unsupported address size.\n"));
    }
}

/* Return the type of an address, for signed arithmetic.  */

static struct type *
signed_address_type (void)
{
  switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
    {
    case 2:
      return builtin_type_int16;
    case 4:
      return builtin_type_int32;
    case 8:
      return builtin_type_int64;
    default:
      internal_error (__FILE__, __LINE__,
		      _("Unsupported address size.\n"));
    }
}
\f
/* The engine for the expression evaluator.  Using the context in CTX,
   evaluate the expression between OP_PTR and OP_END.  */

static void
execute_stack_op (struct dwarf_expr_context *ctx,
		  gdb_byte *op_ptr, gdb_byte *op_end)
{
  ctx->in_reg = 0;

  while (op_ptr < op_end)
    {
      enum dwarf_location_atom op = *op_ptr++;
      CORE_ADDR result;
      ULONGEST uoffset, reg;
      LONGEST offset;
      int bytes_read;

      switch (op)
	{
	case DW_OP_lit0:
	case DW_OP_lit1:
	case DW_OP_lit2:
	case DW_OP_lit3:
	case DW_OP_lit4:
	case DW_OP_lit5:
	case DW_OP_lit6:
	case DW_OP_lit7:
	case DW_OP_lit8:
	case DW_OP_lit9:
	case DW_OP_lit10:
	case DW_OP_lit11:
	case DW_OP_lit12:
	case DW_OP_lit13:
	case DW_OP_lit14:
	case DW_OP_lit15:
	case DW_OP_lit16:
	case DW_OP_lit17:
	case DW_OP_lit18:
	case DW_OP_lit19:
	case DW_OP_lit20:
	case DW_OP_lit21:
	case DW_OP_lit22:
	case DW_OP_lit23:
	case DW_OP_lit24:
	case DW_OP_lit25:
	case DW_OP_lit26:
	case DW_OP_lit27:
	case DW_OP_lit28:
	case DW_OP_lit29:
	case DW_OP_lit30:
	case DW_OP_lit31:
	  result = op - DW_OP_lit0;
	  break;

	case DW_OP_addr:
	  result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
	  op_ptr += bytes_read;
	  break;

	case DW_OP_const1u:
	  result = extract_unsigned_integer (op_ptr, 1);
	  op_ptr += 1;
	  break;
	case DW_OP_const1s:
	  result = extract_signed_integer (op_ptr, 1);
	  op_ptr += 1;
	  break;
	case DW_OP_const2u:
	  result = extract_unsigned_integer (op_ptr, 2);
	  op_ptr += 2;
	  break;
	case DW_OP_const2s:
	  result = extract_signed_integer (op_ptr, 2);
	  op_ptr += 2;
	  break;
	case DW_OP_const4u:
	  result = extract_unsigned_integer (op_ptr, 4);
	  op_ptr += 4;
	  break;
	case DW_OP_const4s:
	  result = extract_signed_integer (op_ptr, 4);
	  op_ptr += 4;
	  break;
	case DW_OP_const8u:
	  result = extract_unsigned_integer (op_ptr, 8);
	  op_ptr += 8;
	  break;
	case DW_OP_const8s:
	  result = extract_signed_integer (op_ptr, 8);
	  op_ptr += 8;
	  break;
	case DW_OP_constu:
	  op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
	  result = uoffset;
	  break;
	case DW_OP_consts:
	  op_ptr = read_sleb128 (op_ptr, op_end, &offset);
	  result = offset;
	  break;

	/* The DW_OP_reg operations are required to occur alone in
	   location expressions.  */
	case DW_OP_reg0:
	case DW_OP_reg1:
	case DW_OP_reg2:
	case DW_OP_reg3:
	case DW_OP_reg4:
	case DW_OP_reg5:
	case DW_OP_reg6:
	case DW_OP_reg7:
	case DW_OP_reg8:
	case DW_OP_reg9:
	case DW_OP_reg10:
	case DW_OP_reg11:
	case DW_OP_reg12:
	case DW_OP_reg13:
	case DW_OP_reg14:
	case DW_OP_reg15:
	case DW_OP_reg16:
	case DW_OP_reg17:
	case DW_OP_reg18:
	case DW_OP_reg19:
	case DW_OP_reg20:
	case DW_OP_reg21:
	case DW_OP_reg22:
	case DW_OP_reg23:
	case DW_OP_reg24:
	case DW_OP_reg25:
	case DW_OP_reg26:
	case DW_OP_reg27:
	case DW_OP_reg28:
	case DW_OP_reg29:
	case DW_OP_reg30:
	case DW_OP_reg31:
	  if (op_ptr != op_end && *op_ptr != DW_OP_piece)
	    error (_("DWARF-2 expression error: DW_OP_reg operations must be "
		   "used either alone or in conjuction with DW_OP_piece."));

	  result = op - DW_OP_reg0;
	  ctx->in_reg = 1;

	  break;

	case DW_OP_regx:
	  op_ptr = read_uleb128 (op_ptr, op_end, &reg);
	  if (op_ptr != op_end && *op_ptr != DW_OP_piece)
	    error (_("DWARF-2 expression error: DW_OP_reg operations must be "
		   "used either alone or in conjuction with DW_OP_piece."));

	  result = reg;
	  ctx->in_reg = 1;
	  break;

	case DW_OP_breg0:
	case DW_OP_breg1:
	case DW_OP_breg2:
	case DW_OP_breg3:
	case DW_OP_breg4:
	case DW_OP_breg5:
	case DW_OP_breg6:
	case DW_OP_breg7:
	case DW_OP_breg8:
	case DW_OP_breg9:
	case DW_OP_breg10:
	case DW_OP_breg11:
	case DW_OP_breg12:
	case DW_OP_breg13:
	case DW_OP_breg14:
	case DW_OP_breg15:
	case DW_OP_breg16:
	case DW_OP_breg17:
	case DW_OP_breg18:
	case DW_OP_breg19:
	case DW_OP_breg20:
	case DW_OP_breg21:
	case DW_OP_breg22:
	case DW_OP_breg23:
	case DW_OP_breg24:
	case DW_OP_breg25:
	case DW_OP_breg26:
	case DW_OP_breg27:
	case DW_OP_breg28:
	case DW_OP_breg29:
	case DW_OP_breg30:
	case DW_OP_breg31:
	  {
	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
	    result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
	    result += offset;
	  }
	  break;
	case DW_OP_bregx:
	  {
	    op_ptr = read_uleb128 (op_ptr, op_end, &reg);
	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
	    result = (ctx->read_reg) (ctx->baton, reg);
	    result += offset;
	  }
	  break;
	case DW_OP_fbreg:
	  {
	    gdb_byte *datastart;
	    size_t datalen;
	    unsigned int before_stack_len;

	    op_ptr = read_sleb128 (op_ptr, op_end, &offset);
	    /* Rather than create a whole new context, we simply
	       record the stack length before execution, then reset it
	       afterwards, effectively erasing whatever the recursive
	       call put there.  */
	    before_stack_len = ctx->stack_len;
	    /* FIXME: cagney/2003-03-26: This code should be using
               get_frame_base_address(), and then implement a dwarf2
               specific this_base method.  */
	    (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
	    dwarf_expr_eval (ctx, datastart, datalen);
	    result = dwarf_expr_fetch (ctx, 0);
	    if (ctx->in_reg)
	      result = (ctx->read_reg) (ctx->baton, result);
	    result = result + offset;
	    ctx->stack_len = before_stack_len;
	    ctx->in_reg = 0;
	  }
	  break;
	case DW_OP_dup:
	  result = dwarf_expr_fetch (ctx, 0);
	  break;

	case DW_OP_drop:
	  dwarf_expr_pop (ctx);
	  goto no_push;

	case DW_OP_pick:
	  offset = *op_ptr++;
	  result = dwarf_expr_fetch (ctx, offset);
	  break;

	case DW_OP_over:
	  result = dwarf_expr_fetch (ctx, 1);
	  break;

	case DW_OP_rot:
	  {
	    CORE_ADDR t1, t2, t3;

	    if (ctx->stack_len < 3)
	       error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
		      ctx->stack_len);
	    t1 = ctx->stack[ctx->stack_len - 1];
	    t2 = ctx->stack[ctx->stack_len - 2];
	    t3 = ctx->stack[ctx->stack_len - 3];
	    ctx->stack[ctx->stack_len - 1] = t2;
	    ctx->stack[ctx->stack_len - 2] = t3;
	    ctx->stack[ctx->stack_len - 3] = t1;
	    goto no_push;
	  }

	case DW_OP_deref:
	case DW_OP_deref_size:
	case DW_OP_abs:
	case DW_OP_neg:
	case DW_OP_not:
	case DW_OP_plus_uconst:
	  /* Unary operations.  */
	  result = dwarf_expr_fetch (ctx, 0);
	  dwarf_expr_pop (ctx);

	  switch (op)
	    {
	    case DW_OP_deref:
	      {
		gdb_byte *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
		int bytes_read;

		(ctx->read_mem) (ctx->baton, buf, result,
				 TARGET_ADDR_BIT / TARGET_CHAR_BIT);
		result = dwarf2_read_address (buf,
					      buf + (TARGET_ADDR_BIT
						     / TARGET_CHAR_BIT),
					      &bytes_read);
	      }
	      break;

	    case DW_OP_deref_size:
	      {
		gdb_byte *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
		int bytes_read;

		(ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
		result = dwarf2_read_address (buf,
					      buf + (TARGET_ADDR_BIT
						     / TARGET_CHAR_BIT),
					      &bytes_read);
	      }
	      break;

	    case DW_OP_abs:
	      if ((signed int) result < 0)
		result = -result;
	      break;
	    case DW_OP_neg:
	      result = -result;
	      break;
	    case DW_OP_not:
	      result = ~result;
	      break;
	    case DW_OP_plus_uconst:
	      op_ptr = read_uleb128 (op_ptr, op_end, &reg);
	      result += reg;
	      break;
	    }
	  break;

	case DW_OP_and:
	case DW_OP_div:
	case DW_OP_minus:
	case DW_OP_mod:
	case DW_OP_mul:
	case DW_OP_or:
	case DW_OP_plus:
	case DW_OP_shl:
	case DW_OP_shr:
	case DW_OP_shra:
	case DW_OP_xor:
	case DW_OP_le:
	case DW_OP_ge:
	case DW_OP_eq:
	case DW_OP_lt:
	case DW_OP_gt:
	case DW_OP_ne:
	  {
	    /* Binary operations.  Use the value engine to do computations in
	       the right width.  */
	    CORE_ADDR first, second;
	    enum exp_opcode binop;
	    struct value *val1, *val2;

	    second = dwarf_expr_fetch (ctx, 0);
	    dwarf_expr_pop (ctx);

	    first = dwarf_expr_fetch (ctx, 0);
	    dwarf_expr_pop (ctx);

	    val1 = value_from_longest (unsigned_address_type (), first);
	    val2 = value_from_longest (unsigned_address_type (), second);

	    switch (op)
	      {
	      case DW_OP_and:
		binop = BINOP_BITWISE_AND;
		break;
	      case DW_OP_div:
		binop = BINOP_DIV;
                break;
	      case DW_OP_minus:
		binop = BINOP_SUB;
		break;
	      case DW_OP_mod:
		binop = BINOP_MOD;
		break;
	      case DW_OP_mul:
		binop = BINOP_MUL;
		break;
	      case DW_OP_or:
		binop = BINOP_BITWISE_IOR;
		break;
	      case DW_OP_plus:
		binop = BINOP_ADD;
		break;
	      case DW_OP_shl:
		binop = BINOP_LSH;
		break;
	      case DW_OP_shr:
		binop = BINOP_RSH;
                break;
	      case DW_OP_shra:
		binop = BINOP_RSH;
		val1 = value_from_longest (signed_address_type (), first);
		break;
	      case DW_OP_xor:
		binop = BINOP_BITWISE_XOR;
		break;
	      case DW_OP_le:
		binop = BINOP_LEQ;
		break;
	      case DW_OP_ge:
		binop = BINOP_GEQ;
		break;
	      case DW_OP_eq:
		binop = BINOP_EQUAL;
		break;
	      case DW_OP_lt:
		binop = BINOP_LESS;
		break;
	      case DW_OP_gt:
		binop = BINOP_GTR;
		break;
	      case DW_OP_ne:
		binop = BINOP_NOTEQUAL;
		break;
	      default:
		internal_error (__FILE__, __LINE__,
				_("Can't be reached."));
	      }
	    result = value_as_long (value_binop (val1, val2, binop));
	  }
	  break;

	case DW_OP_GNU_push_tls_address:
	  /* Variable is at a constant offset in the thread-local
	  storage block into the objfile for the current thread and
	  the dynamic linker module containing this expression. Here
	  we return returns the offset from that base.  The top of the
	  stack has the offset from the beginning of the thread
	  control block at which the variable is located.  Nothing
	  should follow this operator, so the top of stack would be
	  returned.  */
	  result = dwarf_expr_fetch (ctx, 0);
	  dwarf_expr_pop (ctx);
	  result = (ctx->get_tls_address) (ctx->baton, result);
	  break;

	case DW_OP_skip:
	  offset = extract_signed_integer (op_ptr, 2);
	  op_ptr += 2;
	  op_ptr += offset;
	  goto no_push;

	case DW_OP_bra:
	  offset = extract_signed_integer (op_ptr, 2);
	  op_ptr += 2;
	  if (dwarf_expr_fetch (ctx, 0) != 0)
	    op_ptr += offset;
	  dwarf_expr_pop (ctx);
	  goto no_push;

	case DW_OP_nop:
	  goto no_push;

        case DW_OP_piece:
          {
            ULONGEST size;
            CORE_ADDR addr_or_regnum;

            /* Record the piece.  */
            op_ptr = read_uleb128 (op_ptr, op_end, &size);
            addr_or_regnum = dwarf_expr_fetch (ctx, 0);
            add_piece (ctx, ctx->in_reg, addr_or_regnum, size);

            /* Pop off the address/regnum, and clear the in_reg flag.  */
            dwarf_expr_pop (ctx);
            ctx->in_reg = 0;
          }
          goto no_push;

	default:
	  error (_("Unhandled dwarf expression opcode 0x%x"), op);
	}

      /* Most things push a result value.  */
      dwarf_expr_push (ctx, result);
    no_push:;
    }
}
Commit	Line	Data
852483bc MK	1	/* DWARF 2 Expression Evaluator.
852483bc MK	2
197e01b6	3	Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
852483bc	4
4c2df51b DJ	5	Contributed by Daniel Berlin (dan@dberlin.org)
	6
	7	This file is part of GDB.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
197e01b6 EZ	21	Foundation, Inc., 51 Franklin Street, Fifth Floor,
197e01b6 EZ	22	Boston, MA 02110-1301, USA. */
4c2df51b DJ	23
	24	#include "defs.h"
	25	#include "symtab.h"
	26	#include "gdbtypes.h"
	27	#include "value.h"
	28	#include "gdbcore.h"
	29	#include "elf/dwarf2.h"
	30	#include "dwarf2expr.h"
	31
	32	/* Local prototypes. */
	33
	34	static void execute_stack_op (struct dwarf_expr_context *,
852483bc	35	gdb_byte , gdb_byte );
4c2df51b DJ	36
	37	/* Create a new context for the expression evaluator. */
	38
	39	struct dwarf_expr_context *
e4adbba9	40	new_dwarf_expr_context (void)
4c2df51b DJ	41	{
	42	struct dwarf_expr_context *retval;
	43	retval = xcalloc (1, sizeof (struct dwarf_expr_context));
18ec9831 KB	44	retval->stack_len = 0;
	45	retval->stack_allocated = 10;
	46	retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR));
87808bd6 JB	47	retval->num_pieces = 0;
87808bd6 JB	48	retval->pieces = 0;
4c2df51b DJ	49	return retval;
	50	}
	51
	52	/* Release the memory allocated to CTX. */
	53
	54	void
	55	free_dwarf_expr_context (struct dwarf_expr_context *ctx)
	56	{
	57	xfree (ctx->stack);
87808bd6	58	xfree (ctx->pieces);
4c2df51b DJ	59	xfree (ctx);
	60	}
	61
	62	/* Expand the memory allocated to CTX's stack to contain at least
	63	NEED more elements than are currently used. */
	64
	65	static void
	66	dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
	67	{
	68	if (ctx->stack_len + need > ctx->stack_allocated)
	69	{
18ec9831	70	size_t newlen = ctx->stack_len + need + 10;
4c2df51b	71	ctx->stack = xrealloc (ctx->stack,
18ec9831 KB	72	newlen * sizeof (CORE_ADDR));
18ec9831 KB	73	ctx->stack_allocated = newlen;
4c2df51b DJ	74	}
	75	}
	76
	77	/* Push VALUE onto CTX's stack. */
	78
	79	void
	80	dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
	81	{
	82	dwarf_expr_grow_stack (ctx, 1);
	83	ctx->stack[ctx->stack_len++] = value;
	84	}
	85
	86	/* Pop the top item off of CTX's stack. */
	87
	88	void
	89	dwarf_expr_pop (struct dwarf_expr_context *ctx)
	90	{
	91	if (ctx->stack_len <= 0)
8a3fe4f8	92	error (_("dwarf expression stack underflow"));
4c2df51b DJ	93	ctx->stack_len--;
	94	}
	95
	96	/* Retrieve the N'th item on CTX's stack. */
	97
	98	CORE_ADDR
	99	dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
	100	{
ef0fdf07	101	if (ctx->stack_len <= n)
8a3fe4f8	102	error (_("Asked for position %d of stack, stack only has %d elements on it."),
4c2df51b DJ	103	n, ctx->stack_len);
	104	return ctx->stack[ctx->stack_len - (1 + n)];
	105
	106	}
	107
87808bd6 JB	108	/* Add a new piece to CTX's piece list. */
	109	static void
	110	add_piece (struct dwarf_expr_context *ctx,
	111	int in_reg, CORE_ADDR value, ULONGEST size)
	112	{
	113	struct dwarf_expr_piece *p;
	114
	115	ctx->num_pieces++;
	116
	117	if (ctx->pieces)
	118	ctx->pieces = xrealloc (ctx->pieces,
	119	(ctx->num_pieces
	120	* sizeof (struct dwarf_expr_piece)));
	121	else
	122	ctx->pieces = xmalloc (ctx->num_pieces
	123	* sizeof (struct dwarf_expr_piece));
	124
	125	p = &ctx->pieces[ctx->num_pieces - 1];
	126	p->in_reg = in_reg;
	127	p->value = value;
	128	p->size = size;
	129	}
	130
4c2df51b DJ	131	/* Evaluate the expression at ADDR (LEN bytes long) using the context
	132	CTX. */
	133
	134	void
852483bc	135	dwarf_expr_eval (struct dwarf_expr_context ctx, gdb_byte addr, size_t len)
4c2df51b DJ	136	{
	137	execute_stack_op (ctx, addr, addr + len);
	138	}
	139
	140	/* Decode the unsigned LEB128 constant at BUF into the variable pointed to
	141	by R, and return the new value of BUF. Verify that it doesn't extend
	142	past BUF_END. */
	143
852483bc MK	144	gdb_byte *
852483bc MK	145	read_uleb128 (gdb_byte buf, gdb_byte buf_end, ULONGEST * r)
4c2df51b DJ	146	{
	147	unsigned shift = 0;
	148	ULONGEST result = 0;
852483bc	149	gdb_byte byte;
4c2df51b DJ	150
	151	while (1)
	152	{
	153	if (buf >= buf_end)
8a3fe4f8	154	error (_("read_uleb128: Corrupted DWARF expression."));
4c2df51b DJ	155
	156	byte = *buf++;
	157	result \|= (byte & 0x7f) << shift;
	158	if ((byte & 0x80) == 0)
	159	break;
	160	shift += 7;
	161	}
	162	*r = result;
	163	return buf;
	164	}
	165
	166	/* Decode the signed LEB128 constant at BUF into the variable pointed to
	167	by R, and return the new value of BUF. Verify that it doesn't extend
	168	past BUF_END. */
	169
852483bc MK	170	gdb_byte *
852483bc MK	171	read_sleb128 (gdb_byte buf, gdb_byte buf_end, LONGEST * r)
4c2df51b DJ	172	{
	173	unsigned shift = 0;
	174	LONGEST result = 0;
852483bc	175	gdb_byte byte;
4c2df51b DJ	176
	177	while (1)
	178	{
	179	if (buf >= buf_end)
8a3fe4f8	180	error (_("read_sleb128: Corrupted DWARF expression."));
4c2df51b DJ	181
	182	byte = *buf++;
	183	result \|= (byte & 0x7f) << shift;
	184	shift += 7;
	185	if ((byte & 0x80) == 0)
	186	break;
	187	}
	188	if (shift < (sizeof (r) 8) && (byte & 0x40) != 0)
	189	result \|= -(1 << shift);
	190
	191	*r = result;
	192	return buf;
	193	}
	194
	195	/* Read an address from BUF, and verify that it doesn't extend past
	196	BUF_END. The address is returned, and *BYTES_READ is set to the
	197	number of bytes read from BUF. */
	198
0d53c4c4	199	CORE_ADDR
852483bc	200	dwarf2_read_address (gdb_byte buf, gdb_byte buf_end, int *bytes_read)
4c2df51b DJ	201	{
	202	CORE_ADDR result;
	203
	204	if (buf_end - buf < TARGET_ADDR_BIT / TARGET_CHAR_BIT)
8a3fe4f8	205	error (_("dwarf2_read_address: Corrupted DWARF expression."));
4c2df51b DJ	206
4c2df51b DJ	207	*bytes_read = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
af1342ab AC	208	/* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
	209	address is always unsigned. That may or may not be true. */
	210	result = extract_unsigned_integer (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT);
4c2df51b DJ	211	return result;
	212	}
	213
	214	/* Return the type of an address, for unsigned arithmetic. */
	215
	216	static struct type *
	217	unsigned_address_type (void)
	218	{
	219	switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
	220	{
	221	case 2:
	222	return builtin_type_uint16;
	223	case 4:
	224	return builtin_type_uint32;
	225	case 8:
	226	return builtin_type_uint64;
	227	default:
	228	internal_error (__FILE__, __LINE__,
e2e0b3e5	229	_("Unsupported address size.\n"));
4c2df51b DJ	230	}
	231	}
	232
	233	/* Return the type of an address, for signed arithmetic. */
	234
	235	static struct type *
	236	signed_address_type (void)
	237	{
	238	switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
	239	{
	240	case 2:
	241	return builtin_type_int16;
	242	case 4:
	243	return builtin_type_int32;
	244	case 8:
	245	return builtin_type_int64;
	246	default:
	247	internal_error (__FILE__, __LINE__,
e2e0b3e5	248	_("Unsupported address size.\n"));
4c2df51b DJ	249	}
	250	}
	251	\f
	252	/* The engine for the expression evaluator. Using the context in CTX,
	253	evaluate the expression between OP_PTR and OP_END. */
	254
	255	static void
852483bc MK	256	execute_stack_op (struct dwarf_expr_context *ctx,
852483bc MK	257	gdb_byte op_ptr, gdb_byte op_end)
4c2df51b	258	{
18ec9831 KB	259	ctx->in_reg = 0;
18ec9831 KB	260
4c2df51b DJ	261	while (op_ptr < op_end)
	262	{
	263	enum dwarf_location_atom op = *op_ptr++;
61fbb938	264	CORE_ADDR result;
4c2df51b DJ	265	ULONGEST uoffset, reg;
	266	LONGEST offset;
	267	int bytes_read;
4c2df51b	268
4c2df51b DJ	269	switch (op)
	270	{
	271	case DW_OP_lit0:
	272	case DW_OP_lit1:
	273	case DW_OP_lit2:
	274	case DW_OP_lit3:
	275	case DW_OP_lit4:
	276	case DW_OP_lit5:
	277	case DW_OP_lit6:
	278	case DW_OP_lit7:
	279	case DW_OP_lit8:
	280	case DW_OP_lit9:
	281	case DW_OP_lit10:
	282	case DW_OP_lit11:
	283	case DW_OP_lit12:
	284	case DW_OP_lit13:
	285	case DW_OP_lit14:
	286	case DW_OP_lit15:
	287	case DW_OP_lit16:
	288	case DW_OP_lit17:
	289	case DW_OP_lit18:
	290	case DW_OP_lit19:
	291	case DW_OP_lit20:
	292	case DW_OP_lit21:
	293	case DW_OP_lit22:
	294	case DW_OP_lit23:
	295	case DW_OP_lit24:
	296	case DW_OP_lit25:
	297	case DW_OP_lit26:
	298	case DW_OP_lit27:
	299	case DW_OP_lit28:
	300	case DW_OP_lit29:
	301	case DW_OP_lit30:
	302	case DW_OP_lit31:
	303	result = op - DW_OP_lit0;
	304	break;
	305
	306	case DW_OP_addr:
0d53c4c4	307	result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
4c2df51b DJ	308	op_ptr += bytes_read;
	309	break;
	310
	311	case DW_OP_const1u:
	312	result = extract_unsigned_integer (op_ptr, 1);
	313	op_ptr += 1;
	314	break;
	315	case DW_OP_const1s:
	316	result = extract_signed_integer (op_ptr, 1);
	317	op_ptr += 1;
	318	break;
	319	case DW_OP_const2u:
	320	result = extract_unsigned_integer (op_ptr, 2);
	321	op_ptr += 2;
	322	break;
	323	case DW_OP_const2s:
	324	result = extract_signed_integer (op_ptr, 2);
	325	op_ptr += 2;
	326	break;
	327	case DW_OP_const4u:
	328	result = extract_unsigned_integer (op_ptr, 4);
	329	op_ptr += 4;
	330	break;
	331	case DW_OP_const4s:
	332	result = extract_signed_integer (op_ptr, 4);
	333	op_ptr += 4;
	334	break;
	335	case DW_OP_const8u:
	336	result = extract_unsigned_integer (op_ptr, 8);
	337	op_ptr += 8;
	338	break;
	339	case DW_OP_const8s:
	340	result = extract_signed_integer (op_ptr, 8);
	341	op_ptr += 8;
	342	break;
	343	case DW_OP_constu:
	344	op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
	345	result = uoffset;
	346	break;
	347	case DW_OP_consts:
	348	op_ptr = read_sleb128 (op_ptr, op_end, &offset);
	349	result = offset;
	350	break;
	351
	352	/* The DW_OP_reg operations are required to occur alone in
	353	location expressions. */
	354	case DW_OP_reg0:
	355	case DW_OP_reg1:
	356	case DW_OP_reg2:
	357	case DW_OP_reg3:
	358	case DW_OP_reg4:
	359	case DW_OP_reg5:
	360	case DW_OP_reg6:
	361	case DW_OP_reg7:
	362	case DW_OP_reg8:
	363	case DW_OP_reg9:
	364	case DW_OP_reg10:
	365	case DW_OP_reg11:
	366	case DW_OP_reg12:
	367	case DW_OP_reg13:
	368	case DW_OP_reg14:
	369	case DW_OP_reg15:
	370	case DW_OP_reg16:
	371	case DW_OP_reg17:
372	case DW_OP_reg18:
373	case DW_OP_reg19:
374	case DW_OP_reg20:
375	case DW_OP_reg21:
376	case DW_OP_reg22:
377	case DW_OP_reg23:
378	case DW_OP_reg24:
379	case DW_OP_reg25:
380	case DW_OP_reg26:
381	case DW_OP_reg27:
382	case DW_OP_reg28:
383	case DW_OP_reg29:
384	case DW_OP_reg30:
385	case DW_OP_reg31:
18ec9831	386	if (op_ptr != op_end && *op_ptr != DW_OP_piece)
8a3fe4f8 AC	387	error (_("DWARF-2 expression error: DW_OP_reg operations must be "
8a3fe4f8 AC	388	"used either alone or in conjuction with DW_OP_piece."));
4c2df51b	389
61fbb938 DJ	390	result = op - DW_OP_reg0;
61fbb938 DJ	391	ctx->in_reg = 1;
4c2df51b DJ	392
	393	break;
	394
	395	case DW_OP_regx:
	396	op_ptr = read_uleb128 (op_ptr, op_end, &reg);
18ec9831	397	if (op_ptr != op_end && *op_ptr != DW_OP_piece)
8a3fe4f8 AC	398	error (_("DWARF-2 expression error: DW_OP_reg operations must be "
8a3fe4f8 AC	399	"used either alone or in conjuction with DW_OP_piece."));
4c2df51b	400
61fbb938 DJ	401	result = reg;
61fbb938 DJ	402	ctx->in_reg = 1;
4c2df51b DJ	403	break;
	404
	405	case DW_OP_breg0:
	406	case DW_OP_breg1:
	407	case DW_OP_breg2:
	408	case DW_OP_breg3:
	409	case DW_OP_breg4:
	410	case DW_OP_breg5:
	411	case DW_OP_breg6:
	412	case DW_OP_breg7:
	413	case DW_OP_breg8:
	414	case DW_OP_breg9:
	415	case DW_OP_breg10:
	416	case DW_OP_breg11:
	417	case DW_OP_breg12:
	418	case DW_OP_breg13:
	419	case DW_OP_breg14:
	420	case DW_OP_breg15:
	421	case DW_OP_breg16:
	422	case DW_OP_breg17:
	423	case DW_OP_breg18:
	424	case DW_OP_breg19:
	425	case DW_OP_breg20:
	426	case DW_OP_breg21:
	427	case DW_OP_breg22:
	428	case DW_OP_breg23:
	429	case DW_OP_breg24:
	430	case DW_OP_breg25:
	431	case DW_OP_breg26:
	432	case DW_OP_breg27:
	433	case DW_OP_breg28:
	434	case DW_OP_breg29:
	435	case DW_OP_breg30:
	436	case DW_OP_breg31:
	437	{
	438	op_ptr = read_sleb128 (op_ptr, op_end, &offset);
61fbb938	439	result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
4c2df51b DJ	440	result += offset;
	441	}
	442	break;
	443	case DW_OP_bregx:
	444	{
	445	op_ptr = read_uleb128 (op_ptr, op_end, &reg);
	446	op_ptr = read_sleb128 (op_ptr, op_end, &offset);
61fbb938	447	result = (ctx->read_reg) (ctx->baton, reg);
4c2df51b DJ	448	result += offset;
	449	}
	450	break;
	451	case DW_OP_fbreg:
	452	{
852483bc	453	gdb_byte *datastart;
4c2df51b DJ	454	size_t datalen;
	455	unsigned int before_stack_len;
	456
	457	op_ptr = read_sleb128 (op_ptr, op_end, &offset);
	458	/* Rather than create a whole new context, we simply
	459	record the stack length before execution, then reset it
	460	afterwards, effectively erasing whatever the recursive
	461	call put there. */
	462	before_stack_len = ctx->stack_len;
da62e633 AC	463	/* FIXME: cagney/2003-03-26: This code should be using
	464	get_frame_base_address(), and then implement a dwarf2
	465	specific this_base method. */
4c2df51b DJ	466	(ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
	467	dwarf_expr_eval (ctx, datastart, datalen);
	468	result = dwarf_expr_fetch (ctx, 0);
61fbb938 DJ	469	if (ctx->in_reg)
61fbb938 DJ	470	result = (ctx->read_reg) (ctx->baton, result);
4c2df51b DJ	471	result = result + offset;
	472	ctx->stack_len = before_stack_len;
	473	ctx->in_reg = 0;
	474	}
	475	break;
	476	case DW_OP_dup:
	477	result = dwarf_expr_fetch (ctx, 0);
	478	break;
	479
	480	case DW_OP_drop:
	481	dwarf_expr_pop (ctx);
	482	goto no_push;
	483
	484	case DW_OP_pick:
	485	offset = *op_ptr++;
	486	result = dwarf_expr_fetch (ctx, offset);
	487	break;
	488
	489	case DW_OP_over:
	490	result = dwarf_expr_fetch (ctx, 1);
	491	break;
	492
	493	case DW_OP_rot:
	494	{
	495	CORE_ADDR t1, t2, t3;
	496
	497	if (ctx->stack_len < 3)
8a3fe4f8	498	error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
4c2df51b DJ	499	ctx->stack_len);
	500	t1 = ctx->stack[ctx->stack_len - 1];
	501	t2 = ctx->stack[ctx->stack_len - 2];
	502	t3 = ctx->stack[ctx->stack_len - 3];
	503	ctx->stack[ctx->stack_len - 1] = t2;
	504	ctx->stack[ctx->stack_len - 2] = t3;
	505	ctx->stack[ctx->stack_len - 3] = t1;
	506	goto no_push;
	507	}
	508
	509	case DW_OP_deref:
	510	case DW_OP_deref_size:
	511	case DW_OP_abs:
	512	case DW_OP_neg:
	513	case DW_OP_not:
	514	case DW_OP_plus_uconst:
	515	/* Unary operations. */
	516	result = dwarf_expr_fetch (ctx, 0);
	517	dwarf_expr_pop (ctx);
	518
	519	switch (op)
	520	{
	521	case DW_OP_deref:
	522	{
852483bc	523	gdb_byte *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
4c2df51b DJ	524	int bytes_read;
	525
	526	(ctx->read_mem) (ctx->baton, buf, result,
	527	TARGET_ADDR_BIT / TARGET_CHAR_BIT);
0d53c4c4 DJ	528	result = dwarf2_read_address (buf,
	529	buf + (TARGET_ADDR_BIT
	530	/ TARGET_CHAR_BIT),
	531	&bytes_read);
4c2df51b DJ	532	}
	533	break;
	534
	535	case DW_OP_deref_size:
	536	{
852483bc	537	gdb_byte *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
4c2df51b DJ	538	int bytes_read;
	539
	540	(ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
0d53c4c4 DJ	541	result = dwarf2_read_address (buf,
	542	buf + (TARGET_ADDR_BIT
	543	/ TARGET_CHAR_BIT),
	544	&bytes_read);
4c2df51b DJ	545	}
	546	break;
	547
	548	case DW_OP_abs:
	549	if ((signed int) result < 0)
	550	result = -result;
	551	break;
	552	case DW_OP_neg:
	553	result = -result;
	554	break;
	555	case DW_OP_not:
	556	result = ~result;
	557	break;
	558	case DW_OP_plus_uconst:
	559	op_ptr = read_uleb128 (op_ptr, op_end, &reg);
	560	result += reg;
	561	break;
	562	}
	563	break;
	564
	565	case DW_OP_and:
	566	case DW_OP_div:
	567	case DW_OP_minus:
	568	case DW_OP_mod:
	569	case DW_OP_mul:
	570	case DW_OP_or:
	571	case DW_OP_plus:
	572	case DW_OP_shl:
	573	case DW_OP_shr:
	574	case DW_OP_shra:
	575	case DW_OP_xor:
	576	case DW_OP_le:
	577	case DW_OP_ge:
	578	case DW_OP_eq:
	579	case DW_OP_lt:
	580	case DW_OP_gt:
	581	case DW_OP_ne:
	582	{
	583	/* Binary operations. Use the value engine to do computations in
	584	the right width. */
	585	CORE_ADDR first, second;
	586	enum exp_opcode binop;
	587	struct value val1, val2;
	588
	589	second = dwarf_expr_fetch (ctx, 0);
	590	dwarf_expr_pop (ctx);
	591
b263358a	592	first = dwarf_expr_fetch (ctx, 0);
4c2df51b DJ	593	dwarf_expr_pop (ctx);
	594
	595	val1 = value_from_longest (unsigned_address_type (), first);
	596	val2 = value_from_longest (unsigned_address_type (), second);
	597
	598	switch (op)
	599	{
	600	case DW_OP_and:
	601	binop = BINOP_BITWISE_AND;
	602	break;
	603	case DW_OP_div:
	604	binop = BINOP_DIV;
99c87dab	605	break;
4c2df51b DJ	606	case DW_OP_minus:
	607	binop = BINOP_SUB;
	608	break;
	609	case DW_OP_mod:
	610	binop = BINOP_MOD;
	611	break;
	612	case DW_OP_mul:
	613	binop = BINOP_MUL;
	614	break;
	615	case DW_OP_or:
	616	binop = BINOP_BITWISE_IOR;
	617	break;
	618	case DW_OP_plus:
	619	binop = BINOP_ADD;
	620	break;
	621	case DW_OP_shl:
	622	binop = BINOP_LSH;
	623	break;
	624	case DW_OP_shr:
	625	binop = BINOP_RSH;
99c87dab	626	break;
4c2df51b DJ	627	case DW_OP_shra:
	628	binop = BINOP_RSH;
	629	val1 = value_from_longest (signed_address_type (), first);
	630	break;
	631	case DW_OP_xor:
	632	binop = BINOP_BITWISE_XOR;
	633	break;
	634	case DW_OP_le:
	635	binop = BINOP_LEQ;
	636	break;
	637	case DW_OP_ge:
	638	binop = BINOP_GEQ;
	639	break;
	640	case DW_OP_eq:
	641	binop = BINOP_EQUAL;
	642	break;
	643	case DW_OP_lt:
	644	binop = BINOP_LESS;
	645	break;
	646	case DW_OP_gt:
	647	binop = BINOP_GTR;
	648	break;
	649	case DW_OP_ne:
	650	binop = BINOP_NOTEQUAL;
	651	break;
	652	default:
	653	internal_error (__FILE__, __LINE__,
e2e0b3e5	654	_("Can't be reached."));
4c2df51b DJ	655	}
	656	result = value_as_long (value_binop (val1, val2, binop));
	657	}
	658	break;
	659
	660	case DW_OP_GNU_push_tls_address:
c3228f12 EZ	661	/* Variable is at a constant offset in the thread-local
	662	storage block into the objfile for the current thread and
	663	the dynamic linker module containing this expression. Here
	664	we return returns the offset from that base. The top of the
	665	stack has the offset from the beginning of the thread
	666	control block at which the variable is located. Nothing
	667	should follow this operator, so the top of stack would be
	668	returned. */
4c2df51b DJ	669	result = dwarf_expr_fetch (ctx, 0);
	670	dwarf_expr_pop (ctx);
	671	result = (ctx->get_tls_address) (ctx->baton, result);
	672	break;
	673
	674	case DW_OP_skip:
	675	offset = extract_signed_integer (op_ptr, 2);
	676	op_ptr += 2;
	677	op_ptr += offset;
	678	goto no_push;
	679
	680	case DW_OP_bra:
	681	offset = extract_signed_integer (op_ptr, 2);
	682	op_ptr += 2;
	683	if (dwarf_expr_fetch (ctx, 0) != 0)
	684	op_ptr += offset;
	685	dwarf_expr_pop (ctx);
	686	goto no_push;
	687
	688	case DW_OP_nop:
	689	goto no_push;
	690
87808bd6 JB	691	case DW_OP_piece:
	692	{
	693	ULONGEST size;
	694	CORE_ADDR addr_or_regnum;
	695
	696	/* Record the piece. */
	697	op_ptr = read_uleb128 (op_ptr, op_end, &size);
	698	addr_or_regnum = dwarf_expr_fetch (ctx, 0);
	699	add_piece (ctx, ctx->in_reg, addr_or_regnum, size);
	700
	701	/* Pop off the address/regnum, and clear the in_reg flag. */
	702	dwarf_expr_pop (ctx);
	703	ctx->in_reg = 0;
	704	}
	705	goto no_push;
	706
4c2df51b	707	default:
8a3fe4f8	708	error (_("Unhandled dwarf expression opcode 0x%x"), op);
4c2df51b DJ	709	}
	710
	711	/* Most things push a result value. */
	712	dwarf_expr_push (ctx, result);
	713	no_push:;
	714	}
	715	}