{
Type *t1;
- if(s == S) {
- if(!typesu[t->etype])
- diag(Z, "unnamed structure element must be struct/union");
- if(c != CXXX)
- diag(Z, "unnamed structure element cannot have class");
- } else
+ if(s == S)
+ diag(Z, "unnamed structure elements not supported");
+ else
if(c != CXXX)
diag(Z, "structure element cannot have class: %s", s->name);
t1 = t;
typedef struct Callbacks Callbacks;
struct Callbacks {
- Lock;
+ Lock lock;
WinCallbackContext* ctxt[cb_max];
int32 n;
};
argsize += sizeof(uintptr);
}
- runtime·lock(&cbs);
+ runtime·lock(&cbs.lock);
if(runtime·cbctxts == nil)
runtime·cbctxts = &(cbs.ctxt[0]);
n = cbs.n;
for(i=0; i<n; i++) {
if(cbs.ctxt[i]->gobody == fn.data && cbs.ctxt[i]->cleanstack == cleanstack) {
- runtime·unlock(&cbs);
+ runtime·unlock(&cbs.lock);
// runtime·callbackasm is just a series of CALL instructions
// (each is 5 bytes long), and we want callback to arrive at
// correspondent call instruction instead of start of
c->restorestack = 0;
cbs.ctxt[n] = c;
cbs.n++;
- runtime·unlock(&cbs);
+ runtime·unlock(&cbs.lock);
// as before
return (byte*)runtime·callbackasm + n * 5;
mysg.releasetime = -1;
}
- runtime·lock(c);
+ runtime·lock(&c->lock);
if(raceenabled)
runtime·racereadpc(c, pc, chansend);
if(c->closed)
if(sg != nil) {
if(raceenabled)
racesync(c, sg);
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
gp = sg->g;
gp->param = sg;
}
if(!block) {
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
return false;
}
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;
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;
}
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
}
mysg.releasetime = -1;
}
- runtime·lock(c);
+ runtime·lock(&c->lock);
if(c->dataqsiz > 0)
goto asynch;
if(sg != nil) {
if(raceenabled)
racesync(c, sg);
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
if(ep != nil)
c->elemtype->alg->copy(c->elemsize, ep, sg->elem);
}
if(!block) {
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
return false;
}
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;
goto closed;
if(!block) {
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
if(received != nil)
*received = false;
return false;
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;
}
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;
*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;
c0 = sel->lockorder[i];
if(c0 && c0 != c) {
c = sel->lockorder[i];
- runtime·lock(c);
+ runtime·lock(&c->lock);
}
}
}
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);
}
}
if(c == nil)
runtime·panicstring("close of nil channel");
- runtime·lock(c);
+ runtime·lock(&c->lock);
if(c->closed) {
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
runtime·panicstring("close of closed channel");
}
runtime·ready(gp);
}
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
}
func reflect·chanlen(c *Hchan) (len int) {
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.
uint32 pc; /* pc */
uint32 cs; /* old context */
uint32 flags; /* old flags */
- union {
- uint32 usp;
- uint32 sp;
- };
+ uint32 sp;
uint32 ss; /* old stack segment */
};
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->fint, spf->ot);
}
}
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);
}
// compiler has provided some good hash codes for us.
- h = inter->hash;
+ h = inter->typ.hash;
h += 17 * type->hash;
// TODO(rsc): h += 23 * x->mhash ?
h %= nelem(hash);
throw:
// didn't find method
runtime·newTypeAssertionError(
- nil, type->string, inter->string,
+ nil, type->string, inter->typ.string,
iname, &err);
if(locked)
runtime·unlock(&ifacelock);
}
if(tab->type != t) {
runtime·newTypeAssertionError(
- tab->inter->string, tab->type->string, t->string,
+ tab->inter->typ.string, tab->type->string, t->string,
nil, &err);
runtime·panic(err);
}
if(tab == nil) {
// explicit conversions require non-nil interface value.
runtime·newTypeAssertionError(
- nil, nil, inter->string,
+ nil, nil, inter->typ.string,
nil, &err);
runtime·panic(err);
}
if(tab == nil) {
// explicit conversions require non-nil interface value.
runtime·newTypeAssertionError(
- nil, nil, inter->string,
+ nil, nil, inter->typ.string,
nil, &err);
runtime·panic(err);
}
if(t == nil) {
// explicit conversions require non-nil interface value.
runtime·newTypeAssertionError(
- nil, nil, inter->string,
+ nil, nil, inter->typ.string,
nil, &err);
runtime·panic(err);
}
if(t == nil) {
// explicit conversions require non-nil interface value.
runtime·newTypeAssertionError(
- nil, nil, inter->string,
+ nil, nil, inter->typ.string,
nil, &err);
runtime·panic(err);
}
g->m->mcache->local_nlookup++;
if (sizeof(void*) == 4 && g->m->mcache->local_nlookup >= (1<<30)) {
// purge cache stats to prevent overflow
- runtime·lock(&runtime·mheap);
+ runtime·lock(&runtime·mheap.lock);
runtime·purgecachedstats(g->m->mcache);
- runtime·unlock(&runtime·mheap);
+ runtime·unlock(&runtime·mheap.lock);
}
s = runtime·MHeap_LookupMaybe(&runtime·mheap, v);
static struct
{
- Lock;
+ Lock lock;
byte* pos;
byte* end;
} persistent;
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);
typedef struct SpecialFinalizer SpecialFinalizer;
struct SpecialFinalizer
{
- Special;
+ Special special;
FuncVal* fn;
uintptr nret;
Type* fint;
typedef struct SpecialProfile SpecialProfile;
struct SpecialProfile
{
- Special;
+ Special special;
Bucket* b;
};
// 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)
// 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
// spaced CacheLineSize bytes apart, so that each MCentral.Lock
// gets its own cache line.
struct {
- MCentral;
+ MCentral mcentral;
byte pad[CacheLineSize];
} central[NumSizeClasses];
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;
runtime·MCache_ReleaseAll(c);
runtime·stackcache_clear(c);
runtime·gcworkbuffree(c->gcworkbuf);
- 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);
}
static void
s->incache = false;
// 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) {
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;
}
}
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;
}
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;
}
// Replenish central list if empty.
if(!MCentral_Grow(c)) {
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
return nil;
}
goto retry;
runtime·MSpanList_Remove(s);
runtime·MSpanList_InsertBack(&c->empty, s);
s->incache = true;
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
return s;
}
{
int32 cap, n;
- runtime·lock(c);
+ runtime·lock(&c->lock);
s->incache = false;
runtime·MSpanList_Remove(s);
runtime·MSpanList_Insert(&c->nonempty, s);
}
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
}
// Free n objects from a span s back into the central free list c.
{
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) {
runtime·atomicstore(&s->sweepgen, runtime·mheap.sweepgen);
if(s->ref != 0) {
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
return false;
}
runtime·MSpanList_Remove(s);
s->needzero = 1;
s->freelist = nil;
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
runtime·unmarkspan((byte*)(s->start<<PageShift), s->npages<<PageShift);
runtime·MHeap_Free(&runtime·mheap, s, 0);
return true;
byte *p;
MSpan *s;
- runtime·unlock(c);
+ runtime·unlock(&c->lock);
npages = runtime·class_to_allocnpages[c->sizeclass];
size = runtime·class_to_size[c->sizeclass];
n = (npages << PageShift) / size;
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;
}
*tailp = nil;
runtime·markspan((byte*)(s->start<<PageShift), size, n, size*n < (s->npages<<PageShift));
- runtime·lock(c);
+ runtime·lock(&c->lock);
runtime·MSpanList_Insert(&c->nonempty, s);
return true;
}
// 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);
scanblock(p, s->elemsize, nil);
scanblock((void*)&spf->fn, PtrSize, ScanConservatively);
}
c->local_nsmallfree[cl] += nfree;
c->local_cachealloc -= nfree * size;
runtime·xadd64(&mstats.next_gc, -(uint64)(nfree * size * (runtime·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;
return;
if(runtime·gcpercent == GcpercentUnknown) { // first time through
- runtime·lock(&runtime·mheap);
+ runtime·lock(&runtime·mheap.lock);
if(runtime·gcpercent == GcpercentUnknown)
runtime·gcpercent = runtime·readgogc();
- runtime·unlock(&runtime·mheap);
+ runtime·unlock(&runtime·mheap.lock);
}
if(runtime·gcpercent < 0)
return;
// 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);
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->len = n+3;
}
runtime·setgcpercent(int32 in) {
int32 out;
- runtime·lock(&runtime·mheap);
+ runtime·lock(&runtime·mheap.lock);
if(runtime·gcpercent == GcpercentUnknown)
runtime·gcpercent = runtime·readgogc();
out = runtime·gcpercent;
if(in < 0)
in = -1;
runtime·gcpercent = in;
- runtime·unlock(&runtime·mheap);
+ runtime·unlock(&runtime·mheap.lock);
return out;
}
} else if(((InterfaceType*)f->fint)->mhdr.len == 0) {
// convert to empty interface
ef = (Eface*)frame;
- ef->type = f->ot;
+ ef->type = &f->ot->typ;
ef->data = f->arg;
} else {
// convert to interface with methods, via empty interface.
- ef1.type = f->ot;
+ ef1.type = &f->ot->typ;
ef1.data = f->arg;
if(!runtime·ifaceE2I2((InterfaceType*)f->fint, ef1, (Iface*)frame))
runtime·throw("invalid type conversion in runfinq");
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
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
}
// Now sweep everything that is not yet swept.
- runtime·unlock(h);
+ runtime·unlock(&h->lock);
for(;;) {
n = runtime·sweepone();
if(n == -1) // all spans are swept
if(reclaimed >= npage)
break;
}
- runtime·lock(h);
+ runtime·lock(&h->lock);
}
// Allocate a new span of npage pages from the heap for GC'd memory
if(g != g->m->g0)
runtime·throw("mheap_alloc not on M stack");
- runtime·lock(h);
+ runtime·lock(&h->lock);
// To prevent excessive heap growth, before allocating n pages
// we need to sweep and reclaim at least n pages.
runtime·MSpanList_InsertBack(&h->busylarge, s);
}
}
- runtime·unlock(h);
+ runtime·unlock(&h->lock);
return s;
}
if(g != g->m->g0)
runtime·throw("mheap_allocstack not on M stack");
- runtime·lock(h);
+ runtime·lock(&h->lock);
s = MHeap_AllocSpanLocked(h, npage);
if(s != nil) {
s->state = MSpanStack;
s->ref = 0;
mstats.stacks_inuse += s->npages<<PageShift;
}
- runtime·unlock(h);
+ runtime·unlock(&h->lock);
return s;
}
{
if(g != g->m->g0)
runtime·throw("mheap_free not on M stack");
- runtime·lock(h);
+ runtime·lock(&h->lock);
mstats.heap_alloc += g->m->mcache->local_cachealloc;
g->m->mcache->local_cachealloc = 0;
if(acct) {
mstats.heap_objects--;
}
MHeap_FreeSpanLocked(h, s);
- runtime·unlock(h);
+ runtime·unlock(&h->lock);
}
static void
if(g != g->m->g0)
runtime·throw("mheap_freestack not on M stack");
s->needzero = 1;
- runtime·lock(h);
+ runtime·lock(&h->lock);
mstats.stacks_inuse -= s->npages<<PageShift;
MHeap_FreeSpanLocked(h, s);
- runtime·unlock(h);
+ runtime·unlock(&h->lock);
}
static void
static void
scavenge_m(G *gp)
{
- runtime·lock(&runtime·mheap);
+ runtime·lock(&runtime·mheap.lock);
scavenge(g->m->scalararg[0], g->m->scalararg[1], g->m->scalararg[2]);
- runtime·unlock(&runtime·mheap);
+ runtime·unlock(&runtime·mheap.lock);
runtime·gogo(&gp->sched);
}
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->nret = nret;
s->fint = fint;
s->ot = ot;
- if(addspecial(p, s))
+ if(addspecial(p, &s->special))
return true;
// There was an old finalizer
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");
}
Bucket *b;
for(b=mbuckets; b; b=b->allnext) {
- b->allocs += b->prev_allocs;
- b->frees += b->prev_frees;
- b->alloc_bytes += b->prev_alloc_bytes;
- b->free_bytes += b->prev_free_bytes;
-
- b->prev_allocs = b->recent_allocs;
- b->prev_frees = b->recent_frees;
- b->prev_alloc_bytes = b->recent_alloc_bytes;
- b->prev_free_bytes = b->recent_free_bytes;
-
- b->recent_allocs = 0;
- b->recent_frees = 0;
- b->recent_alloc_bytes = 0;
- b->recent_free_bytes = 0;
+ b->data.mp.allocs += b->data.mp.prev_allocs;
+ b->data.mp.frees += b->data.mp.prev_frees;
+ b->data.mp.alloc_bytes += b->data.mp.prev_alloc_bytes;
+ b->data.mp.free_bytes += b->data.mp.prev_free_bytes;
+
+ b->data.mp.prev_allocs = b->data.mp.recent_allocs;
+ b->data.mp.prev_frees = b->data.mp.recent_frees;
+ b->data.mp.prev_alloc_bytes = b->data.mp.recent_alloc_bytes;
+ b->data.mp.prev_free_bytes = b->data.mp.recent_free_bytes;
+
+ b->data.mp.recent_allocs = 0;
+ b->data.mp.recent_frees = 0;
+ b->data.mp.recent_alloc_bytes = 0;
+ b->data.mp.recent_free_bytes = 0;
}
}
nstk = runtime·callers(1, stk, nelem(stk));
runtime·lock(&proflock);
b = stkbucket(MProf, size, stk, nstk, true);
- b->recent_allocs++;
- b->recent_alloc_bytes += size;
+ b->data.mp.recent_allocs++;
+ b->data.mp.recent_alloc_bytes += size;
runtime·unlock(&proflock);
// Setprofilebucket locks a bunch of other mutexes, so we call it outside of proflock.
nstk = runtime·gcallers(g->m->curg, 1, stk, nelem(stk));
runtime·lock(&proflock);
b = stkbucket(MProf, size, stk, nstk, true);
- b->recent_allocs++;
- b->recent_alloc_bytes += size;
+ b->data.mp.recent_allocs++;
+ b->data.mp.recent_alloc_bytes += size;
runtime·unlock(&proflock);
// Setprofilebucket locks a bunch of other mutexes, so we call it outside of proflock.
{
runtime·lock(&proflock);
if(freed) {
- b->recent_frees++;
- b->recent_free_bytes += size;
+ b->data.mp.recent_frees++;
+ b->data.mp.recent_free_bytes += size;
} else {
- b->prev_frees++;
- b->prev_free_bytes += size;
+ b->data.mp.prev_frees++;
+ b->data.mp.prev_free_bytes += size;
}
runtime·unlock(&proflock);
}
nstk = runtime·callers(skip, stk, nelem(stk));
runtime·lock(&proflock);
b = stkbucket(BProf, 0, stk, nstk, true);
- b->count++;
- b->cycles += cycles;
+ b->data.bp.count++;
+ b->data.bp.cycles += cycles;
runtime·unlock(&proflock);
}
{
int32 i;
- r->alloc_bytes = b->alloc_bytes;
- r->free_bytes = b->free_bytes;
- r->alloc_objects = b->allocs;
- r->free_objects = b->frees;
+ r->alloc_bytes = b->data.mp.alloc_bytes;
+ r->free_bytes = b->data.mp.free_bytes;
+ r->alloc_objects = b->data.mp.allocs;
+ r->free_objects = b->data.mp.frees;
for(i=0; i<b->nstk && i<nelem(r->stk); i++)
r->stk[i] = b->stk[i];
for(; i<nelem(r->stk); i++)
n = 0;
clear = true;
for(b=mbuckets; b; b=b->allnext) {
- if(include_inuse_zero || b->alloc_bytes != b->free_bytes)
+ if(include_inuse_zero || b->data.mp.alloc_bytes != b->data.mp.free_bytes)
n++;
- if(b->allocs != 0 || b->frees != 0)
+ if(b->data.mp.allocs != 0 || b->data.mp.frees != 0)
clear = false;
}
if(clear) {
MProf_GC();
n = 0;
for(b=mbuckets; b; b=b->allnext)
- if(include_inuse_zero || b->alloc_bytes != b->free_bytes)
+ if(include_inuse_zero || b->data.mp.alloc_bytes != b->data.mp.free_bytes)
n++;
}
ok = false;
ok = true;
r = (Record*)p.array;
for(b=mbuckets; b; b=b->allnext)
- if(include_inuse_zero || b->alloc_bytes != b->free_bytes)
+ if(include_inuse_zero || b->data.mp.alloc_bytes != b->data.mp.free_bytes)
record(r++, b);
}
runtime·unlock(&proflock);
runtime·lock(&proflock);
for(b=mbuckets; b; b=b->allnext) {
- callback(b, b->nstk, b->stk, b->size, b->allocs, b->frees);
+ callback(b, b->nstk, b->stk, b->size, b->data.mp.allocs, b->data.mp.frees);
}
runtime·unlock(&proflock);
}
ok = true;
r = (BRecord*)p.array;
for(b=bbuckets; b; b=b->allnext, r++) {
- r->count = b->count;
- r->cycles = b->cycles;
+ r->count = b->data.bp.count;
+ r->cycles = b->data.bp.cycles;
for(i=0; i<b->nstk && i<nelem(r->stk); i++)
r->stk[i] = b->stk[i];
for(; i<nelem(r->stk); i++)
uintptr recent_alloc_bytes;
uintptr recent_free_bytes;
- };
+ } mp;
struct // typ == BProf
{
int64 count;
int64 cycles;
- };
- };
+ } bp;
+ } data;
uintptr hash; // hash of size + stk
uintptr size;
uintptr nstk;
// 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
static struct
{
- Lock;
+ Lock lock;
PollDesc* first;
// PollDesc objects must be type-stable,
// because we can get ready notification from epoll/kqueue
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)
pd->rd = 0;
pd->wg = nil;
pd->wd = 0;
- runtime·unlock(pd);
+ runtime·unlock(&pd->lock);
errno = runtime·netpollopen(fd, pd);
}
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) {
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
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)
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;
runtime·deltimer(&pd->wt);
pd->wt.fv = nil;
}
- runtime·unlock(pd);
+ runtime·unlock(&pd->lock);
if(rg)
runtime·ready(rg);
if(wg)
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
// 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) {
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)
PollDesc *pd;
uint32 i, n;
- runtime·lock(&pollcache);
+ runtime·lock(&pollcache.lock);
if(pollcache.first == nil) {
n = PollBlockSize/sizeof(*pd);
if(n == 0)
}
pd = pollcache.first;
pollcache.first = pd->link;
- runtime·unlock(&pollcache);
+ runtime·unlock(&pollcache.lock);
return pd;
}
typedef struct Sched Sched;
struct Sched {
- Lock;
+ Lock lock;
uint64 goidgen;
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);
// 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.
// 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;
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;
}
{
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;
}
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 == g->m->mcache)
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.
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();
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) {
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;
runtime·sched.sysmonwait = false;
runtime·notewakeup(&runtime·sched.sysmonnote);
}
- runtime·unlock(&runtime·sched);
+ runtime·unlock(&runtime·sched.lock);
while(p1) {
p = p1;
}
retry:
- runtime·lock(&runtime·sched);
+ runtime·lock(&runtime·sched.lock);
mput(g->m);
- runtime·unlock(&runtime·sched);
+ runtime·unlock(&runtime·sched.lock);
runtime·notesleep(&g->m->park);
runtime·noteclear(&g->m->park);
if(g->m->helpgc) {
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)
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 == 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.
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();
}
return gp;
// global runq
if(runtime·sched.runqsize) {
- runtime·lock(&runtime·sched);
+ runtime·lock(&runtime·sched.lock);
gp = globrunqget(g->m->p, 0);
- runtime·unlock(&runtime·sched);
+ runtime·unlock(&runtime·sched.lock);
if(gp)
return gp;
}
}
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(g->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(g->m->spinning) {
g->m->spinning = false;
runtime·xadd(&runtime·sched.nmspinning, -1);
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;
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);
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);
// 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(g->m->p, 1);
- runtime·unlock(&runtime·sched);
+ runtime·unlock(&runtime·sched.lock);
if(gp)
resetspinning();
}
{
gp->status = Grunnable;
dropg();
- runtime·lock(&runtime·sched);
+ runtime·lock(&runtime·sched.lock);
globrunqput(gp);
- runtime·unlock(&runtime·sched);
+ runtime·unlock(&runtime·sched.lock);
schedule();
}
}
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);
save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
}
g->m->p->m = nil;
runtime·atomicstore(&g->m->p->status, Psyscall);
if(runtime·sched.gcwaiting) {
- runtime·lock(&runtime·sched);
+ runtime·lock(&runtime·sched.lock);
if (runtime·sched.stopwait > 0 && runtime·cas(&g->m->p->status, Psyscall, Pgcstop)) {
if(--runtime·sched.stopwait == 0)
runtime·notewakeup(&runtime·sched.stopnote);
}
- runtime·unlock(&runtime·sched);
+ runtime·unlock(&runtime·sched.lock);
save(runtime·getcallerpc(&dummy), runtime·getcallersp(&dummy));
}
// Try to get any other idle P.
g->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;
gp->status = Grunnable;
dropg();
- runtime·lock(&runtime·sched);
+ runtime·lock(&runtime·sched.lock);
p = pidleget();
if(p == nil)
globrunqput(gp);
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.
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);
g->m->gcing = 1;
}
static struct {
- Lock;
+ Lock lock;
void (*fn)(uintptr*, int32);
int32 hz;
uintptr pcbuf[100];
((uint8*)runtime·gogo <= pc && pc < (uint8*)runtime·gogo + RuntimeGogoBytes))
traceback = false;
- runtime·lock(&prof);
+ runtime·lock(&prof.lock);
if(prof.fn == nil) {
- runtime·unlock(&prof);
+ runtime·unlock(&prof.lock);
mp->mallocing--;
return;
}
}
}
prof.fn(prof.pcbuf, n);
- runtime·unlock(&prof);
+ runtime·unlock(&prof.lock);
mp->mallocing--;
}
// 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);
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.
runtime·usleep(delay);
if(runtime·debug.schedtrace <= 0 &&
(runtime·sched.gcwaiting || runtime·atomicload(&runtime·sched.npidle) == 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) == 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);
if(starttime == 0)
starttime = now;
- runtime·lock(&runtime·sched);
+ runtime·lock(&runtime·sched.lock);
runtime·printf("SCHED %Dms: gomaxprocs=%d idleprocs=%d threads=%d spinningthreads=%d idlethreads=%d runqueue=%d",
(now-starttime)/1000000, runtime·gomaxprocs, runtime·sched.npidle, runtime·sched.mcount,
runtime·sched.nmspinning, runtime·sched.nmidle, runtime·sched.runqsize);
}
}
if(!detailed) {
- runtime·unlock(&runtime·sched);
+ runtime·unlock(&runtime·sched.lock);
return;
}
for(mp = runtime·allm; mp; mp = mp->alllink) {
lockedm ? lockedm->id : -1);
}
runtime·unlock(&allglock);
- runtime·unlock(&runtime·sched);
+ runtime·unlock(&runtime·sched.lock);
}
// Put mp on midle list.
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;
}
{
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;
}
struct P
{
- Lock;
+ Lock lock;
int32 id;
uint32 status; // one of Pidle/Prunning/...
struct Timers
{
- Lock;
+ Lock lock;
G *timerproc;
bool sleeping;
bool rescheduling;
typedef struct SemaRoot SemaRoot;
struct SemaRoot
{
- Lock;
+ Lock lock;
SemaWaiter* head;
SemaWaiter* tail;
// Number of waiters. Read w/o the lock.
struct semtable
{
- SemaRoot;
+ SemaRoot root;
uint8 pad[CacheLineSize-sizeof(SemaRoot)];
};
#pragma dataflag NOPTR /* mark semtable as 'no pointers', hiding from garbage collector */
static SemaRoot*
semroot(uint32 *addr)
{
- return &semtable[((uintptr)addr >> 3) % SEMTABLESZ];
+ return &semtable[((uintptr)addr >> 3) % SEMTABLESZ].root;
}
static void
s.releasetime = -1;
}
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);
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) {
break;
}
}
- runtime·unlock(root);
+ runtime·unlock(&root->lock);
if(s) {
if(s->releasetime)
s->releasetime = runtime·cputicks();
typedef struct SyncSema SyncSema;
struct SyncSema
{
- Lock;
+ Lock lock;
SemaWaiter* head;
SemaWaiter* tail;
};
w.releasetime = -1;
}
- runtime·lock(s);
+ runtime·lock(&s->lock);
if(s->head && s->head->nrelease > 0) {
// have pending release, consume it
wake = nil;
if(s->head == nil)
s->tail = nil;
}
- runtime·unlock(s);
+ runtime·unlock(&s->lock);
if(wake)
runtime·ready(wake->g);
} else {
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);
}
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;
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);
}
#pragma textflag NOPTR
static struct {
- Note;
+ Note note;
uint32 mask[(NSIG+31)/32];
uint32 wanted[(NSIG+31)/32];
uint32 recv[(NSIG+31)/32];
new = HASSIGNAL;
if(runtime·cas(&sig.state, old, new)) {
if (old == HASWAITER)
- runtime·notewakeup(&sig);
+ runtime·notewakeup(&sig.note);
break;
}
}
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;
}
// 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;
}
t.period = 0;
t.fv = &readyv;
t.arg.data = g;
- runtime·lock(&timers);
+ runtime·lock(&timers.lock);
addtimer(&t);
- runtime·parkunlock(&timers, reason);
+ runtime·parkunlock(&timers.lock, reason);
}
static FuncVal timerprocv = {timerproc};
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
i = t->i;
USED(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;
}
}
if(debug)
dumptimers("deltimer");
- runtime·unlock(&timers);
+ runtime·unlock(&timers.lock);
return true;
}
Eface arg;
for(;;) {
- runtime·lock(&timers);
+ runtime·lock(&timers.lock);
timers.sleeping = false;
now = runtime·nanotime();
for(;;) {
}
f = (void*)t->fv->fn;
arg = t->arg;
- runtime·unlock(&timers);
+ runtime·unlock(&timers.lock);
if(raceenabled)
runtime·raceacquire(t);
f(now, arg);
arg.data = nil;
USED(&arg);
- runtime·lock(&timers);
+ runtime·lock(&timers.lock);
}
if(delta < 0) {
// No timers left - put goroutine to sleep.
timers.rescheduling = true;
g->isbackground = true;
- runtime·parkunlock(&timers, "timer goroutine (idle)");
+ runtime·parkunlock(&timers.lock, "timer goroutine (idle)");
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);
}
}
struct InterfaceType
{
- Type;
+ Type typ;
Slice mhdr;
IMethod m[];
};
struct MapType
{
- Type;
+ Type typ;
Type *key;
Type *elem;
Type *bucket; // internal type representing a hash bucket
struct ChanType
{
- Type;
+ Type typ;
Type *elem;
uintptr dir;
};
struct SliceType
{
- Type;
+ Type typ;
Type *elem;
};
struct FuncType
{
- Type;
+ Type typ;
bool dotdotdot;
Slice in;
Slice out;
struct PtrType
{
- Type;
+ Type typ;
Type *elem;
};
#define SIGN(n) (1UL<<(n-1))
-typedef struct Vlong Vlong;
-struct Vlong
+typedef union Vlong Vlong;
+union Vlong
{
- union
+ long long v;
+ struct
{
- long long v;
- struct
- {
- ulong lo;
- ulong hi;
- };
- struct
- {
- ushort lols;
- ushort loms;
- ushort hils;
- ushort hims;
- };
- };
+ ulong lo;
+ ulong hi;
+ } v2;
};
void runtime·abort(void);
void
_d2v(Vlong *y, double d)
{
- union { double d; struct Vlong; } x;
+ union { double d; Vlong vl; } x;
ulong xhi, xlo, ylo, yhi;
int sh;
x.d = d;
- xhi = (x.hi & 0xfffff) | 0x100000;
- xlo = x.lo;
- sh = 1075 - ((x.hi >> 20) & 0x7ff);
+ xhi = (x.vl.v2.hi & 0xfffff) | 0x100000;
+ xlo = x.vl.v2.lo;
+ sh = 1075 - ((x.vl.v2.hi >> 20) & 0x7ff);
ylo = 0;
yhi = 0;
yhi = d; /* causes something awful */
}
}
- if(x.hi & SIGN(32)) {
+ if(x.vl.v2.hi & SIGN(32)) {
if(ylo != 0) {
ylo = -ylo;
yhi = ~yhi;
yhi = -yhi;
}
- y->hi = yhi;
- y->lo = ylo;
+ y->v2.hi = yhi;
+ y->v2.lo = ylo;
}
void
double
_v2d(Vlong x)
{
- if(x.hi & SIGN(32)) {
- if(x.lo) {
- x.lo = -x.lo;
- x.hi = ~x.hi;
+ if(x.v2.hi & SIGN(32)) {
+ if(x.v2.lo) {
+ x.v2.lo = -x.v2.lo;
+ x.v2.hi = ~x.v2.hi;
} else
- x.hi = -x.hi;
- return -((long)x.hi*4294967296. + x.lo);
+ x.v2.hi = -x.v2.hi;
+ return -((long)x.v2.hi*4294967296. + x.v2.lo);
}
- return (long)x.hi*4294967296. + x.lo;
+ return (long)x.v2.hi*4294967296. + x.v2.lo;
}
float
ulong numlo, numhi, denhi, denlo, quohi, quolo, t;
int i;
- numhi = num.hi;
- numlo = num.lo;
- denhi = den.hi;
- denlo = den.lo;
+ numhi = num.v2.hi;
+ numlo = num.v2.lo;
+ denhi = den.v2.hi;
+ denlo = den.v2.lo;
/*
* get a divide by zero
}
if(q) {
- q->lo = quolo;
- q->hi = quohi;
+ q->v2.lo = quolo;
+ q->v2.hi = quohi;
}
if(r) {
- r->lo = numlo;
- r->hi = numhi;
+ r->v2.lo = numlo;
+ r->v2.hi = numhi;
}
}
ulong n;
Vlong x, q, r;
- if(den.hi > num.hi || (den.hi == num.hi && den.lo > num.lo)){
+ if(den.v2.hi > num.v2.hi || (den.v2.hi == num.v2.hi && den.v2.lo > num.v2.lo)){
if(qp) {
- qp->hi = 0;
- qp->lo = 0;
+ qp->v2.hi = 0;
+ qp->v2.lo = 0;
}
if(rp) {
- rp->hi = num.hi;
- rp->lo = num.lo;
+ rp->v2.hi = num.v2.hi;
+ rp->v2.lo = num.v2.lo;
}
return;
}
- if(den.hi != 0){
- q.hi = 0;
- n = num.hi/den.hi;
- if(_mul64by32(&x, den, n) || x.hi > num.hi || (x.hi == num.hi && x.lo > num.lo))
+ if(den.v2.hi != 0){
+ q.v2.hi = 0;
+ n = num.v2.hi/den.v2.hi;
+ if(_mul64by32(&x, den, n) || x.v2.hi > num.v2.hi || (x.v2.hi == num.v2.hi && x.v2.lo > num.v2.lo))
slowdodiv(num, den, &q, &r);
else {
- q.lo = n;
+ q.v2.lo = n;
r.v = num.v - x.v;
}
} else {
- if(num.hi >= den.lo){
- if(den.lo == 0)
+ if(num.v2.hi >= den.v2.lo){
+ if(den.v2.lo == 0)
runtime·panicdivide();
- q.hi = n = num.hi/den.lo;
- num.hi -= den.lo*n;
+ q.v2.hi = n = num.v2.hi/den.v2.lo;
+ num.v2.hi -= den.v2.lo*n;
} else {
- q.hi = 0;
+ q.v2.hi = 0;
}
- q.lo = _div64by32(num, den.lo, &r.lo);
- r.hi = 0;
+ q.v2.lo = _div64by32(num, den.v2.lo, &r.v2.lo);
+ r.v2.hi = 0;
}
if(qp) {
- qp->lo = q.lo;
- qp->hi = q.hi;
+ qp->v2.lo = q.v2.lo;
+ qp->v2.hi = q.v2.hi;
}
if(rp) {
- rp->lo = r.lo;
- rp->hi = r.hi;
+ rp->v2.lo = r.v2.lo;
+ rp->v2.hi = r.v2.hi;
}
}
_divvu(Vlong *q, Vlong n, Vlong d)
{
- if(n.hi == 0 && d.hi == 0) {
- if(d.lo == 0)
+ if(n.v2.hi == 0 && d.v2.hi == 0) {
+ if(d.v2.lo == 0)
runtime·panicdivide();
- q->hi = 0;
- q->lo = n.lo / d.lo;
+ q->v2.hi = 0;
+ q->v2.lo = n.v2.lo / d.v2.lo;
return;
}
dodiv(n, d, q, 0);
_modvu(Vlong *r, Vlong n, Vlong d)
{
- if(n.hi == 0 && d.hi == 0) {
- if(d.lo == 0)
+ if(n.v2.hi == 0 && d.v2.hi == 0) {
+ if(d.v2.lo == 0)
runtime·panicdivide();
- r->hi = 0;
- r->lo = n.lo % d.lo;
+ r->v2.hi = 0;
+ r->v2.lo = n.v2.lo % d.v2.lo;
return;
}
dodiv(n, d, 0, r);
vneg(Vlong *v)
{
- if(v->lo == 0) {
- v->hi = -v->hi;
+ if(v->v2.lo == 0) {
+ v->v2.hi = -v->v2.hi;
return;
}
- v->lo = -v->lo;
- v->hi = ~v->hi;
+ v->v2.lo = -v->v2.lo;
+ v->v2.hi = ~v->v2.hi;
}
void
{
long nneg, dneg;
- if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
- if((long)n.lo == -0x80000000 && (long)d.lo == -1) {
+ if(n.v2.hi == (((long)n.v2.lo)>>31) && d.v2.hi == (((long)d.v2.lo)>>31)) {
+ if((long)n.v2.lo == -0x80000000 && (long)d.v2.lo == -1) {
// special case: 32-bit -0x80000000 / -1 causes divide error,
// but it's okay in this 64-bit context.
- q->lo = 0x80000000;
- q->hi = 0;
+ q->v2.lo = 0x80000000;
+ q->v2.hi = 0;
return;
}
- if(d.lo == 0)
+ if(d.v2.lo == 0)
runtime·panicdivide();
- q->lo = (long)n.lo / (long)d.lo;
- q->hi = ((long)q->lo) >> 31;
+ q->v2.lo = (long)n.v2.lo / (long)d.v2.lo;
+ q->v2.hi = ((long)q->v2.lo) >> 31;
return;
}
- nneg = n.hi >> 31;
+ nneg = n.v2.hi >> 31;
if(nneg)
vneg(&n);
- dneg = d.hi >> 31;
+ dneg = d.v2.hi >> 31;
if(dneg)
vneg(&d);
dodiv(n, d, q, 0);
{
long nneg, dneg;
- if(n.hi == (((long)n.lo)>>31) && d.hi == (((long)d.lo)>>31)) {
- if((long)n.lo == -0x80000000 && (long)d.lo == -1) {
+ if(n.v2.hi == (((long)n.v2.lo)>>31) && d.v2.hi == (((long)d.v2.lo)>>31)) {
+ if((long)n.v2.lo == -0x80000000 && (long)d.v2.lo == -1) {
// special case: 32-bit -0x80000000 % -1 causes divide error,
// but it's okay in this 64-bit context.
- r->lo = 0;
- r->hi = 0;
+ r->v2.lo = 0;
+ r->v2.hi = 0;
return;
}
- if(d.lo == 0)
+ if(d.v2.lo == 0)
runtime·panicdivide();
- r->lo = (long)n.lo % (long)d.lo;
- r->hi = ((long)r->lo) >> 31;
+ r->v2.lo = (long)n.v2.lo % (long)d.v2.lo;
+ r->v2.hi = ((long)r->v2.lo) >> 31;
return;
}
- nneg = n.hi >> 31;
+ nneg = n.v2.hi >> 31;
if(nneg)
vneg(&n);
- dneg = d.hi >> 31;
+ dneg = d.v2.hi >> 31;
if(dneg)
vneg(&d);
dodiv(n, d, 0, r);
{
long t;
- t = a.hi;
+ t = a.v2.hi;
if(b >= 32) {
- r->hi = t>>31;
+ r->v2.hi = t>>31;
if(b >= 64) {
/* this is illegal re C standard */
- r->lo = t>>31;
+ r->v2.lo = t>>31;
return;
}
- r->lo = t >> (b-32);
+ r->v2.lo = t >> (b-32);
return;
}
if(b <= 0) {
- r->hi = t;
- r->lo = a.lo;
+ r->v2.hi = t;
+ r->v2.lo = a.v2.lo;
return;
}
- r->hi = t >> b;
- r->lo = (t << (32-b)) | (a.lo >> b);
+ r->v2.hi = t >> b;
+ r->v2.lo = (t << (32-b)) | (a.v2.lo >> b);
}
void
{
ulong t;
- t = a.hi;
+ t = a.v2.hi;
if(b >= 32) {
- r->hi = 0;
+ r->v2.hi = 0;
if(b >= 64) {
/* this is illegal re C standard */
- r->lo = 0;
+ r->v2.lo = 0;
return;
}
- r->lo = t >> (b-32);
+ r->v2.lo = t >> (b-32);
return;
}
if(b <= 0) {
- r->hi = t;
- r->lo = a.lo;
+ r->v2.hi = t;
+ r->v2.lo = a.v2.lo;
return;
}
- r->hi = t >> b;
- r->lo = (t << (32-b)) | (a.lo >> b);
+ r->v2.hi = t >> b;
+ r->v2.lo = (t << (32-b)) | (a.v2.lo >> b);
}
#pragma textflag NOSPLIT
{
ulong t;
- t = a.lo;
+ t = a.v2.lo;
if(b >= 32) {
- r->lo = 0;
+ r->v2.lo = 0;
if(b >= 64) {
/* this is illegal re C standard */
- r->hi = 0;
+ r->v2.hi = 0;
return;
}
- r->hi = t << (b-32);
+ r->v2.hi = t << (b-32);
return;
}
if(b <= 0) {
- r->lo = t;
- r->hi = a.hi;
+ r->v2.lo = t;
+ r->v2.hi = a.v2.hi;
return;
}
- r->lo = t << b;
- r->hi = (t >> (32-b)) | (a.hi << b);
+ r->v2.lo = t << b;
+ r->v2.hi = (t >> (32-b)) | (a.v2.hi << b);
}
void
_andv(Vlong *r, Vlong a, Vlong b)
{
- r->hi = a.hi & b.hi;
- r->lo = a.lo & b.lo;
+ r->v2.hi = a.v2.hi & b.v2.hi;
+ r->v2.lo = a.v2.lo & b.v2.lo;
}
void
_orv(Vlong *r, Vlong a, Vlong b)
{
- r->hi = a.hi | b.hi;
- r->lo = a.lo | b.lo;
+ r->v2.hi = a.v2.hi | b.v2.hi;
+ r->v2.lo = a.v2.lo | b.v2.lo;
}
void
_xorv(Vlong *r, Vlong a, Vlong b)
{
- r->hi = a.hi ^ b.hi;
- r->lo = a.lo ^ b.lo;
+ r->v2.hi = a.v2.hi ^ b.v2.hi;
+ r->v2.lo = a.v2.lo ^ b.v2.lo;
}
void
_vpp(Vlong *l, Vlong *r)
{
- l->hi = r->hi;
- l->lo = r->lo;
- r->lo++;
- if(r->lo == 0)
- r->hi++;
+ l->v2.hi = r->v2.hi;
+ l->v2.lo = r->v2.lo;
+ r->v2.lo++;
+ if(r->v2.lo == 0)
+ r->v2.hi++;
}
void
_vmm(Vlong *l, Vlong *r)
{
- l->hi = r->hi;
- l->lo = r->lo;
- if(r->lo == 0)
- r->hi--;
- r->lo--;
+ l->v2.hi = r->v2.hi;
+ l->v2.lo = r->v2.lo;
+ if(r->v2.lo == 0)
+ r->v2.hi--;
+ r->v2.lo--;
}
void
_ppv(Vlong *l, Vlong *r)
{
- r->lo++;
- if(r->lo == 0)
- r->hi++;
- l->hi = r->hi;
- l->lo = r->lo;
+ r->v2.lo++;
+ if(r->v2.lo == 0)
+ r->v2.hi++;
+ l->v2.hi = r->v2.hi;
+ l->v2.lo = r->v2.lo;
}
void
_mmv(Vlong *l, Vlong *r)
{
- if(r->lo == 0)
- r->hi--;
- r->lo--;
- l->hi = r->hi;
- l->lo = r->lo;
+ if(r->v2.lo == 0)
+ r->v2.hi--;
+ r->v2.lo--;
+ l->v2.hi = r->v2.hi;
+ l->v2.lo = r->v2.lo;
}
void
{
Vlong t, u;
- u.lo = 0;
- u.hi = 0;
+ u.v2.lo = 0;
+ u.v2.hi = 0;
switch(type) {
default:
runtime·abort();
break;
case 1: /* schar */
- t.lo = *(schar*)lv;
- t.hi = t.lo >> 31;
+ t.v2.lo = *(schar*)lv;
+ t.v2.hi = t.v2.lo >> 31;
fn(&u, t, rv);
- *(schar*)lv = u.lo;
+ *(schar*)lv = u.v2.lo;
break;
case 2: /* uchar */
- t.lo = *(uchar*)lv;
- t.hi = 0;
+ t.v2.lo = *(uchar*)lv;
+ t.v2.hi = 0;
fn(&u, t, rv);
- *(uchar*)lv = u.lo;
+ *(uchar*)lv = u.v2.lo;
break;
case 3: /* short */
- t.lo = *(short*)lv;
- t.hi = t.lo >> 31;
+ t.v2.lo = *(short*)lv;
+ t.v2.hi = t.v2.lo >> 31;
fn(&u, t, rv);
- *(short*)lv = u.lo;
+ *(short*)lv = u.v2.lo;
break;
case 4: /* ushort */
- t.lo = *(ushort*)lv;
- t.hi = 0;
+ t.v2.lo = *(ushort*)lv;
+ t.v2.hi = 0;
fn(&u, t, rv);
- *(ushort*)lv = u.lo;
+ *(ushort*)lv = u.v2.lo;
break;
case 9: /* int */
- t.lo = *(int*)lv;
- t.hi = t.lo >> 31;
+ t.v2.lo = *(int*)lv;
+ t.v2.hi = t.v2.lo >> 31;
fn(&u, t, rv);
- *(int*)lv = u.lo;
+ *(int*)lv = u.v2.lo;
break;
case 10: /* uint */
- t.lo = *(uint*)lv;
- t.hi = 0;
+ t.v2.lo = *(uint*)lv;
+ t.v2.hi = 0;
fn(&u, t, rv);
- *(uint*)lv = u.lo;
+ *(uint*)lv = u.v2.lo;
break;
case 5: /* long */
- t.lo = *(long*)lv;
- t.hi = t.lo >> 31;
+ t.v2.lo = *(long*)lv;
+ t.v2.hi = t.v2.lo >> 31;
fn(&u, t, rv);
- *(long*)lv = u.lo;
+ *(long*)lv = u.v2.lo;
break;
case 6: /* ulong */
- t.lo = *(ulong*)lv;
- t.hi = 0;
+ t.v2.lo = *(ulong*)lv;
+ t.v2.hi = 0;
fn(&u, t, rv);
- *(ulong*)lv = u.lo;
+ *(ulong*)lv = u.v2.lo;
break;
case 7: /* vlong */
long t;
t = (ulong)p;
- ret->lo = t;
- ret->hi = 0;
+ ret->v2.lo = t;
+ ret->v2.hi = 0;
}
void
long t;
t = sl;
- ret->lo = t;
- ret->hi = t >> 31;
+ ret->v2.lo = t;
+ ret->v2.hi = t >> 31;
}
void
long t;
t = ul;
- ret->lo = t;
- ret->hi = 0;
+ ret->v2.lo = t;
+ ret->v2.hi = 0;
}
void
long t;
t = si;
- ret->lo = t;
- ret->hi = t >> 31;
+ ret->v2.lo = t;
+ ret->v2.hi = t >> 31;
}
void
long t;
t = ui;
- ret->lo = t;
- ret->hi = 0;
+ ret->v2.lo = t;
+ ret->v2.hi = 0;
}
void
long t;
t = (sh << 16) >> 16;
- ret->lo = t;
- ret->hi = t >> 31;
+ ret->v2.lo = t;
+ ret->v2.hi = t >> 31;
}
void
long t;
t = ul & 0xffff;
- ret->lo = t;
- ret->hi = 0;
+ ret->v2.lo = t;
+ ret->v2.hi = 0;
}
void
long t;
t = (uc << 24) >> 24;
- ret->lo = t;
- ret->hi = t >> 31;
+ ret->v2.lo = t;
+ ret->v2.hi = t >> 31;
}
void
long t;
t = ul & 0xff;
- ret->lo = t;
- ret->hi = 0;
+ ret->v2.lo = t;
+ ret->v2.hi = 0;
}
long
{
long t;
- t = rv.lo & 0xff;
+ t = rv.v2.lo & 0xff;
return (t << 24) >> 24;
}
_v2uc(Vlong rv)
{
- return rv.lo & 0xff;
+ return rv.v2.lo & 0xff;
}
long
{
long t;
- t = rv.lo & 0xffff;
+ t = rv.v2.lo & 0xffff;
return (t << 16) >> 16;
}
_v2uh(Vlong rv)
{
- return rv.lo & 0xffff;
+ return rv.v2.lo & 0xffff;
}
long
_v2sl(Vlong rv)
{
- return rv.lo;
+ return rv.v2.lo;
}
long
_v2ul(Vlong rv)
{
- return rv.lo;
+ return rv.v2.lo;
}
long
_v2si(Vlong rv)
{
- return rv.lo;
+ return rv.v2.lo;
}
long
_v2ui(Vlong rv)
{
- return rv.lo;
+ return rv.v2.lo;
}
int
_testv(Vlong rv)
{
- return rv.lo || rv.hi;
+ return rv.v2.lo || rv.v2.hi;
}
int
_eqv(Vlong lv, Vlong rv)
{
- return lv.lo == rv.lo && lv.hi == rv.hi;
+ return lv.v2.lo == rv.v2.lo && lv.v2.hi == rv.v2.hi;
}
int
_nev(Vlong lv, Vlong rv)
{
- return lv.lo != rv.lo || lv.hi != rv.hi;
+ return lv.v2.lo != rv.v2.lo || lv.v2.hi != rv.v2.hi;
}
int
_ltv(Vlong lv, Vlong rv)
{
- return (long)lv.hi < (long)rv.hi ||
- (lv.hi == rv.hi && lv.lo < rv.lo);
+ return (long)lv.v2.hi < (long)rv.v2.hi ||
+ (lv.v2.hi == rv.v2.hi && lv.v2.lo < rv.v2.lo);
}
int
_lev(Vlong lv, Vlong rv)
{
- return (long)lv.hi < (long)rv.hi ||
- (lv.hi == rv.hi && lv.lo <= rv.lo);
+ return (long)lv.v2.hi < (long)rv.v2.hi ||
+ (lv.v2.hi == rv.v2.hi && lv.v2.lo <= rv.v2.lo);
}
int
_gtv(Vlong lv, Vlong rv)
{
- return (long)lv.hi > (long)rv.hi ||
- (lv.hi == rv.hi && lv.lo > rv.lo);
+ return (long)lv.v2.hi > (long)rv.v2.hi ||
+ (lv.v2.hi == rv.v2.hi && lv.v2.lo > rv.v2.lo);
}
int
_gev(Vlong lv, Vlong rv)
{
- return (long)lv.hi > (long)rv.hi ||
- (lv.hi == rv.hi && lv.lo >= rv.lo);
+ return (long)lv.v2.hi > (long)rv.v2.hi ||
+ (lv.v2.hi == rv.v2.hi && lv.v2.lo >= rv.v2.lo);
}
int
_lov(Vlong lv, Vlong rv)
{
- return lv.hi < rv.hi ||
- (lv.hi == rv.hi && lv.lo < rv.lo);
+ return lv.v2.hi < rv.v2.hi ||
+ (lv.v2.hi == rv.v2.hi && lv.v2.lo < rv.v2.lo);
}
int
_lsv(Vlong lv, Vlong rv)
{
- return lv.hi < rv.hi ||
- (lv.hi == rv.hi && lv.lo <= rv.lo);
+ return lv.v2.hi < rv.v2.hi ||
+ (lv.v2.hi == rv.v2.hi && lv.v2.lo <= rv.v2.lo);
}
int
_hiv(Vlong lv, Vlong rv)
{
- return lv.hi > rv.hi ||
- (lv.hi == rv.hi && lv.lo > rv.lo);
+ return lv.v2.hi > rv.v2.hi ||
+ (lv.v2.hi == rv.v2.hi && lv.v2.lo > rv.v2.lo);
}
int
_hsv(Vlong lv, Vlong rv)
{
- return lv.hi > rv.hi ||
- (lv.hi == rv.hi && lv.lo >= rv.lo);
+ return lv.v2.hi > rv.v2.hi ||
+ (lv.v2.hi == rv.v2.hi && lv.v2.lo >= rv.v2.lo);
}
typedef struct Vlong Vlong;
struct Vlong
{
- union
- {
- struct
- {
- ulong lo;
- ulong hi;
- };
- struct
- {
- ushort lols;
- ushort loms;
- ushort hils;
- ushort hims;
- };
- };
+ ulong lo;
+ ulong hi;
};
void runtime·abort(void);
void
_d2v(Vlong *y, double d)
{
- union { double d; struct Vlong; } x;
+ union { double d; Vlong vl; } x;
ulong xhi, xlo, ylo, yhi;
int sh;
x.d = d;
- xhi = (x.hi & 0xfffff) | 0x100000;
- xlo = x.lo;
- sh = 1075 - ((x.hi >> 20) & 0x7ff);
+ xhi = (x.vl.hi & 0xfffff) | 0x100000;
+ xlo = x.vl.lo;
+ sh = 1075 - ((x.vl.hi >> 20) & 0x7ff);
ylo = 0;
yhi = 0;
yhi = d; /* causes something awful */
}
}
- if(x.hi & SIGN(32)) {
+ if(x.vl.hi & SIGN(32)) {
if(ylo != 0) {
ylo = -ylo;
yhi = ~yhi;