1/* This file is automatically generated.  DO NOT EDIT! */
2/* Generated from: NetBSD: mknative-gdb,v 1.7 2016/10/16 04:37:42 mrg Exp  */
3/* Generated from: NetBSD: mknative.common,v 1.11 2014/02/17 21:39:43 christos Exp  */
4
5/* JIT declarations for GDB, the GNU Debugger.
6
7   Copyright (C) 2011-2016 Free Software Foundation, Inc.
8
9   This file is part of GDB.
10
11   This program is free software; you can redistribute it and/or modify
12   it under the terms of the GNU General Public License as published by
13   the Free Software Foundation; either version 3 of the License, or
14   (at your option) any later version.
15
16   This program is distributed in the hope that it will be useful,
17   but WITHOUT ANY WARRANTY; without even the implied warranty of
18   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19   GNU General Public License for more details.
20
21   You should have received a copy of the GNU General Public License
22   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
24#ifndef GDB_JIT_READER_H
25#define GDB_JIT_READER_H
26
27#ifdef __cplusplus
28extern "C" {
29#endif
30
31/* Versioning information.  See gdb_reader_funcs.  */
32
33#define GDB_READER_INTERFACE_VERSION 1
34
35/* Readers must be released under a GPL compatible license.  To
36   declare that the reader is indeed released under a GPL compatible
37   license, invoke the macro GDB_DECLARE_GPL_COMPATIBLE in a source
38   file.  */
39
40#ifdef __cplusplus
41#define GDB_DECLARE_GPL_COMPATIBLE_READER       \
42  extern "C" {                                  \
43  extern int plugin_is_GPL_compatible (void);   \
44  extern int plugin_is_GPL_compatible (void)    \
45  {                                             \
46    return 0;                                   \
47  }                                             \
48  }
49
50#else
51
52#define GDB_DECLARE_GPL_COMPATIBLE_READER       \
53  extern int plugin_is_GPL_compatible (void);   \
54  extern int plugin_is_GPL_compatible (void)    \
55  {                                             \
56    return 0;                                   \
57  }
58
59#endif
60
61/* Represents an address on the target system.  */
62
63typedef unsigned long long GDB_CORE_ADDR;
64
65/* Return status codes.  */
66
67enum gdb_status {
68  GDB_FAIL = 0,
69  GDB_SUCCESS = 1
70};
71
72struct gdb_object;
73struct gdb_symtab;
74struct gdb_block;
75struct gdb_symbol_callbacks;
76
77/* An array of these are used to represent a map from code addresses to line
78   numbers in the source file.  */
79
80struct gdb_line_mapping
81{
82  int line;
83  GDB_CORE_ADDR pc;
84};
85
86/* Create a new GDB code object.  Each code object can have one or
87   more symbol tables, each representing a compiled source file.  */
88
89typedef struct gdb_object *(gdb_object_open) (struct gdb_symbol_callbacks *cb);
90
91/* The callback used to create new symbol table.  CB is the
92   gdb_symbol_callbacks which the structure is part of.  FILE_NAME is
93   an (optionally NULL) file name to associate with this new symbol
94   table.
95
96   Returns a new instance to gdb_symtab that can later be passed to
97   gdb_block_new, gdb_symtab_add_line_mapping and gdb_symtab_close.  */
98
99typedef struct gdb_symtab *(gdb_symtab_open) (struct gdb_symbol_callbacks *cb,
100                                              struct gdb_object *obj,
101                                              const char *file_name);
102
103/* Creates a new block in a given symbol table.  A symbol table is a
104   forest of blocks, each block representing an code address range and
105   a corresponding (optionally NULL) NAME.  In case the block
106   corresponds to a function, the NAME passed should be the name of
107   the function.
108
109   If the new block to be created is a child of (i.e. is nested in)
110   another block, the parent block can be passed in PARENT.  SYMTAB is
111   the symbol table the new block is to belong in.  BEGIN, END is the
112   code address range the block corresponds to.
113
114   Returns a new instance of gdb_block, which, as of now, has no use.
115   Note that the gdb_block returned must not be freed by the
116   caller.  */
117
118typedef struct gdb_block *(gdb_block_open) (struct gdb_symbol_callbacks *cb,
119                                            struct gdb_symtab *symtab,
120                                            struct gdb_block *parent,
121                                            GDB_CORE_ADDR begin,
122                                            GDB_CORE_ADDR end,
123                                            const char *name);
124
125/* Adds a PC to line number mapping for the symbol table SYMTAB.
126   NLINES is the number of elements in LINES, each element
127   corresponding to one (PC, line) pair.  */
128
129typedef void (gdb_symtab_add_line_mapping) (struct gdb_symbol_callbacks *cb,
130                                            struct gdb_symtab *symtab,
131                                            int nlines,
132                                            struct gdb_line_mapping *lines);
133
134/* Close the symtab SYMTAB.  This signals to GDB that no more blocks
135   will be opened on this symtab.  */
136
137typedef void (gdb_symtab_close) (struct gdb_symbol_callbacks *cb,
138                                 struct gdb_symtab *symtab);
139
140
141/* Closes the gdb_object OBJ and adds the emitted information into
142   GDB's internal structures.  Once this is done, the debug
143   information will be picked up and used; this will usually be the
144   last operation in gdb_read_debug_info.  */
145
146typedef void (gdb_object_close) (struct gdb_symbol_callbacks *cb,
147                                 struct gdb_object *obj);
148
149/* Reads LEN bytes from TARGET_MEM in the target's virtual address
150   space into GDB_BUF.
151
152   Returns GDB_FAIL on failure, and GDB_SUCCESS on success.  */
153
154typedef enum gdb_status (gdb_target_read) (GDB_CORE_ADDR target_mem,
155                                           void *gdb_buf, int len);
156
157/* The list of callbacks that are passed to read.  These callbacks are
158   to be used to construct the symbol table.  The functions have been
159   described above.  */
160
161struct gdb_symbol_callbacks
162{
163  gdb_object_open *object_open;
164  gdb_symtab_open *symtab_open;
165  gdb_block_open *block_open;
166  gdb_symtab_close *symtab_close;
167  gdb_object_close *object_close;
168
169  gdb_symtab_add_line_mapping *line_mapping_add;
170  gdb_target_read *target_read;
171
172  /* For internal use by GDB.  */
173  void *priv_data;
174};
175
176/* Forward declaration.  */
177
178struct gdb_reg_value;
179
180/* A function of this type is used to free a gdb_reg_value.  See the
181   comment on `free' in struct gdb_reg_value.  */
182
183typedef void (gdb_reg_value_free) (struct gdb_reg_value *);
184
185/* Denotes the value of a register.  */
186
187struct gdb_reg_value
188{
189  /* The size of the register in bytes.  The reader need not set this
190     field.  This will be set for (defined) register values being read
191     from GDB using reg_get.  */
192  int size;
193
194  /* Set to non-zero if the value for the register is known.  The
195     registers for which the reader does not call reg_set are also
196     assumed to be undefined */
197  int defined;
198
199  /* Since gdb_reg_value is a variable sized structure, it will
200     usually be allocated on the heap.  This function is expected to
201     contain the corresponding "free" function.
202
203     When a pointer to gdb_reg_value is being sent from GDB to the
204     reader (via gdb_unwind_reg_get), the reader is expected to call
205     this function (with the same gdb_reg_value as argument) once it
206     is done with the value.
207
208     When the function sends the a gdb_reg_value to GDB (via
209     gdb_unwind_reg_set), it is expected to set this field to point to
210     an appropriate cleanup routine (or to NULL if no cleanup is
211     required).  */
212  gdb_reg_value_free *free;
213
214  /* The value of the register.  */
215  unsigned char value[1];
216};
217
218/* get_frame_id in gdb_reader_funcs is to return a gdb_frame_id
219   corresponding to the current frame.  The registers corresponding to
220   the current frame can be read using reg_get.  Calling get_frame_id
221   on a particular frame should return the same gdb_frame_id
222   throughout its lifetime (i.e. till before it gets unwound).  One
223   way to do this is by having the CODE_ADDRESS point to the
224   function's first instruction and STACK_ADDRESS point to the value
225   of the stack pointer when entering the function.  */
226
227struct gdb_frame_id
228{
229  GDB_CORE_ADDR code_address;
230  GDB_CORE_ADDR stack_address;
231};
232
233/* Forward declaration.  */
234
235struct gdb_unwind_callbacks;
236
237/* Returns the value of a particular register in the current frame.
238   The current frame is the frame that needs to be unwound into the
239   outer (earlier) frame.
240
241   CB is the struct gdb_unwind_callbacks * the callback belongs to.
242   REGNUM is the DWARF register number of the register that needs to
243   be unwound.
244
245   Returns the gdb_reg_value corresponding to the register requested.
246   In case the value of the register has been optimized away or
247   otherwise unavailable, the defined flag in the returned
248   gdb_reg_value will be zero.  */
249
250typedef struct gdb_reg_value *(gdb_unwind_reg_get)
251                              (struct gdb_unwind_callbacks *cb, int regnum);
252
253/* Sets the previous value of a particular register.  REGNUM is the
254   (DWARF) register number whose value is to be set.  VAL is the value
255   the register is to be set to.
256
257   VAL is *not* copied, so the memory allocated to it cannot be
258   reused.  Once GDB no longer needs the value, it is deallocated
259   using the FREE function (see gdb_reg_value).
260
261   A register can also be "set" to an undefined value by setting the
262   defined in VAL to zero.  */
263
264typedef void (gdb_unwind_reg_set) (struct gdb_unwind_callbacks *cb, int regnum,
265                                   struct gdb_reg_value *val);
266
267/* This struct is passed to unwind in gdb_reader_funcs, and is to be
268   used to unwind the current frame (current being the frame whose
269   registers can be read using reg_get) into the earlier frame.  The
270   functions have been described above.  */
271
272struct gdb_unwind_callbacks
273{
274  gdb_unwind_reg_get *reg_get;
275  gdb_unwind_reg_set *reg_set;
276  gdb_target_read *target_read;
277
278  /* For internal use by GDB.  */
279  void *priv_data;
280};
281
282/* Forward declaration.  */
283
284struct gdb_reader_funcs;
285
286/* Parse the debug info off a block of memory, pointed to by MEMORY
287   (already copied to GDB's address space) and MEMORY_SZ bytes long.
288   The implementation has to use the functions in CB to actually emit
289   the parsed data into GDB.  SELF is the same structure returned by
290   gdb_init_reader.
291
292   Return GDB_FAIL on failure and GDB_SUCCESS on success.  */
293
294typedef enum gdb_status (gdb_read_debug_info) (struct gdb_reader_funcs *self,
295                                               struct gdb_symbol_callbacks *cb,
296                                               void *memory, long memory_sz);
297
298/* Unwind the current frame, CB is the set of unwind callbacks that
299   are to be used to do this.
300
301   Return GDB_FAIL on failure and GDB_SUCCESS on success.  */
302
303typedef enum gdb_status (gdb_unwind_frame) (struct gdb_reader_funcs *self,
304                                            struct gdb_unwind_callbacks *cb);
305
306/* Return the frame ID corresponding to the current frame, using C to
307   read the current register values.  See the comment on struct
308   gdb_frame_id.  */
309
310typedef struct gdb_frame_id (gdb_get_frame_id) (struct gdb_reader_funcs *self,
311                                                struct gdb_unwind_callbacks *c);
312
313/* Called when a reader is being unloaded.  This function should also
314   free SELF, if required.  */
315
316typedef void (gdb_destroy_reader) (struct gdb_reader_funcs *self);
317
318/* Called when the reader is loaded.  Must either return a properly
319   populated gdb_reader_funcs or NULL.  The memory allocated for the
320   gdb_reader_funcs is to be managed by the reader itself (i.e. if it
321   is allocated from the heap, it must also be freed in
322   gdb_destroy_reader).  */
323
324extern struct gdb_reader_funcs *gdb_init_reader (void);
325
326/* Pointer to the functions which implement the reader's
327   functionality.  The individual functions have been documented
328   above.
329
330   None of the fields are optional.  */
331
332struct gdb_reader_funcs
333{
334  /* Must be set to GDB_READER_INTERFACE_VERSION.  */
335  int reader_version;
336
337  /* For use by the reader.  */
338  void *priv_data;
339
340  gdb_read_debug_info *read;
341  gdb_unwind_frame *unwind;
342  gdb_get_frame_id *get_frame_id;
343  gdb_destroy_reader *destroy;
344};
345
346#ifdef __cplusplus
347} /* extern "C" */
348#endif
349
350#endif
351