[binutils.git] / gdb / dwarf2loc.c

/* DWARF 2 location expression support for GDB.

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

   Contributed by Daniel Jacobowitz, MontaVista Software, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "ui-out.h"
#include "value.h"
#include "frame.h"
#include "gdbcore.h"
#include "target.h"
#include "inferior.h"
#include "ax.h"
#include "ax-gdb.h"
#include "regcache.h"
#include "objfiles.h"
#include "exceptions.h"

#include "elf/dwarf2.h"
#include "dwarf2expr.h"
#include "dwarf2loc.h"

#include "gdb_string.h"
#include "gdb_assert.h"

/* A helper function for dealing with location lists.  Given a
   symbol baton (BATON) and a pc value (PC), find the appropriate
   location expression, set *LOCEXPR_LENGTH, and return a pointer
   to the beginning of the expression.  Returns NULL on failure.

   For now, only return the first matching location expression; there
   can be more than one in the list.  */

static gdb_byte *
find_location_expression (struct dwarf2_loclist_baton *baton,
			  size_t *locexpr_length, CORE_ADDR pc)
{
  CORE_ADDR low, high;
  gdb_byte *loc_ptr, *buf_end;
  int length;
  struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
  unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
  CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
  /* Adjust base_address for relocatable objects.  */
  CORE_ADDR base_offset = ANOFFSET (objfile->section_offsets,
				    SECT_OFF_TEXT (objfile));
  CORE_ADDR base_address = baton->base_address + base_offset;

  loc_ptr = baton->data;
  buf_end = baton->data + baton->size;

  while (1)
    {
      low = dwarf2_read_address (loc_ptr, buf_end, addr_size);
      loc_ptr += addr_size;
      high = dwarf2_read_address (loc_ptr, buf_end, addr_size);
      loc_ptr += addr_size;

      /* An end-of-list entry.  */
      if (low == 0 && high == 0)
	return NULL;

      /* A base-address-selection entry.  */
      if ((low & base_mask) == base_mask)
	{
	  base_address = high;
	  continue;
	}

      /* Otherwise, a location expression entry.  */
      low += base_address;
      high += base_address;

      length = extract_unsigned_integer (loc_ptr, 2);
      loc_ptr += 2;

      if (pc >= low && pc < high)
	{
	  *locexpr_length = length;
	  return loc_ptr;
	}

      loc_ptr += length;
    }
}

/* This is the baton used when performing dwarf2 expression
   evaluation.  */
struct dwarf_expr_baton
{
  struct frame_info *frame;
  struct objfile *objfile;
};

/* Helper functions for dwarf2_evaluate_loc_desc.  */

/* Using the frame specified in BATON, return the value of register
   REGNUM, treated as a pointer.  */
static CORE_ADDR
dwarf_expr_read_reg (void *baton, int dwarf_regnum)
{
  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
  CORE_ADDR result;
  int regnum;

  regnum = gdbarch_dwarf2_reg_to_regnum (current_gdbarch, dwarf_regnum);
  result = address_from_register (builtin_type_void_data_ptr,
				  regnum, debaton->frame);
  return result;
}

/* Read memory at ADDR (length LEN) into BUF.  */

static void
dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
{
  read_memory (addr, buf, len);
}

/* Using the frame specified in BATON, find the location expression
   describing the frame base.  Return a pointer to it in START and
   its length in LENGTH.  */
static void
dwarf_expr_frame_base (void *baton, gdb_byte **start, size_t * length)
{
  /* FIXME: cagney/2003-03-26: This code should be using
     get_frame_base_address(), and then implement a dwarf2 specific
     this_base method.  */
  struct symbol *framefunc;
  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;

  framefunc = get_frame_function (debaton->frame);

  /* If we found a frame-relative symbol then it was certainly within
     some function associated with a frame. If we can't find the frame,
     something has gone wrong.  */
  gdb_assert (framefunc != NULL);

  if (SYMBOL_OPS (framefunc) == &dwarf2_loclist_funcs)
    {
      struct dwarf2_loclist_baton *symbaton;
      struct frame_info *frame = debaton->frame;

      symbaton = SYMBOL_LOCATION_BATON (framefunc);
      *start = find_location_expression (symbaton, length,
					 get_frame_address_in_block (frame));
    }
  else
    {
      struct dwarf2_locexpr_baton *symbaton;
      symbaton = SYMBOL_LOCATION_BATON (framefunc);
      *length = symbaton->size;
      *start = symbaton->data;
    }

  if (*start == NULL)
    error (_("Could not find the frame base for \"%s\"."),
	   SYMBOL_NATURAL_NAME (framefunc));
}

/* Using the objfile specified in BATON, find the address for the
   current thread's thread-local storage with offset OFFSET.  */
static CORE_ADDR
dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
{
  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;

  return target_translate_tls_address (debaton->objfile, offset);
}

/* Evaluate a location description, starting at DATA and with length
   SIZE, to find the current location of variable VAR in the context
   of FRAME.  */
static struct value *
dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
			  gdb_byte *data, unsigned short size,
			  struct dwarf2_per_cu_data *per_cu)
{
  struct gdbarch *arch = get_frame_arch (frame);
  struct value *retval;
  struct dwarf_expr_baton baton;
  struct dwarf_expr_context *ctx;

  if (size == 0)
    {
      retval = allocate_value (SYMBOL_TYPE (var));
      VALUE_LVAL (retval) = not_lval;
      set_value_optimized_out (retval, 1);
      return retval;
    }

  baton.frame = frame;
  baton.objfile = dwarf2_per_cu_objfile (per_cu);

  ctx = new_dwarf_expr_context ();
  ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
  ctx->baton = &baton;
  ctx->read_reg = dwarf_expr_read_reg;
  ctx->read_mem = dwarf_expr_read_mem;
  ctx->get_frame_base = dwarf_expr_frame_base;
  ctx->get_tls_address = dwarf_expr_tls_address;

  dwarf_expr_eval (ctx, data, size);
  if (ctx->num_pieces > 0)
    {
      int i;
      long offset = 0;
      bfd_byte *contents;

      retval = allocate_value (SYMBOL_TYPE (var));
      contents = value_contents_raw (retval);
      for (i = 0; i < ctx->num_pieces; i++)
	{
	  struct dwarf_expr_piece *p = &ctx->pieces[i];
	  if (p->in_reg)
	    {
	      bfd_byte regval[MAX_REGISTER_SIZE];
	      int gdb_regnum = gdbarch_dwarf2_reg_to_regnum
				 (arch, p->value);
	      get_frame_register (frame, gdb_regnum, regval);
	      memcpy (contents + offset, regval, p->size);
	    }
	  else /* In memory?  */
	    {
	      read_memory (p->value, contents + offset, p->size);
	    }
	  offset += p->size;
	}
    }
  else if (ctx->in_reg)
    {
      CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
      int gdb_regnum = gdbarch_dwarf2_reg_to_regnum
			 (arch, dwarf_regnum);
      retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
    }
  else
    {
      CORE_ADDR address = dwarf_expr_fetch (ctx, 0);

      retval = allocate_value (SYMBOL_TYPE (var));
      VALUE_LVAL (retval) = lval_memory;
      set_value_lazy (retval, 1);
      VALUE_ADDRESS (retval) = address;
    }

  set_value_initialized (retval, ctx->initialized);

  free_dwarf_expr_context (ctx);

  return retval;
}


\f
/* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */

struct needs_frame_baton
{
  int needs_frame;
};

/* Reads from registers do require a frame.  */
static CORE_ADDR
needs_frame_read_reg (void *baton, int regnum)
{
  struct needs_frame_baton *nf_baton = baton;
  nf_baton->needs_frame = 1;
  return 1;
}

/* Reads from memory do not require a frame.  */
static void
needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
{
  memset (buf, 0, len);
}

/* Frame-relative accesses do require a frame.  */
static void
needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length)
{
  static gdb_byte lit0 = DW_OP_lit0;
  struct needs_frame_baton *nf_baton = baton;

  *start = &lit0;
  *length = 1;

  nf_baton->needs_frame = 1;
}

/* Thread-local accesses do require a frame.  */
static CORE_ADDR
needs_frame_tls_address (void *baton, CORE_ADDR offset)
{
  struct needs_frame_baton *nf_baton = baton;
  nf_baton->needs_frame = 1;
  return 1;
}

/* Return non-zero iff the location expression at DATA (length SIZE)
   requires a frame to evaluate.  */

static int
dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size,
			     struct dwarf2_per_cu_data *per_cu)
{
  struct needs_frame_baton baton;
  struct dwarf_expr_context *ctx;
  int in_reg;

  baton.needs_frame = 0;

  ctx = new_dwarf_expr_context ();
  ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
  ctx->baton = &baton;
  ctx->read_reg = needs_frame_read_reg;
  ctx->read_mem = needs_frame_read_mem;
  ctx->get_frame_base = needs_frame_frame_base;
  ctx->get_tls_address = needs_frame_tls_address;

  dwarf_expr_eval (ctx, data, size);

  in_reg = ctx->in_reg;

  if (ctx->num_pieces > 0)
    {
      int i;

      /* If the location has several pieces, and any of them are in
         registers, then we will need a frame to fetch them from.  */
      for (i = 0; i < ctx->num_pieces; i++)
        if (ctx->pieces[i].in_reg)
          in_reg = 1;
    }

  free_dwarf_expr_context (ctx);

  return baton.needs_frame || in_reg;
}

static void
dwarf2_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax,
			   struct axs_value *value, gdb_byte *data,
			   int size)
{
  if (size == 0)
    error (_("Symbol \"%s\" has been optimized out."),
	   SYMBOL_PRINT_NAME (symbol));

  if (size == 1
      && data[0] >= DW_OP_reg0
      && data[0] <= DW_OP_reg31)
    {
      value->kind = axs_lvalue_register;
      value->u.reg = data[0] - DW_OP_reg0;
    }
  else if (data[0] == DW_OP_regx)
    {
      ULONGEST reg;
      read_uleb128 (data + 1, data + size, &reg);
      value->kind = axs_lvalue_register;
      value->u.reg = reg;
    }
  else if (data[0] == DW_OP_fbreg)
    {
      /* And this is worse than just minimal; we should honor the frame base
	 as above.  */
      int frame_reg;
      LONGEST frame_offset;
      gdb_byte *buf_end;

      buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
      if (buf_end != data + size)
	error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
	       SYMBOL_PRINT_NAME (symbol));

      gdbarch_virtual_frame_pointer (current_gdbarch, 
				     ax->scope, &frame_reg, &frame_offset);
      ax_reg (ax, frame_reg);
      ax_const_l (ax, frame_offset);
      ax_simple (ax, aop_add);

      value->kind = axs_lvalue_memory;
    }
  else if (data[0] >= DW_OP_breg0
	   && data[0] <= DW_OP_breg31)
    {
      unsigned int reg;
      LONGEST offset;
      gdb_byte *buf_end;

      reg = data[0] - DW_OP_breg0;
      buf_end = read_sleb128 (data + 1, data + size, &offset);
      if (buf_end != data + size)
	error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
	       reg, SYMBOL_PRINT_NAME (symbol));

      ax_reg (ax, reg);
      ax_const_l (ax, offset);
      ax_simple (ax, aop_add);

      value->kind = axs_lvalue_memory;
    }
  else
    error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
	   data[0], SYMBOL_PRINT_NAME (symbol));
}
\f
/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
   evaluator to calculate the location.  */
static struct value *
locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
{
  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  struct value *val;
  val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
				  dlbaton->per_cu);

  return val;
}

/* Return non-zero iff we need a frame to evaluate SYMBOL.  */
static int
locexpr_read_needs_frame (struct symbol *symbol)
{
  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
				      dlbaton->per_cu);
}

/* Print a natural-language description of SYMBOL to STREAM.  */
static int
locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
{
  /* FIXME: be more extensive.  */
  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);

  if (dlbaton->size == 1
      && dlbaton->data[0] >= DW_OP_reg0
      && dlbaton->data[0] <= DW_OP_reg31)
    {
      int regno = gdbarch_dwarf2_reg_to_regnum
		    (current_gdbarch, dlbaton->data[0] - DW_OP_reg0);
      fprintf_filtered (stream,
			"a variable in register %s",
			gdbarch_register_name (current_gdbarch, regno));
      return 1;
    }

  /* The location expression for a TLS variable looks like this (on a
     64-bit LE machine):

     DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
                        (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
     
     0x3 is the encoding for DW_OP_addr, which has an operand as long
     as the size of an address on the target machine (here is 8
     bytes).  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
     The operand represents the offset at which the variable is within
     the thread local storage.  */

  if (dlbaton->size > 1 
      && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
    if (dlbaton->data[0] == DW_OP_addr)
      {
	struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
	CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1],
						&dlbaton->data[dlbaton->size - 1],
						addr_size);
	fprintf_filtered (stream, 
			  "a thread-local variable at offset %s in the "
			  "thread-local storage for `%s'",
			  paddr_nz (offset), objfile->name);
	return 1;
      }
  

  fprintf_filtered (stream,
		    "a variable with complex or multiple locations (DWARF2)");
  return 1;
}


/* Describe the location of SYMBOL as an agent value in VALUE, generating
   any necessary bytecode in AX.

   NOTE drow/2003-02-26: This function is extremely minimal, because
   doing it correctly is extremely complicated and there is no
   publicly available stub with tracepoint support for me to test
   against.  When there is one this function should be revisited.  */

static void
locexpr_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
			    struct axs_value * value)
{
  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);

  dwarf2_tracepoint_var_ref (symbol, ax, value, dlbaton->data, dlbaton->size);
}

/* The set of location functions used with the DWARF-2 expression
   evaluator.  */
const struct symbol_ops dwarf2_locexpr_funcs = {
  locexpr_read_variable,
  locexpr_read_needs_frame,
  locexpr_describe_location,
  locexpr_tracepoint_var_ref
};


/* Wrapper functions for location lists.  These generally find
   the appropriate location expression and call something above.  */

/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
   evaluator to calculate the location.  */
static struct value *
loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
{
  struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  struct value *val;
  gdb_byte *data;
  size_t size;

  data = find_location_expression (dlbaton, &size,
				   frame ? get_frame_address_in_block (frame)
				   : 0);
  if (data == NULL)
    {
      val = allocate_value (SYMBOL_TYPE (symbol));
      VALUE_LVAL (val) = not_lval;
      set_value_optimized_out (val, 1);
    }
  else
    val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
				    dlbaton->per_cu);

  return val;
}

/* Return non-zero iff we need a frame to evaluate SYMBOL.  */
static int
loclist_read_needs_frame (struct symbol *symbol)
{
  /* If there's a location list, then assume we need to have a frame
     to choose the appropriate location expression.  With tracking of
     global variables this is not necessarily true, but such tracking
     is disabled in GCC at the moment until we figure out how to
     represent it.  */

  return 1;
}

/* Print a natural-language description of SYMBOL to STREAM.  */
static int
loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
{
  /* FIXME: Could print the entire list of locations.  */
  fprintf_filtered (stream, "a variable with multiple locations");
  return 1;
}

/* Describe the location of SYMBOL as an agent value in VALUE, generating
   any necessary bytecode in AX.  */
static void
loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
			    struct axs_value * value)
{
  struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  gdb_byte *data;
  size_t size;

  data = find_location_expression (dlbaton, &size, ax->scope);
  if (data == NULL)
    error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol));

  dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
}

/* The set of location functions used with the DWARF-2 expression
   evaluator and location lists.  */
const struct symbol_ops dwarf2_loclist_funcs = {
  loclist_read_variable,
  loclist_read_needs_frame,
  loclist_describe_location,
  loclist_tracepoint_var_ref
};
Commit	Line	Data
4c2df51b	1	/* DWARF 2 location expression support for GDB.
feb13ab0	2
9b254dd1	3	Copyright (C) 2003, 2005, 2007, 2008 Free Software Foundation, Inc.
feb13ab0	4
4c2df51b DJ	5	Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
	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
a9762ec7 JB	11	the Free Software Foundation; either version 3 of the License, or
a9762ec7 JB	12	(at your option) any later version.
4c2df51b	13
a9762ec7 JB	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.
4c2df51b DJ	18
4c2df51b DJ	19	You should have received a copy of the GNU General Public License
a9762ec7	20	along with this program. If not, see <http://www.gnu.org/licenses/>. */
4c2df51b DJ	21
	22	#include "defs.h"
	23	#include "ui-out.h"
	24	#include "value.h"
	25	#include "frame.h"
	26	#include "gdbcore.h"
	27	#include "target.h"
	28	#include "inferior.h"
a55cc764 DJ	29	#include "ax.h"
a55cc764 DJ	30	#include "ax-gdb.h"
e4adbba9	31	#include "regcache.h"
c3228f12	32	#include "objfiles.h"
93ad78a7	33	#include "exceptions.h"
4c2df51b DJ	34
	35	#include "elf/dwarf2.h"
	36	#include "dwarf2expr.h"
	37	#include "dwarf2loc.h"
	38
	39	#include "gdb_string.h"
eff4f95e	40	#include "gdb_assert.h"
4c2df51b	41
0d53c4c4 DJ	42	/* A helper function for dealing with location lists. Given a
	43	symbol baton (BATON) and a pc value (PC), find the appropriate
	44	location expression, set *LOCEXPR_LENGTH, and return a pointer
	45	to the beginning of the expression. Returns NULL on failure.
	46
	47	For now, only return the first matching location expression; there
	48	can be more than one in the list. */
	49
852483bc	50	static gdb_byte *
0d53c4c4	51	find_location_expression (struct dwarf2_loclist_baton *baton,
b6b08ebf	52	size_t *locexpr_length, CORE_ADDR pc)
0d53c4c4	53	{
0d53c4c4	54	CORE_ADDR low, high;
852483bc MK	55	gdb_byte loc_ptr, buf_end;
852483bc MK	56	int length;
ae0d2f24 UW	57	struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
ae0d2f24 UW	58	unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
0d53c4c4	59	CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
8edfa926	60	/* Adjust base_address for relocatable objects. */
ae0d2f24 UW	61	CORE_ADDR base_offset = ANOFFSET (objfile->section_offsets,
ae0d2f24 UW	62	SECT_OFF_TEXT (objfile));
8edfa926	63	CORE_ADDR base_address = baton->base_address + base_offset;
0d53c4c4 DJ	64
	65	loc_ptr = baton->data;
	66	buf_end = baton->data + baton->size;
	67
	68	while (1)
	69	{
ae0d2f24 UW	70	low = dwarf2_read_address (loc_ptr, buf_end, addr_size);
	71	loc_ptr += addr_size;
	72	high = dwarf2_read_address (loc_ptr, buf_end, addr_size);
	73	loc_ptr += addr_size;
0d53c4c4 DJ	74
	75	/* An end-of-list entry. */
	76	if (low == 0 && high == 0)
	77	return NULL;
	78
	79	/* A base-address-selection entry. */
	80	if ((low & base_mask) == base_mask)
	81	{
	82	base_address = high;
	83	continue;
	84	}
	85
	86	/* Otherwise, a location expression entry. */
	87	low += base_address;
	88	high += base_address;
	89
	90	length = extract_unsigned_integer (loc_ptr, 2);
	91	loc_ptr += 2;
	92
	93	if (pc >= low && pc < high)
	94	{
	95	*locexpr_length = length;
	96	return loc_ptr;
	97	}
	98
	99	loc_ptr += length;
	100	}
	101	}
	102
4c2df51b DJ	103	/* This is the baton used when performing dwarf2 expression
	104	evaluation. */
	105	struct dwarf_expr_baton
	106	{
	107	struct frame_info *frame;
	108	struct objfile *objfile;
	109	};
	110
	111	/* Helper functions for dwarf2_evaluate_loc_desc. */
	112
4bc9efe1	113	/* Using the frame specified in BATON, return the value of register
0b2b0195	114	REGNUM, treated as a pointer. */
4c2df51b	115	static CORE_ADDR
61fbb938	116	dwarf_expr_read_reg (void *baton, int dwarf_regnum)
4c2df51b	117	{
4c2df51b	118	struct dwarf_expr_baton debaton = (struct dwarf_expr_baton ) baton;
e5192dd8	119	CORE_ADDR result;
0b2b0195	120	int regnum;
e4adbba9	121
055d23b8	122	regnum = gdbarch_dwarf2_reg_to_regnum (current_gdbarch, dwarf_regnum);
0b2b0195 UW	123	result = address_from_register (builtin_type_void_data_ptr,
0b2b0195 UW	124	regnum, debaton->frame);
4c2df51b DJ	125	return result;
	126	}
	127
	128	/* Read memory at ADDR (length LEN) into BUF. */
	129
	130	static void
852483bc	131	dwarf_expr_read_mem (void baton, gdb_byte buf, CORE_ADDR addr, size_t len)
4c2df51b DJ	132	{
	133	read_memory (addr, buf, len);
	134	}
	135
	136	/* Using the frame specified in BATON, find the location expression
	137	describing the frame base. Return a pointer to it in START and
	138	its length in LENGTH. */
	139	static void
852483bc	140	dwarf_expr_frame_base (void baton, gdb_byte start, size_t length)
4c2df51b	141	{
da62e633 AC	142	/* FIXME: cagney/2003-03-26: This code should be using
	143	get_frame_base_address(), and then implement a dwarf2 specific
	144	this_base method. */
4c2df51b	145	struct symbol *framefunc;
4c2df51b	146	struct dwarf_expr_baton debaton = (struct dwarf_expr_baton ) baton;
0d53c4c4	147
4c2df51b	148	framefunc = get_frame_function (debaton->frame);
0d53c4c4	149
eff4f95e JG	150	/* If we found a frame-relative symbol then it was certainly within
	151	some function associated with a frame. If we can't find the frame,
	152	something has gone wrong. */
	153	gdb_assert (framefunc != NULL);
	154
a67af2b9	155	if (SYMBOL_OPS (framefunc) == &dwarf2_loclist_funcs)
0d53c4c4 DJ	156	{
0d53c4c4 DJ	157	struct dwarf2_loclist_baton *symbaton;
22c6caba JW	158	struct frame_info *frame = debaton->frame;
22c6caba JW	159
0d53c4c4 DJ	160	symbaton = SYMBOL_LOCATION_BATON (framefunc);
0d53c4c4 DJ	161	*start = find_location_expression (symbaton, length,
22c6caba	162	get_frame_address_in_block (frame));
0d53c4c4 DJ	163	}
	164	else
	165	{
	166	struct dwarf2_locexpr_baton *symbaton;
	167	symbaton = SYMBOL_LOCATION_BATON (framefunc);
	168	*length = symbaton->size;
	169	*start = symbaton->data;
	170	}
	171
	172	if (*start == NULL)
8a3fe4f8	173	error (_("Could not find the frame base for \"%s\"."),
0d53c4c4	174	SYMBOL_NATURAL_NAME (framefunc));
4c2df51b DJ	175	}
	176
	177	/* Using the objfile specified in BATON, find the address for the
	178	current thread's thread-local storage with offset OFFSET. */
	179	static CORE_ADDR
	180	dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
	181	{
	182	struct dwarf_expr_baton debaton = (struct dwarf_expr_baton ) baton;
4c2df51b	183
9e35dae4	184	return target_translate_tls_address (debaton->objfile, offset);
4c2df51b DJ	185	}
	186
	187	/* Evaluate a location description, starting at DATA and with length
	188	SIZE, to find the current location of variable VAR in the context
	189	of FRAME. */
	190	static struct value *
	191	dwarf2_evaluate_loc_desc (struct symbol var, struct frame_info frame,
852483bc	192	gdb_byte *data, unsigned short size,
ae0d2f24	193	struct dwarf2_per_cu_data *per_cu)
4c2df51b	194	{
87808bd6	195	struct gdbarch *arch = get_frame_arch (frame);
4c2df51b DJ	196	struct value *retval;
	197	struct dwarf_expr_baton baton;
	198	struct dwarf_expr_context *ctx;
	199
0d53c4c4 DJ	200	if (size == 0)
	201	{
	202	retval = allocate_value (SYMBOL_TYPE (var));
	203	VALUE_LVAL (retval) = not_lval;
feb13ab0	204	set_value_optimized_out (retval, 1);
10fb19b6	205	return retval;
0d53c4c4 DJ	206	}
0d53c4c4 DJ	207
4c2df51b	208	baton.frame = frame;
ae0d2f24	209	baton.objfile = dwarf2_per_cu_objfile (per_cu);
4c2df51b DJ	210
4c2df51b DJ	211	ctx = new_dwarf_expr_context ();
ae0d2f24	212	ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
4c2df51b DJ	213	ctx->baton = &baton;
	214	ctx->read_reg = dwarf_expr_read_reg;
	215	ctx->read_mem = dwarf_expr_read_mem;
	216	ctx->get_frame_base = dwarf_expr_frame_base;
	217	ctx->get_tls_address = dwarf_expr_tls_address;
	218
	219	dwarf_expr_eval (ctx, data, size);
87808bd6 JB	220	if (ctx->num_pieces > 0)
87808bd6 JB	221	{
23572eca EZ	222	int i;
	223	long offset = 0;
	224	bfd_byte *contents;
	225
	226	retval = allocate_value (SYMBOL_TYPE (var));
	227	contents = value_contents_raw (retval);
	228	for (i = 0; i < ctx->num_pieces; i++)
	229	{
	230	struct dwarf_expr_piece *p = &ctx->pieces[i];
	231	if (p->in_reg)
	232	{
	233	bfd_byte regval[MAX_REGISTER_SIZE];
055d23b8	234	int gdb_regnum = gdbarch_dwarf2_reg_to_regnum
ad010def	235	(arch, p->value);
23572eca EZ	236	get_frame_register (frame, gdb_regnum, regval);
	237	memcpy (contents + offset, regval, p->size);
	238	}
	239	else /* In memory? */
	240	{
	241	read_memory (p->value, contents + offset, p->size);
	242	}
	243	offset += p->size;
	244	}
87808bd6 JB	245	}
87808bd6 JB	246	else if (ctx->in_reg)
051caad9	247	{
5ca2e327	248	CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
055d23b8	249	int gdb_regnum = gdbarch_dwarf2_reg_to_regnum
ad010def	250	(arch, dwarf_regnum);
5ca2e327	251	retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
051caad9	252	}
4c2df51b DJ	253	else
4c2df51b DJ	254	{
5ca2e327 JB	255	CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
5ca2e327 JB	256
61fbb938	257	retval = allocate_value (SYMBOL_TYPE (var));
4c2df51b	258	VALUE_LVAL (retval) = lval_memory;
dfa52d88	259	set_value_lazy (retval, 1);
5ca2e327	260	VALUE_ADDRESS (retval) = address;
4c2df51b DJ	261	}
4c2df51b DJ	262
42be36b3 CT	263	set_value_initialized (retval, ctx->initialized);
42be36b3 CT	264
4c2df51b DJ	265	free_dwarf_expr_context (ctx);
	266
	267	return retval;
	268	}
	269
	270
	271
	272
	273	\f
	274	/* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
	275
	276	struct needs_frame_baton
	277	{
	278	int needs_frame;
	279	};
	280
	281	/* Reads from registers do require a frame. */
	282	static CORE_ADDR
61fbb938	283	needs_frame_read_reg (void *baton, int regnum)
4c2df51b DJ	284	{
	285	struct needs_frame_baton *nf_baton = baton;
	286	nf_baton->needs_frame = 1;
	287	return 1;
	288	}
	289
	290	/* Reads from memory do not require a frame. */
	291	static void
852483bc	292	needs_frame_read_mem (void baton, gdb_byte buf, CORE_ADDR addr, size_t len)
4c2df51b DJ	293	{
	294	memset (buf, 0, len);
	295	}
	296
	297	/* Frame-relative accesses do require a frame. */
	298	static void
852483bc	299	needs_frame_frame_base (void baton, gdb_byte start, size_t length)
4c2df51b	300	{
852483bc	301	static gdb_byte lit0 = DW_OP_lit0;
4c2df51b DJ	302	struct needs_frame_baton *nf_baton = baton;
	303
	304	*start = &lit0;
	305	*length = 1;
	306
	307	nf_baton->needs_frame = 1;
	308	}
	309
	310	/* Thread-local accesses do require a frame. */
	311	static CORE_ADDR
	312	needs_frame_tls_address (void *baton, CORE_ADDR offset)
	313	{
	314	struct needs_frame_baton *nf_baton = baton;
	315	nf_baton->needs_frame = 1;
	316	return 1;
	317	}
	318
	319	/* Return non-zero iff the location expression at DATA (length SIZE)
	320	requires a frame to evaluate. */
	321
	322	static int
ae0d2f24 UW	323	dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size,
ae0d2f24 UW	324	struct dwarf2_per_cu_data *per_cu)
4c2df51b DJ	325	{
	326	struct needs_frame_baton baton;
	327	struct dwarf_expr_context *ctx;
f630a401	328	int in_reg;
4c2df51b DJ	329
	330	baton.needs_frame = 0;
	331
	332	ctx = new_dwarf_expr_context ();
ae0d2f24	333	ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
4c2df51b DJ	334	ctx->baton = &baton;
	335	ctx->read_reg = needs_frame_read_reg;
	336	ctx->read_mem = needs_frame_read_mem;
	337	ctx->get_frame_base = needs_frame_frame_base;
	338	ctx->get_tls_address = needs_frame_tls_address;
	339
	340	dwarf_expr_eval (ctx, data, size);
	341
f630a401 DJ	342	in_reg = ctx->in_reg;
f630a401 DJ	343
87808bd6 JB	344	if (ctx->num_pieces > 0)
	345	{
	346	int i;
	347
	348	/* If the location has several pieces, and any of them are in
	349	registers, then we will need a frame to fetch them from. */
	350	for (i = 0; i < ctx->num_pieces; i++)
	351	if (ctx->pieces[i].in_reg)
	352	in_reg = 1;
	353	}
	354
4c2df51b DJ	355	free_dwarf_expr_context (ctx);
4c2df51b DJ	356
f630a401	357	return baton.needs_frame \|\| in_reg;
4c2df51b DJ	358	}
4c2df51b DJ	359
0d53c4c4	360	static void
852483bc MK	361	dwarf2_tracepoint_var_ref (struct symbol symbol, struct agent_expr ax,
852483bc MK	362	struct axs_value value, gdb_byte data,
0d53c4c4 DJ	363	int size)
	364	{
	365	if (size == 0)
8a3fe4f8	366	error (_("Symbol \"%s\" has been optimized out."),
0d53c4c4 DJ	367	SYMBOL_PRINT_NAME (symbol));
	368
	369	if (size == 1
	370	&& data[0] >= DW_OP_reg0
	371	&& data[0] <= DW_OP_reg31)
	372	{
	373	value->kind = axs_lvalue_register;
	374	value->u.reg = data[0] - DW_OP_reg0;
	375	}
	376	else if (data[0] == DW_OP_regx)
	377	{
	378	ULONGEST reg;
	379	read_uleb128 (data + 1, data + size, &reg);
	380	value->kind = axs_lvalue_register;
	381	value->u.reg = reg;
	382	}
	383	else if (data[0] == DW_OP_fbreg)
	384	{
	385	/* And this is worse than just minimal; we should honor the frame base
	386	as above. */
	387	int frame_reg;
	388	LONGEST frame_offset;
852483bc	389	gdb_byte *buf_end;
0d53c4c4 DJ	390
	391	buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
	392	if (buf_end != data + size)
8a3fe4f8	393	error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
0d53c4c4	394	SYMBOL_PRINT_NAME (symbol));
4c2df51b	395
c7bb205c UW	396	gdbarch_virtual_frame_pointer (current_gdbarch,
c7bb205c UW	397	ax->scope, &frame_reg, &frame_offset);
0d53c4c4 DJ	398	ax_reg (ax, frame_reg);
	399	ax_const_l (ax, frame_offset);
	400	ax_simple (ax, aop_add);
4c2df51b	401
9c238357 RC	402	value->kind = axs_lvalue_memory;
	403	}
	404	else if (data[0] >= DW_OP_breg0
	405	&& data[0] <= DW_OP_breg31)
	406	{
	407	unsigned int reg;
	408	LONGEST offset;
	409	gdb_byte *buf_end;
	410
	411	reg = data[0] - DW_OP_breg0;
	412	buf_end = read_sleb128 (data + 1, data + size, &offset);
	413	if (buf_end != data + size)
	414	error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
	415	reg, SYMBOL_PRINT_NAME (symbol));
	416
	417	ax_reg (ax, reg);
	418	ax_const_l (ax, offset);
0d53c4c4	419	ax_simple (ax, aop_add);
9c238357	420
0d53c4c4 DJ	421	value->kind = axs_lvalue_memory;
	422	}
	423	else
9c238357 RC	424	error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
9c238357 RC	425	data[0], SYMBOL_PRINT_NAME (symbol));
0d53c4c4	426	}
4c2df51b DJ	427	\f
	428	/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
	429	evaluator to calculate the location. */
	430	static struct value *
	431	locexpr_read_variable (struct symbol symbol, struct frame_info frame)
	432	{
	433	struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
	434	struct value *val;
	435	val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
ae0d2f24	436	dlbaton->per_cu);
4c2df51b DJ	437
	438	return val;
	439	}
	440
	441	/* Return non-zero iff we need a frame to evaluate SYMBOL. */
	442	static int
	443	locexpr_read_needs_frame (struct symbol *symbol)
	444	{
	445	struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
ae0d2f24 UW	446	return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
ae0d2f24 UW	447	dlbaton->per_cu);
4c2df51b DJ	448	}
	449
	450	/* Print a natural-language description of SYMBOL to STREAM. */
	451	static int
	452	locexpr_describe_location (struct symbol symbol, struct ui_file stream)
	453	{
	454	/* FIXME: be more extensive. */
	455	struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
ae0d2f24	456	int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4c2df51b DJ	457
	458	if (dlbaton->size == 1
	459	&& dlbaton->data[0] >= DW_OP_reg0
	460	&& dlbaton->data[0] <= DW_OP_reg31)
	461	{
055d23b8 UW	462	int regno = gdbarch_dwarf2_reg_to_regnum
055d23b8 UW	463	(current_gdbarch, dlbaton->data[0] - DW_OP_reg0);
4c2df51b	464	fprintf_filtered (stream,
c9f4d572 UW	465	"a variable in register %s",
c9f4d572 UW	466	gdbarch_register_name (current_gdbarch, regno));
4c2df51b DJ	467	return 1;
	468	}
	469
c3228f12 EZ	470	/* The location expression for a TLS variable looks like this (on a
	471	64-bit LE machine):
	472
	473	DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
	474	(DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
	475
	476	0x3 is the encoding for DW_OP_addr, which has an operand as long
	477	as the size of an address on the target machine (here is 8
	478	bytes). 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
	479	The operand represents the offset at which the variable is within
	480	the thread local storage. */
	481
	482	if (dlbaton->size > 1
	483	&& dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
	484	if (dlbaton->data[0] == DW_OP_addr)
	485	{
ae0d2f24	486	struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
c3228f12	487	CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1],
c193f044	488	&dlbaton->data[dlbaton->size - 1],
ae0d2f24	489	addr_size);
c3228f12	490	fprintf_filtered (stream,
32ffcbed	491	"a thread-local variable at offset %s in the "
c3228f12	492	"thread-local storage for `%s'",
ae0d2f24	493	paddr_nz (offset), objfile->name);
c3228f12 EZ	494	return 1;
	495	}
	496
	497
4c2df51b DJ	498	fprintf_filtered (stream,
	499	"a variable with complex or multiple locations (DWARF2)");
	500	return 1;
	501	}
	502
a55cc764 DJ	503
	504	/* Describe the location of SYMBOL as an agent value in VALUE, generating
	505	any necessary bytecode in AX.
	506
	507	NOTE drow/2003-02-26: This function is extremely minimal, because
	508	doing it correctly is extremely complicated and there is no
	509	publicly available stub with tracepoint support for me to test
	510	against. When there is one this function should be revisited. */
	511
0d53c4c4	512	static void
a55cc764 DJ	513	locexpr_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
	514	struct axs_value * value)
	515	{
	516	struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
	517
0d53c4c4	518	dwarf2_tracepoint_var_ref (symbol, ax, value, dlbaton->data, dlbaton->size);
a55cc764 DJ	519	}
a55cc764 DJ	520
4c2df51b DJ	521	/* The set of location functions used with the DWARF-2 expression
4c2df51b DJ	522	evaluator. */
a67af2b9	523	const struct symbol_ops dwarf2_locexpr_funcs = {
4c2df51b DJ	524	locexpr_read_variable,
	525	locexpr_read_needs_frame,
	526	locexpr_describe_location,
a55cc764	527	locexpr_tracepoint_var_ref
4c2df51b	528	};
0d53c4c4 DJ	529
	530
	531	/* Wrapper functions for location lists. These generally find
	532	the appropriate location expression and call something above. */
	533
	534	/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
	535	evaluator to calculate the location. */
	536	static struct value *
	537	loclist_read_variable (struct symbol symbol, struct frame_info frame)
	538	{
	539	struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
	540	struct value *val;
852483bc	541	gdb_byte *data;
b6b08ebf	542	size_t size;
0d53c4c4 DJ	543
0d53c4c4 DJ	544	data = find_location_expression (dlbaton, &size,
22c6caba JW	545	frame ? get_frame_address_in_block (frame)
22c6caba JW	546	: 0);
0d53c4c4	547	if (data == NULL)
806048c6 DJ	548	{
	549	val = allocate_value (SYMBOL_TYPE (symbol));
	550	VALUE_LVAL (val) = not_lval;
	551	set_value_optimized_out (val, 1);
	552	}
	553	else
	554	val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
ae0d2f24	555	dlbaton->per_cu);
0d53c4c4 DJ	556
	557	return val;
	558	}
	559
	560	/* Return non-zero iff we need a frame to evaluate SYMBOL. */
	561	static int
	562	loclist_read_needs_frame (struct symbol *symbol)
	563	{
	564	/* If there's a location list, then assume we need to have a frame
	565	to choose the appropriate location expression. With tracking of
	566	global variables this is not necessarily true, but such tracking
	567	is disabled in GCC at the moment until we figure out how to
	568	represent it. */
	569
	570	return 1;
	571	}
	572
	573	/* Print a natural-language description of SYMBOL to STREAM. */
	574	static int
	575	loclist_describe_location (struct symbol symbol, struct ui_file stream)
	576	{
	577	/* FIXME: Could print the entire list of locations. */
	578	fprintf_filtered (stream, "a variable with multiple locations");
	579	return 1;
	580	}
	581
	582	/* Describe the location of SYMBOL as an agent value in VALUE, generating
	583	any necessary bytecode in AX. */
	584	static void
	585	loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
	586	struct axs_value * value)
	587	{
	588	struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
852483bc	589	gdb_byte *data;
b6b08ebf	590	size_t size;
0d53c4c4 DJ	591
	592	data = find_location_expression (dlbaton, &size, ax->scope);
	593	if (data == NULL)
8a3fe4f8	594	error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol));
0d53c4c4 DJ	595
	596	dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
	597	}
	598
	599	/* The set of location functions used with the DWARF-2 expression
	600	evaluator and location lists. */
a67af2b9	601	const struct symbol_ops dwarf2_loclist_funcs = {
0d53c4c4 DJ	602	loclist_read_variable,
	603	loclist_read_needs_frame,
	604	loclist_describe_location,
	605	loclist_tracepoint_var_ref
	606	};