[thirdparty/binutils-gdb.git] / opcodes / loongarch-coder.c

/* LoongArch opcode support.
   Copyright (C) 2021-2023 Free Software Foundation, Inc.
   Contributed by Loongson Ltd.

   This file is part of the GNU opcodes library.

   This library 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, or (at your option)
   any later version.

   It 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; see the file COPYING3.  If not,
   see <http://www.gnu.org/licenses/>.  */
#include "sysdep.h"
#include "opcode/loongarch.h"

int
is_unsigned (const char *c_str)
{
  if (c_str[0] == '0' && (c_str[1] == 'x' || c_str[1] == 'X'))
    {
      c_str += 2;
      while (('a' <= *c_str && *c_str <= 'f')
	     || ('A' <= *c_str && *c_str <= 'F')
	     || ('0' <= *c_str && *c_str <= '9'))
	c_str++;
    }
  else if (*c_str == '\0')
    return 0;
  else
    while ('0' <= *c_str && *c_str <= '9')
      c_str++;
  return *c_str == '\0';
}

int
is_signed (const char *c_str)
{
  return *c_str == '-' ? is_unsigned (c_str + 1) : is_unsigned (c_str);
}

int
loongarch_get_bit_field_width (const char *bit_field, char **end)
{
  int width = 0;
  char has_specify = 0, *bit_field_1 = (char *) bit_field;
  if (bit_field_1 && *bit_field_1 != '\0')
    while (1)
      {
	strtol (bit_field_1, &bit_field_1, 10);

	if (*bit_field_1 != ':')
	  break;
	bit_field_1++;

	width += strtol (bit_field_1, &bit_field_1, 10);
	has_specify = 1;

	if (*bit_field_1 != '|')
	  break;
	bit_field_1++;
      }
  if (end)
    *end = bit_field_1;
  return has_specify ? width : -1;
}

int32_t
loongarch_decode_imm (const char *bit_field, insn_t insn, int si)
{
  int32_t ret = 0;
  uint32_t t;
  int len = 0, width, b_start;
  char *bit_field_1 = (char *) bit_field;
  while (1)
    {
      b_start = strtol (bit_field_1, &bit_field_1, 10);
      if (*bit_field_1 != ':')
	break;
      width = strtol (bit_field_1 + 1, &bit_field_1, 10);
      len += width;

      t = insn;
      t <<= sizeof (t) * 8 - width - b_start;
      t >>= sizeof (t) * 8 - width;
      ret <<= width;
      ret |= t;

      if (*bit_field_1 != '|')
	break;
      bit_field_1++;
    }

  if (*bit_field_1 == '<' && *(++bit_field_1) == '<')
    {
      width = atoi (bit_field_1 + 1);
      ret <<= width;
      len += width;
    }
  else if (*bit_field_1 == '+')
    ret += atoi (bit_field_1 + 1);

  /* Extend signed bit.  */
  if (si)
    {
      uint32_t sign = 1u << (len - 1);
      ret = (ret ^ sign) - sign;
    }

  return ret;
}

static insn_t
loongarch_encode_imm (const char *bit_field, int32_t imm)
{
  char *bit_field_1 = (char *) bit_field;
  char *t = bit_field_1;
  int width, b_start;
  insn_t ret = 0;
  uint32_t i;
  uint32_t uimm = (uint32_t)imm;

  width = loongarch_get_bit_field_width (t, &t);
  if (width == -1)
    return ret;

  if (*t == '<' && *(++t) == '<')
    width += atoi (t + 1);
  else if (*t == '+')
    uimm -= atoi (t + 1);

  uimm = width ? (uimm << (sizeof (uimm) * 8 - width)) : 0;

  while (1)
    {
      b_start = strtol (bit_field_1, &bit_field_1, 10);
      if (*bit_field_1 != ':')
	break;
      width = strtol (bit_field_1 + 1, &bit_field_1, 10);
      i = uimm;
      i = width ? (i >> (sizeof (i) * 8 - width)) : 0;
      i = (b_start == 32) ? 0 : (i << b_start);
      ret |= i;
      uimm = (width == 32) ? 0 : (uimm << width);

      if (*bit_field_1 != '|')
	break;
      bit_field_1++;
    }
  return ret;
}

/* Parse such FORMAT
   ""
   "u"
   "v0:5,r5:5,s10:10<<2"
   "r0:5,r5:5,r10:5,u15:2+1"
   "r,r,u0:5+32,u0:5+1"
*/
static int
loongarch_parse_format (const char *format, char *esc1s, char *esc2s,
			const char **bit_fields)
{
  size_t arg_num = 0;

  if (*format == '\0')
    goto end;

  while (1)
    {
      /* esc1    esc2
	 for "[a-zA-Z][a-zA-Z]?"  */
      if (('a' <= *format && *format <= 'z')
	  || ('A' <= *format && *format <= 'Z'))
	{
	  *esc1s++ = *format++;
	  if (('a' <= *format && *format <= 'z')
	      || ('A' <= *format && *format <= 'Z'))
	    *esc2s++ = *format++;
	  else
	    *esc2s++ = '\0';
	}
      else
	return -1;

      arg_num++;
      if (MAX_ARG_NUM_PLUS_2 - 2 < arg_num)
	/* Need larger MAX_ARG_NUM_PLUS_2.  */
	return -1;

      *bit_fields++ = format;

      if ('0' <= *format && *format <= '9')
	{
	  /* For "[0-9]+:[0-9]+(\|[0-9]+:[0-9]+)*".  */
	  while (1)
	    {
	      while ('0' <= *format && *format <= '9')
		format++;

	      if (*format != ':')
		return -1;
	      format++;

	      if (!('0' <= *format && *format <= '9'))
		return -1;
	      while ('0' <= *format && *format <= '9')
		format++;

	      if (*format != '|')
		break;
	      format++;
	    }

	  /* For "((\+|<<)[1-9][0-9]*)?".  */
	  do
	    {
	      if (*format == '+')
		format++;
	      else if (format[0] == '<' && format[1] == '<')
		format += 2;
	      else
		break;

	      if (!('1' <= *format && *format <= '9'))
		return -1;
	      while ('0' <= *format && *format <= '9')
		format++;
	    }
	  while (0);
	}

      if (*format == ',')
	format++;
      else if (*format == '\0')
	break;
      else
	return -1;
    }

 end:
  *esc1s = '\0';
  return 0;
}

size_t
loongarch_split_args_by_comma (char *args, const char *arg_strs[])
{
  size_t num = 0;

  if (*args)
    arg_strs[num++] = args;
  for (; *args; args++)
    if (*args == ',')
      {
	if (MAX_ARG_NUM_PLUS_2 - 1 == num)
	  break;
	else
	  *args = '\0', arg_strs[num++] = args + 1;
      }
  arg_strs[num] = NULL;
  return num;
}

char *
loongarch_cat_splited_strs (const char *arg_strs[])
{
  char *ret;
  size_t n, l;

  for (l = 0, n = 0; arg_strs[n]; n++)
    l += strlen (arg_strs[n]);
  ret = malloc (l + n + 1);
  if (!ret)
    return ret;

  ret[0] = '\0';
  if (0 < n)
    strcat (ret, arg_strs[0]);
  for (l = 1; l < n; l++)
    strcat (ret, ","), strcat (ret, arg_strs[l]);
  return ret;
}

insn_t
loongarch_foreach_args (const char *format, const char *arg_strs[],
			int32_t (*helper) (char esc1, char esc2,
					   const char *bit_field,
					   const char *arg, void *context),
			void *context)
{
  char esc1s[MAX_ARG_NUM_PLUS_2 - 1], esc2s[MAX_ARG_NUM_PLUS_2 - 1];
  const char *bit_fields[MAX_ARG_NUM_PLUS_2 - 1];
  size_t i;
  insn_t ret = 0;
  int ok;

  ok = loongarch_parse_format (format, esc1s, esc2s, bit_fields) == 0;

  /* Make sure the num of actual args is equal to the num of escape.  */
  for (i = 0; esc1s[i] && arg_strs[i]; i++)
    ;
  ok = ok && !esc1s[i] && !arg_strs[i];

  if (ok && helper)
    {
      for (i = 0; arg_strs[i]; i++)
	ret |= loongarch_encode_imm (bit_fields[i],
				     helper (esc1s[i], esc2s[i],
					     bit_fields[i], arg_strs[i],
					     context));
      ret |= helper ('\0', '\0', NULL, NULL, context);
    }

  return ret;
}

int
loongarch_check_format (const char *format)
{
  char esc1s[MAX_ARG_NUM_PLUS_2 - 1], esc2s[MAX_ARG_NUM_PLUS_2 - 1];
  const char *bit_fields[MAX_ARG_NUM_PLUS_2 - 1];

  if (!format)
    return -1;

  return loongarch_parse_format (format, esc1s, esc2s, bit_fields);
}

int
loongarch_check_macro (const char *format, const char *macro)
{
  int num_of_args;
  char esc1s[MAX_ARG_NUM_PLUS_2 - 1], esc2s[MAX_ARG_NUM_PLUS_2 - 1];
  const char *bit_fields[MAX_ARG_NUM_PLUS_2 - 1];

  if (!format || !macro
      || loongarch_parse_format (format, esc1s, esc2s, bit_fields) != 0)
    return -1;

  for (num_of_args = 0; esc1s[num_of_args]; num_of_args++)
    ;

  for (; macro[0]; macro++)
    if (macro[0] == '%')
      {
	macro++;
	if ('1' <= macro[0] && macro[0] <= '9')
	  {
	    if (num_of_args < macro[0] - '0')
	      /* Out of args num.  */
	      return -1;
	  }
	else if (macro[0] == 'f')
	  ;
	else if (macro[0] == '%')
	  ;
	else
	  return -1;
      }
  return 0;
}

static const char *
I (char esc_ch1 ATTRIBUTE_UNUSED, char esc_ch2 ATTRIBUTE_UNUSED,
   const char *c_str)
{
  return c_str;
}

char *
loongarch_expand_macro_with_format_map (
  const char *format, const char *macro, const char *const arg_strs[],
  const char *(*map) (char esc1, char esc2, const char *arg),
  char *(*helper) (const char *const arg_strs[], void *context), void *context,
  size_t len_str)
{
  char esc1s[MAX_ARG_NUM_PLUS_2 - 1], esc2s[MAX_ARG_NUM_PLUS_2 - 1];
  const char *bit_fields[MAX_ARG_NUM_PLUS_2 - 1];
  const char *src;
  char *dest;

  /* The expanded macro character length does not exceed 1000, and number of
     label is 6 at most in the expanded macro. The len_str is the length of
     str.  */
  char *buffer =(char *) malloc(1024 +  6 * len_str);

  if (format)
    loongarch_parse_format (format, esc1s, esc2s, bit_fields);

  src = macro;
  dest = buffer;

  while (*src)
    if (*src == '%')
      {
	src++;
	if ('1' <= *src && *src <= '9')
	  {
	    size_t i = *src - '1';
	    const char *t = map (esc1s[i], esc2s[i], arg_strs[i]);
	    while (*t)
	      *dest++ = *t++;
	  }
	else if (*src == '%')
	  *dest++ = '%';
	else if (*src == 'f' && helper)
	  {
	    char *b, *t;
	    t = b = (*helper) (arg_strs, context);
	    if (b)
	      {
		while (*t)
		  *dest++ = *t++;
		free (b);
	      }
	  }
	src++;
      }
    else
      *dest++ = *src++;

  *dest = '\0';
  return buffer;
}

char *
loongarch_expand_macro (const char *macro, const char *const arg_strs[],
			char *(*helper) (const char *const arg_strs[],
					 void *context),
			void *context, size_t len_str)
{
  return loongarch_expand_macro_with_format_map (NULL, macro, arg_strs, I,
						 helper, context, len_str);
}

size_t
loongarch_bits_imm_needed (int64_t imm, int si)
{
  size_t ret;
  if (si)
    {
      if (imm < 0)
	{
	  uint64_t uimm = (uint64_t) imm;
	  uint64_t uimax = UINT64_C (1) << 63;
	  for (ret = 0; (uimm & uimax) != 0; uimm <<= 1, ret++)
	    ;
	  ret = 64 - ret + 1;
	}
      else
	ret = loongarch_bits_imm_needed (imm, 0) + 1;
    }
  else
    {
      uint64_t t = imm;
      for (ret = 0; t; t >>= 1, ret++)
	;
    }
  return ret;
}

void
loongarch_eliminate_adjacent_repeat_char (char *dest, char c)
{
  if (c == '\0')
    return;
  char *src = dest;
  while (*dest)
    {
      while (src[0] == c && src[0] == src[1])
	src++;
      *dest++ = *src++;
    }
}
Commit	Line	Data
6cc76c40	1	/* LoongArch opcode support.
d87bef3a	2	Copyright (C) 2021-2023 Free Software Foundation, Inc.
6cc76c40	3	Contributed by Loongson Ltd.
	4
	5	This file is part of the GNU opcodes library.
	6
	7	This library 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, or (at your option)
	10	any later version.
	11
	12	It is distributed in the hope that it will be useful, but WITHOUT
	13	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
	14	or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
	15	License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; see the file COPYING3. If not,
	19	see <http://www.gnu.org/licenses/>. */
	20	#include "sysdep.h"
	21	#include "opcode/loongarch.h"
	22
	23	int
	24	is_unsigned (const char *c_str)
	25	{
	26	if (c_str[0] == '0' && (c_str[1] == 'x' \|\| c_str[1] == 'X'))
	27	{
	28	c_str += 2;
	29	while (('a' <= c_str && c_str <= 'f')
	30	\|\| ('A' <= c_str && c_str <= 'F')
	31	\|\| ('0' <= c_str && c_str <= '9'))
	32	c_str++;
	33	}
	34	else if (*c_str == '\0')
	35	return 0;
	36	else
	37	while ('0' <= c_str && c_str <= '9')
	38	c_str++;
	39	return *c_str == '\0';
	40	}
	41
	42	int
	43	is_signed (const char *c_str)
	44	{
	45	return *c_str == '-' ? is_unsigned (c_str + 1) : is_unsigned (c_str);
	46	}
	47
	48	int
	49	loongarch_get_bit_field_width (const char bit_field, char *end)
	50	{
	51	int width = 0;
	52	char has_specify = 0, bit_field_1 = (char ) bit_field;
	53	if (bit_field_1 && *bit_field_1 != '\0')
	54	while (1)
	55	{
	56	strtol (bit_field_1, &bit_field_1, 10);
	57
	58	if (*bit_field_1 != ':')
	59	break;
	60	bit_field_1++;
	61
	62	width += strtol (bit_field_1, &bit_field_1, 10);
	63	has_specify = 1;
	64
	65	if (*bit_field_1 != '\|')
	66	break;
67	bit_field_1++;
68	}
69	if (end)
70	*end = bit_field_1;
71	return has_specify ? width : -1;
72	}
73
74	int32_t
75	loongarch_decode_imm (const char *bit_field, insn_t insn, int si)
76	{
77	int32_t ret = 0;
78	uint32_t t;
79	int len = 0, width, b_start;
80	char bit_field_1 = (char ) bit_field;
81	while (1)
82	{
83	b_start = strtol (bit_field_1, &bit_field_1, 10);
84	if (*bit_field_1 != ':')
85	break;
86	width = strtol (bit_field_1 + 1, &bit_field_1, 10);
87	len += width;
88
89	t = insn;
90	t <<= sizeof (t) * 8 - width - b_start;
91	t >>= sizeof (t) * 8 - width;
92	ret <<= width;
93	ret \|= t;
94
95	if (*bit_field_1 != '\|')
96	break;
97	bit_field_1++;
98	}
99
100	if (bit_field_1 == '<' && (++bit_field_1) == '<')
101	{
102	width = atoi (bit_field_1 + 1);
103	ret <<= width;
104	len += width;
105	}
106	else if (*bit_field_1 == '+')
107	ret += atoi (bit_field_1 + 1);
108
e36144c9	109	/* Extend signed bit. */
6cc76c40	110	if (si)
6cc76c40	111	{
e36144c9	112	uint32_t sign = 1u << (len - 1);
e36144c9	113	ret = (ret ^ sign) - sign;
6cc76c40	114	}
e36144c9	115
6cc76c40	116	return ret;
	117	}
	118
	119	static insn_t
	120	loongarch_encode_imm (const char *bit_field, int32_t imm)
	121	{
	122	char bit_field_1 = (char ) bit_field;
	123	char *t = bit_field_1;
	124	int width, b_start;
	125	insn_t ret = 0;
	126	uint32_t i;
	127	uint32_t uimm = (uint32_t)imm;
	128
	129	width = loongarch_get_bit_field_width (t, &t);
	130	if (width == -1)
	131	return ret;
	132
	133	if (t == '<' && (++t) == '<')
	134	width += atoi (t + 1);
	135	else if (*t == '+')
	136	uimm -= atoi (t + 1);
	137
e36144c9	138	uimm = width ? (uimm << (sizeof (uimm) * 8 - width)) : 0;
e36144c9	139
6cc76c40	140	while (1)
	141	{
	142	b_start = strtol (bit_field_1, &bit_field_1, 10);
	143	if (*bit_field_1 != ':')
	144	break;
	145	width = strtol (bit_field_1 + 1, &bit_field_1, 10);
	146	i = uimm;
e36144c9	147	i = width ? (i >> (sizeof (i) * 8 - width)) : 0;
e36144c9	148	i = (b_start == 32) ? 0 : (i << b_start);
6cc76c40	149	ret \|= i;
e36144c9	150	uimm = (width == 32) ? 0 : (uimm << width);
6cc76c40	151
	152	if (*bit_field_1 != '\|')
	153	break;
	154	bit_field_1++;
	155	}
	156	return ret;
	157	}
	158
	159	/* Parse such FORMAT
	160	""
	161	"u"
	162	"v0:5,r5:5,s10:10<<2"
	163	"r0:5,r5:5,r10:5,u15:2+1"
	164	"r,r,u0:5+32,u0:5+1"
	165	*/
	166	static int
	167	loongarch_parse_format (const char format, char esc1s, char *esc2s,
	168	const char **bit_fields)
	169	{
	170	size_t arg_num = 0;
	171
	172	if (*format == '\0')
	173	goto end;
	174
	175	while (1)
	176	{
	177	/* esc1 esc2
	178	for "[a-zA-Z][a-zA-Z]?" */
	179	if (('a' <= format && format <= 'z')
	180	\|\| ('A' <= format && format <= 'Z'))
	181	{
	182	esc1s++ = format++;
	183	if (('a' <= format && format <= 'z')
	184	\|\| ('A' <= format && format <= 'Z'))
	185	esc2s++ = format++;
	186	else
	187	*esc2s++ = '\0';
	188	}
	189	else
	190	return -1;
	191
	192	arg_num++;
	193	if (MAX_ARG_NUM_PLUS_2 - 2 < arg_num)
	194	/* Need larger MAX_ARG_NUM_PLUS_2. */
	195	return -1;
	196
	197	*bit_fields++ = format;
	198
	199	if ('0' <= format && format <= '9')
	200	{
	201	/* For "[0-9]+:[0-9]+(\\|[0-9]+:[0-9]+)". /
	202	while (1)
	203	{
	204	while ('0' <= format && format <= '9')
	205	format++;
	206
	207	if (*format != ':')
	208	return -1;
	209	format++;
	210
	211	if (!('0' <= format && format <= '9'))
	212	return -1;
	213	while ('0' <= format && format <= '9')
	214	format++;
215
216	if (*format != '\|')
217	break;
218	format++;
219	}
220
221	/* For "((\+\|<<)[1-9][0-9])?". /
222	do
223	{
224	if (*format == '+')
225	format++;
226	else if (format[0] == '<' && format[1] == '<')
227	format += 2;
228	else
229	break;
230
231	if (!('1' <= format && format <= '9'))
232	return -1;
233	while ('0' <= format && format <= '9')
234	format++;
235	}
236	while (0);
237	}
238
239	if (*format == ',')
240	format++;
241	else if (*format == '\0')
242	break;
243	else
244	return -1;
245	}
246
247	end:
248	*esc1s = '\0';
249	return 0;
250	}
251
252	size_t
253	loongarch_split_args_by_comma (char args, const char arg_strs[])
254	{
255	size_t num = 0;
256
257	if (*args)
258	arg_strs[num++] = args;
259	for (; *args; args++)
260	if (*args == ',')
261	{
262	if (MAX_ARG_NUM_PLUS_2 - 1 == num)
263	break;
264	else
265	*args = '\0', arg_strs[num++] = args + 1;
266	}
267	arg_strs[num] = NULL;
268	return num;
269	}
270
271	char *
272	loongarch_cat_splited_strs (const char *arg_strs[])
273	{
274	char *ret;
275	size_t n, l;
276
277	for (l = 0, n = 0; arg_strs[n]; n++)
278	l += strlen (arg_strs[n]);
279	ret = malloc (l + n + 1);
280	if (!ret)
281	return ret;
282
283	ret[0] = '\0';
284	if (0 < n)
285	strcat (ret, arg_strs[0]);
286	for (l = 1; l < n; l++)
287	strcat (ret, ","), strcat (ret, arg_strs[l]);
288	return ret;
289	}
290
291	insn_t
292	loongarch_foreach_args (const char format, const char arg_strs[],
293	int32_t (*helper) (char esc1, char esc2,
294	const char *bit_field,
295	const char arg, void context),
296	void *context)
297	{
298	char esc1s[MAX_ARG_NUM_PLUS_2 - 1], esc2s[MAX_ARG_NUM_PLUS_2 - 1];
299	const char *bit_fields[MAX_ARG_NUM_PLUS_2 - 1];
300	size_t i;
301	insn_t ret = 0;
302	int ok;
303
304	ok = loongarch_parse_format (format, esc1s, esc2s, bit_fields) == 0;
305
306	/* Make sure the num of actual args is equal to the num of escape. */
307	for (i = 0; esc1s[i] && arg_strs[i]; i++)
308	;
309	ok = ok && !esc1s[i] && !arg_strs[i];
310
311	if (ok && helper)
312	{
313	for (i = 0; arg_strs[i]; i++)
314	ret \|= loongarch_encode_imm (bit_fields[i],
315	helper (esc1s[i], esc2s[i],
316	bit_fields[i], arg_strs[i],
317	context));
318	ret \|= helper ('\0', '\0', NULL, NULL, context);
319	}
320
321	return ret;
322	}
323
324	int
325	loongarch_check_format (const char *format)
326	{
327	char esc1s[MAX_ARG_NUM_PLUS_2 - 1], esc2s[MAX_ARG_NUM_PLUS_2 - 1];
328	const char *bit_fields[MAX_ARG_NUM_PLUS_2 - 1];
329
330	if (!format)
331	return -1;
332
333	return loongarch_parse_format (format, esc1s, esc2s, bit_fields);
334	}
335
336	int
337	loongarch_check_macro (const char format, const char macro)
338	{
339	int num_of_args;
340	char esc1s[MAX_ARG_NUM_PLUS_2 - 1], esc2s[MAX_ARG_NUM_PLUS_2 - 1];
341	const char *bit_fields[MAX_ARG_NUM_PLUS_2 - 1];
342
343	if (!format \|\| !macro
344	\|\| loongarch_parse_format (format, esc1s, esc2s, bit_fields) != 0)
345	return -1;
346
347	for (num_of_args = 0; esc1s[num_of_args]; num_of_args++)
348	;
349
350	for (; macro[0]; macro++)
351	if (macro[0] == '%')
352	{
353	macro++;
354	if ('1' <= macro[0] && macro[0] <= '9')
355	{
356	if (num_of_args < macro[0] - '0')
357	/* Out of args num. */
358	return -1;
359	}
360	else if (macro[0] == 'f')
361	;
362	else if (macro[0] == '%')
363	;
364	else
365	return -1;
366	}
367	return 0;
368	}
369
370	static const char *
371	I (char esc_ch1 ATTRIBUTE_UNUSED, char esc_ch2 ATTRIBUTE_UNUSED,
372	const char *c_str)
373	{
374	return c_str;
375	}
376
377	char *
378	loongarch_expand_macro_with_format_map (
379	const char format, const char macro, const char *const arg_strs[],
380	const char (map) (char esc1, char esc2, const char *arg),
5fb13d7e	381	char (helper) (const char const arg_strs[], void context), void *context,
5fb13d7e	382	size_t len_str)
6cc76c40	383	{
	384	char esc1s[MAX_ARG_NUM_PLUS_2 - 1], esc2s[MAX_ARG_NUM_PLUS_2 - 1];
	385	const char *bit_fields[MAX_ARG_NUM_PLUS_2 - 1];
	386	const char *src;
	387	char *dest;
5fb13d7e	388
	389	/* The expanded macro character length does not exceed 1000, and number of
	390	label is 6 at most in the expanded macro. The len_str is the length of
	391	str. */
	392	char buffer =(char ) malloc(1024 + 6 * len_str);
6cc76c40	393
	394	if (format)
	395	loongarch_parse_format (format, esc1s, esc2s, bit_fields);
	396
	397	src = macro;
	398	dest = buffer;
	399
	400	while (*src)
	401	if (*src == '%')
	402	{
	403	src++;
	404	if ('1' <= src && src <= '9')
	405	{
	406	size_t i = *src - '1';
	407	const char *t = map (esc1s[i], esc2s[i], arg_strs[i]);
	408	while (*t)
	409	dest++ = t++;
	410	}
	411	else if (*src == '%')
	412	*dest++ = '%';
	413	else if (*src == 'f' && helper)
	414	{
	415	char b, t;
	416	t = b = (*helper) (arg_strs, context);
	417	if (b)
	418	{
	419	while (*t)
	420	dest++ = t++;
	421	free (b);
	422	}
	423	}
	424	src++;
	425	}
	426	else
	427	dest++ = src++;
	428
	429	*dest = '\0';
5fb13d7e	430	return buffer;
6cc76c40	431	}
	432
	433	char *
	434	loongarch_expand_macro (const char macro, const char const arg_strs[],
	435	char (helper) (const char *const arg_strs[],
	436	void *context),
5fb13d7e	437	void *context, size_t len_str)
6cc76c40	438	{
6cc76c40	439	return loongarch_expand_macro_with_format_map (NULL, macro, arg_strs, I,
5fb13d7e	440	helper, context, len_str);
6cc76c40	441	}
	442
	443	size_t
	444	loongarch_bits_imm_needed (int64_t imm, int si)
	445	{
	446	size_t ret;
	447	if (si)
	448	{
	449	if (imm < 0)
	450	{
	451	uint64_t uimm = (uint64_t) imm;
	452	uint64_t uimax = UINT64_C (1) << 63;
	453	for (ret = 0; (uimm & uimax) != 0; uimm <<= 1, ret++)
	454	;
	455	ret = 64 - ret + 1;
	456	}
	457	else
	458	ret = loongarch_bits_imm_needed (imm, 0) + 1;
	459	}
	460	else
	461	{
	462	uint64_t t = imm;
	463	for (ret = 0; t; t >>= 1, ret++)
	464	;
	465	}
	466	return ret;
	467	}
	468
	469	void
	470	loongarch_eliminate_adjacent_repeat_char (char *dest, char c)
	471	{
	472	if (c == '\0')
	473	return;
	474	char *src = dest;
	475	while (*dest)
	476	{
	477	while (src[0] == c && src[0] == src[1])
	478	src++;
	479	dest++ = src++;
	480	}
	481	}