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       return retval;
 205     }
 206
 207   baton.frame = frame;
 208   baton.objfile = objfile;
 209
 210   ctx = new_dwarf_expr_context ();
 211   ctx->baton = &baton;
 212   ctx->read_reg = dwarf_expr_read_reg;
 213   ctx->read_mem = dwarf_expr_read_mem;
 214   ctx->get_frame_base = dwarf_expr_frame_base;
 215   ctx->get_tls_address = dwarf_expr_tls_address;
 216
 217   dwarf_expr_eval (ctx, data, size);
 218   if (ctx->num_pieces > 0)
 219     {
 220       int i;
 221       long offset = 0;
 222       bfd_byte *contents;
 223
 224       retval = allocate_value (SYMBOL_TYPE (var));
 225       contents = value_contents_raw (retval);
 226       for (i = 0; i < ctx->num_pieces; i++)
 227         {
 228           struct dwarf_expr_piece *p = &ctx->pieces[i];
 229           if (p->in_reg)
 230             {
 231               bfd_byte regval[MAX_REGISTER_SIZE];
 232               int gdb_regnum = DWARF2_REG_TO_REGNUM (p->value);
 233               get_frame_register (frame, gdb_regnum, regval);
 234               memcpy (contents + offset, regval, p->size);
 235             }
 236           else /* In memory?  */
 237             {
 238               read_memory (p->value, contents + offset, p->size);
 239             }
 240           offset += p->size;
 241         }
 242     }
 243   else if (ctx->in_reg)
 244     {
 245       CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
 246       int gdb_regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
 247       retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
 248     }
 249   else
 250     {
 251       CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
 252
 253       retval = allocate_value (SYMBOL_TYPE (var));
 254       VALUE_LVAL (retval) = lval_memory;
 255       set_value_lazy (retval, 1);
 256       VALUE_ADDRESS (retval) = address;
 257     }
 258
 259   set_value_initialized (retval, ctx->initialized);
 260
 261   free_dwarf_expr_context (ctx);
 262
 263   return retval;
 264 }
 265
 266
 267
 268
 269 \f
 270 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 271
 272 struct needs_frame_baton
 273 {
 274   int needs_frame;
 275 };
 276
 277 /* Reads from registers do require a frame.  */
 278 static CORE_ADDR
 279 needs_frame_read_reg (void *baton, int regnum)
 280 {
 281   struct needs_frame_baton *nf_baton = baton;
 282   nf_baton->needs_frame = 1;
 283   return 1;
 284 }
 285
 286 /* Reads from memory do not require a frame.  */
 287 static void
 288 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 289 {
 290   memset (buf, 0, len);
 291 }
 292
 293 /* Frame-relative accesses do require a frame.  */
 294 static void
 295 needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length)
 296 {
 297   static gdb_byte lit0 = DW_OP_lit0;
 298   struct needs_frame_baton *nf_baton = baton;
 299
 300   *start = &lit0;
 301   *length = 1;
 302
 303   nf_baton->needs_frame = 1;
 304 }
 305
 306 /* Thread-local accesses do require a frame.  */
 307 static CORE_ADDR
 308 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 309 {
 310   struct needs_frame_baton *nf_baton = baton;
 311   nf_baton->needs_frame = 1;
 312   return 1;
 313 }
 314
 315 /* Return non-zero iff the location expression at DATA (length SIZE)
 316    requires a frame to evaluate.  */
 317
 318 static int
 319 dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size)
 320 {
 321   struct needs_frame_baton baton;
 322   struct dwarf_expr_context *ctx;
 323   int in_reg;
 324
 325   baton.needs_frame = 0;
 326
 327   ctx = new_dwarf_expr_context ();
 328   ctx->baton = &baton;
 329   ctx->read_reg = needs_frame_read_reg;
 330   ctx->read_mem = needs_frame_read_mem;
 331   ctx->get_frame_base = needs_frame_frame_base;
 332   ctx->get_tls_address = needs_frame_tls_address;
 333
 334   dwarf_expr_eval (ctx, data, size);
 335
 336   in_reg = ctx->in_reg;
 337
 338   if (ctx->num_pieces > 0)
 339     {
 340       int i;
 341
 342       /* If the location has several pieces, and any of them are in
 343          registers, then we will need a frame to fetch them from.  */
 344       for (i = 0; i < ctx->num_pieces; i++)
 345         if (ctx->pieces[i].in_reg)
 346           in_reg = 1;
 347     }
 348
 349   free_dwarf_expr_context (ctx);
 350
 351   return baton.needs_frame || in_reg;
 352 }
 353
 354 static void
 355 dwarf2_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax,
 356                            struct axs_value *value, gdb_byte *data,
 357                            int size)
 358 {
 359   if (size == 0)
 360     error (_("Symbol \"%s\" has been optimized out."),
 361            SYMBOL_PRINT_NAME (symbol));
 362
 363   if (size == 1
 364       && data[0] >= DW_OP_reg0
 365       && data[0] <= DW_OP_reg31)
 366     {
 367       value->kind = axs_lvalue_register;
 368       value->u.reg = data[0] - DW_OP_reg0;
 369     }
 370   else if (data[0] == DW_OP_regx)
 371     {
 372       ULONGEST reg;
 373       read_uleb128 (data + 1, data + size, &reg);
 374       value->kind = axs_lvalue_register;
 375       value->u.reg = reg;
 376     }
 377   else if (data[0] == DW_OP_fbreg)
 378     {
 379       /* And this is worse than just minimal; we should honor the frame base
 380          as above.  */
 381       int frame_reg;
 382       LONGEST frame_offset;
 383       gdb_byte *buf_end;
 384
 385       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
 386       if (buf_end != data + size)
 387         error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
 388                SYMBOL_PRINT_NAME (symbol));
 389
 390       TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
 391       ax_reg (ax, frame_reg);
 392       ax_const_l (ax, frame_offset);
 393       ax_simple (ax, aop_add);
 394
 395       value->kind = axs_lvalue_memory;
 396     }
 397   else if (data[0] >= DW_OP_breg0
 398            && data[0] <= DW_OP_breg31)
 399     {
 400       unsigned int reg;
 401       LONGEST offset;
 402       gdb_byte *buf_end;
 403
 404       reg = data[0] - DW_OP_breg0;
 405       buf_end = read_sleb128 (data + 1, data + size, &offset);
 406       if (buf_end != data + size)
 407         error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
 408                reg, SYMBOL_PRINT_NAME (symbol));
 409
 410       ax_reg (ax, reg);
 411       ax_const_l (ax, offset);
 412       ax_simple (ax, aop_add);
 413
 414       value->kind = axs_lvalue_memory;
 415     }
 416   else
 417     error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
 418            data[0], SYMBOL_PRINT_NAME (symbol));
 419 }
 420 \f
 421 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 422    evaluator to calculate the location.  */
 423 static struct value *
 424 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
 425 {
 426   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 427   struct value *val;
 428   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
 429                                   dlbaton->objfile);
 430
 431   return val;
 432 }
 433
 434 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 435 static int
 436 locexpr_read_needs_frame (struct symbol *symbol)
 437 {
 438   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 439   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size);
 440 }
 441
 442 /* Print a natural-language description of SYMBOL to STREAM.  */
 443 static int
 444 locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
 445 {
 446   /* FIXME: be more extensive.  */
 447   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 448
 449   if (dlbaton->size == 1
 450       && dlbaton->data[0] >= DW_OP_reg0
 451       && dlbaton->data[0] <= DW_OP_reg31)
 452     {
 453       int regno = DWARF2_REG_TO_REGNUM (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 };