[thirdparty/binutils-gdb.git] / gdb / regcache.h

/* Cache and manage the values of registers for GDB, the GNU debugger.

   Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
   2002, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#ifndef REGCACHE_H
#define REGCACHE_H

struct regcache;
struct gdbarch;
struct address_space;

extern struct regcache *get_current_regcache (void);
extern struct regcache *get_thread_regcache (ptid_t ptid);
extern struct regcache *get_thread_arch_regcache (ptid_t, struct gdbarch *);

void regcache_xfree (struct regcache *regcache);
struct cleanup *make_cleanup_regcache_xfree (struct regcache *regcache);
struct regcache *regcache_xmalloc (struct gdbarch *gdbarch,
				   struct address_space *aspace);

/* Return REGCACHE's architecture.  */

extern struct gdbarch *get_regcache_arch (const struct regcache *regcache);

/* Return REGCACHE's address space.  */

extern struct address_space *get_regcache_aspace (const struct regcache *);

enum register_status
  {
    /* The register value is not in the cache, and we don't know yet
       whether it's available in the target (or traceframe).  */
    REG_UNKNOWN = 0,

    /* The register value is valid and cached.  */
    REG_VALID = 1,

    /* The register value is unavailable.  E.g., we're inspecting a
       traceframe, and this register wasn't collected.  Note that this
       is different a different "unavailable" from saying the register
       does not exist in the target's architecture --- in that case,
       the target should have given us a target description that does
       not include the register in the first place.  */
    REG_UNAVAILABLE = -1
  };

enum register_status regcache_register_status (const struct regcache *regcache,
					       int regnum);

/* Transfer a raw register [0..NUM_REGS) between core-gdb and the
   regcache.  The read variants return the status of the register.  */

enum register_status regcache_raw_read (struct regcache *regcache,
					int rawnum, gdb_byte *buf);
void regcache_raw_write (struct regcache *regcache, int rawnum,
			 const gdb_byte *buf);
extern enum register_status
  regcache_raw_read_signed (struct regcache *regcache,
			    int regnum, LONGEST *val);
extern enum register_status
  regcache_raw_read_unsigned (struct regcache *regcache,
			      int regnum, ULONGEST *val);
extern void regcache_raw_write_signed (struct regcache *regcache,
				       int regnum, LONGEST val);
extern void regcache_raw_write_unsigned (struct regcache *regcache,
					 int regnum, ULONGEST val);

/* Partial transfer of raw registers.  These perform read, modify,
   write style operations.  The read variant returns the status of the
   register.  */

extern enum register_status
  regcache_raw_read_part (struct regcache *regcache, int regnum,
			  int offset, int len, gdb_byte *buf);
void regcache_raw_write_part (struct regcache *regcache, int regnum,
			      int offset, int len, const gdb_byte *buf);

void regcache_invalidate (struct regcache *regcache, int regnum);

/* Transfer of pseudo-registers.  The read variants return a register
   status, as an indication of when a ``cooked'' register was
   constructed from valid, invalid or unavailable ``raw''
   registers.  */

/* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS).  */
enum register_status regcache_cooked_read (struct regcache *regcache,
					   int rawnum, gdb_byte *buf);
void regcache_cooked_write (struct regcache *regcache, int rawnum,
			    const gdb_byte *buf);

/* Read register REGNUM from REGCACHE and return a new value.  This
   will call mark_value_bytes_unavailable as appropriate.  */

struct value *regcache_cooked_read_value (struct regcache *regcache,
					  int regnum);

/* Read a register as a signed/unsigned quantity.  */
extern enum register_status
  regcache_cooked_read_signed (struct regcache *regcache,
			       int regnum, LONGEST *val);
extern enum register_status
  regcache_cooked_read_unsigned (struct regcache *regcache,
				 int regnum, ULONGEST *val);
extern void regcache_cooked_write_signed (struct regcache *regcache,
					  int regnum, LONGEST val);
extern void regcache_cooked_write_unsigned (struct regcache *regcache,
					    int regnum, ULONGEST val);

/* Partial transfer of a cooked register.  These perform read, modify,
   write style operations.  */

enum register_status regcache_cooked_read_part (struct regcache *regcache,
						int regnum, int offset,
						int len, gdb_byte *buf);
void regcache_cooked_write_part (struct regcache *regcache, int regnum,
				 int offset, int len, const gdb_byte *buf);

/* Special routines to read/write the PC.  */

extern CORE_ADDR regcache_read_pc (struct regcache *regcache);
extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);

/* Transfer a raw register [0..NUM_REGS) between the regcache and the
   target.  These functions are called by the target in response to a
   target_fetch_registers() or target_store_registers().  */

extern void regcache_raw_supply (struct regcache *regcache,
				 int regnum, const void *buf);
extern void regcache_raw_collect (const struct regcache *regcache,
				  int regnum, void *buf);


/* The type of a register.  This function is slightly more efficient
   then its gdbarch vector counterpart since it returns a precomputed
   value stored in a table.  */

extern struct type *register_type (struct gdbarch *gdbarch, int regnum);


/* Return the size of register REGNUM.  All registers should have only
   one size.  */
   
extern int register_size (struct gdbarch *gdbarch, int regnum);


/* Save/restore a register cache.  The set of registers saved /
   restored into the DST regcache determined by the save_reggroup /
   restore_reggroup respectively.  COOKED_READ returns zero iff the
   register's value can't be returned.  */

typedef enum register_status (regcache_cooked_read_ftype) (void *src,
							   int regnum,
							   gdb_byte *buf);

extern void regcache_save (struct regcache *dst,
			   regcache_cooked_read_ftype *cooked_read,
			   void *cooked_read_context);
extern void regcache_restore (struct regcache *dst,
			      regcache_cooked_read_ftype *cooked_read,
			      void *cooked_read_context);

/* Copy/duplicate the contents of a register cache.  By default, the
   operation is pass-through.  Writes to DST and reads from SRC will
   go through to the target.

   The ``cpy'' functions can not have overlapping SRC and DST buffers.

   ``no passthrough'' versions do not go through to the target.  They
   only transfer values already in the cache.  */

extern struct regcache *regcache_dup (struct regcache *regcache);
extern void regcache_cpy (struct regcache *dest, struct regcache *src);
extern void regcache_cpy_no_passthrough (struct regcache *dest,
					 struct regcache *src);

extern void registers_changed (void);
extern void registers_changed_ptid (ptid_t);

#endif /* REGCACHE_H */
Commit	Line	Data
4e052eda	1	/* Cache and manage the values of registers for GDB, the GNU debugger.
3fadccb3	2
6aba47ca	3	Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
7b6bb8da	4	2002, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4e052eda AC	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
a9762ec7	10	the Free Software Foundation; either version 3 of the License, or
4e052eda AC	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
a9762ec7	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
4e052eda AC	20
	21	#ifndef REGCACHE_H
	22	#define REGCACHE_H
	23
3fadccb3 AC	24	struct regcache;
3fadccb3 AC	25	struct gdbarch;
6c95b8df	26	struct address_space;
3fadccb3	27
594f7785 UW	28	extern struct regcache *get_current_regcache (void);
594f7785 UW	29	extern struct regcache *get_thread_regcache (ptid_t ptid);
c2250ad1	30	extern struct regcache get_thread_arch_regcache (ptid_t, struct gdbarch );
3fadccb3 AC	31
3fadccb3 AC	32	void regcache_xfree (struct regcache *regcache);
36160dc4	33	struct cleanup make_cleanup_regcache_xfree (struct regcache regcache);
d37346f0 DJ	34	struct regcache regcache_xmalloc (struct gdbarch gdbarch,
d37346f0 DJ	35	struct address_space *aspace);
3fadccb3	36
41d35cb0 MK	37	/* Return REGCACHE's architecture. */
	38
	39	extern struct gdbarch get_regcache_arch (const struct regcache regcache);
	40
6c95b8df PA	41	/* Return REGCACHE's address space. */
6c95b8df PA	42
3e43a32a	43	extern struct address_space get_regcache_aspace (const struct regcache );
6c95b8df	44
ee99023e PA	45	enum register_status
	46	{
	47	/* The register value is not in the cache, and we don't know yet
	48	whether it's available in the target (or traceframe). */
	49	REG_UNKNOWN = 0,
	50
	51	/* The register value is valid and cached. */
	52	REG_VALID = 1,
	53
	54	/* The register value is unavailable. E.g., we're inspecting a
	55	traceframe, and this register wasn't collected. Note that this
	56	is different a different "unavailable" from saying the register
	57	does not exist in the target's architecture --- in that case,
	58	the target should have given us a target description that does
	59	not include the register in the first place. */
	60	REG_UNAVAILABLE = -1
	61	};
	62
	63	enum register_status regcache_register_status (const struct regcache *regcache,
	64	int regnum);
	65
61a0eb5b	66	/* Transfer a raw register [0..NUM_REGS) between core-gdb and the
05d1431c	67	regcache. The read variants return the status of the register. */
61a0eb5b	68
05d1431c PA	69	enum register_status regcache_raw_read (struct regcache *regcache,
05d1431c PA	70	int rawnum, gdb_byte *buf);
1aaa5f99	71	void regcache_raw_write (struct regcache *regcache, int rawnum,
2d522557	72	const gdb_byte *buf);
05d1431c PA	73	extern enum register_status
	74	regcache_raw_read_signed (struct regcache *regcache,
	75	int regnum, LONGEST *val);
	76	extern enum register_status
	77	regcache_raw_read_unsigned (struct regcache *regcache,
	78	int regnum, ULONGEST *val);
c00dcbe9 MK	79	extern void regcache_raw_write_signed (struct regcache *regcache,
	80	int regnum, LONGEST val);
	81	extern void regcache_raw_write_unsigned (struct regcache *regcache,
	82	int regnum, ULONGEST val);
06c0b04e	83
05d1431c PA	84	/* Partial transfer of raw registers. These perform read, modify,
	85	write style operations. The read variant returns the status of the
	86	register. */
06c0b04e	87
05d1431c PA	88	extern enum register_status
	89	regcache_raw_read_part (struct regcache *regcache, int regnum,
	90	int offset, int len, gdb_byte *buf);
06c0b04e	91	void regcache_raw_write_part (struct regcache *regcache, int regnum,
2d522557	92	int offset, int len, const gdb_byte *buf);
06c0b04e	93
9c5ea4d9 UW	94	void regcache_invalidate (struct regcache *regcache, int regnum);
9c5ea4d9 UW	95
05d1431c PA	96	/* Transfer of pseudo-registers. The read variants return a register
	97	status, as an indication of when a ``cooked'' register was
	98	constructed from valid, invalid or unavailable ``raw''
	99	registers. */
	100
68365089	101	/* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
05d1431c PA	102	enum register_status regcache_cooked_read (struct regcache *regcache,
05d1431c PA	103	int rawnum, gdb_byte *buf);
68365089	104	void regcache_cooked_write (struct regcache *regcache, int rawnum,
2d522557	105	const gdb_byte *buf);
68365089	106
3543a589 TT	107	/* Read register REGNUM from REGCACHE and return a new value. This
	108	will call mark_value_bytes_unavailable as appropriate. */
	109
	110	struct value regcache_cooked_read_value (struct regcache regcache,
	111	int regnum);
	112
a378f419	113	/* Read a register as a signed/unsigned quantity. */
05d1431c PA	114	extern enum register_status
	115	regcache_cooked_read_signed (struct regcache *regcache,
	116	int regnum, LONGEST *val);
	117	extern enum register_status
	118	regcache_cooked_read_unsigned (struct regcache *regcache,
	119	int regnum, ULONGEST *val);
a66a9c23 AC	120	extern void regcache_cooked_write_signed (struct regcache *regcache,
	121	int regnum, LONGEST val);
	122	extern void regcache_cooked_write_unsigned (struct regcache *regcache,
	123	int regnum, ULONGEST val);
a378f419	124
06c0b04e AC	125	/* Partial transfer of a cooked register. These perform read, modify,
	126	write style operations. */
	127
05d1431c PA	128	enum register_status regcache_cooked_read_part (struct regcache *regcache,
	129	int regnum, int offset,
	130	int len, gdb_byte *buf);
06c0b04e	131	void regcache_cooked_write_part (struct regcache *regcache, int regnum,
2d522557	132	int offset, int len, const gdb_byte *buf);
06c0b04e	133
515630c5 UW	134	/* Special routines to read/write the PC. */
	135
	136	extern CORE_ADDR regcache_read_pc (struct regcache *regcache);
	137	extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
	138
193cb69f AC	139	/* Transfer a raw register [0..NUM_REGS) between the regcache and the
	140	target. These functions are called by the target in response to a
	141	target_fetch_registers() or target_store_registers(). */
	142
9a661b68	143	extern void regcache_raw_supply (struct regcache *regcache,
6618125d	144	int regnum, const void *buf);
9a661b68	145	extern void regcache_raw_collect (const struct regcache *regcache,
6618125d	146	int regnum, void *buf);
193cb69f AC	147
193cb69f AC	148
bb425013 AC	149	/* The type of a register. This function is slightly more efficient
bb425013 AC	150	then its gdbarch vector counterpart since it returns a precomputed
01e1877c	151	value stored in a table. */
bb425013 AC	152
	153	extern struct type register_type (struct gdbarch gdbarch, int regnum);
	154
	155
08a617da	156	/* Return the size of register REGNUM. All registers should have only
01e1877c	157	one size. */
08a617da AC	158
	159	extern int register_size (struct gdbarch *gdbarch, int regnum);
	160
	161
5602984a AC	162	/* Save/restore a register cache. The set of registers saved /
	163	restored into the DST regcache determined by the save_reggroup /
	164	restore_reggroup respectively. COOKED_READ returns zero iff the
	165	register's value can't be returned. */
	166
05d1431c PA	167	typedef enum register_status (regcache_cooked_read_ftype) (void *src,
	168	int regnum,
	169	gdb_byte *buf);
5602984a AC	170
	171	extern void regcache_save (struct regcache *dst,
	172	regcache_cooked_read_ftype *cooked_read,
2d522557	173	void *cooked_read_context);
5602984a AC	174	extern void regcache_restore (struct regcache *dst,
5602984a AC	175	regcache_cooked_read_ftype *cooked_read,
2d522557	176	void *cooked_read_context);
2d28509a	177
37e71372 AC	178	/* Copy/duplicate the contents of a register cache. By default, the
	179	operation is pass-through. Writes to DST and reads from SRC will
	180	go through to the target.
	181
	182	The ``cpy'' functions can not have overlapping SRC and DST buffers.
3fadccb3 AC	183
3fadccb3 AC	184	``no passthrough'' versions do not go through to the target. They
37e71372	185	only transfer values already in the cache. */
3fadccb3	186
3fadccb3	187	extern struct regcache regcache_dup (struct regcache regcache);
3fadccb3	188	extern void regcache_cpy (struct regcache dest, struct regcache src);
3e43a32a MS	189	extern void regcache_cpy_no_passthrough (struct regcache *dest,
3e43a32a MS	190	struct regcache *src);
3fadccb3	191
4e052eda	192	extern void registers_changed (void);
e66408ed	193	extern void registers_changed_ptid (ptid_t);
4e052eda	194
4e052eda	195	#endif /* REGCACHE_H */