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       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 168       *start = find_location_expression (symbaton, length,
 169                                          get_frame_pc (debaton->frame));
 170     }
 171   else
 172     {
 173       struct dwarf2_locexpr_baton *symbaton;
 174       symbaton = SYMBOL_LOCATION_BATON (framefunc);
 175       *length = symbaton->size;
 176       *start = symbaton->data;
 177     }
 178
 179   if (*start == NULL)
 180     error (_("Could not find the frame base for \"%s\"."),
 181            SYMBOL_NATURAL_NAME (framefunc));
 182 }
 183
 184 /* Using the objfile specified in BATON, find the address for the
 185    current thread's thread-local storage with offset OFFSET.  */
 186 static CORE_ADDR
 187 dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 188 {
 189   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
 190   volatile CORE_ADDR addr = 0;
 191
 192   if (target_get_thread_local_address_p ()
 193       && gdbarch_fetch_tls_load_module_address_p (current_gdbarch))
 194     {
 195       ptid_t ptid = inferior_ptid;
 196       struct objfile *objfile = debaton->objfile;
 197       volatile struct gdb_exception ex;
 198
 199       TRY_CATCH (ex, RETURN_MASK_ALL)
 200         {
 201           CORE_ADDR lm_addr;
 202
 203           /* Fetch the load module address for this objfile.  */
 204           lm_addr = gdbarch_fetch_tls_load_module_address (current_gdbarch,
 205                                                            objfile);
 206           /* If it's 0, throw the appropriate exception.  */
 207           if (lm_addr == 0)
 208             throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
 209                          _("TLS load module not found"));
 210
 211           addr = target_get_thread_local_address (ptid, lm_addr, offset);
 212         }
 213       /* If an error occurred, print TLS related messages here.  Otherwise,
 214          throw the error to some higher catcher.  */
 215       if (ex.reason < 0)
 216         {
 217           int objfile_is_library = (objfile->flags & OBJF_SHARED);
 218
 219           switch (ex.error)
 220             {
 221             case TLS_NO_LIBRARY_SUPPORT_ERROR:
 222               error (_("Cannot find thread-local variables in this thread library."));
 223               break;
 224             case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
 225               if (objfile_is_library)
 226                 error (_("Cannot find shared library `%s' in dynamic"
 227                          " linker's load module list"), objfile->name);
 228               else
 229                 error (_("Cannot find executable file `%s' in dynamic"
 230                          " linker's load module list"), objfile->name);
 231               break;
 232             case TLS_NOT_ALLOCATED_YET_ERROR:
 233               if (objfile_is_library)
 234                 error (_("The inferior has not yet allocated storage for"
 235                          " thread-local variables in\n"
 236                          "the shared library `%s'\n"
 237                          "for %s"),
 238                        objfile->name, target_pid_to_str (ptid));
 239               else
 240                 error (_("The inferior has not yet allocated storage for"
 241                          " thread-local variables in\n"
 242                          "the executable `%s'\n"
 243                          "for %s"),
 244                        objfile->name, target_pid_to_str (ptid));
 245               break;
 246             case TLS_GENERIC_ERROR:
 247               if (objfile_is_library)
 248                 error (_("Cannot find thread-local storage for %s, "
 249                          "shared library %s:\n%s"),
 250                        target_pid_to_str (ptid),
 251                        objfile->name, ex.message);
 252               else
 253                 error (_("Cannot find thread-local storage for %s, "
 254                          "executable file %s:\n%s"),
 255                        target_pid_to_str (ptid),
 256                        objfile->name, ex.message);
 257               break;
 258             default:
 259               throw_exception (ex);
 260               break;
 261             }
 262         }
 263     }
 264   /* It wouldn't be wrong here to try a gdbarch method, too; finding
 265      TLS is an ABI-specific thing.  But we don't do that yet.  */
 266   else
 267     error (_("Cannot find thread-local variables on this target"));
 268
 269   return addr;
 270 }
 271
 272 /* Evaluate a location description, starting at DATA and with length
 273    SIZE, to find the current location of variable VAR in the context
 274    of FRAME.  */
 275 static struct value *
 276 dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
 277                           gdb_byte *data, unsigned short size,
 278                           struct objfile *objfile)
 279 {
 280   struct gdbarch *arch = get_frame_arch (frame);
 281   struct value *retval;
 282   struct dwarf_expr_baton baton;
 283   struct dwarf_expr_context *ctx;
 284
 285   if (size == 0)
 286     {
 287       retval = allocate_value (SYMBOL_TYPE (var));
 288       VALUE_LVAL (retval) = not_lval;
 289       set_value_optimized_out (retval, 1);
 290     }
 291
 292   baton.frame = frame;
 293   baton.objfile = objfile;
 294
 295   ctx = new_dwarf_expr_context ();
 296   ctx->baton = &baton;
 297   ctx->read_reg = dwarf_expr_read_reg;
 298   ctx->read_mem = dwarf_expr_read_mem;
 299   ctx->get_frame_base = dwarf_expr_frame_base;
 300   ctx->get_tls_address = dwarf_expr_tls_address;
 301
 302   dwarf_expr_eval (ctx, data, size);
 303   if (ctx->num_pieces > 0)
 304     {
 305       int i;
 306       long offset = 0;
 307       bfd_byte *contents;
 308
 309       retval = allocate_value (SYMBOL_TYPE (var));
 310       contents = value_contents_raw (retval);
 311       for (i = 0; i < ctx->num_pieces; i++)
 312         {
 313           struct dwarf_expr_piece *p = &ctx->pieces[i];
 314           if (p->in_reg)
 315             {
 316               bfd_byte regval[MAX_REGISTER_SIZE];
 317               int gdb_regnum = DWARF2_REG_TO_REGNUM (p->value);
 318               get_frame_register (frame, gdb_regnum, regval);
 319               memcpy (contents + offset, regval, p->size);
 320             }
 321           else /* In memory?  */
 322             {
 323               read_memory (p->value, contents + offset, p->size);
 324             }
 325           offset += p->size;
 326         }
 327     }
 328   else if (ctx->in_reg)
 329     {
 330       CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
 331       int gdb_regnum = DWARF2_REG_TO_REGNUM (dwarf_regnum);
 332       retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
 333     }
 334   else
 335     {
 336       CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
 337
 338       retval = allocate_value (SYMBOL_TYPE (var));
 339       VALUE_LVAL (retval) = lval_memory;
 340       set_value_lazy (retval, 1);
 341       VALUE_ADDRESS (retval) = address;
 342     }
 343
 344   free_dwarf_expr_context (ctx);
 345
 346   return retval;
 347 }
 348
 349
 350
 351
 352 \f
 353 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 354
 355 struct needs_frame_baton
 356 {
 357   int needs_frame;
 358 };
 359
 360 /* Reads from registers do require a frame.  */
 361 static CORE_ADDR
 362 needs_frame_read_reg (void *baton, int regnum)
 363 {
 364   struct needs_frame_baton *nf_baton = baton;
 365   nf_baton->needs_frame = 1;
 366   return 1;
 367 }
 368
 369 /* Reads from memory do not require a frame.  */
 370 static void
 371 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 372 {
 373   memset (buf, 0, len);
 374 }
 375
 376 /* Frame-relative accesses do require a frame.  */
 377 static void
 378 needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length)
 379 {
 380   static gdb_byte lit0 = DW_OP_lit0;
 381   struct needs_frame_baton *nf_baton = baton;
 382
 383   *start = &lit0;
 384   *length = 1;
 385
 386   nf_baton->needs_frame = 1;
 387 }
 388
 389 /* Thread-local accesses do require a frame.  */
 390 static CORE_ADDR
 391 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 392 {
 393   struct needs_frame_baton *nf_baton = baton;
 394   nf_baton->needs_frame = 1;
 395   return 1;
 396 }
 397
 398 /* Return non-zero iff the location expression at DATA (length SIZE)
 399    requires a frame to evaluate.  */
 400
 401 static int
 402 dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size)
 403 {
 404   struct needs_frame_baton baton;
 405   struct dwarf_expr_context *ctx;
 406   int in_reg;
 407
 408   baton.needs_frame = 0;
 409
 410   ctx = new_dwarf_expr_context ();
 411   ctx->baton = &baton;
 412   ctx->read_reg = needs_frame_read_reg;
 413   ctx->read_mem = needs_frame_read_mem;
 414   ctx->get_frame_base = needs_frame_frame_base;
 415   ctx->get_tls_address = needs_frame_tls_address;
 416
 417   dwarf_expr_eval (ctx, data, size);
 418
 419   in_reg = ctx->in_reg;
 420
 421   if (ctx->num_pieces > 0)
 422     {
 423       int i;
 424
 425       /* If the location has several pieces, and any of them are in
 426          registers, then we will need a frame to fetch them from.  */
 427       for (i = 0; i < ctx->num_pieces; i++)
 428         if (ctx->pieces[i].in_reg)
 429           in_reg = 1;
 430     }
 431
 432   free_dwarf_expr_context (ctx);
 433
 434   return baton.needs_frame || in_reg;
 435 }
 436
 437 static void
 438 dwarf2_tracepoint_var_ref (struct symbol *symbol, struct agent_expr *ax,
 439                            struct axs_value *value, gdb_byte *data,
 440                            int size)
 441 {
 442   if (size == 0)
 443     error (_("Symbol \"%s\" has been optimized out."),
 444            SYMBOL_PRINT_NAME (symbol));
 445
 446   if (size == 1
 447       && data[0] >= DW_OP_reg0
 448       && data[0] <= DW_OP_reg31)
 449     {
 450       value->kind = axs_lvalue_register;
 451       value->u.reg = data[0] - DW_OP_reg0;
 452     }
 453   else if (data[0] == DW_OP_regx)
 454     {
 455       ULONGEST reg;
 456       read_uleb128 (data + 1, data + size, &reg);
 457       value->kind = axs_lvalue_register;
 458       value->u.reg = reg;
 459     }
 460   else if (data[0] == DW_OP_fbreg)
 461     {
 462       /* And this is worse than just minimal; we should honor the frame base
 463          as above.  */
 464       int frame_reg;
 465       LONGEST frame_offset;
 466       gdb_byte *buf_end;
 467
 468       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
 469       if (buf_end != data + size)
 470         error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
 471                SYMBOL_PRINT_NAME (symbol));
 472
 473       TARGET_VIRTUAL_FRAME_POINTER (ax->scope, &frame_reg, &frame_offset);
 474       ax_reg (ax, frame_reg);
 475       ax_const_l (ax, frame_offset);
 476       ax_simple (ax, aop_add);
 477
 478       ax_const_l (ax, frame_offset);
 479       ax_simple (ax, aop_add);
 480       value->kind = axs_lvalue_memory;
 481     }
 482   else
 483     error (_("Unsupported DWARF opcode in the location of \"%s\"."),
 484            SYMBOL_PRINT_NAME (symbol));
 485 }
 486 \f
 487 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 488    evaluator to calculate the location.  */
 489 static struct value *
 490 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
 491 {
 492   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 493   struct value *val;
 494   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
 495                                   dlbaton->objfile);
 496
 497   return val;
 498 }
 499
 500 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 501 static int
 502 locexpr_read_needs_frame (struct symbol *symbol)
 503 {
 504   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 505   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size);
 506 }
 507
 508 /* Print a natural-language description of SYMBOL to STREAM.  */
 509 static int
 510 locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
 511 {
 512   /* FIXME: be more extensive.  */
 513   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 514
 515   if (dlbaton->size == 1
 516       && dlbaton->data[0] >= DW_OP_reg0
 517       && dlbaton->data[0] <= DW_OP_reg31)
 518     {
 519       int regno = DWARF2_REG_TO_REGNUM (dlbaton->data[0] - DW_OP_reg0);
 520       fprintf_filtered (stream,
 521                         "a variable in register %s", REGISTER_NAME (regno));
 522       return 1;
 523     }
 524
 525   /* The location expression for a TLS variable looks like this (on a
 526      64-bit LE machine):
 527
 528      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
 529                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
 530
 531      0x3 is the encoding for DW_OP_addr, which has an operand as long
 532      as the size of an address on the target machine (here is 8
 533      bytes).  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
 534      The operand represents the offset at which the variable is within
 535      the thread local storage.  */
 536
 537   if (dlbaton->size > 1
 538       && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
 539     if (dlbaton->data[0] == DW_OP_addr)
 540       {
 541         int bytes_read;
 542         CORE_ADDR offset = dwarf2_read_address (&dlbaton->data[1],
 543                                                 &dlbaton->data[dlbaton->size - 1],
 544                                                 &bytes_read);
 545         fprintf_filtered (stream,
 546                           "a thread-local variable at offset %s in the "
 547                           "thread-local storage for `%s'",
 548                           paddr_nz (offset), dlbaton->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 agent_expr * ax,
 569                             struct axs_value * value)
 570 {
 571   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 572
 573   dwarf2_tracepoint_var_ref (symbol, ax, value, dlbaton->data, dlbaton->size);
 574 }
 575
 576 /* The set of location functions used with the DWARF-2 expression
 577    evaluator.  */
 578 const struct symbol_ops dwarf2_locexpr_funcs = {
 579   locexpr_read_variable,
 580   locexpr_read_needs_frame,
 581   locexpr_describe_location,
 582   locexpr_tracepoint_var_ref
 583 };
 584
 585
 586 /* Wrapper functions for location lists.  These generally find
 587    the appropriate location expression and call something above.  */
 588
 589 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 590    evaluator to calculate the location.  */
 591 static struct value *
 592 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 593 {
 594   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 595   struct value *val;
 596   gdb_byte *data;
 597   size_t size;
 598
 599   data = find_location_expression (dlbaton, &size,
 600                                    frame ? get_frame_pc (frame) : 0);
 601   if (data == NULL)
 602     {
 603       val = allocate_value (SYMBOL_TYPE (symbol));
 604       VALUE_LVAL (val) = not_lval;
 605       set_value_optimized_out (val, 1);
 606     }
 607   else
 608     val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
 609                                     dlbaton->objfile);
 610
 611   return val;
 612 }
 613
 614 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 615 static int
 616 loclist_read_needs_frame (struct symbol *symbol)
 617 {
 618   /* If there's a location list, then assume we need to have a frame
 619      to choose the appropriate location expression.  With tracking of
 620      global variables this is not necessarily true, but such tracking
 621      is disabled in GCC at the moment until we figure out how to
 622      represent it.  */
 623
 624   return 1;
 625 }
 626
 627 /* Print a natural-language description of SYMBOL to STREAM.  */
 628 static int
 629 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 630 {
 631   /* FIXME: Could print the entire list of locations.  */
 632   fprintf_filtered (stream, "a variable with multiple locations");
 633   return 1;
 634 }
 635
 636 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 637    any necessary bytecode in AX.  */
 638 static void
 639 loclist_tracepoint_var_ref (struct symbol * symbol, struct agent_expr * ax,
 640                             struct axs_value * value)
 641 {
 642   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 643   gdb_byte *data;
 644   size_t size;
 645
 646   data = find_location_expression (dlbaton, &size, ax->scope);
 647   if (data == NULL)
 648     error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol));
 649
 650   dwarf2_tracepoint_var_ref (symbol, ax, value, data, size);
 651 }
 652
 653 /* The set of location functions used with the DWARF-2 expression
 654    evaluator and location lists.  */
 655 const struct symbol_ops dwarf2_loclist_funcs = {
 656   loclist_read_variable,
 657   loclist_read_needs_frame,
 658   loclist_describe_location,
 659   loclist_tracepoint_var_ref
 660 };