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