cmd/5g, etc: prepare Node.Val to be unexported

Remove all uses of Node.Val outside of the gc package.

A subsequent, automated commit in the Go 1.6 cycle
will unexport Node.Val.

No functional changes. Passes toolstash -cmp.

Change-Id: Ia92ae6a7766c83ab3e45c69edab24a9581c824f9
Reviewed-on: https://go-review.googlesource.com/9267
Reviewed-by: Russ Cox <rsc@golang.org>

diff --git a/src/cmd/5g/gsubr.go b/src/cmd/5g/gsubr.go
index db46d6e9ee5e3b84697a930d88eac086490f66ac..2f70bfd468d72c0eafbad679e129eed43e16fd94 100644 (file)
--- a/src/cmd/5g/gsubr.go
+++ b/src/cmd/5g/gsubr.go
@@ -111,7 +111,7 @@ func split64(n *gc.Node, lo *gc.Node, hi *gc.Node) {
 
        case gc.OLITERAL:
                var n1 gc.Node
-               gc.Convconst(&n1, n.Type, &n.Val)
+               n.Convconst(&n1, n.Type)
                i := n1.Int()
                gc.Nodconst(lo, gc.Types[gc.TUINT32], int64(uint32(i)))
                i >>= 32
@@ -160,12 +160,12 @@ func gmove(f *gc.Node, t *gc.Node) {
                var con gc.Node
                switch tt {
                default:
-                       gc.Convconst(&con, t.Type, &f.Val)
+                       f.Convconst(&con, t.Type)
 
                case gc.TINT16,
                        gc.TINT8:
                        var con gc.Node
-                       gc.Convconst(&con, gc.Types[gc.TINT32], &f.Val)
+                       f.Convconst(&con, gc.Types[gc.TINT32])
                        var r1 gc.Node
                        gc.Regalloc(&r1, con.Type, t)
                        gins(arm.AMOVW, &con, &r1)
@@ -176,7 +176,7 @@ func gmove(f *gc.Node, t *gc.Node) {
                case gc.TUINT16,
                        gc.TUINT8:
                        var con gc.Node
-                       gc.Convconst(&con, gc.Types[gc.TUINT32], &f.Val)
+                       f.Convconst(&con, gc.Types[gc.TUINT32])
                        var r1 gc.Node
                        gc.Regalloc(&r1, con.Type, t)
                        gins(arm.AMOVW, &con, &r1)

diff --git a/src/cmd/6g/gsubr.go b/src/cmd/6g/gsubr.go
index 4e54bc8de5e4470aded889e8e60449495d8203d2..9b9141468ee58957aa451250d1821494ebfb3d7b 100644 (file)
--- a/src/cmd/6g/gsubr.go
+++ b/src/cmd/6g/gsubr.go
@@ -160,7 +160,7 @@ func bignodes() {
        gc.Nodconst(&bigi, gc.Types[gc.TUINT64], 0)
        bigi.SetBigInt(&i)
 
-       gc.Convconst(&bigf, gc.Types[gc.TFLOAT64], &bigi.Val)
+       bigi.Convconst(&bigf, gc.Types[gc.TFLOAT64])
 }
 
 /*
@@ -191,7 +191,7 @@ func gmove(f *gc.Node, t *gc.Node) {
        // convert constant to desired type
        if f.Op == gc.OLITERAL {
                var con gc.Node
-               gc.Convconst(&con, t.Type, &f.Val)
+               f.Convconst(&con, t.Type)
                f = &con
                ft = tt // so big switch will choose a simple mov
 

diff --git a/src/cmd/7g/gsubr.go b/src/cmd/7g/gsubr.go
index 2f03b121b45b2af9bc740dec89541c7345a9f28a..0f617079ad178c5c75124839b061c4eedfd3a4dd 100644 (file)
--- a/src/cmd/7g/gsubr.go
+++ b/src/cmd/7g/gsubr.go
@@ -161,13 +161,13 @@ func gmove(f *gc.Node, t *gc.Node) {
                var con gc.Node
                switch tt {
                default:
-                       gc.Convconst(&con, t.Type, &f.Val)
+                       f.Convconst(&con, t.Type)
 
                case gc.TINT32,
                        gc.TINT16,
                        gc.TINT8:
                        var con gc.Node
-                       gc.Convconst(&con, gc.Types[gc.TINT64], &f.Val)
+                       f.Convconst(&con, gc.Types[gc.TINT64])
                        var r1 gc.Node
                        gc.Regalloc(&r1, con.Type, t)
                        gins(arm64.AMOVD, &con, &r1)
@@ -179,7 +179,7 @@ func gmove(f *gc.Node, t *gc.Node) {
                        gc.TUINT16,
                        gc.TUINT8:
                        var con gc.Node
-                       gc.Convconst(&con, gc.Types[gc.TUINT64], &f.Val)
+                       f.Convconst(&con, gc.Types[gc.TUINT64])
                        var r1 gc.Node
                        gc.Regalloc(&r1, con.Type, t)
                        gins(arm64.AMOVD, &con, &r1)
@@ -468,14 +468,13 @@ hard:
 }
 
 func intLiteral(n *gc.Node) (x int64, ok bool) {
-       if n == nil || n.Op != gc.OLITERAL {
+       switch {
+       case n == nil:
                return
-       }
-       switch n.Val.Ctype {
-       case gc.CTINT, gc.CTRUNE:
+       case gc.Isconst(n, gc.CTINT):
                return n.Int(), true
-       case gc.CTBOOL:
-               return int64(obj.Bool2int(n.Val.U.Bval)), true
+       case gc.Isconst(n, gc.CTBOOL):
+               return int64(obj.Bool2int(n.Bool())), true
        }
        return
 }

diff --git a/src/cmd/8g/gsubr.go b/src/cmd/8g/gsubr.go
index 6878883b2895ba46d2921f2744f1e7af66b1eb72..b0b0aedabcf4b11ead968d98cb91b9876070d5ab 100644 (file)
--- a/src/cmd/8g/gsubr.go
+++ b/src/cmd/8g/gsubr.go
@@ -700,7 +700,7 @@ func split64(n *gc.Node, lo *gc.Node, hi *gc.Node) {
 
        case gc.OLITERAL:
                var n1 gc.Node
-               gc.Convconst(&n1, n.Type, &n.Val)
+               n.Convconst(&n1, n.Type)
                i := n1.Int()
                gc.Nodconst(lo, gc.Types[gc.TUINT32], int64(uint32(i)))
                i >>= 32
@@ -737,7 +737,7 @@ func bignodes() {
        bignodes_did = true
 
        gc.Nodconst(&zerof, gc.Types[gc.TINT64], 0)
-       gc.Convconst(&zerof, gc.Types[gc.TFLOAT64], &zerof.Val)
+       zerof.Convconst(&zerof, gc.Types[gc.TFLOAT64])
 
        var i big.Int
        i.SetInt64(1)
@@ -746,12 +746,12 @@ func bignodes() {
 
        gc.Nodconst(&bigi, gc.Types[gc.TUINT64], 0)
        bigi.SetBigInt(&i)
-       gc.Convconst(&two63f, gc.Types[gc.TFLOAT64], &bigi.Val)
+       bigi.Convconst(&two63f, gc.Types[gc.TFLOAT64])
 
        gc.Nodconst(&bigi, gc.Types[gc.TUINT64], 0)
        i.Lsh(&i, 1)
        bigi.SetBigInt(&i)
-       gc.Convconst(&two64f, gc.Types[gc.TFLOAT64], &bigi.Val)
+       bigi.Convconst(&two64f, gc.Types[gc.TFLOAT64])
 }
 
 func memname(n *gc.Node, t *gc.Type) {
@@ -790,7 +790,7 @@ func gmove(f *gc.Node, t *gc.Node) {
        // convert constant to desired type
        if f.Op == gc.OLITERAL {
                var con gc.Node
-               gc.Convconst(&con, t.Type, &f.Val)
+               f.Convconst(&con, t.Type)
                f = &con
                ft = gc.Simsimtype(con.Type)
        }
@@ -1061,7 +1061,7 @@ func floatmove(f *gc.Node, t *gc.Node) {
        // convert constant to desired type
        if f.Op == gc.OLITERAL {
                var con gc.Node
-               gc.Convconst(&con, t.Type, &f.Val)
+               f.Convconst(&con, t.Type)
                f = &con
                ft = gc.Simsimtype(con.Type)
 

diff --git a/src/cmd/9g/gsubr.go b/src/cmd/9g/gsubr.go
index f14f93734c42e689579fe4b21d7bffd45380dea9..3a7c884fd11c5f973d1dc9a82083c1744215cec7 100644 (file)
--- a/src/cmd/9g/gsubr.go
+++ b/src/cmd/9g/gsubr.go
@@ -165,7 +165,7 @@ func bignodes() {
        gc.Nodconst(&bigi, gc.Types[gc.TUINT64], 0)
        bigi.SetBigInt(&i)
 
-       gc.Convconst(&bigf, gc.Types[gc.TFLOAT64], &bigi.Val)
+       bigi.Convconst(&bigf, gc.Types[gc.TFLOAT64])
 }
 
 /*
@@ -200,13 +200,13 @@ func gmove(f *gc.Node, t *gc.Node) {
                var con gc.Node
                switch tt {
                default:
-                       gc.Convconst(&con, t.Type, &f.Val)
+                       f.Convconst(&con, t.Type)
 
                case gc.TINT32,
                        gc.TINT16,
                        gc.TINT8:
                        var con gc.Node
-                       gc.Convconst(&con, gc.Types[gc.TINT64], &f.Val)
+                       f.Convconst(&con, gc.Types[gc.TINT64])
                        var r1 gc.Node
                        gc.Regalloc(&r1, con.Type, t)
                        gins(ppc64.AMOVD, &con, &r1)
@@ -218,7 +218,7 @@ func gmove(f *gc.Node, t *gc.Node) {
                        gc.TUINT16,
                        gc.TUINT8:
                        var con gc.Node
-                       gc.Convconst(&con, gc.Types[gc.TUINT64], &f.Val)
+                       f.Convconst(&con, gc.Types[gc.TUINT64])
                        var r1 gc.Node
                        gc.Regalloc(&r1, con.Type, t)
                        gins(ppc64.AMOVD, &con, &r1)
@@ -546,14 +546,13 @@ hard:
 }
 
 func intLiteral(n *gc.Node) (x int64, ok bool) {
-       if n == nil || n.Op != gc.OLITERAL {
+       switch {
+       case n == nil:
                return
-       }
-       switch n.Val.Ctype {
-       case gc.CTINT, gc.CTRUNE:
+       case gc.Isconst(n, gc.CTINT):
                return n.Int(), true
-       case gc.CTBOOL:
-               return int64(obj.Bool2int(n.Val.U.Bval)), true
+       case gc.Isconst(n, gc.CTBOOL):
+               return int64(obj.Bool2int(n.Bool())), true
        }
        return
 }

diff --git a/src/cmd/internal/gc/const.go b/src/cmd/internal/gc/const.go
index 748752679bc271af41bd0106e286644246fa9790..69f2e5c9045822ba798f0c765d074f9f1bf647b1 100644 (file)
--- a/src/cmd/internal/gc/const.go
+++ b/src/cmd/internal/gc/const.go
@@ -37,6 +37,15 @@ func (n *Node) SetBigInt(x *big.Int) {
        n.Val.U.Xval.Val.Set(x)
 }
 
+// Bool returns n as an bool.
+// n must be an boolean constant.
+func (n *Node) Bool() bool {
+       if !Isconst(n, CTBOOL) {
+               Fatal("Int(%v)", n)
+       }
+       return n.Val.U.Bval
+}
+
 /*
  * truncate float literal fv to 32-bit or 64-bit precision
  * according to type; return truncated value.
@@ -1426,32 +1435,30 @@ func iconv(x int64, et int) int64 {
        return x
 }
 
-/*
- * convert constant val to type t; leave in con.
- * for back end.
- */
-func Convconst(con *Node, t *Type, val *Val) {
+// Convconst converts constant node n to type t and
+// places the result in con.
+func (n *Node) Convconst(con *Node, t *Type) {
        tt := Simsimtype(t)
 
        // copy the constant for conversion
        Nodconst(con, Types[TINT8], 0)
 
        con.Type = t
-       con.Val = *val
+       con.Val = n.Val
 
        if Isint[tt] {
                con.Val.Ctype = CTINT
                con.Val.U.Xval = new(Mpint)
                var i int64
-               switch val.Ctype {
+               switch n.Val.Ctype {
                default:
-                       Fatal("convconst ctype=%d %v", val.Ctype, Tconv(t, obj.FmtLong))
+                       Fatal("convconst ctype=%d %v", n.Val.Ctype, Tconv(t, obj.FmtLong))
 
                case CTINT, CTRUNE:
-                       i = Mpgetfix(val.U.Xval)
+                       i = Mpgetfix(n.Val.U.Xval)
 
                case CTBOOL:
-                       i = int64(obj.Bool2int(val.U.Bval))
+                       i = int64(obj.Bool2int(n.Val.U.Bval))
 
                case CTNIL:
                        i = 0
@@ -1479,7 +1486,6 @@ func Convconst(con *Node, t *Type, val *Val) {
                        con.Val.U.Cval.Real = *truncfltlit(&con.Val.U.Cval.Real, Types[TFLOAT32])
                        con.Val.U.Cval.Imag = *truncfltlit(&con.Val.U.Cval.Imag, Types[TFLOAT32])
                }
-
                return
        }