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