CbC/CbC_gcc: libiberty/cplus-dem.c comparison

comparison libiberty/cplus-dem.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	f6334be47118
children	84e7813d76e9

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* Demangler for GNU C++
-Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
+Copyright (C) 1989-2017 Free Software Foundation, Inc.
-2000, 2001, 2002, 2003, 2004, 2010 Free Software Foundation, Inc.
 Written by James Clark (jjc@jclark.uucp)
 Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
 Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
 This file is part of the libiberty library.
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #else
 void * malloc ();
 void * realloc ();
+#endif
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+#ifndef INT_MAX
+# define INT_MAX       (int)(((unsigned int) ~0) >> 1)          /* 0x7FFFFFFF */
 #endif
 #include <demangle.h>
 #undef CURRENT_DEMANGLING_STYLE
 #define CURRENT_DEMANGLING_STYLE work->options
 int forgetting_types; /* Nonzero if we are not remembering the types
 			   we see.  */
 string* previous_argument; /* The last function argument demangled.  */
 int nrepeats;         /* The number of times to repeat the previous
 			   argument.  */
+int *proctypevec;     /* Indices of currently processed remembered typevecs.  */
+int proctypevec_size;
+int nproctypes;
 };
 #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
 #define PRINT_ARG_TYPES       (work -> options & DMGL_PARAMS)
 typedef enum type_kind_t
 {
 tk_none,
 tk_pointer,
 tk_reference,
+tk_rvalue_reference,
 tk_integral,
 tk_bool,
 tk_char,
 tk_real
 } type_kind_t;
 gnat_demangling,
 "GNAT style demangling"
 }
 ,
 {
+DLANG_DEMANGLING_STYLE_STRING,
+dlang_demangling,
+"DLANG style demangling"
+}
+,
+{
+RUST_DEMANGLING_STYLE_STRING,
+rust_demangling,
+"Rust style demangling"
+}
+,
+{
 NULL, unknown_demangling, NULL
 }
 };
 #define STRING_EMPTY(str)	((str) -> b == (str) -> p)
 iterate_demangle_function (struct work_stuff *,
 const char **, string *, const char *);
 static void remember_type (struct work_stuff *, const char *, int);
+static void push_processed_type (struct work_stuff *, int);
+static void pop_processed_type (struct work_stuff *);
 static void remember_Btype (struct work_stuff *, const char *, int, int);
 static int register_Btype (struct work_stuff *);
 static void remember_Ktype (struct work_stuff *, const char *, int);
 if (! ISDIGIT ((unsigned char)**type))
 return -1;
 while (ISDIGIT ((unsigned char)**type))
 {
-count *= 10;
+const int digit = **type - '0';
+/* Check for overflow.  */
-/* Check for overflow.
+if (count > ((INT_MAX - digit) / 10))
-	 We assume that count is represented using two's-complement;
-	 no power of two is divisible by ten, so if an overflow occurs
-	 when multiplying by ten, the result will not be a multiple of
-	 ten.  */
-if ((count % 10) != 0)
 	{
 	  while (ISDIGIT ((unsigned char) **type))
 	    (*type)++;
 	  return -1;
 	}
-count += **type - '0';
+count *= 10;
+count += digit;
 (*type)++;
 }
 if (count < 0)
 count = -1;
 work->options = options;
 if ((work->options & DMGL_STYLE_MASK) == 0)
 work->options |= (int) current_demangling_style & DMGL_STYLE_MASK;
 /* The V3 ABI demangling is implemented elsewhere.  */
-if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
+if (GNU_V3_DEMANGLING || RUST_DEMANGLING || AUTO_DEMANGLING)
 {
 ret = cplus_demangle_v3 (mangled, work->options);
-if (ret || GNU_V3_DEMANGLING)
+if (GNU_V3_DEMANGLING)
+	return ret;
+if (ret)
+	{
+	  /* Rust symbols are GNU_V3 mangled plus some extra subtitutions.
+	     The subtitutions are always smaller, so do in place changes.  */
+	  if (rust_is_mangled (ret))
+	    rust_demangle_sym (ret);
+	  else if (RUST_DEMANGLING)
+	    {
+	      free (ret);
+	      ret = NULL;
+	    }
+	}
+if (ret || RUST_DEMANGLING)
 	return ret;
 }
 if (JAVA_DEMANGLING)
 {
 }
 if (GNAT_DEMANGLING)
 return ada_demangle (mangled, options);
+if (DLANG_DEMANGLING)
+{
+ret = dlang_demangle (mangled, options);
+if (ret)
+	return ret;
+}
 ret = internal_cplus_demangle (work, mangled);
 squangle_mop_up (work);
 return (ret);
 }
+char *
+rust_demangle (const char *mangled, int options)
+{
+/* Rust symbols are GNU_V3 mangled plus some extra subtitutions.  */
+char *ret = cplus_demangle_v3 (mangled, options);
+/* The Rust subtitutions are always smaller, so do in place changes.  */
+if (ret != NULL)
+{
+if (rust_is_mangled (ret))
+	rust_demangle_sym (ret);
+else
+	{
+	  free (ret);
+	  ret = NULL;
+	}
+}
+return ret;
+}
 /* Demangle ada names.  The encoding is documented in gcc/ada/exp_dbug.ads.  */
 char *
 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
 {
 int len0;
 const char* p;
 char *d;
-char *demangled;
+char *demangled = NULL;
 /* Discard leading _ada_, which is used for library level subprograms.  */
 if (strncmp (mangled, "_ada_", 5) == 0)
 mangled += 5;
 }
 *d = 0;
 return demangled;
 unknown:
+XDELETEVEC (demangled);
 len0 = strlen (mangled);
 demangled = XNEWVEC (char, len0 + 3);
 if (mangled[0] == '<')
 strcpy (demangled, mangled);
 	 example.  */
 if ((AUTO_DEMANGLING || GNU_DEMANGLING))
 	{
 	  success = gnu_special (work, &mangled, &decl);
+	  if (!success)
+	    {
+	      delete_work_stuff (work);
+	      string_delete (&decl);
+	    }
 	}
 if (!success)
 	{
 	  success = demangle_prefix (work, &mangled, &decl);
 	}
 /* clean up the B and K type mangling types. */
 forget_B_and_K_types (work);
 if (work -> btypevec != NULL)
 {
 free ((char *) work -> btypevec);
+work->btypevec = NULL;
+work->bsize = 0;
 }
 if (work -> ktypevec != NULL)
 {
 free ((char *) work -> ktypevec);
+work->ktypevec = NULL;
+work->ksize = 0;
 }
 }
 /* Copy the work state and storage.  */
 to->btypevec[i] = XNEWVEC (char , len);
 memcpy (to->btypevec[i], from->btypevec[i], len);
 }
+if (from->proctypevec)
+to->proctypevec =
+XDUPVEC (int, from->proctypevec, from->proctypevec_size);
 if (from->ntmpl_args)
 to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
 for (i = 0; i < from->ntmpl_args; i++)
 {
 delete_non_B_K_work_stuff (struct work_stuff *work)
 {
 /* Discard the remembered types, if any.  */
 forget_types (work);
-if (work -> typevec != NULL)
+if (work->typevec != NULL)
 {
-free ((char *) work -> typevec);
+free ((char *) work->typevec);
-work -> typevec = NULL;
+work->typevec = NULL;
-work -> typevec_size = 0;
+work->typevec_size = 0;
+}
+if (work->proctypevec != NULL)
+{
+free (work->proctypevec);
+work->proctypevec = NULL;
+work->proctypevec_size = 0;
 }
 if (work->tmpl_argvec)
 {
 int i;
 for (i = 0; i < work->ntmpl_args; i++)
-	if (work->tmpl_argvec[i])
+	free ((char*) work->tmpl_argvec[i]);
-	  free ((char*) work->tmpl_argvec[i]);
 free ((char*) work->tmpl_argvec);
 work->tmpl_argvec = NULL;
 }
 if (work->previous_argument)
 	      /* A G++ template function.  Read the template arguments. */
 	      success = demangle_template (work, mangled, declp, 0, 0,
 					   0);
 	      if (!(work->constructor & 1))
 		expect_return_type = 1;
-	      (*mangled)++;
+	      if (!**mangled)
+		success = 0;
+	      else
+	        (*mangled)++;
 	      break;
 	    }
-	  else
+	  /* fall through */
-	    /* fall through */
-	    {;}
 	default:
 	  if (AUTO_DEMANGLING || GNU_DEMANGLING)
 	    {
 	      /* Assume we have stumbled onto the first outermost function
 else
 	success = 0;
 }
 else if (tk == tk_real)
 success = demangle_real_value (work, mangled, s);
-else if (tk == tk_pointer || tk == tk_reference)
+else if (tk == tk_pointer || tk == tk_reference
+	   || tk == tk_rvalue_reference)
 {
 if (**mangled == 'Q')
 	success = demangle_qualified (work, mangled, s,
 				      /*isfuncname=*/0,
 				      /*append=*/1);
 else
 	{
 	  int symbol_len  = consume_count (mangled);
-	  if (symbol_len == -1)
+	  if (symbol_len == -1
+	      || symbol_len > (long) strlen (*mangled))
 	    return -1;
 	  if (symbol_len == 0)
 	    string_appendn (s, "0", 1);
 	  else
 	    {
 /* get template name */
 if (**mangled == 'z')
 	{
 	  int idx;
 	  (*mangled)++;
+	  if (**mangled == '\0')
+	    return (0);
 	  (*mangled)++;
 	  idx = consume_count_with_underscores (mangled);
 	  if (idx == -1
 	      || (work->tmpl_argvec && idx >= work->ntmpl_args)
 {
 int n;
 int success = 1;
 const char *p;
-if ((*mangled)[0] == '_'
+if ((*mangled)[0] == '_' && (*mangled)[1] != '\0'
 && strchr (cplus_markers, (*mangled)[1]) != NULL
 && (*mangled)[2] == '_')
 {
 /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
 (*mangled) += 3;
 	   && (((*mangled)[1] == '_'
 		&& (*mangled)[2] == 'v'
 		&& (*mangled)[3] == 't'
 		&& (*mangled)[4] == '_')
 	       || ((*mangled)[1] == 'v'
-		   && (*mangled)[2] == 't'
+		   && (*mangled)[2] == 't' && (*mangled)[3] != '\0'
 		   && strchr (cplus_markers, (*mangled)[3]) != NULL)))
 {
 /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
 and create the decl.  Note that we consume the entire mangled
 	 input string, which means that demangle_signature has no work
 		  if (n > (int) strlen (*mangled))
 		    {
 		      success = 1;
 		      break;
 		    }
+		  else if (n == -1)
+		    {
+		      success = 0;
+		      break;
+		    }
 		}
 	      else
 		{
 		  n = strcspn (*mangled, cplus_markers);
 		}
 (*mangled) += 8;
 delta = consume_count (mangled);
 if (delta == -1)
 	success = 0;
+else if (**mangled != '_')
+success = 0;
 else
 	{
 	  char *method = internal_cplus_demangle (work, ++*mangled);
 	  if (method)
 static int
 do_type (struct work_stuff *work, const char **mangled, string *result)
 {
 int n;
+int i;
+int is_proctypevec;
 int done;
 int success;
 string decl;
 const char *remembered_type;
 int type_quals;
 string_init (&decl);
 string_init (result);
 done = 0;
 success = 1;
+is_proctypevec = 0;
 while (success && !done)
 {
 int member;
 switch (**mangled)
 	{
 	case 'R':
 	  (*mangled)++;
 	  string_prepend (&decl, "&");
 	  if (tk == tk_none)
 	    tk = tk_reference;
+	  break;
+	  /* An rvalue reference type */
+	case 'O':
+	  (*mangled)++;
+	  string_prepend (&decl, "&&");
+	  if (tk == tk_none)
+	    tk = tk_rvalue_reference;
 	  break;
 	  /* An array */
 	case 'A':
 	  {
 	  }
 	/* A back reference to a previously seen type */
 	case 'T':
 	  (*mangled)++;
-	  if (!get_count (mangled, &n) || n >= work -> ntypes)
+	  if (!get_count (mangled, &n) || n < 0 || n >= work -> ntypes)
 	    {
 	      success = 0;
 	    }
 	  else
-	    {
+	    for (i = 0; i < work->nproctypes; i++)
-	      remembered_type = work -> typevec[n];
+	      if (work -> proctypevec [i] == n)
+	        success = 0;
+	  if (success)
+	    {
+	      is_proctypevec = 1;
+	      push_processed_type (work, n);
+	      remembered_type = work->typevec[n];
 	      mangled = &remembered_type;
 	    }
 	  break;
 	  /* A function */
 	  if (success && (**mangled == '_'))
 	    (*mangled)++;
 	  break;
 	case 'M':
-	case 'O':
 	  {
 	    type_quals = TYPE_UNQUALIFIED;
 	    member = **mangled == 'M';
 	    (*mangled)++;
 		  {
 		    string_prependn (&decl, temp.b, temp.p - temp.b);
 		    string_delete (&temp);
 		  }
 		else
-		  break;
+		  {
+		    string_delete (&temp);
+		    break;
+		  }
 	      }
 	    else if (**mangled == 'Q')
 	      {
 		success = demangle_qualified (work, mangled, &decl,
 					      /*isfuncnam=*/0,
 		  default:
 		    break;
 		  }
-		if (*(*mangled)++ != 'F')
+		if (*(*mangled) != 'F')
 		  {
 		    success = 0;
 		    break;
 		  }
+		(*mangled)++;
 	      }
 	    if ((member && !demangle_nested_args (work, mangled, &decl))
 		|| **mangled != '_')
 	      {
 		success = 0;
 }
 /* A back reference to a previously seen squangled type */
 case 'B':
 (*mangled)++;
-if (!get_count (mangled, &n) || n >= work -> numb)
+if (!get_count (mangled, &n) || n < 0 || n >= work -> numb)
 	success = 0;
 else
 	string_append (result, work->btypevec[n]);
 break;
 	}
 }
 else
 string_delete (result);
 string_delete (&decl);
+if (is_proctypevec)
+pop_processed_type (work);
 if (success)
 /* Assume an integral type, if we're not sure.  */
 return (int) ((tk == tk_none) ? tk_integral : tk);
 else
 if (!ISDIGIT ((unsigned char)**mangled))
 	{
 	  success = 0;
 	  break;
 	}
+/* fall through */
 case 'I':
 (*mangled)++;
 if (**mangled == '_')
 	{
 	  int i;
 (*mangled)++;
 literal_len = consume_count (mangled);
-if (literal_len <= 0)
+if (literal_len <= 0
+|| literal_len > (long) strlen (*mangled))
 return 0;
 /* Literal parameters are names of arrays, functions, etc.  and the
 canonical representation uses the address operator */
 string_append (result, "&");
 remember_type (work, start, *mangled - start);
 return 1;
 }
 static void
+push_processed_type (struct work_stuff *work, int typevec_index)
+{
+if (work->nproctypes >= work->proctypevec_size)
+{
+if (!work->proctypevec_size)
+	{
+	  work->proctypevec_size = 4;
+	  work->proctypevec = XNEWVEC (int, work->proctypevec_size);
+	}
+else
+	{
+	  if (work->proctypevec_size < 16)
+	    /* Double when small.  */
+	    work->proctypevec_size *= 2;
+	  else
+	    {
+	      /* Grow slower when large.  */
+	      if (work->proctypevec_size > (INT_MAX / 3) * 2)
+xmalloc_failed (INT_MAX);
+work->proctypevec_size = (work->proctypevec_size * 3 / 2);
+	    }
+work->proctypevec
+= XRESIZEVEC (int, work->proctypevec, work->proctypevec_size);
+	}
+}
+work->proctypevec [work->nproctypes++] = typevec_index;
+}
+static void
+pop_processed_type (struct work_stuff *work)
+{
+work->nproctypes--;
+}
+static void
 remember_type (struct work_stuff *work, const char *start, int len)
 {
 char *tem;
 if (work->forgetting_types)
 	  work -> typevec_size = 3;
 	  work -> typevec = XNEWVEC (char *, work->typevec_size);
 	}
 else
 	{
+if (work -> typevec_size > INT_MAX / 2)
+	    xmalloc_failed (INT_MAX);
 	  work -> typevec_size *= 2;
 	  work -> typevec
 	    = XRESIZEVEC (char *, work->typevec, work->typevec_size);
 	}
 }
 	  work -> ksize = 5;
 	  work -> ktypevec = XNEWVEC (char *, work->ksize);
 	}
 else
 	{
+if (work -> ksize > INT_MAX / 2)
+	    xmalloc_failed (INT_MAX);
 	  work -> ksize *= 2;
 	  work -> ktypevec
 	    = XRESIZEVEC (char *, work->ktypevec, work->ksize);
 	}
 }
 	  work -> bsize = 5;
 	  work -> btypevec = XNEWVEC (char *, work->bsize);
 	}
 else
 	{
+if (work -> bsize > INT_MAX / 2)
+	    xmalloc_failed (INT_MAX);
 	  work -> bsize *= 2;
 	  work -> btypevec
 	    = XRESIZEVEC (char *, work->btypevec, work->bsize);
 	}
 }
 	      tem = work -> typevec[t];
 	      if (need_comma && PRINT_ARG_TYPES)
 		{
 		  string_append (declp, ", ");
 		}
+	      push_processed_type (work, t);
 	      if (!do_arg (work, &tem, &arg))
 		{
+		  pop_processed_type (work);
 		  return (0);
 		}
+	      pop_processed_type (work);
 	      if (PRINT_ARG_TYPES)
 		{
 		  string_appends (declp, &arg);
 		}
 	      string_delete (&arg);
 s->e = s->b + n;
 }
 else if (s->e - s->p < n)
 {
 tem = s->p - s->b;
+if (n > INT_MAX / 2 - tem)
+xmalloc_failed (INT_MAX);
 n += tem;
 n *= 2;
 s->b = XRESIZEVEC (char, s->b, n);
 s->p = s->b + tem;
 s->e = s->b + n;

Mercurial > hg > CbC > CbC_gcc

comparison libiberty/cplus-dem.c @ 111:04ced10e8804