cmd/compile/internal/gc: introduce type for untyped constant kinds

Change-Id: Ia34b6dd099d07d5e1d4bffe775a20fa92705fdb0
Reviewed-on: https://go-review.googlesource.com/16335
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

diff --git a/src/cmd/compile/internal/gc/bexport.go b/src/cmd/compile/internal/gc/bexport.go
index cb15af08ea506bd870152188f8f5f0ea61d66825..b49f0fb55298bd17ef2aaaf57c5df539bba62edc 100644 (file)
--- a/src/cmd/compile/internal/gc/bexport.go
+++ b/src/cmd/compile/internal/gc/bexport.go
@@ -963,7 +963,7 @@ var tagString = [...]string{
 // untype returns the "pseudo" untyped type for a Ctype (import/export use only).
 // (we can't use an pre-initialized array because we must be sure all types are
 // set up)
-func untype(ctype int) *Type {
+func untype(ctype Ctype) *Type {
        switch ctype {
        case CTINT:
                return idealint

diff --git a/src/cmd/compile/internal/gc/const.go b/src/cmd/compile/internal/gc/const.go
index 87bd9982d89cb3b6ccac33f2c0fe1d52690cc91c..7b1c020fa8af5884b4d764367336de09b891f274 100644 (file)
--- a/src/cmd/compile/internal/gc/const.go
+++ b/src/cmd/compile/internal/gc/const.go
@@ -249,7 +249,7 @@ func convlit1(np **Node, t *Type, explicit bool) {
                if n.Type.Etype == TUNSAFEPTR && t.Etype != TUINTPTR {
                        goto bad
                }
-               ct := int(n.Val().Ctype())
+               ct := n.Val().Ctype()
                if Isint[et] {
                        switch ct {
                        default:
@@ -468,14 +468,14 @@ func tostr(v Val) Val {
        return v
 }
 
-func consttype(n *Node) int {
+func consttype(n *Node) Ctype {
        if n == nil || n.Op != OLITERAL {
                return -1
        }
-       return int(n.Val().Ctype())
+       return n.Val().Ctype()
 }
 
-func Isconst(n *Node, ct int) bool {
+func Isconst(n *Node, ct Ctype) bool {
        t := consttype(n)
 
        // If the caller is asking for CTINT, allow CTRUNE too.
@@ -588,6 +588,17 @@ func evconst(n *Node) {
                wl = TIDEAL
        }
 
+       // avoid constant conversions in switches below
+       const (
+               CTINT_  = uint32(CTINT)
+               CTRUNE_ = uint32(CTRUNE)
+               CTFLT_  = uint32(CTFLT)
+               CTCPLX_ = uint32(CTCPLX)
+               CTSTR_  = uint32(CTSTR)
+               CTBOOL_ = uint32(CTBOOL)
+               CTNIL_  = uint32(CTNIL)
+       )
+
        nr := n.Right
        var rv Val
        var lno int
@@ -609,11 +620,10 @@ func evconst(n *Node) {
                                Yyerror("illegal constant expression %v %v", Oconv(int(n.Op), 0), nl.Type)
                                n.Diag = 1
                        }
-
                        return
 
-               case OCONV<<16 | CTNIL,
-                       OARRAYBYTESTR<<16 | CTNIL:
+               case OCONV<<16 | CTNIL_,
+                       OARRAYBYTESTR<<16 | CTNIL_:
                        if n.Type.Etype == TSTRING {
                                v = tostr(v)
                                nl.Type = n.Type
@@ -622,24 +632,24 @@ func evconst(n *Node) {
                        fallthrough
 
                        // fall through
-               case OCONV<<16 | CTINT,
-                       OCONV<<16 | CTRUNE,
-                       OCONV<<16 | CTFLT,
-                       OCONV<<16 | CTSTR:
+               case OCONV<<16 | CTINT_,
+                       OCONV<<16 | CTRUNE_,
+                       OCONV<<16 | CTFLT_,
+                       OCONV<<16 | CTSTR_:
                        convlit1(&nl, n.Type, true)
 
                        v = nl.Val()
 
-               case OPLUS<<16 | CTINT,
-                       OPLUS<<16 | CTRUNE:
+               case OPLUS<<16 | CTINT_,
+                       OPLUS<<16 | CTRUNE_:
                        break
 
-               case OMINUS<<16 | CTINT,
-                       OMINUS<<16 | CTRUNE:
+               case OMINUS<<16 | CTINT_,
+                       OMINUS<<16 | CTRUNE_:
                        mpnegfix(v.U.(*Mpint))
 
-               case OCOM<<16 | CTINT,
-                       OCOM<<16 | CTRUNE:
+               case OCOM<<16 | CTINT_,
+                       OCOM<<16 | CTRUNE_:
                        et := Txxx
                        if nl.Type != nil {
                                et = int(nl.Type.Etype)
@@ -665,20 +675,20 @@ func evconst(n *Node) {
 
                        mpxorfixfix(v.U.(*Mpint), &b)
 
-               case OPLUS<<16 | CTFLT:
+               case OPLUS<<16 | CTFLT_:
                        break
 
-               case OMINUS<<16 | CTFLT:
+               case OMINUS<<16 | CTFLT_:
                        mpnegflt(v.U.(*Mpflt))
 
-               case OPLUS<<16 | CTCPLX:
+               case OPLUS<<16 | CTCPLX_:
                        break
 
-               case OMINUS<<16 | CTCPLX:
+               case OMINUS<<16 | CTCPLX_:
                        mpnegflt(&v.U.(*Mpcplx).Real)
                        mpnegflt(&v.U.(*Mpcplx).Imag)
 
-               case ONOT<<16 | CTBOOL:
+               case ONOT<<16 | CTBOOL_:
                        if !v.U.(bool) {
                                goto settrue
                        }
@@ -789,20 +799,20 @@ func evconst(n *Node) {
        default:
                goto illegal
 
-       case OADD<<16 | CTINT,
-               OADD<<16 | CTRUNE:
+       case OADD<<16 | CTINT_,
+               OADD<<16 | CTRUNE_:
                mpaddfixfix(v.U.(*Mpint), rv.U.(*Mpint), 0)
 
-       case OSUB<<16 | CTINT,
-               OSUB<<16 | CTRUNE:
+       case OSUB<<16 | CTINT_,
+               OSUB<<16 | CTRUNE_:
                mpsubfixfix(v.U.(*Mpint), rv.U.(*Mpint))
 
-       case OMUL<<16 | CTINT,
-               OMUL<<16 | CTRUNE:
+       case OMUL<<16 | CTINT_,
+               OMUL<<16 | CTRUNE_:
                mpmulfixfix(v.U.(*Mpint), rv.U.(*Mpint))
 
-       case ODIV<<16 | CTINT,
-               ODIV<<16 | CTRUNE:
+       case ODIV<<16 | CTINT_,
+               ODIV<<16 | CTRUNE_:
                if mpcmpfixc(rv.U.(*Mpint), 0) == 0 {
                        Yyerror("division by zero")
                        mpsetovf(v.U.(*Mpint))
@@ -811,8 +821,8 @@ func evconst(n *Node) {
 
                mpdivfixfix(v.U.(*Mpint), rv.U.(*Mpint))
 
-       case OMOD<<16 | CTINT,
-               OMOD<<16 | CTRUNE:
+       case OMOD<<16 | CTINT_,
+               OMOD<<16 | CTRUNE_:
                if mpcmpfixc(rv.U.(*Mpint), 0) == 0 {
                        Yyerror("division by zero")
                        mpsetovf(v.U.(*Mpint))
@@ -821,40 +831,40 @@ func evconst(n *Node) {
 
                mpmodfixfix(v.U.(*Mpint), rv.U.(*Mpint))
 
-       case OLSH<<16 | CTINT,
-               OLSH<<16 | CTRUNE:
+       case OLSH<<16 | CTINT_,
+               OLSH<<16 | CTRUNE_:
                mplshfixfix(v.U.(*Mpint), rv.U.(*Mpint))
 
-       case ORSH<<16 | CTINT,
-               ORSH<<16 | CTRUNE:
+       case ORSH<<16 | CTINT_,
+               ORSH<<16 | CTRUNE_:
                mprshfixfix(v.U.(*Mpint), rv.U.(*Mpint))
 
-       case OOR<<16 | CTINT,
-               OOR<<16 | CTRUNE:
+       case OOR<<16 | CTINT_,
+               OOR<<16 | CTRUNE_:
                mporfixfix(v.U.(*Mpint), rv.U.(*Mpint))
 
-       case OAND<<16 | CTINT,
-               OAND<<16 | CTRUNE:
+       case OAND<<16 | CTINT_,
+               OAND<<16 | CTRUNE_:
                mpandfixfix(v.U.(*Mpint), rv.U.(*Mpint))
 
-       case OANDNOT<<16 | CTINT,
-               OANDNOT<<16 | CTRUNE:
+       case OANDNOT<<16 | CTINT_,
+               OANDNOT<<16 | CTRUNE_:
                mpandnotfixfix(v.U.(*Mpint), rv.U.(*Mpint))
 
-       case OXOR<<16 | CTINT,
-               OXOR<<16 | CTRUNE:
+       case OXOR<<16 | CTINT_,
+               OXOR<<16 | CTRUNE_:
                mpxorfixfix(v.U.(*Mpint), rv.U.(*Mpint))
 
-       case OADD<<16 | CTFLT:
+       case OADD<<16 | CTFLT_:
                mpaddfltflt(v.U.(*Mpflt), rv.U.(*Mpflt))
 
-       case OSUB<<16 | CTFLT:
+       case OSUB<<16 | CTFLT_:
                mpsubfltflt(v.U.(*Mpflt), rv.U.(*Mpflt))
 
-       case OMUL<<16 | CTFLT:
+       case OMUL<<16 | CTFLT_:
                mpmulfltflt(v.U.(*Mpflt), rv.U.(*Mpflt))
 
-       case ODIV<<16 | CTFLT:
+       case ODIV<<16 | CTFLT_:
                if mpcmpfltc(rv.U.(*Mpflt), 0) == 0 {
                        Yyerror("division by zero")
                        Mpmovecflt(v.U.(*Mpflt), 1.0)
@@ -865,7 +875,7 @@ func evconst(n *Node) {
 
                // The default case above would print 'ideal % ideal',
        // which is not quite an ideal error.
-       case OMOD<<16 | CTFLT:
+       case OMOD<<16 | CTFLT_:
                if n.Diag == 0 {
                        Yyerror("illegal constant expression: floating-point %% operation")
                        n.Diag = 1
@@ -873,18 +883,18 @@ func evconst(n *Node) {
 
                return
 
-       case OADD<<16 | CTCPLX:
+       case OADD<<16 | CTCPLX_:
                mpaddfltflt(&v.U.(*Mpcplx).Real, &rv.U.(*Mpcplx).Real)
                mpaddfltflt(&v.U.(*Mpcplx).Imag, &rv.U.(*Mpcplx).Imag)
 
-       case OSUB<<16 | CTCPLX:
+       case OSUB<<16 | CTCPLX_:
                mpsubfltflt(&v.U.(*Mpcplx).Real, &rv.U.(*Mpcplx).Real)
                mpsubfltflt(&v.U.(*Mpcplx).Imag, &rv.U.(*Mpcplx).Imag)
 
-       case OMUL<<16 | CTCPLX:
+       case OMUL<<16 | CTCPLX_:
                cmplxmpy(v.U.(*Mpcplx), rv.U.(*Mpcplx))
 
-       case ODIV<<16 | CTCPLX:
+       case ODIV<<16 | CTCPLX_:
                if mpcmpfltc(&rv.U.(*Mpcplx).Real, 0) == 0 && mpcmpfltc(&rv.U.(*Mpcplx).Imag, 0) == 0 {
                        Yyerror("complex division by zero")
                        Mpmovecflt(&rv.U.(*Mpcplx).Real, 1.0)
@@ -894,157 +904,157 @@ func evconst(n *Node) {
 
                cmplxdiv(v.U.(*Mpcplx), rv.U.(*Mpcplx))
 
-       case OEQ<<16 | CTNIL:
+       case OEQ<<16 | CTNIL_:
                goto settrue
 
-       case ONE<<16 | CTNIL:
+       case ONE<<16 | CTNIL_:
                goto setfalse
 
-       case OEQ<<16 | CTINT,
-               OEQ<<16 | CTRUNE:
+       case OEQ<<16 | CTINT_,
+               OEQ<<16 | CTRUNE_:
                if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) == 0 {
                        goto settrue
                }
                goto setfalse
 
-       case ONE<<16 | CTINT,
-               ONE<<16 | CTRUNE:
+       case ONE<<16 | CTINT_,
+               ONE<<16 | CTRUNE_:
                if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) != 0 {
                        goto settrue
                }
                goto setfalse
 
-       case OLT<<16 | CTINT,
-               OLT<<16 | CTRUNE:
+       case OLT<<16 | CTINT_,
+               OLT<<16 | CTRUNE_:
                if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) < 0 {
                        goto settrue
                }
                goto setfalse
 
-       case OLE<<16 | CTINT,
-               OLE<<16 | CTRUNE:
+       case OLE<<16 | CTINT_,
+               OLE<<16 | CTRUNE_:
                if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) <= 0 {
                        goto settrue
                }
                goto setfalse
 
-       case OGE<<16 | CTINT,
-               OGE<<16 | CTRUNE:
+       case OGE<<16 | CTINT_,
+               OGE<<16 | CTRUNE_:
                if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) >= 0 {
                        goto settrue
                }
                goto setfalse
 
-       case OGT<<16 | CTINT,
-               OGT<<16 | CTRUNE:
+       case OGT<<16 | CTINT_,
+               OGT<<16 | CTRUNE_:
                if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) > 0 {
                        goto settrue
                }
                goto setfalse
 
-       case OEQ<<16 | CTFLT:
+       case OEQ<<16 | CTFLT_:
                if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) == 0 {
                        goto settrue
                }
                goto setfalse
 
-       case ONE<<16 | CTFLT:
+       case ONE<<16 | CTFLT_:
                if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) != 0 {
                        goto settrue
                }
                goto setfalse
 
-       case OLT<<16 | CTFLT:
+       case OLT<<16 | CTFLT_:
                if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) < 0 {
                        goto settrue
                }
                goto setfalse
 
-       case OLE<<16 | CTFLT:
+       case OLE<<16 | CTFLT_:
                if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) <= 0 {
                        goto settrue
                }
                goto setfalse
 
-       case OGE<<16 | CTFLT:
+       case OGE<<16 | CTFLT_:
                if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) >= 0 {
                        goto settrue
                }
                goto setfalse
 
-       case OGT<<16 | CTFLT:
+       case OGT<<16 | CTFLT_:
                if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) > 0 {
                        goto settrue
                }
                goto setfalse
 
-       case OEQ<<16 | CTCPLX:
+       case OEQ<<16 | CTCPLX_:
                if mpcmpfltflt(&v.U.(*Mpcplx).Real, &rv.U.(*Mpcplx).Real) == 0 && mpcmpfltflt(&v.U.(*Mpcplx).Imag, &rv.U.(*Mpcplx).Imag) == 0 {
                        goto settrue
                }
                goto setfalse
 
-       case ONE<<16 | CTCPLX:
+       case ONE<<16 | CTCPLX_:
                if mpcmpfltflt(&v.U.(*Mpcplx).Real, &rv.U.(*Mpcplx).Real) != 0 || mpcmpfltflt(&v.U.(*Mpcplx).Imag, &rv.U.(*Mpcplx).Imag) != 0 {
                        goto settrue
                }
                goto setfalse
 
-       case OEQ<<16 | CTSTR:
+       case OEQ<<16 | CTSTR_:
                if strlit(nl) == strlit(nr) {
                        goto settrue
                }
                goto setfalse
 
-       case ONE<<16 | CTSTR:
+       case ONE<<16 | CTSTR_:
                if strlit(nl) != strlit(nr) {
                        goto settrue
                }
                goto setfalse
 
-       case OLT<<16 | CTSTR:
+       case OLT<<16 | CTSTR_:
                if strlit(nl) < strlit(nr) {
                        goto settrue
                }
                goto setfalse
 
-       case OLE<<16 | CTSTR:
+       case OLE<<16 | CTSTR_:
                if strlit(nl) <= strlit(nr) {
                        goto settrue
                }
                goto setfalse
 
-       case OGE<<16 | CTSTR:
+       case OGE<<16 | CTSTR_:
                if strlit(nl) >= strlit(nr) {
                        goto settrue
                }
                goto setfalse
 
-       case OGT<<16 | CTSTR:
+       case OGT<<16 | CTSTR_:
                if strlit(nl) > strlit(nr) {
                        goto settrue
                }
                goto setfalse
 
-       case OOROR<<16 | CTBOOL:
+       case OOROR<<16 | CTBOOL_:
                if v.U.(bool) || rv.U.(bool) {
                        goto settrue
                }
                goto setfalse
 
-       case OANDAND<<16 | CTBOOL:
+       case OANDAND<<16 | CTBOOL_:
                if v.U.(bool) && rv.U.(bool) {
                        goto settrue
                }
                goto setfalse
 
-       case OEQ<<16 | CTBOOL:
+       case OEQ<<16 | CTBOOL_:
                if v.U.(bool) == rv.U.(bool) {
                        goto settrue
                }
                goto setfalse
 
-       case ONE<<16 | CTBOOL:
+       case ONE<<16 | CTBOOL_:
                if v.U.(bool) != rv.U.(bool) {
                        goto settrue
                }
@@ -1091,8 +1101,6 @@ illegal:
                Yyerror("illegal constant expression: %v %v %v", nl.Type, Oconv(int(n.Op), 0), nr.Type)
                n.Diag = 1
        }
-
-       return
 }
 
 func nodlit(v Val) *Node {
@@ -1138,7 +1146,7 @@ func nodcplxlit(r Val, i Val) *Node {
 
 // idealkind returns a constant kind like consttype
 // but for an arbitrary "ideal" (untyped constant) expression.
-func idealkind(n *Node) int {
+func idealkind(n *Node) Ctype {
        if n == nil || !isideal(n.Type) {
                return CTxxx
        }
@@ -1148,7 +1156,7 @@ func idealkind(n *Node) int {
                return CTxxx
 
        case OLITERAL:
-               return int(n.Val().Ctype())
+               return n.Val().Ctype()
 
                // numeric kinds.
        case OADD,

diff --git a/src/cmd/compile/internal/gc/go.go b/src/cmd/compile/internal/gc/go.go
index 550f332d07a5f693b04e5aa2bf93edc9f01404ae..12f07494b930dae25250788f739d79b32087fff7 100644 (file)
--- a/src/cmd/compile/internal/gc/go.go
+++ b/src/cmd/compile/internal/gc/go.go
@@ -10,8 +10,6 @@ import (
        "cmd/internal/obj"
 )
 
-// avoid <ctype.h>
-
 // The parser's maximum stack size.
 // We have to use a #define macro here since yacc
 // or bison will check for its definition and use
@@ -95,7 +93,7 @@ type Val struct {
 
 type NilVal struct{}
 
-func (v Val) Ctype() int {
+func (v Val) Ctype() Ctype {
        switch x := v.U.(type) {
        default:
                Fatalf("unexpected Ctype for %T", v.U)
@@ -312,8 +310,11 @@ const (
        NTYPE
 )
 
+// Ctype describes the constant kind of an "ideal" (untyped) constant.
+type Ctype int8
+
 const (
-       CTxxx = iota
+       CTxxx Ctype = iota
 
        CTINT
        CTRUNE

diff --git a/src/cmd/compile/internal/gc/swt.go b/src/cmd/compile/internal/gc/swt.go
index 9ed30b2a827d5aea00a5cca5fa636b2eafffe0a5..3600e18268c8a4bc8bab7180cfbc997ee784172a 100644 (file)
--- a/src/cmd/compile/internal/gc/swt.go
+++ b/src/cmd/compile/internal/gc/swt.go
@@ -744,11 +744,11 @@ func exprcmp(c1, c2 *caseClause) int {
        n2 := c2.node.Left
 
        // sort by type (for switches on interface)
-       ct := int(n1.Val().Ctype())
-       if ct > int(n2.Val().Ctype()) {
+       ct := n1.Val().Ctype()
+       if ct > n2.Val().Ctype() {
                return +1
        }
-       if ct < int(n2.Val().Ctype()) {
+       if ct < n2.Val().Ctype() {
                return -1
        }
        if !Eqtype(n1.Type, n2.Type) {