[binutils.git] / gdb / common / common-utils.c

/* Shared general utility routines for GDB, the GNU debugger.

   Copyright (C) 1986-2019 Free Software Foundation, Inc.

   This file is part of GDB.

   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 "common-defs.h"
#include "common-utils.h"
#include "host-defs.h"
#include <ctype.h>

/* The xmalloc() (libiberty.h) family of memory management routines.

   These are like the ISO-C malloc() family except that they implement
   consistent semantics and guard against typical memory management
   problems.  */

/* NOTE: These are declared using PTR to ensure consistency with
   "libiberty.h".  xfree() is GDB local.  */

PTR                            /* ARI: PTR */
xmalloc (size_t size)
{
  void *val;

  /* See libiberty/xmalloc.c.  This function need's to match that's
     semantics.  It never returns NULL.  */
  if (size == 0)
    size = 1;

  val = malloc (size);         /* ARI: malloc */
  if (val == NULL)
    malloc_failure (size);

  return val;
}

PTR                              /* ARI: PTR */
xrealloc (PTR ptr, size_t size)          /* ARI: PTR */
{
  void *val;

  /* See libiberty/xmalloc.c.  This function need's to match that's
     semantics.  It never returns NULL.  */
  if (size == 0)
    size = 1;

  if (ptr != NULL)
    val = realloc (ptr, size);	/* ARI: realloc */
  else
    val = malloc (size);	        /* ARI: malloc */
  if (val == NULL)
    malloc_failure (size);

  return val;
}

PTR                            /* ARI: PTR */           
xcalloc (size_t number, size_t size)
{
  void *mem;

  /* See libiberty/xmalloc.c.  This function need's to match that's
     semantics.  It never returns NULL.  */
  if (number == 0 || size == 0)
    {
      number = 1;
      size = 1;
    }

  mem = calloc (number, size);      /* ARI: xcalloc */
  if (mem == NULL)
    malloc_failure (number * size);

  return mem;
}

void *
xzalloc (size_t size)
{
  return xcalloc (1, size);
}

void
xmalloc_failed (size_t size)
{
  malloc_failure (size);
}

/* Like asprintf/vasprintf but get an internal_error if the call
   fails. */

char *
xstrprintf (const char *format, ...)
{
  char *ret;
  va_list args;

  va_start (args, format);
  ret = xstrvprintf (format, args);
  va_end (args);
  return ret;
}

char *
xstrvprintf (const char *format, va_list ap)
{
  char *ret = NULL;
  int status = vasprintf (&ret, format, ap);

  /* NULL is returned when there was a memory allocation problem, or
     any other error (for instance, a bad format string).  A negative
     status (the printed length) with a non-NULL buffer should never
     happen, but just to be sure.  */
  if (ret == NULL || status < 0)
    internal_error (__FILE__, __LINE__, _("vasprintf call failed"));
  return ret;
}

int
xsnprintf (char *str, size_t size, const char *format, ...)
{
  va_list args;
  int ret;

  va_start (args, format);
  ret = vsnprintf (str, size, format, args);
  gdb_assert (ret < size);
  va_end (args);

  return ret;
}

/* See documentation in common-utils.h.  */

std::string
string_printf (const char* fmt, ...)
{
  va_list vp;
  int size;

  va_start (vp, fmt);
  size = vsnprintf (NULL, 0, fmt, vp);
  va_end (vp);

  std::string str (size, '\0');

  /* C++11 and later guarantee std::string uses contiguous memory and
     always includes the terminating '\0'.  */
  va_start (vp, fmt);
  vsprintf (&str[0], fmt, vp);
  va_end (vp);

  return str;
}

/* See documentation in common-utils.h.  */

std::string
string_vprintf (const char* fmt, va_list args)
{
  va_list vp;
  size_t size;

  va_copy (vp, args);
  size = vsnprintf (NULL, 0, fmt, vp);
  va_end (vp);

  std::string str (size, '\0');

  /* C++11 and later guarantee std::string uses contiguous memory and
     always includes the terminating '\0'.  */
  vsprintf (&str[0], fmt, args);

  return str;
}


/* See documentation in common-utils.h.  */

void
string_appendf (std::string &str, const char *fmt, ...)
{
  va_list vp;

  va_start (vp, fmt);
  string_vappendf (str, fmt, vp);
  va_end (vp);
}


/* See documentation in common-utils.h.  */

void
string_vappendf (std::string &str, const char *fmt, va_list args)
{
  va_list vp;
  int grow_size;

  va_copy (vp, args);
  grow_size = vsnprintf (NULL, 0, fmt, vp);
  va_end (vp);

  size_t curr_size = str.size ();
  str.resize (curr_size + grow_size);

  /* C++11 and later guarantee std::string uses contiguous memory and
     always includes the terminating '\0'.  */
  vsprintf (&str[curr_size], fmt, args);
}

char *
savestring (const char *ptr, size_t len)
{
  char *p = (char *) xmalloc (len + 1);

  memcpy (p, ptr, len);
  p[len] = 0;
  return p;
}

/* The bit offset of the highest byte in a ULONGEST, for overflow
   checking.  */

#define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)

/* True (non-zero) iff DIGIT is a valid digit in radix BASE,
   where 2 <= BASE <= 36.  */

static int
is_digit_in_base (unsigned char digit, int base)
{
  if (!isalnum (digit))
    return 0;
  if (base <= 10)
    return (isdigit (digit) && digit < base + '0');
  else
    return (isdigit (digit) || tolower (digit) < base - 10 + 'a');
}

static int
digit_to_int (unsigned char c)
{
  if (isdigit (c))
    return c - '0';
  else
    return tolower (c) - 'a' + 10;
}

/* As for strtoul, but for ULONGEST results.  */

ULONGEST
strtoulst (const char *num, const char **trailer, int base)
{
  unsigned int high_part;
  ULONGEST result;
  int minus = 0;
  int i = 0;

  /* Skip leading whitespace.  */
  while (isspace (num[i]))
    i++;

  /* Handle prefixes.  */
  if (num[i] == '+')
    i++;
  else if (num[i] == '-')
    {
      minus = 1;
      i++;
    }

  if (base == 0 || base == 16)
    {
      if (num[i] == '0' && (num[i + 1] == 'x' || num[i + 1] == 'X'))
	{
	  i += 2;
	  if (base == 0)
	    base = 16;
	}
    }

  if (base == 0 && num[i] == '0')
    base = 8;

  if (base == 0)
    base = 10;

  if (base < 2 || base > 36)
    {
      errno = EINVAL;
      return 0;
    }

  result = high_part = 0;
  for (; is_digit_in_base (num[i], base); i += 1)
    {
      result = result * base + digit_to_int (num[i]);
      high_part = high_part * base + (unsigned int) (result >> HIGH_BYTE_POSN);
      result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1;
      if (high_part > 0xff)
	{
	  errno = ERANGE;
	  result = ~ (ULONGEST) 0;
	  high_part = 0;
	  minus = 0;
	  break;
	}
    }

  if (trailer != NULL)
    *trailer = &num[i];

  result = result + ((ULONGEST) high_part << HIGH_BYTE_POSN);
  if (minus)
    return -result;
  else
    return result;
}

/* See documentation in common-utils.h.  */

char *
skip_spaces (char *chp)
{
  if (chp == NULL)
    return NULL;
  while (*chp && isspace (*chp))
    chp++;
  return chp;
}

/* A const-correct version of the above.  */

const char *
skip_spaces (const char *chp)
{
  if (chp == NULL)
    return NULL;
  while (*chp && isspace (*chp))
    chp++;
  return chp;
}

/* See documentation in common-utils.h.  */

const char *
skip_to_space (const char *chp)
{
  if (chp == NULL)
    return NULL;
  while (*chp && !isspace (*chp))
    chp++;
  return chp;
}

/* See documentation in common-utils.h.  */

char *
skip_to_space (char *chp)
{
  return (char *) skip_to_space ((const char *) chp);
}

/* See common/common-utils.h.  */

void
free_vector_argv (std::vector<char *> &v)
{
  for (char *el : v)
    xfree (el);

  v.clear ();
}

/* See common/common-utils.h.  */

std::string
stringify_argv (const std::vector<char *> &args)
{
  std::string ret;

  if (!args.empty () && args[0] != NULL)
    {
      for (auto s : args)
	if (s != NULL)
	  {
	    ret += s;
	    ret += ' ';
	  }

      /* Erase the last whitespace.  */
      ret.erase (ret.end () - 1);
    }

  return ret;
}

/* See common/common-utils.h.  */

ULONGEST
align_up (ULONGEST v, int n)
{
  /* Check that N is really a power of two.  */
  gdb_assert (n && (n & (n-1)) == 0);
  return (v + n - 1) & -n;
}

/* See common/common-utils.h.  */

ULONGEST
align_down (ULONGEST v, int n)
{
  /* Check that N is really a power of two.  */
  gdb_assert (n && (n & (n-1)) == 0);
  return (v & -n);
}
Commit	Line	Data
d26e3629 KY	1	/* Shared general utility routines for GDB, the GNU debugger.
d26e3629 KY	2
42a4f53d	3	Copyright (C) 1986-2019 Free Software Foundation, Inc.
d26e3629 KY	4
	5	This file is part of GDB.
	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 3 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, see <http://www.gnu.org/licenses/>. */
	19
727605ca	20	#include "common-defs.h"
2090129c	21	#include "common-utils.h"
03aef70f JK	22	#include "host-defs.h"
03aef70f JK	23	#include <ctype.h>
d26e3629	24
d26e3629 KY	25	/* The xmalloc() (libiberty.h) family of memory management routines.
	26
	27	These are like the ISO-C malloc() family except that they implement
	28	consistent semantics and guard against typical memory management
	29	problems. */
	30
	31	/* NOTE: These are declared using PTR to ensure consistency with
	32	"libiberty.h". xfree() is GDB local. */
	33
	34	PTR /* ARI: PTR */
	35	xmalloc (size_t size)
	36	{
	37	void *val;
	38
	39	/* See libiberty/xmalloc.c. This function need's to match that's
	40	semantics. It never returns NULL. */
	41	if (size == 0)
	42	size = 1;
	43
	44	val = malloc (size); /* ARI: malloc */
	45	if (val == NULL)
	46	malloc_failure (size);
	47
	48	return val;
	49	}
	50
	51	PTR /* ARI: PTR */
	52	xrealloc (PTR ptr, size_t size) /* ARI: PTR */
	53	{
	54	void *val;
	55
	56	/* See libiberty/xmalloc.c. This function need's to match that's
	57	semantics. It never returns NULL. */
	58	if (size == 0)
	59	size = 1;
	60
	61	if (ptr != NULL)
	62	val = realloc (ptr, size); /* ARI: realloc */
	63	else
	64	val = malloc (size); /* ARI: malloc */
	65	if (val == NULL)
	66	malloc_failure (size);
	67
	68	return val;
	69	}
	70
	71	PTR /* ARI: PTR */
	72	xcalloc (size_t number, size_t size)
	73	{
	74	void *mem;
	75
	76	/* See libiberty/xmalloc.c. This function need's to match that's
	77	semantics. It never returns NULL. */
	78	if (number == 0 \|\| size == 0)
	79	{
	80	number = 1;
	81	size = 1;
	82	}
	83
	84	mem = calloc (number, size); /* ARI: xcalloc */
	85	if (mem == NULL)
	86	malloc_failure (number * size);
	87
	88	return mem;
89	}
90
91	void *
92	xzalloc (size_t size)
93	{
94	return xcalloc (1, size);
95	}
96
51403f74 NC	97	void
	98	xmalloc_failed (size_t size)
	99	{
	100	malloc_failure (size);
	101	}
	102
d26e3629 KY	103	/* Like asprintf/vasprintf but get an internal_error if the call
	104	fails. */
	105
	106	char *
	107	xstrprintf (const char *format, ...)
	108	{
	109	char *ret;
	110	va_list args;
	111
	112	va_start (args, format);
	113	ret = xstrvprintf (format, args);
	114	va_end (args);
	115	return ret;
	116	}
	117
	118	char *
	119	xstrvprintf (const char *format, va_list ap)
	120	{
	121	char *ret = NULL;
	122	int status = vasprintf (&ret, format, ap);
	123
	124	/* NULL is returned when there was a memory allocation problem, or
	125	any other error (for instance, a bad format string). A negative
	126	status (the printed length) with a non-NULL buffer should never
	127	happen, but just to be sure. */
	128	if (ret == NULL \|\| status < 0)
	129	internal_error (__FILE__, __LINE__, _("vasprintf call failed"));
	130	return ret;
	131	}
	132
d26e3629 KY	133	int
	134	xsnprintf (char str, size_t size, const char format, ...)
	135	{
	136	va_list args;
	137	int ret;
	138
	139	va_start (args, format);
	140	ret = vsnprintf (str, size, format, args);
	141	gdb_assert (ret < size);
	142	va_end (args);
	143
	144	return ret;
	145	}
baea0dae	146
d4081a38 PA	147	/* See documentation in common-utils.h. */
	148
	149	std::string
	150	string_printf (const char* fmt, ...)
	151	{
	152	va_list vp;
	153	int size;
	154
	155	va_start (vp, fmt);
	156	size = vsnprintf (NULL, 0, fmt, vp);
	157	va_end (vp);
	158
	159	std::string str (size, '\0');
	160
	161	/* C++11 and later guarantee std::string uses contiguous memory and
	162	always includes the terminating '\0'. */
	163	va_start (vp, fmt);
	164	vsprintf (&str[0], fmt, vp);
	165	va_end (vp);
	166
	167	return str;
	168	}
	169
bd413795 TT	170	/* See documentation in common-utils.h. */
	171
	172	std::string
	173	string_vprintf (const char* fmt, va_list args)
	174	{
	175	va_list vp;
	176	size_t size;
	177
	178	va_copy (vp, args);
	179	size = vsnprintf (NULL, 0, fmt, vp);
	180	va_end (vp);
	181
	182	std::string str (size, '\0');
	183
	184	/* C++11 and later guarantee std::string uses contiguous memory and
	185	always includes the terminating '\0'. */
	186	vsprintf (&str[0], fmt, args);
	187
	188	return str;
	189	}
	190
31b833b3 PA	191
	192	/* See documentation in common-utils.h. */
	193
	194	void
	195	string_appendf (std::string &str, const char *fmt, ...)
	196	{
	197	va_list vp;
	198
	199	va_start (vp, fmt);
	200	string_vappendf (str, fmt, vp);
	201	va_end (vp);
	202	}
	203
	204
	205	/* See documentation in common-utils.h. */
	206
	207	void
	208	string_vappendf (std::string &str, const char *fmt, va_list args)
	209	{
	210	va_list vp;
	211	int grow_size;
	212
	213	va_copy (vp, args);
	214	grow_size = vsnprintf (NULL, 0, fmt, vp);
	215	va_end (vp);
	216
	217	size_t curr_size = str.size ();
	218	str.resize (curr_size + grow_size);
	219
	220	/* C++11 and later guarantee std::string uses contiguous memory and
	221	always includes the terminating '\0'. */
	222	vsprintf (&str[curr_size], fmt, args);
	223	}
	224
baea0dae PA	225	char *
	226	savestring (const char *ptr, size_t len)
	227	{
	228	char p = (char ) xmalloc (len + 1);
	229
	230	memcpy (p, ptr, len);
	231	p[len] = 0;
	232	return p;
	233	}
03aef70f JK	234
	235	/* The bit offset of the highest byte in a ULONGEST, for overflow
	236	checking. */
	237
	238	#define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
	239
	240	/* True (non-zero) iff DIGIT is a valid digit in radix BASE,
	241	where 2 <= BASE <= 36. */
	242
	243	static int
	244	is_digit_in_base (unsigned char digit, int base)
	245	{
	246	if (!isalnum (digit))
	247	return 0;
	248	if (base <= 10)
	249	return (isdigit (digit) && digit < base + '0');
	250	else
	251	return (isdigit (digit) \|\| tolower (digit) < base - 10 + 'a');
	252	}
	253
	254	static int
	255	digit_to_int (unsigned char c)
	256	{
	257	if (isdigit (c))
	258	return c - '0';
	259	else
	260	return tolower (c) - 'a' + 10;
	261	}
	262
	263	/* As for strtoul, but for ULONGEST results. */
	264
	265	ULONGEST
	266	strtoulst (const char num, const char *trailer, int base)
	267	{
	268	unsigned int high_part;
	269	ULONGEST result;
	270	int minus = 0;
	271	int i = 0;
	272
	273	/* Skip leading whitespace. */
	274	while (isspace (num[i]))
	275	i++;
	276
	277	/* Handle prefixes. */
	278	if (num[i] == '+')
	279	i++;
	280	else if (num[i] == '-')
	281	{
	282	minus = 1;
	283	i++;
	284	}
	285
	286	if (base == 0 \|\| base == 16)
	287	{
	288	if (num[i] == '0' && (num[i + 1] == 'x' \|\| num[i + 1] == 'X'))
	289	{
	290	i += 2;
	291	if (base == 0)
	292	base = 16;
	293	}
	294	}
	295
	296	if (base == 0 && num[i] == '0')
	297	base = 8;
298
299	if (base == 0)
300	base = 10;
301
302	if (base < 2 \|\| base > 36)
303	{
304	errno = EINVAL;
305	return 0;
306	}
307
308	result = high_part = 0;
309	for (; is_digit_in_base (num[i], base); i += 1)
310	{
311	result = result * base + digit_to_int (num[i]);
312	high_part = high_part * base + (unsigned int) (result >> HIGH_BYTE_POSN);
313	result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1;
314	if (high_part > 0xff)
315	{
316	errno = ERANGE;
317	result = ~ (ULONGEST) 0;
318	high_part = 0;
319	minus = 0;
320	break;
321	}
322	}
323
324	if (trailer != NULL)
325	*trailer = &num[i];
326
327	result = result + ((ULONGEST) high_part << HIGH_BYTE_POSN);
328	if (minus)
329	return -result;
330	else
331	return result;
332	}
333
41548caa	334	/* See documentation in common-utils.h. */
03aef70f JK	335
	336	char *
	337	skip_spaces (char *chp)
	338	{
	339	if (chp == NULL)
	340	return NULL;
	341	while (chp && isspace (chp))
	342	chp++;
	343	return chp;
	344	}
	345
	346	/* A const-correct version of the above. */
	347
	348	const char *
f1735a53	349	skip_spaces (const char *chp)
03aef70f JK	350	{
	351	if (chp == NULL)
	352	return NULL;
	353	while (chp && isspace (chp))
	354	chp++;
	355	return chp;
	356	}
	357
41548caa	358	/* See documentation in common-utils.h. */
03aef70f JK	359
03aef70f JK	360	const char *
f1735a53	361	skip_to_space (const char *chp)
03aef70f JK	362	{
	363	if (chp == NULL)
	364	return NULL;
	365	while (chp && !isspace (chp))
	366	chp++;
	367	return chp;
	368	}
7c5ded6a	369
f1735a53 TT	370	/* See documentation in common-utils.h. */
	371
	372	char *
	373	skip_to_space (char *chp)
	374	{
	375	return (char ) skip_to_space ((const char ) chp);
	376	}
	377
7c5ded6a SDJ	378	/* See common/common-utils.h. */
	379
	380	void
	381	free_vector_argv (std::vector<char *> &v)
	382	{
	383	for (char *el : v)
	384	xfree (el);
	385
	386	v.clear ();
	387	}
2090129c SDJ	388
	389	/* See common/common-utils.h. */
	390
	391	std::string
	392	stringify_argv (const std::vector<char *> &args)
	393	{
	394	std::string ret;
	395
2f91880f	396	if (!args.empty () && args[0] != NULL)
2090129c SDJ	397	{
	398	for (auto s : args)
	399	if (s != NULL)
	400	{
	401	ret += s;
	402	ret += ' ';
	403	}
	404
	405	/* Erase the last whitespace. */
	406	ret.erase (ret.end () - 1);
	407	}
	408
	409	return ret;
	410	}
25e3c82c SDJ	411
	412	/* See common/common-utils.h. */
	413
a3b60e45 JK	414	ULONGEST
	415	align_up (ULONGEST v, int n)
	416	{
	417	/* Check that N is really a power of two. */
	418	gdb_assert (n && (n & (n-1)) == 0);
	419	return (v + n - 1) & -n;
	420	}
	421
	422	/* See common/common-utils.h. */
	423
	424	ULONGEST
	425	align_down (ULONGEST v, int n)
	426	{
	427	/* Check that N is really a power of two. */
	428	gdb_assert (n && (n & (n-1)) == 0);
	429	return (v & -n);
	430	}