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

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

   Copyright (C) 1986-2014 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 *);
extern struct regcache *get_thread_arch_aspace_regcache (ptid_t,
							 struct gdbarch *,
							 struct address_space *);

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);

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