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   struct value *retval;
 209   struct dwarf_expr_baton baton;
 210   struct dwarf_expr_context *ctx;
 211
 212   if (size == 0)
 213     {
 214       retval = allocate_value (SYMBOL_TYPE (var));
 215       VALUE_LVAL (retval) = not_lval;
 216       VALUE_OPTIMIZED_OUT (retval) = 1;
 217     }
 218
 219   baton.frame = frame;
 220   baton.objfile = objfile;
 221
 222   ctx = new_dwarf_expr_context ();
 223   ctx->baton = &baton;
 224   ctx->read_reg = dwarf_expr_read_reg;
 225   ctx->read_mem = dwarf_expr_read_mem;
 226   ctx->get_frame_base = dwarf_expr_frame_base;
 227   ctx->get_tls_address = dwarf_expr_tls_address;
 228
 229   dwarf_expr_eval (ctx, data, size);
 230
 231   if (ctx->in_reg)
 232     {
 233       CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
 234       int gdb_regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
 235       retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
 236     }
 237   else
 238     {
 239       CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
 240
 241       retval = allocate_value (SYMBOL_TYPE (var));
 242       VALUE_BFD_SECTION (retval) = SYMBOL_BFD_SECTION (var);
 243
 244       VALUE_LVAL (retval) = lval_memory;
 245       VALUE_LAZY (retval) = 1;
 246       VALUE_ADDRESS (retval) = address;
 247     }
 248
 249   free_dwarf_expr_context (ctx);
 250
 251   return retval;
 252 }
 253
 254
 255
 256
 257 \f
 258 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 259
 260 struct needs_frame_baton
 261 {
 262   int needs_frame;
 263 };
 264
 265 /* Reads from registers do require a frame.  */
 266 static CORE_ADDR
 267 needs_frame_read_reg (void *baton, int regnum)
 268 {
 269   struct needs_frame_baton *nf_baton = baton;
 270   nf_baton->needs_frame = 1;
 271   return 1;
 272 }
 273
 274 /* Reads from memory do not require a frame.  */
 275 static void
 276 needs_frame_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
 277 {
 278   memset (buf, 0, len);
 279 }
 280
 281 /* Frame-relative accesses do require a frame.  */
 282 static void
 283 needs_frame_frame_base (void *baton, unsigned char **start, size_t * length)
 284 {
 285   static char lit0 = DW_OP_lit0;
 286   struct needs_frame_baton *nf_baton = baton;
 287
 288   *start = &lit0;
 289   *length = 1;
 290
 291   nf_baton->needs_frame = 1;
 292 }
 293
 294 /* Thread-local accesses do require a frame.  */
 295 static CORE_ADDR
 296 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 297 {
 298   struct needs_frame_baton *nf_baton = baton;
 299   nf_baton->needs_frame = 1;
 300   return 1;
 301 }
 302
 303 /* Return non-zero iff the location expression at DATA (length SIZE)
 304    requires a frame to evaluate.  */
 305
 306 static int
 307 dwarf2_loc_desc_needs_frame (unsigned char *data, unsigned short size)
 308 {
 309   struct needs_frame_baton baton;
 310   struct dwarf_expr_context *ctx;
 311   int in_reg;
 312
 313   baton.needs_frame = 0;
 314
 315   ctx = new_dwarf_expr_context ();
 316   ctx->baton = &baton;
 317   ctx->read_reg = needs_frame_read_reg;
 318   ctx->read_mem = needs_frame_read_mem;
 319   ctx->get_frame_base = needs_frame_frame_base;
 320   ctx->get_tls_address = needs_frame_tls_address;
 321
 322   dwarf_expr_eval (ctx, data, size);
 323
 324   in_reg = ctx->in_reg;
 325
 326   free_dwarf_expr_context (ctx);
 327
 328   return baton.needs_frame || in_reg;
 329 }
 330
 331 static void
 332 dwarf2_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 333                            struct axs_value * value, unsigned char *data,
 334                            int size)
 335 {
 336   if (size == 0)
 337     error ("Symbol \"%s\" has been optimized out.",
 338            SYMBOL_PRINT_NAME (symbol));
 339
 340   if (size == 1
 341       && data[0] >= DW_OP_reg0
 342       && data[0] <= DW_OP_reg31)
 343     {
 344       value->kind = axs_lvalue_register;
 345       value->u.reg = data[0] - DW_OP_reg0;
 346     }
 347   else if (data[0] == DW_OP_regx)
 348     {
 349       ULONGEST reg;
 350       read_uleb128 (data + 1, data + size, &reg);
 351       value->kind = axs_lvalue_register;
 352       value->u.reg = reg;
 353     }
 354   else if (data[0] == DW_OP_fbreg)
 355     {
 356       /* And this is worse than just minimal; we should honor the frame base
 357          as above.  */
 358       int frame_reg;
 359       LONGEST frame_offset;
 360       unsigned char *buf_end;
 361
 362       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
 363       if (buf_end != data + size)
 364         error ("Unexpected opcode after DW_OP_fbreg for symbol \"%s\".",
 365                SYMBOL_PRINT_NAME (symbol));
 366
 367       TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
 368       ax_reg (ax, frame_reg);
 369       ax_const_l (ax, frame_offset);
 370       ax_simple (ax, aop_add);
 371
 372       ax_const_l (ax, frame_offset);
 373       ax_simple (ax, aop_add);
 374       value->kind = axs_lvalue_memory;
 375     }
 376   else
 377     error ("Unsupported DWARF opcode in the location of \"%s\".",
 378            SYMBOL_PRINT_NAME (symbol));
 379 }
 380 \f
 381 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 382    evaluator to calculate the location.  */
 383 static struct value *
 384 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
 385 {
 386   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 387   struct value *val;
 388   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
 389                                   dlbaton->objfile);
 390
 391   return val;
 392 }
 393
 394 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 395 static int
 396 locexpr_read_needs_frame (struct symbol *symbol)
 397 {
 398   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 399   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size);
 400 }
 401
 402 /* Print a natural-language description of SYMBOL to STREAM.  */
 403 static int
 404 locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
 405 {
 406   /* FIXME: be more extensive.  */
 407   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 408
 409   if (dlbaton->size == 1
 410       && dlbaton->data[0] >= DW_OP_reg0
 411       && dlbaton->data[0] <= DW_OP_reg31)
 412     {
 413       int regno = DWARF2_REG_TO_REGNUM (dlbaton->data[0] - DW_OP_reg0);
 414       fprintf_filtered (stream,
 415                         "a variable in register %s", REGISTER_NAME (regno));
 416       return 1;
 417     }
 418
 419   /* The location expression for a TLS variable looks like this (on a
 420      64-bit LE machine):
 421
 422      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
 423                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
 424
 425      0x3 is the encoding for DW_OP_addr, which has an operand as long
 426      as the size of an address on the target machine (here is 8
 427      bytes).  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
 428      The operand represents the offset at which the variable is within
 429      the thread local storage.  */
 430
 431   if (dlbaton->size > 1
 432       && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
 433     if (dlbaton->data[0] == DW_OP_addr)
 434       {
 435         int bytes_read;
 436         CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1],
 437                                                 &dlbaton->data[dlbaton->size - 1],
 438                                                 &bytes_read);
 439         fprintf_filtered (stream,
 440                           "a thread-local variable at offset %s in the "
 441                           "thread-local storage for `%s'",
 442                           paddr_nz (offset), dlbaton->objfile->name);
 443         return 1;
 444       }
 445
 446
 447   fprintf_filtered (stream,
 448                     "a variable with complex or multiple locations (DWARF2)");
 449   return 1;
 450 }
 451
 452
 453 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 454    any necessary bytecode in AX.
 455
 456    NOTE drow/2003-02-26: This function is extremely minimal, because
 457    doing it correctly is extremely complicated and there is no
 458    publicly available stub with tracepoint support for me to test
 459    against.  When there is one this function should be revisited.  */
 460
 461 static void
 462 locexpr_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 463                             struct axs_value * value)
 464 {
 465   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 466
 467   dwarf2_tracepoint_var_ref (symbol, ax, value, dlbaton->data, dlbaton->size);
 468 }
 469
 470 /* The set of location functions used with the DWARF-2 expression
 471    evaluator.  */
 472 const struct symbol_ops dwarf2_locexpr_funcs = {
 473   locexpr_read_variable,
 474   locexpr_read_needs_frame,
 475   locexpr_describe_location,
 476   locexpr_tracepoint_var_ref
 477 };
 478
 479
 480 /* Wrapper functions for location lists.  These generally find
 481    the appropriate location expression and call something above.  */
 482
 483 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 484    evaluator to calculate the location.  */
 485 static struct value *
 486 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 487 {
 488   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 489   struct value *val;
 490   unsigned char *data;
 491   size_t size;
 492
 493   data = find_location_expression (dlbaton, &size,
 494                                    frame ? get_frame_pc (frame) : 0);
 495   if (data == NULL)
 496     error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol));
 497
 498   val = dwarf2_evaluate_loc_desc (symbol, frame, data, size, dlbaton->objfile);
 499
 500   return val;
 501 }
 502
 503 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 504 static int
 505 loclist_read_needs_frame (struct symbol *symbol)
 506 {
 507   /* If there's a location list, then assume we need to have a frame
 508      to choose the appropriate location expression.  With tracking of
 509      global variables this is not necessarily true, but such tracking
 510      is disabled in GCC at the moment until we figure out how to
 511      represent it.  */
 512
 513   return 1;
 514 }
 515
 516 /* Print a natural-language description of SYMBOL to STREAM.  */
 517 static int
 518 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 519 {
 520   /* FIXME: Could print the entire list of locations.  */
 521   fprintf_filtered (stream, "a variable with multiple locations");
 522   return 1;
 523 }
 524
 525 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 526    any necessary bytecode in AX.  */
 527 static void
 528 loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 529                             struct axs_value * value)
 530 {
 531   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 532   unsigned char *data;
 533   size_t size;
 534
 535   data = find_location_expression (dlbaton, &size, ax->scope);
 536   if (data == NULL)
 537     error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol));
 538
 539   dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
 540 }
 541
 542 /* The set of location functions used with the DWARF-2 expression
 543    evaluator and location lists.  */
 544 const struct symbol_ops dwarf2_loclist_funcs = {
 545   loclist_read_variable,
 546   loclist_read_needs_frame,
 547   loclist_describe_location,
 548   loclist_tracepoint_var_ref
 549 };