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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libiberty/] [testsuite/] [test-demangle.c] - Blame information for rev 736

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 736 jeremybenn
/* 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
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 *
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
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
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
}

powered by: WebSVN 2.1.0

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