gdb/dwarf2loc.c

   1 /* DWARF 2 location expression support for GDB.
   2
   3    Copyright (C) 2003, 2005, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6    Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "ui-out.h"
  25 #include "value.h"
  26 #include "frame.h"
  27 #include "gdbcore.h"
  28 #include "target.h"
  29 #include "inferior.h"
  30 #include "ax.h"
  31 #include "ax-gdb.h"
  32 #include "regcache.h"
  33 #include "objfiles.h"
  34 #include "exceptions.h"
  35 #include "block.h"
  36
  37 #include "dwarf2.h"
  38 #include "dwarf2expr.h"
  39 #include "dwarf2loc.h"
  40 #include "dwarf2-frame.h"
  41
  42 #include "gdb_string.h"
  43 #include "gdb_assert.h"
  44
  45 static void
  46 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
  47                          gdb_byte **start, size_t *length);
  48
  49 /* A helper function for dealing with location lists.  Given a
  50    symbol baton (BATON) and a pc value (PC), find the appropriate
  51    location expression, set *LOCEXPR_LENGTH, and return a pointer
  52    to the beginning of the expression.  Returns NULL on failure.
  53
  54    For now, only return the first matching location expression; there
  55    can be more than one in the list.  */
  56
  57 static gdb_byte *
  58 find_location_expression (struct dwarf2_loclist_baton *baton,
  59                           size_t *locexpr_length, CORE_ADDR pc)
  60 {
  61   CORE_ADDR low, high;
  62   gdb_byte *loc_ptr, *buf_end;
  63   int length;
  64   struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
  65   struct gdbarch *gdbarch = get_objfile_arch (objfile);
  66   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  67   unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
  68   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
  69   /* Adjust base_address for relocatable objects.  */
  70   CORE_ADDR base_offset = ANOFFSET (objfile->section_offsets,
  71                                     SECT_OFF_TEXT (objfile));
  72   CORE_ADDR base_address = baton->base_address + base_offset;
  73
  74   loc_ptr = baton->data;
  75   buf_end = baton->data + baton->size;
  76
  77   while (1)
  78     {
  79       if (buf_end - loc_ptr < 2 * addr_size)
  80         error (_("find_location_expression: Corrupted DWARF expression."));
  81
  82       low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
  83       loc_ptr += addr_size;
  84
  85       /* A base-address-selection entry.  */
  86       if (low == base_mask)
  87         {
  88           base_address = dwarf2_read_address (gdbarch,
  89                                               loc_ptr, buf_end, addr_size);
  90           loc_ptr += addr_size;
  91           continue;
  92         }
  93
  94       high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
  95       loc_ptr += addr_size;
  96
  97       /* An end-of-list entry.  */
  98       if (low == 0 && high == 0)
  99         return NULL;
 100
 101       /* Otherwise, a location expression entry.  */
 102       low += base_address;
 103       high += base_address;
 104
 105       length = extract_unsigned_integer (loc_ptr, 2, byte_order);
 106       loc_ptr += 2;
 107
 108       if (pc >= low && pc < high)
 109         {
 110           *locexpr_length = length;
 111           return loc_ptr;
 112         }
 113
 114       loc_ptr += length;
 115     }
 116 }
 117
 118 /* This is the baton used when performing dwarf2 expression
 119    evaluation.  */
 120 struct dwarf_expr_baton
 121 {
 122   struct frame_info *frame;
 123   struct objfile *objfile;
 124 };
 125
 126 /* Helper functions for dwarf2_evaluate_loc_desc.  */
 127
 128 /* Using the frame specified in BATON, return the value of register
 129    REGNUM, treated as a pointer.  */
 130 static CORE_ADDR
 131 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
 132 {
 133   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 134   struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
 135   CORE_ADDR result;
 136   int regnum;
 137
 138   regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
 139   result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr,
 140                                   regnum, debaton->frame);
 141   return result;
 142 }
 143
 144 /* Read memory at ADDR (length LEN) into BUF.  */
 145
 146 static void
 147 dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 148 {
 149   read_memory (addr, buf, len);
 150 }
 151
 152 /* Using the frame specified in BATON, find the location expression
 153    describing the frame base.  Return a pointer to it in START and
 154    its length in LENGTH.  */
 155 static void
 156 dwarf_expr_frame_base (void *baton, gdb_byte **start, size_t * length)
 157 {
 158   /* FIXME: cagney/2003-03-26: This code should be using
 159      get_frame_base_address(), and then implement a dwarf2 specific
 160      this_base method.  */
 161   struct symbol *framefunc;
 162   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 163
 164   /* Use block_linkage_function, which returns a real (not inlined)
 165      function, instead of get_frame_function, which may return an
 166      inlined function.  */
 167   framefunc = block_linkage_function (get_frame_block (debaton->frame, NULL));
 168
 169   /* If we found a frame-relative symbol then it was certainly within
 170      some function associated with a frame. If we can't find the frame,
 171      something has gone wrong.  */
 172   gdb_assert (framefunc != NULL);
 173
 174   dwarf_expr_frame_base_1 (framefunc,
 175                            get_frame_address_in_block (debaton->frame),
 176                            start, length);
 177 }
 178
 179 static void
 180 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
 181                          gdb_byte **start, size_t *length)
 182 {
 183   if (SYMBOL_LOCATION_BATON (framefunc) == NULL)
 184     *start = NULL;
 185   else if (SYMBOL_COMPUTED_OPS (framefunc) == &dwarf2_loclist_funcs)
 186     {
 187       struct dwarf2_loclist_baton *symbaton;
 188
 189       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 190       *start = find_location_expression (symbaton, length, pc);
 191     }
 192   else
 193     {
 194       struct dwarf2_locexpr_baton *symbaton;
 195       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 196       if (symbaton != NULL)
 197         {
 198           *length = symbaton->size;
 199           *start = symbaton->data;
 200         }
 201       else
 202         *start = NULL;
 203     }
 204
 205   if (*start == NULL)
 206     error (_("Could not find the frame base for \"%s\"."),
 207            SYMBOL_NATURAL_NAME (framefunc));
 208 }
 209
 210 /* Helper function for dwarf2_evaluate_loc_desc.  Computes the CFA for
 211    the frame in BATON.  */
 212
 213 static CORE_ADDR
 214 dwarf_expr_frame_cfa (void *baton)
 215 {
 216   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 217   return dwarf2_frame_cfa (debaton->frame);
 218 }
 219
 220 /* Using the objfile specified in BATON, find the address for the
 221    current thread's thread-local storage with offset OFFSET.  */
 222 static CORE_ADDR
 223 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 224 {
 225   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 226
 227   return target_translate_tls_address (debaton->objfile, offset);
 228 }
 229
 230 struct piece_closure
 231 {
 232   /* The number of pieces used to describe this variable.  */
 233   int n_pieces;
 234
 235   /* The target address size, used only for DWARF_VALUE_STACK.  */
 236   int addr_size;
 237
 238   /* The pieces themselves.  */
 239   struct dwarf_expr_piece *pieces;
 240 };
 241
 242 /* Allocate a closure for a value formed from separately-described
 243    PIECES.  */
 244
 245 static struct piece_closure *
 246 allocate_piece_closure (int n_pieces, struct dwarf_expr_piece *pieces,
 247                         int addr_size)
 248 {
 249   struct piece_closure *c = XZALLOC (struct piece_closure);
 250
 251   c->n_pieces = n_pieces;
 252   c->addr_size = addr_size;
 253   c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
 254
 255   memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
 256
 257   return c;
 258 }
 259
 260 static void
 261 read_pieced_value (struct value *v)
 262 {
 263   int i;
 264   long offset = 0;
 265   gdb_byte *contents;
 266   struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
 267   struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
 268
 269   contents = value_contents_raw (v);
 270   for (i = 0; i < c->n_pieces; i++)
 271     {
 272       struct dwarf_expr_piece *p = &c->pieces[i];
 273       switch (p->location)
 274         {
 275         case DWARF_VALUE_REGISTER:
 276           {
 277             struct gdbarch *arch = get_frame_arch (frame);
 278             int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch,
 279                                                            p->v.expr.value);
 280             int reg_offset = 0;
 281
 282             if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
 283                 && p->size < register_size (arch, gdb_regnum))
 284               /* Big-endian, and we want less than full size.  */
 285               reg_offset = register_size (arch, gdb_regnum) - p->size;
 286
 287             get_frame_register_bytes (frame, gdb_regnum, reg_offset, p->size,
 288                                       contents + offset);
 289           }
 290           break;
 291
 292         case DWARF_VALUE_MEMORY:
 293           if (p->v.expr.in_stack_memory)
 294             read_stack (p->v.expr.value, contents + offset, p->size);
 295           else
 296             read_memory (p->v.expr.value, contents + offset, p->size);
 297           break;
 298
 299         case DWARF_VALUE_STACK:
 300           {
 301             struct gdbarch *gdbarch = get_type_arch (value_type (v));
 302             size_t n = p->size;
 303             if (n > c->addr_size)
 304               n = c->addr_size;
 305             store_unsigned_integer (contents + offset, n,
 306                                     gdbarch_byte_order (gdbarch),
 307                                     p->v.expr.value);
 308           }
 309           break;
 310
 311         case DWARF_VALUE_LITERAL:
 312           {
 313             size_t n = p->size;
 314             if (n > p->v.literal.length)
 315               n = p->v.literal.length;
 316             memcpy (contents + offset, p->v.literal.data, n);
 317           }
 318           break;
 319
 320         default:
 321           internal_error (__FILE__, __LINE__, _("invalid location type"));
 322         }
 323       offset += p->size;
 324     }
 325 }
 326
 327 static void
 328 write_pieced_value (struct value *to, struct value *from)
 329 {
 330   int i;
 331   long offset = 0;
 332   gdb_byte *contents;
 333   struct piece_closure *c = (struct piece_closure *) value_computed_closure (to);
 334   struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
 335
 336   if (frame == NULL)
 337     {
 338       set_value_optimized_out (to, 1);
 339       return;
 340     }
 341
 342   contents = value_contents_raw (from);
 343   for (i = 0; i < c->n_pieces; i++)
 344     {
 345       struct dwarf_expr_piece *p = &c->pieces[i];
 346       switch (p->location)
 347         {
 348         case DWARF_VALUE_REGISTER:
 349           {
 350             struct gdbarch *arch = get_frame_arch (frame);
 351             int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.expr.value);
 352             int reg_offset = 0;
 353
 354             if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
 355                 && p->size < register_size (arch, gdb_regnum))
 356               /* Big-endian, and we want less than full size.  */
 357               reg_offset = register_size (arch, gdb_regnum) - p->size;
 358
 359             put_frame_register_bytes (frame, gdb_regnum, reg_offset, p->size,
 360                                       contents + offset);
 361           }
 362           break;
 363         case DWARF_VALUE_MEMORY:
 364           write_memory (p->v.expr.value, contents + offset, p->size);
 365           break;
 366         default:
 367           set_value_optimized_out (to, 1);
 368           return;
 369         }
 370       offset += p->size;
 371     }
 372 }
 373
 374 static void *
 375 copy_pieced_value_closure (struct value *v)
 376 {
 377   struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
 378
 379   return allocate_piece_closure (c->n_pieces, c->pieces, c->addr_size);
 380 }
 381
 382 static void
 383 free_pieced_value_closure (struct value *v)
 384 {
 385   struct piece_closure *c = (struct piece_closure *) value_computed_closure (v);
 386
 387   xfree (c->pieces);
 388   xfree (c);
 389 }
 390
 391 /* Functions for accessing a variable described by DW_OP_piece.  */
 392 static struct lval_funcs pieced_value_funcs = {
 393   read_pieced_value,
 394   write_pieced_value,
 395   copy_pieced_value_closure,
 396   free_pieced_value_closure
 397 };
 398
 399 /* Evaluate a location description, starting at DATA and with length
 400    SIZE, to find the current location of variable VAR in the context
 401    of FRAME.  */
 402 static struct value *
 403 dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
 404                           gdb_byte *data, unsigned short size,
 405                           struct dwarf2_per_cu_data *per_cu)
 406 {
 407   struct value *retval;
 408   struct dwarf_expr_baton baton;
 409   struct dwarf_expr_context *ctx;
 410   struct cleanup *old_chain;
 411
 412   if (size == 0)
 413     {
 414       retval = allocate_value (SYMBOL_TYPE (var));
 415       VALUE_LVAL (retval) = not_lval;
 416       set_value_optimized_out (retval, 1);
 417       return retval;
 418     }
 419
 420   baton.frame = frame;
 421   baton.objfile = dwarf2_per_cu_objfile (per_cu);
 422
 423   ctx = new_dwarf_expr_context ();
 424   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
 425
 426   ctx->gdbarch = get_objfile_arch (baton.objfile);
 427   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
 428   ctx->baton = &baton;
 429   ctx->read_reg = dwarf_expr_read_reg;
 430   ctx->read_mem = dwarf_expr_read_mem;
 431   ctx->get_frame_base = dwarf_expr_frame_base;
 432   ctx->get_frame_cfa = dwarf_expr_frame_cfa;
 433   ctx->get_tls_address = dwarf_expr_tls_address;
 434
 435   dwarf_expr_eval (ctx, data, size);
 436   if (ctx->num_pieces > 0)
 437     {
 438       struct piece_closure *c;
 439       struct frame_id frame_id = get_frame_id (frame);
 440
 441       c = allocate_piece_closure (ctx->num_pieces, ctx->pieces,
 442                                   ctx->addr_size);
 443       retval = allocate_computed_value (SYMBOL_TYPE (var),
 444                                         &pieced_value_funcs,
 445                                         c);
 446       VALUE_FRAME_ID (retval) = frame_id;
 447     }
 448   else
 449     {
 450       switch (ctx->location)
 451         {
 452         case DWARF_VALUE_REGISTER:
 453           {
 454             struct gdbarch *arch = get_frame_arch (frame);
 455             CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
 456             int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
 457             retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
 458           }
 459           break;
 460
 461         case DWARF_VALUE_MEMORY:
 462           {
 463             CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
 464             int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
 465
 466             retval = allocate_value (SYMBOL_TYPE (var));
 467             VALUE_LVAL (retval) = lval_memory;
 468             set_value_lazy (retval, 1);
 469             if (in_stack_memory)
 470               set_value_stack (retval, 1);
 471             set_value_address (retval, address);
 472           }
 473           break;
 474
 475         case DWARF_VALUE_STACK:
 476           {
 477             ULONGEST value = (ULONGEST) dwarf_expr_fetch (ctx, 0);
 478             bfd_byte *contents;
 479             size_t n = ctx->addr_size;
 480
 481             retval = allocate_value (SYMBOL_TYPE (var));
 482             contents = value_contents_raw (retval);
 483             if (n > TYPE_LENGTH (SYMBOL_TYPE (var)))
 484               n = TYPE_LENGTH (SYMBOL_TYPE (var));
 485             store_unsigned_integer (contents, n,
 486                                     gdbarch_byte_order (ctx->gdbarch),
 487                                     value);
 488           }
 489           break;
 490
 491         case DWARF_VALUE_LITERAL:
 492           {
 493             bfd_byte *contents;
 494             size_t n = ctx->len;
 495
 496             retval = allocate_value (SYMBOL_TYPE (var));
 497             contents = value_contents_raw (retval);
 498             if (n > TYPE_LENGTH (SYMBOL_TYPE (var)))
 499               n = TYPE_LENGTH (SYMBOL_TYPE (var));
 500             memcpy (contents, ctx->data, n);
 501           }
 502           break;
 503
 504         default:
 505           internal_error (__FILE__, __LINE__, _("invalid location type"));
 506         }
 507     }
 508
 509   set_value_initialized (retval, ctx->initialized);
 510
 511   do_cleanups (old_chain);
 512
 513   return retval;
 514 }
 515 \f
 516 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 517
 518 struct needs_frame_baton
 519 {
 520   int needs_frame;
 521 };
 522
 523 /* Reads from registers do require a frame.  */
 524 static CORE_ADDR
 525 needs_frame_read_reg (void *baton, int regnum)
 526 {
 527   struct needs_frame_baton *nf_baton = baton;
 528   nf_baton->needs_frame = 1;
 529   return 1;
 530 }
 531
 532 /* Reads from memory do not require a frame.  */
 533 static void
 534 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 535 {
 536   memset (buf, 0, len);
 537 }
 538
 539 /* Frame-relative accesses do require a frame.  */
 540 static void
 541 needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length)
 542 {
 543   static gdb_byte lit0 = DW_OP_lit0;
 544   struct needs_frame_baton *nf_baton = baton;
 545
 546   *start = &lit0;
 547   *length = 1;
 548
 549   nf_baton->needs_frame = 1;
 550 }
 551
 552 /* CFA accesses require a frame.  */
 553
 554 static CORE_ADDR
 555 needs_frame_frame_cfa (void *baton)
 556 {
 557   struct needs_frame_baton *nf_baton = baton;
 558   nf_baton->needs_frame = 1;
 559   return 1;
 560 }
 561
 562 /* Thread-local accesses do require a frame.  */
 563 static CORE_ADDR
 564 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 565 {
 566   struct needs_frame_baton *nf_baton = baton;
 567   nf_baton->needs_frame = 1;
 568   return 1;
 569 }
 570
 571 /* Return non-zero iff the location expression at DATA (length SIZE)
 572    requires a frame to evaluate.  */
 573
 574 static int
 575 dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size,
 576                              struct dwarf2_per_cu_data *per_cu)
 577 {
 578   struct needs_frame_baton baton;
 579   struct dwarf_expr_context *ctx;
 580   int in_reg;
 581   struct cleanup *old_chain;
 582
 583   baton.needs_frame = 0;
 584
 585   ctx = new_dwarf_expr_context ();
 586   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
 587
 588   ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (per_cu));
 589   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
 590   ctx->baton = &baton;
 591   ctx->read_reg = needs_frame_read_reg;
 592   ctx->read_mem = needs_frame_read_mem;
 593   ctx->get_frame_base = needs_frame_frame_base;
 594   ctx->get_frame_cfa = needs_frame_frame_cfa;
 595   ctx->get_tls_address = needs_frame_tls_address;
 596
 597   dwarf_expr_eval (ctx, data, size);
 598
 599   in_reg = ctx->location == DWARF_VALUE_REGISTER;
 600
 601   if (ctx->num_pieces > 0)
 602     {
 603       int i;
 604
 605       /* If the location has several pieces, and any of them are in
 606          registers, then we will need a frame to fetch them from.  */
 607       for (i = 0; i < ctx->num_pieces; i++)
 608         if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
 609           in_reg = 1;
 610     }
 611
 612   do_cleanups (old_chain);
 613
 614   return baton.needs_frame || in_reg;
 615 }
 616
 617 static void
 618 dwarf2_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
 619                            struct agent_expr *ax, struct axs_value *value,
 620                            gdb_byte *data, int size)
 621 {
 622   if (!data || size == 0)
 623     {
 624       value->optimized_out = 1;
 625     }
 626   else if (size == 1
 627       && data[0] >= DW_OP_reg0
 628       && data[0] <= DW_OP_reg31)
 629     {
 630       value->kind = axs_lvalue_register;
 631       value->u.reg = data[0] - DW_OP_reg0;
 632     }
 633   else if (data[0] == DW_OP_regx)
 634     {
 635       ULONGEST reg;
 636       read_uleb128 (data + 1, data + size, &reg);
 637       value->kind = axs_lvalue_register;
 638       value->u.reg = reg;
 639     }
 640   else if (data[0] == DW_OP_fbreg)
 641     {
 642       struct block *b;
 643       struct symbol *framefunc;
 644       int frame_reg = 0;
 645       LONGEST frame_offset;
 646       gdb_byte *buf_end;
 647       gdb_byte *base_data;
 648       size_t base_size;
 649       LONGEST base_offset = 0;
 650
 651       b = block_for_pc (ax->scope);
 652
 653       if (!b)
 654         error (_("No block found for address"));
 655
 656       framefunc = block_linkage_function (b);
 657
 658       if (!framefunc)
 659         error (_("No function found for block"));
 660
 661       dwarf_expr_frame_base_1 (framefunc, ax->scope,
 662                                &base_data, &base_size);
 663
 664       if (base_data[0] >= DW_OP_breg0
 665            && base_data[0] <= DW_OP_breg31)
 666         {
 667           frame_reg = base_data[0] - DW_OP_breg0;
 668           buf_end = read_sleb128 (base_data + 1, base_data + base_size, &base_offset);
 669           if (buf_end != base_data + base_size)
 670             error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
 671                    frame_reg, SYMBOL_PRINT_NAME (symbol));
 672         }
 673       else
 674         {
 675           /* We don't know what to do with the frame base expression,
 676              so we can't trace this variable; give up.  */
 677           error (_("Cannot generate expression to collect symbol \"%s\"; DWARF 2 encoding not handled"),
 678                  SYMBOL_PRINT_NAME (symbol));
 679         }
 680
 681       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
 682       if (buf_end != data + size)
 683         error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
 684                SYMBOL_PRINT_NAME (symbol));
 685
 686       ax_reg (ax, frame_reg);
 687       ax_const_l (ax, base_offset + frame_offset);
 688       ax_simple (ax, aop_add);
 689
 690       value->kind = axs_lvalue_memory;
 691     }
 692   else if (data[0] >= DW_OP_breg0
 693            && data[0] <= DW_OP_breg31)
 694     {
 695       unsigned int reg;
 696       LONGEST offset;
 697       gdb_byte *buf_end;
 698
 699       reg = data[0] - DW_OP_breg0;
 700       buf_end = read_sleb128 (data + 1, data + size, &offset);
 701       if (buf_end != data + size)
 702         error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
 703                reg, SYMBOL_PRINT_NAME (symbol));
 704
 705       ax_reg (ax, reg);
 706       ax_const_l (ax, offset);
 707       ax_simple (ax, aop_add);
 708
 709       value->kind = axs_lvalue_memory;
 710     }
 711   else
 712     error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
 713            data[0], SYMBOL_PRINT_NAME (symbol));
 714 }
 715 \f
 716 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 717    evaluator to calculate the location.  */
 718 static struct value *
 719 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
 720 {
 721   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 722   struct value *val;
 723   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
 724                                   dlbaton->per_cu);
 725
 726   return val;
 727 }
 728
 729 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 730 static int
 731 locexpr_read_needs_frame (struct symbol *symbol)
 732 {
 733   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 734   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
 735                                       dlbaton->per_cu);
 736 }
 737
 738 /* Print a natural-language description of SYMBOL to STREAM.  */
 739 static int
 740 locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
 741 {
 742   /* FIXME: be more extensive.  */
 743   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 744   int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
 745
 746   if (dlbaton->size == 1
 747       && dlbaton->data[0] >= DW_OP_reg0
 748       && dlbaton->data[0] <= DW_OP_reg31)
 749     {
 750       struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
 751       struct gdbarch *gdbarch = get_objfile_arch (objfile);
 752       int regno = gdbarch_dwarf2_reg_to_regnum (gdbarch,
 753                                                 dlbaton->data[0] - DW_OP_reg0);
 754       fprintf_filtered (stream,
 755                         "a variable in register %s",
 756                         gdbarch_register_name (gdbarch, regno));
 757       return 1;
 758     }
 759
 760   /* The location expression for a TLS variable looks like this (on a
 761      64-bit LE machine):
 762
 763      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
 764                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
 765
 766      0x3 is the encoding for DW_OP_addr, which has an operand as long
 767      as the size of an address on the target machine (here is 8
 768      bytes).  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
 769      The operand represents the offset at which the variable is within
 770      the thread local storage.  */
 771
 772   if (dlbaton->size > 1
 773       && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
 774     if (dlbaton->data[0] == DW_OP_addr)
 775       {
 776         struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
 777         struct gdbarch *gdbarch = get_objfile_arch (objfile);
 778         CORE_ADDR offset = dwarf2_read_address (gdbarch,
 779                                                 &dlbaton->data[1],
 780                                                 &dlbaton->data[dlbaton->size - 1],
 781                                                 addr_size);
 782         fprintf_filtered (stream,
 783                           "a thread-local variable at offset %s in the "
 784                           "thread-local storage for `%s'",
 785                           paddress (gdbarch, offset), objfile->name);
 786         return 1;
 787       }
 788
 789
 790   fprintf_filtered (stream,
 791                     "a variable with complex or multiple locations (DWARF2)");
 792   return 1;
 793 }
 794
 795
 796 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 797    any necessary bytecode in AX.
 798
 799    NOTE drow/2003-02-26: This function is extremely minimal, because
 800    doing it correctly is extremely complicated and there is no
 801    publicly available stub with tracepoint support for me to test
 802    against.  When there is one this function should be revisited.  */
 803
 804 static void
 805 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
 806                             struct agent_expr *ax, struct axs_value *value)
 807 {
 808   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 809
 810   dwarf2_tracepoint_var_ref (symbol, gdbarch, ax, value,
 811                              dlbaton->data, dlbaton->size);
 812 }
 813
 814 /* The set of location functions used with the DWARF-2 expression
 815    evaluator.  */
 816 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
 817   locexpr_read_variable,
 818   locexpr_read_needs_frame,
 819   locexpr_describe_location,
 820   locexpr_tracepoint_var_ref
 821 };
 822
 823
 824 /* Wrapper functions for location lists.  These generally find
 825    the appropriate location expression and call something above.  */
 826
 827 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 828    evaluator to calculate the location.  */
 829 static struct value *
 830 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 831 {
 832   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 833   struct value *val;
 834   gdb_byte *data;
 835   size_t size;
 836
 837   data = find_location_expression (dlbaton, &size,
 838                                    frame ? get_frame_address_in_block (frame)
 839                                    : 0);
 840   if (data == NULL)
 841     {
 842       val = allocate_value (SYMBOL_TYPE (symbol));
 843       VALUE_LVAL (val) = not_lval;
 844       set_value_optimized_out (val, 1);
 845     }
 846   else
 847     val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
 848                                     dlbaton->per_cu);
 849
 850   return val;
 851 }
 852
 853 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 854 static int
 855 loclist_read_needs_frame (struct symbol *symbol)
 856 {
 857   /* If there's a location list, then assume we need to have a frame
 858      to choose the appropriate location expression.  With tracking of
 859      global variables this is not necessarily true, but such tracking
 860      is disabled in GCC at the moment until we figure out how to
 861      represent it.  */
 862
 863   return 1;
 864 }
 865
 866 /* Print a natural-language description of SYMBOL to STREAM.  */
 867 static int
 868 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 869 {
 870   /* FIXME: Could print the entire list of locations.  */
 871   fprintf_filtered (stream, "a variable with multiple locations");
 872   return 1;
 873 }
 874
 875 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 876    any necessary bytecode in AX.  */
 877 static void
 878 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
 879                             struct agent_expr *ax, struct axs_value *value)
 880 {
 881   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 882   gdb_byte *data;
 883   size_t size;
 884
 885   data = find_location_expression (dlbaton, &size, ax->scope);
 886
 887   dwarf2_tracepoint_var_ref (symbol, gdbarch, ax, value, data, size);
 888 }
 889
 890 /* The set of location functions used with the DWARF-2 expression
 891    evaluator and location lists.  */
 892 const struct symbol_computed_ops dwarf2_loclist_funcs = {
 893   loclist_read_variable,
 894   loclist_read_needs_frame,
 895   loclist_describe_location,
 896   loclist_tracepoint_var_ref
 897 };