GDB (xrefs)

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