WebSVN – Kolibri OS – Diff – /contrib/toolchain/binutils/include/opcode/tilegx.h


/* TILE-Gx opcode information.
 *
 *    Copyright (C) 2011-2015 Free Software Foundation, Inc.
 *
 *    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, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
 *    MA 02110-1301, USA.
 */
 
#ifndef opcode_tile_h
#define opcode_tile_h
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef unsigned long long tilegx_bundle_bits;
 
 
enum
{
  TILEGX_MAX_OPERANDS = 4 /* bfexts */
};
 
typedef enum
{
  TILEGX_OPC_BPT,
  TILEGX_OPC_INFO,
  TILEGX_OPC_INFOL,
  TILEGX_OPC_LD4S_TLS,
  TILEGX_OPC_LD_TLS,
  TILEGX_OPC_MOVE,
  TILEGX_OPC_MOVEI,
  TILEGX_OPC_MOVELI,
  TILEGX_OPC_PREFETCH,
  TILEGX_OPC_PREFETCH_ADD_L1,
  TILEGX_OPC_PREFETCH_ADD_L1_FAULT,
  TILEGX_OPC_PREFETCH_ADD_L2,
  TILEGX_OPC_PREFETCH_ADD_L2_FAULT,
  TILEGX_OPC_PREFETCH_ADD_L3,
  TILEGX_OPC_PREFETCH_ADD_L3_FAULT,
  TILEGX_OPC_PREFETCH_L1,
  TILEGX_OPC_PREFETCH_L1_FAULT,
  TILEGX_OPC_PREFETCH_L2,
  TILEGX_OPC_PREFETCH_L2_FAULT,
  TILEGX_OPC_PREFETCH_L3,
  TILEGX_OPC_PREFETCH_L3_FAULT,
  TILEGX_OPC_RAISE,
  TILEGX_OPC_ADD,
  TILEGX_OPC_ADDI,
  TILEGX_OPC_ADDLI,
  TILEGX_OPC_ADDX,
  TILEGX_OPC_ADDXI,
  TILEGX_OPC_ADDXLI,
  TILEGX_OPC_ADDXSC,
  TILEGX_OPC_AND,
  TILEGX_OPC_ANDI,
  TILEGX_OPC_BEQZ,
  TILEGX_OPC_BEQZT,
  TILEGX_OPC_BFEXTS,
  TILEGX_OPC_BFEXTU,
  TILEGX_OPC_BFINS,
  TILEGX_OPC_BGEZ,
  TILEGX_OPC_BGEZT,
  TILEGX_OPC_BGTZ,
  TILEGX_OPC_BGTZT,
  TILEGX_OPC_BLBC,
  TILEGX_OPC_BLBCT,
  TILEGX_OPC_BLBS,
  TILEGX_OPC_BLBST,
  TILEGX_OPC_BLEZ,
  TILEGX_OPC_BLEZT,
  TILEGX_OPC_BLTZ,
  TILEGX_OPC_BLTZT,
  TILEGX_OPC_BNEZ,
  TILEGX_OPC_BNEZT,
  TILEGX_OPC_CLZ,
  TILEGX_OPC_CMOVEQZ,
  TILEGX_OPC_CMOVNEZ,
  TILEGX_OPC_CMPEQ,
  TILEGX_OPC_CMPEQI,
  TILEGX_OPC_CMPEXCH,
  TILEGX_OPC_CMPEXCH4,
  TILEGX_OPC_CMPLES,
  TILEGX_OPC_CMPLEU,
  TILEGX_OPC_CMPLTS,
  TILEGX_OPC_CMPLTSI,
  TILEGX_OPC_CMPLTU,
  TILEGX_OPC_CMPLTUI,
  TILEGX_OPC_CMPNE,
  TILEGX_OPC_CMUL,
  TILEGX_OPC_CMULA,
  TILEGX_OPC_CMULAF,
  TILEGX_OPC_CMULF,
  TILEGX_OPC_CMULFR,
  TILEGX_OPC_CMULH,
  TILEGX_OPC_CMULHR,
  TILEGX_OPC_CRC32_32,
  TILEGX_OPC_CRC32_8,
  TILEGX_OPC_CTZ,
  TILEGX_OPC_DBLALIGN,
  TILEGX_OPC_DBLALIGN2,
  TILEGX_OPC_DBLALIGN4,
  TILEGX_OPC_DBLALIGN6,
  TILEGX_OPC_DRAIN,
  TILEGX_OPC_DTLBPR,
  TILEGX_OPC_EXCH,
  TILEGX_OPC_EXCH4,
  TILEGX_OPC_FDOUBLE_ADD_FLAGS,
  TILEGX_OPC_FDOUBLE_ADDSUB,
  TILEGX_OPC_FDOUBLE_MUL_FLAGS,
  TILEGX_OPC_FDOUBLE_PACK1,
  TILEGX_OPC_FDOUBLE_PACK2,
  TILEGX_OPC_FDOUBLE_SUB_FLAGS,
  TILEGX_OPC_FDOUBLE_UNPACK_MAX,
  TILEGX_OPC_FDOUBLE_UNPACK_MIN,
  TILEGX_OPC_FETCHADD,
  TILEGX_OPC_FETCHADD4,
  TILEGX_OPC_FETCHADDGEZ,
  TILEGX_OPC_FETCHADDGEZ4,
  TILEGX_OPC_FETCHAND,
  TILEGX_OPC_FETCHAND4,
  TILEGX_OPC_FETCHOR,
  TILEGX_OPC_FETCHOR4,
  TILEGX_OPC_FINV,
  TILEGX_OPC_FLUSH,
  TILEGX_OPC_FLUSHWB,
  TILEGX_OPC_FNOP,
  TILEGX_OPC_FSINGLE_ADD1,
  TILEGX_OPC_FSINGLE_ADDSUB2,
  TILEGX_OPC_FSINGLE_MUL1,
  TILEGX_OPC_FSINGLE_MUL2,
  TILEGX_OPC_FSINGLE_PACK1,
  TILEGX_OPC_FSINGLE_PACK2,
  TILEGX_OPC_FSINGLE_SUB1,
  TILEGX_OPC_ICOH,
  TILEGX_OPC_ILL,
  TILEGX_OPC_INV,
  TILEGX_OPC_IRET,
  TILEGX_OPC_J,
  TILEGX_OPC_JAL,
  TILEGX_OPC_JALR,
  TILEGX_OPC_JALRP,
  TILEGX_OPC_JR,
  TILEGX_OPC_JRP,
  TILEGX_OPC_LD,
  TILEGX_OPC_LD1S,
  TILEGX_OPC_LD1S_ADD,
  TILEGX_OPC_LD1U,
  TILEGX_OPC_LD1U_ADD,
  TILEGX_OPC_LD2S,
  TILEGX_OPC_LD2S_ADD,
  TILEGX_OPC_LD2U,
  TILEGX_OPC_LD2U_ADD,
  TILEGX_OPC_LD4S,
  TILEGX_OPC_LD4S_ADD,
  TILEGX_OPC_LD4U,
  TILEGX_OPC_LD4U_ADD,
  TILEGX_OPC_LD_ADD,
  TILEGX_OPC_LDNA,
  TILEGX_OPC_LDNA_ADD,
  TILEGX_OPC_LDNT,
  TILEGX_OPC_LDNT1S,
  TILEGX_OPC_LDNT1S_ADD,
  TILEGX_OPC_LDNT1U,
  TILEGX_OPC_LDNT1U_ADD,
  TILEGX_OPC_LDNT2S,
  TILEGX_OPC_LDNT2S_ADD,
  TILEGX_OPC_LDNT2U,
  TILEGX_OPC_LDNT2U_ADD,
  TILEGX_OPC_LDNT4S,
  TILEGX_OPC_LDNT4S_ADD,
  TILEGX_OPC_LDNT4U,
  TILEGX_OPC_LDNT4U_ADD,
  TILEGX_OPC_LDNT_ADD,
  TILEGX_OPC_LNK,
  TILEGX_OPC_MF,
  TILEGX_OPC_MFSPR,
  TILEGX_OPC_MM,
  TILEGX_OPC_MNZ,
  TILEGX_OPC_MTSPR,
  TILEGX_OPC_MUL_HS_HS,
  TILEGX_OPC_MUL_HS_HU,
  TILEGX_OPC_MUL_HS_LS,
  TILEGX_OPC_MUL_HS_LU,
  TILEGX_OPC_MUL_HU_HU,
  TILEGX_OPC_MUL_HU_LS,
  TILEGX_OPC_MUL_HU_LU,
  TILEGX_OPC_MUL_LS_LS,
  TILEGX_OPC_MUL_LS_LU,
  TILEGX_OPC_MUL_LU_LU,
  TILEGX_OPC_MULA_HS_HS,
  TILEGX_OPC_MULA_HS_HU,
  TILEGX_OPC_MULA_HS_LS,
  TILEGX_OPC_MULA_HS_LU,
  TILEGX_OPC_MULA_HU_HU,
  TILEGX_OPC_MULA_HU_LS,
  TILEGX_OPC_MULA_HU_LU,
  TILEGX_OPC_MULA_LS_LS,
  TILEGX_OPC_MULA_LS_LU,
  TILEGX_OPC_MULA_LU_LU,
  TILEGX_OPC_MULAX,
  TILEGX_OPC_MULX,
  TILEGX_OPC_MZ,
  TILEGX_OPC_NAP,
  TILEGX_OPC_NOP,
  TILEGX_OPC_NOR,
  TILEGX_OPC_OR,
  TILEGX_OPC_ORI,
  TILEGX_OPC_PCNT,
  TILEGX_OPC_REVBITS,
  TILEGX_OPC_REVBYTES,
  TILEGX_OPC_ROTL,
  TILEGX_OPC_ROTLI,
  TILEGX_OPC_SHL,
  TILEGX_OPC_SHL16INSLI,
  TILEGX_OPC_SHL1ADD,
  TILEGX_OPC_SHL1ADDX,
  TILEGX_OPC_SHL2ADD,
  TILEGX_OPC_SHL2ADDX,
  TILEGX_OPC_SHL3ADD,
  TILEGX_OPC_SHL3ADDX,
  TILEGX_OPC_SHLI,
  TILEGX_OPC_SHLX,
  TILEGX_OPC_SHLXI,
  TILEGX_OPC_SHRS,
  TILEGX_OPC_SHRSI,
  TILEGX_OPC_SHRU,
  TILEGX_OPC_SHRUI,
  TILEGX_OPC_SHRUX,
  TILEGX_OPC_SHRUXI,
  TILEGX_OPC_SHUFFLEBYTES,
  TILEGX_OPC_ST,
  TILEGX_OPC_ST1,
  TILEGX_OPC_ST1_ADD,
  TILEGX_OPC_ST2,
  TILEGX_OPC_ST2_ADD,
  TILEGX_OPC_ST4,
  TILEGX_OPC_ST4_ADD,
  TILEGX_OPC_ST_ADD,
  TILEGX_OPC_STNT,
  TILEGX_OPC_STNT1,
  TILEGX_OPC_STNT1_ADD,
  TILEGX_OPC_STNT2,
  TILEGX_OPC_STNT2_ADD,
  TILEGX_OPC_STNT4,
  TILEGX_OPC_STNT4_ADD,
  TILEGX_OPC_STNT_ADD,
  TILEGX_OPC_SUB,
  TILEGX_OPC_SUBX,
  TILEGX_OPC_SUBXSC,
  TILEGX_OPC_SWINT0,
  TILEGX_OPC_SWINT1,
  TILEGX_OPC_SWINT2,
  TILEGX_OPC_SWINT3,
  TILEGX_OPC_TBLIDXB0,
  TILEGX_OPC_TBLIDXB1,
  TILEGX_OPC_TBLIDXB2,
  TILEGX_OPC_TBLIDXB3,
  TILEGX_OPC_V1ADD,
  TILEGX_OPC_V1ADDI,
  TILEGX_OPC_V1ADDUC,
  TILEGX_OPC_V1ADIFFU,
  TILEGX_OPC_V1AVGU,
  TILEGX_OPC_V1CMPEQ,
  TILEGX_OPC_V1CMPEQI,
  TILEGX_OPC_V1CMPLES,
  TILEGX_OPC_V1CMPLEU,
  TILEGX_OPC_V1CMPLTS,
  TILEGX_OPC_V1CMPLTSI,
  TILEGX_OPC_V1CMPLTU,
  TILEGX_OPC_V1CMPLTUI,
  TILEGX_OPC_V1CMPNE,
  TILEGX_OPC_V1DDOTPU,
  TILEGX_OPC_V1DDOTPUA,
  TILEGX_OPC_V1DDOTPUS,
  TILEGX_OPC_V1DDOTPUSA,
  TILEGX_OPC_V1DOTP,
  TILEGX_OPC_V1DOTPA,
  TILEGX_OPC_V1DOTPU,
  TILEGX_OPC_V1DOTPUA,
  TILEGX_OPC_V1DOTPUS,
  TILEGX_OPC_V1DOTPUSA,
  TILEGX_OPC_V1INT_H,
  TILEGX_OPC_V1INT_L,
  TILEGX_OPC_V1MAXU,
  TILEGX_OPC_V1MAXUI,
  TILEGX_OPC_V1MINU,
  TILEGX_OPC_V1MINUI,
  TILEGX_OPC_V1MNZ,
  TILEGX_OPC_V1MULTU,
  TILEGX_OPC_V1MULU,
  TILEGX_OPC_V1MULUS,
  TILEGX_OPC_V1MZ,
  TILEGX_OPC_V1SADAU,
  TILEGX_OPC_V1SADU,
  TILEGX_OPC_V1SHL,
  TILEGX_OPC_V1SHLI,
  TILEGX_OPC_V1SHRS,
  TILEGX_OPC_V1SHRSI,
  TILEGX_OPC_V1SHRU,
  TILEGX_OPC_V1SHRUI,
  TILEGX_OPC_V1SUB,
  TILEGX_OPC_V1SUBUC,
  TILEGX_OPC_V2ADD,
  TILEGX_OPC_V2ADDI,
  TILEGX_OPC_V2ADDSC,
  TILEGX_OPC_V2ADIFFS,
  TILEGX_OPC_V2AVGS,
  TILEGX_OPC_V2CMPEQ,
  TILEGX_OPC_V2CMPEQI,
  TILEGX_OPC_V2CMPLES,
  TILEGX_OPC_V2CMPLEU,
  TILEGX_OPC_V2CMPLTS,
  TILEGX_OPC_V2CMPLTSI,
  TILEGX_OPC_V2CMPLTU,
  TILEGX_OPC_V2CMPLTUI,
  TILEGX_OPC_V2CMPNE,
  TILEGX_OPC_V2DOTP,
  TILEGX_OPC_V2DOTPA,
  TILEGX_OPC_V2INT_H,
  TILEGX_OPC_V2INT_L,
  TILEGX_OPC_V2MAXS,
  TILEGX_OPC_V2MAXSI,
  TILEGX_OPC_V2MINS,
  TILEGX_OPC_V2MINSI,
  TILEGX_OPC_V2MNZ,
  TILEGX_OPC_V2MULFSC,
  TILEGX_OPC_V2MULS,
  TILEGX_OPC_V2MULTS,
  TILEGX_OPC_V2MZ,
  TILEGX_OPC_V2PACKH,
  TILEGX_OPC_V2PACKL,
  TILEGX_OPC_V2PACKUC,
  TILEGX_OPC_V2SADAS,
  TILEGX_OPC_V2SADAU,
  TILEGX_OPC_V2SADS,
  TILEGX_OPC_V2SADU,
  TILEGX_OPC_V2SHL,
  TILEGX_OPC_V2SHLI,
  TILEGX_OPC_V2SHLSC,
  TILEGX_OPC_V2SHRS,
  TILEGX_OPC_V2SHRSI,
  TILEGX_OPC_V2SHRU,
  TILEGX_OPC_V2SHRUI,
  TILEGX_OPC_V2SUB,
  TILEGX_OPC_V2SUBSC,
  TILEGX_OPC_V4ADD,
  TILEGX_OPC_V4ADDSC,
  TILEGX_OPC_V4INT_H,
  TILEGX_OPC_V4INT_L,
  TILEGX_OPC_V4PACKSC,
  TILEGX_OPC_V4SHL,
  TILEGX_OPC_V4SHLSC,
  TILEGX_OPC_V4SHRS,
  TILEGX_OPC_V4SHRU,
  TILEGX_OPC_V4SUB,
  TILEGX_OPC_V4SUBSC,
  TILEGX_OPC_WH64,
  TILEGX_OPC_XOR,
  TILEGX_OPC_XORI,
  TILEGX_OPC_NONE
} tilegx_mnemonic;
 
/* 64-bit pattern for a { bpt ; nop } bundle. */
#define TILEGX_BPT_BUNDLE 0x286a44ae51485000ULL
 
 
 
static __inline unsigned int
get_BFEnd_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 12)) & 0x3f);
}
 
static __inline unsigned int
get_BFOpcodeExtension_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 24)) & 0xf);
}
 
static __inline unsigned int
get_BFStart_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 18)) & 0x3f);
}
 
static __inline unsigned int
get_BrOff_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 31)) & 0x0000003f) |
         (((unsigned int)(n >> 37)) & 0x0001ffc0);
}
 
static __inline unsigned int
get_BrType_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 54)) & 0x1f);
}
 
static __inline unsigned int
get_Dest_Imm8_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 31)) & 0x0000003f) |
         (((unsigned int)(n >> 43)) & 0x000000c0);
}
 
static __inline unsigned int
get_Dest_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 0)) & 0x3f);
}
 
static __inline unsigned int
get_Dest_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 31)) & 0x3f);
}
 
static __inline unsigned int
get_Dest_Y0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 0)) & 0x3f);
}
 
static __inline unsigned int
get_Dest_Y1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 31)) & 0x3f);
}
 
static __inline unsigned int
get_Imm16_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 12)) & 0xffff);
}
 
static __inline unsigned int
get_Imm16_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 43)) & 0xffff);
}
 
static __inline unsigned int
get_Imm8OpcodeExtension_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 20)) & 0xff);
}
 
static __inline unsigned int
get_Imm8OpcodeExtension_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 51)) & 0xff);
}
 
static __inline unsigned int
get_Imm8_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 12)) & 0xff);
}
 
static __inline unsigned int
get_Imm8_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 43)) & 0xff);
}
 
static __inline unsigned int
get_Imm8_Y0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 12)) & 0xff);
}
 
static __inline unsigned int
get_Imm8_Y1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 43)) & 0xff);
}
 
static __inline unsigned int
get_JumpOff_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 31)) & 0x7ffffff);
}
 
static __inline unsigned int
get_JumpOpcodeExtension_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 58)) & 0x1);
}
 
static __inline unsigned int
get_MF_Imm14_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 37)) & 0x3fff);
}
 
static __inline unsigned int
get_MT_Imm14_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 31)) & 0x0000003f) |
         (((unsigned int)(n >> 37)) & 0x00003fc0);
}
 
static __inline unsigned int
get_Mode(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 62)) & 0x3);
}
 
static __inline unsigned int
get_Opcode_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 28)) & 0x7);
}
 
static __inline unsigned int
get_Opcode_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 59)) & 0x7);
}
 
static __inline unsigned int
get_Opcode_Y0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 27)) & 0xf);
}
 
static __inline unsigned int
get_Opcode_Y1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 58)) & 0xf);
}
 
static __inline unsigned int
get_Opcode_Y2(tilegx_bundle_bits n)
{
  return (((n >> 26)) & 0x00000001) |
         (((unsigned int)(n >> 56)) & 0x00000002);
}
 
static __inline unsigned int
get_RRROpcodeExtension_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 18)) & 0x3ff);
}
 
static __inline unsigned int
get_RRROpcodeExtension_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 49)) & 0x3ff);
}
 
static __inline unsigned int
get_RRROpcodeExtension_Y0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 18)) & 0x3);
}
 
static __inline unsigned int
get_RRROpcodeExtension_Y1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 49)) & 0x3);
}
 
static __inline unsigned int
get_ShAmt_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 12)) & 0x3f);
}
 
static __inline unsigned int
get_ShAmt_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 43)) & 0x3f);
}
 
static __inline unsigned int
get_ShAmt_Y0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 12)) & 0x3f);
}
 
static __inline unsigned int
get_ShAmt_Y1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 43)) & 0x3f);
}
 
static __inline unsigned int
get_ShiftOpcodeExtension_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 18)) & 0x3ff);
}
 
static __inline unsigned int
get_ShiftOpcodeExtension_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 49)) & 0x3ff);
}
 
static __inline unsigned int
get_ShiftOpcodeExtension_Y0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 18)) & 0x3);
}
 
static __inline unsigned int
get_ShiftOpcodeExtension_Y1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 49)) & 0x3);
}
 
static __inline unsigned int
get_SrcA_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 6)) & 0x3f);
}
 
static __inline unsigned int
get_SrcA_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 37)) & 0x3f);
}
 
static __inline unsigned int
get_SrcA_Y0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 6)) & 0x3f);
}
 
static __inline unsigned int
get_SrcA_Y1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 37)) & 0x3f);
}
 
static __inline unsigned int
get_SrcA_Y2(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 20)) & 0x3f);
}
 
static __inline unsigned int
get_SrcBDest_Y2(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 51)) & 0x3f);
}
 
static __inline unsigned int
get_SrcB_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 12)) & 0x3f);
}
 
static __inline unsigned int
get_SrcB_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 43)) & 0x3f);
}
 
static __inline unsigned int
get_SrcB_Y0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 12)) & 0x3f);
}
 
static __inline unsigned int
get_SrcB_Y1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 43)) & 0x3f);
}
 
static __inline unsigned int
get_UnaryOpcodeExtension_X0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 12)) & 0x3f);
}
 
static __inline unsigned int
get_UnaryOpcodeExtension_X1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 43)) & 0x3f);
}
 
static __inline unsigned int
get_UnaryOpcodeExtension_Y0(tilegx_bundle_bits num)
{
  const unsigned int n = (unsigned int)num;
  return (((n >> 12)) & 0x3f);
}
 
static __inline unsigned int
get_UnaryOpcodeExtension_Y1(tilegx_bundle_bits n)
{
  return (((unsigned int)(n >> 43)) & 0x3f);
}
 
 
static __inline int
sign_extend(int n, int num_bits)
{
  int shift = (int)(sizeof(int) * 8 - num_bits);
  return (n << shift) >> shift;
}
 
 
 
static __inline tilegx_bundle_bits
create_BFEnd_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 12);
}
 
static __inline tilegx_bundle_bits
create_BFOpcodeExtension_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0xf) << 24);
}
 
static __inline tilegx_bundle_bits
create_BFStart_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 18);
}
 
static __inline tilegx_bundle_bits
create_BrOff_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x0000003f)) << 31) |
         (((tilegx_bundle_bits)(n & 0x0001ffc0)) << 37);
}
 
static __inline tilegx_bundle_bits
create_BrType_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x1f)) << 54);
}
 
static __inline tilegx_bundle_bits
create_Dest_Imm8_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x0000003f)) << 31) |
         (((tilegx_bundle_bits)(n & 0x000000c0)) << 43);
}
 
static __inline tilegx_bundle_bits
create_Dest_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 0);
}
 
static __inline tilegx_bundle_bits
create_Dest_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3f)) << 31);
}
 
static __inline tilegx_bundle_bits
create_Dest_Y0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 0);
}
 
static __inline tilegx_bundle_bits
create_Dest_Y1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3f)) << 31);
}
 
static __inline tilegx_bundle_bits
create_Imm16_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0xffff) << 12);
}
 
static __inline tilegx_bundle_bits
create_Imm16_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0xffff)) << 43);
}
 
static __inline tilegx_bundle_bits
create_Imm8OpcodeExtension_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0xff) << 20);
}
 
static __inline tilegx_bundle_bits
create_Imm8OpcodeExtension_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0xff)) << 51);
}
 
static __inline tilegx_bundle_bits
create_Imm8_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0xff) << 12);
}
 
static __inline tilegx_bundle_bits
create_Imm8_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0xff)) << 43);
}
 
static __inline tilegx_bundle_bits
create_Imm8_Y0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0xff) << 12);
}
 
static __inline tilegx_bundle_bits
create_Imm8_Y1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0xff)) << 43);
}
 
static __inline tilegx_bundle_bits
create_JumpOff_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x7ffffff)) << 31);
}
 
static __inline tilegx_bundle_bits
create_JumpOpcodeExtension_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x1)) << 58);
}
 
static __inline tilegx_bundle_bits
create_MF_Imm14_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3fff)) << 37);
}
 
static __inline tilegx_bundle_bits
create_MT_Imm14_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x0000003f)) << 31) |
         (((tilegx_bundle_bits)(n & 0x00003fc0)) << 37);
}
 
static __inline tilegx_bundle_bits
create_Mode(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3)) << 62);
}
 
static __inline tilegx_bundle_bits
create_Opcode_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x7) << 28);
}
 
static __inline tilegx_bundle_bits
create_Opcode_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x7)) << 59);
}
 
static __inline tilegx_bundle_bits
create_Opcode_Y0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0xf) << 27);
}
 
static __inline tilegx_bundle_bits
create_Opcode_Y1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0xf)) << 58);
}
 
static __inline tilegx_bundle_bits
create_Opcode_Y2(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x00000001) << 26) |
         (((tilegx_bundle_bits)(n & 0x00000002)) << 56);
}
 
static __inline tilegx_bundle_bits
create_RRROpcodeExtension_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3ff) << 18);
}
 
static __inline tilegx_bundle_bits
create_RRROpcodeExtension_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3ff)) << 49);
}
 
static __inline tilegx_bundle_bits
create_RRROpcodeExtension_Y0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3) << 18);
}
 
static __inline tilegx_bundle_bits
create_RRROpcodeExtension_Y1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3)) << 49);
}
 
static __inline tilegx_bundle_bits
create_ShAmt_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 12);
}
 
static __inline tilegx_bundle_bits
create_ShAmt_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3f)) << 43);
}
 
static __inline tilegx_bundle_bits
create_ShAmt_Y0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 12);
}
 
static __inline tilegx_bundle_bits
create_ShAmt_Y1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3f)) << 43);
}
 
static __inline tilegx_bundle_bits
create_ShiftOpcodeExtension_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3ff) << 18);
}
 
static __inline tilegx_bundle_bits
create_ShiftOpcodeExtension_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3ff)) << 49);
}
 
static __inline tilegx_bundle_bits
create_ShiftOpcodeExtension_Y0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3) << 18);
}
 
static __inline tilegx_bundle_bits
create_ShiftOpcodeExtension_Y1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3)) << 49);
}
 
static __inline tilegx_bundle_bits
create_SrcA_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 6);
}
 
static __inline tilegx_bundle_bits
create_SrcA_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3f)) << 37);
}
 
static __inline tilegx_bundle_bits
create_SrcA_Y0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 6);
}
 
static __inline tilegx_bundle_bits
create_SrcA_Y1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3f)) << 37);
}
 
static __inline tilegx_bundle_bits
create_SrcA_Y2(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 20);
}
 
static __inline tilegx_bundle_bits
create_SrcBDest_Y2(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3f)) << 51);
}
 
static __inline tilegx_bundle_bits
create_SrcB_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 12);
}
 
static __inline tilegx_bundle_bits
create_SrcB_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3f)) << 43);
}
 
static __inline tilegx_bundle_bits
create_SrcB_Y0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 12);
}
 
static __inline tilegx_bundle_bits
create_SrcB_Y1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3f)) << 43);
}
 
static __inline tilegx_bundle_bits
create_UnaryOpcodeExtension_X0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 12);
}
 
static __inline tilegx_bundle_bits
create_UnaryOpcodeExtension_X1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3f)) << 43);
}
 
static __inline tilegx_bundle_bits
create_UnaryOpcodeExtension_Y0(int num)
{
  const unsigned int n = (unsigned int)num;
  return ((n & 0x3f) << 12);
}
 
static __inline tilegx_bundle_bits
create_UnaryOpcodeExtension_Y1(int num)
{
  const unsigned int n = (unsigned int)num;
  return (((tilegx_bundle_bits)(n & 0x3f)) << 43);
}
 
 
typedef enum
{
  TILEGX_PIPELINE_X0,
  TILEGX_PIPELINE_X1,
  TILEGX_PIPELINE_Y0,
  TILEGX_PIPELINE_Y1,
  TILEGX_PIPELINE_Y2,
} tilegx_pipeline;
 
#define tilegx_is_x_pipeline(p) ((int)(p) <= (int)TILEGX_PIPELINE_X1)
 
typedef enum
{
  TILEGX_OP_TYPE_REGISTER,
  TILEGX_OP_TYPE_IMMEDIATE,
  TILEGX_OP_TYPE_ADDRESS,
  TILEGX_OP_TYPE_SPR
} tilegx_operand_type;
 
/* These are the bits that determine if a bundle is in the X encoding. */
#define TILEGX_BUNDLE_MODE_MASK ((tilegx_bundle_bits)3 << 62)
 
enum
{
  /* Maximum number of instructions in a bundle (2 for X, 3 for Y). */
  TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE = 3,
 
  /* How many different pipeline encodings are there? X0, X1, Y0, Y1, Y2. */
  TILEGX_NUM_PIPELINE_ENCODINGS = 5,
 
  /* Log base 2 of TILEGX_BUNDLE_SIZE_IN_BYTES. */
  TILEGX_LOG2_BUNDLE_SIZE_IN_BYTES = 3,
 
  /* Instructions take this many bytes. */
  TILEGX_BUNDLE_SIZE_IN_BYTES = 1 << TILEGX_LOG2_BUNDLE_SIZE_IN_BYTES,
 
  /* Log base 2 of TILEGX_BUNDLE_ALIGNMENT_IN_BYTES. */
  TILEGX_LOG2_BUNDLE_ALIGNMENT_IN_BYTES = 3,
 
  /* Bundles should be aligned modulo this number of bytes. */
  TILEGX_BUNDLE_ALIGNMENT_IN_BYTES =
    (1 << TILEGX_LOG2_BUNDLE_ALIGNMENT_IN_BYTES),
 
  /* Number of registers (some are magic, such as network I/O). */
  TILEGX_NUM_REGISTERS = 64,
};
 
 
struct tilegx_operand
{
  /* Is this operand a register, immediate or address? */
  tilegx_operand_type type;
 
  /* The default relocation type for this operand.  */
  signed int default_reloc : 16;
 
  /* How many bits is this value? (used for range checking) */
  unsigned int num_bits : 5;
 
  /* Is the value signed? (used for range checking) */
  unsigned int is_signed : 1;
 
  /* Is this operand a source register? */
  unsigned int is_src_reg : 1;
 
  /* Is this operand written? (i.e. is it a destination register) */
  unsigned int is_dest_reg : 1;
 
  /* Is this operand PC-relative? */
  unsigned int is_pc_relative : 1;
 
  /* By how many bits do we right shift the value before inserting? */
  unsigned int rightshift : 2;
 
  /* Return the bits for this operand to be ORed into an existing bundle. */
  tilegx_bundle_bits (*insert) (int op);
 
  /* Extract this operand and return it. */
  unsigned int (*extract) (tilegx_bundle_bits bundle);
};
 
 
extern const struct tilegx_operand tilegx_operands[];
 
/* One finite-state machine per pipe for rapid instruction decoding. */
extern const unsigned short * const
tilegx_bundle_decoder_fsms[TILEGX_NUM_PIPELINE_ENCODINGS];
 
 
struct tilegx_opcode
{
  /* The opcode mnemonic, e.g. "add" */
  const char *name;
 
  /* The enum value for this mnemonic. */
  tilegx_mnemonic mnemonic;
 
  /* A bit mask of which of the five pipes this instruction
     is compatible with:
     X0  0x01
     X1  0x02
     Y0  0x04
     Y1  0x08
     Y2  0x10 */
  unsigned char pipes;
 
  /* How many operands are there? */
  unsigned char num_operands;
 
  /* Which register does this write implicitly, or TREG_ZERO if none? */
  unsigned char implicitly_written_register;
 
  /* Can this be bundled with other instructions (almost always true). */
  unsigned char can_bundle;
 
  /* The description of the operands. Each of these is an
   * index into the tilegx_operands[] table. */
  unsigned char operands[TILEGX_NUM_PIPELINE_ENCODINGS][TILEGX_MAX_OPERANDS];
 
#if !defined(__KERNEL__) && !defined(_LIBC)
  /* A mask of which bits have predefined values for each pipeline.
   * This is useful for disassembly. */
  tilegx_bundle_bits fixed_bit_masks[TILEGX_NUM_PIPELINE_ENCODINGS];
 
  /* For each bit set in fixed_bit_masks, what the value is for this
   * instruction. */
  tilegx_bundle_bits fixed_bit_values[TILEGX_NUM_PIPELINE_ENCODINGS];
#endif
};
 
extern const struct tilegx_opcode tilegx_opcodes[];
 
/* Used for non-textual disassembly into structs. */
struct tilegx_decoded_instruction
{
  const struct tilegx_opcode *opcode;
  const struct tilegx_operand *operands[TILEGX_MAX_OPERANDS];
  long long operand_values[TILEGX_MAX_OPERANDS];
};
 
 
/* Disassemble a bundle into a struct for machine processing. */
extern int parse_insn_tilegx(tilegx_bundle_bits bits,
                             unsigned long long pc,
                             struct tilegx_decoded_instruction
                             decoded[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE]);
 
 
#if !defined(__KERNEL__) && !defined(_LIBC)
/* Canonical names of all the registers. */
/* ISSUE: This table lives in "tile-dis.c" */
extern const char * const tilegx_register_names[];
 
/* Descriptor for a special-purpose register. */
struct tilegx_spr
{
  /* The number */
  int number;
 
  /* The name */
  const char *name;
};
 
/* List of all the SPRs; ordered by increasing number. */
extern const struct tilegx_spr tilegx_sprs[];
 
/* Number of special-purpose registers. */
extern const int tilegx_num_sprs;
 
extern const char *
get_tilegx_spr_name (int num);
#endif /* !__KERNEL__ && !_LIBC */
 
/* Make a few "tile_" variables to simply common code between
   architectures.  */
 
typedef tilegx_bundle_bits tile_bundle_bits;
#define TILE_BUNDLE_SIZE_IN_BYTES TILEGX_BUNDLE_SIZE_IN_BYTES
#define TILE_BUNDLE_ALIGNMENT_IN_BYTES TILEGX_BUNDLE_ALIGNMENT_IN_BYTES
#define TILE_LOG2_BUNDLE_ALIGNMENT_IN_BYTES \
  TILEGX_LOG2_BUNDLE_ALIGNMENT_IN_BYTES
 
#ifdef __cplusplus
}
#endif
 
#endif /* opcode_tilegx_h */

Rev 5191	Rev 6324
1	/* TILE-Gx opcode information.	1	/* TILE-Gx opcode information.
2	*	2	*
3	* Copyright 2011 Free Software Foundation, Inc.	3	* Copyright (C) 2011-2015 Free Software Foundation, Inc.
4	*	4	*
5	* This program is free software; you can redistribute it and/or modify	5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by	6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 3 of the License, or	7	* the Free Software Foundation; either version 3 of the License, or
8	* (at your option) any later version.	8	* (at your option) any later version.
9	*	9	*
10	* This program is distributed in the hope that it will be useful,	10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.	13	* GNU General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU General Public License	15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software	16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,	17	* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
18	* MA 02110-1301, USA.	18	* MA 02110-1301, USA.
19	*/	19	*/
20		20
21	#ifndef opcode_tile_h	21	#ifndef opcode_tile_h
22	#define opcode_tile_h	22	#define opcode_tile_h
-		23
-		24	#ifdef __cplusplus
-		25	extern "C" {
-		26	#endif
23		27
24	typedef unsigned long long tilegx_bundle_bits;	28	typedef unsigned long long tilegx_bundle_bits;
25		29
26		30
27	enum	31	enum
28	{	32	{
29	TILEGX_MAX_OPERANDS = 4 /* bfexts */	33	TILEGX_MAX_OPERANDS = 4 /* bfexts */
30	};	34	};
31		35
32	typedef enum	36	typedef enum
33	{	37	{
34	TILEGX_OPC_BPT,	38	TILEGX_OPC_BPT,
35	TILEGX_OPC_INFO,	39	TILEGX_OPC_INFO,
36	TILEGX_OPC_INFOL,	40	TILEGX_OPC_INFOL,
37	TILEGX_OPC_LD4S_TLS,	41	TILEGX_OPC_LD4S_TLS,
38	TILEGX_OPC_LD_TLS,	42	TILEGX_OPC_LD_TLS,
39	TILEGX_OPC_MOVE,	43	TILEGX_OPC_MOVE,
40	TILEGX_OPC_MOVEI,	44	TILEGX_OPC_MOVEI,
41	TILEGX_OPC_MOVELI,	45	TILEGX_OPC_MOVELI,
42	TILEGX_OPC_PREFETCH,	46	TILEGX_OPC_PREFETCH,
43	TILEGX_OPC_PREFETCH_ADD_L1,	47	TILEGX_OPC_PREFETCH_ADD_L1,
44	TILEGX_OPC_PREFETCH_ADD_L1_FAULT,	48	TILEGX_OPC_PREFETCH_ADD_L1_FAULT,
45	TILEGX_OPC_PREFETCH_ADD_L2,	49	TILEGX_OPC_PREFETCH_ADD_L2,
46	TILEGX_OPC_PREFETCH_ADD_L2_FAULT,	50	TILEGX_OPC_PREFETCH_ADD_L2_FAULT,
47	TILEGX_OPC_PREFETCH_ADD_L3,	51	TILEGX_OPC_PREFETCH_ADD_L3,
48	TILEGX_OPC_PREFETCH_ADD_L3_FAULT,	52	TILEGX_OPC_PREFETCH_ADD_L3_FAULT,
49	TILEGX_OPC_PREFETCH_L1,	53	TILEGX_OPC_PREFETCH_L1,
50	TILEGX_OPC_PREFETCH_L1_FAULT,	54	TILEGX_OPC_PREFETCH_L1_FAULT,
51	TILEGX_OPC_PREFETCH_L2,	55	TILEGX_OPC_PREFETCH_L2,
52	TILEGX_OPC_PREFETCH_L2_FAULT,	56	TILEGX_OPC_PREFETCH_L2_FAULT,
53	TILEGX_OPC_PREFETCH_L3,	57	TILEGX_OPC_PREFETCH_L3,
54	TILEGX_OPC_PREFETCH_L3_FAULT,	58	TILEGX_OPC_PREFETCH_L3_FAULT,
55	TILEGX_OPC_RAISE,	59	TILEGX_OPC_RAISE,
56	TILEGX_OPC_ADD,	60	TILEGX_OPC_ADD,
57	TILEGX_OPC_ADDI,	61	TILEGX_OPC_ADDI,
58	TILEGX_OPC_ADDLI,	62	TILEGX_OPC_ADDLI,
59	TILEGX_OPC_ADDX,	63	TILEGX_OPC_ADDX,
60	TILEGX_OPC_ADDXI,	64	TILEGX_OPC_ADDXI,
61	TILEGX_OPC_ADDXLI,	65	TILEGX_OPC_ADDXLI,
62	TILEGX_OPC_ADDXSC,	66	TILEGX_OPC_ADDXSC,
63	TILEGX_OPC_AND,	67	TILEGX_OPC_AND,
64	TILEGX_OPC_ANDI,	68	TILEGX_OPC_ANDI,
65	TILEGX_OPC_BEQZ,	69	TILEGX_OPC_BEQZ,
66	TILEGX_OPC_BEQZT,	70	TILEGX_OPC_BEQZT,
67	TILEGX_OPC_BFEXTS,	71	TILEGX_OPC_BFEXTS,
68	TILEGX_OPC_BFEXTU,	72	TILEGX_OPC_BFEXTU,
69	TILEGX_OPC_BFINS,	73	TILEGX_OPC_BFINS,
70	TILEGX_OPC_BGEZ,	74	TILEGX_OPC_BGEZ,
71	TILEGX_OPC_BGEZT,	75	TILEGX_OPC_BGEZT,
72	TILEGX_OPC_BGTZ,	76	TILEGX_OPC_BGTZ,
73	TILEGX_OPC_BGTZT,	77	TILEGX_OPC_BGTZT,
74	TILEGX_OPC_BLBC,	78	TILEGX_OPC_BLBC,
75	TILEGX_OPC_BLBCT,	79	TILEGX_OPC_BLBCT,
76	TILEGX_OPC_BLBS,	80	TILEGX_OPC_BLBS,
77	TILEGX_OPC_BLBST,	81	TILEGX_OPC_BLBST,
78	TILEGX_OPC_BLEZ,	82	TILEGX_OPC_BLEZ,
79	TILEGX_OPC_BLEZT,	83	TILEGX_OPC_BLEZT,
80	TILEGX_OPC_BLTZ,	84	TILEGX_OPC_BLTZ,
81	TILEGX_OPC_BLTZT,	85	TILEGX_OPC_BLTZT,
82	TILEGX_OPC_BNEZ,	86	TILEGX_OPC_BNEZ,
83	TILEGX_OPC_BNEZT,	87	TILEGX_OPC_BNEZT,
84	TILEGX_OPC_CLZ,	88	TILEGX_OPC_CLZ,
85	TILEGX_OPC_CMOVEQZ,	89	TILEGX_OPC_CMOVEQZ,
86	TILEGX_OPC_CMOVNEZ,	90	TILEGX_OPC_CMOVNEZ,
87	TILEGX_OPC_CMPEQ,	91	TILEGX_OPC_CMPEQ,
88	TILEGX_OPC_CMPEQI,	92	TILEGX_OPC_CMPEQI,
89	TILEGX_OPC_CMPEXCH,	93	TILEGX_OPC_CMPEXCH,
90	TILEGX_OPC_CMPEXCH4,	94	TILEGX_OPC_CMPEXCH4,
91	TILEGX_OPC_CMPLES,	95	TILEGX_OPC_CMPLES,
92	TILEGX_OPC_CMPLEU,	96	TILEGX_OPC_CMPLEU,
93	TILEGX_OPC_CMPLTS,	97	TILEGX_OPC_CMPLTS,
94	TILEGX_OPC_CMPLTSI,	98	TILEGX_OPC_CMPLTSI,
95	TILEGX_OPC_CMPLTU,	99	TILEGX_OPC_CMPLTU,
96	TILEGX_OPC_CMPLTUI,	100	TILEGX_OPC_CMPLTUI,
97	TILEGX_OPC_CMPNE,	101	TILEGX_OPC_CMPNE,
98	TILEGX_OPC_CMUL,	102	TILEGX_OPC_CMUL,
99	TILEGX_OPC_CMULA,	103	TILEGX_OPC_CMULA,
100	TILEGX_OPC_CMULAF,	104	TILEGX_OPC_CMULAF,
101	TILEGX_OPC_CMULF,	105	TILEGX_OPC_CMULF,
102	TILEGX_OPC_CMULFR,	106	TILEGX_OPC_CMULFR,
103	TILEGX_OPC_CMULH,	107	TILEGX_OPC_CMULH,
104	TILEGX_OPC_CMULHR,	108	TILEGX_OPC_CMULHR,
105	TILEGX_OPC_CRC32_32,	109	TILEGX_OPC_CRC32_32,
106	TILEGX_OPC_CRC32_8,	110	TILEGX_OPC_CRC32_8,
107	TILEGX_OPC_CTZ,	111	TILEGX_OPC_CTZ,
108	TILEGX_OPC_DBLALIGN,	112	TILEGX_OPC_DBLALIGN,
109	TILEGX_OPC_DBLALIGN2,	113	TILEGX_OPC_DBLALIGN2,
110	TILEGX_OPC_DBLALIGN4,	114	TILEGX_OPC_DBLALIGN4,
111	TILEGX_OPC_DBLALIGN6,	115	TILEGX_OPC_DBLALIGN6,
112	TILEGX_OPC_DRAIN,	116	TILEGX_OPC_DRAIN,
113	TILEGX_OPC_DTLBPR,	117	TILEGX_OPC_DTLBPR,
114	TILEGX_OPC_EXCH,	118	TILEGX_OPC_EXCH,
115	TILEGX_OPC_EXCH4,	119	TILEGX_OPC_EXCH4,
116	TILEGX_OPC_FDOUBLE_ADD_FLAGS,	120	TILEGX_OPC_FDOUBLE_ADD_FLAGS,
117	TILEGX_OPC_FDOUBLE_ADDSUB,	121	TILEGX_OPC_FDOUBLE_ADDSUB,
118	TILEGX_OPC_FDOUBLE_MUL_FLAGS,	122	TILEGX_OPC_FDOUBLE_MUL_FLAGS,
119	TILEGX_OPC_FDOUBLE_PACK1,	123	TILEGX_OPC_FDOUBLE_PACK1,
120	TILEGX_OPC_FDOUBLE_PACK2,	124	TILEGX_OPC_FDOUBLE_PACK2,
121	TILEGX_OPC_FDOUBLE_SUB_FLAGS,	125	TILEGX_OPC_FDOUBLE_SUB_FLAGS,
122	TILEGX_OPC_FDOUBLE_UNPACK_MAX,	126	TILEGX_OPC_FDOUBLE_UNPACK_MAX,
123	TILEGX_OPC_FDOUBLE_UNPACK_MIN,	127	TILEGX_OPC_FDOUBLE_UNPACK_MIN,
124	TILEGX_OPC_FETCHADD,	128	TILEGX_OPC_FETCHADD,
125	TILEGX_OPC_FETCHADD4,	129	TILEGX_OPC_FETCHADD4,
126	TILEGX_OPC_FETCHADDGEZ,	130	TILEGX_OPC_FETCHADDGEZ,
127	TILEGX_OPC_FETCHADDGEZ4,	131	TILEGX_OPC_FETCHADDGEZ4,
128	TILEGX_OPC_FETCHAND,	132	TILEGX_OPC_FETCHAND,
129	TILEGX_OPC_FETCHAND4,	133	TILEGX_OPC_FETCHAND4,
130	TILEGX_OPC_FETCHOR,	134	TILEGX_OPC_FETCHOR,
131	TILEGX_OPC_FETCHOR4,	135	TILEGX_OPC_FETCHOR4,
132	TILEGX_OPC_FINV,	136	TILEGX_OPC_FINV,
133	TILEGX_OPC_FLUSH,	137	TILEGX_OPC_FLUSH,
134	TILEGX_OPC_FLUSHWB,	138	TILEGX_OPC_FLUSHWB,
135	TILEGX_OPC_FNOP,	139	TILEGX_OPC_FNOP,
136	TILEGX_OPC_FSINGLE_ADD1,	140	TILEGX_OPC_FSINGLE_ADD1,
137	TILEGX_OPC_FSINGLE_ADDSUB2,	141	TILEGX_OPC_FSINGLE_ADDSUB2,
138	TILEGX_OPC_FSINGLE_MUL1,	142	TILEGX_OPC_FSINGLE_MUL1,
139	TILEGX_OPC_FSINGLE_MUL2,	143	TILEGX_OPC_FSINGLE_MUL2,
140	TILEGX_OPC_FSINGLE_PACK1,	144	TILEGX_OPC_FSINGLE_PACK1,
141	TILEGX_OPC_FSINGLE_PACK2,	145	TILEGX_OPC_FSINGLE_PACK2,
142	TILEGX_OPC_FSINGLE_SUB1,	146	TILEGX_OPC_FSINGLE_SUB1,
143	TILEGX_OPC_ICOH,	147	TILEGX_OPC_ICOH,
144	TILEGX_OPC_ILL,	148	TILEGX_OPC_ILL,
145	TILEGX_OPC_INV,	149	TILEGX_OPC_INV,
146	TILEGX_OPC_IRET,	150	TILEGX_OPC_IRET,
147	TILEGX_OPC_J,	151	TILEGX_OPC_J,
148	TILEGX_OPC_JAL,	152	TILEGX_OPC_JAL,
149	TILEGX_OPC_JALR,	153	TILEGX_OPC_JALR,
150	TILEGX_OPC_JALRP,	154	TILEGX_OPC_JALRP,
151	TILEGX_OPC_JR,	155	TILEGX_OPC_JR,
152	TILEGX_OPC_JRP,	156	TILEGX_OPC_JRP,
153	TILEGX_OPC_LD,	157	TILEGX_OPC_LD,
154	TILEGX_OPC_LD1S,	158	TILEGX_OPC_LD1S,
155	TILEGX_OPC_LD1S_ADD,	159	TILEGX_OPC_LD1S_ADD,
156	TILEGX_OPC_LD1U,	160	TILEGX_OPC_LD1U,
157	TILEGX_OPC_LD1U_ADD,	161	TILEGX_OPC_LD1U_ADD,
158	TILEGX_OPC_LD2S,	162	TILEGX_OPC_LD2S,
159	TILEGX_OPC_LD2S_ADD,	163	TILEGX_OPC_LD2S_ADD,
160	TILEGX_OPC_LD2U,	164	TILEGX_OPC_LD2U,
161	TILEGX_OPC_LD2U_ADD,	165	TILEGX_OPC_LD2U_ADD,
162	TILEGX_OPC_LD4S,	166	TILEGX_OPC_LD4S,
163	TILEGX_OPC_LD4S_ADD,	167	TILEGX_OPC_LD4S_ADD,
164	TILEGX_OPC_LD4U,	168	TILEGX_OPC_LD4U,
165	TILEGX_OPC_LD4U_ADD,	169	TILEGX_OPC_LD4U_ADD,
166	TILEGX_OPC_LD_ADD,	170	TILEGX_OPC_LD_ADD,
167	TILEGX_OPC_LDNA,	171	TILEGX_OPC_LDNA,
168	TILEGX_OPC_LDNA_ADD,	172	TILEGX_OPC_LDNA_ADD,
169	TILEGX_OPC_LDNT,	173	TILEGX_OPC_LDNT,
170	TILEGX_OPC_LDNT1S,	174	TILEGX_OPC_LDNT1S,
171	TILEGX_OPC_LDNT1S_ADD,	175	TILEGX_OPC_LDNT1S_ADD,
172	TILEGX_OPC_LDNT1U,	176	TILEGX_OPC_LDNT1U,
173	TILEGX_OPC_LDNT1U_ADD,	177	TILEGX_OPC_LDNT1U_ADD,
174	TILEGX_OPC_LDNT2S,	178	TILEGX_OPC_LDNT2S,
175	TILEGX_OPC_LDNT2S_ADD,	179	TILEGX_OPC_LDNT2S_ADD,
176	TILEGX_OPC_LDNT2U,	180	TILEGX_OPC_LDNT2U,
177	TILEGX_OPC_LDNT2U_ADD,	181	TILEGX_OPC_LDNT2U_ADD,
178	TILEGX_OPC_LDNT4S,	182	TILEGX_OPC_LDNT4S,
179	TILEGX_OPC_LDNT4S_ADD,	183	TILEGX_OPC_LDNT4S_ADD,
180	TILEGX_OPC_LDNT4U,	184	TILEGX_OPC_LDNT4U,
181	TILEGX_OPC_LDNT4U_ADD,	185	TILEGX_OPC_LDNT4U_ADD,
182	TILEGX_OPC_LDNT_ADD,	186	TILEGX_OPC_LDNT_ADD,
183	TILEGX_OPC_LNK,	187	TILEGX_OPC_LNK,
184	TILEGX_OPC_MF,	188	TILEGX_OPC_MF,
185	TILEGX_OPC_MFSPR,	189	TILEGX_OPC_MFSPR,
186	TILEGX_OPC_MM,	190	TILEGX_OPC_MM,
187	TILEGX_OPC_MNZ,	191	TILEGX_OPC_MNZ,
188	TILEGX_OPC_MTSPR,	192	TILEGX_OPC_MTSPR,
189	TILEGX_OPC_MUL_HS_HS,	193	TILEGX_OPC_MUL_HS_HS,
190	TILEGX_OPC_MUL_HS_HU,	194	TILEGX_OPC_MUL_HS_HU,
191	TILEGX_OPC_MUL_HS_LS,	195	TILEGX_OPC_MUL_HS_LS,
192	TILEGX_OPC_MUL_HS_LU,	196	TILEGX_OPC_MUL_HS_LU,
193	TILEGX_OPC_MUL_HU_HU,	197	TILEGX_OPC_MUL_HU_HU,
194	TILEGX_OPC_MUL_HU_LS,	198	TILEGX_OPC_MUL_HU_LS,
195	TILEGX_OPC_MUL_HU_LU,	199	TILEGX_OPC_MUL_HU_LU,
196	TILEGX_OPC_MUL_LS_LS,	200	TILEGX_OPC_MUL_LS_LS,
197	TILEGX_OPC_MUL_LS_LU,	201	TILEGX_OPC_MUL_LS_LU,
198	TILEGX_OPC_MUL_LU_LU,	202	TILEGX_OPC_MUL_LU_LU,
199	TILEGX_OPC_MULA_HS_HS,	203	TILEGX_OPC_MULA_HS_HS,
200	TILEGX_OPC_MULA_HS_HU,	204	TILEGX_OPC_MULA_HS_HU,
201	TILEGX_OPC_MULA_HS_LS,	205	TILEGX_OPC_MULA_HS_LS,
202	TILEGX_OPC_MULA_HS_LU,	206	TILEGX_OPC_MULA_HS_LU,
203	TILEGX_OPC_MULA_HU_HU,	207	TILEGX_OPC_MULA_HU_HU,
204	TILEGX_OPC_MULA_HU_LS,	208	TILEGX_OPC_MULA_HU_LS,
205	TILEGX_OPC_MULA_HU_LU,	209	TILEGX_OPC_MULA_HU_LU,
206	TILEGX_OPC_MULA_LS_LS,	210	TILEGX_OPC_MULA_LS_LS,
207	TILEGX_OPC_MULA_LS_LU,	211	TILEGX_OPC_MULA_LS_LU,
208	TILEGX_OPC_MULA_LU_LU,	212	TILEGX_OPC_MULA_LU_LU,
209	TILEGX_OPC_MULAX,	213	TILEGX_OPC_MULAX,
210	TILEGX_OPC_MULX,	214	TILEGX_OPC_MULX,
211	TILEGX_OPC_MZ,	215	TILEGX_OPC_MZ,
212	TILEGX_OPC_NAP,	216	TILEGX_OPC_NAP,
213	TILEGX_OPC_NOP,	217	TILEGX_OPC_NOP,
214	TILEGX_OPC_NOR,	218	TILEGX_OPC_NOR,
215	TILEGX_OPC_OR,	219	TILEGX_OPC_OR,
216	TILEGX_OPC_ORI,	220	TILEGX_OPC_ORI,
217	TILEGX_OPC_PCNT,	221	TILEGX_OPC_PCNT,
218	TILEGX_OPC_REVBITS,	222	TILEGX_OPC_REVBITS,
219	TILEGX_OPC_REVBYTES,	223	TILEGX_OPC_REVBYTES,
220	TILEGX_OPC_ROTL,	224	TILEGX_OPC_ROTL,
221	TILEGX_OPC_ROTLI,	225	TILEGX_OPC_ROTLI,
222	TILEGX_OPC_SHL,	226	TILEGX_OPC_SHL,
223	TILEGX_OPC_SHL16INSLI,	227	TILEGX_OPC_SHL16INSLI,
224	TILEGX_OPC_SHL1ADD,	228	TILEGX_OPC_SHL1ADD,
225	TILEGX_OPC_SHL1ADDX,	229	TILEGX_OPC_SHL1ADDX,
226	TILEGX_OPC_SHL2ADD,	230	TILEGX_OPC_SHL2ADD,
227	TILEGX_OPC_SHL2ADDX,	231	TILEGX_OPC_SHL2ADDX,
228	TILEGX_OPC_SHL3ADD,	232	TILEGX_OPC_SHL3ADD,
229	TILEGX_OPC_SHL3ADDX,	233	TILEGX_OPC_SHL3ADDX,
230	TILEGX_OPC_SHLI,	234	TILEGX_OPC_SHLI,
231	TILEGX_OPC_SHLX,	235	TILEGX_OPC_SHLX,
232	TILEGX_OPC_SHLXI,	236	TILEGX_OPC_SHLXI,
233	TILEGX_OPC_SHRS,	237	TILEGX_OPC_SHRS,
234	TILEGX_OPC_SHRSI,	238	TILEGX_OPC_SHRSI,
235	TILEGX_OPC_SHRU,	239	TILEGX_OPC_SHRU,
236	TILEGX_OPC_SHRUI,	240	TILEGX_OPC_SHRUI,
237	TILEGX_OPC_SHRUX,	241	TILEGX_OPC_SHRUX,
238	TILEGX_OPC_SHRUXI,	242	TILEGX_OPC_SHRUXI,
239	TILEGX_OPC_SHUFFLEBYTES,	243	TILEGX_OPC_SHUFFLEBYTES,
240	TILEGX_OPC_ST,	244	TILEGX_OPC_ST,
241	TILEGX_OPC_ST1,	245	TILEGX_OPC_ST1,
242	TILEGX_OPC_ST1_ADD,	246	TILEGX_OPC_ST1_ADD,
243	TILEGX_OPC_ST2,	247	TILEGX_OPC_ST2,
244	TILEGX_OPC_ST2_ADD,	248	TILEGX_OPC_ST2_ADD,
245	TILEGX_OPC_ST4,	249	TILEGX_OPC_ST4,
246	TILEGX_OPC_ST4_ADD,	250	TILEGX_OPC_ST4_ADD,
247	TILEGX_OPC_ST_ADD,	251	TILEGX_OPC_ST_ADD,
248	TILEGX_OPC_STNT,	252	TILEGX_OPC_STNT,
249	TILEGX_OPC_STNT1,	253	TILEGX_OPC_STNT1,
250	TILEGX_OPC_STNT1_ADD,	254	TILEGX_OPC_STNT1_ADD,
251	TILEGX_OPC_STNT2,	255	TILEGX_OPC_STNT2,
252	TILEGX_OPC_STNT2_ADD,	256	TILEGX_OPC_STNT2_ADD,
253	TILEGX_OPC_STNT4,	257	TILEGX_OPC_STNT4,
254	TILEGX_OPC_STNT4_ADD,	258	TILEGX_OPC_STNT4_ADD,
255	TILEGX_OPC_STNT_ADD,	259	TILEGX_OPC_STNT_ADD,
256	TILEGX_OPC_SUB,	260	TILEGX_OPC_SUB,
257	TILEGX_OPC_SUBX,	261	TILEGX_OPC_SUBX,
258	TILEGX_OPC_SUBXSC,	262	TILEGX_OPC_SUBXSC,
259	TILEGX_OPC_SWINT0,	263	TILEGX_OPC_SWINT0,
260	TILEGX_OPC_SWINT1,	264	TILEGX_OPC_SWINT1,
261	TILEGX_OPC_SWINT2,	265	TILEGX_OPC_SWINT2,
262	TILEGX_OPC_SWINT3,	266	TILEGX_OPC_SWINT3,
263	TILEGX_OPC_TBLIDXB0,	267	TILEGX_OPC_TBLIDXB0,
264	TILEGX_OPC_TBLIDXB1,	268	TILEGX_OPC_TBLIDXB1,
265	TILEGX_OPC_TBLIDXB2,	269	TILEGX_OPC_TBLIDXB2,
266	TILEGX_OPC_TBLIDXB3,	270	TILEGX_OPC_TBLIDXB3,
267	TILEGX_OPC_V1ADD,	271	TILEGX_OPC_V1ADD,
268	TILEGX_OPC_V1ADDI,	272	TILEGX_OPC_V1ADDI,
269	TILEGX_OPC_V1ADDUC,	273	TILEGX_OPC_V1ADDUC,
270	TILEGX_OPC_V1ADIFFU,	274	TILEGX_OPC_V1ADIFFU,
271	TILEGX_OPC_V1AVGU,	275	TILEGX_OPC_V1AVGU,
272	TILEGX_OPC_V1CMPEQ,	276	TILEGX_OPC_V1CMPEQ,
273	TILEGX_OPC_V1CMPEQI,	277	TILEGX_OPC_V1CMPEQI,
274	TILEGX_OPC_V1CMPLES,	278	TILEGX_OPC_V1CMPLES,
275	TILEGX_OPC_V1CMPLEU,	279	TILEGX_OPC_V1CMPLEU,
276	TILEGX_OPC_V1CMPLTS,	280	TILEGX_OPC_V1CMPLTS,
277	TILEGX_OPC_V1CMPLTSI,	281	TILEGX_OPC_V1CMPLTSI,
278	TILEGX_OPC_V1CMPLTU,	282	TILEGX_OPC_V1CMPLTU,
279	TILEGX_OPC_V1CMPLTUI,	283	TILEGX_OPC_V1CMPLTUI,
280	TILEGX_OPC_V1CMPNE,	284	TILEGX_OPC_V1CMPNE,
281	TILEGX_OPC_V1DDOTPU,	285	TILEGX_OPC_V1DDOTPU,
282	TILEGX_OPC_V1DDOTPUA,	286	TILEGX_OPC_V1DDOTPUA,
283	TILEGX_OPC_V1DDOTPUS,	287	TILEGX_OPC_V1DDOTPUS,
284	TILEGX_OPC_V1DDOTPUSA,	288	TILEGX_OPC_V1DDOTPUSA,
285	TILEGX_OPC_V1DOTP,	289	TILEGX_OPC_V1DOTP,
286	TILEGX_OPC_V1DOTPA,	290	TILEGX_OPC_V1DOTPA,
287	TILEGX_OPC_V1DOTPU,	291	TILEGX_OPC_V1DOTPU,
288	TILEGX_OPC_V1DOTPUA,	292	TILEGX_OPC_V1DOTPUA,
289	TILEGX_OPC_V1DOTPUS,	293	TILEGX_OPC_V1DOTPUS,
290	TILEGX_OPC_V1DOTPUSA,	294	TILEGX_OPC_V1DOTPUSA,
291	TILEGX_OPC_V1INT_H,	295	TILEGX_OPC_V1INT_H,
292	TILEGX_OPC_V1INT_L,	296	TILEGX_OPC_V1INT_L,
293	TILEGX_OPC_V1MAXU,	297	TILEGX_OPC_V1MAXU,
294	TILEGX_OPC_V1MAXUI,	298	TILEGX_OPC_V1MAXUI,
295	TILEGX_OPC_V1MINU,	299	TILEGX_OPC_V1MINU,
296	TILEGX_OPC_V1MINUI,	300	TILEGX_OPC_V1MINUI,
297	TILEGX_OPC_V1MNZ,	301	TILEGX_OPC_V1MNZ,
298	TILEGX_OPC_V1MULTU,	302	TILEGX_OPC_V1MULTU,
299	TILEGX_OPC_V1MULU,	303	TILEGX_OPC_V1MULU,
300	TILEGX_OPC_V1MULUS,	304	TILEGX_OPC_V1MULUS,
301	TILEGX_OPC_V1MZ,	305	TILEGX_OPC_V1MZ,
302	TILEGX_OPC_V1SADAU,	306	TILEGX_OPC_V1SADAU,
303	TILEGX_OPC_V1SADU,	307	TILEGX_OPC_V1SADU,
304	TILEGX_OPC_V1SHL,	308	TILEGX_OPC_V1SHL,
305	TILEGX_OPC_V1SHLI,	309	TILEGX_OPC_V1SHLI,
306	TILEGX_OPC_V1SHRS,	310	TILEGX_OPC_V1SHRS,
307	TILEGX_OPC_V1SHRSI,	311	TILEGX_OPC_V1SHRSI,
308	TILEGX_OPC_V1SHRU,	312	TILEGX_OPC_V1SHRU,
309	TILEGX_OPC_V1SHRUI,	313	TILEGX_OPC_V1SHRUI,
310	TILEGX_OPC_V1SUB,	314	TILEGX_OPC_V1SUB,
311	TILEGX_OPC_V1SUBUC,	315	TILEGX_OPC_V1SUBUC,
312	TILEGX_OPC_V2ADD,	316	TILEGX_OPC_V2ADD,
313	TILEGX_OPC_V2ADDI,	317	TILEGX_OPC_V2ADDI,
314	TILEGX_OPC_V2ADDSC,	318	TILEGX_OPC_V2ADDSC,
315	TILEGX_OPC_V2ADIFFS,	319	TILEGX_OPC_V2ADIFFS,
316	TILEGX_OPC_V2AVGS,	320	TILEGX_OPC_V2AVGS,
317	TILEGX_OPC_V2CMPEQ,	321	TILEGX_OPC_V2CMPEQ,
318	TILEGX_OPC_V2CMPEQI,	322	TILEGX_OPC_V2CMPEQI,
319	TILEGX_OPC_V2CMPLES,	323	TILEGX_OPC_V2CMPLES,
320	TILEGX_OPC_V2CMPLEU,	324	TILEGX_OPC_V2CMPLEU,
321	TILEGX_OPC_V2CMPLTS,	325	TILEGX_OPC_V2CMPLTS,
322	TILEGX_OPC_V2CMPLTSI,	326	TILEGX_OPC_V2CMPLTSI,
323	TILEGX_OPC_V2CMPLTU,	327	TILEGX_OPC_V2CMPLTU,
324	TILEGX_OPC_V2CMPLTUI,	328	TILEGX_OPC_V2CMPLTUI,
325	TILEGX_OPC_V2CMPNE,	329	TILEGX_OPC_V2CMPNE,
326	TILEGX_OPC_V2DOTP,	330	TILEGX_OPC_V2DOTP,
327	TILEGX_OPC_V2DOTPA,	331	TILEGX_OPC_V2DOTPA,
328	TILEGX_OPC_V2INT_H,	332	TILEGX_OPC_V2INT_H,
329	TILEGX_OPC_V2INT_L,	333	TILEGX_OPC_V2INT_L,
330	TILEGX_OPC_V2MAXS,	334	TILEGX_OPC_V2MAXS,
331	TILEGX_OPC_V2MAXSI,	335	TILEGX_OPC_V2MAXSI,
332	TILEGX_OPC_V2MINS,	336	TILEGX_OPC_V2MINS,
333	TILEGX_OPC_V2MINSI,	337	TILEGX_OPC_V2MINSI,
334	TILEGX_OPC_V2MNZ,	338	TILEGX_OPC_V2MNZ,
335	TILEGX_OPC_V2MULFSC,	339	TILEGX_OPC_V2MULFSC,
336	TILEGX_OPC_V2MULS,	340	TILEGX_OPC_V2MULS,
337	TILEGX_OPC_V2MULTS,	341	TILEGX_OPC_V2MULTS,
338	TILEGX_OPC_V2MZ,	342	TILEGX_OPC_V2MZ,
339	TILEGX_OPC_V2PACKH,	343	TILEGX_OPC_V2PACKH,
340	TILEGX_OPC_V2PACKL,	344	TILEGX_OPC_V2PACKL,
341	TILEGX_OPC_V2PACKUC,	345	TILEGX_OPC_V2PACKUC,
342	TILEGX_OPC_V2SADAS,	346	TILEGX_OPC_V2SADAS,
343	TILEGX_OPC_V2SADAU,	347	TILEGX_OPC_V2SADAU,
344	TILEGX_OPC_V2SADS,	348	TILEGX_OPC_V2SADS,
345	TILEGX_OPC_V2SADU,	349	TILEGX_OPC_V2SADU,
346	TILEGX_OPC_V2SHL,	350	TILEGX_OPC_V2SHL,
347	TILEGX_OPC_V2SHLI,	351	TILEGX_OPC_V2SHLI,
348	TILEGX_OPC_V2SHLSC,	352	TILEGX_OPC_V2SHLSC,
349	TILEGX_OPC_V2SHRS,	353	TILEGX_OPC_V2SHRS,
350	TILEGX_OPC_V2SHRSI,	354	TILEGX_OPC_V2SHRSI,
351	TILEGX_OPC_V2SHRU,	355	TILEGX_OPC_V2SHRU,
352	TILEGX_OPC_V2SHRUI,	356	TILEGX_OPC_V2SHRUI,
353	TILEGX_OPC_V2SUB,	357	TILEGX_OPC_V2SUB,
354	TILEGX_OPC_V2SUBSC,	358	TILEGX_OPC_V2SUBSC,
355	TILEGX_OPC_V4ADD,	359	TILEGX_OPC_V4ADD,
356	TILEGX_OPC_V4ADDSC,	360	TILEGX_OPC_V4ADDSC,
357	TILEGX_OPC_V4INT_H,	361	TILEGX_OPC_V4INT_H,
358	TILEGX_OPC_V4INT_L,	362	TILEGX_OPC_V4INT_L,
359	TILEGX_OPC_V4PACKSC,	363	TILEGX_OPC_V4PACKSC,
360	TILEGX_OPC_V4SHL,	364	TILEGX_OPC_V4SHL,
361	TILEGX_OPC_V4SHLSC,	365	TILEGX_OPC_V4SHLSC,
362	TILEGX_OPC_V4SHRS,	366	TILEGX_OPC_V4SHRS,
363	TILEGX_OPC_V4SHRU,	367	TILEGX_OPC_V4SHRU,
364	TILEGX_OPC_V4SUB,	368	TILEGX_OPC_V4SUB,
365	TILEGX_OPC_V4SUBSC,	369	TILEGX_OPC_V4SUBSC,
366	TILEGX_OPC_WH64,	370	TILEGX_OPC_WH64,
367	TILEGX_OPC_XOR,	371	TILEGX_OPC_XOR,
368	TILEGX_OPC_XORI,	372	TILEGX_OPC_XORI,
369	TILEGX_OPC_NONE	373	TILEGX_OPC_NONE
370	} tilegx_mnemonic;	374	} tilegx_mnemonic;
371		375
372	/* 64-bit pattern for a { bpt ; nop } bundle. */	376	/* 64-bit pattern for a { bpt ; nop } bundle. */
373	#define TILEGX_BPT_BUNDLE 0x286a44ae51485000ULL	377	#define TILEGX_BPT_BUNDLE 0x286a44ae51485000ULL
374		378
375		379
376		380
377	static __inline unsigned int	381	static __inline unsigned int
378	get_BFEnd_X0(tilegx_bundle_bits num)	382	get_BFEnd_X0(tilegx_bundle_bits num)
379	{	383	{
380	const unsigned int n = (unsigned int)num;	384	const unsigned int n = (unsigned int)num;
381	return (((n >> 12)) & 0x3f);	385	return (((n >> 12)) & 0x3f);
382	}	386	}
383		387
384	static __inline unsigned int	388	static __inline unsigned int
385	get_BFOpcodeExtension_X0(tilegx_bundle_bits num)	389	get_BFOpcodeExtension_X0(tilegx_bundle_bits num)
386	{	390	{
387	const unsigned int n = (unsigned int)num;	391	const unsigned int n = (unsigned int)num;
388	return (((n >> 24)) & 0xf);	392	return (((n >> 24)) & 0xf);
389	}	393	}
390		394
391	static __inline unsigned int	395	static __inline unsigned int
392	get_BFStart_X0(tilegx_bundle_bits num)	396	get_BFStart_X0(tilegx_bundle_bits num)
393	{	397	{
394	const unsigned int n = (unsigned int)num;	398	const unsigned int n = (unsigned int)num;
395	return (((n >> 18)) & 0x3f);	399	return (((n >> 18)) & 0x3f);
396	}	400	}
397		401
398	static __inline unsigned int	402	static __inline unsigned int
399	get_BrOff_X1(tilegx_bundle_bits n)	403	get_BrOff_X1(tilegx_bundle_bits n)
400	{	404	{
401	return (((unsigned int)(n >> 31)) & 0x0000003f) \|	405	return (((unsigned int)(n >> 31)) & 0x0000003f) \|
402	(((unsigned int)(n >> 37)) & 0x0001ffc0);	406	(((unsigned int)(n >> 37)) & 0x0001ffc0);
403	}	407	}
404		408
405	static __inline unsigned int	409	static __inline unsigned int
406	get_BrType_X1(tilegx_bundle_bits n)	410	get_BrType_X1(tilegx_bundle_bits n)
407	{	411	{
408	return (((unsigned int)(n >> 54)) & 0x1f);	412	return (((unsigned int)(n >> 54)) & 0x1f);
409	}	413	}
410		414
411	static __inline unsigned int	415	static __inline unsigned int
412	get_Dest_Imm8_X1(tilegx_bundle_bits n)	416	get_Dest_Imm8_X1(tilegx_bundle_bits n)
413	{	417	{
414	return (((unsigned int)(n >> 31)) & 0x0000003f) \|	418	return (((unsigned int)(n >> 31)) & 0x0000003f) \|
415	(((unsigned int)(n >> 43)) & 0x000000c0);	419	(((unsigned int)(n >> 43)) & 0x000000c0);
416	}	420	}
417		421
418	static __inline unsigned int	422	static __inline unsigned int
419	get_Dest_X0(tilegx_bundle_bits num)	423	get_Dest_X0(tilegx_bundle_bits num)
420	{	424	{
421	const unsigned int n = (unsigned int)num;	425	const unsigned int n = (unsigned int)num;
422	return (((n >> 0)) & 0x3f);	426	return (((n >> 0)) & 0x3f);
423	}	427	}
424		428
425	static __inline unsigned int	429	static __inline unsigned int
426	get_Dest_X1(tilegx_bundle_bits n)	430	get_Dest_X1(tilegx_bundle_bits n)
427	{	431	{
428	return (((unsigned int)(n >> 31)) & 0x3f);	432	return (((unsigned int)(n >> 31)) & 0x3f);
429	}	433	}
430		434
431	static __inline unsigned int	435	static __inline unsigned int
432	get_Dest_Y0(tilegx_bundle_bits num)	436	get_Dest_Y0(tilegx_bundle_bits num)
433	{	437	{
434	const unsigned int n = (unsigned int)num;	438	const unsigned int n = (unsigned int)num;
435	return (((n >> 0)) & 0x3f);	439	return (((n >> 0)) & 0x3f);
436	}	440	}
437		441
438	static __inline unsigned int	442	static __inline unsigned int
439	get_Dest_Y1(tilegx_bundle_bits n)	443	get_Dest_Y1(tilegx_bundle_bits n)
440	{	444	{
441	return (((unsigned int)(n >> 31)) & 0x3f);	445	return (((unsigned int)(n >> 31)) & 0x3f);
442	}	446	}
443		447
444	static __inline unsigned int	448	static __inline unsigned int
445	get_Imm16_X0(tilegx_bundle_bits num)	449	get_Imm16_X0(tilegx_bundle_bits num)
446	{	450	{
447	const unsigned int n = (unsigned int)num;	451	const unsigned int n = (unsigned int)num;
448	return (((n >> 12)) & 0xffff);	452	return (((n >> 12)) & 0xffff);
449	}	453	}
450		454
451	static __inline unsigned int	455	static __inline unsigned int
452	get_Imm16_X1(tilegx_bundle_bits n)	456	get_Imm16_X1(tilegx_bundle_bits n)
453	{	457	{
454	return (((unsigned int)(n >> 43)) & 0xffff);	458	return (((unsigned int)(n >> 43)) & 0xffff);
455	}	459	}
456		460
457	static __inline unsigned int	461	static __inline unsigned int
458	get_Imm8OpcodeExtension_X0(tilegx_bundle_bits num)	462	get_Imm8OpcodeExtension_X0(tilegx_bundle_bits num)
459	{	463	{
460	const unsigned int n = (unsigned int)num;	464	const unsigned int n = (unsigned int)num;
461	return (((n >> 20)) & 0xff);	465	return (((n >> 20)) & 0xff);
462	}	466	}
463		467
464	static __inline unsigned int	468	static __inline unsigned int
465	get_Imm8OpcodeExtension_X1(tilegx_bundle_bits n)	469	get_Imm8OpcodeExtension_X1(tilegx_bundle_bits n)
466	{	470	{
467	return (((unsigned int)(n >> 51)) & 0xff);	471	return (((unsigned int)(n >> 51)) & 0xff);
468	}	472	}
469		473
470	static __inline unsigned int	474	static __inline unsigned int
471	get_Imm8_X0(tilegx_bundle_bits num)	475	get_Imm8_X0(tilegx_bundle_bits num)
472	{	476	{
473	const unsigned int n = (unsigned int)num;	477	const unsigned int n = (unsigned int)num;
474	return (((n >> 12)) & 0xff);	478	return (((n >> 12)) & 0xff);
475	}	479	}
476		480
477	static __inline unsigned int	481	static __inline unsigned int
478	get_Imm8_X1(tilegx_bundle_bits n)	482	get_Imm8_X1(tilegx_bundle_bits n)
479	{	483	{
480	return (((unsigned int)(n >> 43)) & 0xff);	484	return (((unsigned int)(n >> 43)) & 0xff);
481	}	485	}
482		486
483	static __inline unsigned int	487	static __inline unsigned int
484	get_Imm8_Y0(tilegx_bundle_bits num)	488	get_Imm8_Y0(tilegx_bundle_bits num)
485	{	489	{
486	const unsigned int n = (unsigned int)num;	490	const unsigned int n = (unsigned int)num;
487	return (((n >> 12)) & 0xff);	491	return (((n >> 12)) & 0xff);
488	}	492	}
489		493
490	static __inline unsigned int	494	static __inline unsigned int
491	get_Imm8_Y1(tilegx_bundle_bits n)	495	get_Imm8_Y1(tilegx_bundle_bits n)
492	{	496	{
493	return (((unsigned int)(n >> 43)) & 0xff);	497	return (((unsigned int)(n >> 43)) & 0xff);
494	}	498	}
495		499
496	static __inline unsigned int	500	static __inline unsigned int

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/include/opcode/tilegx.h – Rev 5191 → 6324