code review 92760044: runtime: use duff zero and copy to initialize memory

src/cmd/5g/ggen.c

 // Copyright 2009 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.
 
 #undef  EXTERN
 #define EXTERN
 #include <u.h>
 #include <libc.h>
 #include "gg.h"
 #include "opt.h"
 
 static Prog* appendpp(Prog*, int, int, int, int32, int, int, int32);
+static Prog *zerorange(Prog *p, vlong frame, vlong lo, vlong hi, uint32 *r0);
 
 void
 defframe(Prog *ptxt)
 {
-        uint32 frame;
-        Prog *p, *p1;
+        uint32 frame, r0;
+        Prog *p;
+        vlong hi, lo;
         NodeList *l;
         Node *n;
-        vlong i;
 
         // fill in argument size
         ptxt->to.type = D_CONST2;
         ptxt->to.offset2 = rnd(curfn->type->argwid, widthptr);
 
         // fill in final stack size
         frame = rnd(stksize+maxarg, widthptr);
         ptxt->to.offset = frame;
 ········
         // insert code to contain ambiguously live variables
         // so that garbage collector only sees initialized values
         // when it looks for pointers.
-        //
-        // TODO: determine best way to zero the given values.
-        // among other problems, R0 is initialized to 0 multiple times,
-        // but that's really the tip of the iceberg.
         p = ptxt;
+        lo = hi = 0;
+        r0 = 0;
         for(l=curfn->dcl; l != nil; l = l->next) {
                 n = l->n;
                 if(!n->needzero)
                         continue;
                 if(n->class != PAUTO)
                         fatal("needzero class %d", n->class);
                 if(n->type->width % widthptr != 0 || n->xoffset % widthptr != 0 || n->type->width == 0)
                         fatal("var %lN has size %d offset %d", n, (int)n->type->width, (int)n->xoffset);
-                if(n->type->width <= 8*widthptr) {
-                        p = appendpp(p, AMOVW, D_CONST, NREG, 0, D_REG, 0, 0);
-                        for(i = 0; i < n->type->width; i += widthptr)·
-                                p = appendpp(p, AMOVW, D_REG, 0, 0, D_OREG, REGSP, 4+frame+n->xoffset+i);
-                } else {
-                        p = appendpp(p, AMOVW, D_CONST, NREG, 0, D_REG, 0, 0);
-                        p = appendpp(p, AADD, D_CONST, NREG, 4+frame+n->xoffset, D_REG, 1, 0);
-                        p->reg = REGSP; 
-                        p = appendpp(p, AADD, D_CONST, NREG, n->type->width, D_REG, 2, 0); ·····
-                        p->reg = 1; ····
-                        p1 = p = appendpp(p, AMOVW, D_REG, 0, 0, D_OREG, 1, 4); 
-                        p->scond |= C_PBIT; ····
-                        p = appendpp(p, ACMP, D_REG, 1, 0, D_NONE, 0, 0); ······
-                        p->reg = 2; ····
-                        p = appendpp(p, ABNE, D_NONE, NREG, 0, D_BRANCH, NREG, 0); ·····
-                        patch(p, p1);
+                if(lo != hi && n->xoffset + n->type->width >= lo - 2*widthptr) {
+                        // merge with range we already have
+                        lo = rnd(n->xoffset, widthptr);
+                        continue;
                 }
-        } ······
+                // zero old range
+                p = zerorange(p, frame, lo, hi, &r0);
+
+                // set new range
+                hi = n->xoffset + n->type->width;
+                lo = n->xoffset;
+        }
+        // zero final range
+        zerorange(p, frame, lo, hi, &r0);
+}
+
+static Prog*
+zerorange(Prog *p, vlong frame, vlong lo, vlong hi, uint32 *r0)
+{
+        vlong cnt, i;
+        Prog *p1;
+        Node *f;
+
+        cnt = hi - lo;
+        if(cnt == 0)
+                return p;
+        if(*r0 == 0) {
+                p = appendpp(p, AMOVW, D_CONST, NREG, 0, D_REG, 0, 0);
+                *r0 = 1;
+        }
+        if(cnt < 4*widthptr) {
+                for(i = 0; i < cnt; i += widthptr)·
+                        p = appendpp(p, AMOVW, D_REG, 0, 0, D_OREG, REGSP, 4+frame+lo+i);
+        } else if(cnt <= 128*widthptr) {
+                p = appendpp(p, AADD, D_CONST, NREG, 4+frame+lo, D_REG, 1, 0);
+                p->reg = REGSP;
+                p = appendpp(p, ADUFFZERO, D_NONE, NREG, 0, D_OREG, NREG, 0);
+                f = sysfunc("duffzero");
+                naddr(f, &p->to, 1);
+                afunclit(&p->to, f);
+                p->to.offset = 4*(128-cnt/widthptr);
+        } else {
+                p = appendpp(p, AADD, D_CONST, NREG, 4+frame+lo, D_REG, 1, 0);
+                p->reg = REGSP;
+                p = appendpp(p, AADD, D_CONST, NREG, cnt, D_REG, 2, 0);
+                p->reg = 1;
+                p1 = p = appendpp(p, AMOVW, D_REG, 0, 0, D_OREG, 1, 4);
+                p->scond |= C_PBIT;
+                p = appendpp(p, ACMP, D_REG, 1, 0, D_NONE, 0, 0);
+                p->reg = 2;
+                p = appendpp(p, ABNE, D_NONE, NREG, 0, D_BRANCH, NREG, 0);
+                patch(p, p1);
+        }
+        return p;
 }
 
 static Prog*····
 appendpp(Prog *p, int as, int ftype, int freg, int32 foffset, int ttype, int treg, int32 toffset)·······
 {·······
         Prog *q;········
 ················
         q = mal(sizeof(*q));····
         clearp(q);······
         q->as = as;·····
@@ skipping 747 matching lines @@
         gmove(&n2, res);
 
         regfree(&n1);
         regfree(&n2);
 }
 
 void
 clearfat(Node *nl)
 {
         uint32 w, c, q;
-        Node dst, nc, nz, end;
+        Node dst, nc, nz, end, r0, r1, *f;
         Prog *p, *pl;
 
         /* clear a fat object */
         if(debug['g'])
                 dump("\nclearfat", nl);
 
         w = nl->type->width;
         // Avoid taking the address for simple enough types.
         if(componentgen(N, nl))
                 return;
 
         c = w % 4;      // bytes
         q = w / 4;      // quads
 
-        regalloc(&dst, types[tptr], N);
+        r0.op = OREGISTER;
+        r0.val.u.reg = REGALLOC_R0;
+        r1.op = OREGISTER;
+        r1.val.u.reg = REGALLOC_R0 + 1;
+        regalloc(&dst, types[tptr], &r1);
         agen(nl, &dst);
         nodconst(&nc, types[TUINT32], 0);
-        regalloc(&nz, types[TUINT32], 0);
+        regalloc(&nz, types[TUINT32], &r0);
         cgen(&nc, &nz);
 
-        if(q >= 4) {
+        if(q > 128) {
                 regalloc(&end, types[tptr], N);
                 p = gins(AMOVW, &dst, &end);
                 p->from.type = D_CONST;
                 p->from.offset = q*4;
 
                 p = gins(AMOVW, &nz, &dst);
                 p->to.type = D_OREG;
                 p->to.offset = 4;
                 p->scond |= C_PBIT;
                 pl = p;
 
                 p = gins(ACMP, &dst, N);
                 raddr(&end, p);
                 patch(gbranch(ABNE, T, 0), pl);
 
                 regfree(&end);
+        } else if(q >= 4) {
+                f = sysfunc("duffzero");
+                p = gins(ADUFFZERO, N, f);
+                afunclit(&p->to, f);
+                // 4 and 128 = magic constants: see ../../pkg/runtime/asm_arm.s
+                p->to.offset = 4*(128-q);
         } else
         while(q > 0) {
                 p = gins(AMOVW, &nz, &dst);
                 p->to.type = D_OREG;
                 p->to.offset = 4;
                 p->scond |= C_PBIT;
 //print("1. %P\n", p);
                 q--;
         }
 
@@ skipping 41 matching lines @@
                 p1->to.reg = reg;
                 p1->to.offset = 0;
                 p1->scond = C_SCOND_EQ;
                 p->as = ACMP;
                 p->from.type = D_CONST;
                 p->from.reg = NREG;
                 p->from.offset = 0;
                 p->reg = reg;
         }
 }