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