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   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       TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
 389       ax_reg (ax, frame_reg);
 390       ax_const_l (ax, frame_offset);
 391       ax_simple (ax, aop_add);
 392
 393       value->kind = axs_lvalue_memory;
 394     }
 395   else if (data[0] >= DW_OP_breg0
 396            && data[0] <= DW_OP_breg31)
 397     {
 398       unsigned int reg;
 399       LONGEST offset;
 400       gdb_byte *buf_end;
 401
 402       reg = data[0] - DW_OP_breg0;
 403       buf_end = read_sleb128 (data + 1, data + size, &offset);
 404       if (buf_end != data + size)
 405         error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
 406                reg, SYMBOL_PRINT_NAME (symbol));
 407
 408       ax_reg (ax, reg);
 409       ax_const_l (ax, offset);
 410       ax_simple (ax, aop_add);
 411
 412       value->kind = axs_lvalue_memory;
 413     }
 414   else
 415     error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
 416            data[0], SYMBOL_PRINT_NAME (symbol));
 417 }
 418 \f
 419 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 420    evaluator to calculate the location.  */
 421 static struct value *
 422 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
 423 {
 424   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 425   struct value *val;
 426   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
 427                                   dlbaton->objfile);
 428
 429   return val;
 430 }
 431
 432 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 433 static int
 434 locexpr_read_needs_frame (struct symbol *symbol)
 435 {
 436   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 437   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size);
 438 }
 439
 440 /* Print a natural-language description of SYMBOL to STREAM.  */
 441 static int
 442 locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
 443 {
 444   /* FIXME: be more extensive.  */
 445   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 446
 447   if (dlbaton->size == 1
 448       && dlbaton->data[0] >= DW_OP_reg0
 449       && dlbaton->data[0] <= DW_OP_reg31)
 450     {
 451       int regno = DWARF2_REG_TO_REGNUM (dlbaton->data[0] - DW_OP_reg0);
 452       fprintf_filtered (stream,
 453                         "a variable in register %s", REGISTER_NAME (regno));
 454       return 1;
 455     }
 456
 457   /* The location expression for a TLS variable looks like this (on a
 458      64-bit LE machine):
 459
 460      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
 461                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
 462
 463      0x3 is the encoding for DW_OP_addr, which has an operand as long
 464      as the size of an address on the target machine (here is 8
 465      bytes).  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
 466      The operand represents the offset at which the variable is within
 467      the thread local storage.  */
 468
 469   if (dlbaton->size > 1
 470       && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
 471     if (dlbaton->data[0] == DW_OP_addr)
 472       {
 473         int bytes_read;
 474         CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1],
 475                                                 &dlbaton->data[dlbaton->size - 1],
 476                                                 &bytes_read);
 477         fprintf_filtered (stream,
 478                           "a thread-local variable at offset %s in the "
 479                           "thread-local storage for `%s'",
 480                           paddr_nz (offset), dlbaton->objfile->name);
 481         return 1;
 482       }
 483
 484
 485   fprintf_filtered (stream,
 486                     "a variable with complex or multiple locations (DWARF2)");
 487   return 1;
 488 }
 489
 490
 491 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 492    any necessary bytecode in AX.
 493
 494    NOTE drow/2003-02-26: This function is extremely minimal, because
 495    doing it correctly is extremely complicated and there is no
 496    publicly available stub with tracepoint support for me to test
 497    against.  When there is one this function should be revisited.  */
 498
 499 static void
 500 locexpr_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 501                             struct axs_value * value)
 502 {
 503   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 504
 505   dwarf2_tracepoint_var_ref (symbol, ax, value, dlbaton->data, dlbaton->size);
 506 }
 507
 508 /* The set of location functions used with the DWARF-2 expression
 509    evaluator.  */
 510 const struct symbol_ops dwarf2_locexpr_funcs = {
 511   locexpr_read_variable,
 512   locexpr_read_needs_frame,
 513   locexpr_describe_location,
 514   locexpr_tracepoint_var_ref
 515 };
 516
 517
 518 /* Wrapper functions for location lists.  These generally find
 519    the appropriate location expression and call something above.  */
 520
 521 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 522    evaluator to calculate the location.  */
 523 static struct value *
 524 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 525 {
 526   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 527   struct value *val;
 528   gdb_byte *data;
 529   size_t size;
 530
 531   data = find_location_expression (dlbaton, &size,
 532                                    frame ? get_frame_address_in_block (frame)
 533                                    : 0);
 534   if (data == NULL)
 535     {
 536       val = allocate_value (SYMBOL_TYPE (symbol));
 537       VALUE_LVAL (val) = not_lval;
 538       set_value_optimized_out (val, 1);
 539     }
 540   else
 541     val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
 542                                     dlbaton->objfile);
 543
 544   return val;
 545 }
 546
 547 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 548 static int
 549 loclist_read_needs_frame (struct symbol *symbol)
 550 {
 551   /* If there's a location list, then assume we need to have a frame
 552      to choose the appropriate location expression.  With tracking of
 553      global variables this is not necessarily true, but such tracking
 554      is disabled in GCC at the moment until we figure out how to
 555      represent it.  */
 556
 557   return 1;
 558 }
 559
 560 /* Print a natural-language description of SYMBOL to STREAM.  */
 561 static int
 562 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 563 {
 564   /* FIXME: Could print the entire list of locations.  */
 565   fprintf_filtered (stream, "a variable with multiple locations");
 566   return 1;
 567 }
 568
 569 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 570    any necessary bytecode in AX.  */
 571 static void
 572 loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 573                             struct axs_value * value)
 574 {
 575   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 576   gdb_byte *data;
 577   size_t size;
 578
 579   data = find_location_expression (dlbaton, &size, ax->scope);
 580   if (data == NULL)
 581     error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol));
 582
 583   dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
 584 }
 585
 586 /* The set of location functions used with the DWARF-2 expression
 587    evaluator and location lists.  */
 588 const struct symbol_ops dwarf2_loclist_funcs = {
 589   loclist_read_variable,
 590   loclist_read_needs_frame,
 591   loclist_describe_location,
 592   loclist_tracepoint_var_ref
 593 };