Commit | Line | Data |
---|---|---|
fbbe92c5 SDJ |
1 | /* Functions that provide the mechanism to parse a syscall XML file |
2 | and get its values. | |
3 | ||
61baf725 | 4 | Copyright (C) 2009-2017 Free Software Foundation, Inc. |
fbbe92c5 SDJ |
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 | #include "defs.h" | |
22 | #include "gdbtypes.h" | |
23 | #include "xml-support.h" | |
24 | #include "xml-syscall.h" | |
458c8db8 | 25 | #include "gdbarch.h" |
fbbe92c5 SDJ |
26 | |
27 | /* For the struct syscall definition. */ | |
28 | #include "target.h" | |
29 | ||
30 | #include "filenames.h" | |
31 | ||
fbbe92c5 SDJ |
32 | #ifndef HAVE_LIBEXPAT |
33 | ||
34 | /* Dummy functions to indicate that there's no support for fetching | |
35 | syscalls information. */ | |
36 | ||
37 | static void | |
38 | syscall_warn_user (void) | |
39 | { | |
40 | static int have_warned = 0; | |
41 | if (!have_warned) | |
42 | { | |
43 | have_warned = 1; | |
44 | warning (_("Can not parse XML syscalls information; XML support was " | |
45 | "disabled at compile time.")); | |
46 | } | |
47 | } | |
48 | ||
49 | void | |
7e7cbeb3 | 50 | set_xml_syscall_file_name (struct gdbarch *gdbarch, const char *name) |
fbbe92c5 | 51 | { |
bccd0dd2 | 52 | return; |
fbbe92c5 SDJ |
53 | } |
54 | ||
55 | void | |
7e7cbeb3 | 56 | get_syscall_by_number (struct gdbarch *gdbarch, |
458c8db8 | 57 | int syscall_number, struct syscall *s) |
fbbe92c5 SDJ |
58 | { |
59 | syscall_warn_user (); | |
60 | s->number = syscall_number; | |
61 | s->name = NULL; | |
62 | } | |
63 | ||
64 | void | |
7e7cbeb3 SDJ |
65 | get_syscall_by_name (struct gdbarch *gdbarch, const char *syscall_name, |
66 | struct syscall *s) | |
fbbe92c5 SDJ |
67 | { |
68 | syscall_warn_user (); | |
69 | s->number = UNKNOWN_SYSCALL; | |
70 | s->name = syscall_name; | |
71 | } | |
72 | ||
73 | const char ** | |
7e7cbeb3 | 74 | get_syscall_names (struct gdbarch *gdbarch) |
fbbe92c5 SDJ |
75 | { |
76 | syscall_warn_user (); | |
77 | return NULL; | |
78 | } | |
79 | ||
e3487908 GKB |
80 | struct syscall * |
81 | get_syscalls_by_group (struct gdbarch *gdbarch, const char *group) | |
82 | { | |
83 | syscall_warn_user (); | |
84 | return NULL; | |
85 | } | |
86 | ||
87 | const char ** | |
88 | get_syscall_group_names (struct gdbarch *gdbarch) | |
89 | { | |
90 | syscall_warn_user (); | |
91 | return NULL; | |
92 | } | |
93 | ||
fbbe92c5 SDJ |
94 | #else /* ! HAVE_LIBEXPAT */ |
95 | ||
96 | /* Structure which describes a syscall. */ | |
97 | typedef struct syscall_desc | |
98 | { | |
99 | /* The syscall number. */ | |
100 | ||
101 | int number; | |
102 | ||
103 | /* The syscall name. */ | |
104 | ||
105 | char *name; | |
106 | } *syscall_desc_p; | |
107 | DEF_VEC_P(syscall_desc_p); | |
108 | ||
e3487908 GKB |
109 | /* Structure of a syscall group. */ |
110 | typedef struct syscall_group_desc | |
111 | { | |
112 | /* The group name. */ | |
113 | ||
114 | char *name; | |
115 | ||
116 | /* The syscalls that are part of the group. */ | |
117 | ||
118 | VEC(syscall_desc_p) *syscalls; | |
119 | } *syscall_group_desc_p; | |
120 | DEF_VEC_P(syscall_group_desc_p); | |
121 | ||
fbbe92c5 SDJ |
122 | /* Structure that represents syscalls information. */ |
123 | struct syscalls_info | |
124 | { | |
125 | /* The syscalls. */ | |
126 | ||
127 | VEC(syscall_desc_p) *syscalls; | |
458c8db8 | 128 | |
e3487908 GKB |
129 | /* The syscall groups. */ |
130 | ||
131 | VEC(syscall_group_desc_p) *groups; | |
132 | ||
458c8db8 SDJ |
133 | /* Variable that will hold the last known data-directory. This is |
134 | useful to know whether we should re-read the XML info for the | |
135 | target. */ | |
136 | ||
137 | char *my_gdb_datadir; | |
fbbe92c5 SDJ |
138 | }; |
139 | ||
140 | /* Callback data for syscall information parsing. */ | |
141 | struct syscall_parsing_data | |
142 | { | |
143 | /* The syscalls_info we are building. */ | |
144 | ||
458c8db8 | 145 | struct syscalls_info *syscalls_info; |
fbbe92c5 SDJ |
146 | }; |
147 | ||
fbbe92c5 SDJ |
148 | static struct syscalls_info * |
149 | allocate_syscalls_info (void) | |
150 | { | |
41bf6aca | 151 | return XCNEW (struct syscalls_info); |
fbbe92c5 SDJ |
152 | } |
153 | ||
154 | static void | |
458c8db8 | 155 | syscalls_info_free_syscalls_desc (struct syscall_desc *sd) |
fbbe92c5 SDJ |
156 | { |
157 | xfree (sd->name); | |
158 | } | |
159 | ||
e3487908 GKB |
160 | /* Free syscall_group_desc members but not the structure itself. */ |
161 | ||
162 | static void | |
163 | syscalls_info_free_syscall_group_desc (struct syscall_group_desc *sd) | |
164 | { | |
165 | VEC_free (syscall_desc_p, sd->syscalls); | |
166 | xfree (sd->name); | |
167 | } | |
168 | ||
fbbe92c5 SDJ |
169 | static void |
170 | free_syscalls_info (void *arg) | |
171 | { | |
19ba03f4 | 172 | struct syscalls_info *syscalls_info = (struct syscalls_info *) arg; |
fbbe92c5 | 173 | struct syscall_desc *sysdesc; |
e3487908 | 174 | struct syscall_group_desc *groupdesc; |
fbbe92c5 SDJ |
175 | int i; |
176 | ||
458c8db8 SDJ |
177 | xfree (syscalls_info->my_gdb_datadir); |
178 | ||
179 | if (syscalls_info->syscalls != NULL) | |
180 | { | |
181 | for (i = 0; | |
182 | VEC_iterate (syscall_desc_p, syscalls_info->syscalls, i, sysdesc); | |
183 | i++) | |
184 | syscalls_info_free_syscalls_desc (sysdesc); | |
185 | VEC_free (syscall_desc_p, syscalls_info->syscalls); | |
186 | } | |
fbbe92c5 | 187 | |
e3487908 GKB |
188 | if (syscalls_info->groups != NULL) |
189 | { | |
190 | for (i = 0; | |
191 | VEC_iterate (syscall_group_desc_p, | |
192 | syscalls_info->groups, i, groupdesc); | |
193 | i++) | |
194 | syscalls_info_free_syscall_group_desc (groupdesc); | |
195 | ||
196 | VEC_free (syscall_group_desc_p, syscalls_info->groups); | |
197 | } | |
198 | ||
458c8db8 | 199 | xfree (syscalls_info); |
fbbe92c5 SDJ |
200 | } |
201 | ||
70221824 | 202 | static struct cleanup * |
458c8db8 | 203 | make_cleanup_free_syscalls_info (struct syscalls_info *syscalls_info) |
fbbe92c5 | 204 | { |
458c8db8 | 205 | return make_cleanup (free_syscalls_info, syscalls_info); |
fbbe92c5 SDJ |
206 | } |
207 | ||
e3487908 GKB |
208 | /* Create a new syscall group. Return pointer to the |
209 | syscall_group_desc structure that represents the new group. */ | |
210 | ||
211 | static struct syscall_group_desc * | |
212 | syscall_group_create_syscall_group_desc (struct syscalls_info *syscalls_info, | |
213 | const char *group) | |
214 | { | |
215 | struct syscall_group_desc *groupdesc = XCNEW (struct syscall_group_desc); | |
216 | ||
217 | groupdesc->name = xstrdup (group); | |
218 | ||
219 | VEC_safe_push (syscall_group_desc_p, syscalls_info->groups, groupdesc); | |
220 | ||
221 | return groupdesc; | |
222 | } | |
223 | ||
224 | /* Add a syscall to the group. If group doesn't exist, create it. */ | |
225 | ||
226 | static void | |
227 | syscall_group_add_syscall (struct syscalls_info *syscalls_info, | |
228 | struct syscall_desc *syscall, | |
229 | const char *group) | |
230 | { | |
231 | struct syscall_group_desc *groupdesc = NULL; | |
232 | int i; | |
233 | ||
234 | /* Search for an existing group. */ | |
235 | for (i = 0; | |
236 | VEC_iterate (syscall_group_desc_p, syscalls_info->groups, i, groupdesc); | |
237 | i++) | |
238 | { | |
239 | if (strcmp (groupdesc->name, group) == 0) | |
240 | break; | |
241 | } | |
242 | ||
243 | if (groupdesc == NULL) | |
244 | { | |
245 | /* No group was found with this name. We must create a new | |
246 | one. */ | |
247 | groupdesc = syscall_group_create_syscall_group_desc (syscalls_info, | |
248 | group); | |
249 | } | |
250 | ||
251 | VEC_safe_push (syscall_desc_p, groupdesc->syscalls, syscall); | |
252 | } | |
253 | ||
fbbe92c5 | 254 | static void |
458c8db8 | 255 | syscall_create_syscall_desc (struct syscalls_info *syscalls_info, |
e3487908 GKB |
256 | const char *name, int number, |
257 | char *groups) | |
fbbe92c5 | 258 | { |
41bf6aca | 259 | struct syscall_desc *sysdesc = XCNEW (struct syscall_desc); |
e3487908 | 260 | char *group; |
fbbe92c5 SDJ |
261 | |
262 | sysdesc->name = xstrdup (name); | |
263 | sysdesc->number = number; | |
264 | ||
458c8db8 | 265 | VEC_safe_push (syscall_desc_p, syscalls_info->syscalls, sysdesc); |
e3487908 GKB |
266 | |
267 | /* Add syscall to its groups. */ | |
268 | if (groups != NULL) | |
269 | { | |
270 | for (group = strtok (groups, ","); | |
271 | group != NULL; | |
272 | group = strtok (NULL, ",")) | |
273 | syscall_group_add_syscall (syscalls_info, sysdesc, group); | |
274 | } | |
fbbe92c5 SDJ |
275 | } |
276 | ||
fbbe92c5 SDJ |
277 | /* Handle the start of a <syscall> element. */ |
278 | static void | |
279 | syscall_start_syscall (struct gdb_xml_parser *parser, | |
280 | const struct gdb_xml_element *element, | |
281 | void *user_data, VEC(gdb_xml_value_s) *attributes) | |
282 | { | |
19ba03f4 | 283 | struct syscall_parsing_data *data = (struct syscall_parsing_data *) user_data; |
fbbe92c5 SDJ |
284 | struct gdb_xml_value *attrs = VEC_address (gdb_xml_value_s, attributes); |
285 | int len, i; | |
286 | /* syscall info. */ | |
287 | char *name = NULL; | |
288 | int number = 0; | |
e3487908 | 289 | char *groups = NULL; |
fbbe92c5 SDJ |
290 | |
291 | len = VEC_length (gdb_xml_value_s, attributes); | |
292 | ||
293 | for (i = 0; i < len; i++) | |
294 | { | |
295 | if (strcmp (attrs[i].name, "name") == 0) | |
19ba03f4 | 296 | name = (char *) attrs[i].value; |
fbbe92c5 SDJ |
297 | else if (strcmp (attrs[i].name, "number") == 0) |
298 | number = * (ULONGEST *) attrs[i].value; | |
e3487908 GKB |
299 | else if (strcmp (attrs[i].name, "groups") == 0) |
300 | groups = (char *) attrs[i].value; | |
fbbe92c5 SDJ |
301 | else |
302 | internal_error (__FILE__, __LINE__, | |
303 | _("Unknown attribute name '%s'."), attrs[i].name); | |
304 | } | |
305 | ||
154f592e | 306 | gdb_assert (name); |
e3487908 | 307 | syscall_create_syscall_desc (data->syscalls_info, name, number, groups); |
fbbe92c5 SDJ |
308 | } |
309 | ||
310 | ||
311 | /* The elements and attributes of an XML syscall document. */ | |
312 | static const struct gdb_xml_attribute syscall_attr[] = { | |
313 | { "number", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL }, | |
314 | { "name", GDB_XML_AF_NONE, NULL, NULL }, | |
e3487908 | 315 | { "groups", GDB_XML_AF_OPTIONAL, NULL, NULL }, |
fbbe92c5 SDJ |
316 | { NULL, GDB_XML_AF_NONE, NULL, NULL } |
317 | }; | |
318 | ||
319 | static const struct gdb_xml_element syscalls_info_children[] = { | |
320 | { "syscall", syscall_attr, NULL, | |
321 | GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE, | |
322 | syscall_start_syscall, NULL }, | |
323 | { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } | |
324 | }; | |
325 | ||
326 | static const struct gdb_xml_element syselements[] = { | |
327 | { "syscalls_info", NULL, syscalls_info_children, | |
f8e50cfe | 328 | GDB_XML_EF_NONE, NULL, NULL }, |
fbbe92c5 SDJ |
329 | { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } |
330 | }; | |
331 | ||
332 | static struct syscalls_info * | |
333 | syscall_parse_xml (const char *document, xml_fetch_another fetcher, | |
334 | void *fetcher_baton) | |
335 | { | |
336 | struct cleanup *result_cleanup; | |
fbbe92c5 | 337 | struct syscall_parsing_data data; |
fbbe92c5 | 338 | |
458c8db8 SDJ |
339 | data.syscalls_info = allocate_syscalls_info (); |
340 | result_cleanup = make_cleanup_free_syscalls_info (data.syscalls_info); | |
fbbe92c5 | 341 | |
efc0eabd PA |
342 | if (gdb_xml_parse_quick (_("syscalls info"), NULL, |
343 | syselements, document, &data) == 0) | |
fbbe92c5 SDJ |
344 | { |
345 | /* Parsed successfully. */ | |
346 | discard_cleanups (result_cleanup); | |
458c8db8 | 347 | return data.syscalls_info; |
fbbe92c5 SDJ |
348 | } |
349 | else | |
350 | { | |
351 | warning (_("Could not load XML syscalls info; ignoring")); | |
352 | do_cleanups (result_cleanup); | |
353 | return NULL; | |
354 | } | |
355 | } | |
356 | ||
357 | /* Function responsible for initializing the information | |
358 | about the syscalls. It reads the XML file and fills the | |
359 | struct syscalls_info with the values. | |
360 | ||
361 | Returns the struct syscalls_info if the file is valid, NULL otherwise. */ | |
458c8db8 | 362 | static struct syscalls_info * |
fbbe92c5 SDJ |
363 | xml_init_syscalls_info (const char *filename) |
364 | { | |
b7b030ad TT |
365 | gdb::unique_xmalloc_ptr<char> full_file |
366 | = xml_fetch_content_from_file (filename, gdb_datadir); | |
fbbe92c5 | 367 | if (full_file == NULL) |
bccd0dd2 | 368 | return NULL; |
fbbe92c5 | 369 | |
b7b030ad TT |
370 | return syscall_parse_xml (full_file.get (), |
371 | xml_fetch_content_from_file, | |
372 | (void *) ldirname (filename).c_str ()); | |
fbbe92c5 SDJ |
373 | } |
374 | ||
375 | /* Initializes the syscalls_info structure according to the | |
376 | architecture. */ | |
377 | static void | |
458c8db8 | 378 | init_syscalls_info (struct gdbarch *gdbarch) |
fbbe92c5 | 379 | { |
458c8db8 SDJ |
380 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); |
381 | const char *xml_syscall_file = gdbarch_xml_syscall_file (gdbarch); | |
382 | ||
626ea16d | 383 | /* Should we re-read the XML info for this target? */ |
458c8db8 SDJ |
384 | if (syscalls_info != NULL && syscalls_info->my_gdb_datadir != NULL |
385 | && filename_cmp (syscalls_info->my_gdb_datadir, gdb_datadir) != 0) | |
626ea16d SDJ |
386 | { |
387 | /* The data-directory changed from the last time we used it. | |
388 | It means that we have to re-read the XML info. */ | |
458c8db8 SDJ |
389 | free_syscalls_info (syscalls_info); |
390 | syscalls_info = NULL; | |
391 | set_gdbarch_syscalls_info (gdbarch, NULL); | |
626ea16d SDJ |
392 | } |
393 | ||
458c8db8 SDJ |
394 | /* Did we succeed at initializing this? */ |
395 | if (syscalls_info != NULL) | |
fbbe92c5 | 396 | return; |
fbbe92c5 | 397 | |
458c8db8 | 398 | syscalls_info = xml_init_syscalls_info (xml_syscall_file); |
fbbe92c5 | 399 | |
458c8db8 SDJ |
400 | /* If there was some error reading the XML file, we initialize |
401 | gdbarch->syscalls_info anyway, in order to store information | |
402 | about our attempt. */ | |
403 | if (syscalls_info == NULL) | |
404 | syscalls_info = allocate_syscalls_info (); | |
fbbe92c5 | 405 | |
458c8db8 | 406 | if (syscalls_info->syscalls == NULL) |
fbbe92c5 | 407 | { |
458c8db8 | 408 | if (xml_syscall_file != NULL) |
3e43a32a | 409 | warning (_("Could not load the syscall XML file `%s/%s'."), |
626ea16d | 410 | gdb_datadir, xml_syscall_file); |
fbbe92c5 | 411 | else |
3e43a32a | 412 | warning (_("There is no XML file to open.")); |
bccd0dd2 | 413 | |
3e43a32a MS |
414 | warning (_("GDB will not be able to display " |
415 | "syscall names nor to verify if\n" | |
416 | "any provided syscall numbers are valid.")); | |
fbbe92c5 | 417 | } |
626ea16d SDJ |
418 | |
419 | /* Saving the data-directory used to read this XML info. */ | |
458c8db8 SDJ |
420 | syscalls_info->my_gdb_datadir = xstrdup (gdb_datadir); |
421 | ||
422 | set_gdbarch_syscalls_info (gdbarch, syscalls_info); | |
fbbe92c5 SDJ |
423 | } |
424 | ||
e3487908 GKB |
425 | /* Search for a syscall group by its name. Return syscall_group_desc |
426 | structure for the group if found or NULL otherwise. */ | |
427 | ||
428 | static struct syscall_group_desc * | |
429 | syscall_group_get_group_by_name (const struct syscalls_info *syscalls_info, | |
430 | const char *group) | |
431 | { | |
432 | struct syscall_group_desc *groupdesc; | |
433 | int i; | |
434 | ||
435 | if (syscalls_info == NULL) | |
436 | return NULL; | |
437 | ||
438 | if (group == NULL) | |
439 | return NULL; | |
440 | ||
441 | /* Search for existing group. */ | |
442 | for (i = 0; | |
443 | VEC_iterate (syscall_group_desc_p, syscalls_info->groups, i, groupdesc); | |
444 | i++) | |
445 | { | |
446 | if (strcmp (groupdesc->name, group) == 0) | |
447 | return groupdesc; | |
448 | } | |
449 | ||
450 | return NULL; | |
451 | } | |
452 | ||
fbbe92c5 | 453 | static int |
458c8db8 | 454 | xml_get_syscall_number (struct gdbarch *gdbarch, |
fbbe92c5 SDJ |
455 | const char *syscall_name) |
456 | { | |
458c8db8 | 457 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); |
fbbe92c5 SDJ |
458 | struct syscall_desc *sysdesc; |
459 | int i; | |
460 | ||
458c8db8 | 461 | if (syscalls_info == NULL |
fbbe92c5 SDJ |
462 | || syscall_name == NULL) |
463 | return UNKNOWN_SYSCALL; | |
464 | ||
465 | for (i = 0; | |
458c8db8 | 466 | VEC_iterate(syscall_desc_p, syscalls_info->syscalls, i, sysdesc); |
fbbe92c5 SDJ |
467 | i++) |
468 | if (strcmp (sysdesc->name, syscall_name) == 0) | |
469 | return sysdesc->number; | |
470 | ||
471 | return UNKNOWN_SYSCALL; | |
472 | } | |
473 | ||
474 | static const char * | |
458c8db8 | 475 | xml_get_syscall_name (struct gdbarch *gdbarch, |
fbbe92c5 SDJ |
476 | int syscall_number) |
477 | { | |
458c8db8 | 478 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); |
fbbe92c5 SDJ |
479 | struct syscall_desc *sysdesc; |
480 | int i; | |
481 | ||
458c8db8 | 482 | if (syscalls_info == NULL |
fbbe92c5 SDJ |
483 | || syscall_number < 0) |
484 | return NULL; | |
485 | ||
486 | for (i = 0; | |
458c8db8 | 487 | VEC_iterate(syscall_desc_p, syscalls_info->syscalls, i, sysdesc); |
fbbe92c5 SDJ |
488 | i++) |
489 | if (sysdesc->number == syscall_number) | |
490 | return sysdesc->name; | |
491 | ||
492 | return NULL; | |
493 | } | |
494 | ||
fbbe92c5 | 495 | static const char ** |
458c8db8 | 496 | xml_list_of_syscalls (struct gdbarch *gdbarch) |
fbbe92c5 | 497 | { |
458c8db8 | 498 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); |
fbbe92c5 SDJ |
499 | struct syscall_desc *sysdesc; |
500 | const char **names = NULL; | |
501 | int nsyscalls; | |
502 | int i; | |
503 | ||
458c8db8 | 504 | if (syscalls_info == NULL) |
fbbe92c5 SDJ |
505 | return NULL; |
506 | ||
458c8db8 | 507 | nsyscalls = VEC_length (syscall_desc_p, syscalls_info->syscalls); |
224c3ddb | 508 | names = XNEWVEC (const char *, nsyscalls + 1); |
fbbe92c5 SDJ |
509 | |
510 | for (i = 0; | |
458c8db8 | 511 | VEC_iterate (syscall_desc_p, syscalls_info->syscalls, i, sysdesc); |
fbbe92c5 SDJ |
512 | i++) |
513 | names[i] = sysdesc->name; | |
514 | ||
515 | names[i] = NULL; | |
516 | ||
517 | return names; | |
518 | } | |
519 | ||
e3487908 GKB |
520 | /* Iterate over the syscall_group_desc element to return a list of |
521 | syscalls that are part of the given group, terminated by an empty | |
522 | element. If the syscall group doesn't exist, return NULL. */ | |
523 | ||
524 | static struct syscall * | |
525 | xml_list_syscalls_by_group (struct gdbarch *gdbarch, const char *group) | |
526 | { | |
527 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); | |
528 | struct syscall_group_desc *groupdesc; | |
529 | struct syscall_desc *sysdesc; | |
530 | struct syscall *syscalls = NULL; | |
531 | int nsyscalls; | |
532 | int i; | |
533 | ||
534 | if (syscalls_info == NULL) | |
535 | return NULL; | |
536 | ||
537 | groupdesc = syscall_group_get_group_by_name (syscalls_info, group); | |
538 | if (groupdesc == NULL) | |
539 | return NULL; | |
540 | ||
541 | nsyscalls = VEC_length (syscall_desc_p, groupdesc->syscalls); | |
542 | syscalls = (struct syscall*) xmalloc ((nsyscalls + 1) | |
543 | * sizeof (struct syscall)); | |
544 | ||
545 | for (i = 0; | |
546 | VEC_iterate (syscall_desc_p, groupdesc->syscalls, i, sysdesc); | |
547 | i++) | |
548 | { | |
549 | syscalls[i].name = sysdesc->name; | |
550 | syscalls[i].number = sysdesc->number; | |
551 | } | |
552 | ||
553 | /* Add final element marker. */ | |
554 | syscalls[i].name = NULL; | |
555 | syscalls[i].number = 0; | |
556 | ||
557 | return syscalls; | |
558 | } | |
559 | ||
560 | /* Return a NULL terminated list of syscall groups or an empty list, if | |
561 | no syscall group is available. Return NULL, if there is no syscall | |
562 | information available. */ | |
563 | ||
564 | static const char ** | |
565 | xml_list_of_groups (struct gdbarch *gdbarch) | |
566 | { | |
567 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); | |
568 | struct syscall_group_desc *groupdesc; | |
569 | const char **names = NULL; | |
570 | int i; | |
571 | int ngroups; | |
572 | ||
573 | if (syscalls_info == NULL) | |
574 | return NULL; | |
575 | ||
576 | ngroups = VEC_length (syscall_group_desc_p, syscalls_info->groups); | |
577 | names = (const char**) xmalloc ((ngroups + 1) * sizeof (char *)); | |
578 | ||
579 | for (i = 0; | |
580 | VEC_iterate (syscall_group_desc_p, syscalls_info->groups, i, groupdesc); | |
581 | i++) | |
582 | names[i] = groupdesc->name; | |
583 | ||
584 | names[i] = NULL; | |
585 | ||
586 | return names; | |
587 | } | |
588 | ||
fbbe92c5 | 589 | void |
458c8db8 | 590 | set_xml_syscall_file_name (struct gdbarch *gdbarch, const char *name) |
fbbe92c5 | 591 | { |
458c8db8 | 592 | set_gdbarch_xml_syscall_file (gdbarch, name); |
fbbe92c5 SDJ |
593 | } |
594 | ||
595 | void | |
458c8db8 SDJ |
596 | get_syscall_by_number (struct gdbarch *gdbarch, |
597 | int syscall_number, struct syscall *s) | |
fbbe92c5 | 598 | { |
458c8db8 | 599 | init_syscalls_info (gdbarch); |
fbbe92c5 SDJ |
600 | |
601 | s->number = syscall_number; | |
458c8db8 | 602 | s->name = xml_get_syscall_name (gdbarch, syscall_number); |
fbbe92c5 SDJ |
603 | } |
604 | ||
605 | void | |
458c8db8 SDJ |
606 | get_syscall_by_name (struct gdbarch *gdbarch, |
607 | const char *syscall_name, struct syscall *s) | |
fbbe92c5 | 608 | { |
458c8db8 | 609 | init_syscalls_info (gdbarch); |
fbbe92c5 | 610 | |
458c8db8 | 611 | s->number = xml_get_syscall_number (gdbarch, syscall_name); |
fbbe92c5 SDJ |
612 | s->name = syscall_name; |
613 | } | |
614 | ||
615 | const char ** | |
458c8db8 | 616 | get_syscall_names (struct gdbarch *gdbarch) |
fbbe92c5 | 617 | { |
458c8db8 | 618 | init_syscalls_info (gdbarch); |
fbbe92c5 | 619 | |
458c8db8 | 620 | return xml_list_of_syscalls (gdbarch); |
fbbe92c5 SDJ |
621 | } |
622 | ||
e3487908 GKB |
623 | /* See comment in xml-syscall.h. */ |
624 | ||
625 | struct syscall * | |
626 | get_syscalls_by_group (struct gdbarch *gdbarch, const char *group) | |
627 | { | |
628 | init_syscalls_info (gdbarch); | |
629 | ||
630 | return xml_list_syscalls_by_group (gdbarch, group); | |
631 | } | |
632 | ||
633 | /* See comment in xml-syscall.h. */ | |
634 | ||
635 | const char ** | |
636 | get_syscall_group_names (struct gdbarch *gdbarch) | |
637 | { | |
638 | init_syscalls_info (gdbarch); | |
639 | ||
640 | return xml_list_of_groups (gdbarch); | |
641 | } | |
642 | ||
fbbe92c5 | 643 | #endif /* ! HAVE_LIBEXPAT */ |