gdb/dwarf2loc.c

   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
  33 #include "elf/dwarf2.h"
  34 #include "dwarf2expr.h"
  35 #include "dwarf2loc.h"
  36
  37 #include "gdb_string.h"
  38
  39 #ifndef DWARF2_REG_TO_REGNUM
  40 #define DWARF2_REG_TO_REGNUM(REG) (REG)
  41 #endif
  42
  43 /* A helper function for dealing with location lists.  Given a
  44    symbol baton (BATON) and a pc value (PC), find the appropriate
  45    location expression, set *LOCEXPR_LENGTH, and return a pointer
  46    to the beginning of the expression.  Returns NULL on failure.
  47
  48    For now, only return the first matching location expression; there
  49    can be more than one in the list.  */
  50
  51 static char *
  52 find_location_expression (struct dwarf2_loclist_baton *baton,
  53                           int *locexpr_length, CORE_ADDR pc)
  54 {
  55   CORE_ADDR base_address = baton->base_address;
  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
  61   loc_ptr = baton->data;
  62   buf_end = baton->data + baton->size;
  63
  64   while (1)
  65     {
  66       low = dwarf2_read_address (loc_ptr, buf_end, &length);
  67       loc_ptr += length;
  68       high = dwarf2_read_address (loc_ptr, buf_end, &length);
  69       loc_ptr += length;
  70
  71       /* An end-of-list entry.  */
  72       if (low == 0 && high == 0)
  73         return NULL;
  74
  75       /* A base-address-selection entry.  */
  76       if ((low & base_mask) == base_mask)
  77         {
  78           base_address = high;
  79           continue;
  80         }
  81
  82       /* Otherwise, a location expression entry.  */
  83       low += base_address;
  84       high += base_address;
  85
  86       length = extract_unsigned_integer (loc_ptr, 2);
  87       loc_ptr += 2;
  88
  89       if (pc >= low && pc < high)
  90         {
  91           *locexpr_length = length;
  92           return loc_ptr;
  93         }
  94
  95       loc_ptr += length;
  96     }
  97 }
  98
  99 /* This is the baton used when performing dwarf2 expression
 100    evaluation.  */
 101 struct dwarf_expr_baton
 102 {
 103   struct frame_info *frame;
 104   struct objfile *objfile;
 105 };
 106
 107 /* Helper functions for dwarf2_evaluate_loc_desc.  */
 108
 109 /* Using the frame specified in BATON, read register REGNUM.  The lval
 110    type will be returned in LVALP, and for lval_memory the register
 111    save address will be returned in ADDRP.  */
 112 static CORE_ADDR
 113 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
 114 {
 115   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 116   CORE_ADDR result, save_addr;
 117   enum lval_type lval_type;
 118   char *buf;
 119   int optimized, regnum, realnum, regsize;
 120
 121   regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
 122   regsize = register_size (current_gdbarch, regnum);
 123   buf = (char *) alloca (regsize);
 124
 125   frame_register (debaton->frame, regnum, &optimized, &lval_type, &save_addr,
 126                   &realnum, buf);
 127   result = extract_address (buf, regsize);
 128
 129   return result;
 130 }
 131
 132 /* Read memory at ADDR (length LEN) into BUF.  */
 133
 134 static void
 135 dwarf_expr_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
 136 {
 137   read_memory (addr, buf, len);
 138 }
 139
 140 /* Using the frame specified in BATON, find the location expression
 141    describing the frame base.  Return a pointer to it in START and
 142    its length in LENGTH.  */
 143 static void
 144 dwarf_expr_frame_base (void *baton, unsigned char **start, size_t * length)
 145 {
 146   /* FIXME: cagney/2003-03-26: This code should be using
 147      get_frame_base_address(), and then implement a dwarf2 specific
 148      this_base method.  */
 149   struct symbol *framefunc;
 150   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 151
 152   framefunc = get_frame_function (debaton->frame);
 153
 154   if (SYMBOL_LOCATION_FUNCS (framefunc) == &dwarf2_loclist_funcs)
 155     {
 156       struct dwarf2_loclist_baton *symbaton;
 157       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 158       *start = find_location_expression (symbaton, length,
 159                                          get_frame_pc (debaton->frame));
 160     }
 161   else
 162     {
 163       struct dwarf2_locexpr_baton *symbaton;
 164       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 165       *length = symbaton->size;
 166       *start = symbaton->data;
 167     }
 168
 169   if (*start == NULL)
 170     error ("Could not find the frame base for \"%s\".",
 171            SYMBOL_NATURAL_NAME (framefunc));
 172 }
 173
 174 /* Using the objfile specified in BATON, find the address for the
 175    current thread's thread-local storage with offset OFFSET.  */
 176 static CORE_ADDR
 177 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 178 {
 179   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 180   CORE_ADDR addr;
 181
 182   if (target_get_thread_local_address_p ())
 183     addr = target_get_thread_local_address (inferior_ptid,
 184                                             debaton->objfile,
 185                                             offset);
 186   else
 187     error ("Cannot find thread-local variables on this target");
 188
 189   return addr;
 190 }
 191
 192 /* Evaluate a location description, starting at DATA and with length
 193    SIZE, to find the current location of variable VAR in the context
 194    of FRAME.  */
 195 static struct value *
 196 dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
 197                           unsigned char *data, unsigned short size,
 198                           struct objfile *objfile)
 199 {
 200   CORE_ADDR result;
 201   struct value *retval;
 202   struct dwarf_expr_baton baton;
 203   struct dwarf_expr_context *ctx;
 204
 205   if (size == 0)
 206     {
 207       retval = allocate_value (SYMBOL_TYPE (var));
 208       VALUE_LVAL (retval) = not_lval;
 209       VALUE_OPTIMIZED_OUT (retval) = 1;
 210     }
 211
 212   baton.frame = frame;
 213   baton.objfile = objfile;
 214
 215   ctx = new_dwarf_expr_context ();
 216   ctx->baton = &baton;
 217   ctx->read_reg = dwarf_expr_read_reg;
 218   ctx->read_mem = dwarf_expr_read_mem;
 219   ctx->get_frame_base = dwarf_expr_frame_base;
 220   ctx->get_tls_address = dwarf_expr_tls_address;
 221
 222   dwarf_expr_eval (ctx, data, size);
 223   result = dwarf_expr_fetch (ctx, 0);
 224
 225   if (ctx->in_reg)
 226     retval = value_from_register (SYMBOL_TYPE (var), result, frame);
 227   else
 228     {
 229       retval = allocate_value (SYMBOL_TYPE (var));
 230       VALUE_BFD_SECTION (retval) = SYMBOL_BFD_SECTION (var);
 231
 232       VALUE_LVAL (retval) = lval_memory;
 233       VALUE_LAZY (retval) = 1;
 234       VALUE_ADDRESS (retval) = result;
 235     }
 236
 237   free_dwarf_expr_context (ctx);
 238
 239   return retval;
 240 }
 241
 242
 243
 244
 245 \f
 246 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 247
 248 struct needs_frame_baton
 249 {
 250   int needs_frame;
 251 };
 252
 253 /* Reads from registers do require a frame.  */
 254 static CORE_ADDR
 255 needs_frame_read_reg (void *baton, int regnum)
 256 {
 257   struct needs_frame_baton *nf_baton = baton;
 258   nf_baton->needs_frame = 1;
 259   return 1;
 260 }
 261
 262 /* Reads from memory do not require a frame.  */
 263 static void
 264 needs_frame_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
 265 {
 266   memset (buf, 0, len);
 267 }
 268
 269 /* Frame-relative accesses do require a frame.  */
 270 static void
 271 needs_frame_frame_base (void *baton, unsigned char **start, size_t * length)
 272 {
 273   static char lit0 = DW_OP_lit0;
 274   struct needs_frame_baton *nf_baton = baton;
 275
 276   *start = &lit0;
 277   *length = 1;
 278
 279   nf_baton->needs_frame = 1;
 280 }
 281
 282 /* Thread-local accesses do require a frame.  */
 283 static CORE_ADDR
 284 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 285 {
 286   struct needs_frame_baton *nf_baton = baton;
 287   nf_baton->needs_frame = 1;
 288   return 1;
 289 }
 290
 291 /* Return non-zero iff the location expression at DATA (length SIZE)
 292    requires a frame to evaluate.  */
 293
 294 static int
 295 dwarf2_loc_desc_needs_frame (unsigned char *data, unsigned short size)
 296 {
 297   struct needs_frame_baton baton;
 298   struct dwarf_expr_context *ctx;
 299
 300   baton.needs_frame = 0;
 301
 302   ctx = new_dwarf_expr_context ();
 303   ctx->baton = &baton;
 304   ctx->read_reg = needs_frame_read_reg;
 305   ctx->read_mem = needs_frame_read_mem;
 306   ctx->get_frame_base = needs_frame_frame_base;
 307   ctx->get_tls_address = needs_frame_tls_address;
 308
 309   dwarf_expr_eval (ctx, data, size);
 310
 311   free_dwarf_expr_context (ctx);
 312
 313   return baton.needs_frame;
 314 }
 315
 316 static void
 317 dwarf2_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 318                            struct axs_value * value, unsigned char *data,
 319                            int size)
 320 {
 321   if (size == 0)
 322     error ("Symbol \"%s\" has been optimized out.",
 323            SYMBOL_PRINT_NAME (symbol));
 324
 325   if (size == 1
 326       && data[0] >= DW_OP_reg0
 327       && data[0] <= DW_OP_reg31)
 328     {
 329       value->kind = axs_lvalue_register;
 330       value->u.reg = data[0] - DW_OP_reg0;
 331     }
 332   else if (data[0] == DW_OP_regx)
 333     {
 334       ULONGEST reg;
 335       read_uleb128 (data + 1, data + size, &reg);
 336       value->kind = axs_lvalue_register;
 337       value->u.reg = reg;
 338     }
 339   else if (data[0] == DW_OP_fbreg)
 340     {
 341       /* And this is worse than just minimal; we should honor the frame base
 342          as above.  */
 343       int frame_reg;
 344       LONGEST frame_offset;
 345       unsigned char *buf_end;
 346
 347       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
 348       if (buf_end != data + size)
 349         error ("Unexpected opcode after DW_OP_fbreg for symbol \"%s\".",
 350                SYMBOL_PRINT_NAME (symbol));
 351
 352       TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
 353       ax_reg (ax, frame_reg);
 354       ax_const_l (ax, frame_offset);
 355       ax_simple (ax, aop_add);
 356
 357       ax_const_l (ax, frame_offset);
 358       ax_simple (ax, aop_add);
 359       value->kind = axs_lvalue_memory;
 360     }
 361   else
 362     error ("Unsupported DWARF opcode in the location of \"%s\".",
 363            SYMBOL_PRINT_NAME (symbol));
 364 }
 365 \f
 366 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 367    evaluator to calculate the location.  */
 368 static struct value *
 369 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
 370 {
 371   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 372   struct value *val;
 373   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
 374                                   dlbaton->objfile);
 375
 376   return val;
 377 }
 378
 379 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 380 static int
 381 locexpr_read_needs_frame (struct symbol *symbol)
 382 {
 383   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 384   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size);
 385 }
 386
 387 /* Print a natural-language description of SYMBOL to STREAM.  */
 388 static int
 389 locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
 390 {
 391   /* FIXME: be more extensive.  */
 392   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 393
 394   if (dlbaton->size == 1
 395       && dlbaton->data[0] >= DW_OP_reg0
 396       && dlbaton->data[0] <= DW_OP_reg31)
 397     {
 398       int regno = DWARF2_REG_TO_REGNUM (dlbaton->data[0] - DW_OP_reg0);
 399       fprintf_filtered (stream,
 400                         "a variable in register %s", REGISTER_NAME (regno));
 401       return 1;
 402     }
 403
 404   fprintf_filtered (stream,
 405                     "a variable with complex or multiple locations (DWARF2)");
 406   return 1;
 407 }
 408
 409
 410 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 411    any necessary bytecode in AX.
 412
 413    NOTE drow/2003-02-26: This function is extremely minimal, because
 414    doing it correctly is extremely complicated and there is no
 415    publicly available stub with tracepoint support for me to test
 416    against.  When there is one this function should be revisited.  */
 417
 418 static void
 419 locexpr_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 420                             struct axs_value * value)
 421 {
 422   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 423
 424   dwarf2_tracepoint_var_ref (symbol, ax, value, dlbaton->data, dlbaton->size);
 425 }
 426
 427 /* The set of location functions used with the DWARF-2 expression
 428    evaluator.  */
 429 struct location_funcs dwarf2_locexpr_funcs = {
 430   locexpr_read_variable,
 431   locexpr_read_needs_frame,
 432   locexpr_describe_location,
 433   locexpr_tracepoint_var_ref
 434 };
 435
 436
 437 /* Wrapper functions for location lists.  These generally find
 438    the appropriate location expression and call something above.  */
 439
 440 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 441    evaluator to calculate the location.  */
 442 static struct value *
 443 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 444 {
 445   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 446   struct value *val;
 447   unsigned char *data;
 448   int size;
 449
 450   data = find_location_expression (dlbaton, &size,
 451                                    frame ? get_frame_pc (frame) : 0);
 452   if (data == NULL)
 453     error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol));
 454
 455   val = dwarf2_evaluate_loc_desc (symbol, frame, data, size, dlbaton->objfile);
 456
 457   return val;
 458 }
 459
 460 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 461 static int
 462 loclist_read_needs_frame (struct symbol *symbol)
 463 {
 464   /* If there's a location list, then assume we need to have a frame
 465      to choose the appropriate location expression.  With tracking of
 466      global variables this is not necessarily true, but such tracking
 467      is disabled in GCC at the moment until we figure out how to
 468      represent it.  */
 469
 470   return 1;
 471 }
 472
 473 /* Print a natural-language description of SYMBOL to STREAM.  */
 474 static int
 475 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 476 {
 477   /* FIXME: Could print the entire list of locations.  */
 478   fprintf_filtered (stream, "a variable with multiple locations");
 479   return 1;
 480 }
 481
 482 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 483    any necessary bytecode in AX.  */
 484 static void
 485 loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 486                             struct axs_value * value)
 487 {
 488   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 489   unsigned char *data;
 490   int size;
 491
 492   data = find_location_expression (dlbaton, &size, ax->scope);
 493   if (data == NULL)
 494     error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol));
 495
 496   dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
 497 }
 498
 499 /* The set of location functions used with the DWARF-2 expression
 500    evaluator and location lists.  */
 501 struct location_funcs dwarf2_loclist_funcs = {
 502   loclist_read_variable,
 503   loclist_read_needs_frame,
 504   loclist_describe_location,
 505   loclist_tracepoint_var_ref
 506 };