[deliverable/binutils-gdb.git] / opcodes / s390-dis.c

/* s390-dis.c -- Disassemble S390 instructions
   Copyright 2000, 2001, 2002, 2003, 2005, 2007, 2008
   Free Software Foundation, Inc.
   Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).

   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 file; see the file COPYING.  If not, write to the
   Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

#include <stdio.h>
#include "ansidecl.h"
#include "sysdep.h"
#include "dis-asm.h"
#include "opintl.h"
#include "opcode/s390.h"

static int init_flag = 0;
static int opc_index[256];
static int current_arch_mask = 0;

/* Set up index table for first opcode byte.  */

static void
init_disasm (struct disassemble_info *info)
{
  const struct s390_opcode *opcode;
  const struct s390_opcode *opcode_end;
  const char *p;

  memset (opc_index, 0, sizeof (opc_index));
  opcode_end = s390_opcodes + s390_num_opcodes;
  for (opcode = s390_opcodes; opcode < opcode_end; opcode++)
    {
      opc_index[(int) opcode->opcode[0]] = opcode - s390_opcodes;
      while ((opcode < opcode_end) &&
	     (opcode[1].opcode[0] == opcode->opcode[0]))
	opcode++;
    }

  for (p = info->disassembler_options; p != NULL; )
    {
      if (CONST_STRNEQ (p, "esa"))
	current_arch_mask = 1 << S390_OPCODE_ESA;
      else if (CONST_STRNEQ (p, "zarch"))
	current_arch_mask = 1 << S390_OPCODE_ZARCH;
      else
	fprintf (stderr, "Unknown S/390 disassembler option: %s\n", p);

      p = strchr (p, ',');
      if (p != NULL)
	p++;
    }

  if (!current_arch_mask)
    switch (info->mach)
      {
      case bfd_mach_s390_31:
	current_arch_mask = 1 << S390_OPCODE_ESA;
	break;
      case bfd_mach_s390_64:
	current_arch_mask = 1 << S390_OPCODE_ZARCH;
	break;
      default:
	abort ();
      }

  init_flag = 1;
}

/* Extracts an operand value from an instruction.  */

static inline unsigned int
s390_extract_operand (unsigned char *insn, const struct s390_operand *operand)
{
  unsigned int val;
  int bits;

  /* Extract fragments of the operand byte for byte.  */
  insn += operand->shift / 8;
  bits = (operand->shift & 7) + operand->bits;
  val = 0;
  do
    {
      val <<= 8;
      val |= (unsigned int) *insn++;
      bits -= 8;
    }
  while (bits > 0);
  val >>= -bits;
  val &= ((1U << (operand->bits - 1)) << 1) - 1;

  /* Check for special long displacement case.  */
  if (operand->bits == 20 && operand->shift == 20)
    val = (val & 0xff) << 12 | (val & 0xfff00) >> 8;

  /* Sign extend value if the operand is signed or pc relative.  */
  if ((operand->flags & (S390_OPERAND_SIGNED | S390_OPERAND_PCREL))
      && (val & (1U << (operand->bits - 1))))
    val |= (-1U << (operand->bits - 1)) << 1;

  /* Double value if the operand is pc relative.  */
  if (operand->flags & S390_OPERAND_PCREL)
    val <<= 1;

  /* Length x in an instructions has real length x + 1.  */
  if (operand->flags & S390_OPERAND_LENGTH)
    val++;
  return val;
}

/* Print a S390 instruction.  */

int
print_insn_s390 (bfd_vma memaddr, struct disassemble_info *info)
{
  bfd_byte buffer[6];
  const struct s390_opcode *opcode;
  const struct s390_opcode *opcode_end;
  unsigned int value;
  int status, opsize, bufsize;
  char separator;

  if (init_flag == 0)
    init_disasm (info);

  /* The output looks better if we put 6 bytes on a line.  */
  info->bytes_per_line = 6;

  /* Every S390 instruction is max 6 bytes long.  */
  memset (buffer, 0, 6);
  status = (*info->read_memory_func) (memaddr, buffer, 6, info);
  if (status != 0)
    {
      for (bufsize = 0; bufsize < 6; bufsize++)
	if ((*info->read_memory_func) (memaddr, buffer, bufsize + 1, info) != 0)
	  break;
      if (bufsize <= 0)
	{
	  (*info->memory_error_func) (status, memaddr, info);
	  return -1;
	}
      /* Opsize calculation looks strange but it works
	 00xxxxxx -> 2 bytes, 01xxxxxx/10xxxxxx -> 4 bytes,
	 11xxxxxx -> 6 bytes.  */
      opsize = ((((buffer[0] >> 6) + 1) >> 1) + 1) << 1;
      status = opsize > bufsize;
    }
  else
    {
      bufsize = 6;
      opsize = ((((buffer[0] >> 6) + 1) >> 1) + 1) << 1;
    }

  if (status == 0)
    {
      /* Find the first match in the opcode table.  */
      opcode_end = s390_opcodes + s390_num_opcodes;
      for (opcode = s390_opcodes + opc_index[(int) buffer[0]];
	   (opcode < opcode_end) && (buffer[0] == opcode->opcode[0]);
	   opcode++)
	{
	  const struct s390_operand *operand;
	  const unsigned char *opindex;

	  /* Check architecture.  */
	  if (!(opcode->modes & current_arch_mask))
	    continue;
	  /* Check signature of the opcode.  */
	  if ((buffer[1] & opcode->mask[1]) != opcode->opcode[1]
	      || (buffer[2] & opcode->mask[2]) != opcode->opcode[2]
	      || (buffer[3] & opcode->mask[3]) != opcode->opcode[3]
	      || (buffer[4] & opcode->mask[4]) != opcode->opcode[4]
	      || (buffer[5] & opcode->mask[5]) != opcode->opcode[5])
	    continue;

	  /* The instruction is valid.  */
	  if (opcode->operands[0] != 0)
	    (*info->fprintf_func) (info->stream, "%s\t", opcode->name);
	  else
	    (*info->fprintf_func) (info->stream, "%s", opcode->name);

	  /* Extract the operands.  */
	  separator = 0;
	  for (opindex = opcode->operands; *opindex != 0; opindex++)
	    {
	      unsigned int value;

	      operand = s390_operands + *opindex;
	      value = s390_extract_operand (buffer, operand);

	      if ((operand->flags & S390_OPERAND_INDEX) && value == 0)
		continue;
	      if ((operand->flags & S390_OPERAND_BASE) &&
		  value == 0 && separator == '(')
		{
		  separator = ',';
		  continue;
		}

	      if (separator)
		(*info->fprintf_func) (info->stream, "%c", separator);

	      if (operand->flags & S390_OPERAND_GPR)
		(*info->fprintf_func) (info->stream, "%%r%i", value);
	      else if (operand->flags & S390_OPERAND_FPR)
		(*info->fprintf_func) (info->stream, "%%f%i", value);
	      else if (operand->flags & S390_OPERAND_AR)
		(*info->fprintf_func) (info->stream, "%%a%i", value);
	      else if (operand->flags & S390_OPERAND_CR)
		(*info->fprintf_func) (info->stream, "%%c%i", value);
	      else if (operand->flags & S390_OPERAND_PCREL)
		(*info->print_address_func) (memaddr + (int) value, info);
	      else if (operand->flags & S390_OPERAND_SIGNED)
		(*info->fprintf_func) (info->stream, "%i", (int) value);
	      else
		(*info->fprintf_func) (info->stream, "%u", value);

	      if (operand->flags & S390_OPERAND_DISP)
		{
		  separator = '(';
		}
	      else if (operand->flags & S390_OPERAND_BASE)
		{
		  (*info->fprintf_func) (info->stream, ")");
		  separator = ',';
		}
	      else
		separator = ',';
	    }

	  /* Found instruction, printed it, return its size.  */
	  return opsize;
	}
      /* No matching instruction found, fall through to hex print.  */
    }

  if (bufsize >= 4)
    {
      value = (unsigned int) buffer[0];
      value = (value << 8) + (unsigned int) buffer[1];
      value = (value << 8) + (unsigned int) buffer[2];
      value = (value << 8) + (unsigned int) buffer[3];
      (*info->fprintf_func) (info->stream, ".long\t0x%08x", value);
      return 4;
    }
  else if (bufsize >= 2)
    {
      value = (unsigned int) buffer[0];
      value = (value << 8) + (unsigned int) buffer[1];
      (*info->fprintf_func) (info->stream, ".short\t0x%04x", value);
      return 2;
    }
  else
    {
      value = (unsigned int) buffer[0];
      (*info->fprintf_func) (info->stream, ".byte\t0x%02x", value);
      return 1;
    }
}

void
print_s390_disassembler_options (FILE *stream)
{
  fprintf (stream, _("\n\
The following S/390 specific disassembler options are supported for use\n\
with the -M switch (multiple options should be separated by commas):\n"));

  fprintf (stream, _("  esa         Disassemble in ESA architecture mode\n"));
  fprintf (stream, _("  zarch       Disassemble in z/Architecture mode\n"));
}
Commit	Line	Data
a85d7ed0	1	/* s390-dis.c -- Disassemble S390 instructions
aa820537 AM	2	Copyright 2000, 2001, 2002, 2003, 2005, 2007, 2008
aa820537 AM	3	Free Software Foundation, Inc.
a85d7ed0 NC	4	Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
a85d7ed0 NC	5
9b201bb5	6	This file is part of the GNU opcodes library.
a85d7ed0	7
9b201bb5	8	This library is free software; you can redistribute it and/or modify
a85d7ed0	9	it under the terms of the GNU General Public License as published by
9b201bb5 NC	10	the Free Software Foundation; either version 3, or (at your option)
9b201bb5 NC	11	any later version.
a85d7ed0	12
9b201bb5 NC	13	It is distributed in the hope that it will be useful, but WITHOUT
	14	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
	15	or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
	16	License for more details.
a85d7ed0 NC	17
a85d7ed0 NC	18	You should have received a copy of the GNU General Public License
9b201bb5 NC	19	along with this file; see the file COPYING. If not, write to the
	20	Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
	21	MA 02110-1301, USA. */
a85d7ed0 NC	22
	23	#include <stdio.h>
	24	#include "ansidecl.h"
	25	#include "sysdep.h"
	26	#include "dis-asm.h"
112b7c50	27	#include "opintl.h"
a85d7ed0 NC	28	#include "opcode/s390.h"
	29
	30	static int init_flag = 0;
	31	static int opc_index[256];
	32	static int current_arch_mask = 0;
	33
44f2a95d KH	34	/* Set up index table for first opcode byte. */
	35
	36	static void
47b0e7ad	37	init_disasm (struct disassemble_info *info)
a85d7ed0 NC	38	{
	39	const struct s390_opcode *opcode;
	40	const struct s390_opcode *opcode_end;
112b7c50	41	const char *p;
a85d7ed0	42
44f2a95d	43	memset (opc_index, 0, sizeof (opc_index));
a85d7ed0	44	opcode_end = s390_opcodes + s390_num_opcodes;
44f2a95d KH	45	for (opcode = s390_opcodes; opcode < opcode_end; opcode++)
	46	{
	47	opc_index[(int) opcode->opcode[0]] = opcode - s390_opcodes;
	48	while ((opcode < opcode_end) &&
	49	(opcode[1].opcode[0] == opcode->opcode[0]))
	50	opcode++;
	51	}
112b7c50 AK	52
112b7c50 AK	53	for (p = info->disassembler_options; p != NULL; )
44f2a95d	54	{
112b7c50 AK	55	if (CONST_STRNEQ (p, "esa"))
	56	current_arch_mask = 1 << S390_OPCODE_ESA;
	57	else if (CONST_STRNEQ (p, "zarch"))
	58	current_arch_mask = 1 << S390_OPCODE_ZARCH;
	59	else
	60	fprintf (stderr, "Unknown S/390 disassembler option: %s\n", p);
	61
	62	p = strchr (p, ',');
	63	if (p != NULL)
	64	p++;
44f2a95d	65	}
112b7c50 AK	66
	67	if (!current_arch_mask)
	68	switch (info->mach)
	69	{
	70	case bfd_mach_s390_31:
	71	current_arch_mask = 1 << S390_OPCODE_ESA;
	72	break;
	73	case bfd_mach_s390_64:
	74	current_arch_mask = 1 << S390_OPCODE_ZARCH;
	75	break;
	76	default:
	77	abort ();
	78	}
	79
a85d7ed0 NC	80	init_flag = 1;
	81	}
	82
	83	/* Extracts an operand value from an instruction. */
	84
	85	static inline unsigned int
47b0e7ad	86	s390_extract_operand (unsigned char insn, const struct s390_operand operand)
a85d7ed0 NC	87	{
	88	unsigned int val;
	89	int bits;
	90
44f2a95d KH	91	/* Extract fragments of the operand byte for byte. */
44f2a95d KH	92	insn += operand->shift / 8;
a85d7ed0 NC	93	bits = (operand->shift & 7) + operand->bits;
a85d7ed0 NC	94	val = 0;
44f2a95d KH	95	do
	96	{
	97	val <<= 8;
	98	val \|= (unsigned int) *insn++;
	99	bits -= 8;
	100	}
	101	while (bits > 0);
a85d7ed0	102	val >>= -bits;
44f2a95d KH	103	val &= ((1U << (operand->bits - 1)) << 1) - 1;
44f2a95d KH	104
bac02689 MS	105	/* Check for special long displacement case. */
	106	if (operand->bits == 20 && operand->shift == 20)
	107	val = (val & 0xff) << 12 \| (val & 0xfff00) >> 8;
	108
44f2a95d KH	109	/* Sign extend value if the operand is signed or pc relative. */
	110	if ((operand->flags & (S390_OPERAND_SIGNED \| S390_OPERAND_PCREL))
	111	&& (val & (1U << (operand->bits - 1))))
	112	val \|= (-1U << (operand->bits - 1)) << 1;
	113
	114	/* Double value if the operand is pc relative. */
a85d7ed0 NC	115	if (operand->flags & S390_OPERAND_PCREL)
a85d7ed0 NC	116	val <<= 1;
44f2a95d	117
47b0e7ad	118	/* Length x in an instructions has real length x + 1. */
a85d7ed0 NC	119	if (operand->flags & S390_OPERAND_LENGTH)
	120	val++;
	121	return val;
	122	}
	123
	124	/* Print a S390 instruction. */
	125
	126	int
47b0e7ad	127	print_insn_s390 (bfd_vma memaddr, struct disassemble_info *info)
a85d7ed0 NC	128	{
	129	bfd_byte buffer[6];
	130	const struct s390_opcode *opcode;
	131	const struct s390_opcode *opcode_end;
	132	unsigned int value;
	133	int status, opsize, bufsize;
	134	char separator;
	135
	136	if (init_flag == 0)
44f2a95d	137	init_disasm (info);
a85d7ed0 NC	138
	139	/* The output looks better if we put 6 bytes on a line. */
	140	info->bytes_per_line = 6;
	141
	142	/* Every S390 instruction is max 6 bytes long. */
44f2a95d	143	memset (buffer, 0, 6);
a85d7ed0	144	status = (*info->read_memory_func) (memaddr, buffer, 6, info);
44f2a95d KH	145	if (status != 0)
	146	{
	147	for (bufsize = 0; bufsize < 6; bufsize++)
	148	if ((*info->read_memory_func) (memaddr, buffer, bufsize + 1, info) != 0)
	149	break;
	150	if (bufsize <= 0)
	151	{
	152	(*info->memory_error_func) (status, memaddr, info);
	153	return -1;
	154	}
	155	/* Opsize calculation looks strange but it works
	156	00xxxxxx -> 2 bytes, 01xxxxxx/10xxxxxx -> 4 bytes,
	157	11xxxxxx -> 6 bytes. */
	158	opsize = ((((buffer[0] >> 6) + 1) >> 1) + 1) << 1;
	159	status = opsize > bufsize;
	160	}
	161	else
	162	{
	163	bufsize = 6;
	164	opsize = ((((buffer[0] >> 6) + 1) >> 1) + 1) << 1;
	165	}
	166
	167	if (status == 0)
	168	{
	169	/* Find the first match in the opcode table. */
	170	opcode_end = s390_opcodes + s390_num_opcodes;
	171	for (opcode = s390_opcodes + opc_index[(int) buffer[0]];
	172	(opcode < opcode_end) && (buffer[0] == opcode->opcode[0]);
	173	opcode++)
	174	{
	175	const struct s390_operand *operand;
	176	const unsigned char *opindex;
	177
	178	/* Check architecture. */
af169f23	179	if (!(opcode->modes & current_arch_mask))
44f2a95d KH	180	continue;
	181	/* Check signature of the opcode. */
	182	if ((buffer[1] & opcode->mask[1]) != opcode->opcode[1]
	183	\|\| (buffer[2] & opcode->mask[2]) != opcode->opcode[2]
	184	\|\| (buffer[3] & opcode->mask[3]) != opcode->opcode[3]
	185	\|\| (buffer[4] & opcode->mask[4]) != opcode->opcode[4]
	186	\|\| (buffer[5] & opcode->mask[5]) != opcode->opcode[5])
	187	continue;
	188
	189	/* The instruction is valid. */
	190	if (opcode->operands[0] != 0)
	191	(*info->fprintf_func) (info->stream, "%s\t", opcode->name);
	192	else
	193	(*info->fprintf_func) (info->stream, "%s", opcode->name);
	194
	195	/* Extract the operands. */
	196	separator = 0;
	197	for (opindex = opcode->operands; *opindex != 0; opindex++)
	198	{
	199	unsigned int value;
	200
	201	operand = s390_operands + *opindex;
	202	value = s390_extract_operand (buffer, operand);
	203
	204	if ((operand->flags & S390_OPERAND_INDEX) && value == 0)
	205	continue;
	206	if ((operand->flags & S390_OPERAND_BASE) &&
	207	value == 0 && separator == '(')
	208	{
	209	separator = ',';
	210	continue;
	211	}
	212
	213	if (separator)
	214	(*info->fprintf_func) (info->stream, "%c", separator);
	215
	216	if (operand->flags & S390_OPERAND_GPR)
	217	(*info->fprintf_func) (info->stream, "%%r%i", value);
	218	else if (operand->flags & S390_OPERAND_FPR)
	219	(*info->fprintf_func) (info->stream, "%%f%i", value);
	220	else if (operand->flags & S390_OPERAND_AR)
	221	(*info->fprintf_func) (info->stream, "%%a%i", value);
	222	else if (operand->flags & S390_OPERAND_CR)
	223	(*info->fprintf_func) (info->stream, "%%c%i", value);
	224	else if (operand->flags & S390_OPERAND_PCREL)
	225	(*info->print_address_func) (memaddr + (int) value, info);
	226	else if (operand->flags & S390_OPERAND_SIGNED)
	227	(*info->fprintf_func) (info->stream, "%i", (int) value);
	228	else
ad101263	229	(*info->fprintf_func) (info->stream, "%u", value);
44f2a95d KH	230
	231	if (operand->flags & S390_OPERAND_DISP)
	232	{
	233	separator = '(';
	234	}
	235	else if (operand->flags & S390_OPERAND_BASE)
	236	{
	237	(*info->fprintf_func) (info->stream, ")");
	238	separator = ',';
	239	}
	240	else
	241	separator = ',';
	242	}
	243
	244	/* Found instruction, printed it, return its size. */
	245	return opsize;
	246	}
	247	/* No matching instruction found, fall through to hex print. */
	248	}
	249
	250	if (bufsize >= 4)
	251	{
	252	value = (unsigned int) buffer[0];
	253	value = (value << 8) + (unsigned int) buffer[1];
	254	value = (value << 8) + (unsigned int) buffer[2];
	255	value = (value << 8) + (unsigned int) buffer[3];
	256	(*info->fprintf_func) (info->stream, ".long\t0x%08x", value);
	257	return 4;
	258	}
	259	else if (bufsize >= 2)
	260	{
	261	value = (unsigned int) buffer[0];
	262	value = (value << 8) + (unsigned int) buffer[1];
	263	(*info->fprintf_func) (info->stream, ".short\t0x%04x", value);
	264	return 2;
a85d7ed0	265	}
44f2a95d KH	266	else
	267	{
	268	value = (unsigned int) buffer[0];
	269	(*info->fprintf_func) (info->stream, ".byte\t0x%02x", value);
	270	return 1;
a85d7ed0	271	}
a85d7ed0	272	}
112b7c50 AK	273
	274	void
	275	print_s390_disassembler_options (FILE *stream)
	276	{
	277	fprintf (stream, _("\n\
	278	The following S/390 specific disassembler options are supported for use\n\
	279	with the -M switch (multiple options should be separated by commas):\n"));
	280
	281	fprintf (stream, _(" esa Disassemble in ESA architecture mode\n"));
	282	fprintf (stream, _(" zarch Disassemble in z/Architecture mode\n"));
	283	}