GDB (xrefs)
/tmp/gdb-7.10/gdb/dwarf2loc.c
Go to the documentation of this file.
1 /* DWARF 2 location expression support for GDB.
2 
3  Copyright (C) 2003-2015 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 "block.h"
34 #include "gdbcmd.h"
35 
36 #include "dwarf2.h"
37 #include "dwarf2expr.h"
38 #include "dwarf2loc.h"
39 #include "dwarf2-frame.h"
40 #include "compile/compile.h"
41 
42 extern int dwarf_always_disassemble;
43 
44 extern const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs;
45 
46 static struct value *dwarf2_evaluate_loc_desc_full (struct type *type,
47  struct frame_info *frame,
48  const gdb_byte *data,
49  size_t size,
50  struct dwarf2_per_cu_data *per_cu,
51  LONGEST byte_offset);
52 
53 /* Until these have formal names, we define these here.
54  ref: http://gcc.gnu.org/wiki/DebugFission
55  Each entry in .debug_loc.dwo begins with a byte that describes the entry,
56  and is then followed by data specific to that entry. */
57 
59 {
60  /* Indicates the end of the list of entries. */
62 
63  /* This is followed by an unsigned LEB128 number that is an index into
64  .debug_addr and specifies the base address for all following entries. */
66 
67  /* This is followed by two unsigned LEB128 numbers that are indices into
68  .debug_addr and specify the beginning and ending addresses, and then
69  a normal location expression as in .debug_loc. */
71 
72  /* This is followed by an unsigned LEB128 number that is an index into
73  .debug_addr and specifies the beginning address, and a 4 byte unsigned
74  number that specifies the length, and then a normal location expression
75  as in .debug_loc. */
77 
78  /* An internal value indicating there is insufficient data. */
80 
81  /* An internal value indicating an invalid kind of entry was found. */
83 };
84 
85 /* Helper function which throws an error if a synthetic pointer is
86  invalid. */
87 
88 static void
90 {
91  error (_("access outside bounds of object "
92  "referenced via synthetic pointer"));
93 }
94 
95 /* Decode the addresses in a non-dwo .debug_loc entry.
96  A pointer to the next byte to examine is returned in *NEW_PTR.
97  The encoded low,high addresses are return in *LOW,*HIGH.
98  The result indicates the kind of entry found. */
99 
100 static enum debug_loc_kind
101 decode_debug_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end,
102  const gdb_byte **new_ptr,
103  CORE_ADDR *low, CORE_ADDR *high,
104  enum bfd_endian byte_order,
105  unsigned int addr_size,
106  int signed_addr_p)
107 {
108  CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
109 
110  if (buf_end - loc_ptr < 2 * addr_size)
112 
113  if (signed_addr_p)
114  *low = extract_signed_integer (loc_ptr, addr_size, byte_order);
115  else
116  *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
117  loc_ptr += addr_size;
118 
119  if (signed_addr_p)
120  *high = extract_signed_integer (loc_ptr, addr_size, byte_order);
121  else
122  *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
123  loc_ptr += addr_size;
124 
125  *new_ptr = loc_ptr;
126 
127  /* A base-address-selection entry. */
128  if ((*low & base_mask) == base_mask)
129  return DEBUG_LOC_BASE_ADDRESS;
130 
131  /* An end-of-list entry. */
132  if (*low == 0 && *high == 0)
133  return DEBUG_LOC_END_OF_LIST;
134 
135  return DEBUG_LOC_START_END;
136 }
137 
138 /* Decode the addresses in .debug_loc.dwo entry.
139  A pointer to the next byte to examine is returned in *NEW_PTR.
140  The encoded low,high addresses are return in *LOW,*HIGH.
141  The result indicates the kind of entry found. */
142 
143 static enum debug_loc_kind
145  const gdb_byte *loc_ptr,
146  const gdb_byte *buf_end,
147  const gdb_byte **new_ptr,
148  CORE_ADDR *low, CORE_ADDR *high,
149  enum bfd_endian byte_order)
150 {
151  uint64_t low_index, high_index;
152 
153  if (loc_ptr == buf_end)
155 
156  switch (*loc_ptr++)
157  {
159  *new_ptr = loc_ptr;
160  return DEBUG_LOC_END_OF_LIST;
162  *low = 0;
163  loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
164  if (loc_ptr == NULL)
166  *high = dwarf2_read_addr_index (per_cu, high_index);
167  *new_ptr = loc_ptr;
168  return DEBUG_LOC_BASE_ADDRESS;
169  case DEBUG_LOC_START_END:
170  loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
171  if (loc_ptr == NULL)
173  *low = dwarf2_read_addr_index (per_cu, low_index);
174  loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
175  if (loc_ptr == NULL)
177  *high = dwarf2_read_addr_index (per_cu, high_index);
178  *new_ptr = loc_ptr;
179  return DEBUG_LOC_START_END;
181  loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
182  if (loc_ptr == NULL)
184  *low = dwarf2_read_addr_index (per_cu, low_index);
185  if (loc_ptr + 4 > buf_end)
187  *high = *low;
188  *high += extract_unsigned_integer (loc_ptr, 4, byte_order);
189  *new_ptr = loc_ptr + 4;
190  return DEBUG_LOC_START_LENGTH;
191  default:
193  }
194 }
195 
196 /* A function for dealing with location lists. Given a
197  symbol baton (BATON) and a pc value (PC), find the appropriate
198  location expression, set *LOCEXPR_LENGTH, and return a pointer
199  to the beginning of the expression. Returns NULL on failure.
200 
201  For now, only return the first matching location expression; there
202  can be more than one in the list. */
203 
204 const gdb_byte *
206  size_t *locexpr_length, CORE_ADDR pc)
207 {
208  struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
209  struct gdbarch *gdbarch = get_objfile_arch (objfile);
210  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
211  unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
212  int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
213  /* Adjust base_address for relocatable objects. */
214  CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu);
215  CORE_ADDR base_address = baton->base_address + base_offset;
216  const gdb_byte *loc_ptr, *buf_end;
217 
218  loc_ptr = baton->data;
219  buf_end = baton->data + baton->size;
220 
221  while (1)
222  {
223  CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
224  int length;
225  enum debug_loc_kind kind;
226  const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
227 
228  if (baton->from_dwo)
229  kind = decode_debug_loc_dwo_addresses (baton->per_cu,
230  loc_ptr, buf_end, &new_ptr,
231  &low, &high, byte_order);
232  else
233  kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
234  &low, &high,
235  byte_order, addr_size,
236  signed_addr_p);
237  loc_ptr = new_ptr;
238  switch (kind)
239  {
241  *locexpr_length = 0;
242  return NULL;
244  base_address = high + base_offset;
245  continue;
246  case DEBUG_LOC_START_END:
248  break;
251  error (_("dwarf2_find_location_expression: "
252  "Corrupted DWARF expression."));
253  default:
254  gdb_assert_not_reached ("bad debug_loc_kind");
255  }
256 
257  /* Otherwise, a location expression entry.
258  If the entry is from a DWO, don't add base address: the entry is
259  from .debug_addr which has absolute addresses. */
260  if (! baton->from_dwo)
261  {
262  low += base_address;
263  high += base_address;
264  }
265 
266  length = extract_unsigned_integer (loc_ptr, 2, byte_order);
267  loc_ptr += 2;
268 
269  if (low == high && pc == low)
270  {
271  /* This is entry PC record present only at entry point
272  of a function. Verify it is really the function entry point. */
273 
274  const struct block *pc_block = block_for_pc (pc);
275  struct symbol *pc_func = NULL;
276 
277  if (pc_block)
278  pc_func = block_linkage_function (pc_block);
279 
280  if (pc_func && pc == BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func)))
281  {
282  *locexpr_length = length;
283  return loc_ptr;
284  }
285  }
286 
287  if (pc >= low && pc < high)
288  {
289  *locexpr_length = length;
290  return loc_ptr;
291  }
292 
293  loc_ptr += length;
294  }
295 }
296 
297 /* This is the baton used when performing dwarf2 expression
298  evaluation. */
300 {
301  struct frame_info *frame;
304 };
305 
306 /* Helper functions for dwarf2_evaluate_loc_desc. */
307 
308 /* Using the frame specified in BATON, return the value of register
309  REGNUM, treated as a pointer. */
310 static CORE_ADDR
311 dwarf_expr_read_addr_from_reg (void *baton, int dwarf_regnum)
312 {
313  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
314  struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
315  int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
316 
317  return address_from_register (regnum, debaton->frame);
318 }
319 
320 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback. */
321 
322 static struct value *
323 dwarf_expr_get_reg_value (void *baton, struct type *type, int dwarf_regnum)
324 {
325  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
326  struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
327  int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
328 
329  return value_from_register (type, regnum, debaton->frame);
330 }
331 
332 /* Read memory at ADDR (length LEN) into BUF. */
333 
334 static void
335 dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
336 {
337  read_memory (addr, buf, len);
338 }
339 
340 /* Using the frame specified in BATON, find the location expression
341  describing the frame base. Return a pointer to it in START and
342  its length in LENGTH. */
343 static void
344 dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length)
345 {
346  /* FIXME: cagney/2003-03-26: This code should be using
347  get_frame_base_address(), and then implement a dwarf2 specific
348  this_base method. */
349  struct symbol *framefunc;
350  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
351  const struct block *bl = get_frame_block (debaton->frame, NULL);
352 
353  if (bl == NULL)
354  error (_("frame address is not available."));
355 
356  /* Use block_linkage_function, which returns a real (not inlined)
357  function, instead of get_frame_function, which may return an
358  inlined function. */
359  framefunc = block_linkage_function (bl);
360 
361  /* If we found a frame-relative symbol then it was certainly within
362  some function associated with a frame. If we can't find the frame,
363  something has gone wrong. */
364  gdb_assert (framefunc != NULL);
365 
368  start, length);
369 }
370 
371 /* Implement find_frame_base_location method for LOC_BLOCK functions using
372  DWARF expression for its DW_AT_frame_base. */
373 
374 static void
376  const gdb_byte **start, size_t *length)
377 {
378  struct dwarf2_locexpr_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
379 
380  *length = symbaton->size;
381  *start = symbaton->data;
382 }
383 
384 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
385  function uses DWARF expression for its DW_AT_frame_base. */
386 
387 const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs =
388 {
390 };
391 
392 /* Implement find_frame_base_location method for LOC_BLOCK functions using
393  DWARF location list for its DW_AT_frame_base. */
394 
395 static void
397  const gdb_byte **start, size_t *length)
398 {
399  struct dwarf2_loclist_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
400 
401  *start = dwarf2_find_location_expression (symbaton, length, pc);
402 }
403 
404 /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
405  function uses DWARF location list for its DW_AT_frame_base. */
406 
407 const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs =
408 {
410 };
411 
412 /* See dwarf2loc.h. */
413 
414 void
416  const gdb_byte **start, size_t *length)
417 {
418  if (SYMBOL_BLOCK_OPS (framefunc) != NULL)
419  {
420  const struct symbol_block_ops *ops_block = SYMBOL_BLOCK_OPS (framefunc);
421 
422  ops_block->find_frame_base_location (framefunc, pc, start, length);
423  }
424  else
425  *length = 0;
426 
427  if (*length == 0)
428  error (_("Could not find the frame base for \"%s\"."),
429  SYMBOL_NATURAL_NAME (framefunc));
430 }
431 
432 /* Helper function for dwarf2_evaluate_loc_desc. Computes the CFA for
433  the frame in BATON. */
434 
435 static CORE_ADDR
436 dwarf_expr_frame_cfa (void *baton)
437 {
438  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
439 
440  return dwarf2_frame_cfa (debaton->frame);
441 }
442 
443 /* Helper function for dwarf2_evaluate_loc_desc. Computes the PC for
444  the frame in BATON. */
445 
446 static CORE_ADDR
447 dwarf_expr_frame_pc (void *baton)
448 {
449  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
450 
451  return get_frame_address_in_block (debaton->frame);
452 }
453 
454 /* Using the objfile specified in BATON, find the address for the
455  current thread's thread-local storage with offset OFFSET. */
456 static CORE_ADDR
458 {
459  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
460  struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu);
461 
462  return target_translate_tls_address (objfile, offset);
463 }
464 
465 /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
466  current CU (as is PER_CU). State of the CTX is not affected by the
467  call and return. */
468 
469 static void
471  struct dwarf2_per_cu_data *per_cu,
472  CORE_ADDR (*get_frame_pc) (void *baton),
473  void *baton)
474 {
475  struct dwarf2_locexpr_baton block;
476 
477  block = dwarf2_fetch_die_loc_cu_off (die_offset, per_cu, get_frame_pc, baton);
478 
479  /* DW_OP_call_ref is currently not supported. */
480  gdb_assert (block.per_cu == per_cu);
481 
482  dwarf_expr_eval (ctx, block.data, block.size);
483 }
484 
485 /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc. */
486 
487 static void
489 {
490  struct dwarf_expr_baton *debaton = ctx->baton;
491 
492  per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
493  ctx->funcs->get_frame_pc, ctx->baton);
494 }
495 
496 /* Callback function for dwarf2_evaluate_loc_desc. */
497 
498 static struct type *
500  cu_offset die_offset)
501 {
502  struct dwarf_expr_baton *debaton = ctx->baton;
503 
504  return dwarf2_get_die_type (die_offset, debaton->per_cu);
505 }
506 
507 /* See dwarf2loc.h. */
508 
509 unsigned int entry_values_debug = 0;
510 
511 /* Helper to set entry_values_debug. */
512 
513 static void
514 show_entry_values_debug (struct ui_file *file, int from_tty,
515  struct cmd_list_element *c, const char *value)
516 {
517  fprintf_filtered (file,
518  _("Entry values and tail call frames debugging is %s.\n"),
519  value);
520 }
521 
522 /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
523  CALLER_FRAME (for registers) can be NULL if it is not known. This function
524  always returns valid address or it throws NO_ENTRY_VALUE_ERROR. */
525 
526 static CORE_ADDR
527 call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
528  struct call_site *call_site,
529  struct frame_info *caller_frame)
530 {
531  switch (FIELD_LOC_KIND (call_site->target))
532  {
534  {
536  struct value *val;
537  struct type *caller_core_addr_type;
538  struct gdbarch *caller_arch;
539 
540  dwarf_block = FIELD_DWARF_BLOCK (call_site->target);
541  if (dwarf_block == NULL)
542  {
543  struct bound_minimal_symbol msym;
544 
545  msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
547  _("DW_AT_GNU_call_site_target is not specified "
548  "at %s in %s"),
549  paddress (call_site_gdbarch, call_site->pc),
550  (msym.minsym == NULL ? "???"
551  : MSYMBOL_PRINT_NAME (msym.minsym)));
552 
553  }
554  if (caller_frame == NULL)
555  {
556  struct bound_minimal_symbol msym;
557 
558  msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
560  _("DW_AT_GNU_call_site_target DWARF block resolving "
561  "requires known frame which is currently not "
562  "available at %s in %s"),
563  paddress (call_site_gdbarch, call_site->pc),
564  (msym.minsym == NULL ? "???"
565  : MSYMBOL_PRINT_NAME (msym.minsym)));
566 
567  }
568  caller_arch = get_frame_arch (caller_frame);
569  caller_core_addr_type = builtin_type (caller_arch)->builtin_func_ptr;
570  val = dwarf2_evaluate_loc_desc (caller_core_addr_type, caller_frame,
571  dwarf_block->data, dwarf_block->size,
572  dwarf_block->per_cu);
573  /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
574  location. */
575  if (VALUE_LVAL (val) == lval_memory)
576  return value_address (val);
577  else
578  return value_as_address (val);
579  }
580 
582  {
583  const char *physname;
584  struct bound_minimal_symbol msym;
585 
586  physname = FIELD_STATIC_PHYSNAME (call_site->target);
587 
588  /* Handle both the mangled and demangled PHYSNAME. */
589  msym = lookup_minimal_symbol (physname, NULL, NULL);
590  if (msym.minsym == NULL)
591  {
592  msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
594  _("Cannot find function \"%s\" for a call site target "
595  "at %s in %s"),
596  physname, paddress (call_site_gdbarch, call_site->pc),
597  (msym.minsym == NULL ? "???"
598  : MSYMBOL_PRINT_NAME (msym.minsym)));
599 
600  }
601  return BMSYMBOL_VALUE_ADDRESS (msym);
602  }
603 
605  return FIELD_STATIC_PHYSADDR (call_site->target);
606 
607  default:
608  internal_error (__FILE__, __LINE__, _("invalid call site target kind"));
609  }
610 }
611 
612 /* Convert function entry point exact address ADDR to the function which is
613  compliant with TAIL_CALL_LIST_COMPLETE condition. Throw
614  NO_ENTRY_VALUE_ERROR otherwise. */
615 
616 static struct symbol *
617 func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr)
618 {
619  struct symbol *sym = find_pc_function (addr);
620  struct type *type;
621 
622  if (sym == NULL || BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) != addr)
624  _("DW_TAG_GNU_call_site resolving failed to find function "
625  "name for address %s"),
626  paddress (gdbarch, addr));
627 
628  type = SYMBOL_TYPE (sym);
629  gdb_assert (TYPE_CODE (type) == TYPE_CODE_FUNC);
631 
632  return sym;
633 }
634 
635 /* Verify function with entry point exact address ADDR can never call itself
636  via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
637  can call itself via tail calls.
638 
639  If a funtion can tail call itself its entry value based parameters are
640  unreliable. There is no verification whether the value of some/all
641  parameters is unchanged through the self tail call, we expect if there is
642  a self tail call all the parameters can be modified. */
643 
644 static void
645 func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr)
646 {
647  struct obstack addr_obstack;
648  struct cleanup *old_chain;
649  CORE_ADDR addr;
650 
651  /* Track here CORE_ADDRs which were already visited. */
652  htab_t addr_hash;
653 
654  /* The verification is completely unordered. Track here function addresses
655  which still need to be iterated. */
656  VEC (CORE_ADDR) *todo = NULL;
657 
658  obstack_init (&addr_obstack);
659  old_chain = make_cleanup_obstack_free (&addr_obstack);
660  addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
661  &addr_obstack, hashtab_obstack_allocate,
662  NULL);
663  make_cleanup_htab_delete (addr_hash);
664 
666 
667  VEC_safe_push (CORE_ADDR, todo, verify_addr);
668  while (!VEC_empty (CORE_ADDR, todo))
669  {
670  struct symbol *func_sym;
671  struct call_site *call_site;
672 
673  addr = VEC_pop (CORE_ADDR, todo);
674 
675  func_sym = func_addr_to_tail_call_list (gdbarch, addr);
676 
677  for (call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym));
678  call_site; call_site = call_site->tail_call_next)
679  {
680  CORE_ADDR target_addr;
681  void **slot;
682 
683  /* CALLER_FRAME with registers is not available for tail-call jumped
684  frames. */
685  target_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
686 
687  if (target_addr == verify_addr)
688  {
689  struct bound_minimal_symbol msym;
690 
691  msym = lookup_minimal_symbol_by_pc (verify_addr);
693  _("DW_OP_GNU_entry_value resolving has found "
694  "function \"%s\" at %s can call itself via tail "
695  "calls"),
696  (msym.minsym == NULL ? "???"
697  : MSYMBOL_PRINT_NAME (msym.minsym)),
698  paddress (gdbarch, verify_addr));
699  }
700 
701  slot = htab_find_slot (addr_hash, &target_addr, INSERT);
702  if (*slot == NULL)
703  {
704  *slot = obstack_copy (&addr_obstack, &target_addr,
705  sizeof (target_addr));
706  VEC_safe_push (CORE_ADDR, todo, target_addr);
707  }
708  }
709  }
710 
711  do_cleanups (old_chain);
712 }
713 
714 /* Print user readable form of CALL_SITE->PC to gdb_stdlog. Used only for
715  ENTRY_VALUES_DEBUG. */
716 
717 static void
718 tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site)
719 {
720  CORE_ADDR addr = call_site->pc;
721  struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (addr - 1);
722 
723  fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr),
724  (msym.minsym == NULL ? "???"
725  : MSYMBOL_PRINT_NAME (msym.minsym)));
726 
727 }
728 
729 /* vec.h needs single word type name, typedef it. */
730 typedef struct call_site *call_sitep;
731 
732 /* Define VEC (call_sitep) functions. */
733 DEF_VEC_P (call_sitep);
734 
735 /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
736  only top callers and bottom callees which are present in both. GDBARCH is
737  used only for ENTRY_VALUES_DEBUG. RESULTP is NULL after return if there are
738  no remaining possibilities to provide unambiguous non-trivial result.
739  RESULTP should point to NULL on the first (initialization) call. Caller is
740  responsible for xfree of any RESULTP data. */
741 
742 static void
743 chain_candidate (struct gdbarch *gdbarch, struct call_site_chain **resultp,
744  VEC (call_sitep) *chain)
745 {
746  struct call_site_chain *result = *resultp;
747  long length = VEC_length (call_sitep, chain);
748  int callers, callees, idx;
749 
750  if (result == NULL)
751  {
752  /* Create the initial chain containing all the passed PCs. */
753 
754  result = xmalloc (sizeof (*result) + sizeof (*result->call_site)
755  * (length - 1));
756  result->length = length;
757  result->callers = result->callees = length;
758  if (!VEC_empty (call_sitep, chain))
759  memcpy (result->call_site, VEC_address (call_sitep, chain),
760  sizeof (*result->call_site) * length);
761  *resultp = result;
762 
763  if (entry_values_debug)
764  {
765  fprintf_unfiltered (gdb_stdlog, "tailcall: initial:");
766  for (idx = 0; idx < length; idx++)
767  tailcall_dump (gdbarch, result->call_site[idx]);
769  }
770 
771  return;
772  }
773 
774  if (entry_values_debug)
775  {
776  fprintf_unfiltered (gdb_stdlog, "tailcall: compare:");
777  for (idx = 0; idx < length; idx++)
778  tailcall_dump (gdbarch, VEC_index (call_sitep, chain, idx));
780  }
781 
782  /* Intersect callers. */
783 
784  callers = min (result->callers, length);
785  for (idx = 0; idx < callers; idx++)
786  if (result->call_site[idx] != VEC_index (call_sitep, chain, idx))
787  {
788  result->callers = idx;
789  break;
790  }
791 
792  /* Intersect callees. */
793 
794  callees = min (result->callees, length);
795  for (idx = 0; idx < callees; idx++)
796  if (result->call_site[result->length - 1 - idx]
797  != VEC_index (call_sitep, chain, length - 1 - idx))
798  {
799  result->callees = idx;
800  break;
801  }
802 
803  if (entry_values_debug)
804  {
805  fprintf_unfiltered (gdb_stdlog, "tailcall: reduced:");
806  for (idx = 0; idx < result->callers; idx++)
807  tailcall_dump (gdbarch, result->call_site[idx]);
809  for (idx = 0; idx < result->callees; idx++)
810  tailcall_dump (gdbarch, result->call_site[result->length
811  - result->callees + idx]);
813  }
814 
815  if (result->callers == 0 && result->callees == 0)
816  {
817  /* There are no common callers or callees. It could be also a direct
818  call (which has length 0) with ambiguous possibility of an indirect
819  call - CALLERS == CALLEES == 0 is valid during the first allocation
820  but any subsequence processing of such entry means ambiguity. */
821  xfree (result);
822  *resultp = NULL;
823  return;
824  }
825 
826  /* See call_site_find_chain_1 why there is no way to reach the bottom callee
827  PC again. In such case there must be two different code paths to reach
828  it. CALLERS + CALLEES equal to LENGTH in the case of self tail-call. */
829  gdb_assert (result->callers + result->callees <= result->length);
830 }
831 
832 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
833  assumed frames between them use GDBARCH. Use depth first search so we can
834  keep single CHAIN of call_site's back to CALLER_PC. Function recursion
835  would have needless GDB stack overhead. Caller is responsible for xfree of
836  the returned result. Any unreliability results in thrown
837  NO_ENTRY_VALUE_ERROR. */
838 
839 static struct call_site_chain *
840 call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
841  CORE_ADDR callee_pc)
842 {
843  CORE_ADDR save_callee_pc = callee_pc;
844  struct obstack addr_obstack;
845  struct cleanup *back_to_retval, *back_to_workdata;
846  struct call_site_chain *retval = NULL;
847  struct call_site *call_site;
848 
849  /* Mark CALL_SITEs so we do not visit the same ones twice. */
850  htab_t addr_hash;
851 
852  /* CHAIN contains only the intermediate CALL_SITEs. Neither CALLER_PC's
853  call_site nor any possible call_site at CALLEE_PC's function is there.
854  Any CALL_SITE in CHAIN will be iterated to its siblings - via
855  TAIL_CALL_NEXT. This is inappropriate for CALLER_PC's call_site. */
856  VEC (call_sitep) *chain = NULL;
857 
858  /* We are not interested in the specific PC inside the callee function. */
859  callee_pc = get_pc_function_start (callee_pc);
860  if (callee_pc == 0)
861  throw_error (NO_ENTRY_VALUE_ERROR, _("Unable to find function for PC %s"),
862  paddress (gdbarch, save_callee_pc));
863 
864  back_to_retval = make_cleanup (free_current_contents, &retval);
865 
866  obstack_init (&addr_obstack);
867  back_to_workdata = make_cleanup_obstack_free (&addr_obstack);
868  addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
869  &addr_obstack, hashtab_obstack_allocate,
870  NULL);
871  make_cleanup_htab_delete (addr_hash);
872 
873  make_cleanup (VEC_cleanup (call_sitep), &chain);
874 
875  /* Do not push CALL_SITE to CHAIN. Push there only the first tail call site
876  at the target's function. All the possible tail call sites in the
877  target's function will get iterated as already pushed into CHAIN via their
878  TAIL_CALL_NEXT. */
879  call_site = call_site_for_pc (gdbarch, caller_pc);
880 
881  while (call_site)
882  {
883  CORE_ADDR target_func_addr;
884  struct call_site *target_call_site;
885 
886  /* CALLER_FRAME with registers is not available for tail-call jumped
887  frames. */
888  target_func_addr = call_site_to_target_addr (gdbarch, call_site, NULL);
889 
890  if (target_func_addr == callee_pc)
891  {
892  chain_candidate (gdbarch, &retval, chain);
893  if (retval == NULL)
894  break;
895 
896  /* There is no way to reach CALLEE_PC again as we would prevent
897  entering it twice as being already marked in ADDR_HASH. */
898  target_call_site = NULL;
899  }
900  else
901  {
902  struct symbol *target_func;
903 
904  target_func = func_addr_to_tail_call_list (gdbarch, target_func_addr);
905  target_call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func));
906  }
907 
908  do
909  {
910  /* Attempt to visit TARGET_CALL_SITE. */
911 
912  if (target_call_site)
913  {
914  void **slot;
915 
916  slot = htab_find_slot (addr_hash, &target_call_site->pc, INSERT);
917  if (*slot == NULL)
918  {
919  /* Successfully entered TARGET_CALL_SITE. */
920 
921  *slot = &target_call_site->pc;
922  VEC_safe_push (call_sitep, chain, target_call_site);
923  break;
924  }
925  }
926 
927  /* Backtrack (without revisiting the originating call_site). Try the
928  callers's sibling; if there isn't any try the callers's callers's
929  sibling etc. */
930 
931  target_call_site = NULL;
932  while (!VEC_empty (call_sitep, chain))
933  {
934  call_site = VEC_pop (call_sitep, chain);
935 
936  gdb_assert (htab_find_slot (addr_hash, &call_site->pc,
937  NO_INSERT) != NULL);
938  htab_remove_elt (addr_hash, &call_site->pc);
939 
940  target_call_site = call_site->tail_call_next;
941  if (target_call_site)
942  break;
943  }
944  }
945  while (target_call_site);
946 
947  if (VEC_empty (call_sitep, chain))
948  call_site = NULL;
949  else
950  call_site = VEC_last (call_sitep, chain);
951  }
952 
953  if (retval == NULL)
954  {
955  struct bound_minimal_symbol msym_caller, msym_callee;
956 
957  msym_caller = lookup_minimal_symbol_by_pc (caller_pc);
958  msym_callee = lookup_minimal_symbol_by_pc (callee_pc);
960  _("There are no unambiguously determinable intermediate "
961  "callers or callees between caller function \"%s\" at %s "
962  "and callee function \"%s\" at %s"),
963  (msym_caller.minsym == NULL
964  ? "???" : MSYMBOL_PRINT_NAME (msym_caller.minsym)),
965  paddress (gdbarch, caller_pc),
966  (msym_callee.minsym == NULL
967  ? "???" : MSYMBOL_PRINT_NAME (msym_callee.minsym)),
968  paddress (gdbarch, callee_pc));
969  }
970 
971  do_cleanups (back_to_workdata);
972  discard_cleanups (back_to_retval);
973  return retval;
974 }
975 
976 /* Create and return call_site_chain for CALLER_PC and CALLEE_PC. All the
977  assumed frames between them use GDBARCH. If valid call_site_chain cannot be
978  constructed return NULL. Caller is responsible for xfree of the returned
979  result. */
980 
981 struct call_site_chain *
982 call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
983  CORE_ADDR callee_pc)
984 {
985  struct call_site_chain *retval = NULL;
986 
987  TRY
988  {
989  retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc);
990  }
992  {
993  if (e.error == NO_ENTRY_VALUE_ERROR)
994  {
995  if (entry_values_debug)
997 
998  return NULL;
999  }
1000  else
1001  throw_exception (e);
1002  }
1003  END_CATCH
1004 
1005  return retval;
1006 }
1007 
1008 /* Return 1 if KIND and KIND_U match PARAMETER. Return 0 otherwise. */
1009 
1010 static int
1012  enum call_site_parameter_kind kind,
1013  union call_site_parameter_u kind_u)
1014 {
1015  if (kind == parameter->kind)
1016  switch (kind)
1017  {
1019  return kind_u.dwarf_reg == parameter->u.dwarf_reg;
1021  return kind_u.fb_offset == parameter->u.fb_offset;
1023  return kind_u.param_offset.cu_off == parameter->u.param_offset.cu_off;
1024  }
1025  return 0;
1026 }
1027 
1028 /* Fetch call_site_parameter from caller matching KIND and KIND_U.
1029  FRAME is for callee.
1030 
1031  Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
1032  otherwise. */
1033 
1034 static struct call_site_parameter *
1037  union call_site_parameter_u kind_u,
1038  struct dwarf2_per_cu_data **per_cu_return)
1039 {
1040  CORE_ADDR func_addr, caller_pc;
1041  struct gdbarch *gdbarch;
1042  struct frame_info *caller_frame;
1043  struct call_site *call_site;
1044  int iparams;
1045  /* Initialize it just to avoid a GCC false warning. */
1046  struct call_site_parameter *parameter = NULL;
1047  CORE_ADDR target_addr;
1048 
1049  while (get_frame_type (frame) == INLINE_FRAME)
1050  {
1051  frame = get_prev_frame (frame);
1052  gdb_assert (frame != NULL);
1053  }
1054 
1055  func_addr = get_frame_func (frame);
1056  gdbarch = get_frame_arch (frame);
1057  caller_frame = get_prev_frame (frame);
1058  if (gdbarch != frame_unwind_arch (frame))
1059  {
1060  struct bound_minimal_symbol msym
1061  = lookup_minimal_symbol_by_pc (func_addr);
1062  struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);
1063 
1065  _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
1066  "(of %s (%s)) does not match caller gdbarch %s"),
1067  gdbarch_bfd_arch_info (gdbarch)->printable_name,
1068  paddress (gdbarch, func_addr),
1069  (msym.minsym == NULL ? "???"
1070  : MSYMBOL_PRINT_NAME (msym.minsym)),
1071  gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
1072  }
1073 
1074  if (caller_frame == NULL)
1075  {
1076  struct bound_minimal_symbol msym
1077  = lookup_minimal_symbol_by_pc (func_addr);
1078 
1079  throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_GNU_entry_value resolving "
1080  "requires caller of %s (%s)"),
1081  paddress (gdbarch, func_addr),
1082  (msym.minsym == NULL ? "???"
1083  : MSYMBOL_PRINT_NAME (msym.minsym)));
1084  }
1085  caller_pc = get_frame_pc (caller_frame);
1086  call_site = call_site_for_pc (gdbarch, caller_pc);
1087 
1088  target_addr = call_site_to_target_addr (gdbarch, call_site, caller_frame);
1089  if (target_addr != func_addr)
1090  {
1091  struct minimal_symbol *target_msym, *func_msym;
1092 
1093  target_msym = lookup_minimal_symbol_by_pc (target_addr).minsym;
1094  func_msym = lookup_minimal_symbol_by_pc (func_addr).minsym;
1096  _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
1097  "but the called frame is for %s at %s"),
1098  (target_msym == NULL ? "???"
1099  : MSYMBOL_PRINT_NAME (target_msym)),
1100  paddress (gdbarch, target_addr),
1101  func_msym == NULL ? "???" : MSYMBOL_PRINT_NAME (func_msym),
1102  paddress (gdbarch, func_addr));
1103  }
1104 
1105  /* No entry value based parameters would be reliable if this function can
1106  call itself via tail calls. */
1107  func_verify_no_selftailcall (gdbarch, func_addr);
1108 
1109  for (iparams = 0; iparams < call_site->parameter_count; iparams++)
1110  {
1111  parameter = &call_site->parameter[iparams];
1112  if (call_site_parameter_matches (parameter, kind, kind_u))
1113  break;
1114  }
1115  if (iparams == call_site->parameter_count)
1116  {
1117  struct minimal_symbol *msym
1118  = lookup_minimal_symbol_by_pc (caller_pc).minsym;
1119 
1120  /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
1121  determine its value. */
1122  throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
1123  "at DW_TAG_GNU_call_site %s at %s"),
1124  paddress (gdbarch, caller_pc),
1125  msym == NULL ? "???" : MSYMBOL_PRINT_NAME (msym));
1126  }
1127 
1128  *per_cu_return = call_site->per_cu;
1129  return parameter;
1130 }
1131 
1132 /* Return value for PARAMETER matching DEREF_SIZE. If DEREF_SIZE is -1, return
1133  the normal DW_AT_GNU_call_site_value block. Otherwise return the
1134  DW_AT_GNU_call_site_data_value (dereferenced) block.
1135 
1136  TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
1137  struct value.
1138 
1139  Function always returns non-NULL, non-optimized out value. It throws
1140  NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason. */
1141 
1142 static struct value *
1144  CORE_ADDR deref_size, struct type *type,
1145  struct frame_info *caller_frame,
1146  struct dwarf2_per_cu_data *per_cu)
1147 {
1148  const gdb_byte *data_src;
1149  gdb_byte *data;
1150  size_t size;
1151 
1152  data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1153  size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1154 
1155  /* DEREF_SIZE size is not verified here. */
1156  if (data_src == NULL)
1158  _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1159 
1160  /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
1161  location. Postprocessing of DWARF_VALUE_MEMORY would lose the type from
1162  DWARF block. */
1163  data = alloca (size + 1);
1164  memcpy (data, data_src, size);
1165  data[size] = DW_OP_stack_value;
1166 
1167  return dwarf2_evaluate_loc_desc (type, caller_frame, data, size + 1, per_cu);
1168 }
1169 
1170 /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
1171  Choose DEREF_SIZE value of that parameter. Search caller of the CTX's
1172  frame. CTX must be of dwarf_expr_ctx_funcs kind.
1173 
1174  The CTX caller can be from a different CU - per_cu_dwarf_call implementation
1175  can be more simple as it does not support cross-CU DWARF executions. */
1176 
1177 static void
1179  enum call_site_parameter_kind kind,
1180  union call_site_parameter_u kind_u,
1181  int deref_size)
1182 {
1183  struct dwarf_expr_baton *debaton;
1184  struct frame_info *frame, *caller_frame;
1185  struct dwarf2_per_cu_data *caller_per_cu;
1186  struct dwarf_expr_baton baton_local;
1187  struct dwarf_expr_context saved_ctx;
1188  struct call_site_parameter *parameter;
1189  const gdb_byte *data_src;
1190  size_t size;
1191 
1192  gdb_assert (ctx->funcs == &dwarf_expr_ctx_funcs);
1193  debaton = ctx->baton;
1194  frame = debaton->frame;
1195  caller_frame = get_prev_frame (frame);
1196 
1197  parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
1198  &caller_per_cu);
1199  data_src = deref_size == -1 ? parameter->value : parameter->data_value;
1200  size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;
1201 
1202  /* DEREF_SIZE size is not verified here. */
1203  if (data_src == NULL)
1205  _("Cannot resolve DW_AT_GNU_call_site_data_value"));
1206 
1207  baton_local.frame = caller_frame;
1208  baton_local.per_cu = caller_per_cu;
1209  baton_local.obj_address = 0;
1210 
1211  saved_ctx.gdbarch = ctx->gdbarch;
1212  saved_ctx.addr_size = ctx->addr_size;
1213  saved_ctx.offset = ctx->offset;
1214  saved_ctx.baton = ctx->baton;
1215  ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (baton_local.per_cu));
1216  ctx->addr_size = dwarf2_per_cu_addr_size (baton_local.per_cu);
1217  ctx->offset = dwarf2_per_cu_text_offset (baton_local.per_cu);
1218  ctx->baton = &baton_local;
1219 
1220  dwarf_expr_eval (ctx, data_src, size);
1221 
1222  ctx->gdbarch = saved_ctx.gdbarch;
1223  ctx->addr_size = saved_ctx.addr_size;
1224  ctx->offset = saved_ctx.offset;
1225  ctx->baton = saved_ctx.baton;
1226 }
1227 
1228 /* Callback function for dwarf2_evaluate_loc_desc.
1229  Fetch the address indexed by DW_OP_GNU_addr_index. */
1230 
1231 static CORE_ADDR
1232 dwarf_expr_get_addr_index (void *baton, unsigned int index)
1233 {
1234  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
1235 
1236  return dwarf2_read_addr_index (debaton->per_cu, index);
1237 }
1238 
1239 /* Callback function for get_object_address. Return the address of the VLA
1240  object. */
1241 
1242 static CORE_ADDR
1244 {
1245  struct dwarf_expr_baton *debaton = baton;
1246 
1247  gdb_assert (debaton != NULL);
1248 
1249  if (debaton->obj_address == 0)
1250  error (_("Location address is not set."));
1251 
1252  return debaton->obj_address;
1253 }
1254 
1255 /* VALUE must be of type lval_computed with entry_data_value_funcs. Perform
1256  the indirect method on it, that is use its stored target value, the sole
1257  purpose of entry_data_value_funcs.. */
1258 
1259 static struct value *
1261 {
1262  struct type *checked_type = check_typedef (value_type (value));
1263  struct value *target_val;
1264 
1265  if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
1266  return NULL;
1267 
1268  target_val = value_computed_closure (value);
1269  value_incref (target_val);
1270  return target_val;
1271 }
1272 
1273 /* Implement copy_closure. */
1274 
1275 static void *
1277 {
1278  struct value *target_val = value_computed_closure (v);
1279 
1280  value_incref (target_val);
1281  return target_val;
1282 }
1283 
1284 /* Implement free_closure. */
1285 
1286 static void
1288 {
1289  struct value *target_val = value_computed_closure (v);
1290 
1291  value_free (target_val);
1292 }
1293 
1294 /* Vector for methods for an entry value reference where the referenced value
1295  is stored in the caller. On the first dereference use
1296  DW_AT_GNU_call_site_data_value in the caller. */
1297 
1298 static const struct lval_funcs entry_data_value_funcs =
1299 {
1300  NULL, /* read */
1301  NULL, /* write */
1302  NULL, /* indirect */
1304  NULL, /* check_synthetic_pointer */
1307 };
1308 
1309 /* Read parameter of TYPE at (callee) FRAME's function entry. KIND and KIND_U
1310  are used to match DW_AT_location at the caller's
1311  DW_TAG_GNU_call_site_parameter.
1312 
1313  Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1314  cannot resolve the parameter for any reason. */
1315 
1316 static struct value *
1318  enum call_site_parameter_kind kind,
1319  union call_site_parameter_u kind_u)
1320 {
1321  struct type *checked_type = check_typedef (type);
1322  struct type *target_type = TYPE_TARGET_TYPE (checked_type);
1323  struct frame_info *caller_frame = get_prev_frame (frame);
1324  struct value *outer_val, *target_val, *val;
1325  struct call_site_parameter *parameter;
1326  struct dwarf2_per_cu_data *caller_per_cu;
1327 
1328  parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
1329  &caller_per_cu);
1330 
1331  outer_val = dwarf_entry_parameter_to_value (parameter, -1 /* deref_size */,
1332  type, caller_frame,
1333  caller_per_cu);
1334 
1335  /* Check if DW_AT_GNU_call_site_data_value cannot be used. If it should be
1336  used and it is not available do not fall back to OUTER_VAL - dereferencing
1337  TYPE_CODE_REF with non-entry data value would give current value - not the
1338  entry value. */
1339 
1340  if (TYPE_CODE (checked_type) != TYPE_CODE_REF
1341  || TYPE_TARGET_TYPE (checked_type) == NULL)
1342  return outer_val;
1343 
1344  target_val = dwarf_entry_parameter_to_value (parameter,
1345  TYPE_LENGTH (target_type),
1346  target_type, caller_frame,
1347  caller_per_cu);
1348 
1349  release_value (target_val);
1350  val = allocate_computed_value (type, &entry_data_value_funcs,
1351  target_val /* closure */);
1352 
1353  /* Copy the referencing pointer to the new computed value. */
1354  memcpy (value_contents_raw (val), value_contents_raw (outer_val),
1355  TYPE_LENGTH (checked_type));
1356  set_value_lazy (val, 0);
1357 
1358  return val;
1359 }
1360 
1361 /* Read parameter of TYPE at (callee) FRAME's function entry. DATA and
1362  SIZE are DWARF block used to match DW_AT_location at the caller's
1363  DW_TAG_GNU_call_site_parameter.
1364 
1365  Function always returns non-NULL value. It throws NO_ENTRY_VALUE_ERROR if it
1366  cannot resolve the parameter for any reason. */
1367 
1368 static struct value *
1370  const gdb_byte *block, size_t block_len)
1371 {
1372  union call_site_parameter_u kind_u;
1373 
1374  kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len);
1375  if (kind_u.dwarf_reg != -1)
1377  kind_u);
1378 
1379  if (dwarf_block_to_fb_offset (block, block + block_len, &kind_u.fb_offset))
1381  kind_u);
1382 
1383  /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
1384  suppressed during normal operation. The expression can be arbitrary if
1385  there is no caller-callee entry value binding expected. */
1387  _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
1388  "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
1389 }
1390 
1392 {
1393  /* Reference count. */
1394  int refc;
1395 
1396  /* The CU from which this closure's expression came. */
1398 
1399  /* The number of pieces used to describe this variable. */
1401 
1402  /* The target address size, used only for DWARF_VALUE_STACK. */
1404 
1405  /* The pieces themselves. */
1407 };
1408 
1409 /* Allocate a closure for a value formed from separately-described
1410  PIECES. */
1411 
1412 static struct piece_closure *
1414  int n_pieces, struct dwarf_expr_piece *pieces,
1415  int addr_size)
1416 {
1417  struct piece_closure *c = XCNEW (struct piece_closure);
1418  int i;
1419 
1420  c->refc = 1;
1421  c->per_cu = per_cu;
1422  c->n_pieces = n_pieces;
1423  c->addr_size = addr_size;
1424  c->pieces = XCNEWVEC (struct dwarf_expr_piece, n_pieces);
1425 
1426  memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
1427  for (i = 0; i < n_pieces; ++i)
1428  if (c->pieces[i].location == DWARF_VALUE_STACK)
1429  value_incref (c->pieces[i].v.value);
1430 
1431  return c;
1432 }
1433 
1434 /* The lowest-level function to extract bits from a byte buffer.
1435  SOURCE is the buffer. It is updated if we read to the end of a
1436  byte.
1437  SOURCE_OFFSET_BITS is the offset of the first bit to read. It is
1438  updated to reflect the number of bits actually read.
1439  NBITS is the number of bits we want to read. It is updated to
1440  reflect the number of bits actually read. This function may read
1441  fewer bits.
1442  BITS_BIG_ENDIAN is taken directly from gdbarch.
1443  This function returns the extracted bits. */
1444 
1445 static unsigned int
1447  unsigned int *source_offset_bits,
1448  int *nbits, int bits_big_endian)
1449 {
1450  unsigned int avail, mask, datum;
1451 
1452  gdb_assert (*source_offset_bits < 8);
1453 
1454  avail = 8 - *source_offset_bits;
1455  if (avail > *nbits)
1456  avail = *nbits;
1457 
1458  mask = (1 << avail) - 1;
1459  datum = **source;
1460  if (bits_big_endian)
1461  datum >>= 8 - (*source_offset_bits + *nbits);
1462  else
1463  datum >>= *source_offset_bits;
1464  datum &= mask;
1465 
1466  *nbits -= avail;
1467  *source_offset_bits += avail;
1468  if (*source_offset_bits >= 8)
1469  {
1470  *source_offset_bits -= 8;
1471  ++*source;
1472  }
1473 
1474  return datum;
1475 }
1476 
1477 /* Extract some bits from a source buffer and move forward in the
1478  buffer.
1479 
1480  SOURCE is the source buffer. It is updated as bytes are read.
1481  SOURCE_OFFSET_BITS is the offset into SOURCE. It is updated as
1482  bits are read.
1483  NBITS is the number of bits to read.
1484  BITS_BIG_ENDIAN is taken directly from gdbarch.
1485 
1486  This function returns the bits that were read. */
1487 
1488 static unsigned int
1489 extract_bits (const gdb_byte **source, unsigned int *source_offset_bits,
1490  int nbits, int bits_big_endian)
1491 {
1492  unsigned int datum;
1493 
1494  gdb_assert (nbits > 0 && nbits <= 8);
1495 
1496  datum = extract_bits_primitive (source, source_offset_bits, &nbits,
1497  bits_big_endian);
1498  if (nbits > 0)
1499  {
1500  unsigned int more;
1501 
1502  more = extract_bits_primitive (source, source_offset_bits, &nbits,
1503  bits_big_endian);
1504  if (bits_big_endian)
1505  datum <<= nbits;
1506  else
1507  more <<= nbits;
1508  datum |= more;
1509  }
1510 
1511  return datum;
1512 }
1513 
1514 /* Write some bits into a buffer and move forward in the buffer.
1515 
1516  DATUM is the bits to write. The low-order bits of DATUM are used.
1517  DEST is the destination buffer. It is updated as bytes are
1518  written.
1519  DEST_OFFSET_BITS is the bit offset in DEST at which writing is
1520  done.
1521  NBITS is the number of valid bits in DATUM.
1522  BITS_BIG_ENDIAN is taken directly from gdbarch. */
1523 
1524 static void
1525 insert_bits (unsigned int datum,
1526  gdb_byte *dest, unsigned int dest_offset_bits,
1527  int nbits, int bits_big_endian)
1528 {
1529  unsigned int mask;
1530 
1531  gdb_assert (dest_offset_bits + nbits <= 8);
1532 
1533  mask = (1 << nbits) - 1;
1534  if (bits_big_endian)
1535  {
1536  datum <<= 8 - (dest_offset_bits + nbits);
1537  mask <<= 8 - (dest_offset_bits + nbits);
1538  }
1539  else
1540  {
1541  datum <<= dest_offset_bits;
1542  mask <<= dest_offset_bits;
1543  }
1544 
1545  gdb_assert ((datum & ~mask) == 0);
1546 
1547  *dest = (*dest & ~mask) | datum;
1548 }
1549 
1550 /* Copy bits from a source to a destination.
1551 
1552  DEST is where the bits should be written.
1553  DEST_OFFSET_BITS is the bit offset into DEST.
1554  SOURCE is the source of bits.
1555  SOURCE_OFFSET_BITS is the bit offset into SOURCE.
1556  BIT_COUNT is the number of bits to copy.
1557  BITS_BIG_ENDIAN is taken directly from gdbarch. */
1558 
1559 static void
1560 copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
1561  const gdb_byte *source, unsigned int source_offset_bits,
1562  unsigned int bit_count,
1563  int bits_big_endian)
1564 {
1565  unsigned int dest_avail;
1566  int datum;
1567 
1568  /* Reduce everything to byte-size pieces. */
1569  dest += dest_offset_bits / 8;
1570  dest_offset_bits %= 8;
1571  source += source_offset_bits / 8;
1572  source_offset_bits %= 8;
1573 
1574  dest_avail = 8 - dest_offset_bits % 8;
1575 
1576  /* See if we can fill the first destination byte. */
1577  if (dest_avail < bit_count)
1578  {
1579  datum = extract_bits (&source, &source_offset_bits, dest_avail,
1580  bits_big_endian);
1581  insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
1582  ++dest;
1583  dest_offset_bits = 0;
1584  bit_count -= dest_avail;
1585  }
1586 
1587  /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
1588  than 8 bits remaining. */
1589  gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
1590  for (; bit_count >= 8; bit_count -= 8)
1591  {
1592  datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
1593  *dest++ = (gdb_byte) datum;
1594  }
1595 
1596  /* Finally, we may have a few leftover bits. */
1597  gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
1598  if (bit_count > 0)
1599  {
1600  datum = extract_bits (&source, &source_offset_bits, bit_count,
1601  bits_big_endian);
1602  insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
1603  }
1604 }
1605 
1606 static void
1608 {
1609  int i;
1610  long offset = 0;
1611  ULONGEST bits_to_skip;
1612  gdb_byte *contents;
1613  struct piece_closure *c
1614  = (struct piece_closure *) value_computed_closure (v);
1615  struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
1616  size_t type_len;
1617  size_t buffer_size = 0;
1618  gdb_byte *buffer = NULL;
1619  struct cleanup *cleanup;
1620  int bits_big_endian
1622 
1623  if (value_type (v) != value_enclosing_type (v))
1624  internal_error (__FILE__, __LINE__,
1625  _("Should not be able to create a lazy value with "
1626  "an enclosing type"));
1627 
1628  cleanup = make_cleanup (free_current_contents, &buffer);
1629 
1630  contents = value_contents_raw (v);
1631  bits_to_skip = 8 * value_offset (v);
1632  if (value_bitsize (v))
1633  {
1634  bits_to_skip += value_bitpos (v);
1635  type_len = value_bitsize (v);
1636  }
1637  else
1638  type_len = 8 * TYPE_LENGTH (value_type (v));
1639 
1640  for (i = 0; i < c->n_pieces && offset < type_len; i++)
1641  {
1642  struct dwarf_expr_piece *p = &c->pieces[i];
1643  size_t this_size, this_size_bits;
1644  long dest_offset_bits, source_offset_bits, source_offset;
1645  const gdb_byte *intermediate_buffer;
1646 
1647  /* Compute size, source, and destination offsets for copying, in
1648  bits. */
1649  this_size_bits = p->size;
1650  if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1651  {
1652  bits_to_skip -= this_size_bits;
1653  continue;
1654  }
1655  if (bits_to_skip > 0)
1656  {
1657  dest_offset_bits = 0;
1658  source_offset_bits = bits_to_skip;
1659  this_size_bits -= bits_to_skip;
1660  bits_to_skip = 0;
1661  }
1662  else
1663  {
1664  dest_offset_bits = offset;
1665  source_offset_bits = 0;
1666  }
1667  if (this_size_bits > type_len - offset)
1668  this_size_bits = type_len - offset;
1669 
1670  this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1671  source_offset = source_offset_bits / 8;
1672  if (buffer_size < this_size)
1673  {
1674  buffer_size = this_size;
1675  buffer = xrealloc (buffer, buffer_size);
1676  }
1677  intermediate_buffer = buffer;
1678 
1679  /* Copy from the source to DEST_BUFFER. */
1680  switch (p->location)
1681  {
1682  case DWARF_VALUE_REGISTER:
1683  {
1684  struct gdbarch *arch = get_frame_arch (frame);
1686 
1687  if (gdb_regnum != -1)
1688  {
1689  int optim, unavail;
1690  int reg_offset = source_offset;
1691 
1692  if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1693  && this_size < register_size (arch, gdb_regnum))
1694  {
1695  /* Big-endian, and we want less than full size. */
1696  reg_offset = register_size (arch, gdb_regnum) - this_size;
1697  /* We want the lower-order THIS_SIZE_BITS of the bytes
1698  we extract from the register. */
1699  source_offset_bits += 8 * this_size - this_size_bits;
1700  }
1701 
1702  if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1703  this_size, buffer,
1704  &optim, &unavail))
1705  {
1706  /* Just so garbage doesn't ever shine through. */
1707  memset (buffer, 0, this_size);
1708 
1709  if (optim)
1710  mark_value_bits_optimized_out (v, offset, this_size_bits);
1711  if (unavail)
1712  mark_value_bits_unavailable (v, offset, this_size_bits);
1713  }
1714  }
1715  else
1716  {
1717  error (_("Unable to access DWARF register number %s"),
1718  paddress (arch, p->v.regno));
1719  }
1720  }
1721  break;
1722 
1723  case DWARF_VALUE_MEMORY:
1724  read_value_memory (v, offset,
1725  p->v.mem.in_stack_memory,
1726  p->v.mem.addr + source_offset,
1727  buffer, this_size);
1728  break;
1729 
1730  case DWARF_VALUE_STACK:
1731  {
1732  size_t n = this_size;
1733 
1734  if (n > c->addr_size - source_offset)
1735  n = (c->addr_size >= source_offset
1736  ? c->addr_size - source_offset
1737  : 0);
1738  if (n == 0)
1739  {
1740  /* Nothing. */
1741  }
1742  else
1743  {
1744  const gdb_byte *val_bytes = value_contents_all (p->v.value);
1745 
1746  intermediate_buffer = val_bytes + source_offset;
1747  }
1748  }
1749  break;
1750 
1751  case DWARF_VALUE_LITERAL:
1752  {
1753  size_t n = this_size;
1754 
1755  if (n > p->v.literal.length - source_offset)
1756  n = (p->v.literal.length >= source_offset
1757  ? p->v.literal.length - source_offset
1758  : 0);
1759  if (n != 0)
1760  intermediate_buffer = p->v.literal.data + source_offset;
1761  }
1762  break;
1763 
1764  /* These bits show up as zeros -- but do not cause the value
1765  to be considered optimized-out. */
1767  break;
1768 
1770  mark_value_bits_optimized_out (v, offset, this_size_bits);
1771  break;
1772 
1773  default:
1774  internal_error (__FILE__, __LINE__, _("invalid location type"));
1775  }
1776 
1779  copy_bitwise (contents, dest_offset_bits,
1780  intermediate_buffer, source_offset_bits % 8,
1781  this_size_bits, bits_big_endian);
1782 
1783  offset += this_size_bits;
1784  }
1785 
1786  do_cleanups (cleanup);
1787 }
1788 
1789 static void
1791 {
1792  int i;
1793  long offset = 0;
1794  ULONGEST bits_to_skip;
1795  const gdb_byte *contents;
1796  struct piece_closure *c
1797  = (struct piece_closure *) value_computed_closure (to);
1798  struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
1799  size_t type_len;
1800  size_t buffer_size = 0;
1801  gdb_byte *buffer = NULL;
1802  struct cleanup *cleanup;
1803  int bits_big_endian
1805 
1806  if (frame == NULL)
1807  {
1809  return;
1810  }
1811 
1812  cleanup = make_cleanup (free_current_contents, &buffer);
1813 
1814  contents = value_contents (from);
1815  bits_to_skip = 8 * value_offset (to);
1816  if (value_bitsize (to))
1817  {
1818  bits_to_skip += value_bitpos (to);
1819  type_len = value_bitsize (to);
1820  }
1821  else
1822  type_len = 8 * TYPE_LENGTH (value_type (to));
1823 
1824  for (i = 0; i < c->n_pieces && offset < type_len; i++)
1825  {
1826  struct dwarf_expr_piece *p = &c->pieces[i];
1827  size_t this_size_bits, this_size;
1828  long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
1829  int need_bitwise;
1830  const gdb_byte *source_buffer;
1831 
1832  this_size_bits = p->size;
1833  if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
1834  {
1835  bits_to_skip -= this_size_bits;
1836  continue;
1837  }
1838  if (this_size_bits > type_len - offset)
1839  this_size_bits = type_len - offset;
1840  if (bits_to_skip > 0)
1841  {
1842  dest_offset_bits = bits_to_skip;
1843  source_offset_bits = 0;
1844  this_size_bits -= bits_to_skip;
1845  bits_to_skip = 0;
1846  }
1847  else
1848  {
1849  dest_offset_bits = 0;
1850  source_offset_bits = offset;
1851  }
1852 
1853  this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
1854  source_offset = source_offset_bits / 8;
1855  dest_offset = dest_offset_bits / 8;
1856  if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
1857  {
1858  source_buffer = contents + source_offset;
1859  need_bitwise = 0;
1860  }
1861  else
1862  {
1863  if (buffer_size < this_size)
1864  {
1865  buffer_size = this_size;
1866  buffer = xrealloc (buffer, buffer_size);
1867  }
1868  source_buffer = buffer;
1869  need_bitwise = 1;
1870  }
1871 
1872  switch (p->location)
1873  {
1874  case DWARF_VALUE_REGISTER:
1875  {
1876  struct gdbarch *arch = get_frame_arch (frame);
1878 
1879  if (gdb_regnum != -1)
1880  {
1881  int reg_offset = dest_offset;
1882 
1883  if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
1884  && this_size <= register_size (arch, gdb_regnum))
1885  {
1886  /* Big-endian, and we want less than full size. */
1887  reg_offset = register_size (arch, gdb_regnum) - this_size;
1888  }
1889 
1890  if (need_bitwise)
1891  {
1892  int optim, unavail;
1893 
1894  if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
1895  this_size, buffer,
1896  &optim, &unavail))
1897  {
1898  if (optim)
1900  _("Can't do read-modify-write to "
1901  "update bitfield; containing word "
1902  "has been optimized out"));
1903  if (unavail)
1905  _("Can't do read-modify-write to update "
1906  "bitfield; containing word "
1907  "is unavailable"));
1908  }
1909  copy_bitwise (buffer, dest_offset_bits,
1910  contents, source_offset_bits,
1911  this_size_bits,
1912  bits_big_endian);
1913  }
1914 
1915  put_frame_register_bytes (frame, gdb_regnum, reg_offset,
1916  this_size, source_buffer);
1917  }
1918  else
1919  {
1920  error (_("Unable to write to DWARF register number %s"),
1921  paddress (arch, p->v.regno));
1922  }
1923  }
1924  break;
1925  case DWARF_VALUE_MEMORY:
1926  if (need_bitwise)
1927  {
1928  /* Only the first and last bytes can possibly have any
1929  bits reused. */
1930  read_memory (p->v.mem.addr + dest_offset, buffer, 1);
1931  read_memory (p->v.mem.addr + dest_offset + this_size - 1,
1932  buffer + this_size - 1, 1);
1933  copy_bitwise (buffer, dest_offset_bits,
1934  contents, source_offset_bits,
1935  this_size_bits,
1936  bits_big_endian);
1937  }
1938 
1939  write_memory (p->v.mem.addr + dest_offset,
1940  source_buffer, this_size);
1941  break;
1942  default:
1944  break;
1945  }
1946  offset += this_size_bits;
1947  }
1948 
1949  do_cleanups (cleanup);
1950 }
1951 
1952 /* An implementation of an lval_funcs method to see whether a value is
1953  a synthetic pointer. */
1954 
1955 static int
1956 check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
1957  int bit_length)
1958 {
1959  struct piece_closure *c
1960  = (struct piece_closure *) value_computed_closure (value);
1961  int i;
1962 
1963  bit_offset += 8 * value_offset (value);
1964  if (value_bitsize (value))
1965  bit_offset += value_bitpos (value);
1966 
1967  for (i = 0; i < c->n_pieces && bit_length > 0; i++)
1968  {
1969  struct dwarf_expr_piece *p = &c->pieces[i];
1970  size_t this_size_bits = p->size;
1971 
1972  if (bit_offset > 0)
1973  {
1974  if (bit_offset >= this_size_bits)
1975  {
1976  bit_offset -= this_size_bits;
1977  continue;
1978  }
1979 
1980  bit_length -= this_size_bits - bit_offset;
1981  bit_offset = 0;
1982  }
1983  else
1984  bit_length -= this_size_bits;
1985 
1987  return 0;
1988  }
1989 
1990  return 1;
1991 }
1992 
1993 /* A wrapper function for get_frame_address_in_block. */
1994 
1995 static CORE_ADDR
1997 {
1998  return get_frame_address_in_block (baton);
1999 }
2000 
2001 /* An implementation of an lval_funcs method to indirect through a
2002  pointer. This handles the synthetic pointer case when needed. */
2003 
2004 static struct value *
2006 {
2007  struct piece_closure *c
2008  = (struct piece_closure *) value_computed_closure (value);
2009  struct type *type;
2010  struct frame_info *frame;
2011  struct dwarf2_locexpr_baton baton;
2012  int i, bit_offset, bit_length;
2013  struct dwarf_expr_piece *piece = NULL;
2014  LONGEST byte_offset;
2015  enum bfd_endian byte_order;
2016 
2017  type = check_typedef (value_type (value));
2018  if (TYPE_CODE (type) != TYPE_CODE_PTR)
2019  return NULL;
2020 
2021  bit_length = 8 * TYPE_LENGTH (type);
2022  bit_offset = 8 * value_offset (value);
2023  if (value_bitsize (value))
2024  bit_offset += value_bitpos (value);
2025 
2026  for (i = 0; i < c->n_pieces && bit_length > 0; i++)
2027  {
2028  struct dwarf_expr_piece *p = &c->pieces[i];
2029  size_t this_size_bits = p->size;
2030 
2031  if (bit_offset > 0)
2032  {
2033  if (bit_offset >= this_size_bits)
2034  {
2035  bit_offset -= this_size_bits;
2036  continue;
2037  }
2038 
2039  bit_length -= this_size_bits - bit_offset;
2040  bit_offset = 0;
2041  }
2042  else
2043  bit_length -= this_size_bits;
2044 
2046  return NULL;
2047 
2048  if (bit_length != 0)
2049  error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
2050 
2051  piece = p;
2052  break;
2053  }
2054 
2055  frame = get_selected_frame (_("No frame selected."));
2056 
2057  /* This is an offset requested by GDB, such as value subscripts.
2058  However, due to how synthetic pointers are implemented, this is
2059  always presented to us as a pointer type. This means we have to
2060  sign-extend it manually as appropriate. Use raw
2061  extract_signed_integer directly rather than value_as_address and
2062  sign extend afterwards on architectures that would need it
2063  (mostly everywhere except MIPS, which has signed addresses) as
2064  the later would go through gdbarch_pointer_to_address and thus
2065  return a CORE_ADDR with high bits set on architectures that
2066  encode address spaces and other things in CORE_ADDR. */
2067  byte_order = gdbarch_byte_order (get_frame_arch (frame));
2068  byte_offset = extract_signed_integer (value_contents (value),
2069  TYPE_LENGTH (type), byte_order);
2070  byte_offset += piece->v.ptr.offset;
2071 
2072  gdb_assert (piece);
2073  baton
2074  = dwarf2_fetch_die_loc_sect_off (piece->v.ptr.die, c->per_cu,
2076  frame);
2077 
2078  if (baton.data != NULL)
2079  return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
2080  baton.data, baton.size, baton.per_cu,
2081  byte_offset);
2082 
2083  {
2084  struct obstack temp_obstack;
2085  struct cleanup *cleanup;
2086  const gdb_byte *bytes;
2087  LONGEST len;
2088  struct value *result;
2089 
2090  obstack_init (&temp_obstack);
2091  cleanup = make_cleanup_obstack_free (&temp_obstack);
2092 
2093  bytes = dwarf2_fetch_constant_bytes (piece->v.ptr.die, c->per_cu,
2094  &temp_obstack, &len);
2095  if (bytes == NULL)
2097  else
2098  {
2099  if (byte_offset < 0
2100  || byte_offset + TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > len)
2102  bytes += byte_offset;
2103  result = value_from_contents (TYPE_TARGET_TYPE (type), bytes);
2104  }
2105 
2106  do_cleanups (cleanup);
2107  return result;
2108  }
2109 }
2110 
2111 static void *
2113 {
2114  struct piece_closure *c
2115  = (struct piece_closure *) value_computed_closure (v);
2116 
2117  ++c->refc;
2118  return c;
2119 }
2120 
2121 static void
2123 {
2124  struct piece_closure *c
2125  = (struct piece_closure *) value_computed_closure (v);
2126 
2127  --c->refc;
2128  if (c->refc == 0)
2129  {
2130  int i;
2131 
2132  for (i = 0; i < c->n_pieces; ++i)
2133  if (c->pieces[i].location == DWARF_VALUE_STACK)
2134  value_free (c->pieces[i].v.value);
2135 
2136  xfree (c->pieces);
2137  xfree (c);
2138  }
2139 }
2140 
2141 /* Functions for accessing a variable described by DW_OP_piece. */
2142 static const struct lval_funcs pieced_value_funcs = {
2146  NULL, /* coerce_ref */
2150 };
2151 
2152 /* Virtual method table for dwarf2_evaluate_loc_desc_full below. */
2153 
2154 const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
2155 {
2168 };
2169 
2170 /* Evaluate a location description, starting at DATA and with length
2171  SIZE, to find the current location of variable of TYPE in the
2172  context of FRAME. BYTE_OFFSET is applied after the contents are
2173  computed. */
2174 
2175 static struct value *
2177  const gdb_byte *data, size_t size,
2178  struct dwarf2_per_cu_data *per_cu,
2179  LONGEST byte_offset)
2180 {
2181  struct value *retval;
2182  struct dwarf_expr_baton baton;
2183  struct dwarf_expr_context *ctx;
2184  struct cleanup *old_chain, *value_chain;
2185  struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
2186 
2187  if (byte_offset < 0)
2189 
2190  if (size == 0)
2191  return allocate_optimized_out_value (type);
2192 
2193  baton.frame = frame;
2194  baton.per_cu = per_cu;
2195  baton.obj_address = 0;
2196 
2197  ctx = new_dwarf_expr_context ();
2198  old_chain = make_cleanup_free_dwarf_expr_context (ctx);
2199  value_chain = make_cleanup_value_free_to_mark (value_mark ());
2200 
2201  ctx->gdbarch = get_objfile_arch (objfile);
2202  ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
2204  ctx->offset = dwarf2_per_cu_text_offset (per_cu);
2205  ctx->baton = &baton;
2206  ctx->funcs = &dwarf_expr_ctx_funcs;
2207 
2208  TRY
2209  {
2210  dwarf_expr_eval (ctx, data, size);
2211  }
2212  CATCH (ex, RETURN_MASK_ERROR)
2213  {
2214  if (ex.error == NOT_AVAILABLE_ERROR)
2215  {
2216  do_cleanups (old_chain);
2217  retval = allocate_value (type);
2218  mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (type));
2219  return retval;
2220  }
2221  else if (ex.error == NO_ENTRY_VALUE_ERROR)
2222  {
2223  if (entry_values_debug)
2225  do_cleanups (old_chain);
2226  return allocate_optimized_out_value (type);
2227  }
2228  else
2229  throw_exception (ex);
2230  }
2231  END_CATCH
2232 
2233  if (ctx->num_pieces > 0)
2234  {
2235  struct piece_closure *c;
2236  struct frame_id frame_id = get_frame_id (frame);
2237  ULONGEST bit_size = 0;
2238  int i;
2239 
2240  for (i = 0; i < ctx->num_pieces; ++i)
2241  bit_size += ctx->pieces[i].size;
2242  if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
2244 
2245  c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
2246  ctx->addr_size);
2247  /* We must clean up the value chain after creating the piece
2248  closure but before allocating the result. */
2249  do_cleanups (value_chain);
2250  retval = allocate_computed_value (type, &pieced_value_funcs, c);
2251  VALUE_FRAME_ID (retval) = frame_id;
2252  set_value_offset (retval, byte_offset);
2253  }
2254  else
2255  {
2256  switch (ctx->location)
2257  {
2258  case DWARF_VALUE_REGISTER:
2259  {
2260  struct gdbarch *arch = get_frame_arch (frame);
2261  int dwarf_regnum
2263  int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
2264 
2265  if (byte_offset != 0)
2266  error (_("cannot use offset on synthetic pointer to register"));
2267  do_cleanups (value_chain);
2268  if (gdb_regnum == -1)
2269  error (_("Unable to access DWARF register number %d"),
2270  dwarf_regnum);
2271  retval = value_from_register (type, gdb_regnum, frame);
2272  if (value_optimized_out (retval))
2273  {
2274  struct value *tmp;
2275 
2276  /* This means the register has undefined value / was
2277  not saved. As we're computing the location of some
2278  variable etc. in the program, not a value for
2279  inspecting a register ($pc, $sp, etc.), return a
2280  generic optimized out value instead, so that we show
2281  <optimized out> instead of <not saved>. */
2282  do_cleanups (value_chain);
2283  tmp = allocate_value (type);
2284  value_contents_copy (tmp, 0, retval, 0, TYPE_LENGTH (type));
2285  retval = tmp;
2286  }
2287  }
2288  break;
2289 
2290  case DWARF_VALUE_MEMORY:
2291  {
2293  int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
2294 
2295  do_cleanups (value_chain);
2296  retval = value_at_lazy (type, address + byte_offset);
2297  if (in_stack_memory)
2298  set_value_stack (retval, 1);
2299  }
2300  break;
2301 
2302  case DWARF_VALUE_STACK:
2303  {
2304  struct value *value = dwarf_expr_fetch (ctx, 0);
2305  gdb_byte *contents;
2306  const gdb_byte *val_bytes;
2307  size_t n = TYPE_LENGTH (value_type (value));
2308 
2309  if (byte_offset + TYPE_LENGTH (type) > n)
2311 
2312  val_bytes = value_contents_all (value);
2313  val_bytes += byte_offset;
2314  n -= byte_offset;
2315 
2316  /* Preserve VALUE because we are going to free values back
2317  to the mark, but we still need the value contents
2318  below. */
2319  value_incref (value);
2320  do_cleanups (value_chain);
2321  make_cleanup_value_free (value);
2322 
2323  retval = allocate_value (type);
2324  contents = value_contents_raw (retval);
2325  if (n > TYPE_LENGTH (type))
2326  {
2327  struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2328 
2329  if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2330  val_bytes += n - TYPE_LENGTH (type);
2331  n = TYPE_LENGTH (type);
2332  }
2333  memcpy (contents, val_bytes, n);
2334  }
2335  break;
2336 
2337  case DWARF_VALUE_LITERAL:
2338  {
2339  bfd_byte *contents;
2340  const bfd_byte *ldata;
2341  size_t n = ctx->len;
2342 
2343  if (byte_offset + TYPE_LENGTH (type) > n)
2345 
2346  do_cleanups (value_chain);
2347  retval = allocate_value (type);
2348  contents = value_contents_raw (retval);
2349 
2350  ldata = ctx->data + byte_offset;
2351  n -= byte_offset;
2352 
2353  if (n > TYPE_LENGTH (type))
2354  {
2355  struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);
2356 
2357  if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
2358  ldata += n - TYPE_LENGTH (type);
2359  n = TYPE_LENGTH (type);
2360  }
2361  memcpy (contents, ldata, n);
2362  }
2363  break;
2364 
2366  do_cleanups (value_chain);
2367  retval = allocate_optimized_out_value (type);
2368  break;
2369 
2370  /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
2371  operation by execute_stack_op. */
2373  /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
2374  it can only be encountered when making a piece. */
2375  default:
2376  internal_error (__FILE__, __LINE__, _("invalid location type"));
2377  }
2378  }
2379 
2380  set_value_initialized (retval, ctx->initialized);
2381 
2382  do_cleanups (old_chain);
2383 
2384  return retval;
2385 }
2386 
2387 /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
2388  passes 0 as the byte_offset. */
2389 
2390 struct value *
2392  const gdb_byte *data, size_t size,
2393  struct dwarf2_per_cu_data *per_cu)
2394 {
2395  return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
2396 }
2397 
2398 /* Evaluates a dwarf expression and stores the result in VAL, expecting
2399  that the dwarf expression only produces a single CORE_ADDR. ADDR is a
2400  context (location of a variable) and might be needed to evaluate the
2401  location expression.
2402  Returns 1 on success, 0 otherwise. */
2403 
2404 static int
2406  CORE_ADDR addr,
2407  CORE_ADDR *valp)
2408 {
2409  struct dwarf_expr_context *ctx;
2410  struct dwarf_expr_baton baton;
2411  struct objfile *objfile;
2412  struct cleanup *cleanup;
2413 
2414  if (dlbaton == NULL || dlbaton->size == 0)
2415  return 0;
2416 
2417  ctx = new_dwarf_expr_context ();
2418  cleanup = make_cleanup_free_dwarf_expr_context (ctx);
2419 
2420  baton.frame = get_selected_frame (NULL);
2421  baton.per_cu = dlbaton->per_cu;
2422  baton.obj_address = addr;
2423 
2424  objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
2425 
2426  ctx->gdbarch = get_objfile_arch (objfile);
2427  ctx->addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
2429  ctx->offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
2430  ctx->funcs = &dwarf_expr_ctx_funcs;
2431  ctx->baton = &baton;
2432 
2433  dwarf_expr_eval (ctx, dlbaton->data, dlbaton->size);
2434 
2435  switch (ctx->location)
2436  {
2437  case DWARF_VALUE_REGISTER:
2438  case DWARF_VALUE_MEMORY:
2439  case DWARF_VALUE_STACK:
2440  *valp = dwarf_expr_fetch_address (ctx, 0);
2441  if (ctx->location == DWARF_VALUE_REGISTER)
2442  *valp = dwarf_expr_read_addr_from_reg (&baton, *valp);
2443  do_cleanups (cleanup);
2444  return 1;
2445  case DWARF_VALUE_LITERAL:
2446  *valp = extract_signed_integer (ctx->data, ctx->len,
2447  gdbarch_byte_order (ctx->gdbarch));
2448  do_cleanups (cleanup);
2449  return 1;
2450  /* Unsupported dwarf values. */
2453  break;
2454  }
2455 
2456  do_cleanups (cleanup);
2457  return 0;
2458 }
2459 
2460 /* See dwarf2loc.h. */
2461 
2462 int
2464  struct property_addr_info *addr_stack,
2465  CORE_ADDR *value)
2466 {
2467  if (prop == NULL)
2468  return 0;
2469 
2470  switch (prop->kind)
2471  {
2472  case PROP_LOCEXPR:
2473  {
2474  const struct dwarf2_property_baton *baton = prop->data.baton;
2475 
2476  if (dwarf2_locexpr_baton_eval (&baton->locexpr, addr_stack->addr,
2477  value))
2478  {
2479  if (baton->referenced_type)
2480  {
2481  struct value *val = value_at (baton->referenced_type, *value);
2482 
2483  *value = value_as_address (val);
2484  }
2485  return 1;
2486  }
2487  }
2488  break;
2489 
2490  case PROP_LOCLIST:
2491  {
2492  struct dwarf2_property_baton *baton = prop->data.baton;
2493  struct frame_info *frame = get_selected_frame (NULL);
2495  const gdb_byte *data;
2496  struct value *val;
2497  size_t size;
2498 
2499  data = dwarf2_find_location_expression (&baton->loclist, &size, pc);
2500  if (data != NULL)
2501  {
2502  val = dwarf2_evaluate_loc_desc (baton->referenced_type, frame, data,
2503  size, baton->loclist.per_cu);
2504  if (!value_optimized_out (val))
2505  {
2506  *value = value_as_address (val);
2507  return 1;
2508  }
2509  }
2510  }
2511  break;
2512 
2513  case PROP_CONST:
2514  *value = prop->data.const_val;
2515  return 1;
2516 
2517  case PROP_ADDR_OFFSET:
2518  {
2519  struct dwarf2_property_baton *baton = prop->data.baton;
2520  struct property_addr_info *pinfo;
2521  struct value *val;
2522 
2523  for (pinfo = addr_stack; pinfo != NULL; pinfo = pinfo->next)
2524  if (pinfo->type == baton->referenced_type)
2525  break;
2526  if (pinfo == NULL)
2527  error (_("cannot find reference address for offset property"));
2528  if (pinfo->valaddr != NULL)
2529  val = value_from_contents
2530  (baton->offset_info.type,
2531  pinfo->valaddr + baton->offset_info.offset);
2532  else
2533  val = value_at (baton->offset_info.type,
2534  pinfo->addr + baton->offset_info.offset);
2535  *value = value_as_address (val);
2536  return 1;
2537  }
2538  }
2539 
2540  return 0;
2541 }
2542 
2543 /* See dwarf2loc.h. */
2544 
2545 void
2547  const char *result_name,
2548  struct gdbarch *gdbarch,
2549  unsigned char *registers_used,
2550  const struct dynamic_prop *prop,
2551  CORE_ADDR pc,
2552  struct symbol *sym)
2553 {
2554  struct dwarf2_property_baton *baton = prop->data.baton;
2555  const gdb_byte *data;
2556  size_t size;
2557  struct dwarf2_per_cu_data *per_cu;
2558 
2559  if (prop->kind == PROP_LOCEXPR)
2560  {
2561  data = baton->locexpr.data;
2562  size = baton->locexpr.size;
2563  per_cu = baton->locexpr.per_cu;
2564  }
2565  else
2566  {
2567  gdb_assert (prop->kind == PROP_LOCLIST);
2568 
2569  data = dwarf2_find_location_expression (&baton->loclist, &size, pc);
2570  per_cu = baton->loclist.per_cu;
2571  }
2572 
2573  compile_dwarf_bounds_to_c (stream, result_name, prop, sym, pc,
2574  gdbarch, registers_used,
2575  dwarf2_per_cu_addr_size (per_cu),
2576  data, data + size, per_cu);
2577 }
2578 
2579 
2580 /* Helper functions and baton for dwarf2_loc_desc_needs_frame. */
2581 
2583 {
2586 };
2587 
2588 /* Reads from registers do require a frame. */
2589 static CORE_ADDR
2591 {
2592  struct needs_frame_baton *nf_baton = baton;
2593 
2594  nf_baton->needs_frame = 1;
2595  return 1;
2596 }
2597 
2598 /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
2599  Reads from registers do require a frame. */
2600 
2601 static struct value *
2602 needs_frame_get_reg_value (void *baton, struct type *type, int regnum)
2603 {
2604  struct needs_frame_baton *nf_baton = baton;
2605 
2606  nf_baton->needs_frame = 1;
2607  return value_zero (type, not_lval);
2608 }
2609 
2610 /* Reads from memory do not require a frame. */
2611 static void
2612 needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
2613 {
2614  memset (buf, 0, len);
2615 }
2616 
2617 /* Frame-relative accesses do require a frame. */
2618 static void
2619 needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
2620 {
2621  static gdb_byte lit0 = DW_OP_lit0;
2622  struct needs_frame_baton *nf_baton = baton;
2623 
2624  *start = &lit0;
2625  *length = 1;
2626 
2627  nf_baton->needs_frame = 1;
2628 }
2629 
2630 /* CFA accesses require a frame. */
2631 
2632 static CORE_ADDR
2634 {
2635  struct needs_frame_baton *nf_baton = baton;
2636 
2637  nf_baton->needs_frame = 1;
2638  return 1;
2639 }
2640 
2641 /* Thread-local accesses do require a frame. */
2642 static CORE_ADDR
2644 {
2645  struct needs_frame_baton *nf_baton = baton;
2646 
2647  nf_baton->needs_frame = 1;
2648  return 1;
2649 }
2650 
2651 /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame. */
2652 
2653 static void
2655 {
2656  struct needs_frame_baton *nf_baton = ctx->baton;
2657 
2658  per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
2659  ctx->funcs->get_frame_pc, ctx->baton);
2660 }
2661 
2662 /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame. */
2663 
2664 static void
2666  enum call_site_parameter_kind kind,
2667  union call_site_parameter_u kind_u, int deref_size)
2668 {
2669  struct needs_frame_baton *nf_baton = ctx->baton;
2670 
2671  nf_baton->needs_frame = 1;
2672 
2673  /* The expression may require some stub values on DWARF stack. */
2674  dwarf_expr_push_address (ctx, 0, 0);
2675 }
2676 
2677 /* DW_OP_GNU_addr_index doesn't require a frame. */
2678 
2679 static CORE_ADDR
2680 needs_get_addr_index (void *baton, unsigned int index)
2681 {
2682  /* Nothing to do. */
2683  return 1;
2684 }
2685 
2686 /* DW_OP_push_object_address has a frame already passed through. */
2687 
2688 static CORE_ADDR
2689 needs_get_obj_addr (void *baton)
2690 {
2691  /* Nothing to do. */
2692  return 1;
2693 }
2694 
2695 /* Virtual method table for dwarf2_loc_desc_needs_frame below. */
2696 
2697 static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs =
2698 {
2704  needs_frame_frame_cfa, /* get_frame_pc */
2707  NULL, /* get_base_type */
2711 };
2712 
2713 /* Return non-zero iff the location expression at DATA (length SIZE)
2714  requires a frame to evaluate. */
2715 
2716 static int
2718  struct dwarf2_per_cu_data *per_cu)
2719 {
2720  struct needs_frame_baton baton;
2721  struct dwarf_expr_context *ctx;
2722  int in_reg;
2723  struct cleanup *old_chain;
2724  struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
2725 
2726  baton.needs_frame = 0;
2727  baton.per_cu = per_cu;
2728 
2729  ctx = new_dwarf_expr_context ();
2730  old_chain = make_cleanup_free_dwarf_expr_context (ctx);
2732 
2733  ctx->gdbarch = get_objfile_arch (objfile);
2734  ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
2736  ctx->offset = dwarf2_per_cu_text_offset (per_cu);
2737  ctx->baton = &baton;
2738  ctx->funcs = &needs_frame_ctx_funcs;
2739 
2740  dwarf_expr_eval (ctx, data, size);
2741 
2742  in_reg = ctx->location == DWARF_VALUE_REGISTER;
2743 
2744  if (ctx->num_pieces > 0)
2745  {
2746  int i;
2747 
2748  /* If the location has several pieces, and any of them are in
2749  registers, then we will need a frame to fetch them from. */
2750  for (i = 0; i < ctx->num_pieces; i++)
2751  if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
2752  in_reg = 1;
2753  }
2754 
2755  do_cleanups (old_chain);
2756 
2757  return baton.needs_frame || in_reg;
2758 }
2759 
2760 /* A helper function that throws an unimplemented error mentioning a
2761  given DWARF operator. */
2762 
2763 static void
2764 unimplemented (unsigned int op)
2765 {
2766  const char *name = get_DW_OP_name (op);
2767 
2768  if (name)
2769  error (_("DWARF operator %s cannot be translated to an agent expression"),
2770  name);
2771  else
2772  error (_("Unknown DWARF operator 0x%02x cannot be translated "
2773  "to an agent expression"),
2774  op);
2775 }
2776 
2777 /* See dwarf2loc.h. */
2778 
2779 int
2780 dwarf2_reg_to_regnum_or_error (struct gdbarch *arch, int dwarf_reg)
2781 {
2782  int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
2783  if (reg == -1)
2784  error (_("Unable to access DWARF register number %d"), dwarf_reg);
2785  return reg;
2786 }
2787 
2788 /* A helper function that emits an access to memory. ARCH is the
2789  target architecture. EXPR is the expression which we are building.
2790  NBITS is the number of bits we want to read. This emits the
2791  opcodes needed to read the memory and then extract the desired
2792  bits. */
2793 
2794 static void
2795 access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
2796 {
2797  ULONGEST nbytes = (nbits + 7) / 8;
2798 
2799  gdb_assert (nbytes > 0 && nbytes <= sizeof (LONGEST));
2800 
2801  if (expr->tracing)
2802  ax_trace_quick (expr, nbytes);
2803 
2804  if (nbits <= 8)
2805  ax_simple (expr, aop_ref8);
2806  else if (nbits <= 16)
2807  ax_simple (expr, aop_ref16);
2808  else if (nbits <= 32)
2809  ax_simple (expr, aop_ref32);
2810  else
2811  ax_simple (expr, aop_ref64);
2812 
2813  /* If we read exactly the number of bytes we wanted, we're done. */
2814  if (8 * nbytes == nbits)
2815  return;
2816 
2817  if (gdbarch_bits_big_endian (arch))
2818  {
2819  /* On a bits-big-endian machine, we want the high-order
2820  NBITS. */
2821  ax_const_l (expr, 8 * nbytes - nbits);
2822  ax_simple (expr, aop_rsh_unsigned);
2823  }
2824  else
2825  {
2826  /* On a bits-little-endian box, we want the low-order NBITS. */
2827  ax_zero_ext (expr, nbits);
2828  }
2829 }
2830 
2831 /* A helper function to return the frame's PC. */
2832 
2833 static CORE_ADDR
2834 get_ax_pc (void *baton)
2835 {
2836  struct agent_expr *expr = baton;
2837 
2838  return expr->scope;
2839 }
2840 
2841 /* Compile a DWARF location expression to an agent expression.
2842 
2843  EXPR is the agent expression we are building.
2844  LOC is the agent value we modify.
2845  ARCH is the architecture.
2846  ADDR_SIZE is the size of addresses, in bytes.
2847  OP_PTR is the start of the location expression.
2848  OP_END is one past the last byte of the location expression.
2849 
2850  This will throw an exception for various kinds of errors -- for
2851  example, if the expression cannot be compiled, or if the expression
2852  is invalid. */
2853 
2854 void
2856  struct gdbarch *arch, unsigned int addr_size,
2857  const gdb_byte *op_ptr, const gdb_byte *op_end,
2858  struct dwarf2_per_cu_data *per_cu)
2859 {
2860  struct cleanup *cleanups;
2861  int i, *offsets;
2862  VEC(int) *dw_labels = NULL, *patches = NULL;
2863  const gdb_byte * const base = op_ptr;
2864  const gdb_byte *previous_piece = op_ptr;
2865  enum bfd_endian byte_order = gdbarch_byte_order (arch);
2866  ULONGEST bits_collected = 0;
2867  unsigned int addr_size_bits = 8 * addr_size;
2868  int bits_big_endian = gdbarch_bits_big_endian (arch);
2869 
2870  offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
2871  cleanups = make_cleanup (xfree, offsets);
2872 
2873  for (i = 0; i < op_end - op_ptr; ++i)
2874  offsets[i] = -1;
2875 
2876  make_cleanup (VEC_cleanup (int), &dw_labels);
2877  make_cleanup (VEC_cleanup (int), &patches);
2878 
2879  /* By default we are making an address. */
2880  loc->kind = axs_lvalue_memory;
2881 
2882  while (op_ptr < op_end)
2883  {
2884  enum dwarf_location_atom op = *op_ptr;
2885  uint64_t uoffset, reg;
2886  int64_t offset;
2887  int i;
2888 
2889  offsets[op_ptr - base] = expr->len;
2890  ++op_ptr;
2891 
2892  /* Our basic approach to code generation is to map DWARF
2893  operations directly to AX operations. However, there are
2894  some differences.
2895 
2896  First, DWARF works on address-sized units, but AX always uses
2897  LONGEST. For most operations we simply ignore this
2898  difference; instead we generate sign extensions as needed
2899  before division and comparison operations. It would be nice
2900  to omit the sign extensions, but there is no way to determine
2901  the size of the target's LONGEST. (This code uses the size
2902  of the host LONGEST in some cases -- that is a bug but it is
2903  difficult to fix.)
2904 
2905  Second, some DWARF operations cannot be translated to AX.
2906  For these we simply fail. See
2907  http://sourceware.org/bugzilla/show_bug.cgi?id=11662. */
2908  switch (op)
2909  {
2910  case DW_OP_lit0:
2911  case DW_OP_lit1:
2912  case DW_OP_lit2:
2913  case DW_OP_lit3:
2914  case DW_OP_lit4:
2915  case DW_OP_lit5:
2916  case DW_OP_lit6:
2917  case DW_OP_lit7:
2918  case DW_OP_lit8:
2919  case DW_OP_lit9:
2920  case DW_OP_lit10:
2921  case DW_OP_lit11:
2922  case DW_OP_lit12:
2923  case DW_OP_lit13:
2924  case DW_OP_lit14:
2925  case DW_OP_lit15:
2926  case DW_OP_lit16:
2927  case DW_OP_lit17:
2928  case DW_OP_lit18:
2929  case DW_OP_lit19:
2930  case DW_OP_lit20:
2931  case DW_OP_lit21:
2932  case DW_OP_lit22:
2933  case DW_OP_lit23:
2934  case DW_OP_lit24:
2935  case DW_OP_lit25:
2936  case DW_OP_lit26:
2937  case DW_OP_lit27:
2938  case DW_OP_lit28:
2939  case DW_OP_lit29:
2940  case DW_OP_lit30:
2941  case DW_OP_lit31:
2942  ax_const_l (expr, op - DW_OP_lit0);
2943  break;
2944 
2945  case DW_OP_addr:
2946  uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
2947  op_ptr += addr_size;
2948  /* Some versions of GCC emit DW_OP_addr before
2949  DW_OP_GNU_push_tls_address. In this case the value is an
2950  index, not an address. We don't support things like
2951  branching between the address and the TLS op. */
2952  if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
2953  uoffset += dwarf2_per_cu_text_offset (per_cu);
2954  ax_const_l (expr, uoffset);
2955  break;
2956 
2957  case DW_OP_const1u:
2958  ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order));
2959  op_ptr += 1;
2960  break;
2961  case DW_OP_const1s:
2962  ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order));
2963  op_ptr += 1;
2964  break;
2965  case DW_OP_const2u:
2966  ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order));
2967  op_ptr += 2;
2968  break;
2969  case DW_OP_const2s:
2970  ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order));
2971  op_ptr += 2;
2972  break;
2973  case DW_OP_const4u:
2974  ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order));
2975  op_ptr += 4;
2976  break;
2977  case DW_OP_const4s:
2978  ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order));
2979  op_ptr += 4;
2980  break;
2981  case DW_OP_const8u:
2982  ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order));
2983  op_ptr += 8;
2984  break;
2985  case DW_OP_const8s:
2986  ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order));
2987  op_ptr += 8;
2988  break;
2989  case DW_OP_constu:
2990  op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
2991  ax_const_l (expr, uoffset);
2992  break;
2993  case DW_OP_consts:
2994  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
2995  ax_const_l (expr, offset);
2996  break;
2997 
2998  case DW_OP_reg0:
2999  case DW_OP_reg1:
3000  case DW_OP_reg2:
3001  case DW_OP_reg3:
3002  case DW_OP_reg4:
3003  case DW_OP_reg5:
3004  case DW_OP_reg6:
3005  case DW_OP_reg7:
3006  case DW_OP_reg8:
3007  case DW_OP_reg9:
3008  case DW_OP_reg10:
3009  case DW_OP_reg11:
3010  case DW_OP_reg12:
3011  case DW_OP_reg13:
3012  case DW_OP_reg14:
3013  case DW_OP_reg15:
3014  case DW_OP_reg16:
3015  case DW_OP_reg17:
3016  case DW_OP_reg18:
3017  case DW_OP_reg19:
3018  case DW_OP_reg20:
3019  case DW_OP_reg21:
3020  case DW_OP_reg22:
3021  case DW_OP_reg23:
3022  case DW_OP_reg24:
3023  case DW_OP_reg25:
3024  case DW_OP_reg26:
3025  case DW_OP_reg27:
3026  case DW_OP_reg28:
3027  case DW_OP_reg29:
3028  case DW_OP_reg30:
3029  case DW_OP_reg31:
3030  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
3031  loc->u.reg = dwarf2_reg_to_regnum_or_error (arch, op - DW_OP_reg0);
3032  loc->kind = axs_lvalue_register;
3033  break;
3034 
3035  case DW_OP_regx:
3036  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
3037  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
3038  loc->u.reg = dwarf2_reg_to_regnum_or_error (arch, reg);
3039  loc->kind = axs_lvalue_register;
3040  break;
3041 
3042  case DW_OP_implicit_value:
3043  {
3044  uint64_t len;
3045 
3046  op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
3047  if (op_ptr + len > op_end)
3048  error (_("DW_OP_implicit_value: too few bytes available."));
3049  if (len > sizeof (ULONGEST))
3050  error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
3051  (int) len);
3052 
3053  ax_const_l (expr, extract_unsigned_integer (op_ptr, len,
3054  byte_order));
3055  op_ptr += len;
3056  dwarf_expr_require_composition (op_ptr, op_end,
3057  "DW_OP_implicit_value");
3058 
3059  loc->kind = axs_rvalue;
3060  }
3061  break;
3062 
3063  case DW_OP_stack_value:
3064  dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
3065  loc->kind = axs_rvalue;
3066  break;
3067 
3068  case DW_OP_breg0:
3069  case DW_OP_breg1:
3070  case DW_OP_breg2:
3071  case DW_OP_breg3:
3072  case DW_OP_breg4:
3073  case DW_OP_breg5:
3074  case DW_OP_breg6:
3075  case DW_OP_breg7:
3076  case DW_OP_breg8:
3077  case DW_OP_breg9:
3078  case DW_OP_breg10:
3079  case DW_OP_breg11:
3080  case DW_OP_breg12:
3081  case DW_OP_breg13:
3082  case DW_OP_breg14:
3083  case DW_OP_breg15:
3084  case DW_OP_breg16:
3085  case DW_OP_breg17:
3086  case DW_OP_breg18:
3087  case DW_OP_breg19:
3088  case DW_OP_breg20:
3089  case DW_OP_breg21:
3090  case DW_OP_breg22:
3091  case DW_OP_breg23:
3092  case DW_OP_breg24:
3093  case DW_OP_breg25:
3094  case DW_OP_breg26:
3095  case DW_OP_breg27:
3096  case DW_OP_breg28:
3097  case DW_OP_breg29:
3098  case DW_OP_breg30:
3099  case DW_OP_breg31:
3100  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3101  i = dwarf2_reg_to_regnum_or_error (arch, op - DW_OP_breg0);
3102  ax_reg (expr, i);
3103  if (offset != 0)
3104  {
3105  ax_const_l (expr, offset);
3106  ax_simple (expr, aop_add);
3107  }
3108  break;
3109  case DW_OP_bregx:
3110  {
3111  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
3112  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3113  i = dwarf2_reg_to_regnum_or_error (arch, reg);
3114  ax_reg (expr, i);
3115  if (offset != 0)
3116  {
3117  ax_const_l (expr, offset);
3118  ax_simple (expr, aop_add);
3119  }
3120  }
3121  break;
3122  case DW_OP_fbreg:
3123  {
3124  const gdb_byte *datastart;
3125  size_t datalen;
3126  const struct block *b;
3127  struct symbol *framefunc;
3128 
3129  b = block_for_pc (expr->scope);
3130 
3131  if (!b)
3132  error (_("No block found for address"));
3133 
3134  framefunc = block_linkage_function (b);
3135 
3136  if (!framefunc)
3137  error (_("No function found for block"));
3138 
3139  func_get_frame_base_dwarf_block (framefunc, expr->scope,
3140  &datastart, &datalen);
3141 
3142  op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
3143  dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
3144  datastart + datalen, per_cu);
3145  if (loc->kind == axs_lvalue_register)
3146  require_rvalue (expr, loc);
3147 
3148  if (offset != 0)
3149  {
3150  ax_const_l (expr, offset);
3151  ax_simple (expr, aop_add);
3152  }
3153 
3154  loc->kind = axs_lvalue_memory;
3155  }
3156  break;
3157 
3158  case DW_OP_dup:
3159  ax_simple (expr, aop_dup);
3160  break;
3161 
3162  case DW_OP_drop:
3163  ax_simple (expr, aop_pop);
3164  break;
3165 
3166  case DW_OP_pick:
3167  offset = *op_ptr++;
3168  ax_pick (expr, offset);
3169  break;
3170 
3171  case DW_OP_swap:
3172  ax_simple (expr, aop_swap);
3173  break;
3174 
3175  case DW_OP_over:
3176  ax_pick (expr, 1);
3177  break;
3178 
3179  case DW_OP_rot:
3180  ax_simple (expr, aop_rot);
3181  break;
3182 
3183  case DW_OP_deref:
3184  case DW_OP_deref_size:
3185  {
3186  int size;
3187 
3188  if (op == DW_OP_deref_size)
3189  size = *op_ptr++;
3190  else
3191  size = addr_size;
3192 
3193  if (size != 1 && size != 2 && size != 4 && size != 8)
3194  error (_("Unsupported size %d in %s"),
3195  size, get_DW_OP_name (op));
3196  access_memory (arch, expr, size * TARGET_CHAR_BIT);
3197  }
3198  break;
3199 
3200  case DW_OP_abs:
3201  /* Sign extend the operand. */
3202  ax_ext (expr, addr_size_bits);
3203  ax_simple (expr, aop_dup);
3204  ax_const_l (expr, 0);
3205  ax_simple (expr, aop_less_signed);
3206  ax_simple (expr, aop_log_not);
3207  i = ax_goto (expr, aop_if_goto);
3208  /* We have to emit 0 - X. */
3209  ax_const_l (expr, 0);
3210  ax_simple (expr, aop_swap);
3211  ax_simple (expr, aop_sub);
3212  ax_label (expr, i, expr->len);
3213  break;
3214 
3215  case DW_OP_neg:
3216  /* No need to sign extend here. */
3217  ax_const_l (expr, 0);
3218  ax_simple (expr, aop_swap);
3219  ax_simple (expr, aop_sub);
3220  break;
3221 
3222  case DW_OP_not:
3223  /* Sign extend the operand. */
3224  ax_ext (expr, addr_size_bits);
3225  ax_simple (expr, aop_bit_not);
3226  break;
3227 
3228  case DW_OP_plus_uconst:
3229  op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
3230  /* It would be really weird to emit `DW_OP_plus_uconst 0',
3231  but we micro-optimize anyhow. */
3232  if (reg != 0)
3233  {
3234  ax_const_l (expr, reg);
3235  ax_simple (expr, aop_add);
3236  }
3237  break;
3238 
3239  case DW_OP_and:
3240  ax_simple (expr, aop_bit_and);
3241  break;
3242 
3243  case DW_OP_div:
3244  /* Sign extend the operands. */
3245  ax_ext (expr, addr_size_bits);
3246  ax_simple (expr, aop_swap);
3247  ax_ext (expr, addr_size_bits);
3248  ax_simple (expr, aop_swap);
3249  ax_simple (expr, aop_div_signed);
3250  break;
3251 
3252  case DW_OP_minus:
3253  ax_simple (expr, aop_sub);
3254  break;
3255 
3256  case DW_OP_mod:
3257  ax_simple (expr, aop_rem_unsigned);
3258  break;
3259 
3260  case DW_OP_mul:
3261  ax_simple (expr, aop_mul);
3262  break;
3263 
3264  case DW_OP_or:
3265  ax_simple (expr, aop_bit_or);
3266  break;
3267 
3268  case DW_OP_plus:
3269  ax_simple (expr, aop_add);
3270  break;
3271 
3272  case DW_OP_shl:
3273  ax_simple (expr, aop_lsh);
3274  break;
3275 
3276  case DW_OP_shr:
3277  ax_simple (expr, aop_rsh_unsigned);
3278  break;
3279 
3280  case DW_OP_shra:
3281  ax_simple (expr, aop_rsh_signed);
3282  break;
3283 
3284  case DW_OP_xor:
3285  ax_simple (expr, aop_bit_xor);
3286  break;
3287 
3288  case DW_OP_le:
3289  /* Sign extend the operands. */
3290  ax_ext (expr, addr_size_bits);
3291  ax_simple (expr, aop_swap);
3292  ax_ext (expr, addr_size_bits);
3293  /* Note no swap here: A <= B is !(B < A). */
3294  ax_simple (expr, aop_less_signed);
3295  ax_simple (expr, aop_log_not);
3296  break;
3297 
3298  case DW_OP_ge:
3299  /* Sign extend the operands. */
3300  ax_ext (expr, addr_size_bits);
3301  ax_simple (expr, aop_swap);
3302  ax_ext (expr, addr_size_bits);
3303  ax_simple (expr, aop_swap);
3304  /* A >= B is !(A < B). */
3305  ax_simple (expr, aop_less_signed);
3306  ax_simple (expr, aop_log_not);
3307  break;
3308 
3309  case DW_OP_eq:
3310  /* Sign extend the operands. */
3311  ax_ext (expr, addr_size_bits);
3312  ax_simple (expr, aop_swap);
3313  ax_ext (expr, addr_size_bits);
3314  /* No need for a second swap here. */
3315  ax_simple (expr, aop_equal);
3316  break;
3317 
3318  case DW_OP_lt:
3319  /* Sign extend the operands. */
3320  ax_ext (expr, addr_size_bits);
3321  ax_simple (expr, aop_swap);
3322  ax_ext (expr, addr_size_bits);
3323  ax_simple (expr, aop_swap);
3324  ax_simple (expr, aop_less_signed);
3325  break;
3326 
3327  case DW_OP_gt:
3328  /* Sign extend the operands. */
3329  ax_ext (expr, addr_size_bits);
3330  ax_simple (expr, aop_swap);
3331  ax_ext (expr, addr_size_bits);
3332  /* Note no swap here: A > B is B < A. */
3333  ax_simple (expr, aop_less_signed);
3334  break;
3335 
3336  case DW_OP_ne:
3337  /* Sign extend the operands. */
3338  ax_ext (expr, addr_size_bits);
3339  ax_simple (expr, aop_swap);
3340  ax_ext (expr, addr_size_bits);
3341  /* No need for a swap here. */
3342  ax_simple (expr, aop_equal);
3343  ax_simple (expr, aop_log_not);
3344  break;
3345 
3346  case DW_OP_call_frame_cfa:
3347  {
3348  int regnum;
3349  CORE_ADDR text_offset;
3350  LONGEST off;
3351  const gdb_byte *cfa_start, *cfa_end;
3352 
3353  if (dwarf2_fetch_cfa_info (arch, expr->scope, per_cu,
3354  &regnum, &off,
3355  &text_offset, &cfa_start, &cfa_end))
3356  {
3357  /* Register. */
3358  ax_reg (expr, regnum);
3359  if (off != 0)
3360  {
3361  ax_const_l (expr, off);
3362  ax_simple (expr, aop_add);
3363  }
3364  }
3365  else
3366  {
3367  /* Another expression. */
3368  ax_const_l (expr, text_offset);
3369  dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
3370  cfa_start, cfa_end, per_cu);
3371  }
3372 
3373  loc->kind = axs_lvalue_memory;
3374  }
3375  break;
3376 
3377  case DW_OP_GNU_push_tls_address:
3378  unimplemented (op);
3379  break;
3380 
3381  case DW_OP_push_object_address:
3382  unimplemented (op);
3383  break;
3384 
3385  case DW_OP_skip:
3386  offset = extract_signed_integer (op_ptr, 2, byte_order);
3387  op_ptr += 2;
3388  i = ax_goto (expr, aop_goto);
3389  VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3390  VEC_safe_push (int, patches, i);
3391  break;
3392 
3393  case DW_OP_bra:
3394  offset = extract_signed_integer (op_ptr, 2, byte_order);
3395  op_ptr += 2;
3396  /* Zero extend the operand. */
3397  ax_zero_ext (expr, addr_size_bits);
3398  i = ax_goto (expr, aop_if_goto);
3399  VEC_safe_push (int, dw_labels, op_ptr + offset - base);
3400  VEC_safe_push (int, patches, i);
3401  break;
3402 
3403  case DW_OP_nop:
3404  break;
3405 
3406  case DW_OP_piece:
3407  case DW_OP_bit_piece:
3408  {
3409  uint64_t size, offset;
3410 
3411  if (op_ptr - 1 == previous_piece)
3412  error (_("Cannot translate empty pieces to agent expressions"));
3413  previous_piece = op_ptr - 1;
3414 
3415  op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
3416  if (op == DW_OP_piece)
3417  {
3418  size *= 8;
3419  offset = 0;
3420  }
3421  else
3422  op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);
3423 
3424  if (bits_collected + size > 8 * sizeof (LONGEST))
3425  error (_("Expression pieces exceed word size"));
3426 
3427  /* Access the bits. */
3428  switch (loc->kind)
3429  {
3430  case axs_lvalue_register:
3431  ax_reg (expr, loc->u.reg);
3432  break;
3433 
3434  case axs_lvalue_memory:
3435  /* Offset the pointer, if needed. */
3436  if (offset > 8)
3437  {
3438  ax_const_l (expr, offset / 8);
3439  ax_simple (expr, aop_add);
3440  offset %= 8;
3441  }
3442  access_memory (arch, expr, size);
3443  break;
3444  }
3445 
3446  /* For a bits-big-endian target, shift up what we already
3447  have. For a bits-little-endian target, shift up the
3448  new data. Note that there is a potential bug here if
3449  the DWARF expression leaves multiple values on the
3450  stack. */
3451  if (bits_collected > 0)
3452  {
3453  if (bits_big_endian)
3454  {
3455  ax_simple (expr, aop_swap);
3456  ax_const_l (expr, size);
3457  ax_simple (expr, aop_lsh);
3458  /* We don't need a second swap here, because
3459  aop_bit_or is symmetric. */
3460  }
3461  else
3462  {
3463  ax_const_l (expr, size);
3464  ax_simple (expr, aop_lsh);
3465  }
3466  ax_simple (expr, aop_bit_or);
3467  }
3468 
3469  bits_collected += size;
3470  loc->kind = axs_rvalue;
3471  }
3472  break;
3473 
3474  case DW_OP_GNU_uninit:
3475  unimplemented (op);
3476 
3477  case DW_OP_call2:
3478  case DW_OP_call4:
3479  {
3480  struct dwarf2_locexpr_baton block;
3481  int size = (op == DW_OP_call2 ? 2 : 4);
3482  cu_offset offset;
3483 
3484  uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
3485  op_ptr += size;
3486 
3487  offset.cu_off = uoffset;
3488  block = dwarf2_fetch_die_loc_cu_off (offset, per_cu,
3489  get_ax_pc, expr);
3490 
3491  /* DW_OP_call_ref is currently not supported. */
3492  gdb_assert (block.per_cu == per_cu);
3493 
3494  dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
3495  block.data, block.data + block.size,
3496  per_cu);
3497  }
3498  break;
3499 
3500  case DW_OP_call_ref:
3501  unimplemented (op);
3502 
3503  default:
3504  unimplemented (op);
3505  }
3506  }
3507 
3508  /* Patch all the branches we emitted. */
3509  for (i = 0; i < VEC_length (int, patches); ++i)
3510  {
3511  int targ = offsets[VEC_index (int, dw_labels, i)];
3512  if (targ == -1)
3513  internal_error (__FILE__, __LINE__, _("invalid label"));
3514  ax_label (expr, VEC_index (int, patches, i), targ);
3515  }
3516 
3517  do_cleanups (cleanups);
3518 }
3519 
3520 
3521 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
3522  evaluator to calculate the location. */
3523 static struct value *
3525 {
3526  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3527  struct value *val;
3528 
3529  val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3530  dlbaton->size, dlbaton->per_cu);
3531 
3532  return val;
3533 }
3534 
3535 /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
3536  entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
3537  will be thrown. */
3538 
3539 static struct value *
3541 {
3542  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3543 
3544  return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data,
3545  dlbaton->size);
3546 }
3547 
3548 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
3549 static int
3551 {
3552  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
3553 
3554  return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
3555  dlbaton->per_cu);
3556 }
3557 
3558 /* Return true if DATA points to the end of a piece. END is one past
3559  the last byte in the expression. */
3560 
3561 static int
3562 piece_end_p (const gdb_byte *data, const gdb_byte *end)
3563 {
3564  return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
3565 }
3566 
3567 /* Helper for locexpr_describe_location_piece that finds the name of a
3568  DWARF register. */
3569 
3570 static const char *
3571 locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum)
3572 {
3573  int regnum;
3574 
3575  regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
3576  return gdbarch_register_name (gdbarch, regnum);
3577 }
3578 
3579 /* Nicely describe a single piece of a location, returning an updated
3580  position in the bytecode sequence. This function cannot recognize
3581  all locations; if a location is not recognized, it simply returns
3582  DATA. If there is an error during reading, e.g. we run off the end
3583  of the buffer, an error is thrown. */
3584 
3585 static const gdb_byte *
3587  CORE_ADDR addr, struct objfile *objfile,
3588  struct dwarf2_per_cu_data *per_cu,
3589  const gdb_byte *data, const gdb_byte *end,
3590  unsigned int addr_size)
3591 {
3592  struct gdbarch *gdbarch = get_objfile_arch (objfile);
3593  size_t leb128_size;
3594 
3595  if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
3596  {
3597  fprintf_filtered (stream, _("a variable in $%s"),
3598  locexpr_regname (gdbarch, data[0] - DW_OP_reg0));
3599  data += 1;
3600  }
3601  else if (data[0] == DW_OP_regx)
3602  {
3603  uint64_t reg;
3604 
3605  data = safe_read_uleb128 (data + 1, end, &reg);
3606  fprintf_filtered (stream, _("a variable in $%s"),
3607  locexpr_regname (gdbarch, reg));
3608  }
3609  else if (data[0] == DW_OP_fbreg)
3610  {
3611  const struct block *b;
3612  struct symbol *framefunc;
3613  int frame_reg = 0;
3614  int64_t frame_offset;
3615  const gdb_byte *base_data, *new_data, *save_data = data;
3616  size_t base_size;
3617  int64_t base_offset = 0;
3618 
3619  new_data = safe_read_sleb128 (data + 1, end, &frame_offset);
3620  if (!piece_end_p (new_data, end))
3621  return data;
3622  data = new_data;
3623 
3624  b = block_for_pc (addr);
3625 
3626  if (!b)
3627  error (_("No block found for address for symbol \"%s\"."),
3628  SYMBOL_PRINT_NAME (symbol));
3629 
3630  framefunc = block_linkage_function (b);
3631 
3632  if (!framefunc)
3633  error (_("No function found for block for symbol \"%s\"."),
3634  SYMBOL_PRINT_NAME (symbol));
3635 
3636  func_get_frame_base_dwarf_block (framefunc, addr, &base_data, &base_size);
3637 
3638  if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
3639  {
3640  const gdb_byte *buf_end;
3641 
3642  frame_reg = base_data[0] - DW_OP_breg0;
3643  buf_end = safe_read_sleb128 (base_data + 1, base_data + base_size,
3644  &base_offset);
3645  if (buf_end != base_data + base_size)
3646  error (_("Unexpected opcode after "
3647  "DW_OP_breg%u for symbol \"%s\"."),
3648  frame_reg, SYMBOL_PRINT_NAME (symbol));
3649  }
3650  else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
3651  {
3652  /* The frame base is just the register, with no offset. */
3653  frame_reg = base_data[0] - DW_OP_reg0;
3654  base_offset = 0;
3655  }
3656  else
3657  {
3658  /* We don't know what to do with the frame base expression,
3659  so we can't trace this variable; give up. */
3660  return save_data;
3661  }
3662 
3663  fprintf_filtered (stream,
3664  _("a variable at frame base reg $%s offset %s+%s"),
3665  locexpr_regname (gdbarch, frame_reg),
3666  plongest (base_offset), plongest (frame_offset));
3667  }
3668  else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
3669  && piece_end_p (data, end))
3670  {
3671  int64_t offset;
3672 
3673  data = safe_read_sleb128 (data + 1, end, &offset);
3674 
3675  fprintf_filtered (stream,
3676  _("a variable at offset %s from base reg $%s"),
3677  plongest (offset),
3678  locexpr_regname (gdbarch, data[0] - DW_OP_breg0));
3679  }
3680 
3681  /* The location expression for a TLS variable looks like this (on a
3682  64-bit LE machine):
3683 
3684  DW_AT_location : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
3685  (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)
3686 
3687  0x3 is the encoding for DW_OP_addr, which has an operand as long
3688  as the size of an address on the target machine (here is 8
3689  bytes). Note that more recent version of GCC emit DW_OP_const4u
3690  or DW_OP_const8u, depending on address size, rather than
3691  DW_OP_addr. 0xe0 is the encoding for DW_OP_GNU_push_tls_address.
3692  The operand represents the offset at which the variable is within
3693  the thread local storage. */
3694 
3695  else if (data + 1 + addr_size < end
3696  && (data[0] == DW_OP_addr
3697  || (addr_size == 4 && data[0] == DW_OP_const4u)
3698  || (addr_size == 8 && data[0] == DW_OP_const8u))
3699  && data[1 + addr_size] == DW_OP_GNU_push_tls_address
3700  && piece_end_p (data + 2 + addr_size, end))
3701  {
3702  ULONGEST offset;
3703  offset = extract_unsigned_integer (data + 1, addr_size,
3704  gdbarch_byte_order (gdbarch));
3705 
3706  fprintf_filtered (stream,
3707  _("a thread-local variable at offset 0x%s "
3708  "in the thread-local storage for `%s'"),
3709  phex_nz (offset, addr_size), objfile_name (objfile));
3710 
3711  data += 1 + addr_size + 1;
3712  }
3713 
3714  /* With -gsplit-dwarf a TLS variable can also look like this:
3715  DW_AT_location : 3 byte block: fc 4 e0
3716  (DW_OP_GNU_const_index: 4;
3717  DW_OP_GNU_push_tls_address) */
3718  else if (data + 3 <= end
3719  && data + 1 + (leb128_size = skip_leb128 (data + 1, end)) < end
3720  && data[0] == DW_OP_GNU_const_index
3721  && leb128_size > 0
3722  && data[1 + leb128_size] == DW_OP_GNU_push_tls_address
3723  && piece_end_p (data + 2 + leb128_size, end))
3724  {
3725  uint64_t offset;
3726 
3727  data = safe_read_uleb128 (data + 1, end, &offset);
3728  offset = dwarf2_read_addr_index (per_cu, offset);
3729  fprintf_filtered (stream,
3730  _("a thread-local variable at offset 0x%s "
3731  "in the thread-local storage for `%s'"),
3732  phex_nz (offset, addr_size), objfile_name (objfile));
3733  ++data;
3734  }
3735 
3736  else if (data[0] >= DW_OP_lit0
3737  && data[0] <= DW_OP_lit31
3738  && data + 1 < end
3739  && data[1] == DW_OP_stack_value)
3740  {
3741  fprintf_filtered (stream, _("the constant %d"), data[0] - DW_OP_lit0);
3742  data += 2;
3743  }
3744 
3745  return data;
3746 }
3747 
3748 /* Disassemble an expression, stopping at the end of a piece or at the
3749  end of the expression. Returns a pointer to the next unread byte
3750  in the input expression. If ALL is nonzero, then this function
3751  will keep going until it reaches the end of the expression.
3752  If there is an error during reading, e.g. we run off the end
3753  of the buffer, an error is thrown. */
3754 
3755 static const gdb_byte *
3757  struct gdbarch *arch, unsigned int addr_size,
3758  int offset_size, const gdb_byte *start,
3759  const gdb_byte *data, const gdb_byte *end,
3760  int indent, int all,
3761  struct dwarf2_per_cu_data *per_cu)
3762 {
3763  while (data < end
3764  && (all
3765  || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
3766  {
3767  enum dwarf_location_atom op = *data++;
3768  uint64_t ul;
3769  int64_t l;
3770  const char *name;
3771 
3772  name = get_DW_OP_name (op);
3773 
3774  if (!name)
3775  error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
3776  op, (long) (data - 1 - start));
3777  fprintf_filtered (stream, " %*ld: %s", indent + 4,
3778  (long) (data - 1 - start), name);
3779 
3780  switch (op)
3781  {
3782  case DW_OP_addr:
3783  ul = extract_unsigned_integer (data, addr_size,
3784  gdbarch_byte_order (arch));
3785  data += addr_size;
3786  fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
3787  break;
3788 
3789  case DW_OP_const1u:
3790  ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch));
3791  data += 1;
3792  fprintf_filtered (stream, " %s", pulongest (ul));
3793  break;
3794  case DW_OP_const1s:
3795  l = extract_signed_integer (data, 1, gdbarch_byte_order (arch));
3796  data += 1;
3797  fprintf_filtered (stream, " %s", plongest (l));
3798  break;
3799  case DW_OP_const2u:
3800  ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3801  data += 2;
3802  fprintf_filtered (stream, " %s", pulongest (ul));
3803  break;
3804  case DW_OP_const2s:
3805  l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3806  data += 2;
3807  fprintf_filtered (stream, " %s", plongest (l));
3808  break;
3809  case DW_OP_const4u:
3810  ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3811  data += 4;
3812  fprintf_filtered (stream, " %s", pulongest (ul));
3813  break;
3814  case DW_OP_const4s:
3815  l = extract_signed_integer (data, 4, gdbarch_byte_order (arch));
3816  data += 4;
3817  fprintf_filtered (stream, " %s", plongest (l));
3818  break;
3819  case DW_OP_const8u:
3820  ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch));
3821  data += 8;
3822  fprintf_filtered (stream, " %s", pulongest (ul));
3823  break;
3824  case DW_OP_const8s:
3825  l = extract_signed_integer (data, 8, gdbarch_byte_order (arch));
3826  data += 8;
3827  fprintf_filtered (stream, " %s", plongest (l));
3828  break;
3829  case DW_OP_constu:
3830  data = safe_read_uleb128 (data, end, &ul);
3831  fprintf_filtered (stream, " %s", pulongest (ul));
3832  break;
3833  case DW_OP_consts:
3834  data = safe_read_sleb128 (data, end, &l);
3835  fprintf_filtered (stream, " %s", plongest (l));
3836  break;
3837 
3838  case DW_OP_reg0:
3839  case DW_OP_reg1:
3840  case DW_OP_reg2:
3841  case DW_OP_reg3:
3842  case DW_OP_reg4:
3843  case DW_OP_reg5:
3844  case DW_OP_reg6:
3845  case DW_OP_reg7:
3846  case DW_OP_reg8:
3847  case DW_OP_reg9:
3848  case DW_OP_reg10:
3849  case DW_OP_reg11:
3850  case DW_OP_reg12:
3851  case DW_OP_reg13:
3852  case DW_OP_reg14:
3853  case DW_OP_reg15:
3854  case DW_OP_reg16:
3855  case DW_OP_reg17:
3856  case DW_OP_reg18:
3857  case DW_OP_reg19:
3858  case DW_OP_reg20:
3859  case DW_OP_reg21:
3860  case DW_OP_reg22:
3861  case DW_OP_reg23:
3862  case DW_OP_reg24:
3863  case DW_OP_reg25:
3864  case DW_OP_reg26:
3865  case DW_OP_reg27:
3866  case DW_OP_reg28:
3867  case DW_OP_reg29:
3868  case DW_OP_reg30:
3869  case DW_OP_reg31:
3870  fprintf_filtered (stream, " [$%s]",
3871  locexpr_regname (arch, op - DW_OP_reg0));
3872  break;
3873 
3874  case DW_OP_regx:
3875  data = safe_read_uleb128 (data, end, &ul);
3876  fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
3877  locexpr_regname (arch, (int) ul));
3878  break;
3879 
3880  case DW_OP_implicit_value:
3881  data = safe_read_uleb128 (data, end, &ul);
3882  data += ul;
3883  fprintf_filtered (stream, " %s", pulongest (ul));
3884  break;
3885 
3886  case DW_OP_breg0:
3887  case DW_OP_breg1:
3888  case DW_OP_breg2:
3889  case DW_OP_breg3:
3890  case DW_OP_breg4:
3891  case DW_OP_breg5:
3892  case DW_OP_breg6:
3893  case DW_OP_breg7:
3894  case DW_OP_breg8:
3895  case DW_OP_breg9:
3896  case DW_OP_breg10:
3897  case DW_OP_breg11:
3898  case DW_OP_breg12:
3899  case DW_OP_breg13:
3900  case DW_OP_breg14:
3901  case DW_OP_breg15:
3902  case DW_OP_breg16:
3903  case DW_OP_breg17:
3904  case DW_OP_breg18:
3905  case DW_OP_breg19:
3906  case DW_OP_breg20:
3907  case DW_OP_breg21:
3908  case DW_OP_breg22:
3909  case DW_OP_breg23:
3910  case DW_OP_breg24:
3911  case DW_OP_breg25:
3912  case DW_OP_breg26:
3913  case DW_OP_breg27:
3914  case DW_OP_breg28:
3915  case DW_OP_breg29:
3916  case DW_OP_breg30:
3917  case DW_OP_breg31:
3918  data = safe_read_sleb128 (data, end, &l);
3919  fprintf_filtered (stream, " %s [$%s]", plongest (l),
3920  locexpr_regname (arch, op - DW_OP_breg0));
3921  break;
3922 
3923  case DW_OP_bregx:
3924  data = safe_read_uleb128 (data, end, &ul);
3925  data = safe_read_sleb128 (data, end, &l);
3926  fprintf_filtered (stream, " register %s [$%s] offset %s",
3927  pulongest (ul),
3928  locexpr_regname (arch, (int) ul),
3929  plongest (l));
3930  break;
3931 
3932  case DW_OP_fbreg:
3933  data = safe_read_sleb128 (data, end, &l);
3934  fprintf_filtered (stream, " %s", plongest (l));
3935  break;
3936 
3937  case DW_OP_xderef_size:
3938  case DW_OP_deref_size:
3939  case DW_OP_pick:
3940  fprintf_filtered (stream, " %d", *data);
3941  ++data;
3942  break;
3943 
3944  case DW_OP_plus_uconst:
3945  data = safe_read_uleb128 (data, end, &ul);
3946  fprintf_filtered (stream, " %s", pulongest (ul));
3947  break;
3948 
3949  case DW_OP_skip:
3950  l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3951  data += 2;
3952  fprintf_filtered (stream, " to %ld",
3953  (long) (data + l - start));
3954  break;
3955 
3956  case DW_OP_bra:
3957  l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
3958  data += 2;
3959  fprintf_filtered (stream, " %ld",
3960  (long) (data + l - start));
3961  break;
3962 
3963  case DW_OP_call2:
3964  ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
3965  data += 2;
3966  fprintf_filtered (stream, " offset %s", phex_nz (ul, 2));
3967  break;
3968 
3969  case DW_OP_call4:
3970  ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
3971  data += 4;
3972  fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
3973  break;
3974 
3975  case DW_OP_call_ref:
3976  ul = extract_unsigned_integer (data, offset_size,
3977  gdbarch_byte_order (arch));
3978  data += offset_size;
3979  fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
3980  break;
3981 
3982  case DW_OP_piece:
3983  data = safe_read_uleb128 (data, end, &ul);
3984  fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
3985  break;
3986 
3987  case DW_OP_bit_piece:
3988  {
3989  uint64_t offset;
3990 
3991  data = safe_read_uleb128 (data, end, &ul);
3992  data = safe_read_uleb128 (data, end, &offset);
3993  fprintf_filtered (stream, " size %s offset %s (bits)",
3994  pulongest (ul), pulongest (offset));
3995  }
3996  break;
3997 
3998  case DW_OP_GNU_implicit_pointer:
3999  {
4000  ul = extract_unsigned_integer (data, offset_size,
4001  gdbarch_byte_order (arch));
4002  data += offset_size;
4003 
4004  data = safe_read_sleb128 (data, end, &l);
4005 
4006  fprintf_filtered (stream, " DIE %s offset %s",
4007  phex_nz (ul, offset_size),
4008  plongest (l));
4009  }
4010  break;
4011 
4012  case DW_OP_GNU_deref_type:
4013  {
4014  int addr_size = *data++;
4015  cu_offset offset;
4016  struct type *type;
4017 
4018  data = safe_read_uleb128 (data, end, &ul);
4019  offset.cu_off = ul;
4020  type = dwarf2_get_die_type (offset, per_cu);
4021  fprintf_filtered (stream, "<");
4022  type_print (type, "", stream, -1);
4023  fprintf_filtered (stream, " [0x%s]> %d", phex_nz (offset.cu_off, 0),
4024  addr_size);
4025  }
4026  break;
4027 
4028  case DW_OP_GNU_const_type:
4029  {
4030  cu_offset type_die;
4031  struct type *type;
4032 
4033  data = safe_read_uleb128 (data, end, &ul);
4034  type_die.cu_off = ul;
4035  type = dwarf2_get_die_type (type_die, per_cu);
4036  fprintf_filtered (stream, "<");
4037  type_print (type, "", stream, -1);
4038  fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
4039  }
4040  break;
4041 
4042  case DW_OP_GNU_regval_type:
4043  {
4044  uint64_t reg;
4045  cu_offset type_die;
4046  struct type *type;
4047 
4048  data = safe_read_uleb128 (data, end, &reg);
4049  data = safe_read_uleb128 (data, end, &ul);
4050  type_die.cu_off = ul;
4051 
4052  type = dwarf2_get_die_type (type_die, per_cu);
4053  fprintf_filtered (stream, "<");
4054  type_print (type, "", stream, -1);
4055  fprintf_filtered (stream, " [0x%s]> [$%s]",
4056  phex_nz (type_die.cu_off, 0),
4057  locexpr_regname (arch, reg));
4058  }
4059  break;
4060 
4061  case DW_OP_GNU_convert:
4062  case DW_OP_GNU_reinterpret:
4063  {
4064  cu_offset type_die;
4065 
4066  data = safe_read_uleb128 (data, end, &ul);
4067  type_die.cu_off = ul;
4068 
4069  if (type_die.cu_off == 0)
4070  fprintf_filtered (stream, "<0>");
4071  else
4072  {
4073  struct type *type;
4074 
4075  type = dwarf2_get_die_type (type_die, per_cu);
4076  fprintf_filtered (stream, "<");
4077  type_print (type, "", stream, -1);
4078  fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
4079  }
4080  }
4081  break;
4082 
4083  case DW_OP_GNU_entry_value:
4084  data = safe_read_uleb128 (data, end, &ul);
4085  fputc_filtered ('\n', stream);
4086  disassemble_dwarf_expression (stream, arch, addr_size, offset_size,
4087  start, data, data + ul, indent + 2,
4088  all, per_cu);
4089  data += ul;
4090  continue;
4091 
4092  case DW_OP_GNU_parameter_ref:
4093  ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
4094  data += 4;
4095  fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
4096  break;
4097 
4098  case DW_OP_GNU_addr_index:
4099  data = safe_read_uleb128 (data, end, &ul);
4100  ul = dwarf2_read_addr_index (per_cu, ul);
4101  fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
4102  break;
4103  case DW_OP_GNU_const_index:
4104  data = safe_read_uleb128 (data, end, &ul);
4105  ul = dwarf2_read_addr_index (per_cu, ul);
4106  fprintf_filtered (stream, " %s", pulongest (ul));
4107  break;
4108  }
4109 
4110  fprintf_filtered (stream, "\n");
4111  }
4112 
4113  return data;
4114 }
4115 
4116 /* Describe a single location, which may in turn consist of multiple
4117  pieces. */
4118 
4119 static void
4121  struct ui_file *stream,
4122  const gdb_byte *data, size_t size,
4123  struct objfile *objfile, unsigned int addr_size,
4124  int offset_size, struct dwarf2_per_cu_data *per_cu)
4125 {
4126  const gdb_byte *end = data + size;
4127  int first_piece = 1, bad = 0;
4128 
4129  while (data < end)
4130  {
4131  const gdb_byte *here = data;
4132  int disassemble = 1;
4133 
4134  if (first_piece)
4135  first_piece = 0;
4136  else
4137  fprintf_filtered (stream, _(", and "));
4138 
4139  if (!dwarf_always_disassemble)
4140  {
4141  data = locexpr_describe_location_piece (symbol, stream,
4142  addr, objfile, per_cu,
4143  data, end, addr_size);
4144  /* If we printed anything, or if we have an empty piece,
4145  then don't disassemble. */
4146  if (data != here
4147  || data[0] == DW_OP_piece
4148  || data[0] == DW_OP_bit_piece)
4149  disassemble = 0;
4150  }
4151  if (disassemble)
4152  {
4153  fprintf_filtered (stream, _("a complex DWARF expression:\n"));
4154  data = disassemble_dwarf_expression (stream,
4155  get_objfile_arch (objfile),
4156  addr_size, offset_size, data,
4157  data, end, 0,
4158  dwarf_always_disassemble,
4159  per_cu);
4160  }
4161 
4162  if (data < end)
4163  {
4164  int empty = data == here;
4165 
4166  if (disassemble)
4167  fprintf_filtered (stream, " ");
4168  if (data[0] == DW_OP_piece)
4169  {
4170  uint64_t bytes;
4171 
4172  data = safe_read_uleb128 (data + 1, end, &bytes);
4173 
4174  if (empty)
4175  fprintf_filtered (stream, _("an empty %s-byte piece"),
4176  pulongest (bytes));
4177  else
4178  fprintf_filtered (stream, _(" [%s-byte piece]"),
4179  pulongest (bytes));
4180  }
4181  else if (data[0] == DW_OP_bit_piece)
4182  {
4183  uint64_t bits, offset;
4184 
4185  data = safe_read_uleb128 (data + 1, end, &bits);
4186  data = safe_read_uleb128 (data, end, &offset);
4187 
4188  if (empty)
4189  fprintf_filtered (stream,
4190  _("an empty %s-bit piece"),
4191  pulongest (bits));
4192  else
4193  fprintf_filtered (stream,
4194  _(" [%s-bit piece, offset %s bits]"),
4195  pulongest (bits), pulongest (offset));
4196  }
4197  else
4198  {
4199  bad = 1;
4200  break;
4201  }
4202  }
4203  }
4204 
4205  if (bad || data > end)
4206  error (_("Corrupted DWARF2 expression for \"%s\"."),
4207  SYMBOL_PRINT_NAME (symbol));
4208 }
4209 
4210 /* Print a natural-language description of SYMBOL to STREAM. This
4211  version is for a symbol with a single location. */
4212 
4213 static void
4215  struct ui_file *stream)
4216 {
4217  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4218  struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
4219  unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4220  int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
4221 
4222  locexpr_describe_location_1 (symbol, addr, stream,
4223  dlbaton->data, dlbaton->size,
4224  objfile, addr_size, offset_size,
4225  dlbaton->per_cu);
4226 }
4227 
4228 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4229  any necessary bytecode in AX. */
4230 
4231 static void
4232 locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
4233  struct agent_expr *ax, struct axs_value *value)
4234 {
4235  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4236  unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4237 
4238  if (dlbaton->size == 0)
4239  value->optimized_out = 1;
4240  else
4241  dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
4242  dlbaton->data, dlbaton->data + dlbaton->size,
4243  dlbaton->per_cu);
4244 }
4245 
4246 /* symbol_computed_ops 'generate_c_location' method. */
4247 
4248 static void
4249 locexpr_generate_c_location (struct symbol *sym, struct ui_file *stream,
4250  struct gdbarch *gdbarch,
4251  unsigned char *registers_used,
4252  CORE_ADDR pc, const char *result_name)
4253 {
4254  struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (sym);
4255  unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4256 
4257  if (dlbaton->size == 0)
4258  error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym));
4259 
4260  compile_dwarf_expr_to_c (stream, result_name,
4261  sym, pc, gdbarch, registers_used, addr_size,
4262  dlbaton->data, dlbaton->data + dlbaton->size,
4263  dlbaton->per_cu);
4264 }
4265 
4266 /* The set of location functions used with the DWARF-2 expression
4267  evaluator. */
4268 const struct symbol_computed_ops dwarf2_locexpr_funcs = {
4273  0, /* location_has_loclist */
4276 };
4277 
4278 
4279 /* Wrapper functions for location lists. These generally find
4280  the appropriate location expression and call something above. */
4281 
4282 /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
4283  evaluator to calculate the location. */
4284 static struct value *
4286 {
4287  struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4288  struct value *val;
4289  const gdb_byte *data;
4290  size_t size;
4291  CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
4292 
4293  data = dwarf2_find_location_expression (dlbaton, &size, pc);
4294  val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
4295  dlbaton->per_cu);
4296 
4297  return val;
4298 }
4299 
4300 /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
4301  entry. SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
4302  will be thrown.
4303 
4304  Function always returns non-NULL value, it may be marked optimized out if
4305  inferior frame information is not available. It throws NO_ENTRY_VALUE_ERROR
4306  if it cannot resolve the parameter for any reason. */
4307 
4308 static struct value *
4310 {
4311  struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4312  const gdb_byte *data;
4313  size_t size;
4314  CORE_ADDR pc;
4315 
4316  if (frame == NULL || !get_frame_func_if_available (frame, &pc))
4317  return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4318 
4319  data = dwarf2_find_location_expression (dlbaton, &size, pc);
4320  if (data == NULL)
4321  return allocate_optimized_out_value (SYMBOL_TYPE (symbol));
4322 
4323  return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, data, size);
4324 }
4325 
4326 /* Return non-zero iff we need a frame to evaluate SYMBOL. */
4327 static int
4329 {
4330  /* If there's a location list, then assume we need to have a frame
4331  to choose the appropriate location expression. With tracking of
4332  global variables this is not necessarily true, but such tracking
4333  is disabled in GCC at the moment until we figure out how to
4334  represent it. */
4335 
4336  return 1;
4337 }
4338 
4339 /* Print a natural-language description of SYMBOL to STREAM. This
4340  version applies when there is a list of different locations, each
4341  with a specified address range. */
4342 
4343 static void
4345  struct ui_file *stream)
4346 {
4347  struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4348  const gdb_byte *loc_ptr, *buf_end;
4349  struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
4350  struct gdbarch *gdbarch = get_objfile_arch (objfile);
4351  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
4352  unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4353  int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
4354  int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
4355  /* Adjust base_address for relocatable objects. */
4356  CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
4357  CORE_ADDR base_address = dlbaton->base_address + base_offset;
4358  int done = 0;
4359 
4360  loc_ptr = dlbaton->data;
4361  buf_end = dlbaton->data + dlbaton->size;
4362 
4363  fprintf_filtered (stream, _("multi-location:\n"));
4364 
4365  /* Iterate through locations until we run out. */
4366  while (!done)
4367  {
4368  CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
4369  int length;
4370  enum debug_loc_kind kind;
4371  const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */
4372 
4373  if (dlbaton->from_dwo)
4374  kind = decode_debug_loc_dwo_addresses (dlbaton->per_cu,
4375  loc_ptr, buf_end, &new_ptr,
4376  &low, &high, byte_order);
4377  else
4378  kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
4379  &low, &high,
4380  byte_order, addr_size,
4381  signed_addr_p);
4382  loc_ptr = new_ptr;
4383  switch (kind)
4384  {
4385  case DEBUG_LOC_END_OF_LIST:
4386  done = 1;
4387  continue;
4389  base_address = high + base_offset;
4390  fprintf_filtered (stream, _(" Base address %s"),
4391  paddress (gdbarch, base_address));
4392  continue;
4393  case DEBUG_LOC_START_END:
4395  break;
4398  error (_("Corrupted DWARF expression for symbol \"%s\"."),
4399  SYMBOL_PRINT_NAME (symbol));
4400  default:
4401  gdb_assert_not_reached ("bad debug_loc_kind");
4402  }
4403 
4404  /* Otherwise, a location expression entry. */
4405  low += base_address;
4406  high += base_address;
4407 
4408  low = gdbarch_adjust_dwarf2_addr (gdbarch, low);
4409  high = gdbarch_adjust_dwarf2_addr (gdbarch, high);
4410 
4411  length = extract_unsigned_integer (loc_ptr, 2, byte_order);
4412  loc_ptr += 2;
4413 
4414  /* (It would improve readability to print only the minimum
4415  necessary digits of the second number of the range.) */
4416  fprintf_filtered (stream, _(" Range %s-%s: "),
4417  paddress (gdbarch, low), paddress (gdbarch, high));
4418 
4419  /* Now describe this particular location. */
4420  locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
4421  objfile, addr_size, offset_size,
4422  dlbaton->per_cu);
4423 
4424  fprintf_filtered (stream, "\n");
4425 
4426  loc_ptr += length;
4427  }
4428 }
4429 
4430 /* Describe the location of SYMBOL as an agent value in VALUE, generating
4431  any necessary bytecode in AX. */
4432 static void
4433 loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
4434  struct agent_expr *ax, struct axs_value *value)
4435 {
4436  struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
4437  const gdb_byte *data;
4438  size_t size;
4439  unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4440 
4441  data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
4442  if (size == 0)
4443  value->optimized_out = 1;
4444  else
4445  dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
4446  dlbaton->per_cu);
4447 }
4448 
4449 /* symbol_computed_ops 'generate_c_location' method. */
4450 
4451 static void
4452 loclist_generate_c_location (struct symbol *sym, struct ui_file *stream,
4453  struct gdbarch *gdbarch,
4454  unsigned char *registers_used,
4455  CORE_ADDR pc, const char *result_name)
4456 {
4457  struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (sym);
4458  unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
4459  const gdb_byte *data;
4460  size_t size;
4461 
4462  data = dwarf2_find_location_expression (dlbaton, &size, pc);
4463  if (size == 0)
4464  error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym));
4465 
4466  compile_dwarf_expr_to_c (stream, result_name,
4467  sym, pc, gdbarch, registers_used, addr_size,
4468  data, data + size,
4469  dlbaton->per_cu);
4470 }
4471 
4472 /* The set of location functions used with the DWARF-2 expression
4473  evaluator and location lists. */
4474 const struct symbol_computed_ops dwarf2_loclist_funcs = {
4479  1, /* location_has_loclist */
4482 };
4483 
4484 /* Provide a prototype to silence -Wmissing-prototypes. */
4486 
4487 void
4489 {
4491  &entry_values_debug,
4492  _("Set entry values and tail call frames "
4493  "debugging."),
4494  _("Show entry values and tail call frames "
4495  "debugging."),
4496  _("When non-zero, the process of determining "
4497  "parameter values from function entry point "
4498  "and tail call frames will be printed."),
4499  NULL,
4502 }
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:733
void dwarf_expr_push_address(struct dwarf_expr_context *ctx, CORE_ADDR value, int in_stack_memory)
Definition: dwarf2expr.c:167
struct value * value_zero(struct type *type, enum lval_type lv)
Definition: valops.c:842
size_t data_value_size
Definition: gdbtypes.h:1150
struct dwarf2_locexpr_baton dwarf2_fetch_die_loc_cu_off(cu_offset offset_in_cu, struct dwarf2_per_cu_data *per_cu, CORE_ADDR(*get_frame_pc)(void *baton), void *baton)
Definition: dwarf2read.c:20050
static enum debug_loc_kind decode_debug_loc_addresses(const gdb_byte *loc_ptr, const gdb_byte *buf_end, const gdb_byte **new_ptr, CORE_ADDR *low, CORE_ADDR *high, enum bfd_endian byte_order, unsigned int addr_size, int signed_addr_p)
Definition: dwarf2loc.c:101
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
int dwarf2_per_cu_offset_size(struct dwarf2_per_cu_data *cu)
Definition: dwarf2read.c:21906
struct value * value_mark(void)
Definition: value.c:1499
static void needs_frame_read_mem(void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
Definition: dwarf2loc.c:2612
struct dwarf2_per_cu_data * per_cu
Definition: gdbtypes.h:1181
unsigned char from_dwo
Definition: dwarf2loc.h:197
void compile_dwarf_bounds_to_c(struct ui_file *stream, const char *result_name, const struct dynamic_prop *prop, struct symbol *sym, CORE_ADDR pc, struct gdbarch *arch, unsigned char *registers_used, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, struct dwarf2_per_cu_data *per_cu)
static struct value * locexpr_read_variable_at_entry(struct symbol *symbol, struct frame_info *frame)
Definition: dwarf2loc.c:3540
static void loclist_generate_c_location(struct symbol *sym, struct ui_file *stream, struct gdbarch *gdbarch, unsigned char *registers_used, CORE_ADDR pc, const char *result_name)
Definition: dwarf2loc.c:4452
struct type * referenced_type
Definition: dwarf2loc.h:226
int ax_goto(struct agent_expr *x, enum agent_op op)
Definition: ax-general.c:216
static void needs_frame_dwarf_call(struct dwarf_expr_context *ctx, cu_offset die_offset)
Definition: dwarf2loc.c:2654
CORE_ADDR get_frame_address_in_block(struct frame_info *this_frame)
Definition: frame.c:2248
static CORE_ADDR needs_frame_tls_address(void *baton, CORE_ADDR offset)
Definition: dwarf2loc.c:2643
struct dwarf2_per_cu_data * per_cu
Definition: dwarf2loc.h:193
bfd * obfd
Definition: objfiles.h:313
union dynamic_prop_data data
Definition: gdbtypes.h:434
static void loclist_describe_location(struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream)
Definition: dwarf2loc.c:4344
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
#define VALUE_FRAME_ID(val)
Definition: value.h:436
static CORE_ADDR dwarf_expr_get_obj_addr(void *baton)
Definition: dwarf2loc.c:1243
struct type * builtin_func_ptr
Definition: gdbtypes.h:1544
static void access_memory(struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
Definition: dwarf2loc.c:2795
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
hashval_t core_addr_hash(const void *ap)
Definition: utils.c:2783
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
void set_value_initialized(struct value *val, int status)
Definition: value.c:3771
struct call_site * call_site[1]
Definition: dwarf2loc.h:278
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:763
static int leb128_size(const gdb_byte *buf)
Definition: dwarf2read.c:16955
int dwarf2_fetch_cfa_info(struct gdbarch *gdbarch, CORE_ADDR pc, struct dwarf2_per_cu_data *data, int *regnum_out, LONGEST *offset_out, CORE_ADDR *text_offset_out, const gdb_byte **cfa_start_out, const gdb_byte **cfa_end_out)
Definition: dwarf2-frame.c:893
bfd_vma CORE_ADDR
Definition: common-types.h:41
struct dwarf2_per_cu_data * per_cu
Definition: dwarf2loc.c:302
const gdb_byte * valaddr
Definition: dwarf2loc.h:115
static int locexpr_read_needs_frame(struct symbol *symbol)
Definition: dwarf2loc.c:3550
static const char * locexpr_regname(struct gdbarch *gdbarch, int dwarf_regnum)
Definition: dwarf2loc.c:3571
static CORE_ADDR dwarf_expr_read_addr_from_reg(void *baton, int dwarf_regnum)
Definition: dwarf2loc.c:311
static struct value * locexpr_read_variable(struct symbol *symbol, struct frame_info *frame)
Definition: dwarf2loc.c:3524
static void show_entry_values_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: dwarf2loc.c:514
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
void value_contents_copy(struct value *dst, int dst_offset, struct value *src, int src_offset, int length)
Definition: value.c:1295
static void dwarf_expr_push_dwarf_reg_entry_value(struct dwarf_expr_context *ctx, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u, int deref_size)
Definition: dwarf2loc.c:1178
struct type * type
Definition: dwarf2loc.h:112
void xfree(void *)
Definition: common-utils.c:97
DEF_VEC_P(call_sitep)
CORE_ADDR base_address
Definition: dwarf2loc.h:183
static CORE_ADDR needs_frame_frame_cfa(void *baton)
Definition: dwarf2loc.c:2633
int value_offset(const struct value *value)
Definition: value.c:1032
struct value * value_from_contents(struct type *type, const gdb_byte *contents)
Definition: value.c:3553
CORE_ADDR dwarf2_read_addr_index(struct dwarf2_per_cu_data *per_cu, unsigned int addr_index)
Definition: dwarf2read.c:16861
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2122
struct dwarf_expr_piece::@52::@55 ptr
LONGEST value_as_long(struct value *val)
Definition: value.c:2654
static struct value * dwarf2_evaluate_loc_desc_full(struct type *type, struct frame_info *frame, const gdb_byte *data, size_t size, struct dwarf2_per_cu_data *per_cu, LONGEST byte_offset)
Definition: dwarf2loc.c:2176
if(!(yy_init))
Definition: ada-lex.c:1072
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
const gdb_byte * data
Definition: dwarf2loc.h:186
int fputc_filtered(int c, struct ui_file *stream)
Definition: utils.c:2178
CORE_ADDR dwarf2_frame_cfa(struct frame_info *this_frame)
struct cleanup * make_cleanup_value_free(struct value *value)
Definition: utils.c:404
CORE_ADDR addr
Definition: dwarf2loc.h:118
static CORE_ADDR needs_get_addr_index(void *baton, unsigned int index)
Definition: dwarf2loc.c:2680
void value_incref(struct value *val)
Definition: value.c:1508
int value_bitpos(const struct value *value)
Definition: value.c:1043
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition: valops.c:940
void put_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, const gdb_byte *myaddr)
Definition: frame.c:1351
static struct value * loclist_read_variable(struct symbol *symbol, struct frame_info *frame)
Definition: dwarf2loc.c:4285
struct ui_file * gdb_stdout
Definition: main.c:71
#define FIELD_DWARF_BLOCK(thisfld)
Definition: gdbtypes.h:1348
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
#define TYPE_SPECIFIC_FIELD(thistype)
Definition: gdbtypes.h:1308
cu_offset param_offset
Definition: gdbtypes.h:1131
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
void * value_computed_closure(const struct value *v)
Definition: value.c:1420
struct gdbarch * gdbarch
Definition: dwarf2expr.h:141
static int reg_offset[]
Definition: i386gnu-nat.c:42
const gdb_byte * dwarf2_fetch_constant_bytes(sect_offset, struct dwarf2_per_cu_data *, struct obstack *, LONGEST *)
Definition: dwarf2read.c:20085
static void insert_bits(unsigned int datum, gdb_byte *dest, unsigned int dest_offset_bits, int nbits, int bits_big_endian)
Definition: dwarf2loc.c:1525
static int loclist_read_needs_frame(struct symbol *symbol)
Definition: dwarf2loc.c:4328
void value_free(struct value *val)
Definition: value.c:1518
struct symbol * block_linkage_function(const struct block *bl)
Definition: block.c:100
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:360
Definition: ax.h:95
void set_value_lazy(struct value *value, int val)
Definition: value.c:1311
static void func_verify_no_selftailcall(struct gdbarch *gdbarch, CORE_ADDR verify_addr)
Definition: dwarf2loc.c:645
static void loclist_tracepoint_var_ref(struct symbol *symbol, struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value)
Definition: dwarf2loc.c:4433
void dwarf_expr_require_composition(const gdb_byte *op_ptr, const gdb_byte *op_end, const char *op_name)
Definition: dwarf2expr.c:408
void mark_value_bytes_unavailable(struct value *value, int offset, int length)
Definition: value.c:593
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
int dwarf2_per_cu_addr_size(struct dwarf2_per_cu_data *cu)
Definition: dwarf2read.c:21893
static void dwarf_expr_read_mem(void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
Definition: dwarf2loc.c:335
#define SYMBOL_BLOCK_OPS(symbol)
Definition: symtab.h:802
const gdb_byte * safe_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
Definition: dwarf2expr.c:373
#define VEC(T)
Definition: vec.h:398
void ax_reg(struct agent_expr *x, int reg)
Definition: ax-general.c:290
static void locexpr_tracepoint_var_ref(struct symbol *symbol, struct gdbarch *gdbarch, struct agent_expr *ax, struct axs_value *value)
Definition: dwarf2loc.c:4232
static void loclist_find_frame_base_location(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
Definition: dwarf2loc.c:396
#define _(String)
Definition: gdb_locale.h:40
static int call_site_parameter_matches(struct call_site_parameter *parameter, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u)
Definition: dwarf2loc.c:1011
static void per_cu_dwarf_call(struct dwarf_expr_context *ctx, cu_offset die_offset, struct dwarf2_per_cu_data *per_cu, CORE_ADDR(*get_frame_pc)(void *baton), void *baton)
Definition: dwarf2loc.c:470
#define FIELD_LOC_KIND(thisfld)
Definition: gdbtypes.h:1341
#define BLOCK_START(bl)
Definition: block.h:116
#define bits(obj, st, fn)
const gdb_byte * dwarf2_find_location_expression(struct dwarf2_loclist_baton *baton, size_t *locexpr_length, CORE_ADDR pc)
Definition: dwarf2loc.c:205
union axs_value::@27 u
#define END_CATCH
struct objfile * dwarf2_per_cu_objfile(struct dwarf2_per_cu_data *cu)
Definition: dwarf2read.c:21857
#define VALUE_LVAL(val)
Definition: value.h:411
struct value * allocate_value(struct type *type)
Definition: value.c:962
const struct block * block_for_pc(CORE_ADDR pc)
Definition: block.c:282
struct value * dwarf_expr_fetch(struct dwarf_expr_context *ctx, int n)
Definition: dwarf2expr.c:188
char optimized_out
Definition: ax-gdb.h:86
static struct piece_closure * allocate_piece_closure(struct dwarf2_per_cu_data *per_cu, int n_pieces, struct dwarf_expr_piece *pieces, int addr_size)
Definition: dwarf2loc.c:1413
static void chain_candidate(struct gdbarch *gdbarch, struct call_site_chain **resultp, VEC(call_sitep)*chain)
Definition: dwarf2loc.c:743
static enum debug_loc_kind decode_debug_loc_dwo_addresses(struct dwarf2_per_cu_data *per_cu, const gdb_byte *loc_ptr, const gdb_byte *buf_end, const gdb_byte **new_ptr, CORE_ADDR *low, CORE_ADDR *high, enum bfd_endian byte_order)
Definition: dwarf2loc.c:144
int longest_to_int(LONGEST)
Definition: valprint.c:1054
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
struct gdbarch * frame_unwind_arch(struct frame_info *next_frame)
Definition: frame.c:2541
CORE_ADDR obj_address
Definition: dwarf2loc.c:303
static void write_pieced_value(struct value *to, struct value *from)
Definition: dwarf2loc.c:1790
static CORE_ADDR dwarf_expr_frame_pc(void *baton)
Definition: dwarf2loc.c:447
#define TRY
#define MSYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:410
static int dwarf2_locexpr_baton_eval(const struct dwarf2_locexpr_baton *dlbaton, CORE_ADDR addr, CORE_ADDR *valp)
Definition: dwarf2loc.c:2405
gdb_byte * contents
Definition: value.c:323
struct value * dwarf2_evaluate_loc_desc(struct type *type, struct frame_info *frame, const gdb_byte *data, size_t size, struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2loc.c:2391
static void dwarf_expr_frame_base(void *baton, const gdb_byte **start, size_t *length)
Definition: dwarf2loc.c:344
const char *const name
Definition: aarch64-tdep.c:68
struct value * value_from_register(struct type *type, int regnum, struct frame_info *frame)
Definition: findvar.c:699
int * from
Definition: varobj.h:282
enum frame_type get_frame_type(struct frame_info *frame)
Definition: frame.c:2463
void(* find_frame_base_location)(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
Definition: symtab.h:666
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:473
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
static int check_pieced_synthetic_pointer(const struct value *value, int bit_offset, int bit_length)
Definition: dwarf2loc.c:1956
static struct symbol * func_addr_to_tail_call_list(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: dwarf2loc.c:617
#define CATCH(EXCEPTION, MASK)
static struct value * loclist_read_variable_at_entry(struct symbol *symbol, struct frame_info *frame)
Definition: dwarf2loc.c:4309
struct dwarf_expr_piece::@52::@53 mem
static void locexpr_describe_location_1(struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream, const gdb_byte *data, size_t size, struct objfile *objfile, unsigned int addr_size, int offset_size, struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2loc.c:4120
static void locexpr_describe_location(struct symbol *symbol, CORE_ADDR addr, struct ui_file *stream)
Definition: dwarf2loc.c:4214
const struct dwarf_expr_context_funcs * funcs
Definition: dwarf2expr.h:158
static void free_pieced_value_closure(struct value *v)
Definition: dwarf2loc.c:2122
int fputc_unfiltered(int c, struct ui_file *stream)
Definition: utils.c:2169
static void tailcall_dump(struct gdbarch *gdbarch, const struct call_site *call_site)
Definition: dwarf2loc.c:718
int core_addr_eq(const void *ap, const void *bp)
Definition: utils.c:2793
void initialize_file_ftype(void)
Definition: defs.h:281
struct value * allocate_computed_value(struct type *type, const struct lval_funcs *funcs, void *closure)
Definition: value.c:987
int reg
Definition: ax-gdb.h:91
void compile_dwarf_expr_to_c(struct ui_file *stream, const char *result_name, struct symbol *sym, CORE_ADDR pc, struct gdbarch *arch, unsigned char *registers_used, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, struct dwarf2_per_cu_data *per_cu)
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
unsigned int tracing
Definition: ax.h:156
int value_bitsize(const struct value *value)
Definition: value.c:1054
struct symbol * find_pc_function(CORE_ADDR pc)
Definition: blockframe.c:150
call_site_parameter_kind
Definition: gdbtypes.h:1092
const struct block * get_frame_block(struct frame_info *frame, CORE_ADDR *addr_in_block)
Definition: blockframe.c:55
void mark_value_bits_unavailable(struct value *value, int offset, int length)
Definition: value.c:587
static struct call_site_parameter * dwarf_expr_reg_to_entry_parameter(struct frame_info *frame, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u, struct dwarf2_per_cu_data **per_cu_return)
Definition: dwarf2loc.c:1035
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
static int piece_end_p(const gdb_byte *data, const gdb_byte *end)
Definition: dwarf2loc.c:3562
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
const gdb_byte * value_contents_all(struct value *value)
Definition: value.c:1188
CORE_ADDR pc
Definition: gdbtypes.h:1163
struct cleanup * make_cleanup_value_free_to_mark(struct value *mark)
Definition: utils.c:388
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
void free_current_contents(void *ptr)
Definition: utils.c:476
struct type * value_enclosing_type(struct value *value)
Definition: value.c:1098
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
#define VEC_length(T, V)
Definition: vec.h:124
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
struct dwarf2_per_cu_data * per_cu
Definition: dwarf2loc.h:176
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
void dwarf2_compile_expr_to_ax(struct agent_expr *expr, struct axs_value *loc, struct gdbarch *arch, unsigned int addr_size, const gdb_byte *op_ptr, const gdb_byte *op_end, struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2loc.c:2855
static CORE_ADDR dwarf_expr_tls_address(void *baton, CORE_ADDR offset)
Definition: dwarf2loc.c:457
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
struct frame_info * frame
Definition: dwarf2loc.c:301
void ax_ext(struct agent_expr *x, int n)
Definition: ax-general.c:180
Definition: gdbtypes.h:749
static struct value * entry_data_value_coerce_ref(const struct value *value)
Definition: dwarf2loc.c:1260
static struct value * dwarf_entry_parameter_to_value(struct call_site_parameter *parameter, CORE_ADDR deref_size, struct type *type, struct frame_info *caller_frame, struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2loc.c:1143
#define VEC_index(T, V, I)
Definition: vec.h:151
static struct type * dwarf_expr_get_base_type(struct dwarf_expr_context *ctx, cu_offset die_offset)
Definition: dwarf2loc.c:499
void ax_label(struct agent_expr *x, int patch, int target)
Definition: ax-general.c:231
CORE_ADDR(* get_frame_pc)(void *baton)
Definition: dwarf2expr.h:56
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:232
static const gdb_byte * gdb_read_uleb128(const gdb_byte *buf, const gdb_byte *buf_end, uint64_t *r)
Definition: dwarf2expr.h:303
static void invalid_synthetic_pointer(void)
Definition: dwarf2loc.c:89
static void needs_dwarf_reg_entry_value(struct dwarf_expr_context *ctx, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u, int deref_size)
Definition: dwarf2loc.c:2665
static struct value * value_of_dwarf_reg_entry(struct type *type, struct frame_info *frame, enum call_site_parameter_kind kind, union call_site_parameter_u kind_u)
Definition: dwarf2loc.c:1317
struct dwarf2_locexpr_baton locexpr
Definition: dwarf2loc.h:230
static const char * type
Definition: language.c:103
#define gdb_assert(expr)
Definition: gdb_assert.h:33
struct dwarf_expr_piece * pieces
Definition: dwarf2loc.c:1406
static struct value * value_of_dwarf_block_entry(struct type *type, struct frame_info *frame, const gdb_byte *block, size_t block_len)
Definition: dwarf2loc.c:1369
CORE_ADDR gdbarch_adjust_dwarf2_addr(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: gdbarch.c:3200
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2117
#define min(a, b)
Definition: defs.h:106
struct dwarf_expr_context * new_dwarf_expr_context(void)
Definition: dwarf2expr.c:93
void ax_simple(struct agent_expr *x, enum agent_op op)
Definition: ax-general.c:140
static void needs_frame_frame_base(void *baton, const gdb_byte **start, size_t *length)
Definition: dwarf2loc.c:2619
struct property_addr_info * next
Definition: dwarf2loc.h:122
void set_value_offset(struct value *value, int offset)
Definition: value.c:1037
struct value * value_at_lazy(struct type *type, CORE_ADDR addr)
Definition: valops.c:951
#define VEC_pop(T, V)
Definition: vec.h:270
debug_loc_kind
Definition: dwarf2loc.c:58
struct dwarf_expr_piece::@52::@54 literal
static CORE_ADDR call_site_to_target_addr(struct gdbarch *call_site_gdbarch, struct call_site *call_site, struct frame_info *caller_frame)
Definition: dwarf2loc.c:527
static unsigned int extract_bits_primitive(const gdb_byte **source, unsigned int *source_offset_bits, int *nbits, int bits_big_endian)
Definition: dwarf2loc.c:1446
CORE_ADDR dwarf2_per_cu_text_offset(struct dwarf2_per_cu_data *cu)
Definition: dwarf2read.c:21938
struct type * dwarf2_get_die_type(cu_offset die_offset, struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:20208
int regnum
Definition: aarch64-tdep.c:69
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:173
static void entry_data_value_free_closure(struct value *v)
Definition: dwarf2loc.c:1287
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
static CORE_ADDR dwarf_expr_get_addr_index(void *baton, unsigned int index)
Definition: dwarf2loc.c:1232
void * xmalloc(YYSIZE_T)
#define TYPE_TAIL_CALL_LIST(thistype)
Definition: gdbtypes.h:1325
LONGEST const_val
Definition: gdbtypes.h:419
struct ui_file * gdb_stdlog
Definition: main.c:73
gdb_regnum
Definition: arm-tdep.h:29
enum dwarf_value_location location
Definition: dwarf2expr.h:209
CORE_ADDR address_from_register(int regnum, struct frame_info *frame)
Definition: findvar.c:749
struct dwarf_expr_piece * pieces
Definition: dwarf2expr.h:202
static void dwarf_expr_dwarf_call(struct dwarf_expr_context *ctx, cu_offset die_offset)
Definition: dwarf2loc.c:488
const gdb_byte * safe_read_sleb128(const gdb_byte *buf, const gdb_byte *buf_end, int64_t *r)
Definition: dwarf2expr.c:385
Definition: regdef.h:22
#define VEC_last(T, V)
Definition: vec.h:142
Definition: block.h:60
#define VEC_empty(T, V)
Definition: vec.h:132
Definition: value.c:172
static const gdb_byte * disassemble_dwarf_expression(struct ui_file *stream, struct gdbarch *arch, unsigned int addr_size, int offset_size, const gdb_byte *start, const gdb_byte *data, const gdb_byte *end, int indent, int all, struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2loc.c:3756
struct dwarf2_offset_baton offset_info
Definition: dwarf2loc.h:236
void * hashtab_obstack_allocate(void *data, size_t size, size_t count)
Definition: utils.c:2982
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
int gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, int dwarf2_regnr)
Definition: gdbarch.c:2100
int dwarf_block_to_dwarf_reg(const gdb_byte *buf, const gdb_byte *buf_end)
Definition: dwarf2expr.c:464
void throw_exception(struct gdb_exception exception)
bfd_byte gdb_byte
Definition: common-types.h:38
struct dwarf2_loclist_baton loclist
Definition: dwarf2loc.h:233
int get_frame_func_if_available(struct frame_info *this_frame, CORE_ADDR *pc)
Definition: frame.c:876
__extension__ enum call_site_parameter_kind kind
Definition: gdbtypes.h:1136
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
static void locexpr_generate_c_location(struct symbol *sym, struct ui_file *stream, struct gdbarch *gdbarch, unsigned char *registers_used, CORE_ADDR pc, const char *result_name)
Definition: dwarf2loc.c:4249
int dwarf2_reg_to_regnum_or_error(struct gdbarch *arch, int dwarf_reg)
Definition: dwarf2loc.c:2780
int value_optimized_out(struct value *value)
Definition: value.c:1346
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
struct call_site * call_sitep
Definition: dwarf2loc.c:730
static const gdb_byte * locexpr_describe_location_piece(struct symbol *symbol, struct ui_file *stream, CORE_ADDR addr, struct objfile *objfile, struct dwarf2_per_cu_data *per_cu, const gdb_byte *data, const gdb_byte *end, unsigned int addr_size)
Definition: dwarf2loc.c:3586
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:801
const gdb_byte * data
Definition: dwarf2expr.h:172
void func_get_frame_base_dwarf_block(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
Definition: dwarf2loc.c:415
CORE_ADDR target_translate_tls_address(struct objfile *objfile, CORE_ADDR offset)
Definition: target.c:809
void mark_value_bytes_optimized_out(struct value *value, int offset, int length)
Definition: value.c:1360
struct dwarf2_locexpr_baton dwarf2_fetch_die_loc_sect_off(sect_offset offset_in_cu, struct dwarf2_per_cu_data *per_cu, CORE_ADDR(*get_frame_pc)(void *baton), void *baton)
Definition: dwarf2read.c:19987
void dwarf2_compile_property_to_c(struct ui_file *stream, const char *result_name, struct gdbarch *gdbarch, unsigned char *registers_used, const struct dynamic_prop *prop, CORE_ADDR pc, struct symbol *sym)
Definition: dwarf2loc.c:2546
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:185
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
void read_value_memory(struct value *val, int embedded_offset, int stack, CORE_ADDR memaddr, gdb_byte *buffer, size_t length)
Definition: valops.c:957
int len
Definition: ax.h:101
const gdb_byte * value
Definition: gdbtypes.h:1143
void mark_value_bits_optimized_out(struct value *value, int offset, int length)
Definition: value.c:1370
unsigned int cu_off
Definition: gdbtypes.h:62
const gdb_byte * data_value
Definition: gdbtypes.h:1149
struct minimal_symbol * minsym
Definition: minsyms.h:32
static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs
Definition: dwarf2loc.c:2697
struct call_site_parameter parameter[1]
Definition: gdbtypes.h:1185
static CORE_ADDR get_ax_pc(void *baton)
Definition: dwarf2loc.c:2834
int offset
Definition: agent.c:65
const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs
Definition: dwarf2loc.c:2154
CORE_ADDR offset
Definition: dwarf2expr.h:151
Definition: buffer.h:23
static struct value * dwarf_expr_get_reg_value(void *baton, struct type *type, int dwarf_regnum)
Definition: dwarf2loc.c:323
#define VEC_address(T, V)
Definition: vec.h:369
unsigned parameter_count
Definition: gdbtypes.h:1176
void require_rvalue(struct agent_expr *ax, struct axs_value *value)
Definition: ax-gdb.c:764
struct cleanup * make_cleanup_htab_delete(htab_t htab)
Definition: utils.c:343
static CORE_ADDR dwarf_expr_frame_cfa(void *baton)
Definition: dwarf2loc.c:436
static CORE_ADDR needs_get_obj_addr(void *baton)
Definition: dwarf2loc.c:2689
void ax_trace_quick(struct agent_expr *x, int n)
Definition: ax-general.c:196
void ax_const_l(struct agent_expr *x, LONGEST l)
Definition: ax-general.c:245
int dwarf_expr_fetch_in_stack_memory(struct dwarf_expr_context *ctx, int n)
Definition: dwarf2expr.c:288
struct gdbarch * arch
Definition: symtab.h:725
void set_value_stack(struct value *value, int val)
Definition: value.c:1323
void ax_pick(struct agent_expr *x, int depth)
Definition: ax-general.c:150
int get_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, gdb_byte *myaddr, int *optimizedp, int *unavailablep)
Definition: frame.c:1274
enum dynamic_prop_kind kind
Definition: gdbtypes.h:431
#define SYMBOL_NATURAL_NAME(symbol)
Definition: symtab.h:231
enum dwarf_value_location location
Definition: dwarf2expr.h:166
int dwarf2_evaluate_property(const struct dynamic_prop *prop, struct property_addr_info *addr_stack, CORE_ADDR *value)
Definition: dwarf2loc.c:2463
int gdbarch_bits_big_endian(struct gdbarch *gdbarch)
Definition: gdbarch.c:1456
unsigned long long ULONGEST
Definition: common-types.h:53
int dwarf_always_disassemble
Definition: dwarf2read.c:23371
void release_value(struct value *val)
Definition: value.c:1603
struct call_site * call_site_for_pc(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: block.c:224
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
const gdb_byte * data
Definition: dwarf2loc.h:168
#define VEC_cleanup(T)
Definition: vec.h:187
struct type * value_type(const struct value *value)
Definition: value.c:1021
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
struct call_site * tail_call_next
Definition: gdbtypes.h:1167
Definition: symtab.h:703
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1411
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:175
static CORE_ADDR get_frame_address_in_block_wrapper(void *baton)
Definition: dwarf2loc.c:1996
static void locexpr_find_frame_base_location(struct symbol *framefunc, CORE_ADDR pc, const gdb_byte **start, size_t *length)
Definition: dwarf2loc.c:375
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2679
union dwarf_expr_piece::@52 v
CORE_ADDR dwarf_expr_fetch_address(struct dwarf_expr_context *ctx, int n)
Definition: dwarf2expr.c:255
static struct call_site_chain * call_site_find_chain_1(struct gdbarch *gdbarch, CORE_ADDR caller_pc, CORE_ADDR callee_pc)
Definition: dwarf2loc.c:840
void ax_zero_ext(struct agent_expr *x, int n)
Definition: ax-general.c:188
gdb_byte * value_contents_raw(struct value *value)
Definition: value.c:1084
static void unimplemented(unsigned int op)
Definition: dwarf2loc.c:2764
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
static void read_pieced_value(struct value *v)
Definition: dwarf2loc.c:1607
int int * to
Definition: varobj.h:282
static void * copy_pieced_value_closure(const struct value *v)
Definition: dwarf2loc.c:2112
CORE_ADDR address
Definition: value.c:216
#define FIELD_STATIC_PHYSADDR(thisfld)
Definition: gdbtypes.h:1347
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
Definition: blockframe.c:86
void dwarf_expr_eval(struct dwarf_expr_context *ctx, const gdb_byte *addr, size_t len)
Definition: dwarf2expr.c:358
static int dwarf2_loc_desc_needs_frame(const gdb_byte *data, size_t size, struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2loc.c:2717
struct value * allocate_optimized_out_value(struct type *type)
Definition: value.c:1003
static struct value * needs_frame_get_reg_value(void *baton, struct type *type, int regnum)
Definition: dwarf2loc.c:2602
static CORE_ADDR needs_frame_read_addr_from_reg(void *baton, int regnum)
Definition: dwarf2loc.c:2590
LONGEST extract_signed_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:49
struct cleanup * make_cleanup_obstack_free(struct obstack *obstack)
Definition: utils.c:225
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:389
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1440
Definition: defs.h:353
struct type * type
Definition: dwarf2loc.h:214
int dwarf2_per_cu_ref_addr_size(struct dwarf2_per_cu_data *cu)
Definition: dwarf2read.c:21919
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
enum axs_lvalue_kind kind
Definition: ax-gdb.h:77
enum bfd_endian byte_order
Definition: gdbarch.c:128
struct call_site_target target
Definition: gdbtypes.h:1172
static void copy_bitwise(gdb_byte *dest, unsigned int dest_offset_bits, const gdb_byte *source, unsigned int source_offset_bits, unsigned int bit_count, int bits_big_endian)
Definition: dwarf2loc.c:1560
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:920
#define FIELD_STATIC_PHYSNAME(thisfld)
Definition: gdbtypes.h:1346
struct dwarf2_per_cu_data * per_cu
Definition: dwarf2loc.c:1397
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
struct call_site_chain * call_site_find_chain(struct gdbarch *gdbarch, CORE_ADDR caller_pc, CORE_ADDR callee_pc)
Definition: dwarf2loc.c:982
int dwarf_block_to_fb_offset(const gdb_byte *buf, const gdb_byte *buf_end, CORE_ADDR *fb_offset_return)
Definition: dwarf2expr.c:566
union call_site_parameter_u u
Definition: gdbtypes.h:1138
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
struct value * value
Definition: dwarf2expr.h:226
void throw_error(enum errors error, const char *fmt,...)
long long LONGEST
Definition: common-types.h:52
static struct value * indirect_pieced_value(struct value *value)
Definition: dwarf2loc.c:2005
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
struct dwarf2_per_cu_data * per_cu
Definition: dwarf2loc.c:2585
#define SYMBOL_LOCATION_BATON(symbol)
Definition: symtab.h:804
CORE_ADDR scope
Definition: ax.h:110
struct cleanup * make_cleanup_free_dwarf_expr_context(struct dwarf_expr_context *ctx)
Definition: dwarf2expr.c:129
static void * entry_data_value_copy_closure(const struct value *v)
Definition: dwarf2loc.c:1276
const ULONGEST const LONGEST len
Definition: target.h:309
static unsigned int extract_bits(const gdb_byte **source, unsigned int *source_offset_bits, int nbits, int bits_big_endian)
Definition: dwarf2loc.c:1489
initialize_file_ftype _initialize_dwarf2loc