code review 6242061: runtime: update field types in preparation for GC changes

src/pkg/runtime/mgc0.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.
 
 // Garbage collector.
 
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "stack.h"
@@ skipping 521 matching lines @@
 
 static void
 addstackroots(G *gp)
 {
         M *mp;
         int32 n;
         Stktop *stk;
         byte *sp, *guard;
 
         stk = (Stktop*)gp->stackbase;
-        guard = gp->stackguard;
+        guard = (byte*)gp->stackguard;
 
         if(gp == g) {
                 // Scanning our own stack: start at &gp.
                 sp = (byte*)&gp;
         } else if((mp = gp->m) != nil && mp->helpgc) {
                 // gchelper's stack is in active use and has no interesting pointers.
                 return;
         } else {
                 // Scanning another goroutine's stack.
                 // The goroutine is usually asleep (the world is stopped).
-                sp = gp->sched.sp;
+                sp = (byte*)gp->sched.sp;
 
                 // The exception is that if the goroutine is about to enter or might
                 // have just exited a system call, it may be executing code such
                 // as schedlock and may have needed to start a new stack segment.
                 // Use the stack segment and stack pointer at the time of
                 // the system call instead, since that won't change underfoot.
-                if(gp->gcstack != nil) {
+                if(gp->gcstack != (uintptr)nil) {
                         stk = (Stktop*)gp->gcstack;
-                        sp = gp->gcsp;
-                        guard = gp->gcguard;
+                        sp = (byte*)gp->gcsp;
+                        guard = (byte*)gp->gcguard;
                 }
         }
 
         n = 0;
         while(stk) {
                 if(sp < guard-StackGuard || (byte*)stk < sp) {
                         runtime·printf("scanstack inconsistent: g%d#%d sp=%p not in [%p,%p]\n", gp->goid, n, sp, guard-StackGuard, stk);
                         runtime·throw("scanstack");
                 }
                 addroot(sp, (byte*)stk - sp);
-                sp = stk->gobuf.sp;
+                sp = (byte*)stk->gobuf.sp;
                 guard = stk->stackguard;
                 stk = (Stktop*)stk->stackbase;
                 n++;
         }
 }
 
 static void
 addfinroots(void *v)
 {
         uintptr size;
@@ skipping 665 matching lines @@
         uintptr n;
 
         n = (h->arena_used - h->arena_start) / wordsPerBitmapWord;
         n = (n+bitmapChunk-1) & ~(bitmapChunk-1);
         if(h->bitmap_mapped >= n)
                 return;
 
         runtime·SysMap(h->arena_start - n, n - h->bitmap_mapped);
         h->bitmap_mapped = n;
 }