1/* Machine independent variables that describe the core file under GDB.
2
3   Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4   1997, 1998, 1999, 2000, 2001, 2004, 2007 Free Software Foundation, Inc.
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
10   the Free Software Foundation; either version 3 of the License, or
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
19   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21/* Interface routines for core, executable, etc.  */
22
23#if !defined (GDBCORE_H)
24#define GDBCORE_H 1
25
26struct type;
27struct regcache;
28
29#include "bfd.h"
30
31/* Return the name of the executable file as a string.
32   ERR nonzero means get error if there is none specified;
33   otherwise return 0 in that case.  */
34
35extern char *get_exec_file (int err);
36
37/* Nonzero if there is a core file.  */
38
39extern int have_core_file_p (void);
40
41/* Read "memory data" from whatever target or inferior we have.
42   Returns zero if successful, errno value if not.  EIO is used for
43   address out of bounds.  If breakpoints are inserted, returns shadow
44   contents, not the breakpoints themselves.  From breakpoint.c.  */
45
46/* NOTE: cagney/2004-06-10: Code reading from a live inferior can use
47   the get_frame_memory methods, code reading from an exec can use the
48   target methods.  */
49
50extern int read_memory_nobpt (CORE_ADDR memaddr, gdb_byte *myaddr,
51			      unsigned len);
52
53/* Report a memory error with error().  */
54
55extern void memory_error (int status, CORE_ADDR memaddr);
56
57/* Like target_read_memory, but report an error if can't read.  */
58
59extern void read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
60
61/* Read an integer from debugged memory, given address and number of
62   bytes.  */
63
64extern LONGEST read_memory_integer (CORE_ADDR memaddr, int len);
65extern int safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value);
66
67/* Read an unsigned integer from debugged memory, given address and
68   number of bytes.  */
69
70extern ULONGEST read_memory_unsigned_integer (CORE_ADDR memaddr, int len);
71
72/* Read a null-terminated string from the debuggee's memory, given address,
73 * a buffer into which to place the string, and the maximum available space */
74
75extern void read_memory_string (CORE_ADDR, char *, int);
76
77/* Read the pointer of type TYPE at ADDR, and return the address it
78   represents. */
79
80CORE_ADDR read_memory_typed_address (CORE_ADDR addr, struct type *type);
81
82/* This takes a char *, not void *.  This is probably right, because
83   passing in an int * or whatever is wrong with respect to
84   byteswapping, alignment, different sizes for host vs. target types,
85   etc.  */
86
87extern void write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len);
88
89/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer.  */
90extern void write_memory_unsigned_integer (CORE_ADDR addr, int len,
91                                           ULONGEST value);
92
93/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer.  */
94extern void write_memory_signed_integer (CORE_ADDR addr, int len,
95                                         LONGEST value);
96
97extern void generic_search (int len, char *data, char *mask,
98			    CORE_ADDR startaddr, int increment,
99			    CORE_ADDR lorange, CORE_ADDR hirange,
100			    CORE_ADDR * addr_found, char *data_found);
101
102/* Hook for `exec_file_command' command to call.  */
103
104extern void (*deprecated_exec_file_display_hook) (char *filename);
105
106/* Hook for "file_command", which is more useful than above
107   (because it is invoked AFTER symbols are read, not before).  */
108
109extern void (*deprecated_file_changed_hook) (char *filename);
110
111extern void specify_exec_file_hook (void (*hook) (char *filename));
112
113/* Binary File Diddlers for the exec and core files.  */
114
115extern bfd *core_bfd;
116extern bfd *exec_bfd;
117
118/* Whether to open exec and core files read-only or read-write.  */
119
120extern int write_files;
121
122extern void core_file_command (char *filename, int from_tty);
123
124extern void exec_file_attach (char *filename, int from_tty);
125
126extern void exec_file_clear (int from_tty);
127
128extern void validate_files (void);
129
130/* The target vector for core files. */
131
132extern struct target_ops core_ops;
133
134/* The current default bfd target.  */
135
136extern char *gnutarget;
137
138extern void set_gnutarget (char *);
139
140/* Structure to keep track of core register reading functions for
141   various core file types.  */
142
143struct core_fns
144  {
145
146    /* BFD flavour that a core file handler is prepared to read.  This
147       can be used by the handler's core tasting function as a first
148       level filter to reject BFD's that don't have the right
149       flavour. */
150
151    enum bfd_flavour core_flavour;
152
153    /* Core file handler function to call to recognize corefile
154       formats that BFD rejects.  Some core file format just don't fit
155       into the BFD model, or may require other resources to identify
156       them, that simply aren't available to BFD (such as symbols from
157       another file).  Returns nonzero if the handler recognizes the
158       format, zero otherwise. */
159
160    int (*check_format) (bfd *);
161
162    /* Core file handler function to call to ask if it can handle a
163       given core file format or not.  Returns zero if it can't,
164       nonzero otherwise. */
165
166    int (*core_sniffer) (struct core_fns *, bfd *);
167
168    /* Extract the register values out of the core file and supply them
169       into REGCACHE.
170
171       CORE_REG_SECT points to the register values themselves, read into
172       memory.
173
174       CORE_REG_SIZE is the size of that area.
175
176       WHICH says which set of registers we are handling:
177         0 --- integer registers
178         2 --- floating-point registers, on machines where they are
179               discontiguous
180         3 --- extended floating-point registers, on machines where
181               these are present in yet a third area.  (GNU/Linux uses
182               this to get at the SSE registers.)
183
184       REG_ADDR is the offset from u.u_ar0 to the register values relative to
185       core_reg_sect.  This is used with old-fashioned core files to locate the
186       registers in a large upage-plus-stack ".reg" section.  Original upage
187       address X is at location core_reg_sect+x+reg_addr. */
188
189    void (*core_read_registers) (struct regcache *regcache,
190				 char *core_reg_sect,
191				 unsigned core_reg_size,
192				 int which, CORE_ADDR reg_addr);
193
194    /* Finds the next struct core_fns.  They are allocated and
195       initialized in whatever module implements the functions pointed
196       to; an initializer calls deprecated_add_core_fns to add them to
197       the global chain.  */
198
199    struct core_fns *next;
200
201  };
202
203/* NOTE: cagney/2004-04-05: Replaced by "regset.h" and
204   regset_from_core_section().  */
205extern void deprecated_add_core_fns (struct core_fns *cf);
206extern int default_core_sniffer (struct core_fns *cf, bfd * abfd);
207extern int default_check_format (bfd * abfd);
208
209#endif /* !defined (GDBCORE_H) */
210