[dev.power64] code review 152570049: all: merge default into dev.power64

src/cmd/gc/fmt.c

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include        <u.h>
 #include        <libc.h>
 #include        "go.h"
 #include        "opnames.h"
 
 //
@@ skipping 792 matching lines @@
                 if(fmtmode == FExp && n->right == N)
                         break;
 
                 if(n->colas && !complexinit)
                         fmtprint(f, "%N := %N", n->left, n->right);
                 else
                         fmtprint(f, "%N = %N", n->left, n->right);
                 break;
 
         case OASOP:
+                if(n->implicit) {
+                        if(n->etype == OADD)
+                                fmtprint(f, "%N++", n->left);
+                        else
+                                fmtprint(f, "%N--", n->left);
+                        break;
+                }
                 fmtprint(f, "%N %#O= %N", n->left, n->etype, n->right);
                 break;
 
         case OAS2:
                 if(n->colas && !complexinit) {
                         fmtprint(f, "%,H := %,H", n->list, n->rlist);
                         break;
                 }
                 // fallthrough
         case OAS2DOTTYPE:
@@ skipping 278 matching lines @@
                         // be misinterpreted as a unary operator: * or <-.
                         if(isptr[n->type->etype] || (n->type->etype == TCHAN && n->type->chan == Crecv))
                                 return fmtprint(f, "(%T)(%V)", n->type, &n->val);
                         else·
                                 return fmtprint(f, "%T(%V)", n->type, &n->val);
                 }
                 return fmtprint(f, "%V", &n->val);
 
         case ONAME:
                 // Special case: name used as local variable in export.
-                switch(n->class&~PHEAP){
-                case PAUTO:
-                case PPARAM:
-                case PPARAMOUT:
-                        // _ becomes ~b%d internally; print as _ for export
-                        if(fmtmode == FExp && n->sym && n->sym->name[0] == '~' && n->sym->name[1] == 'b')
-                                return fmtprint(f, "_");
-                        if(fmtmode == FExp && n->sym && !isblank(n) && n->vargen > 0)
-                                return fmtprint(f, "%S·%d", n->sym, n->vargen);
-                }
+                // _ becomes ~b%d internally; print as _ for export
+                if(fmtmode == FExp && n->sym && n->sym->name[0] == '~' && n->sym->name[1] == 'b')
+                        return fmtprint(f, "_");
+                if(fmtmode == FExp && n->sym && !isblank(n) && n->vargen > 0)
+                        return fmtprint(f, "%S·%d", n->sym, n->vargen);
 
                 // Special case: explicit name of func (*T) method(...) is turned into pkg.(*T).method,
                 // but for export, this should be rendered as (*pkg.T).meth.
                 // These nodes have the special property that they are names with a left OTYPE and a right ONAME.
                 if(fmtmode == FExp && n->left && n->left->op == OTYPE && n->right && n->right->op == ONAME) {
                         if(isptr[n->left->type->etype])
                                 return fmtprint(f, "(%T).%hhS", n->left->type, n->right->sym);
                         else
                                 return fmtprint(f, "%T.%hhS", n->left->type, n->right->sym);
                 }
@@ skipping 549 matching lines @@
 dumplist(char *s, NodeList *l)
 {
         print("%s%+H\n", s, l);
 }
 
 void
 dump(char *s, Node *n)
 {
         print("%s [%p]%+N\n", s, n, n);
 }