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