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