gdb/dwarf2loc.c

   1 /* DWARF 2 location expression support for GDB.
   2
   3    Copyright (C) 2003, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
   4
   5    Contributed by Daniel Jacobowitz, MontaVista Software, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  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 #include "exceptions.h"
  34 #include "block.h"
  35
  36 #include "dwarf2.h"
  37 #include "dwarf2expr.h"
  38 #include "dwarf2loc.h"
  39 #include "dwarf2-frame.h"
  40
  41 #include "gdb_string.h"
  42 #include "gdb_assert.h"
  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 gdb_byte *
  53 find_location_expression (struct dwarf2_loclist_baton *baton,
  54                           size_t *locexpr_length, CORE_ADDR pc)
  55 {
  56   CORE_ADDR low, high;
  57   gdb_byte *loc_ptr, *buf_end;
  58   int length;
  59   struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
  60   struct gdbarch *gdbarch = get_objfile_arch (objfile);
  61   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  62   unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
  63   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
  64   /* Adjust base_address for relocatable objects.  */
  65   CORE_ADDR base_offset = ANOFFSET (objfile->section_offsets,
  66                                     SECT_OFF_TEXT (objfile));
  67   CORE_ADDR base_address = baton->base_address + base_offset;
  68
  69   loc_ptr = baton->data;
  70   buf_end = baton->data + baton->size;
  71
  72   while (1)
  73     {
  74       if (buf_end - loc_ptr < 2 * addr_size)
  75         error (_("find_location_expression: Corrupted DWARF expression."));
  76
  77       low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
  78       loc_ptr += addr_size;
  79
  80       /* A base-address-selection entry.  */
  81       if (low == base_mask)
  82         {
  83           base_address = dwarf2_read_address (gdbarch,
  84                                               loc_ptr, buf_end, addr_size);
  85           loc_ptr += addr_size;
  86           continue;
  87         }
  88
  89       high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
  90       loc_ptr += addr_size;
  91
  92       /* An end-of-list entry.  */
  93       if (low == 0 && high == 0)
  94         return NULL;
  95
  96       /* Otherwise, a location expression entry.  */
  97       low += base_address;
  98       high += base_address;
  99
 100       length = extract_unsigned_integer (loc_ptr, 2, byte_order);
 101       loc_ptr += 2;
 102
 103       if (pc >= low && pc < high)
 104         {
 105           *locexpr_length = length;
 106           return loc_ptr;
 107         }
 108
 109       loc_ptr += length;
 110     }
 111 }
 112
 113 /* This is the baton used when performing dwarf2 expression
 114    evaluation.  */
 115 struct dwarf_expr_baton
 116 {
 117   struct frame_info *frame;
 118   struct objfile *objfile;
 119 };
 120
 121 /* Helper functions for dwarf2_evaluate_loc_desc.  */
 122
 123 /* Using the frame specified in BATON, return the value of register
 124    REGNUM, treated as a pointer.  */
 125 static CORE_ADDR
 126 dwarf_expr_read_reg (void *baton, int dwarf_regnum)
 127 {
 128   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 129   struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
 130   CORE_ADDR result;
 131   int regnum;
 132
 133   regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
 134   result = address_from_register (builtin_type (gdbarch)->builtin_data_ptr,
 135                                   regnum, debaton->frame);
 136   return result;
 137 }
 138
 139 /* Read memory at ADDR (length LEN) into BUF.  */
 140
 141 static void
 142 dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 143 {
 144   read_memory (addr, buf, len);
 145 }
 146
 147 /* Using the frame specified in BATON, find the location expression
 148    describing the frame base.  Return a pointer to it in START and
 149    its length in LENGTH.  */
 150 static void
 151 dwarf_expr_frame_base (void *baton, gdb_byte **start, size_t * length)
 152 {
 153   /* FIXME: cagney/2003-03-26: This code should be using
 154      get_frame_base_address(), and then implement a dwarf2 specific
 155      this_base method.  */
 156   struct symbol *framefunc;
 157   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 158
 159   /* Use block_linkage_function, which returns a real (not inlined)
 160      function, instead of get_frame_function, which may return an
 161      inlined function.  */
 162   framefunc = block_linkage_function (get_frame_block (debaton->frame, NULL));
 163
 164   /* If we found a frame-relative symbol then it was certainly within
 165      some function associated with a frame. If we can't find the frame,
 166      something has gone wrong.  */
 167   gdb_assert (framefunc != NULL);
 168
 169   if (SYMBOL_LOCATION_BATON (framefunc) == NULL)
 170     *start = NULL;
 171   else if (SYMBOL_COMPUTED_OPS (framefunc) == &dwarf2_loclist_funcs)
 172     {
 173       struct dwarf2_loclist_baton *symbaton;
 174       struct frame_info *frame = debaton->frame;
 175
 176       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 177       *start = find_location_expression (symbaton, length,
 178                                          get_frame_address_in_block (frame));
 179     }
 180   else
 181     {
 182       struct dwarf2_locexpr_baton *symbaton;
 183       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 184       if (symbaton != NULL)
 185         {
 186           *length = symbaton->size;
 187           *start = symbaton->data;
 188         }
 189       else
 190         *start = NULL;
 191     }
 192
 193   if (*start == NULL)
 194     error (_("Could not find the frame base for \"%s\"."),
 195            SYMBOL_NATURAL_NAME (framefunc));
 196 }
 197
 198 /* Helper function for dwarf2_evaluate_loc_desc.  Computes the CFA for
 199    the frame in BATON.  */
 200
 201 static CORE_ADDR
 202 dwarf_expr_frame_cfa (void *baton)
 203 {
 204   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 205   return dwarf2_frame_cfa (debaton->frame);
 206 }
 207
 208 /* Using the objfile specified in BATON, find the address for the
 209    current thread's thread-local storage with offset OFFSET.  */
 210 static CORE_ADDR
 211 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 212 {
 213   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 214
 215   return target_translate_tls_address (debaton->objfile, offset);
 216 }
 217
 218 /* Evaluate a location description, starting at DATA and with length
 219    SIZE, to find the current location of variable VAR in the context
 220    of FRAME.  */
 221 static struct value *
 222 dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
 223                           gdb_byte *data, unsigned short size,
 224                           struct dwarf2_per_cu_data *per_cu)
 225 {
 226   struct value *retval;
 227   struct dwarf_expr_baton baton;
 228   struct dwarf_expr_context *ctx;
 229   struct cleanup *old_chain;
 230
 231   if (size == 0)
 232     {
 233       retval = allocate_value (SYMBOL_TYPE (var));
 234       VALUE_LVAL (retval) = not_lval;
 235       set_value_optimized_out (retval, 1);
 236       return retval;
 237     }
 238
 239   baton.frame = frame;
 240   baton.objfile = dwarf2_per_cu_objfile (per_cu);
 241
 242   ctx = new_dwarf_expr_context ();
 243   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
 244
 245   ctx->gdbarch = get_objfile_arch (baton.objfile);
 246   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
 247   ctx->baton = &baton;
 248   ctx->read_reg = dwarf_expr_read_reg;
 249   ctx->read_mem = dwarf_expr_read_mem;
 250   ctx->get_frame_base = dwarf_expr_frame_base;
 251   ctx->get_frame_cfa = dwarf_expr_frame_cfa;
 252   ctx->get_tls_address = dwarf_expr_tls_address;
 253
 254   dwarf_expr_eval (ctx, data, size);
 255   if (ctx->num_pieces > 0)
 256     {
 257       int i;
 258       long offset = 0;
 259       bfd_byte *contents;
 260
 261       retval = allocate_value (SYMBOL_TYPE (var));
 262       contents = value_contents_raw (retval);
 263       for (i = 0; i < ctx->num_pieces; i++)
 264         {
 265           struct dwarf_expr_piece *p = &ctx->pieces[i];
 266           if (p->in_reg)
 267             {
 268               struct gdbarch *arch = get_frame_arch (frame);
 269               bfd_byte regval[MAX_REGISTER_SIZE];
 270               int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->value);
 271               get_frame_register (frame, gdb_regnum, regval);
 272               memcpy (contents + offset, regval, p->size);
 273             }
 274           else /* In memory?  */
 275             {
 276               read_memory (p->value, contents + offset, p->size);
 277             }
 278           offset += p->size;
 279         }
 280     }
 281   else if (ctx->in_reg)
 282     {
 283       struct gdbarch *arch = get_frame_arch (frame);
 284       CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
 285       int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
 286       retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
 287     }
 288   else
 289     {
 290       CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
 291
 292       retval = allocate_value (SYMBOL_TYPE (var));
 293       VALUE_LVAL (retval) = lval_memory;
 294       set_value_lazy (retval, 1);
 295       set_value_stack (retval, 1);
 296       set_value_address (retval, address);
 297     }
 298
 299   set_value_initialized (retval, ctx->initialized);
 300
 301   do_cleanups (old_chain);
 302
 303   return retval;
 304 }
 305
 306
 307
 308
 309 \f
 310 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 311
 312 struct needs_frame_baton
 313 {
 314   int needs_frame;
 315 };
 316
 317 /* Reads from registers do require a frame.  */
 318 static CORE_ADDR
 319 needs_frame_read_reg (void *baton, int regnum)
 320 {
 321   struct needs_frame_baton *nf_baton = baton;
 322   nf_baton->needs_frame = 1;
 323   return 1;
 324 }
 325
 326 /* Reads from memory do not require a frame.  */
 327 static void
 328 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 329 {
 330   memset (buf, 0, len);
 331 }
 332
 333 /* Frame-relative accesses do require a frame.  */
 334 static void
 335 needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length)
 336 {
 337   static gdb_byte lit0 = DW_OP_lit0;
 338   struct needs_frame_baton *nf_baton = baton;
 339
 340   *start = &lit0;
 341   *length = 1;
 342
 343   nf_baton->needs_frame = 1;
 344 }
 345
 346 /* CFA accesses require a frame.  */
 347
 348 static CORE_ADDR
 349 needs_frame_frame_cfa (void *baton)
 350 {
 351   struct needs_frame_baton *nf_baton = baton;
 352   nf_baton->needs_frame = 1;
 353   return 1;
 354 }
 355
 356 /* Thread-local accesses do require a frame.  */
 357 static CORE_ADDR
 358 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 359 {
 360   struct needs_frame_baton *nf_baton = baton;
 361   nf_baton->needs_frame = 1;
 362   return 1;
 363 }
 364
 365 /* Return non-zero iff the location expression at DATA (length SIZE)
 366    requires a frame to evaluate.  */
 367
 368 static int
 369 dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size,
 370                              struct dwarf2_per_cu_data *per_cu)
 371 {
 372   struct needs_frame_baton baton;
 373   struct dwarf_expr_context *ctx;
 374   int in_reg;
 375   struct cleanup *old_chain;
 376
 377   baton.needs_frame = 0;
 378
 379   ctx = new_dwarf_expr_context ();
 380   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
 381
 382   ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (per_cu));
 383   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
 384   ctx->baton = &baton;
 385   ctx->read_reg = needs_frame_read_reg;
 386   ctx->read_mem = needs_frame_read_mem;
 387   ctx->get_frame_base = needs_frame_frame_base;
 388   ctx->get_frame_cfa = needs_frame_frame_cfa;
 389   ctx->get_tls_address = needs_frame_tls_address;
 390
 391   dwarf_expr_eval (ctx, data, size);
 392
 393   in_reg = ctx->in_reg;
 394
 395   if (ctx->num_pieces > 0)
 396     {
 397       int i;
 398
 399       /* If the location has several pieces, and any of them are in
 400          registers, then we will need a frame to fetch them from.  */
 401       for (i = 0; i < ctx->num_pieces; i++)
 402         if (ctx->pieces[i].in_reg)
 403           in_reg = 1;
 404     }
 405
 406   do_cleanups (old_chain);
 407
 408   return baton.needs_frame || in_reg;
 409 }
 410
 411 static void
 412 dwarf2_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
 413                            struct agent_expr *ax, struct axs_value *value,
 414                            gdb_byte *data, int size)
 415 {
 416   if (size == 0)
 417     error (_("Symbol \"%s\" has been optimized out."),
 418            SYMBOL_PRINT_NAME (symbol));
 419
 420   if (size == 1
 421       && data[0] >= DW_OP_reg0
 422       && data[0] <= DW_OP_reg31)
 423     {
 424       value->kind = axs_lvalue_register;
 425       value->u.reg = data[0] - DW_OP_reg0;
 426     }
 427   else if (data[0] == DW_OP_regx)
 428     {
 429       ULONGEST reg;
 430       read_uleb128 (data + 1, data + size, &reg);
 431       value->kind = axs_lvalue_register;
 432       value->u.reg = reg;
 433     }
 434   else if (data[0] == DW_OP_fbreg)
 435     {
 436       /* And this is worse than just minimal; we should honor the frame base
 437          as above.  */
 438       int frame_reg;
 439       LONGEST frame_offset;
 440       gdb_byte *buf_end;
 441
 442       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
 443       if (buf_end != data + size)
 444         error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
 445                SYMBOL_PRINT_NAME (symbol));
 446
 447       gdbarch_virtual_frame_pointer (gdbarch,
 448                                      ax->scope, &frame_reg, &frame_offset);
 449       ax_reg (ax, frame_reg);
 450       ax_const_l (ax, frame_offset);
 451       ax_simple (ax, aop_add);
 452
 453       value->kind = axs_lvalue_memory;
 454     }
 455   else if (data[0] >= DW_OP_breg0
 456            && data[0] <= DW_OP_breg31)
 457     {
 458       unsigned int reg;
 459       LONGEST offset;
 460       gdb_byte *buf_end;
 461
 462       reg = data[0] - DW_OP_breg0;
 463       buf_end = read_sleb128 (data + 1, data + size, &offset);
 464       if (buf_end != data + size)
 465         error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
 466                reg, SYMBOL_PRINT_NAME (symbol));
 467
 468       ax_reg (ax, reg);
 469       ax_const_l (ax, offset);
 470       ax_simple (ax, aop_add);
 471
 472       value->kind = axs_lvalue_memory;
 473     }
 474   else
 475     error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
 476            data[0], SYMBOL_PRINT_NAME (symbol));
 477 }
 478 \f
 479 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 480    evaluator to calculate the location.  */
 481 static struct value *
 482 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
 483 {
 484   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 485   struct value *val;
 486   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
 487                                   dlbaton->per_cu);
 488
 489   return val;
 490 }
 491
 492 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 493 static int
 494 locexpr_read_needs_frame (struct symbol *symbol)
 495 {
 496   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 497   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
 498                                       dlbaton->per_cu);
 499 }
 500
 501 /* Print a natural-language description of SYMBOL to STREAM.  */
 502 static int
 503 locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
 504 {
 505   /* FIXME: be more extensive.  */
 506   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 507   int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
 508
 509   if (dlbaton->size == 1
 510       && dlbaton->data[0] >= DW_OP_reg0
 511       && dlbaton->data[0] <= DW_OP_reg31)
 512     {
 513       struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
 514       struct gdbarch *gdbarch = get_objfile_arch (objfile);
 515       int regno = gdbarch_dwarf2_reg_to_regnum (gdbarch,
 516                                                 dlbaton->data[0] - DW_OP_reg0);
 517       fprintf_filtered (stream,
 518                         "a variable in register %s",
 519                         gdbarch_register_name (gdbarch, regno));
 520       return 1;
 521     }
 522
 523   /* The location expression for a TLS variable looks like this (on a
 524      64-bit LE machine):
 525
 526      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
 527                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
 528
 529      0x3 is the encoding for DW_OP_addr, which has an operand as long
 530      as the size of an address on the target machine (here is 8
 531      bytes).  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
 532      The operand represents the offset at which the variable is within
 533      the thread local storage.  */
 534
 535   if (dlbaton->size > 1
 536       && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
 537     if (dlbaton->data[0] == DW_OP_addr)
 538       {
 539         struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
 540         struct gdbarch *gdbarch = get_objfile_arch (objfile);
 541         CORE_ADDR offset = dwarf2_read_address (gdbarch,
 542                                                 &dlbaton->data[1],
 543                                                 &dlbaton->data[dlbaton->size - 1],
 544                                                 addr_size);
 545         fprintf_filtered (stream,
 546                           "a thread-local variable at offset %s in the "
 547                           "thread-local storage for `%s'",
 548                           paddress (gdbarch, offset), objfile->name);
 549         return 1;
 550       }
 551
 552
 553   fprintf_filtered (stream,
 554                     "a variable with complex or multiple locations (DWARF2)");
 555   return 1;
 556 }
 557
 558
 559 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 560    any necessary bytecode in AX.
 561
 562    NOTE drow/2003-02-26: This function is extremely minimal, because
 563    doing it correctly is extremely complicated and there is no
 564    publicly available stub with tracepoint support for me to test
 565    against.  When there is one this function should be revisited.  */
 566
 567 static void
 568 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
 569                             struct agent_expr *ax, struct axs_value *value)
 570 {
 571   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 572
 573   dwarf2_tracepoint_var_ref (symbol, gdbarch, ax, value,
 574                              dlbaton->data, dlbaton->size);
 575 }
 576
 577 /* The set of location functions used with the DWARF-2 expression
 578    evaluator.  */
 579 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
 580   locexpr_read_variable,
 581   locexpr_read_needs_frame,
 582   locexpr_describe_location,
 583   locexpr_tracepoint_var_ref
 584 };
 585
 586
 587 /* Wrapper functions for location lists.  These generally find
 588    the appropriate location expression and call something above.  */
 589
 590 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 591    evaluator to calculate the location.  */
 592 static struct value *
 593 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 594 {
 595   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 596   struct value *val;
 597   gdb_byte *data;
 598   size_t size;
 599
 600   data = find_location_expression (dlbaton, &size,
 601                                    frame ? get_frame_address_in_block (frame)
 602                                    : 0);
 603   if (data == NULL)
 604     {
 605       val = allocate_value (SYMBOL_TYPE (symbol));
 606       VALUE_LVAL (val) = not_lval;
 607       set_value_optimized_out (val, 1);
 608     }
 609   else
 610     val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
 611                                     dlbaton->per_cu);
 612
 613   return val;
 614 }
 615
 616 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 617 static int
 618 loclist_read_needs_frame (struct symbol *symbol)
 619 {
 620   /* If there's a location list, then assume we need to have a frame
 621      to choose the appropriate location expression.  With tracking of
 622      global variables this is not necessarily true, but such tracking
 623      is disabled in GCC at the moment until we figure out how to
 624      represent it.  */
 625
 626   return 1;
 627 }
 628
 629 /* Print a natural-language description of SYMBOL to STREAM.  */
 630 static int
 631 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 632 {
 633   /* FIXME: Could print the entire list of locations.  */
 634   fprintf_filtered (stream, "a variable with multiple locations");
 635   return 1;
 636 }
 637
 638 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 639    any necessary bytecode in AX.  */
 640 static void
 641 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
 642                             struct agent_expr *ax, struct axs_value *value)
 643 {
 644   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 645   gdb_byte *data;
 646   size_t size;
 647
 648   data = find_location_expression (dlbaton, &size, ax->scope);
 649   if (data == NULL)
 650     error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol));
 651
 652   dwarf2_tracepoint_var_ref (symbol, gdbarch, ax, value, data, size);
 653 }
 654
 655 /* The set of location functions used with the DWARF-2 expression
 656    evaluator and location lists.  */
 657 const struct symbol_computed_ops dwarf2_loclist_funcs = {
 658   loclist_read_variable,
 659   loclist_read_needs_frame,
 660   loclist_describe_location,
 661   loclist_tracepoint_var_ref
 662 };