cmd/compile: split Addrconst out of Naddr

There are only three Prog types that we were creating with an OLITERAL
Node: ATEXT, ATYPE, and AFUNCDATA. ATEXT's value we later overwrite in
defframe, and ATYPE's we don't even need. AFUNCDATA only needs integer
constants, so get rid of all the non-int constant logic and skip
creating a Node representation for the constant.

While here, there are a few other Naddr code paths that are no longer
needed, so turn those into Fatalfs.

Passes toolstash/buildall.

Change-Id: I4cc9b92c3011890afd4f31ebeba8b1b42b753cab
Reviewed-on: https://go-review.googlesource.com/30074
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

diff --git a/src/cmd/compile/internal/gc/gsubr.go b/src/cmd/compile/internal/gc/gsubr.go
index 10e94754bea8e8c3854c7178d3f6deb7bbfba722..35f96270d8468c7a1edf9a9aba745f8c9def430b 100644 (file)
--- a/src/cmd/compile/internal/gc/gsubr.go
+++ b/src/cmd/compile/internal/gc/gsubr.go
@@ -177,72 +177,45 @@ func Naddr(a *obj.Addr, n *Node) {
                return
        }
 
-       switch n.Op {
-       default:
-               a := a // copy to let escape into Ctxt.Dconv
+       if n.Op != ONAME {
                Debug['h'] = 1
                Dump("naddr", n)
                Fatalf("naddr: bad %v %v", n.Op, Ctxt.Dconv(a))
+       }
 
-       case ONAME:
-               a.Offset = n.Xoffset
-               s := n.Sym
-               a.Node = n.Orig
-
-               //if(a->node >= (Node*)&n)
-               //      fatal("stack node");
-               if s == nil {
-                       s = lookup(".noname")
-               }
-               if n.Name.Method && n.Type != nil && n.Type.Sym != nil && n.Type.Sym.Pkg != nil {
-                       s = Pkglookup(s.Name, n.Type.Sym.Pkg)
-               }
-
-               a.Type = obj.TYPE_MEM
-               switch n.Class {
-               default:
-                       Fatalf("naddr: ONAME class %v %d\n", n.Sym, n.Class)
-
-               case PEXTERN, PFUNC:
-                       a.Name = obj.NAME_EXTERN
-
-               case PAUTO:
-                       a.Name = obj.NAME_AUTO
+       a.Offset = n.Xoffset
+       s := n.Sym
+       a.Node = n.Orig
 
-               case PPARAM, PPARAMOUT:
-                       a.Name = obj.NAME_PARAM
-               }
-
-               a.Sym = Linksym(s)
+       if s == nil {
+               Fatalf("naddr: nil sym %v", n)
+       }
+       if n.Name.Method && n.Type != nil && n.Type.Sym != nil && n.Type.Sym.Pkg != nil {
+               Fatalf("naddr: weird method %v", n)
+       }
 
-       case OLITERAL:
-               switch u := n.Val().U.(type) {
-               default:
-                       Fatalf("naddr: const %L", n.Type)
+       a.Type = obj.TYPE_MEM
+       switch n.Class {
+       default:
+               Fatalf("naddr: ONAME class %v %d\n", n.Sym, n.Class)
 
-               case *Mpflt:
-                       a.Type = obj.TYPE_FCONST
-                       a.Val = u.Float64()
+       case PEXTERN, PFUNC:
+               a.Name = obj.NAME_EXTERN
 
-               case *Mpint:
-                       a.Sym = nil
-                       a.Type = obj.TYPE_CONST
-                       a.Offset = u.Int64()
+       case PAUTO:
+               a.Name = obj.NAME_AUTO
 
-               case string:
-                       datagostring(u, a)
+       case PPARAM, PPARAMOUT:
+               a.Name = obj.NAME_PARAM
+       }
 
-               case bool:
-                       a.Sym = nil
-                       a.Type = obj.TYPE_CONST
-                       a.Offset = int64(obj.Bool2int(u))
+       a.Sym = Linksym(s)
+}
 
-               case *NilVal:
-                       a.Sym = nil
-                       a.Type = obj.TYPE_CONST
-                       a.Offset = 0
-               }
-       }
+func Addrconst(a *obj.Addr, v int64) {
+       a.Sym = nil
+       a.Type = obj.TYPE_CONST
+       a.Offset = v
 }
 
 func newplist() *obj.Plist {

diff --git a/src/cmd/compile/internal/gc/pgen.go b/src/cmd/compile/internal/gc/pgen.go
index c7530ab7f22a101daf641c722b4662a7f5f4ad5d..9b7cd6ba822859a2705a4bff22d46c459642cdb8 100644 (file)
--- a/src/cmd/compile/internal/gc/pgen.go
+++ b/src/cmd/compile/internal/gc/pgen.go
@@ -17,14 +17,12 @@ import (
 var makefuncdatasym_nsym int
 
 func makefuncdatasym(nameprefix string, funcdatakind int64) *Sym {
-       var nod Node
-
        sym := lookupN(nameprefix, makefuncdatasym_nsym)
        makefuncdatasym_nsym++
        pnod := newname(sym)
        pnod.Class = PEXTERN
-       Nodconst(&nod, Types[TINT32], funcdatakind)
-       Gins(obj.AFUNCDATA, &nod, pnod)
+       p := Gins(obj.AFUNCDATA, nil, pnod)
+       Addrconst(&p.From, funcdatakind)
        return sym
 }
 
@@ -376,13 +374,11 @@ func compile(fn *Node) {
 
        setlineno(Curfn)
 
-       var nod1 Node
-       Nodconst(&nod1, Types[TINT32], 0)
        nam := Curfn.Func.Nname
        if isblank(nam) {
                nam = nil
        }
-       ptxt := Gins(obj.ATEXT, nam, &nod1)
+       ptxt := Gins(obj.ATEXT, nam, nil)
        ptxt.From3 = new(obj.Addr)
        if fn.Func.Dupok {
                ptxt.From3.Offset |= obj.DUPOK
@@ -432,8 +428,7 @@ func compile(fn *Node) {
                }
                switch n.Class {
                case PAUTO, PPARAM, PPARAMOUT:
-                       Nodconst(&nod1, Types[TUINTPTR], n.Type.Width)
-                       p := Gins(obj.ATYPE, n, &nod1)
+                       p := Gins(obj.ATYPE, n, nil)
                        p.From.Gotype = Linksym(ngotype(n))
                }
        }