1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2 Copyright 1986, 87, 89, 91, 94, 95, 96, 1998
3 Free Software Foundation, Inc.
5 This file is part of GDB.
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 2 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "gdb_string.h"
31 #include "floatformat.h"
32 #include "symfile.h" /* for overlay functions */
34 /* This is used to indicate that we don't know the format of the floating point
35 number. Typically, this is useful for native ports, where the actual format
36 is irrelevant, since no conversions will be taking place. */
38 const struct floatformat floatformat_unknown
;
40 /* Registers we shouldn't try to store. */
41 #if !defined (CANNOT_STORE_REGISTER)
42 #define CANNOT_STORE_REGISTER(regno) 0
45 static void write_register_gen
PARAMS ((int, char *));
47 static int read_relative_register_raw_bytes_for_frame
PARAMS ((int regnum
, char *myaddr
, struct frame_info
* frame
));
49 /* Basic byte-swapping routines. GDB has needed these for a long time...
50 All extract a target-format integer at ADDR which is LEN bytes long. */
52 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
53 /* 8 bit characters are a pretty safe assumption these days, so we
54 assume it throughout all these swapping routines. If we had to deal with
55 9 bit characters, we would need to make len be in bits and would have
56 to re-write these routines... */
61 extract_signed_integer (addr
, len
)
67 unsigned char *startaddr
= (unsigned char *) addr
;
68 unsigned char *endaddr
= startaddr
+ len
;
70 if (len
> (int) sizeof (LONGEST
))
72 That operation is not available on integers of more than %d bytes.",
75 /* Start at the most significant end of the integer, and work towards
76 the least significant. */
77 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
80 /* Do the sign extension once at the start. */
81 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
82 for (++p
; p
< endaddr
; ++p
)
83 retval
= (retval
<< 8) | *p
;
88 /* Do the sign extension once at the start. */
89 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
90 for (--p
; p
>= startaddr
; --p
)
91 retval
= (retval
<< 8) | *p
;
97 extract_unsigned_integer (addr
, len
)
103 unsigned char *startaddr
= (unsigned char *) addr
;
104 unsigned char *endaddr
= startaddr
+ len
;
106 if (len
> (int) sizeof (ULONGEST
))
108 That operation is not available on integers of more than %d bytes.",
111 /* Start at the most significant end of the integer, and work towards
112 the least significant. */
114 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
116 for (p
= startaddr
; p
< endaddr
; ++p
)
117 retval
= (retval
<< 8) | *p
;
121 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
122 retval
= (retval
<< 8) | *p
;
127 /* Sometimes a long long unsigned integer can be extracted as a
128 LONGEST value. This is done so that we can print these values
129 better. If this integer can be converted to a LONGEST, this
130 function returns 1 and sets *PVAL. Otherwise it returns 0. */
133 extract_long_unsigned_integer (addr
, orig_len
, pval
)
138 char *p
, *first_addr
;
142 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
144 for (p
= (char *) addr
;
145 len
> (int) sizeof (LONGEST
) && p
< (char *) addr
+ orig_len
;
157 first_addr
= (char *) addr
;
158 for (p
= (char *) addr
+ orig_len
- 1;
159 len
> (int) sizeof (LONGEST
) && p
>= (char *) addr
;
169 if (len
<= (int) sizeof (LONGEST
))
171 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
180 extract_address (addr
, len
)
184 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
185 whether we want this to be true eventually. */
186 return (CORE_ADDR
) extract_unsigned_integer (addr
, len
);
190 store_signed_integer (addr
, len
, val
)
196 unsigned char *startaddr
= (unsigned char *) addr
;
197 unsigned char *endaddr
= startaddr
+ len
;
199 /* Start at the least significant end of the integer, and work towards
200 the most significant. */
201 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
203 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
211 for (p
= startaddr
; p
< endaddr
; ++p
)
220 store_unsigned_integer (addr
, len
, val
)
226 unsigned char *startaddr
= (unsigned char *) addr
;
227 unsigned char *endaddr
= startaddr
+ len
;
229 /* Start at the least significant end of the integer, and work towards
230 the most significant. */
231 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
233 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
241 for (p
= startaddr
; p
< endaddr
; ++p
)
249 /* Store the literal address "val" into
250 gdb-local memory pointed to by "addr"
253 store_address (addr
, len
, val
)
258 store_unsigned_integer (addr
, len
, val
);
261 /* Swap LEN bytes at BUFFER between target and host byte-order. */
262 #define SWAP_FLOATING(buffer,len) \
265 if (TARGET_BYTE_ORDER != HOST_BYTE_ORDER) \
268 char *p = (char *)(buffer); \
269 char *q = ((char *)(buffer)) + len - 1; \
270 for (; p < q; p++, q--) \
280 /* Extract a floating-point number from a target-order byte-stream at ADDR.
281 Returns the value as type DOUBLEST.
283 If the host and target formats agree, we just copy the raw data into the
284 appropriate type of variable and return, letting the host increase precision
285 as necessary. Otherwise, we call the conversion routine and let it do the
289 extract_floating (addr
, len
)
295 if (len
== sizeof (float))
297 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
301 memcpy (&retval
, addr
, sizeof (retval
));
305 floatformat_to_doublest (TARGET_FLOAT_FORMAT
, addr
, &dretval
);
307 else if (len
== sizeof (double))
309 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
313 memcpy (&retval
, addr
, sizeof (retval
));
317 floatformat_to_doublest (TARGET_DOUBLE_FORMAT
, addr
, &dretval
);
319 else if (len
== sizeof (DOUBLEST
))
321 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
325 memcpy (&retval
, addr
, sizeof (retval
));
329 floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT
, addr
, &dretval
);
331 #ifdef TARGET_EXTRACT_FLOATING
332 else if (TARGET_EXTRACT_FLOATING (addr
, len
, &dretval
))
337 error ("Can't deal with a floating point number of %d bytes.", len
);
344 store_floating (addr
, len
, val
)
349 if (len
== sizeof (float))
351 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
353 float floatval
= val
;
355 memcpy (addr
, &floatval
, sizeof (floatval
));
358 floatformat_from_doublest (TARGET_FLOAT_FORMAT
, &val
, addr
);
360 else if (len
== sizeof (double))
362 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
364 double doubleval
= val
;
366 memcpy (addr
, &doubleval
, sizeof (doubleval
));
369 floatformat_from_doublest (TARGET_DOUBLE_FORMAT
, &val
, addr
);
371 else if (len
== sizeof (DOUBLEST
))
373 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
374 memcpy (addr
, &val
, sizeof (val
));
376 floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT
, &val
, addr
);
378 #ifdef TARGET_STORE_FLOATING
379 else if (TARGET_STORE_FLOATING (addr
, len
, val
))
384 error ("Can't deal with a floating point number of %d bytes.", len
);
389 /* Return the address in which frame FRAME's value of register REGNUM
390 has been saved in memory. Or return zero if it has not been saved.
391 If REGNUM specifies the SP, the value we return is actually
392 the SP value, not an address where it was saved. */
395 find_saved_register (frame
, regnum
)
396 struct frame_info
*frame
;
399 register struct frame_info
*frame1
= NULL
;
400 register CORE_ADDR addr
= 0;
402 if (frame
== NULL
) /* No regs saved if want current frame */
405 #ifdef HAVE_REGISTER_WINDOWS
406 /* We assume that a register in a register window will only be saved
407 in one place (since the name changes and/or disappears as you go
408 towards inner frames), so we only call get_frame_saved_regs on
409 the current frame. This is directly in contradiction to the
410 usage below, which assumes that registers used in a frame must be
411 saved in a lower (more interior) frame. This change is a result
412 of working on a register window machine; get_frame_saved_regs
413 always returns the registers saved within a frame, within the
414 context (register namespace) of that frame. */
416 /* However, note that we don't want this to return anything if
417 nothing is saved (if there's a frame inside of this one). Also,
418 callers to this routine asking for the stack pointer want the
419 stack pointer saved for *this* frame; this is returned from the
422 if (REGISTER_IN_WINDOW_P (regnum
))
424 frame1
= get_next_frame (frame
);
426 return 0; /* Registers of this frame are active. */
428 /* Get the SP from the next frame in; it will be this
430 if (regnum
!= SP_REGNUM
)
433 FRAME_INIT_SAVED_REGS (frame1
);
434 return frame1
->saved_regs
[regnum
]; /* ... which might be zero */
436 #endif /* HAVE_REGISTER_WINDOWS */
438 /* Note that this next routine assumes that registers used in
439 frame x will be saved only in the frame that x calls and
440 frames interior to it. This is not true on the sparc, but the
441 above macro takes care of it, so we should be all right. */
445 frame1
= get_prev_frame (frame1
);
446 if (frame1
== 0 || frame1
== frame
)
448 FRAME_INIT_SAVED_REGS (frame1
);
449 if (frame1
->saved_regs
[regnum
])
450 addr
= frame1
->saved_regs
[regnum
];
456 /* Find register number REGNUM relative to FRAME and put its (raw,
457 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
458 variable was optimized out (and thus can't be fetched). Set *LVAL
459 to lval_memory, lval_register, or not_lval, depending on whether
460 the value was fetched from memory, from a register, or in a strange
461 and non-modifiable way (e.g. a frame pointer which was calculated
462 rather than fetched). Set *ADDRP to the address, either in memory
463 on as a REGISTER_BYTE offset into the registers array.
465 Note that this implementation never sets *LVAL to not_lval. But
466 it can be replaced by defining GET_SAVED_REGISTER and supplying
469 The argument RAW_BUFFER must point to aligned memory. */
472 default_get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
476 struct frame_info
*frame
;
478 enum lval_type
*lval
;
482 if (!target_has_registers
)
483 error ("No registers.");
485 /* Normal systems don't optimize out things with register numbers. */
486 if (optimized
!= NULL
)
488 addr
= find_saved_register (frame
, regnum
);
493 if (regnum
== SP_REGNUM
)
495 if (raw_buffer
!= NULL
)
497 /* Put it back in target format. */
498 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
), (LONGEST
) addr
);
504 if (raw_buffer
!= NULL
)
505 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
510 *lval
= lval_register
;
511 addr
= REGISTER_BYTE (regnum
);
512 if (raw_buffer
!= NULL
)
513 read_register_gen (regnum
, raw_buffer
);
519 #if !defined (GET_SAVED_REGISTER)
520 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
521 default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
524 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
528 struct frame_info
*frame
;
530 enum lval_type
*lval
;
532 GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
535 /* Copy the bytes of register REGNUM, relative to the input stack frame,
536 into our memory at MYADDR, in target byte order.
537 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
539 Returns 1 if could not be read, 0 if could. */
542 read_relative_register_raw_bytes_for_frame (regnum
, myaddr
, frame
)
545 struct frame_info
*frame
;
548 if (regnum
== FP_REGNUM
&& frame
)
550 /* Put it back in target format. */
551 store_address (myaddr
, REGISTER_RAW_SIZE (FP_REGNUM
),
552 (LONGEST
) FRAME_FP (frame
));
557 get_saved_register (myaddr
, &optim
, (CORE_ADDR
*) NULL
, frame
,
558 regnum
, (enum lval_type
*) NULL
);
560 if (register_valid
[regnum
] < 0)
561 return 1; /* register value not available */
566 /* Copy the bytes of register REGNUM, relative to the current stack frame,
567 into our memory at MYADDR, in target byte order.
568 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
570 Returns 1 if could not be read, 0 if could. */
573 read_relative_register_raw_bytes (regnum
, myaddr
)
577 return read_relative_register_raw_bytes_for_frame (regnum
, myaddr
,
581 /* Return a `value' with the contents of register REGNUM
582 in its virtual format, with the type specified by
583 REGISTER_VIRTUAL_TYPE.
585 NOTE: returns NULL if register value is not available.
586 Caller will check return value or die! */
589 value_of_register (regnum
)
594 register value_ptr reg_val
;
595 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
598 get_saved_register (raw_buffer
, &optim
, &addr
,
599 selected_frame
, regnum
, &lval
);
601 if (register_valid
[regnum
] < 0)
602 return NULL
; /* register value not available */
604 reg_val
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
606 /* Convert raw data to virtual format if necessary. */
608 if (REGISTER_CONVERTIBLE (regnum
))
610 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
611 raw_buffer
, VALUE_CONTENTS_RAW (reg_val
));
613 else if (REGISTER_RAW_SIZE (regnum
) == REGISTER_VIRTUAL_SIZE (regnum
))
614 memcpy (VALUE_CONTENTS_RAW (reg_val
), raw_buffer
,
615 REGISTER_RAW_SIZE (regnum
));
617 internal_error ("Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
618 REGISTER_NAME (regnum
),
620 REGISTER_RAW_SIZE (regnum
),
621 REGISTER_VIRTUAL_SIZE (regnum
));
622 VALUE_LVAL (reg_val
) = lval
;
623 VALUE_ADDRESS (reg_val
) = addr
;
624 VALUE_REGNO (reg_val
) = regnum
;
625 VALUE_OPTIMIZED_OUT (reg_val
) = optim
;
629 /* Low level examining and depositing of registers.
631 The caller is responsible for making
632 sure that the inferior is stopped before calling the fetching routines,
633 or it will get garbage. (a change from GDB version 3, in which
634 the caller got the value from the last stop). */
636 /* Contents and state of the registers (in target byte order). */
640 /* VALID_REGISTER is non-zero if it has been fetched, -1 if the
641 register value was not available. */
643 signed char *register_valid
;
645 /* The thread/process associated with the current set of registers. For now,
646 -1 is special, and means `no current process'. */
647 int registers_pid
= -1;
649 /* Indicate that registers may have changed, so invalidate the cache. */
655 int numregs
= ARCH_NUM_REGS
;
659 /* Force cleanup of any alloca areas if using C alloca instead of
660 a builtin alloca. This particular call is used to clean up
661 areas allocated by low level target code which may build up
662 during lengthy interactions between gdb and the target before
663 gdb gives control to the user (ie watchpoints). */
666 for (i
= 0; i
< numregs
; i
++)
667 register_valid
[i
] = 0;
669 if (registers_changed_hook
)
670 registers_changed_hook ();
673 /* Indicate that all registers have been fetched, so mark them all valid. */
678 int numregs
= ARCH_NUM_REGS
;
679 for (i
= 0; i
< numregs
; i
++)
680 register_valid
[i
] = 1;
683 /* read_register_bytes and write_register_bytes are generally a *BAD* idea.
684 They are inefficient because they need to check for partial updates, which
685 can only be done by scanning through all of the registers and seeing if the
686 bytes that are being read/written fall inside of an invalid register. [The
687 main reason this is necessary is that register sizes can vary, so a simple
688 index won't suffice.] It is far better to call read_register_gen if you
689 want to get at the raw register contents, as it only takes a regno as an
690 argument, and therefore can't do a partial register update. It would also
691 be good to have a write_register_gen for similar reasons.
693 Prior to the recent fixes to check for partial updates, both read and
694 write_register_bytes always checked to see if any registers were stale, and
695 then called target_fetch_registers (-1) to update the whole set. This
696 caused really slowed things down for remote targets. */
698 /* Copy INLEN bytes of consecutive data from registers
699 starting with the INREGBYTE'th byte of register data
700 into memory at MYADDR. */
703 read_register_bytes (inregbyte
, myaddr
, inlen
)
708 int inregend
= inregbyte
+ inlen
;
711 if (registers_pid
!= inferior_pid
)
713 registers_changed ();
714 registers_pid
= inferior_pid
;
717 /* See if we are trying to read bytes from out-of-date registers. If so,
718 update just those registers. */
720 for (regno
= 0; regno
< NUM_REGS
; regno
++)
722 int regstart
, regend
;
725 if (register_valid
[regno
])
728 if (REGISTER_NAME (regno
) == NULL
|| *REGISTER_NAME (regno
) == '\0')
731 regstart
= REGISTER_BYTE (regno
);
732 regend
= regstart
+ REGISTER_RAW_SIZE (regno
);
734 startin
= regstart
>= inregbyte
&& regstart
< inregend
;
735 endin
= regend
> inregbyte
&& regend
<= inregend
;
737 if (!startin
&& !endin
)
740 /* We've found an invalid register where at least one byte will be read.
741 Update it from the target. */
743 target_fetch_registers (regno
);
745 if (!register_valid
[regno
])
746 error ("read_register_bytes: Couldn't update register %d.", regno
);
750 memcpy (myaddr
, ®isters
[inregbyte
], inlen
);
753 /* Read register REGNO into memory at MYADDR, which must be large enough
754 for REGISTER_RAW_BYTES (REGNO). Target byte-order.
755 If the register is known to be the size of a CORE_ADDR or smaller,
756 read_register can be used instead. */
758 read_register_gen (regno
, myaddr
)
762 if (registers_pid
!= inferior_pid
)
764 registers_changed ();
765 registers_pid
= inferior_pid
;
768 if (!register_valid
[regno
])
769 target_fetch_registers (regno
);
770 memcpy (myaddr
, ®isters
[REGISTER_BYTE (regno
)],
771 REGISTER_RAW_SIZE (regno
));
774 /* Write register REGNO at MYADDR to the target. MYADDR points at
775 REGISTER_RAW_BYTES(REGNO), which must be in target byte-order. */
778 write_register_gen (regno
, myaddr
)
784 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
785 the registers array if something writes to this register. */
786 if (CANNOT_STORE_REGISTER (regno
))
789 if (registers_pid
!= inferior_pid
)
791 registers_changed ();
792 registers_pid
= inferior_pid
;
795 size
= REGISTER_RAW_SIZE (regno
);
797 /* If we have a valid copy of the register, and new value == old value,
798 then don't bother doing the actual store. */
800 if (register_valid
[regno
]
801 && memcmp (®isters
[REGISTER_BYTE (regno
)], myaddr
, size
) == 0)
804 target_prepare_to_store ();
806 memcpy (®isters
[REGISTER_BYTE (regno
)], myaddr
, size
);
808 register_valid
[regno
] = 1;
810 target_store_registers (regno
);
813 /* Copy INLEN bytes of consecutive data from memory at MYADDR
814 into registers starting with the MYREGSTART'th byte of register data. */
817 write_register_bytes (myregstart
, myaddr
, inlen
)
822 int myregend
= myregstart
+ inlen
;
825 target_prepare_to_store ();
827 /* Scan through the registers updating any that are covered by the range
828 myregstart<=>myregend using write_register_gen, which does nice things
829 like handling threads, and avoiding updates when the new and old contents
832 for (regno
= 0; regno
< NUM_REGS
; regno
++)
834 int regstart
, regend
;
836 char regbuf
[MAX_REGISTER_RAW_SIZE
];
838 regstart
= REGISTER_BYTE (regno
);
839 regend
= regstart
+ REGISTER_RAW_SIZE (regno
);
841 startin
= regstart
>= myregstart
&& regstart
< myregend
;
842 endin
= regend
> myregstart
&& regend
<= myregend
;
844 if (!startin
&& !endin
)
845 continue; /* Register is completely out of range */
847 if (startin
&& endin
) /* register is completely in range */
849 write_register_gen (regno
, myaddr
+ (regstart
- myregstart
));
853 /* We may be doing a partial update of an invalid register. Update it
854 from the target before scribbling on it. */
855 read_register_gen (regno
, regbuf
);
858 memcpy (registers
+ regstart
,
859 myaddr
+ regstart
- myregstart
,
860 myregend
- regstart
);
862 memcpy (registers
+ myregstart
,
864 regend
- myregstart
);
865 target_store_registers (regno
);
869 /* Return the raw contents of register REGNO, regarding it as an integer. */
870 /* This probably should be returning LONGEST rather than CORE_ADDR. */
873 read_register (regno
)
876 if (registers_pid
!= inferior_pid
)
878 registers_changed ();
879 registers_pid
= inferior_pid
;
882 if (!register_valid
[regno
])
883 target_fetch_registers (regno
);
885 return (CORE_ADDR
) extract_address (®isters
[REGISTER_BYTE (regno
)],
886 REGISTER_RAW_SIZE (regno
));
890 read_register_pid (regno
, pid
)
896 if (pid
== inferior_pid
)
897 return read_register (regno
);
899 save_pid
= inferior_pid
;
903 retval
= read_register (regno
);
905 inferior_pid
= save_pid
;
910 /* Store VALUE, into the raw contents of register number REGNO.
911 This should probably write a LONGEST rather than a CORE_ADDR */
914 write_register (regno
, val
)
921 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
922 the registers array if something writes to this register. */
923 if (CANNOT_STORE_REGISTER (regno
))
926 if (registers_pid
!= inferior_pid
)
928 registers_changed ();
929 registers_pid
= inferior_pid
;
932 size
= REGISTER_RAW_SIZE (regno
);
934 store_signed_integer (buf
, size
, (LONGEST
) val
);
936 /* If we have a valid copy of the register, and new value == old value,
937 then don't bother doing the actual store. */
939 if (register_valid
[regno
]
940 && memcmp (®isters
[REGISTER_BYTE (regno
)], buf
, size
) == 0)
943 target_prepare_to_store ();
945 memcpy (®isters
[REGISTER_BYTE (regno
)], buf
, size
);
947 register_valid
[regno
] = 1;
949 target_store_registers (regno
);
953 write_register_pid (regno
, val
, pid
)
960 if (pid
== inferior_pid
)
962 write_register (regno
, val
);
966 save_pid
= inferior_pid
;
970 write_register (regno
, val
);
972 inferior_pid
= save_pid
;
975 /* Record that register REGNO contains VAL.
976 This is used when the value is obtained from the inferior or core dump,
977 so there is no need to store the value there.
979 If VAL is a NULL pointer, then it's probably an unsupported register. We
980 just set it's value to all zeros. We might want to record this fact, and
981 report it to the users of read_register and friends.
985 supply_register (regno
, val
)
990 if (registers_pid
!= inferior_pid
)
992 registers_changed ();
993 registers_pid
= inferior_pid
;
997 register_valid
[regno
] = 1;
999 memcpy (®isters
[REGISTER_BYTE (regno
)], val
, REGISTER_RAW_SIZE (regno
));
1001 memset (®isters
[REGISTER_BYTE (regno
)], '\000', REGISTER_RAW_SIZE (regno
));
1003 /* On some architectures, e.g. HPPA, there are a few stray bits in some
1004 registers, that the rest of the code would like to ignore. */
1005 #ifdef CLEAN_UP_REGISTER_VALUE
1006 CLEAN_UP_REGISTER_VALUE (regno
, ®isters
[REGISTER_BYTE (regno
)]);
1011 /* This routine is getting awfully cluttered with #if's. It's probably
1012 time to turn this into READ_PC and define it in the tm.h file.
1015 1999-06-08: The following were re-written so that it assumes the
1016 existance of a TARGET_READ_PC et.al. macro. A default generic
1017 version of that macro is made available where needed.
1019 Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
1020 by the multi-arch framework, it will eventually be possible to
1021 eliminate the intermediate read_pc_pid(). The client would call
1022 TARGET_READ_PC directly. (cagney). */
1024 #ifndef TARGET_READ_PC
1025 #define TARGET_READ_PC generic_target_read_pc
1029 generic_target_read_pc (pid
)
1034 CORE_ADDR pc_val
= ADDR_BITS_REMOVE ((CORE_ADDR
) read_register_pid (PC_REGNUM
, pid
));
1038 internal_error ("generic_target_read_pc");
1046 int saved_inferior_pid
;
1049 /* In case pid != inferior_pid. */
1050 saved_inferior_pid
= inferior_pid
;
1053 pc_val
= TARGET_READ_PC (pid
);
1055 inferior_pid
= saved_inferior_pid
;
1062 return read_pc_pid (inferior_pid
);
1065 #ifndef TARGET_WRITE_PC
1066 #define TARGET_WRITE_PC generic_target_write_pc
1070 generic_target_write_pc (pc
, pid
)
1076 write_register_pid (PC_REGNUM
, pc
, pid
);
1078 if (NPC_REGNUM
>= 0)
1079 write_register_pid (NPC_REGNUM
, pc
+ 4, pid
);
1081 if (NNPC_REGNUM
>= 0)
1082 write_register_pid (NNPC_REGNUM
, pc
+ 8, pid
);
1086 internal_error ("generic_target_write_pc");
1091 write_pc_pid (pc
, pid
)
1095 int saved_inferior_pid
;
1097 /* In case pid != inferior_pid. */
1098 saved_inferior_pid
= inferior_pid
;
1101 TARGET_WRITE_PC (pc
, pid
);
1103 inferior_pid
= saved_inferior_pid
;
1110 write_pc_pid (pc
, inferior_pid
);
1113 /* Cope with strage ways of getting to the stack and frame pointers */
1115 #ifndef TARGET_READ_SP
1116 #define TARGET_READ_SP generic_target_read_sp
1120 generic_target_read_sp ()
1124 return read_register (SP_REGNUM
);
1126 internal_error ("generic_target_read_sp");
1132 return TARGET_READ_SP ();
1135 #ifndef TARGET_WRITE_SP
1136 #define TARGET_WRITE_SP generic_target_write_sp
1140 generic_target_write_sp (val
)
1146 write_register (SP_REGNUM
, val
);
1150 internal_error ("generic_target_write_sp");
1157 TARGET_WRITE_SP (val
);
1160 #ifndef TARGET_READ_FP
1161 #define TARGET_READ_FP generic_target_read_fp
1165 generic_target_read_fp ()
1169 return read_register (FP_REGNUM
);
1171 internal_error ("generic_target_read_fp");
1177 return TARGET_READ_FP ();
1180 #ifndef TARGET_WRITE_FP
1181 #define TARGET_WRITE_FP generic_target_write_fp
1185 generic_target_write_fp (val
)
1191 write_register (FP_REGNUM
, val
);
1195 internal_error ("generic_target_write_fp");
1202 TARGET_WRITE_FP (val
);
1205 /* Will calling read_var_value or locate_var_value on SYM end
1206 up caring what frame it is being evaluated relative to? SYM must
1209 symbol_read_needs_frame (sym
)
1212 switch (SYMBOL_CLASS (sym
))
1214 /* All cases listed explicitly so that gcc -Wall will detect it if
1215 we failed to consider one. */
1220 case LOC_REGPARM_ADDR
:
1224 case LOC_BASEREG_ARG
:
1225 case LOC_THREAD_LOCAL_STATIC
:
1235 /* Getting the address of a label can be done independently of the block,
1236 even if some *uses* of that address wouldn't work so well without
1240 case LOC_CONST_BYTES
:
1241 case LOC_UNRESOLVED
:
1242 case LOC_OPTIMIZED_OUT
:
1248 /* Given a struct symbol for a variable,
1249 and a stack frame id, read the value of the variable
1250 and return a (pointer to a) struct value containing the value.
1251 If the variable cannot be found, return a zero pointer.
1252 If FRAME is NULL, use the selected_frame. */
1255 read_var_value (var
, frame
)
1256 register struct symbol
*var
;
1257 struct frame_info
*frame
;
1259 register value_ptr v
;
1260 struct type
*type
= SYMBOL_TYPE (var
);
1264 v
= allocate_value (type
);
1265 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
1266 VALUE_BFD_SECTION (v
) = SYMBOL_BFD_SECTION (var
);
1268 len
= TYPE_LENGTH (type
);
1271 frame
= selected_frame
;
1273 switch (SYMBOL_CLASS (var
))
1276 /* Put the constant back in target format. */
1277 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
1278 (LONGEST
) SYMBOL_VALUE (var
));
1279 VALUE_LVAL (v
) = not_lval
;
1283 /* Put the constant back in target format. */
1284 if (overlay_debugging
)
1285 store_address (VALUE_CONTENTS_RAW (v
), len
,
1286 (LONGEST
) symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
1287 SYMBOL_BFD_SECTION (var
)));
1289 store_address (VALUE_CONTENTS_RAW (v
), len
,
1290 (LONGEST
) SYMBOL_VALUE_ADDRESS (var
));
1291 VALUE_LVAL (v
) = not_lval
;
1294 case LOC_CONST_BYTES
:
1297 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
1298 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
1299 VALUE_LVAL (v
) = not_lval
;
1304 if (overlay_debugging
)
1305 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
1306 SYMBOL_BFD_SECTION (var
));
1308 addr
= SYMBOL_VALUE_ADDRESS (var
);
1312 /* The import slot does not have a real address in it from the
1313 dynamic loader (dld.sl on HP-UX), if the target hasn't begun
1314 execution yet, so check for that. */
1315 if (!target_has_execution
)
1317 Attempt to access variable defined in different shared object or load module when\n\
1318 addresses have not been bound by the dynamic loader. Try again when executable is running.");
1320 addr
= SYMBOL_VALUE_ADDRESS (var
);
1321 addr
= read_memory_unsigned_integer
1322 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1328 addr
= FRAME_ARGS_ADDRESS (frame
);
1331 addr
+= SYMBOL_VALUE (var
);
1337 addr
= FRAME_ARGS_ADDRESS (frame
);
1340 addr
+= SYMBOL_VALUE (var
);
1341 addr
= read_memory_unsigned_integer
1342 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1349 addr
= FRAME_LOCALS_ADDRESS (frame
);
1350 addr
+= SYMBOL_VALUE (var
);
1354 case LOC_BASEREG_ARG
:
1356 char buf
[MAX_REGISTER_RAW_SIZE
];
1357 get_saved_register (buf
, NULL
, NULL
, frame
, SYMBOL_BASEREG (var
),
1359 addr
= extract_address (buf
, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var
)));
1360 addr
+= SYMBOL_VALUE (var
);
1364 case LOC_THREAD_LOCAL_STATIC
:
1366 char buf
[MAX_REGISTER_RAW_SIZE
];
1368 get_saved_register (buf
, NULL
, NULL
, frame
, SYMBOL_BASEREG (var
),
1370 addr
= extract_address (buf
, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var
)));
1371 addr
+= SYMBOL_VALUE (var
);
1376 error ("Cannot look up value of a typedef");
1380 if (overlay_debugging
)
1381 VALUE_ADDRESS (v
) = symbol_overlayed_address
1382 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
1384 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
1389 case LOC_REGPARM_ADDR
:
1392 int regno
= SYMBOL_VALUE (var
);
1397 b
= get_frame_block (frame
);
1399 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
1401 regval
= value_from_register (lookup_pointer_type (type
),
1406 error ("Value of register variable not available.");
1408 addr
= value_as_pointer (regval
);
1409 VALUE_LVAL (v
) = lval_memory
;
1413 regval
= value_from_register (type
, regno
, frame
);
1416 error ("Value of register variable not available.");
1422 case LOC_UNRESOLVED
:
1424 struct minimal_symbol
*msym
;
1426 msym
= lookup_minimal_symbol (SYMBOL_NAME (var
), NULL
, NULL
);
1429 if (overlay_debugging
)
1430 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
1431 SYMBOL_BFD_SECTION (msym
));
1433 addr
= SYMBOL_VALUE_ADDRESS (msym
);
1437 case LOC_OPTIMIZED_OUT
:
1438 VALUE_LVAL (v
) = not_lval
;
1439 VALUE_OPTIMIZED_OUT (v
) = 1;
1443 error ("Cannot look up value of a botched symbol.");
1447 VALUE_ADDRESS (v
) = addr
;
1452 /* Return a value of type TYPE, stored in register REGNUM, in frame
1455 NOTE: returns NULL if register value is not available.
1456 Caller will check return value or die! */
1459 value_from_register (type
, regnum
, frame
)
1462 struct frame_info
*frame
;
1464 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1467 value_ptr v
= allocate_value (type
);
1468 char *value_bytes
= 0;
1469 int value_bytes_copied
= 0;
1470 int num_storage_locs
;
1471 enum lval_type lval
;
1474 CHECK_TYPEDEF (type
);
1475 len
= TYPE_LENGTH (type
);
1477 VALUE_REGNO (v
) = regnum
;
1479 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
1480 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
1483 if (num_storage_locs
> 1
1484 #ifdef GDB_TARGET_IS_H8500
1485 || TYPE_CODE (type
) == TYPE_CODE_PTR
1489 /* Value spread across multiple storage locations. */
1492 int mem_stor
= 0, reg_stor
= 0;
1493 int mem_tracking
= 1;
1494 CORE_ADDR last_addr
= 0;
1495 CORE_ADDR first_addr
= 0;
1497 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
1499 /* Copy all of the data out, whereever it may be. */
1501 #ifdef GDB_TARGET_IS_H8500
1502 /* This piece of hideosity is required because the H8500 treats registers
1503 differently depending upon whether they are used as pointers or not. As a
1504 pointer, a register needs to have a page register tacked onto the front.
1505 An alternate way to do this would be to have gcc output different register
1506 numbers for the pointer & non-pointer form of the register. But, it
1507 doesn't, so we're stuck with this. */
1509 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1520 page_regnum
= SEG_D_REGNUM
;
1524 page_regnum
= SEG_E_REGNUM
;
1528 page_regnum
= SEG_T_REGNUM
;
1533 get_saved_register (value_bytes
+ 1,
1540 if (register_valid
[page_regnum
] == -1)
1541 return NULL
; /* register value not available */
1543 if (lval
== lval_register
)
1550 get_saved_register (value_bytes
+ 2,
1557 if (register_valid
[regnum
] == -1)
1558 return NULL
; /* register value not available */
1560 if (lval
== lval_register
)
1565 mem_tracking
= mem_tracking
&& (addr
== last_addr
);
1570 #endif /* GDB_TARGET_IS_H8500 */
1571 for (local_regnum
= regnum
;
1572 value_bytes_copied
< len
;
1573 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
1576 get_saved_register (value_bytes
+ value_bytes_copied
,
1583 if (register_valid
[local_regnum
] == -1)
1584 return NULL
; /* register value not available */
1586 if (regnum
== local_regnum
)
1588 if (lval
== lval_register
)
1596 && (regnum
== local_regnum
1597 || addr
== last_addr
));
1602 if ((reg_stor
&& mem_stor
)
1603 || (mem_stor
&& !mem_tracking
))
1604 /* Mixed storage; all of the hassle we just went through was
1605 for some good purpose. */
1607 VALUE_LVAL (v
) = lval_reg_frame_relative
;
1608 VALUE_FRAME (v
) = FRAME_FP (frame
);
1609 VALUE_FRAME_REGNUM (v
) = regnum
;
1613 VALUE_LVAL (v
) = lval_memory
;
1614 VALUE_ADDRESS (v
) = first_addr
;
1618 VALUE_LVAL (v
) = lval_register
;
1619 VALUE_ADDRESS (v
) = first_addr
;
1622 internal_error ("value_from_register: Value not stored anywhere!");
1624 VALUE_OPTIMIZED_OUT (v
) = optim
;
1626 /* Any structure stored in more than one register will always be
1627 an integral number of registers. Otherwise, you'd need to do
1628 some fiddling with the last register copied here for little
1631 /* Copy into the contents section of the value. */
1632 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
1634 /* Finally do any conversion necessary when extracting this
1635 type from more than one register. */
1636 #ifdef REGISTER_CONVERT_TO_TYPE
1637 REGISTER_CONVERT_TO_TYPE (regnum
, type
, VALUE_CONTENTS_RAW (v
));
1642 /* Data is completely contained within a single register. Locate the
1643 register's contents in a real register or in core;
1644 read the data in raw format. */
1646 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
1648 if (register_valid
[regnum
] == -1)
1649 return NULL
; /* register value not available */
1651 VALUE_OPTIMIZED_OUT (v
) = optim
;
1652 VALUE_LVAL (v
) = lval
;
1653 VALUE_ADDRESS (v
) = addr
;
1655 /* Convert raw data to virtual format if necessary. */
1657 if (REGISTER_CONVERTIBLE (regnum
))
1659 REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
,
1660 raw_buffer
, VALUE_CONTENTS_RAW (v
));
1664 /* Raw and virtual formats are the same for this register. */
1666 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
&& len
< REGISTER_RAW_SIZE (regnum
))
1668 /* Big-endian, and we want less than full size. */
1669 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
1672 memcpy (VALUE_CONTENTS_RAW (v
), raw_buffer
+ VALUE_OFFSET (v
), len
);
1678 /* Given a struct symbol for a variable or function,
1679 and a stack frame id,
1680 return a (pointer to a) struct value containing the properly typed
1684 locate_var_value (var
, frame
)
1685 register struct symbol
*var
;
1686 struct frame_info
*frame
;
1689 struct type
*type
= SYMBOL_TYPE (var
);
1690 value_ptr lazy_value
;
1692 /* Evaluate it first; if the result is a memory address, we're fine.
1693 Lazy evaluation pays off here. */
1695 lazy_value
= read_var_value (var
, frame
);
1696 if (lazy_value
== 0)
1697 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
1699 if (VALUE_LAZY (lazy_value
)
1700 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1704 addr
= VALUE_ADDRESS (lazy_value
);
1705 val
= value_from_longest (lookup_pointer_type (type
), (LONGEST
) addr
);
1706 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
1710 /* Not a memory address; check what the problem was. */
1711 switch (VALUE_LVAL (lazy_value
))
1714 case lval_reg_frame_relative
:
1715 error ("Address requested for identifier \"%s\" which is in a register.",
1716 SYMBOL_SOURCE_NAME (var
));
1720 error ("Can't take address of \"%s\" which isn't an lvalue.",
1721 SYMBOL_SOURCE_NAME (var
));
1724 return 0; /* For lint -- never reached */
1728 static void build_findvar
PARAMS ((void));
1732 /* We allocate some extra slop since we do a lot of memcpy's around
1733 `registers', and failing-soft is better than failing hard. */
1734 int sizeof_registers
= REGISTER_BYTES
+ /* SLOP */ 256;
1735 int sizeof_register_valid
= NUM_REGS
* sizeof (*register_valid
);
1736 registers
= xmalloc (sizeof_registers
);
1737 memset (registers
, 0, sizeof_registers
);
1738 register_valid
= xmalloc (sizeof_register_valid
);
1739 memset (register_valid
, 0, sizeof_register_valid
);
1742 void _initialize_findvar
PARAMS ((void));
1744 _initialize_findvar ()
1748 register_gdbarch_swap (®isters
, sizeof (registers
), NULL
);
1749 register_gdbarch_swap (®ister_valid
, sizeof (register_valid
), NULL
);
1750 register_gdbarch_swap (NULL
, 0, build_findvar
);