File: | src/gnu/usr.bin/binutils/gdb/findvar.c |
Warning: | line 526, column 2 Value stored to 'b' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* Find a variable's value in memory, for GDB, the GNU debugger. |
2 | |
3 | Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, |
4 | 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004 Free Software |
5 | Foundation, Inc. |
6 | |
7 | This file is part of GDB. |
8 | |
9 | This program is free software; you can redistribute it and/or modify |
10 | it under the terms of the GNU General Public License as published by |
11 | the Free Software Foundation; either version 2 of the License, or |
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, write to the Free Software |
21 | Foundation, Inc., 59 Temple Place - Suite 330, |
22 | Boston, MA 02111-1307, USA. */ |
23 | |
24 | #include "defs.h" |
25 | #include "symtab.h" |
26 | #include "gdbtypes.h" |
27 | #include "frame.h" |
28 | #include "value.h" |
29 | #include "gdbcore.h" |
30 | #include "inferior.h" |
31 | #include "target.h" |
32 | #include "gdb_string.h" |
33 | #include "gdb_assert.h" |
34 | #include "floatformat.h" |
35 | #include "symfile.h" /* for overlay functions */ |
36 | #include "regcache.h" |
37 | #include "user-regs.h" |
38 | #include "block.h" |
39 | |
40 | /* Basic byte-swapping routines. GDB has needed these for a long time... |
41 | All extract a target-format integer at ADDR which is LEN bytes long. */ |
42 | |
43 | #if TARGET_CHAR_BIT8 != 8 || HOST_CHAR_BIT8 != 8 |
44 | /* 8 bit characters are a pretty safe assumption these days, so we |
45 | assume it throughout all these swapping routines. If we had to deal with |
46 | 9 bit characters, we would need to make len be in bits and would have |
47 | to re-write these routines... */ |
48 | you lose |
49 | #endif |
50 | |
51 | LONGESTlong |
52 | extract_signed_integer (const void *addr, int len) |
53 | { |
54 | LONGESTlong retval; |
55 | const unsigned char *p; |
56 | const unsigned char *startaddr = addr; |
57 | const unsigned char *endaddr = startaddr + len; |
58 | |
59 | if (len > (int) sizeof (LONGESTlong)) |
60 | error ("\ |
61 | That operation is not available on integers of more than %d bytes.", |
62 | (int) sizeof (LONGESTlong)); |
63 | |
64 | /* Start at the most significant end of the integer, and work towards |
65 | the least significant. */ |
66 | if (TARGET_BYTE_ORDER(gdbarch_byte_order (current_gdbarch)) == BFD_ENDIAN_BIG) |
67 | { |
68 | p = startaddr; |
69 | /* Do the sign extension once at the start. */ |
70 | retval = ((LONGESTlong) * p ^ 0x80) - 0x80; |
71 | for (++p; p < endaddr; ++p) |
72 | retval = (retval << 8) | *p; |
73 | } |
74 | else |
75 | { |
76 | p = endaddr - 1; |
77 | /* Do the sign extension once at the start. */ |
78 | retval = ((LONGESTlong) * p ^ 0x80) - 0x80; |
79 | for (--p; p >= startaddr; --p) |
80 | retval = (retval << 8) | *p; |
81 | } |
82 | return retval; |
83 | } |
84 | |
85 | ULONGESTunsigned long |
86 | extract_unsigned_integer (const void *addr, int len) |
87 | { |
88 | ULONGESTunsigned long retval; |
89 | const unsigned char *p; |
90 | const unsigned char *startaddr = addr; |
91 | const unsigned char *endaddr = startaddr + len; |
92 | |
93 | if (len > (int) sizeof (ULONGESTunsigned long)) |
94 | error ("\ |
95 | That operation is not available on integers of more than %d bytes.", |
96 | (int) sizeof (ULONGESTunsigned long)); |
97 | |
98 | /* Start at the most significant end of the integer, and work towards |
99 | the least significant. */ |
100 | retval = 0; |
101 | if (TARGET_BYTE_ORDER(gdbarch_byte_order (current_gdbarch)) == BFD_ENDIAN_BIG) |
102 | { |
103 | for (p = startaddr; p < endaddr; ++p) |
104 | retval = (retval << 8) | *p; |
105 | } |
106 | else |
107 | { |
108 | for (p = endaddr - 1; p >= startaddr; --p) |
109 | retval = (retval << 8) | *p; |
110 | } |
111 | return retval; |
112 | } |
113 | |
114 | /* Sometimes a long long unsigned integer can be extracted as a |
115 | LONGEST value. This is done so that we can print these values |
116 | better. If this integer can be converted to a LONGEST, this |
117 | function returns 1 and sets *PVAL. Otherwise it returns 0. */ |
118 | |
119 | int |
120 | extract_long_unsigned_integer (const void *addr, int orig_len, LONGESTlong *pval) |
121 | { |
122 | char *p, *first_addr; |
123 | int len; |
124 | |
125 | len = orig_len; |
126 | if (TARGET_BYTE_ORDER(gdbarch_byte_order (current_gdbarch)) == BFD_ENDIAN_BIG) |
127 | { |
128 | for (p = (char *) addr; |
129 | len > (int) sizeof (LONGESTlong) && p < (char *) addr + orig_len; |
130 | p++) |
131 | { |
132 | if (*p == 0) |
133 | len--; |
134 | else |
135 | break; |
136 | } |
137 | first_addr = p; |
138 | } |
139 | else |
140 | { |
141 | first_addr = (char *) addr; |
142 | for (p = (char *) addr + orig_len - 1; |
143 | len > (int) sizeof (LONGESTlong) && p >= (char *) addr; |
144 | p--) |
145 | { |
146 | if (*p == 0) |
147 | len--; |
148 | else |
149 | break; |
150 | } |
151 | } |
152 | |
153 | if (len <= (int) sizeof (LONGESTlong)) |
154 | { |
155 | *pval = (LONGESTlong) extract_unsigned_integer (first_addr, |
156 | sizeof (LONGESTlong)); |
157 | return 1; |
158 | } |
159 | |
160 | return 0; |
161 | } |
162 | |
163 | |
164 | /* Treat the bytes at BUF as a pointer of type TYPE, and return the |
165 | address it represents. */ |
166 | CORE_ADDR |
167 | extract_typed_address (const void *buf, struct type *type) |
168 | { |
169 | if (TYPE_CODE (type)(type)->main_type->code != TYPE_CODE_PTR |
170 | && TYPE_CODE (type)(type)->main_type->code != TYPE_CODE_REF) |
171 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/findvar.c", __LINE__171, |
172 | "extract_typed_address: " |
173 | "type is not a pointer or reference"); |
174 | |
175 | return POINTER_TO_ADDRESS (type, buf)(gdbarch_pointer_to_address (current_gdbarch, type, buf)); |
176 | } |
177 | |
178 | |
179 | void |
180 | store_signed_integer (void *addr, int len, LONGESTlong val) |
181 | { |
182 | unsigned char *p; |
183 | unsigned char *startaddr = (unsigned char *) addr; |
184 | unsigned char *endaddr = startaddr + len; |
185 | |
186 | /* Start at the least significant end of the integer, and work towards |
187 | the most significant. */ |
188 | if (TARGET_BYTE_ORDER(gdbarch_byte_order (current_gdbarch)) == BFD_ENDIAN_BIG) |
189 | { |
190 | for (p = endaddr - 1; p >= startaddr; --p) |
191 | { |
192 | *p = val & 0xff; |
193 | val >>= 8; |
194 | } |
195 | } |
196 | else |
197 | { |
198 | for (p = startaddr; p < endaddr; ++p) |
199 | { |
200 | *p = val & 0xff; |
201 | val >>= 8; |
202 | } |
203 | } |
204 | } |
205 | |
206 | void |
207 | store_unsigned_integer (void *addr, int len, ULONGESTunsigned long val) |
208 | { |
209 | unsigned char *p; |
210 | unsigned char *startaddr = (unsigned char *) addr; |
211 | unsigned char *endaddr = startaddr + len; |
212 | |
213 | /* Start at the least significant end of the integer, and work towards |
214 | the most significant. */ |
215 | if (TARGET_BYTE_ORDER(gdbarch_byte_order (current_gdbarch)) == BFD_ENDIAN_BIG) |
216 | { |
217 | for (p = endaddr - 1; p >= startaddr; --p) |
218 | { |
219 | *p = val & 0xff; |
220 | val >>= 8; |
221 | } |
222 | } |
223 | else |
224 | { |
225 | for (p = startaddr; p < endaddr; ++p) |
226 | { |
227 | *p = val & 0xff; |
228 | val >>= 8; |
229 | } |
230 | } |
231 | } |
232 | |
233 | /* Store the address ADDR as a pointer of type TYPE at BUF, in target |
234 | form. */ |
235 | void |
236 | store_typed_address (void *buf, struct type *type, CORE_ADDR addr) |
237 | { |
238 | if (TYPE_CODE (type)(type)->main_type->code != TYPE_CODE_PTR |
239 | && TYPE_CODE (type)(type)->main_type->code != TYPE_CODE_REF) |
240 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/findvar.c", __LINE__240, |
241 | "store_typed_address: " |
242 | "type is not a pointer or reference"); |
243 | |
244 | ADDRESS_TO_POINTER (type, buf, addr)(gdbarch_address_to_pointer (current_gdbarch, type, buf, addr )); |
245 | } |
246 | |
247 | |
248 | |
249 | /* Return a `value' with the contents of (virtual or cooked) register |
250 | REGNUM as found in the specified FRAME. The register's type is |
251 | determined by register_type(). |
252 | |
253 | NOTE: returns NULL if register value is not available. Caller will |
254 | check return value or die! */ |
255 | |
256 | struct value * |
257 | value_of_register (int regnum, struct frame_info *frame) |
258 | { |
259 | CORE_ADDR addr; |
260 | int optim; |
261 | struct value *reg_val; |
262 | int realnum; |
263 | char raw_buffer[MAX_REGISTER_SIZE]; |
264 | enum lval_type lval; |
265 | |
266 | /* User registers lie completely outside of the range of normal |
267 | registers. Catch them early so that the target never sees them. */ |
268 | if (regnum >= NUM_REGS(gdbarch_num_regs (current_gdbarch)) + NUM_PSEUDO_REGS(gdbarch_num_pseudo_regs (current_gdbarch))) |
269 | return value_of_user_reg (regnum, frame); |
270 | |
271 | frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer); |
272 | |
273 | /* FIXME: cagney/2002-05-15: This test is just bogus. |
274 | |
275 | It indicates that the target failed to supply a value for a |
276 | register because it was "not available" at this time. Problem |
277 | is, the target still has the register and so get saved_register() |
278 | may be returning a value saved on the stack. */ |
279 | |
280 | if (register_cached (regnum) < 0) |
281 | return NULL((void*)0); /* register value not available */ |
282 | |
283 | reg_val = allocate_value (register_type (current_gdbarch, regnum)); |
284 | |
285 | memcpy (VALUE_CONTENTS_RAW (reg_val)((char *) (reg_val)->aligner.contents + (reg_val)->embedded_offset ), raw_buffer, |
286 | register_size (current_gdbarch, regnum)); |
287 | VALUE_LVAL (reg_val)(reg_val)->lval = lval; |
288 | VALUE_ADDRESS (reg_val)(reg_val)->location.address = addr; |
289 | VALUE_REGNO (reg_val)(reg_val)->regno = regnum; |
290 | VALUE_OPTIMIZED_OUT (reg_val)((reg_val)->optimized_out) = optim; |
291 | return reg_val; |
292 | } |
293 | |
294 | /* Given a pointer of type TYPE in target form in BUF, return the |
295 | address it represents. */ |
296 | CORE_ADDR |
297 | unsigned_pointer_to_address (struct type *type, const void *buf) |
298 | { |
299 | return extract_unsigned_integer (buf, TYPE_LENGTH (type)(type)->length); |
300 | } |
301 | |
302 | CORE_ADDR |
303 | signed_pointer_to_address (struct type *type, const void *buf) |
304 | { |
305 | return extract_signed_integer (buf, TYPE_LENGTH (type)(type)->length); |
306 | } |
307 | |
308 | /* Given an address, store it as a pointer of type TYPE in target |
309 | format in BUF. */ |
310 | void |
311 | unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr) |
312 | { |
313 | store_unsigned_integer (buf, TYPE_LENGTH (type)(type)->length, addr); |
314 | } |
315 | |
316 | void |
317 | address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr) |
318 | { |
319 | store_signed_integer (buf, TYPE_LENGTH (type)(type)->length, addr); |
320 | } |
321 | |
322 | /* Will calling read_var_value or locate_var_value on SYM end |
323 | up caring what frame it is being evaluated relative to? SYM must |
324 | be non-NULL. */ |
325 | int |
326 | symbol_read_needs_frame (struct symbol *sym) |
327 | { |
328 | switch (SYMBOL_CLASS (sym)(sym)->aclass) |
329 | { |
330 | /* All cases listed explicitly so that gcc -Wall will detect it if |
331 | we failed to consider one. */ |
332 | case LOC_COMPUTED: |
333 | case LOC_COMPUTED_ARG: |
334 | /* FIXME: cagney/2004-01-26: It should be possible to |
335 | unconditionally call the SYMBOL_OPS method when available. |
336 | Unfortunately DWARF 2 stores the frame-base (instead of the |
337 | function) location in a function's symbol. Oops! For the |
338 | moment enable this when/where applicable. */ |
339 | return SYMBOL_OPS (sym)(sym)->ops->read_needs_frame (sym); |
340 | |
341 | case LOC_REGISTER: |
342 | case LOC_ARG: |
343 | case LOC_REF_ARG: |
344 | case LOC_REGPARM: |
345 | case LOC_REGPARM_ADDR: |
346 | case LOC_LOCAL: |
347 | case LOC_LOCAL_ARG: |
348 | case LOC_BASEREG: |
349 | case LOC_BASEREG_ARG: |
350 | case LOC_HP_THREAD_LOCAL_STATIC: |
351 | return 1; |
352 | |
353 | case LOC_UNDEF: |
354 | case LOC_CONST: |
355 | case LOC_STATIC: |
356 | case LOC_INDIRECT: |
357 | case LOC_TYPEDEF: |
358 | |
359 | case LOC_LABEL: |
360 | /* Getting the address of a label can be done independently of the block, |
361 | even if some *uses* of that address wouldn't work so well without |
362 | the right frame. */ |
363 | |
364 | case LOC_BLOCK: |
365 | case LOC_CONST_BYTES: |
366 | case LOC_UNRESOLVED: |
367 | case LOC_OPTIMIZED_OUT: |
368 | return 0; |
369 | } |
370 | return 1; |
371 | } |
372 | |
373 | /* Given a struct symbol for a variable, |
374 | and a stack frame id, read the value of the variable |
375 | and return a (pointer to a) struct value containing the value. |
376 | If the variable cannot be found, return a zero pointer. |
377 | If FRAME is NULL, use the deprecated_selected_frame. */ |
378 | |
379 | struct value * |
380 | read_var_value (struct symbol *var, struct frame_info *frame) |
381 | { |
382 | struct value *v; |
383 | struct type *type = SYMBOL_TYPE (var)(var)->type; |
384 | CORE_ADDR addr; |
385 | int len; |
386 | |
387 | v = allocate_value (type); |
388 | VALUE_LVAL (v)(v)->lval = lval_memory; /* The most likely possibility. */ |
389 | VALUE_BFD_SECTION (v)((v)->bfd_section) = SYMBOL_BFD_SECTION (var)(var)->ginfo.bfd_section; |
390 | |
391 | len = TYPE_LENGTH (type)(type)->length; |
392 | |
393 | |
394 | /* FIXME drow/2003-09-06: this call to the selected frame should be |
395 | pushed upwards to the callers. */ |
396 | if (frame == NULL((void*)0)) |
397 | frame = deprecated_safe_get_selected_frame (); |
398 | |
399 | switch (SYMBOL_CLASS (var)(var)->aclass) |
400 | { |
401 | case LOC_CONST: |
402 | /* Put the constant back in target format. */ |
403 | store_signed_integer (VALUE_CONTENTS_RAW (v)((char *) (v)->aligner.contents + (v)->embedded_offset), len, |
404 | (LONGESTlong) SYMBOL_VALUE (var)(var)->ginfo.value.ivalue); |
405 | VALUE_LVAL (v)(v)->lval = not_lval; |
406 | return v; |
407 | |
408 | case LOC_LABEL: |
409 | /* Put the constant back in target format. */ |
410 | if (overlay_debugging) |
411 | { |
412 | CORE_ADDR addr |
413 | = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var)(var)->ginfo.value.address, |
414 | SYMBOL_BFD_SECTION (var)(var)->ginfo.bfd_section); |
415 | store_typed_address (VALUE_CONTENTS_RAW (v)((char *) (v)->aligner.contents + (v)->embedded_offset), type, addr); |
416 | } |
417 | else |
418 | store_typed_address (VALUE_CONTENTS_RAW (v)((char *) (v)->aligner.contents + (v)->embedded_offset), type, |
419 | SYMBOL_VALUE_ADDRESS (var)(var)->ginfo.value.address); |
420 | VALUE_LVAL (v)(v)->lval = not_lval; |
421 | return v; |
422 | |
423 | case LOC_CONST_BYTES: |
424 | { |
425 | char *bytes_addr; |
426 | bytes_addr = SYMBOL_VALUE_BYTES (var)(var)->ginfo.value.bytes; |
427 | memcpy (VALUE_CONTENTS_RAW (v)((char *) (v)->aligner.contents + (v)->embedded_offset), bytes_addr, len); |
428 | VALUE_LVAL (v)(v)->lval = not_lval; |
429 | return v; |
430 | } |
431 | |
432 | case LOC_STATIC: |
433 | if (overlay_debugging) |
434 | addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var)(var)->ginfo.value.address, |
435 | SYMBOL_BFD_SECTION (var)(var)->ginfo.bfd_section); |
436 | else |
437 | addr = SYMBOL_VALUE_ADDRESS (var)(var)->ginfo.value.address; |
438 | break; |
439 | |
440 | case LOC_INDIRECT: |
441 | { |
442 | /* The import slot does not have a real address in it from the |
443 | dynamic loader (dld.sl on HP-UX), if the target hasn't |
444 | begun execution yet, so check for that. */ |
445 | CORE_ADDR locaddr; |
446 | struct value *loc; |
447 | if (!target_has_execution(current_target.to_has_execution)) |
448 | error ("\ |
449 | Attempt to access variable defined in different shared object or load module when\n\ |
450 | addresses have not been bound by the dynamic loader. Try again when executable is running."); |
451 | |
452 | locaddr = SYMBOL_VALUE_ADDRESS (var)(var)->ginfo.value.address; |
453 | loc = value_at (lookup_pointer_type (type), locaddr, NULL((void*)0)); |
454 | addr = value_as_address (loc); |
455 | } |
456 | |
457 | case LOC_ARG: |
458 | if (frame == NULL((void*)0)) |
459 | return 0; |
460 | addr = get_frame_args_address (frame); |
461 | if (!addr) |
462 | return 0; |
463 | addr += SYMBOL_VALUE (var)(var)->ginfo.value.ivalue; |
464 | break; |
465 | |
466 | case LOC_REF_ARG: |
467 | { |
468 | struct value *ref; |
469 | CORE_ADDR argref; |
470 | if (frame == NULL((void*)0)) |
471 | return 0; |
472 | argref = get_frame_args_address (frame); |
473 | if (!argref) |
474 | return 0; |
475 | argref += SYMBOL_VALUE (var)(var)->ginfo.value.ivalue; |
476 | ref = value_at (lookup_pointer_type (type), argref, NULL((void*)0)); |
477 | addr = value_as_address (ref); |
478 | break; |
479 | } |
480 | |
481 | case LOC_LOCAL: |
482 | case LOC_LOCAL_ARG: |
483 | if (frame == NULL((void*)0)) |
484 | return 0; |
485 | addr = get_frame_locals_address (frame); |
486 | addr += SYMBOL_VALUE (var)(var)->ginfo.value.ivalue; |
487 | break; |
488 | |
489 | case LOC_BASEREG: |
490 | case LOC_BASEREG_ARG: |
491 | case LOC_HP_THREAD_LOCAL_STATIC: |
492 | { |
493 | struct value *regval; |
494 | |
495 | regval = value_from_register (lookup_pointer_type (type), |
496 | SYMBOL_BASEREG (var)(var)->aux_value.basereg, frame); |
497 | if (regval == NULL((void*)0)) |
498 | error ("Value of base register not available."); |
499 | addr = value_as_address (regval); |
500 | addr += SYMBOL_VALUE (var)(var)->ginfo.value.ivalue; |
501 | break; |
502 | } |
503 | |
504 | case LOC_TYPEDEF: |
505 | error ("Cannot look up value of a typedef"); |
506 | break; |
507 | |
508 | case LOC_BLOCK: |
509 | if (overlay_debugging) |
510 | VALUE_ADDRESS (v)(v)->location.address = symbol_overlayed_address |
511 | (BLOCK_START (SYMBOL_BLOCK_VALUE (var))((var)->ginfo.value.block)->startaddr, SYMBOL_BFD_SECTION (var)(var)->ginfo.bfd_section); |
512 | else |
513 | VALUE_ADDRESS (v)(v)->location.address = BLOCK_START (SYMBOL_BLOCK_VALUE (var))((var)->ginfo.value.block)->startaddr; |
514 | return v; |
515 | |
516 | case LOC_REGISTER: |
517 | case LOC_REGPARM: |
518 | case LOC_REGPARM_ADDR: |
519 | { |
520 | struct block *b; |
521 | int regno = SYMBOL_VALUE (var)(var)->ginfo.value.ivalue; |
522 | struct value *regval; |
523 | |
524 | if (frame == NULL((void*)0)) |
525 | return 0; |
526 | b = get_frame_block (frame, 0); |
Value stored to 'b' is never read | |
527 | |
528 | if (SYMBOL_CLASS (var)(var)->aclass == LOC_REGPARM_ADDR) |
529 | { |
530 | regval = value_from_register (lookup_pointer_type (type), |
531 | regno, |
532 | frame); |
533 | |
534 | if (regval == NULL((void*)0)) |
535 | error ("Value of register variable not available."); |
536 | |
537 | addr = value_as_address (regval); |
538 | VALUE_LVAL (v)(v)->lval = lval_memory; |
539 | } |
540 | else |
541 | { |
542 | regval = value_from_register (type, regno, frame); |
543 | |
544 | if (regval == NULL((void*)0)) |
545 | error ("Value of register variable not available."); |
546 | return regval; |
547 | } |
548 | } |
549 | break; |
550 | |
551 | case LOC_COMPUTED: |
552 | case LOC_COMPUTED_ARG: |
553 | /* FIXME: cagney/2004-01-26: It should be possible to |
554 | unconditionally call the SYMBOL_OPS method when available. |
555 | Unfortunately DWARF 2 stores the frame-base (instead of the |
556 | function) location in a function's symbol. Oops! For the |
557 | moment enable this when/where applicable. */ |
558 | if (frame == 0 && SYMBOL_OPS (var)(var)->ops->read_needs_frame (var)) |
559 | return 0; |
560 | return SYMBOL_OPS (var)(var)->ops->read_variable (var, frame); |
561 | |
562 | case LOC_UNRESOLVED: |
563 | { |
564 | struct minimal_symbol *msym; |
565 | |
566 | msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var)(var)->ginfo.name, NULL((void*)0), NULL((void*)0)); |
567 | if (msym == NULL((void*)0)) |
568 | return 0; |
569 | if (overlay_debugging) |
570 | addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym)(msym)->ginfo.value.address, |
571 | SYMBOL_BFD_SECTION (msym)(msym)->ginfo.bfd_section); |
572 | else |
573 | addr = SYMBOL_VALUE_ADDRESS (msym)(msym)->ginfo.value.address; |
574 | } |
575 | break; |
576 | |
577 | case LOC_OPTIMIZED_OUT: |
578 | VALUE_LVAL (v)(v)->lval = not_lval; |
579 | VALUE_OPTIMIZED_OUT (v)((v)->optimized_out) = 1; |
580 | return v; |
581 | |
582 | default: |
583 | error ("Cannot look up value of a botched symbol."); |
584 | break; |
585 | } |
586 | |
587 | VALUE_ADDRESS (v)(v)->location.address = addr; |
588 | VALUE_LAZY (v)(v)->lazy = 1; |
589 | return v; |
590 | } |
591 | |
592 | /* Return a value of type TYPE, stored in register REGNUM, in frame |
593 | FRAME. |
594 | |
595 | NOTE: returns NULL if register value is not available. |
596 | Caller will check return value or die! */ |
597 | |
598 | struct value * |
599 | value_from_register (struct type *type, int regnum, struct frame_info *frame) |
600 | { |
601 | struct gdbarch *gdbarch = get_frame_arch (frame); |
602 | struct value *v = allocate_value (type); |
603 | CHECK_TYPEDEF (type)(type) = check_typedef (type); |
604 | |
605 | if (TYPE_LENGTH (type)(type)->length == 0) |
606 | { |
607 | /* It doesn't matter much what we return for this: since the |
608 | length is zero, it could be anything. But if allowed to see |
609 | a zero-length type, the register-finding loop below will set |
610 | neither mem_stor nor reg_stor, and then report an internal |
611 | error. |
612 | |
613 | Zero-length types can legitimately arise from declarations |
614 | like 'struct {}' (a GCC extension, not valid ISO C). GDB may |
615 | also create them when it finds bogus debugging information; |
616 | for example, in GCC 2.95.4 and binutils 2.11.93.0.2, the |
617 | STABS BINCL->EXCL compression process can create bad type |
618 | numbers. GDB reads these as TYPE_CODE_UNDEF types, with zero |
619 | length. (That bug is actually the only known way to get a |
620 | zero-length value allocated to a register --- which is what |
621 | it takes to make it here.) |
622 | |
623 | We'll just attribute the value to the original register. */ |
624 | VALUE_LVAL (v)(v)->lval = lval_register; |
625 | VALUE_ADDRESS (v)(v)->location.address = regnum; |
626 | VALUE_REGNO (v)(v)->regno = regnum; |
627 | } |
628 | else if (CONVERT_REGISTER_P (regnum, type)(gdbarch_convert_register_p (current_gdbarch, regnum, type))) |
629 | { |
630 | /* The ISA/ABI need to something weird when obtaining the |
631 | specified value from this register. It might need to |
632 | re-order non-adjacent, starting with REGNUM (see MIPS and |
633 | i386). It might need to convert the [float] register into |
634 | the corresponding [integer] type (see Alpha). The assumption |
635 | is that REGISTER_TO_VALUE populates the entire value |
636 | including the location. */ |
637 | REGISTER_TO_VALUE (frame, regnum, type, VALUE_CONTENTS_RAW (v))(gdbarch_register_to_value (current_gdbarch, frame, regnum, type , ((char *) (v)->aligner.contents + (v)->embedded_offset ))); |
638 | VALUE_LVAL (v)(v)->lval = lval_reg_frame_relative; |
639 | VALUE_FRAME_ID (v)((v)->frame_id) = get_frame_id (frame); |
640 | VALUE_FRAME_REGNUM (v)((v)->location.regnum) = regnum; |
641 | } |
642 | else |
643 | { |
644 | int local_regnum; |
645 | int mem_stor = 0, reg_stor = 0; |
646 | int mem_tracking = 1; |
647 | CORE_ADDR last_addr = 0; |
648 | CORE_ADDR first_addr = 0; |
649 | int first_realnum = regnum; |
650 | int len = TYPE_LENGTH (type)(type)->length; |
651 | int value_bytes_copied; |
652 | int optimized = 0; |
653 | char *value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE)__builtin_alloca(len + MAX_REGISTER_SIZE); |
654 | |
655 | /* Copy all of the data out, whereever it may be. */ |
656 | for (local_regnum = regnum, value_bytes_copied = 0; |
657 | value_bytes_copied < len; |
658 | (value_bytes_copied += register_size (current_gdbarch, local_regnum), |
659 | ++local_regnum)) |
660 | { |
661 | int realnum; |
662 | int optim; |
663 | enum lval_type lval; |
664 | CORE_ADDR addr; |
665 | frame_register (frame, local_regnum, &optim, &lval, &addr, |
666 | &realnum, value_bytes + value_bytes_copied); |
667 | optimized += optim; |
668 | if (register_cached (local_regnum) == -1) |
669 | return NULL((void*)0); /* register value not available */ |
670 | |
671 | if (regnum == local_regnum) |
672 | { |
673 | first_addr = addr; |
674 | first_realnum = realnum; |
675 | } |
676 | if (lval == lval_register) |
677 | reg_stor++; |
678 | else |
679 | { |
680 | mem_stor++; |
681 | |
682 | mem_tracking = (mem_tracking |
683 | && (regnum == local_regnum |
684 | || addr == last_addr)); |
685 | } |
686 | last_addr = addr; |
687 | } |
688 | |
689 | /* FIXME: cagney/2003-06-04: Shouldn't this always use |
690 | lval_reg_frame_relative? If it doesn't and the register's |
691 | location changes (say after a resume) then this value is |
692 | going to have wrong information. */ |
693 | if ((reg_stor && mem_stor) |
694 | || (mem_stor && !mem_tracking)) |
695 | /* Mixed storage; all of the hassle we just went through was |
696 | for some good purpose. */ |
697 | { |
698 | VALUE_LVAL (v)(v)->lval = lval_reg_frame_relative; |
699 | VALUE_FRAME_ID (v)((v)->frame_id) = get_frame_id (frame); |
700 | VALUE_FRAME_REGNUM (v)((v)->location.regnum) = regnum; |
701 | } |
702 | else if (mem_stor) |
703 | { |
704 | VALUE_LVAL (v)(v)->lval = lval_memory; |
705 | VALUE_ADDRESS (v)(v)->location.address = first_addr; |
706 | } |
707 | else if (reg_stor) |
708 | { |
709 | VALUE_LVAL (v)(v)->lval = lval_register; |
710 | VALUE_ADDRESS (v)(v)->location.address = first_addr; |
711 | VALUE_REGNO (v)(v)->regno = first_realnum; |
712 | } |
713 | else |
714 | internal_error (__FILE__"/usr/src/gnu/usr.bin/binutils/gdb/findvar.c", __LINE__714, |
715 | "value_from_register: Value not stored anywhere!"); |
716 | |
717 | VALUE_OPTIMIZED_OUT (v)((v)->optimized_out) = optimized; |
718 | |
719 | /* Any structure stored in more than one register will always be |
720 | an integral number of registers. Otherwise, you need to do |
721 | some fiddling with the last register copied here for little |
722 | endian machines. */ |
723 | if (TARGET_BYTE_ORDER(gdbarch_byte_order (current_gdbarch)) == BFD_ENDIAN_BIG |
724 | && len < register_size (current_gdbarch, regnum)) |
725 | /* Big-endian, and we want less than full size. */ |
726 | VALUE_OFFSET (v)(v)->offset = register_size (current_gdbarch, regnum) - len; |
727 | else |
728 | VALUE_OFFSET (v)(v)->offset = 0; |
729 | memcpy (VALUE_CONTENTS_RAW (v)((char *) (v)->aligner.contents + (v)->embedded_offset), value_bytes + VALUE_OFFSET (v)(v)->offset, len); |
730 | } |
731 | return v; |
732 | } |
733 | |
734 | |
735 | /* Given a struct symbol for a variable or function, |
736 | and a stack frame id, |
737 | return a (pointer to a) struct value containing the properly typed |
738 | address. */ |
739 | |
740 | struct value * |
741 | locate_var_value (struct symbol *var, struct frame_info *frame) |
742 | { |
743 | CORE_ADDR addr = 0; |
744 | struct type *type = SYMBOL_TYPE (var)(var)->type; |
745 | struct value *lazy_value; |
746 | |
747 | /* Evaluate it first; if the result is a memory address, we're fine. |
748 | Lazy evaluation pays off here. */ |
749 | |
750 | lazy_value = read_var_value (var, frame); |
751 | if (lazy_value == 0) |
752 | error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var)(demangle ? (symbol_natural_name (&(var)->ginfo)) : (var )->ginfo.name)); |
753 | |
754 | if (VALUE_LAZY (lazy_value)(lazy_value)->lazy |
755 | || TYPE_CODE (type)(type)->main_type->code == TYPE_CODE_FUNC) |
756 | { |
757 | struct value *val; |
758 | |
759 | addr = VALUE_ADDRESS (lazy_value)(lazy_value)->location.address; |
760 | val = value_from_pointer (lookup_pointer_type (type), addr); |
761 | VALUE_BFD_SECTION (val)((val)->bfd_section) = VALUE_BFD_SECTION (lazy_value)((lazy_value)->bfd_section); |
762 | return val; |
763 | } |
764 | |
765 | /* Not a memory address; check what the problem was. */ |
766 | switch (VALUE_LVAL (lazy_value)(lazy_value)->lval) |
767 | { |
768 | case lval_register: |
769 | gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL((void) (((gdbarch_register_name (current_gdbarch, (lazy_value )->regno)) != ((void*)0) && *(gdbarch_register_name (current_gdbarch, (lazy_value)->regno)) != '\0') ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/findvar.c", 770, "%s: Assertion `%s' failed." , __PRETTY_FUNCTION__, "REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\\0'" ), 0))) |
770 | && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\0')((void) (((gdbarch_register_name (current_gdbarch, (lazy_value )->regno)) != ((void*)0) && *(gdbarch_register_name (current_gdbarch, (lazy_value)->regno)) != '\0') ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/findvar.c", 770, "%s: Assertion `%s' failed." , __PRETTY_FUNCTION__, "REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\\0'" ), 0))); |
771 | error("Address requested for identifier " |
772 | "\"%s\" which is in register $%s", |
773 | SYMBOL_PRINT_NAME (var)(demangle ? (symbol_natural_name (&(var)->ginfo)) : (var )->ginfo.name), |
774 | REGISTER_NAME (VALUE_REGNO (lazy_value))(gdbarch_register_name (current_gdbarch, (lazy_value)->regno ))); |
775 | break; |
776 | |
777 | case lval_reg_frame_relative: |
778 | gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL((void) (((gdbarch_register_name (current_gdbarch, ((lazy_value )->location.regnum))) != ((void*)0) && *(gdbarch_register_name (current_gdbarch, ((lazy_value)->location.regnum))) != '\0' ) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/findvar.c" , 779, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\\0'" ), 0))) |
779 | && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0')((void) (((gdbarch_register_name (current_gdbarch, ((lazy_value )->location.regnum))) != ((void*)0) && *(gdbarch_register_name (current_gdbarch, ((lazy_value)->location.regnum))) != '\0' ) ? 0 : (internal_error ("/usr/src/gnu/usr.bin/binutils/gdb/findvar.c" , 779, "%s: Assertion `%s' failed.", __PRETTY_FUNCTION__, "REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\\0'" ), 0))); |
780 | error("Address requested for identifier " |
781 | "\"%s\" which is in frame register $%s", |
782 | SYMBOL_PRINT_NAME (var)(demangle ? (symbol_natural_name (&(var)->ginfo)) : (var )->ginfo.name), |
783 | REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value))(gdbarch_register_name (current_gdbarch, ((lazy_value)->location .regnum)))); |
784 | break; |
785 | |
786 | default: |
787 | error ("Can't take address of \"%s\" which isn't an lvalue.", |
788 | SYMBOL_PRINT_NAME (var)(demangle ? (symbol_natural_name (&(var)->ginfo)) : (var )->ginfo.name)); |
789 | break; |
790 | } |
791 | return 0; /* For lint -- never reached */ |
792 | } |