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 (void *addr
, int len
)
65 unsigned char *startaddr
= (unsigned char *) addr
;
66 unsigned char *endaddr
= startaddr
+ len
;
68 if (len
> (int) sizeof (LONGEST
))
70 That operation is not available on integers of more than %d bytes.",
73 /* Start at the most significant end of the integer, and work towards
74 the least significant. */
75 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
78 /* Do the sign extension once at the start. */
79 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
80 for (++p
; p
< endaddr
; ++p
)
81 retval
= (retval
<< 8) | *p
;
86 /* Do the sign extension once at the start. */
87 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
88 for (--p
; p
>= startaddr
; --p
)
89 retval
= (retval
<< 8) | *p
;
95 extract_unsigned_integer (void *addr
, int len
)
99 unsigned char *startaddr
= (unsigned char *) addr
;
100 unsigned char *endaddr
= startaddr
+ len
;
102 if (len
> (int) sizeof (ULONGEST
))
104 That operation is not available on integers of more than %d bytes.",
107 /* Start at the most significant end of the integer, and work towards
108 the least significant. */
110 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
112 for (p
= startaddr
; p
< endaddr
; ++p
)
113 retval
= (retval
<< 8) | *p
;
117 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
118 retval
= (retval
<< 8) | *p
;
123 /* Sometimes a long long unsigned integer can be extracted as a
124 LONGEST value. This is done so that we can print these values
125 better. If this integer can be converted to a LONGEST, this
126 function returns 1 and sets *PVAL. Otherwise it returns 0. */
129 extract_long_unsigned_integer (void *addr
, int orig_len
, LONGEST
*pval
)
131 char *p
, *first_addr
;
135 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
137 for (p
= (char *) addr
;
138 len
> (int) sizeof (LONGEST
) && p
< (char *) addr
+ orig_len
;
150 first_addr
= (char *) addr
;
151 for (p
= (char *) addr
+ orig_len
- 1;
152 len
> (int) sizeof (LONGEST
) && p
>= (char *) addr
;
162 if (len
<= (int) sizeof (LONGEST
))
164 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
173 extract_address (void *addr
, int len
)
175 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
176 whether we want this to be true eventually. */
177 return (CORE_ADDR
) extract_unsigned_integer (addr
, len
);
181 store_signed_integer (void *addr
, int len
, LONGEST val
)
184 unsigned char *startaddr
= (unsigned char *) addr
;
185 unsigned char *endaddr
= startaddr
+ len
;
187 /* Start at the least significant end of the integer, and work towards
188 the most significant. */
189 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
191 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
199 for (p
= startaddr
; p
< endaddr
; ++p
)
208 store_unsigned_integer (void *addr
, int len
, ULONGEST val
)
211 unsigned char *startaddr
= (unsigned char *) addr
;
212 unsigned char *endaddr
= startaddr
+ len
;
214 /* Start at the least significant end of the integer, and work towards
215 the most significant. */
216 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
218 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
226 for (p
= startaddr
; p
< endaddr
; ++p
)
234 /* Store the literal address "val" into
235 gdb-local memory pointed to by "addr"
238 store_address (void *addr
, int len
, LONGEST val
)
240 store_unsigned_integer (addr
, len
, val
);
243 /* Extract a floating-point number from a target-order byte-stream at ADDR.
244 Returns the value as type DOUBLEST.
246 If the host and target formats agree, we just copy the raw data into the
247 appropriate type of variable and return, letting the host increase precision
248 as necessary. Otherwise, we call the conversion routine and let it do the
252 extract_floating (void *addr
, int len
)
256 if (len
* TARGET_CHAR_BIT
== TARGET_FLOAT_BIT
)
258 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
262 memcpy (&retval
, addr
, sizeof (retval
));
266 floatformat_to_doublest (TARGET_FLOAT_FORMAT
, addr
, &dretval
);
268 else if (len
* TARGET_CHAR_BIT
== TARGET_DOUBLE_BIT
)
270 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
274 memcpy (&retval
, addr
, sizeof (retval
));
278 floatformat_to_doublest (TARGET_DOUBLE_FORMAT
, addr
, &dretval
);
280 else if (len
* TARGET_CHAR_BIT
== TARGET_LONG_DOUBLE_BIT
)
282 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
286 memcpy (&retval
, addr
, sizeof (retval
));
290 floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT
, addr
, &dretval
);
294 error ("Can't deal with a floating point number of %d bytes.", len
);
301 store_floating (void *addr
, int len
, DOUBLEST val
)
303 if (len
* TARGET_CHAR_BIT
== TARGET_FLOAT_BIT
)
305 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
307 float floatval
= val
;
309 memcpy (addr
, &floatval
, sizeof (floatval
));
312 floatformat_from_doublest (TARGET_FLOAT_FORMAT
, &val
, addr
);
314 else if (len
* TARGET_CHAR_BIT
== TARGET_DOUBLE_BIT
)
316 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
318 double doubleval
= val
;
320 memcpy (addr
, &doubleval
, sizeof (doubleval
));
323 floatformat_from_doublest (TARGET_DOUBLE_FORMAT
, &val
, addr
);
325 else if (len
* TARGET_CHAR_BIT
== TARGET_LONG_DOUBLE_BIT
)
327 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
328 memcpy (addr
, &val
, sizeof (val
));
330 floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT
, &val
, addr
);
334 error ("Can't deal with a floating point number of %d bytes.", len
);
339 /* Return the address in which frame FRAME's value of register REGNUM
340 has been saved in memory. Or return zero if it has not been saved.
341 If REGNUM specifies the SP, the value we return is actually
342 the SP value, not an address where it was saved. */
345 find_saved_register (frame
, regnum
)
346 struct frame_info
*frame
;
349 register struct frame_info
*frame1
= NULL
;
350 register CORE_ADDR addr
= 0;
352 if (frame
== NULL
) /* No regs saved if want current frame */
355 #ifdef HAVE_REGISTER_WINDOWS
356 /* We assume that a register in a register window will only be saved
357 in one place (since the name changes and/or disappears as you go
358 towards inner frames), so we only call get_frame_saved_regs on
359 the current frame. This is directly in contradiction to the
360 usage below, which assumes that registers used in a frame must be
361 saved in a lower (more interior) frame. This change is a result
362 of working on a register window machine; get_frame_saved_regs
363 always returns the registers saved within a frame, within the
364 context (register namespace) of that frame. */
366 /* However, note that we don't want this to return anything if
367 nothing is saved (if there's a frame inside of this one). Also,
368 callers to this routine asking for the stack pointer want the
369 stack pointer saved for *this* frame; this is returned from the
372 if (REGISTER_IN_WINDOW_P (regnum
))
374 frame1
= get_next_frame (frame
);
376 return 0; /* Registers of this frame are active. */
378 /* Get the SP from the next frame in; it will be this
380 if (regnum
!= SP_REGNUM
)
383 FRAME_INIT_SAVED_REGS (frame1
);
384 return frame1
->saved_regs
[regnum
]; /* ... which might be zero */
386 #endif /* HAVE_REGISTER_WINDOWS */
388 /* Note that this next routine assumes that registers used in
389 frame x will be saved only in the frame that x calls and
390 frames interior to it. This is not true on the sparc, but the
391 above macro takes care of it, so we should be all right. */
395 frame1
= get_prev_frame (frame1
);
396 if (frame1
== 0 || frame1
== frame
)
398 FRAME_INIT_SAVED_REGS (frame1
);
399 if (frame1
->saved_regs
[regnum
])
400 addr
= frame1
->saved_regs
[regnum
];
406 /* Find register number REGNUM relative to FRAME and put its (raw,
407 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
408 variable was optimized out (and thus can't be fetched). Set *LVAL
409 to lval_memory, lval_register, or not_lval, depending on whether
410 the value was fetched from memory, from a register, or in a strange
411 and non-modifiable way (e.g. a frame pointer which was calculated
412 rather than fetched). Set *ADDRP to the address, either in memory
413 on as a REGISTER_BYTE offset into the registers array.
415 Note that this implementation never sets *LVAL to not_lval. But
416 it can be replaced by defining GET_SAVED_REGISTER and supplying
419 The argument RAW_BUFFER must point to aligned memory. */
422 default_get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
426 struct frame_info
*frame
;
428 enum lval_type
*lval
;
432 if (!target_has_registers
)
433 error ("No registers.");
435 /* Normal systems don't optimize out things with register numbers. */
436 if (optimized
!= NULL
)
438 addr
= find_saved_register (frame
, regnum
);
443 if (regnum
== SP_REGNUM
)
445 if (raw_buffer
!= NULL
)
447 /* Put it back in target format. */
448 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
), (LONGEST
) addr
);
454 if (raw_buffer
!= NULL
)
455 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
460 *lval
= lval_register
;
461 addr
= REGISTER_BYTE (regnum
);
462 if (raw_buffer
!= NULL
)
463 read_register_gen (regnum
, raw_buffer
);
469 #if !defined (GET_SAVED_REGISTER)
470 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
471 default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
474 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
478 struct frame_info
*frame
;
480 enum lval_type
*lval
;
482 GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
485 /* Copy the bytes of register REGNUM, relative to the input stack frame,
486 into our memory at MYADDR, in target byte order.
487 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
489 Returns 1 if could not be read, 0 if could. */
492 read_relative_register_raw_bytes_for_frame (regnum
, myaddr
, frame
)
495 struct frame_info
*frame
;
498 if (regnum
== FP_REGNUM
&& frame
)
500 /* Put it back in target format. */
501 store_address (myaddr
, REGISTER_RAW_SIZE (FP_REGNUM
),
502 (LONGEST
) FRAME_FP (frame
));
507 get_saved_register (myaddr
, &optim
, (CORE_ADDR
*) NULL
, frame
,
508 regnum
, (enum lval_type
*) NULL
);
510 if (register_valid
[regnum
] < 0)
511 return 1; /* register value not available */
516 /* Copy the bytes of register REGNUM, relative to the current stack frame,
517 into our memory at MYADDR, in target byte order.
518 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
520 Returns 1 if could not be read, 0 if could. */
523 read_relative_register_raw_bytes (regnum
, myaddr
)
527 return read_relative_register_raw_bytes_for_frame (regnum
, myaddr
,
531 /* Return a `value' with the contents of register REGNUM
532 in its virtual format, with the type specified by
533 REGISTER_VIRTUAL_TYPE.
535 NOTE: returns NULL if register value is not available.
536 Caller will check return value or die! */
539 value_of_register (regnum
)
544 register value_ptr reg_val
;
545 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
548 get_saved_register (raw_buffer
, &optim
, &addr
,
549 selected_frame
, regnum
, &lval
);
551 if (register_valid
[regnum
] < 0)
552 return NULL
; /* register value not available */
554 reg_val
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
556 /* Convert raw data to virtual format if necessary. */
558 if (REGISTER_CONVERTIBLE (regnum
))
560 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
561 raw_buffer
, VALUE_CONTENTS_RAW (reg_val
));
563 else if (REGISTER_RAW_SIZE (regnum
) == REGISTER_VIRTUAL_SIZE (regnum
))
564 memcpy (VALUE_CONTENTS_RAW (reg_val
), raw_buffer
,
565 REGISTER_RAW_SIZE (regnum
));
567 internal_error ("Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
568 REGISTER_NAME (regnum
),
570 REGISTER_RAW_SIZE (regnum
),
571 REGISTER_VIRTUAL_SIZE (regnum
));
572 VALUE_LVAL (reg_val
) = lval
;
573 VALUE_ADDRESS (reg_val
) = addr
;
574 VALUE_REGNO (reg_val
) = regnum
;
575 VALUE_OPTIMIZED_OUT (reg_val
) = optim
;
579 /* Low level examining and depositing of registers.
581 The caller is responsible for making
582 sure that the inferior is stopped before calling the fetching routines,
583 or it will get garbage. (a change from GDB version 3, in which
584 the caller got the value from the last stop). */
586 /* Contents and state of the registers (in target byte order). */
590 /* VALID_REGISTER is non-zero if it has been fetched, -1 if the
591 register value was not available. */
593 signed char *register_valid
;
595 /* The thread/process associated with the current set of registers. For now,
596 -1 is special, and means `no current process'. */
597 int registers_pid
= -1;
599 /* Indicate that registers may have changed, so invalidate the cache. */
605 int numregs
= ARCH_NUM_REGS
;
609 /* Force cleanup of any alloca areas if using C alloca instead of
610 a builtin alloca. This particular call is used to clean up
611 areas allocated by low level target code which may build up
612 during lengthy interactions between gdb and the target before
613 gdb gives control to the user (ie watchpoints). */
616 for (i
= 0; i
< numregs
; i
++)
617 register_valid
[i
] = 0;
619 if (registers_changed_hook
)
620 registers_changed_hook ();
623 /* Indicate that all registers have been fetched, so mark them all valid. */
628 int numregs
= ARCH_NUM_REGS
;
629 for (i
= 0; i
< numregs
; i
++)
630 register_valid
[i
] = 1;
633 /* read_register_bytes and write_register_bytes are generally a *BAD*
634 idea. They are inefficient because they need to check for partial
635 updates, which can only be done by scanning through all of the
636 registers and seeing if the bytes that are being read/written fall
637 inside of an invalid register. [The main reason this is necessary
638 is that register sizes can vary, so a simple index won't suffice.]
639 It is far better to call read_register_gen and write_register_gen
640 if you want to get at the raw register contents, as it only takes a
641 regno as an argument, and therefore can't do a partial register
644 Prior to the recent fixes to check for partial updates, both read
645 and write_register_bytes always checked to see if any registers
646 were stale, and then called target_fetch_registers (-1) to update
647 the whole set. This caused really slowed things down for remote
650 /* Copy INLEN bytes of consecutive data from registers
651 starting with the INREGBYTE'th byte of register data
652 into memory at MYADDR. */
655 read_register_bytes (inregbyte
, myaddr
, inlen
)
660 int inregend
= inregbyte
+ inlen
;
663 if (registers_pid
!= inferior_pid
)
665 registers_changed ();
666 registers_pid
= inferior_pid
;
669 /* See if we are trying to read bytes from out-of-date registers. If so,
670 update just those registers. */
672 for (regno
= 0; regno
< NUM_REGS
; regno
++)
674 int regstart
, regend
;
676 if (register_valid
[regno
])
679 if (REGISTER_NAME (regno
) == NULL
|| *REGISTER_NAME (regno
) == '\0')
682 regstart
= REGISTER_BYTE (regno
);
683 regend
= regstart
+ REGISTER_RAW_SIZE (regno
);
685 if (regend
<= inregbyte
|| inregend
<= regstart
)
686 /* The range the user wants to read doesn't overlap with regno. */
689 /* We've found an invalid register where at least one byte will be read.
690 Update it from the target. */
691 target_fetch_registers (regno
);
693 if (!register_valid
[regno
])
694 error ("read_register_bytes: Couldn't update register %d.", regno
);
698 memcpy (myaddr
, ®isters
[inregbyte
], inlen
);
701 /* Read register REGNO into memory at MYADDR, which must be large enough
702 for REGISTER_RAW_BYTES (REGNO). Target byte-order.
703 If the register is known to be the size of a CORE_ADDR or smaller,
704 read_register can be used instead. */
706 read_register_gen (regno
, myaddr
)
710 if (registers_pid
!= inferior_pid
)
712 registers_changed ();
713 registers_pid
= inferior_pid
;
716 if (!register_valid
[regno
])
717 target_fetch_registers (regno
);
718 memcpy (myaddr
, ®isters
[REGISTER_BYTE (regno
)],
719 REGISTER_RAW_SIZE (regno
));
722 /* Write register REGNO at MYADDR to the target. MYADDR points at
723 REGISTER_RAW_BYTES(REGNO), which must be in target byte-order. */
726 write_register_gen (regno
, myaddr
)
732 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
733 the registers array if something writes to this register. */
734 if (CANNOT_STORE_REGISTER (regno
))
737 if (registers_pid
!= inferior_pid
)
739 registers_changed ();
740 registers_pid
= inferior_pid
;
743 size
= REGISTER_RAW_SIZE (regno
);
745 /* If we have a valid copy of the register, and new value == old value,
746 then don't bother doing the actual store. */
748 if (register_valid
[regno
]
749 && memcmp (®isters
[REGISTER_BYTE (regno
)], myaddr
, size
) == 0)
752 target_prepare_to_store ();
754 memcpy (®isters
[REGISTER_BYTE (regno
)], myaddr
, size
);
756 register_valid
[regno
] = 1;
758 target_store_registers (regno
);
761 /* Copy INLEN bytes of consecutive data from memory at MYADDR
762 into registers starting with the MYREGSTART'th byte of register data. */
765 write_register_bytes (myregstart
, myaddr
, inlen
)
770 int myregend
= myregstart
+ inlen
;
773 target_prepare_to_store ();
775 /* Scan through the registers updating any that are covered by the range
776 myregstart<=>myregend using write_register_gen, which does nice things
777 like handling threads, and avoiding updates when the new and old contents
780 for (regno
= 0; regno
< NUM_REGS
; regno
++)
782 int regstart
, regend
;
784 regstart
= REGISTER_BYTE (regno
);
785 regend
= regstart
+ REGISTER_RAW_SIZE (regno
);
787 /* Is this register completely outside the range the user is writing? */
788 if (myregend
<= regstart
|| regend
<= myregstart
)
791 /* Is this register completely within the range the user is writing? */
792 else if (myregstart
<= regstart
&& regend
<= myregend
)
793 write_register_gen (regno
, myaddr
+ (regstart
- myregstart
));
795 /* The register partially overlaps the range being written. */
798 char regbuf
[MAX_REGISTER_RAW_SIZE
];
799 /* What's the overlap between this register's bytes and
800 those the caller wants to write? */
801 int overlapstart
= max (regstart
, myregstart
);
802 int overlapend
= min (regend
, myregend
);
804 /* We may be doing a partial update of an invalid register.
805 Update it from the target before scribbling on it. */
806 read_register_gen (regno
, regbuf
);
808 memcpy (registers
+ overlapstart
,
809 myaddr
+ (overlapstart
- myregstart
),
810 overlapend
- overlapstart
);
812 target_store_registers (regno
);
818 /* Return the raw contents of register REGNO, regarding it as an integer. */
819 /* This probably should be returning LONGEST rather than CORE_ADDR. */
822 read_register (regno
)
825 if (registers_pid
!= inferior_pid
)
827 registers_changed ();
828 registers_pid
= inferior_pid
;
831 if (!register_valid
[regno
])
832 target_fetch_registers (regno
);
834 return (CORE_ADDR
) extract_address (®isters
[REGISTER_BYTE (regno
)],
835 REGISTER_RAW_SIZE (regno
));
839 read_register_pid (regno
, pid
)
845 if (pid
== inferior_pid
)
846 return read_register (regno
);
848 save_pid
= inferior_pid
;
852 retval
= read_register (regno
);
854 inferior_pid
= save_pid
;
859 /* Store VALUE, into the raw contents of register number REGNO.
860 This should probably write a LONGEST rather than a CORE_ADDR */
863 write_register (regno
, val
)
870 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
871 the registers array if something writes to this register. */
872 if (CANNOT_STORE_REGISTER (regno
))
875 if (registers_pid
!= inferior_pid
)
877 registers_changed ();
878 registers_pid
= inferior_pid
;
881 size
= REGISTER_RAW_SIZE (regno
);
883 store_signed_integer (buf
, size
, (LONGEST
) val
);
885 /* If we have a valid copy of the register, and new value == old value,
886 then don't bother doing the actual store. */
888 if (register_valid
[regno
]
889 && memcmp (®isters
[REGISTER_BYTE (regno
)], buf
, size
) == 0)
892 target_prepare_to_store ();
894 memcpy (®isters
[REGISTER_BYTE (regno
)], buf
, size
);
896 register_valid
[regno
] = 1;
898 target_store_registers (regno
);
902 write_register_pid (regno
, val
, pid
)
909 if (pid
== inferior_pid
)
911 write_register (regno
, val
);
915 save_pid
= inferior_pid
;
919 write_register (regno
, val
);
921 inferior_pid
= save_pid
;
924 /* Record that register REGNO contains VAL.
925 This is used when the value is obtained from the inferior or core dump,
926 so there is no need to store the value there.
928 If VAL is a NULL pointer, then it's probably an unsupported register. We
929 just set it's value to all zeros. We might want to record this fact, and
930 report it to the users of read_register and friends.
934 supply_register (regno
, val
)
939 if (registers_pid
!= inferior_pid
)
941 registers_changed ();
942 registers_pid
= inferior_pid
;
946 register_valid
[regno
] = 1;
948 memcpy (®isters
[REGISTER_BYTE (regno
)], val
, REGISTER_RAW_SIZE (regno
));
950 memset (®isters
[REGISTER_BYTE (regno
)], '\000', REGISTER_RAW_SIZE (regno
));
952 /* On some architectures, e.g. HPPA, there are a few stray bits in some
953 registers, that the rest of the code would like to ignore. */
954 #ifdef CLEAN_UP_REGISTER_VALUE
955 CLEAN_UP_REGISTER_VALUE (regno
, ®isters
[REGISTER_BYTE (regno
)]);
960 /* This routine is getting awfully cluttered with #if's. It's probably
961 time to turn this into READ_PC and define it in the tm.h file.
964 1999-06-08: The following were re-written so that it assumes the
965 existance of a TARGET_READ_PC et.al. macro. A default generic
966 version of that macro is made available where needed.
968 Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
969 by the multi-arch framework, it will eventually be possible to
970 eliminate the intermediate read_pc_pid(). The client would call
971 TARGET_READ_PC directly. (cagney). */
973 #ifndef TARGET_READ_PC
974 #define TARGET_READ_PC generic_target_read_pc
978 generic_target_read_pc (int pid
)
983 CORE_ADDR pc_val
= ADDR_BITS_REMOVE ((CORE_ADDR
) read_register_pid (PC_REGNUM
, pid
));
987 internal_error ("generic_target_read_pc");
995 int saved_inferior_pid
;
998 /* In case pid != inferior_pid. */
999 saved_inferior_pid
= inferior_pid
;
1002 pc_val
= TARGET_READ_PC (pid
);
1004 inferior_pid
= saved_inferior_pid
;
1011 return read_pc_pid (inferior_pid
);
1014 #ifndef TARGET_WRITE_PC
1015 #define TARGET_WRITE_PC generic_target_write_pc
1019 generic_target_write_pc (pc
, pid
)
1025 write_register_pid (PC_REGNUM
, pc
, pid
);
1027 if (NPC_REGNUM
>= 0)
1028 write_register_pid (NPC_REGNUM
, pc
+ 4, pid
);
1030 if (NNPC_REGNUM
>= 0)
1031 write_register_pid (NNPC_REGNUM
, pc
+ 8, pid
);
1035 internal_error ("generic_target_write_pc");
1040 write_pc_pid (pc
, pid
)
1044 int saved_inferior_pid
;
1046 /* In case pid != inferior_pid. */
1047 saved_inferior_pid
= inferior_pid
;
1050 TARGET_WRITE_PC (pc
, pid
);
1052 inferior_pid
= saved_inferior_pid
;
1059 write_pc_pid (pc
, inferior_pid
);
1062 /* Cope with strage ways of getting to the stack and frame pointers */
1064 #ifndef TARGET_READ_SP
1065 #define TARGET_READ_SP generic_target_read_sp
1069 generic_target_read_sp ()
1073 return read_register (SP_REGNUM
);
1075 internal_error ("generic_target_read_sp");
1081 return TARGET_READ_SP ();
1084 #ifndef TARGET_WRITE_SP
1085 #define TARGET_WRITE_SP generic_target_write_sp
1089 generic_target_write_sp (val
)
1095 write_register (SP_REGNUM
, val
);
1099 internal_error ("generic_target_write_sp");
1106 TARGET_WRITE_SP (val
);
1109 #ifndef TARGET_READ_FP
1110 #define TARGET_READ_FP generic_target_read_fp
1114 generic_target_read_fp ()
1118 return read_register (FP_REGNUM
);
1120 internal_error ("generic_target_read_fp");
1126 return TARGET_READ_FP ();
1129 #ifndef TARGET_WRITE_FP
1130 #define TARGET_WRITE_FP generic_target_write_fp
1134 generic_target_write_fp (val
)
1140 write_register (FP_REGNUM
, val
);
1144 internal_error ("generic_target_write_fp");
1151 TARGET_WRITE_FP (val
);
1154 /* Will calling read_var_value or locate_var_value on SYM end
1155 up caring what frame it is being evaluated relative to? SYM must
1158 symbol_read_needs_frame (sym
)
1161 switch (SYMBOL_CLASS (sym
))
1163 /* All cases listed explicitly so that gcc -Wall will detect it if
1164 we failed to consider one. */
1169 case LOC_REGPARM_ADDR
:
1173 case LOC_BASEREG_ARG
:
1174 case LOC_THREAD_LOCAL_STATIC
:
1184 /* Getting the address of a label can be done independently of the block,
1185 even if some *uses* of that address wouldn't work so well without
1189 case LOC_CONST_BYTES
:
1190 case LOC_UNRESOLVED
:
1191 case LOC_OPTIMIZED_OUT
:
1197 /* Given a struct symbol for a variable,
1198 and a stack frame id, read the value of the variable
1199 and return a (pointer to a) struct value containing the value.
1200 If the variable cannot be found, return a zero pointer.
1201 If FRAME is NULL, use the selected_frame. */
1204 read_var_value (var
, frame
)
1205 register struct symbol
*var
;
1206 struct frame_info
*frame
;
1208 register value_ptr v
;
1209 struct type
*type
= SYMBOL_TYPE (var
);
1213 v
= allocate_value (type
);
1214 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
1215 VALUE_BFD_SECTION (v
) = SYMBOL_BFD_SECTION (var
);
1217 len
= TYPE_LENGTH (type
);
1220 frame
= selected_frame
;
1222 switch (SYMBOL_CLASS (var
))
1225 /* Put the constant back in target format. */
1226 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
1227 (LONGEST
) SYMBOL_VALUE (var
));
1228 VALUE_LVAL (v
) = not_lval
;
1232 /* Put the constant back in target format. */
1233 if (overlay_debugging
)
1234 store_address (VALUE_CONTENTS_RAW (v
), len
,
1235 (LONGEST
) symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
1236 SYMBOL_BFD_SECTION (var
)));
1238 store_address (VALUE_CONTENTS_RAW (v
), len
,
1239 (LONGEST
) SYMBOL_VALUE_ADDRESS (var
));
1240 VALUE_LVAL (v
) = not_lval
;
1243 case LOC_CONST_BYTES
:
1246 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
1247 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
1248 VALUE_LVAL (v
) = not_lval
;
1253 if (overlay_debugging
)
1254 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
1255 SYMBOL_BFD_SECTION (var
));
1257 addr
= SYMBOL_VALUE_ADDRESS (var
);
1261 /* The import slot does not have a real address in it from the
1262 dynamic loader (dld.sl on HP-UX), if the target hasn't begun
1263 execution yet, so check for that. */
1264 if (!target_has_execution
)
1266 Attempt to access variable defined in different shared object or load module when\n\
1267 addresses have not been bound by the dynamic loader. Try again when executable is running.");
1269 addr
= SYMBOL_VALUE_ADDRESS (var
);
1270 addr
= read_memory_unsigned_integer
1271 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1277 addr
= FRAME_ARGS_ADDRESS (frame
);
1280 addr
+= SYMBOL_VALUE (var
);
1286 addr
= FRAME_ARGS_ADDRESS (frame
);
1289 addr
+= SYMBOL_VALUE (var
);
1290 addr
= read_memory_unsigned_integer
1291 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1298 addr
= FRAME_LOCALS_ADDRESS (frame
);
1299 addr
+= SYMBOL_VALUE (var
);
1303 case LOC_BASEREG_ARG
:
1305 char buf
[MAX_REGISTER_RAW_SIZE
];
1306 get_saved_register (buf
, NULL
, NULL
, frame
, SYMBOL_BASEREG (var
),
1308 addr
= extract_address (buf
, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var
)));
1309 addr
+= SYMBOL_VALUE (var
);
1313 case LOC_THREAD_LOCAL_STATIC
:
1315 char buf
[MAX_REGISTER_RAW_SIZE
];
1317 get_saved_register (buf
, NULL
, NULL
, frame
, SYMBOL_BASEREG (var
),
1319 addr
= extract_address (buf
, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var
)));
1320 addr
+= SYMBOL_VALUE (var
);
1325 error ("Cannot look up value of a typedef");
1329 if (overlay_debugging
)
1330 VALUE_ADDRESS (v
) = symbol_overlayed_address
1331 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
1333 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
1338 case LOC_REGPARM_ADDR
:
1341 int regno
= SYMBOL_VALUE (var
);
1346 b
= get_frame_block (frame
);
1348 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
1350 regval
= value_from_register (lookup_pointer_type (type
),
1355 error ("Value of register variable not available.");
1357 addr
= value_as_pointer (regval
);
1358 VALUE_LVAL (v
) = lval_memory
;
1362 regval
= value_from_register (type
, regno
, frame
);
1365 error ("Value of register variable not available.");
1371 case LOC_UNRESOLVED
:
1373 struct minimal_symbol
*msym
;
1375 msym
= lookup_minimal_symbol (SYMBOL_NAME (var
), NULL
, NULL
);
1378 if (overlay_debugging
)
1379 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
1380 SYMBOL_BFD_SECTION (msym
));
1382 addr
= SYMBOL_VALUE_ADDRESS (msym
);
1386 case LOC_OPTIMIZED_OUT
:
1387 VALUE_LVAL (v
) = not_lval
;
1388 VALUE_OPTIMIZED_OUT (v
) = 1;
1392 error ("Cannot look up value of a botched symbol.");
1396 VALUE_ADDRESS (v
) = addr
;
1401 /* Return a value of type TYPE, stored in register REGNUM, in frame
1404 NOTE: returns NULL if register value is not available.
1405 Caller will check return value or die! */
1408 value_from_register (type
, regnum
, frame
)
1411 struct frame_info
*frame
;
1413 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1416 value_ptr v
= allocate_value (type
);
1417 char *value_bytes
= 0;
1418 int value_bytes_copied
= 0;
1419 int num_storage_locs
;
1420 enum lval_type lval
;
1423 CHECK_TYPEDEF (type
);
1424 len
= TYPE_LENGTH (type
);
1426 /* Pointers on D10V are really only 16 bits, but we lie to gdb elsewhere... */
1427 if (GDB_TARGET_IS_D10V
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1430 VALUE_REGNO (v
) = regnum
;
1432 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
1433 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
1436 if (num_storage_locs
> 1
1437 #ifdef GDB_TARGET_IS_H8500
1438 || TYPE_CODE (type
) == TYPE_CODE_PTR
1442 /* Value spread across multiple storage locations. */
1445 int mem_stor
= 0, reg_stor
= 0;
1446 int mem_tracking
= 1;
1447 CORE_ADDR last_addr
= 0;
1448 CORE_ADDR first_addr
= 0;
1450 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
1452 /* Copy all of the data out, whereever it may be. */
1454 #ifdef GDB_TARGET_IS_H8500
1455 /* This piece of hideosity is required because the H8500 treats registers
1456 differently depending upon whether they are used as pointers or not. As a
1457 pointer, a register needs to have a page register tacked onto the front.
1458 An alternate way to do this would be to have gcc output different register
1459 numbers for the pointer & non-pointer form of the register. But, it
1460 doesn't, so we're stuck with this. */
1462 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1473 page_regnum
= SEG_D_REGNUM
;
1477 page_regnum
= SEG_E_REGNUM
;
1481 page_regnum
= SEG_T_REGNUM
;
1486 get_saved_register (value_bytes
+ 1,
1493 if (register_valid
[page_regnum
] == -1)
1494 return NULL
; /* register value not available */
1496 if (lval
== lval_register
)
1503 get_saved_register (value_bytes
+ 2,
1510 if (register_valid
[regnum
] == -1)
1511 return NULL
; /* register value not available */
1513 if (lval
== lval_register
)
1518 mem_tracking
= mem_tracking
&& (addr
== last_addr
);
1523 #endif /* GDB_TARGET_IS_H8500 */
1524 for (local_regnum
= regnum
;
1525 value_bytes_copied
< len
;
1526 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
1529 get_saved_register (value_bytes
+ value_bytes_copied
,
1536 if (register_valid
[local_regnum
] == -1)
1537 return NULL
; /* register value not available */
1539 if (regnum
== local_regnum
)
1541 if (lval
== lval_register
)
1549 && (regnum
== local_regnum
1550 || addr
== last_addr
));
1555 if ((reg_stor
&& mem_stor
)
1556 || (mem_stor
&& !mem_tracking
))
1557 /* Mixed storage; all of the hassle we just went through was
1558 for some good purpose. */
1560 VALUE_LVAL (v
) = lval_reg_frame_relative
;
1561 VALUE_FRAME (v
) = FRAME_FP (frame
);
1562 VALUE_FRAME_REGNUM (v
) = regnum
;
1566 VALUE_LVAL (v
) = lval_memory
;
1567 VALUE_ADDRESS (v
) = first_addr
;
1571 VALUE_LVAL (v
) = lval_register
;
1572 VALUE_ADDRESS (v
) = first_addr
;
1575 internal_error ("value_from_register: Value not stored anywhere!");
1577 VALUE_OPTIMIZED_OUT (v
) = optim
;
1579 /* Any structure stored in more than one register will always be
1580 an integral number of registers. Otherwise, you'd need to do
1581 some fiddling with the last register copied here for little
1584 /* Copy into the contents section of the value. */
1585 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
1587 /* Finally do any conversion necessary when extracting this
1588 type from more than one register. */
1589 #ifdef REGISTER_CONVERT_TO_TYPE
1590 REGISTER_CONVERT_TO_TYPE (regnum
, type
, VALUE_CONTENTS_RAW (v
));
1595 /* Data is completely contained within a single register. Locate the
1596 register's contents in a real register or in core;
1597 read the data in raw format. */
1599 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
1601 if (register_valid
[regnum
] == -1)
1602 return NULL
; /* register value not available */
1604 VALUE_OPTIMIZED_OUT (v
) = optim
;
1605 VALUE_LVAL (v
) = lval
;
1606 VALUE_ADDRESS (v
) = addr
;
1608 /* Convert raw data to virtual format if necessary. */
1610 if (REGISTER_CONVERTIBLE (regnum
))
1612 REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
,
1613 raw_buffer
, VALUE_CONTENTS_RAW (v
));
1617 /* Raw and virtual formats are the same for this register. */
1619 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
&& len
< REGISTER_RAW_SIZE (regnum
))
1621 /* Big-endian, and we want less than full size. */
1622 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
1625 memcpy (VALUE_CONTENTS_RAW (v
), raw_buffer
+ VALUE_OFFSET (v
), len
);
1628 if (GDB_TARGET_IS_D10V
1629 && TYPE_CODE (type
) == TYPE_CODE_PTR
1630 && TYPE_TARGET_TYPE (type
)
1631 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
1633 /* pointer to function */
1635 unsigned short snum
;
1636 snum
= (unsigned short) extract_unsigned_integer (VALUE_CONTENTS_RAW (v
), 2);
1637 num
= D10V_MAKE_IADDR (snum
);
1638 store_address (VALUE_CONTENTS_RAW (v
), 4, num
);
1640 else if (GDB_TARGET_IS_D10V
1641 && TYPE_CODE (type
) == TYPE_CODE_PTR
)
1643 /* pointer to data */
1645 unsigned short snum
;
1646 snum
= (unsigned short) extract_unsigned_integer (VALUE_CONTENTS_RAW (v
), 2);
1647 num
= D10V_MAKE_DADDR (snum
);
1648 store_address (VALUE_CONTENTS_RAW (v
), 4, num
);
1654 /* Given a struct symbol for a variable or function,
1655 and a stack frame id,
1656 return a (pointer to a) struct value containing the properly typed
1660 locate_var_value (var
, frame
)
1661 register struct symbol
*var
;
1662 struct frame_info
*frame
;
1665 struct type
*type
= SYMBOL_TYPE (var
);
1666 value_ptr lazy_value
;
1668 /* Evaluate it first; if the result is a memory address, we're fine.
1669 Lazy evaluation pays off here. */
1671 lazy_value
= read_var_value (var
, frame
);
1672 if (lazy_value
== 0)
1673 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
1675 if (VALUE_LAZY (lazy_value
)
1676 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1680 addr
= VALUE_ADDRESS (lazy_value
);
1681 val
= value_from_longest (lookup_pointer_type (type
), (LONGEST
) addr
);
1682 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
1686 /* Not a memory address; check what the problem was. */
1687 switch (VALUE_LVAL (lazy_value
))
1690 case lval_reg_frame_relative
:
1691 error ("Address requested for identifier \"%s\" which is in a register.",
1692 SYMBOL_SOURCE_NAME (var
));
1696 error ("Can't take address of \"%s\" which isn't an lvalue.",
1697 SYMBOL_SOURCE_NAME (var
));
1700 return 0; /* For lint -- never reached */
1704 static void build_findvar
PARAMS ((void));
1708 /* We allocate some extra slop since we do a lot of memcpy's around
1709 `registers', and failing-soft is better than failing hard. */
1710 int sizeof_registers
= REGISTER_BYTES
+ /* SLOP */ 256;
1711 int sizeof_register_valid
= NUM_REGS
* sizeof (*register_valid
);
1712 registers
= xmalloc (sizeof_registers
);
1713 memset (registers
, 0, sizeof_registers
);
1714 register_valid
= xmalloc (sizeof_register_valid
);
1715 memset (register_valid
, 0, sizeof_register_valid
);
1718 void _initialize_findvar
PARAMS ((void));
1720 _initialize_findvar ()
1724 register_gdbarch_swap (®isters
, sizeof (registers
), NULL
);
1725 register_gdbarch_swap (®ister_valid
, sizeof (register_valid
), NULL
);
1726 register_gdbarch_swap (NULL
, 0, build_findvar
);