[dev.power64] code review 160200044: build: merge default into dev.power64

src/cmd/gc/order.c

 // Copyright 2012 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.
 
 // Rewrite tree to use separate statements to enforce
 // order of evaluation.  Makes walk easier, because it
 // can (after this runs) reorder at will within an expression.
 //
 // Rewrite x op= y into x = x op y.
 //
@@ skipping 575 matching lines @@
 
         case OAS2RECV:
                 // Special: avoid copy of receive.
                 // Use temporary variables to hold result,
                 // so that chanrecv can take address of temporary.
                 t = marktemp(order);
                 orderexprlist(n->list, order);
                 orderexpr(&n->rlist->n->left, order);  // arg to recv
                 ch = n->rlist->n->left->type;
                 tmp1 = ordertemp(ch->type, order, haspointers(ch->type));
-                tmp2 = ordertemp(types[TBOOL], order, 0);
+                if(!isblank(n->list->next->n))
+                        tmp2 = ordertemp(n->list->next->n->type, order, 0);
+                else
+                        tmp2 = ordertemp(types[TBOOL], order, 0);
                 order->out = list(order->out, n);
                 r = nod(OAS, n->list->n, tmp1);
                 typecheck(&r, Etop);
                 ordermapassign(r, order);
                 r = nod(OAS, n->list->next->n, tmp2);
                 typecheck(&r, Etop);
                 ordermapassign(r, order);
                 n->list = list(list1(tmp1), tmp2);
                 cleantemp(t, order);
                 break;
@@ skipping 154 matching lines @@
 
         case ORETURN:
                 ordercallargs(&n->list, order);
                 order->out = list(order->out, n);
                 break;
 ········
         case OSELECT:
                 // Special: clean case temporaries in each block entry.
                 // Select must enter one of its blocks, so there is no
                 // need for a cleaning at the end.
+                // Doubly special: evaluation order for select is stricter
+                // than ordinary expressions. Even something like p.c
+                // has to be hoisted into a temporary, so that it cannot be
+                // reordered after the channel evaluation for a different
+                // case (if p were nil, then the timing of the fault would
+                // give this away).
                 t = marktemp(order);
                 for(l=n->list; l; l=l->next) {
                         if(l->n->op != OXCASE)
                                 fatal("order select case %O", l->n->op);
                         r = l->n->left;
                         setlineno(l->n);
                         // Append any new body prologue to ninit.
                         // The next loop will insert ninit into nbody.
                         if(l->n->ninit != nil)
                                 fatal("order select ninit");
@@ skipping 22 matching lines @@
                                         if(r->ninit != nil) {
                                                 yyerror("ninit on select recv");
                                                 dumplist("ninit", r->ninit);
                                         }
                                         // case x = <-c
                                         // case x, ok = <-c
                                         // r->left is x, r->ntest is ok, r->right is ORECV, r->right->left is c.
                                         // r->left == N means 'case <-c'.
                                         // c is always evaluated; x and ok are only evaluated when assigned.
                                         orderexpr(&r->right->left, order);
+                                        if(r->right->left->op != ONAME)
+                                                r->right->left = ordercopyexpr(r->right->left, r->right->left->type, order, 0);
 
                                         // Introduce temporary for receive and move actual copy into case body.
                                         // avoids problems with target being addressed, as usual.
                                         // NOTE: If we wanted to be clever, we could arrange for just one
                                         // temporary per distinct type, sharing the temp among all receives
                                         // with that temp. Similarly one ok bool could be shared among all
                                         // the x,ok receives. Not worth doing until there's a clear need.
                                         if(r->left != N && isblank(r->left))
                                                 r->left = N;
                                         if(r->left != N) {
@@ skipping 225 matching lines @@
                         // completes. We could be more aggressive and try to arrange for it
                         // to be cleaned up when the call completes.
                         n->alloc = ordertemp(n->type->type, order, 0);
                 }
                 break;
 
         case ORECV:
                 orderexpr(&n->left, order);
                 n = ordercopyexpr(n, n->type, order, 1);
                 break;
+
+        case OEQ:
+        case ONE:
+                orderexpr(&n->left, order);
+                orderexpr(&n->right, order);
+                t = n->left->type;
+                if(t->etype == TSTRUCT || isfixedarray(t)) {
+                        // for complex comparisons, we need both args to be
+                        // addressable so we can pass them to the runtime.
+                        orderaddrtemp(&n->left, order);
+                        orderaddrtemp(&n->right, order);
+                }
+                break;
         }
 ········
         lineno = lno;
 
         *np = n;
 }