[dev.cc] cmd/new6g etc: reconvert from C

Reconvert using rsc.io/c2go rev 27b3f59.
(Same as last conversion, but C sources have changed
due to merging master into this branch.)

Change-Id: Ib314bb9ac14a726ceb83e2ecf4d1ad2d0b331c38
Reviewed-on: https://go-review.googlesource.com/5471
Reviewed-by: Rob Pike <r@golang.org>

diff --git a/src/cmd/internal/gc/closure.go b/src/cmd/internal/gc/closure.go
index 4c9b0af6f8cb08d80b360631a0afe2b90498796f..c2c802eb2d9bbc63a81d256f61293ff5d931cf90 100644 (file)
--- a/src/cmd/internal/gc/closure.go
+++ b/src/cmd/internal/gc/closure.go
@@ -21,6 +21,7 @@ func closurehdr(ntype *Node) {
        n = Nod(OCLOSURE, nil, nil)
        n.Ntype = ntype
        n.Funcdepth = Funcdepth
+       n.Outerfunc = Curfn
 
        funchdr(n)
 
@@ -133,7 +134,62 @@ func typecheckclosure(func_ *Node, top int) {
        xtop = list(xtop, makeclosure(func_))
 }
 
-var makeclosure_closgen int
+// closurename returns name for OCLOSURE n.
+// It is not as simple as it ought to be, because we typecheck nested closures
+// starting from the innermost one. So when we check the inner closure,
+// we don't yet have name for the outer closure. This function uses recursion
+// to generate names all the way up if necessary.
+
+var closurename_closgen int
+
+func closurename(n *Node) *Sym {
+       var outer string
+       var prefix string
+       var gen int
+
+       if n.Sym != nil {
+               return n.Sym
+       }
+       gen = 0
+       outer = ""
+       prefix = ""
+       if n.Outerfunc == nil {
+               // Global closure.
+               outer = "glob"
+
+               prefix = "func"
+               closurename_closgen++
+               gen = closurename_closgen
+       } else if n.Outerfunc.Op == ODCLFUNC {
+               // The outermost closure inside of a named function.
+               outer = n.Outerfunc.Nname.Sym.Name
+
+               prefix = "func"
+
+               // Yes, functions can be named _.
+               // Can't use function closgen in such case,
+               // because it would lead to name clashes.
+               if !isblank(n.Outerfunc.Nname) {
+                       n.Outerfunc.Closgen++
+                       gen = n.Outerfunc.Closgen
+               } else {
+                       closurename_closgen++
+                       gen = closurename_closgen
+               }
+       } else if n.Outerfunc.Op == OCLOSURE {
+               // Nested closure, recurse.
+               outer = closurename(n.Outerfunc).Name
+
+               prefix = ""
+               n.Outerfunc.Closgen++
+               gen = n.Outerfunc.Closgen
+       } else {
+               Fatal("closurename called for %v", Nconv(n, obj.FmtShort))
+       }
+       namebuf = fmt.Sprintf("%s.%s%d", outer, prefix, gen)
+       n.Sym = Lookup(namebuf)
+       return n.Sym
+}
 
 func makeclosure(func_ *Node) *Node {
        var xtype *Node
@@ -151,9 +207,7 @@ func makeclosure(func_ *Node) *Node {
        // create the function
        xfunc = Nod(ODCLFUNC, nil, nil)
 
-       makeclosure_closgen++
-       namebuf = fmt.Sprintf("func·%.3d", makeclosure_closgen)
-       xfunc.Nname = newname(Lookup(namebuf))
+       xfunc.Nname = newname(closurename(func_))
        xfunc.Nname.Sym.Flags |= SymExported // disable export
        xfunc.Nname.Ntype = xtype
        xfunc.Nname.Defn = xfunc
@@ -412,7 +466,7 @@ func walkclosure(func_ *Node, init **NodeList) *Node {
        // and has one float64 argument and no results,
        // the generated code looks like:
        //
-       //      clos = &struct{F uintptr; A0 *int; A1 *string}{func·001, &i, &s}
+       //      clos = &struct{.F uintptr; i *int; s *string}{func.1, &i, &s}
        //
        // The use of the struct provides type information to the garbage
        // collector so that it can walk the closure. We could use (in this case)
@@ -423,7 +477,7 @@ func walkclosure(func_ *Node, init **NodeList) *Node {
 
        typ = Nod(OTSTRUCT, nil, nil)
 
-       typ.List = list1(Nod(ODCLFIELD, newname(Lookup("F")), typenod(Types[TUINTPTR])))
+       typ.List = list1(Nod(ODCLFIELD, newname(Lookup(".F")), typenod(Types[TUINTPTR])))
        for l = func_.Cvars; l != nil; l = l.Next {
                v = l.N
                if v.Op == OXXX {
@@ -508,13 +562,11 @@ func makepartialcall(fn *Node, t0 *Type, meth *Node) *Node {
        var i int
        var ddd int
 
-       // TODO: names are not right
        rcvrtype = fn.Left.Type
-
        if exportname(meth.Sym.Name) {
-               p = fmt.Sprintf("%v.%s·fm", Tconv(rcvrtype, obj.FmtLeft|obj.FmtShort), meth.Sym.Name)
+               p = fmt.Sprintf("(%v).%s-fm", Tconv(rcvrtype, obj.FmtLeft|obj.FmtShort), meth.Sym.Name)
        } else {
-               p = fmt.Sprintf("%v.(%v)·fm", Tconv(rcvrtype, obj.FmtLeft|obj.FmtShort), Sconv(meth.Sym, obj.FmtLeft))
+               p = fmt.Sprintf("(%v).(%v)-fm", Tconv(rcvrtype, obj.FmtLeft|obj.FmtShort), Sconv(meth.Sym, obj.FmtLeft))
        }
        basetype = rcvrtype
        if Isptr[rcvrtype.Etype] != 0 {

diff --git a/src/cmd/internal/gc/fmt.go b/src/cmd/internal/gc/fmt.go
index 3df4bc32ec36be980582afc6fc38f544dc8337d4..43e5d551375facd18cf0dcc66db21a462af8e479 100644 (file)
--- a/src/cmd/internal/gc/fmt.go
+++ b/src/cmd/internal/gc/fmt.go
@@ -1177,8 +1177,8 @@ var opprec = []int{
        OSEND:         3,
        OANDAND:       2,
        OOROR:         1,
-       OAS:// Statements handled by stmtfmt
-       -1,
+       // Statements handled by stmtfmt
+       OAS:         -1,
        OAS2:        -1,
        OAS2DOTTYPE: -1,
        OAS2FUNC:    -1,

diff --git a/src/cmd/internal/gc/go.go b/src/cmd/internal/gc/go.go
index 16cc4495f7e5878772c7b9b035c44448e5bef210..a1ddb6250da9d981bb8924b85618e0a474cb3384 100644 (file)
--- a/src/cmd/internal/gc/go.go
+++ b/src/cmd/internal/gc/go.go
@@ -203,6 +203,8 @@ type Node struct {
        Dcl            *NodeList
        Inl            *NodeList
        Inldcl         *NodeList
+       Closgen        int
+       Outerfunc      *Node
        Val            Val
        Ntype          *Node
        Defn           *Node

diff --git a/src/cmd/internal/gc/init.go b/src/cmd/internal/gc/init.go
index 2805f3930b4fa5e422ce732c17bcc64c38dfb35f..9202ac5c758f6c255456157371b593bcbadca8af 100644 (file)
--- a/src/cmd/internal/gc/init.go
+++ b/src/cmd/internal/gc/init.go
@@ -24,14 +24,14 @@ import "fmt"
  * it is called by the initialization before
  * main is run. to make it unique within a
  * package and also uncallable, the name,
- * normally "pkg.init", is altered to "pkg.init·1".
+ * normally "pkg.init", is altered to "pkg.init.1".
  */
 
 var renameinit_initgen int
 
 func renameinit() *Sym {
        renameinit_initgen++
-       namebuf = fmt.Sprintf("init·%d", renameinit_initgen)
+       namebuf = fmt.Sprintf("init.%d", renameinit_initgen)
        return Lookup(namebuf)
 }
 
@@ -48,7 +48,7 @@ func renameinit() *Sym {
  *             // over all matching imported symbols
  *                     <pkg>.init()                    (7)
  *             { <init stmts> }                        (8)
- *             init·<n>() // if any                   (9)
+ *             init.<n>() // if any                    (9)
  *             initdone· = 2;                         (10)
  *             return                                  (11)
  *     }
@@ -85,9 +85,8 @@ func anyinit(n *NodeList) bool {
        }
 
        // is there an explicit init function
-       namebuf = fmt.Sprintf("init·1")
+       s = Lookup("init.1")
 
-       s = Lookup(namebuf)
        if s.Def != nil {
                return true
        }
@@ -201,7 +200,7 @@ func fninit(n *NodeList) {
        // (9)
        // could check that it is fn of no args/returns
        for i = 1; ; i++ {
-               namebuf = fmt.Sprintf("init·%d", i)
+               namebuf = fmt.Sprintf("init.%d", i)
                s = Lookup(namebuf)
                if s.Def == nil {
                        break

diff --git a/src/cmd/internal/gc/pgen.go b/src/cmd/internal/gc/pgen.go
index 5d93ee6c05fd093b23d9065a3f095b32c75085d0..c4c0dd4936cf5b5d27ae2c41987642cdb756eb11 100644 (file)
--- a/src/cmd/internal/gc/pgen.go
+++ b/src/cmd/internal/gc/pgen.go
@@ -409,7 +409,7 @@ func compile(fn *Node) {
        dowidth(Curfn.Type)
 
        if fn.Nbody == nil {
-               if pure_go != 0 || strings.HasPrefix(fn.Nname.Sym.Name, "init·") {
+               if pure_go != 0 || strings.HasPrefix(fn.Nname.Sym.Name, "init.") {
                        Yyerror("missing function body", fn)
                        goto ret
                }

diff --git a/src/cmd/internal/gc/reflect.go b/src/cmd/internal/gc/reflect.go
index ba9b75d4d53dfdfe972837eeabea46af4677fa92..ee080404b3f7656714aca8beeb066058ef07f685 100644 (file)
--- a/src/cmd/internal/gc/reflect.go
+++ b/src/cmd/internal/gc/reflect.go
@@ -188,7 +188,7 @@ func mapbucket(t *Type) *Type {
        }
 
        // See comment on hmap.overflow in ../../runtime/hashmap.go.
-       if !haspointers(t.Type) && !haspointers(t.Down) {
+       if !haspointers(t.Type) && !haspointers(t.Down) && t.Type.Width <= MAXKEYSIZE && t.Down.Width <= MAXVALSIZE {
                bucket.Haspointers = 1 // no pointers
        }
 

diff --git a/src/cmd/internal/obj/ppc64/obj9.go b/src/cmd/internal/obj/ppc64/obj9.go
index 7524674dd8ed219605431e4afc27e9a1d7257e37..a2c33f54bba75421760ee48a3e64dbdc2461252a 100644 (file)
--- a/src/cmd/internal/obj/ppc64/obj9.go
+++ b/src/cmd/internal/obj/ppc64/obj9.go
@@ -550,6 +550,7 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym) {
                        if false {
                                // Debug bad returns
                                q = ctxt.NewProg()
+
                                q.As = AMOVD
                                q.Lineno = p.Lineno
                                q.From.Type = obj.TYPE_MEM

diff --git a/src/cmd/new6g/gsubr.go b/src/cmd/new6g/gsubr.go
index 0f50723f969b7f3aed34319715af25e999937810..c440f8c5f7a5cb4fb67fa3da496970a98e0cc7e0 100644 (file)
--- a/src/cmd/new6g/gsubr.go
+++ b/src/cmd/new6g/gsubr.go
@@ -719,9 +719,9 @@ func samaddr(f *gc.Node, t *gc.Node) bool {
 func gins(as int, f *gc.Node, t *gc.Node) *obj.Prog {
        var w int32
        var p *obj.Prog
-       var af obj.Addr
        //      Node nod;
 
+       var af obj.Addr
        var at obj.Addr
 
        //      if(f != N && f->op == OINDEX) {