/src/binutils-gdb/opcodes/kvx-dis.c

Source
/* kvx-dis.c -- Kalray MPPA generic disassembler.
   Copyright (C) 2009-2026 Free Software Foundation, Inc.
   Contributed by Kalray SA.

   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/>.  */

#define STATIC_TABLE
#define DEFINE_TABLE

#include "sysdep.h"
#include "disassemble.h"
#include "libiberty.h"
#include "opintl.h"
#include <assert.h>
#include "elf-bfd.h"
#include "kvx-dis.h"

#include "elf/kvx.h"
#include "opcode/kvx.h"

/* Steering values for the kvx VLIW architecture.  */

typedef enum
{
  Steering_BCU,
  Steering_LSU,
  Steering_MAU,
  Steering_ALU,
  Steering__
} enum_Steering;
typedef uint8_t Steering;

/* BundleIssue enumeration.  */

typedef enum
{
  BundleIssue_BCU,
  BundleIssue_TCA,
  BundleIssue_ALU0,
  BundleIssue_ALU1,
  BundleIssue_MAU,
  BundleIssue_LSU,
  BundleIssue__,
} enum_BundleIssue;
typedef uint8_t BundleIssue;

/* An IMMX syllable is associated with the BundleIssue Extension_BundleIssue[extension].  */
static const BundleIssue Extension_BundleIssue[] = {
  BundleIssue_ALU0,
  BundleIssue_ALU1,
  BundleIssue_MAU,
  BundleIssue_LSU
};

static inline int
kvx_steering (uint32_t x)
{
  return (((x) & 0x60000000) >> 29);
}

static inline int
kvx_extension (uint32_t x)
{
  return (((x) & 0x18000000) >> 27);
}

static inline int
kvx_has_parallel_bit (uint32_t x)
{
  return (((x) & 0x80000000) == 0x80000000);
}

static inline int
kvx_is_tca_opcode (uint32_t x)
{
  unsigned major = ((x) >> 24) & 0x1F;
  return (major > 1) && (major < 8);
}

static inline int
kvx_is_nop_opcode (uint32_t x)
{
  return ((x) << 1) == 0xFFFFFFFE;
}

/* A raw instruction.  */

struct insn_s
{
  uint32_t syllables[KVXMAXSYLLABLES];
  int len;
};
typedef struct insn_s insn_t;


static uint32_t bundle_words[KVXMAXBUNDLEWORDS];

static insn_t bundle_insn[KVXMAXBUNDLEISSUE];

/* A re-interpreted instruction.  */

struct instr_s
{
  int valid;
  int opcode;
  int immx[2];
  int immx_valid[2];
  int immx_count;
  int nb_syllables;
};

/* Option for "pretty printing", ie, not the usual little endian objdump output.  */
static int opt_pretty = 0;
/* Option for not emiting a new line between all bundles.  */
static int opt_compact_assembly = 0;

void
parse_kvx_dis_option (const char *option)
{
  /* Try to match options that are simple flags.  */
  if (startswith (option, "pretty"))
    {
      opt_pretty = 1;
      return;
    }

  if (startswith (option, "compact-assembly"))
    {
      opt_compact_assembly = 1;
      return;
    }

  if (startswith (option, "no-compact-assembly"))
    {
      opt_compact_assembly = 0;
      return;
    }

  /* Invalid option.  */
  opcodes_error_handler (_("unrecognised disassembler option: %s"), option);
}

static void
parse_kvx_dis_options (const char *options)
{
  const char *option_end;

  if (options == NULL)
    return;

  while (*options != '\0')
    {
      /* Skip empty options.  */
      if (*options == ',')
  {
    options++;
    continue;
  }

      /* We know that *options is neither NUL or a comma.  */
      option_end = options + 1;
      while (*option_end != ',' && *option_end != '\0')
  option_end++;

      parse_kvx_dis_option (options);

      /* Go on to the next one.  If option_end points to a comma, it
         will be skipped above.  */
      options = option_end;
    }
}

struct kvx_dis_env
{
  int kvx_arch_size;
  struct kvxopc *opc_table;
  struct kvx_Register *kvx_registers;
  const char ***kvx_modifiers;
  int *kvx_dec_registers;
  int *kvx_regfiles;
  unsigned int kvx_max_dec_registers;
  int initialized_p;
};

static struct kvx_dis_env env = {
  .kvx_arch_size = 0,
  .opc_table = NULL,
  .kvx_registers = NULL,
  .kvx_modifiers = NULL,
  .kvx_dec_registers = NULL,
  .kvx_regfiles = NULL,
  .initialized_p = 0,
  .kvx_max_dec_registers = 0
};

static void
kvx_dis_init (struct disassemble_info *info)
{
  env.kvx_arch_size = 32;
  switch (info->mach)
    {
    case bfd_mach_kv3_1_64:
      env.kvx_arch_size = 64;
      /* fallthrough */
    case bfd_mach_kv3_1_usr:
    case bfd_mach_kv3_1:
    default:
      env.opc_table = kvx_kv3_v1_optab;
      env.kvx_regfiles = kvx_kv3_v1_regfiles;
      env.kvx_registers = kvx_kv3_v1_registers;
      env.kvx_modifiers = kvx_kv3_v1_modifiers;
      env.kvx_dec_registers = kvx_kv3_v1_dec_registers;
      break;
    case bfd_mach_kv3_2_64:
      env.kvx_arch_size = 64;
      /* fallthrough */
    case bfd_mach_kv3_2_usr:
    case bfd_mach_kv3_2:
      env.opc_table = kvx_kv3_v2_optab;
      env.kvx_regfiles = kvx_kv3_v2_regfiles;
      env.kvx_registers = kvx_kv3_v2_registers;
      env.kvx_modifiers = kvx_kv3_v2_modifiers;
      env.kvx_dec_registers = kvx_kv3_v2_dec_registers;
      break;
    case bfd_mach_kv4_1_64:
      env.kvx_arch_size = 64;
      /* fallthrough */
    case bfd_mach_kv4_1_usr:
    case bfd_mach_kv4_1:
      env.opc_table = kvx_kv4_v1_optab;
      env.kvx_regfiles = kvx_kv4_v1_regfiles;
      env.kvx_registers = kvx_kv4_v1_registers;
      env.kvx_modifiers = kvx_kv4_v1_modifiers;
      env.kvx_dec_registers = kvx_kv4_v1_dec_registers;
      break;
    }

  env.kvx_max_dec_registers = env.kvx_regfiles[KVX_REGFILE_DEC_REGISTERS];

  if (info->disassembler_options)
    parse_kvx_dis_options (info->disassembler_options);

  env.initialized_p = 1;
}

static bool
kvx_reassemble_bundle (int wordcount, int *_insncount)
{

  /* Debugging flag.  */
  int debug = 0;

  /* Available resources.  */
  int bcu_taken = 0;
  int tca_taken = 0;
  int alu0_taken = 0;
  int alu1_taken = 0;
  int mau_taken = 0;
  int lsu_taken = 0;

  if (debug)
    fprintf (stderr, "kvx_reassemble_bundle: wordcount = %d\n", wordcount);

  if (wordcount > KVXMAXBUNDLEWORDS)
    {
      if (debug)
  fprintf (stderr, "bundle exceeds maximum size\n");
      return false;
    }

  struct instr_s instr[KVXMAXBUNDLEISSUE];
  memset (instr, 0, sizeof (instr));
  assert (KVXMAXBUNDLEISSUE >= BundleIssue__);

  int i;
  unsigned int j;

  for (i = 0; i < wordcount; i++)
    {
      uint32_t syllable = bundle_words[i];
      switch (kvx_steering (syllable))
  {
  case Steering_BCU:
    /* BCU or TCA instruction.  */
    if (i == 0)
      {
        if (kvx_is_tca_opcode (syllable))
    {
      if (tca_taken)
        {
          if (debug)
      fprintf (stderr, "Too many TCA instructions");
          return false;
        }
      if (debug)
        fprintf (stderr,
           "Syllable 0: Set valid on TCA for instr %d with 0x%x\n",
           BundleIssue_TCA, syllable);
      instr[BundleIssue_TCA].valid = 1;
      instr[BundleIssue_TCA].opcode = syllable;
      instr[BundleIssue_TCA].nb_syllables = 1;
      tca_taken = 1;
    }
        else
    {
      if (debug)
        fprintf (stderr,
           "Syllable 0: Set valid on BCU for instr %d with 0x%x\n",
           BundleIssue_BCU, syllable);

      instr[BundleIssue_BCU].valid = 1;
      instr[BundleIssue_BCU].opcode = syllable;
      instr[BundleIssue_BCU].nb_syllables = 1;
      bcu_taken = 1;
    }
      }
    else
      {
        if (i == 1 && bcu_taken && kvx_is_tca_opcode (syllable))
    {
      if (tca_taken)
        {
          if (debug)
      fprintf (stderr, "Too many TCA instructions");
          return false;
        }
      if (debug)
        fprintf (stderr,
           "Syllable 0: Set valid on TCA for instr %d with 0x%x\n",
           BundleIssue_TCA, syllable);
      instr[BundleIssue_TCA].valid = 1;
      instr[BundleIssue_TCA].opcode = syllable;
      instr[BundleIssue_TCA].nb_syllables = 1;
      tca_taken = 1;
    }
        else
    {
      /* Not first syllable in bundle, IMMX.  */
      struct instr_s *instr_p =
        &(instr[Extension_BundleIssue[kvx_extension (syllable)]]);
      int immx_count = instr_p->immx_count;
      if (immx_count > 1)
        {
          if (debug)
      fprintf (stderr, "Too many IMMX syllables");
          return false;
        }
      instr_p->immx[immx_count] = syllable;
      instr_p->immx_valid[immx_count] = 1;
      instr_p->nb_syllables++;
      if (debug)
        fprintf (stderr,
           "Set IMMX[%d] on instr %d for extension %d @ %d\n",
           immx_count,
           Extension_BundleIssue[kvx_extension (syllable)],
           kvx_extension (syllable), i);
      instr_p->immx_count = immx_count + 1;
    }
      }
    break;

  case Steering_ALU:
    if (alu0_taken == 0)
      {
        if (debug)
    fprintf (stderr, "Set valid on ALU0 for instr %d with 0x%x\n",
       BundleIssue_ALU0, syllable);
        instr[BundleIssue_ALU0].valid = 1;
        instr[BundleIssue_ALU0].opcode = syllable;
        instr[BundleIssue_ALU0].nb_syllables = 1;
        alu0_taken = 1;
      }
    else if (alu1_taken == 0)
      {
        if (debug)
    fprintf (stderr, "Set valid on ALU1 for instr %d with 0x%x\n",
       BundleIssue_ALU1, syllable);
        instr[BundleIssue_ALU1].valid = 1;
        instr[BundleIssue_ALU1].opcode = syllable;
        instr[BundleIssue_ALU1].nb_syllables = 1;
        alu1_taken = 1;
      }
    else if (mau_taken == 0)
      {
        if (debug)
    fprintf (stderr,
       "Set valid on MAU (ALU) for instr %d with 0x%x\n",
       BundleIssue_MAU, syllable);
        instr[BundleIssue_MAU].valid = 1;
        instr[BundleIssue_MAU].opcode = syllable;
        instr[BundleIssue_MAU].nb_syllables = 1;
        mau_taken = 1;
      }
    else if (lsu_taken == 0)
      {
        if (debug)
    fprintf (stderr,
       "Set valid on LSU (ALU) for instr %d with 0x%x\n",
       BundleIssue_LSU, syllable);
        instr[BundleIssue_LSU].valid = 1;
        instr[BundleIssue_LSU].opcode = syllable;
        instr[BundleIssue_LSU].nb_syllables = 1;
        lsu_taken = 1;
      }
    else if (kvx_is_nop_opcode (syllable))
      {
        if (debug)
    fprintf (stderr, "Ignoring NOP (ALU) syllable\n");
      }
    else
      {
        if (debug)
    fprintf (stderr, "Too many ALU instructions");
        return false;
      }
    break;

  case Steering_MAU:
    if (mau_taken == 1)
      {
        if (debug)
    fprintf (stderr, "Too many MAU instructions");
        return false;
      }
    else
      {
        if (debug)
    fprintf (stderr, "Set valid on MAU for instr %d with 0x%x\n",
       BundleIssue_MAU, syllable);
        instr[BundleIssue_MAU].valid = 1;
        instr[BundleIssue_MAU].opcode = syllable;
        instr[BundleIssue_MAU].nb_syllables = 1;
        mau_taken = 1;
      }
    break;

  case Steering_LSU:
    if (lsu_taken == 1)
      {
        if (debug)
    fprintf (stderr, "Too many LSU instructions");
        return false;
      }
    else
      {
        if (debug)
    fprintf (stderr, "Set valid on LSU for instr %d with 0x%x\n",
       BundleIssue_LSU, syllable);
        instr[BundleIssue_LSU].valid = 1;
        instr[BundleIssue_LSU].opcode = syllable;
        instr[BundleIssue_LSU].nb_syllables = 1;
        lsu_taken = 1;
      }
  }
      if (debug)
  fprintf (stderr, "Continue %d < %d?\n", i, wordcount);
    }

  /* Fill bundle_insn and count read syllables.  */
  int instr_idx = 0;
  for (i = 0; i < KVXMAXBUNDLEISSUE; i++)
    {
      if (instr[i].valid == 1)
  {
    int syllable_idx = 0;

    /* First copy opcode.  */
    bundle_insn[instr_idx].syllables[syllable_idx++] = instr[i].opcode;
    bundle_insn[instr_idx].len = 1;

    for (j = 0; j < 2; j++)
      {
        if (instr[i].immx_valid[j])
    {
      if (debug)
        fprintf (stderr, "Instr %d valid immx[%d] is valid\n", i,
           j);
      bundle_insn[instr_idx].syllables[syllable_idx++] =
        instr[i].immx[j];
      bundle_insn[instr_idx].len++;
    }
      }

    if (debug)
      fprintf (stderr,
         "Instr %d valid, copying in bundle_insn (%d syllables <-> %d)\n",
         i, bundle_insn[instr_idx].len, instr[i].nb_syllables);
    instr_idx++;
  }
    }

  if (debug)
    fprintf (stderr, "End => %d instructions\n", instr_idx);

  *_insncount = instr_idx;
  return true;
}

struct decoded_insn
{
  /* The entry in the opc_table. */
  struct kvxopc *opc;
  /* The number of operands.  */
  int nb_ops;
  /* The content of an operands.  */
  struct
  {
    enum
    {
      CAT_REGISTER,
      CAT_MODIFIER,
      CAT_IMMEDIATE,
    } type;
    /* The value of the operands.  */
    uint64_t val;
    /* If it is an immediate, its sign.  */
    int sign;
    /* If it is an immediate, is it pc relative.  */
    int pcrel;
    /* The width of the operand.  */
    int width;
    /* If it is a modifier, the modifier category.
       An index in the modifier table.  */
    int mod_idx;
  } operands[KVXMAXOPERANDS];
};

static int
decode_insn (bfd_vma memaddr, insn_t * insn, struct decoded_insn *res)
{

  int found = 0;
  int idx = 0;
  for (struct kvxopc * op = env.opc_table;
       op->as_op && (((char) op->as_op[0]) != 0); op++)
    {
      /* Find the format of this insn.  */
      int opcode_match = 1;

      if (op->wordcount != insn->len)
  continue;

      for (int i = 0; i < op->wordcount; i++)
  if ((op->codewords[i].mask & insn->syllables[i]) !=
      op->codewords[i].opcode)
    opcode_match = 0;

      int encoding_space_flags = env.kvx_arch_size == 32
  ? kvxOPCODE_FLAG_MODE32 : kvxOPCODE_FLAG_MODE64;

      for (int i = 0; i < op->wordcount; i++)
  if (!(op->codewords[i].flags & encoding_space_flags))
    opcode_match = 0;

      if (opcode_match)
  {
    res->opc = op;

    for (int i = 0; op->format[i]; i++)
      {
        struct kvx_bitfield *bf = op->format[i]->bfield;
        int bf_nb = op->format[i]->bitfields;
        int width = op->format[i]->width;
        int type = op->format[i]->type;
        const char *type_name = op->format[i]->tname;
        int flags = op->format[i]->flags;
        int shift = op->format[i]->shift;
        int bias = op->format[i]->bias;
        uint64_t value = 0;

        for (int bf_idx = 0; bf_idx < bf_nb; bf_idx++)
    {
      int insn_idx = (int) bf[bf_idx].to_offset / 32;
      int to_offset = bf[bf_idx].to_offset % 32;
      uint64_t encoded_value =
        insn->syllables[insn_idx] >> to_offset;
      encoded_value &= (1LL << bf[bf_idx].size) - 1;
      value |= encoded_value << bf[bf_idx].from_offset;
    }
        if (flags & kvxSIGNED)
    {
      uint64_t signbit = 1LL << (width - 1);
      value = (value ^ signbit) - signbit;
    }
        value = (value << shift) + bias;

#define KVX_PRINT_REG(regfile,value) \
    if(env.kvx_regfiles[regfile]+value < env.kvx_max_dec_registers) { \
        res->operands[idx].val = env.kvx_dec_registers[env.kvx_regfiles[regfile]+value]; \
        res->operands[idx].type = CAT_REGISTER; \
  idx++; \
    } else { \
        res->operands[idx].val = ~0; \
        res->operands[idx].type = CAT_REGISTER; \
  idx++; \
    }

        if (env.opc_table == kvx_kv3_v1_optab)
    {
      switch (type)
        {
        case RegClass_kv3_v1_singleReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_GPR, value)
          break;
        case RegClass_kv3_v1_pairedReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_PGR, value)
          break;
        case RegClass_kv3_v1_quadReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_QGR, value)
          break;
        case RegClass_kv3_v1_systemReg:
        case RegClass_kv3_v1_aloneReg:
        case RegClass_kv3_v1_onlyraReg:
        case RegClass_kv3_v1_onlygetReg:
        case RegClass_kv3_v1_onlysetReg:
        case RegClass_kv3_v1_onlyfxReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_SFR, value)
          break;
        case RegClass_kv3_v1_coproReg0M4:
        case RegClass_kv3_v1_coproReg1M4:
        case RegClass_kv3_v1_coproReg2M4:
        case RegClass_kv3_v1_coproReg3M4:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XCR, value)
          break;
        case RegClass_kv3_v1_blockRegE:
        case RegClass_kv3_v1_blockRegO:
        case RegClass_kv3_v1_blockReg0M4:
        case RegClass_kv3_v1_blockReg1M4:
        case RegClass_kv3_v1_blockReg2M4:
        case RegClass_kv3_v1_blockReg3M4:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XBR, value)
          break;
        case RegClass_kv3_v1_vectorReg:
        case RegClass_kv3_v1_vectorRegE:
        case RegClass_kv3_v1_vectorRegO:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XVR, value)
          break;
        case RegClass_kv3_v1_tileReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XTR, value)
          break;
        case RegClass_kv3_v1_matrixReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XMR, value)
          break;
        case Immediate_kv3_v1_sysnumber:
        case Immediate_kv3_v1_signed10:
        case Immediate_kv3_v1_signed16:
        case Immediate_kv3_v1_signed27:
        case Immediate_kv3_v1_wrapped32:
        case Immediate_kv3_v1_signed37:
        case Immediate_kv3_v1_signed43:
        case Immediate_kv3_v1_signed54:
        case Immediate_kv3_v1_wrapped64:
        case Immediate_kv3_v1_unsigned6:
          res->operands[idx].val = value;
          res->operands[idx].sign = flags & kvxSIGNED;
          res->operands[idx].width = width;
          res->operands[idx].type = CAT_IMMEDIATE;
          res->operands[idx].pcrel = 0;
          idx++;
          break;
        case Immediate_kv3_v1_pcrel17:
        case Immediate_kv3_v1_pcrel27:
          res->operands[idx].val = value + memaddr;
          res->operands[idx].sign = flags & kvxSIGNED;
          res->operands[idx].width = width;
          res->operands[idx].type = CAT_IMMEDIATE;
          res->operands[idx].pcrel = 1;
          idx++;
          break;
        case Modifier_kv3_v1_column:
        case Modifier_kv3_v1_comparison:
        case Modifier_kv3_v1_doscale:
        case Modifier_kv3_v1_exunum:
        case Modifier_kv3_v1_floatcomp:
        case Modifier_kv3_v1_qindex:
        case Modifier_kv3_v1_rectify:
        case Modifier_kv3_v1_rounding:
        case Modifier_kv3_v1_roundint:
        case Modifier_kv3_v1_saturate:
        case Modifier_kv3_v1_scalarcond:
        case Modifier_kv3_v1_silent:
        case Modifier_kv3_v1_simplecond:
        case Modifier_kv3_v1_speculate:
        case Modifier_kv3_v1_splat32:
        case Modifier_kv3_v1_variant:
          {
      int sz = 0;
      int mod_idx = type - Modifier_kv3_v1_column;
      for (sz = 0; env.kvx_modifiers[mod_idx][sz]; ++sz);
      const char *mod = value < (unsigned) sz
        ? env.kvx_modifiers[mod_idx][value] : NULL;
      if (!mod) goto retry;
      res->operands[idx].val = value;
      res->operands[idx].type = CAT_MODIFIER;
      res->operands[idx].mod_idx = mod_idx;
      idx++;
          }
          break;
        default:
          fprintf (stderr, "error: unexpected operand type (%s)\n",
             type_name);
          exit (-1);
        };
    }
        else if (env.opc_table == kvx_kv3_v2_optab)
    {
      switch (type)
        {
        case RegClass_kv3_v2_singleReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_GPR, value)
          break;
        case RegClass_kv3_v2_pairedReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_PGR, value)
          break;
        case RegClass_kv3_v2_quadReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_QGR, value)
          break;
        case RegClass_kv3_v2_systemReg:
        case RegClass_kv3_v2_aloneReg:
        case RegClass_kv3_v2_onlyraReg:
        case RegClass_kv3_v2_onlygetReg:
        case RegClass_kv3_v2_onlysetReg:
        case RegClass_kv3_v2_onlyfxReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_SFR, value)
          break;
        case RegClass_kv3_v2_coproReg:
        case RegClass_kv3_v2_coproReg0M4:
        case RegClass_kv3_v2_coproReg1M4:
        case RegClass_kv3_v2_coproReg2M4:
        case RegClass_kv3_v2_coproReg3M4:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XCR, value)
          break;
        case RegClass_kv3_v2_blockReg:
        case RegClass_kv3_v2_blockRegE:
        case RegClass_kv3_v2_blockRegO:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XBR, value)
          break;
        case RegClass_kv3_v2_vectorReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XVR, value)
          break;
        case RegClass_kv3_v2_tileReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XTR, value)
          break;
        case RegClass_kv3_v2_matrixReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XMR, value)
          break;
        case RegClass_kv3_v2_buffer2Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X2R, value)
          break;
        case RegClass_kv3_v2_buffer4Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X4R, value)
          break;
        case RegClass_kv3_v2_buffer8Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X8R, value)
          break;
        case RegClass_kv3_v2_buffer16Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X16R, value)
          break;
        case RegClass_kv3_v2_buffer32Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X32R, value)
          break;
        case RegClass_kv3_v2_buffer64Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X64R, value)
          break;
        case Immediate_kv3_v2_brknumber:
        case Immediate_kv3_v2_sysnumber:
        case Immediate_kv3_v2_signed10:
        case Immediate_kv3_v2_signed16:
        case Immediate_kv3_v2_signed27:
        case Immediate_kv3_v2_wrapped32:
        case Immediate_kv3_v2_signed37:
        case Immediate_kv3_v2_signed43:
        case Immediate_kv3_v2_signed54:
        case Immediate_kv3_v2_wrapped64:
        case Immediate_kv3_v2_unsigned6:
          res->operands[idx].val = value;
          res->operands[idx].sign = flags & kvxSIGNED;
          res->operands[idx].width = width;
          res->operands[idx].type = CAT_IMMEDIATE;
          res->operands[idx].pcrel = 0;
          idx++;
          break;
        case Immediate_kv3_v2_pcrel27:
        case Immediate_kv3_v2_pcrel17:
          res->operands[idx].val = value + memaddr;
          res->operands[idx].sign = flags & kvxSIGNED;
          res->operands[idx].width = width;
          res->operands[idx].type = CAT_IMMEDIATE;
          res->operands[idx].pcrel = 1;
          idx++;
          break;
        case Modifier_kv3_v2_accesses:
        case Modifier_kv3_v2_boolcas:
        case Modifier_kv3_v2_cachelev:
        case Modifier_kv3_v2_channel:
        case Modifier_kv3_v2_coherency:
        case Modifier_kv3_v2_comparison:
        case Modifier_kv3_v2_conjugate:
        case Modifier_kv3_v2_doscale:
        case Modifier_kv3_v2_exunum:
        case Modifier_kv3_v2_floatcomp:
        case Modifier_kv3_v2_hindex:
        case Modifier_kv3_v2_lsomask:
        case Modifier_kv3_v2_lsumask:
        case Modifier_kv3_v2_lsupack:
        case Modifier_kv3_v2_qindex:
        case Modifier_kv3_v2_rounding:
        case Modifier_kv3_v2_scalarcond:
        case Modifier_kv3_v2_shuffleV:
        case Modifier_kv3_v2_shuffleX:
        case Modifier_kv3_v2_silent:
        case Modifier_kv3_v2_simplecond:
        case Modifier_kv3_v2_speculate:
        case Modifier_kv3_v2_splat32:
        case Modifier_kv3_v2_transpose:
        case Modifier_kv3_v2_variant:
          {
      int sz = 0;
      int mod_idx = type - Modifier_kv3_v2_accesses;
      for (sz = 0; env.kvx_modifiers[mod_idx][sz];
           ++sz);
      const char *mod = value < (unsigned) sz
        ? env.kvx_modifiers[mod_idx][value] : NULL;
      if (!mod) goto retry;
      res->operands[idx].val = value;
      res->operands[idx].type = CAT_MODIFIER;
      res->operands[idx].mod_idx = mod_idx;
      idx++;
          };
          break;
        default:
          fprintf (stderr,
             "error: unexpected operand type (%s)\n",
             type_name);
          exit (-1);
        };
    }
        else if (env.opc_table == kvx_kv4_v1_optab)
    {
      switch (type)
        {

        case RegClass_kv4_v1_singleReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_GPR, value)
          break;
        case RegClass_kv4_v1_pairedReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_PGR, value)
          break;
        case RegClass_kv4_v1_quadReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_QGR, value)
          break;
        case RegClass_kv4_v1_systemReg:
        case RegClass_kv4_v1_aloneReg:
        case RegClass_kv4_v1_onlyraReg:
        case RegClass_kv4_v1_onlygetReg:
        case RegClass_kv4_v1_onlysetReg:
        case RegClass_kv4_v1_onlyfxReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_SFR, value)
          break;
        case RegClass_kv4_v1_coproReg:
        case RegClass_kv4_v1_coproReg0M4:
        case RegClass_kv4_v1_coproReg1M4:
        case RegClass_kv4_v1_coproReg2M4:
        case RegClass_kv4_v1_coproReg3M4:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XCR, value)
          break;
        case RegClass_kv4_v1_blockReg:
        case RegClass_kv4_v1_blockRegE:
        case RegClass_kv4_v1_blockRegO:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XBR, value)
          break;
        case RegClass_kv4_v1_vectorReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XVR, value)
          break;
        case RegClass_kv4_v1_tileReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XTR, value)
          break;
        case RegClass_kv4_v1_matrixReg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_XMR, value)
          break;
        case RegClass_kv4_v1_buffer2Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X2R, value)
          break;
        case RegClass_kv4_v1_buffer4Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X4R, value)
          break;
        case RegClass_kv4_v1_buffer8Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X8R, value)
          break;
        case RegClass_kv4_v1_buffer16Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X16R, value)
          break;
        case RegClass_kv4_v1_buffer32Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X32R, value)
          break;
        case RegClass_kv4_v1_buffer64Reg:
          KVX_PRINT_REG (KVX_REGFILE_DEC_X64R, value)
          break;
        case Immediate_kv4_v1_brknumber:
        case Immediate_kv4_v1_sysnumber:
        case Immediate_kv4_v1_signed10:
        case Immediate_kv4_v1_signed16:
        case Immediate_kv4_v1_signed27:
        case Immediate_kv4_v1_wrapped32:
        case Immediate_kv4_v1_signed37:
        case Immediate_kv4_v1_signed43:
        case Immediate_kv4_v1_signed54:
        case Immediate_kv4_v1_wrapped64:
        case Immediate_kv4_v1_unsigned6:
          res->operands[idx].val = value;
          res->operands[idx].sign = flags & kvxSIGNED;
          res->operands[idx].width = width;
          res->operands[idx].type = CAT_IMMEDIATE;
          res->operands[idx].pcrel = 0;
          idx++;
          break;
        case Immediate_kv4_v1_pcrel27:
        case Immediate_kv4_v1_pcrel17:
          res->operands[idx].val = value + memaddr;
          res->operands[idx].sign = flags & kvxSIGNED;
          res->operands[idx].width = width;
          res->operands[idx].type = CAT_IMMEDIATE;
          res->operands[idx].pcrel = 1;
          idx++;
          break;
        case Modifier_kv4_v1_accesses:
        case Modifier_kv4_v1_boolcas:
        case Modifier_kv4_v1_cachelev:
        case Modifier_kv4_v1_channel:
        case Modifier_kv4_v1_coherency:
        case Modifier_kv4_v1_comparison:
        case Modifier_kv4_v1_conjugate:
        case Modifier_kv4_v1_doscale:
        case Modifier_kv4_v1_exunum:
        case Modifier_kv4_v1_floatcomp:
        case Modifier_kv4_v1_hindex:
        case Modifier_kv4_v1_lsomask:
        case Modifier_kv4_v1_lsumask:
        case Modifier_kv4_v1_lsupack:
        case Modifier_kv4_v1_qindex:
        case Modifier_kv4_v1_rounding:
        case Modifier_kv4_v1_scalarcond:
        case Modifier_kv4_v1_shuffleV:
        case Modifier_kv4_v1_shuffleX:
        case Modifier_kv4_v1_silent:
        case Modifier_kv4_v1_simplecond:
        case Modifier_kv4_v1_speculate:
        case Modifier_kv4_v1_splat32:
        case Modifier_kv4_v1_transpose:
        case Modifier_kv4_v1_variant:
          {
      int sz = 0;
      int mod_idx = type - Modifier_kv4_v1_accesses;
      for (sz = 0; env.kvx_modifiers[mod_idx][sz]; ++sz);
      const char *mod = value < (unsigned) sz
        ? env.kvx_modifiers[mod_idx][value] : NULL;
      if (!mod) goto retry;
      res->operands[idx].val = value;
      res->operands[idx].type = CAT_MODIFIER;
      res->operands[idx].mod_idx = mod_idx;
      idx++;
          }
          break;
        default:
          fprintf (stderr, "error: unexpected operand type (%s)\n",
             type_name);
          exit (-1);
        };
    }

#undef KVX_PRINT_REG
      }

    found = 1;
    break;
  retry:;
    idx = 0;
    continue;
  }
 }
  res->nb_ops = idx;
  return found;
}

int
print_insn_kvx (bfd_vma memaddr, struct disassemble_info *info)
{
  static int insnindex = 0;
  static int insncount = 0;
  insn_t *insn;
  int readsofar = 0;
  int found = 0;
  int invalid_bundle = 0;

  if (!env.initialized_p)
    kvx_dis_init (info);

  /* Clear instruction information field.  */
  info->insn_info_valid = 0;
  info->branch_delay_insns = 0;
  info->data_size = 0;
  info->insn_type = dis_noninsn;
  info->target = 0;
  info->target2 = 0;

  /* Set line length.  */
  info->bytes_per_line = 16;


  /* If this is the beginning of the bundle, read BUNDLESIZE words and apply
     decentrifugate function.  */
  if (insnindex == 0)
    {
      int wordcount;
      for (wordcount = 0; wordcount < KVXMAXBUNDLEWORDS; wordcount++)
  {
    int status;
    status =
      (*info->read_memory_func) (memaddr + 4 * wordcount,
               (bfd_byte *) (bundle_words +
                 wordcount), 4, info);
    if (status != 0)
      {
        (*info->memory_error_func) (status, memaddr + 4 * wordcount,
            info);
        return -1;
      }
    if (!kvx_has_parallel_bit (bundle_words[wordcount]))
      break;
  }
      wordcount++;
      invalid_bundle = !kvx_reassemble_bundle (wordcount, &insncount);
    }

  assert (insnindex < KVXMAXBUNDLEISSUE);
  insn = &(bundle_insn[insnindex]);
  readsofar = insn->len * 4;
  insnindex++;

  if (opt_pretty)
    {
      (*info->fprintf_func) (info->stream, "[ ");
      for (int i = 0; i < insn->len; i++)
  (*info->fprintf_func) (info->stream, "%08x ", insn->syllables[i]);
      (*info->fprintf_func) (info->stream, "] ");
    }

  /* Check for extension to right iff this is not the end of bundle.  */

  struct decoded_insn dec;
  memset (&dec, 0, sizeof dec);
  if (!invalid_bundle && (found = decode_insn (memaddr, insn, &dec)))
    {
      int ch;
      (*info->fprintf_func) (info->stream, "%s", dec.opc->as_op);
      const char *fmtp = dec.opc->fmtstring;
      for (int i = 0; i < dec.nb_ops; ++i)
  {
    /* Print characters in the format string up to the following % or nul.  */
    while ((ch = *fmtp) && ch != '%')
      {
        (*info->fprintf_func) (info->stream, "%c", ch);
        fmtp++;
      }

    /* Skip past %s.  */
    if (ch == '%')
      {
        ch = *fmtp++;
        fmtp++;
      }

    switch (dec.operands[i].type)
      {
      case CAT_REGISTER:
        (*info->fprintf_func) (info->stream, "%s",
             env.kvx_registers[dec.operands[i].val].name);
        break;
      case CAT_MODIFIER:
        {
    const char *mod = env.kvx_modifiers[dec.operands[i].mod_idx][dec.operands[i].val];
    (*info->fprintf_func) (info->stream, "%s", !mod || !strcmp (mod, ".") ? "" : mod);
        }
        break;
      case CAT_IMMEDIATE:
        {
    if (dec.operands[i].pcrel)
      {
        /* Fill in instruction information.  */
        info->insn_info_valid = 1;
        info->insn_type =
          dec.operands[i].width ==
          17 ? dis_condbranch : dis_branch;
        info->target = dec.operands[i].val;

        info->print_address_func (dec.operands[i].val, info);
      }
    else if (dec.operands[i].sign)
      {
        if (dec.operands[i].width <= 32)
          {
      (*info->fprintf_func) (info->stream, "%" PRId32 " (0x%" PRIx32 ")",
                 (int32_t) dec.operands[i].val,
                 (int32_t) dec.operands[i].val);
          }
        else
          {
      (*info->fprintf_func) (info->stream, "%" PRId64 " (0x%" PRIx64 ")",
                 dec.operands[i].val,
                 dec.operands[i].val);
          }
      }
    else
      {
        if (dec.operands[i].width <= 32)
          {
      (*info->fprintf_func) (info->stream, "%" PRIu32 " (0x%" PRIx32 ")",
                 (uint32_t) dec.operands[i].
                 val,
                 (uint32_t) dec.operands[i].
                 val);
          }
        else
          {
      (*info->fprintf_func) (info->stream, "%" PRIu64 " (0x%" PRIx64 ")",
                 (uint64_t) dec.
                 operands[i].val,
                 (uint64_t) dec.
                 operands[i].val);
          }
      }
        }
        break;
      default:
        break;

      }
  }

      while ((ch = *fmtp))
  {
    (*info->fprintf_styled_func) (info->stream, dis_style_text, "%c",
          ch);
    fmtp++;
  }
    }
  else
    {
      (*info->fprintf_func) (info->stream, "*** invalid opcode ***\n");
      insnindex = 0;
      readsofar = 4;
    }

  if (found && (insnindex == insncount))
    {
      (*info->fprintf_func) (info->stream, ";;");
      if (!opt_compact_assembly)
  (*info->fprintf_func) (info->stream, "\n");
      insnindex = 0;
    }

  return readsofar;
}

/* This function searches in the current bundle for the instructions required
   by unwinding. For prologue:
     (1) addd $r12 = $r12, <res_stack>
     (2) get <gpr_ra_reg> = $ra
     (3) sd <ofs>[$r12] = <gpr_ra_reg> or sq/so containing <gpr_ra_reg>
     (4) sd <ofs>[$r12] = $r14 or sq/so containing r14
     (5) addd $r14 = $r12, <fp_ofs> or copyd $r14 = $r12
   The only difference seen between the code generated by gcc and clang
   is the setting/resetting r14. gcc could also generate copyd $r14=$r12
   instead of add addd $r14 = $r12, <ofs> when <ofs> is 0.
   Vice-versa, <ofs> is not guaranteed to be 0 for clang, so, clang
   could also generate addd instead of copyd
     (6) call, icall, goto, igoto, cb., ret
  For epilogue:
     (1) addd $r12 = $r12, <res_stack>
     (2) addd $r12 = $r14, <offset> or copyd $r12 = $r14
   Same comment as prologue (5).
     (3) ret, goto
     (4) call, icall, igoto, cb.  */

int
decode_prologue_epilogue_bundle (bfd_vma memaddr,
         struct disassemble_info *info,
         struct kvx_prologue_epilogue_bundle *peb)
{
  int i, nb_insn, nb_syl;

  peb->nb_insn = 0;

  if (info->arch != bfd_arch_kvx)
    return -1;

  if (!env.initialized_p)
    kvx_dis_init (info);

  /* Read the bundle.  */
  for (nb_syl = 0; nb_syl < KVXMAXBUNDLEWORDS; nb_syl++)
    {
      if ((*info->read_memory_func) (memaddr + 4 * nb_syl,
             (bfd_byte *) &bundle_words[nb_syl], 4,
             info))
  return -1;
      if (!kvx_has_parallel_bit (bundle_words[nb_syl]))
  break;
    }
  nb_syl++;
  if (!kvx_reassemble_bundle (nb_syl, &nb_insn))
    return -1;

  /* Check for extension to right if this is not the end of bundle
     find the format of this insn.  */
  for (int idx_insn = 0; idx_insn < nb_insn; idx_insn++)
    {
      insn_t *insn = &bundle_insn[idx_insn];
      int is_add = 0, is_get = 0, is_a_peb_insn = 0, is_copyd = 0;

      struct decoded_insn dec;
      memset (&dec, 0, sizeof dec);
      if (!decode_insn (memaddr, insn, &dec))
  continue;

      const char *op_name = dec.opc->as_op;
      struct kvx_prologue_epilogue_insn *crt_peb_insn;

      crt_peb_insn = &peb->insn[peb->nb_insn];
      crt_peb_insn->nb_gprs = 0;

      if (!strcmp (op_name, "addd"))
  is_add = 1;
      else if (!strcmp (op_name, "copyd"))
  is_copyd = 1;
      else if (!strcmp (op_name, "get"))
  is_get = 1;
      else if (!strcmp (op_name, "sd"))
  {
    crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_SD;
    is_a_peb_insn = 1;
  }
      else if (!strcmp (op_name, "sq"))
  {
    crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_SQ;
    is_a_peb_insn = 1;
  }
      else if (!strcmp (op_name, "so"))
  {
    crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_SO;
    is_a_peb_insn = 1;
  }
      else if (!strcmp (op_name, "ret"))
  {
    crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_RET;
    is_a_peb_insn = 1;
  }
      else if (!strcmp (op_name, "goto"))
  {
    crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_GOTO;
    is_a_peb_insn = 1;
  }
      else if (!strcmp (op_name, "igoto"))
  {
    crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_IGOTO;
    is_a_peb_insn = 1;
  }
      else if (!strcmp (op_name, "call") || !strcmp (op_name, "icall"))
  {
    crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_CALL;
    is_a_peb_insn = 1;
  }
      else if (!strncmp (op_name, "cb", 2))
  {
    crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_CB;
    is_a_peb_insn = 1;
  }
      else
  continue;

      for (i = 0; dec.opc->format[i]; i++)
  {
    struct kvx_operand *fmt = dec.opc->format[i];
    struct kvx_bitfield *bf = fmt->bfield;
    int bf_nb = fmt->bitfields;
    int width = fmt->width;
    int type = fmt->type;
    int flags = fmt->flags;
    int shift = fmt->shift;
    int bias = fmt->bias;
    uint64_t encoded_value, value = 0;

    for (int bf_idx = 0; bf_idx < bf_nb; bf_idx++)
      {
        int insn_idx = (int) bf[bf_idx].to_offset / 32;
        int to_offset = bf[bf_idx].to_offset % 32;
        encoded_value = insn->syllables[insn_idx] >> to_offset;
        encoded_value &= (1LL << bf[bf_idx].size) - 1;
        value |= encoded_value << bf[bf_idx].from_offset;
      }
    if (flags & kvxSIGNED)
      {
        uint64_t signbit = 1LL << (width - 1);
        value = (value ^ signbit) - signbit;
      }
    value = (value << shift) + bias;

#define chk_type(core_, val_) \
      (env.opc_table == kvx_## core_ ##_optab && type == (val_))

    if (chk_type (kv3_v1, RegClass_kv3_v1_singleReg)
        || chk_type (kv3_v2, RegClass_kv3_v2_singleReg)
        || chk_type (kv4_v1, RegClass_kv4_v1_singleReg))
      {
        if (env.kvx_regfiles[KVX_REGFILE_DEC_GPR] + value
      >= env.kvx_max_dec_registers)
    return -1;
        if (is_add && i < 2)
    {
      if (i == 0)
        {
          if (value == KVX_GPR_REG_SP)
      crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_ADD_SP;
          else if (value == KVX_GPR_REG_FP)
      crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_ADD_FP;
          else
      is_add = 0;
        }
      else if (i == 1)
        {
          if (value == KVX_GPR_REG_SP)
      is_a_peb_insn = 1;
          else if (value == KVX_GPR_REG_FP
             && crt_peb_insn->insn_type
             == KVX_PROL_EPIL_INSN_ADD_SP)
      {
        crt_peb_insn->insn_type
          = KVX_PROL_EPIL_INSN_RESTORE_SP_FROM_FP;
        is_a_peb_insn = 1;
      }
          else
      is_add = 0;
        }
    }
        else if (is_copyd && i < 2)
    {
      if (i == 0)
        {
          if (value == KVX_GPR_REG_FP)
      {
        crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_ADD_FP;
        crt_peb_insn->immediate = 0;
      }
          else if (value == KVX_GPR_REG_SP)
      {
        crt_peb_insn->insn_type
          = KVX_PROL_EPIL_INSN_RESTORE_SP_FROM_FP;
        crt_peb_insn->immediate = 0;
      }
          else
      is_copyd = 0;
        }
      else if (i == 1)
        {
          if (value == KVX_GPR_REG_SP
        && crt_peb_insn->insn_type
        == KVX_PROL_EPIL_INSN_ADD_FP)
      is_a_peb_insn = 1;
          else if (value == KVX_GPR_REG_FP
             && crt_peb_insn->insn_type
             == KVX_PROL_EPIL_INSN_RESTORE_SP_FROM_FP)
      is_a_peb_insn = 1;
          else
      is_copyd = 0;
        }
    }
        else
    crt_peb_insn->gpr_reg[crt_peb_insn->nb_gprs++] = value;
      }
    else if (chk_type (kv3_v1, RegClass_kv3_v1_pairedReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_pairedReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_pairedReg))
      crt_peb_insn->gpr_reg[crt_peb_insn->nb_gprs++] = value * 2;
    else if (chk_type (kv3_v1, RegClass_kv3_v1_quadReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_quadReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_quadReg))
      crt_peb_insn->gpr_reg[crt_peb_insn->nb_gprs++] = value * 4;
    else if (chk_type (kv3_v1, RegClass_kv3_v1_systemReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_systemReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_systemReg)
       || chk_type (kv3_v1, RegClass_kv3_v1_aloneReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_aloneReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_aloneReg)
       || chk_type (kv3_v1, RegClass_kv3_v1_onlyraReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_onlyraReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_onlygetReg)
       || chk_type (kv3_v1, RegClass_kv3_v1_onlygetReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_onlygetReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_onlygetReg)
       || chk_type (kv3_v1, RegClass_kv3_v1_onlysetReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_onlysetReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_onlysetReg)
       || chk_type (kv3_v1, RegClass_kv3_v1_onlyfxReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_onlyfxReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_onlyfxReg))
      {
        if (env.kvx_regfiles[KVX_REGFILE_DEC_GPR] + value
      >= env.kvx_max_dec_registers)
    return -1;
        if (is_get && !strcmp (env.kvx_registers[env.kvx_dec_registers[env.kvx_regfiles[KVX_REGFILE_DEC_SFR] + value]].name, "$ra"))
    {
      crt_peb_insn->insn_type = KVX_PROL_EPIL_INSN_GET_RA;
      is_a_peb_insn = 1;
    }
      }
    else if (chk_type (kv3_v1, RegClass_kv3_v1_coproReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_coproReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_coproReg)
       || chk_type (kv3_v1, RegClass_kv3_v1_blockReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_blockReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_blockReg)
       || chk_type (kv3_v1, RegClass_kv3_v1_vectorReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_vectorReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_vectorReg)
       || chk_type (kv3_v1, RegClass_kv3_v1_tileReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_tileReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_tileReg)
       || chk_type (kv3_v1, RegClass_kv3_v1_matrixReg)
       || chk_type (kv3_v2, RegClass_kv3_v2_matrixReg)
       || chk_type (kv4_v1, RegClass_kv4_v1_matrixReg)
       || chk_type (kv3_v1, Modifier_kv3_v1_scalarcond)
       || chk_type (kv3_v1, Modifier_kv3_v1_column)
       || chk_type (kv3_v1, Modifier_kv3_v1_comparison)
       || chk_type (kv3_v1, Modifier_kv3_v1_doscale)
       || chk_type (kv3_v1, Modifier_kv3_v1_exunum)
       || chk_type (kv3_v1, Modifier_kv3_v1_floatcomp)
       || chk_type (kv3_v1, Modifier_kv3_v1_qindex)
       || chk_type (kv3_v1, Modifier_kv3_v1_rectify)
       || chk_type (kv3_v1, Modifier_kv3_v1_rounding)
       || chk_type (kv3_v1, Modifier_kv3_v1_roundint)
       || chk_type (kv3_v1, Modifier_kv3_v1_saturate)
       || chk_type (kv3_v1, Modifier_kv3_v1_scalarcond)
       || chk_type (kv3_v1, Modifier_kv3_v1_silent)
       || chk_type (kv3_v1, Modifier_kv3_v1_simplecond)
       || chk_type (kv3_v1, Modifier_kv3_v1_speculate)
       || chk_type (kv3_v1, Modifier_kv3_v1_splat32)
       || chk_type (kv3_v1, Modifier_kv3_v1_variant)
       || chk_type (kv3_v2, Modifier_kv3_v2_accesses)
       || chk_type (kv3_v2, Modifier_kv3_v2_boolcas)
       || chk_type (kv3_v2, Modifier_kv3_v2_cachelev)
       || chk_type (kv3_v2, Modifier_kv3_v2_channel)
       || chk_type (kv3_v2, Modifier_kv3_v2_coherency)
       || chk_type (kv3_v2, Modifier_kv3_v2_comparison)
       || chk_type (kv3_v2, Modifier_kv3_v2_conjugate)
       || chk_type (kv3_v2, Modifier_kv3_v2_doscale)
       || chk_type (kv3_v2, Modifier_kv3_v2_exunum)
       || chk_type (kv3_v2, Modifier_kv3_v2_floatcomp)
       || chk_type (kv3_v2, Modifier_kv3_v2_hindex)
       || chk_type (kv3_v2, Modifier_kv3_v2_lsomask)
       || chk_type (kv3_v2, Modifier_kv3_v2_lsumask)
       || chk_type (kv3_v2, Modifier_kv3_v2_lsupack)
       || chk_type (kv3_v2, Modifier_kv3_v2_qindex)
       || chk_type (kv3_v2, Modifier_kv3_v2_rounding)
       || chk_type (kv3_v2, Modifier_kv3_v2_scalarcond)
       || chk_type (kv3_v2, Modifier_kv3_v2_shuffleV)
       || chk_type (kv3_v2, Modifier_kv3_v2_shuffleX)
       || chk_type (kv3_v2, Modifier_kv3_v2_silent)
       || chk_type (kv3_v2, Modifier_kv3_v2_simplecond)
       || chk_type (kv3_v2, Modifier_kv3_v2_speculate)
       || chk_type (kv3_v2, Modifier_kv3_v2_splat32)
       || chk_type (kv3_v2, Modifier_kv3_v2_transpose)
       || chk_type (kv3_v2, Modifier_kv3_v2_variant)
       || chk_type (kv4_v1, Modifier_kv4_v1_accesses)
       || chk_type (kv4_v1, Modifier_kv4_v1_boolcas)
       || chk_type (kv4_v1, Modifier_kv4_v1_cachelev)
       || chk_type (kv4_v1, Modifier_kv4_v1_channel)
       || chk_type (kv4_v1, Modifier_kv4_v1_coherency)
       || chk_type (kv4_v1, Modifier_kv4_v1_comparison)
       || chk_type (kv4_v1, Modifier_kv4_v1_conjugate)
       || chk_type (kv4_v1, Modifier_kv4_v1_doscale)
       || chk_type (kv4_v1, Modifier_kv4_v1_exunum)
       || chk_type (kv4_v1, Modifier_kv4_v1_floatcomp)
       || chk_type (kv4_v1, Modifier_kv4_v1_hindex)
       || chk_type (kv4_v1, Modifier_kv4_v1_lsomask)
       || chk_type (kv4_v1, Modifier_kv4_v1_lsumask)
       || chk_type (kv4_v1, Modifier_kv4_v1_lsupack)
       || chk_type (kv4_v1, Modifier_kv4_v1_qindex)
       || chk_type (kv4_v1, Modifier_kv4_v1_rounding)
       || chk_type (kv4_v1, Modifier_kv4_v1_scalarcond)
       || chk_type (kv4_v1, Modifier_kv4_v1_shuffleV)
       || chk_type (kv4_v1, Modifier_kv4_v1_shuffleX)
       || chk_type (kv4_v1, Modifier_kv4_v1_silent)
       || chk_type (kv4_v1, Modifier_kv4_v1_simplecond)
       || chk_type (kv4_v1, Modifier_kv4_v1_speculate)
       || chk_type (kv4_v1, Modifier_kv4_v1_splat32)
       || chk_type (kv4_v1, Modifier_kv4_v1_transpose)
       || chk_type (kv4_v1, Modifier_kv4_v1_variant))
      {
        /* Do nothing.  */
      }
    else if (chk_type (kv3_v1, Immediate_kv3_v1_sysnumber)
       || chk_type (kv3_v2, Immediate_kv3_v2_sysnumber)
       || chk_type (kv4_v1, Immediate_kv4_v1_sysnumber)
       || chk_type (kv3_v2, Immediate_kv3_v2_wrapped8)
       || chk_type (kv4_v1, Immediate_kv4_v1_wrapped8)
       || chk_type (kv3_v1, Immediate_kv3_v1_signed10)
       || chk_type (kv3_v2, Immediate_kv3_v2_signed10)
       || chk_type (kv4_v1, Immediate_kv4_v1_signed10)
       || chk_type (kv3_v1, Immediate_kv3_v1_signed16)
       || chk_type (kv3_v2, Immediate_kv3_v2_signed16)
       || chk_type (kv4_v1, Immediate_kv4_v1_signed16)
       || chk_type (kv3_v1, Immediate_kv3_v1_signed27)
       || chk_type (kv3_v2, Immediate_kv3_v2_signed27)
       || chk_type (kv4_v1, Immediate_kv4_v1_signed27)
       || chk_type (kv3_v1, Immediate_kv3_v1_wrapped32)
       || chk_type (kv3_v2, Immediate_kv3_v2_wrapped32)
       || chk_type (kv4_v1, Immediate_kv4_v1_wrapped32)
       || chk_type (kv3_v1, Immediate_kv3_v1_signed37)
       || chk_type (kv3_v2, Immediate_kv3_v2_signed37)
       || chk_type (kv4_v1, Immediate_kv4_v1_signed37)
       || chk_type (kv3_v1, Immediate_kv3_v1_signed43)
       || chk_type (kv3_v2, Immediate_kv3_v2_signed43)
       || chk_type (kv4_v1, Immediate_kv4_v1_signed43)
       || chk_type (kv3_v1, Immediate_kv3_v1_signed54)
       || chk_type (kv3_v2, Immediate_kv3_v2_signed54)
       || chk_type (kv4_v1, Immediate_kv4_v1_signed54)
       || chk_type (kv3_v1, Immediate_kv3_v1_wrapped64)
       || chk_type (kv3_v2, Immediate_kv3_v2_wrapped64)
       || chk_type (kv4_v1, Immediate_kv4_v1_wrapped64)
       || chk_type (kv3_v1, Immediate_kv3_v1_unsigned6)
       || chk_type (kv3_v2, Immediate_kv3_v2_unsigned6)
       || chk_type (kv4_v1, Immediate_kv4_v1_unsigned6))
      crt_peb_insn->immediate = value;
    else if (chk_type (kv3_v1, Immediate_kv3_v1_pcrel17)
       || chk_type (kv3_v2, Immediate_kv3_v2_pcrel17)
       || chk_type (kv4_v1, Immediate_kv4_v1_pcrel17)
       || chk_type (kv3_v1, Immediate_kv3_v1_pcrel27)
       || chk_type (kv3_v2, Immediate_kv3_v2_pcrel27)
       || chk_type (kv4_v1, Immediate_kv4_v1_pcrel27))
      crt_peb_insn->immediate = value + memaddr;
    else
      return -1;
  }

      if (is_a_peb_insn)
  peb->nb_insn++;
      continue;
    }

  return nb_syl * 4;
#undef chk_type
}

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

  fprintf (stream, _("\n\
  pretty               Print 32-bit words in natural order corresponding to \
re-ordered instruction.\n"));

  fprintf (stream, _("\n\
  compact-assembly     Do not emit a new line between bundles of instructions.\
\n"));

  fprintf (stream, _("\n\
  no-compact-assembly  Emit a new line between bundles of instructions.\n"));

  fprintf (stream, _("\n"));
}

Coverage Report

Created: 2026-07-12 09:22