Rizin
unix-like reverse engineering framework and cli tools
Classes | Macros | Functions | Variables
sparc-opc.c File Reference
#include <stdio.h>
#include <string.h>
#include "sysdep.h"
#include "opcode/sparc.h"

Go to the source code of this file.

Classes

struct  arg
 

Macros

#define MASK_V6   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V6)
 
#define MASK_V7   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V7)
 
#define MASK_V8   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V8)
 
#define MASK_SPARCLET   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_SPARCLET)
 
#define MASK_SPARCLITE   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_SPARCLITE)
 
#define MASK_V9   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9)
 
#define MASK_V9A   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9A)
 
#define MASK_V9B   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9B)
 
#define v6
 
#define v6notlet
 
#define v7
 
#define v8
 
#define sparclet   (MASK_SPARCLET)
 
#define sparclite   (MASK_SPARCLITE)
 
#define v9   (MASK_V9 | MASK_V9A | MASK_V9B)
 
#define v9a   (MASK_V9A | MASK_V9B)
 
#define v9b   (MASK_V9B)
 
#define v6notv9
 
#define v9notv9a   (MASK_V9)
 
#define COND(x)   (((x) & 0xf) << 25)
 
#define MCOND(x, i_or_f)   ((((i_or_f) & 1) << 18) | (((x) >> 11) & (0xf << 14))) /* v9 */
 
#define RCOND(x)   (((x) & 0x7) << 10) /* v9 */
 
#define CONDA   (COND (0x8))
 
#define CONDCC   (COND (0xd))
 
#define CONDCS   (COND (0x5))
 
#define CONDE   (COND (0x1))
 
#define CONDG   (COND (0xa))
 
#define CONDGE   (COND (0xb))
 
#define CONDGU   (COND (0xc))
 
#define CONDL   (COND (0x3))
 
#define CONDLE   (COND (0x2))
 
#define CONDLEU   (COND (0x4))
 
#define CONDN   (COND (0x0))
 
#define CONDNE   (COND (0x9))
 
#define CONDNEG   (COND (0x6))
 
#define CONDPOS   (COND (0xe))
 
#define CONDVC   (COND (0xf))
 
#define CONDVS   (COND (0x7))
 
#define CONDNZ   CONDNE
 
#define CONDZ   CONDE
 
#define CONDGEU   CONDCC
 
#define CONDLU   CONDCS
 
#define FCONDA   (COND (0x8))
 
#define FCONDE   (COND (0x9))
 
#define FCONDG   (COND (0x6))
 
#define FCONDGE   (COND (0xb))
 
#define FCONDL   (COND (0x4))
 
#define FCONDLE   (COND (0xd))
 
#define FCONDLG   (COND (0x2))
 
#define FCONDN   (COND (0x0))
 
#define FCONDNE   (COND (0x1))
 
#define FCONDO   (COND (0xf))
 
#define FCONDU   (COND (0x7))
 
#define FCONDUE   (COND (0xa))
 
#define FCONDUG   (COND (0x5))
 
#define FCONDUGE   (COND (0xc))
 
#define FCONDUL   (COND (0x3))
 
#define FCONDULE   (COND (0xe))
 
#define FCONDNZ   FCONDNE
 
#define FCONDZ   FCONDE
 
#define ICC   (0) /* v9 */
 
#define XCC   (1 << 12) /* v9 */
 
#define FCC(x)   (((x) & 0x3) << 11) /* v9 */
 
#define FBFCC(x)   (((x) & 0x3) << 20) /* v9 */
 
#define COMMUTEOP(opcode, op3, arch_mask)
 
#define br(opcode, mask, lose, flags)
 
#define brx(opcode, mask, lose, flags)
 
#define tr(opcode, mask, lose, flags)
 
#define cond(bop, top, mask, flags)
 
#define brr(opcode, mask, lose, flags)
 
#define condr(bop, mask, flags)
 
#define movr(opcode, mask, flags)
 
#define fmrrs(opcode, mask, lose, flags)
 
#define fmrrd(opcode, mask, lose, flags)
 
#define fmrrq(opcode, mask, lose, flags)
 
#define fmovrs(mop, mask, flags)
 
#define fmovrd(mop, mask, flags)
 
#define fmovrq(mop, mask, flags)
 
#define movicc(opcode, cond, flags)
 
#define movfcc(opcode, fcond, flags)
 
#define movcc(opcode, cond, fcond, flags)
 
#define FM_SF   1 /* v9 - values for fpsize */
 
#define FM_DF   2 /* v9 */
 
#define FM_QF   3 /* v9 */
 
#define fmoviccx(opcode, fpsize, args, cond, flags)
 
#define fmovfccx(opcode, fpsize, args, fcond, flags)
 
#define fmovccx(opcode, fpsize, args, cond, fcond, flags)
 
#define fmovicc(suffix, cond, flags)
 
#define fmovfcc(suffix, fcond, flags)
 
#define fmovcc(suffix, cond, fcond, flags)
 
#define CBR(opcode, mask, lose, flags, arch)
 
#define FBR(opcode, mask, lose, flags)
 
#define FBRX(opcode, mask, lose, flags)
 
#define CONDFC(fop, cop, mask, flags)
 
#define CONDFCL(fop, cop, mask, flags)
 
#define CONDF(fop, mask, flags)
 
#define CMPFCC(x)   (((x)&0x3)<<25)
 
#define EFPOP1_2(name, op, args)   { name, F3F(2, 0x36, op), F3F(~2, ~0x36, ~(op))|RS1_G0, args, 0, sparclite }
 
#define EFPOP1_3(name, op, args)   { name, F3F(2, 0x36, op), F3F(~2, ~0x36, ~(op)), args, 0, sparclite }
 
#define EFPOP2_2(name, op, args)   { name, F3F(2, 0x37, op), F3F(~2, ~0x37, ~(op))|RD_G0, args, 0, sparclite }
 
#define BIT5   (1<<5)
 
#define SLCBCC2(opcode, mask, lose)
 
#define SLCBCC(opcode, mask)    SLCBCC2(opcode, F2(0, 7)|COND(mask), F2(~0, ~7)|COND(~(mask)))
 
#define IMPDEP(name, code)
 

Functions

enum sparc_opcode_arch_val sparc_opcode_lookup_arch (const char *name)
 
static int lookup_name (const arg *table, const char *name)
 
static const char * lookup_value (const arg *table, int value)
 
int sparc_encode_asi (const char *name)
 
const char * sparc_decode_asi (int value)
 
int sparc_encode_membar (const char *name)
 
const char * sparc_decode_membar (int value)
 
int sparc_encode_prefetch (const char *name)
 
const char * sparc_decode_prefetch (int value)
 
int sparc_encode_sparclet_cpreg (const char *name)
 
const char * sparc_decode_sparclet_cpreg (int value)
 

Variables

const struct sparc_opcode_arch sparc_opcode_archs []
 
const struct sparc_opcode sparc_opcodes []
 
const int sparc_num_opcodes = ((sizeof sparc_opcodes)/(sizeof sparc_opcodes[0]))
 
static arg asi_table []
 
static arg membar_table []
 
static arg prefetch_table []
 
static arg sparclet_cpreg_table []
 

Macro Definition Documentation

◆ BIT5

#define BIT5   (1<<5)

◆ br

#define br (   opcode,
  mask,
  lose,
  flags 
)
Value:
{ opcode, (mask)|ANNUL, (lose), ",a l", (flags), v6 }, \
{ opcode, (mask) , (lose)|ANNUL, "l", (flags), v6 }
mask
#define mask()
Definition: analysis_h8300.c:39
ANNUL
#define ANNUL
Definition: sparc.h:211
flags
static struct sockaddr static addrlen static backlog const void static flags void flags
Definition: sfsocketcall.h:123
v6
#define v6
Definition: sparc-opc.c:45

◆ brr

#define brr (   opcode,
  mask,
  lose,
  flags 
)
Value:
/* v9 */ \
{ opcode, (mask)|BPRED, ANNUL|(lose), "1,k", F_DELAYED|(flags), v9 }, \
{ opcode, (mask)|BPRED, ANNUL|(lose), ",T 1,k", F_DELAYED|(flags), v9 }, \
{ opcode, (mask)|BPRED|ANNUL, (lose), ",a 1,k", F_DELAYED|(flags), v9 }, \
{ opcode, (mask)|BPRED|ANNUL, (lose), ",a,T 1,k", F_DELAYED|(flags), v9 }, \
{ opcode, (mask), ANNUL|BPRED|(lose), ",N 1,k", F_DELAYED|(flags), v9 }, \
{ opcode, (mask)|ANNUL, BPRED|(lose), ",a,N 1,k", F_DELAYED|(flags), v9 }
F_DELAYED
#define F_DELAYED
Definition: sparc.h:102
BPRED
#define BPRED
Definition: sparc.h:212
v9
#define v9
Definition: sparc-opc.c:62

◆ brx

#define brx (   opcode,
  mask,
  lose,
  flags 
)
Value:
/* v9 */ \
{ opcode, (mask)|(2<<20)|BPRED, ANNUL|(lose), "Z,G", (flags), v9 }, \
{ opcode, (mask)|(2<<20)|BPRED, ANNUL|(lose), ",T Z,G", (flags), v9 }, \
{ opcode, (mask)|(2<<20)|BPRED|ANNUL, (lose), ",a Z,G", (flags), v9 }, \
{ opcode, (mask)|(2<<20)|BPRED|ANNUL, (lose), ",a,T Z,G", (flags), v9 }, \
{ opcode, (mask)|(2<<20), ANNUL|BPRED|(lose), ",N Z,G", (flags), v9 }, \
{ opcode, (mask)|(2<<20)|ANNUL, BPRED|(lose), ",a,N Z,G", (flags), v9 }, \
{ opcode, (mask)|BPRED, ANNUL|(lose)|(2<<20), "z,G", (flags), v9 }, \
{ opcode, (mask)|BPRED, ANNUL|(lose)|(2<<20), ",T z,G", (flags), v9 }, \
{ opcode, (mask)|BPRED|ANNUL, (lose)|(2<<20), ",a z,G", (flags), v9 }, \
{ opcode, (mask)|BPRED|ANNUL, (lose)|(2<<20), ",a,T z,G", (flags), v9 }, \
{ opcode, (mask), ANNUL|BPRED|(lose)|(2<<20), ",N z,G", (flags), v9 }, \
{ opcode, (mask)|ANNUL, BPRED|(lose)|(2<<20), ",a,N z,G", (flags), v9 }

◆ CBR

#define CBR (   opcode,
  mask,
  lose,
  flags,
  arch 
)
Value:
{ opcode, (mask), ANNUL | (lose), "l", (flags) | F_DELAYED, arch }, \
{ opcode, (mask) | ANNUL, (lose), ",a l", (flags) | F_DELAYED, arch }
arch
cs_arch arch
Definition: cstool.c:13

◆ CMPFCC

#define CMPFCC (   x)    (((x)&0x3)<<25)

◆ COMMUTEOP

#define COMMUTEOP (   opcode,
  op3,
  arch_mask 
)
Value:
{ opcode, F3(2, op3, 0), F3(~2, ~(op3), ~0)|ASI(~0), "1,2,d", 0, arch_mask }, \
{ opcode, F3(2, op3, 1), F3(~2, ~(op3), ~1), "1,i,d", 0, arch_mask }, \
{ opcode, F3(2, op3, 1), F3(~2, ~(op3), ~1), "i,1,d", 0, arch_mask }
F3
#define F3(x, y, z)
Definition: sparc.h:199
ASI
#define ASI(x)
Definition: sparc.h:202

Definition at line 172 of file sparc-opc.c.

◆ cond

#define cond (   bop,
  top,
  mask,
  flags 
)
Value:
brx(bop, F2(0, 1)|(mask), F2(~0, ~1)|((~(mask))&COND(~0)), F_DELAYED|(flags)), /* v9 */ \
br(bop, F2(0, 2)|(mask), F2(~0, ~2)|((~(mask))&COND(~0)), F_DELAYED|(flags)), \
tr(top, F3(2, 0x3a, 0)|(mask), F3(~2, ~0x3a, 0)|((~(mask))&COND(~0)), ((flags) & ~(F_UNBR|F_CONDBR)))
F_UNBR
#define F_UNBR
Definition: lanai.h:126
F_CONDBR
#define F_CONDBR
Definition: lanai.h:125
F2
#define F2(x, y)
Definition: sparc.h:198
brx
#define brx(opcode, mask, lose, flags)
COND
#define COND(x)
Definition: sparc-opc.c:108

◆ COND

#define COND (   x)    (((x) & 0xf) << 25)

Definition at line 108 of file sparc-opc.c.

◆ CONDA

#define CONDA   (COND (0x8))

Definition at line 116 of file sparc-opc.c.

◆ CONDCC

#define CONDCC   (COND (0xd))

Definition at line 117 of file sparc-opc.c.

◆ CONDCS

#define CONDCS   (COND (0x5))

Definition at line 118 of file sparc-opc.c.

◆ CONDE

#define CONDE   (COND (0x1))

Definition at line 119 of file sparc-opc.c.

◆ CONDF

#define CONDF (   fop,
  mask,
  flags 
)
Value:
FBRX(fop, F2(0, 5)|COND(mask), F2(~0, ~5)|COND(~(mask)), flags), /* v9 */ \
FBR(fop, F2(0, 6)|COND(mask), F2(~0, ~6)|COND(~(mask)), flags)
FBRX
#define FBRX(opcode, mask, lose, flags)

◆ CONDFC

#define CONDFC (   fop,
  cop,
  mask,
  flags 
)
Value:
FBRX(fop, F2(0, 5)|COND(mask), F2(~0, ~5)|COND(~(mask)), flags), /* v9 */ \
FBR(fop, F2(0, 6)|COND(mask), F2(~0, ~6)|COND(~(mask)), flags), \
CBR(cop, F2(0, 7)|COND(mask), F2(~0, ~7)|COND(~(mask)), flags, v6notlet)
v6notlet
#define v6notlet
Definition: sparc-opc.c:48

◆ CONDFCL

#define CONDFCL (   fop,
  cop,
  mask,
  flags 
)
Value:
FBRX(fop, F2(0, 5)|COND(mask), F2(~0, ~5)|COND(~(mask)), flags), /* v9 */ \
FBR(fop, F2(0, 6)|COND(mask), F2(~0, ~6)|COND(~(mask)), flags), \
CBR(cop, F2(0, 7)|COND(mask), F2(~0, ~7)|COND(~(mask)), flags, v6)

◆ CONDG

#define CONDG   (COND (0xa))

Definition at line 120 of file sparc-opc.c.

◆ CONDGE

#define CONDGE   (COND (0xb))

Definition at line 121 of file sparc-opc.c.

◆ CONDGEU

#define CONDGEU   CONDCC

Definition at line 135 of file sparc-opc.c.

◆ CONDGU

#define CONDGU   (COND (0xc))

Definition at line 122 of file sparc-opc.c.

◆ CONDL

#define CONDL   (COND (0x3))

Definition at line 123 of file sparc-opc.c.

◆ CONDLE

#define CONDLE   (COND (0x2))

Definition at line 124 of file sparc-opc.c.

◆ CONDLEU

#define CONDLEU   (COND (0x4))

Definition at line 125 of file sparc-opc.c.

◆ CONDLU

#define CONDLU   CONDCS

Definition at line 136 of file sparc-opc.c.

◆ CONDN

#define CONDN   (COND (0x0))

Definition at line 126 of file sparc-opc.c.

◆ CONDNE

#define CONDNE   (COND (0x9))

Definition at line 127 of file sparc-opc.c.

◆ CONDNEG

#define CONDNEG   (COND (0x6))

Definition at line 128 of file sparc-opc.c.

◆ CONDNZ

#define CONDNZ   CONDNE

Definition at line 133 of file sparc-opc.c.

◆ CONDPOS

#define CONDPOS   (COND (0xe))

Definition at line 129 of file sparc-opc.c.

◆ condr

#define condr (   bop,
  mask,
  flags 
)
Value:
/* v9 */ \
brr(bop, F2(0, 3)|COND(mask), F2(~0, ~3)|COND(~(mask)), (flags)) /* v9 */

◆ CONDVC

#define CONDVC   (COND (0xf))

Definition at line 130 of file sparc-opc.c.

◆ CONDVS

#define CONDVS   (COND (0x7))

Definition at line 131 of file sparc-opc.c.

◆ CONDZ

#define CONDZ   CONDE

Definition at line 134 of file sparc-opc.c.

◆ EFPOP1_2

#define EFPOP1_2 (   name,
  op,
  args 
)    { name, F3F(2, 0x36, op), F3F(~2, ~0x36, ~(op))|RS1_G0, args, 0, sparclite }

◆ EFPOP1_3

#define EFPOP1_3 (   name,
  op,
  args 
)    { name, F3F(2, 0x36, op), F3F(~2, ~0x36, ~(op)), args, 0, sparclite }

◆ EFPOP2_2

#define EFPOP2_2 (   name,
  op,
  args 
)    { name, F3F(2, 0x37, op), F3F(~2, ~0x37, ~(op))|RD_G0, args, 0, sparclite }

◆ FBFCC

#define FBFCC (   x)    (((x) & 0x3) << 20) /* v9 */

Definition at line 161 of file sparc-opc.c.

◆ FBR

#define FBR (   opcode,
  mask,
  lose,
  flags 
)
Value:
{ opcode, (mask), ANNUL | (lose), "l", (flags) | F_DELAYED | F_FBR, v6 }, \
{ opcode, (mask) | ANNUL, (lose), ",a l", (flags) | F_DELAYED | F_FBR, v6 }
F_FBR
#define F_FBR
Definition: sparc.h:108

◆ FBRX

#define FBRX (   opcode,
  mask,
  lose,
  flags 
)
Value:
/* v9 */ \
{ opcode, FBFCC(0)|(mask)|BPRED, ANNUL|FBFCC(~0)|(lose), "6,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(0)|(mask)|BPRED, ANNUL|FBFCC(~0)|(lose), ",T 6,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(0)|(mask)|BPRED|ANNUL, FBFCC(~0)|(lose), ",a 6,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(0)|(mask)|BPRED|ANNUL, FBFCC(~0)|(lose), ",a,T 6,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(0)|(mask), ANNUL|BPRED|FBFCC(~0)|(lose), ",N 6,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(0)|(mask)|ANNUL, BPRED|FBFCC(~0)|(lose), ",a,N 6,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(1)|(mask)|BPRED, ANNUL|FBFCC(~1)|(lose), "7,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(1)|(mask)|BPRED, ANNUL|FBFCC(~1)|(lose), ",T 7,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(1)|(mask)|BPRED|ANNUL, FBFCC(~1)|(lose), ",a 7,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(1)|(mask)|BPRED|ANNUL, FBFCC(~1)|(lose), ",a,T 7,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(1)|(mask), ANNUL|BPRED|FBFCC(~1)|(lose), ",N 7,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(1)|(mask)|ANNUL, BPRED|FBFCC(~1)|(lose), ",a,N 7,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(2)|(mask)|BPRED, ANNUL|FBFCC(~2)|(lose), "8,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(2)|(mask)|BPRED, ANNUL|FBFCC(~2)|(lose), ",T 8,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(2)|(mask)|BPRED|ANNUL, FBFCC(~2)|(lose), ",a 8,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(2)|(mask)|BPRED|ANNUL, FBFCC(~2)|(lose), ",a,T 8,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(2)|(mask), ANNUL|BPRED|FBFCC(~2)|(lose), ",N 8,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(2)|(mask)|ANNUL, BPRED|FBFCC(~2)|(lose), ",a,N 8,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(3)|(mask)|BPRED, ANNUL|FBFCC(~3)|(lose), "9,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(3)|(mask)|BPRED, ANNUL|FBFCC(~3)|(lose), ",T 9,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(3)|(mask)|BPRED|ANNUL, FBFCC(~3)|(lose), ",a 9,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(3)|(mask)|BPRED|ANNUL, FBFCC(~3)|(lose), ",a,T 9,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(3)|(mask), ANNUL|BPRED|FBFCC(~3)|(lose), ",N 9,G", (flags)|F_DELAYED|F_FBR, v9 }, \
{ opcode, FBFCC(3)|(mask)|ANNUL, BPRED|FBFCC(~3)|(lose), ",a,N 9,G", (flags)|F_DELAYED|F_FBR, v9 }
FBFCC
#define FBFCC(x)
Definition: sparc-opc.c:161

◆ FCC

#define FCC (   x)    (((x) & 0x3) << 11) /* v9 */

Definition at line 160 of file sparc-opc.c.

◆ FCONDA

#define FCONDA   (COND (0x8))

Definition at line 138 of file sparc-opc.c.

◆ FCONDE

#define FCONDE   (COND (0x9))

Definition at line 139 of file sparc-opc.c.

◆ FCONDG

#define FCONDG   (COND (0x6))

Definition at line 140 of file sparc-opc.c.

◆ FCONDGE

#define FCONDGE   (COND (0xb))

Definition at line 141 of file sparc-opc.c.

◆ FCONDL

#define FCONDL   (COND (0x4))

Definition at line 142 of file sparc-opc.c.

◆ FCONDLE

#define FCONDLE   (COND (0xd))

Definition at line 143 of file sparc-opc.c.

◆ FCONDLG

#define FCONDLG   (COND (0x2))

Definition at line 144 of file sparc-opc.c.

◆ FCONDN

#define FCONDN   (COND (0x0))

Definition at line 145 of file sparc-opc.c.

◆ FCONDNE

#define FCONDNE   (COND (0x1))

Definition at line 146 of file sparc-opc.c.

◆ FCONDNZ

#define FCONDNZ   FCONDNE

Definition at line 155 of file sparc-opc.c.

◆ FCONDO

#define FCONDO   (COND (0xf))

Definition at line 147 of file sparc-opc.c.

◆ FCONDU

#define FCONDU   (COND (0x7))

Definition at line 148 of file sparc-opc.c.

◆ FCONDUE

#define FCONDUE   (COND (0xa))

Definition at line 149 of file sparc-opc.c.

◆ FCONDUG

#define FCONDUG   (COND (0x5))

Definition at line 150 of file sparc-opc.c.

◆ FCONDUGE

#define FCONDUGE   (COND (0xc))

Definition at line 151 of file sparc-opc.c.

◆ FCONDUL

#define FCONDUL   (COND (0x3))

Definition at line 152 of file sparc-opc.c.

◆ FCONDULE

#define FCONDULE   (COND (0xe))

Definition at line 153 of file sparc-opc.c.

◆ FCONDZ

#define FCONDZ   FCONDE

Definition at line 156 of file sparc-opc.c.

◆ FM_DF

#define FM_DF   2 /* v9 */

◆ FM_QF

#define FM_QF   3 /* v9 */

◆ FM_SF

#define FM_SF   1 /* v9 - values for fpsize */

◆ fmovcc

#define fmovcc (   suffix,
  cond,
  fcond,
  flags 
)
Value:
/* v9 */ \
fmovccx("fmovd" suffix, FM_DF, "B,H", cond, fcond, flags), \
fmovccx("fmovq" suffix, FM_QF, "R,J", cond, fcond, flags), \
fmovccx("fmovs" suffix, FM_SF, "f,g", cond, fcond, flags)
suffix
unsigned char suffix[65536]
Definition: gun.c:164
FM_DF
#define FM_DF
cond
#define cond(bop, top, mask, flags)
FM_SF
#define FM_SF
FM_QF
#define FM_QF

◆ fmovccx

#define fmovccx (   opcode,
  fpsize,
  args,
  cond,
  fcond,
  flags 
)
Value:
/* v9 */ \
{ opcode, F3F(2, 0x35, 0x100+(fpsize))|MCOND(cond,0), F3F(~2, ~0x35, ~(0x100+(fpsize)))|MCOND(~(cond),~0), "z," args, (flags) | F_FLOAT, v9 }, \
{ opcode, F3F(2, 0x35, 0x000+(fpsize))|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x000+(fpsize)))|MCOND(~(fcond),~0), "6," args, (flags) | F_FLOAT, v9 }, \
{ opcode, F3F(2, 0x35, 0x180+(fpsize))|MCOND(cond,0), F3F(~2, ~0x35, ~(0x180+(fpsize)))|MCOND(~(cond),~0), "Z," args, (flags) | F_FLOAT, v9 }, \
{ opcode, F3F(2, 0x35, 0x040+(fpsize))|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x040+(fpsize)))|MCOND(~(fcond),~0), "7," args, (flags) | F_FLOAT, v9 }, \
{ opcode, F3F(2, 0x35, 0x080+(fpsize))|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x080+(fpsize)))|MCOND(~(fcond),~0), "8," args, (flags) | F_FLOAT, v9 }, \
{ opcode, F3F(2, 0x35, 0x0c0+(fpsize))|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x0c0+(fpsize)))|MCOND(~(fcond),~0), "9," args, (flags) | F_FLOAT, v9 }
F_FLOAT
#define F_FLOAT
Definition: sparc.h:107
F3F
#define F3F(x, y, z)
Definition: sparc.h:196
args
int args
Definition: mipsasm.c:18
MCOND
#define MCOND(x, i_or_f)
Definition: sparc-opc.c:111

◆ fmovfcc

#define fmovfcc (   suffix,
  fcond,
  flags 
)
Value:
/* v9 */ \
fmovfccx("fmovd" suffix, FM_DF, "B,H", fcond, flags), \
fmovfccx("fmovq" suffix, FM_QF, "R,J", fcond, flags), \
fmovfccx("fmovs" suffix, FM_SF, "f,g", fcond, flags)

◆ fmovfccx

#define fmovfccx (   opcode,
  fpsize,
  args,
  fcond,
  flags 
)
Value:
/* v9 */ \
{ opcode, F3F(2, 0x35, 0x000+(fpsize))|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x000+(fpsize)))|MCOND(~(fcond),~0), "6," args, flags, v9 }, \
{ opcode, F3F(2, 0x35, 0x040+(fpsize))|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x040+(fpsize)))|MCOND(~(fcond),~0), "7," args, flags, v9 }, \
{ opcode, F3F(2, 0x35, 0x080+(fpsize))|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x080+(fpsize)))|MCOND(~(fcond),~0), "8," args, flags, v9 }, \
{ opcode, F3F(2, 0x35, 0x0c0+(fpsize))|MCOND(fcond,0), F3F(~2, ~0x35, ~(0x0c0+(fpsize)))|MCOND(~(fcond),~0), "9," args, flags, v9 }

◆ fmovicc

#define fmovicc (   suffix,
  cond,
  flags 
)
Value:
/* v9 */ \
fmoviccx("fmovd" suffix, FM_DF, "B,H", cond, flags), \
fmoviccx("fmovq" suffix, FM_QF, "R,J", cond, flags), \
fmoviccx("fmovs" suffix, FM_SF, "f,g", cond, flags)

◆ fmoviccx

#define fmoviccx (   opcode,
  fpsize,
  args,
  cond,
  flags 
)
Value:
/* v9 */ \
{ opcode, F3F(2, 0x35, 0x100+(fpsize))|MCOND(cond,0), F3F(~2, ~0x35, ~(0x100+(fpsize)))|MCOND(~(cond),~0), "z," args, flags, v9 }, \
{ opcode, F3F(2, 0x35, 0x180+(fpsize))|MCOND(cond,0), F3F(~2, ~0x35, ~(0x180+(fpsize)))|MCOND(~(cond),~0), "Z," args, flags, v9 }

◆ fmovrd

#define fmovrd (   mop,
  mask,
  flags 
)
Value:
/* v9 */ \
fmrrd(mop, F3(2, 0x35, 0)|OPF_LOW5(6)|RCOND(mask), F3(~2, ~0x35, 0)|OPF_LOW5(~6)|RCOND(~(mask)), (flags)) /* v9 */
OPF_LOW5
#define OPF_LOW5(x)
Definition: sparc.h:195
RCOND
#define RCOND(x)
Definition: sparc-opc.c:114

◆ fmovrq

#define fmovrq (   mop,
  mask,
  flags 
)
Value:
/* v9 */ \
fmrrq(mop, F3(2, 0x35, 0)|OPF_LOW5(7)|RCOND(mask), F3(~2, ~0x35, 0)|OPF_LOW5(~7)|RCOND(~(mask)), (flags)) /* v9 */

◆ fmovrs

#define fmovrs (   mop,
  mask,
  flags 
)
Value:
/* v9 */ \
fmrrs(mop, F3(2, 0x35, 0)|OPF_LOW5(5)|RCOND(mask), F3(~2, ~0x35, 0)|OPF_LOW5(~5)|RCOND(~(mask)), (flags)) /* v9 */

◆ fmrrd

#define fmrrd (   opcode,
  mask,
  lose,
  flags 
)
Value:
/* v9 */ \
{ opcode, (mask), (lose), "1,B,H", (flags) | F_FLOAT, v9 }

◆ fmrrq

#define fmrrq (   opcode,
  mask,
  lose,
  flags 
)
Value:
/* v9 */ \
{ opcode, (mask), (lose), "1,R,J", (flags) | F_FLOAT, v9 }

◆ fmrrs

#define fmrrs (   opcode,
  mask,
  lose,
  flags 
)
Value:
/* v9 */ \
{ opcode, (mask), (lose), "1,f,g", (flags) | F_FLOAT, v9 }

◆ ICC

#define ICC   (0) /* v9 */

Definition at line 158 of file sparc-opc.c.

◆ IMPDEP

#define IMPDEP (   name,
  code 
)
Value:
{ name, F3(2, code, 0), F3(~2, ~(code), ~0)|ASI(~0), "1,2,d", 0, v9notv9a }, \
{ name, F3(2, code, 1), F3(~2, ~(code), ~1), "1,i,d", 0, v9notv9a }, \
{ name, F3(2, code, 0), F3(~2, ~(code), ~0), "x,1,2,d", 0, v9notv9a }, \
{ name, F3(2, code, 0), F3(~2, ~(code), ~0), "x,e,f,g", 0, v9notv9a }
name
const char * name
Definition: op.c:541
v9notv9a
#define v9notv9a
Definition: sparc-opc.c:70
code
Definition: inftree9.h:24

◆ MASK_SPARCLET

#define MASK_SPARCLET   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_SPARCLET)

Definition at line 37 of file sparc-opc.c.

◆ MASK_SPARCLITE

#define MASK_SPARCLITE   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_SPARCLITE)

Definition at line 38 of file sparc-opc.c.

◆ MASK_V6

#define MASK_V6   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V6)

Definition at line 34 of file sparc-opc.c.

◆ MASK_V7

#define MASK_V7   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V7)

Definition at line 35 of file sparc-opc.c.

◆ MASK_V8

#define MASK_V8   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V8)

Definition at line 36 of file sparc-opc.c.

◆ MASK_V9

#define MASK_V9   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9)

Definition at line 39 of file sparc-opc.c.

◆ MASK_V9A

#define MASK_V9A   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9A)

Definition at line 40 of file sparc-opc.c.

◆ MASK_V9B

#define MASK_V9B   SPARC_OPCODE_ARCH_MASK (SPARC_OPCODE_ARCH_V9B)

Definition at line 41 of file sparc-opc.c.

◆ MCOND

#define MCOND (   x,
  i_or_f 
)    ((((i_or_f) & 1) << 18) | (((x) >> 11) & (0xf << 14))) /* v9 */

Definition at line 111 of file sparc-opc.c.

◆ movcc

#define movcc (   opcode,
  cond,
  fcond,
  flags 
)
Value:
/* v9 */ \
movfcc (opcode, fcond, flags), /* v9 */ \
movicc (opcode, cond, flags) /* v9 */

◆ movfcc

#define movfcc (   opcode,
  fcond,
  flags 
)
Value:
/* v9 */ \
{ opcode, F3(2, 0x2c, 0)|FCC(0)|MCOND(fcond,0), MCOND(~(fcond),~0)|FCC(~0)|F3(~2, ~0x2c, ~0), "6,2,d", flags, v9 }, \
{ opcode, F3(2, 0x2c, 1)|FCC(0)|MCOND(fcond,0), MCOND(~(fcond),~0)|FCC(~0)|F3(~2, ~0x2c, ~1), "6,I,d", flags, v9 }, \
{ opcode, F3(2, 0x2c, 0)|FCC(1)|MCOND(fcond,0), MCOND(~(fcond),~0)|FCC(~1)|F3(~2, ~0x2c, ~0), "7,2,d", flags, v9 }, \
{ opcode, F3(2, 0x2c, 1)|FCC(1)|MCOND(fcond,0), MCOND(~(fcond),~0)|FCC(~1)|F3(~2, ~0x2c, ~1), "7,I,d", flags, v9 }, \
{ opcode, F3(2, 0x2c, 0)|FCC(2)|MCOND(fcond,0), MCOND(~(fcond),~0)|FCC(~2)|F3(~2, ~0x2c, ~0), "8,2,d", flags, v9 }, \
{ opcode, F3(2, 0x2c, 1)|FCC(2)|MCOND(fcond,0), MCOND(~(fcond),~0)|FCC(~2)|F3(~2, ~0x2c, ~1), "8,I,d", flags, v9 }, \
{ opcode, F3(2, 0x2c, 0)|FCC(3)|MCOND(fcond,0), MCOND(~(fcond),~0)|FCC(~3)|F3(~2, ~0x2c, ~0), "9,2,d", flags, v9 }, \
{ opcode, F3(2, 0x2c, 1)|FCC(3)|MCOND(fcond,0), MCOND(~(fcond),~0)|FCC(~3)|F3(~2, ~0x2c, ~1), "9,I,d", flags, v9 }
FCC
#define FCC(x)
Definition: sparc-opc.c:160

◆ movicc

#define movicc (   opcode,
  cond,
  flags 
)
Value:
/* v9 */ \
{ opcode, F3(2, 0x2c, 0)|MCOND(cond,1)|ICC, F3(~2, ~0x2c, ~0)|MCOND(~(cond),~1)|XCC|(1<<11), "z,2,d", flags, v9 }, \
{ opcode, F3(2, 0x2c, 1)|MCOND(cond,1)|ICC, F3(~2, ~0x2c, ~1)|MCOND(~(cond),~1)|XCC|(1<<11), "z,I,d", flags, v9 }, \
{ opcode, F3(2, 0x2c, 0)|MCOND(cond,1)|XCC, F3(~2, ~0x2c, ~0)|MCOND(~(cond),~1)|(1<<11), "Z,2,d", flags, v9 }, \
{ opcode, F3(2, 0x2c, 1)|MCOND(cond,1)|XCC, F3(~2, ~0x2c, ~1)|MCOND(~(cond),~1)|(1<<11), "Z,I,d", flags, v9 }
ICC
#define ICC
Definition: sparc-opc.c:158
XCC
#define XCC
Definition: sparc-opc.c:159

◆ movr

#define movr (   opcode,
  mask,
  flags 
)
Value:
/* v9 */ \
{ opcode, F3(2, 0x2f, 0)|RCOND(mask), F3(~2, ~0x2f, ~0)|RCOND(~(mask)), "1,2,d", (flags), v9 }, \
{ opcode, F3(2, 0x2f, 1)|RCOND(mask), F3(~2, ~0x2f, ~1)|RCOND(~(mask)), "1,j,d", (flags), v9 }

◆ RCOND

#define RCOND (   x)    (((x) & 0x7) << 10) /* v9 */

Definition at line 114 of file sparc-opc.c.

◆ SLCBCC

#define SLCBCC (   opcode,
  mask 
)     SLCBCC2(opcode, F2(0, 7)|COND(mask), F2(~0, ~7)|COND(~(mask)))

◆ SLCBCC2

#define SLCBCC2 (   opcode,
  mask,
  lose 
)
Value:
{ opcode, (mask), ANNUL|(lose), "l", F_DELAYED|F_CONDBR, sparclet }, \
{ opcode, (mask)|ANNUL, (lose), ",a l", F_DELAYED|F_CONDBR, sparclet }
sparclet
#define sparclet
Definition: sparc-opc.c:60

◆ sparclet

#define sparclet   (MASK_SPARCLET)

Definition at line 60 of file sparc-opc.c.

◆ sparclite

#define sparclite   (MASK_SPARCLITE)

Definition at line 61 of file sparc-opc.c.

◆ tr

#define tr (   opcode,
  mask,
  lose,
  flags 
)
Value:
{ opcode, (mask)|(2<<11)|IMMED, (lose)|RS1_G0, "Z,i", (flags), v9 }, /* %g0 + imm */ \
{ opcode, (mask)|(2<<11)|IMMED, (lose), "Z,1+i", (flags), v9 }, /* rs1 + imm */ \
{ opcode, (mask)|(2<<11), IMMED|(lose), "Z,1+2", (flags), v9 }, /* rs1 + rs2 */ \
{ opcode, (mask)|(2<<11), IMMED|(lose)|RS2_G0, "Z,1", (flags), v9 }, /* rs1 + %g0 */ \
{ opcode, (mask)|IMMED, (lose)|RS1_G0, "z,i", (flags)|F_ALIAS, v9 }, /* %g0 + imm */ \
{ opcode, (mask)|IMMED, (lose), "z,1+i", (flags)|F_ALIAS, v9 }, /* rs1 + imm */ \
{ opcode, (mask), IMMED|(lose), "z,1+2", (flags)|F_ALIAS, v9 }, /* rs1 + rs2 */ \
{ opcode, (mask), IMMED|(lose)|RS2_G0, "z,1", (flags)|F_ALIAS, v9 }, /* rs1 + %g0 */ \
{ opcode, (mask)|IMMED, (lose)|RS1_G0, "i", (flags), v6 }, /* %g0 + imm */ \
{ opcode, (mask)|IMMED, (lose), "1+i", (flags), v6 }, /* rs1 + imm */ \
{ opcode, (mask), IMMED|(lose), "1+2", (flags), v6 }, /* rs1 + rs2 */ \
{ opcode, (mask), IMMED|(lose)|RS2_G0, "1", (flags), v6 } /* rs1 + %g0 */
F_ALIAS
#define F_ALIAS
Definition: aarch64.h:722
RS2_G0
#define RS2_G0
Definition: sparc.h:216
IMMED
#define IMMED
Definition: sparc.h:213
RS1_G0
#define RS1_G0
Definition: sparc.h:215

◆ v6

#define v6
Value:
(MASK_V6 | MASK_V7 | MASK_V8 | MASK_SPARCLET \
| MASK_SPARCLITE | MASK_V9 | MASK_V9A | MASK_V9B)
MASK_SPARCLET
#define MASK_SPARCLET
Definition: sparc-opc.c:37
MASK_SPARCLITE
#define MASK_SPARCLITE
Definition: sparc-opc.c:38
MASK_V8
#define MASK_V8
Definition: sparc-opc.c:36
MASK_V6
#define MASK_V6
Definition: sparc-opc.c:34
MASK_V9
#define MASK_V9
Definition: sparc-opc.c:39
MASK_V9A
#define MASK_V9A
Definition: sparc-opc.c:40
MASK_V7
#define MASK_V7
Definition: sparc-opc.c:35
MASK_V9B
#define MASK_V9B
Definition: sparc-opc.c:41

Definition at line 45 of file sparc-opc.c.

◆ v6notlet

#define v6notlet
Value:
(MASK_V6 | MASK_V7 | MASK_V8 \
| MASK_SPARCLITE | MASK_V9 | MASK_V9A | MASK_V9B)

Definition at line 48 of file sparc-opc.c.

◆ v6notv9

#define v6notv9
Value:
(MASK_V6 | MASK_V7 | MASK_V8 \
| MASK_SPARCLET | MASK_SPARCLITE)

Definition at line 66 of file sparc-opc.c.

◆ v7

#define v7
Value:
(MASK_V7 | MASK_V8 | MASK_SPARCLET \
| MASK_SPARCLITE | MASK_V9 | MASK_V9A | MASK_V9B)

Definition at line 50 of file sparc-opc.c.

◆ v8

v2 v22 v2 v22 v2 v15 v2 v14 v2 v22 v2 v22 v2 v15 v2 v14 v2 v22 v2 v22 v2 v22 v2 v22 v2 v8
Value:
(MASK_V8 | MASK_SPARCLET | MASK_SPARCLITE \
| MASK_V9 | MASK_V9A | MASK_V9B)

Definition at line 58 of file sparc-opc.c.

◆ v9

#define v9   (MASK_V9 | MASK_V9A | MASK_V9B)

Definition at line 62 of file sparc-opc.c.

◆ v9a

#define v9a   (MASK_V9A | MASK_V9B)

Definition at line 63 of file sparc-opc.c.

◆ v9b

#define v9b   (MASK_V9B)

Definition at line 64 of file sparc-opc.c.

◆ v9notv9a

#define v9notv9a   (MASK_V9)

Definition at line 70 of file sparc-opc.c.

◆ XCC

#define XCC   (1 << 12) /* v9 */

Definition at line 159 of file sparc-opc.c.

Function Documentation

◆ lookup_name()

static int lookup_name ( const arg *  table,
const char *  name 
)
static

Definition at line 1844 of file sparc-opc.c.

1845 {
1846  const arg *p;
1847 
1848  for (p = table; p->name; ++p) {
1849  if (strcmp (name, p->name) == 0) {
1850  return p->value;
1851  }
1852  }
1853 
1854  return -1;
1855 }
p
void * p
Definition: libc.cpp:67
name
Definition: z80asm.h:102

References p.

Referenced by sparc_encode_asi(), sparc_encode_membar(), sparc_encode_prefetch(), and sparc_encode_sparclet_cpreg().

◆ lookup_value()

static const char* lookup_value ( const arg *  table,
int  value 
)
static

Definition at line 1860 of file sparc-opc.c.

1861 {
1862  const arg *p;
1863 
1864  for (p = table; p->name; ++p) {
1865  if (value == p->value) {
1866  return p->name;
1867  }
1868  }
1869 
1870  return NULL;
1871 }
value
static int value
Definition: cmd_api.c:93
NULL
#define NULL
Definition: cris-opc.c:27

References NULL, p, and value.

Referenced by sparc_decode_asi(), sparc_decode_membar(), sparc_decode_prefetch(), and sparc_decode_sparclet_cpreg().

◆ sparc_decode_asi()

const char* sparc_decode_asi ( int  value)

Definition at line 2051 of file sparc-opc.c.

2052 {
2053  return lookup_value (asi_table, value);
2054 }
lookup_value
static const char * lookup_value(const arg *table, int value)
Definition: sparc-opc.c:1860
asi_table
static arg asi_table[]
Definition: sparc-opc.c:1875

References asi_table, lookup_value(), and value.

Referenced by print_insn_sparc().

◆ sparc_decode_membar()

const char* sparc_decode_membar ( int  value)

Definition at line 2081 of file sparc-opc.c.

2082 {
2083  return lookup_value (membar_table, value);
2084 }
membar_table
static arg membar_table[]
Definition: sparc-opc.c:2058

References lookup_value(), membar_table, and value.

Referenced by print_insn_sparc().

◆ sparc_decode_prefetch()

const char* sparc_decode_prefetch ( int  value)

Definition at line 2115 of file sparc-opc.c.

2116 {
2117  return lookup_value (prefetch_table, value);
2118 }
prefetch_table
static arg prefetch_table[]
Definition: sparc-opc.c:2088

References lookup_value(), prefetch_table, and value.

Referenced by print_insn_sparc().

◆ sparc_decode_sparclet_cpreg()

const char* sparc_decode_sparclet_cpreg ( int  value)

Definition at line 2145 of file sparc-opc.c.

2146 {
2147  return lookup_value (sparclet_cpreg_table, value);
2148 }
sparclet_cpreg_table
static arg sparclet_cpreg_table[]
Definition: sparc-opc.c:2122

References lookup_value(), sparclet_cpreg_table, and value.

Referenced by print_insn_sparc().

◆ sparc_encode_asi()

int sparc_encode_asi ( const char *  name)

Definition at line 2043 of file sparc-opc.c.

2044 {
2045  return lookup_name (asi_table, name);
2046 }
lookup_name
static int lookup_name(const arg *table, const char *name)
Definition: sparc-opc.c:1844

References asi_table, and lookup_name().

◆ sparc_encode_membar()

int sparc_encode_membar ( const char *  name)

Definition at line 2073 of file sparc-opc.c.

2074 {
2075  return lookup_name (membar_table, name);
2076 }

References lookup_name(), and membar_table.

◆ sparc_encode_prefetch()

int sparc_encode_prefetch ( const char *  name)

Definition at line 2107 of file sparc-opc.c.

2108 {
2109  return lookup_name (prefetch_table, name);
2110 }

References lookup_name(), and prefetch_table.

◆ sparc_encode_sparclet_cpreg()

int sparc_encode_sparclet_cpreg ( const char *  name)

Definition at line 2137 of file sparc-opc.c.

2138 {
2139  return lookup_name (sparclet_cpreg_table, name);
2140 }

References lookup_name(), and sparclet_cpreg_table.

◆ sparc_opcode_lookup_arch()

enum sparc_opcode_arch_val sparc_opcode_lookup_arch ( const char *  name)

Definition at line 1 of file sparc-opc.c.

95 {
96  const struct sparc_opcode_arch *p;
97 
98  for (p = &sparc_opcode_archs[0]; p->name; ++p) {
99  if (strcmp (name, p->name) == 0) {
100  return (enum sparc_opcode_arch_val) (p - &sparc_opcode_archs[0]);
101  }
102  }
103 
104  return SPARC_OPCODE_ARCH_BAD;
105 }
sparc_opcode_arch_val
sparc_opcode_arch_val
Definition: sparc.h:43
SPARC_OPCODE_ARCH_BAD
@ SPARC_OPCODE_ARCH_BAD
Definition: sparc.h:53
sparc_opcode_archs
const struct sparc_opcode_arch sparc_opcode_archs[]
Definition: sparc-opc.c:75
sparc_opcode_arch
Definition: sparc.h:68

Variable Documentation

◆ asi_table

arg asi_table[]
static

Definition at line 1875 of file sparc-opc.c.

Referenced by sparc_decode_asi(), and sparc_encode_asi().

◆ membar_table

arg membar_table[]
static
Initial value:
=
{
{ 0x40, "#Sync" },
{ 0x20, "#MemIssue" },
{ 0x10, "#Lookaside" },
{ 0x08, "#StoreStore" },
{ 0x04, "#LoadStore" },
{ 0x02, "#StoreLoad" },
{ 0x01, "#LoadLoad" },
{ 0, 0 }
}

Definition at line 2058 of file sparc-opc.c.

Referenced by sparc_decode_membar(), and sparc_encode_membar().

◆ prefetch_table

arg prefetch_table[]
static
Initial value:
=
{
{ 0, "#n_reads" },
{ 1, "#one_read" },
{ 2, "#n_writes" },
{ 3, "#one_write" },
{ 4, "#page" },
{ 16, "#invalidate" },
{ 17, "#unified", },
{ 20, "#n_reads_strong", },
{ 21, "#one_read_strong", },
{ 22, "#n_writes_strong", },
{ 23, "#one_write_strong", },
{ 0, 0 }
}

Definition at line 2088 of file sparc-opc.c.

Referenced by sparc_decode_prefetch(), and sparc_encode_prefetch().

◆ sparc_num_opcodes

const int sparc_num_opcodes = ((sizeof sparc_opcodes)/(sizeof sparc_opcodes[0]))

Definition at line 1831 of file sparc-opc.c.

Referenced by print_insn_sparc().

◆ sparc_opcode_archs

const struct sparc_opcode_arch sparc_opcode_archs[]
Initial value:
=
{
{ "v6", MASK_V6 },
{ "v7", MASK_V6 | MASK_V7 },
{ "v8", MASK_V6 | MASK_V7 | MASK_V8 },
{ "sparclet", MASK_V6 | MASK_V7 | MASK_V8 | MASK_SPARCLET },
{ "sparclite", MASK_V6 | MASK_V7 | MASK_V8 | MASK_SPARCLITE },
{ "v9", MASK_V6 | MASK_V7 | MASK_V8 | MASK_V9 },
{ "v9a", MASK_V6 | MASK_V7 | MASK_V8 | MASK_V9 | MASK_V9A },
{ "v9b", MASK_V6 | MASK_V7 | MASK_V8 | MASK_V9 | MASK_V9A | MASK_V9B },
{ NULL, 0 }
}

Definition at line 1 of file sparc-opc.c.

◆ sparc_opcodes

const struct sparc_opcode sparc_opcodes[]

Definition at line 1 of file sparc-opc.c.

Referenced by print_insn_sparc().

◆ sparclet_cpreg_table

arg sparclet_cpreg_table[]
static
Initial value:
=
{
{ 0, "%ccsr" },
{ 1, "%ccfr" },
{ 2, "%cccrcr" },
{ 3, "%ccpr" },
{ 4, "%ccsr2" },
{ 5, "%cccrr" },
{ 6, "%ccrstr" },
{ 0, 0 }
}

Definition at line 2122 of file sparc-opc.c.

Referenced by sparc_decode_sparclet_cpreg(), and sparc_encode_sparclet_cpreg().