cmd/compile/internal: named types for Etype and Op in struct Node
Type Op is enfored now.
Type EType will need further CLs.
Added TODOs where Node.EType is used as a union type.
The TODOs have the format `TODO(marvin): Fix Node.EType union type.`.
Furthermore:
-The flag of Econv function in fmt.go is removed, since unused.
-Some cleaning along the way, e.g. declare vars first when getting initialized.
Passes go build -toolexec 'toolstash -cmp' -a std.
Fixes #11846
Change-Id: I908b955d5a78a195604970983fb9194bd9e9260b
Reviewed-on: https://go-review.googlesource.com/14956
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Marvin Stenger <marvin.stenger94@gmail.com>
diff --git a/src/cmd/compile/internal/x86/cgen64.go b/src/cmd/compile/internal/x86/cgen64.go
index f1e570d..9dffa61 100644
--- a/src/cmd/compile/internal/x86/cgen64.go
+++ b/src/cmd/compile/internal/x86/cgen64.go
@@ -486,8 +486,8 @@
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)
+ gins(optoas(n.Op, lo1.Type), &lo2, &ax)
+ gins(optoas(n.Op, lo1.Type), &hi2, &dx)
}
if gc.Is64(r.Type) {
@@ -505,7 +505,7 @@
* generate comparison of nl, nr, both 64-bit.
* nl is memory; nr is constant or memory.
*/
-func cmp64(nl *gc.Node, nr *gc.Node, op int, likely int, to *obj.Prog) {
+func cmp64(nl *gc.Node, nr *gc.Node, op gc.Op, likely int, to *obj.Prog) {
var lo1 gc.Node
var hi1 gc.Node
var lo2 gc.Node
diff --git a/src/cmd/compile/internal/x86/ggen.go b/src/cmd/compile/internal/x86/ggen.go
index 85ae808..4e72dcb 100644
--- a/src/cmd/compile/internal/x86/ggen.go
+++ b/src/cmd/compile/internal/x86/ggen.go
@@ -191,7 +191,7 @@
* res = nl % nr
* according to op.
*/
-func dodiv(op int, nl *gc.Node, nr *gc.Node, res *gc.Node, ax *gc.Node, dx *gc.Node) {
+func dodiv(op gc.Op, nl *gc.Node, nr *gc.Node, res *gc.Node, ax *gc.Node, dx *gc.Node) {
// Have to be careful about handling
// most negative int divided by -1 correctly.
// The hardware will trap.
@@ -338,7 +338,7 @@
* res = nl / nr
* res = nl % nr
*/
-func cgen_div(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+func cgen_div(op gc.Op, nl *gc.Node, nr *gc.Node, res *gc.Node) {
if gc.Is64(nl.Type) {
gc.Fatalf("cgen_div %v", nl.Type)
}
@@ -365,7 +365,7 @@
* res = nl << nr
* res = nl >> nr
*/
-func cgen_shift(op int, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) {
+func cgen_shift(op gc.Op, bounded bool, nl *gc.Node, nr *gc.Node, res *gc.Node) {
if nl.Type.Width > 4 {
gc.Fatalf("cgen_shift %v", nl.Type)
}
@@ -489,7 +489,7 @@
* there is no 2-operand byte multiply instruction so
* we do a full-width multiplication and truncate afterwards.
*/
-func cgen_bmul(op int, nl *gc.Node, nr *gc.Node, res *gc.Node) bool {
+func cgen_bmul(op gc.Op, nl *gc.Node, nr *gc.Node, res *gc.Node) bool {
if optoas(op, nl.Type) != x86.AIMULB {
return false
}
@@ -628,18 +628,18 @@
if nl.Ullman >= nr.Ullman {
gc.Cgen(nl, &f0)
if nr.Addable {
- gins(foptoas(int(n.Op), n.Type, 0), nr, &f0)
+ gins(foptoas(n.Op, n.Type, 0), nr, &f0)
} else {
gc.Cgen(nr, &f0)
- gins(foptoas(int(n.Op), n.Type, Fpop), &f0, &f1)
+ gins(foptoas(n.Op, n.Type, Fpop), &f0, &f1)
}
} else {
gc.Cgen(nr, &f0)
if nl.Addable {
- gins(foptoas(int(n.Op), n.Type, Frev), nl, &f0)
+ gins(foptoas(n.Op, n.Type, Frev), nl, &f0)
} else {
gc.Cgen(nl, &f0)
- gins(foptoas(int(n.Op), n.Type, Frev|Fpop), &f0, &f1)
+ gins(foptoas(n.Op, n.Type, Frev|Fpop), &f0, &f1)
}
}
@@ -651,7 +651,7 @@
gc.Cgen(nl, &f0)
if n.Op != gc.OCONV && n.Op != gc.OPLUS {
- gins(foptoas(int(n.Op), n.Type, 0), nil, nil)
+ gins(foptoas(n.Op, n.Type, 0), nil, nil)
}
gmove(&f0, res)
return
@@ -678,7 +678,7 @@
// symmetric binary
case gc.OADD,
gc.OMUL:
- a = foptoas(int(n.Op), nl.Type, 0)
+ a = foptoas(n.Op, nl.Type, 0)
goto sbop
@@ -686,7 +686,7 @@
case gc.OSUB,
gc.OMOD,
gc.ODIV:
- a = foptoas(int(n.Op), nl.Type, 0)
+ a = foptoas(n.Op, nl.Type, 0)
goto abop
}
@@ -729,7 +729,7 @@
func bgen_float(n *gc.Node, wantTrue bool, likely int, to *obj.Prog) {
nl := n.Left
nr := n.Right
- a := int(n.Op)
+ op := n.Op
if !wantTrue {
// brcom is not valid on floats when NaN is involved.
p1 := gc.Gbranch(obj.AJMP, nil, 0)
@@ -745,11 +745,11 @@
}
if gc.Thearch.Use387 {
- a = gc.Brrev(a) // because the args are stacked
- if a == gc.OGE || a == gc.OGT {
+ op = gc.Brrev(op) // because the args are stacked
+ if op == gc.OGE || op == gc.OGT {
// only < and <= work right with NaN; reverse if needed
nl, nr = nr, nl
- a = gc.Brrev(a)
+ op = gc.Brrev(op)
}
var ax, n2, tmp gc.Node
@@ -808,10 +808,10 @@
nl = &n3
}
- if a == gc.OGE || a == gc.OGT {
- // only < and <= work right with NaN; reverse if needed
+ if op == gc.OGE || op == gc.OGT {
+ // only < and <= work right with NopN; reverse if needed
nl, nr = nr, nl
- a = gc.Brrev(a)
+ op = gc.Brrev(op)
}
gins(foptoas(gc.OCMP, nr.Type, 0), nl, nr)
@@ -821,7 +821,7 @@
gc.Regfree(nr)
}
- switch a {
+ switch op {
case gc.OEQ:
// neither NE nor P
p1 := gc.Gbranch(x86.AJNE, nil, -likely)
@@ -834,7 +834,7 @@
gc.Patch(gc.Gbranch(x86.AJNE, nil, likely), to)
gc.Patch(gc.Gbranch(x86.AJPS, nil, likely), to)
default:
- gc.Patch(gc.Gbranch(optoas(a, nr.Type), nil, likely), to)
+ gc.Patch(gc.Gbranch(optoas(op, nr.Type), nil, likely), to)
}
}
diff --git a/src/cmd/compile/internal/x86/gsubr.go b/src/cmd/compile/internal/x86/gsubr.go
index f57bbcb..698f92d 100644
--- a/src/cmd/compile/internal/x86/gsubr.go
+++ b/src/cmd/compile/internal/x86/gsubr.go
@@ -53,402 +53,443 @@
/*
* return Axxx for Oxxx on type t.
*/
-func optoas(op int, t *gc.Type) int {
+func optoas(op gc.Op, t *gc.Type) int {
if t == nil {
gc.Fatalf("optoas: t is nil")
}
+ // avoid constant conversions in switches below
+ const (
+ OMINUS_ = uint32(gc.OMINUS) << 16
+ OLSH_ = uint32(gc.OLSH) << 16
+ ORSH_ = uint32(gc.ORSH) << 16
+ OADD_ = uint32(gc.OADD) << 16
+ OSUB_ = uint32(gc.OSUB) << 16
+ OMUL_ = uint32(gc.OMUL) << 16
+ ODIV_ = uint32(gc.ODIV) << 16
+ OMOD_ = uint32(gc.OMOD) << 16
+ OOR_ = uint32(gc.OOR) << 16
+ OAND_ = uint32(gc.OAND) << 16
+ OXOR_ = uint32(gc.OXOR) << 16
+ OEQ_ = uint32(gc.OEQ) << 16
+ ONE_ = uint32(gc.ONE) << 16
+ OLT_ = uint32(gc.OLT) << 16
+ OLE_ = uint32(gc.OLE) << 16
+ OGE_ = uint32(gc.OGE) << 16
+ OGT_ = uint32(gc.OGT) << 16
+ OCMP_ = uint32(gc.OCMP) << 16
+ OAS_ = uint32(gc.OAS) << 16
+ OHMUL_ = uint32(gc.OHMUL) << 16
+ OADDR_ = uint32(gc.OADDR) << 16
+ OINC_ = uint32(gc.OINC) << 16
+ ODEC_ = uint32(gc.ODEC) << 16
+ OLROT_ = uint32(gc.OLROT) << 16
+ OEXTEND_ = uint32(gc.OEXTEND) << 16
+ OCOM_ = uint32(gc.OCOM) << 16
+ )
+
a := obj.AXXX
switch uint32(op)<<16 | uint32(gc.Simtype[t.Etype]) {
default:
gc.Fatalf("optoas: no entry %v-%v", gc.Oconv(int(op), 0), t)
- case gc.OADDR<<16 | gc.TPTR32:
+ case OADDR_ | gc.TPTR32:
a = x86.ALEAL
- case gc.OEQ<<16 | gc.TBOOL,
- gc.OEQ<<16 | gc.TINT8,
- gc.OEQ<<16 | gc.TUINT8,
- gc.OEQ<<16 | gc.TINT16,
- gc.OEQ<<16 | gc.TUINT16,
- gc.OEQ<<16 | gc.TINT32,
- gc.OEQ<<16 | gc.TUINT32,
- gc.OEQ<<16 | gc.TINT64,
- gc.OEQ<<16 | gc.TUINT64,
- gc.OEQ<<16 | gc.TPTR32,
- gc.OEQ<<16 | gc.TPTR64,
- gc.OEQ<<16 | gc.TFLOAT32,
- gc.OEQ<<16 | gc.TFLOAT64:
+ case OEQ_ | gc.TBOOL,
+ OEQ_ | gc.TINT8,
+ OEQ_ | gc.TUINT8,
+ OEQ_ | gc.TINT16,
+ OEQ_ | gc.TUINT16,
+ OEQ_ | gc.TINT32,
+ OEQ_ | gc.TUINT32,
+ OEQ_ | gc.TINT64,
+ OEQ_ | gc.TUINT64,
+ OEQ_ | gc.TPTR32,
+ OEQ_ | gc.TPTR64,
+ OEQ_ | gc.TFLOAT32,
+ OEQ_ | gc.TFLOAT64:
a = x86.AJEQ
- case gc.ONE<<16 | gc.TBOOL,
- gc.ONE<<16 | gc.TINT8,
- gc.ONE<<16 | gc.TUINT8,
- gc.ONE<<16 | gc.TINT16,
- gc.ONE<<16 | gc.TUINT16,
- gc.ONE<<16 | gc.TINT32,
- gc.ONE<<16 | gc.TUINT32,
- gc.ONE<<16 | gc.TINT64,
- gc.ONE<<16 | gc.TUINT64,
- gc.ONE<<16 | gc.TPTR32,
- gc.ONE<<16 | gc.TPTR64,
- gc.ONE<<16 | gc.TFLOAT32,
- gc.ONE<<16 | gc.TFLOAT64:
+ case ONE_ | gc.TBOOL,
+ ONE_ | gc.TINT8,
+ ONE_ | gc.TUINT8,
+ ONE_ | gc.TINT16,
+ ONE_ | gc.TUINT16,
+ ONE_ | gc.TINT32,
+ ONE_ | gc.TUINT32,
+ ONE_ | gc.TINT64,
+ ONE_ | gc.TUINT64,
+ ONE_ | gc.TPTR32,
+ ONE_ | gc.TPTR64,
+ ONE_ | gc.TFLOAT32,
+ ONE_ | gc.TFLOAT64:
a = x86.AJNE
- case gc.OLT<<16 | gc.TINT8,
- gc.OLT<<16 | gc.TINT16,
- gc.OLT<<16 | gc.TINT32,
- gc.OLT<<16 | gc.TINT64:
+ case OLT_ | gc.TINT8,
+ OLT_ | gc.TINT16,
+ OLT_ | gc.TINT32,
+ OLT_ | gc.TINT64:
a = x86.AJLT
- case gc.OLT<<16 | gc.TUINT8,
- gc.OLT<<16 | gc.TUINT16,
- gc.OLT<<16 | gc.TUINT32,
- gc.OLT<<16 | gc.TUINT64:
+ case OLT_ | gc.TUINT8,
+ OLT_ | gc.TUINT16,
+ OLT_ | gc.TUINT32,
+ OLT_ | gc.TUINT64:
a = x86.AJCS
- case gc.OLE<<16 | gc.TINT8,
- gc.OLE<<16 | gc.TINT16,
- gc.OLE<<16 | gc.TINT32,
- gc.OLE<<16 | gc.TINT64:
+ case OLE_ | gc.TINT8,
+ OLE_ | gc.TINT16,
+ OLE_ | gc.TINT32,
+ OLE_ | gc.TINT64:
a = x86.AJLE
- case gc.OLE<<16 | gc.TUINT8,
- gc.OLE<<16 | gc.TUINT16,
- gc.OLE<<16 | gc.TUINT32,
- gc.OLE<<16 | gc.TUINT64:
+ case OLE_ | gc.TUINT8,
+ OLE_ | gc.TUINT16,
+ OLE_ | gc.TUINT32,
+ OLE_ | gc.TUINT64:
a = x86.AJLS
- case gc.OGT<<16 | gc.TINT8,
- gc.OGT<<16 | gc.TINT16,
- gc.OGT<<16 | gc.TINT32,
- gc.OGT<<16 | gc.TINT64:
+ case OGT_ | gc.TINT8,
+ OGT_ | gc.TINT16,
+ OGT_ | gc.TINT32,
+ OGT_ | gc.TINT64:
a = x86.AJGT
- case gc.OGT<<16 | gc.TUINT8,
- gc.OGT<<16 | gc.TUINT16,
- gc.OGT<<16 | gc.TUINT32,
- gc.OGT<<16 | gc.TUINT64,
- gc.OLT<<16 | gc.TFLOAT32,
- gc.OLT<<16 | gc.TFLOAT64:
+ case OGT_ | gc.TUINT8,
+ OGT_ | gc.TUINT16,
+ OGT_ | gc.TUINT32,
+ OGT_ | gc.TUINT64,
+ OLT_ | gc.TFLOAT32,
+ OLT_ | gc.TFLOAT64:
a = x86.AJHI
- case gc.OGE<<16 | gc.TINT8,
- gc.OGE<<16 | gc.TINT16,
- gc.OGE<<16 | gc.TINT32,
- gc.OGE<<16 | gc.TINT64:
+ case OGE_ | gc.TINT8,
+ OGE_ | gc.TINT16,
+ OGE_ | gc.TINT32,
+ OGE_ | gc.TINT64:
a = x86.AJGE
- case gc.OGE<<16 | gc.TUINT8,
- gc.OGE<<16 | gc.TUINT16,
- gc.OGE<<16 | gc.TUINT32,
- gc.OGE<<16 | gc.TUINT64,
- gc.OLE<<16 | gc.TFLOAT32,
- gc.OLE<<16 | gc.TFLOAT64:
+ case OGE_ | gc.TUINT8,
+ OGE_ | gc.TUINT16,
+ OGE_ | gc.TUINT32,
+ OGE_ | gc.TUINT64,
+ OLE_ | gc.TFLOAT32,
+ OLE_ | gc.TFLOAT64:
a = x86.AJCC
- case gc.OCMP<<16 | gc.TBOOL,
- gc.OCMP<<16 | gc.TINT8,
- gc.OCMP<<16 | gc.TUINT8:
+ case OCMP_ | gc.TBOOL,
+ OCMP_ | gc.TINT8,
+ OCMP_ | gc.TUINT8:
a = x86.ACMPB
- case gc.OCMP<<16 | gc.TINT16,
- gc.OCMP<<16 | gc.TUINT16:
+ case OCMP_ | gc.TINT16,
+ OCMP_ | gc.TUINT16:
a = x86.ACMPW
- case gc.OCMP<<16 | gc.TINT32,
- gc.OCMP<<16 | gc.TUINT32,
- gc.OCMP<<16 | gc.TPTR32:
+ case OCMP_ | gc.TINT32,
+ OCMP_ | gc.TUINT32,
+ OCMP_ | gc.TPTR32:
a = x86.ACMPL
- case gc.OAS<<16 | gc.TBOOL,
- gc.OAS<<16 | gc.TINT8,
- gc.OAS<<16 | gc.TUINT8:
+ case OAS_ | gc.TBOOL,
+ OAS_ | gc.TINT8,
+ OAS_ | gc.TUINT8:
a = x86.AMOVB
- case gc.OAS<<16 | gc.TINT16,
- gc.OAS<<16 | gc.TUINT16:
+ case OAS_ | gc.TINT16,
+ OAS_ | gc.TUINT16:
a = x86.AMOVW
- case gc.OAS<<16 | gc.TINT32,
- gc.OAS<<16 | gc.TUINT32,
- gc.OAS<<16 | gc.TPTR32:
+ case OAS_ | gc.TINT32,
+ OAS_ | gc.TUINT32,
+ OAS_ | gc.TPTR32:
a = x86.AMOVL
- case gc.OAS<<16 | gc.TFLOAT32:
+ case OAS_ | gc.TFLOAT32:
a = x86.AMOVSS
- case gc.OAS<<16 | gc.TFLOAT64:
+ case OAS_ | gc.TFLOAT64:
a = x86.AMOVSD
- case gc.OADD<<16 | gc.TINT8,
- gc.OADD<<16 | gc.TUINT8:
+ case OADD_ | gc.TINT8,
+ OADD_ | gc.TUINT8:
a = x86.AADDB
- case gc.OADD<<16 | gc.TINT16,
- gc.OADD<<16 | gc.TUINT16:
+ case OADD_ | gc.TINT16,
+ OADD_ | gc.TUINT16:
a = x86.AADDW
- case gc.OADD<<16 | gc.TINT32,
- gc.OADD<<16 | gc.TUINT32,
- gc.OADD<<16 | gc.TPTR32:
+ case OADD_ | gc.TINT32,
+ OADD_ | gc.TUINT32,
+ OADD_ | gc.TPTR32:
a = x86.AADDL
- case gc.OSUB<<16 | gc.TINT8,
- gc.OSUB<<16 | gc.TUINT8:
+ case OSUB_ | gc.TINT8,
+ OSUB_ | gc.TUINT8:
a = x86.ASUBB
- case gc.OSUB<<16 | gc.TINT16,
- gc.OSUB<<16 | gc.TUINT16:
+ case OSUB_ | gc.TINT16,
+ OSUB_ | gc.TUINT16:
a = x86.ASUBW
- case gc.OSUB<<16 | gc.TINT32,
- gc.OSUB<<16 | gc.TUINT32,
- gc.OSUB<<16 | gc.TPTR32:
+ case OSUB_ | gc.TINT32,
+ OSUB_ | gc.TUINT32,
+ OSUB_ | gc.TPTR32:
a = x86.ASUBL
- case gc.OINC<<16 | gc.TINT8,
- gc.OINC<<16 | gc.TUINT8:
+ case OINC_ | gc.TINT8,
+ OINC_ | gc.TUINT8:
a = x86.AINCB
- case gc.OINC<<16 | gc.TINT16,
- gc.OINC<<16 | gc.TUINT16:
+ case OINC_ | gc.TINT16,
+ OINC_ | gc.TUINT16:
a = x86.AINCW
- case gc.OINC<<16 | gc.TINT32,
- gc.OINC<<16 | gc.TUINT32,
- gc.OINC<<16 | gc.TPTR32:
+ case OINC_ | gc.TINT32,
+ OINC_ | gc.TUINT32,
+ OINC_ | gc.TPTR32:
a = x86.AINCL
- case gc.ODEC<<16 | gc.TINT8,
- gc.ODEC<<16 | gc.TUINT8:
+ case ODEC_ | gc.TINT8,
+ ODEC_ | gc.TUINT8:
a = x86.ADECB
- case gc.ODEC<<16 | gc.TINT16,
- gc.ODEC<<16 | gc.TUINT16:
+ case ODEC_ | gc.TINT16,
+ ODEC_ | gc.TUINT16:
a = x86.ADECW
- case gc.ODEC<<16 | gc.TINT32,
- gc.ODEC<<16 | gc.TUINT32,
- gc.ODEC<<16 | gc.TPTR32:
+ case ODEC_ | gc.TINT32,
+ ODEC_ | gc.TUINT32,
+ ODEC_ | gc.TPTR32:
a = x86.ADECL
- case gc.OCOM<<16 | gc.TINT8,
- gc.OCOM<<16 | gc.TUINT8:
+ case OCOM_ | gc.TINT8,
+ OCOM_ | gc.TUINT8:
a = x86.ANOTB
- case gc.OCOM<<16 | gc.TINT16,
- gc.OCOM<<16 | gc.TUINT16:
+ case OCOM_ | gc.TINT16,
+ OCOM_ | gc.TUINT16:
a = x86.ANOTW
- case gc.OCOM<<16 | gc.TINT32,
- gc.OCOM<<16 | gc.TUINT32,
- gc.OCOM<<16 | gc.TPTR32:
+ case OCOM_ | gc.TINT32,
+ OCOM_ | gc.TUINT32,
+ OCOM_ | gc.TPTR32:
a = x86.ANOTL
- case gc.OMINUS<<16 | gc.TINT8,
- gc.OMINUS<<16 | gc.TUINT8:
+ case OMINUS_ | gc.TINT8,
+ OMINUS_ | gc.TUINT8:
a = x86.ANEGB
- case gc.OMINUS<<16 | gc.TINT16,
- gc.OMINUS<<16 | gc.TUINT16:
+ case OMINUS_ | gc.TINT16,
+ OMINUS_ | gc.TUINT16:
a = x86.ANEGW
- case gc.OMINUS<<16 | gc.TINT32,
- gc.OMINUS<<16 | gc.TUINT32,
- gc.OMINUS<<16 | gc.TPTR32:
+ case OMINUS_ | gc.TINT32,
+ OMINUS_ | gc.TUINT32,
+ OMINUS_ | gc.TPTR32:
a = x86.ANEGL
- case gc.OAND<<16 | gc.TINT8,
- gc.OAND<<16 | gc.TUINT8:
+ case OAND_ | gc.TINT8,
+ OAND_ | gc.TUINT8:
a = x86.AANDB
- case gc.OAND<<16 | gc.TINT16,
- gc.OAND<<16 | gc.TUINT16:
+ case OAND_ | gc.TINT16,
+ OAND_ | gc.TUINT16:
a = x86.AANDW
- case gc.OAND<<16 | gc.TINT32,
- gc.OAND<<16 | gc.TUINT32,
- gc.OAND<<16 | gc.TPTR32:
+ case OAND_ | gc.TINT32,
+ OAND_ | gc.TUINT32,
+ OAND_ | gc.TPTR32:
a = x86.AANDL
- case gc.OOR<<16 | gc.TINT8,
- gc.OOR<<16 | gc.TUINT8:
+ case OOR_ | gc.TINT8,
+ OOR_ | gc.TUINT8:
a = x86.AORB
- case gc.OOR<<16 | gc.TINT16,
- gc.OOR<<16 | gc.TUINT16:
+ case OOR_ | gc.TINT16,
+ OOR_ | gc.TUINT16:
a = x86.AORW
- case gc.OOR<<16 | gc.TINT32,
- gc.OOR<<16 | gc.TUINT32,
- gc.OOR<<16 | gc.TPTR32:
+ case OOR_ | gc.TINT32,
+ OOR_ | gc.TUINT32,
+ OOR_ | gc.TPTR32:
a = x86.AORL
- case gc.OXOR<<16 | gc.TINT8,
- gc.OXOR<<16 | gc.TUINT8:
+ case OXOR_ | gc.TINT8,
+ OXOR_ | gc.TUINT8:
a = x86.AXORB
- case gc.OXOR<<16 | gc.TINT16,
- gc.OXOR<<16 | gc.TUINT16:
+ case OXOR_ | gc.TINT16,
+ OXOR_ | gc.TUINT16:
a = x86.AXORW
- case gc.OXOR<<16 | gc.TINT32,
- gc.OXOR<<16 | gc.TUINT32,
- gc.OXOR<<16 | gc.TPTR32:
+ case OXOR_ | gc.TINT32,
+ OXOR_ | gc.TUINT32,
+ OXOR_ | gc.TPTR32:
a = x86.AXORL
- case gc.OLROT<<16 | gc.TINT8,
- gc.OLROT<<16 | gc.TUINT8:
+ case OLROT_ | gc.TINT8,
+ OLROT_ | gc.TUINT8:
a = x86.AROLB
- case gc.OLROT<<16 | gc.TINT16,
- gc.OLROT<<16 | gc.TUINT16:
+ case OLROT_ | gc.TINT16,
+ OLROT_ | gc.TUINT16:
a = x86.AROLW
- case gc.OLROT<<16 | gc.TINT32,
- gc.OLROT<<16 | gc.TUINT32,
- gc.OLROT<<16 | gc.TPTR32:
+ case OLROT_ | gc.TINT32,
+ OLROT_ | gc.TUINT32,
+ OLROT_ | gc.TPTR32:
a = x86.AROLL
- case gc.OLSH<<16 | gc.TINT8,
- gc.OLSH<<16 | gc.TUINT8:
+ case OLSH_ | gc.TINT8,
+ OLSH_ | gc.TUINT8:
a = x86.ASHLB
- case gc.OLSH<<16 | gc.TINT16,
- gc.OLSH<<16 | gc.TUINT16:
+ case OLSH_ | gc.TINT16,
+ OLSH_ | gc.TUINT16:
a = x86.ASHLW
- case gc.OLSH<<16 | gc.TINT32,
- gc.OLSH<<16 | gc.TUINT32,
- gc.OLSH<<16 | gc.TPTR32:
+ case OLSH_ | gc.TINT32,
+ OLSH_ | gc.TUINT32,
+ OLSH_ | gc.TPTR32:
a = x86.ASHLL
- case gc.ORSH<<16 | gc.TUINT8:
+ case ORSH_ | gc.TUINT8:
a = x86.ASHRB
- case gc.ORSH<<16 | gc.TUINT16:
+ case ORSH_ | gc.TUINT16:
a = x86.ASHRW
- case gc.ORSH<<16 | gc.TUINT32,
- gc.ORSH<<16 | gc.TPTR32:
+ case ORSH_ | gc.TUINT32,
+ ORSH_ | gc.TPTR32:
a = x86.ASHRL
- case gc.ORSH<<16 | gc.TINT8:
+ case ORSH_ | gc.TINT8:
a = x86.ASARB
- case gc.ORSH<<16 | gc.TINT16:
+ case ORSH_ | gc.TINT16:
a = x86.ASARW
- case gc.ORSH<<16 | gc.TINT32:
+ case ORSH_ | gc.TINT32:
a = x86.ASARL
- case gc.OHMUL<<16 | gc.TINT8,
- gc.OMUL<<16 | gc.TINT8,
- gc.OMUL<<16 | gc.TUINT8:
+ case OHMUL_ | gc.TINT8,
+ OMUL_ | gc.TINT8,
+ OMUL_ | gc.TUINT8:
a = x86.AIMULB
- case gc.OHMUL<<16 | gc.TINT16,
- gc.OMUL<<16 | gc.TINT16,
- gc.OMUL<<16 | gc.TUINT16:
+ case OHMUL_ | gc.TINT16,
+ OMUL_ | gc.TINT16,
+ OMUL_ | gc.TUINT16:
a = x86.AIMULW
- case gc.OHMUL<<16 | gc.TINT32,
- gc.OMUL<<16 | gc.TINT32,
- gc.OMUL<<16 | gc.TUINT32,
- gc.OMUL<<16 | gc.TPTR32:
+ case OHMUL_ | gc.TINT32,
+ OMUL_ | gc.TINT32,
+ OMUL_ | gc.TUINT32,
+ OMUL_ | gc.TPTR32:
a = x86.AIMULL
- case gc.OHMUL<<16 | gc.TUINT8:
+ case OHMUL_ | gc.TUINT8:
a = x86.AMULB
- case gc.OHMUL<<16 | gc.TUINT16:
+ case OHMUL_ | gc.TUINT16:
a = x86.AMULW
- case gc.OHMUL<<16 | gc.TUINT32,
- gc.OHMUL<<16 | gc.TPTR32:
+ case OHMUL_ | gc.TUINT32,
+ OHMUL_ | gc.TPTR32:
a = x86.AMULL
- case gc.ODIV<<16 | gc.TINT8,
- gc.OMOD<<16 | gc.TINT8:
+ case ODIV_ | gc.TINT8,
+ OMOD_ | gc.TINT8:
a = x86.AIDIVB
- case gc.ODIV<<16 | gc.TUINT8,
- gc.OMOD<<16 | gc.TUINT8:
+ case ODIV_ | gc.TUINT8,
+ OMOD_ | gc.TUINT8:
a = x86.ADIVB
- case gc.ODIV<<16 | gc.TINT16,
- gc.OMOD<<16 | gc.TINT16:
+ case ODIV_ | gc.TINT16,
+ OMOD_ | gc.TINT16:
a = x86.AIDIVW
- case gc.ODIV<<16 | gc.TUINT16,
- gc.OMOD<<16 | gc.TUINT16:
+ case ODIV_ | gc.TUINT16,
+ OMOD_ | gc.TUINT16:
a = x86.ADIVW
- case gc.ODIV<<16 | gc.TINT32,
- gc.OMOD<<16 | gc.TINT32:
+ case ODIV_ | gc.TINT32,
+ OMOD_ | gc.TINT32:
a = x86.AIDIVL
- case gc.ODIV<<16 | gc.TUINT32,
- gc.ODIV<<16 | gc.TPTR32,
- gc.OMOD<<16 | gc.TUINT32,
- gc.OMOD<<16 | gc.TPTR32:
+ case ODIV_ | gc.TUINT32,
+ ODIV_ | gc.TPTR32,
+ OMOD_ | gc.TUINT32,
+ OMOD_ | gc.TPTR32:
a = x86.ADIVL
- case gc.OEXTEND<<16 | gc.TINT16:
+ case OEXTEND_ | gc.TINT16:
a = x86.ACWD
- case gc.OEXTEND<<16 | gc.TINT32:
+ case OEXTEND_ | gc.TINT32:
a = x86.ACDQ
}
return a
}
-func foptoas(op int, t *gc.Type, flg int) int {
+func foptoas(op gc.Op, t *gc.Type, flg int) int {
a := obj.AXXX
- et := int(gc.Simtype[t.Etype])
+ et := gc.Simtype[t.Etype]
+
+ // avoid constant conversions in switches below
+ const (
+ OCMP_ = uint32(gc.OCMP) << 16
+ OAS_ = uint32(gc.OAS) << 16
+ OADD_ = uint32(gc.OADD) << 16
+ OSUB_ = uint32(gc.OSUB) << 16
+ OMUL_ = uint32(gc.OMUL) << 16
+ ODIV_ = uint32(gc.ODIV) << 16
+ OMINUS_ = uint32(gc.OMINUS) << 16
+ )
if !gc.Thearch.Use387 {
switch uint32(op)<<16 | uint32(et) {
default:
gc.Fatalf("foptoas-sse: no entry %v-%v", gc.Oconv(int(op), 0), t)
- case gc.OCMP<<16 | gc.TFLOAT32:
+ case OCMP_ | gc.TFLOAT32:
a = x86.AUCOMISS
- case gc.OCMP<<16 | gc.TFLOAT64:
+ case OCMP_ | gc.TFLOAT64:
a = x86.AUCOMISD
- case gc.OAS<<16 | gc.TFLOAT32:
+ case OAS_ | gc.TFLOAT32:
a = x86.AMOVSS
- case gc.OAS<<16 | gc.TFLOAT64:
+ case OAS_ | gc.TFLOAT64:
a = x86.AMOVSD
- case gc.OADD<<16 | gc.TFLOAT32:
+ case OADD_ | gc.TFLOAT32:
a = x86.AADDSS
- case gc.OADD<<16 | gc.TFLOAT64:
+ case OADD_ | gc.TFLOAT64:
a = x86.AADDSD
- case gc.OSUB<<16 | gc.TFLOAT32:
+ case OSUB_ | gc.TFLOAT32:
a = x86.ASUBSS
- case gc.OSUB<<16 | gc.TFLOAT64:
+ case OSUB_ | gc.TFLOAT64:
a = x86.ASUBSD
- case gc.OMUL<<16 | gc.TFLOAT32:
+ case OMUL_ | gc.TFLOAT32:
a = x86.AMULSS
- case gc.OMUL<<16 | gc.TFLOAT64:
+ case OMUL_ | gc.TFLOAT64:
a = x86.AMULSD
- case gc.ODIV<<16 | gc.TFLOAT32:
+ case ODIV_ | gc.TFLOAT32:
a = x86.ADIVSS
- case gc.ODIV<<16 | gc.TFLOAT64:
+ case ODIV_ | gc.TFLOAT64:
a = x86.ADIVSD
}
@@ -470,79 +511,79 @@
}
switch uint32(op)<<16 | (uint32(et)<<8 | uint32(flg)) {
- case gc.OADD<<16 | (gc.TFLOAT32<<8 | 0):
+ case OADD_ | (gc.TFLOAT32<<8 | 0):
return x86.AFADDF
- case gc.OADD<<16 | (gc.TFLOAT64<<8 | 0):
+ case OADD_ | (gc.TFLOAT64<<8 | 0):
return x86.AFADDD
- case gc.OADD<<16 | (gc.TFLOAT64<<8 | Fpop):
+ case OADD_ | (gc.TFLOAT64<<8 | Fpop):
return x86.AFADDDP
- case gc.OSUB<<16 | (gc.TFLOAT32<<8 | 0):
+ case OSUB_ | (gc.TFLOAT32<<8 | 0):
return x86.AFSUBF
- case gc.OSUB<<16 | (gc.TFLOAT32<<8 | Frev):
+ case OSUB_ | (gc.TFLOAT32<<8 | Frev):
return x86.AFSUBRF
- case gc.OSUB<<16 | (gc.TFLOAT64<<8 | 0):
+ case OSUB_ | (gc.TFLOAT64<<8 | 0):
return x86.AFSUBD
- case gc.OSUB<<16 | (gc.TFLOAT64<<8 | Frev):
+ case OSUB_ | (gc.TFLOAT64<<8 | Frev):
return x86.AFSUBRD
- case gc.OSUB<<16 | (gc.TFLOAT64<<8 | Fpop):
+ case OSUB_ | (gc.TFLOAT64<<8 | Fpop):
return x86.AFSUBDP
- case gc.OSUB<<16 | (gc.TFLOAT64<<8 | (Fpop | Frev)):
+ case OSUB_ | (gc.TFLOAT64<<8 | (Fpop | Frev)):
return x86.AFSUBRDP
- case gc.OMUL<<16 | (gc.TFLOAT32<<8 | 0):
+ case OMUL_ | (gc.TFLOAT32<<8 | 0):
return x86.AFMULF
- case gc.OMUL<<16 | (gc.TFLOAT64<<8 | 0):
+ case OMUL_ | (gc.TFLOAT64<<8 | 0):
return x86.AFMULD
- case gc.OMUL<<16 | (gc.TFLOAT64<<8 | Fpop):
+ case OMUL_ | (gc.TFLOAT64<<8 | Fpop):
return x86.AFMULDP
- case gc.ODIV<<16 | (gc.TFLOAT32<<8 | 0):
+ case ODIV_ | (gc.TFLOAT32<<8 | 0):
return x86.AFDIVF
- case gc.ODIV<<16 | (gc.TFLOAT32<<8 | Frev):
+ case ODIV_ | (gc.TFLOAT32<<8 | Frev):
return x86.AFDIVRF
- case gc.ODIV<<16 | (gc.TFLOAT64<<8 | 0):
+ case ODIV_ | (gc.TFLOAT64<<8 | 0):
return x86.AFDIVD
- case gc.ODIV<<16 | (gc.TFLOAT64<<8 | Frev):
+ case ODIV_ | (gc.TFLOAT64<<8 | Frev):
return x86.AFDIVRD
- case gc.ODIV<<16 | (gc.TFLOAT64<<8 | Fpop):
+ case ODIV_ | (gc.TFLOAT64<<8 | Fpop):
return x86.AFDIVDP
- case gc.ODIV<<16 | (gc.TFLOAT64<<8 | (Fpop | Frev)):
+ case ODIV_ | (gc.TFLOAT64<<8 | (Fpop | Frev)):
return x86.AFDIVRDP
- case gc.OCMP<<16 | (gc.TFLOAT32<<8 | 0):
+ case OCMP_ | (gc.TFLOAT32<<8 | 0):
return x86.AFCOMF
- case gc.OCMP<<16 | (gc.TFLOAT32<<8 | Fpop):
+ case OCMP_ | (gc.TFLOAT32<<8 | Fpop):
return x86.AFCOMFP
- case gc.OCMP<<16 | (gc.TFLOAT64<<8 | 0):
+ case OCMP_ | (gc.TFLOAT64<<8 | 0):
return x86.AFCOMD
- case gc.OCMP<<16 | (gc.TFLOAT64<<8 | Fpop):
+ case OCMP_ | (gc.TFLOAT64<<8 | Fpop):
return x86.AFCOMDP
- case gc.OCMP<<16 | (gc.TFLOAT64<<8 | Fpop2):
+ case OCMP_ | (gc.TFLOAT64<<8 | Fpop2):
return x86.AFCOMDPP
- case gc.OMINUS<<16 | (gc.TFLOAT32<<8 | 0):
+ case OMINUS_ | (gc.TFLOAT32<<8 | 0):
return x86.AFCHS
- case gc.OMINUS<<16 | (gc.TFLOAT64<<8 | 0):
+ case OMINUS_ | (gc.TFLOAT64<<8 | 0):
return x86.AFCHS
}
@@ -583,8 +624,8 @@
gins(as, &n1, n2)
}
-func ginscmp(op int, t *gc.Type, n1, n2 *gc.Node, likely int) *obj.Prog {
- if gc.Isint[t.Etype] || int(t.Etype) == gc.Tptr {
+func ginscmp(op gc.Op, t *gc.Type, n1, n2 *gc.Node, likely int) *obj.Prog {
+ if gc.Isint[t.Etype] || t.Etype == gc.Tptr {
if (n1.Op == gc.OLITERAL || n1.Op == gc.OADDR && n1.Left.Op == gc.ONAME) && n2.Op != gc.OLITERAL {
// Reverse comparison to place constant (including address constant) last.
op = gc.Brrev(op)
