s390x

Imports

Imports # 

"cmd/internal/obj"
"cmd/internal/obj"
"fmt"
"cmd/internal/obj"
"cmd/internal/objabi"
"fmt"
"log"
"math"
"slices"
"fmt"
"cmd/internal/obj"
"cmd/internal/objabi"
"cmd/internal/sys"
"internal/abi"
"log"
"math"
"math/bits"
"cmd/internal/obj"
"cmd/internal/obj"

Constants & Variables

AADD const #

integer arithmetic

const AADD = *ast.BinaryExpr

AADDC const # 

const AADDC

AADDE const # 

const AADDE

AADDW const # 

const AADDW

AAND const #

integer bitwise

const AAND

AANDW const # 

const AANDW

ABC const #

branch

const ABC

ABCL const # 

const ABCL

ABEQ const # 

const ABEQ

ABGE const # 

const ABGE

ABGT const # 

const ABGT

ABL const # 

const ABL = obj.ACALL

ABLE const # 

const ABLE

ABLEU const # 

const ABLEU

ABLT const # 

const ABLT

ABLTU const # 

const ABLTU

ABNE const # 

const ABNE

ABR const #

aliases

const ABR = obj.AJMP

ABRC const # 

const ABRC

ABRCT const #

branch on count

const ABRCT

ABRCTG const # 

const ABRCTG

ABRRK const #

Breakpoint

const ABRRK

ABVC const # 

const ABVC

ABVS const # 

const ABVS

ABYTE const #

binary

const ABYTE

ACDFBRA const # 

const ACDFBRA

ACDGBRA const # 

const ACDGBRA

ACDLFBR const # 

const ACDLFBR

ACDLGBR const # 

const ACDLGBR

ACEBR const # 

const ACEBR

ACEFBRA const #

convert from int32/int64 to float/float64

const ACEFBRA

ACEGBRA const # 

const ACEGBRA

ACELFBR const #

convert from uint32/uint64 to float/float64

const ACELFBR

ACELGBR const # 

const ACELGBR

ACFDBRA const # 

const ACFDBRA

ACFEBRA const #

convert from float/float64 to int32/int64

const ACFEBRA

ACGDBRA const # 

const ACGDBRA

ACGEBRA const # 

const ACGEBRA

ACGIJ const # 

const ACGIJ

ACGRJ const # 

const ACGRJ

ACIJ const # 

const ACIJ

ACLC const # 

const ACLC

ACLEAR const #

macros

const ACLEAR

ACLFDBR const # 

const ACLFDBR

ACLFEBR const #

convert from float/float64 to uint32/uint64

const ACLFEBR

ACLGDBR const # 

const ACLGDBR

ACLGEBR const # 

const ACLGEBR

ACLGIJ const # 

const ACLGIJ

ACLGRJ const # 

const ACLGRJ

ACLIJ const # 

const ACLIJ

ACLRJ const # 

const ACLRJ

ACMP const #

compare

const ACMP

ACMPBEQ const # 

const ACMPBEQ

ACMPBGE const # 

const ACMPBGE

ACMPBGT const # 

const ACMPBGT

ACMPBLE const # 

const ACMPBLE

ACMPBLT const # 

const ACMPBLT

ACMPBNE const # 

const ACMPBNE

ACMPU const # 

const ACMPU

ACMPUBEQ const # 

const ACMPUBEQ

ACMPUBGE const # 

const ACMPUBGE

ACMPUBGT const # 

const ACMPUBGT

ACMPUBLE const # 

const ACMPUBLE

ACMPUBLT const # 

const ACMPUBLT

ACMPUBNE const # 

const ACMPUBNE

ACMPW const # 

const ACMPW

ACMPWU const # 

const ACMPWU

ACPSDR const # 

const ACPSDR

ACRJ const #

compare and branch

const ACRJ

ACS const #

compare and swap

const ACS

ACSG const # 

const ACSG

ADIVD const # 

const ADIVD

ADIVDU const # 

const ADIVDU

ADIVW const # 

const ADIVW

ADIVWU const # 

const ADIVWU

ADWORD const # 

const ADWORD

AEXRL const #

load

const AEXRL

AFABS const #

floating point

const AFABS

AFADD const # 

const AFADD

AFADDS const # 

const AFADDS

AFCMPO const # 

const AFCMPO

AFCMPU const # 

const AFCMPU

AFDIV const # 

const AFDIV

AFDIVS const # 

const AFDIVS

AFIDBR const # 

const AFIDBR

AFIEBR const # 

const AFIEBR

AFLOGR const #

find leftmost one

const AFLOGR

AFMADD const # 

const AFMADD

AFMADDS const # 

const AFMADDS

AFMOVD const # 

const AFMOVD

AFMOVS const # 

const AFMOVS

AFMSUB const # 

const AFMSUB

AFMSUBS const # 

const AFMSUBS

AFMUL const # 

const AFMUL

AFMULS const # 

const AFMULS

AFNABS const # 

const AFNABS

AFNEG const # 

const AFNEG

AFNEGS const # 

const AFNEGS

AFSQRT const # 

const AFSQRT

AFSQRTS const # 

const AFSQRTS

AFSUB const # 

const AFSUB

AFSUBS const # 

const AFSUBS

AIPM const #

insert program mask

const AIPM

AKDSA const # 

const AKDSA

AKIMD const # 

const AKIMD

AKLMD const # 

const AKLMD

AKM const #

crypto

const AKM

AKMA const # 

const AKMA

AKMC const # 

const AKMC

AKMCTR const # 

const AKMCTR

ALA const # 

const ALA

ALAA const #

interlocked load and op

const ALAA

ALAAG const # 

const ALAAG

ALAAL const # 

const ALAAL

ALAALG const # 

const ALAALG

ALAN const # 

const ALAN

ALANG const # 

const ALANG

ALAO const # 

const ALAO

ALAOG const # 

const ALAOG

ALARL const # 

const ALARL

ALAST const #

end marker

const ALAST

ALAX const # 

const ALAX

ALAXG const # 

const ALAXG

ALAY const # 

const ALAY

ALDEBR const # 

const ALDEBR

ALDGR const #

move from GPR to FPR and vice versa

const ALDGR

ALEDBR const # 

const ALEDBR

ALGDR const # 

const ALGDR

ALMG const # 

const ALMG

ALMY const #

load/store multiple

const ALMY

ALNDFR const # 

const ALNDFR

ALOCGR const # 

const ALOCGR

ALOCR const # 

const ALOCR

ALPDFR const # 

const ALPDFR

ALTDBR const # 

const ALTDBR

ALTEBR const # 

const ALTEBR

AMLGR const # 

const AMLGR

AMODD const # 

const AMODD

AMODDU const # 

const AMODDU

AMODW const # 

const AMODW

AMODWU const # 

const AMODWU

AMOVB const # 

const AMOVB

AMOVBZ const # 

const AMOVBZ

AMOVD const # 

const AMOVD

AMOVDBR const # 

const AMOVDBR

AMOVDEQ const #

conditional moves

const AMOVDEQ

AMOVDGE const # 

const AMOVDGE

AMOVDGT const # 

const AMOVDGT

AMOVDLE const # 

const AMOVDLE

AMOVDLT const # 

const AMOVDLT

AMOVDNE const # 

const AMOVDNE

AMOVH const # 

const AMOVH

AMOVHBR const # 

const AMOVHBR

AMOVHZ const # 

const AMOVHZ

AMOVW const # 

const AMOVW

AMOVWBR const #

integer moves

const AMOVWBR

AMOVWZ const # 

const AMOVWZ

AMULHD const # 

const AMULHD

AMULHDU const # 

const AMULHDU

AMULLD const # 

const AMULLD

AMULLW const # 

const AMULLW

AMVC const #

storage-and-storage

const AMVC

AMVCIN const # 

const AMVCIN

ANC const # 

const ANC

ANEG const # 

const ANEG

ANEGW const # 

const ANEGW

ANOPH const # 

const ANOPH

AOC const # 

const AOC

AOR const # 

const AOR

AORW const # 

const AORW

APOPCNT const #

population count

const APOPCNT

ARISBG const # 

const ARISBG

ARISBGN const # 

const ARISBGN

ARISBGNZ const # 

const ARISBGNZ

ARISBGZ const # 

const ARISBGZ

ARISBHG const # 

const ARISBHG

ARISBHGZ const # 

const ARISBHGZ

ARISBLG const # 

const ARISBLG

ARISBLGZ const # 

const ARISBLGZ

ARLL const # 

const ARLL

ARLLG const # 

const ARLLG

ARNSBG const # 

const ARNSBG

ARNSBGT const # 

const ARNSBGT

AROSBG const # 

const AROSBG

AROSBGT const # 

const AROSBGT

ARXSBG const # 

const ARXSBG

ARXSBGT const # 

const ARXSBGT

ASLD const # 

const ASLD

ASLW const # 

const ASLW

ASPM const #

set program mask

const ASPM

ASRAD const # 

const ASRAD

ASRAW const # 

const ASRAW

ASRD const # 

const ASRD

ASRW const # 

const ASRW

ASTCK const #

store clock

const ASTCK

ASTCKC const # 

const ASTCKC

ASTCKE const # 

const ASTCKE

ASTCKF const # 

const ASTCKF

ASTMG const # 

const ASTMG

ASTMY const # 

const ASTMY

ASUB const # 

const ASUB

ASUBC const # 

const ASUBC

ASUBE const # 

const ASUBE

ASUBV const # 

const ASUBV

ASUBW const # 

const ASUBW

ASYNC const #

serialize

const ASYNC

ASYSCALL const # 

const ASYSCALL

ATCDB const # 

const ATCDB

ATCEB const # 

const ATCEB

ATMHH const #

test under mask

const ATMHH

ATMHL const # 

const ATMHL

ATMLH const # 

const ATMLH

ATMLL const # 

const ATMLL

AVA const #

vector

const AVA

AVAB const # 

const AVAB

AVAC const # 

const AVAC

AVACC const # 

const AVACC

AVACCB const # 

const AVACCB

AVACCC const # 

const AVACCC

AVACCCQ const # 

const AVACCCQ

AVACCF const # 

const AVACCF

AVACCG const # 

const AVACCG

AVACCH const # 

const AVACCH

AVACCQ const # 

const AVACCQ

AVACQ const # 

const AVACQ

AVAF const # 

const AVAF

AVAG const # 

const AVAG

AVAH const # 

const AVAH

AVAQ const # 

const AVAQ

AVAVG const # 

const AVAVG

AVAVGB const # 

const AVAVGB

AVAVGF const # 

const AVAVGF

AVAVGG const # 

const AVAVGG

AVAVGH const # 

const AVAVGH

AVAVGL const # 

const AVAVGL

AVAVGLB const # 

const AVAVGLB

AVAVGLF const # 

const AVAVGLF

AVAVGLG const # 

const AVAVGLG

AVAVGLH const # 

const AVAVGLH

AVCDG const # 

const AVCDG

AVCDGB const # 

const AVCDGB

AVCDLG const # 

const AVCDLG

AVCDLGB const # 

const AVCDLGB

AVCEQ const # 

const AVCEQ

AVCEQB const # 

const AVCEQB

AVCEQBS const # 

const AVCEQBS

AVCEQF const # 

const AVCEQF

AVCEQFS const # 

const AVCEQFS

AVCEQG const # 

const AVCEQG

AVCEQGS const # 

const AVCEQGS

AVCEQH const # 

const AVCEQH

AVCEQHS const # 

const AVCEQHS

AVCGD const # 

const AVCGD

AVCGDB const # 

const AVCGDB

AVCH const # 

const AVCH

AVCHB const # 

const AVCHB

AVCHBS const # 

const AVCHBS

AVCHF const # 

const AVCHF

AVCHFS const # 

const AVCHFS

AVCHG const # 

const AVCHG

AVCHGS const # 

const AVCHGS

AVCHH const # 

const AVCHH

AVCHHS const # 

const AVCHHS

AVCHL const # 

const AVCHL

AVCHLB const # 

const AVCHLB

AVCHLBS const # 

const AVCHLBS

AVCHLF const # 

const AVCHLF

AVCHLFS const # 

const AVCHLFS

AVCHLG const # 

const AVCHLG

AVCHLGS const # 

const AVCHLGS

AVCHLH const # 

const AVCHLH

AVCHLHS const # 

const AVCHLHS

AVCKSM const # 

const AVCKSM

AVCLGD const # 

const AVCLGD

AVCLGDB const # 

const AVCLGDB

AVCLZ const # 

const AVCLZ

AVCLZB const # 

const AVCLZB

AVCLZF const # 

const AVCLZF

AVCLZG const # 

const AVCLZG

AVCLZH const # 

const AVCLZH

AVCTZ const # 

const AVCTZ

AVCTZB const # 

const AVCTZB

AVCTZF const # 

const AVCTZF

AVCTZG const # 

const AVCTZG

AVCTZH const # 

const AVCTZH

AVEC const # 

const AVEC

AVECB const # 

const AVECB

AVECF const # 

const AVECF

AVECG const # 

const AVECG

AVECH const # 

const AVECH

AVECL const # 

const AVECL

AVECLB const # 

const AVECLB

AVECLF const # 

const AVECLF

AVECLG const # 

const AVECLG

AVECLH const # 

const AVECLH

AVERIM const # 

const AVERIM

AVERIMB const # 

const AVERIMB

AVERIMF const # 

const AVERIMF

AVERIMG const # 

const AVERIMG

AVERIMH const # 

const AVERIMH

AVERLL const # 

const AVERLL

AVERLLB const # 

const AVERLLB

AVERLLF const # 

const AVERLLF

AVERLLG const # 

const AVERLLG

AVERLLH const # 

const AVERLLH

AVERLLV const # 

const AVERLLV

AVERLLVB const # 

const AVERLLVB

AVERLLVF const # 

const AVERLLVF

AVERLLVG const # 

const AVERLLVG

AVERLLVH const # 

const AVERLLVH

AVESL const # 

const AVESL

AVESLB const # 

const AVESLB

AVESLF const # 

const AVESLF

AVESLG const # 

const AVESLG

AVESLH const # 

const AVESLH

AVESLV const # 

const AVESLV

AVESLVB const # 

const AVESLVB

AVESLVF const # 

const AVESLVF

AVESLVG const # 

const AVESLVG

AVESLVH const # 

const AVESLVH

AVESRA const # 

const AVESRA

AVESRAB const # 

const AVESRAB

AVESRAF const # 

const AVESRAF

AVESRAG const # 

const AVESRAG

AVESRAH const # 

const AVESRAH

AVESRAV const # 

const AVESRAV

AVESRAVB const # 

const AVESRAVB

AVESRAVF const # 

const AVESRAVF

AVESRAVG const # 

const AVESRAVG

AVESRAVH const # 

const AVESRAVH

AVESRL const # 

const AVESRL

AVESRLB const # 

const AVESRLB

AVESRLF const # 

const AVESRLF

AVESRLG const # 

const AVESRLG

AVESRLH const # 

const AVESRLH

AVESRLV const # 

const AVESRLV

AVESRLVB const # 

const AVESRLVB

AVESRLVF const # 

const AVESRLVF

AVESRLVG const # 

const AVESRLVG

AVESRLVH const # 

const AVESRLVH

AVFA const # 

const AVFA

AVFADB const # 

const AVFADB

AVFAE const # 

const AVFAE

AVFAEB const # 

const AVFAEB

AVFAEBS const # 

const AVFAEBS

AVFAEF const # 

const AVFAEF

AVFAEFS const # 

const AVFAEFS

AVFAEH const # 

const AVFAEH

AVFAEHS const # 

const AVFAEHS

AVFAEZB const # 

const AVFAEZB

AVFAEZBS const # 

const AVFAEZBS

AVFAEZF const # 

const AVFAEZF

AVFAEZFS const # 

const AVFAEZFS

AVFAEZH const # 

const AVFAEZH

AVFAEZHS const # 

const AVFAEZHS

AVFCE const # 

const AVFCE

AVFCEDB const # 

const AVFCEDB

AVFCEDBS const # 

const AVFCEDBS

AVFCH const # 

const AVFCH

AVFCHDB const # 

const AVFCHDB

AVFCHDBS const # 

const AVFCHDBS

AVFCHE const # 

const AVFCHE

AVFCHEDB const # 

const AVFCHEDB

AVFCHEDBS const # 

const AVFCHEDBS

AVFD const # 

const AVFD

AVFDDB const # 

const AVFDDB

AVFEE const # 

const AVFEE

AVFEEB const # 

const AVFEEB

AVFEEBS const # 

const AVFEEBS

AVFEEF const # 

const AVFEEF

AVFEEFS const # 

const AVFEEFS

AVFEEH const # 

const AVFEEH

AVFEEHS const # 

const AVFEEHS

AVFEEZB const # 

const AVFEEZB

AVFEEZBS const # 

const AVFEEZBS

AVFEEZF const # 

const AVFEEZF

AVFEEZFS const # 

const AVFEEZFS

AVFEEZH const # 

const AVFEEZH

AVFEEZHS const # 

const AVFEEZHS

AVFENE const # 

const AVFENE

AVFENEB const # 

const AVFENEB

AVFENEBS const # 

const AVFENEBS

AVFENEF const # 

const AVFENEF

AVFENEFS const # 

const AVFENEFS

AVFENEH const # 

const AVFENEH

AVFENEHS const # 

const AVFENEHS

AVFENEZB const # 

const AVFENEZB

AVFENEZBS const # 

const AVFENEZBS

AVFENEZF const # 

const AVFENEZF

AVFENEZFS const # 

const AVFENEZFS

AVFENEZH const # 

const AVFENEZH

AVFENEZHS const # 

const AVFENEZHS

AVFI const # 

const AVFI

AVFIDB const # 

const AVFIDB

AVFLCDB const # 

const AVFLCDB

AVFLNDB const # 

const AVFLNDB

AVFLPDB const # 

const AVFLPDB

AVFM const # 

const AVFM

AVFMA const # 

const AVFMA

AVFMADB const # 

const AVFMADB

AVFMDB const # 

const AVFMDB

AVFMS const # 

const AVFMS

AVFMSDB const # 

const AVFMSDB

AVFPSO const # 

const AVFPSO

AVFPSODB const # 

const AVFPSODB

AVFS const # 

const AVFS

AVFSDB const # 

const AVFSDB

AVFSQ const # 

const AVFSQ

AVFSQDB const # 

const AVFSQDB

AVFTCI const # 

const AVFTCI

AVFTCIDB const # 

const AVFTCIDB

AVGBM const # 

const AVGBM

AVGEF const # 

const AVGEF

AVGEG const # 

const AVGEG

AVGFM const # 

const AVGFM

AVGFMA const # 

const AVGFMA

AVGFMAB const # 

const AVGFMAB

AVGFMAF const # 

const AVGFMAF

AVGFMAG const # 

const AVGFMAG

AVGFMAH const # 

const AVGFMAH

AVGFMB const # 

const AVGFMB

AVGFMF const # 

const AVGFMF

AVGFMG const # 

const AVGFMG

AVGFMH const # 

const AVGFMH

AVGM const # 

const AVGM

AVGMB const # 

const AVGMB

AVGMF const # 

const AVGMF

AVGMG const # 

const AVGMG

AVGMH const # 

const AVGMH

AVISTR const # 

const AVISTR

AVISTRB const # 

const AVISTRB

AVISTRBS const # 

const AVISTRBS

AVISTRF const # 

const AVISTRF

AVISTRFS const # 

const AVISTRFS

AVISTRH const # 

const AVISTRH

AVISTRHS const # 

const AVISTRHS

AVL const # 

const AVL

AVLBB const # 

const AVLBB

AVLC const # 

const AVLC

AVLCB const # 

const AVLCB

AVLCF const # 

const AVLCF

AVLCG const # 

const AVLCG

AVLCH const # 

const AVLCH

AVLDE const # 

const AVLDE

AVLDEB const # 

const AVLDEB

AVLEB const # 

const AVLEB

AVLED const # 

const AVLED

AVLEDB const # 

const AVLEDB

AVLEF const # 

const AVLEF

AVLEG const # 

const AVLEG

AVLEH const # 

const AVLEH

AVLEIB const # 

const AVLEIB

AVLEIF const # 

const AVLEIF

AVLEIG const # 

const AVLEIG

AVLEIH const # 

const AVLEIH

AVLGV const # 

const AVLGV

AVLGVB const # 

const AVLGVB

AVLGVF const # 

const AVLGVF

AVLGVG const # 

const AVLGVG

AVLGVH const # 

const AVLGVH

AVLL const # 

const AVLL

AVLLEZ const # 

const AVLLEZ

AVLLEZB const # 

const AVLLEZB

AVLLEZF const # 

const AVLLEZF

AVLLEZG const # 

const AVLLEZG

AVLLEZH const # 

const AVLLEZH

AVLM const # 

const AVLM

AVLP const # 

const AVLP

AVLPB const # 

const AVLPB

AVLPF const # 

const AVLPF

AVLPG const # 

const AVLPG

AVLPH const # 

const AVLPH

AVLR const # 

const AVLR

AVLREP const # 

const AVLREP

AVLREPB const # 

const AVLREPB

AVLREPF const # 

const AVLREPF

AVLREPG const # 

const AVLREPG

AVLREPH const # 

const AVLREPH

AVLVG const # 

const AVLVG

AVLVGB const # 

const AVLVGB

AVLVGF const # 

const AVLVGF

AVLVGG const # 

const AVLVGG

AVLVGH const # 

const AVLVGH

AVLVGP const # 

const AVLVGP

AVMAE const # 

const AVMAE

AVMAEB const # 

const AVMAEB

AVMAEF const # 

const AVMAEF

AVMAEH const # 

const AVMAEH

AVMAH const # 

const AVMAH

AVMAHB const # 

const AVMAHB

AVMAHF const # 

const AVMAHF

AVMAHH const # 

const AVMAHH

AVMAL const # 

const AVMAL

AVMALB const # 

const AVMALB

AVMALE const # 

const AVMALE

AVMALEB const # 

const AVMALEB

AVMALEF const # 

const AVMALEF

AVMALEH const # 

const AVMALEH

AVMALF const # 

const AVMALF

AVMALH const # 

const AVMALH

AVMALHB const # 

const AVMALHB

AVMALHF const # 

const AVMALHF

AVMALHH const # 

const AVMALHH

AVMALHW const # 

const AVMALHW

AVMALO const # 

const AVMALO

AVMALOB const # 

const AVMALOB

AVMALOF const # 

const AVMALOF

AVMALOH const # 

const AVMALOH

AVMAO const # 

const AVMAO

AVMAOB const # 

const AVMAOB

AVMAOF const # 

const AVMAOF

AVMAOH const # 

const AVMAOH

AVME const # 

const AVME

AVMEB const # 

const AVMEB

AVMEF const # 

const AVMEF

AVMEH const # 

const AVMEH

AVMH const # 

const AVMH

AVMHB const # 

const AVMHB

AVMHF const # 

const AVMHF

AVMHH const # 

const AVMHH

AVML const # 

const AVML

AVMLB const # 

const AVMLB

AVMLE const # 

const AVMLE

AVMLEB const # 

const AVMLEB

AVMLEF const # 

const AVMLEF

AVMLEH const # 

const AVMLEH

AVMLF const # 

const AVMLF

AVMLH const # 

const AVMLH

AVMLHB const # 

const AVMLHB

AVMLHF const # 

const AVMLHF

AVMLHH const # 

const AVMLHH

AVMLHW const # 

const AVMLHW

AVMLO const # 

const AVMLO

AVMLOB const # 

const AVMLOB

AVMLOF const # 

const AVMLOF

AVMLOH const # 

const AVMLOH

AVMN const # 

const AVMN

AVMNB const # 

const AVMNB

AVMNF const # 

const AVMNF

AVMNG const # 

const AVMNG

AVMNH const # 

const AVMNH

AVMNL const # 

const AVMNL

AVMNLB const # 

const AVMNLB

AVMNLF const # 

const AVMNLF

AVMNLG const # 

const AVMNLG

AVMNLH const # 

const AVMNLH

AVMO const # 

const AVMO

AVMOB const # 

const AVMOB

AVMOF const # 

const AVMOF

AVMOH const # 

const AVMOH

AVMRH const # 

const AVMRH

AVMRHB const # 

const AVMRHB

AVMRHF const # 

const AVMRHF

AVMRHG const # 

const AVMRHG

AVMRHH const # 

const AVMRHH

AVMRL const # 

const AVMRL

AVMRLB const # 

const AVMRLB

AVMRLF const # 

const AVMRLF

AVMRLG const # 

const AVMRLG

AVMRLH const # 

const AVMRLH

AVMSLEG const # 

const AVMSLEG

AVMSLEOG const # 

const AVMSLEOG

AVMSLG const # 

const AVMSLG

AVMSLOG const # 

const AVMSLOG

AVMX const # 

const AVMX

AVMXB const # 

const AVMXB

AVMXF const # 

const AVMXF

AVMXG const # 

const AVMXG

AVMXH const # 

const AVMXH

AVMXL const # 

const AVMXL

AVMXLB const # 

const AVMXLB

AVMXLF const # 

const AVMXLF

AVMXLG const # 

const AVMXLG

AVMXLH const # 

const AVMXLH

AVN const # 

const AVN

AVNC const # 

const AVNC

AVNO const # 

const AVNO

AVNOT const # 

const AVNOT

AVO const # 

const AVO

AVONE const # 

const AVONE

AVPDI const # 

const AVPDI

AVPERM const # 

const AVPERM

AVPK const # 

const AVPK

AVPKF const # 

const AVPKF

AVPKG const # 

const AVPKG

AVPKH const # 

const AVPKH

AVPKLS const # 

const AVPKLS

AVPKLSF const # 

const AVPKLSF

AVPKLSFS const # 

const AVPKLSFS

AVPKLSG const # 

const AVPKLSG

AVPKLSGS const # 

const AVPKLSGS

AVPKLSH const # 

const AVPKLSH

AVPKLSHS const # 

const AVPKLSHS

AVPKS const # 

const AVPKS

AVPKSF const # 

const AVPKSF

AVPKSFS const # 

const AVPKSFS

AVPKSG const # 

const AVPKSG

AVPKSGS const # 

const AVPKSGS

AVPKSH const # 

const AVPKSH

AVPKSHS const # 

const AVPKSHS

AVPOPCT const # 

const AVPOPCT

AVREP const # 

const AVREP

AVREPB const # 

const AVREPB

AVREPF const # 

const AVREPF

AVREPG const # 

const AVREPG

AVREPH const # 

const AVREPH

AVREPI const # 

const AVREPI

AVREPIB const # 

const AVREPIB

AVREPIF const # 

const AVREPIF

AVREPIG const # 

const AVREPIG

AVREPIH const # 

const AVREPIH

AVS const # 

const AVS

AVSB const # 

const AVSB

AVSBCBI const # 

const AVSBCBI

AVSBCBIQ const # 

const AVSBCBIQ

AVSBI const # 

const AVSBI

AVSBIQ const # 

const AVSBIQ

AVSCBI const # 

const AVSCBI

AVSCBIB const # 

const AVSCBIB

AVSCBIF const # 

const AVSCBIF

AVSCBIG const # 

const AVSCBIG

AVSCBIH const # 

const AVSCBIH

AVSCBIQ const # 

const AVSCBIQ

AVSCEF const # 

const AVSCEF

AVSCEG const # 

const AVSCEG

AVSEG const # 

const AVSEG

AVSEGB const # 

const AVSEGB

AVSEGF const # 

const AVSEGF

AVSEGH const # 

const AVSEGH

AVSEL const # 

const AVSEL

AVSF const # 

const AVSF

AVSG const # 

const AVSG

AVSH const # 

const AVSH

AVSL const # 

const AVSL

AVSLB const # 

const AVSLB

AVSLDB const # 

const AVSLDB

AVSQ const # 

const AVSQ

AVSRA const # 

const AVSRA

AVSRAB const # 

const AVSRAB

AVSRL const # 

const AVSRL

AVSRLB const # 

const AVSRLB

AVST const # 

const AVST

AVSTEB const # 

const AVSTEB

AVSTEF const # 

const AVSTEF

AVSTEG const # 

const AVSTEG

AVSTEH const # 

const AVSTEH

AVSTL const # 

const AVSTL

AVSTM const # 

const AVSTM

AVSTRC const # 

const AVSTRC

AVSTRCB const # 

const AVSTRCB

AVSTRCBS const # 

const AVSTRCBS

AVSTRCF const # 

const AVSTRCF

AVSTRCFS const # 

const AVSTRCFS

AVSTRCH const # 

const AVSTRCH

AVSTRCHS const # 

const AVSTRCHS

AVSTRCZB const # 

const AVSTRCZB

AVSTRCZBS const # 

const AVSTRCZBS

AVSTRCZF const # 

const AVSTRCZF

AVSTRCZFS const # 

const AVSTRCZFS

AVSTRCZH const # 

const AVSTRCZH

AVSTRCZHS const # 

const AVSTRCZHS

AVSUM const # 

const AVSUM

AVSUMB const # 

const AVSUMB

AVSUMG const # 

const AVSUMG

AVSUMGF const # 

const AVSUMGF

AVSUMGH const # 

const AVSUMGH

AVSUMH const # 

const AVSUMH

AVSUMQ const # 

const AVSUMQ

AVSUMQF const # 

const AVSUMQF

AVSUMQG const # 

const AVSUMQG

AVTM const # 

const AVTM

AVUPH const # 

const AVUPH

AVUPHB const # 

const AVUPHB

AVUPHF const # 

const AVUPHF

AVUPHH const # 

const AVUPHH

AVUPL const # 

const AVUPL

AVUPLB const # 

const AVUPLB

AVUPLF const # 

const AVUPLF

AVUPLH const # 

const AVUPLH

AVUPLHB const # 

const AVUPLHB

AVUPLHF const # 

const AVUPLHF

AVUPLHH const # 

const AVUPLHH

AVUPLHW const # 

const AVUPLHW

AVUPLL const # 

const AVUPLL

AVUPLLB const # 

const AVUPLLB

AVUPLLF const # 

const AVUPLLF

AVUPLLH const # 

const AVUPLLH

AVX const # 

const AVX

AVZERO const # 

const AVZERO

AWCDGB const # 

const AWCDGB

AWCDLGB const # 

const AWCDLGB

AWCGDB const # 

const AWCGDB

AWCLGDB const # 

const AWCLGDB

AWFADB const # 

const AWFADB

AWFC const # 

const AWFC

AWFCDB const # 

const AWFCDB

AWFCEDB const # 

const AWFCEDB

AWFCEDBS const # 

const AWFCEDBS

AWFCHDB const # 

const AWFCHDB

AWFCHDBS const # 

const AWFCHDBS

AWFCHEDB const # 

const AWFCHEDB

AWFCHEDBS const # 

const AWFCHEDBS

AWFDDB const # 

const AWFDDB

AWFIDB const # 

const AWFIDB

AWFK const # 

const AWFK

AWFKDB const # 

const AWFKDB

AWFLCDB const # 

const AWFLCDB

AWFLNDB const # 

const AWFLNDB

AWFLPDB const # 

const AWFLPDB

AWFMADB const # 

const AWFMADB

AWFMDB const # 

const AWFMDB

AWFMSDB const # 

const AWFMSDB

AWFPSODB const # 

const AWFPSODB

AWFSDB const # 

const AWFSDB

AWFSQDB const # 

const AWFSQDB

AWFTCIDB const # 

const AWFTCIDB

AWLDEB const # 

const AWLDEB

AWLEDB const # 

const AWLEDB

AWORD const # 

const AWORD

AXC const # 

const AXC

AXOR const # 

const AXOR

AXORW const # 

const AXORW

Always const #

4-bit mask

const Always CCMask = *ast.BinaryExpr

Anames var # 

var Anames = []string{...}

BIG const # 

const BIG = *ast.BinaryExpr

BRANCH const # 

const BRANCH

Borrow const # 

const Borrow CCMask = NoCarry

C_ADDCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_ADDCON

C_ADDR const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_ADDR

C_ANDCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_ANDCON

C_ANY const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_ANY

C_AREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_AREG

C_DACON const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_DACON

C_DCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_DCON

C_FREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_FREG

C_GOK const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_GOK

C_GOTADDR const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_GOTADDR

C_LACON const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_LACON

C_LAUTO const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_LAUTO

C_LBRA const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_LBRA

C_LCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_LCON

C_LOREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_LOREG

C_NCLASS const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_NCLASS

C_NONE const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_NONE = iota

C_REG const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_REG

C_SACON const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_SACON

C_SAUTO const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_SAUTO

C_SBRA const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_SBRA

C_SCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_SCON

C_SOREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_SOREG

C_SYMADDR const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_SYMADDR

C_TEXTSIZE const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_TEXTSIZE

C_TLS_IE const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_TLS_IE

C_TLS_LE const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_TLS_LE

C_UCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_UCON

C_VREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_VREG

C_ZCON const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_ZCON

C_ZOREG const #

go:generate go run ../mkcnames.go -i a.out.go -o anamesz.go -p s390x

const C_ZOREG

Carry const #

useful aliases

const Carry CCMask = GreaterOrUnordered

DISP12 const # 

const DISP12 = 4096

DISP16 const # 

const DISP16 = 65536

DISP20 const # 

const DISP20 = 1048576

Equal const #

1-bit masks

const Equal CCMask = *ast.BinaryExpr

EqualOrUnordered const #

2-bit masks

const EqualOrUnordered CCMask = *ast.BinaryExpr

Greater const # 

const Greater CCMask = *ast.BinaryExpr

GreaterOrEqual const # 

const GreaterOrEqual CCMask = *ast.BinaryExpr

GreaterOrUnordered const # 

const GreaterOrUnordered CCMask = *ast.BinaryExpr

LEAF const #

mark flags

const LEAF = *ast.BinaryExpr

Less const # 

const Less CCMask = *ast.BinaryExpr

LessOrEqual const # 

const LessOrEqual CCMask = *ast.BinaryExpr

LessOrGreater const # 

const LessOrGreater CCMask = *ast.BinaryExpr

LessOrUnordered const # 

const LessOrUnordered CCMask = *ast.BinaryExpr

Links390x var # 

var Links390x = obj.LinkArch{...}

NFREG const # 

const NFREG = 16

NREG const # 

const NREG = 16

NSNAME const # 

const NSNAME = 8

NSYM const # 

const NSYM = 50

Never const # 

const Never CCMask = 0

NoBorrow const # 

const NoBorrow CCMask = Carry

NoCarry const # 

const NoCarry CCMask = LessOrEqual

NotEqual const #

3-bit masks

const NotEqual CCMask = *ast.BinaryExpr

NotGreater const # 

const NotGreater CCMask = *ast.BinaryExpr

NotLess const # 

const NotLess CCMask = *ast.BinaryExpr

NotUnordered const # 

const NotUnordered CCMask = *ast.BinaryExpr

REGARG const # 

const REGARG = *ast.UnaryExpr

REGCTXT const # 

const REGCTXT = REG_R12

REGG const # 

const REGG = REG_R13

REGRT1 const # 

const REGRT1 = REG_R3

REGRT2 const # 

const REGRT2 = REG_R4

REGSP const # 

const REGSP = REG_R15

REGTMP const # 

const REGTMP = REG_R10

REGTMP2 const # 

const REGTMP2 = REG_R11

REG_AR0 const #

Access registers (ARs). The thread pointer is typically stored in the register pair AR0 and AR1.

const REG_AR0

REG_AR1 const # 

const REG_AR1

REG_AR10 const # 

const REG_AR10

REG_AR11 const # 

const REG_AR11

REG_AR12 const # 

const REG_AR12

REG_AR13 const # 

const REG_AR13

REG_AR14 const # 

const REG_AR14

REG_AR15 const # 

const REG_AR15

REG_AR2 const # 

const REG_AR2

REG_AR3 const # 

const REG_AR3

REG_AR4 const # 

const REG_AR4

REG_AR5 const # 

const REG_AR5

REG_AR6 const # 

const REG_AR6

REG_AR7 const # 

const REG_AR7

REG_AR8 const # 

const REG_AR8

REG_AR9 const # 

const REG_AR9

REG_F0 const #

Floating point registers (FPRs).

const REG_F0

REG_F1 const # 

const REG_F1

REG_F10 const # 

const REG_F10

REG_F11 const # 

const REG_F11

REG_F12 const # 

const REG_F12

REG_F13 const # 

const REG_F13

REG_F14 const # 

const REG_F14

REG_F15 const # 

const REG_F15

REG_F2 const # 

const REG_F2

REG_F3 const # 

const REG_F3

REG_F4 const # 

const REG_F4

REG_F5 const # 

const REG_F5

REG_F6 const # 

const REG_F6

REG_F7 const # 

const REG_F7

REG_F8 const # 

const REG_F8

REG_F9 const # 

const REG_F9

REG_LR const # 

const REG_LR = REG_R14

REG_R0 const #

General purpose registers (GPRs).

const REG_R0 = *ast.BinaryExpr

REG_R1 const # 

const REG_R1

REG_R10 const # 

const REG_R10

REG_R11 const # 

const REG_R11

REG_R12 const # 

const REG_R12

REG_R13 const # 

const REG_R13

REG_R14 const # 

const REG_R14

REG_R15 const # 

const REG_R15

REG_R2 const # 

const REG_R2

REG_R3 const # 

const REG_R3

REG_R4 const # 

const REG_R4

REG_R5 const # 

const REG_R5

REG_R6 const # 

const REG_R6

REG_R7 const # 

const REG_R7

REG_R8 const # 

const REG_R8

REG_R9 const # 

const REG_R9

REG_RESERVED const # 

const REG_RESERVED

REG_V0 const #

Vector registers (VRs) - only available when the vector facility is installed. V0-V15 are aliases for F0-F15. We keep them in a separate space to make printing etc. easier If the code generator ever emits vector instructions it will need to take into account the aliasing.

const REG_V0

REG_V1 const # 

const REG_V1

REG_V10 const # 

const REG_V10

REG_V11 const # 

const REG_V11

REG_V12 const # 

const REG_V12

REG_V13 const # 

const REG_V13

REG_V14 const # 

const REG_V14

REG_V15 const # 

const REG_V15

REG_V16 const # 

const REG_V16

REG_V17 const # 

const REG_V17

REG_V18 const # 

const REG_V18

REG_V19 const # 

const REG_V19

REG_V2 const # 

const REG_V2

REG_V20 const # 

const REG_V20

REG_V21 const # 

const REG_V21

REG_V22 const # 

const REG_V22

REG_V23 const # 

const REG_V23

REG_V24 const # 

const REG_V24

REG_V25 const # 

const REG_V25

REG_V26 const # 

const REG_V26

REG_V27 const # 

const REG_V27

REG_V28 const # 

const REG_V28

REG_V29 const # 

const REG_V29

REG_V3 const # 

const REG_V3

REG_V30 const # 

const REG_V30

REG_V31 const # 

const REG_V31

REG_V4 const # 

const REG_V4

REG_V5 const # 

const REG_V5

REG_V6 const # 

const REG_V6

REG_V7 const # 

const REG_V7

REG_V8 const # 

const REG_V8

REG_V9 const # 

const REG_V9

S390XDWARFRegisters var #

LINUX for zSeries ELF Application Binary Interface Supplement https://refspecs.linuxfoundation.org/ELF/zSeries/lzsabi0_zSeries/x1472.html

var S390XDWARFRegisters = map[int16]int16{...}

USETMP const # 

const USETMP

Unordered const # 

const Unordered CCMask = *ast.BinaryExpr

_a const # 

const _a form = iota

_b const # 

const _b

_c const # 

const _c

_d const # 

const _d

_e const # 

const _e

_f const # 

const _f

cnamesz var #

This order should be strictly consistent to that in a.out.go.

var cnamesz = []string{...}

funcAlign const #

instruction layout.

const funcAlign = 16

op_A const # 

const op_A uint32 = 0x5A00

op_AD const # 

const op_AD uint32 = 0x6A00

op_ADB const # 

const op_ADB uint32 = 0xED1A

op_ADBR const # 

const op_ADBR uint32 = 0xB31A

op_ADR const # 

const op_ADR uint32 = 0x2A00

op_ADTR const # 

const op_ADTR uint32 = 0xB3D2

op_ADTRA const # 

const op_ADTRA uint32 = 0xB3D2

op_AE const # 

const op_AE uint32 = 0x7A00

op_AEB const # 

const op_AEB uint32 = 0xED0A

op_AEBR const # 

const op_AEBR uint32 = 0xB30A

op_AER const # 

const op_AER uint32 = 0x3A00

op_AFI const # 

const op_AFI uint32 = 0xC209

op_AG const # 

const op_AG uint32 = 0xE308

op_AGF const # 

const op_AGF uint32 = 0xE318

op_AGFI const # 

const op_AGFI uint32 = 0xC208

op_AGFR const # 

const op_AGFR uint32 = 0xB918

op_AGHI const # 

const op_AGHI uint32 = 0xA70B

op_AGHIK const # 

const op_AGHIK uint32 = 0xECD9

op_AGR const # 

const op_AGR uint32 = 0xB908

op_AGRK const # 

const op_AGRK uint32 = 0xB9E8

op_AGSI const # 

const op_AGSI uint32 = 0xEB7A

op_AH const # 

const op_AH uint32 = 0x4A00

op_AHHHR const # 

const op_AHHHR uint32 = 0xB9C8

op_AHHLR const # 

const op_AHHLR uint32 = 0xB9D8

op_AHI const # 

const op_AHI uint32 = 0xA70A

op_AHIK const # 

const op_AHIK uint32 = 0xECD8

op_AHY const # 

const op_AHY uint32 = 0xE37A

op_AIH const # 

const op_AIH uint32 = 0xCC08

op_AL const # 

const op_AL uint32 = 0x5E00

op_ALC const # 

const op_ALC uint32 = 0xE398

op_ALCG const # 

const op_ALCG uint32 = 0xE388

op_ALCGR const # 

const op_ALCGR uint32 = 0xB988

op_ALCR const # 

const op_ALCR uint32 = 0xB998

op_ALFI const # 

const op_ALFI uint32 = 0xC20B

op_ALG const # 

const op_ALG uint32 = 0xE30A

op_ALGF const # 

const op_ALGF uint32 = 0xE31A

op_ALGFI const # 

const op_ALGFI uint32 = 0xC20A

op_ALGFR const # 

const op_ALGFR uint32 = 0xB91A

op_ALGHSIK const # 

const op_ALGHSIK uint32 = 0xECDB

op_ALGR const # 

const op_ALGR uint32 = 0xB90A

op_ALGRK const # 

const op_ALGRK uint32 = 0xB9EA

op_ALGSI const # 

const op_ALGSI uint32 = 0xEB7E

op_ALHHHR const # 

const op_ALHHHR uint32 = 0xB9CA

op_ALHHLR const # 

const op_ALHHLR uint32 = 0xB9DA

op_ALHSIK const # 

const op_ALHSIK uint32 = 0xECDA

op_ALR const # 

const op_ALR uint32 = 0x1E00

op_ALRK const # 

const op_ALRK uint32 = 0xB9FA

op_ALSI const # 

const op_ALSI uint32 = 0xEB6E

op_ALSIH const # 

const op_ALSIH uint32 = 0xCC0A

op_ALSIHN const # 

const op_ALSIHN uint32 = 0xCC0B

op_ALY const # 

const op_ALY uint32 = 0xE35E

op_AP const # 

const op_AP uint32 = 0xFA00

op_AR const # 

const op_AR uint32 = 0x1A00

op_ARK const # 

const op_ARK uint32 = 0xB9F8

op_ASI const # 

const op_ASI uint32 = 0xEB6A

op_AU const # 

const op_AU uint32 = 0x7E00

op_AUR const # 

const op_AUR uint32 = 0x3E00

op_AW const # 

const op_AW uint32 = 0x6E00

op_AWR const # 

const op_AWR uint32 = 0x2E00

op_AXBR const # 

const op_AXBR uint32 = 0xB34A

op_AXR const # 

const op_AXR uint32 = 0x3600

op_AXTR const # 

const op_AXTR uint32 = 0xB3DA

op_AXTRA const # 

const op_AXTRA uint32 = 0xB3DA

op_AY const # 

const op_AY uint32 = 0xE35A

op_BAKR const # 

const op_BAKR uint32 = 0xB240

op_BAL const # 

const op_BAL uint32 = 0x4500

op_BALR const # 

const op_BALR uint32 = 0x0500

op_BAS const # 

const op_BAS uint32 = 0x4D00

op_BASR const # 

const op_BASR uint32 = 0x0D00

op_BASSM const # 

const op_BASSM uint32 = 0x0C00

op_BC const # 

const op_BC uint32 = 0x4700

op_BCR const # 

const op_BCR uint32 = 0x0700

op_BCT const # 

const op_BCT uint32 = 0x4600

op_BCTG const # 

const op_BCTG uint32 = 0xE346

op_BCTGR const # 

const op_BCTGR uint32 = 0xB946

op_BCTR const # 

const op_BCTR uint32 = 0x0600

op_BPP const # 

const op_BPP uint32 = 0xC700

op_BPRP const # 

const op_BPRP uint32 = 0xC500

op_BRAS const # 

const op_BRAS uint32 = 0xA705

op_BRASL const # 

const op_BRASL uint32 = 0xC005

op_BRC const # 

const op_BRC uint32 = 0xA704

op_BRCL const # 

const op_BRCL uint32 = 0xC004

op_BRCT const # 

const op_BRCT uint32 = 0xA706

op_BRCTG const # 

const op_BRCTG uint32 = 0xA707

op_BRCTH const # 

const op_BRCTH uint32 = 0xCC06

op_BRRK const # 

const op_BRRK uint32 = 0x0001

op_BRXH const # 

const op_BRXH uint32 = 0x8400

op_BRXHG const # 

const op_BRXHG uint32 = 0xEC44

op_BRXLE const # 

const op_BRXLE uint32 = 0x8500

op_BRXLG const # 

const op_BRXLG uint32 = 0xEC45

op_BSA const # 

const op_BSA uint32 = 0xB25A

op_BSG const # 

const op_BSG uint32 = 0xB258

op_BSM const # 

const op_BSM uint32 = 0x0B00

op_BXH const # 

const op_BXH uint32 = 0x8600

op_BXHG const # 

const op_BXHG uint32 = 0xEB44

op_BXLE const # 

const op_BXLE uint32 = 0x8700

op_BXLEG const # 

const op_BXLEG uint32 = 0xEB45

op_C const # 

const op_C uint32 = 0x5900

op_CD const # 

const op_CD uint32 = 0x6900

op_CDB const # 

const op_CDB uint32 = 0xED19

op_CDBR const # 

const op_CDBR uint32 = 0xB319

op_CDFBR const # 

const op_CDFBR uint32 = 0xB395

op_CDFBRA const # 

const op_CDFBRA uint32 = 0xB395

op_CDFR const # 

const op_CDFR uint32 = 0xB3B5

op_CDFTR const # 

const op_CDFTR uint32 = 0xB951

op_CDGBR const # 

const op_CDGBR uint32 = 0xB3A5

op_CDGBRA const # 

const op_CDGBRA uint32 = 0xB3A5

op_CDGR const # 

const op_CDGR uint32 = 0xB3C5

op_CDGTR const # 

const op_CDGTR uint32 = 0xB3F1

op_CDGTRA const # 

const op_CDGTRA uint32 = 0xB3F1

op_CDLFBR const # 

const op_CDLFBR uint32 = 0xB391

op_CDLFTR const # 

const op_CDLFTR uint32 = 0xB953

op_CDLGBR const # 

const op_CDLGBR uint32 = 0xB3A1

op_CDLGTR const # 

const op_CDLGTR uint32 = 0xB952

op_CDPT const # 

const op_CDPT uint32 = 0xEDAE

op_CDR const # 

const op_CDR uint32 = 0x2900

op_CDS const # 

const op_CDS uint32 = 0xBB00

op_CDSG const # 

const op_CDSG uint32 = 0xEB3E

op_CDSTR const # 

const op_CDSTR uint32 = 0xB3F3

op_CDSY const # 

const op_CDSY uint32 = 0xEB31

op_CDTR const # 

const op_CDTR uint32 = 0xB3E4

op_CDUTR const # 

const op_CDUTR uint32 = 0xB3F2

op_CDZT const # 

const op_CDZT uint32 = 0xEDAA

op_CE const # 

const op_CE uint32 = 0x7900

op_CEB const # 

const op_CEB uint32 = 0xED09

op_CEBR const # 

const op_CEBR uint32 = 0xB309

op_CEDTR const # 

const op_CEDTR uint32 = 0xB3F4

op_CEFBR const # 

const op_CEFBR uint32 = 0xB394

op_CEFBRA const # 

const op_CEFBRA uint32 = 0xB394

op_CEFR const # 

const op_CEFR uint32 = 0xB3B4

op_CEGBR const # 

const op_CEGBR uint32 = 0xB3A4

op_CEGBRA const # 

const op_CEGBRA uint32 = 0xB3A4

op_CEGR const # 

const op_CEGR uint32 = 0xB3C4

op_CELFBR const # 

const op_CELFBR uint32 = 0xB390

op_CELGBR const # 

const op_CELGBR uint32 = 0xB3A0

op_CER const # 

const op_CER uint32 = 0x3900

op_CEXTR const # 

const op_CEXTR uint32 = 0xB3FC

op_CFC const # 

const op_CFC uint32 = 0xB21A

op_CFDBR const # 

const op_CFDBR uint32 = 0xB399

op_CFDBRA const # 

const op_CFDBRA uint32 = 0xB399

op_CFDR const # 

const op_CFDR uint32 = 0xB3B9

op_CFDTR const # 

const op_CFDTR uint32 = 0xB941

op_CFEBR const # 

const op_CFEBR uint32 = 0xB398

op_CFEBRA const # 

const op_CFEBRA uint32 = 0xB398

op_CFER const # 

const op_CFER uint32 = 0xB3B8

op_CFI const # 

const op_CFI uint32 = 0xC20D

op_CFXBR const # 

const op_CFXBR uint32 = 0xB39A

op_CFXBRA const # 

const op_CFXBRA uint32 = 0xB39A

op_CFXR const # 

const op_CFXR uint32 = 0xB3BA

op_CFXTR const # 

const op_CFXTR uint32 = 0xB949

op_CG const # 

const op_CG uint32 = 0xE320

op_CGDBR const # 

const op_CGDBR uint32 = 0xB3A9

op_CGDBRA const # 

const op_CGDBRA uint32 = 0xB3A9

op_CGDR const # 

const op_CGDR uint32 = 0xB3C9

op_CGDTR const # 

const op_CGDTR uint32 = 0xB3E1

op_CGDTRA const # 

const op_CGDTRA uint32 = 0xB3E1

op_CGEBR const # 

const op_CGEBR uint32 = 0xB3A8

op_CGEBRA const # 

const op_CGEBRA uint32 = 0xB3A8

op_CGER const # 

const op_CGER uint32 = 0xB3C8

op_CGF const # 

const op_CGF uint32 = 0xE330

op_CGFI const # 

const op_CGFI uint32 = 0xC20C

op_CGFR const # 

const op_CGFR uint32 = 0xB930

op_CGFRL const # 

const op_CGFRL uint32 = 0xC60C

op_CGH const # 

const op_CGH uint32 = 0xE334

op_CGHI const # 

const op_CGHI uint32 = 0xA70F

op_CGHRL const # 

const op_CGHRL uint32 = 0xC604

op_CGHSI const # 

const op_CGHSI uint32 = 0xE558

op_CGIB const # 

const op_CGIB uint32 = 0xECFC

op_CGIJ const # 

const op_CGIJ uint32 = 0xEC7C

op_CGIT const # 

const op_CGIT uint32 = 0xEC70

op_CGR const # 

const op_CGR uint32 = 0xB920

op_CGRB const # 

const op_CGRB uint32 = 0xECE4

op_CGRJ const # 

const op_CGRJ uint32 = 0xEC64

op_CGRL const # 

const op_CGRL uint32 = 0xC608

op_CGRT const # 

const op_CGRT uint32 = 0xB960

op_CGXBR const # 

const op_CGXBR uint32 = 0xB3AA

op_CGXBRA const # 

const op_CGXBRA uint32 = 0xB3AA

op_CGXR const # 

const op_CGXR uint32 = 0xB3CA

op_CGXTR const # 

const op_CGXTR uint32 = 0xB3E9

op_CGXTRA const # 

const op_CGXTRA uint32 = 0xB3E9

op_CH const # 

const op_CH uint32 = 0x4900

op_CHF const # 

const op_CHF uint32 = 0xE3CD

op_CHHR const # 

const op_CHHR uint32 = 0xB9CD

op_CHHSI const # 

const op_CHHSI uint32 = 0xE554

op_CHI const # 

const op_CHI uint32 = 0xA70E

op_CHLR const # 

const op_CHLR uint32 = 0xB9DD

op_CHRL const # 

const op_CHRL uint32 = 0xC605

op_CHSI const # 

const op_CHSI uint32 = 0xE55C

op_CHY const # 

const op_CHY uint32 = 0xE379

op_CIB const # 

const op_CIB uint32 = 0xECFE

op_CIH const # 

const op_CIH uint32 = 0xCC0D

op_CIJ const # 

const op_CIJ uint32 = 0xEC7E

op_CIT const # 

const op_CIT uint32 = 0xEC72

op_CKSM const # 

const op_CKSM uint32 = 0xB241

op_CL const # 

const op_CL uint32 = 0x5500

op_CLC const # 

const op_CLC uint32 = 0xD500

op_CLCL const # 

const op_CLCL uint32 = 0x0F00

op_CLCLE const # 

const op_CLCLE uint32 = 0xA900

op_CLCLU const # 

const op_CLCLU uint32 = 0xEB8F

op_CLFDBR const # 

const op_CLFDBR uint32 = 0xB39D

op_CLFDTR const # 

const op_CLFDTR uint32 = 0xB943

op_CLFEBR const # 

const op_CLFEBR uint32 = 0xB39C

op_CLFHSI const # 

const op_CLFHSI uint32 = 0xE55D

op_CLFI const # 

const op_CLFI uint32 = 0xC20F

op_CLFIT const # 

const op_CLFIT uint32 = 0xEC73

op_CLFXBR const # 

const op_CLFXBR uint32 = 0xB39E

op_CLFXTR const # 

const op_CLFXTR uint32 = 0xB94B

op_CLG const # 

const op_CLG uint32 = 0xE321

op_CLGDBR const # 

const op_CLGDBR uint32 = 0xB3AD

op_CLGDTR const # 

const op_CLGDTR uint32 = 0xB942

op_CLGEBR const # 

const op_CLGEBR uint32 = 0xB3AC

op_CLGF const # 

const op_CLGF uint32 = 0xE331

op_CLGFI const # 

const op_CLGFI uint32 = 0xC20E

op_CLGFR const # 

const op_CLGFR uint32 = 0xB931

op_CLGFRL const # 

const op_CLGFRL uint32 = 0xC60E

op_CLGHRL const # 

const op_CLGHRL uint32 = 0xC606

op_CLGHSI const # 

const op_CLGHSI uint32 = 0xE559

op_CLGIB const # 

const op_CLGIB uint32 = 0xECFD

op_CLGIJ const # 

const op_CLGIJ uint32 = 0xEC7D

op_CLGIT const # 

const op_CLGIT uint32 = 0xEC71

op_CLGR const # 

const op_CLGR uint32 = 0xB921

op_CLGRB const # 

const op_CLGRB uint32 = 0xECE5

op_CLGRJ const # 

const op_CLGRJ uint32 = 0xEC65

op_CLGRL const # 

const op_CLGRL uint32 = 0xC60A

op_CLGRT const # 

const op_CLGRT uint32 = 0xB961

op_CLGT const # 

const op_CLGT uint32 = 0xEB2B

op_CLGXBR const # 

const op_CLGXBR uint32 = 0xB3AE

op_CLGXTR const # 

const op_CLGXTR uint32 = 0xB94A

op_CLHF const # 

const op_CLHF uint32 = 0xE3CF

op_CLHHR const # 

const op_CLHHR uint32 = 0xB9CF

op_CLHHSI const # 

const op_CLHHSI uint32 = 0xE555

op_CLHLR const # 

const op_CLHLR uint32 = 0xB9DF

op_CLHRL const # 

const op_CLHRL uint32 = 0xC607

op_CLI const # 

const op_CLI uint32 = 0x9500

op_CLIB const # 

const op_CLIB uint32 = 0xECFF

op_CLIH const # 

const op_CLIH uint32 = 0xCC0F

op_CLIJ const # 

const op_CLIJ uint32 = 0xEC7F

op_CLIY const # 

const op_CLIY uint32 = 0xEB55

op_CLM const # 

const op_CLM uint32 = 0xBD00

op_CLMH const # 

const op_CLMH uint32 = 0xEB20

op_CLMY const # 

const op_CLMY uint32 = 0xEB21

op_CLR const # 

const op_CLR uint32 = 0x1500

op_CLRB const # 

const op_CLRB uint32 = 0xECF7

op_CLRJ const # 

const op_CLRJ uint32 = 0xEC77

op_CLRL const # 

const op_CLRL uint32 = 0xC60F

op_CLRT const # 

const op_CLRT uint32 = 0xB973

op_CLST const # 

const op_CLST uint32 = 0xB25D

op_CLT const # 

const op_CLT uint32 = 0xEB23

op_CLY const # 

const op_CLY uint32 = 0xE355

op_CMPSC const # 

const op_CMPSC uint32 = 0xB263

op_CP const # 

const op_CP uint32 = 0xF900

op_CPDT const # 

const op_CPDT uint32 = 0xEDAC

op_CPSDR const # 

const op_CPSDR uint32 = 0xB372

op_CPXT const # 

const op_CPXT uint32 = 0xEDAD

op_CPYA const # 

const op_CPYA uint32 = 0xB24D

op_CR const # 

const op_CR uint32 = 0x1900

op_CRB const # 

const op_CRB uint32 = 0xECF6

op_CRDTE const # 

const op_CRDTE uint32 = 0xB98F

op_CRJ const # 

const op_CRJ uint32 = 0xEC76

op_CRL const # 

const op_CRL uint32 = 0xC60D

op_CRT const # 

const op_CRT uint32 = 0xB972

op_CS const # 

const op_CS uint32 = 0xBA00

op_CSCH const # 

const op_CSCH uint32 = 0xB230

op_CSDTR const # 

const op_CSDTR uint32 = 0xB3E3

op_CSG const # 

const op_CSG uint32 = 0xEB30

op_CSP const # 

const op_CSP uint32 = 0xB250

op_CSPG const # 

const op_CSPG uint32 = 0xB98A

op_CSST const # 

const op_CSST uint32 = 0xC802

op_CSXTR const # 

const op_CSXTR uint32 = 0xB3EB

op_CSY const # 

const op_CSY uint32 = 0xEB14

op_CU12 const # 

const op_CU12 uint32 = 0xB2A7

op_CU14 const # 

const op_CU14 uint32 = 0xB9B0

op_CU21 const # 

const op_CU21 uint32 = 0xB2A6

op_CU24 const # 

const op_CU24 uint32 = 0xB9B1

op_CU41 const # 

const op_CU41 uint32 = 0xB9B2

op_CU42 const # 

const op_CU42 uint32 = 0xB9B3

op_CUDTR const # 

const op_CUDTR uint32 = 0xB3E2

op_CUSE const # 

const op_CUSE uint32 = 0xB257

op_CUTFU const # 

const op_CUTFU uint32 = 0xB2A7

op_CUUTF const # 

const op_CUUTF uint32 = 0xB2A6

op_CUXTR const # 

const op_CUXTR uint32 = 0xB3EA

op_CVB const # 

const op_CVB uint32 = 0x4F00

op_CVBG const # 

const op_CVBG uint32 = 0xE30E

op_CVBY const # 

const op_CVBY uint32 = 0xE306

op_CVD const # 

const op_CVD uint32 = 0x4E00

op_CVDG const # 

const op_CVDG uint32 = 0xE32E

op_CVDY const # 

const op_CVDY uint32 = 0xE326

op_CXBR const # 

const op_CXBR uint32 = 0xB349

op_CXFBR const # 

const op_CXFBR uint32 = 0xB396

op_CXFBRA const # 

const op_CXFBRA uint32 = 0xB396

op_CXFR const # 

const op_CXFR uint32 = 0xB3B6

op_CXFTR const # 

const op_CXFTR uint32 = 0xB959

op_CXGBR const # 

const op_CXGBR uint32 = 0xB3A6

op_CXGBRA const # 

const op_CXGBRA uint32 = 0xB3A6

op_CXGR const # 

const op_CXGR uint32 = 0xB3C6

op_CXGTR const # 

const op_CXGTR uint32 = 0xB3F9

op_CXGTRA const # 

const op_CXGTRA uint32 = 0xB3F9

op_CXLFBR const # 

const op_CXLFBR uint32 = 0xB392

op_CXLFTR const # 

const op_CXLFTR uint32 = 0xB95B

op_CXLGBR const # 

const op_CXLGBR uint32 = 0xB3A2

op_CXLGTR const # 

const op_CXLGTR uint32 = 0xB95A

op_CXPT const #

added in z13

const op_CXPT uint32 = 0xEDAF

op_CXR const # 

const op_CXR uint32 = 0xB369

op_CXSTR const # 

const op_CXSTR uint32 = 0xB3FB

op_CXTR const # 

const op_CXTR uint32 = 0xB3EC

op_CXUTR const # 

const op_CXUTR uint32 = 0xB3FA

op_CXZT const # 

const op_CXZT uint32 = 0xEDAB

op_CY const # 

const op_CY uint32 = 0xE359

op_CZDT const # 

const op_CZDT uint32 = 0xEDA8

op_CZXT const # 

const op_CZXT uint32 = 0xEDA9

op_D const # 

const op_D uint32 = 0x5D00

op_DD const # 

const op_DD uint32 = 0x6D00

op_DDB const # 

const op_DDB uint32 = 0xED1D

op_DDBR const # 

const op_DDBR uint32 = 0xB31D

op_DDR const # 

const op_DDR uint32 = 0x2D00

op_DDTR const # 

const op_DDTR uint32 = 0xB3D1

op_DDTRA const # 

const op_DDTRA uint32 = 0xB3D1

op_DE const # 

const op_DE uint32 = 0x7D00

op_DEB const # 

const op_DEB uint32 = 0xED0D

op_DEBR const # 

const op_DEBR uint32 = 0xB30D

op_DER const # 

const op_DER uint32 = 0x3D00

op_DIDBR const # 

const op_DIDBR uint32 = 0xB35B

op_DIEBR const # 

const op_DIEBR uint32 = 0xB353

op_DL const # 

const op_DL uint32 = 0xE397

op_DLG const # 

const op_DLG uint32 = 0xE387

op_DLGR const # 

const op_DLGR uint32 = 0xB987

op_DLR const # 

const op_DLR uint32 = 0xB997

op_DP const # 

const op_DP uint32 = 0xFD00

op_DR const # 

const op_DR uint32 = 0x1D00

op_DSG const # 

const op_DSG uint32 = 0xE30D

op_DSGF const # 

const op_DSGF uint32 = 0xE31D

op_DSGFR const # 

const op_DSGFR uint32 = 0xB91D

op_DSGR const # 

const op_DSGR uint32 = 0xB90D

op_DXBR const # 

const op_DXBR uint32 = 0xB34D

op_DXR const # 

const op_DXR uint32 = 0xB22D

op_DXTR const # 

const op_DXTR uint32 = 0xB3D9

op_DXTRA const # 

const op_DXTRA uint32 = 0xB3D9

op_EAR const # 

const op_EAR uint32 = 0xB24F

op_ECAG const # 

const op_ECAG uint32 = 0xEB4C

op_ECTG const # 

const op_ECTG uint32 = 0xC801

op_ED const # 

const op_ED uint32 = 0xDE00

op_EDMK const # 

const op_EDMK uint32 = 0xDF00

op_EEDTR const # 

const op_EEDTR uint32 = 0xB3E5

op_EEXTR const # 

const op_EEXTR uint32 = 0xB3ED

op_EFPC const # 

const op_EFPC uint32 = 0xB38C

op_EPAIR const # 

const op_EPAIR uint32 = 0xB99A

op_EPAR const # 

const op_EPAR uint32 = 0xB226

op_EPSW const # 

const op_EPSW uint32 = 0xB98D

op_EREG const # 

const op_EREG uint32 = 0xB249

op_EREGG const # 

const op_EREGG uint32 = 0xB90E

op_ESAIR const # 

const op_ESAIR uint32 = 0xB99B

op_ESAR const # 

const op_ESAR uint32 = 0xB227

op_ESDTR const # 

const op_ESDTR uint32 = 0xB3E7

op_ESEA const # 

const op_ESEA uint32 = 0xB99D

op_ESTA const # 

const op_ESTA uint32 = 0xB24A

op_ESXTR const # 

const op_ESXTR uint32 = 0xB3EF

op_ETND const # 

const op_ETND uint32 = 0xB2EC

op_EX const # 

const op_EX uint32 = 0x4400

op_EXRL const # 

const op_EXRL uint32 = 0xC600

op_FIDBR const # 

const op_FIDBR uint32 = 0xB35F

op_FIDBRA const # 

const op_FIDBRA uint32 = 0xB35F

op_FIDR const # 

const op_FIDR uint32 = 0xB37F

op_FIDTR const # 

const op_FIDTR uint32 = 0xB3D7

op_FIEBR const # 

const op_FIEBR uint32 = 0xB357

op_FIEBRA const # 

const op_FIEBRA uint32 = 0xB357

op_FIER const # 

const op_FIER uint32 = 0xB377

op_FIXBR const # 

const op_FIXBR uint32 = 0xB347

op_FIXBRA const # 

const op_FIXBRA uint32 = 0xB347

op_FIXR const # 

const op_FIXR uint32 = 0xB367

op_FIXTR const # 

const op_FIXTR uint32 = 0xB3DF

op_FLOGR const # 

const op_FLOGR uint32 = 0xB983

op_HDR const # 

const op_HDR uint32 = 0x2400

op_HER const # 

const op_HER uint32 = 0x3400

op_HSCH const # 

const op_HSCH uint32 = 0xB231

op_IAC const # 

const op_IAC uint32 = 0xB224

op_IC const # 

const op_IC uint32 = 0x4300

op_ICM const # 

const op_ICM uint32 = 0xBF00

op_ICMH const # 

const op_ICMH uint32 = 0xEB80

op_ICMY const # 

const op_ICMY uint32 = 0xEB81

op_ICY const # 

const op_ICY uint32 = 0xE373

op_IDTE const # 

const op_IDTE uint32 = 0xB98E

op_IEDTR const # 

const op_IEDTR uint32 = 0xB3F6

op_IEXTR const # 

const op_IEXTR uint32 = 0xB3FE

op_IIHF const # 

const op_IIHF uint32 = 0xC008

op_IIHH const # 

const op_IIHH uint32 = 0xA500

op_IIHL const # 

const op_IIHL uint32 = 0xA501

op_IILF const # 

const op_IILF uint32 = 0xC009

op_IILH const # 

const op_IILH uint32 = 0xA502

op_IILL const # 

const op_IILL uint32 = 0xA503

op_IPK const # 

const op_IPK uint32 = 0xB20B

op_IPM const # 

const op_IPM uint32 = 0xB222

op_IPTE const # 

const op_IPTE uint32 = 0xB221

op_ISKE const # 

const op_ISKE uint32 = 0xB229

op_IVSK const # 

const op_IVSK uint32 = 0xB223

op_KDB const # 

const op_KDB uint32 = 0xED18

op_KDBR const # 

const op_KDBR uint32 = 0xB318

op_KDSA const #

added in z15

const op_KDSA uint32 = 0xB93A

op_KDTR const # 

const op_KDTR uint32 = 0xB3E0

op_KEB const # 

const op_KEB uint32 = 0xED08

op_KEBR const # 

const op_KEBR uint32 = 0xB308

op_KIMD const # 

const op_KIMD uint32 = 0xB93E

op_KLMD const # 

const op_KLMD uint32 = 0xB93F

op_KM const # 

const op_KM uint32 = 0xB92E

op_KMA const # 

const op_KMA uint32 = 0xB929

op_KMAC const # 

const op_KMAC uint32 = 0xB91E

op_KMC const # 

const op_KMC uint32 = 0xB92F

op_KMCTR const # 

const op_KMCTR uint32 = 0xB92D

op_KMF const # 

const op_KMF uint32 = 0xB92A

op_KMO const # 

const op_KMO uint32 = 0xB92B

op_KXBR const # 

const op_KXBR uint32 = 0xB348

op_KXTR const # 

const op_KXTR uint32 = 0xB3E8

op_L const # 

const op_L uint32 = 0x5800

op_LA const # 

const op_LA uint32 = 0x4100

op_LAA const # 

const op_LAA uint32 = 0xEBF8

op_LAAG const # 

const op_LAAG uint32 = 0xEBE8

op_LAAL const # 

const op_LAAL uint32 = 0xEBFA

op_LAALG const # 

const op_LAALG uint32 = 0xEBEA

op_LAE const # 

const op_LAE uint32 = 0x5100

op_LAEY const # 

const op_LAEY uint32 = 0xE375

op_LAM const # 

const op_LAM uint32 = 0x9A00

op_LAMY const # 

const op_LAMY uint32 = 0xEB9A

op_LAN const # 

const op_LAN uint32 = 0xEBF4

op_LANG const # 

const op_LANG uint32 = 0xEBE4

op_LAO const # 

const op_LAO uint32 = 0xEBF6

op_LAOG const # 

const op_LAOG uint32 = 0xEBE6

op_LARL const # 

const op_LARL uint32 = 0xC000

op_LASP const # 

const op_LASP uint32 = 0xE500

op_LAT const # 

const op_LAT uint32 = 0xE39F

op_LAX const # 

const op_LAX uint32 = 0xEBF7

op_LAXG const # 

const op_LAXG uint32 = 0xEBE7

op_LAY const # 

const op_LAY uint32 = 0xE371

op_LB const # 

const op_LB uint32 = 0xE376

op_LBH const # 

const op_LBH uint32 = 0xE3C0

op_LBR const # 

const op_LBR uint32 = 0xB926

op_LCCB const # 

const op_LCCB uint32 = 0xE727

op_LCDBR const # 

const op_LCDBR uint32 = 0xB313

op_LCDFR const # 

const op_LCDFR uint32 = 0xB373

op_LCDR const # 

const op_LCDR uint32 = 0x2300

op_LCEBR const # 

const op_LCEBR uint32 = 0xB303

op_LCER const # 

const op_LCER uint32 = 0x3300

op_LCGFR const # 

const op_LCGFR uint32 = 0xB913

op_LCGR const # 

const op_LCGR uint32 = 0xB903

op_LCR const # 

const op_LCR uint32 = 0x1300

op_LCTL const # 

const op_LCTL uint32 = 0xB700

op_LCTLG const # 

const op_LCTLG uint32 = 0xEB2F

op_LCXBR const # 

const op_LCXBR uint32 = 0xB343

op_LCXR const # 

const op_LCXR uint32 = 0xB363

op_LD const # 

const op_LD uint32 = 0x6800

op_LDE const # 

const op_LDE uint32 = 0xED24

op_LDEB const # 

const op_LDEB uint32 = 0xED04

op_LDEBR const # 

const op_LDEBR uint32 = 0xB304

op_LDER const # 

const op_LDER uint32 = 0xB324

op_LDETR const # 

const op_LDETR uint32 = 0xB3D4

op_LDGR const # 

const op_LDGR uint32 = 0xB3C1

op_LDR const # 

const op_LDR uint32 = 0x2800

op_LDXBR const # 

const op_LDXBR uint32 = 0xB345

op_LDXBRA const # 

const op_LDXBRA uint32 = 0xB345

op_LDXR const # 

const op_LDXR uint32 = 0x2500

op_LDXTR const # 

const op_LDXTR uint32 = 0xB3DD

op_LDY const # 

const op_LDY uint32 = 0xED65

op_LE const # 

const op_LE uint32 = 0x7800

op_LEDBR const # 

const op_LEDBR uint32 = 0xB344

op_LEDBRA const # 

const op_LEDBRA uint32 = 0xB344

op_LEDR const # 

const op_LEDR uint32 = 0x3500

op_LEDTR const # 

const op_LEDTR uint32 = 0xB3D5

op_LER const # 

const op_LER uint32 = 0x3800

op_LEXBR const # 

const op_LEXBR uint32 = 0xB346

op_LEXBRA const # 

const op_LEXBRA uint32 = 0xB346

op_LEXR const # 

const op_LEXR uint32 = 0xB366

op_LEY const # 

const op_LEY uint32 = 0xED64

op_LFAS const # 

const op_LFAS uint32 = 0xB2BD

op_LFH const # 

const op_LFH uint32 = 0xE3CA

op_LFHAT const # 

const op_LFHAT uint32 = 0xE3C8

op_LFPC const # 

const op_LFPC uint32 = 0xB29D

op_LG const # 

const op_LG uint32 = 0xE304

op_LGAT const # 

const op_LGAT uint32 = 0xE385

op_LGB const # 

const op_LGB uint32 = 0xE377

op_LGBR const # 

const op_LGBR uint32 = 0xB906

op_LGDR const # 

const op_LGDR uint32 = 0xB3CD

op_LGF const # 

const op_LGF uint32 = 0xE314

op_LGFI const # 

const op_LGFI uint32 = 0xC001

op_LGFR const # 

const op_LGFR uint32 = 0xB914

op_LGFRL const # 

const op_LGFRL uint32 = 0xC40C

op_LGH const # 

const op_LGH uint32 = 0xE315

op_LGHI const # 

const op_LGHI uint32 = 0xA709

op_LGHR const # 

const op_LGHR uint32 = 0xB907

op_LGHRL const # 

const op_LGHRL uint32 = 0xC404

op_LGR const # 

const op_LGR uint32 = 0xB904

op_LGRL const # 

const op_LGRL uint32 = 0xC408

op_LH const # 

const op_LH uint32 = 0x4800

op_LHH const # 

const op_LHH uint32 = 0xE3C4

op_LHI const # 

const op_LHI uint32 = 0xA708

op_LHR const # 

const op_LHR uint32 = 0xB927

op_LHRL const # 

const op_LHRL uint32 = 0xC405

op_LHY const # 

const op_LHY uint32 = 0xE378

op_LLC const # 

const op_LLC uint32 = 0xE394

op_LLCH const # 

const op_LLCH uint32 = 0xE3C2

op_LLCR const # 

const op_LLCR uint32 = 0xB994

op_LLGC const # 

const op_LLGC uint32 = 0xE390

op_LLGCR const # 

const op_LLGCR uint32 = 0xB984

op_LLGF const # 

const op_LLGF uint32 = 0xE316

op_LLGFAT const # 

const op_LLGFAT uint32 = 0xE39D

op_LLGFR const # 

const op_LLGFR uint32 = 0xB916

op_LLGFRL const # 

const op_LLGFRL uint32 = 0xC40E

op_LLGH const # 

const op_LLGH uint32 = 0xE391

op_LLGHR const # 

const op_LLGHR uint32 = 0xB985

op_LLGHRL const # 

const op_LLGHRL uint32 = 0xC406

op_LLGT const # 

const op_LLGT uint32 = 0xE317

op_LLGTAT const # 

const op_LLGTAT uint32 = 0xE39C

op_LLGTR const # 

const op_LLGTR uint32 = 0xB917

op_LLH const # 

const op_LLH uint32 = 0xE395

op_LLHH const # 

const op_LLHH uint32 = 0xE3C6

op_LLHR const # 

const op_LLHR uint32 = 0xB995

op_LLHRL const # 

const op_LLHRL uint32 = 0xC402

op_LLIHF const # 

const op_LLIHF uint32 = 0xC00E

op_LLIHH const # 

const op_LLIHH uint32 = 0xA50C

op_LLIHL const # 

const op_LLIHL uint32 = 0xA50D

op_LLILF const # 

const op_LLILF uint32 = 0xC00F

op_LLILH const # 

const op_LLILH uint32 = 0xA50E

op_LLILL const # 

const op_LLILL uint32 = 0xA50F

op_LLZRGF const # 

const op_LLZRGF uint32 = 0xE33A

op_LM const # 

const op_LM uint32 = 0x9800

op_LMD const # 

const op_LMD uint32 = 0xEF00

op_LMG const # 

const op_LMG uint32 = 0xEB04

op_LMH const # 

const op_LMH uint32 = 0xEB96

op_LMY const # 

const op_LMY uint32 = 0xEB98

op_LNDBR const # 

const op_LNDBR uint32 = 0xB311

op_LNDFR const # 

const op_LNDFR uint32 = 0xB371

op_LNDR const # 

const op_LNDR uint32 = 0x2100

op_LNEBR const # 

const op_LNEBR uint32 = 0xB301

op_LNER const # 

const op_LNER uint32 = 0x3100

op_LNGFR const # 

const op_LNGFR uint32 = 0xB911

op_LNGR const # 

const op_LNGR uint32 = 0xB901

op_LNR const # 

const op_LNR uint32 = 0x1100

op_LNXBR const # 

const op_LNXBR uint32 = 0xB341

op_LNXR const # 

const op_LNXR uint32 = 0xB361

op_LOC const # 

const op_LOC uint32 = 0xEBF2

op_LOCFH const # 

const op_LOCFH uint32 = 0xEBE0

op_LOCFHR const # 

const op_LOCFHR uint32 = 0xB9E0

op_LOCG const # 

const op_LOCG uint32 = 0xEBE2

op_LOCGHI const # 

const op_LOCGHI uint32 = 0xEC46

op_LOCGR const # 

const op_LOCGR uint32 = 0xB9E2

op_LOCHHI const # 

const op_LOCHHI uint32 = 0xEC4E

op_LOCHI const # 

const op_LOCHI uint32 = 0xEC42

op_LOCR const # 

const op_LOCR uint32 = 0xB9F2

op_LPD const # 

const op_LPD uint32 = 0xC804

op_LPDBR const # 

const op_LPDBR uint32 = 0xB310

op_LPDFR const # 

const op_LPDFR uint32 = 0xB370

op_LPDG const # 

const op_LPDG uint32 = 0xC805

op_LPDR const # 

const op_LPDR uint32 = 0x2000

op_LPEBR const # 

const op_LPEBR uint32 = 0xB300

op_LPER const # 

const op_LPER uint32 = 0x3000

op_LPGFR const # 

const op_LPGFR uint32 = 0xB910

op_LPGR const # 

const op_LPGR uint32 = 0xB900

op_LPQ const # 

const op_LPQ uint32 = 0xE38F

op_LPR const # 

const op_LPR uint32 = 0x1000

op_LPSW const # 

const op_LPSW uint32 = 0x8200

op_LPSWE const # 

const op_LPSWE uint32 = 0xB2B2

op_LPTEA const # 

const op_LPTEA uint32 = 0xB9AA

op_LPXBR const # 

const op_LPXBR uint32 = 0xB340

op_LPXR const # 

const op_LPXR uint32 = 0xB360

op_LR const # 

const op_LR uint32 = 0x1800

op_LRA const # 

const op_LRA uint32 = 0xB100

op_LRAG const # 

const op_LRAG uint32 = 0xE303

op_LRAY const # 

const op_LRAY uint32 = 0xE313

op_LRDR const # 

const op_LRDR uint32 = 0x2500

op_LRER const # 

const op_LRER uint32 = 0x3500

op_LRL const # 

const op_LRL uint32 = 0xC40D

op_LRV const # 

const op_LRV uint32 = 0xE31E

op_LRVG const # 

const op_LRVG uint32 = 0xE30F

op_LRVGR const # 

const op_LRVGR uint32 = 0xB90F

op_LRVH const # 

const op_LRVH uint32 = 0xE31F

op_LRVR const # 

const op_LRVR uint32 = 0xB91F

op_LT const # 

const op_LT uint32 = 0xE312

op_LTDBR const # 

const op_LTDBR uint32 = 0xB312

op_LTDR const # 

const op_LTDR uint32 = 0x2200

op_LTDTR const # 

const op_LTDTR uint32 = 0xB3D6

op_LTEBR const # 

const op_LTEBR uint32 = 0xB302

op_LTER const # 

const op_LTER uint32 = 0x3200

op_LTG const # 

const op_LTG uint32 = 0xE302

op_LTGF const # 

const op_LTGF uint32 = 0xE332

op_LTGFR const # 

const op_LTGFR uint32 = 0xB912

op_LTGR const # 

const op_LTGR uint32 = 0xB902

op_LTR const # 

const op_LTR uint32 = 0x1200

op_LTXBR const # 

const op_LTXBR uint32 = 0xB342

op_LTXR const # 

const op_LTXR uint32 = 0xB362

op_LTXTR const # 

const op_LTXTR uint32 = 0xB3DE

op_LURA const # 

const op_LURA uint32 = 0xB24B

op_LURAG const # 

const op_LURAG uint32 = 0xB905

op_LXD const # 

const op_LXD uint32 = 0xED25

op_LXDB const # 

const op_LXDB uint32 = 0xED05

op_LXDBR const # 

const op_LXDBR uint32 = 0xB305

op_LXDR const # 

const op_LXDR uint32 = 0xB325

op_LXDTR const # 

const op_LXDTR uint32 = 0xB3DC

op_LXE const # 

const op_LXE uint32 = 0xED26

op_LXEB const # 

const op_LXEB uint32 = 0xED06

op_LXEBR const # 

const op_LXEBR uint32 = 0xB306

op_LXER const # 

const op_LXER uint32 = 0xB326

op_LXR const # 

const op_LXR uint32 = 0xB365

op_LY const # 

const op_LY uint32 = 0xE358

op_LZDR const # 

const op_LZDR uint32 = 0xB375

op_LZER const # 

const op_LZER uint32 = 0xB374

op_LZRF const # 

const op_LZRF uint32 = 0xE33B

op_LZRG const # 

const op_LZRG uint32 = 0xE32A

op_LZXR const # 

const op_LZXR uint32 = 0xB376

op_M const # 

const op_M uint32 = 0x5C00

op_MAD const # 

const op_MAD uint32 = 0xED3E

op_MADB const # 

const op_MADB uint32 = 0xED1E

op_MADBR const # 

const op_MADBR uint32 = 0xB31E

op_MADR const # 

const op_MADR uint32 = 0xB33E

op_MAE const # 

const op_MAE uint32 = 0xED2E

op_MAEB const # 

const op_MAEB uint32 = 0xED0E

op_MAEBR const # 

const op_MAEBR uint32 = 0xB30E

op_MAER const # 

const op_MAER uint32 = 0xB32E

op_MAY const # 

const op_MAY uint32 = 0xED3A

op_MAYH const # 

const op_MAYH uint32 = 0xED3C

op_MAYHR const # 

const op_MAYHR uint32 = 0xB33C

op_MAYL const # 

const op_MAYL uint32 = 0xED38

op_MAYLR const # 

const op_MAYLR uint32 = 0xB338

op_MAYR const # 

const op_MAYR uint32 = 0xB33A

op_MC const # 

const op_MC uint32 = 0xAF00

op_MD const # 

const op_MD uint32 = 0x6C00

op_MDB const # 

const op_MDB uint32 = 0xED1C

op_MDBR const # 

const op_MDBR uint32 = 0xB31C

op_MDE const # 

const op_MDE uint32 = 0x7C00

op_MDEB const # 

const op_MDEB uint32 = 0xED0C

op_MDEBR const # 

const op_MDEBR uint32 = 0xB30C

op_MDER const # 

const op_MDER uint32 = 0x3C00

op_MDR const # 

const op_MDR uint32 = 0x2C00

op_MDTR const # 

const op_MDTR uint32 = 0xB3D0

op_MDTRA const # 

const op_MDTRA uint32 = 0xB3D0

op_ME const # 

const op_ME uint32 = 0x7C00

op_MEE const # 

const op_MEE uint32 = 0xED37

op_MEEB const # 

const op_MEEB uint32 = 0xED17

op_MEEBR const # 

const op_MEEBR uint32 = 0xB317

op_MEER const # 

const op_MEER uint32 = 0xB337

op_MER const # 

const op_MER uint32 = 0x3C00

op_MFY const # 

const op_MFY uint32 = 0xE35C

op_MGHI const # 

const op_MGHI uint32 = 0xA70D

op_MH const # 

const op_MH uint32 = 0x4C00

op_MHI const # 

const op_MHI uint32 = 0xA70C

op_MHY const # 

const op_MHY uint32 = 0xE37C

op_ML const # 

const op_ML uint32 = 0xE396

op_MLG const # 

const op_MLG uint32 = 0xE386

op_MLGR const # 

const op_MLGR uint32 = 0xB986

op_MLR const # 

const op_MLR uint32 = 0xB996

op_MP const # 

const op_MP uint32 = 0xFC00

op_MR const # 

const op_MR uint32 = 0x1C00

op_MS const # 

const op_MS uint32 = 0x7100

op_MSCH const # 

const op_MSCH uint32 = 0xB232

op_MSD const # 

const op_MSD uint32 = 0xED3F

op_MSDB const # 

const op_MSDB uint32 = 0xED1F

op_MSDBR const # 

const op_MSDBR uint32 = 0xB31F

op_MSDR const # 

const op_MSDR uint32 = 0xB33F

op_MSE const # 

const op_MSE uint32 = 0xED2F

op_MSEB const # 

const op_MSEB uint32 = 0xED0F

op_MSEBR const # 

const op_MSEBR uint32 = 0xB30F

op_MSER const # 

const op_MSER uint32 = 0xB32F

op_MSFI const # 

const op_MSFI uint32 = 0xC201

op_MSG const # 

const op_MSG uint32 = 0xE30C

op_MSGF const # 

const op_MSGF uint32 = 0xE31C

op_MSGFI const # 

const op_MSGFI uint32 = 0xC200

op_MSGFR const # 

const op_MSGFR uint32 = 0xB91C

op_MSGR const # 

const op_MSGR uint32 = 0xB90C

op_MSR const # 

const op_MSR uint32 = 0xB252

op_MSTA const # 

const op_MSTA uint32 = 0xB247

op_MSY const # 

const op_MSY uint32 = 0xE351

op_MVC const # 

const op_MVC uint32 = 0xD200

op_MVCDK const # 

const op_MVCDK uint32 = 0xE50F

op_MVCIN const # 

const op_MVCIN uint32 = 0xE800

op_MVCK const # 

const op_MVCK uint32 = 0xD900

op_MVCL const # 

const op_MVCL uint32 = 0x0E00

op_MVCLE const # 

const op_MVCLE uint32 = 0xA800

op_MVCLU const # 

const op_MVCLU uint32 = 0xEB8E

op_MVCOS const # 

const op_MVCOS uint32 = 0xC800

op_MVCP const # 

const op_MVCP uint32 = 0xDA00

op_MVCS const # 

const op_MVCS uint32 = 0xDB00

op_MVCSK const # 

const op_MVCSK uint32 = 0xE50E

op_MVGHI const # 

const op_MVGHI uint32 = 0xE548

op_MVHHI const # 

const op_MVHHI uint32 = 0xE544

op_MVHI const # 

const op_MVHI uint32 = 0xE54C

op_MVI const # 

const op_MVI uint32 = 0x9200

op_MVIY const # 

const op_MVIY uint32 = 0xEB52

op_MVN const # 

const op_MVN uint32 = 0xD100

op_MVO const # 

const op_MVO uint32 = 0xF100

op_MVPG const # 

const op_MVPG uint32 = 0xB254

op_MVST const # 

const op_MVST uint32 = 0xB255

op_MVZ const # 

const op_MVZ uint32 = 0xD300

op_MXBR const # 

const op_MXBR uint32 = 0xB34C

op_MXD const # 

const op_MXD uint32 = 0x6700

op_MXDB const # 

const op_MXDB uint32 = 0xED07

op_MXDBR const # 

const op_MXDBR uint32 = 0xB307

op_MXDR const # 

const op_MXDR uint32 = 0x2700

op_MXR const # 

const op_MXR uint32 = 0x2600

op_MXTR const # 

const op_MXTR uint32 = 0xB3D8

op_MXTRA const # 

const op_MXTRA uint32 = 0xB3D8

op_MY const # 

const op_MY uint32 = 0xED3B

op_MYH const # 

const op_MYH uint32 = 0xED3D

op_MYHR const # 

const op_MYHR uint32 = 0xB33D

op_MYL const # 

const op_MYL uint32 = 0xED39

op_MYLR const # 

const op_MYLR uint32 = 0xB339

op_MYR const # 

const op_MYR uint32 = 0xB33B

op_N const # 

const op_N uint32 = 0x5400

op_NC const # 

const op_NC uint32 = 0xD400

op_NG const # 

const op_NG uint32 = 0xE380

op_NGR const # 

const op_NGR uint32 = 0xB980

op_NGRK const # 

const op_NGRK uint32 = 0xB9E4

op_NI const # 

const op_NI uint32 = 0x9400

op_NIAI const # 

const op_NIAI uint32 = 0xB2FA

op_NIHF const # 

const op_NIHF uint32 = 0xC00A

op_NIHH const # 

const op_NIHH uint32 = 0xA504

op_NIHL const # 

const op_NIHL uint32 = 0xA505

op_NILF const # 

const op_NILF uint32 = 0xC00B

op_NILH const # 

const op_NILH uint32 = 0xA506

op_NILL const # 

const op_NILL uint32 = 0xA507

op_NIY const # 

const op_NIY uint32 = 0xEB54

op_NR const # 

const op_NR uint32 = 0x1400

op_NRK const # 

const op_NRK uint32 = 0xB9F4

op_NTSTG const # 

const op_NTSTG uint32 = 0xE325

op_NY const # 

const op_NY uint32 = 0xE354

op_O const # 

const op_O uint32 = 0x5600

op_OC const # 

const op_OC uint32 = 0xD600

op_OG const # 

const op_OG uint32 = 0xE381

op_OGR const # 

const op_OGR uint32 = 0xB981

op_OGRK const # 

const op_OGRK uint32 = 0xB9E6

op_OI const # 

const op_OI uint32 = 0x9600

op_OIHF const # 

const op_OIHF uint32 = 0xC00C

op_OIHH const # 

const op_OIHH uint32 = 0xA508

op_OIHL const # 

const op_OIHL uint32 = 0xA509

op_OILF const # 

const op_OILF uint32 = 0xC00D

op_OILH const # 

const op_OILH uint32 = 0xA50A

op_OILL const # 

const op_OILL uint32 = 0xA50B

op_OIY const # 

const op_OIY uint32 = 0xEB56

op_OR const # 

const op_OR uint32 = 0x1600

op_ORK const # 

const op_ORK uint32 = 0xB9F6

op_OY const # 

const op_OY uint32 = 0xE356

op_PACK const # 

const op_PACK uint32 = 0xF200

op_PALB const # 

const op_PALB uint32 = 0xB248

op_PC const # 

const op_PC uint32 = 0xB218

op_PCC const # 

const op_PCC uint32 = 0xB92C

op_PCKMO const # 

const op_PCKMO uint32 = 0xB928

op_PFD const # 

const op_PFD uint32 = 0xE336

op_PFDRL const # 

const op_PFDRL uint32 = 0xC602

op_PFMF const # 

const op_PFMF uint32 = 0xB9AF

op_PFPO const # 

const op_PFPO uint32 = 0x010A

op_PGIN const # 

const op_PGIN uint32 = 0xB22E

op_PGOUT const # 

const op_PGOUT uint32 = 0xB22F

op_PKA const # 

const op_PKA uint32 = 0xE900

op_PKU const # 

const op_PKU uint32 = 0xE100

op_PLO const # 

const op_PLO uint32 = 0xEE00

op_POPCNT const # 

const op_POPCNT uint32 = 0xB9E1

op_PPA const # 

const op_PPA uint32 = 0xB2E8

op_PR const # 

const op_PR uint32 = 0x0101

op_PT const # 

const op_PT uint32 = 0xB228

op_PTF const # 

const op_PTF uint32 = 0xB9A2

op_PTFF const # 

const op_PTFF uint32 = 0x0104

op_PTI const # 

const op_PTI uint32 = 0xB99E

op_PTLB const # 

const op_PTLB uint32 = 0xB20D

op_QADTR const # 

const op_QADTR uint32 = 0xB3F5

op_QAXTR const # 

const op_QAXTR uint32 = 0xB3FD

op_RCHP const # 

const op_RCHP uint32 = 0xB23B

op_RISBG const # 

const op_RISBG uint32 = 0xEC55

op_RISBGN const # 

const op_RISBGN uint32 = 0xEC59

op_RISBHG const # 

const op_RISBHG uint32 = 0xEC5D

op_RISBLG const # 

const op_RISBLG uint32 = 0xEC51

op_RLL const # 

const op_RLL uint32 = 0xEB1D

op_RLLG const # 

const op_RLLG uint32 = 0xEB1C

op_RNSBG const # 

const op_RNSBG uint32 = 0xEC54

op_ROSBG const # 

const op_ROSBG uint32 = 0xEC56

op_RP const # 

const op_RP uint32 = 0xB277

op_RRBE const # 

const op_RRBE uint32 = 0xB22A

op_RRBM const # 

const op_RRBM uint32 = 0xB9AE

op_RRDTR const # 

const op_RRDTR uint32 = 0xB3F7

op_RRXTR const # 

const op_RRXTR uint32 = 0xB3FF

op_RSCH const # 

const op_RSCH uint32 = 0xB238

op_RXSBG const # 

const op_RXSBG uint32 = 0xEC57

op_S const # 

const op_S uint32 = 0x5B00

op_SAC const # 

const op_SAC uint32 = 0xB219

op_SACF const # 

const op_SACF uint32 = 0xB279

op_SAL const # 

const op_SAL uint32 = 0xB237

op_SAM24 const # 

const op_SAM24 uint32 = 0x010C

op_SAM31 const # 

const op_SAM31 uint32 = 0x010D

op_SAM64 const # 

const op_SAM64 uint32 = 0x010E

op_SAR const # 

const op_SAR uint32 = 0xB24E

op_SCHM const # 

const op_SCHM uint32 = 0xB23C

op_SCK const # 

const op_SCK uint32 = 0xB204

op_SCKC const # 

const op_SCKC uint32 = 0xB206

op_SCKPF const # 

const op_SCKPF uint32 = 0x0107

op_SD const # 

const op_SD uint32 = 0x6B00

op_SDB const # 

const op_SDB uint32 = 0xED1B

op_SDBR const # 

const op_SDBR uint32 = 0xB31B

op_SDR const # 

const op_SDR uint32 = 0x2B00

op_SDTR const # 

const op_SDTR uint32 = 0xB3D3

op_SDTRA const # 

const op_SDTRA uint32 = 0xB3D3

op_SE const # 

const op_SE uint32 = 0x7B00

op_SEB const # 

const op_SEB uint32 = 0xED0B

op_SEBR const # 

const op_SEBR uint32 = 0xB30B

op_SER const # 

const op_SER uint32 = 0x3B00

op_SFASR const # 

const op_SFASR uint32 = 0xB385

op_SFPC const # 

const op_SFPC uint32 = 0xB384

op_SG const # 

const op_SG uint32 = 0xE309

op_SGF const # 

const op_SGF uint32 = 0xE319

op_SGFR const # 

const op_SGFR uint32 = 0xB919

op_SGR const # 

const op_SGR uint32 = 0xB909

op_SGRK const # 

const op_SGRK uint32 = 0xB9E9

op_SH const # 

const op_SH uint32 = 0x4B00

op_SHHHR const # 

const op_SHHHR uint32 = 0xB9C9

op_SHHLR const # 

const op_SHHLR uint32 = 0xB9D9

op_SHY const # 

const op_SHY uint32 = 0xE37B

op_SIGP const # 

const op_SIGP uint32 = 0xAE00

op_SL const # 

const op_SL uint32 = 0x5F00

op_SLA const # 

const op_SLA uint32 = 0x8B00

op_SLAG const # 

const op_SLAG uint32 = 0xEB0B

op_SLAK const # 

const op_SLAK uint32 = 0xEBDD

op_SLB const # 

const op_SLB uint32 = 0xE399

op_SLBG const # 

const op_SLBG uint32 = 0xE389

op_SLBGR const # 

const op_SLBGR uint32 = 0xB989

op_SLBR const # 

const op_SLBR uint32 = 0xB999

op_SLDA const # 

const op_SLDA uint32 = 0x8F00

op_SLDL const # 

const op_SLDL uint32 = 0x8D00

op_SLDT const # 

const op_SLDT uint32 = 0xED40

op_SLFI const # 

const op_SLFI uint32 = 0xC205

op_SLG const # 

const op_SLG uint32 = 0xE30B

op_SLGF const # 

const op_SLGF uint32 = 0xE31B

op_SLGFI const # 

const op_SLGFI uint32 = 0xC204

op_SLGFR const # 

const op_SLGFR uint32 = 0xB91B

op_SLGR const # 

const op_SLGR uint32 = 0xB90B

op_SLGRK const # 

const op_SLGRK uint32 = 0xB9EB

op_SLHHHR const # 

const op_SLHHHR uint32 = 0xB9CB

op_SLHHLR const # 

const op_SLHHLR uint32 = 0xB9DB

op_SLL const # 

const op_SLL uint32 = 0x8900

op_SLLG const # 

const op_SLLG uint32 = 0xEB0D

op_SLLK const # 

const op_SLLK uint32 = 0xEBDF

op_SLR const # 

const op_SLR uint32 = 0x1F00

op_SLRK const # 

const op_SLRK uint32 = 0xB9FB

op_SLXT const # 

const op_SLXT uint32 = 0xED48

op_SLY const # 

const op_SLY uint32 = 0xE35F

op_SP const # 

const op_SP uint32 = 0xFB00

op_SPKA const # 

const op_SPKA uint32 = 0xB20A

op_SPM const # 

const op_SPM uint32 = 0x0400

op_SPT const # 

const op_SPT uint32 = 0xB208

op_SPX const # 

const op_SPX uint32 = 0xB210

op_SQD const # 

const op_SQD uint32 = 0xED35

op_SQDB const # 

const op_SQDB uint32 = 0xED15

op_SQDBR const # 

const op_SQDBR uint32 = 0xB315

op_SQDR const # 

const op_SQDR uint32 = 0xB244

op_SQE const # 

const op_SQE uint32 = 0xED34

op_SQEB const # 

const op_SQEB uint32 = 0xED14

op_SQEBR const # 

const op_SQEBR uint32 = 0xB314

op_SQER const # 

const op_SQER uint32 = 0xB245

op_SQXBR const # 

const op_SQXBR uint32 = 0xB316

op_SQXR const # 

const op_SQXR uint32 = 0xB336

op_SR const # 

const op_SR uint32 = 0x1B00

op_SRA const # 

const op_SRA uint32 = 0x8A00

op_SRAG const # 

const op_SRAG uint32 = 0xEB0A

op_SRAK const # 

const op_SRAK uint32 = 0xEBDC

op_SRDA const # 

const op_SRDA uint32 = 0x8E00

op_SRDL const # 

const op_SRDL uint32 = 0x8C00

op_SRDT const # 

const op_SRDT uint32 = 0xED41

op_SRK const # 

const op_SRK uint32 = 0xB9F9

op_SRL const # 

const op_SRL uint32 = 0x8800

op_SRLG const # 

const op_SRLG uint32 = 0xEB0C

op_SRLK const # 

const op_SRLK uint32 = 0xEBDE

op_SRNM const # 

const op_SRNM uint32 = 0xB299

op_SRNMB const # 

const op_SRNMB uint32 = 0xB2B8

op_SRNMT const # 

const op_SRNMT uint32 = 0xB2B9

op_SRP const # 

const op_SRP uint32 = 0xF000

op_SRST const # 

const op_SRST uint32 = 0xB25E

op_SRSTU const # 

const op_SRSTU uint32 = 0xB9BE

op_SRXT const # 

const op_SRXT uint32 = 0xED49

op_SSAIR const # 

const op_SSAIR uint32 = 0xB99F

op_SSAR const # 

const op_SSAR uint32 = 0xB225

op_SSCH const # 

const op_SSCH uint32 = 0xB233

op_SSKE const # 

const op_SSKE uint32 = 0xB22B

op_SSM const # 

const op_SSM uint32 = 0x8000

op_ST const # 

const op_ST uint32 = 0x5000

op_STAM const # 

const op_STAM uint32 = 0x9B00

op_STAMY const # 

const op_STAMY uint32 = 0xEB9B

op_STAP const # 

const op_STAP uint32 = 0xB212

op_STC const # 

const op_STC uint32 = 0x4200

op_STCH const # 

const op_STCH uint32 = 0xE3C3

op_STCK const # 

const op_STCK uint32 = 0xB205

op_STCKC const # 

const op_STCKC uint32 = 0xB207

op_STCKE const # 

const op_STCKE uint32 = 0xB278

op_STCKF const # 

const op_STCKF uint32 = 0xB27C

op_STCM const # 

const op_STCM uint32 = 0xBE00

op_STCMH const # 

const op_STCMH uint32 = 0xEB2C

op_STCMY const # 

const op_STCMY uint32 = 0xEB2D

op_STCPS const # 

const op_STCPS uint32 = 0xB23A

op_STCRW const # 

const op_STCRW uint32 = 0xB239

op_STCTG const # 

const op_STCTG uint32 = 0xEB25

op_STCTL const # 

const op_STCTL uint32 = 0xB600

op_STCY const # 

const op_STCY uint32 = 0xE372

op_STD const # 

const op_STD uint32 = 0x6000

op_STDY const # 

const op_STDY uint32 = 0xED67

op_STE const # 

const op_STE uint32 = 0x7000

op_STEY const # 

const op_STEY uint32 = 0xED66

op_STFH const # 

const op_STFH uint32 = 0xE3CB

op_STFL const # 

const op_STFL uint32 = 0xB2B1

op_STFLE const # 

const op_STFLE uint32 = 0xB2B0

op_STFPC const # 

const op_STFPC uint32 = 0xB29C

op_STG const # 

const op_STG uint32 = 0xE324

op_STGRL const # 

const op_STGRL uint32 = 0xC40B

op_STH const # 

const op_STH uint32 = 0x4000

op_STHH const # 

const op_STHH uint32 = 0xE3C7

op_STHRL const # 

const op_STHRL uint32 = 0xC407

op_STHY const # 

const op_STHY uint32 = 0xE370

op_STIDP const # 

const op_STIDP uint32 = 0xB202

op_STM const # 

const op_STM uint32 = 0x9000

op_STMG const # 

const op_STMG uint32 = 0xEB24

op_STMH const # 

const op_STMH uint32 = 0xEB26

op_STMY const # 

const op_STMY uint32 = 0xEB90

op_STNSM const # 

const op_STNSM uint32 = 0xAC00

op_STOC const # 

const op_STOC uint32 = 0xEBF3

op_STOCFH const # 

const op_STOCFH uint32 = 0xEBE1

op_STOCG const # 

const op_STOCG uint32 = 0xEBE3

op_STOSM const # 

const op_STOSM uint32 = 0xAD00

op_STPQ const # 

const op_STPQ uint32 = 0xE38E

op_STPT const # 

const op_STPT uint32 = 0xB209

op_STPX const # 

const op_STPX uint32 = 0xB211

op_STRAG const # 

const op_STRAG uint32 = 0xE502

op_STRL const # 

const op_STRL uint32 = 0xC40F

op_STRV const # 

const op_STRV uint32 = 0xE33E

op_STRVG const # 

const op_STRVG uint32 = 0xE32F

op_STRVH const # 

const op_STRVH uint32 = 0xE33F

op_STSCH const # 

const op_STSCH uint32 = 0xB234

op_STSI const # 

const op_STSI uint32 = 0xB27D

op_STURA const # 

const op_STURA uint32 = 0xB246

op_STURG const # 

const op_STURG uint32 = 0xB925

op_STY const # 

const op_STY uint32 = 0xE350

op_SU const # 

const op_SU uint32 = 0x7F00

op_SUR const # 

const op_SUR uint32 = 0x3F00

op_SVC const # 

const op_SVC uint32 = 0x0A00

op_SW const # 

const op_SW uint32 = 0x6F00

op_SWR const # 

const op_SWR uint32 = 0x2F00

op_SXBR const # 

const op_SXBR uint32 = 0xB34B

op_SXR const # 

const op_SXR uint32 = 0x3700

op_SXTR const # 

const op_SXTR uint32 = 0xB3DB

op_SXTRA const # 

const op_SXTRA uint32 = 0xB3DB

op_SY const # 

const op_SY uint32 = 0xE35B

op_TABORT const # 

const op_TABORT uint32 = 0xB2FC

op_TAM const # 

const op_TAM uint32 = 0x010B

op_TAR const # 

const op_TAR uint32 = 0xB24C

op_TB const # 

const op_TB uint32 = 0xB22C

op_TBDR const # 

const op_TBDR uint32 = 0xB351

op_TBEDR const # 

const op_TBEDR uint32 = 0xB350

op_TBEGIN const # 

const op_TBEGIN uint32 = 0xE560

op_TBEGINC const # 

const op_TBEGINC uint32 = 0xE561

op_TCDB const # 

const op_TCDB uint32 = 0xED11

op_TCEB const # 

const op_TCEB uint32 = 0xED10

op_TCXB const # 

const op_TCXB uint32 = 0xED12

op_TDCDT const # 

const op_TDCDT uint32 = 0xED54

op_TDCET const # 

const op_TDCET uint32 = 0xED50

op_TDCXT const # 

const op_TDCXT uint32 = 0xED58

op_TDGDT const # 

const op_TDGDT uint32 = 0xED55

op_TDGET const # 

const op_TDGET uint32 = 0xED51

op_TDGXT const # 

const op_TDGXT uint32 = 0xED59

op_TEND const # 

const op_TEND uint32 = 0xB2F8

op_THDER const # 

const op_THDER uint32 = 0xB358

op_THDR const # 

const op_THDR uint32 = 0xB359

op_TM const # 

const op_TM uint32 = 0x9100

op_TMH const # 

const op_TMH uint32 = 0xA700

op_TMHH const # 

const op_TMHH uint32 = 0xA702

op_TMHL const # 

const op_TMHL uint32 = 0xA703

op_TML const # 

const op_TML uint32 = 0xA701

op_TMLH const # 

const op_TMLH uint32 = 0xA700

op_TMLL const # 

const op_TMLL uint32 = 0xA701

op_TMY const # 

const op_TMY uint32 = 0xEB51

op_TP const # 

const op_TP uint32 = 0xEBC0

op_TPI const # 

const op_TPI uint32 = 0xB236

op_TPROT const # 

const op_TPROT uint32 = 0xE501

op_TR const # 

const op_TR uint32 = 0xDC00

op_TRACE const # 

const op_TRACE uint32 = 0x9900

op_TRACG const # 

const op_TRACG uint32 = 0xEB0F

op_TRAP2 const # 

const op_TRAP2 uint32 = 0x01FF

op_TRAP4 const # 

const op_TRAP4 uint32 = 0xB2FF

op_TRE const # 

const op_TRE uint32 = 0xB2A5

op_TROO const # 

const op_TROO uint32 = 0xB993

op_TROT const # 

const op_TROT uint32 = 0xB992

op_TRT const # 

const op_TRT uint32 = 0xDD00

op_TRTE const # 

const op_TRTE uint32 = 0xB9BF

op_TRTO const # 

const op_TRTO uint32 = 0xB991

op_TRTR const # 

const op_TRTR uint32 = 0xD000

op_TRTRE const # 

const op_TRTRE uint32 = 0xB9BD

op_TRTT const # 

const op_TRTT uint32 = 0xB990

op_TS const # 

const op_TS uint32 = 0x9300

op_TSCH const # 

const op_TSCH uint32 = 0xB235

op_UNPK const # 

const op_UNPK uint32 = 0xF300

op_UNPKA const # 

const op_UNPKA uint32 = 0xEA00

op_UNPKU const # 

const op_UNPKU uint32 = 0xE200

op_UPT const # 

const op_UPT uint32 = 0x0102

op_VA const # 

const op_VA uint32 = 0xE7F3

op_VAC const # 

const op_VAC uint32 = 0xE7BB

op_VACC const # 

const op_VACC uint32 = 0xE7F1

op_VACCC const # 

const op_VACCC uint32 = 0xE7B9

op_VAVG const # 

const op_VAVG uint32 = 0xE7F2

op_VAVGL const # 

const op_VAVGL uint32 = 0xE7F0

op_VCDG const # 

const op_VCDG uint32 = 0xE7C3

op_VCDLG const # 

const op_VCDLG uint32 = 0xE7C1

op_VCEQ const # 

const op_VCEQ uint32 = 0xE7F8

op_VCGD const # 

const op_VCGD uint32 = 0xE7C2

op_VCH const # 

const op_VCH uint32 = 0xE7FB

op_VCHL const # 

const op_VCHL uint32 = 0xE7F9

op_VCKSM const # 

const op_VCKSM uint32 = 0xE766

op_VCLGD const # 

const op_VCLGD uint32 = 0xE7C0

op_VCLZ const # 

const op_VCLZ uint32 = 0xE753

op_VCTZ const # 

const op_VCTZ uint32 = 0xE752

op_VEC const # 

const op_VEC uint32 = 0xE7DB

op_VECL const # 

const op_VECL uint32 = 0xE7D9

op_VERIM const # 

const op_VERIM uint32 = 0xE772

op_VERLL const # 

const op_VERLL uint32 = 0xE733

op_VERLLV const # 

const op_VERLLV uint32 = 0xE773

op_VESL const # 

const op_VESL uint32 = 0xE730

op_VESLV const # 

const op_VESLV uint32 = 0xE770

op_VESRA const # 

const op_VESRA uint32 = 0xE73A

op_VESRAV const # 

const op_VESRAV uint32 = 0xE77A

op_VESRL const # 

const op_VESRL uint32 = 0xE738

op_VESRLV const # 

const op_VESRLV uint32 = 0xE778

op_VFA const # 

const op_VFA uint32 = 0xE7E3

op_VFAE const # 

const op_VFAE uint32 = 0xE782

op_VFCE const # 

const op_VFCE uint32 = 0xE7E8

op_VFCH const # 

const op_VFCH uint32 = 0xE7EB

op_VFCHE const # 

const op_VFCHE uint32 = 0xE7EA

op_VFD const # 

const op_VFD uint32 = 0xE7E5

op_VFEE const # 

const op_VFEE uint32 = 0xE780

op_VFENE const # 

const op_VFENE uint32 = 0xE781

op_VFI const # 

const op_VFI uint32 = 0xE7C7

op_VFM const # 

const op_VFM uint32 = 0xE7E7

op_VFMA const # 

const op_VFMA uint32 = 0xE78F

op_VFMS const # 

const op_VFMS uint32 = 0xE78E

op_VFPSO const # 

const op_VFPSO uint32 = 0xE7CC

op_VFS const # 

const op_VFS uint32 = 0xE7E2

op_VFSQ const # 

const op_VFSQ uint32 = 0xE7CE

op_VFTCI const # 

const op_VFTCI uint32 = 0xE74A

op_VGBM const # 

const op_VGBM uint32 = 0xE744

op_VGEF const # 

const op_VGEF uint32 = 0xE713

op_VGEG const # 

const op_VGEG uint32 = 0xE712

op_VGFM const # 

const op_VGFM uint32 = 0xE7B4

op_VGFMA const # 

const op_VGFMA uint32 = 0xE7BC

op_VGM const # 

const op_VGM uint32 = 0xE746

op_VISTR const # 

const op_VISTR uint32 = 0xE75C

op_VL const # 

const op_VL uint32 = 0xE706

op_VLBB const # 

const op_VLBB uint32 = 0xE707

op_VLC const # 

const op_VLC uint32 = 0xE7DE

op_VLDE const # 

const op_VLDE uint32 = 0xE7C4

op_VLEB const # 

const op_VLEB uint32 = 0xE700

op_VLED const # 

const op_VLED uint32 = 0xE7C5

op_VLEF const # 

const op_VLEF uint32 = 0xE703

op_VLEG const # 

const op_VLEG uint32 = 0xE702

op_VLEH const # 

const op_VLEH uint32 = 0xE701

op_VLEIB const # 

const op_VLEIB uint32 = 0xE740

op_VLEIF const # 

const op_VLEIF uint32 = 0xE743

op_VLEIG const # 

const op_VLEIG uint32 = 0xE742

op_VLEIH const # 

const op_VLEIH uint32 = 0xE741

op_VLGV const # 

const op_VLGV uint32 = 0xE721

op_VLL const # 

const op_VLL uint32 = 0xE737

op_VLLEZ const # 

const op_VLLEZ uint32 = 0xE704

op_VLM const # 

const op_VLM uint32 = 0xE736

op_VLP const # 

const op_VLP uint32 = 0xE7DF

op_VLR const # 

const op_VLR uint32 = 0xE756

op_VLREP const # 

const op_VLREP uint32 = 0xE705

op_VLVG const # 

const op_VLVG uint32 = 0xE722

op_VLVGP const # 

const op_VLVGP uint32 = 0xE762

op_VMAE const # 

const op_VMAE uint32 = 0xE7AE

op_VMAH const # 

const op_VMAH uint32 = 0xE7AB

op_VMAL const # 

const op_VMAL uint32 = 0xE7AA

op_VMALE const # 

const op_VMALE uint32 = 0xE7AC

op_VMALH const # 

const op_VMALH uint32 = 0xE7A9

op_VMALO const # 

const op_VMALO uint32 = 0xE7AD

op_VMAO const # 

const op_VMAO uint32 = 0xE7AF

op_VME const # 

const op_VME uint32 = 0xE7A6

op_VMH const # 

const op_VMH uint32 = 0xE7A3

op_VML const # 

const op_VML uint32 = 0xE7A2

op_VMLE const # 

const op_VMLE uint32 = 0xE7A4

op_VMLH const # 

const op_VMLH uint32 = 0xE7A1

op_VMLO const # 

const op_VMLO uint32 = 0xE7A5

op_VMN const # 

const op_VMN uint32 = 0xE7FE

op_VMNL const # 

const op_VMNL uint32 = 0xE7FC

op_VMO const # 

const op_VMO uint32 = 0xE7A7

op_VMRH const # 

const op_VMRH uint32 = 0xE761

op_VMRL const # 

const op_VMRL uint32 = 0xE760

op_VMSL const # 

const op_VMSL uint32 = 0xE7B8

op_VMX const # 

const op_VMX uint32 = 0xE7FF

op_VMXL const # 

const op_VMXL uint32 = 0xE7FD

op_VN const # 

const op_VN uint32 = 0xE768

op_VNC const # 

const op_VNC uint32 = 0xE769

op_VNO const # 

const op_VNO uint32 = 0xE76B

op_VO const # 

const op_VO uint32 = 0xE76A

op_VPDI const # 

const op_VPDI uint32 = 0xE784

op_VPERM const # 

const op_VPERM uint32 = 0xE78C

op_VPK const # 

const op_VPK uint32 = 0xE794

op_VPKLS const # 

const op_VPKLS uint32 = 0xE795

op_VPKS const # 

const op_VPKS uint32 = 0xE797

op_VPOPCT const # 

const op_VPOPCT uint32 = 0xE750

op_VREP const # 

const op_VREP uint32 = 0xE74D

op_VREPI const # 

const op_VREPI uint32 = 0xE745

op_VS const # 

const op_VS uint32 = 0xE7F7

op_VSBCBI const # 

const op_VSBCBI uint32 = 0xE7BD

op_VSBI const # 

const op_VSBI uint32 = 0xE7BF

op_VSCBI const # 

const op_VSCBI uint32 = 0xE7F5

op_VSCEF const # 

const op_VSCEF uint32 = 0xE71B

op_VSCEG const # 

const op_VSCEG uint32 = 0xE71A

op_VSEG const # 

const op_VSEG uint32 = 0xE75F

op_VSEL const # 

const op_VSEL uint32 = 0xE78D

op_VSL const # 

const op_VSL uint32 = 0xE774

op_VSLB const # 

const op_VSLB uint32 = 0xE775

op_VSLDB const # 

const op_VSLDB uint32 = 0xE777

op_VSRA const # 

const op_VSRA uint32 = 0xE77E

op_VSRAB const # 

const op_VSRAB uint32 = 0xE77F

op_VSRL const # 

const op_VSRL uint32 = 0xE77C

op_VSRLB const # 

const op_VSRLB uint32 = 0xE77D

op_VST const # 

const op_VST uint32 = 0xE70E

op_VSTEB const # 

const op_VSTEB uint32 = 0xE708

op_VSTEF const # 

const op_VSTEF uint32 = 0xE70B

op_VSTEG const # 

const op_VSTEG uint32 = 0xE70A

op_VSTEH const # 

const op_VSTEH uint32 = 0xE709

op_VSTL const # 

const op_VSTL uint32 = 0xE73F

op_VSTM const # 

const op_VSTM uint32 = 0xE73E

op_VSTRC const # 

const op_VSTRC uint32 = 0xE78A

op_VSUM const # 

const op_VSUM uint32 = 0xE764

op_VSUMG const # 

const op_VSUMG uint32 = 0xE765

op_VSUMQ const # 

const op_VSUMQ uint32 = 0xE767

op_VTM const # 

const op_VTM uint32 = 0xE7D8

op_VUPH const # 

const op_VUPH uint32 = 0xE7D7

op_VUPL const # 

const op_VUPL uint32 = 0xE7D6

op_VUPLH const # 

const op_VUPLH uint32 = 0xE7D5

op_VUPLL const # 

const op_VUPLL uint32 = 0xE7D4

op_VX const # 

const op_VX uint32 = 0xE76D

op_WFC const # 

const op_WFC uint32 = 0xE7CB

op_WFK const # 

const op_WFK uint32 = 0xE7CA

op_X const # 

const op_X uint32 = 0x5700

op_XC const # 

const op_XC uint32 = 0xD700

op_XG const # 

const op_XG uint32 = 0xE382

op_XGR const # 

const op_XGR uint32 = 0xB982

op_XGRK const # 

const op_XGRK uint32 = 0xB9E7

op_XI const # 

const op_XI uint32 = 0x9700

op_XIHF const # 

const op_XIHF uint32 = 0xC006

op_XILF const # 

const op_XILF uint32 = 0xC007

op_XIY const # 

const op_XIY uint32 = 0xEB57

op_XR const # 

const op_XR uint32 = 0x1700

op_XRK const # 

const op_XRK uint32 = 0xB9F7

op_XSCH const # 

const op_XSCH uint32 = 0xB276

op_XY const # 

const op_XY uint32 = 0xE357

op_ZAP const # 

const op_ZAP uint32 = 0xF800

oprange var # 

var oprange [*ast.BinaryExpr][]Optab

optab var # 

var optab = []Optab{...}

sizeE const #

z instructions sizes

const sizeE = 2

sizeI const #

z instructions sizes

const sizeI = 2

sizeIE const #

z instructions sizes

const sizeIE = 4

sizeMII const #

z instructions sizes

const sizeMII = 6

sizeRI const #

z instructions sizes

const sizeRI = 4

sizeRI1 const #

z instructions sizes

const sizeRI1 = 4

sizeRI2 const #

z instructions sizes

const sizeRI2 = 4

sizeRI3 const #

z instructions sizes

const sizeRI3 = 4

sizeRIE const #

z instructions sizes

const sizeRIE = 6

sizeRIE1 const #

z instructions sizes

const sizeRIE1 = 6

sizeRIE2 const #

z instructions sizes

const sizeRIE2 = 6

sizeRIE3 const #

z instructions sizes

const sizeRIE3 = 6

sizeRIE4 const #

z instructions sizes

const sizeRIE4 = 6

sizeRIE5 const #

z instructions sizes

const sizeRIE5 = 6

sizeRIE6 const #

z instructions sizes

const sizeRIE6 = 6

sizeRIL const #

z instructions sizes

const sizeRIL = 6

sizeRIL1 const #

z instructions sizes

const sizeRIL1 = 6

sizeRIL2 const #

z instructions sizes

const sizeRIL2 = 6

sizeRIL3 const #

z instructions sizes

const sizeRIL3 = 6

sizeRIS const #

z instructions sizes

const sizeRIS = 6

sizeRR const #

z instructions sizes

const sizeRR = 2

sizeRRD const #

z instructions sizes

const sizeRRD = 4

sizeRRE const #

z instructions sizes

const sizeRRE = 4

sizeRRF const #

z instructions sizes

const sizeRRF = 4

sizeRRF1 const #

z instructions sizes

const sizeRRF1 = 4

sizeRRF2 const #

z instructions sizes

const sizeRRF2 = 4

sizeRRF3 const #

z instructions sizes

const sizeRRF3 = 4

sizeRRF4 const #

z instructions sizes

const sizeRRF4 = 4

sizeRRF5 const #

z instructions sizes

const sizeRRF5 = 4

sizeRRR const #

z instructions sizes

const sizeRRR = 2

sizeRRS const #

z instructions sizes

const sizeRRS = 6

sizeRS const #

z instructions sizes

const sizeRS = 4

sizeRS1 const #

z instructions sizes

const sizeRS1 = 4

sizeRS2 const #

z instructions sizes

const sizeRS2 = 4

sizeRSI const #

z instructions sizes

const sizeRSI = 4

sizeRSL const #

z instructions sizes

const sizeRSL = 6

sizeRSY const #

z instructions sizes

const sizeRSY = 6

sizeRSY1 const #

z instructions sizes

const sizeRSY1 = 6

sizeRSY2 const #

z instructions sizes

const sizeRSY2 = 6

sizeRX const #

z instructions sizes

const sizeRX = 4

sizeRX1 const #

z instructions sizes

const sizeRX1 = 4

sizeRX2 const #

z instructions sizes

const sizeRX2 = 4

sizeRXE const #

z instructions sizes

const sizeRXE = 6

sizeRXF const #

z instructions sizes

const sizeRXF = 6

sizeRXY const #

z instructions sizes

const sizeRXY = 6

sizeRXY1 const #

z instructions sizes

const sizeRXY1 = 6

sizeRXY2 const #

z instructions sizes

const sizeRXY2 = 6

sizeS const #

z instructions sizes

const sizeS = 4

sizeSI const #

z instructions sizes

const sizeSI = 4

sizeSIL const #

z instructions sizes

const sizeSIL = 6

sizeSIY const #

z instructions sizes

const sizeSIY = 6

sizeSMI const #

z instructions sizes

const sizeSMI = 6

sizeSS const #

z instructions sizes

const sizeSS = 6

sizeSS1 const #

z instructions sizes

const sizeSS1 = 6

sizeSS2 const #

z instructions sizes

const sizeSS2 = 6

sizeSS3 const #

z instructions sizes

const sizeSS3 = 6

sizeSS4 const #

z instructions sizes

const sizeSS4 = 6

sizeSS5 const #

z instructions sizes

const sizeSS5 = 6

sizeSS6 const #

z instructions sizes

const sizeSS6 = 6

sizeSSE const #

z instructions sizes

const sizeSSE = 6

sizeSSF const #

z instructions sizes

const sizeSSF = 6

unaryDst var # 

var unaryDst = map[obj.As]bool{...}

xcmp var # 

var xcmp [C_NCLASS][C_NCLASS]bool

Type Aliases

CCMask type #

CCMask represents a 4-bit condition code mask. Bits that are not part of the mask should be 0. Condition code masks represent the 4 possible values of the 2-bit condition code as individual bits. Since IBM Z is a big-endian platform bits are numbered from left to right. The lowest value, 0, is represented by 8 (0b1000) and the highest value, 3, is represented by 1 (0b0001). Note that condition code values have different semantics depending on the instruction that set the condition code. The names given here assume that the condition code was set by an integer or floating point comparison. Other instructions may use these same codes to indicate different results such as a carry or overflow.

type CCMask uint8

form type #

instruction format variations

type form int

Structs

Optab struct # 

type Optab struct {
as obj.As
i uint8
a1 uint8
a2 uint8
a3 uint8
a4 uint8
a5 uint8
a6 uint8
}

RotateParams struct #

RotateParams represents the immediates required for a "rotate then ... selected bits instruction". The Start and End values are the indexes that represent the masked region. They are inclusive and are in big- endian order (bit 0 is the MSB, bit 63 is the LSB). They may wrap around. Some examples: Masked region | Start | End --------------------------+-------+---- 0x00_00_00_00_00_00_00_0f | 60 | 63 0xf0_00_00_00_00_00_00_00 | 0 | 3 0xf0_00_00_00_00_00_00_0f | 60 | 3 The Amount value represents the amount to rotate the input left by. Note that this rotation is performed before the masked region is used.

type RotateParams struct {
Start uint8
End uint8
Amount uint8
}

ctxtz struct #

ctxtz holds state while assembling a single function. Each function gets a fresh ctxtz. This allows for multiple functions to be safely concurrently assembled.

type ctxtz struct {
ctxt *obj.Link
newprog obj.ProgAlloc
cursym *obj.LSym
autosize int32
instoffset int64
pc int64
}

Functions

CanBeAnSSAAux method # 

func (RotateParams) CanBeAnSSAAux()

CanBeAnSSAAux method # 

func (CCMask) CanBeAnSSAAux()

DRconv function # 

func DRconv(a int) string

InMask method #

InMask provides a mask representing the selected bits relative to the source value (i.e. pre-rotation).

func (r RotateParams) InMask() uint64

InMerge method #

InMerge tries to generate a new set of parameters representing the intersection between the selected bits and the provided mask as applied to the source value (i.e. pre-rotation). If the intersection is unrepresentable (0 or not contiguous) nil will be returned.

func (r RotateParams) InMerge(mask uint64) *RotateParams

Inverse method #

Inverse returns the complement of the condition code mask.

func (c CCMask) Inverse() CCMask

NewRotateParams function #

NewRotateParams creates a set of parameters representing a rotation left by the amount provided and a selection of the bits between the provided start and end indexes (inclusive). The start and end indexes and the rotation amount must all be in the range 0-63 inclusive or this function will panic.

func NewRotateParams(start uint8, end uint8, amount uint8) RotateParams

OutMask method #

OutMask provides a mask representing the selected bits.

func (r RotateParams) OutMask() uint64

OutMerge method #

OutMerge tries to generate a new set of parameters representing the intersection between the selected bits and the provided mask. If the intersection is unrepresentable (0 or not contiguous) nil will be returned.

func (r RotateParams) OutMerge(mask uint64) *RotateParams

ReverseComparison method #

ReverseComparison swaps the bits at 0b0100 and 0b0010 in the mask, reversing the behavior of greater than and less than conditions.

func (c CCMask) ReverseComparison() CCMask

RotateLeft method #

RotateLeft generates a new set of parameters with the rotation amount increased by the given value. The selected bits are left unchanged.

func (r RotateParams) RotateLeft(amount uint8) RotateParams

String method # 

func (c CCMask) String() string

aclass method # 

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

addcallreloc method #

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)

addrilreloc method #

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)

addrilrelocoffset method # 

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

asmout method # 

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

branchMask method # 

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

buildop function # 

func buildop(ctxt *obj.Link)

cmp function # 

func cmp(a int, b int) bool

init function # 

func init()

init function # 

func init()

isU12 function #

find if the displacement is within 12 bit.

func isU12(displacement int32) bool

isUnsafePoint method #

Return whether p is an unsafe point.

func (c *ctxtz) isUnsafePoint(p *obj.Prog) bool

isint32 function # 

func isint32(v int64) bool

isuint32 function # 

func isuint32(v uint64) bool

oclass function # 

func oclass(a *obj.Addr) int

ocmp function # 

func ocmp(p1 Optab, p2 Optab) int

oplook method # 

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

opset function # 

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

preprocess function # 

func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc)

progedit function # 

func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc)

rconv function # 

func rconv(r int) string

regoff method # 

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

regtmp function # 

func regtmp(p *obj.Prog) uint32

rewriteToUseGot method #

Rewrite p, if necessary, to access global data via the global offset table.

func (c *ctxtz) rewriteToUseGot(p *obj.Prog)

rxb function # 

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

singleElementMask function #

singleElementMask returns the single element mask bits required for the given instruction.

func singleElementMask(as obj.As) uint32

spanz function # 

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

stacksplitPost method #

stacksplitPost generates the function epilogue that calls morestack and returns the new last instruction in the function. p is the last Prog in the function. pPre and pPreempt, if non-nil, are the instructions that branch to the epilogue. This will fill in their branch targets. pCheck is the Prog that begins the stack check.

func (c *ctxtz) stacksplitPost(p *obj.Prog, pPre *obj.Prog, pPreempt *obj.Prog, pCheck *obj.Prog, framesize int32) *obj.Prog

stacksplitPre method #

stacksplitPre generates the function stack check prologue following Prog p (which should be the TEXT Prog). It returns one or two branch Progs that must be patched to jump to the morestack epilogue, and the Prog that starts the morestack check.

func (c *ctxtz) stacksplitPre(p *obj.Prog, framesize int32) (pPre *obj.Prog, pPreempt *obj.Prog, pCheck *obj.Prog)

vop function #

vop returns the opcode, element size and condition setting for the given (possibly extended) mnemonic.

func vop(as obj.As) (opcode uint32, es uint32, cs uint32)

vregoff method # 

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

zE function # 

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

zI function # 

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

zMII function # 

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

zRI function # 

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

zRIE function #

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 uint32, r1 uint32, r2_m3_r3 uint32, i2_ri4_ri2 uint32, i3 uint32, i4 uint32, m3 uint32, i2_i5 uint32, asm *[]byte)

zRIL function # 

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

zRIS function # 

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

zRR function # 

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

zRRD function # 

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

zRRE function # 

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

zRRF function # 

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

zRRS function # 

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

zRS function # 

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

zRSI function # 

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

zRSL function # 

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

zRSY function # 

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

zRX function # 

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

zRXE function # 

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

zRXF function # 

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

zRXY function # 

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

zS function # 

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

zSI function # 

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

zSIL function # 

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

zSIY function # 

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

zSMI function # 

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

zSS function #

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 uint32, l1_r1 uint32, l2_i3_r3 uint32, b1_b2 uint32, d1_d2 uint32, b2_b4 uint32, d2_d4 uint32, asm *[]byte)

zSSE function # 

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

zSSF function # 

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

zVRIa function # 

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

zVRIb function # 

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

zVRIc function # 

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

zVRId function # 

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

zVRIe function # 

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

zVRRa function # 

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

zVRRb function # 

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

zVRRc function # 

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

zVRRd function # 

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

zVRRe function # 

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

zVRRf function # 

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

zVRS function # 

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

zVRV function # 

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

zVRX function # 

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

zopload method #

zopload returns the RXY op for the given load.

func (c *ctxtz) zopload(a obj.As) uint32

zopload12 method #

zopload12 returns the RX op with 12 bit displacement for the given load.

func (c *ctxtz) zopload12(a obj.As) (uint32, bool)

zopril method #

zopril returns the RIL op for the given a.

func (c *ctxtz) zopril(a obj.As) uint32

zoprr method #

zoprr returns the RR op for the given a.

func (c *ctxtz) zoprr(a obj.As) uint32

zoprre method #

zoprre returns the RRE op for the given a.

func (c *ctxtz) zoprre(a obj.As) uint32

zopstore method #

zopstore returns the RXY op for the given store.

func (c *ctxtz) zopstore(a obj.As) uint32

zopstore12 method #

zopstore12 returns the RX op with 12 bit displacement for the given store.

func (c *ctxtz) zopstore12(a obj.As) (uint32, bool)

Generated with Arrow