gdb/dwarf2loc.c

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