Commit | Line | Data |
---|---|---|
fbbe92c5 SDJ |
1 | /* Functions that provide the mechanism to parse a syscall XML file |
2 | and get its values. | |
3 | ||
e2882c85 | 4 | Copyright (C) 2009-2018 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. */ | |
5a9dcda1 | 97 | struct syscall_desc |
fbbe92c5 | 98 | { |
5a9dcda1 SM |
99 | syscall_desc (int number_, std::string name_) |
100 | : number (number_), name (name_) | |
101 | {} | |
102 | ||
fbbe92c5 SDJ |
103 | /* The syscall number. */ |
104 | ||
105 | int number; | |
106 | ||
107 | /* The syscall name. */ | |
108 | ||
5a9dcda1 SM |
109 | std::string name; |
110 | }; | |
111 | ||
112 | typedef std::unique_ptr<syscall_desc> syscall_desc_up; | |
fbbe92c5 | 113 | |
e3487908 | 114 | /* Structure of a syscall group. */ |
5a9dcda1 | 115 | struct syscall_group_desc |
e3487908 | 116 | { |
5a9dcda1 SM |
117 | syscall_group_desc (const std::string &name_) |
118 | : name (name_) | |
119 | {} | |
120 | ||
e3487908 GKB |
121 | /* The group name. */ |
122 | ||
5a9dcda1 | 123 | std::string name; |
e3487908 | 124 | |
5a9dcda1 SM |
125 | /* The syscalls that are part of the group. This is a non-owning |
126 | reference. */ | |
e3487908 | 127 | |
5a9dcda1 SM |
128 | std::vector<syscall_desc *> syscalls; |
129 | }; | |
130 | ||
131 | typedef std::unique_ptr<syscall_group_desc> syscall_group_desc_up; | |
e3487908 | 132 | |
fbbe92c5 SDJ |
133 | /* Structure that represents syscalls information. */ |
134 | struct syscalls_info | |
135 | { | |
136 | /* The syscalls. */ | |
137 | ||
5a9dcda1 | 138 | std::vector<syscall_desc_up> syscalls; |
458c8db8 | 139 | |
e3487908 GKB |
140 | /* The syscall groups. */ |
141 | ||
5a9dcda1 | 142 | std::vector<syscall_group_desc_up> groups; |
e3487908 | 143 | |
458c8db8 SDJ |
144 | /* Variable that will hold the last known data-directory. This is |
145 | useful to know whether we should re-read the XML info for the | |
146 | target. */ | |
147 | ||
5a9dcda1 | 148 | std::string my_gdb_datadir; |
fbbe92c5 SDJ |
149 | }; |
150 | ||
5a9dcda1 SM |
151 | typedef std::unique_ptr<syscalls_info> syscalls_info_up; |
152 | ||
fbbe92c5 SDJ |
153 | /* Callback data for syscall information parsing. */ |
154 | struct syscall_parsing_data | |
155 | { | |
156 | /* The syscalls_info we are building. */ | |
157 | ||
458c8db8 | 158 | struct syscalls_info *syscalls_info; |
fbbe92c5 SDJ |
159 | }; |
160 | ||
e3487908 GKB |
161 | /* Create a new syscall group. Return pointer to the |
162 | syscall_group_desc structure that represents the new group. */ | |
163 | ||
164 | static struct syscall_group_desc * | |
165 | syscall_group_create_syscall_group_desc (struct syscalls_info *syscalls_info, | |
166 | const char *group) | |
167 | { | |
5a9dcda1 | 168 | syscall_group_desc *groupdesc = new syscall_group_desc (group); |
e3487908 | 169 | |
5a9dcda1 | 170 | syscalls_info->groups.emplace_back (groupdesc); |
e3487908 GKB |
171 | |
172 | return groupdesc; | |
173 | } | |
174 | ||
175 | /* Add a syscall to the group. If group doesn't exist, create it. */ | |
176 | ||
177 | static void | |
178 | syscall_group_add_syscall (struct syscalls_info *syscalls_info, | |
179 | struct syscall_desc *syscall, | |
180 | const char *group) | |
181 | { | |
e3487908 | 182 | /* Search for an existing group. */ |
5a9dcda1 SM |
183 | std::vector<syscall_group_desc_up>::iterator it |
184 | = syscalls_info->groups.begin (); | |
185 | ||
186 | for (; it != syscalls_info->groups.end (); it++) | |
e3487908 | 187 | { |
5a9dcda1 | 188 | if ((*it)->name == group) |
e3487908 GKB |
189 | break; |
190 | } | |
191 | ||
5a9dcda1 SM |
192 | syscall_group_desc *groupdesc; |
193 | ||
194 | if (it != syscalls_info->groups.end ()) | |
195 | groupdesc = it->get (); | |
196 | else | |
e3487908 GKB |
197 | { |
198 | /* No group was found with this name. We must create a new | |
199 | one. */ | |
200 | groupdesc = syscall_group_create_syscall_group_desc (syscalls_info, | |
201 | group); | |
202 | } | |
203 | ||
5a9dcda1 | 204 | groupdesc->syscalls.push_back (syscall); |
e3487908 GKB |
205 | } |
206 | ||
fbbe92c5 | 207 | static void |
458c8db8 | 208 | syscall_create_syscall_desc (struct syscalls_info *syscalls_info, |
e3487908 GKB |
209 | const char *name, int number, |
210 | char *groups) | |
fbbe92c5 | 211 | { |
5a9dcda1 | 212 | syscall_desc *sysdesc = new syscall_desc (number, name); |
fbbe92c5 | 213 | |
5a9dcda1 | 214 | syscalls_info->syscalls.emplace_back (sysdesc); |
e3487908 GKB |
215 | |
216 | /* Add syscall to its groups. */ | |
217 | if (groups != NULL) | |
218 | { | |
5a9dcda1 | 219 | for (char *group = strtok (groups, ","); |
e3487908 GKB |
220 | group != NULL; |
221 | group = strtok (NULL, ",")) | |
222 | syscall_group_add_syscall (syscalls_info, sysdesc, group); | |
223 | } | |
fbbe92c5 SDJ |
224 | } |
225 | ||
fbbe92c5 SDJ |
226 | /* Handle the start of a <syscall> element. */ |
227 | static void | |
228 | syscall_start_syscall (struct gdb_xml_parser *parser, | |
229 | const struct gdb_xml_element *element, | |
4d0fdd9b SM |
230 | void *user_data, |
231 | std::vector<gdb_xml_value> &attributes) | |
fbbe92c5 | 232 | { |
19ba03f4 | 233 | struct syscall_parsing_data *data = (struct syscall_parsing_data *) user_data; |
fbbe92c5 SDJ |
234 | /* syscall info. */ |
235 | char *name = NULL; | |
236 | int number = 0; | |
e3487908 | 237 | char *groups = NULL; |
fbbe92c5 | 238 | |
4d0fdd9b | 239 | for (const gdb_xml_value &attr : attributes) |
fbbe92c5 | 240 | { |
4d0fdd9b SM |
241 | if (strcmp (attr.name, "name") == 0) |
242 | name = (char *) attr.value.get (); | |
243 | else if (strcmp (attr.name, "number") == 0) | |
244 | number = * (ULONGEST *) attr.value.get (); | |
245 | else if (strcmp (attr.name, "groups") == 0) | |
246 | groups = (char *) attr.value.get (); | |
fbbe92c5 SDJ |
247 | else |
248 | internal_error (__FILE__, __LINE__, | |
4d0fdd9b | 249 | _("Unknown attribute name '%s'."), attr.name); |
fbbe92c5 SDJ |
250 | } |
251 | ||
154f592e | 252 | gdb_assert (name); |
e3487908 | 253 | syscall_create_syscall_desc (data->syscalls_info, name, number, groups); |
fbbe92c5 SDJ |
254 | } |
255 | ||
256 | ||
257 | /* The elements and attributes of an XML syscall document. */ | |
258 | static const struct gdb_xml_attribute syscall_attr[] = { | |
259 | { "number", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL }, | |
260 | { "name", GDB_XML_AF_NONE, NULL, NULL }, | |
e3487908 | 261 | { "groups", GDB_XML_AF_OPTIONAL, NULL, NULL }, |
fbbe92c5 SDJ |
262 | { NULL, GDB_XML_AF_NONE, NULL, NULL } |
263 | }; | |
264 | ||
265 | static const struct gdb_xml_element syscalls_info_children[] = { | |
266 | { "syscall", syscall_attr, NULL, | |
267 | GDB_XML_EF_OPTIONAL | GDB_XML_EF_REPEATABLE, | |
268 | syscall_start_syscall, NULL }, | |
269 | { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } | |
270 | }; | |
271 | ||
272 | static const struct gdb_xml_element syselements[] = { | |
273 | { "syscalls_info", NULL, syscalls_info_children, | |
f8e50cfe | 274 | GDB_XML_EF_NONE, NULL, NULL }, |
fbbe92c5 SDJ |
275 | { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL } |
276 | }; | |
277 | ||
278 | static struct syscalls_info * | |
279 | syscall_parse_xml (const char *document, xml_fetch_another fetcher, | |
280 | void *fetcher_baton) | |
281 | { | |
fbbe92c5 | 282 | struct syscall_parsing_data data; |
5a9dcda1 | 283 | syscalls_info_up sysinfo (new syscalls_info ()); |
fbbe92c5 | 284 | |
5a9dcda1 | 285 | data.syscalls_info = sysinfo.get (); |
fbbe92c5 | 286 | |
efc0eabd PA |
287 | if (gdb_xml_parse_quick (_("syscalls info"), NULL, |
288 | syselements, document, &data) == 0) | |
fbbe92c5 SDJ |
289 | { |
290 | /* Parsed successfully. */ | |
5a9dcda1 | 291 | return sysinfo.release (); |
fbbe92c5 SDJ |
292 | } |
293 | else | |
294 | { | |
295 | warning (_("Could not load XML syscalls info; ignoring")); | |
fbbe92c5 SDJ |
296 | return NULL; |
297 | } | |
298 | } | |
299 | ||
300 | /* Function responsible for initializing the information | |
301 | about the syscalls. It reads the XML file and fills the | |
302 | struct syscalls_info with the values. | |
303 | ||
304 | Returns the struct syscalls_info if the file is valid, NULL otherwise. */ | |
458c8db8 | 305 | static struct syscalls_info * |
fbbe92c5 SDJ |
306 | xml_init_syscalls_info (const char *filename) |
307 | { | |
9018be22 | 308 | gdb::optional<gdb::char_vector> full_file |
b7b030ad | 309 | = xml_fetch_content_from_file (filename, gdb_datadir); |
9018be22 | 310 | if (!full_file) |
bccd0dd2 | 311 | return NULL; |
fbbe92c5 | 312 | |
9018be22 | 313 | return syscall_parse_xml (full_file->data (), |
b7b030ad TT |
314 | xml_fetch_content_from_file, |
315 | (void *) ldirname (filename).c_str ()); | |
fbbe92c5 SDJ |
316 | } |
317 | ||
318 | /* Initializes the syscalls_info structure according to the | |
319 | architecture. */ | |
320 | static void | |
458c8db8 | 321 | init_syscalls_info (struct gdbarch *gdbarch) |
fbbe92c5 | 322 | { |
458c8db8 SDJ |
323 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); |
324 | const char *xml_syscall_file = gdbarch_xml_syscall_file (gdbarch); | |
325 | ||
626ea16d | 326 | /* Should we re-read the XML info for this target? */ |
5a9dcda1 SM |
327 | if (syscalls_info != NULL && !syscalls_info->my_gdb_datadir.empty () |
328 | && filename_cmp (syscalls_info->my_gdb_datadir.c_str (), | |
329 | gdb_datadir) != 0) | |
626ea16d SDJ |
330 | { |
331 | /* The data-directory changed from the last time we used it. | |
332 | It means that we have to re-read the XML info. */ | |
5a9dcda1 | 333 | delete syscalls_info; |
458c8db8 SDJ |
334 | syscalls_info = NULL; |
335 | set_gdbarch_syscalls_info (gdbarch, NULL); | |
626ea16d SDJ |
336 | } |
337 | ||
458c8db8 SDJ |
338 | /* Did we succeed at initializing this? */ |
339 | if (syscalls_info != NULL) | |
fbbe92c5 | 340 | return; |
fbbe92c5 | 341 | |
458c8db8 | 342 | syscalls_info = xml_init_syscalls_info (xml_syscall_file); |
fbbe92c5 | 343 | |
458c8db8 SDJ |
344 | /* If there was some error reading the XML file, we initialize |
345 | gdbarch->syscalls_info anyway, in order to store information | |
346 | about our attempt. */ | |
347 | if (syscalls_info == NULL) | |
5a9dcda1 | 348 | syscalls_info = new struct syscalls_info (); |
fbbe92c5 | 349 | |
5a9dcda1 | 350 | if (syscalls_info->syscalls.empty ()) |
fbbe92c5 | 351 | { |
458c8db8 | 352 | if (xml_syscall_file != NULL) |
3e43a32a | 353 | warning (_("Could not load the syscall XML file `%s/%s'."), |
626ea16d | 354 | gdb_datadir, xml_syscall_file); |
fbbe92c5 | 355 | else |
3e43a32a | 356 | warning (_("There is no XML file to open.")); |
bccd0dd2 | 357 | |
3e43a32a MS |
358 | warning (_("GDB will not be able to display " |
359 | "syscall names nor to verify if\n" | |
360 | "any provided syscall numbers are valid.")); | |
fbbe92c5 | 361 | } |
626ea16d SDJ |
362 | |
363 | /* Saving the data-directory used to read this XML info. */ | |
5a9dcda1 | 364 | syscalls_info->my_gdb_datadir.assign (gdb_datadir); |
458c8db8 SDJ |
365 | |
366 | set_gdbarch_syscalls_info (gdbarch, syscalls_info); | |
fbbe92c5 SDJ |
367 | } |
368 | ||
e3487908 GKB |
369 | /* Search for a syscall group by its name. Return syscall_group_desc |
370 | structure for the group if found or NULL otherwise. */ | |
371 | ||
372 | static struct syscall_group_desc * | |
373 | syscall_group_get_group_by_name (const struct syscalls_info *syscalls_info, | |
374 | const char *group) | |
375 | { | |
e3487908 GKB |
376 | if (syscalls_info == NULL) |
377 | return NULL; | |
378 | ||
379 | if (group == NULL) | |
380 | return NULL; | |
381 | ||
5a9dcda1 SM |
382 | /* Search for existing group. */ |
383 | for (const syscall_group_desc_up &groupdesc : syscalls_info->groups) | |
e3487908 | 384 | { |
5a9dcda1 SM |
385 | if (groupdesc->name == group) |
386 | return groupdesc.get (); | |
e3487908 GKB |
387 | } |
388 | ||
389 | return NULL; | |
390 | } | |
391 | ||
fbbe92c5 | 392 | static int |
458c8db8 | 393 | xml_get_syscall_number (struct gdbarch *gdbarch, |
fbbe92c5 SDJ |
394 | const char *syscall_name) |
395 | { | |
458c8db8 | 396 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); |
fbbe92c5 | 397 | |
458c8db8 | 398 | if (syscalls_info == NULL |
fbbe92c5 SDJ |
399 | || syscall_name == NULL) |
400 | return UNKNOWN_SYSCALL; | |
401 | ||
5a9dcda1 SM |
402 | for (const syscall_desc_up &sysdesc : syscalls_info->syscalls) |
403 | if (sysdesc->name == syscall_name) | |
fbbe92c5 SDJ |
404 | return sysdesc->number; |
405 | ||
406 | return UNKNOWN_SYSCALL; | |
407 | } | |
408 | ||
409 | static const char * | |
458c8db8 | 410 | xml_get_syscall_name (struct gdbarch *gdbarch, |
fbbe92c5 SDJ |
411 | int syscall_number) |
412 | { | |
458c8db8 | 413 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); |
fbbe92c5 | 414 | |
458c8db8 | 415 | if (syscalls_info == NULL |
fbbe92c5 SDJ |
416 | || syscall_number < 0) |
417 | return NULL; | |
418 | ||
5a9dcda1 | 419 | for (const syscall_desc_up &sysdesc : syscalls_info->syscalls) |
fbbe92c5 | 420 | if (sysdesc->number == syscall_number) |
5a9dcda1 | 421 | return sysdesc->name.c_str (); |
fbbe92c5 SDJ |
422 | |
423 | return NULL; | |
424 | } | |
425 | ||
fbbe92c5 | 426 | static const char ** |
458c8db8 | 427 | xml_list_of_syscalls (struct gdbarch *gdbarch) |
fbbe92c5 | 428 | { |
458c8db8 | 429 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); |
fbbe92c5 | 430 | |
458c8db8 | 431 | if (syscalls_info == NULL) |
fbbe92c5 SDJ |
432 | return NULL; |
433 | ||
5a9dcda1 SM |
434 | int nsyscalls = syscalls_info->syscalls.size (); |
435 | const char **names = XNEWVEC (const char *, nsyscalls + 1); | |
fbbe92c5 | 436 | |
5a9dcda1 SM |
437 | int i; |
438 | for (i = 0; i < syscalls_info->syscalls.size (); i++) | |
439 | names[i] = syscalls_info->syscalls[i]->name.c_str (); | |
fbbe92c5 SDJ |
440 | |
441 | names[i] = NULL; | |
442 | ||
443 | return names; | |
444 | } | |
445 | ||
e3487908 GKB |
446 | /* Iterate over the syscall_group_desc element to return a list of |
447 | syscalls that are part of the given group, terminated by an empty | |
448 | element. If the syscall group doesn't exist, return NULL. */ | |
449 | ||
450 | static struct syscall * | |
451 | xml_list_syscalls_by_group (struct gdbarch *gdbarch, const char *group) | |
452 | { | |
453 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); | |
454 | struct syscall_group_desc *groupdesc; | |
e3487908 GKB |
455 | struct syscall *syscalls = NULL; |
456 | int nsyscalls; | |
457 | int i; | |
458 | ||
459 | if (syscalls_info == NULL) | |
460 | return NULL; | |
461 | ||
462 | groupdesc = syscall_group_get_group_by_name (syscalls_info, group); | |
463 | if (groupdesc == NULL) | |
464 | return NULL; | |
465 | ||
5a9dcda1 | 466 | nsyscalls = groupdesc->syscalls.size (); |
e3487908 GKB |
467 | syscalls = (struct syscall*) xmalloc ((nsyscalls + 1) |
468 | * sizeof (struct syscall)); | |
469 | ||
5a9dcda1 | 470 | for (i = 0; i < groupdesc->syscalls.size (); i++) |
e3487908 | 471 | { |
5a9dcda1 SM |
472 | syscalls[i].name = groupdesc->syscalls[i]->name.c_str (); |
473 | syscalls[i].number = groupdesc->syscalls[i]->number; | |
e3487908 GKB |
474 | } |
475 | ||
476 | /* Add final element marker. */ | |
477 | syscalls[i].name = NULL; | |
478 | syscalls[i].number = 0; | |
479 | ||
480 | return syscalls; | |
481 | } | |
482 | ||
483 | /* Return a NULL terminated list of syscall groups or an empty list, if | |
484 | no syscall group is available. Return NULL, if there is no syscall | |
485 | information available. */ | |
486 | ||
487 | static const char ** | |
488 | xml_list_of_groups (struct gdbarch *gdbarch) | |
489 | { | |
490 | struct syscalls_info *syscalls_info = gdbarch_syscalls_info (gdbarch); | |
e3487908 | 491 | const char **names = NULL; |
e3487908 | 492 | int ngroups; |
5a9dcda1 | 493 | int i; |
e3487908 GKB |
494 | |
495 | if (syscalls_info == NULL) | |
496 | return NULL; | |
497 | ||
5a9dcda1 | 498 | ngroups = syscalls_info->groups.size (); |
e3487908 GKB |
499 | names = (const char**) xmalloc ((ngroups + 1) * sizeof (char *)); |
500 | ||
5a9dcda1 SM |
501 | for (i = 0; i < syscalls_info->groups.size (); i++) |
502 | names[i] = syscalls_info->groups[i]->name.c_str (); | |
e3487908 GKB |
503 | |
504 | names[i] = NULL; | |
505 | ||
506 | return names; | |
507 | } | |
508 | ||
fbbe92c5 | 509 | void |
458c8db8 | 510 | set_xml_syscall_file_name (struct gdbarch *gdbarch, const char *name) |
fbbe92c5 | 511 | { |
458c8db8 | 512 | set_gdbarch_xml_syscall_file (gdbarch, name); |
fbbe92c5 SDJ |
513 | } |
514 | ||
515 | void | |
458c8db8 SDJ |
516 | get_syscall_by_number (struct gdbarch *gdbarch, |
517 | int syscall_number, struct syscall *s) | |
fbbe92c5 | 518 | { |
458c8db8 | 519 | init_syscalls_info (gdbarch); |
fbbe92c5 SDJ |
520 | |
521 | s->number = syscall_number; | |
458c8db8 | 522 | s->name = xml_get_syscall_name (gdbarch, syscall_number); |
fbbe92c5 SDJ |
523 | } |
524 | ||
525 | void | |
458c8db8 SDJ |
526 | get_syscall_by_name (struct gdbarch *gdbarch, |
527 | const char *syscall_name, struct syscall *s) | |
fbbe92c5 | 528 | { |
458c8db8 | 529 | init_syscalls_info (gdbarch); |
fbbe92c5 | 530 | |
458c8db8 | 531 | s->number = xml_get_syscall_number (gdbarch, syscall_name); |
fbbe92c5 SDJ |
532 | s->name = syscall_name; |
533 | } | |
534 | ||
535 | const char ** | |
458c8db8 | 536 | get_syscall_names (struct gdbarch *gdbarch) |
fbbe92c5 | 537 | { |
458c8db8 | 538 | init_syscalls_info (gdbarch); |
fbbe92c5 | 539 | |
458c8db8 | 540 | return xml_list_of_syscalls (gdbarch); |
fbbe92c5 SDJ |
541 | } |
542 | ||
e3487908 GKB |
543 | /* See comment in xml-syscall.h. */ |
544 | ||
545 | struct syscall * | |
546 | get_syscalls_by_group (struct gdbarch *gdbarch, const char *group) | |
547 | { | |
548 | init_syscalls_info (gdbarch); | |
549 | ||
550 | return xml_list_syscalls_by_group (gdbarch, group); | |
551 | } | |
552 | ||
553 | /* See comment in xml-syscall.h. */ | |
554 | ||
555 | const char ** | |
556 | get_syscall_group_names (struct gdbarch *gdbarch) | |
557 | { | |
558 | init_syscalls_info (gdbarch); | |
559 | ||
560 | return xml_list_of_groups (gdbarch); | |
561 | } | |
562 | ||
fbbe92c5 | 563 | #endif /* ! HAVE_LIBEXPAT */ |