gdb/dwarf2loc.c

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