gdb/dwarf2loc.c

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