From 8e4586f1e6c3ff948cd3e64690bcde11158662c7 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Mon, 6 Oct 2014 13:09:14 -0400 Subject: net: disable TestDualStackUDPListener in short mode This test is flaky, just like TestDualStackTCPListener. That one was disabled. Disable this one too. Update issue 5001 LGTM=bradfitz R=rlh, bradfitz CC=golang-codereviews https://codereview.appspot.com/154950043 --- src/net/unicast_posix_test.go | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src') diff --git a/src/net/unicast_posix_test.go b/src/net/unicast_posix_test.go index 452ac9254..ab7ef40a7 100644 --- a/src/net/unicast_posix_test.go +++ b/src/net/unicast_posix_test.go @@ -204,6 +204,9 @@ func TestDualStackTCPListener(t *testing.T) { // to a test listener with various address families, differnet // listening address and same port. func TestDualStackUDPListener(t *testing.T) { + if testing.Short() { + t.Skip("skipping in -short mode, see issue 5001") + } switch runtime.GOOS { case "plan9": t.Skipf("skipping test on %q", runtime.GOOS) -- cgit v1.2.1 From 5869c235d76fb8341743989d86d8565ae8d211d3 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Mon, 6 Oct 2014 14:17:48 -0400 Subject: cmd/8l: accept R_386_GOT32 in push instruction Fixes issue 8382. LGTM=iant R=iant CC=golang-codereviews https://codereview.appspot.com/149540045 --- src/cmd/8l/asm.c | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/cmd/8l/asm.c b/src/cmd/8l/asm.c index c135dce70..98c042403 100644 --- a/src/cmd/8l/asm.c +++ b/src/cmd/8l/asm.c @@ -117,13 +117,21 @@ adddynrel(LSym *s, Reloc *r) case 256 + R_386_GOT32: if(targ->type != SDYNIMPORT) { // have symbol - // turn MOVL of GOT entry into LEAL of symbol itself - if(r->off < 2 || s->p[r->off-2] != 0x8b) { - diag("unexpected GOT reloc for non-dynamic symbol %s", targ->name); + if(r->off >= 2 && s->p[r->off-2] == 0x8b) { + // turn MOVL of GOT entry into LEAL of symbol address, relative to GOT. + s->p[r->off-2] = 0x8d; + r->type = R_GOTOFF; return; } - s->p[r->off-2] = 0x8d; - r->type = R_GOTOFF; + if(r->off >= 2 && s->p[r->off-2] == 0xff && s->p[r->off-1] == 0xb3) { + // turn PUSHL of GOT entry into PUSHL of symbol itself. + // use unnecessary SS prefix to keep instruction same length. + s->p[r->off-2] = 0x36; + s->p[r->off-1] = 0x68; + r->type = R_ADDR; + return; + } + diag("unexpected GOT reloc for non-dynamic symbol %s", targ->name); return; } addgotsym(ctxt, targ); -- cgit v1.2.1 From 7ad347e9e6e3bc5723b709768c87e87bd4c7493c Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Mon, 6 Oct 2014 14:18:09 -0400 Subject: runtime: update docs, code for SetFinalizer At last minute before 1.3 we relaxed SetFinalizer to avoid crashes when you pass the result of a global alloc to it. This avoids the crash but makes SetFinalizer a bit too relaxed. Document that the finalizer of a global allocation may not run. Tighten the SetFinalizer check to ignore a global allocation but not ignore everything else. Fixes issue 7656. LGTM=r, iant R=golang-codereviews, iant, r CC=dvyukov, golang-codereviews, khr, rlh https://codereview.appspot.com/145930043 --- src/runtime/malloc.go | 37 +++++++++++++++++++++++-------------- src/runtime/mfinal_test.go | 13 ++++++++++--- 2 files changed, 33 insertions(+), 17 deletions(-) (limited to 'src') diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go index fc22cc29e..99d14e314 100644 --- a/src/runtime/malloc.go +++ b/src/runtime/malloc.go @@ -488,6 +488,10 @@ func GC() { gogc(2) } +// linker-provided +var noptrdata struct{} +var enoptrbss struct{} + // SetFinalizer sets the finalizer associated with x to f. // When the garbage collector finds an unreachable block // with an associated finalizer, it clears the association and runs @@ -527,6 +531,10 @@ func GC() { // It is not guaranteed that a finalizer will run if the size of *x is // zero bytes. // +// It is not guaranteed that a finalizer will run for objects allocated +// in initializers for package-level variables. Such objects may be +// linker-allocated, not heap-allocated. +// // A single goroutine runs all finalizers for a program, sequentially. // If a finalizer must run for a long time, it should do so by starting // a new goroutine. @@ -544,24 +552,25 @@ func SetFinalizer(obj interface{}, finalizer interface{}) { gothrow("nil elem type!") } - // As an implementation detail we do not run finalizers for zero-sized objects, - // because we use &runtime·zerobase for all such allocations. - if ot.elem.size == 0 { - return - } - // find the containing object _, base, _ := findObject(e.data) - // The following check is required for cases when a user passes a pointer to composite - // literal, but compiler makes it a pointer to global. For example: - // var Foo = &Object{} - // func main() { - // runtime.SetFinalizer(Foo, nil) - // } - // See issue 7656. if base == nil { - return + // 0-length objects are okay. + if e.data == unsafe.Pointer(&zerobase) { + return + } + + // Global initializers might be linker-allocated. + // var Foo = &Object{} + // func main() { + // runtime.SetFinalizer(Foo, nil) + // } + // The segments are, in order: text, rodata, noptrdata, data, bss, noptrbss. + if uintptr(unsafe.Pointer(&noptrdata)) <= uintptr(e.data) && uintptr(e.data) < uintptr(unsafe.Pointer(&enoptrbss)) { + return + } + gothrow("runtime.SetFinalizer: pointer not in allocated block") } if e.data != base { diff --git a/src/runtime/mfinal_test.go b/src/runtime/mfinal_test.go index 6b53888ab..d2cead287 100644 --- a/src/runtime/mfinal_test.go +++ b/src/runtime/mfinal_test.go @@ -44,10 +44,17 @@ func TestFinalizerType(t *testing.T) { {func(x *int) interface{} { return (*Tint)(x) }, func(v Tinter) { finalize((*int)(v.(*Tint))) }}, } - for _, tt := range finalizerTests { + for i, tt := range finalizerTests { done := make(chan bool, 1) go func() { - v := new(int) + // allocate struct with pointer to avoid hitting tinyalloc. + // Otherwise we can't be sure when the allocation will + // be freed. + type T struct { + v int + p unsafe.Pointer + } + v := &new(T).v *v = 97531 runtime.SetFinalizer(tt.convert(v), tt.finalizer) v = nil @@ -58,7 +65,7 @@ func TestFinalizerType(t *testing.T) { select { case <-ch: case <-time.After(time.Second * 4): - t.Errorf("finalizer for type %T didn't run", tt.finalizer) + t.Errorf("#%d: finalizer for type %T didn't run", i, tt.finalizer) } } } -- cgit v1.2.1