Initial commit of llgo.

llvm-svn: 222857

1 files changed, 1788 insertions, 0 deletions

diff --git a/llgo/libgo-noext.diff b/llgo/libgo-noext.diff
new file mode 100644
index 00000000000..2277270dd81
--- /dev/null
+++ b/llgo/libgo-noext.diff
@@ -0,0 +1,1788 @@
+diff -r 225a208260a6 libgo/runtime/chan.goc
+--- a/libgo/runtime/chan.goc	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/chan.goc	Tue Sep 23 15:59:57 2014 -0700
+@@ -115,7 +115,7 @@
+ 		mysg.releasetime = -1;
+ 	}
+ 
+-	runtime_lock(c);
++	runtime_lock(&c->lock);
+ 	if(raceenabled)
+ 		runtime_racereadpc(c, pc, chansend);
+ 	if(c->closed)
+@@ -128,7 +128,7 @@
+ 	if(sg != nil) {
+ 		if(raceenabled)
+ 			racesync(c, sg);
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 
+ 		gp = sg->g;
+ 		gp->param = sg;
+@@ -141,7 +141,7 @@
+ 	}
+ 
+ 	if(!block) {
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 		return false;
+ 	}
+ 
+@@ -150,10 +150,10 @@
+ 	mysg.selectdone = nil;
+ 	g->param = nil;
+ 	enqueue(&c->sendq, &mysg);
+-	runtime_parkunlock(c, "chan send");
++	runtime_parkunlock(&c->lock, "chan send");
+ 
+ 	if(g->param == nil) {
+-		runtime_lock(c);
++		runtime_lock(&c->lock);
+ 		if(!c->closed)
+ 			runtime_throw("chansend: spurious wakeup");
+ 		goto closed;
+@@ -170,16 +170,16 @@
+ 
+ 	if(c->qcount >= c->dataqsiz) {
+ 		if(!block) {
+-			runtime_unlock(c);
++			runtime_unlock(&c->lock);
+ 			return false;
+ 		}
+ 		mysg.g = g;
+ 		mysg.elem = nil;
+ 		mysg.selectdone = nil;
+ 		enqueue(&c->sendq, &mysg);
+-		runtime_parkunlock(c, "chan send");
++		runtime_parkunlock(&c->lock, "chan send");
+ 
+-		runtime_lock(c);
++		runtime_lock(&c->lock);
+ 		goto asynch;
+ 	}
+ 
+@@ -196,18 +196,18 @@
+ 	sg = dequeue(&c->recvq);
+ 	if(sg != nil) {
+ 		gp = sg->g;
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 		if(sg->releasetime)
+ 			sg->releasetime = runtime_cputicks();
+ 		runtime_ready(gp);
+ 	} else
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 	if(mysg.releasetime > 0)
+ 		runtime_blockevent(mysg.releasetime - t0, 2);
+ 	return true;
+ 
+ closed:
+-	runtime_unlock(c);
++	runtime_unlock(&c->lock);
+ 	runtime_panicstring("send on closed channel");
+ 	return false;  // not reached
+ }
+@@ -247,7 +247,7 @@
+ 		mysg.releasetime = -1;
+ 	}
+ 
+-	runtime_lock(c);
++	runtime_lock(&c->lock);
+ 	if(c->dataqsiz > 0)
+ 		goto asynch;
+ 
+@@ -258,7 +258,7 @@
+ 	if(sg != nil) {
+ 		if(raceenabled)
+ 			racesync(c, sg);
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 
+ 		if(ep != nil)
+ 			runtime_memmove(ep, sg->elem, c->elemsize);
+@@ -274,7 +274,7 @@
+ 	}
+ 
+ 	if(!block) {
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 		return false;
+ 	}
+ 
+@@ -283,10 +283,10 @@
+ 	mysg.selectdone = nil;
+ 	g->param = nil;
+ 	enqueue(&c->recvq, &mysg);
+-	runtime_parkunlock(c, "chan receive");
++	runtime_parkunlock(&c->lock, "chan receive");
+ 
+ 	if(g->param == nil) {
+-		runtime_lock(c);
++		runtime_lock(&c->lock);
+ 		if(!c->closed)
+ 			runtime_throw("chanrecv: spurious wakeup");
+ 		goto closed;
+@@ -304,7 +304,7 @@
+ 			goto closed;
+ 
+ 		if(!block) {
+-			runtime_unlock(c);
++			runtime_unlock(&c->lock);
+ 			if(received != nil)
+ 				*received = false;
+ 			return false;
+@@ -313,9 +313,9 @@
+ 		mysg.elem = nil;
+ 		mysg.selectdone = nil;
+ 		enqueue(&c->recvq, &mysg);
+-		runtime_parkunlock(c, "chan receive");
++		runtime_parkunlock(&c->lock, "chan receive");
+ 
+-		runtime_lock(c);
++		runtime_lock(&c->lock);
+ 		goto asynch;
+ 	}
+ 
+@@ -334,12 +334,12 @@
+ 	sg = dequeue(&c->sendq);
+ 	if(sg != nil) {
+ 		gp = sg->g;
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 		if(sg->releasetime)
+ 			sg->releasetime = runtime_cputicks();
+ 		runtime_ready(gp);
+ 	} else
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 
+ 	if(received != nil)
+ 		*received = true;
+@@ -354,7 +354,7 @@
+ 		*received = false;
+ 	if(raceenabled)
+ 		runtime_raceacquire(c);
+-	runtime_unlock(c);
++	runtime_unlock(&c->lock);
+ 	if(mysg.releasetime > 0)
+ 		runtime_blockevent(mysg.releasetime - t0, 2);
+ 	return true;
+@@ -628,7 +628,7 @@
+ 		c0 = sel->lockorder[i];
+ 		if(c0 && c0 != c) {
+ 			c = sel->lockorder[i];
+-			runtime_lock(c);
++			runtime_lock(&c->lock);
+ 		}
+ 	}
+ }
+@@ -656,7 +656,7 @@
+ 		c = sel->lockorder[i];
+ 		if(i>0 && sel->lockorder[i-1] == c)
+ 			continue;  // will unlock it on the next iteration
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 	}
+ }
+ 
+@@ -1071,9 +1071,9 @@
+ 	if(runtime_gcwaiting())
+ 		runtime_gosched();
+ 
+-	runtime_lock(c);
++	runtime_lock(&c->lock);
+ 	if(c->closed) {
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 		runtime_panicstring("close of closed channel");
+ 	}
+ 
+@@ -1108,7 +1108,7 @@
+ 		runtime_ready(gp);
+ 	}
+ 
+-	runtime_unlock(c);
++	runtime_unlock(&c->lock);
+ }
+ 
+ void
+diff -r 225a208260a6 libgo/runtime/chan.h
+--- a/libgo/runtime/chan.h	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/chan.h	Tue Sep 23 15:59:57 2014 -0700
+@@ -39,7 +39,7 @@
+ 	uintgo	recvx;			// receive index
+ 	WaitQ	recvq;			// list of recv waiters
+ 	WaitQ	sendq;			// list of send waiters
+-	Lock;
++	Lock	lock;
+ };
+ 
+ // Buffer follows Hchan immediately in memory.
+diff -r 225a208260a6 libgo/runtime/heapdump.c
+--- a/libgo/runtime/heapdump.c	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/heapdump.c	Tue Sep 23 15:59:57 2014 -0700
+@@ -387,7 +387,7 @@
+ 				if(sp->kind != KindSpecialFinalizer)
+ 					continue;
+ 				spf = (SpecialFinalizer*)sp;
+-				p = (byte*)((s->start << PageShift) + spf->offset);
++				p = (byte*)((s->start << PageShift) + spf->special.offset);
+ 				dumpfinalizer(p, spf->fn, spf->ft, spf->ot);
+ 			}
+ 		}
+@@ -566,7 +566,7 @@
+ 			if(sp->kind != KindSpecialProfile)
+ 				continue;
+ 			spp = (SpecialProfile*)sp;
+-			p = (byte*)((s->start << PageShift) + spp->offset);
++			p = (byte*)((s->start << PageShift) + spp->special.offset);
+ 			dumpint(TagAllocSample);
+ 			dumpint((uintptr)p);
+ 			dumpint((uintptr)spp->b);
+diff -r 225a208260a6 libgo/runtime/malloc.goc
+--- a/libgo/runtime/malloc.goc	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/malloc.goc	Tue Sep 23 15:59:57 2014 -0700
+@@ -440,9 +440,9 @@
+ 	m->mcache->local_nlookup++;
+ 	if (sizeof(void*) == 4 && m->mcache->local_nlookup >= (1<<30)) {
+ 		// purge cache stats to prevent overflow
+-		runtime_lock(&runtime_mheap);
++		runtime_lock(&runtime_mheap.lock);
+ 		runtime_purgecachedstats(m->mcache);
+-		runtime_unlock(&runtime_mheap);
++		runtime_unlock(&runtime_mheap.lock);
+ 	}
+ 
+ 	s = runtime_MHeap_LookupMaybe(&runtime_mheap, v);
+@@ -743,7 +743,7 @@
+ 
+ static struct
+ {
+-	Lock;
++	Lock	lock;
+ 	byte*	pos;
+ 	byte*	end;
+ } persistent;
+@@ -772,19 +772,19 @@
+ 		align = 8;
+ 	if(size >= PersistentAllocMaxBlock)
+ 		return runtime_SysAlloc(size, stat);
+-	runtime_lock(&persistent);
++	runtime_lock(&persistent.lock);
+ 	persistent.pos = (byte*)ROUND((uintptr)persistent.pos, align);
+ 	if(persistent.pos + size > persistent.end) {
+ 		persistent.pos = runtime_SysAlloc(PersistentAllocChunk, &mstats.other_sys);
+ 		if(persistent.pos == nil) {
+-			runtime_unlock(&persistent);
++			runtime_unlock(&persistent.lock);
+ 			runtime_throw("runtime: cannot allocate memory");
+ 		}
+ 		persistent.end = persistent.pos + PersistentAllocChunk;
+ 	}
+ 	p = persistent.pos;
+ 	persistent.pos += size;
+-	runtime_unlock(&persistent);
++	runtime_unlock(&persistent.lock);
+ 	if(stat != &mstats.other_sys) {
+ 		// reaccount the allocation against provided stat
+ 		runtime_xadd64(stat, size);
+diff -r 225a208260a6 libgo/runtime/malloc.h
+--- a/libgo/runtime/malloc.h	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/malloc.h	Tue Sep 23 15:59:57 2014 -0700
+@@ -390,7 +390,7 @@
+ typedef struct SpecialFinalizer SpecialFinalizer;
+ struct SpecialFinalizer
+ {
+-	Special;
++	Special		special;
+ 	FuncVal*	fn;
+ 	const FuncType*	ft;
+ 	const PtrType*	ot;
+@@ -401,7 +401,7 @@
+ typedef struct SpecialProfile SpecialProfile;
+ struct SpecialProfile
+ {
+-	Special;
++	Special	special;
+ 	Bucket*	b;
+ };
+ 
+@@ -458,7 +458,7 @@
+ // Central list of free objects of a given size.
+ struct MCentral
+ {
+-	Lock;
++	Lock  lock;
+ 	int32 sizeclass;
+ 	MSpan nonempty;	// list of spans with a free object
+ 	MSpan empty;	// list of spans with no free objects (or cached in an MCache)
+@@ -476,7 +476,7 @@
+ // but all the other global data is here too.
+ struct MHeap
+ {
+-	Lock;
++	Lock lock;
+ 	MSpan free[MaxMHeapList];	// free lists of given length
+ 	MSpan freelarge;		// free lists length >= MaxMHeapList
+ 	MSpan busy[MaxMHeapList];	// busy lists of large objects of given length
+@@ -505,7 +505,7 @@
+ 	// spaced CacheLineSize bytes apart, so that each MCentral.Lock
+ 	// gets its own cache line.
+ 	struct {
+-		MCentral;
++		MCentral mcentral;
+ 		byte pad[64];
+ 	} central[NumSizeClasses];
+ 
+diff -r 225a208260a6 libgo/runtime/mcache.c
+--- a/libgo/runtime/mcache.c	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/mcache.c	Tue Sep 23 15:59:57 2014 -0700
+@@ -23,9 +23,9 @@
+ 	MCache *c;
+ 	int32 i;
+ 
+-	runtime_lock(&runtime_mheap);
++	runtime_lock(&runtime_mheap.lock);
+ 	c = runtime_FixAlloc_Alloc(&runtime_mheap.cachealloc);
+-	runtime_unlock(&runtime_mheap);
++	runtime_unlock(&runtime_mheap.lock);
+ 	runtime_memclr((byte*)c, sizeof(*c));
+ 	for(i = 0; i < NumSizeClasses; i++)
+ 		c->alloc[i] = &emptymspan;
+@@ -44,10 +44,10 @@
+ runtime_freemcache(MCache *c)
+ {
+ 	runtime_MCache_ReleaseAll(c);
+-	runtime_lock(&runtime_mheap);
++	runtime_lock(&runtime_mheap.lock);
+ 	runtime_purgecachedstats(c);
+ 	runtime_FixAlloc_Free(&runtime_mheap.cachealloc, c);
+-	runtime_unlock(&runtime_mheap);
++	runtime_unlock(&runtime_mheap.lock);
+ }
+ 
+ // Gets a span that has a free object in it and assigns it
+@@ -64,19 +64,19 @@
+ 	if(s->freelist != nil)
+ 		runtime_throw("refill on a nonempty span");
+ 	if(s != &emptymspan)
+-		runtime_MCentral_UncacheSpan(&runtime_mheap.central[sizeclass], s);
++		runtime_MCentral_UncacheSpan(&runtime_mheap.central[sizeclass].mcentral, s);
+ 
+ 	// Push any explicitly freed objects to the central lists.
+ 	// Not required, but it seems like a good time to do it.
+ 	l = &c->free[sizeclass];
+ 	if(l->nlist > 0) {
+-		runtime_MCentral_FreeList(&runtime_mheap.central[sizeclass], l->list);
++		runtime_MCentral_FreeList(&runtime_mheap.central[sizeclass].mcentral, l->list);
+ 		l->list = nil;
+ 		l->nlist = 0;
+ 	}
+ 
+ 	// Get a new cached span from the central lists.
+-	s = runtime_MCentral_CacheSpan(&runtime_mheap.central[sizeclass]);
++	s = runtime_MCentral_CacheSpan(&runtime_mheap.central[sizeclass].mcentral);
+ 	if(s == nil)
+ 		runtime_throw("out of memory");
+ 	if(s->freelist == nil) {
+@@ -102,7 +102,7 @@
+ 	// We transfer a span at a time from MCentral to MCache,
+ 	// so we'll do the same in the other direction.
+ 	if(l->nlist >= (runtime_class_to_allocnpages[sizeclass]<<PageShift)/size) {
+-		runtime_MCentral_FreeList(&runtime_mheap.central[sizeclass], l->list);
++		runtime_MCentral_FreeList(&runtime_mheap.central[sizeclass].mcentral, l->list);
+ 		l->list = nil;
+ 		l->nlist = 0;
+ 	}
+@@ -118,12 +118,12 @@
+ 	for(i=0; i<NumSizeClasses; i++) {
+ 		s = c->alloc[i];
+ 		if(s != &emptymspan) {
+-			runtime_MCentral_UncacheSpan(&runtime_mheap.central[i], s);
++			runtime_MCentral_UncacheSpan(&runtime_mheap.central[i].mcentral, s);
+ 			c->alloc[i] = &emptymspan;
+ 		}
+ 		l = &c->free[i];
+ 		if(l->nlist > 0) {
+-			runtime_MCentral_FreeList(&runtime_mheap.central[i], l->list);
++			runtime_MCentral_FreeList(&runtime_mheap.central[i].mcentral, l->list);
+ 			l->list = nil;
+ 			l->nlist = 0;
+ 		}
+diff -r 225a208260a6 libgo/runtime/mcentral.c
+--- a/libgo/runtime/mcentral.c	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/mcentral.c	Tue Sep 23 15:59:57 2014 -0700
+@@ -39,14 +39,14 @@
+ 	int32 cap, n;
+ 	uint32 sg;
+ 
+-	runtime_lock(c);
++	runtime_lock(&c->lock);
+ 	sg = runtime_mheap.sweepgen;
+ retry:
+ 	for(s = c->nonempty.next; s != &c->nonempty; s = s->next) {
+ 		if(s->sweepgen == sg-2 && runtime_cas(&s->sweepgen, sg-2, sg-1)) {
+-			runtime_unlock(c);
++			runtime_unlock(&c->lock);
+ 			runtime_MSpan_Sweep(s);
+-			runtime_lock(c);
++			runtime_lock(&c->lock);
+ 			// the span could have been moved to heap, retry
+ 			goto retry;
+ 		}
+@@ -65,9 +65,9 @@
+ 			runtime_MSpanList_Remove(s);
+ 			// swept spans are at the end of the list
+ 			runtime_MSpanList_InsertBack(&c->empty, s);
+-			runtime_unlock(c);
++			runtime_unlock(&c->lock);
+ 			runtime_MSpan_Sweep(s);
+-			runtime_lock(c);
++			runtime_lock(&c->lock);
+ 			// the span could be moved to nonempty or heap, retry
+ 			goto retry;
+ 		}
+@@ -82,7 +82,7 @@
+ 
+ 	// Replenish central list if empty.
+ 	if(!MCentral_Grow(c)) {
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 		return nil;
+ 	}
+ 	goto retry;
+@@ -98,7 +98,7 @@
+ 	runtime_MSpanList_Remove(s);
+ 	runtime_MSpanList_InsertBack(&c->empty, s);
+ 	s->incache = true;
+-	runtime_unlock(c);
++	runtime_unlock(&c->lock);
+ 	return s;
+ }
+ 
+@@ -109,7 +109,7 @@
+ 	MLink *v;
+ 	int32 cap, n;
+ 
+-	runtime_lock(c);
++	runtime_lock(&c->lock);
+ 
+ 	s->incache = false;
+ 
+@@ -135,7 +135,7 @@
+ 		runtime_MSpanList_Remove(s);
+ 		runtime_MSpanList_Insert(&c->nonempty, s);
+ 	}
+-	runtime_unlock(c);
++	runtime_unlock(&c->lock);
+ }
+ 
+ // Free the list of objects back into the central free list c.
+@@ -145,12 +145,12 @@
+ {
+ 	MLink *next;
+ 
+-	runtime_lock(c);
++	runtime_lock(&c->lock);
+ 	for(; start != nil; start = next) {
+ 		next = start->next;
+ 		MCentral_Free(c, start);
+ 	}
+-	runtime_unlock(c);
++	runtime_unlock(&c->lock);
+ }
+ 
+ // Helper: free one object back into the central free list.
+@@ -193,7 +193,7 @@
+ 	// If s is completely freed, return it to the heap.
+ 	if(s->ref == 0) {
+ 		MCentral_ReturnToHeap(c, s); // unlocks c
+-		runtime_lock(c);
++		runtime_lock(&c->lock);
+ 	}
+ }
+ 
+@@ -206,7 +206,7 @@
+ {
+ 	if(s->incache)
+ 		runtime_throw("freespan into cached span");
+-	runtime_lock(c);
++	runtime_lock(&c->lock);
+ 
+ 	// Move to nonempty if necessary.
+ 	if(s->freelist == nil) {
+@@ -227,7 +227,7 @@
+ 	runtime_atomicstore(&s->sweepgen, runtime_mheap.sweepgen);
+ 
+ 	if(s->ref != 0) {
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 		return false;
+ 	}
+ 
+@@ -260,12 +260,12 @@
+ 	byte *p;
+ 	MSpan *s;
+ 
+-	runtime_unlock(c);
++	runtime_unlock(&c->lock);
+ 	runtime_MGetSizeClassInfo(c->sizeclass, &size, &npages, &n);
+ 	s = runtime_MHeap_Alloc(&runtime_mheap, npages, c->sizeclass, 0, 1);
+ 	if(s == nil) {
+ 		// TODO(rsc): Log out of memory
+-		runtime_lock(c);
++		runtime_lock(&c->lock);
+ 		return false;
+ 	}
+ 
+@@ -282,7 +282,7 @@
+ 	*tailp = nil;
+ 	runtime_markspan((byte*)(s->start<<PageShift), size, n, size*n < (s->npages<<PageShift));
+ 
+-	runtime_lock(c);
++	runtime_lock(&c->lock);
+ 	c->nfree += n;
+ 	runtime_MSpanList_Insert(&c->nonempty, s);
+ 	return true;
+@@ -301,7 +301,7 @@
+ 	if(s->ref != 0)
+ 		runtime_throw("ref wrong");
+ 	c->nfree -= (s->npages << PageShift) / size;
+-	runtime_unlock(c);
++	runtime_unlock(&c->lock);
+ 	runtime_unmarkspan((byte*)(s->start<<PageShift), s->npages<<PageShift);
+ 	runtime_MHeap_Free(&runtime_mheap, s, 0);
+ }
+diff -r 225a208260a6 libgo/runtime/mgc0.c
+--- a/libgo/runtime/mgc0.c	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/mgc0.c	Tue Sep 23 15:59:57 2014 -0700
+@@ -225,7 +225,7 @@
+ 	Note	alldone;
+ 	ParFor	*markfor;
+ 
+-	Lock;
++	Lock	lock;
+ 	byte	*chunk;
+ 	uintptr	nchunk;
+ } work __attribute__((aligned(8)));
+@@ -1337,7 +1337,7 @@
+ 				// retain everything it points to.
+ 				spf = (SpecialFinalizer*)sp;
+ 				// A finalizer can be set for an inner byte of an object, find object beginning.
+-				p = (void*)((s->start << PageShift) + spf->offset/s->elemsize*s->elemsize);
++				p = (void*)((s->start << PageShift) + spf->special.offset/s->elemsize*s->elemsize);
+ 				enqueue1(&wbuf, (Obj){p, s->elemsize, 0});
+ 				enqueue1(&wbuf, (Obj){(void*)&spf->fn, PtrSize, 0});
+ 				enqueue1(&wbuf, (Obj){(void*)&spf->ft, PtrSize, 0});
+@@ -1378,7 +1378,7 @@
+ 	b = (Workbuf*)runtime_lfstackpop(&work.empty);
+ 	if(b == nil) {
+ 		// Need to allocate.
+-		runtime_lock(&work);
++		runtime_lock(&work.lock);
+ 		if(work.nchunk < sizeof *b) {
+ 			work.nchunk = 1<<20;
+ 			work.chunk = runtime_SysAlloc(work.nchunk, &mstats.gc_sys);
+@@ -1388,7 +1388,7 @@
+ 		b = (Workbuf*)work.chunk;
+ 		work.chunk += sizeof *b;
+ 		work.nchunk -= sizeof *b;
+-		runtime_unlock(&work);
++		runtime_unlock(&work.lock);
+ 	}
+ 	b->nobj = 0;
+ 	return b;
+@@ -1802,7 +1802,7 @@
+ 		c->local_nsmallfree[cl] += nfree;
+ 		c->local_cachealloc -= nfree * size;
+ 		runtime_xadd64(&mstats.next_gc, -(uint64)(nfree * size * (gcpercent + 100)/100));
+-		res = runtime_MCentral_FreeSpan(&runtime_mheap.central[cl], s, nfree, head.next, end);
++		res = runtime_MCentral_FreeSpan(&runtime_mheap.central[cl].mcentral, s, nfree, head.next, end);
+ 		//MCentral_FreeSpan updates sweepgen
+ 	}
+ 	return res;
+@@ -2147,10 +2147,10 @@
+ 		return;
+ 
+ 	if(gcpercent == GcpercentUnknown) {	// first time through
+-		runtime_lock(&runtime_mheap);
++		runtime_lock(&runtime_mheap.lock);
+ 		if(gcpercent == GcpercentUnknown)
+ 			gcpercent = readgogc();
+-		runtime_unlock(&runtime_mheap);
++		runtime_unlock(&runtime_mheap.lock);
+ 	}
+ 	if(gcpercent < 0)
+ 		return;
+@@ -2421,7 +2421,7 @@
+ 
+ 	// Pass back: pauses, last gc (absolute time), number of gc, total pause ns.
+ 	p = (uint64*)pauses->array;
+-	runtime_lock(&runtime_mheap);
++	runtime_lock(&runtime_mheap.lock);
+ 	n = mstats.numgc;
+ 	if(n > nelem(mstats.pause_ns))
+ 		n = nelem(mstats.pause_ns);
+@@ -2436,7 +2436,7 @@
+ 	p[n] = mstats.last_gc;
+ 	p[n+1] = mstats.numgc;
+ 	p[n+2] = mstats.pause_total_ns;	
+-	runtime_unlock(&runtime_mheap);
++	runtime_unlock(&runtime_mheap.lock);
+ 	pauses->__count = n+3;
+ }
+ 
+@@ -2444,14 +2444,14 @@
+ runtime_setgcpercent(int32 in) {
+ 	int32 out;
+ 
+-	runtime_lock(&runtime_mheap);
++	runtime_lock(&runtime_mheap.lock);
+ 	if(gcpercent == GcpercentUnknown)
+ 		gcpercent = readgogc();
+ 	out = gcpercent;
+ 	if(in < 0)
+ 		in = -1;
+ 	gcpercent = in;
+-	runtime_unlock(&runtime_mheap);
++	runtime_unlock(&runtime_mheap.lock);
+ 	return out;
+ }
+ 
+diff -r 225a208260a6 libgo/runtime/mheap.c
+--- a/libgo/runtime/mheap.c	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/mheap.c	Tue Sep 23 15:59:57 2014 -0700
+@@ -70,7 +70,7 @@
+ 	runtime_MSpanList_Init(&h->freelarge);
+ 	runtime_MSpanList_Init(&h->busylarge);
+ 	for(i=0; i<nelem(h->central); i++)
+-		runtime_MCentral_Init(&h->central[i], i);
++		runtime_MCentral_Init(&h->central[i].mcentral, i);
+ }
+ 
+ void
+@@ -109,9 +109,9 @@
+ 			runtime_MSpanList_Remove(s);
+ 			// swept spans are at the end of the list
+ 			runtime_MSpanList_InsertBack(list, s);
+-			runtime_unlock(h);
++			runtime_unlock(&h->lock);
+ 			n += runtime_MSpan_Sweep(s);
+-			runtime_lock(h);
++			runtime_lock(&h->lock);
+ 			if(n >= npages)
+ 				return n;
+ 			// the span could have been moved elsewhere
+@@ -156,7 +156,7 @@
+ 	}
+ 
+ 	// Now sweep everything that is not yet swept.
+-	runtime_unlock(h);
++	runtime_unlock(&h->lock);
+ 	for(;;) {
+ 		n = runtime_sweepone();
+ 		if(n == (uintptr)-1)  // all spans are swept
+@@ -165,7 +165,7 @@
+ 		if(reclaimed >= npage)
+ 			break;
+ 	}
+-	runtime_lock(h);
++	runtime_lock(&h->lock);
+ }
+ 
+ // Allocate a new span of npage pages from the heap
+@@ -175,7 +175,7 @@
+ {
+ 	MSpan *s;
+ 
+-	runtime_lock(h);
++	runtime_lock(&h->lock);
+ 	mstats.heap_alloc += runtime_m()->mcache->local_cachealloc;
+ 	runtime_m()->mcache->local_cachealloc = 0;
+ 	s = MHeap_AllocLocked(h, npage, sizeclass);
+@@ -191,7 +191,7 @@
+ 				runtime_MSpanList_InsertBack(&h->busylarge, s);
+ 		}
+ 	}
+-	runtime_unlock(h);
++	runtime_unlock(&h->lock);
+ 	if(s != nil) {
+ 		if(needzero && s->needzero)
+ 			runtime_memclr((byte*)(s->start<<PageShift), s->npages<<PageShift);
+@@ -386,7 +386,7 @@
+ void
+ runtime_MHeap_Free(MHeap *h, MSpan *s, int32 acct)
+ {
+-	runtime_lock(h);
++	runtime_lock(&h->lock);
+ 	mstats.heap_alloc += runtime_m()->mcache->local_cachealloc;
+ 	runtime_m()->mcache->local_cachealloc = 0;
+ 	mstats.heap_inuse -= s->npages<<PageShift;
+@@ -395,7 +395,7 @@
+ 		mstats.heap_objects--;
+ 	}
+ 	MHeap_FreeLocked(h, s);
+-	runtime_unlock(h);
++	runtime_unlock(&h->lock);
+ }
+ 
+ static void
+@@ -548,10 +548,10 @@
+ 		runtime_noteclear(&note);
+ 		runtime_notetsleepg(&note, tick);
+ 
+-		runtime_lock(h);
++		runtime_lock(&h->lock);
+ 		unixnow = runtime_unixnanotime();
+ 		if(unixnow - mstats.last_gc > forcegc) {
+-			runtime_unlock(h);
++			runtime_unlock(&h->lock);
+ 			// The scavenger can not block other goroutines,
+ 			// otherwise deadlock detector can fire spuriously.
+ 			// GC blocks other goroutines via the runtime_worldsema.
+@@ -561,11 +561,11 @@
+ 			runtime_notetsleepg(&note, -1);
+ 			if(runtime_debug.gctrace > 0)
+ 				runtime_printf("scvg%d: GC forced\n", k);
+-			runtime_lock(h);
++			runtime_lock(&h->lock);
+ 		}
+ 		now = runtime_nanotime();
+ 		scavenge(k, now, limit);
+-		runtime_unlock(h);
++		runtime_unlock(&h->lock);
+ 	}
+ }
+ 
+@@ -575,9 +575,9 @@
+ runtime_debug_freeOSMemory(void)
+ {
+ 	runtime_gc(2);  // force GC and do eager sweep
+-	runtime_lock(&runtime_mheap);
++	runtime_lock(&runtime_mheap.lock);
+ 	scavenge(-1, ~(uintptr)0, 0);
+-	runtime_unlock(&runtime_mheap);
++	runtime_unlock(&runtime_mheap.lock);
+ }
+ 
+ // Initialize a new span with the given start and npages.
+@@ -752,11 +752,11 @@
+ 	runtime_lock(&runtime_mheap.speciallock);
+ 	s = runtime_FixAlloc_Alloc(&runtime_mheap.specialfinalizeralloc);
+ 	runtime_unlock(&runtime_mheap.speciallock);
+-	s->kind = KindSpecialFinalizer;
++	s->special.kind = KindSpecialFinalizer;
+ 	s->fn = f;
+ 	s->ft = ft;
+ 	s->ot = ot;
+-	if(addspecial(p, s))
++	if(addspecial(p, &s->special))
+ 		return true;
+ 
+ 	// There was an old finalizer
+@@ -789,9 +789,9 @@
+ 	runtime_lock(&runtime_mheap.speciallock);
+ 	s = runtime_FixAlloc_Alloc(&runtime_mheap.specialprofilealloc);
+ 	runtime_unlock(&runtime_mheap.speciallock);
+-	s->kind = KindSpecialProfile;
++	s->special.kind = KindSpecialProfile;
+ 	s->b = b;
+-	if(!addspecial(p, s))
++	if(!addspecial(p, &s->special))
+ 		runtime_throw("setprofilebucket: profile already set");
+ }
+ 
+@@ -879,14 +879,14 @@
+ 	// remove the span from whatever list it is in now
+ 	if(s->sizeclass > 0) {
+ 		// must be in h->central[x].empty
+-		c = &h->central[s->sizeclass];
+-		runtime_lock(c);
++		c = &h->central[s->sizeclass].mcentral;
++		runtime_lock(&c->lock);
+ 		runtime_MSpanList_Remove(s);
+-		runtime_unlock(c);
+-		runtime_lock(h);
++		runtime_unlock(&c->lock);
++		runtime_lock(&h->lock);
+ 	} else {
+ 		// must be in h->busy/busylarge
+-		runtime_lock(h);
++		runtime_lock(&h->lock);
+ 		runtime_MSpanList_Remove(s);
+ 	}
+ 	// heap is locked now
+@@ -933,18 +933,18 @@
+ 
+ 	// place the span into a new list
+ 	if(s->sizeclass > 0) {
+-		runtime_unlock(h);
+-		c = &h->central[s->sizeclass];
+-		runtime_lock(c);
++		runtime_unlock(&h->lock);
++		c = &h->central[s->sizeclass].mcentral;
++		runtime_lock(&c->lock);
+ 		// swept spans are at the end of the list
+ 		runtime_MSpanList_InsertBack(&c->empty, s);
+-		runtime_unlock(c);
++		runtime_unlock(&c->lock);
+ 	} else {
+ 		// Swept spans are at the end of lists.
+ 		if(s->npages < nelem(h->free))
+ 			runtime_MSpanList_InsertBack(&h->busy[s->npages], s);
+ 		else
+ 			runtime_MSpanList_InsertBack(&h->busylarge, s);
+-		runtime_unlock(h);
++		runtime_unlock(&h->lock);
+ 	}
+ }
+diff -r 225a208260a6 libgo/runtime/netpoll.goc
+--- a/libgo/runtime/netpoll.goc	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/netpoll.goc	Tue Sep 23 15:59:57 2014 -0700
+@@ -53,7 +53,7 @@
+ 	// pollReset, pollWait, pollWaitCanceled and runtime_netpollready (IO rediness notification)
+ 	// proceed w/o taking the lock. So closing, rg, rd, wg and wd are manipulated
+ 	// in a lock-free way by all operations.
+-	Lock;		// protectes the following fields
++	Lock	lock;	// protectes the following fields
+ 	uintptr	fd;
+ 	bool	closing;
+ 	uintptr	seq;	// protects from stale timers and ready notifications
+@@ -68,7 +68,7 @@
+ 
+ static struct
+ {
+-	Lock;
++	Lock		lock;
+ 	PollDesc*	first;
+ 	// PollDesc objects must be type-stable,
+ 	// because we can get ready notification from epoll/kqueue
+@@ -100,7 +100,7 @@
+ 
+ func runtime_pollOpen(fd uintptr) (pd *PollDesc, errno int) {
+ 	pd = allocPollDesc();
+-	runtime_lock(pd);
++	runtime_lock(&pd->lock);
+ 	if(pd->wg != nil && pd->wg != READY)
+ 		runtime_throw("runtime_pollOpen: blocked write on free descriptor");
+ 	if(pd->rg != nil && pd->rg != READY)
+@@ -112,7 +112,7 @@
+ 	pd->rd = 0;
+ 	pd->wg = nil;
+ 	pd->wd = 0;
+-	runtime_unlock(pd);
++	runtime_unlock(&pd->lock);
+ 
+ 	errno = runtime_netpollopen(fd, pd);
+ }
+@@ -125,10 +125,10 @@
+ 	if(pd->rg != nil && pd->rg != READY)
+ 		runtime_throw("runtime_pollClose: blocked read on closing descriptor");
+ 	runtime_netpollclose(pd->fd);
+-	runtime_lock(&pollcache);
++	runtime_lock(&pollcache.lock);
+ 	pd->link = pollcache.first;
+ 	pollcache.first = pd;
+-	runtime_unlock(&pollcache);
++	runtime_unlock(&pollcache.lock);
+ }
+ 
+ func runtime_pollReset(pd *PollDesc, mode int) (err int) {
+@@ -169,9 +169,9 @@
+ func runtime_pollSetDeadline(pd *PollDesc, d int64, mode int) {
+ 	G *rg, *wg;
+ 
+-	runtime_lock(pd);
++	runtime_lock(&pd->lock);
+ 	if(pd->closing) {
+-		runtime_unlock(pd);
++		runtime_unlock(&pd->lock);
+ 		return;
+ 	}
+ 	pd->seq++;  // invalidate current timers
+@@ -223,7 +223,7 @@
+ 		rg = netpollunblock(pd, 'r', false);
+ 	if(pd->wd < 0)
+ 		wg = netpollunblock(pd, 'w', false);
+-	runtime_unlock(pd);
++	runtime_unlock(&pd->lock);
+ 	if(rg)
+ 		runtime_ready(rg);
+ 	if(wg)
+@@ -233,7 +233,7 @@
+ func runtime_pollUnblock(pd *PollDesc) {
+ 	G *rg, *wg;
+ 
+-	runtime_lock(pd);
++	runtime_lock(&pd->lock);
+ 	if(pd->closing)
+ 		runtime_throw("runtime_pollUnblock: already closing");
+ 	pd->closing = true;
+@@ -249,7 +249,7 @@
+ 		runtime_deltimer(&pd->wt);
+ 		pd->wt.fv = nil;
+ 	}
+-	runtime_unlock(pd);
++	runtime_unlock(&pd->lock);
+ 	if(rg)
+ 		runtime_ready(rg);
+ 	if(wg)
+@@ -277,13 +277,13 @@
+ void
+ runtime_netpolllock(PollDesc *pd)
+ {
+-	runtime_lock(pd);
++	runtime_lock(&pd->lock);
+ }
+ 
+ void
+ runtime_netpollunlock(PollDesc *pd)
+ {
+-	runtime_unlock(pd);
++	runtime_unlock(&pd->lock);
+ }
+ 
+ // make pd ready, newly runnable goroutines (if any) are enqueued info gpp list
+@@ -401,10 +401,10 @@
+ 	// If it's stale, ignore the timer event.
+ 	seq = (uintptr)arg.type;
+ 	rg = wg = nil;
+-	runtime_lock(pd);
++	runtime_lock(&pd->lock);
+ 	if(seq != pd->seq) {
+ 		// The descriptor was reused or timers were reset.
+-		runtime_unlock(pd);
++		runtime_unlock(&pd->lock);
+ 		return;
+ 	}
+ 	if(read) {
+@@ -421,7 +421,7 @@
+ 		runtime_atomicstorep(&pd->wt.fv, nil);  // full memory barrier between store to wd and load of wg in netpollunblock
+ 		wg = netpollunblock(pd, 'w', false);
+ 	}
+-	runtime_unlock(pd);
++	runtime_unlock(&pd->lock);
+ 	if(rg)
+ 		runtime_ready(rg);
+ 	if(wg)
+@@ -452,7 +452,7 @@
+ 	PollDesc *pd;
+ 	uint32 i, n;
+ 
+-	runtime_lock(&pollcache);
++	runtime_lock(&pollcache.lock);
+ 	if(pollcache.first == nil) {
+ 		n = PollBlockSize/sizeof(*pd);
+ 		if(n == 0)
+@@ -467,6 +467,6 @@
+ 	}
+ 	pd = pollcache.first;
+ 	pollcache.first = pd->link;
+-	runtime_unlock(&pollcache);
++	runtime_unlock(&pollcache.lock);
+ 	return pd;
+ }
+diff -r 225a208260a6 libgo/runtime/proc.c
+--- a/libgo/runtime/proc.c	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/proc.c	Tue Sep 23 15:59:57 2014 -0700
+@@ -357,7 +357,7 @@
+ 
+ typedef struct Sched Sched;
+ struct Sched {
+-	Lock;
++	Lock	lock;
+ 
+ 	uint64	goidgen;
+ 	M*	midle;	 // idle m's waiting for work
+@@ -770,7 +770,7 @@
+ 
+ 	mp->fastrand = 0x49f6428aUL + mp->id + runtime_cputicks();
+ 
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	mp->id = runtime_sched.mcount++;
+ 	checkmcount();
+ 	runtime_mpreinit(mp);
+@@ -781,7 +781,7 @@
+ 	// runtime_NumCgoCall() iterates over allm w/o schedlock,
+ 	// so we need to publish it safely.
+ 	runtime_atomicstorep(&runtime_allm, mp);
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ }
+ 
+ // Mark gp ready to run.
+@@ -808,7 +808,7 @@
+ 
+ 	// Figure out how many CPUs to use during GC.
+ 	// Limited by gomaxprocs, number of actual CPUs, and MaxGcproc.
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	n = runtime_gomaxprocs;
+ 	if(n > runtime_ncpu)
+ 		n = runtime_ncpu > 0 ? runtime_ncpu : 1;
+@@ -816,7 +816,7 @@
+ 		n = MaxGcproc;
+ 	if(n > runtime_sched.nmidle+1) // one M is currently running
+ 		n = runtime_sched.nmidle+1;
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 	return n;
+ }
+ 
+@@ -825,14 +825,14 @@
+ {
+ 	int32 n;
+ 
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	n = runtime_gomaxprocs;
+ 	if(n > runtime_ncpu)
+ 		n = runtime_ncpu;
+ 	if(n > MaxGcproc)
+ 		n = MaxGcproc;
+ 	n -= runtime_sched.nmidle+1; // one M is currently running
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 	return n > 0;
+ }
+ 
+@@ -842,7 +842,7 @@
+ 	M *mp;
+ 	int32 n, pos;
+ 
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	pos = 0;
+ 	for(n = 1; n < nproc; n++) {  // one M is currently running
+ 		if(runtime_allp[pos]->mcache == m->mcache)
+@@ -855,7 +855,7 @@
+ 		pos++;
+ 		runtime_notewakeup(&mp->park);
+ 	}
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ }
+ 
+ // Similar to stoptheworld but best-effort and can be called several times.
+@@ -894,7 +894,7 @@
+ 	P *p;
+ 	bool wait;
+ 
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	runtime_sched.stopwait = runtime_gomaxprocs;
+ 	runtime_atomicstore((uint32*)&runtime_sched.gcwaiting, 1);
+ 	preemptall();
+@@ -914,7 +914,7 @@
+ 		runtime_sched.stopwait--;
+ 	}
+ 	wait = runtime_sched.stopwait > 0;
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 
+ 	// wait for remaining P's to stop voluntarily
+ 	if(wait) {
+@@ -948,7 +948,7 @@
+ 	gp = runtime_netpoll(false);  // non-blocking
+ 	injectglist(gp);
+ 	add = needaddgcproc();
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	if(newprocs) {
+ 		procresize(newprocs);
+ 		newprocs = 0;
+@@ -972,7 +972,7 @@
+ 		runtime_sched.sysmonwait = false;
+ 		runtime_notewakeup(&runtime_sched.sysmonnote);
+ 	}
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 
+ 	while(p1) {
+ 		p = p1;
+@@ -1404,9 +1404,9 @@
+ 	}
+ 
+ retry:
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	mput(m);
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 	runtime_notesleep(&m->park);
+ 	runtime_noteclear(&m->park);
+ 	if(m->helpgc) {
+@@ -1433,18 +1433,18 @@
+ 	M *mp;
+ 	void (*fn)(void);
+ 
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	if(p == nil) {
+ 		p = pidleget();
+ 		if(p == nil) {
+-			runtime_unlock(&runtime_sched);
++			runtime_unlock(&runtime_sched.lock);
+ 			if(spinning)
+ 				runtime_xadd(&runtime_sched.nmspinning, -1);
+ 			return;
+ 		}
+ 	}
+ 	mp = mget();
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 	if(mp == nil) {
+ 		fn = nil;
+ 		if(spinning)
+@@ -1477,28 +1477,28 @@
+ 		startm(p, true);
+ 		return;
+ 	}
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	if(runtime_sched.gcwaiting) {
+ 		p->status = Pgcstop;
+ 		if(--runtime_sched.stopwait == 0)
+ 			runtime_notewakeup(&runtime_sched.stopnote);
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 		return;
+ 	}
+ 	if(runtime_sched.runqsize) {
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 		startm(p, false);
+ 		return;
+ 	}
+ 	// If this is the last running P and nobody is polling network,
+ 	// need to wakeup another M to poll network.
+ 	if(runtime_sched.npidle == (uint32)runtime_gomaxprocs-1 && runtime_atomicload64(&runtime_sched.lastpoll) != 0) {
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 		startm(p, false);
+ 		return;
+ 	}
+ 	pidleput(p);
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ }
+ 
+ // Tries to add one more P to execute G's.
+@@ -1570,11 +1570,11 @@
+ 		runtime_xadd(&runtime_sched.nmspinning, -1);
+ 	}
+ 	p = releasep();
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	p->status = Pgcstop;
+ 	if(--runtime_sched.stopwait == 0)
+ 		runtime_notewakeup(&runtime_sched.stopnote);
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 	stopm();
+ }
+ 
+@@ -1625,9 +1625,9 @@
+ 		return gp;
+ 	// global runq
+ 	if(runtime_sched.runqsize) {
+-		runtime_lock(&runtime_sched);
++		runtime_lock(&runtime_sched.lock);
+ 		gp = globrunqget(m->p, 0);
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 		if(gp)
+ 			return gp;
+ 	}
+@@ -1661,19 +1661,19 @@
+ 	}
+ stop:
+ 	// return P and block
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	if(runtime_sched.gcwaiting) {
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 		goto top;
+ 	}
+ 	if(runtime_sched.runqsize) {
+ 		gp = globrunqget(m->p, 0);
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 		return gp;
+ 	}
+ 	p = releasep();
+ 	pidleput(p);
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 	if(m->spinning) {
+ 		m->spinning = false;
+ 		runtime_xadd(&runtime_sched.nmspinning, -1);
+@@ -1682,9 +1682,9 @@
+ 	for(i = 0; i < runtime_gomaxprocs; i++) {
+ 		p = runtime_allp[i];
+ 		if(p && p->runqhead != p->runqtail) {
+-			runtime_lock(&runtime_sched);
++			runtime_lock(&runtime_sched.lock);
+ 			p = pidleget();
+-			runtime_unlock(&runtime_sched);
++			runtime_unlock(&runtime_sched.lock);
+ 			if(p) {
+ 				acquirep(p);
+ 				goto top;
+@@ -1701,9 +1701,9 @@
+ 		gp = runtime_netpoll(true);  // block until new work is available
+ 		runtime_atomicstore64(&runtime_sched.lastpoll, runtime_nanotime());
+ 		if(gp) {
+-			runtime_lock(&runtime_sched);
++			runtime_lock(&runtime_sched.lock);
+ 			p = pidleget();
+-			runtime_unlock(&runtime_sched);
++			runtime_unlock(&runtime_sched.lock);
+ 			if(p) {
+ 				acquirep(p);
+ 				injectglist(gp->schedlink);
+@@ -1746,14 +1746,14 @@
+ 
+ 	if(glist == nil)
+ 		return;
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	for(n = 0; glist; n++) {
+ 		gp = glist;
+ 		glist = gp->schedlink;
+ 		gp->status = Grunnable;
+ 		globrunqput(gp);
+ 	}
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 
+ 	for(; n && runtime_sched.npidle; n--)
+ 		startm(nil, false);
+@@ -1784,9 +1784,9 @@
+ 	// This is a fancy way to say tick%61==0,
+ 	// it uses 2 MUL instructions instead of a single DIV and so is faster on modern processors.
+ 	if(tick - (((uint64)tick*0x4325c53fu)>>36)*61 == 0 && runtime_sched.runqsize > 0) {
+-		runtime_lock(&runtime_sched);
++		runtime_lock(&runtime_sched.lock);
+ 		gp = globrunqget(m->p, 1);
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 		if(gp)
+ 			resetspinning();
+ 	}
+@@ -1880,9 +1880,9 @@
+ 	gp->status = Grunnable;
+ 	gp->m = nil;
+ 	m->curg = nil;
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	globrunqput(gp);
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 	if(m->lockedg) {
+ 		stoplockedm();
+ 		execute(gp);  // Never returns.
+@@ -1985,24 +1985,24 @@
+ 	g->status = Gsyscall;
+ 
+ 	if(runtime_atomicload(&runtime_sched.sysmonwait)) {  // TODO: fast atomic
+-		runtime_lock(&runtime_sched);
++		runtime_lock(&runtime_sched.lock);
+ 		if(runtime_atomicload(&runtime_sched.sysmonwait)) {
+ 			runtime_atomicstore(&runtime_sched.sysmonwait, 0);
+ 			runtime_notewakeup(&runtime_sched.sysmonnote);
+ 		}
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 	}
+ 
+ 	m->mcache = nil;
+ 	m->p->m = nil;
+ 	runtime_atomicstore(&m->p->status, Psyscall);
+ 	if(runtime_sched.gcwaiting) {
+-		runtime_lock(&runtime_sched);
++		runtime_lock(&runtime_sched.lock);
+ 		if (runtime_sched.stopwait > 0 && runtime_cas(&m->p->status, Psyscall, Pgcstop)) {
+ 			if(--runtime_sched.stopwait == 0)
+ 				runtime_notewakeup(&runtime_sched.stopnote);
+ 		}
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 	}
+ 
+ 	m->locks--;
+@@ -2113,13 +2113,13 @@
+ 	// Try to get any other idle P.
+ 	m->p = nil;
+ 	if(runtime_sched.pidle) {
+-		runtime_lock(&runtime_sched);
++		runtime_lock(&runtime_sched.lock);
+ 		p = pidleget();
+ 		if(p && runtime_atomicload(&runtime_sched.sysmonwait)) {
+ 			runtime_atomicstore(&runtime_sched.sysmonwait, 0);
+ 			runtime_notewakeup(&runtime_sched.sysmonnote);
+ 		}
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 		if(p) {
+ 			acquirep(p);
+ 			return true;
+@@ -2138,7 +2138,7 @@
+ 	gp->status = Grunnable;
+ 	gp->m = nil;
+ 	m->curg = nil;
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	p = pidleget();
+ 	if(p == nil)
+ 		globrunqput(gp);
+@@ -2146,7 +2146,7 @@
+ 		runtime_atomicstore(&runtime_sched.sysmonwait, 0);
+ 		runtime_notewakeup(&runtime_sched.sysmonnote);
+ 	}
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 	if(p) {
+ 		acquirep(p);
+ 		execute(gp);  // Never returns.
+@@ -2425,13 +2425,13 @@
+ 
+ 	if(n > MaxGomaxprocs)
+ 		n = MaxGomaxprocs;
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	ret = runtime_gomaxprocs;
+ 	if(n <= 0 || n == ret) {
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 		return ret;
+ 	}
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 
+ 	runtime_semacquire(&runtime_worldsema, false);
+ 	m->gcing = 1;
+@@ -2536,7 +2536,7 @@
+ }
+ 
+ static struct {
+-	Lock;
++	Lock lock;
+ 	void (*fn)(uintptr*, int32);
+ 	int32 hz;
+ 	uintptr pcbuf[TracebackMaxFrames];
+@@ -2568,9 +2568,9 @@
+ 	if(mp->mcache == nil)
+ 		traceback = false;
+ 
+-	runtime_lock(&prof);
++	runtime_lock(&prof.lock);
+ 	if(prof.fn == nil) {
+-		runtime_unlock(&prof);
++		runtime_unlock(&prof.lock);
+ 		mp->mallocing--;
+ 		return;
+ 	}
+@@ -2598,7 +2598,7 @@
+ 			prof.pcbuf[1] = (uintptr)System;
+ 	}
+ 	prof.fn(prof.pcbuf, n);
+-	runtime_unlock(&prof);
++	runtime_unlock(&prof.lock);
+ 	mp->mallocing--;
+ }
+ 
+@@ -2623,13 +2623,13 @@
+ 	// it would deadlock.
+ 	runtime_resetcpuprofiler(0);
+ 
+-	runtime_lock(&prof);
++	runtime_lock(&prof.lock);
+ 	prof.fn = fn;
+ 	prof.hz = hz;
+-	runtime_unlock(&prof);
+-	runtime_lock(&runtime_sched);
++	runtime_unlock(&prof.lock);
++	runtime_lock(&runtime_sched.lock);
+ 	runtime_sched.profilehz = hz;
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 
+ 	if(hz != 0)
+ 		runtime_resetcpuprofiler(hz);
+@@ -2767,11 +2767,11 @@
+ static void
+ incidlelocked(int32 v)
+ {
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	runtime_sched.nmidlelocked += v;
+ 	if(v > 0)
+ 		checkdead();
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ }
+ 
+ // Check for deadlock situation.
+@@ -2840,16 +2840,16 @@
+ 		runtime_usleep(delay);
+ 		if(runtime_debug.schedtrace <= 0 &&
+ 			(runtime_sched.gcwaiting || runtime_atomicload(&runtime_sched.npidle) == (uint32)runtime_gomaxprocs)) {  // TODO: fast atomic
+-			runtime_lock(&runtime_sched);
++			runtime_lock(&runtime_sched.lock);
+ 			if(runtime_atomicload(&runtime_sched.gcwaiting) || runtime_atomicload(&runtime_sched.npidle) == (uint32)runtime_gomaxprocs) {
+ 				runtime_atomicstore(&runtime_sched.sysmonwait, 1);
+-				runtime_unlock(&runtime_sched);
++				runtime_unlock(&runtime_sched.lock);
+ 				runtime_notesleep(&runtime_sched.sysmonnote);
+ 				runtime_noteclear(&runtime_sched.sysmonnote);
+ 				idle = 0;
+ 				delay = 20;
+ 			} else
+-				runtime_unlock(&runtime_sched);
++				runtime_unlock(&runtime_sched.lock);
+ 		}
+ 		// poll network if not polled for more than 10ms
+ 		lastpoll = runtime_atomicload64(&runtime_sched.lastpoll);
+@@ -2978,7 +2978,7 @@
+ 	if(starttime == 0)
+ 		starttime = now;
+ 
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	runtime_printf("SCHED %Dms: gomaxprocs=%d idleprocs=%d threads=%d idlethreads=%d runqueue=%d",
+ 		(now-starttime)/1000000, runtime_gomaxprocs, runtime_sched.npidle, runtime_sched.mcount,
+ 		runtime_sched.nmidle, runtime_sched.runqsize);
+@@ -3014,7 +3014,7 @@
+ 		}
+ 	}
+ 	if(!detailed) {
+-		runtime_unlock(&runtime_sched);
++		runtime_unlock(&runtime_sched.lock);
+ 		return;
+ 	}
+ 	for(mp = runtime_allm; mp; mp = mp->alllink) {
+@@ -3046,7 +3046,7 @@
+ 			lockedm ? lockedm->id : -1);
+ 	}
+ 	runtime_unlock(&allglock);
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ }
+ 
+ // Put mp on midle list.
+@@ -3202,9 +3202,9 @@
+ 	for(i=0; i<n; i++)
+ 		batch[i]->schedlink = batch[i+1];
+ 	// Now put the batch on global queue.
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	globrunqputbatch(batch[0], batch[n], n+1);
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 	return true;
+ }
+ 
+@@ -3356,11 +3356,11 @@
+ {
+ 	int32 out;
+ 
+-	runtime_lock(&runtime_sched);
++	runtime_lock(&runtime_sched.lock);
+ 	out = runtime_sched.maxmcount;
+ 	runtime_sched.maxmcount = in;
+ 	checkmcount();
+-	runtime_unlock(&runtime_sched);
++	runtime_unlock(&runtime_sched.lock);
+ 	return out;
+ }
+ 
+diff -r 225a208260a6 libgo/runtime/runtime.h
+--- a/libgo/runtime/runtime.h	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/runtime.h	Tue Sep 23 15:59:57 2014 -0700
+@@ -286,7 +286,7 @@
+ 
+ struct P
+ {
+-	Lock;
++	Lock	lock;
+ 
+ 	int32	id;
+ 	uint32	status;		// one of Pidle/Prunning/...
+@@ -384,7 +384,7 @@
+ 
+ struct	Timers
+ {
+-	Lock;
++	Lock	lock;
+ 	G	*timerproc;
+ 	bool		sleeping;
+ 	bool		rescheduling;
+diff -r 225a208260a6 libgo/runtime/sema.goc
+--- a/libgo/runtime/sema.goc	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/sema.goc	Tue Sep 23 15:59:57 2014 -0700
+@@ -35,7 +35,7 @@
+ typedef struct SemaRoot SemaRoot;
+ struct SemaRoot
+ {
+-	Lock;
++	Lock		lock;
+ 	SemaWaiter*	head;
+ 	SemaWaiter*	tail;
+ 	// Number of waiters. Read w/o the lock.
+@@ -47,7 +47,7 @@
+ 
+ struct semtable
+ {
+-	SemaRoot;
++	SemaRoot root;
+ 	uint8 pad[CacheLineSize-sizeof(SemaRoot)];
+ };
+ static struct semtable semtable[SEMTABLESZ];
+@@ -55,7 +55,7 @@
+ static SemaRoot*
+ semroot(uint32 volatile *addr)
+ {
+-	return &semtable[((uintptr)addr >> 3) % SEMTABLESZ];
++	return &semtable[((uintptr)addr >> 3) % SEMTABLESZ].root;
+ }
+ 
+ static void
+@@ -124,19 +124,19 @@
+ 	}
+ 	for(;;) {
+ 
+-		runtime_lock(root);
++		runtime_lock(&root->lock);
+ 		// Add ourselves to nwait to disable "easy case" in semrelease.
+ 		runtime_xadd(&root->nwait, 1);
+ 		// Check cansemacquire to avoid missed wakeup.
+ 		if(cansemacquire(addr)) {
+ 			runtime_xadd(&root->nwait, -1);
+-			runtime_unlock(root);
++			runtime_unlock(&root->lock);
+ 			return;
+ 		}
+ 		// Any semrelease after the cansemacquire knows we're waiting
+ 		// (we set nwait above), so go to sleep.
+ 		semqueue(root, addr, &s);
+-		runtime_parkunlock(root, "semacquire");
++		runtime_parkunlock(&root->lock, "semacquire");
+ 		if(cansemacquire(addr)) {
+ 			if(t0)
+ 				runtime_blockevent(s.releasetime - t0, 3);
+@@ -161,11 +161,11 @@
+ 		return;
+ 
+ 	// Harder case: search for a waiter and wake it.
+-	runtime_lock(root);
++	runtime_lock(&root->lock);
+ 	if(runtime_atomicload(&root->nwait) == 0) {
+ 		// The count is already consumed by another goroutine,
+ 		// so no need to wake up another goroutine.
+-		runtime_unlock(root);
++		runtime_unlock(&root->lock);
+ 		return;
+ 	}
+ 	for(s = root->head; s; s = s->next) {
+@@ -175,7 +175,7 @@
+ 			break;
+ 		}
+ 	}
+-	runtime_unlock(root);
++	runtime_unlock(&root->lock);
+ 	if(s) {
+ 		if(s->releasetime)
+ 			s->releasetime = runtime_cputicks();
+@@ -211,7 +211,7 @@
+ typedef struct SyncSema SyncSema;
+ struct SyncSema
+ {
+-	Lock;
++	Lock		lock;
+ 	SemaWaiter*	head;
+ 	SemaWaiter*	tail;
+ };
+@@ -238,7 +238,7 @@
+ 		w.releasetime = -1;
+ 	}
+ 
+-	runtime_lock(s);
++	runtime_lock(&s->lock);
+ 	if(s->head && s->head->nrelease > 0) {
+ 		// have pending release, consume it
+ 		wake = nil;
+@@ -249,7 +249,7 @@
+ 			if(s->head == nil)
+ 				s->tail = nil;
+ 		}
+-		runtime_unlock(s);
++		runtime_unlock(&s->lock);
+ 		if(wake)
+ 			runtime_ready(wake->g);
+ 	} else {
+@@ -259,7 +259,7 @@
+ 		else
+ 			s->tail->next = &w;
+ 		s->tail = &w;
+-		runtime_parkunlock(s, "semacquire");
++		runtime_parkunlock(&s->lock, "semacquire");
+ 		if(t0)
+ 			runtime_blockevent(w.releasetime - t0, 2);
+ 	}
+@@ -274,7 +274,7 @@
+ 	w.next = nil;
+ 	w.releasetime = 0;
+ 
+-	runtime_lock(s);
++	runtime_lock(&s->lock);
+ 	while(w.nrelease > 0 && s->head && s->head->nrelease < 0) {
+ 		// have pending acquire, satisfy it
+ 		wake = s->head;
+@@ -293,7 +293,7 @@
+ 		else
+ 			s->tail->next = &w;
+ 		s->tail = &w;
+-		runtime_parkunlock(s, "semarelease");
++		runtime_parkunlock(&s->lock, "semarelease");
+ 	} else
+-		runtime_unlock(s);
++		runtime_unlock(&s->lock);
+ }
+diff -r 225a208260a6 libgo/runtime/sigqueue.goc
+--- a/libgo/runtime/sigqueue.goc	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/sigqueue.goc	Tue Sep 23 15:59:57 2014 -0700
+@@ -32,7 +32,7 @@
+ #include "defs.h"
+ 
+ static struct {
+-	Note;
++	Note note;
+ 	uint32 mask[(NSIG+31)/32];
+ 	uint32 wanted[(NSIG+31)/32];
+ 	uint32 state;
+@@ -70,7 +70,7 @@
+ 					new = HASSIGNAL;
+ 				if(runtime_cas(&sig.state, old, new)) {
+ 					if (old == HASWAITER)
+-						runtime_notewakeup(&sig);
++						runtime_notewakeup(&sig.note);
+ 					break;
+ 				}
+ 			}
+@@ -107,8 +107,8 @@
+ 				new = HASWAITER;
+ 			if(runtime_cas(&sig.state, old, new)) {
+ 				if (new == HASWAITER) {
+-					runtime_notetsleepg(&sig, -1);
+-					runtime_noteclear(&sig);
++					runtime_notetsleepg(&sig.note, -1);
++					runtime_noteclear(&sig.note);
+ 				}
+ 				break;
+ 			}
+@@ -138,7 +138,7 @@
+ 		// to use for initialization.  It does not pass
+ 		// signal information in m.
+ 		sig.inuse = true;	// enable reception of signals; cannot disable
+-		runtime_noteclear(&sig);
++		runtime_noteclear(&sig.note);
+ 		return;
+ 	}
+ 	
+diff -r 225a208260a6 libgo/runtime/time.goc
+--- a/libgo/runtime/time.goc	Mon Sep 22 14:14:24 2014 -0700
++++ b/libgo/runtime/time.goc	Tue Sep 23 15:59:57 2014 -0700
+@@ -94,17 +94,17 @@
+ 	t.period = 0;
+ 	t.fv = &readyv;
+ 	t.arg.__object = g;
+-	runtime_lock(&timers);
++	runtime_lock(&timers.lock);
+ 	addtimer(&t);
+-	runtime_parkunlock(&timers, reason);
++	runtime_parkunlock(&timers.lock, reason);
+ }
+ 
+ void
+ runtime_addtimer(Timer *t)
+ {
+-	runtime_lock(&timers);
++	runtime_lock(&timers.lock);
+ 	addtimer(t);
+-	runtime_unlock(&timers);
++	runtime_unlock(&timers.lock);
+ }
+ 
+ // Add a timer to the heap and start or kick the timer proc
+@@ -169,14 +169,14 @@
+ 	i = t->i;
+ 	gi = i;
+ 
+-	runtime_lock(&timers);
++	runtime_lock(&timers.lock);
+ 
+ 	// t may not be registered anymore and may have
+ 	// a bogus i (typically 0, if generated by Go).
+ 	// Verify it before proceeding.
+ 	i = t->i;
+ 	if(i < 0 || i >= timers.len || timers.t[i] != t) {
+-		runtime_unlock(&timers);
++		runtime_unlock(&timers.lock);
+ 		return false;
+ 	}
+ 
+@@ -192,7 +192,7 @@
+ 	}
+ 	if(debug)
+ 		dumptimers("deltimer");
+-	runtime_unlock(&timers);
++	runtime_unlock(&timers.lock);
+ 	return true;
+ }
+ 
+@@ -210,7 +210,7 @@
+ 	Eface arg;
+ 
+ 	for(;;) {
+-		runtime_lock(&timers);
++		runtime_lock(&timers.lock);
+ 		timers.sleeping = false;
+ 		now = runtime_nanotime();
+ 		for(;;) {
+@@ -236,7 +236,7 @@
+ 			fv = t->fv;
+ 			f = (void*)t->fv->fn;
+ 			arg = t->arg;
+-			runtime_unlock(&timers);
++			runtime_unlock(&timers.lock);
+ 			if(raceenabled)
+ 				runtime_raceacquire(t);
+ 			__go_set_closure(fv);
+@@ -249,20 +249,20 @@
+ 			arg.__object = nil;
+ 			USED(&arg);
+ 
+-			runtime_lock(&timers);
++			runtime_lock(&timers.lock);
+ 		}
+ 		if(delta < 0) {
+ 			// No timers left - put goroutine to sleep.
+ 			timers.rescheduling = true;
+ 			runtime_g()->isbackground = true;
+-			runtime_parkunlock(&timers, "timer goroutine (idle)");
++			runtime_parkunlock(&timers.lock, "timer goroutine (idle)");
+ 			runtime_g()->isbackground = false;
+ 			continue;
+ 		}
+ 		// At least one timer pending.  Sleep until then.
+ 		timers.sleeping = true;
+ 		runtime_noteclear(&timers.waitnote);
+-		runtime_unlock(&timers);
++		runtime_unlock(&timers.lock);
+ 		runtime_notetsleepg(&timers.waitnote, delta);
+ 	}
+ }