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

/* DWARF 2 Expression Evaluator.

   Copyright (C) 2001, 2002, 2003, 2005, 2007, 2008
   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 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 "gdbtypes.h"
#include "value.h"
#include "gdbcore.h"
#include "elf/dwarf2.h"
#include "dwarf2expr.h"
#include "gdb_assert.h"

/* Local prototypes.  */

static void execute_stack_op (struct dwarf_expr_context *,
			      gdb_byte *, gdb_byte *);
static struct type *unsigned_address_type (int);

/* 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;
  retval->max_recursion_depth = 0x100;
  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)
{
  int old_recursion_depth = ctx->recursion_depth;

  execute_stack_op (ctx, addr, addr + len);

  /* CTX RECURSION_DEPTH becomes invalid if an exception was thrown here.  */

  gdb_assert (ctx->recursion_depth == old_recursion_depth);
}

/* 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 of size ADDR_SIZE from BUF, and verify that it
   doesn't extend past BUF_END.  */

CORE_ADDR
dwarf2_read_address (struct gdbarch *gdbarch, gdb_byte *buf,
		     gdb_byte *buf_end, int addr_size)
{
  CORE_ADDR result;

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

  /* For most architectures, calling extract_unsigned_integer() alone
     is sufficient for extracting an address.  However, some
     architectures (e.g. MIPS) use signed addresses and using
     extract_unsigned_integer() will not produce a correct
     result.  Make sure we invoke gdbarch_integer_to_address()
     for those architectures which require it.

     The use of `unsigned_address_type' in the code below refers to
     the type of buf and has no bearing on the signedness of the
     address being returned.  */

  if (gdbarch_integer_to_address_p (gdbarch))
    return gdbarch_integer_to_address
	     (gdbarch, unsigned_address_type (addr_size), buf);

  return extract_unsigned_integer (buf, addr_size);
}

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

static struct type *
unsigned_address_type (int addr_size)
{
  switch (addr_size)
    {
    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 of size ADDR_SIZE,
   for signed arithmetic.  */

static struct type *
signed_address_type (int addr_size)
{
  switch (addr_size)
    {
    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;
  ctx->initialized = 1;  /* Default is initialized.  */

  if (ctx->recursion_depth > ctx->max_recursion_depth)
    error (_("DWARF-2 expression error: Loop detected (%d)."),
	   ctx->recursion_depth);
  ctx->recursion_depth++;

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

      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 (ctx->gdbarch,
					op_ptr, op_end, ctx->addr_size);
	  op_ptr += ctx->addr_size;
	  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
	      && *op_ptr != DW_OP_GNU_uninit)
	    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 (ctx->addr_size);
		(ctx->read_mem) (ctx->baton, buf, result, ctx->addr_size);
		result = dwarf2_read_address (ctx->gdbarch,
					      buf, buf + ctx->addr_size,
					      ctx->addr_size);
	      }
	      break;

	    case DW_OP_deref_size:
	      {
		int addr_size = *op_ptr++;
		gdb_byte *buf = alloca (addr_size);
		(ctx->read_mem) (ctx->baton, buf, result, addr_size);
		result = dwarf2_read_address (ctx->gdbarch,
					      buf, buf + addr_size,
					      addr_size);
	      }
	      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 (ctx->addr_size), first);
	    val2 = value_from_longest
		     (unsigned_address_type (ctx->addr_size), 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 (ctx->addr_size), 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;

	case DW_OP_GNU_uninit:
	  if (op_ptr != op_end)
	    error (_("DWARF-2 expression error: DW_OP_GNU_unint must always "
		   "be the very last op."));

	  ctx->initialized = 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:;
    }

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