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 #ifndef DWARF2_REG_TO_REGNUM
  44 #define DWARF2_REG_TO_REGNUM(REG) (REG)
  45 #endif
  46
  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
  55 static gdb_byte *
  56 find_location_expression (struct dwarf2_loclist_baton *baton,
  57                           size_t *locexpr_length, CORE_ADDR pc)
  58 {
  59   CORE_ADDR low, high;
  60   gdb_byte *loc_ptr, *buf_end;
  61   int length;
  62   unsigned int addr_size = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
  63   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
  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;
  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
 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
 117 /* Using the frame specified in BATON, return the value of register
 118    REGNUM, treated as a pointer.  */
 119 static CORE_ADDR
 120 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
 121 {
 122   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 123   CORE_ADDR result;
 124   int regnum;
 125
 126   regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
 127   result = address_from_register (builtin_type_void_data_ptr,
 128                                   regnum, debaton->frame);
 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, gdb_byte *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, gdb_byte **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_OPS (framefunc) == &dwarf2_loclist_funcs)
 155     {
 156       struct dwarf2_loclist_baton *symbaton;
 157       struct frame_info *frame = debaton->frame;
 158
 159       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 160       *start = find_location_expression (symbaton, length,
 161                                          get_frame_address_in_block (frame));
 162     }
 163   else
 164     {
 165       struct dwarf2_locexpr_baton *symbaton;
 166       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 167       *length = symbaton->size;
 168       *start = symbaton->data;
 169     }
 170
 171   if (*start == NULL)
 172     error (_("Could not find the frame base for \"%s\"."),
 173            SYMBOL_NATURAL_NAME (framefunc));
 174 }
 175
 176 /* Using the objfile specified in BATON, find the address for the
 177    current thread's thread-local storage with offset OFFSET.  */
 178 static CORE_ADDR
 179 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 180 {
 181   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 182
 183   return target_translate_tls_address (debaton->objfile, offset);
 184 }
 185
 186 /* Evaluate a location description, starting at DATA and with length
 187    SIZE, to find the current location of variable VAR in the context
 188    of FRAME.  */
 189 static struct value *
 190 dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
 191                           gdb_byte *data, unsigned short size,
 192                           struct objfile *objfile)
 193 {
 194   struct gdbarch *arch = get_frame_arch (frame);
 195   struct value *retval;
 196   struct dwarf_expr_baton baton;
 197   struct dwarf_expr_context *ctx;
 198
 199   if (size == 0)
 200     {
 201       retval = allocate_value (SYMBOL_TYPE (var));
 202       VALUE_LVAL (retval) = not_lval;
 203       set_value_optimized_out (retval, 1);
 204     }
 205
 206   baton.frame = frame;
 207   baton.objfile = objfile;
 208
 209   ctx = new_dwarf_expr_context ();
 210   ctx->baton = &baton;
 211   ctx->read_reg = dwarf_expr_read_reg;
 212   ctx->read_mem = dwarf_expr_read_mem;
 213   ctx->get_frame_base = dwarf_expr_frame_base;
 214   ctx->get_tls_address = dwarf_expr_tls_address;
 215
 216   dwarf_expr_eval (ctx, data, size);
 217   if (ctx->num_pieces > 0)
 218     {
 219       int i;
 220       long offset = 0;
 221       bfd_byte *contents;
 222
 223       retval = allocate_value (SYMBOL_TYPE (var));
 224       contents = value_contents_raw (retval);
 225       for (i = 0; i < ctx->num_pieces; i++)
 226         {
 227           struct dwarf_expr_piece *p = &ctx->pieces[i];
 228           if (p->in_reg)
 229             {
 230               bfd_byte regval[MAX_REGISTER_SIZE];
 231               int gdb_regnum = DWARF2_REG_TO_REGNUM (p->value);
 232               get_frame_register (frame, gdb_regnum, regval);
 233               memcpy (contents + offset, regval, p->size);
 234             }
 235           else /* In memory?  */
 236             {
 237               read_memory (p->value, contents + offset, p->size);
 238             }
 239           offset += p->size;
 240         }
 241     }
 242   else if (ctx->in_reg)
 243     {
 244       CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
 245       int gdb_regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
 246       retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
 247     }
 248   else
 249     {
 250       CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
 251
 252       retval = allocate_value (SYMBOL_TYPE (var));
 253       VALUE_LVAL (retval) = lval_memory;
 254       set_value_lazy (retval, 1);
 255       VALUE_ADDRESS (retval) = address;
 256     }
 257
 258   free_dwarf_expr_context (ctx);
 259
 260   return retval;
 261 }
 262
 263
 264
 265
 266 \f
 267 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 268
 269 struct needs_frame_baton
 270 {
 271   int needs_frame;
 272 };
 273
 274 /* Reads from registers do require a frame.  */
 275 static CORE_ADDR
 276 needs_frame_read_reg (void *baton, int regnum)
 277 {
 278   struct needs_frame_baton *nf_baton = baton;
 279   nf_baton->needs_frame = 1;
 280   return 1;
 281 }
 282
 283 /* Reads from memory do not require a frame.  */
 284 static void
 285 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 286 {
 287   memset (buf, 0, len);
 288 }
 289
 290 /* Frame-relative accesses do require a frame.  */
 291 static void
 292 needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length)
 293 {
 294   static gdb_byte lit0 = DW_OP_lit0;
 295   struct needs_frame_baton *nf_baton = baton;
 296
 297   *start = &lit0;
 298   *length = 1;
 299
 300   nf_baton->needs_frame = 1;
 301 }
 302
 303 /* Thread-local accesses do require a frame.  */
 304 static CORE_ADDR
 305 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 306 {
 307   struct needs_frame_baton *nf_baton = baton;
 308   nf_baton->needs_frame = 1;
 309   return 1;
 310 }
 311
 312 /* Return non-zero iff the location expression at DATA (length SIZE)
 313    requires a frame to evaluate.  */
 314
 315 static int
 316 dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size)
 317 {
 318   struct needs_frame_baton baton;
 319   struct dwarf_expr_context *ctx;
 320   int in_reg;
 321
 322   baton.needs_frame = 0;
 323
 324   ctx = new_dwarf_expr_context ();
 325   ctx->baton = &baton;
 326   ctx->read_reg = needs_frame_read_reg;
 327   ctx->read_mem = needs_frame_read_mem;
 328   ctx->get_frame_base = needs_frame_frame_base;
 329   ctx->get_tls_address = needs_frame_tls_address;
 330
 331   dwarf_expr_eval (ctx, data, size);
 332
 333   in_reg = ctx->in_reg;
 334
 335   if (ctx->num_pieces > 0)
 336     {
 337       int i;
 338
 339       /* If the location has several pieces, and any of them are in
 340          registers, then we will need a frame to fetch them from.  */
 341       for (i = 0; i < ctx->num_pieces; i++)
 342         if (ctx->pieces[i].in_reg)
 343           in_reg = 1;
 344     }
 345
 346   free_dwarf_expr_context (ctx);
 347
 348   return baton.needs_frame || in_reg;
 349 }
 350
 351 static void
 352 dwarf2_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax,
 353                            struct axs_value *value, gdb_byte *data,
 354                            int size)
 355 {
 356   if (size == 0)
 357     error (_("Symbol \"%s\" has been optimized out."),
 358            SYMBOL_PRINT_NAME (symbol));
 359
 360   if (size == 1
 361       && data[0] >= DW_OP_reg0
 362       && data[0] <= DW_OP_reg31)
 363     {
 364       value->kind = axs_lvalue_register;
 365       value->u.reg = data[0] - DW_OP_reg0;
 366     }
 367   else if (data[0] == DW_OP_regx)
 368     {
 369       ULONGEST reg;
 370       read_uleb128 (data + 1, data + size, &reg);
 371       value->kind = axs_lvalue_register;
 372       value->u.reg = reg;
 373     }
 374   else if (data[0] == DW_OP_fbreg)
 375     {
 376       /* And this is worse than just minimal; we should honor the frame base
 377          as above.  */
 378       int frame_reg;
 379       LONGEST frame_offset;
 380       gdb_byte *buf_end;
 381
 382       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
 383       if (buf_end != data + size)
 384         error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
 385                SYMBOL_PRINT_NAME (symbol));
 386
 387       TARGET_VIRTUAL_FRAME_POINTER (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 = DWARF2_REG_TO_REGNUM (dlbaton->data[0] - DW_OP_reg0);
 451       fprintf_filtered (stream,
 452                         "a variable in register %s", REGISTER_NAME (regno));
 453       return 1;
 454     }
 455
 456   /* The location expression for a TLS variable looks like this (on a
 457      64-bit LE machine):
 458
 459      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
 460                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
 461
 462      0x3 is the encoding for DW_OP_addr, which has an operand as long
 463      as the size of an address on the target machine (here is 8
 464      bytes).  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
 465      The operand represents the offset at which the variable is within
 466      the thread local storage.  */
 467
 468   if (dlbaton->size > 1
 469       && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
 470     if (dlbaton->data[0] == DW_OP_addr)
 471       {
 472         int bytes_read;
 473         CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1],
 474                                                 &dlbaton->data[dlbaton->size - 1],
 475                                                 &bytes_read);
 476         fprintf_filtered (stream,
 477                           "a thread-local variable at offset %s in the "
 478                           "thread-local storage for `%s'",
 479                           paddr_nz (offset), dlbaton->objfile->name);
 480         return 1;
 481       }
 482
 483
 484   fprintf_filtered (stream,
 485                     "a variable with complex or multiple locations (DWARF2)");
 486   return 1;
 487 }
 488
 489
 490 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 491    any necessary bytecode in AX.
 492
 493    NOTE drow/2003-02-26: This function is extremely minimal, because
 494    doing it correctly is extremely complicated and there is no
 495    publicly available stub with tracepoint support for me to test
 496    against.  When there is one this function should be revisited.  */
 497
 498 static void
 499 locexpr_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 500                             struct axs_value * value)
 501 {
 502   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 503
 504   dwarf2_tracepoint_var_ref (symbol, ax, value, dlbaton->data, dlbaton->size);
 505 }
 506
 507 /* The set of location functions used with the DWARF-2 expression
 508    evaluator.  */
 509 const struct symbol_ops dwarf2_locexpr_funcs = {
 510   locexpr_read_variable,
 511   locexpr_read_needs_frame,
 512   locexpr_describe_location,
 513   locexpr_tracepoint_var_ref
 514 };
 515
 516
 517 /* Wrapper functions for location lists.  These generally find
 518    the appropriate location expression and call something above.  */
 519
 520 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 521    evaluator to calculate the location.  */
 522 static struct value *
 523 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 524 {
 525   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 526   struct value *val;
 527   gdb_byte *data;
 528   size_t size;
 529
 530   data = find_location_expression (dlbaton, &size,
 531                                    frame ? get_frame_address_in_block (frame)
 532                                    : 0);
 533   if (data == NULL)
 534     {
 535       val = allocate_value (SYMBOL_TYPE (symbol));
 536       VALUE_LVAL (val) = not_lval;
 537       set_value_optimized_out (val, 1);
 538     }
 539   else
 540     val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
 541                                     dlbaton->objfile);
 542
 543   return val;
 544 }
 545
 546 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 547 static int
 548 loclist_read_needs_frame (struct symbol *symbol)
 549 {
 550   /* If there's a location list, then assume we need to have a frame
 551      to choose the appropriate location expression.  With tracking of
 552      global variables this is not necessarily true, but such tracking
 553      is disabled in GCC at the moment until we figure out how to
 554      represent it.  */
 555
 556   return 1;
 557 }
 558
 559 /* Print a natural-language description of SYMBOL to STREAM.  */
 560 static int
 561 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 562 {
 563   /* FIXME: Could print the entire list of locations.  */
 564   fprintf_filtered (stream, "a variable with multiple locations");
 565   return 1;
 566 }
 567
 568 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 569    any necessary bytecode in AX.  */
 570 static void
 571 loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 572                             struct axs_value * value)
 573 {
 574   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 575   gdb_byte *data;
 576   size_t size;
 577
 578   data = find_location_expression (dlbaton, &size, ax->scope);
 579   if (data == NULL)
 580     error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol));
 581
 582   dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
 583 }
 584
 585 /* The set of location functions used with the DWARF-2 expression
 586    evaluator and location lists.  */
 587 const struct symbol_ops dwarf2_loclist_funcs = {
 588   loclist_read_variable,
 589   loclist_read_needs_frame,
 590   loclist_describe_location,
 591   loclist_tracepoint_var_ref
 592 };