[binutils.git] / gdb / dwarf2expr.c

/* DWARF 2 Expression Evaluator.

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

   Contributed by Daniel Berlin ([email protected])

   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 (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.  Turning the unsigned integer into a value and then
     decomposing that value as an address will cause
     gdbarch_integer_to_address() to be invoked for those
     architectures which require it.  Thus, using value_as_address()
     will produce the correct result for both types of architectures.

     One concern regarding the use of values for this purpose is
     efficiency.  Obviously, these extra calls will take more time to
     execute and creating a value takes more space, space which will
     have to be garbage collected at a later time.  If constructing
     and then decomposing a value for this purpose proves to be too
     inefficient, then gdbarch_integer_to_address() can be called
     directly.

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

  result = value_as_address (value_from_longest 
			      (unsigned_address_type (addr_size),
			       extract_unsigned_integer (buf, addr_size)));
  return result;
}

/* 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 (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 (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 (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 ([email protected])
	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
ae0d2f24	207	dwarf2_read_address (gdb_byte buf, gdb_byte buf_end, int addr_size)
4c2df51b DJ	208	{
	209	CORE_ADDR result;
	210
ae0d2f24	211	if (buf_end - buf < addr_size)
8a3fe4f8	212	error (_("dwarf2_read_address: Corrupted DWARF expression."));
4c2df51b	213
ace186d4 KB	214	/* For most architectures, calling extract_unsigned_integer() alone
	215	is sufficient for extracting an address. However, some
	216	architectures (e.g. MIPS) use signed addresses and using
	217	extract_unsigned_integer() will not produce a correct
	218	result. Turning the unsigned integer into a value and then
	219	decomposing that value as an address will cause
	220	gdbarch_integer_to_address() to be invoked for those
	221	architectures which require it. Thus, using value_as_address()
	222	will produce the correct result for both types of architectures.
	223
	224	One concern regarding the use of values for this purpose is
	225	efficiency. Obviously, these extra calls will take more time to
	226	execute and creating a value takes more space, space which will
	227	have to be garbage collected at a later time. If constructing
	228	and then decomposing a value for this purpose proves to be too
	229	inefficient, then gdbarch_integer_to_address() can be called
	230	directly.
	231
	232	The use of `unsigned_address_type' in the code below refers to
	233	the type of buf and has no bearing on the signedness of the
	234	address being returned. */
	235
	236	result = value_as_address (value_from_longest
ae0d2f24 UW	237	(unsigned_address_type (addr_size),
ae0d2f24 UW	238	extract_unsigned_integer (buf, addr_size)));
4c2df51b DJ	239	return result;
	240	}
	241
ae0d2f24 UW	242	/* Return the type of an address of size ADDR_SIZE,
ae0d2f24 UW	243	for unsigned arithmetic. */
4c2df51b DJ	244
4c2df51b DJ	245	static struct type *
ae0d2f24	246	unsigned_address_type (int addr_size)
4c2df51b	247	{
ae0d2f24	248	switch (addr_size)
4c2df51b DJ	249	{
	250	case 2:
	251	return builtin_type_uint16;
	252	case 4:
	253	return builtin_type_uint32;
	254	case 8:
	255	return builtin_type_uint64;
	256	default:
	257	internal_error (__FILE__, __LINE__,
e2e0b3e5	258	_("Unsupported address size.\n"));
4c2df51b DJ	259	}
	260	}
	261
ae0d2f24 UW	262	/* Return the type of an address of size ADDR_SIZE,
ae0d2f24 UW	263	for signed arithmetic. */
4c2df51b DJ	264
4c2df51b DJ	265	static struct type *
ae0d2f24	266	signed_address_type (int addr_size)
4c2df51b	267	{
ae0d2f24	268	switch (addr_size)
4c2df51b DJ	269	{
	270	case 2:
	271	return builtin_type_int16;
	272	case 4:
	273	return builtin_type_int32;
	274	case 8:
	275	return builtin_type_int64;
	276	default:
	277	internal_error (__FILE__, __LINE__,
e2e0b3e5	278	_("Unsupported address size.\n"));
4c2df51b DJ	279	}
	280	}
	281	\f
	282	/* The engine for the expression evaluator. Using the context in CTX,
	283	evaluate the expression between OP_PTR and OP_END. */
	284
	285	static void
852483bc MK	286	execute_stack_op (struct dwarf_expr_context *ctx,
852483bc MK	287	gdb_byte op_ptr, gdb_byte op_end)
4c2df51b	288	{
18ec9831	289	ctx->in_reg = 0;
42be36b3	290	ctx->initialized = 1; /* Default is initialized. */
18ec9831	291
1e3a102a JK	292	if (ctx->recursion_depth > ctx->max_recursion_depth)
	293	error (_("DWARF-2 expression error: Loop detected (%d)."),
	294	ctx->recursion_depth);
	295	ctx->recursion_depth++;
	296
4c2df51b DJ	297	while (op_ptr < op_end)
	298	{
	299	enum dwarf_location_atom op = *op_ptr++;
61fbb938	300	CORE_ADDR result;
4c2df51b DJ	301	ULONGEST uoffset, reg;
4c2df51b DJ	302	LONGEST offset;
4c2df51b	303
4c2df51b DJ	304	switch (op)
	305	{
	306	case DW_OP_lit0:
	307	case DW_OP_lit1:
	308	case DW_OP_lit2:
	309	case DW_OP_lit3:
	310	case DW_OP_lit4:
	311	case DW_OP_lit5:
	312	case DW_OP_lit6:
	313	case DW_OP_lit7:
	314	case DW_OP_lit8:
	315	case DW_OP_lit9:
	316	case DW_OP_lit10:
	317	case DW_OP_lit11:
	318	case DW_OP_lit12:
	319	case DW_OP_lit13:
	320	case DW_OP_lit14:
	321	case DW_OP_lit15:
	322	case DW_OP_lit16:
	323	case DW_OP_lit17:
	324	case DW_OP_lit18:
	325	case DW_OP_lit19:
	326	case DW_OP_lit20:
	327	case DW_OP_lit21:
	328	case DW_OP_lit22:
	329	case DW_OP_lit23:
	330	case DW_OP_lit24:
	331	case DW_OP_lit25:
	332	case DW_OP_lit26:
	333	case DW_OP_lit27:
	334	case DW_OP_lit28:
	335	case DW_OP_lit29:
	336	case DW_OP_lit30:
	337	case DW_OP_lit31:
	338	result = op - DW_OP_lit0;
	339	break;
	340
	341	case DW_OP_addr:
ae0d2f24 UW	342	result = dwarf2_read_address (op_ptr, op_end, ctx->addr_size);
ae0d2f24 UW	343	op_ptr += ctx->addr_size;
4c2df51b DJ	344	break;
	345
	346	case DW_OP_const1u:
	347	result = extract_unsigned_integer (op_ptr, 1);
	348	op_ptr += 1;
	349	break;
	350	case DW_OP_const1s:
	351	result = extract_signed_integer (op_ptr, 1);
	352	op_ptr += 1;
	353	break;
	354	case DW_OP_const2u:
	355	result = extract_unsigned_integer (op_ptr, 2);
	356	op_ptr += 2;
	357	break;
	358	case DW_OP_const2s:
	359	result = extract_signed_integer (op_ptr, 2);
	360	op_ptr += 2;
	361	break;
	362	case DW_OP_const4u:
	363	result = extract_unsigned_integer (op_ptr, 4);
	364	op_ptr += 4;
	365	break;
	366	case DW_OP_const4s:
	367	result = extract_signed_integer (op_ptr, 4);
	368	op_ptr += 4;
	369	break;
	370	case DW_OP_const8u:
	371	result = extract_unsigned_integer (op_ptr, 8);
	372	op_ptr += 8;
	373	break;
	374	case DW_OP_const8s:
	375	result = extract_signed_integer (op_ptr, 8);
	376	op_ptr += 8;
	377	break;
	378	case DW_OP_constu:
	379	op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
	380	result = uoffset;
	381	break;
	382	case DW_OP_consts:
	383	op_ptr = read_sleb128 (op_ptr, op_end, &offset);
	384	result = offset;
	385	break;
	386
	387	/* The DW_OP_reg operations are required to occur alone in
	388	location expressions. */
	389	case DW_OP_reg0:
	390	case DW_OP_reg1:
	391	case DW_OP_reg2:
	392	case DW_OP_reg3:
	393	case DW_OP_reg4:
	394	case DW_OP_reg5:
	395	case DW_OP_reg6:
	396	case DW_OP_reg7:
	397	case DW_OP_reg8:
	398	case DW_OP_reg9:
	399	case DW_OP_reg10:
	400	case DW_OP_reg11:
	401	case DW_OP_reg12:
	402	case DW_OP_reg13:
	403	case DW_OP_reg14:
	404	case DW_OP_reg15:
	405	case DW_OP_reg16:
	406	case DW_OP_reg17:
	407	case DW_OP_reg18:
408	case DW_OP_reg19:
409	case DW_OP_reg20:
410	case DW_OP_reg21:
411	case DW_OP_reg22:
412	case DW_OP_reg23:
413	case DW_OP_reg24:
414	case DW_OP_reg25:
415	case DW_OP_reg26:
416	case DW_OP_reg27:
417	case DW_OP_reg28:
418	case DW_OP_reg29:
419	case DW_OP_reg30:
420	case DW_OP_reg31:
42be36b3 CT	421	if (op_ptr != op_end
	422	&& *op_ptr != DW_OP_piece
	423	&& *op_ptr != DW_OP_GNU_uninit)
8a3fe4f8 AC	424	error (_("DWARF-2 expression error: DW_OP_reg operations must be "
8a3fe4f8 AC	425	"used either alone or in conjuction with DW_OP_piece."));
4c2df51b	426
61fbb938 DJ	427	result = op - DW_OP_reg0;
61fbb938 DJ	428	ctx->in_reg = 1;
4c2df51b DJ	429
	430	break;
	431
	432	case DW_OP_regx:
	433	op_ptr = read_uleb128 (op_ptr, op_end, &reg);
18ec9831	434	if (op_ptr != op_end && *op_ptr != DW_OP_piece)
8a3fe4f8 AC	435	error (_("DWARF-2 expression error: DW_OP_reg operations must be "
8a3fe4f8 AC	436	"used either alone or in conjuction with DW_OP_piece."));
4c2df51b	437
61fbb938 DJ	438	result = reg;
61fbb938 DJ	439	ctx->in_reg = 1;
4c2df51b DJ	440	break;
	441
	442	case DW_OP_breg0:
	443	case DW_OP_breg1:
	444	case DW_OP_breg2:
	445	case DW_OP_breg3:
	446	case DW_OP_breg4:
	447	case DW_OP_breg5:
	448	case DW_OP_breg6:
	449	case DW_OP_breg7:
	450	case DW_OP_breg8:
	451	case DW_OP_breg9:
	452	case DW_OP_breg10:
	453	case DW_OP_breg11:
	454	case DW_OP_breg12:
	455	case DW_OP_breg13:
	456	case DW_OP_breg14:
	457	case DW_OP_breg15:
	458	case DW_OP_breg16:
	459	case DW_OP_breg17:
	460	case DW_OP_breg18:
	461	case DW_OP_breg19:
	462	case DW_OP_breg20:
	463	case DW_OP_breg21:
	464	case DW_OP_breg22:
	465	case DW_OP_breg23:
	466	case DW_OP_breg24:
	467	case DW_OP_breg25:
	468	case DW_OP_breg26:
	469	case DW_OP_breg27:
	470	case DW_OP_breg28:
	471	case DW_OP_breg29:
	472	case DW_OP_breg30:
	473	case DW_OP_breg31:
	474	{
	475	op_ptr = read_sleb128 (op_ptr, op_end, &offset);
61fbb938	476	result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
4c2df51b DJ	477	result += offset;
	478	}
	479	break;
	480	case DW_OP_bregx:
	481	{
	482	op_ptr = read_uleb128 (op_ptr, op_end, &reg);
	483	op_ptr = read_sleb128 (op_ptr, op_end, &offset);
61fbb938	484	result = (ctx->read_reg) (ctx->baton, reg);
4c2df51b DJ	485	result += offset;
	486	}
	487	break;
	488	case DW_OP_fbreg:
	489	{
852483bc	490	gdb_byte *datastart;
4c2df51b DJ	491	size_t datalen;
	492	unsigned int before_stack_len;
	493
	494	op_ptr = read_sleb128 (op_ptr, op_end, &offset);
	495	/* Rather than create a whole new context, we simply
	496	record the stack length before execution, then reset it
	497	afterwards, effectively erasing whatever the recursive
	498	call put there. */
	499	before_stack_len = ctx->stack_len;
da62e633 AC	500	/* FIXME: cagney/2003-03-26: This code should be using
	501	get_frame_base_address(), and then implement a dwarf2
	502	specific this_base method. */
4c2df51b DJ	503	(ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
	504	dwarf_expr_eval (ctx, datastart, datalen);
	505	result = dwarf_expr_fetch (ctx, 0);
61fbb938 DJ	506	if (ctx->in_reg)
61fbb938 DJ	507	result = (ctx->read_reg) (ctx->baton, result);
4c2df51b DJ	508	result = result + offset;
	509	ctx->stack_len = before_stack_len;
	510	ctx->in_reg = 0;
	511	}
	512	break;
	513	case DW_OP_dup:
	514	result = dwarf_expr_fetch (ctx, 0);
	515	break;
	516
	517	case DW_OP_drop:
	518	dwarf_expr_pop (ctx);
	519	goto no_push;
	520
	521	case DW_OP_pick:
	522	offset = *op_ptr++;
	523	result = dwarf_expr_fetch (ctx, offset);
	524	break;
	525
	526	case DW_OP_over:
	527	result = dwarf_expr_fetch (ctx, 1);
	528	break;
	529
	530	case DW_OP_rot:
	531	{
	532	CORE_ADDR t1, t2, t3;
	533
	534	if (ctx->stack_len < 3)
8a3fe4f8	535	error (_("Not enough elements for DW_OP_rot. Need 3, have %d."),
4c2df51b DJ	536	ctx->stack_len);
	537	t1 = ctx->stack[ctx->stack_len - 1];
	538	t2 = ctx->stack[ctx->stack_len - 2];
	539	t3 = ctx->stack[ctx->stack_len - 3];
	540	ctx->stack[ctx->stack_len - 1] = t2;
	541	ctx->stack[ctx->stack_len - 2] = t3;
	542	ctx->stack[ctx->stack_len - 3] = t1;
	543	goto no_push;
	544	}
	545
	546	case DW_OP_deref:
	547	case DW_OP_deref_size:
	548	case DW_OP_abs:
	549	case DW_OP_neg:
	550	case DW_OP_not:
	551	case DW_OP_plus_uconst:
	552	/* Unary operations. */
	553	result = dwarf_expr_fetch (ctx, 0);
	554	dwarf_expr_pop (ctx);
	555
	556	switch (op)
	557	{
	558	case DW_OP_deref:
	559	{
ae0d2f24 UW	560	gdb_byte *buf = alloca (ctx->addr_size);
	561	(ctx->read_mem) (ctx->baton, buf, result, ctx->addr_size);
	562	result = dwarf2_read_address (buf, buf + ctx->addr_size,
	563	ctx->addr_size);
4c2df51b DJ	564	}
	565	break;
	566
	567	case DW_OP_deref_size:
	568	{
ae0d2f24 UW	569	int addr_size = *op_ptr++;
	570	gdb_byte *buf = alloca (addr_size);
	571	(ctx->read_mem) (ctx->baton, buf, result, addr_size);
	572	result = dwarf2_read_address (buf, buf + addr_size,
	573	addr_size);
4c2df51b DJ	574	}
	575	break;
	576
	577	case DW_OP_abs:
	578	if ((signed int) result < 0)
	579	result = -result;
	580	break;
	581	case DW_OP_neg:
	582	result = -result;
	583	break;
	584	case DW_OP_not:
	585	result = ~result;
	586	break;
	587	case DW_OP_plus_uconst:
	588	op_ptr = read_uleb128 (op_ptr, op_end, &reg);
	589	result += reg;
	590	break;
	591	}
	592	break;
	593
	594	case DW_OP_and:
	595	case DW_OP_div:
	596	case DW_OP_minus:
	597	case DW_OP_mod:
	598	case DW_OP_mul:
	599	case DW_OP_or:
	600	case DW_OP_plus:
	601	case DW_OP_shl:
	602	case DW_OP_shr:
	603	case DW_OP_shra:
	604	case DW_OP_xor:
	605	case DW_OP_le:
	606	case DW_OP_ge:
	607	case DW_OP_eq:
	608	case DW_OP_lt:
	609	case DW_OP_gt:
	610	case DW_OP_ne:
	611	{
	612	/* Binary operations. Use the value engine to do computations in
	613	the right width. */
	614	CORE_ADDR first, second;
	615	enum exp_opcode binop;
	616	struct value val1, val2;
	617
	618	second = dwarf_expr_fetch (ctx, 0);
	619	dwarf_expr_pop (ctx);
	620
b263358a	621	first = dwarf_expr_fetch (ctx, 0);
4c2df51b DJ	622	dwarf_expr_pop (ctx);
4c2df51b DJ	623
ae0d2f24 UW	624	val1 = value_from_longest
	625	(unsigned_address_type (ctx->addr_size), first);
	626	val2 = value_from_longest
	627	(unsigned_address_type (ctx->addr_size), second);
4c2df51b DJ	628
	629	switch (op)
	630	{
	631	case DW_OP_and:
	632	binop = BINOP_BITWISE_AND;
	633	break;
	634	case DW_OP_div:
	635	binop = BINOP_DIV;
99c87dab	636	break;
4c2df51b DJ	637	case DW_OP_minus:
	638	binop = BINOP_SUB;
	639	break;
	640	case DW_OP_mod:
	641	binop = BINOP_MOD;
	642	break;
	643	case DW_OP_mul:
	644	binop = BINOP_MUL;
	645	break;
	646	case DW_OP_or:
	647	binop = BINOP_BITWISE_IOR;
	648	break;
	649	case DW_OP_plus:
	650	binop = BINOP_ADD;
	651	break;
	652	case DW_OP_shl:
	653	binop = BINOP_LSH;
	654	break;
	655	case DW_OP_shr:
	656	binop = BINOP_RSH;
99c87dab	657	break;
4c2df51b DJ	658	case DW_OP_shra:
4c2df51b DJ	659	binop = BINOP_RSH;
ae0d2f24 UW	660	val1 = value_from_longest
ae0d2f24 UW	661	(signed_address_type (ctx->addr_size), first);
4c2df51b DJ	662	break;
	663	case DW_OP_xor:
	664	binop = BINOP_BITWISE_XOR;
	665	break;
	666	case DW_OP_le:
	667	binop = BINOP_LEQ;
	668	break;
	669	case DW_OP_ge:
	670	binop = BINOP_GEQ;
	671	break;
	672	case DW_OP_eq:
	673	binop = BINOP_EQUAL;
	674	break;
	675	case DW_OP_lt:
	676	binop = BINOP_LESS;
	677	break;
	678	case DW_OP_gt:
	679	binop = BINOP_GTR;
	680	break;
	681	case DW_OP_ne:
	682	binop = BINOP_NOTEQUAL;
	683	break;
	684	default:
	685	internal_error (__FILE__, __LINE__,
e2e0b3e5	686	_("Can't be reached."));
4c2df51b DJ	687	}
	688	result = value_as_long (value_binop (val1, val2, binop));
	689	}
	690	break;
	691
	692	case DW_OP_GNU_push_tls_address:
c3228f12 EZ	693	/* Variable is at a constant offset in the thread-local
	694	storage block into the objfile for the current thread and
	695	the dynamic linker module containing this expression. Here
	696	we return returns the offset from that base. The top of the
	697	stack has the offset from the beginning of the thread
	698	control block at which the variable is located. Nothing
	699	should follow this operator, so the top of stack would be
	700	returned. */
4c2df51b DJ	701	result = dwarf_expr_fetch (ctx, 0);
	702	dwarf_expr_pop (ctx);
	703	result = (ctx->get_tls_address) (ctx->baton, result);
	704	break;
	705
	706	case DW_OP_skip:
	707	offset = extract_signed_integer (op_ptr, 2);
	708	op_ptr += 2;
	709	op_ptr += offset;
	710	goto no_push;
	711
	712	case DW_OP_bra:
	713	offset = extract_signed_integer (op_ptr, 2);
	714	op_ptr += 2;
	715	if (dwarf_expr_fetch (ctx, 0) != 0)
	716	op_ptr += offset;
	717	dwarf_expr_pop (ctx);
	718	goto no_push;
	719
	720	case DW_OP_nop:
	721	goto no_push;
	722
87808bd6 JB	723	case DW_OP_piece:
	724	{
	725	ULONGEST size;
	726	CORE_ADDR addr_or_regnum;
	727
	728	/* Record the piece. */
	729	op_ptr = read_uleb128 (op_ptr, op_end, &size);
	730	addr_or_regnum = dwarf_expr_fetch (ctx, 0);
	731	add_piece (ctx, ctx->in_reg, addr_or_regnum, size);
	732
	733	/* Pop off the address/regnum, and clear the in_reg flag. */
	734	dwarf_expr_pop (ctx);
	735	ctx->in_reg = 0;
	736	}
	737	goto no_push;
	738
42be36b3 CT	739	case DW_OP_GNU_uninit:
	740	if (op_ptr != op_end)
	741	error (_("DWARF-2 expression error: DW_OP_GNU_unint must always "
	742	"be the very last op."));
	743
	744	ctx->initialized = 0;
	745	goto no_push;
	746
4c2df51b	747	default:
8a3fe4f8	748	error (_("Unhandled dwarf expression opcode 0x%x"), op);
4c2df51b DJ	749	}
	750
	751	/* Most things push a result value. */
	752	dwarf_expr_push (ctx, result);
	753	no_push:;
	754	}
1e3a102a JK	755
	756	ctx->recursion_depth--;
	757	gdb_assert (ctx->recursion_depth >= 0);
4c2df51b	758	}