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
 219   if (size == 0)
 220     {
 221       retval = allocate_value (SYMBOL_TYPE (var));
 222       VALUE_LVAL (retval) = not_lval;
 223       set_value_optimized_out (retval, 1);
 224       return retval;
 225     }
 226
 227   baton.frame = frame;
 228   baton.objfile = dwarf2_per_cu_objfile (per_cu);
 229
 230   ctx = new_dwarf_expr_context ();
 231   ctx->gdbarch = get_objfile_arch (baton.objfile);
 232   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
 233   ctx->baton = &baton;
 234   ctx->read_reg = dwarf_expr_read_reg;
 235   ctx->read_mem = dwarf_expr_read_mem;
 236   ctx->get_frame_base = dwarf_expr_frame_base;
 237   ctx->get_tls_address = dwarf_expr_tls_address;
 238
 239   dwarf_expr_eval (ctx, data, size);
 240   if (ctx->num_pieces > 0)
 241     {
 242       int i;
 243       long offset = 0;
 244       bfd_byte *contents;
 245
 246       retval = allocate_value (SYMBOL_TYPE (var));
 247       contents = value_contents_raw (retval);
 248       for (i = 0; i < ctx->num_pieces; i++)
 249         {
 250           struct dwarf_expr_piece *p = &ctx->pieces[i];
 251           if (p->in_reg)
 252             {
 253               struct gdbarch *arch = get_frame_arch (frame);
 254               bfd_byte regval[MAX_REGISTER_SIZE];
 255               int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->value);
 256               get_frame_register (frame, gdb_regnum, regval);
 257               memcpy (contents + offset, regval, p->size);
 258             }
 259           else /* In memory?  */
 260             {
 261               read_memory (p->value, contents + offset, p->size);
 262             }
 263           offset += p->size;
 264         }
 265     }
 266   else if (ctx->in_reg)
 267     {
 268       struct gdbarch *arch = get_frame_arch (frame);
 269       CORE_ADDR dwarf_regnum = dwarf_expr_fetch (ctx, 0);
 270       int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
 271       retval = value_from_register (SYMBOL_TYPE (var), gdb_regnum, frame);
 272     }
 273   else
 274     {
 275       CORE_ADDR address = dwarf_expr_fetch (ctx, 0);
 276
 277       retval = allocate_value (SYMBOL_TYPE (var));
 278       VALUE_LVAL (retval) = lval_memory;
 279       set_value_lazy (retval, 1);
 280       set_value_address (retval, address);
 281     }
 282
 283   set_value_initialized (retval, ctx->initialized);
 284
 285   free_dwarf_expr_context (ctx);
 286
 287   return retval;
 288 }
 289
 290
 291
 292
 293 \f
 294 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 295
 296 struct needs_frame_baton
 297 {
 298   int needs_frame;
 299 };
 300
 301 /* Reads from registers do require a frame.  */
 302 static CORE_ADDR
 303 needs_frame_read_reg (void *baton, int regnum)
 304 {
 305   struct needs_frame_baton *nf_baton = baton;
 306   nf_baton->needs_frame = 1;
 307   return 1;
 308 }
 309
 310 /* Reads from memory do not require a frame.  */
 311 static void
 312 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 313 {
 314   memset (buf, 0, len);
 315 }
 316
 317 /* Frame-relative accesses do require a frame.  */
 318 static void
 319 needs_frame_frame_base (void *baton, gdb_byte **start, size_t * length)
 320 {
 321   static gdb_byte lit0 = DW_OP_lit0;
 322   struct needs_frame_baton *nf_baton = baton;
 323
 324   *start = &lit0;
 325   *length = 1;
 326
 327   nf_baton->needs_frame = 1;
 328 }
 329
 330 /* Thread-local accesses do require a frame.  */
 331 static CORE_ADDR
 332 needs_frame_tls_address (void *baton, CORE_ADDR offset)
 333 {
 334   struct needs_frame_baton *nf_baton = baton;
 335   nf_baton->needs_frame = 1;
 336   return 1;
 337 }
 338
 339 /* Return non-zero iff the location expression at DATA (length SIZE)
 340    requires a frame to evaluate.  */
 341
 342 static int
 343 dwarf2_loc_desc_needs_frame (gdb_byte *data, unsigned short size,
 344                              struct dwarf2_per_cu_data *per_cu)
 345 {
 346   struct needs_frame_baton baton;
 347   struct dwarf_expr_context *ctx;
 348   int in_reg;
 349
 350   baton.needs_frame = 0;
 351
 352   ctx = new_dwarf_expr_context ();
 353   ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (per_cu));
 354   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
 355   ctx->baton = &baton;
 356   ctx->read_reg = needs_frame_read_reg;
 357   ctx->read_mem = needs_frame_read_mem;
 358   ctx->get_frame_base = needs_frame_frame_base;
 359   ctx->get_tls_address = needs_frame_tls_address;
 360
 361   dwarf_expr_eval (ctx, data, size);
 362
 363   in_reg = ctx->in_reg;
 364
 365   if (ctx->num_pieces > 0)
 366     {
 367       int i;
 368
 369       /* If the location has several pieces, and any of them are in
 370          registers, then we will need a frame to fetch them from.  */
 371       for (i = 0; i < ctx->num_pieces; i++)
 372         if (ctx->pieces[i].in_reg)
 373           in_reg = 1;
 374     }
 375
 376   free_dwarf_expr_context (ctx);
 377
 378   return baton.needs_frame || in_reg;
 379 }
 380
 381 static void
 382 dwarf2_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
 383                            struct agent_expr *ax, struct axs_value *value,
 384                            gdb_byte *data, int size)
 385 {
 386   if (size == 0)
 387     error (_("Symbol \"%s\" has been optimized out."),
 388            SYMBOL_PRINT_NAME (symbol));
 389
 390   if (size == 1
 391       && data[0] >= DW_OP_reg0
 392       && data[0] <= DW_OP_reg31)
 393     {
 394       value->kind = axs_lvalue_register;
 395       value->u.reg = data[0] - DW_OP_reg0;
 396     }
 397   else if (data[0] == DW_OP_regx)
 398     {
 399       ULONGEST reg;
 400       read_uleb128 (data + 1, data + size, &reg);
 401       value->kind = axs_lvalue_register;
 402       value->u.reg = reg;
 403     }
 404   else if (data[0] == DW_OP_fbreg)
 405     {
 406       /* And this is worse than just minimal; we should honor the frame base
 407          as above.  */
 408       int frame_reg;
 409       LONGEST frame_offset;
 410       gdb_byte *buf_end;
 411
 412       buf_end = read_sleb128 (data + 1, data + size, &frame_offset);
 413       if (buf_end != data + size)
 414         error (_("Unexpected opcode after DW_OP_fbreg for symbol \"%s\"."),
 415                SYMBOL_PRINT_NAME (symbol));
 416
 417       gdbarch_virtual_frame_pointer (gdbarch,
 418                                      ax->scope, &frame_reg, &frame_offset);
 419       ax_reg (ax, frame_reg);
 420       ax_const_l (ax, frame_offset);
 421       ax_simple (ax, aop_add);
 422
 423       value->kind = axs_lvalue_memory;
 424     }
 425   else if (data[0] >= DW_OP_breg0
 426            && data[0] <= DW_OP_breg31)
 427     {
 428       unsigned int reg;
 429       LONGEST offset;
 430       gdb_byte *buf_end;
 431
 432       reg = data[0] - DW_OP_breg0;
 433       buf_end = read_sleb128 (data + 1, data + size, &offset);
 434       if (buf_end != data + size)
 435         error (_("Unexpected opcode after DW_OP_breg%u for symbol \"%s\"."),
 436                reg, SYMBOL_PRINT_NAME (symbol));
 437
 438       ax_reg (ax, reg);
 439       ax_const_l (ax, offset);
 440       ax_simple (ax, aop_add);
 441
 442       value->kind = axs_lvalue_memory;
 443     }
 444   else
 445     error (_("Unsupported DWARF opcode 0x%x in the location of \"%s\"."),
 446            data[0], SYMBOL_PRINT_NAME (symbol));
 447 }
 448 \f
 449 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 450    evaluator to calculate the location.  */
 451 static struct value *
 452 locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
 453 {
 454   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 455   struct value *val;
 456   val = dwarf2_evaluate_loc_desc (symbol, frame, dlbaton->data, dlbaton->size,
 457                                   dlbaton->per_cu);
 458
 459   return val;
 460 }
 461
 462 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 463 static int
 464 locexpr_read_needs_frame (struct symbol *symbol)
 465 {
 466   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 467   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
 468                                       dlbaton->per_cu);
 469 }
 470
 471 /* Print a natural-language description of SYMBOL to STREAM.  */
 472 static int
 473 locexpr_describe_location (struct symbol *symbol, struct ui_file *stream)
 474 {
 475   /* FIXME: be more extensive.  */
 476   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 477   int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
 478
 479   if (dlbaton->size == 1
 480       && dlbaton->data[0] >= DW_OP_reg0
 481       && dlbaton->data[0] <= DW_OP_reg31)
 482     {
 483       struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
 484       struct gdbarch *gdbarch = get_objfile_arch (objfile);
 485       int regno = gdbarch_dwarf2_reg_to_regnum (gdbarch,
 486                                                 dlbaton->data[0] - DW_OP_reg0);
 487       fprintf_filtered (stream,
 488                         "a variable in register %s",
 489                         gdbarch_register_name (gdbarch, regno));
 490       return 1;
 491     }
 492
 493   /* The location expression for a TLS variable looks like this (on a
 494      64-bit LE machine):
 495
 496      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
 497                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
 498
 499      0x3 is the encoding for DW_OP_addr, which has an operand as long
 500      as the size of an address on the target machine (here is 8
 501      bytes).  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
 502      The operand represents the offset at which the variable is within
 503      the thread local storage.  */
 504
 505   if (dlbaton->size > 1
 506       && dlbaton->data[dlbaton->size - 1] == DW_OP_GNU_push_tls_address)
 507     if (dlbaton->data[0] == DW_OP_addr)
 508       {
 509         struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
 510         struct gdbarch *gdbarch = get_objfile_arch (objfile);
 511         CORE_ADDR offset = dwarf2_read_address (gdbarch,
 512                                                 &dlbaton->data[1],
 513                                                 &dlbaton->data[dlbaton->size - 1],
 514                                                 addr_size);
 515         fprintf_filtered (stream,
 516                           "a thread-local variable at offset %s in the "
 517                           "thread-local storage for `%s'",
 518                           paddress (gdbarch, offset), objfile->name);
 519         return 1;
 520       }
 521
 522
 523   fprintf_filtered (stream,
 524                     "a variable with complex or multiple locations (DWARF2)");
 525   return 1;
 526 }
 527
 528
 529 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 530    any necessary bytecode in AX.
 531
 532    NOTE drow/2003-02-26: This function is extremely minimal, because
 533    doing it correctly is extremely complicated and there is no
 534    publicly available stub with tracepoint support for me to test
 535    against.  When there is one this function should be revisited.  */
 536
 537 static void
 538 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
 539                             struct agent_expr *ax, struct axs_value *value)
 540 {
 541   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 542
 543   dwarf2_tracepoint_var_ref (symbol, gdbarch, ax, value,
 544                              dlbaton->data, dlbaton->size);
 545 }
 546
 547 /* The set of location functions used with the DWARF-2 expression
 548    evaluator.  */
 549 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
 550   locexpr_read_variable,
 551   locexpr_read_needs_frame,
 552   locexpr_describe_location,
 553   locexpr_tracepoint_var_ref
 554 };
 555
 556
 557 /* Wrapper functions for location lists.  These generally find
 558    the appropriate location expression and call something above.  */
 559
 560 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
 561    evaluator to calculate the location.  */
 562 static struct value *
 563 loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 564 {
 565   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 566   struct value *val;
 567   gdb_byte *data;
 568   size_t size;
 569
 570   data = find_location_expression (dlbaton, &size,
 571                                    frame ? get_frame_address_in_block (frame)
 572                                    : 0);
 573   if (data == NULL)
 574     {
 575       val = allocate_value (SYMBOL_TYPE (symbol));
 576       VALUE_LVAL (val) = not_lval;
 577       set_value_optimized_out (val, 1);
 578     }
 579   else
 580     val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
 581                                     dlbaton->per_cu);
 582
 583   return val;
 584 }
 585
 586 /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
 587 static int
 588 loclist_read_needs_frame (struct symbol *symbol)
 589 {
 590   /* If there's a location list, then assume we need to have a frame
 591      to choose the appropriate location expression.  With tracking of
 592      global variables this is not necessarily true, but such tracking
 593      is disabled in GCC at the moment until we figure out how to
 594      represent it.  */
 595
 596   return 1;
 597 }
 598
 599 /* Print a natural-language description of SYMBOL to STREAM.  */
 600 static int
 601 loclist_describe_location (struct symbol *symbol, struct ui_file *stream)
 602 {
 603   /* FIXME: Could print the entire list of locations.  */
 604   fprintf_filtered (stream, "a variable with multiple locations");
 605   return 1;
 606 }
 607
 608 /* Describe the location of SYMBOL as an agent value in VALUE, generating
 609    any necessary bytecode in AX.  */
 610 static void
 611 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
 612                             struct agent_expr *ax, struct axs_value *value)
 613 {
 614   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
 615   gdb_byte *data;
 616   size_t size;
 617
 618   data = find_location_expression (dlbaton, &size, ax->scope);
 619   if (data == NULL)
 620     error (_("Variable \"%s\" is not available."), SYMBOL_NATURAL_NAME (symbol));
 621
 622   dwarf2_tracepoint_var_ref (symbol, gdbarch, ax, value, data, size);
 623 }
 624
 625 /* The set of location functions used with the DWARF-2 expression
 626    evaluator and location lists.  */
 627 const struct symbol_computed_ops dwarf2_loclist_funcs = {
 628   loclist_read_variable,
 629   loclist_read_needs_frame,
 630   loclist_describe_location,
 631   loclist_tracepoint_var_ref
 632 };