First Commit

3rdparty/demangler/testsuite/demangler-fuzzer.c

@@ -0,0 +1,108 @@
+/* Demangler fuzzer.
+
+   Copyright (C) 2014-2023 Free Software Foundation, Inc.
+
+   This file is part of GNU libiberty.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include "demangle.h"
+
+#define MAXLEN 253
+#define ALPMIN 33
+#define ALPMAX 127
+
+static char *program_name;
+
+#define DEFAULT_MAXCOUNT 7500000
+
+static void
+print_usage (FILE *fp, int exit_value)
+{
+  fprintf (fp, "Usage: %s [OPTION]...\n", program_name);
+  fprintf (fp, "Options:\n");
+  fprintf (fp, "  -h           Display this message.\n");
+  fprintf (fp, "  -s SEED      Select the random seed to be used.\n");
+  fprintf (fp, "               The default is to base one on the");
+  fprintf (fp, " current time.\n");
+  fprintf (fp, "  -m MAXCOUNT  Exit after MAXCOUNT symbols.\n");
+  fprintf (fp, "               The default is %d.", DEFAULT_MAXCOUNT);
+  fprintf (fp, " Set to `-1' for no limit.\n");
+
+  exit (exit_value);
+}
+
+int
+main (int argc, char *argv[])
+{
+  char symbol[2 + MAXLEN + 1] = "_Z";
+  int seed = -1, seed_set = 0;
+  int count = 0, maxcount = DEFAULT_MAXCOUNT;
+  int optchr;
+
+  program_name = argv[0];
+
+  do
+    {
+      optchr = getopt (argc, argv, "hs:m:t:");
+      switch (optchr)
+	{
+	case '?':  /* Unrecognized option.  */
+	  print_usage (stderr, 1);
+	  break;
+
+	case 'h':
+	  print_usage (stdout, 0);
+	  break;
+
+	case 's':
+	  seed = atoi (optarg);
+	  seed_set = 1;
+	  break;
+
+	case 'm':
+	  maxcount = atoi (optarg);
+	  break;
+	}
+    }
+  while (optchr != -1);
+
+  if (!seed_set)
+    seed = time (NULL);
+  srand (seed);
+  printf ("%s: seed = %d\n", program_name, seed);
+
+  while (maxcount < 0 || count < maxcount)
+    {
+      char *buffer = symbol + 2;
+      int length, i;
+
+      length = rand () % MAXLEN;
+      for (i = 0; i < length; i++)
+	*buffer++ = (rand () % (ALPMAX - ALPMIN)) + ALPMIN;
+
+      *buffer++ = '\0';
+
+      cplus_demangle (symbol, DMGL_AUTO | DMGL_ANSI | DMGL_PARAMS);
+
+      count++;
+    }
+
+  printf ("%s: successfully demangled %d symbols\n", program_name, count);
+  exit (0);
+}

3rdparty/demangler/testsuite/test-demangle.c

@@ -0,0 +1,352 @@
+/* Demangler test program,
+   Copyright (C) 2002-2023 Free Software Foundation, Inc.
+   Written by Zack Weinberg <zack@codesourcery.com
+
+   This file is part of GNU libiberty.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include "ansidecl.h"
+#include <stdio.h>
+#include "libiberty.h"
+#include "demangle.h"
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+#if HAVE_STDLIB_H
+# include <stdlib.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+struct line
+{
+  size_t alloced;
+  char *data;
+};
+
+static unsigned int lineno;
+
+/* Safely read a single line of arbitrary length from standard input.  */
+
+#define LINELEN 80
+
+static void
+get_line(buf)
+     struct line *buf;
+{
+  char *data = buf->data;
+  size_t alloc = buf->alloced;
+  size_t count = 0;
+  int c;
+
+  if (data == 0)
+    {
+      data = xmalloc (LINELEN);
+      alloc = LINELEN;
+    }
+
+  /* Skip comment lines.  */
+  while ((c = getchar()) == '#')
+    {
+      while ((c = getchar()) != EOF && c != '\n');
+      lineno++;
+    }
+
+  /* c is the first character on the line, and it's not a comment
+     line: copy this line into the buffer and return.  */
+  while (c != EOF && c != '\n')
+    {
+      if (count + 1 >= alloc)
+	{
+	  alloc *= 2;
+	  data = xrealloc (data, alloc);
+	}
+      data[count++] = c;
+      c = getchar();
+    }
+  lineno++;
+  data[count] = '\0';
+
+  buf->data = data;
+  buf->alloced = alloc;
+}
+
+/* If we have mmap() and mprotect(), copy the string S just before a
+   protected page, so that if the demangler runs over the end of the
+   string we'll get a fault, and return the address of the new string.
+   If no mmap, or it fails, or it looks too hard, just return S.  */
+
+#ifdef HAVE_SYS_MMAN_H
+#include <sys/mman.h>
+#endif
+#if defined(MAP_ANON) && ! defined (MAP_ANONYMOUS)
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+
+static const char *
+protect_end (const char * s)
+{
+#if defined(HAVE_MMAP) && defined (MAP_ANONYMOUS)
+  size_t pagesize = getpagesize();
+  static char * buf;
+  size_t s_len = strlen (s);
+  char * result;
+  
+  /* Don't try if S is too long.  */
+  if (s_len >= pagesize)
+    return s;
+
+  /* Allocate one page of allocated space followed by an unmapped
+     page.  */
+  if (buf == NULL)
+    {
+      buf = mmap (NULL, pagesize * 2, PROT_READ | PROT_WRITE,
+		  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+      if (! buf)
+	return s;
+      munmap (buf + pagesize, pagesize);
+    }
+  
+  result = buf + (pagesize - s_len - 1);
+  memcpy (result, s, s_len + 1);
+  return result;
+#else
+  return s;
+#endif
+}
+
+static void
+fail (lineno, opts, in, out, exp)
+     int lineno;
+     const char *opts;
+     const char *in;
+     const char *out;
+     const char *exp;
+{
+  printf ("\
+FAIL at line %d, options %s:\n\
+in:  %s\n\
+out: %s\n\
+exp: %s\n",
+	  lineno, opts, in, out != NULL ? out : "(null)", exp);
+}
+
+/* The tester operates on a data file consisting of groups of lines:
+   options
+   input to be demangled
+   expected output
+
+   Supported options:
+     --format=<name>     Sets the demangling style.
+     --no-params         There are two lines of expected output; the first
+                         is with DMGL_PARAMS, the second is without it.
+     --is-v3-ctor        Calls is_gnu_v3_mangled_ctor on input; expected
+                         output is an integer representing ctor_kind.
+     --is-v3-dtor        Likewise, but for dtors.
+     --ret-postfix       Passes the DMGL_RET_POSTFIX option
+     --ret-drop          Passes the DMGL_RET_DROP option
+
+   For compatibility, just in case it matters, the options line may be
+   empty, to mean --format=auto.  If it doesn't start with --, then it
+   may contain only a format name.
+*/
+
+int
+main(argc, argv)
+     int argc;
+     char **argv;
+{
+  enum demangling_styles style = auto_demangling;
+  int no_params;
+  int is_v3_ctor;
+  int is_v3_dtor;
+  int ret_postfix, ret_drop;
+  struct line format;
+  struct line input;
+  struct line expect;
+  char *result;
+  int failures = 0;
+  int tests = 0;
+
+  if (argc > 1)
+    {
+      fprintf (stderr, "usage: %s < test-set\n", argv[0]);
+      return 2;
+    }
+
+  format.data = 0;
+  input.data = 0;
+  expect.data = 0;
+
+  for (;;)
+    {
+      const char *inp;
+      
+      get_line (&format);
+      if (feof (stdin))
+	break;
+
+      get_line (&input);
+      get_line (&expect);
+
+      inp = protect_end (input.data);
+
+      tests++;
+
+      no_params = 0;
+      ret_postfix = 0;
+      ret_drop = 0;
+      is_v3_ctor = 0;
+      is_v3_dtor = 0;
+      if (format.data[0] == '\0')
+	style = auto_demangling;
+      else if (format.data[0] != '-')
+	{
+	  style = cplus_demangle_name_to_style (format.data);
+	  if (style == unknown_demangling)
+	    {
+	      printf ("FAIL at line %d: unknown demangling style %s\n",
+		      lineno, format.data);
+	      failures++;
+	      continue;
+	    }
+	}
+      else
+	{
+	  char *p;
+	  char *opt;
+
+	  p = format.data;
+	  while (*p != '\0')
+	    {
+	      char c;
+
+	      opt = p;
+	      p += strcspn (p, " \t=");
+	      c = *p;
+	      *p = '\0';
+	      if (strcmp (opt, "--format") == 0 && c == '=')
+		{
+		  char *fstyle;
+
+		  *p = c;
+		  ++p;
+		  fstyle = p;
+		  p += strcspn (p, " \t");
+		  c = *p;
+		  *p = '\0';
+		  style = cplus_demangle_name_to_style (fstyle);
+		  if (style == unknown_demangling)
+		    {
+		      printf ("FAIL at line %d: unknown demangling style %s\n",
+			      lineno, fstyle);
+		      failures++;
+		      continue;
+		    }
+		}
+	      else if (strcmp (opt, "--no-params") == 0)
+		no_params = 1;
+	      else if (strcmp (opt, "--is-v3-ctor") == 0)
+		is_v3_ctor = 1;
+	      else if (strcmp (opt, "--is-v3-dtor") == 0)
+		is_v3_dtor = 1;
+	      else if (strcmp (opt, "--ret-postfix") == 0)
+		ret_postfix = 1;
+	      else if (strcmp (opt, "--ret-drop") == 0)
+		ret_drop = 1;
+	      else
+		{
+		  printf ("FAIL at line %d: unrecognized option %s\n",
+			  lineno, opt);
+		  failures++;
+		  continue;
+		}
+	      *p = c;
+	      p += strspn (p, " \t");
+	    }
+	}
+
+      if (is_v3_ctor || is_v3_dtor)
+	{
+	  char buf[20];
+
+	  if (is_v3_ctor)
+	    {
+	      enum gnu_v3_ctor_kinds kc;
+
+	      kc = is_gnu_v3_mangled_ctor (inp);
+	      sprintf (buf, "%d", (int) kc);
+	    }
+	  else
+	    {
+	      enum gnu_v3_dtor_kinds kd;
+
+	      kd = is_gnu_v3_mangled_dtor (inp);
+	      sprintf (buf, "%d", (int) kd);
+	    }
+
+	  if (strcmp (buf, expect.data) != 0)
+	    {
+	      fail (lineno, format.data, input.data, buf, expect.data);
+	      failures++;
+	    }
+
+	  continue;
+	}
+
+      cplus_demangle_set_style (style);
+
+      result = cplus_demangle (inp, (DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES
+				     | (ret_postfix ? DMGL_RET_POSTFIX : 0)
+				     | (ret_drop ? DMGL_RET_DROP : 0)));
+
+      if (result
+	  ? strcmp (result, expect.data)
+	  : strcmp (input.data, expect.data))
+	{
+	  fail (lineno, format.data, input.data, result, expect.data);
+	  failures++;
+	}
+      free (result);
+
+      if (no_params)
+	{
+	  get_line (&expect);
+	  result = cplus_demangle (inp, DMGL_ANSI|DMGL_TYPES);
+
+	  if (result
+	      ? strcmp (result, expect.data)
+	      : strcmp (input.data, expect.data))
+	    {
+	      fail (lineno, format.data, input.data, result, expect.data);
+	      failures++;
+	    }
+	  free (result);
+	}
+    }
+
+  free (format.data);
+  free (input.data);
+  free (expect.data);
+
+  printf ("%s: %d tests, %d failures\n", argv[0], tests, failures);
+  return failures ? 1 : 0;
+}