[deliverable/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 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
a378f419	107	/* Read a register as a signed/unsigned quantity. */
05d1431c PA	108	extern enum register_status
	109	regcache_cooked_read_signed (struct regcache *regcache,
	110	int regnum, LONGEST *val);
	111	extern enum register_status
	112	regcache_cooked_read_unsigned (struct regcache *regcache,
	113	int regnum, ULONGEST *val);
a66a9c23 AC	114	extern void regcache_cooked_write_signed (struct regcache *regcache,
	115	int regnum, LONGEST val);
	116	extern void regcache_cooked_write_unsigned (struct regcache *regcache,
	117	int regnum, ULONGEST val);
a378f419	118
06c0b04e AC	119	/* Partial transfer of a cooked register. These perform read, modify,
	120	write style operations. */
	121
05d1431c PA	122	enum register_status regcache_cooked_read_part (struct regcache *regcache,
	123	int regnum, int offset,
	124	int len, gdb_byte *buf);
06c0b04e	125	void regcache_cooked_write_part (struct regcache *regcache, int regnum,
2d522557	126	int offset, int len, const gdb_byte *buf);
06c0b04e	127
515630c5 UW	128	/* Special routines to read/write the PC. */
	129
	130	extern CORE_ADDR regcache_read_pc (struct regcache *regcache);
	131	extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
	132
193cb69f AC	133	/* Transfer a raw register [0..NUM_REGS) between the regcache and the
	134	target. These functions are called by the target in response to a
	135	target_fetch_registers() or target_store_registers(). */
	136
9a661b68	137	extern void regcache_raw_supply (struct regcache *regcache,
6618125d	138	int regnum, const void *buf);
9a661b68	139	extern void regcache_raw_collect (const struct regcache *regcache,
6618125d	140	int regnum, void *buf);
193cb69f AC	141
193cb69f AC	142
bb425013 AC	143	/* The type of a register. This function is slightly more efficient
bb425013 AC	144	then its gdbarch vector counterpart since it returns a precomputed
01e1877c	145	value stored in a table. */
bb425013 AC	146
	147	extern struct type register_type (struct gdbarch gdbarch, int regnum);
	148
	149
08a617da	150	/* Return the size of register REGNUM. All registers should have only
01e1877c	151	one size. */
08a617da AC	152
	153	extern int register_size (struct gdbarch *gdbarch, int regnum);
	154
	155
5602984a AC	156	/* Save/restore a register cache. The set of registers saved /
	157	restored into the DST regcache determined by the save_reggroup /
	158	restore_reggroup respectively. COOKED_READ returns zero iff the
	159	register's value can't be returned. */
	160
05d1431c PA	161	typedef enum register_status (regcache_cooked_read_ftype) (void *src,
	162	int regnum,
	163	gdb_byte *buf);
5602984a AC	164
	165	extern void regcache_save (struct regcache *dst,
	166	regcache_cooked_read_ftype *cooked_read,
2d522557	167	void *cooked_read_context);
5602984a AC	168	extern void regcache_restore (struct regcache *dst,
5602984a AC	169	regcache_cooked_read_ftype *cooked_read,
2d522557	170	void *cooked_read_context);
2d28509a	171
37e71372 AC	172	/* Copy/duplicate the contents of a register cache. By default, the
	173	operation is pass-through. Writes to DST and reads from SRC will
	174	go through to the target.
	175
	176	The ``cpy'' functions can not have overlapping SRC and DST buffers.
3fadccb3 AC	177
3fadccb3 AC	178	``no passthrough'' versions do not go through to the target. They
37e71372	179	only transfer values already in the cache. */
3fadccb3	180
3fadccb3	181	extern struct regcache regcache_dup (struct regcache regcache);
3fadccb3	182	extern void regcache_cpy (struct regcache dest, struct regcache src);
3e43a32a MS	183	extern void regcache_cpy_no_passthrough (struct regcache *dest,
3e43a32a MS	184	struct regcache *src);
3fadccb3	185
4e052eda	186	extern void registers_changed (void);
e66408ed	187	extern void registers_changed_ptid (ptid_t);
4e052eda	188
4e052eda	189	#endif /* REGCACHE_H */