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", REGISTER_NAME (regno));
 456       return 1;
 457     }
 458
 459   /* The location expression for a TLS variable looks like this (on a
 460      64-bit LE machine):
 461
 462      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
 463                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
 464
 465      0x3 is the encoding for DW_OP_addr, which has an operand as long
 466      as the size of an address on the target machine (here is 8
 467      bytes).  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
 468      The operand represents the offset at which the variable is within
 469      the thread local storage.  */
 470
 471   if (dlbaton->size > 1
 472       && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
 473     if (dlbaton->data[0] == DW_OP_addr)
 474       {
 475         int bytes_read;
 476         CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1],
 477                                                 &dlbaton->data[dlbaton->size - 1],
 478                                                 &bytes_read);
 479         fprintf_filtered (stream,
 480                           "a thread-local variable at offset %s in the "
 481                           "thread-local storage for `%s'",
 482                           paddr_nz (offset), dlbaton->objfile->name);
 483         return 1;
 484       }
 485
 486
 487   fprintf_filtered (stream,
 488                     "a variable with complex or multiple locations (DWARF2)");
 489   return 1;
 490 }
 491
 492
 493 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 494    any necessary bytecode in AX.
 495
 496    NOTE drow/2003-02-26: This function is extremely minimal, because
 497    doing it correctly is extremely complicated and there is no
 498    publicly available stub with tracepoint support for me to test
 499    against.  When there is one this function should be revisited.  */
 500
 501 static void
 502 locexpr_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 503                             struct axs_value * value)
 504 {
 505   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 506
 507   dwarf2_tracepoint_var_ref (symbol, ax, value, dlbaton->data, dlbaton->size);
 508 }
 509
 510 /* The set of location functions used with the DWARF-2 expression
 511    evaluator.  */
 512 const struct symbol_ops dwarf2_locexpr_funcs = {
 513   locexpr_read_variable,
 514   locexpr_read_needs_frame,
 515   locexpr_describe_location,
 516   locexpr_tracepoint_var_ref
 517 };
 518
 519
 520 /* Wrapper functions for location lists.  These generally find
 521    the appropriate location expression and call something above.  */
 522
 523 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 524    evaluator to calculate the location.  */
 525 static struct value *
 526 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 527 {
 528   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 529   struct value *val;
 530   gdb_byte *data;
 531   size_t size;
 532
 533   data = find_location_expression (dlbaton, &size,
 534                                    frame ? get_frame_address_in_block (frame)
 535                                    : 0);
 536   if (data == NULL)
 537     {
 538       val = allocate_value (SYMBOL_TYPE (symbol));
 539       VALUE_LVAL (val) = not_lval;
 540       set_value_optimized_out (val, 1);
 541     }
 542   else
 543     val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
 544                                     dlbaton->objfile);
 545
 546   return val;
 547 }
 548
 549 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 550 static int
 551 loclist_read_needs_frame (struct symbol *symbol)
 552 {
 553   /* If there's a location list, then assume we need to have a frame
 554      to choose the appropriate location expression.  With tracking of
 555      global variables this is not necessarily true, but such tracking
 556      is disabled in GCC at the moment until we figure out how to
 557      represent it.  */
 558
 559   return 1;
 560 }
 561
 562 /* Print a natural-language description of SYMBOL to STREAM.  */
 563 static int
 564 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 565 {
 566   /* FIXME: Could print the entire list of locations.  */
 567   fprintf_filtered (stream, "a variable with multiple locations");
 568   return 1;
 569 }
 570
 571 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 572    any necessary bytecode in AX.  */
 573 static void
 574 loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 575                             struct axs_value * value)
 576 {
 577   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 578   gdb_byte *data;
 579   size_t size;
 580
 581   data = find_location_expression (dlbaton, &size, ax->scope);
 582   if (data == NULL)
 583     error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol));
 584
 585   dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
 586 }
 587
 588 /* The set of location functions used with the DWARF-2 expression
 589    evaluator and location lists.  */
 590 const struct symbol_ops dwarf2_loclist_funcs = {
 591   loclist_read_variable,
 592   loclist_read_needs_frame,
 593   loclist_describe_location,
 594   loclist_tracepoint_var_ref
 595 };