import (
"cmd/internal/gc"
"cmd/internal/obj"
- i386 "cmd/internal/obj/x86"
+ "cmd/internal/obj/x86"
"fmt"
)
gc.OMUL:
a = optoas(int(n.Op), nl.Type)
- if a == i386.AIMULB {
+ if a == x86.AIMULB {
cgen_bmul(int(n.Op), nl, nr, res)
break
}
if gc.Isconst(nl, gc.CTSTR) {
var n1 gc.Node
regalloc(&n1, gc.Types[gc.Tptr], res)
- p1 := gins(i386.ALEAL, nil, &n1)
+ p1 := gins(x86.ALEAL, nil, &n1)
gc.Datastring(nl.Val.U.Sval, &p1.From)
gmove(&n1, res)
regfree(&n1)
var zero gc.Node
gc.Nodconst(&zero, gc.Types[gc.TINT32], 0)
- gins(i386.ACMPL, &hi, &zero)
+ gins(x86.ACMPL, &hi, &zero)
splitclean()
- return gc.Gbranch(i386.AJNE, nil, +1)
+ return gc.Gbranch(x86.AJNE, nil, +1)
}
/*
clearfat(&n1)
var n2 gc.Node
regalloc(&n2, gc.Types[gc.Tptr], res)
- gins(i386.ALEAL, &n1, &n2)
+ gins(x86.ALEAL, &n1, &n2)
gmove(&n2, res)
regfree(&n2)
return
}
var n1 gc.Node
regalloc(&n1, gc.Types[gc.Tptr], res)
- gins(i386.ALEAL, n, &n1)
+ gins(x86.ALEAL, n, &n1)
gmove(&n1, res)
regfree(&n1)
return
if gc.Isconst(nl, gc.CTSTR) {
regalloc(&n3, gc.Types[gc.Tptr], res)
- p1 := gins(i386.ALEAL, nil, &n3)
+ p1 := gins(x86.ALEAL, nil, &n3)
gc.Datastring(nl.Val.U.Sval, &p1.From)
p1.From.Scale = 1
p1.From.Index = n2.Val.U.Reg
} else // nothing to do
if w == 1 || w == 2 || w == 4 || w == 8 {
// LEAL (n3)(n2*w), n3
- p1 := gins(i386.ALEAL, &n2, &n3)
+ p1 := gins(x86.ALEAL, &n2, &n3)
p1.From.Scale = int16(w)
p1.From.Type = obj.TYPE_MEM
// Increase the refcount of the register so that igen's caller
// has to call regfree.
case gc.OINDREG:
- if n.Val.U.Reg != i386.REG_SP {
+ if n.Val.U.Reg != x86.REG_SP {
reg[n.Val.U.Reg]++
}
*a = *n
fp := gc.Structfirst(&flist, gc.Getoutarg(n.Left.Type))
*a = gc.Node{}
a.Op = gc.OINDREG
- a.Val.U.Reg = i386.REG_SP
+ a.Val.U.Reg = x86.REG_SP
a.Addable = 1
a.Xoffset = fp.Width
a.Type = n.Type
var n1 gc.Node
gc.Nodconst(&n1, n.Type, 0)
gins(optoas(gc.OCMP, n.Type), n, &n1)
- a := i386.AJNE
+ a := x86.AJNE
if !true_ {
- a = i386.AJEQ
+ a = x86.AJEQ
}
gc.Patch(gc.Gbranch(a, n.Type, likely), to)
return
var n2 gc.Node
gc.Nodconst(&n2, n.Type, 0)
gins(optoas(gc.OCMP, n.Type), &n1, &n2)
- a := i386.AJNE
+ a := x86.AJNE
if !true_ {
- a = i386.AJEQ
+ a = x86.AJEQ
}
gc.Patch(gc.Gbranch(a, n.Type, likely), to)
regfree(&n1)
}
var dst gc.Node
- gc.Nodreg(&dst, gc.Types[gc.Tptr], i386.REG_DI)
+ gc.Nodreg(&dst, gc.Types[gc.Tptr], x86.REG_DI)
var src gc.Node
- gc.Nodreg(&src, gc.Types[gc.Tptr], i386.REG_SI)
+ gc.Nodreg(&src, gc.Types[gc.Tptr], x86.REG_SI)
var tsrc gc.Node
gc.Tempname(&tsrc, gc.Types[gc.Tptr])
// the src and dst overlap, then reverse direction
if osrc < odst && int64(odst) < int64(osrc)+w {
// reverse direction
- gins(i386.ASTD, nil, nil) // set direction flag
+ gins(x86.ASTD, nil, nil) // set direction flag
if c > 0 {
- gconreg(i386.AADDL, w-1, i386.REG_SI)
- gconreg(i386.AADDL, w-1, i386.REG_DI)
+ gconreg(x86.AADDL, w-1, x86.REG_SI)
+ gconreg(x86.AADDL, w-1, x86.REG_DI)
- gconreg(i386.AMOVL, int64(c), i386.REG_CX)
- gins(i386.AREP, nil, nil) // repeat
- gins(i386.AMOVSB, nil, nil) // MOVB *(SI)-,*(DI)-
+ gconreg(x86.AMOVL, int64(c), x86.REG_CX)
+ gins(x86.AREP, nil, nil) // repeat
+ gins(x86.AMOVSB, nil, nil) // MOVB *(SI)-,*(DI)-
}
if q > 0 {
if c > 0 {
- gconreg(i386.AADDL, -3, i386.REG_SI)
- gconreg(i386.AADDL, -3, i386.REG_DI)
+ gconreg(x86.AADDL, -3, x86.REG_SI)
+ gconreg(x86.AADDL, -3, x86.REG_DI)
} else {
- gconreg(i386.AADDL, w-4, i386.REG_SI)
- gconreg(i386.AADDL, w-4, i386.REG_DI)
+ gconreg(x86.AADDL, w-4, x86.REG_SI)
+ gconreg(x86.AADDL, w-4, x86.REG_DI)
}
- gconreg(i386.AMOVL, int64(q), i386.REG_CX)
- gins(i386.AREP, nil, nil) // repeat
- gins(i386.AMOVSL, nil, nil) // MOVL *(SI)-,*(DI)-
+ gconreg(x86.AMOVL, int64(q), x86.REG_CX)
+ gins(x86.AREP, nil, nil) // repeat
+ gins(x86.AMOVSL, nil, nil) // MOVL *(SI)-,*(DI)-
}
// we leave with the flag clear
- gins(i386.ACLD, nil, nil)
+ gins(x86.ACLD, nil, nil)
} else {
- gins(i386.ACLD, nil, nil) // paranoia. TODO(rsc): remove?
+ gins(x86.ACLD, nil, nil) // paranoia. TODO(rsc): remove?
// normal direction
if q > 128 || (q >= 4 && gc.Nacl) {
- gconreg(i386.AMOVL, int64(q), i386.REG_CX)
- gins(i386.AREP, nil, nil) // repeat
- gins(i386.AMOVSL, nil, nil) // MOVL *(SI)+,*(DI)+
+ gconreg(x86.AMOVL, int64(q), x86.REG_CX)
+ gins(x86.AREP, nil, nil) // repeat
+ gins(x86.AMOVSL, nil, nil) // MOVL *(SI)+,*(DI)+
} else if q >= 4 {
p := gins(obj.ADUFFCOPY, nil, nil)
p.To.Type = obj.TYPE_ADDR
p.To.Offset = 10 * (128 - int64(q))
} else if !gc.Nacl && c == 0 {
var cx gc.Node
- gc.Nodreg(&cx, gc.Types[gc.TINT32], i386.REG_CX)
+ gc.Nodreg(&cx, gc.Types[gc.TINT32], x86.REG_CX)
// We don't need the MOVSL side-effect of updating SI and DI,
// and issuing a sequence of MOVLs directly is faster.
}
} else {
for q > 0 {
- gins(i386.AMOVSL, nil, nil) // MOVL *(SI)+,*(DI)+
+ gins(x86.AMOVSL, nil, nil) // MOVL *(SI)+,*(DI)+
q--
}
}
for c > 0 {
- gins(i386.AMOVSB, nil, nil) // MOVB *(SI)+,*(DI)+
+ gins(x86.AMOVSB, nil, nil) // MOVB *(SI)+,*(DI)+
c--
}
}
import (
"cmd/internal/gc"
"cmd/internal/obj"
- i386 "cmd/internal/obj/x86"
+ "cmd/internal/obj/x86"
)
/*
var hi1 gc.Node
var lo1 gc.Node
split64(res, &lo1, &hi1)
- gins(i386.ANEGL, nil, &lo1)
- gins(i386.AADCL, ncon(0), &hi1)
- gins(i386.ANEGL, nil, &hi1)
+ gins(x86.ANEGL, nil, &lo1)
+ gins(x86.AADCL, ncon(0), &hi1)
+ gins(x86.ANEGL, nil, &hi1)
splitclean()
return
var lo1 gc.Node
var hi1 gc.Node
split64(res, &lo1, &hi1)
- gins(i386.ANOTL, nil, &lo1)
- gins(i386.ANOTL, nil, &hi1)
+ gins(x86.ANOTL, nil, &lo1)
+ gins(x86.ANOTL, nil, &hi1)
splitclean()
return
}
var ax gc.Node
- gc.Nodreg(&ax, gc.Types[gc.TINT32], i386.REG_AX)
+ gc.Nodreg(&ax, gc.Types[gc.TINT32], x86.REG_AX)
var cx gc.Node
- gc.Nodreg(&cx, gc.Types[gc.TINT32], i386.REG_CX)
+ gc.Nodreg(&cx, gc.Types[gc.TINT32], x86.REG_CX)
var dx gc.Node
- gc.Nodreg(&dx, gc.Types[gc.TINT32], i386.REG_DX)
+ gc.Nodreg(&dx, gc.Types[gc.TINT32], x86.REG_DX)
// Setup for binary operation.
var hi1 gc.Node
switch n.Op {
// TODO: Constants
case gc.OADD:
- gins(i386.AMOVL, &lo1, &ax)
+ gins(x86.AMOVL, &lo1, &ax)
- gins(i386.AMOVL, &hi1, &dx)
- gins(i386.AADDL, &lo2, &ax)
- gins(i386.AADCL, &hi2, &dx)
+ gins(x86.AMOVL, &hi1, &dx)
+ gins(x86.AADDL, &lo2, &ax)
+ gins(x86.AADCL, &hi2, &dx)
// TODO: Constants.
case gc.OSUB:
- gins(i386.AMOVL, &lo1, &ax)
+ gins(x86.AMOVL, &lo1, &ax)
- gins(i386.AMOVL, &hi1, &dx)
- gins(i386.ASUBL, &lo2, &ax)
- gins(i386.ASBBL, &hi2, &dx)
+ gins(x86.AMOVL, &hi1, &dx)
+ gins(x86.ASUBL, &lo2, &ax)
+ gins(x86.ASBBL, &hi2, &dx)
// let's call the next two EX and FX.
case gc.OMUL:
regalloc(&fx, gc.Types[gc.TPTR32], nil)
// load args into DX:AX and EX:CX.
- gins(i386.AMOVL, &lo1, &ax)
+ gins(x86.AMOVL, &lo1, &ax)
- gins(i386.AMOVL, &hi1, &dx)
- gins(i386.AMOVL, &lo2, &cx)
- gins(i386.AMOVL, &hi2, &ex)
+ gins(x86.AMOVL, &hi1, &dx)
+ gins(x86.AMOVL, &lo2, &cx)
+ gins(x86.AMOVL, &hi2, &ex)
// if DX and EX are zero, use 32 x 32 -> 64 unsigned multiply.
- gins(i386.AMOVL, &dx, &fx)
+ gins(x86.AMOVL, &dx, &fx)
- gins(i386.AORL, &ex, &fx)
- p1 := gc.Gbranch(i386.AJNE, nil, 0)
- gins(i386.AMULL, &cx, nil) // implicit &ax
+ gins(x86.AORL, &ex, &fx)
+ p1 := gc.Gbranch(x86.AJNE, nil, 0)
+ gins(x86.AMULL, &cx, nil) // implicit &ax
p2 := gc.Gbranch(obj.AJMP, nil, 0)
gc.Patch(p1, gc.Pc)
// full 64x64 -> 64, from 32x32 -> 64.
- gins(i386.AIMULL, &cx, &dx)
-
- gins(i386.AMOVL, &ax, &fx)
- gins(i386.AIMULL, &ex, &fx)
- gins(i386.AADDL, &dx, &fx)
- gins(i386.AMOVL, &cx, &dx)
- gins(i386.AMULL, &dx, nil) // implicit &ax
- gins(i386.AADDL, &fx, &dx)
+ gins(x86.AIMULL, &cx, &dx)
+
+ gins(x86.AMOVL, &ax, &fx)
+ gins(x86.AIMULL, &ex, &fx)
+ gins(x86.AADDL, &dx, &fx)
+ gins(x86.AMOVL, &cx, &dx)
+ gins(x86.AMULL, &dx, nil) // implicit &ax
+ gins(x86.AADDL, &fx, &dx)
gc.Patch(p2, gc.Pc)
regfree(&ex)
// reverse during load to do the first 32 bits of rotate
v -= 32
- gins(i386.AMOVL, &lo1, &dx)
- gins(i386.AMOVL, &hi1, &ax)
+ gins(x86.AMOVL, &lo1, &dx)
+ gins(x86.AMOVL, &hi1, &ax)
} else {
- gins(i386.AMOVL, &lo1, &ax)
- gins(i386.AMOVL, &hi1, &dx)
+ gins(x86.AMOVL, &lo1, &ax)
+ gins(x86.AMOVL, &hi1, &dx)
}
if v == 0 {
} else // done
{
- gins(i386.AMOVL, &dx, &cx)
- p1 := gins(i386.ASHLL, ncon(uint32(v)), &dx)
- p1.From.Index = i386.REG_AX // double-width shift
+ gins(x86.AMOVL, &dx, &cx)
+ p1 := gins(x86.ASHLL, ncon(uint32(v)), &dx)
+ p1.From.Index = x86.REG_AX // double-width shift
p1.From.Scale = 0
- p1 = gins(i386.ASHLL, ncon(uint32(v)), &ax)
- p1.From.Index = i386.REG_CX // double-width shift
+ p1 = gins(x86.ASHLL, ncon(uint32(v)), &ax)
+ p1.From.Index = x86.REG_CX // double-width shift
p1.From.Scale = 0
}
}
splitclean()
split64(res, &lo2, &hi2)
- gins(i386.AMOVL, ncon(0), &lo2)
- gins(i386.AMOVL, ncon(0), &hi2)
+ gins(x86.AMOVL, ncon(0), &lo2)
+ gins(x86.AMOVL, ncon(0), &hi2)
splitclean()
return
}
split64(res, &lo2, &hi2)
gmove(&lo1, &hi2)
if v > 32 {
- gins(i386.ASHLL, ncon(uint32(v-32)), &hi2)
+ gins(x86.ASHLL, ncon(uint32(v-32)), &hi2)
}
- gins(i386.AMOVL, ncon(0), &lo2)
+ gins(x86.AMOVL, ncon(0), &lo2)
splitclean()
splitclean()
return
}
// general shift
- gins(i386.AMOVL, &lo1, &ax)
+ gins(x86.AMOVL, &lo1, &ax)
- gins(i386.AMOVL, &hi1, &dx)
- p1 := gins(i386.ASHLL, ncon(uint32(v)), &dx)
- p1.From.Index = i386.REG_AX // double-width shift
+ gins(x86.AMOVL, &hi1, &dx)
+ p1 := gins(x86.ASHLL, ncon(uint32(v)), &dx)
+ p1.From.Index = x86.REG_AX // double-width shift
p1.From.Scale = 0
- gins(i386.ASHLL, ncon(uint32(v)), &ax)
+ gins(x86.ASHLL, ncon(uint32(v)), &ax)
break
}
// load value into DX:AX.
- gins(i386.AMOVL, &lo1, &ax)
+ gins(x86.AMOVL, &lo1, &ax)
- gins(i386.AMOVL, &hi1, &dx)
+ gins(x86.AMOVL, &hi1, &dx)
// load shift value into register.
// if high bits are set, zero value.
var p1 *obj.Prog
if gc.Is64(r.Type) {
- gins(i386.ACMPL, &hi2, ncon(0))
- p1 = gc.Gbranch(i386.AJNE, nil, +1)
- gins(i386.AMOVL, &lo2, &cx)
+ gins(x86.ACMPL, &hi2, ncon(0))
+ p1 = gc.Gbranch(x86.AJNE, nil, +1)
+ gins(x86.AMOVL, &lo2, &cx)
} else {
cx.Type = gc.Types[gc.TUINT32]
gmove(r, &cx)
}
// if shift count is >=64, zero value
- gins(i386.ACMPL, &cx, ncon(64))
+ gins(x86.ACMPL, &cx, ncon(64))
p2 := gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
if p1 != nil {
gc.Patch(p1, gc.Pc)
}
- gins(i386.AXORL, &dx, &dx)
- gins(i386.AXORL, &ax, &ax)
+ gins(x86.AXORL, &dx, &dx)
+ gins(x86.AXORL, &ax, &ax)
gc.Patch(p2, gc.Pc)
// if shift count is >= 32, zero low.
- gins(i386.ACMPL, &cx, ncon(32))
+ gins(x86.ACMPL, &cx, ncon(32))
p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
- gins(i386.AMOVL, &ax, &dx)
- gins(i386.ASHLL, &cx, &dx) // SHLL only uses bottom 5 bits of count
- gins(i386.AXORL, &ax, &ax)
+ gins(x86.AMOVL, &ax, &dx)
+ gins(x86.ASHLL, &cx, &dx) // SHLL only uses bottom 5 bits of count
+ gins(x86.AXORL, &ax, &ax)
p2 = gc.Gbranch(obj.AJMP, nil, 0)
gc.Patch(p1, gc.Pc)
// general shift
- p1 = gins(i386.ASHLL, &cx, &dx)
+ p1 = gins(x86.ASHLL, &cx, &dx)
- p1.From.Index = i386.REG_AX // double-width shift
+ p1.From.Index = x86.REG_AX // double-width shift
p1.From.Scale = 0
- gins(i386.ASHLL, &cx, &ax)
+ gins(x86.ASHLL, &cx, &ax)
gc.Patch(p2, gc.Pc)
case gc.ORSH:
split64(res, &lo2, &hi2)
if hi1.Type.Etype == gc.TINT32 {
gmove(&hi1, &lo2)
- gins(i386.ASARL, ncon(31), &lo2)
+ gins(x86.ASARL, ncon(31), &lo2)
gmove(&hi1, &hi2)
- gins(i386.ASARL, ncon(31), &hi2)
+ gins(x86.ASARL, ncon(31), &hi2)
} else {
- gins(i386.AMOVL, ncon(0), &lo2)
- gins(i386.AMOVL, ncon(0), &hi2)
+ gins(x86.AMOVL, ncon(0), &lo2)
+ gins(x86.AMOVL, ncon(0), &hi2)
}
splitclean()
}
if hi1.Type.Etype == gc.TINT32 {
gmove(&hi1, &hi2)
- gins(i386.ASARL, ncon(31), &hi2)
+ gins(x86.ASARL, ncon(31), &hi2)
} else {
- gins(i386.AMOVL, ncon(0), &hi2)
+ gins(x86.AMOVL, ncon(0), &hi2)
}
splitclean()
splitclean()
}
// general shift
- gins(i386.AMOVL, &lo1, &ax)
+ gins(x86.AMOVL, &lo1, &ax)
- gins(i386.AMOVL, &hi1, &dx)
- p1 := gins(i386.ASHRL, ncon(uint32(v)), &ax)
- p1.From.Index = i386.REG_DX // double-width shift
+ gins(x86.AMOVL, &hi1, &dx)
+ p1 := gins(x86.ASHRL, ncon(uint32(v)), &ax)
+ p1.From.Index = x86.REG_DX // double-width shift
p1.From.Scale = 0
gins(optoas(gc.ORSH, hi1.Type), ncon(uint32(v)), &dx)
break
}
// load value into DX:AX.
- gins(i386.AMOVL, &lo1, &ax)
+ gins(x86.AMOVL, &lo1, &ax)
- gins(i386.AMOVL, &hi1, &dx)
+ gins(x86.AMOVL, &hi1, &dx)
// load shift value into register.
// if high bits are set, zero value.
var p1 *obj.Prog
if gc.Is64(r.Type) {
- gins(i386.ACMPL, &hi2, ncon(0))
- p1 = gc.Gbranch(i386.AJNE, nil, +1)
- gins(i386.AMOVL, &lo2, &cx)
+ gins(x86.ACMPL, &hi2, ncon(0))
+ p1 = gc.Gbranch(x86.AJNE, nil, +1)
+ gins(x86.AMOVL, &lo2, &cx)
} else {
cx.Type = gc.Types[gc.TUINT32]
gmove(r, &cx)
}
// if shift count is >=64, zero or sign-extend value
- gins(i386.ACMPL, &cx, ncon(64))
+ gins(x86.ACMPL, &cx, ncon(64))
p2 := gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
if p1 != nil {
gc.Patch(p1, gc.Pc)
}
if hi1.Type.Etype == gc.TINT32 {
- gins(i386.ASARL, ncon(31), &dx)
- gins(i386.AMOVL, &dx, &ax)
+ gins(x86.ASARL, ncon(31), &dx)
+ gins(x86.AMOVL, &dx, &ax)
} else {
- gins(i386.AXORL, &dx, &dx)
- gins(i386.AXORL, &ax, &ax)
+ gins(x86.AXORL, &dx, &dx)
+ gins(x86.AXORL, &ax, &ax)
}
gc.Patch(p2, gc.Pc)
// if shift count is >= 32, sign-extend hi.
- gins(i386.ACMPL, &cx, ncon(32))
+ gins(x86.ACMPL, &cx, ncon(32))
p1 = gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TUINT32]), nil, +1)
- gins(i386.AMOVL, &dx, &ax)
+ gins(x86.AMOVL, &dx, &ax)
if hi1.Type.Etype == gc.TINT32 {
- gins(i386.ASARL, &cx, &ax) // SARL only uses bottom 5 bits of count
- gins(i386.ASARL, ncon(31), &dx)
+ gins(x86.ASARL, &cx, &ax) // SARL only uses bottom 5 bits of count
+ gins(x86.ASARL, ncon(31), &dx)
} else {
- gins(i386.ASHRL, &cx, &ax)
- gins(i386.AXORL, &dx, &dx)
+ gins(x86.ASHRL, &cx, &ax)
+ gins(x86.AXORL, &dx, &dx)
}
p2 = gc.Gbranch(obj.AJMP, nil, 0)
gc.Patch(p1, gc.Pc)
// general shift
- p1 = gins(i386.ASHRL, &cx, &ax)
+ p1 = gins(x86.ASHRL, &cx, &ax)
- p1.From.Index = i386.REG_DX // double-width shift
+ p1.From.Index = x86.REG_DX // double-width shift
p1.From.Scale = 0
gins(optoas(gc.ORSH, hi1.Type), &cx, &dx)
gc.Patch(p2, gc.Pc)
break
case 0xffffffff:
- gins(i386.ANOTL, nil, &lo2)
+ gins(x86.ANOTL, nil, &lo2)
default:
- gins(i386.AXORL, ncon(lv), &lo2)
+ gins(x86.AXORL, ncon(lv), &lo2)
}
switch hv {
break
case 0xffffffff:
- gins(i386.ANOTL, nil, &hi2)
+ gins(x86.ANOTL, nil, &hi2)
default:
- gins(i386.AXORL, ncon(hv), &hi2)
+ gins(x86.AXORL, ncon(hv), &hi2)
}
case gc.OAND:
switch lv {
case 0:
- gins(i386.AMOVL, ncon(0), &lo2)
+ gins(x86.AMOVL, ncon(0), &lo2)
default:
gmove(&lo1, &lo2)
if lv != 0xffffffff {
- gins(i386.AANDL, ncon(lv), &lo2)
+ gins(x86.AANDL, ncon(lv), &lo2)
}
}
switch hv {
case 0:
- gins(i386.AMOVL, ncon(0), &hi2)
+ gins(x86.AMOVL, ncon(0), &hi2)
default:
gmove(&hi1, &hi2)
if hv != 0xffffffff {
- gins(i386.AANDL, ncon(hv), &hi2)
+ gins(x86.AANDL, ncon(hv), &hi2)
}
}
gmove(&lo1, &lo2)
case 0xffffffff:
- gins(i386.AMOVL, ncon(0xffffffff), &lo2)
+ gins(x86.AMOVL, ncon(0xffffffff), &lo2)
default:
gmove(&lo1, &lo2)
- gins(i386.AORL, ncon(lv), &lo2)
+ gins(x86.AORL, ncon(lv), &lo2)
}
switch hv {
gmove(&hi1, &hi2)
case 0xffffffff:
- gins(i386.AMOVL, ncon(0xffffffff), &hi2)
+ gins(x86.AMOVL, ncon(0xffffffff), &hi2)
default:
gmove(&hi1, &hi2)
- gins(i386.AORL, ncon(hv), &hi2)
+ gins(x86.AORL, ncon(hv), &hi2)
}
}
return
}
- gins(i386.AMOVL, &lo1, &ax)
- gins(i386.AMOVL, &hi1, &dx)
+ gins(x86.AMOVL, &lo1, &ax)
+ gins(x86.AMOVL, &hi1, &dx)
gins(optoas(int(n.Op), lo1.Type), &lo2, &ax)
gins(optoas(int(n.Op), lo1.Type), &hi2, &dx)
}
splitclean()
split64(res, &lo1, &hi1)
- gins(i386.AMOVL, &ax, &lo1)
- gins(i386.AMOVL, &dx, &hi1)
+ gins(x86.AMOVL, &ax, &lo1)
+ gins(x86.AMOVL, &dx, &hi1)
splitclean()
}
t := hi1.Type
if nl.Op == gc.OLITERAL || nr.Op == gc.OLITERAL {
- gins(i386.ACMPL, &hi1, &hi2)
+ gins(x86.ACMPL, &hi1, &hi2)
} else {
regalloc(&rr, gc.Types[gc.TINT32], nil)
- gins(i386.AMOVL, &hi1, &rr)
- gins(i386.ACMPL, &rr, &hi2)
+ gins(x86.AMOVL, &hi1, &rr)
+ gins(x86.ACMPL, &rr, &hi2)
regfree(&rr)
}
// jeq to
// L:
case gc.OEQ:
- br = gc.Gbranch(i386.AJNE, nil, -likely)
+ br = gc.Gbranch(x86.AJNE, nil, -likely)
// cmp hi
// jne to
// cmp lo
// jne to
case gc.ONE:
- gc.Patch(gc.Gbranch(i386.AJNE, nil, likely), to)
+ gc.Patch(gc.Gbranch(x86.AJNE, nil, likely), to)
// cmp hi
// jgt to
t = lo1.Type
if nl.Op == gc.OLITERAL || nr.Op == gc.OLITERAL {
- gins(i386.ACMPL, &lo1, &lo2)
+ gins(x86.ACMPL, &lo1, &lo2)
} else {
regalloc(&rr, gc.Types[gc.TINT32], nil)
- gins(i386.AMOVL, &lo1, &rr)
- gins(i386.ACMPL, &rr, &lo2)
+ gins(x86.AMOVL, &lo1, &rr)
+ gins(x86.ACMPL, &rr, &lo2)
regfree(&rr)
}
import (
"cmd/internal/gc"
"cmd/internal/obj"
- i386 "cmd/internal/obj/x86"
+ "cmd/internal/obj/x86"
)
var thechar int = '8'
var thestring string = "386"
-var thelinkarch *obj.LinkArch = &i386.Link386
+var thelinkarch *obj.LinkArch = &x86.Link386
func linkarchinit() {
}
gc.Thearch.Thestring = thestring
gc.Thearch.Thelinkarch = thelinkarch
gc.Thearch.Typedefs = typedefs
- gc.Thearch.REGSP = i386.REGSP
- gc.Thearch.REGCTXT = i386.REGCTXT
+ gc.Thearch.REGSP = x86.REGSP
+ gc.Thearch.REGCTXT = x86.REGCTXT
gc.Thearch.MAXWIDTH = MAXWIDTH
gc.Thearch.Anyregalloc = anyregalloc
gc.Thearch.Betypeinit = betypeinit
package main
-import i386 "cmd/internal/obj/x86"
+import "cmd/internal/obj/x86"
import "cmd/internal/gc"
// TODO(rsc):
Fpop2 = 1 << 2
)
-var reg [i386.MAXREG]uint8
+var reg [x86.MAXREG]uint8
var panicdiv *gc.Node
import (
"cmd/internal/gc"
"cmd/internal/obj"
- i386 "cmd/internal/obj/x86"
+ "cmd/internal/obj/x86"
)
func defframe(ptxt *obj.Prog) {
return p
}
if *ax == 0 {
- p = appendpp(p, i386.AMOVL, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, i386.REG_AX, 0)
+ p = appendpp(p, x86.AMOVL, obj.TYPE_CONST, 0, 0, obj.TYPE_REG, x86.REG_AX, 0)
*ax = 1
}
if cnt <= int64(4*gc.Widthreg) {
for i := int64(0); i < cnt; i += int64(gc.Widthreg) {
- p = appendpp(p, i386.AMOVL, obj.TYPE_REG, i386.REG_AX, 0, obj.TYPE_MEM, i386.REG_SP, frame+lo+i)
+ p = appendpp(p, x86.AMOVL, obj.TYPE_REG, x86.REG_AX, 0, obj.TYPE_MEM, x86.REG_SP, frame+lo+i)
}
} else if !gc.Nacl && cnt <= int64(128*gc.Widthreg) {
- p = appendpp(p, i386.ALEAL, obj.TYPE_MEM, i386.REG_SP, frame+lo, obj.TYPE_REG, i386.REG_DI, 0)
+ p = appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, frame+lo, obj.TYPE_REG, x86.REG_DI, 0)
p = appendpp(p, obj.ADUFFZERO, obj.TYPE_NONE, 0, 0, obj.TYPE_ADDR, 0, 1*(128-cnt/int64(gc.Widthreg)))
p.To.Sym = gc.Linksym(gc.Pkglookup("duffzero", gc.Runtimepkg))
} else {
- p = appendpp(p, i386.AMOVL, obj.TYPE_CONST, 0, cnt/int64(gc.Widthreg), obj.TYPE_REG, i386.REG_CX, 0)
- p = appendpp(p, i386.ALEAL, obj.TYPE_MEM, i386.REG_SP, frame+lo, obj.TYPE_REG, i386.REG_DI, 0)
- p = appendpp(p, i386.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
- p = appendpp(p, i386.ASTOSL, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+ p = appendpp(p, x86.AMOVL, obj.TYPE_CONST, 0, cnt/int64(gc.Widthreg), obj.TYPE_REG, x86.REG_CX, 0)
+ p = appendpp(p, x86.ALEAL, obj.TYPE_MEM, x86.REG_SP, frame+lo, obj.TYPE_REG, x86.REG_DI, 0)
+ p = appendpp(p, x86.AREP, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
+ p = appendpp(p, x86.ASTOSL, obj.TYPE_NONE, 0, 0, obj.TYPE_NONE, 0, 0)
}
return p
break
}
n1.Type = z.Type
- gins(i386.AMOVL, &z, &n1)
+ gins(x86.AMOVL, &z, &n1)
n1.Xoffset += 4
}
break
}
n1.Type = z.Type
- gins(i386.AMOVB, &z, &n1)
+ gins(x86.AMOVB, &z, &n1)
n1.Xoffset++
}
}
var n1 gc.Node
- gc.Nodreg(&n1, gc.Types[gc.Tptr], i386.REG_DI)
+ gc.Nodreg(&n1, gc.Types[gc.Tptr], x86.REG_DI)
agen(nl, &n1)
- gconreg(i386.AMOVL, 0, i386.REG_AX)
+ gconreg(x86.AMOVL, 0, x86.REG_AX)
if q > 128 || (q >= 4 && gc.Nacl) {
- gconreg(i386.AMOVL, int64(q), i386.REG_CX)
- gins(i386.AREP, nil, nil) // repeat
- gins(i386.ASTOSL, nil, nil) // STOL AL,*(DI)+
+ gconreg(x86.AMOVL, int64(q), x86.REG_CX)
+ gins(x86.AREP, nil, nil) // repeat
+ gins(x86.ASTOSL, nil, nil) // STOL AL,*(DI)+
} else if q >= 4 {
p := gins(obj.ADUFFZERO, nil, nil)
p.To.Type = obj.TYPE_ADDR
p.To.Offset = 1 * (128 - int64(q))
} else {
for q > 0 {
- gins(i386.ASTOSL, nil, nil) // STOL AL,*(DI)+
+ gins(x86.ASTOSL, nil, nil) // STOL AL,*(DI)+
q--
}
}
for c > 0 {
- gins(i386.ASTOSB, nil, nil) // STOB AL,*(DI)+
+ gins(x86.ASTOSB, nil, nil) // STOB AL,*(DI)+
c--
}
}
// because the NOP pseudo-instruction will be removed by
// the linker.
var reg gc.Node
- gc.Nodreg(®, gc.Types[gc.TINT], i386.REG_AX)
+ gc.Nodreg(®, gc.Types[gc.TINT], x86.REG_AX)
- gins(i386.AXCHGL, ®, ®)
+ gins(x86.AXCHGL, ®, ®)
}
p := gins(obj.ACALL, nil, f)
}
var reg gc.Node
- gc.Nodreg(®, gc.Types[gc.Tptr], i386.REG_DX)
+ gc.Nodreg(®, gc.Types[gc.Tptr], x86.REG_DX)
var r1 gc.Node
- gc.Nodreg(&r1, gc.Types[gc.Tptr], i386.REG_BX)
+ gc.Nodreg(&r1, gc.Types[gc.Tptr], x86.REG_BX)
gmove(f, ®)
reg.Op = gc.OINDREG
gmove(®, &r1)
var stk gc.Node
stk.Op = gc.OINDREG
- stk.Val.U.Reg = i386.REG_SP
+ stk.Val.U.Reg = x86.REG_SP
stk.Xoffset = 0
// size of arguments at 0(SP)
var con gc.Node
gc.Nodconst(&con, gc.Types[gc.TINT32], int64(gc.Argsize(f.Type)))
- gins(i386.AMOVL, &con, &stk)
+ gins(x86.AMOVL, &con, &stk)
// FuncVal* at 4(SP)
stk.Xoffset = int64(gc.Widthptr)
- gins(i386.AMOVL, f, &stk)
+ gins(x86.AMOVL, f, &stk)
if proc == 1 {
ginscall(gc.Newproc, 0)
}
if proc == 2 {
var reg gc.Node
- gc.Nodreg(®, gc.Types[gc.TINT32], i386.REG_AX)
- gins(i386.ATESTL, ®, ®)
- p := gc.Gbranch(i386.AJEQ, nil, +1)
+ gc.Nodreg(®, gc.Types[gc.TINT32], x86.REG_AX)
+ gins(x86.ATESTL, ®, ®)
+ p := gc.Gbranch(x86.AJEQ, nil, +1)
cgen_ret(nil)
gc.Patch(p, gc.Pc)
}
igen(i, &nodi, res) // REG = &inter
var nodsp gc.Node
- gc.Nodindreg(&nodsp, gc.Types[gc.Tptr], i386.REG_SP)
+ gc.Nodindreg(&nodsp, gc.Types[gc.Tptr], x86.REG_SP)
nodsp.Xoffset = 0
if proc != 0 {
proc = 3
} else {
// go/defer. generate go func value.
- gins(i386.ALEAL, &nodo, &nodr) // REG = &(20+offset(REG)) -- i.tab->fun[f]
+ gins(x86.ALEAL, &nodo, &nodr) // REG = &(20+offset(REG)) -- i.tab->fun[f]
}
nodr.Type = n.Left.Type
var nod gc.Node
nod.Op = gc.OINDREG
- nod.Val.U.Reg = i386.REG_SP
+ nod.Val.U.Reg = x86.REG_SP
nod.Addable = 1
nod.Xoffset = fp.Width
var nod1 gc.Node
nod1.Op = gc.OINDREG
- nod1.Val.U.Reg = i386.REG_SP
+ nod1.Val.U.Reg = x86.REG_SP
nod1.Addable = 1
nod1.Xoffset = fp.Width
if res.Op != gc.OREGISTER {
var nod2 gc.Node
regalloc(&nod2, gc.Types[gc.Tptr], res)
- gins(i386.ALEAL, &nod1, &nod2)
- gins(i386.AMOVL, &nod2, res)
+ gins(x86.ALEAL, &nod1, &nod2)
+ gins(x86.AMOVL, &nod2, res)
regfree(&nod2)
} else {
- gins(i386.ALEAL, &nod1, res)
+ gins(x86.ALEAL, &nod1, res)
}
}
}
var ax gc.Node
var oldax gc.Node
- savex(i386.REG_AX, &ax, &oldax, res, t)
+ savex(x86.REG_AX, &ax, &oldax, res, t)
var olddx gc.Node
var dx gc.Node
- savex(i386.REG_DX, &dx, &olddx, res, t)
+ savex(x86.REG_DX, &dx, &olddx, res, t)
dodiv(op, nl, nr, res, &ax, &dx)
restx(&dx, &olddx)
restx(&ax, &oldax)
var oldcx gc.Node
var cx gc.Node
- gc.Nodreg(&cx, gc.Types[gc.TUINT32], i386.REG_CX)
- if reg[i386.REG_CX] > 1 && !gc.Samereg(&cx, res) {
+ gc.Nodreg(&cx, gc.Types[gc.TUINT32], x86.REG_CX)
+ if reg[x86.REG_CX] > 1 && !gc.Samereg(&cx, res) {
gc.Tempname(&oldcx, gc.Types[gc.TUINT32])
gmove(&cx, &oldcx)
}
gc.Tempname(&nt, nr.Type)
n1 = nt
} else {
- gc.Nodreg(&n1, gc.Types[gc.TUINT32], i386.REG_CX)
+ gc.Nodreg(&n1, gc.Types[gc.TUINT32], x86.REG_CX)
regalloc(&n1, nr.Type, &n1) // to hold the shift type in CX
}
if bounded {
if nr.Type.Width > 4 {
// delayed reg alloc
- gc.Nodreg(&n1, gc.Types[gc.TUINT32], i386.REG_CX)
+ gc.Nodreg(&n1, gc.Types[gc.TUINT32], x86.REG_CX)
regalloc(&n1, gc.Types[gc.TUINT32], &n1) // to hold the shift type in CX
var lo gc.Node
var p1 *obj.Prog
if nr.Type.Width > 4 {
// delayed reg alloc
- gc.Nodreg(&n1, gc.Types[gc.TUINT32], i386.REG_CX)
+ gc.Nodreg(&n1, gc.Types[gc.TUINT32], x86.REG_CX)
regalloc(&n1, gc.Types[gc.TUINT32], &n1) // to hold the shift type in CX
var lo gc.Node
cgen(nr, &n2)
// multiply.
- gc.Nodreg(&ax, t, i386.REG_AX)
+ gc.Nodreg(&ax, t, x86.REG_AX)
gmove(&n2, &ax)
gins(a, &n1, nil)
if t.Width == 1 {
// byte multiply behaves differently.
- gc.Nodreg(&ax, t, i386.REG_AH)
+ gc.Nodreg(&ax, t, x86.REG_AH)
- gc.Nodreg(&dx, t, i386.REG_DX)
+ gc.Nodreg(&dx, t, x86.REG_DX)
gmove(&ax, &dx)
}
- gc.Nodreg(&dx, t, i386.REG_DX)
+ gc.Nodreg(&dx, t, x86.REG_DX)
gmove(&dx, res)
}
nl := n.Left
nr := n.Right
- gc.Nodreg(&f0, nl.Type, i386.REG_F0)
- gc.Nodreg(&f1, n.Type, i386.REG_F0+1)
+ gc.Nodreg(&f0, nl.Type, x86.REG_F0)
+ gc.Nodreg(&f1, n.Type, x86.REG_F0+1)
if nr != nil {
// binary
if nl.Ullman >= nr.Ullman {
a = gc.Brrev(a)
}
- gc.Nodreg(&tmp, nr.Type, i386.REG_F0)
- gc.Nodreg(&n2, nr.Type, i386.REG_F0+1)
- gc.Nodreg(&ax, gc.Types[gc.TUINT16], i386.REG_AX)
+ gc.Nodreg(&tmp, nr.Type, x86.REG_F0)
+ gc.Nodreg(&n2, nr.Type, x86.REG_F0+1)
+ gc.Nodreg(&ax, gc.Types[gc.TUINT16], x86.REG_AX)
et = gc.Simsimtype(nr.Type)
if et == gc.TFLOAT64 {
if nl.Ullman > nr.Ullman {
cgen(nl, &tmp)
cgen(nr, &tmp)
- gins(i386.AFXCHD, &tmp, &n2)
+ gins(x86.AFXCHD, &tmp, &n2)
} else {
cgen(nr, &tmp)
cgen(nl, &tmp)
}
- gins(i386.AFUCOMIP, &tmp, &n2)
- gins(i386.AFMOVDP, &tmp, &tmp) // annoying pop but still better than STSW+SAHF
+ gins(x86.AFUCOMIP, &tmp, &n2)
+ gins(x86.AFMOVDP, &tmp, &tmp) // annoying pop but still better than STSW+SAHF
} else {
// TODO(rsc): The moves back and forth to memory
// here are for truncating the value to 32 bits.
cgen(nr, &t1)
cgen(nl, &t2)
gmove(&t2, &tmp)
- gins(i386.AFCOMFP, &t1, &tmp)
- gins(i386.AFSTSW, nil, &ax)
- gins(i386.ASAHF, nil, nil)
+ gins(x86.AFCOMFP, &t1, &tmp)
+ gins(x86.AFSTSW, nil, &ax)
+ gins(x86.ASAHF, nil, nil)
}
goto ret
ret:
if a == gc.OEQ {
// neither NE nor P
- p1 := gc.Gbranch(i386.AJNE, nil, -likely)
+ p1 := gc.Gbranch(x86.AJNE, nil, -likely)
- p2 := gc.Gbranch(i386.AJPS, nil, -likely)
+ p2 := gc.Gbranch(x86.AJPS, nil, -likely)
gc.Patch(gc.Gbranch(obj.AJMP, nil, 0), to)
gc.Patch(p1, gc.Pc)
gc.Patch(p2, gc.Pc)
} else if a == gc.ONE {
// either NE or P
- gc.Patch(gc.Gbranch(i386.AJNE, nil, likely), to)
+ gc.Patch(gc.Gbranch(x86.AJNE, nil, likely), to)
- gc.Patch(gc.Gbranch(i386.AJPS, nil, likely), to)
+ gc.Patch(gc.Gbranch(x86.AJPS, nil, likely), to)
} else {
gc.Patch(gc.Gbranch(optoas(a, nr.Type), nil, likely), to)
}
p2.Lineno = p.Lineno
p1.Pc = 9999
p2.Pc = 9999
- p.As = i386.ACMPL
+ p.As = x86.ACMPL
p.To.Type = obj.TYPE_CONST
p.To.Offset = 0
- p1.As = i386.AJNE
+ p1.As = x86.AJNE
p1.From.Type = obj.TYPE_CONST
p1.From.Offset = 1 // likely
p1.To.Type = obj.TYPE_BRANCH
// crash by write to memory address 0.
// if possible, since we know arg is 0, use 0(arg),
// which will be shorter to encode than plain 0.
- p2.As = i386.AMOVL
+ p2.As = x86.AMOVL
p2.From.Type = obj.TYPE_REG
- p2.From.Reg = i386.REG_AX
+ p2.From.Reg = x86.REG_AX
if regtyp(&p.From) {
p2.To.Type = obj.TYPE_MEM
p2.To.Reg = p.From.Reg
import (
"cmd/internal/gc"
"cmd/internal/obj"
- i386 "cmd/internal/obj/x86"
+ "cmd/internal/obj/x86"
"fmt"
)
gc.Fatal("optoas: no entry %v-%v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
case gc.OADDR<<16 | gc.TPTR32:
- a = i386.ALEAL
+ a = x86.ALEAL
case gc.OEQ<<16 | gc.TBOOL,
gc.OEQ<<16 | gc.TINT8,
gc.OEQ<<16 | gc.TPTR64,
gc.OEQ<<16 | gc.TFLOAT32,
gc.OEQ<<16 | gc.TFLOAT64:
- a = i386.AJEQ
+ a = x86.AJEQ
case gc.ONE<<16 | gc.TBOOL,
gc.ONE<<16 | gc.TINT8,
gc.ONE<<16 | gc.TPTR64,
gc.ONE<<16 | gc.TFLOAT32,
gc.ONE<<16 | gc.TFLOAT64:
- a = i386.AJNE
+ a = x86.AJNE
case gc.OLT<<16 | gc.TINT8,
gc.OLT<<16 | gc.TINT16,
gc.OLT<<16 | gc.TINT32,
gc.OLT<<16 | gc.TINT64:
- a = i386.AJLT
+ a = x86.AJLT
case gc.OLT<<16 | gc.TUINT8,
gc.OLT<<16 | gc.TUINT16,
gc.OLT<<16 | gc.TUINT32,
gc.OLT<<16 | gc.TUINT64:
- a = i386.AJCS
+ a = x86.AJCS
case gc.OLE<<16 | gc.TINT8,
gc.OLE<<16 | gc.TINT16,
gc.OLE<<16 | gc.TINT32,
gc.OLE<<16 | gc.TINT64:
- a = i386.AJLE
+ a = x86.AJLE
case gc.OLE<<16 | gc.TUINT8,
gc.OLE<<16 | gc.TUINT16,
gc.OLE<<16 | gc.TUINT32,
gc.OLE<<16 | gc.TUINT64:
- a = i386.AJLS
+ a = x86.AJLS
case gc.OGT<<16 | gc.TINT8,
gc.OGT<<16 | gc.TINT16,
gc.OGT<<16 | gc.TINT32,
gc.OGT<<16 | gc.TINT64:
- a = i386.AJGT
+ a = x86.AJGT
case gc.OGT<<16 | gc.TUINT8,
gc.OGT<<16 | gc.TUINT16,
gc.OGT<<16 | gc.TUINT64,
gc.OLT<<16 | gc.TFLOAT32,
gc.OLT<<16 | gc.TFLOAT64:
- a = i386.AJHI
+ a = x86.AJHI
case gc.OGE<<16 | gc.TINT8,
gc.OGE<<16 | gc.TINT16,
gc.OGE<<16 | gc.TINT32,
gc.OGE<<16 | gc.TINT64:
- a = i386.AJGE
+ a = x86.AJGE
case gc.OGE<<16 | gc.TUINT8,
gc.OGE<<16 | gc.TUINT16,
gc.OGE<<16 | gc.TUINT64,
gc.OLE<<16 | gc.TFLOAT32,
gc.OLE<<16 | gc.TFLOAT64:
- a = i386.AJCC
+ a = x86.AJCC
case gc.OCMP<<16 | gc.TBOOL,
gc.OCMP<<16 | gc.TINT8,
gc.OCMP<<16 | gc.TUINT8:
- a = i386.ACMPB
+ a = x86.ACMPB
case gc.OCMP<<16 | gc.TINT16,
gc.OCMP<<16 | gc.TUINT16:
- a = i386.ACMPW
+ a = x86.ACMPW
case gc.OCMP<<16 | gc.TINT32,
gc.OCMP<<16 | gc.TUINT32,
gc.OCMP<<16 | gc.TPTR32:
- a = i386.ACMPL
+ a = x86.ACMPL
case gc.OAS<<16 | gc.TBOOL,
gc.OAS<<16 | gc.TINT8,
gc.OAS<<16 | gc.TUINT8:
- a = i386.AMOVB
+ a = x86.AMOVB
case gc.OAS<<16 | gc.TINT16,
gc.OAS<<16 | gc.TUINT16:
- a = i386.AMOVW
+ a = x86.AMOVW
case gc.OAS<<16 | gc.TINT32,
gc.OAS<<16 | gc.TUINT32,
gc.OAS<<16 | gc.TPTR32:
- a = i386.AMOVL
+ a = x86.AMOVL
case gc.OAS<<16 | gc.TFLOAT32:
- a = i386.AMOVSS
+ a = x86.AMOVSS
case gc.OAS<<16 | gc.TFLOAT64:
- a = i386.AMOVSD
+ a = x86.AMOVSD
case gc.OADD<<16 | gc.TINT8,
gc.OADD<<16 | gc.TUINT8:
- a = i386.AADDB
+ a = x86.AADDB
case gc.OADD<<16 | gc.TINT16,
gc.OADD<<16 | gc.TUINT16:
- a = i386.AADDW
+ a = x86.AADDW
case gc.OADD<<16 | gc.TINT32,
gc.OADD<<16 | gc.TUINT32,
gc.OADD<<16 | gc.TPTR32:
- a = i386.AADDL
+ a = x86.AADDL
case gc.OSUB<<16 | gc.TINT8,
gc.OSUB<<16 | gc.TUINT8:
- a = i386.ASUBB
+ a = x86.ASUBB
case gc.OSUB<<16 | gc.TINT16,
gc.OSUB<<16 | gc.TUINT16:
- a = i386.ASUBW
+ a = x86.ASUBW
case gc.OSUB<<16 | gc.TINT32,
gc.OSUB<<16 | gc.TUINT32,
gc.OSUB<<16 | gc.TPTR32:
- a = i386.ASUBL
+ a = x86.ASUBL
case gc.OINC<<16 | gc.TINT8,
gc.OINC<<16 | gc.TUINT8:
- a = i386.AINCB
+ a = x86.AINCB
case gc.OINC<<16 | gc.TINT16,
gc.OINC<<16 | gc.TUINT16:
- a = i386.AINCW
+ a = x86.AINCW
case gc.OINC<<16 | gc.TINT32,
gc.OINC<<16 | gc.TUINT32,
gc.OINC<<16 | gc.TPTR32:
- a = i386.AINCL
+ a = x86.AINCL
case gc.ODEC<<16 | gc.TINT8,
gc.ODEC<<16 | gc.TUINT8:
- a = i386.ADECB
+ a = x86.ADECB
case gc.ODEC<<16 | gc.TINT16,
gc.ODEC<<16 | gc.TUINT16:
- a = i386.ADECW
+ a = x86.ADECW
case gc.ODEC<<16 | gc.TINT32,
gc.ODEC<<16 | gc.TUINT32,
gc.ODEC<<16 | gc.TPTR32:
- a = i386.ADECL
+ a = x86.ADECL
case gc.OCOM<<16 | gc.TINT8,
gc.OCOM<<16 | gc.TUINT8:
- a = i386.ANOTB
+ a = x86.ANOTB
case gc.OCOM<<16 | gc.TINT16,
gc.OCOM<<16 | gc.TUINT16:
- a = i386.ANOTW
+ a = x86.ANOTW
case gc.OCOM<<16 | gc.TINT32,
gc.OCOM<<16 | gc.TUINT32,
gc.OCOM<<16 | gc.TPTR32:
- a = i386.ANOTL
+ a = x86.ANOTL
case gc.OMINUS<<16 | gc.TINT8,
gc.OMINUS<<16 | gc.TUINT8:
- a = i386.ANEGB
+ a = x86.ANEGB
case gc.OMINUS<<16 | gc.TINT16,
gc.OMINUS<<16 | gc.TUINT16:
- a = i386.ANEGW
+ a = x86.ANEGW
case gc.OMINUS<<16 | gc.TINT32,
gc.OMINUS<<16 | gc.TUINT32,
gc.OMINUS<<16 | gc.TPTR32:
- a = i386.ANEGL
+ a = x86.ANEGL
case gc.OAND<<16 | gc.TINT8,
gc.OAND<<16 | gc.TUINT8:
- a = i386.AANDB
+ a = x86.AANDB
case gc.OAND<<16 | gc.TINT16,
gc.OAND<<16 | gc.TUINT16:
- a = i386.AANDW
+ a = x86.AANDW
case gc.OAND<<16 | gc.TINT32,
gc.OAND<<16 | gc.TUINT32,
gc.OAND<<16 | gc.TPTR32:
- a = i386.AANDL
+ a = x86.AANDL
case gc.OOR<<16 | gc.TINT8,
gc.OOR<<16 | gc.TUINT8:
- a = i386.AORB
+ a = x86.AORB
case gc.OOR<<16 | gc.TINT16,
gc.OOR<<16 | gc.TUINT16:
- a = i386.AORW
+ a = x86.AORW
case gc.OOR<<16 | gc.TINT32,
gc.OOR<<16 | gc.TUINT32,
gc.OOR<<16 | gc.TPTR32:
- a = i386.AORL
+ a = x86.AORL
case gc.OXOR<<16 | gc.TINT8,
gc.OXOR<<16 | gc.TUINT8:
- a = i386.AXORB
+ a = x86.AXORB
case gc.OXOR<<16 | gc.TINT16,
gc.OXOR<<16 | gc.TUINT16:
- a = i386.AXORW
+ a = x86.AXORW
case gc.OXOR<<16 | gc.TINT32,
gc.OXOR<<16 | gc.TUINT32,
gc.OXOR<<16 | gc.TPTR32:
- a = i386.AXORL
+ a = x86.AXORL
case gc.OLROT<<16 | gc.TINT8,
gc.OLROT<<16 | gc.TUINT8:
- a = i386.AROLB
+ a = x86.AROLB
case gc.OLROT<<16 | gc.TINT16,
gc.OLROT<<16 | gc.TUINT16:
- a = i386.AROLW
+ a = x86.AROLW
case gc.OLROT<<16 | gc.TINT32,
gc.OLROT<<16 | gc.TUINT32,
gc.OLROT<<16 | gc.TPTR32:
- a = i386.AROLL
+ a = x86.AROLL
case gc.OLSH<<16 | gc.TINT8,
gc.OLSH<<16 | gc.TUINT8:
- a = i386.ASHLB
+ a = x86.ASHLB
case gc.OLSH<<16 | gc.TINT16,
gc.OLSH<<16 | gc.TUINT16:
- a = i386.ASHLW
+ a = x86.ASHLW
case gc.OLSH<<16 | gc.TINT32,
gc.OLSH<<16 | gc.TUINT32,
gc.OLSH<<16 | gc.TPTR32:
- a = i386.ASHLL
+ a = x86.ASHLL
case gc.ORSH<<16 | gc.TUINT8:
- a = i386.ASHRB
+ a = x86.ASHRB
case gc.ORSH<<16 | gc.TUINT16:
- a = i386.ASHRW
+ a = x86.ASHRW
case gc.ORSH<<16 | gc.TUINT32,
gc.ORSH<<16 | gc.TPTR32:
- a = i386.ASHRL
+ a = x86.ASHRL
case gc.ORSH<<16 | gc.TINT8:
- a = i386.ASARB
+ a = x86.ASARB
case gc.ORSH<<16 | gc.TINT16:
- a = i386.ASARW
+ a = x86.ASARW
case gc.ORSH<<16 | gc.TINT32:
- a = i386.ASARL
+ a = x86.ASARL
case gc.OHMUL<<16 | gc.TINT8,
gc.OMUL<<16 | gc.TINT8,
gc.OMUL<<16 | gc.TUINT8:
- a = i386.AIMULB
+ a = x86.AIMULB
case gc.OHMUL<<16 | gc.TINT16,
gc.OMUL<<16 | gc.TINT16,
gc.OMUL<<16 | gc.TUINT16:
- a = i386.AIMULW
+ a = x86.AIMULW
case gc.OHMUL<<16 | gc.TINT32,
gc.OMUL<<16 | gc.TINT32,
gc.OMUL<<16 | gc.TUINT32,
gc.OMUL<<16 | gc.TPTR32:
- a = i386.AIMULL
+ a = x86.AIMULL
case gc.OHMUL<<16 | gc.TUINT8:
- a = i386.AMULB
+ a = x86.AMULB
case gc.OHMUL<<16 | gc.TUINT16:
- a = i386.AMULW
+ a = x86.AMULW
case gc.OHMUL<<16 | gc.TUINT32,
gc.OHMUL<<16 | gc.TPTR32:
- a = i386.AMULL
+ a = x86.AMULL
case gc.ODIV<<16 | gc.TINT8,
gc.OMOD<<16 | gc.TINT8:
- a = i386.AIDIVB
+ a = x86.AIDIVB
case gc.ODIV<<16 | gc.TUINT8,
gc.OMOD<<16 | gc.TUINT8:
- a = i386.ADIVB
+ a = x86.ADIVB
case gc.ODIV<<16 | gc.TINT16,
gc.OMOD<<16 | gc.TINT16:
- a = i386.AIDIVW
+ a = x86.AIDIVW
case gc.ODIV<<16 | gc.TUINT16,
gc.OMOD<<16 | gc.TUINT16:
- a = i386.ADIVW
+ a = x86.ADIVW
case gc.ODIV<<16 | gc.TINT32,
gc.OMOD<<16 | gc.TINT32:
- a = i386.AIDIVL
+ a = x86.AIDIVL
case gc.ODIV<<16 | gc.TUINT32,
gc.ODIV<<16 | gc.TPTR32,
gc.OMOD<<16 | gc.TUINT32,
gc.OMOD<<16 | gc.TPTR32:
- a = i386.ADIVL
+ a = x86.ADIVL
case gc.OEXTEND<<16 | gc.TINT16:
- a = i386.ACWD
+ a = x86.ACWD
case gc.OEXTEND<<16 | gc.TINT32:
- a = i386.ACDQ
+ a = x86.ACDQ
}
return a
gc.Fatal("foptoas-sse: no entry %v-%v", gc.Oconv(int(op), 0), gc.Tconv(t, 0))
case gc.OCMP<<16 | gc.TFLOAT32:
- a = i386.AUCOMISS
+ a = x86.AUCOMISS
case gc.OCMP<<16 | gc.TFLOAT64:
- a = i386.AUCOMISD
+ a = x86.AUCOMISD
case gc.OAS<<16 | gc.TFLOAT32:
- a = i386.AMOVSS
+ a = x86.AMOVSS
case gc.OAS<<16 | gc.TFLOAT64:
- a = i386.AMOVSD
+ a = x86.AMOVSD
case gc.OADD<<16 | gc.TFLOAT32:
- a = i386.AADDSS
+ a = x86.AADDSS
case gc.OADD<<16 | gc.TFLOAT64:
- a = i386.AADDSD
+ a = x86.AADDSD
case gc.OSUB<<16 | gc.TFLOAT32:
- a = i386.ASUBSS
+ a = x86.ASUBSS
case gc.OSUB<<16 | gc.TFLOAT64:
- a = i386.ASUBSD
+ a = x86.ASUBSD
case gc.OMUL<<16 | gc.TFLOAT32:
- a = i386.AMULSS
+ a = x86.AMULSS
case gc.OMUL<<16 | gc.TFLOAT64:
- a = i386.AMULSD
+ a = x86.AMULSD
case gc.ODIV<<16 | gc.TFLOAT32:
- a = i386.ADIVSS
+ a = x86.ADIVSS
case gc.ODIV<<16 | gc.TFLOAT64:
- a = i386.ADIVSD
+ a = x86.ADIVSD
}
return a
switch uint32(op)<<16 | (uint32(et)<<8 | uint32(flg)) {
case gc.OADD<<16 | (gc.TFLOAT32<<8 | 0):
- return i386.AFADDF
+ return x86.AFADDF
case gc.OADD<<16 | (gc.TFLOAT64<<8 | 0):
- return i386.AFADDD
+ return x86.AFADDD
case gc.OADD<<16 | (gc.TFLOAT64<<8 | Fpop):
- return i386.AFADDDP
+ return x86.AFADDDP
case gc.OSUB<<16 | (gc.TFLOAT32<<8 | 0):
- return i386.AFSUBF
+ return x86.AFSUBF
case gc.OSUB<<16 | (gc.TFLOAT32<<8 | Frev):
- return i386.AFSUBRF
+ return x86.AFSUBRF
case gc.OSUB<<16 | (gc.TFLOAT64<<8 | 0):
- return i386.AFSUBD
+ return x86.AFSUBD
case gc.OSUB<<16 | (gc.TFLOAT64<<8 | Frev):
- return i386.AFSUBRD
+ return x86.AFSUBRD
case gc.OSUB<<16 | (gc.TFLOAT64<<8 | Fpop):
- return i386.AFSUBDP
+ return x86.AFSUBDP
case gc.OSUB<<16 | (gc.TFLOAT64<<8 | (Fpop | Frev)):
- return i386.AFSUBRDP
+ return x86.AFSUBRDP
case gc.OMUL<<16 | (gc.TFLOAT32<<8 | 0):
- return i386.AFMULF
+ return x86.AFMULF
case gc.OMUL<<16 | (gc.TFLOAT64<<8 | 0):
- return i386.AFMULD
+ return x86.AFMULD
case gc.OMUL<<16 | (gc.TFLOAT64<<8 | Fpop):
- return i386.AFMULDP
+ return x86.AFMULDP
case gc.ODIV<<16 | (gc.TFLOAT32<<8 | 0):
- return i386.AFDIVF
+ return x86.AFDIVF
case gc.ODIV<<16 | (gc.TFLOAT32<<8 | Frev):
- return i386.AFDIVRF
+ return x86.AFDIVRF
case gc.ODIV<<16 | (gc.TFLOAT64<<8 | 0):
- return i386.AFDIVD
+ return x86.AFDIVD
case gc.ODIV<<16 | (gc.TFLOAT64<<8 | Frev):
- return i386.AFDIVRD
+ return x86.AFDIVRD
case gc.ODIV<<16 | (gc.TFLOAT64<<8 | Fpop):
- return i386.AFDIVDP
+ return x86.AFDIVDP
case gc.ODIV<<16 | (gc.TFLOAT64<<8 | (Fpop | Frev)):
- return i386.AFDIVRDP
+ return x86.AFDIVRDP
case gc.OCMP<<16 | (gc.TFLOAT32<<8 | 0):
- return i386.AFCOMF
+ return x86.AFCOMF
case gc.OCMP<<16 | (gc.TFLOAT32<<8 | Fpop):
- return i386.AFCOMFP
+ return x86.AFCOMFP
case gc.OCMP<<16 | (gc.TFLOAT64<<8 | 0):
- return i386.AFCOMD
+ return x86.AFCOMD
case gc.OCMP<<16 | (gc.TFLOAT64<<8 | Fpop):
- return i386.AFCOMDP
+ return x86.AFCOMDP
case gc.OCMP<<16 | (gc.TFLOAT64<<8 | Fpop2):
- return i386.AFCOMDPP
+ return x86.AFCOMDPP
case gc.OMINUS<<16 | (gc.TFLOAT32<<8 | 0):
- return i386.AFCHS
+ return x86.AFCHS
case gc.OMINUS<<16 | (gc.TFLOAT64<<8 | 0):
- return i386.AFCHS
+ return x86.AFCHS
}
gc.Fatal("foptoas %v %v %#x", gc.Oconv(int(op), 0), gc.Tconv(t, 0), flg)
// REG_DI, // for movstring
// REG_SI, // for movstring
- i386.REG_AX, // for divide
- i386.REG_CX, // for shift
- i386.REG_DX, // for divide
- i386.REG_SP, // for stack
+ x86.REG_AX, // for divide
+ x86.REG_CX, // for shift
+ x86.REG_DX, // for divide
+ x86.REG_SP, // for stack
- i386.REG_BL, // because REG_BX can be allocated
- i386.REG_BH,
+ x86.REG_BL, // because REG_BX can be allocated
+ x86.REG_BH,
}
func ginit() {
for i := 0; i < len(reg); i++ {
reg[i] = 1
}
- for i := i386.REG_AX; i <= i386.REG_DI; i++ {
+ for i := x86.REG_AX; i <= x86.REG_DI; i++ {
reg[i] = 0
}
- for i := i386.REG_X0; i <= i386.REG_X7; i++ {
+ for i := x86.REG_X0; i <= x86.REG_X7; i++ {
reg[i] = 0
}
for i := 0; i < len(resvd); i++ {
}
}
-var regpc [i386.MAXREG]uint32
+var regpc [x86.MAXREG]uint32
func gclean() {
for i := 0; i < len(resvd); i++ {
reg[resvd[i]]--
}
- for i := i386.REG_AX; i <= i386.REG_DI; i++ {
+ for i := x86.REG_AX; i <= x86.REG_DI; i++ {
if reg[i] != 0 {
gc.Yyerror("reg %v left allocated at %x", obj.Rconv(i), regpc[i])
}
}
- for i := i386.REG_X0; i <= i386.REG_X7; i++ {
+ for i := x86.REG_X0; i <= x86.REG_X7; i++ {
if reg[i] != 0 {
gc.Yyerror("reg %v left allocated\n", obj.Rconv(i))
}
func anyregalloc() bool {
var j int
- for i := i386.REG_AX; i <= i386.REG_DI; i++ {
+ for i := x86.REG_AX; i <= x86.REG_DI; i++ {
if reg[i] == 0 {
goto ok
}
ok:
}
- for i := i386.REG_X0; i <= i386.REG_X7; i++ {
+ for i := x86.REG_X0; i <= x86.REG_X7; i++ {
if reg[i] != 0 {
return true
}
gc.TBOOL:
if o != nil && o.Op == gc.OREGISTER {
i = int(o.Val.U.Reg)
- if i >= i386.REG_AX && i <= i386.REG_DI {
+ if i >= x86.REG_AX && i <= x86.REG_DI {
goto out
}
}
- for i = i386.REG_AX; i <= i386.REG_DI; i++ {
+ for i = x86.REG_AX; i <= x86.REG_DI; i++ {
if reg[i] == 0 {
goto out
}
}
fmt.Printf("registers allocated at\n")
- for i := i386.REG_AX; i <= i386.REG_DI; i++ {
+ for i := x86.REG_AX; i <= x86.REG_DI; i++ {
fmt.Printf("\t%v\t%#x\n", obj.Rconv(i), regpc[i])
}
gc.Fatal("out of fixed registers")
case gc.TFLOAT32,
gc.TFLOAT64:
if gc.Use_sse == 0 {
- i = i386.REG_F0
+ i = x86.REG_F0
goto out
}
if o != nil && o.Op == gc.OREGISTER {
i = int(o.Val.U.Reg)
- if i >= i386.REG_X0 && i <= i386.REG_X7 {
+ if i >= x86.REG_X0 && i <= x86.REG_X7 {
goto out
}
}
- for i = i386.REG_X0; i <= i386.REG_X7; i++ {
+ for i = x86.REG_X0; i <= x86.REG_X7; i++ {
if reg[i] == 0 {
goto out
}
}
fmt.Printf("registers allocated at\n")
- for i := i386.REG_X0; i <= i386.REG_X7; i++ {
+ for i := x86.REG_X0; i <= x86.REG_X7; i++ {
fmt.Printf("\t%v\t%#x\n", obj.Rconv(i), regpc[i])
}
gc.Fatal("out of floating registers")
return
out:
- if i == i386.REG_SP {
+ if i == x86.REG_SP {
fmt.Printf("alloc SP\n")
}
if reg[i] == 0 {
regpc[i] = uint32(obj.Getcallerpc(&n))
- if i == i386.REG_AX || i == i386.REG_CX || i == i386.REG_DX || i == i386.REG_SP {
+ if i == x86.REG_AX || i == x86.REG_CX || i == x86.REG_DX || i == x86.REG_SP {
gc.Dump("regalloc-o", o)
gc.Fatal("regalloc %v", obj.Rconv(i))
}
gc.Fatal("regfree: not a register")
}
i := int(n.Val.U.Reg)
- if i == i386.REG_SP {
+ if i == x86.REG_SP {
return
}
if i < 0 || i >= len(reg) {
gc.Fatal("regfree: reg not allocated")
}
reg[i]--
- if reg[i] == 0 && (i == i386.REG_AX || i == i386.REG_CX || i == i386.REG_DX || i == i386.REG_SP) {
+ if reg[i] == 0 && (i == x86.REG_AX || i == x86.REG_CX || i == x86.REG_DX || i == x86.REG_SP) {
gc.Fatal("regfree %v", obj.Rconv(i))
}
}
gc.TINT8<<16 | gc.TUINT8,
gc.TUINT8<<16 | gc.TINT8,
gc.TUINT8<<16 | gc.TUINT8:
- a = i386.AMOVB
+ a = x86.AMOVB
case gc.TINT16<<16 | gc.TINT8, // truncate
gc.TUINT16<<16 | gc.TINT8,
gc.TUINT16<<16 | gc.TUINT8,
gc.TINT32<<16 | gc.TUINT8,
gc.TUINT32<<16 | gc.TUINT8:
- a = i386.AMOVB
+ a = x86.AMOVB
goto rsrc
split64(f, &flo, &fhi)
var r1 gc.Node
- gc.Nodreg(&r1, t.Type, i386.REG_AX)
+ gc.Nodreg(&r1, t.Type, x86.REG_AX)
gmove(&flo, &r1)
- gins(i386.AMOVB, &r1, t)
+ gins(x86.AMOVB, &r1, t)
splitclean()
return
gc.TINT16<<16 | gc.TUINT16,
gc.TUINT16<<16 | gc.TINT16,
gc.TUINT16<<16 | gc.TUINT16:
- a = i386.AMOVW
+ a = x86.AMOVW
case gc.TINT32<<16 | gc.TINT16, // truncate
gc.TUINT32<<16 | gc.TINT16,
gc.TINT32<<16 | gc.TUINT16,
gc.TUINT32<<16 | gc.TUINT16:
- a = i386.AMOVW
+ a = x86.AMOVW
goto rsrc
split64(f, &flo, &fhi)
var r1 gc.Node
- gc.Nodreg(&r1, t.Type, i386.REG_AX)
+ gc.Nodreg(&r1, t.Type, x86.REG_AX)
gmove(&flo, &r1)
- gins(i386.AMOVW, &r1, t)
+ gins(x86.AMOVW, &r1, t)
splitclean()
return
gc.TINT32<<16 | gc.TUINT32,
gc.TUINT32<<16 | gc.TINT32,
gc.TUINT32<<16 | gc.TUINT32:
- a = i386.AMOVL
+ a = x86.AMOVL
case gc.TINT64<<16 | gc.TINT32, // truncate
gc.TUINT64<<16 | gc.TINT32,
split64(f, &flo, &fhi)
var r1 gc.Node
- gc.Nodreg(&r1, t.Type, i386.REG_AX)
+ gc.Nodreg(&r1, t.Type, x86.REG_AX)
gmove(&flo, &r1)
- gins(i386.AMOVL, &r1, t)
+ gins(x86.AMOVL, &r1, t)
splitclean()
return
var thi gc.Node
split64(t, &tlo, &thi)
if f.Op == gc.OLITERAL {
- gins(i386.AMOVL, &flo, &tlo)
- gins(i386.AMOVL, &fhi, &thi)
+ gins(x86.AMOVL, &flo, &tlo)
+ gins(x86.AMOVL, &fhi, &thi)
} else {
var r1 gc.Node
- gc.Nodreg(&r1, gc.Types[gc.TUINT32], i386.REG_AX)
+ gc.Nodreg(&r1, gc.Types[gc.TUINT32], x86.REG_AX)
var r2 gc.Node
- gc.Nodreg(&r2, gc.Types[gc.TUINT32], i386.REG_DX)
- gins(i386.AMOVL, &flo, &r1)
- gins(i386.AMOVL, &fhi, &r2)
- gins(i386.AMOVL, &r1, &tlo)
- gins(i386.AMOVL, &r2, &thi)
+ gc.Nodreg(&r2, gc.Types[gc.TUINT32], x86.REG_DX)
+ gins(x86.AMOVL, &flo, &r1)
+ gins(x86.AMOVL, &fhi, &r2)
+ gins(x86.AMOVL, &r1, &tlo)
+ gins(x86.AMOVL, &r2, &thi)
}
splitclean()
*/
case gc.TINT8<<16 | gc.TINT16, // sign extend int8
gc.TINT8<<16 | gc.TUINT16:
- a = i386.AMOVBWSX
+ a = x86.AMOVBWSX
goto rdst
case gc.TINT8<<16 | gc.TINT32,
gc.TINT8<<16 | gc.TUINT32:
- a = i386.AMOVBLSX
+ a = x86.AMOVBLSX
goto rdst
case gc.TINT8<<16 | gc.TINT64, // convert via int32
case gc.TUINT8<<16 | gc.TINT16, // zero extend uint8
gc.TUINT8<<16 | gc.TUINT16:
- a = i386.AMOVBWZX
+ a = x86.AMOVBWZX
goto rdst
case gc.TUINT8<<16 | gc.TINT32,
gc.TUINT8<<16 | gc.TUINT32:
- a = i386.AMOVBLZX
+ a = x86.AMOVBLZX
goto rdst
case gc.TUINT8<<16 | gc.TINT64, // convert via uint32
case gc.TINT16<<16 | gc.TINT32, // sign extend int16
gc.TINT16<<16 | gc.TUINT32:
- a = i386.AMOVWLSX
+ a = x86.AMOVWLSX
goto rdst
case gc.TUINT16<<16 | gc.TINT32, // zero extend uint16
gc.TUINT16<<16 | gc.TUINT32:
- a = i386.AMOVWLZX
+ a = x86.AMOVWLZX
goto rdst
split64(t, &tlo, &thi)
var flo gc.Node
- gc.Nodreg(&flo, tlo.Type, i386.REG_AX)
+ gc.Nodreg(&flo, tlo.Type, x86.REG_AX)
var fhi gc.Node
- gc.Nodreg(&fhi, thi.Type, i386.REG_DX)
+ gc.Nodreg(&fhi, thi.Type, x86.REG_DX)
gmove(f, &flo)
- gins(i386.ACDQ, nil, nil)
- gins(i386.AMOVL, &flo, &tlo)
- gins(i386.AMOVL, &fhi, &thi)
+ gins(x86.ACDQ, nil, nil)
+ gins(x86.AMOVL, &flo, &tlo)
+ gins(x86.AMOVL, &fhi, &thi)
splitclean()
return
split64(t, &tlo, &thi)
gmove(f, &tlo)
- gins(i386.AMOVL, ncon(0), &thi)
+ gins(x86.AMOVL, ncon(0), &thi)
splitclean()
return
}
}
var r1 gc.Node
- gc.Nodreg(&r1, gc.Types[ft], i386.REG_F0)
+ gc.Nodreg(&r1, gc.Types[ft], x86.REG_F0)
if ft == gc.TFLOAT32 {
- gins(i386.AFMOVF, f, &r1)
+ gins(x86.AFMOVF, f, &r1)
} else {
- gins(i386.AFMOVD, f, &r1)
+ gins(x86.AFMOVD, f, &r1)
}
// set round to zero mode during conversion
var t2 gc.Node
memname(&t2, gc.Types[gc.TUINT16])
- gins(i386.AFSTCW, nil, &t1)
- gins(i386.AMOVW, ncon(0xf7f), &t2)
- gins(i386.AFLDCW, &t2, nil)
+ gins(x86.AFSTCW, nil, &t1)
+ gins(x86.AMOVW, ncon(0xf7f), &t2)
+ gins(x86.AFLDCW, &t2, nil)
if tt == gc.TINT16 {
- gins(i386.AFMOVWP, &r1, t)
+ gins(x86.AFMOVWP, &r1, t)
} else if tt == gc.TINT32 {
- gins(i386.AFMOVLP, &r1, t)
+ gins(x86.AFMOVLP, &r1, t)
} else {
- gins(i386.AFMOVVP, &r1, t)
+ gins(x86.AFMOVVP, &r1, t)
}
- gins(i386.AFLDCW, &t1, nil)
+ gins(x86.AFLDCW, &t1, nil)
return
case gc.TFLOAT32<<16 | gc.TUINT64,
bignodes()
var f0 gc.Node
- gc.Nodreg(&f0, gc.Types[ft], i386.REG_F0)
+ gc.Nodreg(&f0, gc.Types[ft], x86.REG_F0)
var f1 gc.Node
- gc.Nodreg(&f1, gc.Types[ft], i386.REG_F0+1)
+ gc.Nodreg(&f1, gc.Types[ft], x86.REG_F0+1)
var ax gc.Node
- gc.Nodreg(&ax, gc.Types[gc.TUINT16], i386.REG_AX)
+ gc.Nodreg(&ax, gc.Types[gc.TUINT16], x86.REG_AX)
if ft == gc.TFLOAT32 {
- gins(i386.AFMOVF, f, &f0)
+ gins(x86.AFMOVF, f, &f0)
} else {
- gins(i386.AFMOVD, f, &f0)
+ gins(x86.AFMOVD, f, &f0)
}
// if 0 > v { answer = 0 }
- gins(i386.AFMOVD, &zerof, &f0)
+ gins(x86.AFMOVD, &zerof, &f0)
- gins(i386.AFUCOMIP, &f0, &f1)
+ gins(x86.AFUCOMIP, &f0, &f1)
p1 := gc.Gbranch(optoas(gc.OGT, gc.Types[tt]), nil, 0)
// if 1<<64 <= v { answer = 0 too }
- gins(i386.AFMOVD, &two64f, &f0)
+ gins(x86.AFMOVD, &two64f, &f0)
- gins(i386.AFUCOMIP, &f0, &f1)
+ gins(x86.AFUCOMIP, &f0, &f1)
p2 := gc.Gbranch(optoas(gc.OGT, gc.Types[tt]), nil, 0)
gc.Patch(p1, gc.Pc)
- gins(i386.AFMOVVP, &f0, t) // don't care about t, but will pop the stack
+ gins(x86.AFMOVVP, &f0, t) // don't care about t, but will pop the stack
var thi gc.Node
var tlo gc.Node
split64(t, &tlo, &thi)
- gins(i386.AMOVL, ncon(0), &tlo)
- gins(i386.AMOVL, ncon(0), &thi)
+ gins(x86.AMOVL, ncon(0), &tlo)
+ gins(x86.AMOVL, ncon(0), &thi)
splitclean()
p1 = gc.Gbranch(obj.AJMP, nil, 0)
gc.Patch(p2, gc.Pc)
var t2 gc.Node
memname(&t2, gc.Types[gc.TUINT16])
- gins(i386.AFSTCW, nil, &t1)
- gins(i386.AMOVW, ncon(0xf7f), &t2)
- gins(i386.AFLDCW, &t2, nil)
+ gins(x86.AFSTCW, nil, &t1)
+ gins(x86.AMOVW, ncon(0xf7f), &t2)
+ gins(x86.AFLDCW, &t2, nil)
// actual work
- gins(i386.AFMOVD, &two63f, &f0)
+ gins(x86.AFMOVD, &two63f, &f0)
- gins(i386.AFUCOMIP, &f0, &f1)
+ gins(x86.AFUCOMIP, &f0, &f1)
p2 = gc.Gbranch(optoas(gc.OLE, gc.Types[tt]), nil, 0)
- gins(i386.AFMOVVP, &f0, t)
+ gins(x86.AFMOVVP, &f0, t)
p3 := gc.Gbranch(obj.AJMP, nil, 0)
gc.Patch(p2, gc.Pc)
- gins(i386.AFMOVD, &two63f, &f0)
- gins(i386.AFSUBDP, &f0, &f1)
- gins(i386.AFMOVVP, &f0, t)
+ gins(x86.AFMOVD, &two63f, &f0)
+ gins(x86.AFSUBDP, &f0, &f1)
+ gins(x86.AFMOVVP, &f0, t)
split64(t, &tlo, &thi)
- gins(i386.AXORL, ncon(0x80000000), &thi) // + 2^63
+ gins(x86.AXORL, ncon(0x80000000), &thi) // + 2^63
gc.Patch(p3, gc.Pc)
splitclean()
// restore rounding mode
- gins(i386.AFLDCW, &t1, nil)
+ gins(x86.AFLDCW, &t1, nil)
gc.Patch(p1, gc.Pc)
return
goto hardmem
}
var f0 gc.Node
- gc.Nodreg(&f0, t.Type, i386.REG_F0)
- gins(i386.AFMOVV, f, &f0)
+ gc.Nodreg(&f0, t.Type, x86.REG_F0)
+ gins(x86.AFMOVV, f, &f0)
if tt == gc.TFLOAT32 {
- gins(i386.AFMOVFP, &f0, t)
+ gins(x86.AFMOVFP, &f0, t)
} else {
- gins(i386.AFMOVDP, &f0, t)
+ gins(x86.AFMOVDP, &f0, t)
}
return
case gc.TUINT64<<16 | gc.TFLOAT32,
gc.TUINT64<<16 | gc.TFLOAT64:
var ax gc.Node
- gc.Nodreg(&ax, gc.Types[gc.TUINT32], i386.REG_AX)
+ gc.Nodreg(&ax, gc.Types[gc.TUINT32], x86.REG_AX)
var dx gc.Node
- gc.Nodreg(&dx, gc.Types[gc.TUINT32], i386.REG_DX)
+ gc.Nodreg(&dx, gc.Types[gc.TUINT32], x86.REG_DX)
var cx gc.Node
- gc.Nodreg(&cx, gc.Types[gc.TUINT32], i386.REG_CX)
+ gc.Nodreg(&cx, gc.Types[gc.TUINT32], x86.REG_CX)
var t1 gc.Node
gc.Tempname(&t1, f.Type)
var tlo gc.Node
var thi gc.Node
split64(&t1, &tlo, &thi)
gmove(f, &t1)
- gins(i386.ACMPL, &thi, ncon(0))
- p1 := gc.Gbranch(i386.AJLT, nil, 0)
+ gins(x86.ACMPL, &thi, ncon(0))
+ p1 := gc.Gbranch(x86.AJLT, nil, 0)
// native
var r1 gc.Node
- gc.Nodreg(&r1, gc.Types[tt], i386.REG_F0)
+ gc.Nodreg(&r1, gc.Types[tt], x86.REG_F0)
- gins(i386.AFMOVV, &t1, &r1)
+ gins(x86.AFMOVV, &t1, &r1)
if tt == gc.TFLOAT32 {
- gins(i386.AFMOVFP, &r1, t)
+ gins(x86.AFMOVFP, &r1, t)
} else {
- gins(i386.AFMOVDP, &r1, t)
+ gins(x86.AFMOVDP, &r1, t)
}
p2 := gc.Gbranch(obj.AJMP, nil, 0)
gmove(&tlo, &ax)
gmove(&thi, &dx)
- p1 = gins(i386.ASHRL, ncon(1), &ax)
- p1.From.Index = i386.REG_DX // double-width shift DX -> AX
+ p1 = gins(x86.ASHRL, ncon(1), &ax)
+ p1.From.Index = x86.REG_DX // double-width shift DX -> AX
p1.From.Scale = 0
- gins(i386.AMOVL, ncon(0), &cx)
- gins(i386.ASETCC, nil, &cx)
- gins(i386.AORL, &cx, &ax)
- gins(i386.ASHRL, ncon(1), &dx)
+ gins(x86.AMOVL, ncon(0), &cx)
+ gins(x86.ASETCC, nil, &cx)
+ gins(x86.AORL, &cx, &ax)
+ gins(x86.ASHRL, ncon(1), &dx)
gmove(&dx, &thi)
gmove(&ax, &tlo)
- gc.Nodreg(&r1, gc.Types[tt], i386.REG_F0)
+ gc.Nodreg(&r1, gc.Types[tt], x86.REG_F0)
var r2 gc.Node
- gc.Nodreg(&r2, gc.Types[tt], i386.REG_F0+1)
- gins(i386.AFMOVV, &t1, &r1)
- gins(i386.AFMOVD, &r1, &r1)
- gins(i386.AFADDDP, &r1, &r2)
+ gc.Nodreg(&r2, gc.Types[tt], x86.REG_F0+1)
+ gins(x86.AFMOVV, &t1, &r1)
+ gins(x86.AFMOVD, &r1, &r1)
+ gins(x86.AFADDDP, &r1, &r2)
if tt == gc.TFLOAT32 {
- gins(i386.AFMOVFP, &r1, t)
+ gins(x86.AFMOVFP, &r1, t)
} else {
- gins(i386.AFMOVDP, &r1, t)
+ gins(x86.AFMOVDP, &r1, t)
}
gc.Patch(p2, gc.Pc)
splitclean()
goto hardmem
}
var r1 gc.Node
- gc.Nodreg(&r1, gc.Types[ft], i386.REG_F0)
+ gc.Nodreg(&r1, gc.Types[ft], x86.REG_F0)
if f.Op != gc.OREGISTER {
if ft == gc.TFLOAT32 {
- gins(i386.AFMOVF, f, &r1)
+ gins(x86.AFMOVF, f, &r1)
} else {
- gins(i386.AFMOVD, f, &r1)
+ gins(x86.AFMOVD, f, &r1)
}
}
var t2 gc.Node
memname(&t2, gc.Types[gc.TUINT16])
- gins(i386.AFSTCW, nil, &t1)
- gins(i386.AMOVW, ncon(0xf7f), &t2)
- gins(i386.AFLDCW, &t2, nil)
+ gins(x86.AFSTCW, nil, &t1)
+ gins(x86.AMOVW, ncon(0xf7f), &t2)
+ gins(x86.AFLDCW, &t2, nil)
if tt == gc.TINT16 {
- gins(i386.AFMOVWP, &r1, t)
+ gins(x86.AFMOVWP, &r1, t)
} else if tt == gc.TINT32 {
- gins(i386.AFMOVLP, &r1, t)
+ gins(x86.AFMOVLP, &r1, t)
} else {
- gins(i386.AFMOVVP, &r1, t)
+ gins(x86.AFMOVVP, &r1, t)
}
- gins(i386.AFLDCW, &t1, nil)
+ gins(x86.AFLDCW, &t1, nil)
return
// convert via int32.
gc.Fatal("gmove %v", gc.Nconv(t, 0))
case gc.TINT8:
- gins(i386.ACMPL, &t1, ncon(-0x80&(1<<32-1)))
+ gins(x86.ACMPL, &t1, ncon(-0x80&(1<<32-1)))
p1 := gc.Gbranch(optoas(gc.OLT, gc.Types[gc.TINT32]), nil, -1)
- gins(i386.ACMPL, &t1, ncon(0x7f))
+ gins(x86.ACMPL, &t1, ncon(0x7f))
p2 := gc.Gbranch(optoas(gc.OGT, gc.Types[gc.TINT32]), nil, -1)
p3 := gc.Gbranch(obj.AJMP, nil, 0)
gc.Patch(p1, gc.Pc)
gmove(&t1, t)
case gc.TUINT8:
- gins(i386.ATESTL, ncon(0xffffff00), &t1)
- p1 := gc.Gbranch(i386.AJEQ, nil, +1)
- gins(i386.AMOVL, ncon(0), &t1)
+ gins(x86.ATESTL, ncon(0xffffff00), &t1)
+ p1 := gc.Gbranch(x86.AJEQ, nil, +1)
+ gins(x86.AMOVL, ncon(0), &t1)
gc.Patch(p1, gc.Pc)
gmove(&t1, t)
case gc.TUINT16:
- gins(i386.ATESTL, ncon(0xffff0000), &t1)
- p1 := gc.Gbranch(i386.AJEQ, nil, +1)
- gins(i386.AMOVL, ncon(0), &t1)
+ gins(x86.ATESTL, ncon(0xffff0000), &t1)
+ p1 := gc.Gbranch(x86.AJEQ, nil, +1)
+ gins(x86.AMOVL, ncon(0), &t1)
gc.Patch(p1, gc.Pc)
gmove(&t1, t)
}
switch ft {
case gc.TINT16:
- a = i386.AFMOVW
+ a = x86.AFMOVW
case gc.TINT32:
- a = i386.AFMOVL
+ a = x86.AFMOVL
default:
- a = i386.AFMOVV
+ a = x86.AFMOVV
}
// convert via int32 memory
goto hard
}
if f.Op == gc.OREGISTER && t.Op == gc.OREGISTER {
- if f.Val.U.Reg != i386.REG_F0 || t.Val.U.Reg != i386.REG_F0 {
+ if f.Val.U.Reg != x86.REG_F0 || t.Val.U.Reg != x86.REG_F0 {
goto fatal
}
return
}
- a = i386.AFMOVF
+ a = x86.AFMOVF
if ft == gc.TFLOAT64 {
- a = i386.AFMOVD
+ a = x86.AFMOVD
}
if gc.Ismem(t) {
- if f.Op != gc.OREGISTER || f.Val.U.Reg != i386.REG_F0 {
+ if f.Op != gc.OREGISTER || f.Val.U.Reg != x86.REG_F0 {
gc.Fatal("gmove %v", gc.Nconv(f, 0))
}
- a = i386.AFMOVFP
+ a = x86.AFMOVFP
if ft == gc.TFLOAT64 {
- a = i386.AFMOVDP
+ a = x86.AFMOVDP
}
}
goto hard
}
if f.Op == gc.OREGISTER && t.Op == gc.OREGISTER {
- if f.Val.U.Reg != i386.REG_F0 || t.Val.U.Reg != i386.REG_F0 {
+ if f.Val.U.Reg != x86.REG_F0 || t.Val.U.Reg != x86.REG_F0 {
goto fatal
}
return
}
if f.Op == gc.OREGISTER {
- gins(i386.AFMOVDP, f, t)
+ gins(x86.AFMOVDP, f, t)
} else {
- gins(i386.AFMOVF, f, t)
+ gins(x86.AFMOVF, f, t)
}
return
if f.Op == gc.OREGISTER && t.Op == gc.OREGISTER {
var r1 gc.Node
gc.Tempname(&r1, gc.Types[gc.TFLOAT32])
- gins(i386.AFMOVFP, f, &r1)
- gins(i386.AFMOVF, &r1, t)
+ gins(x86.AFMOVFP, f, &r1)
+ gins(x86.AFMOVF, &r1, t)
return
}
if f.Op == gc.OREGISTER {
- gins(i386.AFMOVFP, f, t)
+ gins(x86.AFMOVFP, f, t)
} else {
- gins(i386.AFMOVD, f, t)
+ gins(x86.AFMOVD, f, t)
}
return
}
goto hardmem
case gc.TFLOAT32<<16 | gc.TINT32:
- a = i386.ACVTTSS2SL
+ a = x86.ACVTTSS2SL
goto rdst
case gc.TFLOAT64<<16 | gc.TINT32:
- a = i386.ACVTTSD2SL
+ a = x86.ACVTTSD2SL
goto rdst
// convert via int32 memory
goto hardmem
case gc.TINT32<<16 | gc.TFLOAT32:
- a = i386.ACVTSL2SS
+ a = x86.ACVTSL2SS
goto rdst
case gc.TINT32<<16 | gc.TFLOAT64:
- a = i386.ACVTSL2SD
+ a = x86.ACVTSL2SD
goto rdst
/*
* float to float
*/
case gc.TFLOAT32<<16 | gc.TFLOAT32:
- a = i386.AMOVSS
+ a = x86.AMOVSS
case gc.TFLOAT64<<16 | gc.TFLOAT64:
- a = i386.AMOVSD
+ a = x86.AMOVSD
case gc.TFLOAT32<<16 | gc.TFLOAT64:
- a = i386.ACVTSS2SD
+ a = x86.ACVTSS2SD
goto rdst
case gc.TFLOAT64<<16 | gc.TFLOAT32:
- a = i386.ACVTSD2SS
+ a = x86.ACVTSD2SS
goto rdst
}
* as f, t
*/
func gins(as int, f *gc.Node, t *gc.Node) *obj.Prog {
- if as == i386.AFMOVF && f != nil && f.Op == gc.OREGISTER && t != nil && t.Op == gc.OREGISTER {
+ if as == x86.AFMOVF && f != nil && f.Op == gc.OREGISTER && t != nil && t.Op == gc.OREGISTER {
gc.Fatal("gins MOVF reg, reg")
}
- if as == i386.ACVTSD2SS && f != nil && f.Op == gc.OLITERAL {
+ if as == x86.ACVTSD2SS && f != nil && f.Op == gc.OLITERAL {
gc.Fatal("gins CVTSD2SS const")
}
- if as == i386.AMOVSD && t != nil && t.Op == gc.OREGISTER && t.Val.U.Reg == i386.REG_F0 {
+ if as == x86.AMOVSD && t != nil && t.Op == gc.OREGISTER && t.Val.U.Reg == x86.REG_F0 {
gc.Fatal("gins MOVSD into F0")
}
switch as {
- case i386.AMOVB,
- i386.AMOVW,
- i386.AMOVL:
+ case x86.AMOVB,
+ x86.AMOVW,
+ x86.AMOVL:
if f != nil && t != nil && samaddr(f, t) {
return nil
}
- case i386.ALEAL:
+ case x86.ALEAL:
if f != nil && gc.Isconst(f, gc.CTNIL) {
gc.Fatal("gins LEAL nil %v", gc.Tconv(f.Type, 0))
}
w := 0
switch as {
- case i386.AMOVB:
+ case x86.AMOVB:
w = 1
- case i386.AMOVW:
+ case x86.AMOVW:
w = 2
- case i386.AMOVL:
+ case x86.AMOVL:
w = 4
}
import (
"cmd/internal/gc"
"cmd/internal/obj"
- i386 "cmd/internal/obj/x86"
+ "cmd/internal/obj/x86"
"fmt"
)
const (
REGEXT = 0
- exregoffset = i386.REG_DI
+ exregoffset = x86.REG_DI
)
var gactive uint32
for r := g.Start; r != nil; r = r.Link {
p = r.Prog
switch p.As {
- case i386.ALEAL:
+ case x86.ALEAL:
if regtyp(&p.To) {
if p.From.Sym != nil {
- if p.From.Index == i386.REG_NONE {
+ if p.From.Index == x86.REG_NONE {
conprop(r)
}
}
}
- case i386.AMOVB,
- i386.AMOVW,
- i386.AMOVL,
- i386.AMOVSS,
- i386.AMOVSD:
+ case x86.AMOVB,
+ x86.AMOVW,
+ x86.AMOVL,
+ x86.AMOVSS,
+ x86.AMOVSD:
if regtyp(&p.To) {
if p.From.Type == obj.TYPE_CONST || p.From.Type == obj.TYPE_FCONST {
conprop(r)
for r = g.Start; r != nil; r = r.Link {
p = r.Prog
switch p.As {
- case i386.AMOVL,
- i386.AMOVSS,
- i386.AMOVSD:
+ case x86.AMOVL,
+ x86.AMOVSS,
+ x86.AMOVSD:
if regtyp(&p.To) {
if regtyp(&p.From) {
if copyprop(g, r) {
}
}
- case i386.AMOVBLZX,
- i386.AMOVWLZX,
- i386.AMOVBLSX,
- i386.AMOVWLSX:
+ case x86.AMOVBLZX,
+ x86.AMOVWLZX,
+ x86.AMOVBLSX,
+ x86.AMOVWLSX:
if regtyp(&p.To) {
r1 = rnops(gc.Uniqs(r))
if r1 != nil {
p1 = r1.Prog
if p.As == p1.As && p.To.Type == p1.From.Type && p.To.Reg == p1.From.Reg {
- p1.As = i386.AMOVL
+ p1.As = x86.AMOVL
t++
}
}
}
- case i386.AADDL,
- i386.AADDW:
+ case x86.AADDL,
+ x86.AADDW:
if p.From.Type != obj.TYPE_CONST || needc(p.Link) {
break
}
if p.From.Offset == -1 {
- if p.As == i386.AADDL {
- p.As = i386.ADECL
+ if p.As == x86.AADDL {
+ p.As = x86.ADECL
} else {
- p.As = i386.ADECW
+ p.As = x86.ADECW
}
p.From = obj.Addr{}
break
}
if p.From.Offset == 1 {
- if p.As == i386.AADDL {
- p.As = i386.AINCL
+ if p.As == x86.AADDL {
+ p.As = x86.AINCL
} else {
- p.As = i386.AINCW
+ p.As = x86.AINCW
}
p.From = obj.Addr{}
break
}
- case i386.ASUBL,
- i386.ASUBW:
+ case x86.ASUBL,
+ x86.ASUBW:
if p.From.Type != obj.TYPE_CONST || needc(p.Link) {
break
}
if p.From.Offset == -1 {
- if p.As == i386.ASUBL {
- p.As = i386.AINCL
+ if p.As == x86.ASUBL {
+ p.As = x86.AINCL
} else {
- p.As = i386.AINCW
+ p.As = x86.AINCW
}
p.From = obj.Addr{}
break
}
if p.From.Offset == 1 {
- if p.As == i386.ASUBL {
- p.As = i386.ADECL
+ if p.As == x86.ASUBL {
+ p.As = x86.ADECL
} else {
- p.As = i386.ADECW
+ p.As = x86.ADECW
}
p.From = obj.Addr{}
break
// the processor can do better if we do moves using both.
for r := g.Start; r != nil; r = r.Link {
p = r.Prog
- if p.As == i386.AMOVSD {
+ if p.As == x86.AMOVSD {
if regtyp(&p.From) {
if regtyp(&p.To) {
- p.As = i386.AMOVAPD
+ p.As = x86.AMOVAPD
}
}
}
}
func regtyp(a *obj.Addr) bool {
- return a.Type == obj.TYPE_REG && (i386.REG_AX <= a.Reg && a.Reg <= i386.REG_DI || i386.REG_X0 <= a.Reg && a.Reg <= i386.REG_X7)
+ return a.Type == obj.TYPE_REG && (x86.REG_AX <= a.Reg && a.Reg <= x86.REG_DI || x86.REG_X0 <= a.Reg && a.Reg <= x86.REG_X7)
}
// movb elimination.
p = r.Prog
if regtyp(&p.To) {
switch p.As {
- case i386.AINCB,
- i386.AINCW:
- p.As = i386.AINCL
+ case x86.AINCB,
+ x86.AINCW:
+ p.As = x86.AINCL
- case i386.ADECB,
- i386.ADECW:
- p.As = i386.ADECL
+ case x86.ADECB,
+ x86.ADECW:
+ p.As = x86.ADECL
- case i386.ANEGB,
- i386.ANEGW:
- p.As = i386.ANEGL
+ case x86.ANEGB,
+ x86.ANEGW:
+ p.As = x86.ANEGL
- case i386.ANOTB,
- i386.ANOTW:
- p.As = i386.ANOTL
+ case x86.ANOTB,
+ x86.ANOTW:
+ p.As = x86.ANOTL
}
if regtyp(&p.From) || p.From.Type == obj.TYPE_CONST {
// we don't switch to 32-bit arithmetic if it can
// change how the carry bit is set (and the carry bit is needed).
switch p.As {
- case i386.AMOVB,
- i386.AMOVW:
- p.As = i386.AMOVL
+ case x86.AMOVB,
+ x86.AMOVW:
+ p.As = x86.AMOVL
- case i386.AADDB,
- i386.AADDW:
+ case x86.AADDB,
+ x86.AADDW:
if !needc(p.Link) {
- p.As = i386.AADDL
+ p.As = x86.AADDL
}
- case i386.ASUBB,
- i386.ASUBW:
+ case x86.ASUBB,
+ x86.ASUBW:
if !needc(p.Link) {
- p.As = i386.ASUBL
+ p.As = x86.ASUBL
}
- case i386.AMULB,
- i386.AMULW:
- p.As = i386.AMULL
+ case x86.AMULB,
+ x86.AMULW:
+ p.As = x86.AMULL
- case i386.AIMULB,
- i386.AIMULW:
- p.As = i386.AIMULL
+ case x86.AIMULB,
+ x86.AIMULW:
+ p.As = x86.AIMULL
- case i386.AANDB,
- i386.AANDW:
- p.As = i386.AANDL
+ case x86.AANDB,
+ x86.AANDW:
+ p.As = x86.AANDL
- case i386.AORB,
- i386.AORW:
- p.As = i386.AORL
+ case x86.AORB,
+ x86.AORW:
+ p.As = x86.AORL
- case i386.AXORB,
- i386.AXORW:
- p.As = i386.AXORL
+ case x86.AXORB,
+ x86.AXORW:
+ p.As = x86.AXORL
- case i386.ASHLB,
- i386.ASHLW:
- p.As = i386.ASHLL
+ case x86.ASHLB,
+ x86.ASHLW:
+ p.As = x86.ASHLL
}
} else {
// explicit zero extension
switch p.As {
- case i386.AMOVB:
- p.As = i386.AMOVBLZX
+ case x86.AMOVB:
+ p.As = x86.AMOVBLZX
- case i386.AMOVW:
- p.As = i386.AMOVWLZX
+ case x86.AMOVW:
+ p.As = x86.AMOVWLZX
}
}
}
if REGEXT != 0 /*TypeKind(100016)*/ && v.Type == obj.TYPE_REG && v.Reg <= REGEXT && v.Reg > exregoffset {
return 2
}
- if i386.REGARG >= 0 && v.Type == obj.TYPE_REG && v.Reg == i386.REGARG {
+ if x86.REGARG >= 0 && v.Type == obj.TYPE_REG && v.Reg == x86.REGARG {
return 2
}
if v.Type == p.From.Type && v.Reg == p.From.Reg {
return 3
case obj.ATEXT:
- if i386.REGARG >= 0 && v.Type == obj.TYPE_REG && v.Reg == i386.REGARG {
+ if x86.REGARG >= 0 && v.Type == obj.TYPE_REG && v.Reg == x86.REGARG {
return 3
}
return 0
* semantics
*/
func copyas(a *obj.Addr, v *obj.Addr) bool {
- if i386.REG_AL <= a.Reg && a.Reg <= i386.REG_BL {
+ if x86.REG_AL <= a.Reg && a.Reg <= x86.REG_BL {
gc.Fatal("use of byte register")
}
- if i386.REG_AL <= v.Reg && v.Reg <= i386.REG_BL {
+ if x86.REG_AL <= v.Reg && v.Reg <= x86.REG_BL {
gc.Fatal("use of byte register")
}
func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f int) int {
if copyas(a, v) {
reg := int(s.Reg)
- if reg >= i386.REG_AX && reg <= i386.REG_DI || reg >= i386.REG_X0 && reg <= i386.REG_X7 {
+ if reg >= x86.REG_AX && reg <= x86.REG_DI || reg >= x86.REG_X0 && reg <= x86.REG_X7 {
if f != 0 {
a.Reg = int16(reg)
}
if regtyp(v) {
reg := int(v.Reg)
if a.Type == obj.TYPE_MEM && int(a.Reg) == reg {
- if (s.Reg == i386.REG_BP) && a.Index != obj.TYPE_NONE {
+ if (s.Reg == x86.REG_BP) && a.Index != obj.TYPE_NONE {
return 1 /* can't use BP-base with index */
}
if f != 0 {
}
func smallindir(a *obj.Addr, reg *obj.Addr) bool {
- return regtyp(reg) && a.Type == obj.TYPE_MEM && a.Reg == reg.Reg && a.Index == i386.REG_NONE && 0 <= a.Offset && a.Offset < 4096
+ return regtyp(reg) && a.Type == obj.TYPE_MEM && a.Reg == reg.Reg && a.Index == x86.REG_NONE && 0 <= a.Offset && a.Offset < 4096
}
func stackaddr(a *obj.Addr) bool {
- return a.Type == obj.TYPE_REG && a.Reg == i386.REG_SP
+ return a.Type == obj.TYPE_REG && a.Reg == x86.REG_SP
}
import (
"cmd/internal/gc"
"cmd/internal/obj"
- i386 "cmd/internal/obj/x86"
+ "cmd/internal/obj/x86"
)
var (
- AX = RtoB(i386.REG_AX)
- BX = RtoB(i386.REG_BX)
- CX = RtoB(i386.REG_CX)
- DX = RtoB(i386.REG_DX)
- DI = RtoB(i386.REG_DI)
- SI = RtoB(i386.REG_SI)
+ AX = RtoB(x86.REG_AX)
+ BX = RtoB(x86.REG_BX)
+ CX = RtoB(x86.REG_CX)
+ DX = RtoB(x86.REG_DX)
+ DI = RtoB(x86.REG_DI)
+ SI = RtoB(x86.REG_SI)
LeftRdwr uint32 = gc.LeftRead | gc.LeftWrite
RightRdwr uint32 = gc.RightRead | gc.RightWrite
)
// size variants of an operation even if we just use a subset.
//
// The table is formatted for 8-space tabs.
-var progtable = [i386.ALAST]gc.ProgInfo{
+var progtable = [x86.ALAST]gc.ProgInfo{
obj.ATYPE: gc.ProgInfo{gc.Pseudo | gc.Skip, 0, 0, 0},
obj.ATEXT: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
obj.AFUNCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0},
// NOP is an internal no-op that also stands
// for USED and SET annotations, not the Intel opcode.
- obj.ANOP: gc.ProgInfo{gc.LeftRead | gc.RightWrite, 0, 0, 0},
- i386.AADCL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
- i386.AADCW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
- i386.AADDB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.AADDL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.AADDW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.AADDSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
- i386.AADDSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
- i386.AANDB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.AANDL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.AANDW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- obj.ACALL: gc.ProgInfo{gc.RightAddr | gc.Call | gc.KillCarry, 0, 0, 0},
- i386.ACDQ: gc.ProgInfo{gc.OK, AX, AX | DX, 0},
- i386.ACWD: gc.ProgInfo{gc.OK, AX, AX | DX, 0},
- i386.ACLD: gc.ProgInfo{gc.OK, 0, 0, 0},
- i386.ASTD: gc.ProgInfo{gc.OK, 0, 0, 0},
- i386.ACMPB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
- i386.ACMPL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
- i386.ACMPW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
- i386.ACOMISD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
- i386.ACOMISS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
- i386.ACVTSD2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.ACVTSD2SS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.ACVTSL2SD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.ACVTSL2SS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.ACVTSS2SD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.ACVTSS2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.ACVTTSD2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.ACVTTSS2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.ADECB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
- i386.ADECL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
- i386.ADECW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
- i386.ADIVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
- i386.ADIVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
- i386.ADIVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
- i386.ADIVSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
- i386.ADIVSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
- i386.AFLDCW: gc.ProgInfo{gc.SizeW | gc.LeftAddr, 0, 0, 0},
- i386.AFSTCW: gc.ProgInfo{gc.SizeW | gc.RightAddr, 0, 0, 0},
- i386.AFSTSW: gc.ProgInfo{gc.SizeW | gc.RightAddr | gc.RightWrite, 0, 0, 0},
- i386.AFADDD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFADDDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFADDF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFCOMD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightRead, 0, 0, 0},
- i386.AFCOMDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightRead, 0, 0, 0},
- i386.AFCOMDPP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightRead, 0, 0, 0},
- i386.AFCOMF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightRead, 0, 0, 0},
- i386.AFCOMFP: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightRead, 0, 0, 0},
- i386.AFUCOMIP: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightRead, 0, 0, 0},
- i386.AFCHS: gc.ProgInfo{gc.SizeD | RightRdwr, 0, 0, 0}, // also SizeF
+ obj.ANOP: gc.ProgInfo{gc.LeftRead | gc.RightWrite, 0, 0, 0},
+ x86.AADCL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.AADCW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.AADDB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AADDL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AADDW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AADDSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.AADDSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.AANDB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AANDL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AANDW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ obj.ACALL: gc.ProgInfo{gc.RightAddr | gc.Call | gc.KillCarry, 0, 0, 0},
+ x86.ACDQ: gc.ProgInfo{gc.OK, AX, AX | DX, 0},
+ x86.ACWD: gc.ProgInfo{gc.OK, AX, AX | DX, 0},
+ x86.ACLD: gc.ProgInfo{gc.OK, 0, 0, 0},
+ x86.ASTD: gc.ProgInfo{gc.OK, 0, 0, 0},
+ x86.ACMPB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ACMPL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ACMPW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ACOMISD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ACOMISS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ACVTSD2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSD2SS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSL2SD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSL2SS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSS2SD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTSS2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTTSD2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ACVTTSS2SL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.ADECB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
+ x86.ADECL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
+ x86.ADECW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
+ x86.ADIVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ x86.ADIVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ x86.ADIVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ x86.ADIVSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.ADIVSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.AFLDCW: gc.ProgInfo{gc.SizeW | gc.LeftAddr, 0, 0, 0},
+ x86.AFSTCW: gc.ProgInfo{gc.SizeW | gc.RightAddr, 0, 0, 0},
+ x86.AFSTSW: gc.ProgInfo{gc.SizeW | gc.RightAddr | gc.RightWrite, 0, 0, 0},
+ x86.AFADDD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFADDDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFADDF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFCOMD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ x86.AFCOMDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ x86.AFCOMDPP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ x86.AFCOMF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ x86.AFCOMFP: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ x86.AFUCOMIP: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightRead, 0, 0, 0},
+ x86.AFCHS: gc.ProgInfo{gc.SizeD | RightRdwr, 0, 0, 0}, // also SizeF
- i386.AFDIVDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFDIVF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFDIVD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFDIVRDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFDIVRF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFDIVRD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFXCHD: gc.ProgInfo{gc.SizeD | LeftRdwr | RightRdwr, 0, 0, 0},
- i386.AFSUBD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFSUBDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFSUBF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFSUBRD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFSUBRDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFSUBRF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFMOVD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
- i386.AFMOVF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
- i386.AFMOVL: gc.ProgInfo{gc.SizeL | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
- i386.AFMOVW: gc.ProgInfo{gc.SizeW | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
- i386.AFMOVV: gc.ProgInfo{gc.SizeQ | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ x86.AFDIVDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFDIVF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFDIVD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFDIVRDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFDIVRF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFDIVRD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFXCHD: gc.ProgInfo{gc.SizeD | LeftRdwr | RightRdwr, 0, 0, 0},
+ x86.AFSUBD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFSUBDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFSUBF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFSUBRD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFSUBRDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFSUBRF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFMOVD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ x86.AFMOVF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ x86.AFMOVL: gc.ProgInfo{gc.SizeL | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ x86.AFMOVW: gc.ProgInfo{gc.SizeW | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ x86.AFMOVV: gc.ProgInfo{gc.SizeQ | gc.LeftAddr | gc.RightWrite, 0, 0, 0},
// These instructions are marked as RightAddr
// so that the register optimizer does not try to replace the
// memory references with integer register references.
// But they do not use the previous value at the address, so
// we also mark them RightWrite.
- i386.AFMOVDP: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
- i386.AFMOVFP: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
- i386.AFMOVLP: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
- i386.AFMOVWP: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
- i386.AFMOVVP: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
- i386.AFMULD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFMULDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AFMULF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
- i386.AIDIVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
- i386.AIDIVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
- i386.AIDIVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
- i386.AIMULB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
- i386.AIMULL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.ImulAXDX | gc.SetCarry, 0, 0, 0},
- i386.AIMULW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.ImulAXDX | gc.SetCarry, 0, 0, 0},
- i386.AINCB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
- i386.AINCL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
- i386.AINCW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
- i386.AJCC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJCS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJEQ: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJGE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJGT: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJHI: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJLE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJLS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJLT: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJMI: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJNE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJOC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJOS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJPC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJPL: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
- i386.AJPS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AFMOVDP: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
+ x86.AFMOVFP: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
+ x86.AFMOVLP: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
+ x86.AFMOVWP: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
+ x86.AFMOVVP: gc.ProgInfo{gc.SizeQ | gc.LeftRead | gc.RightWrite | gc.RightAddr, 0, 0, 0},
+ x86.AFMULD: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFMULDP: gc.ProgInfo{gc.SizeD | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AFMULF: gc.ProgInfo{gc.SizeF | gc.LeftAddr | RightRdwr, 0, 0, 0},
+ x86.AIDIVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ x86.AIDIVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ x86.AIDIVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX | DX, AX | DX, 0},
+ x86.AIMULB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ x86.AIMULL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.ImulAXDX | gc.SetCarry, 0, 0, 0},
+ x86.AIMULW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.ImulAXDX | gc.SetCarry, 0, 0, 0},
+ x86.AINCB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
+ x86.AINCL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
+ x86.AINCW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
+ x86.AJCC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJCS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJEQ: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJGE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJGT: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJHI: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJLE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJLS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJLT: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJMI: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJNE: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJOC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJOS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJPC: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJPL: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
+ x86.AJPS: gc.ProgInfo{gc.Cjmp | gc.UseCarry, 0, 0, 0},
obj.AJMP: gc.ProgInfo{gc.Jump | gc.Break | gc.KillCarry, 0, 0, 0},
- i386.ALEAL: gc.ProgInfo{gc.LeftAddr | gc.RightWrite, 0, 0, 0},
- i386.AMOVBLSX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.AMOVBLZX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.AMOVBWSX: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.AMOVBWZX: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.AMOVWLSX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.AMOVWLZX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
- i386.AMOVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
- i386.AMOVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
- i386.AMOVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
- i386.AMOVSB: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
- i386.AMOVSL: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
- i386.AMOVSW: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
+ x86.ALEAL: gc.ProgInfo{gc.LeftAddr | gc.RightWrite, 0, 0, 0},
+ x86.AMOVBLSX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVBLZX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVBWSX: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVBWZX: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVWLSX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVWLZX: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0},
+ x86.AMOVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMOVL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMOVW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMOVSB: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
+ x86.AMOVSL: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
+ x86.AMOVSW: gc.ProgInfo{gc.OK, DI | SI, DI | SI, 0},
obj.ADUFFCOPY: gc.ProgInfo{gc.OK, DI | SI, DI | SI | CX, 0},
- i386.AMOVSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
- i386.AMOVSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMOVSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMOVSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
// We use MOVAPD as a faster synonym for MOVSD.
- i386.AMOVAPD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
- i386.AMULB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
- i386.AMULL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX, AX | DX, 0},
- i386.AMULW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX, AX | DX, 0},
- i386.AMULSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
- i386.AMULSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
- i386.ANEGB: gc.ProgInfo{gc.SizeB | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.ANEGL: gc.ProgInfo{gc.SizeL | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.ANEGW: gc.ProgInfo{gc.SizeW | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.ANOTB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
- i386.ANOTL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
- i386.ANOTW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
- i386.AORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.AORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.AORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.APOPL: gc.ProgInfo{gc.SizeL | gc.RightWrite, 0, 0, 0},
- i386.APUSHL: gc.ProgInfo{gc.SizeL | gc.LeftRead, 0, 0, 0},
- i386.ARCLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
- i386.ARCLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
- i386.ARCLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
- i386.ARCRB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
- i386.ARCRL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
- i386.ARCRW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
- i386.AREP: gc.ProgInfo{gc.OK, CX, CX, 0},
- i386.AREPN: gc.ProgInfo{gc.OK, CX, CX, 0},
+ x86.AMOVAPD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0},
+ x86.AMULB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.SetCarry, AX, AX, 0},
+ x86.AMULL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.SetCarry, AX, AX | DX, 0},
+ x86.AMULW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.SetCarry, AX, AX | DX, 0},
+ x86.AMULSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.AMULSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.ANEGB: gc.ProgInfo{gc.SizeB | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ANEGL: gc.ProgInfo{gc.SizeL | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ANEGW: gc.ProgInfo{gc.SizeW | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ANOTB: gc.ProgInfo{gc.SizeB | RightRdwr, 0, 0, 0},
+ x86.ANOTL: gc.ProgInfo{gc.SizeL | RightRdwr, 0, 0, 0},
+ x86.ANOTW: gc.ProgInfo{gc.SizeW | RightRdwr, 0, 0, 0},
+ x86.AORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.APOPL: gc.ProgInfo{gc.SizeL | gc.RightWrite, 0, 0, 0},
+ x86.APUSHL: gc.ProgInfo{gc.SizeL | gc.LeftRead, 0, 0, 0},
+ x86.ARCLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCRB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCRL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ARCRW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.AREP: gc.ProgInfo{gc.OK, CX, CX, 0},
+ x86.AREPN: gc.ProgInfo{gc.OK, CX, CX, 0},
obj.ARET: gc.ProgInfo{gc.Break | gc.KillCarry, 0, 0, 0},
- i386.AROLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.AROLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.AROLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ARORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ARORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ARORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASAHF: gc.ProgInfo{gc.OK, AX, AX, 0},
- i386.ASALB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASALL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASALW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASARB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASARL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASARW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASBBB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
- i386.ASBBL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
- i386.ASBBW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
- i386.ASETCC: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETCS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETEQ: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETGE: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETGT: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETHI: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETLE: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETLS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETLT: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETMI: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETNE: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETOC: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETOS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETPC: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETPL: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASETPS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
- i386.ASHLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASHLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASHLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASHRB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASHRL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASHRW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
- i386.ASTOSB: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
- i386.ASTOSL: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
- i386.ASTOSW: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ x86.AROLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.AROLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.AROLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ARORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ARORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ARORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASAHF: gc.ProgInfo{gc.OK, AX, AX, 0},
+ x86.ASALB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASALL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASALW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASARB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASARL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASARW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASBBB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ASBBL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ASBBW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry | gc.UseCarry, 0, 0, 0},
+ x86.ASETCC: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETCS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETEQ: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETGE: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETGT: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETHI: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETLE: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETLS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETLT: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETMI: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETNE: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETOC: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETOS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETPC: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETPL: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASETPS: gc.ProgInfo{gc.SizeB | RightRdwr | gc.UseCarry, 0, 0, 0},
+ x86.ASHLB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHLW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHRB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHRL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASHRW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.ShiftCX | gc.SetCarry, 0, 0, 0},
+ x86.ASTOSB: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ x86.ASTOSL: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
+ x86.ASTOSW: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
obj.ADUFFZERO: gc.ProgInfo{gc.OK, AX | DI, DI, 0},
- i386.ASUBB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.ASUBL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.ASUBW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.ASUBSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
- i386.ASUBSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
- i386.ATESTB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
- i386.ATESTL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
- i386.ATESTW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
- i386.AUCOMISD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead, 0, 0, 0},
- i386.AUCOMISS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightRead, 0, 0, 0},
- i386.AXCHGB: gc.ProgInfo{gc.SizeB | LeftRdwr | RightRdwr, 0, 0, 0},
- i386.AXCHGL: gc.ProgInfo{gc.SizeL | LeftRdwr | RightRdwr, 0, 0, 0},
- i386.AXCHGW: gc.ProgInfo{gc.SizeW | LeftRdwr | RightRdwr, 0, 0, 0},
- i386.AXORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.AXORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
- i386.AXORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ASUBB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ASUBL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ASUBW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.ASUBSD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.ASUBSS: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0},
+ x86.ATESTB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ATESTL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.ATESTW: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightRead | gc.SetCarry, 0, 0, 0},
+ x86.AUCOMISD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ x86.AUCOMISS: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightRead, 0, 0, 0},
+ x86.AXCHGB: gc.ProgInfo{gc.SizeB | LeftRdwr | RightRdwr, 0, 0, 0},
+ x86.AXCHGL: gc.ProgInfo{gc.SizeL | LeftRdwr | RightRdwr, 0, 0, 0},
+ x86.AXCHGW: gc.ProgInfo{gc.SizeW | LeftRdwr | RightRdwr, 0, 0, 0},
+ x86.AXORB: gc.ProgInfo{gc.SizeB | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AXORL: gc.ProgInfo{gc.SizeL | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
+ x86.AXORW: gc.ProgInfo{gc.SizeW | gc.LeftRead | RightRdwr | gc.SetCarry, 0, 0, 0},
}
func proginfo(p *obj.Prog) (info gc.ProgInfo) {
if p.From.Type == obj.TYPE_MEM && p.From.Name == obj.NAME_NONE {
info.Regindex |= RtoB(int(p.From.Reg))
}
- if p.From.Index != i386.REG_NONE {
+ if p.From.Index != x86.REG_NONE {
info.Regindex |= RtoB(int(p.From.Index))
}
if p.To.Type == obj.TYPE_MEM && p.To.Name == obj.NAME_NONE {
info.Regindex |= RtoB(int(p.To.Reg))
}
- if p.To.Index != i386.REG_NONE {
+ if p.To.Index != x86.REG_NONE {
info.Regindex |= RtoB(int(p.To.Index))
}
package main
-import i386 "cmd/internal/obj/x86"
+import "cmd/internal/obj/x86"
import "cmd/internal/gc"
const (
}
func excludedregs() uint64 {
- return RtoB(i386.REG_SP)
+ return RtoB(x86.REG_SP)
}
func doregbits(r int) uint64 {
b := uint64(0)
- if r >= i386.REG_AX && r <= i386.REG_DI {
+ if r >= x86.REG_AX && r <= x86.REG_DI {
b |= RtoB(r)
- } else if r >= i386.REG_AL && r <= i386.REG_BL {
- b |= RtoB(r - i386.REG_AL + i386.REG_AX)
- } else if r >= i386.REG_AH && r <= i386.REG_BH {
- b |= RtoB(r - i386.REG_AH + i386.REG_AX)
- } else if r >= i386.REG_X0 && r <= i386.REG_X0+7 {
+ } else if r >= x86.REG_AL && r <= x86.REG_BL {
+ b |= RtoB(r - x86.REG_AL + x86.REG_AX)
+ } else if r >= x86.REG_AH && r <= x86.REG_BH {
+ b |= RtoB(r - x86.REG_AH + x86.REG_AX)
+ } else if r >= x86.REG_X0 && r <= x86.REG_X0+7 {
b |= FtoB(r)
}
return b
}
func RtoB(r int) uint64 {
- if r < i386.REG_AX || r > i386.REG_DI {
+ if r < x86.REG_AX || r > x86.REG_DI {
return 0
}
- return 1 << uint(r-i386.REG_AX)
+ return 1 << uint(r-x86.REG_AX)
}
func BtoR(b uint64) int {
if b == 0 {
return 0
}
- return gc.Bitno(b) + i386.REG_AX
+ return gc.Bitno(b) + x86.REG_AX
}
func FtoB(f int) uint64 {
- if f < i386.REG_X0 || f > i386.REG_X7 {
+ if f < x86.REG_X0 || f > x86.REG_X7 {
return 0
}
- return 1 << uint(f-i386.REG_X0+8)
+ return 1 << uint(f-x86.REG_X0+8)
}
func BtoF(b uint64) int {
if b == 0 {
return 0
}
- return gc.Bitno(b) - 8 + i386.REG_X0
+ return gc.Bitno(b) - 8 + x86.REG_X0
}
continue
}
if strings.HasPrefix(line, `import "`) || strings.HasPrefix(line, `import . "`) ||
- inBlock && (strings.HasPrefix(line, "\t\"") || strings.HasPrefix(line, "\t. \"")) ||
- strings.Contains(line, `i386 "cmd/internal/obj/x86"`) {
+ inBlock && (strings.HasPrefix(line, "\t\"") || strings.HasPrefix(line, "\t. \"")) {
lines[i] = strings.Replace(line, `"cmd/`, `"bootstrap/`, -1)
}
}
import (
"cmd/internal/asm"
"cmd/internal/obj"
- i386 "cmd/internal/obj/x86"
+ "cmd/internal/obj/x86"
)
var (
asm.Thechar = '8'
asm.Thestring = "386"
- asm.Thelinkarch = &i386.Link386
+ asm.Thelinkarch = &x86.Link386
asm.Main()
}
{"SB", LSB, obj.NAME_EXTERN},
{"FP", LFP, obj.NAME_PARAM},
{"PC", LPC, obj.TYPE_BRANCH},
- {"AL", LBREG, i386.REG_AL},
- {"CL", LBREG, i386.REG_CL},
- {"DL", LBREG, i386.REG_DL},
- {"BL", LBREG, i386.REG_BL},
- {"AH", LBREG, i386.REG_AH},
- {"CH", LBREG, i386.REG_CH},
- {"DH", LBREG, i386.REG_DH},
- {"BH", LBREG, i386.REG_BH},
- {"AX", LLREG, i386.REG_AX},
- {"CX", LLREG, i386.REG_CX},
- {"DX", LLREG, i386.REG_DX},
- {"BX", LLREG, i386.REG_BX},
+ {"AL", LBREG, x86.REG_AL},
+ {"CL", LBREG, x86.REG_CL},
+ {"DL", LBREG, x86.REG_DL},
+ {"BL", LBREG, x86.REG_BL},
+ {"AH", LBREG, x86.REG_AH},
+ {"CH", LBREG, x86.REG_CH},
+ {"DH", LBREG, x86.REG_DH},
+ {"BH", LBREG, x86.REG_BH},
+ {"AX", LLREG, x86.REG_AX},
+ {"CX", LLREG, x86.REG_CX},
+ {"DX", LLREG, x86.REG_DX},
+ {"BX", LLREG, x86.REG_BX},
/* "SP", LLREG, REG_SP, */
- {"BP", LLREG, i386.REG_BP},
- {"SI", LLREG, i386.REG_SI},
- {"DI", LLREG, i386.REG_DI},
- {"F0", LFREG, i386.REG_F0 + 0},
- {"F1", LFREG, i386.REG_F0 + 1},
- {"F2", LFREG, i386.REG_F0 + 2},
- {"F3", LFREG, i386.REG_F0 + 3},
- {"F4", LFREG, i386.REG_F0 + 4},
- {"F5", LFREG, i386.REG_F0 + 5},
- {"F6", LFREG, i386.REG_F0 + 6},
- {"F7", LFREG, i386.REG_F0 + 7},
- {"X0", LXREG, i386.REG_X0 + 0},
- {"X1", LXREG, i386.REG_X0 + 1},
- {"X2", LXREG, i386.REG_X0 + 2},
- {"X3", LXREG, i386.REG_X0 + 3},
- {"X4", LXREG, i386.REG_X0 + 4},
- {"X5", LXREG, i386.REG_X0 + 5},
- {"X6", LXREG, i386.REG_X0 + 6},
- {"X7", LXREG, i386.REG_X0 + 7},
- {"CS", LSREG, i386.REG_CS},
- {"SS", LSREG, i386.REG_SS},
- {"DS", LSREG, i386.REG_DS},
- {"ES", LSREG, i386.REG_ES},
- {"FS", LSREG, i386.REG_FS},
- {"GS", LSREG, i386.REG_GS},
- {"TLS", LSREG, i386.REG_TLS},
- {"GDTR", LBREG, i386.REG_GDTR},
- {"IDTR", LBREG, i386.REG_IDTR},
- {"LDTR", LBREG, i386.REG_LDTR},
- {"MSW", LBREG, i386.REG_MSW},
- {"TASK", LBREG, i386.REG_TASK},
- {"CR0", LBREG, i386.REG_CR + 0},
- {"CR1", LBREG, i386.REG_CR + 1},
- {"CR2", LBREG, i386.REG_CR + 2},
- {"CR3", LBREG, i386.REG_CR + 3},
- {"CR4", LBREG, i386.REG_CR + 4},
- {"CR5", LBREG, i386.REG_CR + 5},
- {"CR6", LBREG, i386.REG_CR + 6},
- {"CR7", LBREG, i386.REG_CR + 7},
- {"DR0", LBREG, i386.REG_DR + 0},
- {"DR1", LBREG, i386.REG_DR + 1},
- {"DR2", LBREG, i386.REG_DR + 2},
- {"DR3", LBREG, i386.REG_DR + 3},
- {"DR4", LBREG, i386.REG_DR + 4},
- {"DR5", LBREG, i386.REG_DR + 5},
- {"DR6", LBREG, i386.REG_DR + 6},
- {"DR7", LBREG, i386.REG_DR + 7},
- {"TR0", LBREG, i386.REG_TR + 0},
- {"TR1", LBREG, i386.REG_TR + 1},
- {"TR2", LBREG, i386.REG_TR + 2},
- {"TR3", LBREG, i386.REG_TR + 3},
- {"TR4", LBREG, i386.REG_TR + 4},
- {"TR5", LBREG, i386.REG_TR + 5},
- {"TR6", LBREG, i386.REG_TR + 6},
- {"TR7", LBREG, i386.REG_TR + 7},
- {"AAA", LTYPE0, i386.AAAA},
- {"AAD", LTYPE0, i386.AAAD},
- {"AAM", LTYPE0, i386.AAAM},
- {"AAS", LTYPE0, i386.AAAS},
- {"ADCB", LTYPE3, i386.AADCB},
- {"ADCL", LTYPE3, i386.AADCL},
- {"ADCW", LTYPE3, i386.AADCW},
- {"ADDB", LTYPE3, i386.AADDB},
- {"ADDL", LTYPE3, i386.AADDL},
- {"ADDW", LTYPE3, i386.AADDW},
- {"ADJSP", LTYPE2, i386.AADJSP},
- {"ANDB", LTYPE3, i386.AANDB},
- {"ANDL", LTYPE3, i386.AANDL},
- {"ANDW", LTYPE3, i386.AANDW},
- {"ARPL", LTYPE3, i386.AARPL},
- {"BOUNDL", LTYPE3, i386.ABOUNDL},
- {"BOUNDW", LTYPE3, i386.ABOUNDW},
- {"BSFL", LTYPE3, i386.ABSFL},
- {"BSFW", LTYPE3, i386.ABSFW},
- {"BSRL", LTYPE3, i386.ABSRL},
- {"BSRW", LTYPE3, i386.ABSRW},
- {"BSWAPL", LTYPE1, i386.ABSWAPL},
- {"BTCL", LTYPE3, i386.ABTCL},
- {"BTCW", LTYPE3, i386.ABTCW},
- {"BTL", LTYPE3, i386.ABTL},
- {"BTRL", LTYPE3, i386.ABTRL},
- {"BTRW", LTYPE3, i386.ABTRW},
- {"BTSL", LTYPE3, i386.ABTSL},
- {"BTSW", LTYPE3, i386.ABTSW},
- {"BTW", LTYPE3, i386.ABTW},
- {"BYTE", LTYPE2, i386.ABYTE},
+ {"BP", LLREG, x86.REG_BP},
+ {"SI", LLREG, x86.REG_SI},
+ {"DI", LLREG, x86.REG_DI},
+ {"F0", LFREG, x86.REG_F0 + 0},
+ {"F1", LFREG, x86.REG_F0 + 1},
+ {"F2", LFREG, x86.REG_F0 + 2},
+ {"F3", LFREG, x86.REG_F0 + 3},
+ {"F4", LFREG, x86.REG_F0 + 4},
+ {"F5", LFREG, x86.REG_F0 + 5},
+ {"F6", LFREG, x86.REG_F0 + 6},
+ {"F7", LFREG, x86.REG_F0 + 7},
+ {"X0", LXREG, x86.REG_X0 + 0},
+ {"X1", LXREG, x86.REG_X0 + 1},
+ {"X2", LXREG, x86.REG_X0 + 2},
+ {"X3", LXREG, x86.REG_X0 + 3},
+ {"X4", LXREG, x86.REG_X0 + 4},
+ {"X5", LXREG, x86.REG_X0 + 5},
+ {"X6", LXREG, x86.REG_X0 + 6},
+ {"X7", LXREG, x86.REG_X0 + 7},
+ {"CS", LSREG, x86.REG_CS},
+ {"SS", LSREG, x86.REG_SS},
+ {"DS", LSREG, x86.REG_DS},
+ {"ES", LSREG, x86.REG_ES},
+ {"FS", LSREG, x86.REG_FS},
+ {"GS", LSREG, x86.REG_GS},
+ {"TLS", LSREG, x86.REG_TLS},
+ {"GDTR", LBREG, x86.REG_GDTR},
+ {"IDTR", LBREG, x86.REG_IDTR},
+ {"LDTR", LBREG, x86.REG_LDTR},
+ {"MSW", LBREG, x86.REG_MSW},
+ {"TASK", LBREG, x86.REG_TASK},
+ {"CR0", LBREG, x86.REG_CR + 0},
+ {"CR1", LBREG, x86.REG_CR + 1},
+ {"CR2", LBREG, x86.REG_CR + 2},
+ {"CR3", LBREG, x86.REG_CR + 3},
+ {"CR4", LBREG, x86.REG_CR + 4},
+ {"CR5", LBREG, x86.REG_CR + 5},
+ {"CR6", LBREG, x86.REG_CR + 6},
+ {"CR7", LBREG, x86.REG_CR + 7},
+ {"DR0", LBREG, x86.REG_DR + 0},
+ {"DR1", LBREG, x86.REG_DR + 1},
+ {"DR2", LBREG, x86.REG_DR + 2},
+ {"DR3", LBREG, x86.REG_DR + 3},
+ {"DR4", LBREG, x86.REG_DR + 4},
+ {"DR5", LBREG, x86.REG_DR + 5},
+ {"DR6", LBREG, x86.REG_DR + 6},
+ {"DR7", LBREG, x86.REG_DR + 7},
+ {"TR0", LBREG, x86.REG_TR + 0},
+ {"TR1", LBREG, x86.REG_TR + 1},
+ {"TR2", LBREG, x86.REG_TR + 2},
+ {"TR3", LBREG, x86.REG_TR + 3},
+ {"TR4", LBREG, x86.REG_TR + 4},
+ {"TR5", LBREG, x86.REG_TR + 5},
+ {"TR6", LBREG, x86.REG_TR + 6},
+ {"TR7", LBREG, x86.REG_TR + 7},
+ {"AAA", LTYPE0, x86.AAAA},
+ {"AAD", LTYPE0, x86.AAAD},
+ {"AAM", LTYPE0, x86.AAAM},
+ {"AAS", LTYPE0, x86.AAAS},
+ {"ADCB", LTYPE3, x86.AADCB},
+ {"ADCL", LTYPE3, x86.AADCL},
+ {"ADCW", LTYPE3, x86.AADCW},
+ {"ADDB", LTYPE3, x86.AADDB},
+ {"ADDL", LTYPE3, x86.AADDL},
+ {"ADDW", LTYPE3, x86.AADDW},
+ {"ADJSP", LTYPE2, x86.AADJSP},
+ {"ANDB", LTYPE3, x86.AANDB},
+ {"ANDL", LTYPE3, x86.AANDL},
+ {"ANDW", LTYPE3, x86.AANDW},
+ {"ARPL", LTYPE3, x86.AARPL},
+ {"BOUNDL", LTYPE3, x86.ABOUNDL},
+ {"BOUNDW", LTYPE3, x86.ABOUNDW},
+ {"BSFL", LTYPE3, x86.ABSFL},
+ {"BSFW", LTYPE3, x86.ABSFW},
+ {"BSRL", LTYPE3, x86.ABSRL},
+ {"BSRW", LTYPE3, x86.ABSRW},
+ {"BSWAPL", LTYPE1, x86.ABSWAPL},
+ {"BTCL", LTYPE3, x86.ABTCL},
+ {"BTCW", LTYPE3, x86.ABTCW},
+ {"BTL", LTYPE3, x86.ABTL},
+ {"BTRL", LTYPE3, x86.ABTRL},
+ {"BTRW", LTYPE3, x86.ABTRW},
+ {"BTSL", LTYPE3, x86.ABTSL},
+ {"BTSW", LTYPE3, x86.ABTSW},
+ {"BTW", LTYPE3, x86.ABTW},
+ {"BYTE", LTYPE2, x86.ABYTE},
{"CALL", LTYPEC, obj.ACALL},
- {"CLC", LTYPE0, i386.ACLC},
- {"CLD", LTYPE0, i386.ACLD},
- {"CLI", LTYPE0, i386.ACLI},
- {"CLTS", LTYPE0, i386.ACLTS},
- {"CMC", LTYPE0, i386.ACMC},
- {"CMPB", LTYPE4, i386.ACMPB},
- {"CMPL", LTYPE4, i386.ACMPL},
- {"CMPW", LTYPE4, i386.ACMPW},
- {"CMPSB", LTYPE0, i386.ACMPSB},
- {"CMPSL", LTYPE0, i386.ACMPSL},
- {"CMPSW", LTYPE0, i386.ACMPSW},
- {"CMPXCHG8B", LTYPE1, i386.ACMPXCHG8B},
- {"CMPXCHGB", LTYPE3, i386.ACMPXCHGB},
- {"CMPXCHGL", LTYPE3, i386.ACMPXCHGL},
- {"CMPXCHGW", LTYPE3, i386.ACMPXCHGW},
- {"CPUID", LTYPE0, i386.ACPUID},
- {"DAA", LTYPE0, i386.ADAA},
- {"DAS", LTYPE0, i386.ADAS},
+ {"CLC", LTYPE0, x86.ACLC},
+ {"CLD", LTYPE0, x86.ACLD},
+ {"CLI", LTYPE0, x86.ACLI},
+ {"CLTS", LTYPE0, x86.ACLTS},
+ {"CMC", LTYPE0, x86.ACMC},
+ {"CMPB", LTYPE4, x86.ACMPB},
+ {"CMPL", LTYPE4, x86.ACMPL},
+ {"CMPW", LTYPE4, x86.ACMPW},
+ {"CMPSB", LTYPE0, x86.ACMPSB},
+ {"CMPSL", LTYPE0, x86.ACMPSL},
+ {"CMPSW", LTYPE0, x86.ACMPSW},
+ {"CMPXCHG8B", LTYPE1, x86.ACMPXCHG8B},
+ {"CMPXCHGB", LTYPE3, x86.ACMPXCHGB},
+ {"CMPXCHGL", LTYPE3, x86.ACMPXCHGL},
+ {"CMPXCHGW", LTYPE3, x86.ACMPXCHGW},
+ {"CPUID", LTYPE0, x86.ACPUID},
+ {"DAA", LTYPE0, x86.ADAA},
+ {"DAS", LTYPE0, x86.ADAS},
{"DATA", LTYPED, obj.ADATA},
- {"DECB", LTYPE1, i386.ADECB},
- {"DECL", LTYPE1, i386.ADECL},
- {"DECW", LTYPE1, i386.ADECW},
- {"DIVB", LTYPE2, i386.ADIVB},
- {"DIVL", LTYPE2, i386.ADIVL},
- {"DIVW", LTYPE2, i386.ADIVW},
+ {"DECB", LTYPE1, x86.ADECB},
+ {"DECL", LTYPE1, x86.ADECL},
+ {"DECW", LTYPE1, x86.ADECW},
+ {"DIVB", LTYPE2, x86.ADIVB},
+ {"DIVL", LTYPE2, x86.ADIVL},
+ {"DIVW", LTYPE2, x86.ADIVW},
{"END", LTYPE0, obj.AEND},
- {"ENTER", LTYPE2, i386.AENTER},
+ {"ENTER", LTYPE2, x86.AENTER},
{"GLOBL", LTYPEG, obj.AGLOBL},
- {"HLT", LTYPE0, i386.AHLT},
- {"IDIVB", LTYPE2, i386.AIDIVB},
- {"IDIVL", LTYPE2, i386.AIDIVL},
- {"IDIVW", LTYPE2, i386.AIDIVW},
- {"IMULB", LTYPE2, i386.AIMULB},
- {"IMULL", LTYPEI, i386.AIMULL},
- {"IMULW", LTYPEI, i386.AIMULW},
- {"INB", LTYPE0, i386.AINB},
- {"INL", LTYPE0, i386.AINL},
- {"INW", LTYPE0, i386.AINW},
- {"INCB", LTYPE1, i386.AINCB},
- {"INCL", LTYPE1, i386.AINCL},
- {"INCW", LTYPE1, i386.AINCW},
- {"INSB", LTYPE0, i386.AINSB},
- {"INSL", LTYPE0, i386.AINSL},
- {"INSW", LTYPE0, i386.AINSW},
- {"INT", LTYPE2, i386.AINT},
- {"INTO", LTYPE0, i386.AINTO},
- {"IRETL", LTYPE0, i386.AIRETL},
- {"IRETW", LTYPE0, i386.AIRETW},
- {"JOS", LTYPER, i386.AJOS}, /* overflow set (OF = 1) */
- {"JO", LTYPER, i386.AJOS}, /* alternate */
- {"JOC", LTYPER, i386.AJOC}, /* overflow clear (OF = 0) */
- {"JNO", LTYPER, i386.AJOC}, /* alternate */
- {"JCS", LTYPER, i386.AJCS}, /* carry set (CF = 1) */
- {"JB", LTYPER, i386.AJCS}, /* alternate */
- {"JC", LTYPER, i386.AJCS}, /* alternate */
- {"JNAE", LTYPER, i386.AJCS}, /* alternate */
- {"JLO", LTYPER, i386.AJCS}, /* alternate */
- {"JCC", LTYPER, i386.AJCC}, /* carry clear (CF = 0) */
- {"JAE", LTYPER, i386.AJCC}, /* alternate */
- {"JNB", LTYPER, i386.AJCC}, /* alternate */
- {"JNC", LTYPER, i386.AJCC}, /* alternate */
- {"JHS", LTYPER, i386.AJCC}, /* alternate */
- {"JEQ", LTYPER, i386.AJEQ}, /* equal (ZF = 1) */
- {"JE", LTYPER, i386.AJEQ}, /* alternate */
- {"JZ", LTYPER, i386.AJEQ}, /* alternate */
- {"JNE", LTYPER, i386.AJNE}, /* not equal (ZF = 0) */
- {"JNZ", LTYPER, i386.AJNE}, /* alternate */
- {"JLS", LTYPER, i386.AJLS}, /* lower or same (unsigned) (CF = 1 || ZF = 1) */
- {"JBE", LTYPER, i386.AJLS}, /* alternate */
- {"JNA", LTYPER, i386.AJLS}, /* alternate */
- {"JHI", LTYPER, i386.AJHI}, /* higher (unsigned) (CF = 0 && ZF = 0) */
- {"JA", LTYPER, i386.AJHI}, /* alternate */
- {"JNBE", LTYPER, i386.AJHI}, /* alternate */
- {"JMI", LTYPER, i386.AJMI}, /* negative (minus) (SF = 1) */
- {"JS", LTYPER, i386.AJMI}, /* alternate */
- {"JPL", LTYPER, i386.AJPL}, /* non-negative (plus) (SF = 0) */
- {"JNS", LTYPER, i386.AJPL}, /* alternate */
- {"JPS", LTYPER, i386.AJPS}, /* parity set (PF = 1) */
- {"JP", LTYPER, i386.AJPS}, /* alternate */
- {"JPE", LTYPER, i386.AJPS}, /* alternate */
- {"JPC", LTYPER, i386.AJPC}, /* parity clear (PF = 0) */
- {"JNP", LTYPER, i386.AJPC}, /* alternate */
- {"JPO", LTYPER, i386.AJPC}, /* alternate */
- {"JLT", LTYPER, i386.AJLT}, /* less than (signed) (SF != OF) */
- {"JL", LTYPER, i386.AJLT}, /* alternate */
- {"JNGE", LTYPER, i386.AJLT}, /* alternate */
- {"JGE", LTYPER, i386.AJGE}, /* greater than or equal (signed) (SF = OF) */
- {"JNL", LTYPER, i386.AJGE}, /* alternate */
- {"JLE", LTYPER, i386.AJLE}, /* less than or equal (signed) (ZF = 1 || SF != OF) */
- {"JNG", LTYPER, i386.AJLE}, /* alternate */
- {"JGT", LTYPER, i386.AJGT}, /* greater than (signed) (ZF = 0 && SF = OF) */
- {"JG", LTYPER, i386.AJGT}, /* alternate */
- {"JNLE", LTYPER, i386.AJGT}, /* alternate */
- {"JCXZL", LTYPER, i386.AJCXZL},
- {"JCXZW", LTYPER, i386.AJCXZW},
+ {"HLT", LTYPE0, x86.AHLT},
+ {"IDIVB", LTYPE2, x86.AIDIVB},
+ {"IDIVL", LTYPE2, x86.AIDIVL},
+ {"IDIVW", LTYPE2, x86.AIDIVW},
+ {"IMULB", LTYPE2, x86.AIMULB},
+ {"IMULL", LTYPEI, x86.AIMULL},
+ {"IMULW", LTYPEI, x86.AIMULW},
+ {"INB", LTYPE0, x86.AINB},
+ {"INL", LTYPE0, x86.AINL},
+ {"INW", LTYPE0, x86.AINW},
+ {"INCB", LTYPE1, x86.AINCB},
+ {"INCL", LTYPE1, x86.AINCL},
+ {"INCW", LTYPE1, x86.AINCW},
+ {"INSB", LTYPE0, x86.AINSB},
+ {"INSL", LTYPE0, x86.AINSL},
+ {"INSW", LTYPE0, x86.AINSW},
+ {"INT", LTYPE2, x86.AINT},
+ {"INTO", LTYPE0, x86.AINTO},
+ {"IRETL", LTYPE0, x86.AIRETL},
+ {"IRETW", LTYPE0, x86.AIRETW},
+ {"JOS", LTYPER, x86.AJOS}, /* overflow set (OF = 1) */
+ {"JO", LTYPER, x86.AJOS}, /* alternate */
+ {"JOC", LTYPER, x86.AJOC}, /* overflow clear (OF = 0) */
+ {"JNO", LTYPER, x86.AJOC}, /* alternate */
+ {"JCS", LTYPER, x86.AJCS}, /* carry set (CF = 1) */
+ {"JB", LTYPER, x86.AJCS}, /* alternate */
+ {"JC", LTYPER, x86.AJCS}, /* alternate */
+ {"JNAE", LTYPER, x86.AJCS}, /* alternate */
+ {"JLO", LTYPER, x86.AJCS}, /* alternate */
+ {"JCC", LTYPER, x86.AJCC}, /* carry clear (CF = 0) */
+ {"JAE", LTYPER, x86.AJCC}, /* alternate */
+ {"JNB", LTYPER, x86.AJCC}, /* alternate */
+ {"JNC", LTYPER, x86.AJCC}, /* alternate */
+ {"JHS", LTYPER, x86.AJCC}, /* alternate */
+ {"JEQ", LTYPER, x86.AJEQ}, /* equal (ZF = 1) */
+ {"JE", LTYPER, x86.AJEQ}, /* alternate */
+ {"JZ", LTYPER, x86.AJEQ}, /* alternate */
+ {"JNE", LTYPER, x86.AJNE}, /* not equal (ZF = 0) */
+ {"JNZ", LTYPER, x86.AJNE}, /* alternate */
+ {"JLS", LTYPER, x86.AJLS}, /* lower or same (unsigned) (CF = 1 || ZF = 1) */
+ {"JBE", LTYPER, x86.AJLS}, /* alternate */
+ {"JNA", LTYPER, x86.AJLS}, /* alternate */
+ {"JHI", LTYPER, x86.AJHI}, /* higher (unsigned) (CF = 0 && ZF = 0) */
+ {"JA", LTYPER, x86.AJHI}, /* alternate */
+ {"JNBE", LTYPER, x86.AJHI}, /* alternate */
+ {"JMI", LTYPER, x86.AJMI}, /* negative (minus) (SF = 1) */
+ {"JS", LTYPER, x86.AJMI}, /* alternate */
+ {"JPL", LTYPER, x86.AJPL}, /* non-negative (plus) (SF = 0) */
+ {"JNS", LTYPER, x86.AJPL}, /* alternate */
+ {"JPS", LTYPER, x86.AJPS}, /* parity set (PF = 1) */
+ {"JP", LTYPER, x86.AJPS}, /* alternate */
+ {"JPE", LTYPER, x86.AJPS}, /* alternate */
+ {"JPC", LTYPER, x86.AJPC}, /* parity clear (PF = 0) */
+ {"JNP", LTYPER, x86.AJPC}, /* alternate */
+ {"JPO", LTYPER, x86.AJPC}, /* alternate */
+ {"JLT", LTYPER, x86.AJLT}, /* less than (signed) (SF != OF) */
+ {"JL", LTYPER, x86.AJLT}, /* alternate */
+ {"JNGE", LTYPER, x86.AJLT}, /* alternate */
+ {"JGE", LTYPER, x86.AJGE}, /* greater than or equal (signed) (SF = OF) */
+ {"JNL", LTYPER, x86.AJGE}, /* alternate */
+ {"JLE", LTYPER, x86.AJLE}, /* less than or equal (signed) (ZF = 1 || SF != OF) */
+ {"JNG", LTYPER, x86.AJLE}, /* alternate */
+ {"JGT", LTYPER, x86.AJGT}, /* greater than (signed) (ZF = 0 && SF = OF) */
+ {"JG", LTYPER, x86.AJGT}, /* alternate */
+ {"JNLE", LTYPER, x86.AJGT}, /* alternate */
+ {"JCXZL", LTYPER, x86.AJCXZL},
+ {"JCXZW", LTYPER, x86.AJCXZW},
{"JMP", LTYPEC, obj.AJMP},
- {"LAHF", LTYPE0, i386.ALAHF},
- {"LARL", LTYPE3, i386.ALARL},
- {"LARW", LTYPE3, i386.ALARW},
- {"LEAL", LTYPE3, i386.ALEAL},
- {"LEAW", LTYPE3, i386.ALEAW},
- {"LEAVEL", LTYPE0, i386.ALEAVEL},
- {"LEAVEW", LTYPE0, i386.ALEAVEW},
- {"LOCK", LTYPE0, i386.ALOCK},
- {"LODSB", LTYPE0, i386.ALODSB},
- {"LODSL", LTYPE0, i386.ALODSL},
- {"LODSW", LTYPE0, i386.ALODSW},
- {"LONG", LTYPE2, i386.ALONG},
- {"LOOP", LTYPER, i386.ALOOP},
- {"LOOPEQ", LTYPER, i386.ALOOPEQ},
- {"LOOPNE", LTYPER, i386.ALOOPNE},
- {"LSLL", LTYPE3, i386.ALSLL},
- {"LSLW", LTYPE3, i386.ALSLW},
- {"MOVB", LTYPE3, i386.AMOVB},
- {"MOVL", LTYPEM, i386.AMOVL},
- {"MOVW", LTYPEM, i386.AMOVW},
- {"MOVQ", LTYPEM, i386.AMOVQ},
- {"MOVBLSX", LTYPE3, i386.AMOVBLSX},
- {"MOVBLZX", LTYPE3, i386.AMOVBLZX},
- {"MOVBWSX", LTYPE3, i386.AMOVBWSX},
- {"MOVBWZX", LTYPE3, i386.AMOVBWZX},
- {"MOVWLSX", LTYPE3, i386.AMOVWLSX},
- {"MOVWLZX", LTYPE3, i386.AMOVWLZX},
- {"MOVSB", LTYPE0, i386.AMOVSB},
- {"MOVSL", LTYPE0, i386.AMOVSL},
- {"MOVSW", LTYPE0, i386.AMOVSW},
- {"MULB", LTYPE2, i386.AMULB},
- {"MULL", LTYPE2, i386.AMULL},
- {"MULW", LTYPE2, i386.AMULW},
- {"NEGB", LTYPE1, i386.ANEGB},
- {"NEGL", LTYPE1, i386.ANEGL},
- {"NEGW", LTYPE1, i386.ANEGW},
+ {"LAHF", LTYPE0, x86.ALAHF},
+ {"LARL", LTYPE3, x86.ALARL},
+ {"LARW", LTYPE3, x86.ALARW},
+ {"LEAL", LTYPE3, x86.ALEAL},
+ {"LEAW", LTYPE3, x86.ALEAW},
+ {"LEAVEL", LTYPE0, x86.ALEAVEL},
+ {"LEAVEW", LTYPE0, x86.ALEAVEW},
+ {"LOCK", LTYPE0, x86.ALOCK},
+ {"LODSB", LTYPE0, x86.ALODSB},
+ {"LODSL", LTYPE0, x86.ALODSL},
+ {"LODSW", LTYPE0, x86.ALODSW},
+ {"LONG", LTYPE2, x86.ALONG},
+ {"LOOP", LTYPER, x86.ALOOP},
+ {"LOOPEQ", LTYPER, x86.ALOOPEQ},
+ {"LOOPNE", LTYPER, x86.ALOOPNE},
+ {"LSLL", LTYPE3, x86.ALSLL},
+ {"LSLW", LTYPE3, x86.ALSLW},
+ {"MOVB", LTYPE3, x86.AMOVB},
+ {"MOVL", LTYPEM, x86.AMOVL},
+ {"MOVW", LTYPEM, x86.AMOVW},
+ {"MOVQ", LTYPEM, x86.AMOVQ},
+ {"MOVBLSX", LTYPE3, x86.AMOVBLSX},
+ {"MOVBLZX", LTYPE3, x86.AMOVBLZX},
+ {"MOVBWSX", LTYPE3, x86.AMOVBWSX},
+ {"MOVBWZX", LTYPE3, x86.AMOVBWZX},
+ {"MOVWLSX", LTYPE3, x86.AMOVWLSX},
+ {"MOVWLZX", LTYPE3, x86.AMOVWLZX},
+ {"MOVSB", LTYPE0, x86.AMOVSB},
+ {"MOVSL", LTYPE0, x86.AMOVSL},
+ {"MOVSW", LTYPE0, x86.AMOVSW},
+ {"MULB", LTYPE2, x86.AMULB},
+ {"MULL", LTYPE2, x86.AMULL},
+ {"MULW", LTYPE2, x86.AMULW},
+ {"NEGB", LTYPE1, x86.ANEGB},
+ {"NEGL", LTYPE1, x86.ANEGL},
+ {"NEGW", LTYPE1, x86.ANEGW},
{"NOP", LTYPEN, obj.ANOP},
- {"NOTB", LTYPE1, i386.ANOTB},
- {"NOTL", LTYPE1, i386.ANOTL},
- {"NOTW", LTYPE1, i386.ANOTW},
- {"ORB", LTYPE3, i386.AORB},
- {"ORL", LTYPE3, i386.AORL},
- {"ORW", LTYPE3, i386.AORW},
- {"OUTB", LTYPE0, i386.AOUTB},
- {"OUTL", LTYPE0, i386.AOUTL},
- {"OUTW", LTYPE0, i386.AOUTW},
- {"OUTSB", LTYPE0, i386.AOUTSB},
- {"OUTSL", LTYPE0, i386.AOUTSL},
- {"OUTSW", LTYPE0, i386.AOUTSW},
- {"PAUSE", LTYPEN, i386.APAUSE},
- {"PINSRD", LTYPEX, i386.APINSRD},
- {"POPAL", LTYPE0, i386.APOPAL},
- {"POPAW", LTYPE0, i386.APOPAW},
- {"POPFL", LTYPE0, i386.APOPFL},
- {"POPFW", LTYPE0, i386.APOPFW},
- {"POPL", LTYPE1, i386.APOPL},
- {"POPW", LTYPE1, i386.APOPW},
- {"PUSHAL", LTYPE0, i386.APUSHAL},
- {"PUSHAW", LTYPE0, i386.APUSHAW},
- {"PUSHFL", LTYPE0, i386.APUSHFL},
- {"PUSHFW", LTYPE0, i386.APUSHFW},
- {"PUSHL", LTYPE2, i386.APUSHL},
- {"PUSHW", LTYPE2, i386.APUSHW},
- {"RCLB", LTYPE3, i386.ARCLB},
- {"RCLL", LTYPE3, i386.ARCLL},
- {"RCLW", LTYPE3, i386.ARCLW},
- {"RCRB", LTYPE3, i386.ARCRB},
- {"RCRL", LTYPE3, i386.ARCRL},
- {"RCRW", LTYPE3, i386.ARCRW},
- {"RDTSC", LTYPE0, i386.ARDTSC},
- {"REP", LTYPE0, i386.AREP},
- {"REPN", LTYPE0, i386.AREPN},
+ {"NOTB", LTYPE1, x86.ANOTB},
+ {"NOTL", LTYPE1, x86.ANOTL},
+ {"NOTW", LTYPE1, x86.ANOTW},
+ {"ORB", LTYPE3, x86.AORB},
+ {"ORL", LTYPE3, x86.AORL},
+ {"ORW", LTYPE3, x86.AORW},
+ {"OUTB", LTYPE0, x86.AOUTB},
+ {"OUTL", LTYPE0, x86.AOUTL},
+ {"OUTW", LTYPE0, x86.AOUTW},
+ {"OUTSB", LTYPE0, x86.AOUTSB},
+ {"OUTSL", LTYPE0, x86.AOUTSL},
+ {"OUTSW", LTYPE0, x86.AOUTSW},
+ {"PAUSE", LTYPEN, x86.APAUSE},
+ {"PINSRD", LTYPEX, x86.APINSRD},
+ {"POPAL", LTYPE0, x86.APOPAL},
+ {"POPAW", LTYPE0, x86.APOPAW},
+ {"POPFL", LTYPE0, x86.APOPFL},
+ {"POPFW", LTYPE0, x86.APOPFW},
+ {"POPL", LTYPE1, x86.APOPL},
+ {"POPW", LTYPE1, x86.APOPW},
+ {"PUSHAL", LTYPE0, x86.APUSHAL},
+ {"PUSHAW", LTYPE0, x86.APUSHAW},
+ {"PUSHFL", LTYPE0, x86.APUSHFL},
+ {"PUSHFW", LTYPE0, x86.APUSHFW},
+ {"PUSHL", LTYPE2, x86.APUSHL},
+ {"PUSHW", LTYPE2, x86.APUSHW},
+ {"RCLB", LTYPE3, x86.ARCLB},
+ {"RCLL", LTYPE3, x86.ARCLL},
+ {"RCLW", LTYPE3, x86.ARCLW},
+ {"RCRB", LTYPE3, x86.ARCRB},
+ {"RCRL", LTYPE3, x86.ARCRL},
+ {"RCRW", LTYPE3, x86.ARCRW},
+ {"RDTSC", LTYPE0, x86.ARDTSC},
+ {"REP", LTYPE0, x86.AREP},
+ {"REPN", LTYPE0, x86.AREPN},
{"RET", LTYPE0, obj.ARET},
- {"ROLB", LTYPE3, i386.AROLB},
- {"ROLL", LTYPE3, i386.AROLL},
- {"ROLW", LTYPE3, i386.AROLW},
- {"RORB", LTYPE3, i386.ARORB},
- {"RORL", LTYPE3, i386.ARORL},
- {"RORW", LTYPE3, i386.ARORW},
- {"SAHF", LTYPE0, i386.ASAHF},
- {"SALB", LTYPE3, i386.ASALB},
- {"SALL", LTYPE3, i386.ASALL},
- {"SALW", LTYPE3, i386.ASALW},
- {"SARB", LTYPE3, i386.ASARB},
- {"SARL", LTYPE3, i386.ASARL},
- {"SARW", LTYPE3, i386.ASARW},
- {"SBBB", LTYPE3, i386.ASBBB},
- {"SBBL", LTYPE3, i386.ASBBL},
- {"SBBW", LTYPE3, i386.ASBBW},
- {"SCASB", LTYPE0, i386.ASCASB},
- {"SCASL", LTYPE0, i386.ASCASL},
- {"SCASW", LTYPE0, i386.ASCASW},
- {"SETCC", LTYPE1, i386.ASETCC}, /* see JCC etc above for condition codes */
- {"SETCS", LTYPE1, i386.ASETCS},
- {"SETEQ", LTYPE1, i386.ASETEQ},
- {"SETGE", LTYPE1, i386.ASETGE},
- {"SETGT", LTYPE1, i386.ASETGT},
- {"SETHI", LTYPE1, i386.ASETHI},
- {"SETLE", LTYPE1, i386.ASETLE},
- {"SETLS", LTYPE1, i386.ASETLS},
- {"SETLT", LTYPE1, i386.ASETLT},
- {"SETMI", LTYPE1, i386.ASETMI},
- {"SETNE", LTYPE1, i386.ASETNE},
- {"SETOC", LTYPE1, i386.ASETOC},
- {"SETOS", LTYPE1, i386.ASETOS},
- {"SETPC", LTYPE1, i386.ASETPC},
- {"SETPL", LTYPE1, i386.ASETPL},
- {"SETPS", LTYPE1, i386.ASETPS},
- {"CDQ", LTYPE0, i386.ACDQ},
- {"CWD", LTYPE0, i386.ACWD},
- {"SHLB", LTYPE3, i386.ASHLB},
- {"SHLL", LTYPES, i386.ASHLL},
- {"SHLW", LTYPES, i386.ASHLW},
- {"SHRB", LTYPE3, i386.ASHRB},
- {"SHRL", LTYPES, i386.ASHRL},
- {"SHRW", LTYPES, i386.ASHRW},
- {"STC", LTYPE0, i386.ASTC},
- {"STD", LTYPE0, i386.ASTD},
- {"STI", LTYPE0, i386.ASTI},
- {"STOSB", LTYPE0, i386.ASTOSB},
- {"STOSL", LTYPE0, i386.ASTOSL},
- {"STOSW", LTYPE0, i386.ASTOSW},
- {"SUBB", LTYPE3, i386.ASUBB},
- {"SUBL", LTYPE3, i386.ASUBL},
- {"SUBW", LTYPE3, i386.ASUBW},
- {"SYSCALL", LTYPE0, i386.ASYSCALL},
- {"TESTB", LTYPE3, i386.ATESTB},
- {"TESTL", LTYPE3, i386.ATESTL},
- {"TESTW", LTYPE3, i386.ATESTW},
+ {"ROLB", LTYPE3, x86.AROLB},
+ {"ROLL", LTYPE3, x86.AROLL},
+ {"ROLW", LTYPE3, x86.AROLW},
+ {"RORB", LTYPE3, x86.ARORB},
+ {"RORL", LTYPE3, x86.ARORL},
+ {"RORW", LTYPE3, x86.ARORW},
+ {"SAHF", LTYPE0, x86.ASAHF},
+ {"SALB", LTYPE3, x86.ASALB},
+ {"SALL", LTYPE3, x86.ASALL},
+ {"SALW", LTYPE3, x86.ASALW},
+ {"SARB", LTYPE3, x86.ASARB},
+ {"SARL", LTYPE3, x86.ASARL},
+ {"SARW", LTYPE3, x86.ASARW},
+ {"SBBB", LTYPE3, x86.ASBBB},
+ {"SBBL", LTYPE3, x86.ASBBL},
+ {"SBBW", LTYPE3, x86.ASBBW},
+ {"SCASB", LTYPE0, x86.ASCASB},
+ {"SCASL", LTYPE0, x86.ASCASL},
+ {"SCASW", LTYPE0, x86.ASCASW},
+ {"SETCC", LTYPE1, x86.ASETCC}, /* see JCC etc above for condition codes */
+ {"SETCS", LTYPE1, x86.ASETCS},
+ {"SETEQ", LTYPE1, x86.ASETEQ},
+ {"SETGE", LTYPE1, x86.ASETGE},
+ {"SETGT", LTYPE1, x86.ASETGT},
+ {"SETHI", LTYPE1, x86.ASETHI},
+ {"SETLE", LTYPE1, x86.ASETLE},
+ {"SETLS", LTYPE1, x86.ASETLS},
+ {"SETLT", LTYPE1, x86.ASETLT},
+ {"SETMI", LTYPE1, x86.ASETMI},
+ {"SETNE", LTYPE1, x86.ASETNE},
+ {"SETOC", LTYPE1, x86.ASETOC},
+ {"SETOS", LTYPE1, x86.ASETOS},
+ {"SETPC", LTYPE1, x86.ASETPC},
+ {"SETPL", LTYPE1, x86.ASETPL},
+ {"SETPS", LTYPE1, x86.ASETPS},
+ {"CDQ", LTYPE0, x86.ACDQ},
+ {"CWD", LTYPE0, x86.ACWD},
+ {"SHLB", LTYPE3, x86.ASHLB},
+ {"SHLL", LTYPES, x86.ASHLL},
+ {"SHLW", LTYPES, x86.ASHLW},
+ {"SHRB", LTYPE3, x86.ASHRB},
+ {"SHRL", LTYPES, x86.ASHRL},
+ {"SHRW", LTYPES, x86.ASHRW},
+ {"STC", LTYPE0, x86.ASTC},
+ {"STD", LTYPE0, x86.ASTD},
+ {"STI", LTYPE0, x86.ASTI},
+ {"STOSB", LTYPE0, x86.ASTOSB},
+ {"STOSL", LTYPE0, x86.ASTOSL},
+ {"STOSW", LTYPE0, x86.ASTOSW},
+ {"SUBB", LTYPE3, x86.ASUBB},
+ {"SUBL", LTYPE3, x86.ASUBL},
+ {"SUBW", LTYPE3, x86.ASUBW},
+ {"SYSCALL", LTYPE0, x86.ASYSCALL},
+ {"TESTB", LTYPE3, x86.ATESTB},
+ {"TESTL", LTYPE3, x86.ATESTL},
+ {"TESTW", LTYPE3, x86.ATESTW},
{"TEXT", LTYPET, obj.ATEXT},
- {"VERR", LTYPE2, i386.AVERR},
- {"VERW", LTYPE2, i386.AVERW},
- {"WAIT", LTYPE0, i386.AWAIT},
- {"WORD", LTYPE2, i386.AWORD},
- {"XADDB", LTYPE3, i386.AXADDB},
- {"XADDL", LTYPE3, i386.AXADDL},
- {"XADDW", LTYPE3, i386.AXADDW},
- {"XCHGB", LTYPE3, i386.AXCHGB},
- {"XCHGL", LTYPE3, i386.AXCHGL},
- {"XCHGW", LTYPE3, i386.AXCHGW},
- {"XLAT", LTYPE2, i386.AXLAT},
- {"XORB", LTYPE3, i386.AXORB},
- {"XORL", LTYPE3, i386.AXORL},
- {"XORW", LTYPE3, i386.AXORW},
- {"CMOVLCC", LTYPE3, i386.ACMOVLCC},
- {"CMOVLCS", LTYPE3, i386.ACMOVLCS},
- {"CMOVLEQ", LTYPE3, i386.ACMOVLEQ},
- {"CMOVLGE", LTYPE3, i386.ACMOVLGE},
- {"CMOVLGT", LTYPE3, i386.ACMOVLGT},
- {"CMOVLHI", LTYPE3, i386.ACMOVLHI},
- {"CMOVLLE", LTYPE3, i386.ACMOVLLE},
- {"CMOVLLS", LTYPE3, i386.ACMOVLLS},
- {"CMOVLLT", LTYPE3, i386.ACMOVLLT},
- {"CMOVLMI", LTYPE3, i386.ACMOVLMI},
- {"CMOVLNE", LTYPE3, i386.ACMOVLNE},
- {"CMOVLOC", LTYPE3, i386.ACMOVLOC},
- {"CMOVLOS", LTYPE3, i386.ACMOVLOS},
- {"CMOVLPC", LTYPE3, i386.ACMOVLPC},
- {"CMOVLPL", LTYPE3, i386.ACMOVLPL},
- {"CMOVLPS", LTYPE3, i386.ACMOVLPS},
- {"CMOVWCC", LTYPE3, i386.ACMOVWCC},
- {"CMOVWCS", LTYPE3, i386.ACMOVWCS},
- {"CMOVWEQ", LTYPE3, i386.ACMOVWEQ},
- {"CMOVWGE", LTYPE3, i386.ACMOVWGE},
- {"CMOVWGT", LTYPE3, i386.ACMOVWGT},
- {"CMOVWHI", LTYPE3, i386.ACMOVWHI},
- {"CMOVWLE", LTYPE3, i386.ACMOVWLE},
- {"CMOVWLS", LTYPE3, i386.ACMOVWLS},
- {"CMOVWLT", LTYPE3, i386.ACMOVWLT},
- {"CMOVWMI", LTYPE3, i386.ACMOVWMI},
- {"CMOVWNE", LTYPE3, i386.ACMOVWNE},
- {"CMOVWOC", LTYPE3, i386.ACMOVWOC},
- {"CMOVWOS", LTYPE3, i386.ACMOVWOS},
- {"CMOVWPC", LTYPE3, i386.ACMOVWPC},
- {"CMOVWPL", LTYPE3, i386.ACMOVWPL},
- {"CMOVWPS", LTYPE3, i386.ACMOVWPS},
- {"FMOVB", LTYPE3, i386.AFMOVB},
- {"FMOVBP", LTYPE3, i386.AFMOVBP},
- {"FMOVD", LTYPE3, i386.AFMOVD},
- {"FMOVDP", LTYPE3, i386.AFMOVDP},
- {"FMOVF", LTYPE3, i386.AFMOVF},
- {"FMOVFP", LTYPE3, i386.AFMOVFP},
- {"FMOVL", LTYPE3, i386.AFMOVL},
- {"FMOVLP", LTYPE3, i386.AFMOVLP},
- {"FMOVV", LTYPE3, i386.AFMOVV},
- {"FMOVVP", LTYPE3, i386.AFMOVVP},
- {"FMOVW", LTYPE3, i386.AFMOVW},
- {"FMOVWP", LTYPE3, i386.AFMOVWP},
- {"FMOVX", LTYPE3, i386.AFMOVX},
- {"FMOVXP", LTYPE3, i386.AFMOVXP},
- {"FCMOVCC", LTYPE3, i386.AFCMOVCC},
- {"FCMOVCS", LTYPE3, i386.AFCMOVCS},
- {"FCMOVEQ", LTYPE3, i386.AFCMOVEQ},
- {"FCMOVHI", LTYPE3, i386.AFCMOVHI},
- {"FCMOVLS", LTYPE3, i386.AFCMOVLS},
- {"FCMOVNE", LTYPE3, i386.AFCMOVNE},
- {"FCMOVNU", LTYPE3, i386.AFCMOVNU},
- {"FCMOVUN", LTYPE3, i386.AFCMOVUN},
- {"FCOMB", LTYPE3, i386.AFCOMB},
- {"FCOMBP", LTYPE3, i386.AFCOMBP},
- {"FCOMD", LTYPE3, i386.AFCOMD},
- {"FCOMDP", LTYPE3, i386.AFCOMDP},
- {"FCOMDPP", LTYPE3, i386.AFCOMDPP},
- {"FCOMF", LTYPE3, i386.AFCOMF},
- {"FCOMFP", LTYPE3, i386.AFCOMFP},
- {"FCOMI", LTYPE3, i386.AFCOMI},
- {"FCOMIP", LTYPE3, i386.AFCOMIP},
- {"FCOML", LTYPE3, i386.AFCOML},
- {"FCOMLP", LTYPE3, i386.AFCOMLP},
- {"FCOMW", LTYPE3, i386.AFCOMW},
- {"FCOMWP", LTYPE3, i386.AFCOMWP},
- {"FUCOM", LTYPE3, i386.AFUCOM},
- {"FUCOMI", LTYPE3, i386.AFUCOMI},
- {"FUCOMIP", LTYPE3, i386.AFUCOMIP},
- {"FUCOMP", LTYPE3, i386.AFUCOMP},
- {"FUCOMPP", LTYPE3, i386.AFUCOMPP},
- {"FADDW", LTYPE3, i386.AFADDW},
- {"FADDL", LTYPE3, i386.AFADDL},
- {"FADDF", LTYPE3, i386.AFADDF},
- {"FADDD", LTYPE3, i386.AFADDD},
- {"FADDDP", LTYPE3, i386.AFADDDP},
- {"FSUBDP", LTYPE3, i386.AFSUBDP},
- {"FSUBW", LTYPE3, i386.AFSUBW},
- {"FSUBL", LTYPE3, i386.AFSUBL},
- {"FSUBF", LTYPE3, i386.AFSUBF},
- {"FSUBD", LTYPE3, i386.AFSUBD},
- {"FSUBRDP", LTYPE3, i386.AFSUBRDP},
- {"FSUBRW", LTYPE3, i386.AFSUBRW},
- {"FSUBRL", LTYPE3, i386.AFSUBRL},
- {"FSUBRF", LTYPE3, i386.AFSUBRF},
- {"FSUBRD", LTYPE3, i386.AFSUBRD},
- {"FMULDP", LTYPE3, i386.AFMULDP},
- {"FMULW", LTYPE3, i386.AFMULW},
- {"FMULL", LTYPE3, i386.AFMULL},
- {"FMULF", LTYPE3, i386.AFMULF},
- {"FMULD", LTYPE3, i386.AFMULD},
- {"FDIVDP", LTYPE3, i386.AFDIVDP},
- {"FDIVW", LTYPE3, i386.AFDIVW},
- {"FDIVL", LTYPE3, i386.AFDIVL},
- {"FDIVF", LTYPE3, i386.AFDIVF},
- {"FDIVD", LTYPE3, i386.AFDIVD},
- {"FDIVRDP", LTYPE3, i386.AFDIVRDP},
- {"FDIVRW", LTYPE3, i386.AFDIVRW},
- {"FDIVRL", LTYPE3, i386.AFDIVRL},
- {"FDIVRF", LTYPE3, i386.AFDIVRF},
- {"FDIVRD", LTYPE3, i386.AFDIVRD},
- {"FXCHD", LTYPE3, i386.AFXCHD},
- {"FFREE", LTYPE1, i386.AFFREE},
- {"FLDCW", LTYPE2, i386.AFLDCW},
- {"FLDENV", LTYPE1, i386.AFLDENV},
- {"FRSTOR", LTYPE2, i386.AFRSTOR},
- {"FSAVE", LTYPE1, i386.AFSAVE},
- {"FSTCW", LTYPE1, i386.AFSTCW},
- {"FSTENV", LTYPE1, i386.AFSTENV},
- {"FSTSW", LTYPE1, i386.AFSTSW},
- {"F2XM1", LTYPE0, i386.AF2XM1},
- {"FABS", LTYPE0, i386.AFABS},
- {"FCHS", LTYPE0, i386.AFCHS},
- {"FCLEX", LTYPE0, i386.AFCLEX},
- {"FCOS", LTYPE0, i386.AFCOS},
- {"FDECSTP", LTYPE0, i386.AFDECSTP},
- {"FINCSTP", LTYPE0, i386.AFINCSTP},
- {"FINIT", LTYPE0, i386.AFINIT},
- {"FLD1", LTYPE0, i386.AFLD1},
- {"FLDL2E", LTYPE0, i386.AFLDL2E},
- {"FLDL2T", LTYPE0, i386.AFLDL2T},
- {"FLDLG2", LTYPE0, i386.AFLDLG2},
- {"FLDLN2", LTYPE0, i386.AFLDLN2},
- {"FLDPI", LTYPE0, i386.AFLDPI},
- {"FLDZ", LTYPE0, i386.AFLDZ},
- {"FNOP", LTYPE0, i386.AFNOP},
- {"FPATAN", LTYPE0, i386.AFPATAN},
- {"FPREM", LTYPE0, i386.AFPREM},
- {"FPREM1", LTYPE0, i386.AFPREM1},
- {"FPTAN", LTYPE0, i386.AFPTAN},
- {"FRNDINT", LTYPE0, i386.AFRNDINT},
- {"FSCALE", LTYPE0, i386.AFSCALE},
- {"FSIN", LTYPE0, i386.AFSIN},
- {"FSINCOS", LTYPE0, i386.AFSINCOS},
- {"FSQRT", LTYPE0, i386.AFSQRT},
- {"FTST", LTYPE0, i386.AFTST},
- {"FXAM", LTYPE0, i386.AFXAM},
- {"FXTRACT", LTYPE0, i386.AFXTRACT},
- {"FYL2X", LTYPE0, i386.AFYL2X},
- {"FYL2XP1", LTYPE0, i386.AFYL2XP1},
- {"LFENCE", LTYPE0, i386.ALFENCE},
- {"MFENCE", LTYPE0, i386.AMFENCE},
- {"SFENCE", LTYPE0, i386.ASFENCE},
- {"EMMS", LTYPE0, i386.AEMMS},
- {"PREFETCHT0", LTYPE2, i386.APREFETCHT0},
- {"PREFETCHT1", LTYPE2, i386.APREFETCHT1},
- {"PREFETCHT2", LTYPE2, i386.APREFETCHT2},
- {"PREFETCHNTA", LTYPE2, i386.APREFETCHNTA},
+ {"VERR", LTYPE2, x86.AVERR},
+ {"VERW", LTYPE2, x86.AVERW},
+ {"WAIT", LTYPE0, x86.AWAIT},
+ {"WORD", LTYPE2, x86.AWORD},
+ {"XADDB", LTYPE3, x86.AXADDB},
+ {"XADDL", LTYPE3, x86.AXADDL},
+ {"XADDW", LTYPE3, x86.AXADDW},
+ {"XCHGB", LTYPE3, x86.AXCHGB},
+ {"XCHGL", LTYPE3, x86.AXCHGL},
+ {"XCHGW", LTYPE3, x86.AXCHGW},
+ {"XLAT", LTYPE2, x86.AXLAT},
+ {"XORB", LTYPE3, x86.AXORB},
+ {"XORL", LTYPE3, x86.AXORL},
+ {"XORW", LTYPE3, x86.AXORW},
+ {"CMOVLCC", LTYPE3, x86.ACMOVLCC},
+ {"CMOVLCS", LTYPE3, x86.ACMOVLCS},
+ {"CMOVLEQ", LTYPE3, x86.ACMOVLEQ},
+ {"CMOVLGE", LTYPE3, x86.ACMOVLGE},
+ {"CMOVLGT", LTYPE3, x86.ACMOVLGT},
+ {"CMOVLHI", LTYPE3, x86.ACMOVLHI},
+ {"CMOVLLE", LTYPE3, x86.ACMOVLLE},
+ {"CMOVLLS", LTYPE3, x86.ACMOVLLS},
+ {"CMOVLLT", LTYPE3, x86.ACMOVLLT},
+ {"CMOVLMI", LTYPE3, x86.ACMOVLMI},
+ {"CMOVLNE", LTYPE3, x86.ACMOVLNE},
+ {"CMOVLOC", LTYPE3, x86.ACMOVLOC},
+ {"CMOVLOS", LTYPE3, x86.ACMOVLOS},
+ {"CMOVLPC", LTYPE3, x86.ACMOVLPC},
+ {"CMOVLPL", LTYPE3, x86.ACMOVLPL},
+ {"CMOVLPS", LTYPE3, x86.ACMOVLPS},
+ {"CMOVWCC", LTYPE3, x86.ACMOVWCC},
+ {"CMOVWCS", LTYPE3, x86.ACMOVWCS},
+ {"CMOVWEQ", LTYPE3, x86.ACMOVWEQ},
+ {"CMOVWGE", LTYPE3, x86.ACMOVWGE},
+ {"CMOVWGT", LTYPE3, x86.ACMOVWGT},
+ {"CMOVWHI", LTYPE3, x86.ACMOVWHI},
+ {"CMOVWLE", LTYPE3, x86.ACMOVWLE},
+ {"CMOVWLS", LTYPE3, x86.ACMOVWLS},
+ {"CMOVWLT", LTYPE3, x86.ACMOVWLT},
+ {"CMOVWMI", LTYPE3, x86.ACMOVWMI},
+ {"CMOVWNE", LTYPE3, x86.ACMOVWNE},
+ {"CMOVWOC", LTYPE3, x86.ACMOVWOC},
+ {"CMOVWOS", LTYPE3, x86.ACMOVWOS},
+ {"CMOVWPC", LTYPE3, x86.ACMOVWPC},
+ {"CMOVWPL", LTYPE3, x86.ACMOVWPL},
+ {"CMOVWPS", LTYPE3, x86.ACMOVWPS},
+ {"FMOVB", LTYPE3, x86.AFMOVB},
+ {"FMOVBP", LTYPE3, x86.AFMOVBP},
+ {"FMOVD", LTYPE3, x86.AFMOVD},
+ {"FMOVDP", LTYPE3, x86.AFMOVDP},
+ {"FMOVF", LTYPE3, x86.AFMOVF},
+ {"FMOVFP", LTYPE3, x86.AFMOVFP},
+ {"FMOVL", LTYPE3, x86.AFMOVL},
+ {"FMOVLP", LTYPE3, x86.AFMOVLP},
+ {"FMOVV", LTYPE3, x86.AFMOVV},
+ {"FMOVVP", LTYPE3, x86.AFMOVVP},
+ {"FMOVW", LTYPE3, x86.AFMOVW},
+ {"FMOVWP", LTYPE3, x86.AFMOVWP},
+ {"FMOVX", LTYPE3, x86.AFMOVX},
+ {"FMOVXP", LTYPE3, x86.AFMOVXP},
+ {"FCMOVCC", LTYPE3, x86.AFCMOVCC},
+ {"FCMOVCS", LTYPE3, x86.AFCMOVCS},
+ {"FCMOVEQ", LTYPE3, x86.AFCMOVEQ},
+ {"FCMOVHI", LTYPE3, x86.AFCMOVHI},
+ {"FCMOVLS", LTYPE3, x86.AFCMOVLS},
+ {"FCMOVNE", LTYPE3, x86.AFCMOVNE},
+ {"FCMOVNU", LTYPE3, x86.AFCMOVNU},
+ {"FCMOVUN", LTYPE3, x86.AFCMOVUN},
+ {"FCOMB", LTYPE3, x86.AFCOMB},
+ {"FCOMBP", LTYPE3, x86.AFCOMBP},
+ {"FCOMD", LTYPE3, x86.AFCOMD},
+ {"FCOMDP", LTYPE3, x86.AFCOMDP},
+ {"FCOMDPP", LTYPE3, x86.AFCOMDPP},
+ {"FCOMF", LTYPE3, x86.AFCOMF},
+ {"FCOMFP", LTYPE3, x86.AFCOMFP},
+ {"FCOMI", LTYPE3, x86.AFCOMI},
+ {"FCOMIP", LTYPE3, x86.AFCOMIP},
+ {"FCOML", LTYPE3, x86.AFCOML},
+ {"FCOMLP", LTYPE3, x86.AFCOMLP},
+ {"FCOMW", LTYPE3, x86.AFCOMW},
+ {"FCOMWP", LTYPE3, x86.AFCOMWP},
+ {"FUCOM", LTYPE3, x86.AFUCOM},
+ {"FUCOMI", LTYPE3, x86.AFUCOMI},
+ {"FUCOMIP", LTYPE3, x86.AFUCOMIP},
+ {"FUCOMP", LTYPE3, x86.AFUCOMP},
+ {"FUCOMPP", LTYPE3, x86.AFUCOMPP},
+ {"FADDW", LTYPE3, x86.AFADDW},
+ {"FADDL", LTYPE3, x86.AFADDL},
+ {"FADDF", LTYPE3, x86.AFADDF},
+ {"FADDD", LTYPE3, x86.AFADDD},
+ {"FADDDP", LTYPE3, x86.AFADDDP},
+ {"FSUBDP", LTYPE3, x86.AFSUBDP},
+ {"FSUBW", LTYPE3, x86.AFSUBW},
+ {"FSUBL", LTYPE3, x86.AFSUBL},
+ {"FSUBF", LTYPE3, x86.AFSUBF},
+ {"FSUBD", LTYPE3, x86.AFSUBD},
+ {"FSUBRDP", LTYPE3, x86.AFSUBRDP},
+ {"FSUBRW", LTYPE3, x86.AFSUBRW},
+ {"FSUBRL", LTYPE3, x86.AFSUBRL},
+ {"FSUBRF", LTYPE3, x86.AFSUBRF},
+ {"FSUBRD", LTYPE3, x86.AFSUBRD},
+ {"FMULDP", LTYPE3, x86.AFMULDP},
+ {"FMULW", LTYPE3, x86.AFMULW},
+ {"FMULL", LTYPE3, x86.AFMULL},
+ {"FMULF", LTYPE3, x86.AFMULF},
+ {"FMULD", LTYPE3, x86.AFMULD},
+ {"FDIVDP", LTYPE3, x86.AFDIVDP},
+ {"FDIVW", LTYPE3, x86.AFDIVW},
+ {"FDIVL", LTYPE3, x86.AFDIVL},
+ {"FDIVF", LTYPE3, x86.AFDIVF},
+ {"FDIVD", LTYPE3, x86.AFDIVD},
+ {"FDIVRDP", LTYPE3, x86.AFDIVRDP},
+ {"FDIVRW", LTYPE3, x86.AFDIVRW},
+ {"FDIVRL", LTYPE3, x86.AFDIVRL},
+ {"FDIVRF", LTYPE3, x86.AFDIVRF},
+ {"FDIVRD", LTYPE3, x86.AFDIVRD},
+ {"FXCHD", LTYPE3, x86.AFXCHD},
+ {"FFREE", LTYPE1, x86.AFFREE},
+ {"FLDCW", LTYPE2, x86.AFLDCW},
+ {"FLDENV", LTYPE1, x86.AFLDENV},
+ {"FRSTOR", LTYPE2, x86.AFRSTOR},
+ {"FSAVE", LTYPE1, x86.AFSAVE},
+ {"FSTCW", LTYPE1, x86.AFSTCW},
+ {"FSTENV", LTYPE1, x86.AFSTENV},
+ {"FSTSW", LTYPE1, x86.AFSTSW},
+ {"F2XM1", LTYPE0, x86.AF2XM1},
+ {"FABS", LTYPE0, x86.AFABS},
+ {"FCHS", LTYPE0, x86.AFCHS},
+ {"FCLEX", LTYPE0, x86.AFCLEX},
+ {"FCOS", LTYPE0, x86.AFCOS},
+ {"FDECSTP", LTYPE0, x86.AFDECSTP},
+ {"FINCSTP", LTYPE0, x86.AFINCSTP},
+ {"FINIT", LTYPE0, x86.AFINIT},
+ {"FLD1", LTYPE0, x86.AFLD1},
+ {"FLDL2E", LTYPE0, x86.AFLDL2E},
+ {"FLDL2T", LTYPE0, x86.AFLDL2T},
+ {"FLDLG2", LTYPE0, x86.AFLDLG2},
+ {"FLDLN2", LTYPE0, x86.AFLDLN2},
+ {"FLDPI", LTYPE0, x86.AFLDPI},
+ {"FLDZ", LTYPE0, x86.AFLDZ},
+ {"FNOP", LTYPE0, x86.AFNOP},
+ {"FPATAN", LTYPE0, x86.AFPATAN},
+ {"FPREM", LTYPE0, x86.AFPREM},
+ {"FPREM1", LTYPE0, x86.AFPREM1},
+ {"FPTAN", LTYPE0, x86.AFPTAN},
+ {"FRNDINT", LTYPE0, x86.AFRNDINT},
+ {"FSCALE", LTYPE0, x86.AFSCALE},
+ {"FSIN", LTYPE0, x86.AFSIN},
+ {"FSINCOS", LTYPE0, x86.AFSINCOS},
+ {"FSQRT", LTYPE0, x86.AFSQRT},
+ {"FTST", LTYPE0, x86.AFTST},
+ {"FXAM", LTYPE0, x86.AFXAM},
+ {"FXTRACT", LTYPE0, x86.AFXTRACT},
+ {"FYL2X", LTYPE0, x86.AFYL2X},
+ {"FYL2XP1", LTYPE0, x86.AFYL2XP1},
+ {"LFENCE", LTYPE0, x86.ALFENCE},
+ {"MFENCE", LTYPE0, x86.AMFENCE},
+ {"SFENCE", LTYPE0, x86.ASFENCE},
+ {"EMMS", LTYPE0, x86.AEMMS},
+ {"PREFETCHT0", LTYPE2, x86.APREFETCHT0},
+ {"PREFETCHT1", LTYPE2, x86.APREFETCHT1},
+ {"PREFETCHT2", LTYPE2, x86.APREFETCHT2},
+ {"PREFETCHNTA", LTYPE2, x86.APREFETCHNTA},
{"UNDEF", LTYPE0, obj.AUNDEF},
- {"ADDPD", LTYPE3, i386.AADDPD},
- {"ADDPS", LTYPE3, i386.AADDPS},
- {"ADDSD", LTYPE3, i386.AADDSD},
- {"ADDSS", LTYPE3, i386.AADDSS},
- {"AESENC", LTYPE3, i386.AAESENC},
- {"ANDNPD", LTYPE3, i386.AANDNPD},
- {"ANDNPS", LTYPE3, i386.AANDNPS},
- {"ANDPD", LTYPE3, i386.AANDPD},
- {"ANDPS", LTYPE3, i386.AANDPS},
- {"CMPPD", LTYPEXC, i386.ACMPPD},
- {"CMPPS", LTYPEXC, i386.ACMPPS},
- {"CMPSD", LTYPEXC, i386.ACMPSD},
- {"CMPSS", LTYPEXC, i386.ACMPSS},
- {"COMISD", LTYPE3, i386.ACOMISD},
- {"COMISS", LTYPE3, i386.ACOMISS},
- {"CVTPL2PD", LTYPE3, i386.ACVTPL2PD},
- {"CVTPL2PS", LTYPE3, i386.ACVTPL2PS},
- {"CVTPD2PL", LTYPE3, i386.ACVTPD2PL},
- {"CVTPD2PS", LTYPE3, i386.ACVTPD2PS},
- {"CVTPS2PL", LTYPE3, i386.ACVTPS2PL},
- {"CVTPS2PD", LTYPE3, i386.ACVTPS2PD},
- {"CVTSD2SL", LTYPE3, i386.ACVTSD2SL},
- {"CVTSD2SS", LTYPE3, i386.ACVTSD2SS},
- {"CVTSL2SD", LTYPE3, i386.ACVTSL2SD},
- {"CVTSL2SS", LTYPE3, i386.ACVTSL2SS},
- {"CVTSS2SD", LTYPE3, i386.ACVTSS2SD},
- {"CVTSS2SL", LTYPE3, i386.ACVTSS2SL},
- {"CVTTPD2PL", LTYPE3, i386.ACVTTPD2PL},
- {"CVTTPS2PL", LTYPE3, i386.ACVTTPS2PL},
- {"CVTTSD2SL", LTYPE3, i386.ACVTTSD2SL},
- {"CVTTSS2SL", LTYPE3, i386.ACVTTSS2SL},
- {"DIVPD", LTYPE3, i386.ADIVPD},
- {"DIVPS", LTYPE3, i386.ADIVPS},
- {"DIVSD", LTYPE3, i386.ADIVSD},
- {"DIVSS", LTYPE3, i386.ADIVSS},
- {"MASKMOVOU", LTYPE3, i386.AMASKMOVOU},
- {"MASKMOVDQU", LTYPE3, i386.AMASKMOVOU}, /* syn */
- {"MAXPD", LTYPE3, i386.AMAXPD},
- {"MAXPS", LTYPE3, i386.AMAXPS},
- {"MAXSD", LTYPE3, i386.AMAXSD},
- {"MAXSS", LTYPE3, i386.AMAXSS},
- {"MINPD", LTYPE3, i386.AMINPD},
- {"MINPS", LTYPE3, i386.AMINPS},
- {"MINSD", LTYPE3, i386.AMINSD},
- {"MINSS", LTYPE3, i386.AMINSS},
- {"MOVAPD", LTYPE3, i386.AMOVAPD},
- {"MOVAPS", LTYPE3, i386.AMOVAPS},
- {"MOVO", LTYPE3, i386.AMOVO},
- {"MOVOA", LTYPE3, i386.AMOVO}, /* syn */
- {"MOVOU", LTYPE3, i386.AMOVOU},
- {"MOVHLPS", LTYPE3, i386.AMOVHLPS},
- {"MOVHPD", LTYPE3, i386.AMOVHPD},
- {"MOVHPS", LTYPE3, i386.AMOVHPS},
- {"MOVLHPS", LTYPE3, i386.AMOVLHPS},
- {"MOVLPD", LTYPE3, i386.AMOVLPD},
- {"MOVLPS", LTYPE3, i386.AMOVLPS},
- {"MOVMSKPD", LTYPE3, i386.AMOVMSKPD},
- {"MOVMSKPS", LTYPE3, i386.AMOVMSKPS},
- {"MOVNTO", LTYPE3, i386.AMOVNTO},
- {"MOVNTDQ", LTYPE3, i386.AMOVNTO}, /* syn */
- {"MOVNTPD", LTYPE3, i386.AMOVNTPD},
- {"MOVNTPS", LTYPE3, i386.AMOVNTPS},
- {"MOVSD", LTYPE3, i386.AMOVSD},
- {"MOVSS", LTYPE3, i386.AMOVSS},
- {"MOVUPD", LTYPE3, i386.AMOVUPD},
- {"MOVUPS", LTYPE3, i386.AMOVUPS},
- {"MULPD", LTYPE3, i386.AMULPD},
- {"MULPS", LTYPE3, i386.AMULPS},
- {"MULSD", LTYPE3, i386.AMULSD},
- {"MULSS", LTYPE3, i386.AMULSS},
- {"ORPD", LTYPE3, i386.AORPD},
- {"ORPS", LTYPE3, i386.AORPS},
- {"PADDQ", LTYPE3, i386.APADDQ},
- {"PAND", LTYPE3, i386.APAND},
- {"PCMPEQB", LTYPE3, i386.APCMPEQB},
- {"PMAXSW", LTYPE3, i386.APMAXSW},
- {"PMAXUB", LTYPE3, i386.APMAXUB},
- {"PMINSW", LTYPE3, i386.APMINSW},
- {"PMINUB", LTYPE3, i386.APMINUB},
- {"PMOVMSKB", LTYPE3, i386.APMOVMSKB},
- {"PSADBW", LTYPE3, i386.APSADBW},
- {"PSHUFB", LTYPE3, i386.APSHUFB},
- {"PSHUFHW", LTYPEX, i386.APSHUFHW},
- {"PSHUFL", LTYPEX, i386.APSHUFL},
- {"PSHUFLW", LTYPEX, i386.APSHUFLW},
- {"PSUBB", LTYPE3, i386.APSUBB},
- {"PSUBL", LTYPE3, i386.APSUBL},
- {"PSUBQ", LTYPE3, i386.APSUBQ},
- {"PSUBSB", LTYPE3, i386.APSUBSB},
- {"PSUBSW", LTYPE3, i386.APSUBSW},
- {"PSUBUSB", LTYPE3, i386.APSUBUSB},
- {"PSUBUSW", LTYPE3, i386.APSUBUSW},
- {"PSUBW", LTYPE3, i386.APSUBW},
- {"PUNPCKHQDQ", LTYPE3, i386.APUNPCKHQDQ},
- {"PUNPCKLQDQ", LTYPE3, i386.APUNPCKLQDQ},
- {"PXOR", LTYPE3, i386.APXOR},
- {"RCPPS", LTYPE3, i386.ARCPPS},
- {"RCPSS", LTYPE3, i386.ARCPSS},
- {"RSQRTPS", LTYPE3, i386.ARSQRTPS},
- {"RSQRTSS", LTYPE3, i386.ARSQRTSS},
- {"SQRTPD", LTYPE3, i386.ASQRTPD},
- {"SQRTPS", LTYPE3, i386.ASQRTPS},
- {"SQRTSD", LTYPE3, i386.ASQRTSD},
- {"SQRTSS", LTYPE3, i386.ASQRTSS},
- {"SUBPD", LTYPE3, i386.ASUBPD},
- {"SUBPS", LTYPE3, i386.ASUBPS},
- {"SUBSD", LTYPE3, i386.ASUBSD},
- {"SUBSS", LTYPE3, i386.ASUBSS},
- {"UCOMISD", LTYPE3, i386.AUCOMISD},
- {"UCOMISS", LTYPE3, i386.AUCOMISS},
- {"UNPCKHPD", LTYPE3, i386.AUNPCKHPD},
- {"UNPCKHPS", LTYPE3, i386.AUNPCKHPS},
- {"UNPCKLPD", LTYPE3, i386.AUNPCKLPD},
- {"UNPCKLPS", LTYPE3, i386.AUNPCKLPS},
- {"XORPD", LTYPE3, i386.AXORPD},
- {"XORPS", LTYPE3, i386.AXORPS},
+ {"ADDPD", LTYPE3, x86.AADDPD},
+ {"ADDPS", LTYPE3, x86.AADDPS},
+ {"ADDSD", LTYPE3, x86.AADDSD},
+ {"ADDSS", LTYPE3, x86.AADDSS},
+ {"AESENC", LTYPE3, x86.AAESENC},
+ {"ANDNPD", LTYPE3, x86.AANDNPD},
+ {"ANDNPS", LTYPE3, x86.AANDNPS},
+ {"ANDPD", LTYPE3, x86.AANDPD},
+ {"ANDPS", LTYPE3, x86.AANDPS},
+ {"CMPPD", LTYPEXC, x86.ACMPPD},
+ {"CMPPS", LTYPEXC, x86.ACMPPS},
+ {"CMPSD", LTYPEXC, x86.ACMPSD},
+ {"CMPSS", LTYPEXC, x86.ACMPSS},
+ {"COMISD", LTYPE3, x86.ACOMISD},
+ {"COMISS", LTYPE3, x86.ACOMISS},
+ {"CVTPL2PD", LTYPE3, x86.ACVTPL2PD},
+ {"CVTPL2PS", LTYPE3, x86.ACVTPL2PS},
+ {"CVTPD2PL", LTYPE3, x86.ACVTPD2PL},
+ {"CVTPD2PS", LTYPE3, x86.ACVTPD2PS},
+ {"CVTPS2PL", LTYPE3, x86.ACVTPS2PL},
+ {"CVTPS2PD", LTYPE3, x86.ACVTPS2PD},
+ {"CVTSD2SL", LTYPE3, x86.ACVTSD2SL},
+ {"CVTSD2SS", LTYPE3, x86.ACVTSD2SS},
+ {"CVTSL2SD", LTYPE3, x86.ACVTSL2SD},
+ {"CVTSL2SS", LTYPE3, x86.ACVTSL2SS},
+ {"CVTSS2SD", LTYPE3, x86.ACVTSS2SD},
+ {"CVTSS2SL", LTYPE3, x86.ACVTSS2SL},
+ {"CVTTPD2PL", LTYPE3, x86.ACVTTPD2PL},
+ {"CVTTPS2PL", LTYPE3, x86.ACVTTPS2PL},
+ {"CVTTSD2SL", LTYPE3, x86.ACVTTSD2SL},
+ {"CVTTSS2SL", LTYPE3, x86.ACVTTSS2SL},
+ {"DIVPD", LTYPE3, x86.ADIVPD},
+ {"DIVPS", LTYPE3, x86.ADIVPS},
+ {"DIVSD", LTYPE3, x86.ADIVSD},
+ {"DIVSS", LTYPE3, x86.ADIVSS},
+ {"MASKMOVOU", LTYPE3, x86.AMASKMOVOU},
+ {"MASKMOVDQU", LTYPE3, x86.AMASKMOVOU}, /* syn */
+ {"MAXPD", LTYPE3, x86.AMAXPD},
+ {"MAXPS", LTYPE3, x86.AMAXPS},
+ {"MAXSD", LTYPE3, x86.AMAXSD},
+ {"MAXSS", LTYPE3, x86.AMAXSS},
+ {"MINPD", LTYPE3, x86.AMINPD},
+ {"MINPS", LTYPE3, x86.AMINPS},
+ {"MINSD", LTYPE3, x86.AMINSD},
+ {"MINSS", LTYPE3, x86.AMINSS},
+ {"MOVAPD", LTYPE3, x86.AMOVAPD},
+ {"MOVAPS", LTYPE3, x86.AMOVAPS},
+ {"MOVO", LTYPE3, x86.AMOVO},
+ {"MOVOA", LTYPE3, x86.AMOVO}, /* syn */
+ {"MOVOU", LTYPE3, x86.AMOVOU},
+ {"MOVHLPS", LTYPE3, x86.AMOVHLPS},
+ {"MOVHPD", LTYPE3, x86.AMOVHPD},
+ {"MOVHPS", LTYPE3, x86.AMOVHPS},
+ {"MOVLHPS", LTYPE3, x86.AMOVLHPS},
+ {"MOVLPD", LTYPE3, x86.AMOVLPD},
+ {"MOVLPS", LTYPE3, x86.AMOVLPS},
+ {"MOVMSKPD", LTYPE3, x86.AMOVMSKPD},
+ {"MOVMSKPS", LTYPE3, x86.AMOVMSKPS},
+ {"MOVNTO", LTYPE3, x86.AMOVNTO},
+ {"MOVNTDQ", LTYPE3, x86.AMOVNTO}, /* syn */
+ {"MOVNTPD", LTYPE3, x86.AMOVNTPD},
+ {"MOVNTPS", LTYPE3, x86.AMOVNTPS},
+ {"MOVSD", LTYPE3, x86.AMOVSD},
+ {"MOVSS", LTYPE3, x86.AMOVSS},
+ {"MOVUPD", LTYPE3, x86.AMOVUPD},
+ {"MOVUPS", LTYPE3, x86.AMOVUPS},
+ {"MULPD", LTYPE3, x86.AMULPD},
+ {"MULPS", LTYPE3, x86.AMULPS},
+ {"MULSD", LTYPE3, x86.AMULSD},
+ {"MULSS", LTYPE3, x86.AMULSS},
+ {"ORPD", LTYPE3, x86.AORPD},
+ {"ORPS", LTYPE3, x86.AORPS},
+ {"PADDQ", LTYPE3, x86.APADDQ},
+ {"PAND", LTYPE3, x86.APAND},
+ {"PCMPEQB", LTYPE3, x86.APCMPEQB},
+ {"PMAXSW", LTYPE3, x86.APMAXSW},
+ {"PMAXUB", LTYPE3, x86.APMAXUB},
+ {"PMINSW", LTYPE3, x86.APMINSW},
+ {"PMINUB", LTYPE3, x86.APMINUB},
+ {"PMOVMSKB", LTYPE3, x86.APMOVMSKB},
+ {"PSADBW", LTYPE3, x86.APSADBW},
+ {"PSHUFB", LTYPE3, x86.APSHUFB},
+ {"PSHUFHW", LTYPEX, x86.APSHUFHW},
+ {"PSHUFL", LTYPEX, x86.APSHUFL},
+ {"PSHUFLW", LTYPEX, x86.APSHUFLW},
+ {"PSUBB", LTYPE3, x86.APSUBB},
+ {"PSUBL", LTYPE3, x86.APSUBL},
+ {"PSUBQ", LTYPE3, x86.APSUBQ},
+ {"PSUBSB", LTYPE3, x86.APSUBSB},
+ {"PSUBSW", LTYPE3, x86.APSUBSW},
+ {"PSUBUSB", LTYPE3, x86.APSUBUSB},
+ {"PSUBUSW", LTYPE3, x86.APSUBUSW},
+ {"PSUBW", LTYPE3, x86.APSUBW},
+ {"PUNPCKHQDQ", LTYPE3, x86.APUNPCKHQDQ},
+ {"PUNPCKLQDQ", LTYPE3, x86.APUNPCKLQDQ},
+ {"PXOR", LTYPE3, x86.APXOR},
+ {"RCPPS", LTYPE3, x86.ARCPPS},
+ {"RCPSS", LTYPE3, x86.ARCPSS},
+ {"RSQRTPS", LTYPE3, x86.ARSQRTPS},
+ {"RSQRTSS", LTYPE3, x86.ARSQRTSS},
+ {"SQRTPD", LTYPE3, x86.ASQRTPD},
+ {"SQRTPS", LTYPE3, x86.ASQRTPS},
+ {"SQRTSD", LTYPE3, x86.ASQRTSD},
+ {"SQRTSS", LTYPE3, x86.ASQRTSS},
+ {"SUBPD", LTYPE3, x86.ASUBPD},
+ {"SUBPS", LTYPE3, x86.ASUBPS},
+ {"SUBSD", LTYPE3, x86.ASUBSD},
+ {"SUBSS", LTYPE3, x86.ASUBSS},
+ {"UCOMISD", LTYPE3, x86.AUCOMISD},
+ {"UCOMISS", LTYPE3, x86.AUCOMISS},
+ {"UNPCKHPD", LTYPE3, x86.AUNPCKHPD},
+ {"UNPCKHPS", LTYPE3, x86.AUNPCKHPS},
+ {"UNPCKLPD", LTYPE3, x86.AUNPCKLPD},
+ {"UNPCKLPS", LTYPE3, x86.AUNPCKLPS},
+ {"XORPD", LTYPE3, x86.AXORPD},
+ {"XORPS", LTYPE3, x86.AXORPS},
{"USEFIELD", LTYPEN, obj.AUSEFIELD},
{"PCDATA", LTYPEPC, obj.APCDATA},
{"FUNCDATA", LTYPEF, obj.AFUNCDATA},
}
func cinit() {
- nullgen.Type = i386.REG_NONE
- nullgen.Index = i386.REG_NONE
+ nullgen.Type = x86.REG_NONE
+ nullgen.Index = x86.REG_NONE
}
func checkscale(scale int16) {