[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
	1	/* Cache and manage the values of registers for GDB, the GNU debugger.
	2
	3	Copyright (C) 1986-2014 Free Software Foundation, Inc.
	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
	9	the Free Software Foundation; either version 3 of the License, or
	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
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#ifndef REGCACHE_H
	21	#define REGCACHE_H
	22
	23	struct regcache;
	24	struct gdbarch;
	25	struct address_space;
	26
	27	extern struct regcache *get_current_regcache (void);
	28	extern struct regcache *get_thread_regcache (ptid_t ptid);
	29	extern struct regcache get_thread_arch_regcache (ptid_t, struct gdbarch );
	30	extern struct regcache *get_thread_arch_aspace_regcache (ptid_t,
	31	struct gdbarch *,
	32	struct address_space *);
	33
	34	void regcache_xfree (struct regcache *regcache);
	35	struct cleanup make_cleanup_regcache_xfree (struct regcache regcache);
	36	struct regcache regcache_xmalloc (struct gdbarch gdbarch,
	37	struct address_space *aspace);
	38
	39	/* Return REGCACHE's architecture. */
	40
	41	extern struct gdbarch get_regcache_arch (const struct regcache regcache);
	42
	43	/* Return REGCACHE's address space. */
	44
	45	extern struct address_space get_regcache_aspace (const struct regcache );
	46
	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
	68	/* Transfer a raw register [0..NUM_REGS) between core-gdb and the
	69	regcache. The read variants return the status of the register. */
	70
	71	enum register_status regcache_raw_read (struct regcache *regcache,
	72	int rawnum, gdb_byte *buf);
	73	void regcache_raw_write (struct regcache *regcache, int rawnum,
	74	const gdb_byte *buf);
	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);
	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);
	85
	86	/* Partial transfer of raw registers. These perform read, modify,
	87	write style operations. The read variant returns the status of the
	88	register. */
	89
	90	extern enum register_status
	91	regcache_raw_read_part (struct regcache *regcache, int regnum,
	92	int offset, int len, gdb_byte *buf);
	93	void regcache_raw_write_part (struct regcache *regcache, int regnum,
	94	int offset, int len, const gdb_byte *buf);
	95
	96	void regcache_invalidate (struct regcache *regcache, int regnum);
	97
	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
	103	/* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
	104	enum register_status regcache_cooked_read (struct regcache *regcache,
	105	int rawnum, gdb_byte *buf);
	106	void regcache_cooked_write (struct regcache *regcache, int rawnum,
	107	const gdb_byte *buf);
	108
	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
	115	/* Read a register as a signed/unsigned quantity. */
	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);
	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);
	126
	127	/* Partial transfer of a cooked register. These perform read, modify,
	128	write style operations. */
	129
	130	enum register_status regcache_cooked_read_part (struct regcache *regcache,
	131	int regnum, int offset,
	132	int len, gdb_byte *buf);
	133	void regcache_cooked_write_part (struct regcache *regcache, int regnum,
	134	int offset, int len, const gdb_byte *buf);
	135
	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
	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
	145	extern void regcache_raw_supply (struct regcache *regcache,
	146	int regnum, const void *buf);
	147	extern void regcache_raw_collect (const struct regcache *regcache,
	148	int regnum, void *buf);
	149
	150
	151	/* The type of a register. This function is slightly more efficient
	152	then its gdbarch vector counterpart since it returns a precomputed
	153	value stored in a table. */
	154
	155	extern struct type register_type (struct gdbarch gdbarch, int regnum);
	156
	157
	158	/* Return the size of register REGNUM. All registers should have only
	159	one size. */
	160
	161	extern int register_size (struct gdbarch *gdbarch, int regnum);
	162
	163
	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
	169	typedef enum register_status (regcache_cooked_read_ftype) (void *src,
	170	int regnum,
	171	gdb_byte *buf);
	172
	173	extern void regcache_save (struct regcache *dst,
	174	regcache_cooked_read_ftype *cooked_read,
	175	void *cooked_read_context);
	176
	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.
	182
	183	``no passthrough'' versions do not go through to the target. They
	184	only transfer values already in the cache. */
	185
	186	extern struct regcache regcache_dup (struct regcache regcache);
	187	extern void regcache_cpy (struct regcache dest, struct regcache src);
	188	extern void regcache_cpy_no_passthrough (struct regcache *dest,
	189	struct regcache *src);
	190
	191	extern void registers_changed (void);
	192	extern void registers_changed_ptid (ptid_t);
	193
	194	#endif /* REGCACHE_H */