Skip to content

G
go
Commit 8afb3967 authored by Russ Cox's avatar Russ Cox
Browse files
Options

cmd/8g, cmd/old8a: stop renaming x86 import to i386 

Change-Id: If2872e73da4daa4ff1912883d30c8fc9754ef552
Reviewed-on: https://go-review.googlesource.com/6894Reviewed-by: default avatarRob Pike <r@golang.org>
parent 818eff03
Hide whitespace changes
Inline Side-by-side
Showing with 1412 additions and 1413 deletions
src/cmd/8g/cgen.go
View file @ 8afb3967
......@@ -7,7 +7,7 @@ package main
import (
"cmd/internal/gc"
"cmd/internal/obj"
i386 "cmd/internal/obj/x86"
"cmd/internal/obj/x86"
"fmt"
)
......@@ -272,7 +272,7 @@ func cgen(n *gc.Node, res *gc.Node) {
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
}
......@@ -331,7 +331,7 @@ func cgen(n *gc.Node, res *gc.Node) {
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)
......@@ -529,9 +529,9 @@ func igenindex(n *gc.Node, res *gc.Node, bounded int) *obj.Prog {
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)
}
/*
......@@ -565,7 +565,7 @@ func agen(n *gc.Node, res *gc.Node) {
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
......@@ -578,7 +578,7 @@ func agen(n *gc.Node, res *gc.Node) {
}
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
......@@ -746,7 +746,7 @@ func agen(n *gc.Node, res *gc.Node) {
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
......@@ -769,7 +769,7 @@ func agen(n *gc.Node, res *gc.Node) {
} 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
......@@ -858,7 +858,7 @@ func igen(n *gc.Node, a *gc.Node, res *gc.Node) {
// 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
......@@ -914,7 +914,7 @@ func igen(n *gc.Node, a *gc.Node, res *gc.Node) {
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
......@@ -1030,9 +1030,9 @@ func bgen(n *gc.Node, true_ bool, likely int, to *obj.Prog) {
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
......@@ -1228,9 +1228,9 @@ def:
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)
......@@ -1355,9 +1355,9 @@ func sgen(n *gc.Node, res *gc.Node, w int64) {
}
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])
......@@ -1392,40 +1392,40 @@ func sgen(n *gc.Node, res *gc.Node, w int64) {
// 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
......@@ -1435,7 +1435,7 @@ func sgen(n *gc.Node, res *gc.Node, w int64) {
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.
......@@ -1451,13 +1451,13 @@ func sgen(n *gc.Node, res *gc.Node, w int64) {
}
} 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--
}
}
......
src/cmd/8g/cgen64.go
View file @ 8afb3967
......@@ -7,7 +7,7 @@ package main
import (
"cmd/internal/gc"
"cmd/internal/obj"
i386 "cmd/internal/obj/x86"
"cmd/internal/obj/x86"
)
/*
......@@ -31,9 +31,9 @@ func cgen64(n *gc.Node, res *gc.Node) {
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
......@@ -42,8 +42,8 @@ func cgen64(n *gc.Node, res *gc.Node) {
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
......@@ -78,11 +78,11 @@ func cgen64(n *gc.Node, res *gc.Node) {
}
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
......@@ -99,19 +99,19 @@ func cgen64(n *gc.Node, res *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:
......@@ -122,30 +122,30 @@ func cgen64(n *gc.Node, res *gc.Node) {
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)
......@@ -168,22 +168,22 @@ func cgen64(n *gc.Node, res *gc.Node) {
// 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
}
......@@ -196,8 +196,8 @@ func cgen64(n *gc.Node, res *gc.Node) {
}
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
}
......@@ -209,71 +209,71 @@ func cgen64(n *gc.Node, res *gc.Node) {
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:
......@@ -287,12 +287,12 @@ func cgen64(n *gc.Node, res *gc.Node) {
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()
......@@ -310,9 +310,9 @@ func cgen64(n *gc.Node, res *gc.Node) {
}
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()
......@@ -320,71 +320,71 @@ func cgen64(n *gc.Node, res *gc.Node) {
}
// 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)
......@@ -414,10 +414,10 @@ func cgen64(n *gc.Node, res *gc.Node) {
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 {
......@@ -425,32 +425,32 @@ func cgen64(n *gc.Node, res *gc.Node) {
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)
}
}
......@@ -460,11 +460,11 @@ func cgen64(n *gc.Node, res *gc.Node) {
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 {
......@@ -472,11 +472,11 @@ func cgen64(n *gc.Node, res *gc.Node) {
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)
}
}
......@@ -485,8 +485,8 @@ func cgen64(n *gc.Node, res *gc.Node) {
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)
}
......@@ -497,8 +497,8 @@ func cgen64(n *gc.Node, res *gc.Node) {
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()
}
......@@ -521,11 +521,11 @@ func cmp64(nl *gc.Node, nr *gc.Node, op int, likely int, to *obj.Prog) {
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)
}
......@@ -540,14 +540,14 @@ func cmp64(nl *gc.Node, nr *gc.Node, op int, likely int, to *obj.Prog) {
// 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
......@@ -578,11 +578,11 @@ func cmp64(nl *gc.Node, nr *gc.Node, op int, likely int, to *obj.Prog) {
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)
}
......
src/cmd/8g/galign.go
View file @ 8afb3967
......@@ -7,14 +7,14 @@ package main
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() {
}
......@@ -43,8 +43,8 @@ func main() {
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
......
src/cmd/8g/gg.go
View file @ 8afb3967
......@@ -4,7 +4,7 @@
package main
import i386 "cmd/internal/obj/x86"
import "cmd/internal/obj/x86"
import "cmd/internal/gc"
// TODO(rsc):
......@@ -21,7 +21,7 @@ const (
Fpop2 = 1 << 2
)
var reg [i386.MAXREG]uint8
var reg [x86.MAXREG]uint8
var panicdiv *gc.Node
......
src/cmd/8g/ggen.go
View file @ 8afb3967
......@@ -7,7 +7,7 @@ package main
import (
"cmd/internal/gc"
"cmd/internal/obj"
i386 "cmd/internal/obj/x86"
"cmd/internal/obj/x86"
)
func defframe(ptxt *obj.Prog) {
......@@ -65,23 +65,23 @@ func zerorange(p *obj.Prog, frame int64, lo int64, hi int64, ax *uint32) *obj.Pr
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
......@@ -140,7 +140,7 @@ func clearfat(nl *gc.Node) {
break
}
n1.Type = z.Type
gins(i386.AMOVL, &z, &n1)
gins(x86.AMOVL, &z, &n1)
n1.Xoffset += 4
}
......@@ -152,7 +152,7 @@ func clearfat(nl *gc.Node) {
break
}
n1.Type = z.Type
gins(i386.AMOVB, &z, &n1)
gins(x86.AMOVB, &z, &n1)
n1.Xoffset++
}
......@@ -161,14 +161,14 @@ func clearfat(nl *gc.Node) {
}
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
......@@ -178,13 +178,13 @@ func clearfat(nl *gc.Node) {
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--
}
}
......@@ -225,9 +225,9 @@ func ginscall(f *gc.Node, proc int) {
// because the NOP pseudo-instruction will be removed by
// the linker.
var reg gc.Node
gc.Nodreg(&reg, gc.Types[gc.TINT], i386.REG_AX)
gc.Nodreg(&reg, gc.Types[gc.TINT], x86.REG_AX)
gins(i386.AXCHGL, &reg, &reg)
gins(x86.AXCHGL, &reg, &reg)
}
p := gins(obj.ACALL, nil, f)
......@@ -239,9 +239,9 @@ func ginscall(f *gc.Node, proc int) {
}
var reg gc.Node
gc.Nodreg(&reg, gc.Types[gc.Tptr], i386.REG_DX)
gc.Nodreg(&reg, 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)
reg.Op = gc.OINDREG
gmove(&reg, &r1)
......@@ -256,19 +256,19 @@ func ginscall(f *gc.Node, proc int) {
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)
......@@ -277,9 +277,9 @@ func ginscall(f *gc.Node, proc int) {
}
if proc == 2 {
var reg gc.Node
gc.Nodreg(&reg, gc.Types[gc.TINT32], i386.REG_AX)
gins(i386.ATESTL, &reg, &reg)
p := gc.Gbranch(i386.AJEQ, nil, +1)
gc.Nodreg(&reg, gc.Types[gc.TINT32], x86.REG_AX)
gins(x86.ATESTL, &reg, &reg)
p := gc.Gbranch(x86.AJEQ, nil, +1)
cgen_ret(nil)
gc.Patch(p, gc.Pc)
}
......@@ -318,7 +318,7 @@ func cgen_callinter(n *gc.Node, res *gc.Node, proc int) {
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 {
......@@ -351,7 +351,7 @@ func cgen_callinter(n *gc.Node, res *gc.Node, proc int) {
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
......@@ -431,7 +431,7 @@ func cgen_callret(n *gc.Node, res *gc.Node) {
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
......@@ -458,7 +458,7 @@ func cgen_aret(n *gc.Node, res *gc.Node) {
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
......@@ -467,11 +467,11 @@ func cgen_aret(n *gc.Node, res *gc.Node) {
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)
}
}
......@@ -665,10 +665,10 @@ func cgen_div(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
}
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)
......@@ -711,8 +711,8 @@ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) {
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)
}
......@@ -723,7 +723,7 @@ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) {
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
}
......@@ -745,7 +745,7 @@ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) {
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
......@@ -758,7 +758,7 @@ func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *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
......@@ -858,7 +858,7 @@ func cgen_hmul(nl *gc.Node, nr *gc.Node, res *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)
......@@ -866,13 +866,13 @@ func cgen_hmul(nl *gc.Node, nr *gc.Node, res *gc.Node) {
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)
}
......@@ -931,8 +931,8 @@ func cgen_float387(n *gc.Node, res *gc.Node) {
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 {
......@@ -1118,22 +1118,22 @@ x87:
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.
......@@ -1149,9 +1149,9 @@ x87:
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
......@@ -1159,17 +1159,17 @@ x87:
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)
}
......@@ -1205,10 +1205,10 @@ func expandchecks(firstp *obj.Prog) {
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
......@@ -1217,10 +1217,10 @@ func expandchecks(firstp *obj.Prog) {
// 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
......
src/cmd/8g/gsubr.go
View file @ 8afb3967
......@@ -33,7 +33,7 @@ package main
import (
"cmd/internal/gc"
"cmd/internal/obj"
i386 "cmd/internal/obj/x86"
"cmd/internal/obj/x86"
"fmt"
)
......@@ -56,7 +56,7 @@ func optoas(op int, t *gc.Type) int {
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,
......@@ -71,7 +71,7 @@ func optoas(op int, t *gc.Type) int {
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,
......@@ -86,37 +86,37 @@ func optoas(op int, t *gc.Type) int {
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,
......@@ -124,13 +124,13 @@ func optoas(op int, t *gc.Type) int {
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,
......@@ -138,261 +138,261 @@ func optoas(op int, t *gc.Type) int {
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
......@@ -408,40 +408,40 @@ func foptoas(op int, t *gc.Type, flg int) int {
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
......@@ -463,79 +463,79 @@ func foptoas(op int, t *gc.Type, flg int) int {
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)
......@@ -546,23 +546,23 @@ var resvd = []int{
// 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++ {
......@@ -570,19 +570,19 @@ func ginit() {
}
}
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))
}
......@@ -592,7 +592,7 @@ func gclean() {
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
}
......@@ -605,7 +605,7 @@ func anyregalloc() bool {
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
}
......@@ -641,19 +641,19 @@ func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) {
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")
......@@ -662,24 +662,24 @@ func regalloc(n *gc.Node, t *gc.Type, o *gc.Node) {
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")
......@@ -692,12 +692,12 @@ err:
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))
}
......@@ -715,7 +715,7 @@ func regfree(n *gc.Node) {
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) {
......@@ -725,7 +725,7 @@ func regfree(n *gc.Node) {
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))
}
}
......@@ -936,7 +936,7 @@ func gmove(f *gc.Node, t *gc.Node) {
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,
......@@ -946,7 +946,7 @@ func gmove(f *gc.Node, t *gc.Node) {
gc.TUINT16<<16 | gc.TUINT8,
gc.TINT32<<16 | gc.TUINT8,
gc.TUINT32<<16 | gc.TUINT8:
a = i386.AMOVB
a = x86.AMOVB
goto rsrc
......@@ -959,9 +959,9 @@ func gmove(f *gc.Node, t *gc.Node) {
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
......@@ -969,13 +969,13 @@ func gmove(f *gc.Node, t *gc.Node) {
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
......@@ -988,9 +988,9 @@ func gmove(f *gc.Node, t *gc.Node) {
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
......@@ -998,7 +998,7 @@ func gmove(f *gc.Node, t *gc.Node) {
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,
......@@ -1009,9 +1009,9 @@ func gmove(f *gc.Node, t *gc.Node) {
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
......@@ -1027,17 +1027,17 @@ func gmove(f *gc.Node, t *gc.Node) {
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()
......@@ -1049,13 +1049,13 @@ func gmove(f *gc.Node, t *gc.Node) {
*/
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
......@@ -1066,13 +1066,13 @@ func gmove(f *gc.Node, t *gc.Node) {
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
......@@ -1083,7 +1083,7 @@ func gmove(f *gc.Node, t *gc.Node) {
case gc.TINT16<<16 | gc.TINT32, // sign extend int16
gc.TINT16<<16 | gc.TUINT32:
a = i386.AMOVWLSX
a = x86.AMOVWLSX
goto rdst
......@@ -1095,7 +1095,7 @@ func gmove(f *gc.Node, t *gc.Node) {
case gc.TUINT16<<16 | gc.TINT32, // zero extend uint16
gc.TUINT16<<16 | gc.TUINT32:
a = i386.AMOVWLZX
a = x86.AMOVWLZX
goto rdst
......@@ -1112,13 +1112,13 @@ func gmove(f *gc.Node, t *gc.Node) {
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
......@@ -1129,7 +1129,7 @@ func gmove(f *gc.Node, t *gc.Node) {
split64(t, &tlo, &thi)
gmove(f, &tlo)
gins(i386.AMOVL, ncon(0), &thi)
gins(x86.AMOVL, ncon(0), &thi)
splitclean()
return
}
......@@ -1220,11 +1220,11 @@ func floatmove(f *gc.Node, t *gc.Node) {
}
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
......@@ -1233,17 +1233,17 @@ func floatmove(f *gc.Node, t *gc.Node) {
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,
......@@ -1255,36 +1255,36 @@ func floatmove(f *gc.Node, t *gc.Node) {
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)
......@@ -1299,28 +1299,28 @@ func floatmove(f *gc.Node, t *gc.Node) {
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
......@@ -1334,12 +1334,12 @@ func floatmove(f *gc.Node, t *gc.Node) {
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
......@@ -1349,30 +1349,30 @@ func floatmove(f *gc.Node, t *gc.Node) {
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)
......@@ -1381,25 +1381,25 @@ func floatmove(f *gc.Node, t *gc.Node) {
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()
......@@ -1449,12 +1449,12 @@ func floatmove_387(f *gc.Node, t *gc.Node) {
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)
}
}
......@@ -1464,17 +1464,17 @@ func floatmove_387(f *gc.Node, t *gc.Node) {
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.
......@@ -1493,9 +1493,9 @@ func floatmove_387(f *gc.Node, t *gc.Node) {
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)
......@@ -1505,16 +1505,16 @@ func floatmove_387(f *gc.Node, t *gc.Node) {
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)
}
......@@ -1547,13 +1547,13 @@ func floatmove_387(f *gc.Node, t *gc.Node) {
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
......@@ -1589,23 +1589,23 @@ func floatmove_387(f *gc.Node, t *gc.Node) {
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
}
}
......@@ -1614,16 +1614,16 @@ func floatmove_387(f *gc.Node, t *gc.Node) {
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
......@@ -1634,15 +1634,15 @@ func floatmove_387(f *gc.Node, t *gc.Node) {
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
}
......@@ -1713,11 +1713,11 @@ func floatmove_sse(f *gc.Node, t *gc.Node) {
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
......@@ -1744,28 +1744,28 @@ func floatmove_sse(f *gc.Node, t *gc.Node) {
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
}
......@@ -1820,25 +1820,25 @@ func samaddr(f *gc.Node, t *gc.Node) bool {
* 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))
}
......@@ -1865,13 +1865,13 @@ func gins(as int, f *gc.Node, t *gc.Node) *obj.Prog {
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
}
......
src/cmd/8g/peep.go
View file @ 8afb3967
......@@ -33,13 +33,13 @@ package main
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
......@@ -100,20 +100,20 @@ func peep(firstp *obj.Prog) {
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)
......@@ -135,9 +135,9 @@ loop1:
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) {
......@@ -150,66 +150,66 @@ loop1:
}
}
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
......@@ -228,10 +228,10 @@ loop1:
// 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
}
}
}
......@@ -252,7 +252,7 @@ func excise(r *gc.Flow) {
}
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.
......@@ -269,21 +269,21 @@ func elimshortmov(g *gc.Graph) {
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 {
......@@ -292,54 +292,54 @@ func elimshortmov(g *gc.Graph) {
// 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
}
}
}
......@@ -581,7 +581,7 @@ func copyu(p *obj.Prog, v *obj.Addr, s *obj.Addr) int {
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 {
......@@ -601,7 +601,7 @@ func copyu(p *obj.Prog, v *obj.Addr, s *obj.Addr) int {
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
......@@ -666,10 +666,10 @@ func copyu(p *obj.Prog, v *obj.Addr, s *obj.Addr) int {
* 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")
}
......@@ -728,7 +728,7 @@ func copyau(a *obj.Addr, v *obj.Addr) bool {
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)
}
......@@ -740,7 +740,7 @@ func copysub(a *obj.Addr, v *obj.Addr, s *obj.Addr, f int) int {
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 {
......@@ -813,9 +813,9 @@ loop:
}
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
}
src/cmd/8g/prog.go
View file @ 8afb3967
......@@ -7,16 +7,16 @@ package main
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
)
......@@ -30,7 +30,7 @@ var (
// 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},
......@@ -43,217 +43,217 @@ var progtable = [i386.ALAST]gc.ProgInfo{
// 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) {
......@@ -279,13 +279,13 @@ 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))
}
......
src/cmd/8g/reg.go
View file @ 8afb3967
......@@ -30,7 +30,7 @@
package main
import i386 "cmd/internal/obj/x86"
import "cmd/internal/obj/x86"
import "cmd/internal/gc"
const (
......@@ -62,28 +62,28 @@ func regnames(n *int) []string {
}
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 {
......@@ -91,14 +91,14 @@ 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 {
......@@ -106,5 +106,5 @@ 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
}
src/cmd/dist/buildtool.go
View file @ 8afb3967
......@@ -131,8 +131,7 @@ func bootstrapFixImports(text, srcFile string) string {
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)
}
}
......
src/cmd/old8a/lex.go
View file @ 8afb3967
......@@ -35,7 +35,7 @@ package main
import (
"cmd/internal/asm"
"cmd/internal/obj"
i386 "cmd/internal/obj/x86"
"cmd/internal/obj/x86"
)
var (
......@@ -60,7 +60,7 @@ func main() {
asm.Thechar = '8'
asm.Thestring = "386"
asm.Thelinkarch = &i386.Link386
asm.Thelinkarch = &x86.Link386
asm.Main()
}
......@@ -90,620 +90,620 @@ var lexinit = []asm.Lextab{
{"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) {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7