runtime: always pass type to mallocgc when allocating scannable memory

We allocate scannable memory w/o type only in few places in runtime.
All these cases are not-performance critical (e.g. G or finq args buffer),
and in long term they all need to go away.
It's not worth it to have special code for this case in mallocgc.
So use special fake "notype" type for such allocations.

LGTM=khr
R=golang-codereviews, khr
CC=golang-codereviews, rlh, rsc
https://golang.org/cl/127450044

src/pkg/runtime/malloc.c

@@ -21,7 +21,10 @@ MHeap runtime·mheap;
 #pragma dataflag NOPTR
 MStats runtime·memstats;
 
+static Type* notype;
+
 void runtime·cmallocgc(uintptr size, Type *typ, uint32 flag, void **ret);
+void runtime·gc_notype_ptr(Eface*);
 
 void*
 runtime·mallocgc(uintptr size, Type *typ, uint32 flag)
@@ -31,6 +34,8 @@ runtime·mallocgc(uintptr size, Type *typ, uint32 flag)
 	// Call into the Go version of mallocgc.
 	// TODO: maybe someday we can get rid of this.  It is
 	// probably the only location where we run Go code on the M stack.
+	if((flag&FlagNoScan) == 0 && typ == nil)
+		typ = notype;
 	runtime·cmallocgc(size, typ, flag, &ret);
 	return ret;
 }
@@ -124,6 +129,7 @@ runtime·mallocinit(void)
 	uintptr limit;
 	uint64 i;
 	bool reserved;
+	Eface notype_eface;
 
 	p = nil;
 	p_size = 0;
@@ -251,6 +257,9 @@ runtime·mallocinit(void)
 	// Initialize the rest of the allocator.	
 	runtime·MHeap_Init(&runtime·mheap);
 	g->m->mcache = runtime·allocmcache();
+
+	runtime·gc_notype_ptr(&notype_eface);
+	notype = notype_eface.type;
 }
 
 void*

src/pkg/runtime/malloc.go

@@ -225,7 +225,6 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 			*xbits |= (bitsPointer << 2) << shift
 			goto marked
 		}
-		if typ != nil && (uintptr(typ.gc[0])|uintptr(typ.gc[1])) != 0 && uintptr(typ.size) > ptrSize {
 		if typ.kind&kindGCProg != 0 {
 			nptr := (uintptr(typ.size) + ptrSize - 1) / ptrSize
 			masksize := nptr
@@ -270,22 +269,13 @@ func gomallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer {
 		if te%2 == 0 {
 			te /= 2
 		}
-		}
-		if size == 2*ptrSize {
-			xbitsb := (*uint8)(add(unsafe.Pointer(xbits), shift/8))
-			*xbitsb = (bitsPointer << 2) | (bitsPointer << 6) | bitBoundary
-			goto marked
-		}
 		// Copy pointer bitmask into the bitmap.
 		for i := uintptr(0); i < size0; i += 2 * ptrSize {
-			v := uint8((bitsPointer << 2) | (bitsPointer << 6))
-			if ptrmask != nil {
-				v = *(*uint8)(add(unsafe.Pointer(ptrmask), ti))
+			v := *(*uint8)(add(unsafe.Pointer(ptrmask), ti))
 			ti++
 			if ti == te {
 				ti = 0
 			}
-			}
 			if i == 0 {
 				v |= bitBoundary
 			}

src/pkg/runtime/mgc0.go

@@ -19,6 +19,15 @@ func gc_itab_ptr(ret *interface{}) {
 	*ret = (*itab)(nil)
 }
 
+// Type used for "conservative" allocations in C code.
+type notype [8]*byte
+
+// Called from C. Returns the Go type used for C allocations w/o type.
+func gc_notype_ptr(ret *interface{}) {
+	var x notype
+	*ret = x
+}
+
 func timenow() (sec int64, nsec int32)
 
 func gc_unixnanotime(now *int64) {