contrib/gdb/gdb/dwarf2loc.c

   1 /* DWARF 2 location expression support for GDB.
   2    Copyright 2003 Free Software Foundation, Inc.
   3    Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or (at
  10    your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "ui-out.h"
  24 #include "value.h"
  25 #include "frame.h"
  26 #include "gdbcore.h"
  27 #include "target.h"
  28 #include "inferior.h"
  29 #include "ax.h"
  30 #include "ax-gdb.h"
  31 #include "regcache.h"
  32 #include "objfiles.h"
  33
  34 #include "elf/dwarf2.h"
  35 #include "dwarf2expr.h"
  36 #include "dwarf2loc.h"
  37
  38 #include "gdb_string.h"
  39
  40 #ifndef DWARF2_REG_TO_REGNUM
  41 #define DWARF2_REG_TO_REGNUM(REG) (REG)
  42 #endif
  43
  44 /* A helper function for dealing with location lists.  Given a
  45    symbol baton (BATON) and a pc value (PC), find the appropriate
  46    location expression, set *LOCEXPR_LENGTH, and return a pointer
  47    to the beginning of the expression.  Returns NULL on failure.
  48
  49    For now, only return the first matching location expression; there
  50    can be more than one in the list.  */
  51
  52 static char *
  53 find_location_expression (struct dwarf2_loclist_baton *baton,
  54                           size_t *locexpr_length, CORE_ADDR pc)
  55 {
  56   CORE_ADDR low, high;
  57   char *loc_ptr, *buf_end;
  58   unsigned int addr_size = TARGET_ADDR_BIT / TARGET_CHAR_BIT, length;
  59   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
  60   /* Adjust base_address for relocatable objects.  */
  61   CORE_ADDR base_offset = ANOFFSET (baton->objfile->section_offsets,
  62                                     SECT_OFF_TEXT (baton->objfile));
  63   CORE_ADDR base_address = baton->base_address + base_offset;
  64
  65   loc_ptr = baton->data;
  66   buf_end = baton->data + baton->size;
  67
  68   while (1)
  69     {
  70       low = dwarf2_read_address (loc_ptr, buf_end, &length);
  71       loc_ptr += length;
  72       high = dwarf2_read_address (loc_ptr, buf_end, &length);
  73       loc_ptr += length;
  74
  75       /* An end-of-list entry.  */
  76       if (low == 0 && high == 0)
  77         return NULL;
  78
  79       /* A base-address-selection entry.  */
  80       if ((low & base_mask) == base_mask)
  81         {
  82           base_address = high;
  83           continue;
  84         }
  85
  86       /* Otherwise, a location expression entry.  */
  87       low += base_address;
  88       high += base_address;
  89
  90       length = extract_unsigned_integer (loc_ptr, 2);
  91       loc_ptr += 2;
  92
  93       if (pc >= low && pc < high)
  94         {
  95           *locexpr_length = length;
  96           return loc_ptr;
  97         }
  98
  99       loc_ptr += length;
 100     }
 101 }
 102
 103 /* This is the baton used when performing dwarf2 expression
 104    evaluation.  */
 105 struct dwarf_expr_baton
 106 {
 107   struct frame_info *frame;
 108   struct objfile *objfile;
 109 };
 110
 111 /* Helper functions for dwarf2_evaluate_loc_desc.  */
 112
 113 /* Using the frame specified in BATON, read register REGNUM.  The lval
 114    type will be returned in LVALP, and for lval_memory the register
 115    save address will be returned in ADDRP.  */
 116 static CORE_ADDR
 117 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
 118 {
 119   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 120   CORE_ADDR result, save_addr;
 121   enum lval_type lval_type;
 122   char *buf;
 123   int optimized, regnum, realnum, regsize;
 124
 125   regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
 126   regsize = register_size (current_gdbarch, regnum);
 127   buf = (char *) alloca (regsize);
 128
 129   frame_register (debaton->frame, regnum, &optimized, &lval_type, &save_addr,
 130                   &realnum, buf);
 131   /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
 132      address is always unsigned.  That may or may not be true.  */
 133   result = extract_unsigned_integer (buf, regsize);
 134
 135   return result;
 136 }
 137
 138 /* Read memory at ADDR (length LEN) into BUF.  */
 139
 140 static void
 141 dwarf_expr_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
 142 {
 143   read_memory (addr, buf, len);
 144 }
 145
 146 /* Using the frame specified in BATON, find the location expression
 147    describing the frame base.  Return a pointer to it in START and
 148    its length in LENGTH.  */
 149 static void
 150 dwarf_expr_frame_base (void *baton, unsigned char **start, size_t * length)
 151 {
 152   /* FIXME: cagney/2003-03-26: This code should be using
 153      get_frame_base_address(), and then implement a dwarf2 specific
 154      this_base method.  */
 155   struct symbol *framefunc;
 156   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 157
 158   framefunc = get_frame_function (debaton->frame);
 159
 160   if (SYMBOL_OPS (framefunc) == &dwarf2_loclist_funcs)
 161     {
 162       struct dwarf2_loclist_baton *symbaton;
 163       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 164       *start = find_location_expression (symbaton, length,
 165                                          get_frame_pc (debaton->frame));
 166     }
 167   else
 168     {
 169       struct dwarf2_locexpr_baton *symbaton;
 170       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 171       *length = symbaton->size;
 172       *start = symbaton->data;
 173     }
 174
 175   if (*start == NULL)
 176     error ("Could not find the frame base for \"%s\".",
 177            SYMBOL_NATURAL_NAME (framefunc));
 178 }
 179
 180 /* Using the objfile specified in BATON, find the address for the
 181    current thread's thread-local storage with offset OFFSET.  */
 182 static CORE_ADDR
 183 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 184 {
 185   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 186   CORE_ADDR addr;
 187
 188   if (target_get_thread_local_address_p ())
 189     addr = target_get_thread_local_address (inferior_ptid,
 190                                             debaton->objfile,
 191                                             offset);
 192   /* It wouldn't be wrong here to try a gdbarch method, too; finding
 193      TLS is an ABI-specific thing.  But we don't do that yet.  */
 194   else
 195     error ("Cannot find thread-local variables on this target");
 196
 197   return addr;
 198 }
 199
 200 /* Evaluate a location description, starting at DATA and with length
 201    SIZE, to find the current location of variable VAR in the context
 202    of FRAME.  */
 203 static struct value *
 204 dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
 205                           unsigned char *data, unsigned short size,
 206                           struct objfile *objfile)
 207 {
 208   CORE_ADDR result;
 209   struct gdbarch *arch = get_frame_arch (frame);
 210   struct value *retval;
 211   struct dwarf_expr_baton baton;
 212   struct dwarf_expr_context *ctx;
 213
 214   if (size == 0)
 215     {
 216       retval = allocate_value (SYMBOL_TYPE (var));
 217       VALUE_LVAL (retval) = not_lval;
 218       VALUE_OPTIMIZED_OUT (retval) = 1;
 219     }
 220
 221   baton.frame = frame;
 222   baton.objfile = objfile;
 223
 224   ctx = new_dwarf_expr_context ();
 225   ctx->baton = &baton;
 226   ctx->read_reg = dwarf_expr_read_reg;
 227   ctx->read_mem = dwarf_expr_read_mem;
 228   ctx->get_frame_base = dwarf_expr_frame_base;
 229   ctx->get_tls_address = dwarf_expr_tls_address;
 230
 231   dwarf_expr_eval (ctx, data, size);
 232   result = dwarf_expr_fetch (ctx, 0);
 233
 234   if (ctx->num_pieces > 0)
 235     {
 236       int i;
 237       long offset = 0;
 238       bfd_byte *contents;
 239
 240       retval = allocate_value (SYMBOL_TYPE (var));
 241       contents = VALUE_CONTENTS_RAW (retval);
 242       for (i = 0; i < ctx->num_pieces; i++)
 243        {
 244          struct dwarf_expr_piece *p = &ctx->pieces[i];
 245          if (p->in_reg)
 246            {
 247              bfd_byte regval[MAX_REGISTER_SIZE];
 248              int gdb_regnum = DWARF2_REG_TO_REGNUM (p->value);
 249              get_frame_register (frame, gdb_regnum, regval);
 250              memcpy (contents + offset, regval, p->size);
 251            }
 252          else /* In memory?  */
 253            {
 254              read_memory (p->value, contents + offset, p->size);
 255            }
 256          offset += p->size;
 257        }
 258      }
 259   else if (ctx->in_reg)
 260     {
 261       int regnum = DWARF2_REG_TO_REGNUM (result);
 262       retval = value_from_register (SYMBOL_TYPE (var), regnum, frame);
 263     }
 264   else
 265     {
 266       retval = allocate_value (SYMBOL_TYPE (var));
 267       VALUE_BFD_SECTION (retval) = SYMBOL_BFD_SECTION (var);
 268
 269       VALUE_LVAL (retval) = lval_memory;
 270       VALUE_LAZY (retval) = 1;
 271       VALUE_ADDRESS (retval) = result;
 272     }
 273
 274   set_value_initialized (retval, ctx->initialized);
 275
 276   free_dwarf_expr_context (ctx);
 277
 278   return retval;
 279 }
 280
 281
 282
 283
 284 \f
 285 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 286
 287 struct needs_frame_baton
 288 {
 289   int needs_frame;
 290 };
 291
 292 /* Reads from registers do require a frame.  */
 293 static CORE_ADDR
 294 needs_frame_read_reg (void *baton, int regnum)
 295 {
 296   struct needs_frame_baton *nf_baton = baton;
 297   nf_baton->needs_frame = 1;
 298   return 1;
 299 }
 300
 301 /* Reads from memory do not require a frame.  */
 302 static void
 303 needs_frame_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
 304 {
 305   memset (buf, 0, len);
 306 }
 307
 308 /* Frame-relative accesses do require a frame.  */
 309 static void
 310 needs_frame_frame_base (void *baton, unsigned char **start, size_t * length)
 311 {
 312   static char lit0 = DW_OP_lit0;
 313   struct needs_frame_baton *nf_baton = baton;
 314
 315   *start = &lit0;
 316   *length = 1;
 317
 318   nf_baton->needs_frame = 1;
 319 }
 320
 321 /* Thread-local accesses do require a frame.  */
 322 static CORE_ADDR
 323 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 324 {
 325   struct needs_frame_baton *nf_baton = baton;
 326   nf_baton->needs_frame = 1;
 327   return 1;
 328 }
 329
 330 /* Return non-zero iff the location expression at DATA (length SIZE)
 331    requires a frame to evaluate.  */
 332
 333 static int
 334 dwarf2_loc_desc_needs_frame (unsigned char *data, unsigned short size)
 335 {
 336   struct needs_frame_baton baton;
 337   struct dwarf_expr_context *ctx;
 338   int in_reg;
 339
 340   baton.needs_frame = 0;
 341
 342   ctx = new_dwarf_expr_context ();
 343   ctx->baton = &baton;
 344   ctx->read_reg = needs_frame_read_reg;
 345   ctx->read_mem = needs_frame_read_mem;
 346   ctx->get_frame_base = needs_frame_frame_base;
 347   ctx->get_tls_address = needs_frame_tls_address;
 348
 349   dwarf_expr_eval (ctx, data, size);
 350
 351   in_reg = ctx->in_reg;
 352
 353   if (ctx->num_pieces > 0)
 354     {
 355       int i;
 356
 357       /* If the location has several pieces, and any of them are in
 358          registers, then we will need a frame to fetch them from.  */
 359       for (i = 0; i < ctx->num_pieces; i++)
 360         if (ctx->pieces[i].in_reg)
 361           in_reg = 1;
 362     }
 363
 364   free_dwarf_expr_context (ctx);
 365
 366   return baton.needs_frame || in_reg;
 367 }
 368
 369 static void
 370 dwarf2_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 371                            struct axs_value * value, unsigned char *data,
 372                            int size)
 373 {
 374   if (size == 0)
 375     error ("Symbol \"%s\" has been optimized out.",
 376            SYMBOL_PRINT_NAME (symbol));
 377
 378   if (size == 1
 379       && data[0] >= DW_OP_reg0
 380       && data[0] <= DW_OP_reg31)
 381     {
 382       value->kind = axs_lvalue_register;
 383       value->u.reg = data[0] - DW_OP_reg0;
 384     }
 385   else if (data[0] == DW_OP_regx)
 386     {
 387       ULONGEST reg;
 388       read_uleb128 (data + 1, data + size, &reg);
 389       value->kind = axs_lvalue_register;
 390       value->u.reg = reg;
 391     }
 392   else if (data[0] == DW_OP_fbreg)
 393     {
 394       /* And this is worse than just minimal; we should honor the frame base
 395          as above.  */
 396       int frame_reg;
 397       LONGEST frame_offset;
 398       unsigned char *buf_end;
 399
 400       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
 401       if (buf_end != data + size)
 402         error ("Unexpected opcode after DW_OP_fbreg for symbol \"%s\".",
 403                SYMBOL_PRINT_NAME (symbol));
 404
 405       TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
 406       ax_reg (ax, frame_reg);
 407       ax_const_l (ax, frame_offset);
 408       ax_simple (ax, aop_add);
 409
 410       ax_const_l (ax, frame_offset);
 411       ax_simple (ax, aop_add);
 412       value->kind = axs_lvalue_memory;
 413     }
 414   else
 415     error ("Unsupported DWARF opcode in the location of \"%s\".",
 416            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   unsigned char *data;
 529   size_t size;
 530
 531   data = find_location_expression (dlbaton, &size,
 532                                    frame ? get_frame_pc (frame) : 0);
 533   if (data == NULL)
 534     {
 535       val = allocate_value (SYMBOL_TYPE (symbol));
 536       VALUE_LVAL (val) = not_lval;
 537       VALUE_OPTIMIZED_OUT (val) = 1;
 538     }
 539   else
 540     val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
 541                                     dlbaton->objfile);
 542
 543   return val;
 544 }
 545
 546 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 547 static int
 548 loclist_read_needs_frame (struct symbol *symbol)
 549 {
 550   /* If there's a location list, then assume we need to have a frame
 551      to choose the appropriate location expression.  With tracking of
 552      global variables this is not necessarily true, but such tracking
 553      is disabled in GCC at the moment until we figure out how to
 554      represent it.  */
 555
 556   return 1;
 557 }
 558
 559 /* Print a natural-language description of SYMBOL to STREAM.  */
 560 static int
 561 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 562 {
 563   /* FIXME: Could print the entire list of locations.  */
 564   fprintf_filtered (stream, "a variable with multiple locations");
 565   return 1;
 566 }
 567
 568 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 569    any necessary bytecode in AX.  */
 570 static void
 571 loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 572                             struct axs_value * value)
 573 {
 574   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 575   unsigned char *data;
 576   size_t size;
 577
 578   data = find_location_expression (dlbaton, &size, ax->scope);
 579   if (data == NULL)
 580     error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol));
 581
 582   dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
 583 }
 584
 585 /* The set of location functions used with the DWARF-2 expression
 586    evaluator and location lists.  */
 587 const struct symbol_ops dwarf2_loclist_funcs = {
 588   loclist_read_variable,
 589   loclist_read_needs_frame,
 590   loclist_describe_location,
 591   loclist_tracepoint_var_ref
 592 };