go/src/cmd/internal/obj/s390x/asmz.go

type ctxtz

const funcAlign

type Optab

var optab

var oprange

var xcmp

func spanz(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {}

// Return whether p is an unsafe point.
func (c *ctxtz) isUnsafePoint(p *obj.Prog) bool {}

func isint32(v int64) bool {}

func isuint32(v uint64) bool {}

func (c *ctxtz) aclass(a *obj.Addr) int {}

func (c *ctxtz) oplook(p *obj.Prog) *Optab {}

func cmp(a int, b int) bool {}

func ocmp(p1, p2 Optab) int {}

func opset(a, b obj.As) {}

func buildop(ctxt *obj.Link) {}

const op_A

const op_AD

const op_ADB

const op_ADBR

const op_ADR

const op_ADTR

const op_ADTRA

const op_AE

const op_AEB

const op_AEBR

const op_AER

const op_AFI

const op_AG

const op_AGF

const op_AGFI

const op_AGFR

const op_AGHI

const op_AGHIK

const op_AGR

const op_AGRK

const op_AGSI

const op_AH

const op_AHHHR

const op_AHHLR

const op_AHI

const op_AHIK

const op_AHY

const op_AIH

const op_AL

const op_ALC

const op_ALCG

const op_ALCGR

const op_ALCR

const op_ALFI

const op_ALG

const op_ALGF

const op_ALGFI

const op_ALGFR

const op_ALGHSIK

const op_ALGR

const op_ALGRK

const op_ALGSI

const op_ALHHHR

const op_ALHHLR

const op_ALHSIK

const op_ALR

const op_ALRK

const op_ALSI

const op_ALSIH

const op_ALSIHN

const op_ALY

const op_AP

const op_AR

const op_ARK

const op_ASI

const op_AU

const op_AUR

const op_AW

const op_AWR

const op_AXBR

const op_AXR

const op_AXTR

const op_AXTRA

const op_AY

const op_BAKR

const op_BAL

const op_BALR

const op_BAS

const op_BASR

const op_BASSM

const op_BC

const op_BCR

const op_BCT

const op_BCTG

const op_BCTGR

const op_BCTR

const op_BPP

const op_BPRP

const op_BRAS

const op_BRASL

const op_BRC

const op_BRCL

const op_BRCT

const op_BRCTG

const op_BRCTH

const op_BRXH

const op_BRXHG

const op_BRXLE

const op_BRXLG

const op_BSA

const op_BSG

const op_BSM

const op_BXH

const op_BXHG

const op_BXLE

const op_BXLEG

const op_C

const op_CD

const op_CDB

const op_CDBR

const op_CDFBR

const op_CDFBRA

const op_CDFR

const op_CDFTR

const op_CDGBR

const op_CDGBRA

const op_CDGR

const op_CDGTR

const op_CDGTRA

const op_CDLFBR

const op_CDLFTR

const op_CDLGBR

const op_CDLGTR

const op_CDR

const op_CDS

const op_CDSG

const op_CDSTR

const op_CDSY

const op_CDTR

const op_CDUTR

const op_CDZT

const op_CE

const op_CEB

const op_CEBR

const op_CEDTR

const op_CEFBR

const op_CEFBRA

const op_CEFR

const op_CEGBR

const op_CEGBRA

const op_CEGR

const op_CELFBR

const op_CELGBR

const op_CER

const op_CEXTR

const op_CFC

const op_CFDBR

const op_CFDBRA

const op_CFDR

const op_CFDTR

const op_CFEBR

const op_CFEBRA

const op_CFER

const op_CFI

const op_CFXBR

const op_CFXBRA

const op_CFXR

const op_CFXTR

const op_CG

const op_CGDBR

const op_CGDBRA

const op_CGDR

const op_CGDTR

const op_CGDTRA

const op_CGEBR

const op_CGEBRA

const op_CGER

const op_CGF

const op_CGFI

const op_CGFR

const op_CGFRL

const op_CGH

const op_CGHI

const op_CGHRL

const op_CGHSI

const op_CGIB

const op_CGIJ

const op_CGIT

const op_CGR

const op_CGRB

const op_CGRJ

const op_CGRL

const op_CGRT

const op_CGXBR

const op_CGXBRA

const op_CGXR

const op_CGXTR

const op_CGXTRA

const op_CH

const op_CHF

const op_CHHR

const op_CHHSI

const op_CHI

const op_CHLR

const op_CHRL

const op_CHSI

const op_CHY

const op_CIB

const op_CIH

const op_CIJ

const op_CIT

const op_CKSM

const op_CL

const op_CLC

const op_CLCL

const op_CLCLE

const op_CLCLU

const op_CLFDBR

const op_CLFDTR

const op_CLFEBR

const op_CLFHSI

const op_CLFI

const op_CLFIT

const op_CLFXBR

const op_CLFXTR

const op_CLG

const op_CLGDBR

const op_CLGDTR

const op_CLGEBR

const op_CLGF

const op_CLGFI

const op_CLGFR

const op_CLGFRL

const op_CLGHRL

const op_CLGHSI

const op_CLGIB

const op_CLGIJ

const op_CLGIT

const op_CLGR

const op_CLGRB

const op_CLGRJ

const op_CLGRL

const op_CLGRT

const op_CLGT

const op_CLGXBR

const op_CLGXTR

const op_CLHF

const op_CLHHR

const op_CLHHSI

const op_CLHLR

const op_CLHRL

const op_CLI

const op_CLIB

const op_CLIH

const op_CLIJ

const op_CLIY

const op_CLM

const op_CLMH

const op_CLMY

const op_CLR

const op_CLRB

const op_CLRJ

const op_CLRL

const op_CLRT

const op_CLST

const op_CLT

const op_CLY

const op_CMPSC

const op_CP

const op_CPSDR

const op_CPYA

const op_CR

const op_CRB

const op_CRDTE

const op_CRJ

const op_CRL

const op_CRT

const op_CS

const op_CSCH

const op_CSDTR

const op_CSG

const op_CSP

const op_CSPG

const op_CSST

const op_CSXTR

const op_CSY

const op_CU12

const op_CU14

const op_CU21

const op_CU24

const op_CU41

const op_CU42

const op_CUDTR

const op_CUSE

const op_CUTFU

const op_CUUTF

const op_CUXTR

const op_CVB

const op_CVBG

const op_CVBY

const op_CVD

const op_CVDG

const op_CVDY

const op_CXBR

const op_CXFBR

const op_CXFBRA

const op_CXFR

const op_CXFTR

const op_CXGBR

const op_CXGBRA

const op_CXGR

const op_CXGTR

const op_CXGTRA

const op_CXLFBR

const op_CXLFTR

const op_CXLGBR

const op_CXLGTR

const op_CXR

const op_CXSTR

const op_CXTR

const op_CXUTR

const op_CXZT

const op_CY

const op_CZDT

const op_CZXT

const op_D

const op_DD

const op_DDB

const op_DDBR

const op_DDR

const op_DDTR

const op_DDTRA

const op_DE

const op_DEB

const op_DEBR

const op_DER

const op_DIDBR

const op_DIEBR

const op_DL

const op_DLG

const op_DLGR

const op_DLR

const op_DP

const op_DR

const op_DSG

const op_DSGF

const op_DSGFR

const op_DSGR

const op_DXBR

const op_DXR

const op_DXTR

const op_DXTRA

const op_EAR

const op_ECAG

const op_ECTG

const op_ED

const op_EDMK

const op_EEDTR

const op_EEXTR

const op_EFPC

const op_EPAIR

const op_EPAR

const op_EPSW

const op_EREG

const op_EREGG

const op_ESAIR

const op_ESAR

const op_ESDTR

const op_ESEA

const op_ESTA

const op_ESXTR

const op_ETND

const op_EX

const op_EXRL

const op_FIDBR

const op_FIDBRA

const op_FIDR

const op_FIDTR

const op_FIEBR

const op_FIEBRA

const op_FIER

const op_FIXBR

const op_FIXBRA

const op_FIXR

const op_FIXTR

const op_FLOGR

const op_HDR

const op_HER

const op_HSCH

const op_IAC

const op_IC

const op_ICM

const op_ICMH

const op_ICMY

const op_ICY

const op_IDTE

const op_IEDTR

const op_IEXTR

const op_IIHF

const op_IIHH

const op_IIHL

const op_IILF

const op_IILH

const op_IILL

const op_IPK

const op_IPM

const op_IPTE

const op_ISKE

const op_IVSK

const op_KDB

const op_KDBR

const op_KDTR

const op_KEB

const op_KEBR

const op_KIMD

const op_KLMD

const op_KM

const op_KMAC

const op_KMC

const op_KMA

const op_KMCTR

const op_KMF

const op_KMO

const op_KXBR

const op_KXTR

const op_L

const op_LA

const op_LAA

const op_LAAG

const op_LAAL

const op_LAALG

const op_LAE

const op_LAEY

const op_LAM

const op_LAMY

const op_LAN

const op_LANG

const op_LAO

const op_LAOG

const op_LARL

const op_LASP

const op_LAT

const op_LAX

const op_LAXG

const op_LAY

const op_LB

const op_LBH

const op_LBR

const op_LCDBR

const op_LCDFR

const op_LCDR

const op_LCEBR

const op_LCER

const op_LCGFR

const op_LCGR

const op_LCR

const op_LCTL

const op_LCTLG

const op_LCXBR

const op_LCXR

const op_LD

const op_LDE

const op_LDEB

const op_LDEBR

const op_LDER

const op_LDETR

const op_LDGR

const op_LDR

const op_LDXBR

const op_LDXBRA

const op_LDXR

const op_LDXTR

const op_LDY

const op_LE

const op_LEDBR

const op_LEDBRA

const op_LEDR

const op_LEDTR

const op_LER

const op_LEXBR

const op_LEXBRA

const op_LEXR

const op_LEY

const op_LFAS

const op_LFH

const op_LFHAT

const op_LFPC

const op_LG

const op_LGAT

const op_LGB

const op_LGBR

const op_LGDR

const op_LGF

const op_LGFI

const op_LGFR

const op_LGFRL

const op_LGH

const op_LGHI

const op_LGHR

const op_LGHRL

const op_LGR

const op_LGRL

const op_LH

const op_LHH

const op_LHI

const op_LHR

const op_LHRL

const op_LHY

const op_LLC

const op_LLCH

const op_LLCR

const op_LLGC

const op_LLGCR

const op_LLGF

const op_LLGFAT

const op_LLGFR

const op_LLGFRL

const op_LLGH

const op_LLGHR

const op_LLGHRL

const op_LLGT

const op_LLGTAT

const op_LLGTR

const op_LLH

const op_LLHH

const op_LLHR

const op_LLHRL

const op_LLIHF

const op_LLIHH

const op_LLIHL

const op_LLILF

const op_LLILH

const op_LLILL

const op_LM

const op_LMD

const op_LMG

const op_LMH

const op_LMY

const op_LNDBR

const op_LNDFR

const op_LNDR

const op_LNEBR

const op_LNER

const op_LNGFR

const op_LNGR

const op_LNR

const op_LNXBR

const op_LNXR

const op_LOC

const op_LOCG

const op_LOCGR

const op_LOCR

const op_LPD

const op_LPDBR

const op_LPDFR

const op_LPDG

const op_LPDR

const op_LPEBR

const op_LPER

const op_LPGFR

const op_LPGR

const op_LPQ

const op_LPR

const op_LPSW

const op_LPSWE

const op_LPTEA

const op_LPXBR

const op_LPXR

const op_LR

const op_LRA

const op_LRAG

const op_LRAY

const op_LRDR

const op_LRER

const op_LRL

const op_LRV

const op_LRVG

const op_LRVGR

const op_LRVH

const op_LRVR

const op_LT

const op_LTDBR

const op_LTDR

const op_LTDTR

const op_LTEBR

const op_LTER

const op_LTG

const op_LTGF

const op_LTGFR

const op_LTGR

const op_LTR

const op_LTXBR

const op_LTXR

const op_LTXTR

const op_LURA

const op_LURAG

const op_LXD

const op_LXDB

const op_LXDBR

const op_LXDR

const op_LXDTR

const op_LXE

const op_LXEB

const op_LXEBR

const op_LXER

const op_LXR

const op_LY

const op_LZDR

const op_LZER

const op_LZXR

const op_M

const op_MAD

const op_MADB

const op_MADBR

const op_MADR

const op_MAE

const op_MAEB

const op_MAEBR

const op_MAER

const op_MAY

const op_MAYH

const op_MAYHR

const op_MAYL

const op_MAYLR

const op_MAYR

const op_MC

const op_MD

const op_MDB

const op_MDBR

const op_MDE

const op_MDEB

const op_MDEBR

const op_MDER

const op_MDR

const op_MDTR

const op_MDTRA

const op_ME

const op_MEE

const op_MEEB

const op_MEEBR

const op_MEER

const op_MER

const op_MFY

const op_MGHI

const op_MH

const op_MHI

const op_MHY

const op_ML

const op_MLG

const op_MLGR

const op_MLR

const op_MP

const op_MR

const op_MS

const op_MSCH

const op_MSD

const op_MSDB

const op_MSDBR

const op_MSDR

const op_MSE

const op_MSEB

const op_MSEBR

const op_MSER

const op_MSFI

const op_MSG

const op_MSGF

const op_MSGFI

const op_MSGFR

const op_MSGR

const op_MSR

const op_MSTA

const op_MSY

const op_MVC

const op_MVCDK

const op_MVCIN

const op_MVCK

const op_MVCL

const op_MVCLE

const op_MVCLU

const op_MVCOS

const op_MVCP

const op_MVCS

const op_MVCSK

const op_MVGHI

const op_MVHHI

const op_MVHI

const op_MVI

const op_MVIY

const op_MVN

const op_MVO

const op_MVPG

const op_MVST

const op_MVZ

const op_MXBR

const op_MXD

const op_MXDB

const op_MXDBR

const op_MXDR

const op_MXR

const op_MXTR

const op_MXTRA

const op_MY

const op_MYH

const op_MYHR

const op_MYL

const op_MYLR

const op_MYR

const op_N

const op_NC

const op_NG

const op_NGR

const op_NGRK

const op_NI

const op_NIAI

const op_NIHF

const op_NIHH

const op_NIHL

const op_NILF

const op_NILH

const op_NILL

const op_NIY

const op_NR

const op_NRK

const op_NTSTG

const op_NY

const op_O

const op_OC

const op_OG

const op_OGR

const op_OGRK

const op_OI

const op_OIHF

const op_OIHH

const op_OIHL

const op_OILF

const op_OILH

const op_OILL

const op_OIY

const op_OR

const op_ORK

const op_OY

const op_PACK

const op_PALB

const op_PC

const op_PCC

const op_PCKMO

const op_PFD

const op_PFDRL

const op_PFMF

const op_PFPO

const op_PGIN

const op_PGOUT

const op_PKA

const op_PKU

const op_PLO

const op_POPCNT

const op_PPA

const op_PR

const op_PT

const op_PTF

const op_PTFF

const op_PTI

const op_PTLB

const op_QADTR

const op_QAXTR

const op_RCHP

const op_RISBG

const op_RISBGN

const op_RISBHG

const op_RISBLG

const op_RLL

const op_RLLG

const op_RNSBG

const op_ROSBG

const op_RP

const op_RRBE

const op_RRBM

const op_RRDTR

const op_RRXTR

const op_RSCH

const op_RXSBG

const op_S

const op_SAC

const op_SACF

const op_SAL

const op_SAM24

const op_SAM31

const op_SAM64

const op_SAR

const op_SCHM

const op_SCK

const op_SCKC

const op_SCKPF

const op_SD

const op_SDB

const op_SDBR

const op_SDR

const op_SDTR

const op_SDTRA

const op_SE

const op_SEB

const op_SEBR

const op_SER

const op_SFASR

const op_SFPC

const op_SG

const op_SGF

const op_SGFR

const op_SGR

const op_SGRK

const op_SH

const op_SHHHR

const op_SHHLR

const op_SHY

const op_SIGP

const op_SL

const op_SLA

const op_SLAG

const op_SLAK

const op_SLB

const op_SLBG

const op_SLBGR

const op_SLBR

const op_SLDA

const op_SLDL

const op_SLDT

const op_SLFI

const op_SLG

const op_SLGF

const op_SLGFI

const op_SLGFR

const op_SLGR

const op_SLGRK

const op_SLHHHR

const op_SLHHLR

const op_SLL

const op_SLLG

const op_SLLK

const op_SLR

const op_SLRK

const op_SLXT

const op_SLY

const op_SP

const op_SPKA

const op_SPM

const op_SPT

const op_SPX

const op_SQD

const op_SQDB

const op_SQDBR

const op_SQDR

const op_SQE

const op_SQEB

const op_SQEBR

const op_SQER

const op_SQXBR

const op_SQXR

const op_SR

const op_SRA

const op_SRAG

const op_SRAK

const op_SRDA

const op_SRDL

const op_SRDT

const op_SRK

const op_SRL

const op_SRLG

const op_SRLK

const op_SRNM

const op_SRNMB

const op_SRNMT

const op_SRP

const op_SRST

const op_SRSTU

const op_SRXT

const op_SSAIR

const op_SSAR

const op_SSCH

const op_SSKE

const op_SSM

const op_ST

const op_STAM

const op_STAMY

const op_STAP

const op_STC

const op_STCH

const op_STCK

const op_STCKC

const op_STCKE

const op_STCKF

const op_STCM

const op_STCMH

const op_STCMY

const op_STCPS

const op_STCRW

const op_STCTG

const op_STCTL

const op_STCY

const op_STD

const op_STDY

const op_STE

const op_STEY

const op_STFH

const op_STFL

const op_STFLE

const op_STFPC

const op_STG

const op_STGRL

const op_STH

const op_STHH

const op_STHRL

const op_STHY

const op_STIDP

const op_STM

const op_STMG

const op_STMH

const op_STMY

const op_STNSM

const op_STOC

const op_STOCG

const op_STOSM

const op_STPQ

const op_STPT

const op_STPX

const op_STRAG

const op_STRL

const op_STRV

const op_STRVG

const op_STRVH

const op_STSCH

const op_STSI

const op_STURA

const op_STURG

const op_STY

const op_SU

const op_SUR

const op_SVC

const op_SW

const op_SWR

const op_SXBR

const op_SXR

const op_SXTR

const op_SXTRA

const op_SY

const op_TABORT

const op_TAM

const op_TAR

const op_TB

const op_TBDR

const op_TBEDR

const op_TBEGIN

const op_TBEGINC

const op_TCDB

const op_TCEB

const op_TCXB

const op_TDCDT

const op_TDCET

const op_TDCXT

const op_TDGDT

const op_TDGET

const op_TDGXT

const op_TEND

const op_THDER

const op_THDR

const op_TM

const op_TMH

const op_TMHH

const op_TMHL

const op_TML

const op_TMLH

const op_TMLL

const op_TMY

const op_TP

const op_TPI

const op_TPROT

const op_TR

const op_TRACE

const op_TRACG

const op_TRAP2

const op_TRAP4

const op_TRE

const op_TROO

const op_TROT

const op_TRT

const op_TRTE

const op_TRTO

const op_TRTR

const op_TRTRE

const op_TRTT

const op_TS

const op_TSCH

const op_UNPK

const op_UNPKA

const op_UNPKU

const op_UPT

const op_X

const op_XC

const op_XG

const op_XGR

const op_XGRK

const op_XI

const op_XIHF

const op_XILF

const op_XIY

const op_XR

const op_XRK

const op_XSCH

const op_XY

const op_ZAP

const op_BRRK

const op_CXPT

const op_CDPT

const op_CPXT

const op_CPDT

const op_LZRF

const op_LZRG

const op_LCCB

const op_LOCHHI

const op_LOCHI

const op_LOCGHI

const op_LOCFH

const op_LOCFHR

const op_LLZRGF

const op_STOCFH

const op_VA

const op_VACC

const op_VAC

const op_VACCC

const op_VN

const op_VNC

const op_VAVG

const op_VAVGL

const op_VCKSM

const op_VCEQ

const op_VCH

const op_VCHL

const op_VCLZ

const op_VCTZ

const op_VEC

const op_VECL

const op_VERIM

const op_VERLL

const op_VERLLV

const op_VESLV

const op_VESL

const op_VESRA

const op_VESRAV

const op_VESRL

const op_VESRLV

const op_VX

const op_VFAE

const op_VFEE

const op_VFENE

const op_VFA

const op_WFK

const op_VFCE

const op_VFCH

const op_VFCHE

const op_WFC

const op_VCDG

const op_VCDLG

const op_VCGD

const op_VCLGD

const op_VFD

const op_VLDE

const op_VLED

const op_VFM

const op_VFMA

const op_VFMS

const op_VFPSO

const op_VFSQ

const op_VFS

const op_VFTCI

const op_VGFM

const op_VGFMA

const op_VGEF

const op_VGEG

const op_VGBM

const op_VGM

const op_VISTR

const op_VL

const op_VLR

const op_VLREP

const op_VLC

const op_VLEH

const op_VLEF

const op_VLEG

const op_VLEB

const op_VLEIH

const op_VLEIF

const op_VLEIG

const op_VLEIB

const op_VFI

const op_VLGV

const op_VLLEZ

const op_VLM

const op_VLP

const op_VLBB

const op_VLVG

const op_VLVGP

const op_VLL

const op_VMX

const op_VMXL

const op_VMRH

const op_VMRL

const op_VMN

const op_VMNL

const op_VMAE

const op_VMAH

const op_VMALE

const op_VMALH

const op_VMALO

const op_VMAL

const op_VMAO

const op_VME

const op_VMH

const op_VMLE

const op_VMLH

const op_VMLO

const op_VML

const op_VMO

const op_VNO

const op_VO

const op_VPK

const op_VPKLS

const op_VPKS

const op_VPERM

const op_VPDI

const op_VPOPCT

const op_VREP

const op_VREPI

const op_VSCEF

const op_VSCEG

const op_VSEL

const op_VSL

const op_VSLB

const op_VSLDB

const op_VSRA

const op_VSRAB

const op_VSRL

const op_VSRLB

const op_VSEG

const op_VST

const op_VSTEH

const op_VSTEF

const op_VSTEG

const op_VSTEB

const op_VSTM

const op_VSTL

const op_VSTRC

const op_VS

const op_VSCBI

const op_VSBCBI

const op_VSBI

const op_VSUMG

const op_VSUMQ

const op_VSUM

const op_VTM

const op_VUPH

const op_VUPLH

const op_VUPLL

const op_VUPL

const op_VMSL

const op_KDSA

func oclass(a *obj.Addr) int {}

// Add a relocation for the immediate in a RIL style instruction.
// The addend will be adjusted as required.
func (c *ctxtz) addrilreloc(sym *obj.LSym, add int64) *obj.Reloc {}

func (c *ctxtz) addrilrelocoffset(sym *obj.LSym, add, offset int64) *obj.Reloc {}

// Add a CALL relocation for the immediate in a RIL style instruction.
// The addend will be adjusted as required.
func (c *ctxtz) addcallreloc(sym *obj.LSym, add int64) *obj.Reloc {}

func (c *ctxtz) branchMask(p *obj.Prog) CCMask {}

func regtmp(p *obj.Prog) uint32 {}

func (c *ctxtz) asmout(p *obj.Prog, asm *[]byte) {}

func (c *ctxtz) vregoff(a *obj.Addr) int64 {}

func (c *ctxtz) regoff(a *obj.Addr) int32 {}

// find if the displacement is within 12 bit.
func isU12(displacement int32) bool {}

// zopload12 returns the RX op with 12 bit displacement for the given load.
func (c *ctxtz) zopload12(a obj.As) (uint32, bool) {}

// zopload returns the RXY op for the given load.
func (c *ctxtz) zopload(a obj.As) uint32 {}

// zopstore12 returns the RX op with 12 bit displacement for the given store.
func (c *ctxtz) zopstore12(a obj.As) (uint32, bool) {}

// zopstore returns the RXY op for the given store.
func (c *ctxtz) zopstore(a obj.As) uint32 {}

// zoprre returns the RRE op for the given a.
func (c *ctxtz) zoprre(a obj.As) uint32 {}

// zoprr returns the RR op for the given a.
func (c *ctxtz) zoprr(a obj.As) uint32 {}

// zopril returns the RIL op for the given a.
func (c *ctxtz) zopril(a obj.As) uint32 {}

const sizeE

const sizeI

const sizeIE

const sizeMII

const sizeRI

const sizeRI1

const sizeRI2

const sizeRI3

const sizeRIE

const sizeRIE1

const sizeRIE2

const sizeRIE3

const sizeRIE4

const sizeRIE5

const sizeRIE6

const sizeRIL

const sizeRIL1

const sizeRIL2

const sizeRIL3

const sizeRIS

const sizeRR

const sizeRRD

const sizeRRE

const sizeRRF

const sizeRRF1

const sizeRRF2

const sizeRRF3

const sizeRRF4

const sizeRRF5

const sizeRRR

const sizeRRS

const sizeRS

const sizeRS1

const sizeRS2

const sizeRSI

const sizeRSL

const sizeRSY

const sizeRSY1

const sizeRSY2

const sizeRX

const sizeRX1

const sizeRX2

const sizeRXE

const sizeRXF

const sizeRXY

const sizeRXY1

const sizeRXY2

const sizeS

const sizeSI

const sizeSIL

const sizeSIY

const sizeSMI

const sizeSS

const sizeSS1

const sizeSS2

const sizeSS3

const sizeSS4

const sizeSS5

const sizeSS6

const sizeSSE

const sizeSSF

type form

const _a

const _b

const _c

const _d

const _e

const _f

func zE(op uint32, asm *[]byte) {}

func zI(op, i1 uint32, asm *[]byte) {}

func zMII(op, m1, ri2, ri3 uint32, asm *[]byte) {}

func zRI(op, r1_m1, i2_ri2 uint32, asm *[]byte) {}

// Expected argument values for the instruction formats.
//
// Format    a1  a2   a3  a4  a5  a6  a7
// ------------------------------------
// a         r1,  0,  i2,  0,  0, m3,  0
// b         r1, r2, ri4,  0,  0, m3,  0
// c         r1, m3, ri4,  0,  0,  0, i2
// d         r1, r3,  i2,  0,  0,  0,  0
// e         r1, r3, ri2,  0,  0,  0,  0
// f         r1, r2,   0, i3, i4,  0, i5
// g         r1, m3,  i2,  0,  0,  0,  0
func zRIE(f form, op, r1, r2_m3_r3, i2_ri4_ri2, i3, i4, m3, i2_i5 uint32, asm *[]byte) {}

func zRIL(f form, op, r1_m1, i2_ri2 uint32, asm *[]byte) {}

func zRIS(op, r1, m3, b4, d4, i2 uint32, asm *[]byte) {}

func zRR(op, r1, r2 uint32, asm *[]byte) {}

func zRRD(op, r1, r3, r2 uint32, asm *[]byte) {}

func zRRE(op, r1, r2 uint32, asm *[]byte) {}

func zRRF(op, r3_m3, m4, r1, r2 uint32, asm *[]byte) {}

func zRRS(op, r1, r2, b4, d4, m3 uint32, asm *[]byte) {}

func zRS(op, r1, r3_m3, b2, d2 uint32, asm *[]byte) {}

func zRSI(op, r1, r3, ri2 uint32, asm *[]byte) {}

func zRSL(op, l1, b2, d2 uint32, asm *[]byte) {}

func zRSY(op, r1, r3_m3, b2, d2 uint32, asm *[]byte) {}

func zRX(op, r1_m1, x2, b2, d2 uint32, asm *[]byte) {}

func zRXE(op, r1, x2, b2, d2, m3 uint32, asm *[]byte) {}

func zRXF(op, r3, x2, b2, d2, m1 uint32, asm *[]byte) {}

func zRXY(op, r1_m1, x2, b2, d2 uint32, asm *[]byte) {}

func zS(op, b2, d2 uint32, asm *[]byte) {}

func zSI(op, i2, b1, d1 uint32, asm *[]byte) {}

func zSIL(op, b1, d1, i2 uint32, asm *[]byte) {}

func zSIY(op, i2, b1, d1 uint32, asm *[]byte) {}

func zSMI(op, m1, b3, d3, ri2 uint32, asm *[]byte) {}

// Expected argument values for the instruction formats.
//
// Format    a1  a2  a3  a4  a5  a6
// -------------------------------
// a         l1,  0, b1, d1, b2, d2
// b         l1, l2, b1, d1, b2, d2
// c         l1, i3, b1, d1, b2, d2
// d         r1, r3, b1, d1, b2, d2
// e         r1, r3, b2, d2, b4, d4
// f          0, l2, b1, d1, b2, d2
func zSS(f form, op, l1_r1, l2_i3_r3, b1_b2, d1_d2, b2_b4, d2_d4 uint32, asm *[]byte) {}

func zSSE(op, b1, d1, b2, d2 uint32, asm *[]byte) {}

func zSSF(op, r3, b1, d1, b2, d2 uint32, asm *[]byte) {}

func rxb(va, vb, vc, vd uint32) uint8 {}

func zVRX(op, v1, x2, b2, d2, m3 uint32, asm *[]byte) {}

func zVRV(op, v1, v2, b2, d2, m3 uint32, asm *[]byte) {}

func zVRS(op, v1, v3_r3, b2, d2, m4 uint32, asm *[]byte) {}

func zVRRa(op, v1, v2, m5, m4, m3 uint32, asm *[]byte) {}

func zVRRb(op, v1, v2, v3, m5, m4 uint32, asm *[]byte) {}

func zVRRc(op, v1, v2, v3, m6, m5, m4 uint32, asm *[]byte) {}

func zVRRd(op, v1, v2, v3, m5, m6, v4 uint32, asm *[]byte) {}

func zVRRe(op, v1, v2, v3, m6, m5, v4 uint32, asm *[]byte) {}

func zVRRf(op, v1, r2, r3 uint32, asm *[]byte) {}

func zVRIa(op, v1, i2, m3 uint32, asm *[]byte) {}

func zVRIb(op, v1, i2, i3, m4 uint32, asm *[]byte) {}

func zVRIc(op, v1, v3, i2, m4 uint32, asm *[]byte) {}

func zVRId(op, v1, v2, v3, i4, m5 uint32, asm *[]byte) {}

func zVRIe(op, v1, v2, i3, m5, m4 uint32, asm *[]byte) {}