code review 10136043: runtime: refactor mallocgc

src/pkg/runtime/string.goc

 // 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.
 
 package runtime
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "race.h"
 
@@ skipping 27 matching lines @@
 
 static String
 gostringsize(intgo l)
 {
         String s;
         uint32 ms;
 
         if(l == 0)
                 return runtime·emptystring;
         // leave room for NUL for C runtime (e.g., callers of getenv)
-        s.str = runtime·mallocgc(l+1, FlagNoPointers, 1, 0);
+        s.str = runtime·mallocgc(l+1, 0, FlagNoPointers|FlagNoZero);
         s.len = l;
         s.str[l] = 0;
         for(;;) {
                 ms = runtime·maxstring;
                 if((uint32)l <= ms || runtime·cas(&runtime·maxstring, ms, (uint32)l))
                         break;
         }
         return s;
 }
 
@@ skipping 17 matching lines @@
         s = gostringsize(l);
         runtime·memmove(s.str, str, l);
         return s;
 }
 
 Slice
 runtime·gobytes(byte *p, intgo n)
 {
         Slice sl;
 
-        sl.array = runtime·mallocgc(n, FlagNoPointers, 1, 0);
+        sl.array = runtime·mallocgc(n, 0, FlagNoPointers|FlagNoZero);
         sl.len = n;
         sl.cap = n;
         runtime·memmove(sl.array, p, n);
         return sl;
 }
 
 String
 runtime·gostringnocopy(byte *str)
 {
         String s;
@@ skipping 146 matching lines @@
 
         if(raceenabled) {
                 pc = runtime·getcallerpc(&b);
                 runtime·racereadrangepc(b.array, b.len, pc, runtime·slicebytetostring);
         }
         s = gostringsize(b.len);
         runtime·memmove(s.str, b.array, s.len);
 }
 
 func stringtoslicebyte(s String) (b Slice) {
-        b.array = runtime·mallocgc(s.len, FlagNoPointers, 1, 0);
+        b.array = runtime·mallocgc(s.len, 0, FlagNoPointers|FlagNoZero);
         b.len = s.len;
         b.cap = s.len;
         runtime·memmove(b.array, s.str, s.len);
 }
 
 func slicerunetostring(b Slice) (s String) {
         intgo siz1, siz2, i;
         int32 *a;
         byte dum[8];
         void *pc;
@@ skipping 28 matching lines @@
         // two passes.
         // unlike slicerunetostring, no race because strings are immutable.
         p = s.str;
         ep = s.str+s.len;
         n = 0;
         while(p < ep) {
                 p += runtime·charntorune(&dum, p, ep-p);
                 n++;
         }
 
-        b.array = runtime·mallocgc(n*sizeof(r[0]), FlagNoPointers, 1, 0);
+        b.array = runtime·mallocgc(n*sizeof(r[0]), 0, FlagNoPointers|FlagNoZero);
         b.len = n;
         b.cap = n;
         p = s.str;
         r = (int32*)b.array;
         while(p < ep)
                 p += runtime·charntorune(r++, p, ep-p);
 }
 
 enum
 {
@@ skipping 33 matching lines @@
         if(retv < Runeself) {
                 retk = k+1;
                 goto out;
         }
 
         // multi-char rune
         retk = k + runtime·charntorune(&retv, s.str+k, s.len-k);
 
 out:
 }