[deliverable/binutils-gdb.git] / gdb / ax-general.c

/* Functions for manipulating expressions designed to be executed on the agent
   Copyright (C) 1998, 1999, 2000, 2007, 2008, 2009, 2010
   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/>.  */

/* Despite what the above comment says about this file being part of
   GDB, we would like to keep these functions free of GDB
   dependencies, since we want to be able to use them in contexts
   outside of GDB (test suites, the stub, etc.)  */

#include "defs.h"
#include "ax.h"

#include "value.h"
#include "gdb_string.h"

static void grow_expr (struct agent_expr *x, int n);

static void append_const (struct agent_expr *x, LONGEST val, int n);

static LONGEST read_const (struct agent_expr *x, int o, int n);

static void generic_ext (struct agent_expr *x, enum agent_op op, int n);
\f
/* Functions for building expressions.  */

/* Allocate a new, empty agent expression.  */
struct agent_expr *
new_agent_expr (struct gdbarch *gdbarch, CORE_ADDR scope)
{
  struct agent_expr *x = xmalloc (sizeof (*x));

  x->len = 0;
  x->size = 1;			/* Change this to a larger value once
				   reallocation code is tested.  */
  x->buf = xmalloc (x->size);

  x->gdbarch = gdbarch;
  x->scope = scope;

  /* Bit vector for registers used.  */
  x->reg_mask_len = 1;
  x->reg_mask = xmalloc (x->reg_mask_len * sizeof (x->reg_mask[0]));
  memset (x->reg_mask, 0, x->reg_mask_len * sizeof (x->reg_mask[0]));

  return x;
}

/* Free a agent expression.  */
void
free_agent_expr (struct agent_expr *x)
{
  xfree (x->buf);
  xfree (x->reg_mask);
  xfree (x);
}

static void
do_free_agent_expr_cleanup (void *x)
{
  free_agent_expr (x);
}

struct cleanup *
make_cleanup_free_agent_expr (struct agent_expr *x)
{
  return make_cleanup (do_free_agent_expr_cleanup, x);
}


/* Make sure that X has room for at least N more bytes.  This doesn't
   affect the length, just the allocated size.  */
static void
grow_expr (struct agent_expr *x, int n)
{
  if (x->len + n > x->size)
    {
      x->size *= 2;
      if (x->size < x->len + n)
	x->size = x->len + n + 10;
      x->buf = xrealloc (x->buf, x->size);
    }
}


/* Append the low N bytes of VAL as an N-byte integer to the
   expression X, in big-endian order.  */
static void
append_const (struct agent_expr *x, LONGEST val, int n)
{
  int i;

  grow_expr (x, n);
  for (i = n - 1; i >= 0; i--)
    {
      x->buf[x->len + i] = val & 0xff;
      val >>= 8;
    }
  x->len += n;
}


/* Extract an N-byte big-endian unsigned integer from expression X at
   offset O.  */
static LONGEST
read_const (struct agent_expr *x, int o, int n)
{
  int i;
  LONGEST accum = 0;

  /* Make sure we're not reading off the end of the expression.  */
  if (o + n > x->len)
    error (_("GDB bug: ax-general.c (read_const): incomplete constant"));

  for (i = 0; i < n; i++)
    accum = (accum << 8) | x->buf[o + i];

  return accum;
}


/* Append a simple operator OP to EXPR.  */
void
ax_simple (struct agent_expr *x, enum agent_op op)
{
  grow_expr (x, 1);
  x->buf[x->len++] = op;
}


/* Append a sign-extension or zero-extension instruction to EXPR, to
   extend an N-bit value.  */
static void
generic_ext (struct agent_expr *x, enum agent_op op, int n)
{
  /* N must fit in a byte.  */
  if (n < 0 || n > 255)
    error (_("GDB bug: ax-general.c (generic_ext): bit count out of range"));
  /* That had better be enough range.  */
  if (sizeof (LONGEST) * 8 > 255)
    error (_("GDB bug: ax-general.c (generic_ext): opcode has inadequate range"));

  grow_expr (x, 2);
  x->buf[x->len++] = op;
  x->buf[x->len++] = n;
}


/* Append a sign-extension instruction to EXPR, to extend an N-bit value.  */
void
ax_ext (struct agent_expr *x, int n)
{
  generic_ext (x, aop_ext, n);
}


/* Append a zero-extension instruction to EXPR, to extend an N-bit value.  */
void
ax_zero_ext (struct agent_expr *x, int n)
{
  generic_ext (x, aop_zero_ext, n);
}


/* Append a trace_quick instruction to EXPR, to record N bytes.  */
void
ax_trace_quick (struct agent_expr *x, int n)
{
  /* N must fit in a byte.  */
  if (n < 0 || n > 255)
    error (_("GDB bug: ax-general.c (ax_trace_quick): size out of range for trace_quick"));

  grow_expr (x, 2);
  x->buf[x->len++] = aop_trace_quick;
  x->buf[x->len++] = n;
}


/* Append a goto op to EXPR.  OP is the actual op (must be aop_goto or
   aop_if_goto).  We assume we don't know the target offset yet,
   because it's probably a forward branch, so we leave space in EXPR
   for the target, and return the offset in EXPR of that space, so we
   can backpatch it once we do know the target offset.  Use ax_label
   to do the backpatching.  */
int
ax_goto (struct agent_expr *x, enum agent_op op)
{
  grow_expr (x, 3);
  x->buf[x->len + 0] = op;
  x->buf[x->len + 1] = 0xff;
  x->buf[x->len + 2] = 0xff;
  x->len += 3;
  return x->len - 2;
}

/* Suppose a given call to ax_goto returns some value PATCH.  When you
   know the offset TARGET that goto should jump to, call
   ax_label (EXPR, PATCH, TARGET)
   to patch TARGET into the ax_goto instruction.  */
void
ax_label (struct agent_expr *x, int patch, int target)
{
  /* Make sure the value is in range.  Don't accept 0xffff as an
     offset; that's our magic sentinel value for unpatched branches.  */
  if (target < 0 || target >= 0xffff)
    error (_("GDB bug: ax-general.c (ax_label): label target out of range"));

  x->buf[patch] = (target >> 8) & 0xff;
  x->buf[patch + 1] = target & 0xff;
}


/* Assemble code to push a constant on the stack.  */
void
ax_const_l (struct agent_expr *x, LONGEST l)
{
  static enum agent_op ops[]
  =
  {aop_const8, aop_const16, aop_const32, aop_const64};
  int size;
  int op;

  /* How big is the number?  'op' keeps track of which opcode to use.
     Notice that we don't really care whether the original number was
     signed or unsigned; we always reproduce the value exactly, and
     use the shortest representation.  */
  for (op = 0, size = 8; size < 64; size *= 2, op++)
    {
      LONGEST lim = ((LONGEST) 1) << (size - 1);

      if (-lim <= l && l <= lim - 1)
        break;
    }

  /* Emit the right opcode... */
  ax_simple (x, ops[op]);

  /* Emit the low SIZE bytes as an unsigned number.  We know that
     sign-extending this will yield l.  */
  append_const (x, l, size / 8);

  /* Now, if it was negative, and not full-sized, sign-extend it.  */
  if (l < 0 && size < 64)
    ax_ext (x, size);
}


void
ax_const_d (struct agent_expr *x, LONGEST d)
{
  /* FIXME: floating-point support not present yet.  */
  error (_("GDB bug: ax-general.c (ax_const_d): floating point not supported yet"));
}


/* Assemble code to push the value of register number REG on the
   stack.  */
void
ax_reg (struct agent_expr *x, int reg)
{
  /* Make sure the register number is in range.  */
  if (reg < 0 || reg > 0xffff)
    error (_("GDB bug: ax-general.c (ax_reg): register number out of range"));
  grow_expr (x, 3);
  x->buf[x->len] = aop_reg;
  x->buf[x->len + 1] = (reg >> 8) & 0xff;
  x->buf[x->len + 2] = (reg) & 0xff;
  x->len += 3;
}

/* Assemble code to operate on a trace state variable.  */

void
ax_tsv (struct agent_expr *x, enum agent_op op, int num)
{
  /* Make sure the tsv number is in range.  */
  if (num < 0 || num > 0xffff)
    internal_error (__FILE__, __LINE__, _("ax-general.c (ax_tsv): variable number is %d, out of range"), num);

  grow_expr (x, 3);
  x->buf[x->len] = op;
  x->buf[x->len + 1] = (num >> 8) & 0xff;
  x->buf[x->len + 2] = (num) & 0xff;
  x->len += 3;
}
\f


/* Functions for disassembling agent expressions, and otherwise
   debugging the expression compiler.  */

struct aop_map aop_map[] =
{
  {0, 0, 0, 0, 0},
  {"float", 0, 0, 0, 0},	/* 0x01 */
  {"add", 0, 0, 2, 1},		/* 0x02 */
  {"sub", 0, 0, 2, 1},		/* 0x03 */
  {"mul", 0, 0, 2, 1},		/* 0x04 */
  {"div_signed", 0, 0, 2, 1},	/* 0x05 */
  {"div_unsigned", 0, 0, 2, 1},	/* 0x06 */
  {"rem_signed", 0, 0, 2, 1},	/* 0x07 */
  {"rem_unsigned", 0, 0, 2, 1},	/* 0x08 */
  {"lsh", 0, 0, 2, 1},		/* 0x09 */
  {"rsh_signed", 0, 0, 2, 1},	/* 0x0a */
  {"rsh_unsigned", 0, 0, 2, 1},	/* 0x0b */
  {"trace", 0, 0, 2, 0},	/* 0x0c */
  {"trace_quick", 1, 0, 1, 1},	/* 0x0d */
  {"log_not", 0, 0, 1, 1},	/* 0x0e */
  {"bit_and", 0, 0, 2, 1},	/* 0x0f */
  {"bit_or", 0, 0, 2, 1},	/* 0x10 */
  {"bit_xor", 0, 0, 2, 1},	/* 0x11 */
  {"bit_not", 0, 0, 1, 1},	/* 0x12 */
  {"equal", 0, 0, 2, 1},	/* 0x13 */
  {"less_signed", 0, 0, 2, 1},	/* 0x14 */
  {"less_unsigned", 0, 0, 2, 1},	/* 0x15 */
  {"ext", 1, 0, 1, 1},		/* 0x16 */
  {"ref8", 0, 8, 1, 1},		/* 0x17 */
  {"ref16", 0, 16, 1, 1},	/* 0x18 */
  {"ref32", 0, 32, 1, 1},	/* 0x19 */
  {"ref64", 0, 64, 1, 1},	/* 0x1a */
  {"ref_float", 0, 0, 1, 1},	/* 0x1b */
  {"ref_double", 0, 0, 1, 1},	/* 0x1c */
  {"ref_long_double", 0, 0, 1, 1},	/* 0x1d */
  {"l_to_d", 0, 0, 1, 1},	/* 0x1e */
  {"d_to_l", 0, 0, 1, 1},	/* 0x1f */
  {"if_goto", 2, 0, 1, 0},	/* 0x20 */
  {"goto", 2, 0, 0, 0},		/* 0x21 */
  {"const8", 1, 8, 0, 1},	/* 0x22 */
  {"const16", 2, 16, 0, 1},	/* 0x23 */
  {"const32", 4, 32, 0, 1},	/* 0x24 */
  {"const64", 8, 64, 0, 1},	/* 0x25 */
  {"reg", 2, 0, 0, 1},		/* 0x26 */
  {"end", 0, 0, 0, 0},		/* 0x27 */
  {"dup", 0, 0, 1, 2},		/* 0x28 */
  {"pop", 0, 0, 1, 0},		/* 0x29 */
  {"zero_ext", 1, 0, 1, 1},	/* 0x2a */
  {"swap", 0, 0, 2, 2},		/* 0x2b */
  {"getv", 2, 0, 0, 1},		/* 0x2c */
  {"setv", 2, 0, 0, 1},		/* 0x2d */
  {"tracev", 2, 0, 0, 1},	/* 0x2e */
  {0, 0, 0, 0, 0},		/* 0x2f */
  {"trace16", 2, 0, 1, 1},	/* 0x30 */
};


/* Disassemble the expression EXPR, writing to F.  */
void
ax_print (struct ui_file *f, struct agent_expr *x)
{
  int i;
  int is_float = 0;

  fprintf_filtered (f, _("Scope: %s\n"), paddress (x->gdbarch, x->scope));
  fprintf_filtered (f, _("Reg mask:"));
  for (i = 0; i < x->reg_mask_len; ++i)
    fprintf_filtered (f, _(" %02x"), x->reg_mask[i]);
  fprintf_filtered (f, _("\n"));

  /* Check the size of the name array against the number of entries in
     the enum, to catch additions that people didn't sync.  */
  if ((sizeof (aop_map) / sizeof (aop_map[0]))
      != aop_last)
    error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync"));

  for (i = 0; i < x->len;)
    {
      enum agent_op op = x->buf[i];

      if (op >= (sizeof (aop_map) / sizeof (aop_map[0]))
	  || !aop_map[op].name)
	{
	  fprintf_filtered (f, _("%3d  <bad opcode %02x>\n"), i, op);
	  i++;
	  continue;
	}
      if (i + 1 + aop_map[op].op_size > x->len)
	{
	  fprintf_filtered (f, _("%3d  <incomplete opcode %s>\n"),
			    i, aop_map[op].name);
	  break;
	}

      fprintf_filtered (f, "%3d  %s", i, aop_map[op].name);
      if (aop_map[op].op_size > 0)
	{
	  fputs_filtered (" ", f);

	  print_longest (f, 'd', 0,
			 read_const (x, i + 1, aop_map[op].op_size));
	}
      fprintf_filtered (f, "\n");
      i += 1 + aop_map[op].op_size;

      is_float = (op == aop_float);
    }
}

/* Add register REG to the register mask for expression AX.  */
void
ax_reg_mask (struct agent_expr *ax, int reg)
{
  int byte = reg / 8;

  /* Grow the bit mask if necessary.  */
  if (byte >= ax->reg_mask_len)
    {
      /* It's not appropriate to double here.  This isn't a
	 string buffer.  */
      int new_len = byte + 1;
      unsigned char *new_reg_mask = xrealloc (ax->reg_mask,
					      new_len * sizeof (ax->reg_mask[0]));
      memset (new_reg_mask + ax->reg_mask_len, 0,
	      (new_len - ax->reg_mask_len) * sizeof (ax->reg_mask[0]));
      ax->reg_mask_len = new_len;
      ax->reg_mask = new_reg_mask;
    }

  ax->reg_mask[byte] |= 1 << (reg % 8);
}

/* Given an agent expression AX, fill in requirements and other descriptive
   bits.  */
void
ax_reqs (struct agent_expr *ax)
{
  int i;
  int height;

  /* Jump target table.  targets[i] is non-zero iff we have found a
     jump to offset i.  */
  char *targets = (char *) alloca (ax->len * sizeof (targets[0]));

  /* Instruction boundary table.  boundary[i] is non-zero iff our scan
     has reached an instruction starting at offset i.  */
  char *boundary = (char *) alloca (ax->len * sizeof (boundary[0]));

  /* Stack height record.  If either targets[i] or boundary[i] is
     non-zero, heights[i] is the height the stack should have before
     executing the bytecode at that point.  */
  int *heights = (int *) alloca (ax->len * sizeof (heights[0]));

  /* Pointer to a description of the present op.  */
  struct aop_map *op;

  memset (targets, 0, ax->len * sizeof (targets[0]));
  memset (boundary, 0, ax->len * sizeof (boundary[0]));

  ax->max_height = ax->min_height = height = 0;
  ax->flaw = agent_flaw_none;
  ax->max_data_size = 0;

  for (i = 0; i < ax->len; i += 1 + op->op_size)
    {
      if (ax->buf[i] > (sizeof (aop_map) / sizeof (aop_map[0])))
	{
	  ax->flaw = agent_flaw_bad_instruction;
	  return;
	}

      op = &aop_map[ax->buf[i]];

      if (!op->name)
	{
	  ax->flaw = agent_flaw_bad_instruction;
	  return;
	}

      if (i + 1 + op->op_size > ax->len)
	{
	  ax->flaw = agent_flaw_incomplete_instruction;
	  return;
	}

      /* If this instruction is a forward jump target, does the
         current stack height match the stack height at the jump
         source?  */
      if (targets[i] && (heights[i] != height))
	{
	  ax->flaw = agent_flaw_height_mismatch;
	  return;
	}

      boundary[i] = 1;
      heights[i] = height;

      height -= op->consumed;
      if (height < ax->min_height)
	ax->min_height = height;
      height += op->produced;
      if (height > ax->max_height)
	ax->max_height = height;

      if (op->data_size > ax->max_data_size)
	ax->max_data_size = op->data_size;

      /* For jump instructions, check that the target is a valid
         offset.  If it is, record the fact that that location is a
         jump target, and record the height we expect there.  */
      if (aop_goto == op - aop_map
	  || aop_if_goto == op - aop_map)
	{
	  int target = read_const (ax, i + 1, 2);
	  if (target < 0 || target >= ax->len)
	    {
	      ax->flaw = agent_flaw_bad_jump;
	      return;
	    }

	  /* Do we have any information about what the stack height
             should be at the target?  */
	  if (targets[target] || boundary[target])
	    {
	      if (heights[target] != height)
		{
		  ax->flaw = agent_flaw_height_mismatch;
		  return;
		}
	    }

          /* Record the target, along with the stack height we expect.  */
          targets[target] = 1;
          heights[target] = height;
	}

      /* For unconditional jumps with a successor, check that the
         successor is a target, and pick up its stack height.  */
      if (aop_goto == op - aop_map
	  && i + 3 < ax->len)
	{
	  if (!targets[i + 3])
	    {
	      ax->flaw = agent_flaw_hole;
	      return;
	    }

	  height = heights[i + 3];
	}

      /* For reg instructions, record the register in the bit mask.  */
      if (aop_reg == op - aop_map)
	{
	  int reg = read_const (ax, i + 1, 2);

	  ax_reg_mask (ax, reg);
	}
    }

  /* Check that all the targets are on boundaries.  */
  for (i = 0; i < ax->len; i++)
    if (targets[i] && !boundary[i])
      {
	ax->flaw = agent_flaw_bad_jump;
	return;
      }

  ax->final_height = height;
}
Commit	Line	Data
c906108c	1	/* Functions for manipulating expressions designed to be executed on the agent
4c38e0a4	2	Copyright (C) 1998, 1999, 2000, 2007, 2008, 2009, 2010
0fb0cc75	3	Free Software Foundation, Inc.
c906108c	4
c5aa993b	5	This file is part of GDB.
c906108c	6
c5aa993b JM	7	This program is free software; you can redistribute it and/or modify
c5aa993b JM	8	it under the terms of the GNU General Public License as published by
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
c5aa993b	10	(at your option) any later version.
c906108c	11
c5aa993b JM	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.
c906108c	16
c5aa993b	17	You should have received a copy of the GNU General Public License
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c	19
c906108c SS	20	/* Despite what the above comment says about this file being part of
	21	GDB, we would like to keep these functions free of GDB
	22	dependencies, since we want to be able to use them in contexts
	23	outside of GDB (test suites, the stub, etc.) */
	24
	25	#include "defs.h"
	26	#include "ax.h"
	27
7a292a7a	28	#include "value.h"
b66d6d2e	29	#include "gdb_string.h"
7a292a7a	30
a14ed312	31	static void grow_expr (struct agent_expr *x, int n);
392a587b	32
a14ed312	33	static void append_const (struct agent_expr *x, LONGEST val, int n);
392a587b	34
a14ed312	35	static LONGEST read_const (struct agent_expr *x, int o, int n);
392a587b	36
a14ed312	37	static void generic_ext (struct agent_expr *x, enum agent_op op, int n);
c906108c SS	38	\f
	39	/* Functions for building expressions. */
	40
	41	/* Allocate a new, empty agent expression. */
	42	struct agent_expr *
35c9c7ba	43	new_agent_expr (struct gdbarch *gdbarch, CORE_ADDR scope)
c906108c SS	44	{
c906108c SS	45	struct agent_expr x = xmalloc (sizeof (x));
35c9c7ba	46
c5aa993b	47	x->len = 0;
c906108c SS	48	x->size = 1; /* Change this to a larger value once
c906108c SS	49	reallocation code is tested. */
c5aa993b	50	x->buf = xmalloc (x->size);
35c9c7ba SS	51
35c9c7ba SS	52	x->gdbarch = gdbarch;
c906108c SS	53	x->scope = scope;
c906108c SS	54
35c9c7ba SS	55	/* Bit vector for registers used. */
	56	x->reg_mask_len = 1;
	57	x->reg_mask = xmalloc (x->reg_mask_len * sizeof (x->reg_mask[0]));
	58	memset (x->reg_mask, 0, x->reg_mask_len * sizeof (x->reg_mask[0]));
	59
c906108c SS	60	return x;
	61	}
	62
	63	/* Free a agent expression. */
	64	void
fba45db2	65	free_agent_expr (struct agent_expr *x)
c906108c	66	{
b8c9b27d	67	xfree (x->buf);
35c9c7ba	68	xfree (x->reg_mask);
b8c9b27d	69	xfree (x);
c906108c SS	70	}
c906108c SS	71
f23d52e0 AC	72	static void
	73	do_free_agent_expr_cleanup (void *x)
	74	{
	75	free_agent_expr (x);
	76	}
	77
	78	struct cleanup *
	79	make_cleanup_free_agent_expr (struct agent_expr *x)
	80	{
	81	return make_cleanup (do_free_agent_expr_cleanup, x);
	82	}
	83
c906108c SS	84
	85	/* Make sure that X has room for at least N more bytes. This doesn't
	86	affect the length, just the allocated size. */
	87	static void
fba45db2	88	grow_expr (struct agent_expr *x, int n)
c906108c SS	89	{
	90	if (x->len + n > x->size)
	91	{
	92	x->size *= 2;
	93	if (x->size < x->len + n)
	94	x->size = x->len + n + 10;
	95	x->buf = xrealloc (x->buf, x->size);
	96	}
	97	}
	98
	99
	100	/* Append the low N bytes of VAL as an N-byte integer to the
	101	expression X, in big-endian order. */
	102	static void
fba45db2	103	append_const (struct agent_expr *x, LONGEST val, int n)
c906108c SS	104	{
	105	int i;
	106
	107	grow_expr (x, n);
	108	for (i = n - 1; i >= 0; i--)
	109	{
	110	x->buf[x->len + i] = val & 0xff;
	111	val >>= 8;
	112	}
	113	x->len += n;
	114	}
	115
	116
	117	/* Extract an N-byte big-endian unsigned integer from expression X at
	118	offset O. */
	119	static LONGEST
fba45db2	120	read_const (struct agent_expr *x, int o, int n)
c906108c SS	121	{
	122	int i;
	123	LONGEST accum = 0;
	124
	125	/* Make sure we're not reading off the end of the expression. */
	126	if (o + n > x->len)
3d263c1d	127	error (_("GDB bug: ax-general.c (read_const): incomplete constant"));
c906108c SS	128
	129	for (i = 0; i < n; i++)
	130	accum = (accum << 8) \| x->buf[o + i];
c5aa993b	131
c906108c SS	132	return accum;
	133	}
	134
	135
	136	/* Append a simple operator OP to EXPR. */
	137	void
fba45db2	138	ax_simple (struct agent_expr *x, enum agent_op op)
c906108c SS	139	{
	140	grow_expr (x, 1);
	141	x->buf[x->len++] = op;
	142	}
	143
	144
	145	/* Append a sign-extension or zero-extension instruction to EXPR, to
	146	extend an N-bit value. */
	147	static void
fba45db2	148	generic_ext (struct agent_expr *x, enum agent_op op, int n)
c906108c SS	149	{
	150	/* N must fit in a byte. */
	151	if (n < 0 \|\| n > 255)
3d263c1d	152	error (_("GDB bug: ax-general.c (generic_ext): bit count out of range"));
c906108c SS	153	/* That had better be enough range. */
c906108c SS	154	if (sizeof (LONGEST) * 8 > 255)
3d263c1d	155	error (_("GDB bug: ax-general.c (generic_ext): opcode has inadequate range"));
c906108c SS	156
	157	grow_expr (x, 2);
	158	x->buf[x->len++] = op;
	159	x->buf[x->len++] = n;
	160	}
	161
	162
	163	/* Append a sign-extension instruction to EXPR, to extend an N-bit value. */
	164	void
fba45db2	165	ax_ext (struct agent_expr *x, int n)
c906108c SS	166	{
	167	generic_ext (x, aop_ext, n);
	168	}
	169
	170
	171	/* Append a zero-extension instruction to EXPR, to extend an N-bit value. */
	172	void
fba45db2	173	ax_zero_ext (struct agent_expr *x, int n)
c906108c SS	174	{
	175	generic_ext (x, aop_zero_ext, n);
	176	}
	177
	178
	179	/* Append a trace_quick instruction to EXPR, to record N bytes. */
	180	void
fba45db2	181	ax_trace_quick (struct agent_expr *x, int n)
c906108c SS	182	{
	183	/* N must fit in a byte. */
	184	if (n < 0 \|\| n > 255)
3d263c1d	185	error (_("GDB bug: ax-general.c (ax_trace_quick): size out of range for trace_quick"));
c906108c SS	186
	187	grow_expr (x, 2);
	188	x->buf[x->len++] = aop_trace_quick;
	189	x->buf[x->len++] = n;
	190	}
	191
	192
	193	/* Append a goto op to EXPR. OP is the actual op (must be aop_goto or
	194	aop_if_goto). We assume we don't know the target offset yet,
	195	because it's probably a forward branch, so we leave space in EXPR
	196	for the target, and return the offset in EXPR of that space, so we
	197	can backpatch it once we do know the target offset. Use ax_label
	198	to do the backpatching. */
c5aa993b	199	int
fba45db2	200	ax_goto (struct agent_expr *x, enum agent_op op)
c906108c SS	201	{
	202	grow_expr (x, 3);
	203	x->buf[x->len + 0] = op;
	204	x->buf[x->len + 1] = 0xff;
	205	x->buf[x->len + 2] = 0xff;
	206	x->len += 3;
	207	return x->len - 2;
	208	}
	209
	210	/* Suppose a given call to ax_goto returns some value PATCH. When you
	211	know the offset TARGET that goto should jump to, call
c5aa993b	212	ax_label (EXPR, PATCH, TARGET)
c906108c SS	213	to patch TARGET into the ax_goto instruction. */
c906108c SS	214	void
fba45db2	215	ax_label (struct agent_expr *x, int patch, int target)
c906108c SS	216	{
	217	/* Make sure the value is in range. Don't accept 0xffff as an
	218	offset; that's our magic sentinel value for unpatched branches. */
	219	if (target < 0 \|\| target >= 0xffff)
3d263c1d	220	error (_("GDB bug: ax-general.c (ax_label): label target out of range"));
c5aa993b	221
c906108c SS	222	x->buf[patch] = (target >> 8) & 0xff;
	223	x->buf[patch + 1] = target & 0xff;
	224	}
	225
	226
	227	/* Assemble code to push a constant on the stack. */
	228	void
fba45db2	229	ax_const_l (struct agent_expr *x, LONGEST l)
c906108c SS	230	{
c906108c SS	231	static enum agent_op ops[]
c5aa993b JM	232	=
c5aa993b JM	233	{aop_const8, aop_const16, aop_const32, aop_const64};
c906108c SS	234	int size;
	235	int op;
	236
	237	/* How big is the number? 'op' keeps track of which opcode to use.
	238	Notice that we don't really care whether the original number was
	239	signed or unsigned; we always reproduce the value exactly, and
	240	use the shortest representation. */
	241	for (op = 0, size = 8; size < 64; size *= 2, op++)
44a81774	242	{
cf3e25ca	243	LONGEST lim = ((LONGEST) 1) << (size - 1);
44a81774 JB	244
	245	if (-lim <= l && l <= lim - 1)
	246	break;
	247	}
c906108c SS	248
	249	/* Emit the right opcode... */
	250	ax_simple (x, ops[op]);
	251
	252	/* Emit the low SIZE bytes as an unsigned number. We know that
	253	sign-extending this will yield l. */
	254	append_const (x, l, size / 8);
	255
	256	/* Now, if it was negative, and not full-sized, sign-extend it. */
	257	if (l < 0 && size < 64)
	258	ax_ext (x, size);
	259	}
	260
	261
	262	void
fba45db2	263	ax_const_d (struct agent_expr *x, LONGEST d)
c906108c SS	264	{
c906108c SS	265	/* FIXME: floating-point support not present yet. */
3d263c1d	266	error (_("GDB bug: ax-general.c (ax_const_d): floating point not supported yet"));
c906108c SS	267	}
	268
	269
	270	/* Assemble code to push the value of register number REG on the
	271	stack. */
c5aa993b	272	void
fba45db2	273	ax_reg (struct agent_expr *x, int reg)
c906108c SS	274	{
	275	/* Make sure the register number is in range. */
	276	if (reg < 0 \|\| reg > 0xffff)
3d263c1d	277	error (_("GDB bug: ax-general.c (ax_reg): register number out of range"));
c906108c	278	grow_expr (x, 3);
c5aa993b	279	x->buf[x->len] = aop_reg;
c906108c	280	x->buf[x->len + 1] = (reg >> 8) & 0xff;
c5aa993b	281	x->buf[x->len + 2] = (reg) & 0xff;
c906108c SS	282	x->len += 3;
c906108c SS	283	}
f61e138d SS	284
	285	/* Assemble code to operate on a trace state variable. */
	286
	287	void
	288	ax_tsv (struct agent_expr *x, enum agent_op op, int num)
	289	{
	290	/* Make sure the tsv number is in range. */
	291	if (num < 0 \|\| num > 0xffff)
	292	internal_error (__FILE__, __LINE__, _("ax-general.c (ax_tsv): variable number is %d, out of range"), num);
	293
	294	grow_expr (x, 3);
	295	x->buf[x->len] = op;
	296	x->buf[x->len + 1] = (num >> 8) & 0xff;
	297	x->buf[x->len + 2] = (num) & 0xff;
	298	x->len += 3;
	299	}
c5aa993b	300	\f
c906108c SS	301
c906108c SS	302
c906108c SS	303	/* Functions for disassembling agent expressions, and otherwise
	304	debugging the expression compiler. */
	305
c5aa993b JM	306	struct aop_map aop_map[] =
	307	{
	308	{0, 0, 0, 0, 0},
	309	{"float", 0, 0, 0, 0}, /* 0x01 */
	310	{"add", 0, 0, 2, 1}, /* 0x02 */
	311	{"sub", 0, 0, 2, 1}, /* 0x03 */
	312	{"mul", 0, 0, 2, 1}, /* 0x04 */
	313	{"div_signed", 0, 0, 2, 1}, /* 0x05 */
	314	{"div_unsigned", 0, 0, 2, 1}, /* 0x06 */
	315	{"rem_signed", 0, 0, 2, 1}, /* 0x07 */
	316	{"rem_unsigned", 0, 0, 2, 1}, /* 0x08 */
	317	{"lsh", 0, 0, 2, 1}, /* 0x09 */
	318	{"rsh_signed", 0, 0, 2, 1}, /* 0x0a */
	319	{"rsh_unsigned", 0, 0, 2, 1}, /* 0x0b */
	320	{"trace", 0, 0, 2, 0}, /* 0x0c */
	321	{"trace_quick", 1, 0, 1, 1}, /* 0x0d */
	322	{"log_not", 0, 0, 1, 1}, /* 0x0e */
	323	{"bit_and", 0, 0, 2, 1}, /* 0x0f */
	324	{"bit_or", 0, 0, 2, 1}, /* 0x10 */
	325	{"bit_xor", 0, 0, 2, 1}, /* 0x11 */
	326	{"bit_not", 0, 0, 1, 1}, /* 0x12 */
	327	{"equal", 0, 0, 2, 1}, /* 0x13 */
	328	{"less_signed", 0, 0, 2, 1}, /* 0x14 */
	329	{"less_unsigned", 0, 0, 2, 1}, /* 0x15 */
	330	{"ext", 1, 0, 1, 1}, /* 0x16 */
	331	{"ref8", 0, 8, 1, 1}, /* 0x17 */
	332	{"ref16", 0, 16, 1, 1}, /* 0x18 */
	333	{"ref32", 0, 32, 1, 1}, /* 0x19 */
	334	{"ref64", 0, 64, 1, 1}, /* 0x1a */
	335	{"ref_float", 0, 0, 1, 1}, /* 0x1b */
	336	{"ref_double", 0, 0, 1, 1}, /* 0x1c */
	337	{"ref_long_double", 0, 0, 1, 1}, /* 0x1d */
	338	{"l_to_d", 0, 0, 1, 1}, /* 0x1e */
	339	{"d_to_l", 0, 0, 1, 1}, /* 0x1f */
	340	{"if_goto", 2, 0, 1, 0}, /* 0x20 */
	341	{"goto", 2, 0, 0, 0}, /* 0x21 */
	342	{"const8", 1, 8, 0, 1}, /* 0x22 */
	343	{"const16", 2, 16, 0, 1}, /* 0x23 */
	344	{"const32", 4, 32, 0, 1}, /* 0x24 */
	345	{"const64", 8, 64, 0, 1}, /* 0x25 */
	346	{"reg", 2, 0, 0, 1}, /* 0x26 */
	347	{"end", 0, 0, 0, 0}, /* 0x27 */
	348	{"dup", 0, 0, 1, 2}, /* 0x28 */
	349	{"pop", 0, 0, 1, 0}, /* 0x29 */
	350	{"zero_ext", 1, 0, 1, 1}, /* 0x2a */
	351	{"swap", 0, 0, 2, 2}, /* 0x2b */
f61e138d SS	352	{"getv", 2, 0, 0, 1}, /* 0x2c */
	353	{"setv", 2, 0, 0, 1}, /* 0x2d */
	354	{"tracev", 2, 0, 0, 1}, /* 0x2e */
c5aa993b JM	355	{0, 0, 0, 0, 0}, /* 0x2f */
c5aa993b JM	356	{"trace16", 2, 0, 1, 1}, /* 0x30 */
c906108c SS	357	};
	358
	359
	360	/* Disassemble the expression EXPR, writing to F. */
	361	void
fba45db2	362	ax_print (struct ui_file f, struct agent_expr x)
c906108c SS	363	{
	364	int i;
	365	int is_float = 0;
	366
35c9c7ba SS	367	fprintf_filtered (f, _("Scope: %s\n"), paddress (x->gdbarch, x->scope));
	368	fprintf_filtered (f, _("Reg mask:"));
	369	for (i = 0; i < x->reg_mask_len; ++i)
	370	fprintf_filtered (f, _(" %02x"), x->reg_mask[i]);
	371	fprintf_filtered (f, _("\n"));
	372
c906108c SS	373	/* Check the size of the name array against the number of entries in
	374	the enum, to catch additions that people didn't sync. */
	375	if ((sizeof (aop_map) / sizeof (aop_map[0]))
	376	!= aop_last)
3d263c1d	377	error (_("GDB bug: ax-general.c (ax_print): opcode map out of sync"));
c5aa993b JM	378
c5aa993b JM	379	for (i = 0; i < x->len;)
c906108c SS	380	{
	381	enum agent_op op = x->buf[i];
	382
	383	if (op >= (sizeof (aop_map) / sizeof (aop_map[0]))
c5aa993b	384	\|\| !aop_map[op].name)
c906108c	385	{
3d263c1d	386	fprintf_filtered (f, _("%3d <bad opcode %02x>\n"), i, op);
c906108c SS	387	i++;
	388	continue;
	389	}
	390	if (i + 1 + aop_map[op].op_size > x->len)
	391	{
3d263c1d	392	fprintf_filtered (f, _("%3d <incomplete opcode %s>\n"),
c906108c SS	393	i, aop_map[op].name);
	394	break;
	395	}
	396
	397	fprintf_filtered (f, "%3d %s", i, aop_map[op].name);
	398	if (aop_map[op].op_size > 0)
	399	{
	400	fputs_filtered (" ", f);
c5aa993b	401
c906108c SS	402	print_longest (f, 'd', 0,
	403	read_const (x, i + 1, aop_map[op].op_size));
	404	}
	405	fprintf_filtered (f, "\n");
	406	i += 1 + aop_map[op].op_size;
	407
	408	is_float = (op == aop_float);
	409	}
	410	}
	411
35c9c7ba SS	412	/* Add register REG to the register mask for expression AX. */
	413	void
	414	ax_reg_mask (struct agent_expr *ax, int reg)
	415	{
	416	int byte = reg / 8;
c906108c	417
35c9c7ba SS	418	/* Grow the bit mask if necessary. */
	419	if (byte >= ax->reg_mask_len)
	420	{
	421	/* It's not appropriate to double here. This isn't a
	422	string buffer. */
	423	int new_len = byte + 1;
	424	unsigned char *new_reg_mask = xrealloc (ax->reg_mask,
	425	new_len * sizeof (ax->reg_mask[0]));
	426	memset (new_reg_mask + ax->reg_mask_len, 0,
	427	(new_len - ax->reg_mask_len) * sizeof (ax->reg_mask[0]));
	428	ax->reg_mask_len = new_len;
	429	ax->reg_mask = new_reg_mask;
	430	}
	431
	432	ax->reg_mask[byte] \|= 1 << (reg % 8);
	433	}
	434
	435	/* Given an agent expression AX, fill in requirements and other descriptive
	436	bits. */
c906108c	437	void
35c9c7ba	438	ax_reqs (struct agent_expr *ax)
c906108c SS	439	{
	440	int i;
	441	int height;
	442
3d269a59 JB	443	/* Jump target table. targets[i] is non-zero iff we have found a
3d269a59 JB	444	jump to offset i. */
c906108c SS	445	char targets = (char ) alloca (ax->len * sizeof (targets[0]));
c906108c SS	446
3d269a59 JB	447	/* Instruction boundary table. boundary[i] is non-zero iff our scan
3d269a59 JB	448	has reached an instruction starting at offset i. */
c906108c SS	449	char boundary = (char ) alloca (ax->len * sizeof (boundary[0]));
c906108c SS	450
3d269a59	451	/* Stack height record. If either targets[i] or boundary[i] is
c906108c SS	452	non-zero, heights[i] is the height the stack should have before
	453	executing the bytecode at that point. */
	454	int heights = (int ) alloca (ax->len * sizeof (heights[0]));
	455
	456	/* Pointer to a description of the present op. */
	457	struct aop_map *op;
	458
c906108c SS	459	memset (targets, 0, ax->len * sizeof (targets[0]));
	460	memset (boundary, 0, ax->len * sizeof (boundary[0]));
	461
35c9c7ba SS	462	ax->max_height = ax->min_height = height = 0;
	463	ax->flaw = agent_flaw_none;
	464	ax->max_data_size = 0;
c906108c SS	465
	466	for (i = 0; i < ax->len; i += 1 + op->op_size)
	467	{
	468	if (ax->buf[i] > (sizeof (aop_map) / sizeof (aop_map[0])))
	469	{
35c9c7ba	470	ax->flaw = agent_flaw_bad_instruction;
c906108c SS	471	return;
	472	}
	473
	474	op = &aop_map[ax->buf[i]];
	475
c5aa993b	476	if (!op->name)
c906108c	477	{
35c9c7ba	478	ax->flaw = agent_flaw_bad_instruction;
c906108c SS	479	return;
c906108c SS	480	}
c5aa993b	481
c906108c SS	482	if (i + 1 + op->op_size > ax->len)
c906108c SS	483	{
35c9c7ba	484	ax->flaw = agent_flaw_incomplete_instruction;
c906108c SS	485	return;
	486	}
	487
3d269a59 JB	488	/* If this instruction is a forward jump target, does the
	489	current stack height match the stack height at the jump
	490	source? */
c906108c SS	491	if (targets[i] && (heights[i] != height))
c906108c SS	492	{
35c9c7ba	493	ax->flaw = agent_flaw_height_mismatch;
c906108c SS	494	return;
	495	}
	496
	497	boundary[i] = 1;
	498	heights[i] = height;
	499
	500	height -= op->consumed;
35c9c7ba SS	501	if (height < ax->min_height)
35c9c7ba SS	502	ax->min_height = height;
c906108c	503	height += op->produced;
35c9c7ba SS	504	if (height > ax->max_height)
35c9c7ba SS	505	ax->max_height = height;
c906108c	506
35c9c7ba SS	507	if (op->data_size > ax->max_data_size)
35c9c7ba SS	508	ax->max_data_size = op->data_size;
c906108c SS	509
c906108c SS	510	/* For jump instructions, check that the target is a valid
c5aa993b JM	511	offset. If it is, record the fact that that location is a
c5aa993b JM	512	jump target, and record the height we expect there. */
c906108c SS	513	if (aop_goto == op - aop_map
	514	\|\| aop_if_goto == op - aop_map)
	515	{
	516	int target = read_const (ax, i + 1, 2);
	517	if (target < 0 \|\| target >= ax->len)
	518	{
35c9c7ba	519	ax->flaw = agent_flaw_bad_jump;
c906108c SS	520	return;
c906108c SS	521	}
3d269a59 JB	522
	523	/* Do we have any information about what the stack height
	524	should be at the target? */
	525	if (targets[target] \|\| boundary[target])
c906108c	526	{
3d269a59	527	if (heights[target] != height)
c906108c	528	{
35c9c7ba	529	ax->flaw = agent_flaw_height_mismatch;
c906108c SS	530	return;
	531	}
	532	}
3d269a59 JB	533
	534	/* Record the target, along with the stack height we expect. */
	535	targets[target] = 1;
	536	heights[target] = height;
c906108c	537	}
c5aa993b	538
c906108c SS	539	/* For unconditional jumps with a successor, check that the
	540	successor is a target, and pick up its stack height. */
	541	if (aop_goto == op - aop_map
	542	&& i + 3 < ax->len)
	543	{
c5aa993b	544	if (!targets[i + 3])
c906108c	545	{
35c9c7ba	546	ax->flaw = agent_flaw_hole;
c906108c SS	547	return;
	548	}
	549
	550	height = heights[i + 3];
	551	}
	552
	553	/* For reg instructions, record the register in the bit mask. */
	554	if (aop_reg == op - aop_map)
	555	{
	556	int reg = read_const (ax, i + 1, 2);
c906108c	557
35c9c7ba	558	ax_reg_mask (ax, reg);
c906108c SS	559	}
	560	}
	561
	562	/* Check that all the targets are on boundaries. */
	563	for (i = 0; i < ax->len; i++)
	564	if (targets[i] && !boundary[i])
	565	{
35c9c7ba	566	ax->flaw = agent_flaw_bad_jump;
c906108c SS	567	return;
	568	}
	569
35c9c7ba	570	ax->final_height = height;
c906108c	571	}