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

/* DWARF 2 location expression support for GDB.

   Copyright (C) 2003, 2005 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 2 of the License, or (at
   your option) any later version.

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

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

#include "defs.h"
#include "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"

#ifndef DWARF2_REG_TO_REGNUM
#define DWARF2_REG_TO_REGNUM(REG) (REG)
#endif

/* 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;
  unsigned int addr_size = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
  CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
  /* Adjust base_address for relocatable objects.  */
  CORE_ADDR base_offset = ANOFFSET (baton->objfile->section_offsets,
				    SECT_OFF_TEXT (baton->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, &length);
      loc_ptr += length;
      high = dwarf2_read_address (loc_ptr, buf_end, &length);
      loc_ptr += length;

      /* 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 an unsigned integer.  */
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, save_addr;
  enum lval_type lval_type;
  gdb_byte *buf;
  int optimized, regnum, realnum, regsize;

  regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
  regsize = register_size (current_gdbarch, regnum);
  buf = alloca (regsize);

  frame_unwind_register (debaton->frame, regnum, buf);
  /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
     address is always unsigned.  That may or may not be true.  */
  result = extract_unsigned_integer (buf, regsize);

  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 (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 objfile *objfile)
{
  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);
    }

  baton.frame = frame;
  baton.objfile = objfile;

  ctx = new_dwarf_expr_context ();
  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 = DWARF2_REG_TO_REGNUM (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 = DWARF2_REG_TO_REGNUM (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;
    }

  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 needs_frame_baton baton;
  struct dwarf_expr_context *ctx;
  int in_reg;

  baton.needs_frame = 0;

  ctx = new_dwarf_expr_context ();
  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));

      TARGET_VIRTUAL_FRAME_POINTER (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->objfile);

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

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

  if (dlbaton->size == 1
      && dlbaton->data[0] >= DW_OP_reg0
      && dlbaton->data[0] <= DW_OP_reg31)
    {
      int regno = DWARF2_REG_TO_REGNUM (dlbaton->data[0] - DW_OP_reg0);
      fprintf_filtered (stream,
			"a variable in register %s", REGISTER_NAME (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)
      {
	int bytes_read;
	CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1],
						&dlbaton->data[dlbaton->size - 1],
						&bytes_read);
	fprintf_filtered (stream, 
			  "a thread-local variable at offset %s in the "
			  "thread-local storage for `%s'",
			  paddr_nz (offset), dlbaton->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->objfile);

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