1 /* Demangler test program,
2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3 Written by Zack Weinberg <zack@codesourcery.com
4
5 This file is part of GNU libiberty.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 */
21
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25 #include "ansidecl.h"
26 #include <stdio.h>
27 #include "libiberty.h"
28 #include "demangle.h"
29 #ifdef HAVE_STRING_H
30 #include <string.h>
31 #endif
32 #if HAVE_STDLIB_H
33 # include <stdlib.h>
34 #endif
35
36 struct line
37 {
38 size_t alloced;
39 char *data;
40 };
41
42 static unsigned int lineno;
43
44 /* Safely read a single line of arbitrary length from standard input. */
45
46 #define LINELEN 80
47
48 static void
get_line(buf)49 get_line(buf)
50 struct line *buf;
51 {
52 char *data = buf->data;
53 size_t alloc = buf->alloced;
54 size_t count = 0;
55 int c;
56
57 if (data == 0)
58 {
59 data = xmalloc (LINELEN);
60 alloc = LINELEN;
61 }
62
63 /* Skip comment lines. */
64 while ((c = getchar()) == '#')
65 {
66 while ((c = getchar()) != EOF && c != '\n');
67 lineno++;
68 }
69
70 /* c is the first character on the line, and it's not a comment
71 line: copy this line into the buffer and return. */
72 while (c != EOF && c != '\n')
73 {
74 if (count + 1 >= alloc)
75 {
76 alloc *= 2;
77 data = xrealloc (data, alloc);
78 }
79 data[count++] = c;
80 c = getchar();
81 }
82 lineno++;
83 data[count] = '\0';
84
85 buf->data = data;
86 buf->alloced = alloc;
87 }
88
89 /* If we have mmap() and mprotect(), copy the string S just before a
90 protected page, so that if the demangler runs over the end of the
91 string we'll get a fault, and return the address of the new string.
92 If no mmap, or it fails, or it looks too hard, just return S. */
93
94 #ifdef HAVE_SYS_MMAN_H
95 #include <sys/mman.h>
96 #endif
97 #if defined(MAP_ANON) && ! defined (MAP_ANONYMOUS)
98 #define MAP_ANONYMOUS MAP_ANON
99 #endif
100
101 static const char *
protect_end(const char * s)102 protect_end (const char * s)
103 {
104 #if defined(HAVE_MMAP) && defined (MAP_ANONYMOUS)
105 size_t pagesize = getpagesize();
106 static char * buf;
107 size_t s_len = strlen (s);
108 char * result;
109
110 /* Don't try if S is too long. */
111 if (s_len >= pagesize)
112 return s;
113
114 /* Allocate one page of allocated space followed by an unmapped
115 page. */
116 if (buf == NULL)
117 {
118 buf = mmap (NULL, pagesize * 2, PROT_READ | PROT_WRITE,
119 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
120 if (! buf)
121 return s;
122 munmap (buf + pagesize, pagesize);
123 }
124
125 result = buf + (pagesize - s_len - 1);
126 memcpy (result, s, s_len + 1);
127 return result;
128 #else
129 return s;
130 #endif
131 }
132
133 static void
fail(lineno,opts,in,out,exp)134 fail (lineno, opts, in, out, exp)
135 int lineno;
136 const char *opts;
137 const char *in;
138 const char *out;
139 const char *exp;
140 {
141 printf ("\
142 FAIL at line %d, options %s:\n\
143 in: %s\n\
144 out: %s\n\
145 exp: %s\n",
146 lineno, opts, in, out != NULL ? out : "(null)", exp);
147 }
148
149 /* The tester operates on a data file consisting of groups of lines:
150 options
151 input to be demangled
152 expected output
153
154 Supported options:
155 --format=<name> Sets the demangling style.
156 --no-params There are two lines of expected output; the first
157 is with DMGL_PARAMS, the second is without it.
158 --is-v3-ctor Calls is_gnu_v3_mangled_ctor on input; expected
159 output is an integer representing ctor_kind.
160 --is-v3-dtor Likewise, but for dtors.
161 --ret-postfix Passes the DMGL_RET_POSTFIX option
162 --ret-drop Passes the DMGL_RET_DROP option
163
164 For compatibility, just in case it matters, the options line may be
165 empty, to mean --format=auto. If it doesn't start with --, then it
166 may contain only a format name.
167 */
168
169 int
main(argc,argv)170 main(argc, argv)
171 int argc;
172 char **argv;
173 {
174 enum demangling_styles style = auto_demangling;
175 int no_params;
176 int is_v3_ctor;
177 int is_v3_dtor;
178 int ret_postfix, ret_drop;
179 struct line format;
180 struct line input;
181 struct line expect;
182 char *result;
183 int failures = 0;
184 int tests = 0;
185
186 if (argc > 1)
187 {
188 fprintf (stderr, "usage: %s < test-set\n", argv[0]);
189 return 2;
190 }
191
192 format.data = 0;
193 input.data = 0;
194 expect.data = 0;
195
196 for (;;)
197 {
198 const char *inp;
199
200 get_line (&format);
201 if (feof (stdin))
202 break;
203
204 get_line (&input);
205 get_line (&expect);
206
207 inp = protect_end (input.data);
208
209 tests++;
210
211 no_params = 0;
212 ret_postfix = 0;
213 ret_drop = 0;
214 is_v3_ctor = 0;
215 is_v3_dtor = 0;
216 if (format.data[0] == '\0')
217 style = auto_demangling;
218 else if (format.data[0] != '-')
219 {
220 style = cplus_demangle_name_to_style (format.data);
221 if (style == unknown_demangling)
222 {
223 printf ("FAIL at line %d: unknown demangling style %s\n",
224 lineno, format.data);
225 failures++;
226 continue;
227 }
228 }
229 else
230 {
231 char *p;
232 char *opt;
233
234 p = format.data;
235 while (*p != '\0')
236 {
237 char c;
238
239 opt = p;
240 p += strcspn (p, " \t=");
241 c = *p;
242 *p = '\0';
243 if (strcmp (opt, "--format") == 0 && c == '=')
244 {
245 char *fstyle;
246
247 *p = c;
248 ++p;
249 fstyle = p;
250 p += strcspn (p, " \t");
251 c = *p;
252 *p = '\0';
253 style = cplus_demangle_name_to_style (fstyle);
254 if (style == unknown_demangling)
255 {
256 printf ("FAIL at line %d: unknown demangling style %s\n",
257 lineno, fstyle);
258 failures++;
259 continue;
260 }
261 }
262 else if (strcmp (opt, "--no-params") == 0)
263 no_params = 1;
264 else if (strcmp (opt, "--is-v3-ctor") == 0)
265 is_v3_ctor = 1;
266 else if (strcmp (opt, "--is-v3-dtor") == 0)
267 is_v3_dtor = 1;
268 else if (strcmp (opt, "--ret-postfix") == 0)
269 ret_postfix = 1;
270 else if (strcmp (opt, "--ret-drop") == 0)
271 ret_drop = 1;
272 else
273 {
274 printf ("FAIL at line %d: unrecognized option %s\n",
275 lineno, opt);
276 failures++;
277 continue;
278 }
279 *p = c;
280 p += strspn (p, " \t");
281 }
282 }
283
284 if (is_v3_ctor || is_v3_dtor)
285 {
286 char buf[20];
287
288 if (is_v3_ctor)
289 {
290 enum gnu_v3_ctor_kinds kc;
291
292 kc = is_gnu_v3_mangled_ctor (inp);
293 sprintf (buf, "%d", (int) kc);
294 }
295 else
296 {
297 enum gnu_v3_dtor_kinds kd;
298
299 kd = is_gnu_v3_mangled_dtor (inp);
300 sprintf (buf, "%d", (int) kd);
301 }
302
303 if (strcmp (buf, expect.data) != 0)
304 {
305 fail (lineno, format.data, input.data, buf, expect.data);
306 failures++;
307 }
308
309 continue;
310 }
311
312 cplus_demangle_set_style (style);
313
314 result = cplus_demangle (inp, (DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES
315 | (ret_postfix ? DMGL_RET_POSTFIX : 0)
316 | (ret_drop ? DMGL_RET_DROP : 0)));
317
318 if (result
319 ? strcmp (result, expect.data)
320 : strcmp (input.data, expect.data))
321 {
322 fail (lineno, format.data, input.data, result, expect.data);
323 failures++;
324 }
325 free (result);
326
327 if (no_params)
328 {
329 get_line (&expect);
330 result = cplus_demangle (inp, DMGL_ANSI|DMGL_TYPES);
331
332 if (result
333 ? strcmp (result, expect.data)
334 : strcmp (input.data, expect.data))
335 {
336 fail (lineno, format.data, input.data, result, expect.data);
337 failures++;
338 }
339 free (result);
340 }
341 }
342
343 free (format.data);
344 free (input.data);
345 free (expect.data);
346
347 printf ("%s: %d tests, %d failures\n", argv[0], tests, failures);
348 return failures ? 1 : 0;
349 }
350