gdb/dwarf2loc.c

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