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