OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [gdbcore.h] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Machine independent variables that describe the core file under GDB.
2
   Copyright 1986, 1987, 1989, 1990, 1992, 1995 Free Software Foundation, Inc.
3
 
4
   This file is part of GDB.
5
 
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 2 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 59 Temple Place - Suite 330,
19
   Boston, MA 02111-1307, USA.  */
20
 
21
/* Interface routines for core, executable, etc.  */
22
 
23
#if !defined (GDBCORE_H)
24
#define GDBCORE_H 1
25
 
26
#include "bfd.h"
27
 
28
/* Return the name of the executable file as a string.
29
   ERR nonzero means get error if there is none specified;
30
   otherwise return 0 in that case.  */
31
 
32
extern char *get_exec_file PARAMS ((int err));
33
 
34
/* Nonzero if there is a core file.  */
35
 
36
extern int have_core_file_p PARAMS ((void));
37
 
38
/* Read "memory data" from whatever target or inferior we have.
39
   Returns zero if successful, errno value if not.  EIO is used for
40
   address out of bounds.  If breakpoints are inserted, returns shadow
41
   contents, not the breakpoints themselves.  From breakpoint.c.  */
42
 
43
extern int read_memory_nobpt PARAMS ((CORE_ADDR memaddr, char *myaddr,
44
                                      unsigned len));
45
 
46
/* Report a memory error with error().  */
47
 
48
extern void memory_error PARAMS ((int status, CORE_ADDR memaddr));
49
 
50
/* Like target_read_memory, but report an error if can't read.  */
51
 
52
extern void read_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len));
53
 
54
extern void read_memory_section PARAMS ((CORE_ADDR memaddr, char *myaddr,
55
                                         int len, asection * bfd_section));
56
 
57
/* Read an integer from debugged memory, given address and number of
58
   bytes.  */
59
 
60
extern LONGEST read_memory_integer PARAMS ((CORE_ADDR memaddr, int len));
61
 
62
/* Read an unsigned integer from debugged memory, given address and
63
   number of bytes.  */
64
 
65
extern ULONGEST read_memory_unsigned_integer PARAMS ((CORE_ADDR memaddr, int len));
66
 
67
/* Read a null-terminated string from the debuggee's memory, given address,
68
 * a buffer into which to place the string, and the maximum available space */
69
extern void read_memory_string PARAMS ((CORE_ADDR, char *, int));
70
 
71
/* This takes a char *, not void *.  This is probably right, because
72
   passing in an int * or whatever is wrong with respect to
73
   byteswapping, alignment, different sizes for host vs. target types,
74
   etc.  */
75
 
76
extern void write_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len));
77
 
78
extern void generic_search PARAMS ((int len, char *data, char *mask,
79
                                    CORE_ADDR startaddr, int increment,
80
                                    CORE_ADDR lorange, CORE_ADDR hirange,
81
                                 CORE_ADDR * addr_found, char *data_found));
82
 
83
/* Hook for `exec_file_command' command to call.  */
84
 
85
extern void (*exec_file_display_hook) PARAMS ((char *filename));
86
 
87
/* Hook for "file_command", which is more useful than above
88
   (because it is invoked AFTER symbols are read, not before) */
89
 
90
extern void (*file_changed_hook) PARAMS ((char *filename));
91
 
92
extern void specify_exec_file_hook PARAMS ((void (*hook) (char *filename)));
93
 
94
/* Binary File Diddlers for the exec and core files */
95
 
96
extern bfd *core_bfd;
97
extern bfd *exec_bfd;
98
 
99
/* Whether to open exec and core files read-only or read-write.  */
100
 
101
extern int write_files;
102
 
103
extern void core_file_command PARAMS ((char *filename, int from_tty));
104
 
105
extern void exec_file_attach PARAMS ((char *filename, int from_tty));
106
 
107
extern void exec_file_command PARAMS ((char *filename, int from_tty));
108
 
109
extern void validate_files PARAMS ((void));
110
 
111
extern CORE_ADDR register_addr PARAMS ((int regno, CORE_ADDR blockend));
112
 
113
extern void registers_fetched PARAMS ((void));
114
 
115
#if !defined (KERNEL_U_ADDR)
116
extern CORE_ADDR kernel_u_addr;
117
#define KERNEL_U_ADDR kernel_u_addr
118
#endif
119
 
120
/* The target vector for core files. */
121
 
122
extern struct target_ops core_ops;
123
 
124
/* The current default bfd target.  */
125
 
126
extern char *gnutarget;
127
 
128
extern void set_gnutarget PARAMS ((char *));
129
 
130
/* Structure to keep track of core register reading functions for
131
   various core file types.  */
132
 
133
struct core_fns
134
  {
135
 
136
    /* BFD flavour that a core file handler is prepared to read.  This
137
       can be used by the handler's core tasting function as a first
138
       level filter to reject BFD's that don't have the right
139
       flavour. */
140
 
141
    enum bfd_flavour core_flavour;
142
 
143
    /* Core file handler function to call to recognize corefile
144
       formats that BFD rejects.  Some core file format just don't fit
145
       into the BFD model, or may require other resources to identify
146
       them, that simply aren't available to BFD (such as symbols from
147
       another file).  Returns nonzero if the handler recognizes the
148
       format, zero otherwise. */
149
 
150
    int (*check_format) PARAMS ((bfd *));
151
 
152
    /* Core file handler function to call to ask if it can handle a
153
       given core file format or not.  Returns zero if it can't,
154
       nonzero otherwise. */
155
 
156
    int (*core_sniffer) PARAMS ((struct core_fns *, bfd *));
157
 
158
    /* Extract the register values out of the core file and store them where
159
       `read_register' will find them.
160
 
161
       CORE_REG_SECT points to the register values themselves, read into
162
       memory.
163
 
164
       CORE_REG_SIZE is the size of that area.
165
 
166
       WHICH says which set of registers we are handling:
167
 
168
         2 --- floating-point registers, on machines where they are
169
               discontiguous
170
         3 --- extended floating-point registers, on machines where
171
               these are present in yet a third area.  (GNU/Linux uses
172
               this to get at the SSE registers.)
173
 
174
       REG_ADDR is the offset from u.u_ar0 to the register values relative to
175
       core_reg_sect.  This is used with old-fashioned core files to locate the
176
       registers in a large upage-plus-stack ".reg" section.  Original upage
177
       address X is at location core_reg_sect+x+reg_addr. */
178
 
179
    void (*core_read_registers) PARAMS ((char *core_reg_sect,
180
                                         unsigned core_reg_size,
181
                                         int which, CORE_ADDR reg_addr));
182
 
183
    /* Finds the next struct core_fns.  They are allocated and initialized
184
       in whatever module implements the functions pointed to; an
185
       initializer calls add_core_fns to add them to the global chain.  */
186
 
187
    struct core_fns *next;
188
 
189
  };
190
 
191
extern void add_core_fns PARAMS ((struct core_fns * cf));
192
extern int default_core_sniffer PARAMS ((struct core_fns *cf, bfd *abfd));
193
extern int default_check_format PARAMS ((bfd *abfd));
194
 
195
#endif /* !defined (GDBCORE_H) */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.