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);
292 #ifdef TARGET_EXTRACT_FLOATING
293 else if (TARGET_EXTRACT_FLOATING (addr, len, &dretval))
298 error ("Can't deal with a floating point number of %d bytes.", len);
305 store_floating (void *addr, int len, DOUBLEST val)
307 if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
309 if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT)
311 float floatval = val;
313 memcpy (addr, &floatval, sizeof (floatval));
316 floatformat_from_doublest (TARGET_FLOAT_FORMAT, &val, addr);
318 else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
320 if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT)
322 double doubleval = val;
324 memcpy (addr, &doubleval, sizeof (doubleval));
327 floatformat_from_doublest (TARGET_DOUBLE_FORMAT, &val, addr);
329 else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
331 if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
332 memcpy (addr, &val, sizeof (val));
334 floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr);
336 #ifdef TARGET_STORE_FLOATING
337 else if (TARGET_STORE_FLOATING (addr, len, val))
342 error ("Can't deal with a floating point number of %d bytes.", len);
347 /* Return the address in which frame FRAME's value of register REGNUM
348 has been saved in memory. Or return zero if it has not been saved.
349 If REGNUM specifies the SP, the value we return is actually
350 the SP value, not an address where it was saved. */
353 find_saved_register (frame, regnum)
354 struct frame_info *frame;
357 register struct frame_info *frame1 = NULL;
358 register CORE_ADDR addr = 0;
360 if (frame == NULL) /* No regs saved if want current frame */
363 #ifdef HAVE_REGISTER_WINDOWS
364 /* We assume that a register in a register window will only be saved
365 in one place (since the name changes and/or disappears as you go
366 towards inner frames), so we only call get_frame_saved_regs on
367 the current frame. This is directly in contradiction to the
368 usage below, which assumes that registers used in a frame must be
369 saved in a lower (more interior) frame. This change is a result
370 of working on a register window machine; get_frame_saved_regs
371 always returns the registers saved within a frame, within the
372 context (register namespace) of that frame. */
374 /* However, note that we don't want this to return anything if
375 nothing is saved (if there's a frame inside of this one). Also,
376 callers to this routine asking for the stack pointer want the
377 stack pointer saved for *this* frame; this is returned from the
380 if (REGISTER_IN_WINDOW_P (regnum))
382 frame1 = get_next_frame (frame);
384 return 0; /* Registers of this frame are active. */
386 /* Get the SP from the next frame in; it will be this
388 if (regnum != SP_REGNUM)
391 FRAME_INIT_SAVED_REGS (frame1);
392 return frame1->saved_regs[regnum]; /* ... which might be zero */
394 #endif /* HAVE_REGISTER_WINDOWS */
396 /* Note that this next routine assumes that registers used in
397 frame x will be saved only in the frame that x calls and
398 frames interior to it. This is not true on the sparc, but the
399 above macro takes care of it, so we should be all right. */
403 frame1 = get_prev_frame (frame1);
404 if (frame1 == 0 || frame1 == frame)
406 FRAME_INIT_SAVED_REGS (frame1);
407 if (frame1->saved_regs[regnum])
408 addr = frame1->saved_regs[regnum];
414 /* Find register number REGNUM relative to FRAME and put its (raw,
415 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
416 variable was optimized out (and thus can't be fetched). Set *LVAL
417 to lval_memory, lval_register, or not_lval, depending on whether
418 the value was fetched from memory, from a register, or in a strange
419 and non-modifiable way (e.g. a frame pointer which was calculated
420 rather than fetched). Set *ADDRP to the address, either in memory
421 on as a REGISTER_BYTE offset into the registers array.
423 Note that this implementation never sets *LVAL to not_lval. But
424 it can be replaced by defining GET_SAVED_REGISTER and supplying
427 The argument RAW_BUFFER must point to aligned memory. */
430 default_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
434 struct frame_info *frame;
436 enum lval_type *lval;
440 if (!target_has_registers)
441 error ("No registers.");
443 /* Normal systems don't optimize out things with register numbers. */
444 if (optimized != NULL)
446 addr = find_saved_register (frame, regnum);
451 if (regnum == SP_REGNUM)
453 if (raw_buffer != NULL)
455 /* Put it back in target format. */
456 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), (LONGEST) addr);
462 if (raw_buffer != NULL)
463 read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
468 *lval = lval_register;
469 addr = REGISTER_BYTE (regnum);
470 if (raw_buffer != NULL)
471 read_register_gen (regnum, raw_buffer);
477 #if !defined (GET_SAVED_REGISTER)
478 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
479 default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
482 get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
486 struct frame_info *frame;
488 enum lval_type *lval;
490 GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
493 /* Copy the bytes of register REGNUM, relative to the input stack frame,
494 into our memory at MYADDR, in target byte order.
495 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
497 Returns 1 if could not be read, 0 if could. */
500 read_relative_register_raw_bytes_for_frame (regnum, myaddr, frame)
503 struct frame_info *frame;
506 if (regnum == FP_REGNUM && frame)
508 /* Put it back in target format. */
509 store_address (myaddr, REGISTER_RAW_SIZE (FP_REGNUM),
510 (LONGEST) FRAME_FP (frame));
515 get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
516 regnum, (enum lval_type *) NULL);
518 if (register_valid[regnum] < 0)
519 return 1; /* register value not available */
524 /* Copy the bytes of register REGNUM, relative to the current stack frame,
525 into our memory at MYADDR, in target byte order.
526 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
528 Returns 1 if could not be read, 0 if could. */
531 read_relative_register_raw_bytes (regnum, myaddr)
535 return read_relative_register_raw_bytes_for_frame (regnum, myaddr,
539 /* Return a `value' with the contents of register REGNUM
540 in its virtual format, with the type specified by
541 REGISTER_VIRTUAL_TYPE.
543 NOTE: returns NULL if register value is not available.
544 Caller will check return value or die! */
547 value_of_register (regnum)
552 register value_ptr reg_val;
553 char raw_buffer[MAX_REGISTER_RAW_SIZE];
556 get_saved_register (raw_buffer, &optim, &addr,
557 selected_frame, regnum, &lval);
559 if (register_valid[regnum] < 0)
560 return NULL; /* register value not available */
562 reg_val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
564 /* Convert raw data to virtual format if necessary. */
566 if (REGISTER_CONVERTIBLE (regnum))
568 REGISTER_CONVERT_TO_VIRTUAL (regnum, REGISTER_VIRTUAL_TYPE (regnum),
569 raw_buffer, VALUE_CONTENTS_RAW (reg_val));
571 else if (REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
572 memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
573 REGISTER_RAW_SIZE (regnum));
575 internal_error ("Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
576 REGISTER_NAME (regnum),
578 REGISTER_RAW_SIZE (regnum),
579 REGISTER_VIRTUAL_SIZE (regnum));
580 VALUE_LVAL (reg_val) = lval;
581 VALUE_ADDRESS (reg_val) = addr;
582 VALUE_REGNO (reg_val) = regnum;
583 VALUE_OPTIMIZED_OUT (reg_val) = optim;
587 /* Low level examining and depositing of registers.
589 The caller is responsible for making
590 sure that the inferior is stopped before calling the fetching routines,
591 or it will get garbage. (a change from GDB version 3, in which
592 the caller got the value from the last stop). */
594 /* Contents and state of the registers (in target byte order). */
598 /* VALID_REGISTER is non-zero if it has been fetched, -1 if the
599 register value was not available. */
601 signed char *register_valid;
603 /* The thread/process associated with the current set of registers. For now,
604 -1 is special, and means `no current process'. */
605 int registers_pid = -1;
607 /* Indicate that registers may have changed, so invalidate the cache. */
613 int numregs = ARCH_NUM_REGS;
617 /* Force cleanup of any alloca areas if using C alloca instead of
618 a builtin alloca. This particular call is used to clean up
619 areas allocated by low level target code which may build up
620 during lengthy interactions between gdb and the target before
621 gdb gives control to the user (ie watchpoints). */
624 for (i = 0; i < numregs; i++)
625 register_valid[i] = 0;
627 if (registers_changed_hook)
628 registers_changed_hook ();
631 /* Indicate that all registers have been fetched, so mark them all valid. */
636 int numregs = ARCH_NUM_REGS;
637 for (i = 0; i < numregs; i++)
638 register_valid[i] = 1;
641 /* read_register_bytes and write_register_bytes are generally a *BAD*
642 idea. They are inefficient because they need to check for partial
643 updates, which can only be done by scanning through all of the
644 registers and seeing if the bytes that are being read/written fall
645 inside of an invalid register. [The main reason this is necessary
646 is that register sizes can vary, so a simple index won't suffice.]
647 It is far better to call read_register_gen and write_register_gen
648 if you want to get at the raw register contents, as it only takes a
649 regno as an argument, and therefore can't do a partial register
652 Prior to the recent fixes to check for partial updates, both read
653 and write_register_bytes always checked to see if any registers
654 were stale, and then called target_fetch_registers (-1) to update
655 the whole set. This caused really slowed things down for remote
658 /* Copy INLEN bytes of consecutive data from registers
659 starting with the INREGBYTE'th byte of register data
660 into memory at MYADDR. */
663 read_register_bytes (inregbyte, myaddr, inlen)
668 int inregend = inregbyte + inlen;
671 if (registers_pid != inferior_pid)
673 registers_changed ();
674 registers_pid = inferior_pid;
677 /* See if we are trying to read bytes from out-of-date registers. If so,
678 update just those registers. */
680 for (regno = 0; regno < NUM_REGS; regno++)
682 int regstart, regend;
684 if (register_valid[regno])
687 if (REGISTER_NAME (regno) == NULL || *REGISTER_NAME (regno) == '\0')
690 regstart = REGISTER_BYTE (regno);
691 regend = regstart + REGISTER_RAW_SIZE (regno);
693 if (regend <= inregbyte || inregend <= regstart)
694 /* The range the user wants to read doesn't overlap with regno. */
697 /* We've found an invalid register where at least one byte will be read.
698 Update it from the target. */
699 target_fetch_registers (regno);
701 if (!register_valid[regno])
702 error ("read_register_bytes: Couldn't update register %d.", regno);
706 memcpy (myaddr, ®isters[inregbyte], inlen);
709 /* Read register REGNO into memory at MYADDR, which must be large enough
710 for REGISTER_RAW_BYTES (REGNO). Target byte-order.
711 If the register is known to be the size of a CORE_ADDR or smaller,
712 read_register can be used instead. */
714 read_register_gen (regno, myaddr)
718 if (registers_pid != inferior_pid)
720 registers_changed ();
721 registers_pid = inferior_pid;
724 if (!register_valid[regno])
725 target_fetch_registers (regno);
726 memcpy (myaddr, ®isters[REGISTER_BYTE (regno)],
727 REGISTER_RAW_SIZE (regno));
730 /* Write register REGNO at MYADDR to the target. MYADDR points at
731 REGISTER_RAW_BYTES(REGNO), which must be in target byte-order. */
734 write_register_gen (regno, myaddr)
740 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
741 the registers array if something writes to this register. */
742 if (CANNOT_STORE_REGISTER (regno))
745 if (registers_pid != inferior_pid)
747 registers_changed ();
748 registers_pid = inferior_pid;
751 size = REGISTER_RAW_SIZE (regno);
753 /* If we have a valid copy of the register, and new value == old value,
754 then don't bother doing the actual store. */
756 if (register_valid[regno]
757 && memcmp (®isters[REGISTER_BYTE (regno)], myaddr, size) == 0)
760 target_prepare_to_store ();
762 memcpy (®isters[REGISTER_BYTE (regno)], myaddr, size);
764 register_valid[regno] = 1;
766 target_store_registers (regno);
769 /* Copy INLEN bytes of consecutive data from memory at MYADDR
770 into registers starting with the MYREGSTART'th byte of register data. */
773 write_register_bytes (myregstart, myaddr, inlen)
778 int myregend = myregstart + inlen;
781 target_prepare_to_store ();
783 /* Scan through the registers updating any that are covered by the range
784 myregstart<=>myregend using write_register_gen, which does nice things
785 like handling threads, and avoiding updates when the new and old contents
788 for (regno = 0; regno < NUM_REGS; regno++)
790 int regstart, regend;
792 regstart = REGISTER_BYTE (regno);
793 regend = regstart + REGISTER_RAW_SIZE (regno);
795 /* Is this register completely outside the range the user is writing? */
796 if (myregend <= regstart || regend <= myregstart)
799 /* Is this register completely within the range the user is writing? */
800 else if (myregstart <= regstart && regend <= myregend)
801 write_register_gen (regno, myaddr + (regstart - myregstart));
803 /* The register partially overlaps the range being written. */
806 char regbuf[MAX_REGISTER_RAW_SIZE];
807 /* What's the overlap between this register's bytes and
808 those the caller wants to write? */
809 int overlapstart = max (regstart, myregstart);
810 int overlapend = min (regend, myregend);
812 /* We may be doing a partial update of an invalid register.
813 Update it from the target before scribbling on it. */
814 read_register_gen (regno, regbuf);
816 memcpy (registers + overlapstart,
817 myaddr + (overlapstart - myregstart),
818 overlapend - overlapstart);
820 target_store_registers (regno);
826 /* Return the raw contents of register REGNO, regarding it as an integer. */
827 /* This probably should be returning LONGEST rather than CORE_ADDR. */
830 read_register (regno)
833 if (registers_pid != inferior_pid)
835 registers_changed ();
836 registers_pid = inferior_pid;
839 if (!register_valid[regno])
840 target_fetch_registers (regno);
842 return (CORE_ADDR) extract_address (®isters[REGISTER_BYTE (regno)],
843 REGISTER_RAW_SIZE (regno));
847 read_register_pid (regno, pid)
853 if (pid == inferior_pid)
854 return read_register (regno);
856 save_pid = inferior_pid;
860 retval = read_register (regno);
862 inferior_pid = save_pid;
867 /* Store VALUE, into the raw contents of register number REGNO.
868 This should probably write a LONGEST rather than a CORE_ADDR */
871 write_register (regno, val)
878 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
879 the registers array if something writes to this register. */
880 if (CANNOT_STORE_REGISTER (regno))
883 if (registers_pid != inferior_pid)
885 registers_changed ();
886 registers_pid = inferior_pid;
889 size = REGISTER_RAW_SIZE (regno);
891 store_signed_integer (buf, size, (LONGEST) val);
893 /* If we have a valid copy of the register, and new value == old value,
894 then don't bother doing the actual store. */
896 if (register_valid[regno]
897 && memcmp (®isters[REGISTER_BYTE (regno)], buf, size) == 0)
900 target_prepare_to_store ();
902 memcpy (®isters[REGISTER_BYTE (regno)], buf, size);
904 register_valid[regno] = 1;
906 target_store_registers (regno);
910 write_register_pid (regno, val, pid)
917 if (pid == inferior_pid)
919 write_register (regno, val);
923 save_pid = inferior_pid;
927 write_register (regno, val);
929 inferior_pid = save_pid;
932 /* Record that register REGNO contains VAL.
933 This is used when the value is obtained from the inferior or core dump,
934 so there is no need to store the value there.
936 If VAL is a NULL pointer, then it's probably an unsupported register. We
937 just set it's value to all zeros. We might want to record this fact, and
938 report it to the users of read_register and friends.
942 supply_register (regno, val)
947 if (registers_pid != inferior_pid)
949 registers_changed ();
950 registers_pid = inferior_pid;
954 register_valid[regno] = 1;
956 memcpy (®isters[REGISTER_BYTE (regno)], val, REGISTER_RAW_SIZE (regno));
958 memset (®isters[REGISTER_BYTE (regno)], '\000', REGISTER_RAW_SIZE (regno));
960 /* On some architectures, e.g. HPPA, there are a few stray bits in some
961 registers, that the rest of the code would like to ignore. */
962 #ifdef CLEAN_UP_REGISTER_VALUE
963 CLEAN_UP_REGISTER_VALUE (regno, ®isters[REGISTER_BYTE (regno)]);
968 /* This routine is getting awfully cluttered with #if's. It's probably
969 time to turn this into READ_PC and define it in the tm.h file.
972 1999-06-08: The following were re-written so that it assumes the
973 existance of a TARGET_READ_PC et.al. macro. A default generic
974 version of that macro is made available where needed.
976 Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
977 by the multi-arch framework, it will eventually be possible to
978 eliminate the intermediate read_pc_pid(). The client would call
979 TARGET_READ_PC directly. (cagney). */
981 #ifndef TARGET_READ_PC
982 #define TARGET_READ_PC generic_target_read_pc
986 generic_target_read_pc (int pid)
991 CORE_ADDR pc_val = ADDR_BITS_REMOVE ((CORE_ADDR) read_register_pid (PC_REGNUM, pid));
995 internal_error ("generic_target_read_pc");
1003 int saved_inferior_pid;
1006 /* In case pid != inferior_pid. */
1007 saved_inferior_pid = inferior_pid;
1010 pc_val = TARGET_READ_PC (pid);
1012 inferior_pid = saved_inferior_pid;
1019 return read_pc_pid (inferior_pid);
1022 #ifndef TARGET_WRITE_PC
1023 #define TARGET_WRITE_PC generic_target_write_pc
1027 generic_target_write_pc (pc, pid)
1033 write_register_pid (PC_REGNUM, pc, pid);
1035 if (NPC_REGNUM >= 0)
1036 write_register_pid (NPC_REGNUM, pc + 4, pid);
1038 if (NNPC_REGNUM >= 0)
1039 write_register_pid (NNPC_REGNUM, pc + 8, pid);
1043 internal_error ("generic_target_write_pc");
1048 write_pc_pid (pc, pid)
1052 int saved_inferior_pid;
1054 /* In case pid != inferior_pid. */
1055 saved_inferior_pid = inferior_pid;
1058 TARGET_WRITE_PC (pc, pid);
1060 inferior_pid = saved_inferior_pid;
1067 write_pc_pid (pc, inferior_pid);
1070 /* Cope with strage ways of getting to the stack and frame pointers */
1072 #ifndef TARGET_READ_SP
1073 #define TARGET_READ_SP generic_target_read_sp
1077 generic_target_read_sp ()
1081 return read_register (SP_REGNUM);
1083 internal_error ("generic_target_read_sp");
1089 return TARGET_READ_SP ();
1092 #ifndef TARGET_WRITE_SP
1093 #define TARGET_WRITE_SP generic_target_write_sp
1097 generic_target_write_sp (val)
1103 write_register (SP_REGNUM, val);
1107 internal_error ("generic_target_write_sp");
1114 TARGET_WRITE_SP (val);
1117 #ifndef TARGET_READ_FP
1118 #define TARGET_READ_FP generic_target_read_fp
1122 generic_target_read_fp ()
1126 return read_register (FP_REGNUM);
1128 internal_error ("generic_target_read_fp");
1134 return TARGET_READ_FP ();
1137 #ifndef TARGET_WRITE_FP
1138 #define TARGET_WRITE_FP generic_target_write_fp
1142 generic_target_write_fp (val)
1148 write_register (FP_REGNUM, val);
1152 internal_error ("generic_target_write_fp");
1159 TARGET_WRITE_FP (val);
1162 /* Will calling read_var_value or locate_var_value on SYM end
1163 up caring what frame it is being evaluated relative to? SYM must
1166 symbol_read_needs_frame (sym)
1169 switch (SYMBOL_CLASS (sym))
1171 /* All cases listed explicitly so that gcc -Wall will detect it if
1172 we failed to consider one. */
1177 case LOC_REGPARM_ADDR:
1181 case LOC_BASEREG_ARG:
1182 case LOC_THREAD_LOCAL_STATIC:
1192 /* Getting the address of a label can be done independently of the block,
1193 even if some *uses* of that address wouldn't work so well without
1197 case LOC_CONST_BYTES:
1198 case LOC_UNRESOLVED:
1199 case LOC_OPTIMIZED_OUT:
1205 /* Given a struct symbol for a variable,
1206 and a stack frame id, read the value of the variable
1207 and return a (pointer to a) struct value containing the value.
1208 If the variable cannot be found, return a zero pointer.
1209 If FRAME is NULL, use the selected_frame. */
1212 read_var_value (var, frame)
1213 register struct symbol *var;
1214 struct frame_info *frame;
1216 register value_ptr v;
1217 struct type *type = SYMBOL_TYPE (var);
1221 v = allocate_value (type);
1222 VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */
1223 VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
1225 len = TYPE_LENGTH (type);
1228 frame = selected_frame;
1230 switch (SYMBOL_CLASS (var))
1233 /* Put the constant back in target format. */
1234 store_signed_integer (VALUE_CONTENTS_RAW (v), len,
1235 (LONGEST) SYMBOL_VALUE (var));
1236 VALUE_LVAL (v) = not_lval;
1240 /* Put the constant back in target format. */
1241 if (overlay_debugging)
1242 store_address (VALUE_CONTENTS_RAW (v), len,
1243 (LONGEST) symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
1244 SYMBOL_BFD_SECTION (var)));
1246 store_address (VALUE_CONTENTS_RAW (v), len,
1247 (LONGEST) SYMBOL_VALUE_ADDRESS (var));
1248 VALUE_LVAL (v) = not_lval;
1251 case LOC_CONST_BYTES:
1254 bytes_addr = SYMBOL_VALUE_BYTES (var);
1255 memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
1256 VALUE_LVAL (v) = not_lval;
1261 if (overlay_debugging)
1262 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
1263 SYMBOL_BFD_SECTION (var));
1265 addr = SYMBOL_VALUE_ADDRESS (var);
1269 /* The import slot does not have a real address in it from the
1270 dynamic loader (dld.sl on HP-UX), if the target hasn't begun
1271 execution yet, so check for that. */
1272 if (!target_has_execution)
1274 Attempt to access variable defined in different shared object or load module when\n\
1275 addresses have not been bound by the dynamic loader. Try again when executable is running.");
1277 addr = SYMBOL_VALUE_ADDRESS (var);
1278 addr = read_memory_unsigned_integer
1279 (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
1285 addr = FRAME_ARGS_ADDRESS (frame);
1288 addr += SYMBOL_VALUE (var);
1294 addr = FRAME_ARGS_ADDRESS (frame);
1297 addr += SYMBOL_VALUE (var);
1298 addr = read_memory_unsigned_integer
1299 (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
1306 addr = FRAME_LOCALS_ADDRESS (frame);
1307 addr += SYMBOL_VALUE (var);
1311 case LOC_BASEREG_ARG:
1313 char buf[MAX_REGISTER_RAW_SIZE];
1314 get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
1316 addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
1317 addr += SYMBOL_VALUE (var);
1321 case LOC_THREAD_LOCAL_STATIC:
1323 char buf[MAX_REGISTER_RAW_SIZE];
1325 get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
1327 addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
1328 addr += SYMBOL_VALUE (var);
1333 error ("Cannot look up value of a typedef");
1337 if (overlay_debugging)
1338 VALUE_ADDRESS (v) = symbol_overlayed_address
1339 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
1341 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
1346 case LOC_REGPARM_ADDR:
1349 int regno = SYMBOL_VALUE (var);
1354 b = get_frame_block (frame);
1356 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
1358 regval = value_from_register (lookup_pointer_type (type),
1363 error ("Value of register variable not available.");
1365 addr = value_as_pointer (regval);
1366 VALUE_LVAL (v) = lval_memory;
1370 regval = value_from_register (type, regno, frame);
1373 error ("Value of register variable not available.");
1379 case LOC_UNRESOLVED:
1381 struct minimal_symbol *msym;
1383 msym = lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL);
1386 if (overlay_debugging)
1387 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
1388 SYMBOL_BFD_SECTION (msym));
1390 addr = SYMBOL_VALUE_ADDRESS (msym);
1394 case LOC_OPTIMIZED_OUT:
1395 VALUE_LVAL (v) = not_lval;
1396 VALUE_OPTIMIZED_OUT (v) = 1;
1400 error ("Cannot look up value of a botched symbol.");
1404 VALUE_ADDRESS (v) = addr;
1409 /* Return a value of type TYPE, stored in register REGNUM, in frame
1412 NOTE: returns NULL if register value is not available.
1413 Caller will check return value or die! */
1416 value_from_register (type, regnum, frame)
1419 struct frame_info *frame;
1421 char raw_buffer[MAX_REGISTER_RAW_SIZE];
1424 value_ptr v = allocate_value (type);
1425 char *value_bytes = 0;
1426 int value_bytes_copied = 0;
1427 int num_storage_locs;
1428 enum lval_type lval;
1431 CHECK_TYPEDEF (type);
1432 len = TYPE_LENGTH (type);
1434 /* Pointers on D10V are really only 16 bits, but we lie to gdb elsewhere... */
1435 if (GDB_TARGET_IS_D10V && TYPE_CODE (type) == TYPE_CODE_PTR)
1438 VALUE_REGNO (v) = regnum;
1440 num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
1441 ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
1444 if (num_storage_locs > 1
1445 #ifdef GDB_TARGET_IS_H8500
1446 || TYPE_CODE (type) == TYPE_CODE_PTR
1450 /* Value spread across multiple storage locations. */
1453 int mem_stor = 0, reg_stor = 0;
1454 int mem_tracking = 1;
1455 CORE_ADDR last_addr = 0;
1456 CORE_ADDR first_addr = 0;
1458 value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
1460 /* Copy all of the data out, whereever it may be. */
1462 #ifdef GDB_TARGET_IS_H8500
1463 /* This piece of hideosity is required because the H8500 treats registers
1464 differently depending upon whether they are used as pointers or not. As a
1465 pointer, a register needs to have a page register tacked onto the front.
1466 An alternate way to do this would be to have gcc output different register
1467 numbers for the pointer & non-pointer form of the register. But, it
1468 doesn't, so we're stuck with this. */
1470 if (TYPE_CODE (type) == TYPE_CODE_PTR
1481 page_regnum = SEG_D_REGNUM;
1485 page_regnum = SEG_E_REGNUM;
1489 page_regnum = SEG_T_REGNUM;
1494 get_saved_register (value_bytes + 1,
1501 if (register_valid[page_regnum] == -1)
1502 return NULL; /* register value not available */
1504 if (lval == lval_register)
1511 get_saved_register (value_bytes + 2,
1518 if (register_valid[regnum] == -1)
1519 return NULL; /* register value not available */
1521 if (lval == lval_register)
1526 mem_tracking = mem_tracking && (addr == last_addr);
1531 #endif /* GDB_TARGET_IS_H8500 */
1532 for (local_regnum = regnum;
1533 value_bytes_copied < len;
1534 (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
1537 get_saved_register (value_bytes + value_bytes_copied,
1544 if (register_valid[local_regnum] == -1)
1545 return NULL; /* register value not available */
1547 if (regnum == local_regnum)
1549 if (lval == lval_register)
1557 && (regnum == local_regnum
1558 || addr == last_addr));
1563 if ((reg_stor && mem_stor)
1564 || (mem_stor && !mem_tracking))
1565 /* Mixed storage; all of the hassle we just went through was
1566 for some good purpose. */
1568 VALUE_LVAL (v) = lval_reg_frame_relative;
1569 VALUE_FRAME (v) = FRAME_FP (frame);
1570 VALUE_FRAME_REGNUM (v) = regnum;
1574 VALUE_LVAL (v) = lval_memory;
1575 VALUE_ADDRESS (v) = first_addr;
1579 VALUE_LVAL (v) = lval_register;
1580 VALUE_ADDRESS (v) = first_addr;
1583 internal_error ("value_from_register: Value not stored anywhere!");
1585 VALUE_OPTIMIZED_OUT (v) = optim;
1587 /* Any structure stored in more than one register will always be
1588 an integral number of registers. Otherwise, you'd need to do
1589 some fiddling with the last register copied here for little
1592 /* Copy into the contents section of the value. */
1593 memcpy (VALUE_CONTENTS_RAW (v), value_bytes, len);
1595 /* Finally do any conversion necessary when extracting this
1596 type from more than one register. */
1597 #ifdef REGISTER_CONVERT_TO_TYPE
1598 REGISTER_CONVERT_TO_TYPE (regnum, type, VALUE_CONTENTS_RAW (v));
1603 /* Data is completely contained within a single register. Locate the
1604 register's contents in a real register or in core;
1605 read the data in raw format. */
1607 get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
1609 if (register_valid[regnum] == -1)
1610 return NULL; /* register value not available */
1612 VALUE_OPTIMIZED_OUT (v) = optim;
1613 VALUE_LVAL (v) = lval;
1614 VALUE_ADDRESS (v) = addr;
1616 /* Convert raw data to virtual format if necessary. */
1618 if (REGISTER_CONVERTIBLE (regnum))
1620 REGISTER_CONVERT_TO_VIRTUAL (regnum, type,
1621 raw_buffer, VALUE_CONTENTS_RAW (v));
1625 /* Raw and virtual formats are the same for this register. */
1627 if (TARGET_BYTE_ORDER == BIG_ENDIAN && len < REGISTER_RAW_SIZE (regnum))
1629 /* Big-endian, and we want less than full size. */
1630 VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
1633 memcpy (VALUE_CONTENTS_RAW (v), raw_buffer + VALUE_OFFSET (v), len);
1636 if (GDB_TARGET_IS_D10V
1637 && TYPE_CODE (type) == TYPE_CODE_PTR
1638 && TYPE_TARGET_TYPE (type)
1639 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
1641 /* pointer to function */
1643 unsigned short snum;
1644 snum = (unsigned short) extract_unsigned_integer (VALUE_CONTENTS_RAW (v), 2);
1645 num = D10V_MAKE_IADDR (snum);
1646 store_address (VALUE_CONTENTS_RAW (v), 4, num);
1648 else if (GDB_TARGET_IS_D10V
1649 && TYPE_CODE (type) == TYPE_CODE_PTR)
1651 /* pointer to data */
1653 unsigned short snum;
1654 snum = (unsigned short) extract_unsigned_integer (VALUE_CONTENTS_RAW (v), 2);
1655 num = D10V_MAKE_DADDR (snum);
1656 store_address (VALUE_CONTENTS_RAW (v), 4, num);
1662 /* Given a struct symbol for a variable or function,
1663 and a stack frame id,
1664 return a (pointer to a) struct value containing the properly typed
1668 locate_var_value (var, frame)
1669 register struct symbol *var;
1670 struct frame_info *frame;
1673 struct type *type = SYMBOL_TYPE (var);
1674 value_ptr lazy_value;
1676 /* Evaluate it first; if the result is a memory address, we're fine.
1677 Lazy evaluation pays off here. */
1679 lazy_value = read_var_value (var, frame);
1680 if (lazy_value == 0)
1681 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
1683 if (VALUE_LAZY (lazy_value)
1684 || TYPE_CODE (type) == TYPE_CODE_FUNC)
1688 addr = VALUE_ADDRESS (lazy_value);
1689 val = value_from_longest (lookup_pointer_type (type), (LONGEST) addr);
1690 VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
1694 /* Not a memory address; check what the problem was. */
1695 switch (VALUE_LVAL (lazy_value))
1698 case lval_reg_frame_relative:
1699 error ("Address requested for identifier \"%s\" which is in a register.",
1700 SYMBOL_SOURCE_NAME (var));
1704 error ("Can't take address of \"%s\" which isn't an lvalue.",
1705 SYMBOL_SOURCE_NAME (var));
1708 return 0; /* For lint -- never reached */
1712 static void build_findvar PARAMS ((void));
1716 /* We allocate some extra slop since we do a lot of memcpy's around
1717 `registers', and failing-soft is better than failing hard. */
1718 int sizeof_registers = REGISTER_BYTES + /* SLOP */ 256;
1719 int sizeof_register_valid = NUM_REGS * sizeof (*register_valid);
1720 registers = xmalloc (sizeof_registers);
1721 memset (registers, 0, sizeof_registers);
1722 register_valid = xmalloc (sizeof_register_valid);
1723 memset (register_valid, 0, sizeof_register_valid);
1726 void _initialize_findvar PARAMS ((void));
1728 _initialize_findvar ()
1732 register_gdbarch_swap (®isters, sizeof (registers), NULL);
1733 register_gdbarch_swap (®ister_valid, sizeof (register_valid), NULL);
1734 register_gdbarch_swap (NULL, 0, build_findvar);