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