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
  33 #include "elf/dwarf2.h"
  34 #include "dwarf2expr.h"
  35 #include "dwarf2loc.h"
  36
  37 #include "gdb_string.h"
  38
  39 #ifndef DWARF2_REG_TO_REGNUM
  40 #define DWARF2_REG_TO_REGNUM(REG) (REG)
  41 #endif
  42
  43 /* A helper function for dealing with location lists.  Given a
  44    symbol baton (BATON) and a pc value (PC), find the appropriate
  45    location expression, set *LOCEXPR_LENGTH, and return a pointer
  46    to the beginning of the expression.  Returns NULL on failure.
  47
  48    For now, only return the first matching location expression; there
  49    can be more than one in the list.  */
  50
  51 static char *
  52 find_location_expression (struct dwarf2_loclist_baton *baton,
  53                           int *locexpr_length, CORE_ADDR pc)
  54 {
  55   CORE_ADDR base_address = baton->base_address;
  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
  61   loc_ptr = baton->data;
  62   buf_end = baton->data + baton->size;
  63
  64   while (1)
  65     {
  66       low = dwarf2_read_address (loc_ptr, buf_end, &length);
  67       loc_ptr += length;
  68       high = dwarf2_read_address (loc_ptr, buf_end, &length);
  69       loc_ptr += length;
  70
  71       /* An end-of-list entry.  */
  72       if (low == 0 && high == 0)
  73         return NULL;
  74
  75       /* A base-address-selection entry.  */
  76       if ((low & base_mask) == base_mask)
  77         {
  78           base_address = high;
  79           continue;
  80         }
  81
  82       /* Otherwise, a location expression entry.  */
  83       low += base_address;
  84       high += base_address;
  85
  86       length = extract_unsigned_integer (loc_ptr, 2);
  87       loc_ptr += 2;
  88
  89       if (pc >= low && pc < high)
  90         {
  91           *locexpr_length = length;
  92           return loc_ptr;
  93         }
  94
  95       loc_ptr += length;
  96     }
  97 }
  98
  99 /* This is the baton used when performing dwarf2 expression
 100    evaluation.  */
 101 struct dwarf_expr_baton
 102 {
 103   struct frame_info *frame;
 104   struct objfile *objfile;
 105 };
 106
 107 /* Helper functions for dwarf2_evaluate_loc_desc.  */
 108
 109 /* Using the frame specified in BATON, read register REGNUM.  The lval
 110    type will be returned in LVALP, and for lval_memory the register
 111    save address will be returned in ADDRP.  */
 112 static CORE_ADDR
 113 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
 114 {
 115   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 116   CORE_ADDR result, save_addr;
 117   enum lval_type lval_type;
 118   char *buf;
 119   int optimized, regnum, realnum, regsize;
 120
 121   regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
 122   regsize = register_size (current_gdbarch, regnum);
 123   buf = (char *) alloca (regsize);
 124
 125   frame_register (debaton->frame, regnum, &optimized, &lval_type, &save_addr,
 126                   &realnum, buf);
 127   result = extract_address (buf, regsize);
 128
 129   return result;
 130 }
 131
 132 /* Read memory at ADDR (length LEN) into BUF.  */
 133
 134 static void
 135 dwarf_expr_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
 136 {
 137   read_memory (addr, buf, len);
 138 }
 139
 140 /* Using the frame specified in BATON, find the location expression
 141    describing the frame base.  Return a pointer to it in START and
 142    its length in LENGTH.  */
 143 static void
 144 dwarf_expr_frame_base (void *baton, unsigned char **start, size_t * length)
 145 {
 146   /* FIXME: cagney/2003-03-26: This code should be using
 147      get_frame_base_address(), and then implement a dwarf2 specific
 148      this_base method.  */
 149   struct symbol *framefunc;
 150   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 151
 152   framefunc = get_frame_function (debaton->frame);
 153
 154   if (SYMBOL_LOCATION_FUNCS (framefunc) == &dwarf2_loclist_funcs)
 155     {
 156       struct dwarf2_loclist_baton *symbaton;
 157       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 158       *start = find_location_expression (symbaton, length,
 159                                          get_frame_pc (debaton->frame));
 160     }
 161   else
 162     {
 163       struct dwarf2_locexpr_baton *symbaton;
 164       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 165       *length = symbaton->size;
 166       *start = symbaton->data;
 167     }
 168
 169   if (*start == NULL)
 170     error ("Could not find the frame base for \"%s\".",
 171            SYMBOL_NATURAL_NAME (framefunc));
 172 }
 173
 174 /* Using the objfile specified in BATON, find the address for the
 175    current thread's thread-local storage with offset OFFSET.  */
 176 static CORE_ADDR
 177 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 178 {
 179   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 180   CORE_ADDR addr;
 181
 182   if (target_get_thread_local_address_p ())
 183     addr = target_get_thread_local_address (inferior_ptid,
 184                                             debaton->objfile,
 185                                             offset);
 186   else
 187     error ("Cannot find thread-local variables on this target");
 188
 189   return addr;
 190 }
 191
 192 /* Evaluate a location description, starting at DATA and with length
 193    SIZE, to find the current location of variable VAR in the context
 194    of FRAME.  */
 195 static struct value *
 196 dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
 197                           unsigned char *data, unsigned short size,
 198                           struct objfile *objfile)
 199 {
 200   CORE_ADDR result;
 201   struct value *retval;
 202   struct dwarf_expr_baton baton;
 203   struct dwarf_expr_context *ctx;
 204
 205   if (size == 0)
 206     {
 207       retval = allocate_value (SYMBOL_TYPE (var));
 208       VALUE_LVAL (retval) = not_lval;
 209       VALUE_OPTIMIZED_OUT (retval) = 1;
 210     }
 211
 212   baton.frame = frame;
 213   baton.objfile = objfile;
 214
 215   ctx = new_dwarf_expr_context ();
 216   ctx->baton = &baton;
 217   ctx->read_reg = dwarf_expr_read_reg;
 218   ctx->read_mem = dwarf_expr_read_mem;
 219   ctx->get_frame_base = dwarf_expr_frame_base;
 220   ctx->get_tls_address = dwarf_expr_tls_address;
 221
 222   dwarf_expr_eval (ctx, data, size);
 223   result = dwarf_expr_fetch (ctx, 0);
 224
 225   if (ctx->in_reg)
 226     {
 227       int regnum = DWARF2_REG_TO_REGNUM (result);
 228       retval = value_from_register (SYMBOL_TYPE (var), regnum, frame);
 229     }
 230   else
 231     {
 232       retval = allocate_value (SYMBOL_TYPE (var));
 233       VALUE_BFD_SECTION (retval) = SYMBOL_BFD_SECTION (var);
 234
 235       VALUE_LVAL (retval) = lval_memory;
 236       VALUE_LAZY (retval) = 1;
 237       VALUE_ADDRESS (retval) = result;
 238     }
 239
 240   free_dwarf_expr_context (ctx);
 241
 242   return retval;
 243 }
 244
 245
 246
 247
 248 \f
 249 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 250
 251 struct needs_frame_baton
 252 {
 253   int needs_frame;
 254 };
 255
 256 /* Reads from registers do require a frame.  */
 257 static CORE_ADDR
 258 needs_frame_read_reg (void *baton, int regnum)
 259 {
 260   struct needs_frame_baton *nf_baton = baton;
 261   nf_baton->needs_frame = 1;
 262   return 1;
 263 }
 264
 265 /* Reads from memory do not require a frame.  */
 266 static void
 267 needs_frame_read_mem (void *baton, char *buf, CORE_ADDR addr, size_t len)
 268 {
 269   memset (buf, 0, len);
 270 }
 271
 272 /* Frame-relative accesses do require a frame.  */
 273 static void
 274 needs_frame_frame_base (void *baton, unsigned char **start, size_t * length)
 275 {
 276   static char lit0 = DW_OP_lit0;
 277   struct needs_frame_baton *nf_baton = baton;
 278
 279   *start = &lit0;
 280   *length = 1;
 281
 282   nf_baton->needs_frame = 1;
 283 }
 284
 285 /* Thread-local accesses do require a frame.  */
 286 static CORE_ADDR
 287 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 288 {
 289   struct needs_frame_baton *nf_baton = baton;
 290   nf_baton->needs_frame = 1;
 291   return 1;
 292 }
 293
 294 /* Return non-zero iff the location expression at DATA (length SIZE)
 295    requires a frame to evaluate.  */
 296
 297 static int
 298 dwarf2_loc_desc_needs_frame (unsigned char *data, unsigned short size)
 299 {
 300   struct needs_frame_baton baton;
 301   struct dwarf_expr_context *ctx;
 302
 303   baton.needs_frame = 0;
 304
 305   ctx = new_dwarf_expr_context ();
 306   ctx->baton = &baton;
 307   ctx->read_reg = needs_frame_read_reg;
 308   ctx->read_mem = needs_frame_read_mem;
 309   ctx->get_frame_base = needs_frame_frame_base;
 310   ctx->get_tls_address = needs_frame_tls_address;
 311
 312   dwarf_expr_eval (ctx, data, size);
 313
 314   free_dwarf_expr_context (ctx);
 315
 316   return baton.needs_frame;
 317 }
 318
 319 static void
 320 dwarf2_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 321                            struct axs_value * value, unsigned char *data,
 322                            int size)
 323 {
 324   if (size == 0)
 325     error ("Symbol \"%s\" has been optimized out.",
 326            SYMBOL_PRINT_NAME (symbol));
 327
 328   if (size == 1
 329       && data[0] >= DW_OP_reg0
 330       && data[0] <= DW_OP_reg31)
 331     {
 332       value->kind = axs_lvalue_register;
 333       value->u.reg = data[0] - DW_OP_reg0;
 334     }
 335   else if (data[0] == DW_OP_regx)
 336     {
 337       ULONGEST reg;
 338       read_uleb128 (data + 1, data + size, &reg);
 339       value->kind = axs_lvalue_register;
 340       value->u.reg = reg;
 341     }
 342   else if (data[0] == DW_OP_fbreg)
 343     {
 344       /* And this is worse than just minimal; we should honor the frame base
 345          as above.  */
 346       int frame_reg;
 347       LONGEST frame_offset;
 348       unsigned char *buf_end;
 349
 350       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
 351       if (buf_end != data + size)
 352         error ("Unexpected opcode after DW_OP_fbreg for symbol \"%s\".",
 353                SYMBOL_PRINT_NAME (symbol));
 354
 355       TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
 356       ax_reg (ax, frame_reg);
 357       ax_const_l (ax, frame_offset);
 358       ax_simple (ax, aop_add);
 359
 360       ax_const_l (ax, frame_offset);
 361       ax_simple (ax, aop_add);
 362       value->kind = axs_lvalue_memory;
 363     }
 364   else
 365     error ("Unsupported DWARF opcode in the location of \"%s\".",
 366            SYMBOL_PRINT_NAME (symbol));
 367 }
 368 \f
 369 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 370    evaluator to calculate the location.  */
 371 static struct value *
 372 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
 373 {
 374   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 375   struct value *val;
 376   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
 377                                   dlbaton->objfile);
 378
 379   return val;
 380 }
 381
 382 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 383 static int
 384 locexpr_read_needs_frame (struct symbol *symbol)
 385 {
 386   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 387   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size);
 388 }
 389
 390 /* Print a natural-language description of SYMBOL to STREAM.  */
 391 static int
 392 locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
 393 {
 394   /* FIXME: be more extensive.  */
 395   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 396
 397   if (dlbaton->size == 1
 398       && dlbaton->data[0] >= DW_OP_reg0
 399       && dlbaton->data[0] <= DW_OP_reg31)
 400     {
 401       int regno = DWARF2_REG_TO_REGNUM (dlbaton->data[0] - DW_OP_reg0);
 402       fprintf_filtered (stream,
 403                         "a variable in register %s", REGISTER_NAME (regno));
 404       return 1;
 405     }
 406
 407   fprintf_filtered (stream,
 408                     "a variable with complex or multiple locations (DWARF2)");
 409   return 1;
 410 }
 411
 412
 413 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 414    any necessary bytecode in AX.
 415
 416    NOTE drow/2003-02-26: This function is extremely minimal, because
 417    doing it correctly is extremely complicated and there is no
 418    publicly available stub with tracepoint support for me to test
 419    against.  When there is one this function should be revisited.  */
 420
 421 static void
 422 locexpr_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 423                             struct axs_value * value)
 424 {
 425   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 426
 427   dwarf2_tracepoint_var_ref (symbol, ax, value, dlbaton->data, dlbaton->size);
 428 }
 429
 430 /* The set of location functions used with the DWARF-2 expression
 431    evaluator.  */
 432 struct location_funcs dwarf2_locexpr_funcs = {
 433   locexpr_read_variable,
 434   locexpr_read_needs_frame,
 435   locexpr_describe_location,
 436   locexpr_tracepoint_var_ref
 437 };
 438
 439
 440 /* Wrapper functions for location lists.  These generally find
 441    the appropriate location expression and call something above.  */
 442
 443 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 444    evaluator to calculate the location.  */
 445 static struct value *
 446 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 447 {
 448   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 449   struct value *val;
 450   unsigned char *data;
 451   int size;
 452
 453   data = find_location_expression (dlbaton, &size,
 454                                    frame ? get_frame_pc (frame) : 0);
 455   if (data == NULL)
 456     error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol));
 457
 458   val = dwarf2_evaluate_loc_desc (symbol, frame, data, size, dlbaton->objfile);
 459
 460   return val;
 461 }
 462
 463 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 464 static int
 465 loclist_read_needs_frame (struct symbol *symbol)
 466 {
 467   /* If there's a location list, then assume we need to have a frame
 468      to choose the appropriate location expression.  With tracking of
 469      global variables this is not necessarily true, but such tracking
 470      is disabled in GCC at the moment until we figure out how to
 471      represent it.  */
 472
 473   return 1;
 474 }
 475
 476 /* Print a natural-language description of SYMBOL to STREAM.  */
 477 static int
 478 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 479 {
 480   /* FIXME: Could print the entire list of locations.  */
 481   fprintf_filtered (stream, "a variable with multiple locations");
 482   return 1;
 483 }
 484
 485 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 486    any necessary bytecode in AX.  */
 487 static void
 488 loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 489                             struct axs_value * value)
 490 {
 491   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 492   unsigned char *data;
 493   int size;
 494
 495   data = find_location_expression (dlbaton, &size, ax->scope);
 496   if (data == NULL)
 497     error ("Variable \"%s\" is not available.", SYMBOL_NATURAL_NAME (symbol));
 498
 499   dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
 500 }
 501
 502 /* The set of location functions used with the DWARF-2 expression
 503    evaluator and location lists.  */
 504 struct location_funcs dwarf2_loclist_funcs = {
 505   loclist_read_variable,
 506   loclist_read_needs_frame,
 507   loclist_describe_location,
 508   loclist_tracepoint_var_ref
 509 };