Difference between revisions of "Cores/Copper/Encoding"

Revision as of 15:15, 4 December 2014

Tin Copper Silver Gold Decimal8 Decimal16 

The Mill Architecture is still in development, and new operations may be added or existing operations may be changed. This means the following encodings may still change too and only reflect the current state.

The operation encodings are per Slot, and the subscripts indicate the field widths in bits.

Exu Block

add(op x, imm y)

add(op x, op y)

add1u(u x, u y)

addp(p x, p y, scale s)

addp(p x, imm y, scale s)

addss(s x, s y)

addss(s x, imm y)

addsw(s x, s y)

addsw(s x, imm y)

addswv(s x, s y)

addswv(s x, imm y)

addsx(s x, s y)

addsx(s x, imm y)

addus(u x, imm y)

addus(u x, u y)

adduw(u x, imm y)

adduw(u x, u y)

adduwv(u x, u y)

adduwv(u x, imm y)

addux(u x, u y)

addux(u x, imm y)

all(op v)

alternate(op v1, op v2)

andl(op x, imm y)

andl(op x, op y)

any(op v)

carry(conditioncode)

clear(op x, bit bit)

clear(op x, op bit)

comp(op x)

countlfl(op x)

countltr(op x)

countrfl(op x)

countrtr(op x)

delta(op x, op y)

eql(op x, op y)

eql(conditioncode)

eql(op x, imm y)

eqlp(p x, p y)

extract(op v, i i)

extract(op v, imm i)

exuArgs(op arg)

exuArgs(op arg0, op arg1)

fault(conditioncode)

fault(op x)

flip(op x)

flip(op x, n bit)

flip(op x, bit bit)

geq(conditioncode)

gtr(conditioncode)

gtrs(s x, imm y)

gtru(u x, imm y)

imp(op x, imm y)

imp(op x, op y)

inject(i i)

inject(op v, op x, imm i)

left(op x)

left(op x, width w)

leq(conditioncode)

leqp(p x, p y)

leqs(s x, s y)

lequ(u x, u y)

lss(conditioncode)

lssp(p x, p y)

lsss(s x, s y)

lsss(s x, imm y)

lssu(u x, u y)

lssu(u x, imm y)

mask(op v, width w)

mask(bit bits0, bit bits1, width w)

merge(op op0)

mul(op x, op y)

mulsf(sf x, sf y, bit dot)

mulsfe(sf x, sf y, bit dot)

mulsffz(sf x, sf y, bit dot)

mulsfn(sf x, sf y, bit dot)

mulsfp(sf x, sf y, bit dot)

mulsfs(sf x, sf y, bit dot)

mulsfse(sf x, sf y, bit dot)

mulsfsfz(sf x, sf y, bit dot)

mulsfsn(sf x, sf y, bit dot)

mulsfsp(sf x, sf y, bit dot)

mulsfsz(sf x, sf y, bit dot)

mulsfw(sf x, sf y, bit dot)

mulsfwe(sf x, sf y, bit dot)

mulsfwfz(sf x, sf y, bit dot)

mulsfwn(sf x, sf y, bit dot)

mulsfwp(sf x, sf y, bit dot)

mulsfwz(sf x, sf y, bit dot)

mulsfx(sf x, sf y, bit dot)

mulsfxe(sf x, sf y, bit dot)

mulsfxfz(sf x, sf y, bit dot)

mulsfxn(sf x, sf y, bit dot)

mulsfxp(sf x, sf y, bit dot)

mulsfxz(sf x, sf y, bit dot)

mulsfz(sf x, sf y, bit dot)

mulss(s x, s y)

mulsw(s x, s y)

mulswv(s x, s y)

mulsx(s x, s y)

muluf(uf x, uf y, bit dot)

mulufe(uf x, uf y, bit dot)

muluffz(uf x, uf y, bit dot)

mulufn(uf x, uf y, bit dot)

mulufp(uf x, uf y, bit dot)

mulufs(uf x, uf y, bit dot)

mulufse(uf x, uf y, bit dot)

mulufsfz(uf x, uf y, bit dot)

mulufsn(uf x, uf y, bit dot)

mulufsp(uf x, uf y, bit dot)

mulufsz(uf x, uf y, bit dot)

mulufw(uf x, uf y, bit dot)

mulufwe(uf x, uf y, bit dot)

mulufwfz(uf x, uf y, bit dot)

mulufwn(uf x, uf y, bit dot)

mulufwp(uf x, uf y, bit dot)

mulufwz(uf x, uf y, bit dot)

mulufx(uf x, uf y, bit dot)

mulufxe(uf x, uf y, bit dot)

mulufxfz(uf x, uf y, bit dot)

mulufxn(uf x, uf y, bit dot)

mulufxp(uf x, uf y, bit dot)

mulufxz(uf x, uf y, bit dot)

mulufz(uf x, uf y, bit dot)

mulus(u x, u y)

muluw(u x, u y)

muluwv(u x, u y)

mulux(u x, u y)

nand(op x, imm y)

nand(op x, op y)

NaR(op x)

NaR(NaR kind, width w)

narrow(op v1, op v2)

narrow(op v)

narrowss(s v1, s v2)

narrowss(s v)

narrowsx(s v)

narrowsx(s v1, s v2)

narrowus(u v1, u v2)

narrowus(u v)

narrowux(u v)

narrowux(u v1, u v2)

neg(op x)

negss(s x)

negsw(s x)

negswv(s x)

negsx(s x)

neq(conditioncode)

neq(op x, op y)

neq(op x, imm y)

neqp(p x, p y)

nimp(op x, op y)

nimp(op x, imm y)

nope()

nor(op x, op y)

nor(op x, imm y)

notl(op x)

nxor(op x, op y)

nxor(op x, imm y)

ones(op x)

orl(op x, op y)

orl(op x, imm y)

overflows(conditioncode)

rdivs(s x)

rdivu(u x)

resolve(p x)

reverse(op x)

roots(s x)

rootu(u x)

rotatel(op x, u bits)

rotatel(op x, bit bits)

rotater(op x, u bits)

rotater(op x, bit bits)

rroots(s x)

rrootu(u x)

s2u(op x)

s2us(op x)

s2ux(op x)

set(op x, bit bit)

set(op x, n bit)

shiftl(op x, n bits)

shiftl(op x, bit bits)

shiftlss(s x, n bits)

shiftlss(s x, bit bits)

shiftlsw(s x, n bits)

shiftlsw(s x, bit bits)

shiftlswv(s x, bit bits)

shiftlswv(s x, n bits)

shiftlsx(s x, bit bits)

shiftlsx(s x, n bits)

shiftlus(u x, bit bits)

shiftlus(u x, n bits)

shiftluw(u x, n bits)

shiftluw(u x, bit bits)

shiftluwv(u x, n bits)

shiftluwv(u x, bit bits)

shiftlux(u x, bit bits)

shiftlux(u x, n bits)

shiftrs(s x, n bits)

shiftrs(s x, bit bits)

shiftrsf(sf x, bit bits)

shiftrsfe(sf x, bit bits)

shiftrsffz(sf x, bit bits)

shiftrsfn(sf x, bit bits)

shiftrsfp(sf x, bit bits)

shiftrsfz(sf x, bit bits)

shiftru(u x, bit bits)

shiftru(u x, n bits)

shiftruf(uf x, bit bits)

shiftrufe(uf x, bit bits)

shiftruffz(uf x, bit bits)

shiftrufn(uf x, bit bits)

shiftrufp(uf x, bit bits)

shiftrufz(uf x, bit bits)

shuffle(op vs, op positions)

smeari(op vs)

smearx(op vs)

splat(op v)

sub(op x, imm y)

sub(op x, op y)

sub1u(u x, u y)

subp(p x, imm y, scale s)

subp(p x, p y, scale s)

subss(s x, s y)

subss(s x, imm y)

subsw(s x, s y)

subsw(s x, imm y)

subswv(s x, s y)

subswv(s x, imm y)

subsx(s x, s y)

subsx(s x, imm y)

subus(u x, u y)

subus(u x, imm y)

subuw(u x, u y)

subuw(u x, imm y)

subuwv(u x, u y)

subuwv(u x, imm y)

subux(u x, u y)

subux(u x, imm y)

test(op x, n bit)

test(op x, bit bit)

u2s(op x)

u2ss(op x)

u2sw(op x)

u2swv(op x)

u2sx(op x)

vec(op op0, op op1)

vec(op op0)

widen(op v1, op v2)

widen(op v)

widens(s v)

widensf(sf v)

widensfv(sf v)

widensv(s v)

widenuf(uf v)

widenufv(uf v)

widenv(op v1, op v2)

widenv(op v)