GDB (xrefs)

/tmp/gdb-8.1/gdb/findvar.c
Go to the documentation of this file.
1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "symtab.h"
22 #include "gdbtypes.h"
23 #include "frame.h"
24 #include "value.h"
25 #include "gdbcore.h"
26 #include "inferior.h"
27 #include "target.h"
28 #include "symfile.h" /* for overlay functions */
29 #include "regcache.h"
30 #include "user-regs.h"
31 #include "block.h"
32 #include "objfiles.h"
33 #include "language.h"
34 #include "dwarf2loc.h"
35 #include "selftest.h"
36
37 /* Basic byte-swapping routines. All 'extract' functions return a
38 host-format integer from a target-format integer at ADDR which is
39 LEN bytes long. */
40
41 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
42 /* 8 bit characters are a pretty safe assumption these days, so we
43 assume it throughout all these swapping routines. If we had to deal with
44 9 bit characters, we would need to make len be in bits and would have
45 to re-write these routines... */
46 you lose
47 #endif
48
49 template<typename T, typename>
50 T
51 extract_integer (const gdb_byte *addr, int len, enum bfd_endian byte_order)
52 {
53 T retval = 0;
54 const unsigned char *p;
55 const unsigned char *startaddr = addr;
56 const unsigned char *endaddr = startaddr + len;
57
58 if (len > (int) sizeof (T))
59 error (_("\
60 That operation is not available on integers of more than %d bytes."),
61 (int) sizeof (T));
62
63 /* Start at the most significant end of the integer, and work towards
64 the least significant. */
65 if (byte_order == BFD_ENDIAN_BIG)
66 {
67 p = startaddr;
68 if (std::is_signed<T>::value)
69 {
70 /* Do the sign extension once at the start. */
71 retval = ((LONGEST) * p ^ 0x80) - 0x80;
72 ++p;
73 }
74 for (; p < endaddr; ++p)
75 retval = (retval << 8) | *p;
76 }
77 else
78 {
79 p = endaddr - 1;
80 if (std::is_signed<T>::value)
81 {
82 /* Do the sign extension once at the start. */
83 retval = ((LONGEST) * p ^ 0x80) - 0x80;
84 --p;
85 }
86 for (; p >= startaddr; --p)
87 retval = (retval << 8) | *p;
88 }
89 return retval;
90 }
91
92 /* Explicit instantiations. */
93 template LONGEST extract_integer<LONGEST> (const gdb_byte *addr, int len,
94 enum bfd_endian byte_order);
95 template ULONGEST extract_integer<ULONGEST> (const gdb_byte *addr, int len,
96 enum bfd_endian byte_order);
97
98 /* Sometimes a long long unsigned integer can be extracted as a
99 LONGEST value. This is done so that we can print these values
100 better. If this integer can be converted to a LONGEST, this
101 function returns 1 and sets *PVAL. Otherwise it returns 0. */
102
103 int
104 extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
105 enum bfd_endian byte_order, LONGEST *pval)
106 {
107 const gdb_byte *p;
108 const gdb_byte *first_addr;
109 int len;
110
111 len = orig_len;
112 if (byte_order == BFD_ENDIAN_BIG)
113 {
114 for (p = addr;
115 len > (int) sizeof (LONGEST) && p < addr + orig_len;
116 p++)
117 {
118 if (*p == 0)
119 len--;
120 else
121 break;
122 }
123 first_addr = p;
124 }
125 else
126 {
127 first_addr = addr;
128 for (p = addr + orig_len - 1;
129 len > (int) sizeof (LONGEST) && p >= addr;
130 p--)
131 {
132 if (*p == 0)
133 len--;
134 else
135 break;
136 }
137 }
138
139 if (len <= (int) sizeof (LONGEST))
140 {
141 *pval = (LONGEST) extract_unsigned_integer (first_addr,
142 sizeof (LONGEST),
143 byte_order);
144 return 1;
145 }
146
147 return 0;
148 }
149
150
151 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
152 address it represents. */
153 CORE_ADDR
154 extract_typed_address (const gdb_byte *buf, struct type *type)
155 {
156 if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
157 internal_error (__FILE__, __LINE__,
158 _("extract_typed_address: "
159 "type is not a pointer or reference"));
160
161 return gdbarch_pointer_to_address (get_type_arch (type), type, buf);
162 }
163
164 /* All 'store' functions accept a host-format integer and store a
165 target-format integer at ADDR which is LEN bytes long. */
166 template<typename T, typename>
167 void
168 store_integer (gdb_byte *addr, int len, enum bfd_endian byte_order,
169 T val)
170 {
171 gdb_byte *p;
172 gdb_byte *startaddr = addr;
173 gdb_byte *endaddr = startaddr + len;
174
175 /* Start at the least significant end of the integer, and work towards
176 the most significant. */
177 if (byte_order == BFD_ENDIAN_BIG)
178 {
179 for (p = endaddr - 1; p >= startaddr; --p)
180 {
181 *p = val & 0xff;
182 val >>= 8;
183 }
184 }
185 else
186 {
187 for (p = startaddr; p < endaddr; ++p)
188 {
189 *p = val & 0xff;
190 val >>= 8;
191 }
192 }
193 }
194
195 /* Explicit instantiations. */
196 template void store_integer (gdb_byte *addr, int len,
197 enum bfd_endian byte_order,
198 LONGEST val);
199
200 template void store_integer (gdb_byte *addr, int len,
201 enum bfd_endian byte_order,
202 ULONGEST val);
203
204 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
205 form. */
206 void
207 store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
208 {
209 if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
210 internal_error (__FILE__, __LINE__,
211 _("store_typed_address: "
212 "type is not a pointer or reference"));
213
214 gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr);
215 }
216
217 /* Copy a value from SOURCE of size SOURCE_SIZE bytes to DEST of size DEST_SIZE
218 bytes. If SOURCE_SIZE is greater than DEST_SIZE, then truncate the most
219 significant bytes. If SOURCE_SIZE is less than DEST_SIZE then either sign
220 or zero extended according to IS_SIGNED. Values are stored in memory with
221 endianess BYTE_ORDER. */
222
223 void
224 copy_integer_to_size (gdb_byte *dest, int dest_size, const gdb_byte *source,
225 int source_size, bool is_signed,
226 enum bfd_endian byte_order)
227 {
228 signed int size_diff = dest_size - source_size;
229
230 /* Copy across everything from SOURCE that can fit into DEST. */
231
232 if (byte_order == BFD_ENDIAN_BIG && size_diff > 0)
233 memcpy (dest + size_diff, source, source_size);
234 else if (byte_order == BFD_ENDIAN_BIG && size_diff < 0)
235 memcpy (dest, source - size_diff, dest_size);
236 else
237 memcpy (dest, source, std::min (source_size, dest_size));
238
239 /* Fill the remaining space in DEST by either zero extending or sign
240 extending. */
241
242 if (size_diff > 0)
243 {
244 gdb_byte extension = 0;
245 if (is_signed
246 && ((byte_order != BFD_ENDIAN_BIG && source[source_size - 1] & 0x80)
247 || (byte_order == BFD_ENDIAN_BIG && source[0] & 0x80)))
248 extension = 0xff;
249
250 /* Extend into MSBs of SOURCE. */
251 if (byte_order == BFD_ENDIAN_BIG)
252 memset (dest, extension, size_diff);
253 else
254 memset (dest + source_size, extension, size_diff);
255 }
256 }
257
258 /* Return a `value' with the contents of (virtual or cooked) register
259 REGNUM as found in the specified FRAME. The register's type is
260 determined by register_type(). */
261
262 struct value *
263 value_of_register (int regnum, struct frame_info *frame)
264 {
265 struct gdbarch *gdbarch = get_frame_arch (frame);
266 struct value *reg_val;
267
268 /* User registers lie completely outside of the range of normal
269 registers. Catch them early so that the target never sees them. */
270 if (regnum >= gdbarch_num_regs (gdbarch)
271 + gdbarch_num_pseudo_regs (gdbarch))
272 return value_of_user_reg (regnum, frame);
273
274 reg_val = value_of_register_lazy (frame, regnum);
275 value_fetch_lazy (reg_val);
276 return reg_val;
277 }
278
279 /* Return a `value' with the contents of (virtual or cooked) register
280 REGNUM as found in the specified FRAME. The register's type is
281 determined by register_type(). The value is not fetched. */
282
283 struct value *
284 value_of_register_lazy (struct frame_info *frame, int regnum)
285 {
286 struct gdbarch *gdbarch = get_frame_arch (frame);
287 struct value *reg_val;
288 struct frame_info *next_frame;
289
290 gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
291 + gdbarch_num_pseudo_regs (gdbarch)));
292
293 gdb_assert (frame != NULL);
294
295 next_frame = get_next_frame_sentinel_okay (frame);
296
297 /* We should have a valid next frame. */
298 gdb_assert (frame_id_p (get_frame_id (next_frame)));
299
300 reg_val = allocate_value_lazy (register_type (gdbarch, regnum));
301 VALUE_LVAL (reg_val) = lval_register;
302 VALUE_REGNUM (reg_val) = regnum;
303 VALUE_NEXT_FRAME_ID (reg_val) = get_frame_id (next_frame);
304
305 return reg_val;
306 }
307
308 /* Given a pointer of type TYPE in target form in BUF, return the
309 address it represents. */
310 CORE_ADDR
311 unsigned_pointer_to_address (struct gdbarch *gdbarch,
312 struct type *type, const gdb_byte *buf)
313 {
314 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
315
316 return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
317 }
318
319 CORE_ADDR
320 signed_pointer_to_address (struct gdbarch *gdbarch,
321 struct type *type, const gdb_byte *buf)
322 {
323 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
324
325 return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
326 }
327
328 /* Given an address, store it as a pointer of type TYPE in target
329 format in BUF. */
330 void
331 unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
332 gdb_byte *buf, CORE_ADDR addr)
333 {
334 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
335
336 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
337 }
338
339 void
340 address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
341 gdb_byte *buf, CORE_ADDR addr)
342 {
343 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
344
345 store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
346 }
347
348 /* See value.h. */
349
350 enum symbol_needs_kind
351 symbol_read_needs (struct symbol *sym)
352 {
353 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
354 return SYMBOL_COMPUTED_OPS (sym)->get_symbol_read_needs (sym);
355
356 switch (SYMBOL_CLASS (sym))
357 {
358 /* All cases listed explicitly so that gcc -Wall will detect it if
359 we failed to consider one. */
360 case LOC_COMPUTED:
361 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
362
363 case LOC_REGISTER:
364 case LOC_ARG:
365 case LOC_REF_ARG:
366 case LOC_REGPARM_ADDR:
367 case LOC_LOCAL:
368 return SYMBOL_NEEDS_FRAME;
369
370 case LOC_UNDEF:
371 case LOC_CONST:
372 case LOC_STATIC:
373 case LOC_TYPEDEF:
374
375 case LOC_LABEL:
376 /* Getting the address of a label can be done independently of the block,
377 even if some *uses* of that address wouldn't work so well without
378 the right frame. */
379
380 case LOC_BLOCK:
381 case LOC_CONST_BYTES:
382 case LOC_UNRESOLVED:
383 case LOC_OPTIMIZED_OUT:
384 return SYMBOL_NEEDS_NONE;
385 }
386 return SYMBOL_NEEDS_FRAME;
387 }
388
389 /* See value.h. */
390
391 int
392 symbol_read_needs_frame (struct symbol *sym)
393 {
394 return symbol_read_needs (sym) == SYMBOL_NEEDS_FRAME;
395 }
396
397 /* Private data to be used with minsym_lookup_iterator_cb. */
398
399 struct minsym_lookup_data
400 {
401 /* The name of the minimal symbol we are searching for. */
402 const char *name;
403
404 /* The field where the callback should store the minimal symbol
405 if found. It should be initialized to NULL before the search
406 is started. */
407 struct bound_minimal_symbol result;
408 };
409
410 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
411 It searches by name for a minimal symbol within the given OBJFILE.
412 The arguments are passed via CB_DATA, which in reality is a pointer
413 to struct minsym_lookup_data. */
414
415 static int
416 minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data)
417 {
418 struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data;
419
420 gdb_assert (data->result.minsym == NULL);
421
422 data->result = lookup_minimal_symbol (data->name, NULL, objfile);
423
424 /* The iterator should stop iff a match was found. */
425 return (data->result.minsym != NULL);
426 }
427
428 /* Given static link expression and the frame it lives in, look for the frame
429 the static links points to and return it. Return NULL if we could not find
430 such a frame. */
431
432 static struct frame_info *
433 follow_static_link (struct frame_info *frame,
434 const struct dynamic_prop *static_link)
435 {
436 CORE_ADDR upper_frame_base;
437
438 if (!dwarf2_evaluate_property (static_link, frame, NULL, &upper_frame_base))
439 return NULL;
440
441 /* Now climb up the stack frame until we reach the frame we are interested
442 in. */
443 for (; frame != NULL; frame = get_prev_frame (frame))
444 {
445 struct symbol *framefunc = get_frame_function (frame);
446
447 /* Stacks can be quite deep: give the user a chance to stop this. */
448 QUIT;
449
450 /* If we don't know how to compute FRAME's base address, don't give up:
451 maybe the frame we are looking for is upper in the stace frame. */
452 if (framefunc != NULL
453 && SYMBOL_BLOCK_OPS (framefunc) != NULL
454 && SYMBOL_BLOCK_OPS (framefunc)->get_frame_base != NULL
455 && (SYMBOL_BLOCK_OPS (framefunc)->get_frame_base (framefunc, frame)
456 == upper_frame_base))
457 break;
458 }
459
460 return frame;
461 }
462
463 /* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
464 rules, look for the frame that is actually hosting VAR and return it. If,
465 for some reason, we found no such frame, return NULL.
466
467 This kind of computation is necessary to correctly handle lexically nested
468 functions.
469
470 Note that in some cases, we know what scope VAR comes from but we cannot
471 reach the specific frame that hosts the instance of VAR we are looking for.
472 For backward compatibility purposes (with old compilers), we then look for
473 the first frame that can host it. */
474
475 static struct frame_info *
476 get_hosting_frame (struct symbol *var, const struct block *var_block,
477 struct frame_info *frame)
478 {
479 const struct block *frame_block = NULL;
480
481 if (!symbol_read_needs_frame (var))
482 return NULL;
483
484 /* Some symbols for local variables have no block: this happens when they are
485 not produced by a debug information reader, for instance when GDB creates
486 synthetic symbols. Without block information, we must assume they are
487 local to FRAME. In this case, there is nothing to do. */
488 else if (var_block == NULL)
489 return frame;
490
491 /* We currently assume that all symbols with a location list need a frame.
492 This is true in practice because selecting the location description
493 requires to compute the CFA, hence requires a frame. However we have
494 tests that embed global/static symbols with null location lists.
495 We want to get <optimized out> instead of <frame required> when evaluating
496 them so return a frame instead of raising an error. */
497 else if (var_block == block_global_block (var_block)
498 || var_block == block_static_block (var_block))
499 return frame;
500
501 /* We have to handle the "my_func::my_local_var" notation. This requires us
502 to look for upper frames when we find no block for the current frame: here
503 and below, handle when frame_block == NULL. */
504 if (frame != NULL)
505 frame_block = get_frame_block (frame, NULL);
506
507 /* Climb up the call stack until reaching the frame we are looking for. */
508 while (frame != NULL && frame_block != var_block)
509 {
510 /* Stacks can be quite deep: give the user a chance to stop this. */
511 QUIT;
512
513 if (frame_block == NULL)
514 {
515 frame = get_prev_frame (frame);
516 if (frame == NULL)
517 break;
518 frame_block = get_frame_block (frame, NULL);
519 }
520
521 /* If we failed to find the proper frame, fallback to the heuristic
522 method below. */
523 else if (frame_block == block_global_block (frame_block))
524 {
525 frame = NULL;
526 break;
527 }
528
529 /* Assuming we have a block for this frame: if we are at the function
530 level, the immediate upper lexical block is in an outer function:
531 follow the static link. */
532 else if (BLOCK_FUNCTION (frame_block))
533 {
534 const struct dynamic_prop *static_link
535 = block_static_link (frame_block);
536 int could_climb_up = 0;
537
538 if (static_link != NULL)
539 {
540 frame = follow_static_link (frame, static_link);
541 if (frame != NULL)
542 {
543 frame_block = get_frame_block (frame, NULL);
544 could_climb_up = frame_block != NULL;
545 }
546 }
547 if (!could_climb_up)
548 {
549 frame = NULL;
550 break;
551 }
552 }
553
554 else
555 /* We must be in some function nested lexical block. Just get the
556 outer block: both must share the same frame. */
557 frame_block = BLOCK_SUPERBLOCK (frame_block);
558 }
559
560 /* Old compilers may not provide a static link, or they may provide an
561 invalid one. For such cases, fallback on the old way to evaluate
562 non-local references: just climb up the call stack and pick the first
563 frame that contains the variable we are looking for. */
564 if (frame == NULL)
565 {
566 frame = block_innermost_frame (var_block);
567 if (frame == NULL)
568 {
569 if (BLOCK_FUNCTION (var_block)
570 && !block_inlined_p (var_block)
571 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)))
572 error (_("No frame is currently executing in block %s."),
573 SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)));
574 else
575 error (_("No frame is currently executing in specified"
576 " block"));
577 }
578 }
579
580 return frame;
581 }
582
583 /* A default implementation for the "la_read_var_value" hook in
584 the language vector which should work in most situations. */
585
586 struct value *
587 default_read_var_value (struct symbol *var, const struct block *var_block,
588 struct frame_info *frame)
589 {
590 struct value *v;
591 struct type *type = SYMBOL_TYPE (var);
592 CORE_ADDR addr;
593 enum symbol_needs_kind sym_need;
594
595 /* Call check_typedef on our type to make sure that, if TYPE is
596 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
597 instead of zero. However, we do not replace the typedef type by the
598 target type, because we want to keep the typedef in order to be able to
599 set the returned value type description correctly. */
600 check_typedef (type);
601
602 sym_need = symbol_read_needs (var);
603 if (sym_need == SYMBOL_NEEDS_FRAME)
604 gdb_assert (frame != NULL);
605 else if (sym_need == SYMBOL_NEEDS_REGISTERS && !target_has_registers)
606 error (_("Cannot read `%s' without registers"), SYMBOL_PRINT_NAME (var));
607
608 if (frame != NULL)
609 frame = get_hosting_frame (var, var_block, frame);
610
611 if (SYMBOL_COMPUTED_OPS (var) != NULL)
612 return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
613
614 switch (SYMBOL_CLASS (var))
615 {
616 case LOC_CONST:
617 if (is_dynamic_type (type))
618 {
619 /* Value is a constant byte-sequence and needs no memory access. */
620 type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0);
621 }
622 /* Put the constant back in target format. */
623 v = allocate_value (type);
624 store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
625 gdbarch_byte_order (get_type_arch (type)),
626 (LONGEST) SYMBOL_VALUE (var));
627 VALUE_LVAL (v) = not_lval;
628 return v;
629
630 case LOC_LABEL:
631 /* Put the constant back in target format. */
632 v = allocate_value (type);
633 if (overlay_debugging)
634 {
635 CORE_ADDR addr
636 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
637 SYMBOL_OBJ_SECTION (symbol_objfile (var),
638 var));
639
640 store_typed_address (value_contents_raw (v), type, addr);
641 }
642 else
643 store_typed_address (value_contents_raw (v), type,
644 SYMBOL_VALUE_ADDRESS (var));
645 VALUE_LVAL (v) = not_lval;
646 return v;
647
648 case LOC_CONST_BYTES:
649 if (is_dynamic_type (type))
650 {
651 /* Value is a constant byte-sequence and needs no memory access. */
652 type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0);
653 }
654 v = allocate_value (type);
655 memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
656 TYPE_LENGTH (type));
657 VALUE_LVAL (v) = not_lval;
658 return v;
659
660 case LOC_STATIC:
661 if (overlay_debugging)
662 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
663 SYMBOL_OBJ_SECTION (symbol_objfile (var),
664 var));
665 else
666 addr = SYMBOL_VALUE_ADDRESS (var);
667 break;
668
669 case LOC_ARG:
670 addr = get_frame_args_address (frame);
671 if (!addr)
672 error (_("Unknown argument list address for `%s'."),
673 SYMBOL_PRINT_NAME (var));
674 addr += SYMBOL_VALUE (var);
675 break;
676
677 case LOC_REF_ARG:
678 {
679 struct value *ref;
680 CORE_ADDR argref;
681
682 argref = get_frame_args_address (frame);
683 if (!argref)
684 error (_("Unknown argument list address for `%s'."),
685 SYMBOL_PRINT_NAME (var));
686 argref += SYMBOL_VALUE (var);
687 ref = value_at (lookup_pointer_type (type), argref);
688 addr = value_as_address (ref);
689 break;
690 }
691
692 case LOC_LOCAL:
693 addr = get_frame_locals_address (frame);
694 addr += SYMBOL_VALUE (var);
695 break;
696
697 case LOC_TYPEDEF:
698 error (_("Cannot look up value of a typedef `%s'."),
699 SYMBOL_PRINT_NAME (var));
700 break;
701
702 case LOC_BLOCK:
703 if (overlay_debugging)
704 addr = symbol_overlayed_address
705 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)),
706 SYMBOL_OBJ_SECTION (symbol_objfile (var), var));
707 else
708 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
709 break;
710
711 case LOC_REGISTER:
712 case LOC_REGPARM_ADDR:
713 {
714 int regno = SYMBOL_REGISTER_OPS (var)
715 ->register_number (var, get_frame_arch (frame));
716 struct value *regval;
717
718 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
719 {
720 regval = value_from_register (lookup_pointer_type (type),
721 regno,
722 frame);
723
724 if (regval == NULL)
725 error (_("Value of register variable not available for `%s'."),
726 SYMBOL_PRINT_NAME (var));
727
728 addr = value_as_address (regval);
729 }
730 else
731 {
732 regval = value_from_register (type, regno, frame);
733
734 if (regval == NULL)
735 error (_("Value of register variable not available for `%s'."),
736 SYMBOL_PRINT_NAME (var));
737 return regval;
738 }
739 }
740 break;
741
742 case LOC_COMPUTED:
743 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
744
745 case LOC_UNRESOLVED:
746 {
747 struct minsym_lookup_data lookup_data;
748 struct minimal_symbol *msym;
749 struct obj_section *obj_section;
750
751 memset (&lookup_data, 0, sizeof (lookup_data));
752 lookup_data.name = SYMBOL_LINKAGE_NAME (var);
753
754 gdbarch_iterate_over_objfiles_in_search_order
755 (symbol_arch (var),
756 minsym_lookup_iterator_cb, &lookup_data,
757 symbol_objfile (var));
758 msym = lookup_data.result.minsym;
759
760 /* If we can't find the minsym there's a problem in the symbol info.
761 The symbol exists in the debug info, but it's missing in the minsym
762 table. */
763 if (msym == NULL)
764 {
765 const char *flavour_name
766 = objfile_flavour_name (symbol_objfile (var));
767
768 /* We can't get here unless we've opened the file, so flavour_name
769 can't be NULL. */
770 gdb_assert (flavour_name != NULL);
771 error (_("Missing %s symbol \"%s\"."),
772 flavour_name, SYMBOL_LINKAGE_NAME (var));
773 }
774 obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym);
775 /* Relocate address, unless there is no section or the variable is
776 a TLS variable. */
777 if (obj_section == NULL
778 || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
779 addr = MSYMBOL_VALUE_RAW_ADDRESS (msym);
780 else
781 addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result);
782 if (overlay_debugging)
783 addr = symbol_overlayed_address (addr, obj_section);
784 /* Determine address of TLS variable. */
785 if (obj_section
786 && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
787 addr = target_translate_tls_address (obj_section->objfile, addr);
788 }
789 break;
790
791 case LOC_OPTIMIZED_OUT:
792 return allocate_optimized_out_value (type);
793
794 default:
795 error (_("Cannot look up value of a botched symbol `%s'."),
796 SYMBOL_PRINT_NAME (var));
797 break;
798 }
799
800 v = value_at_lazy (type, addr);
801 return v;
802 }
803
804 /* Calls VAR's language la_read_var_value hook with the given arguments. */
805
806 struct value *
807 read_var_value (struct symbol *var, const struct block *var_block,
808 struct frame_info *frame)
809 {
810 const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
811
812 gdb_assert (lang != NULL);
813 gdb_assert (lang->la_read_var_value != NULL);
814
815 return lang->la_read_var_value (var, var_block, frame);
816 }
817
818 /* Install default attributes for register values. */
819
820 struct value *
821 default_value_from_register (struct gdbarch *gdbarch, struct type *type,
822 int regnum, struct frame_id frame_id)
823 {
824 int len = TYPE_LENGTH (type);
825 struct value *value = allocate_value (type);
826 struct frame_info *frame;
827
828 VALUE_LVAL (value) = lval_register;
829 frame = frame_find_by_id (frame_id);
830
831 if (frame == NULL)
832 frame_id = null_frame_id;
833 else
834 frame_id = get_frame_id (get_next_frame_sentinel_okay (frame));
835
836 VALUE_NEXT_FRAME_ID (value) = frame_id;
837 VALUE_REGNUM (value) = regnum;
838
839 /* Any structure stored in more than one register will always be
840 an integral number of registers. Otherwise, you need to do
841 some fiddling with the last register copied here for little
842 endian machines. */
843 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
844 && len < register_size (gdbarch, regnum))
845 /* Big-endian, and we want less than full size. */
846 set_value_offset (value, register_size (gdbarch, regnum) - len);
847 else
848 set_value_offset (value, 0);
849
850 return value;
851 }
852
853 /* VALUE must be an lval_register value. If regnum is the value's
854 associated register number, and len the length of the values type,
855 read one or more registers in FRAME, starting with register REGNUM,
856 until we've read LEN bytes.
857
858 If any of the registers we try to read are optimized out, then mark the
859 complete resulting value as optimized out. */
860
861 void
862 read_frame_register_value (struct value *value, struct frame_info *frame)
863 {
864 struct gdbarch *gdbarch = get_frame_arch (frame);
865 LONGEST offset = 0;
866 LONGEST reg_offset = value_offset (value);
867 int regnum = VALUE_REGNUM (value);
868 int len = type_length_units (check_typedef (value_type (value)));
869
870 gdb_assert (VALUE_LVAL (value) == lval_register);
871
872 /* Skip registers wholly inside of REG_OFFSET. */
873 while (reg_offset >= register_size (gdbarch, regnum))
874 {
875 reg_offset -= register_size (gdbarch, regnum);
876 regnum++;
877 }
878
879 /* Copy the data. */
880 while (len > 0)
881 {
882 struct value *regval = get_frame_register_value (frame, regnum);
883 int reg_len = type_length_units (value_type (regval)) - reg_offset;
884
885 /* If the register length is larger than the number of bytes
886 remaining to copy, then only copy the appropriate bytes. */
887 if (reg_len > len)
888 reg_len = len;
889
890 value_contents_copy (value, offset, regval, reg_offset, reg_len);
891
892 offset += reg_len;
893 len -= reg_len;
894 reg_offset = 0;
895 regnum++;
896 }
897 }
898
899 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
900
901 struct value *
902 value_from_register (struct type *type, int regnum, struct frame_info *frame)
903 {
904 struct gdbarch *gdbarch = get_frame_arch (frame);
905 struct type *type1 = check_typedef (type);
906 struct value *v;
907
908 if (gdbarch_convert_register_p (gdbarch, regnum, type1))
909 {
910 int optim, unavail, ok;
911
912 /* The ISA/ABI need to something weird when obtaining the
913 specified value from this register. It might need to
914 re-order non-adjacent, starting with REGNUM (see MIPS and
915 i386). It might need to convert the [float] register into
916 the corresponding [integer] type (see Alpha). The assumption
917 is that gdbarch_register_to_value populates the entire value
918 including the location. */
919 v = allocate_value (type);
920 VALUE_LVAL (v) = lval_register;
921 VALUE_NEXT_FRAME_ID (v) = get_frame_id (get_next_frame_sentinel_okay (frame));
922 VALUE_REGNUM (v) = regnum;
923 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
924 value_contents_raw (v), &optim,
925 &unavail);
926
927 if (!ok)
928 {
929 if (optim)
930 mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type));
931 if (unavail)
932 mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
933 }
934 }
935 else
936 {
937 /* Construct the value. */
938 v = gdbarch_value_from_register (gdbarch, type,
939 regnum, get_frame_id (frame));
940
941 /* Get the data. */
942 read_frame_register_value (v, frame);
943 }
944
945 return v;
946 }
947
948 /* Return contents of register REGNUM in frame FRAME as address.
949 Will abort if register value is not available. */
950
951 CORE_ADDR
952 address_from_register (int regnum, struct frame_info *frame)
953 {
954 struct gdbarch *gdbarch = get_frame_arch (frame);
955 struct type *type = builtin_type (gdbarch)->builtin_data_ptr;
956 struct value *value;
957 CORE_ADDR result;
958 int regnum_max_excl = (gdbarch_num_regs (gdbarch)
959 + gdbarch_num_pseudo_regs (gdbarch));
960
961 if (regnum < 0 || regnum >= regnum_max_excl)
962 error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum,
963 regnum_max_excl);
964
965 /* This routine may be called during early unwinding, at a time
966 where the ID of FRAME is not yet known. Calling value_from_register
967 would therefore abort in get_frame_id. However, since we only need
968 a temporary value that is never used as lvalue, we actually do not
969 really need to set its VALUE_NEXT_FRAME_ID. Therefore, we re-implement
970 the core of value_from_register, but use the null_frame_id. */
971
972 /* Some targets require a special conversion routine even for plain
973 pointer types. Avoid constructing a value object in those cases. */
974 if (gdbarch_convert_register_p (gdbarch, regnum, type))
975 {
976 gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
977 int optim, unavail, ok;
978
979 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type,
980 buf, &optim, &unavail);
981 if (!ok)
982 {
983 /* This function is used while computing a location expression.
984 Complain about the value being optimized out, rather than
985 letting value_as_address complain about some random register
986 the expression depends on not being saved. */
987 error_value_optimized_out ();
988 }
989
990 return unpack_long (type, buf);
991 }
992
993 value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
994 read_frame_register_value (value, frame);
995
996 if (value_optimized_out (value))
997 {
998 /* This function is used while computing a location expression.
999 Complain about the value being optimized out, rather than
1000 letting value_as_address complain about some random register
1001 the expression depends on not being saved. */
1002 error_value_optimized_out ();
1003 }
1004
1005 result = value_as_address (value);
1006 release_value (value);
1007 value_free (value);
1008
1009 return result;
1010 }
1011
1012 #if GDB_SELF_TEST
1013 namespace selftests {
1014 namespace findvar_tests {
1015
1016 /* Function to test copy_integer_to_size. Store SOURCE_VAL with size
1017 SOURCE_SIZE to a buffer, making sure no sign extending happens at this
1018 stage. Copy buffer to a new buffer using copy_integer_to_size. Extract
1019 copied value and compare to DEST_VALU. Copy again with a signed
1020 copy_integer_to_size and compare to DEST_VALS. Do everything for both
1021 LITTLE and BIG target endians. Use unsigned values throughout to make
1022 sure there are no implicit sign extensions. */
1023
1024 static void
1025 do_cint_test (ULONGEST dest_valu, ULONGEST dest_vals, int dest_size,
1026 ULONGEST src_val, int src_size)
1027 {
1028 for (int i = 0; i < 2 ; i++)
1029 {
1030 gdb_byte srcbuf[sizeof (ULONGEST)] = {};
1031 gdb_byte destbuf[sizeof (ULONGEST)] = {};
1032 enum bfd_endian byte_order = i ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
1033
1034 /* Fill the src buffer (and later the dest buffer) with non-zero junk,
1035 to ensure zero extensions aren't hidden. */
1036 memset (srcbuf, 0xaa, sizeof (srcbuf));
1037
1038 /* Store (and later extract) using unsigned to ensure there are no sign
1039 extensions. */
1040 store_unsigned_integer (srcbuf, src_size, byte_order, src_val);
1041
1042 /* Test unsigned. */
1043 memset (destbuf, 0xaa, sizeof (destbuf));
1044 copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, false,
1045 byte_order);
1046 SELF_CHECK (dest_valu == extract_unsigned_integer (destbuf, dest_size,
1047 byte_order));
1048
1049 /* Test signed. */
1050 memset (destbuf, 0xaa, sizeof (destbuf));
1051 copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, true,
1052 byte_order);
1053 SELF_CHECK (dest_vals == extract_unsigned_integer (destbuf, dest_size,
1054 byte_order));
1055 }
1056 }
1057
1058 static void
1059 copy_integer_to_size_test ()
1060 {
1061 /* Destination is bigger than the source, which has the signed bit unset. */
1062 do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
1063 do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
1064
1065 /* Destination is bigger than the source, which has the signed bit set. */
1066 do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
1067 do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
1068
1069 /* Destination is smaller than the source. */
1070 do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1071 do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1072
1073 /* Destination and source are the same size. */
1074 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1075 8);
1076 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1077 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1078 8);
1079 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1080
1081 /* Destination is bigger than the source. Source is bigger than 32bits. */
1082 do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1083 do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1084 do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1085 do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1086 }
1087
1088 } // namespace findvar_test
1089 } // namespace selftests
1090
1091 #endif
1092
1093 void
1094 _initialize_findvar (void)
1095 {
1096 #if GDB_SELF_TEST
1097 selftests::register_test
1098 ("copy_integer_to_size",
1099 selftests::findvar_tests::copy_integer_to_size_test);
1100 #endif
1101 }
symbol_read_needs
enum symbol_needs_kind symbol_read_needs(struct symbol *sym)
Definition: findvar.c:351
frame_id_p
int frame_id_p(struct frame_id l)
Definition: frame.c:646
gdbarch
Definition: gdbarch.c:127
extract_long_unsigned_integer
int extract_long_unsigned_integer(const gdb_byte *addr, int orig_len, enum bfd_endian byte_order, LONGEST *pval)
Definition: findvar.c:104
frame_find_by_id
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:803
follow_static_link
static struct frame_info * follow_static_link(struct frame_info *frame, const struct dynamic_prop *static_link)
Definition: findvar.c:433
target_has_registers
#define target_has_registers
Definition: target.h:1740
reg_offset
static int reg_offset[]
Definition: i386-gnu-nat.c:46
SYMBOL_PRINT_NAME
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:542
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
SYMBOL_NEEDS_REGISTERS
Definition: defs.h:550
LOC_BLOCK
Definition: symtab.h:854
copy_integer_to_size
void copy_integer_to_size(gdb_byte *dest, int dest_size, const gdb_byte *source, int source_size, bool is_signed, enum bfd_endian byte_order)
Definition: findvar.c:224
get_prev_frame
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2254
unsigned_address_to_pointer
void unsigned_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
Definition: findvar.c:331
store_integer
void store_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, T val)
Definition: findvar.c:168
obj_section::the_bfd_section
struct bfd_section * the_bfd_section
Definition: objfiles.h:126
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
VALUE_NEXT_FRAME_ID
#define VALUE_NEXT_FRAME_ID(val)
Definition: value.h:441
value_at
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition: valops.c:933
block_global_block
const struct block * block_global_block(const struct block *block)
Definition: block.c:379
lval_register
Definition: defs.h:385
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
mark_value_bytes_unavailable
void mark_value_bytes_unavailable(struct value *value, LONGEST offset, LONGEST length)
Definition: value.c:601
allocate_value_lazy
struct value * allocate_value_lazy(struct type *type)
Definition: value.c:916
SYMBOL_CLASS
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:1155
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
language_def
const struct language_defn * language_def(enum language lang)
Definition: language.c:494
LOC_UNDEF
Definition: symtab.h:797
type_length_units
unsigned int type_length_units(struct type *type)
Definition: gdbtypes.c:260
minsym_lookup_iterator_cb
static int minsym_lookup_iterator_cb(struct objfile *objfile, void *cb_data)
Definition: findvar.c:416
default_read_var_value
struct value * default_read_var_value(struct symbol *var, const struct block *var_block, struct frame_info *frame)
Definition: findvar.c:587
value_free
void value_free(struct value *val)
Definition: value.c:1608
symbol_arch
struct gdbarch * symbol_arch(const struct symbol *symbol)
Definition: symtab.c:5793
frame_info
Definition: frame.c:85
LOC_TYPEDEF
Definition: symtab.h:844
SYMBOL_BLOCK_OPS
#define SYMBOL_BLOCK_OPS(symbol)
Definition: symtab.h:1164
gdbarch_num_regs
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2039
dynamic_prop
Definition: gdbtypes.h:398
_
#define _(String)
Definition: gdb_locale.h:35
defs.h
BLOCK_START
#define BLOCK_START(bl)
Definition: block.h:105
LOC_ARG
Definition: symtab.h:823
SYMBOL_NEEDS_NONE
Definition: defs.h:547
VALUE_LVAL
#define VALUE_LVAL(val)
Definition: value.h:414
allocate_value
struct value * allocate_value(struct type *type)
Definition: value.c:1036
gdbarch_register_to_value
int gdbarch_register_to_value(struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep)
Definition: gdbarch.c:2612
selftests
Definition: selftest.c:25
get_frame_locals_address
CORE_ADDR get_frame_locals_address(struct frame_info *fi)
Definition: frame.c:2566
symbol_objfile
struct objfile * symbol_objfile(const struct symbol *symbol)
Definition: symtab.c:5784
gdbarch_convert_register_p
int gdbarch_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
Definition: gdbarch.c:2595
LOC_LOCAL
Definition: symtab.h:839
objfiles.h
SYMBOL_OBJ_SECTION
#define SYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:471
TYPE_IS_REFERENCE
#define TYPE_IS_REFERENCE(t)
Definition: gdbtypes.h:332
language_defn
Definition: language.h:132
BLOCK_FUNCTION
#define BLOCK_FUNCTION(bl)
Definition: block.h:107
LOC_REGISTER
Definition: symtab.h:819
MSYMBOL_OBJ_SECTION
#define MSYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:700
value_offset
LONGEST value_offset(const struct value *value)
Definition: value.c:1106
gdbarch_num_pseudo_regs
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2057
symtab.h
MSYMBOL_VALUE_RAW_ADDRESS
#define MSYMBOL_VALUE_RAW_ADDRESS(symbol)
Definition: symtab.h:684
symbol_needs_kind
symbol_needs_kind
Definition: defs.h:544
value_from_register
struct value * value_from_register(struct type *type, int regnum, struct frame_info *frame)
Definition: findvar.c:902
get_frame_register_value
struct value * get_frame_register_value(struct frame_info *frame, int regnum)
Definition: frame.c:1238
minsym_lookup_data::name
const char * name
Definition: findvar.c:402
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
SYMBOL_VALUE_ADDRESS
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:464
block_innermost_frame
struct frame_info * block_innermost_frame(const struct block *block)
Definition: blockframe.c:331
LOC_CONST_BYTES
Definition: symtab.h:859
LOC_COMPUTED
Definition: symtab.h:892
minsym_lookup_data::result
struct bound_minimal_symbol result
Definition: findvar.c:407
value_of_register_lazy
struct value * value_of_register_lazy(struct frame_info *frame, int regnum)
Definition: findvar.c:284
extract_integer< ULONGEST >
template ULONGEST extract_integer< ULONGEST >(const gdb_byte *addr, int len, enum bfd_endian byte_order)
read_var_value
struct value * read_var_value(struct symbol *var, const struct block *var_block, struct frame_info *frame)
Definition: findvar.c:807
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
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
register_type
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:152
read_frame_register_value
void read_frame_register_value(struct value *value, struct frame_info *frame)
Definition: findvar.c:862
extract_integer< LONGEST >
template LONGEST extract_integer< LONGEST >(const gdb_byte *addr, int len, enum bfd_endian byte_order)
symbol_read_needs_frame
int symbol_read_needs_frame(struct symbol *sym)
Definition: findvar.c:392
frame.h
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
SYMBOL_NEEDS_FRAME
Definition: defs.h:553
get_frame_function
struct symbol * get_frame_function(struct frame_info *frame)
Definition: blockframe.c:118
SYMBOL_REGISTER_OPS
#define SYMBOL_REGISTER_OPS(symbol)
Definition: symtab.h:1165
SYMBOL_COMPUTED_OPS
#define SYMBOL_COMPUTED_OPS(symbol)
Definition: symtab.h:1163
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
inferior.h
type
Definition: gdbtypes.h:749
VALUE_REGNUM
#define VALUE_REGNUM(val)
Definition: value.h:451
gdbarch_value_from_register
struct value * gdbarch_value_from_register(struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id)
Definition: gdbarch.c:2646
language.h
LOC_CONST
Definition: symtab.h:801
LOC_UNRESOLVED
Definition: symtab.h:883
BLOCK_SUPERBLOCK
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:108
symbol_overlayed_address
CORE_ADDR symbol_overlayed_address(CORE_ADDR address, struct obj_section *section)
Definition: symfile.c:3143
get_type_arch
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:234
get_next_frame_sentinel_okay
struct frame_info * get_next_frame_sentinel_okay(struct frame_info *this_frame)
Definition: frame.c:1784
SYMBOL_LINKAGE_NAME
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:523
value_at_lazy
struct value * value_at_lazy(struct type *type, CORE_ADDR addr)
Definition: valops.c:944
gdbarch_iterate_over_objfiles_in_search_order
void gdbarch_iterate_over_objfiles_in_search_order(struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype *cb, void *cb_data, struct objfile *current_objfile)
Definition: gdbarch.c:4819
LOC_STATIC
Definition: symtab.h:805
extract_integer
T extract_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: findvar.c:51
get_frame_args_address
CORE_ADDR get_frame_args_address(struct frame_info *fi)
Definition: frame.c:2581
set_value_offset
void set_value_offset(struct value *value, LONGEST offset)
Definition: value.c:1111
regnum
int regnum
Definition: aarch64-tdep.c:77
LOC_REGPARM_ADDR
Definition: symtab.h:835
gdbarch_pointer_to_address
CORE_ADDR gdbarch_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition: gdbarch.c:2663
extract_typed_address
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:154
unpack_long
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
Definition: value.c:2880
address_from_register
CORE_ADDR address_from_register(int regnum, struct frame_info *frame)
Definition: findvar.c:952
dwarf2loc.h
SYMBOL_VALUE
#define SYMBOL_VALUE(symbol)
Definition: symtab.h:463
user-regs.h
LOC_REF_ARG
Definition: symtab.h:827
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
value
Definition: value.c:169
address_to_signed_pointer
void address_to_signed_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
Definition: findvar.c:340
language_defn::la_read_var_value
struct value *(* la_read_var_value)(struct symbol *var, const struct block *var_block, struct frame_info *frame)
Definition: language.h:250
objfile
Definition: objfiles.h:286
TYPE_CODE_PTR
Definition: gdbtypes.h:84
_initialize_findvar
void _initialize_findvar(void)
Definition: findvar.c:1094
block_static_link
struct dynamic_prop * block_static_link(const struct block *block)
Definition: block.c:433
obj_section
Definition: objfiles.h:123
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
block_inlined_p
int block_inlined_p(const struct block *bl)
Definition: block.c:126
objfile_flavour_name
const char * objfile_flavour_name(struct objfile *objfile)
Definition: objfiles.c:1587
value_optimized_out
int value_optimized_out(struct value *value)
Definition: value.c:1424
value_fetch_lazy
void value_fetch_lazy(struct value *val)
Definition: value.c:3860
target_translate_tls_address
CORE_ADDR target_translate_tls_address(struct objfile *objfile, CORE_ADDR offset)
Definition: target.c:801
mark_value_bytes_optimized_out
void mark_value_bytes_optimized_out(struct value *value, int offset, int length)
Definition: value.c:1448
gdbcore.h
SYMBOL_BLOCK_VALUE
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:467
block_static_block
const struct block * block_static_block(const struct block *block)
Definition: block.c:364
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
value_of_register
struct value * value_of_register(int regnum, struct frame_info *frame)
Definition: findvar.c:263
get_frame_base
CORE_ADDR get_frame_base(struct frame_info *fi)
Definition: frame.c:2544
resolve_dynamic_type
struct type * resolve_dynamic_type(struct type *type, const gdb_byte *valaddr, CORE_ADDR addr)
Definition: gdbtypes.c:2317
builtin_type::builtin_data_ptr
struct type * builtin_data_ptr
Definition: gdbtypes.h:1554
minsym_lookup_data
Definition: findvar.c:399
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
offset
int offset
Definition: agent.c:65
obj_section::objfile
struct objfile * objfile
Definition: objfiles.h:129
default_value_from_register
struct value * default_value_from_register(struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id)
Definition: findvar.c:821
signed_pointer_to_address
CORE_ADDR signed_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition: findvar.c:320
SYMBOL_LANGUAGE
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:469
LOC_LABEL
Definition: symtab.h:848
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
value.h
store_typed_address
void store_typed_address(gdb_byte *buf, struct type *type, CORE_ADDR addr)
Definition: findvar.c:207
error_value_optimized_out
void error_value_optimized_out(void)
Definition: value.c:1225
overlay_debugging
enum overlay_debugging_state overlay_debugging
Definition: symfile.c:2970
gdbtypes.h
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
unsigned_pointer_to_address
CORE_ADDR unsigned_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
Definition: findvar.c:311
release_value
void release_value(struct value *val)
Definition: value.c:1693
register_size
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:164
is_dynamic_type
int is_dynamic_type(struct type *type)
Definition: gdbtypes.c:1976
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
symbol
Definition: symtab.h:1049
selftest.h
value_as_address
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2762
LOC_OPTIMIZED_OUT
Definition: symtab.h:888
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
value_contents_raw
gdb_byte * value_contents_raw(struct value *value)
Definition: value.c:1158
get_hosting_frame
static struct frame_info * get_hosting_frame(struct symbol *var, const struct block *var_block, struct frame_info *frame)
Definition: findvar.c:476
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
minimal_symbol
Definition: symtab.h:623
bound_minimal_symbol::objfile
struct objfile * objfile
Definition: minsyms.h:39
SYMBOL_VALUE_BYTES
#define SYMBOL_VALUE_BYTES(symbol)
Definition: symtab.h:465
allocate_optimized_out_value
struct value * allocate_optimized_out_value(struct type *type)
Definition: value.c:1077
QUIT
#define QUIT
Definition: defs.h:179
value_of_user_reg
struct value * value_of_user_reg(int regnum, struct frame_info *frame)
Definition: user-regs.c:213
not_lval
Definition: defs.h:381
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
selftests::register_test
void register_test(const std::string &name, selftest *test)
Definition: selftest.c:52
store_signed_integer
static void store_signed_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, LONGEST val)
Definition: defs.h:597
error
void error(const char *fmt,...)
Definition: errors.c:38
gdbarch_address_to_pointer
void gdbarch_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
Definition: gdbarch.c:2680
lookup_pointer_type
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:381
frame_id
Definition: frame.h:111
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
block.h
LONGEST
long long LONGEST
Definition: common-types.h:52
SELF_CHECK
#define SELF_CHECK(VALUE)
Definition: selftest.h:67
symfile.h
store_unsigned_integer
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:604