runtime: copy rdebug code from Go 1.7 runtime

    
    While we're at it, update the runtime/debug package, and start running
    its testsuite by default.  I'm not sure why runtime/debug was not
    previously updated to 1.7.  Doing that led me to fix some minor aspects
    of runtime.Stack and the C function runtime/debug.readGCStats.
    
    Reviewed-on: https://go-review.googlesource.com/31251


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@241261 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/go/gofrontend/MERGE

@@ -1,4 +1,4 @@
-880cb0a45590d992880fc6aabc7484e54c817eeb
+314ba28067383516c213ba84c931f93325a48c39
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.

libgo/Makefile.am

@@ -515,7 +515,6 @@ runtime_files = \
 	lfstack.c \
 	malloc.c \
 	netpoll.c \
-	rdebug.c \
 	reflect.c \
 	runtime1.c \
 	sigqueue.c \
@@ -3035,6 +3034,7 @@ TEST_PACKAGES = \
 	os/user/check \
 	path/filepath/check \
 	regexp/syntax/check \
+	runtime/debug/check \
 	runtime/pprof/check \
 	runtime/internal/atomic/check \
 	runtime/internal/sys/check \

libgo/Makefile.in

@@ -262,7 +262,7 @@ am__objects_6 = go-append.lo go-assert.lo go-assert-interface.lo \
 	$(am__objects_2) panic.lo parfor.lo print.lo proc.lo \
 	runtime.lo signal_unix.lo thread.lo $(am__objects_3) yield.lo \
 	$(am__objects_4) go-iface.lo lfstack.lo malloc.lo netpoll.lo \
-	rdebug.lo reflect.lo runtime1.lo sigqueue.lo $(am__objects_5)
+	reflect.lo runtime1.lo sigqueue.lo $(am__objects_5)
 am_libgo_llgo_la_OBJECTS = $(am__objects_6)
 libgo_llgo_la_OBJECTS = $(am_libgo_llgo_la_OBJECTS)
 libgo_llgo_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
@@ -913,7 +913,6 @@ runtime_files = \
 	lfstack.c \
 	malloc.c \
 	netpoll.c \
-	rdebug.c \
 	reflect.c \
 	runtime1.c \
 	sigqueue.c \
@@ -1384,6 +1383,7 @@ TEST_PACKAGES = \
 	os/user/check \
 	path/filepath/check \
 	regexp/syntax/check \
+	runtime/debug/check \
 	runtime/pprof/check \
 	runtime/internal/atomic/check \
 	runtime/internal/sys/check \
@@ -1624,7 +1624,6 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/parfor.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/proc.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rdebug.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/reflect.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rtems-task-variable-add.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/runtime.Plo@am__quote@

libgo/go/runtime/debug/garbage.go

@@ -16,17 +16,10 @@ type GCStats struct {
 	NumGC          int64           // number of garbage collections
 	PauseTotal     time.Duration   // total pause for all collections
 	Pause          []time.Duration // pause history, most recent first
+	PauseEnd       []time.Time     // pause end times history, most recent first
 	PauseQuantiles []time.Duration
 }
 
-// Implemented in package runtime.
-func readGCStats(*[]time.Duration)
-func enableGC(bool) bool
-func setGCPercent(int) int
-func freeOSMemory()
-func setMaxStack(int) int
-func setMaxThreads(int) int
-
 // ReadGCStats reads statistics about garbage collection into stats.
 // The number of entries in the pause history is system-dependent;
 // stats.Pause slice will be reused if large enough, reallocated otherwise.
@@ -38,25 +31,36 @@ func setMaxThreads(int) int
 func ReadGCStats(stats *GCStats) {
 	// Create a buffer with space for at least two copies of the
 	// pause history tracked by the runtime. One will be returned
-	// to the caller and the other will be used as a temporary buffer
-	// for computing quantiles.
+	// to the caller and the other will be used as transfer buffer
+	// for end times history and as a temporary buffer for
+	// computing quantiles.
 	const maxPause = len(((*runtime.MemStats)(nil)).PauseNs)
-	if cap(stats.Pause) < 2*maxPause {
-		stats.Pause = make([]time.Duration, 2*maxPause)
+	if cap(stats.Pause) < 2*maxPause+3 {
+		stats.Pause = make([]time.Duration, 2*maxPause+3)
 	}
 
-	// readGCStats fills in the pause history (up to maxPause entries)
-	// and then three more: Unix ns time of last GC, number of GC,
-	// and total pause time in nanoseconds. Here we depend on the
-	// fact that time.Duration's native unit is nanoseconds, so the
-	// pauses and the total pause time do not need any conversion.
+	// readGCStats fills in the pause and end times histories (up to
+	// maxPause entries) and then three more: Unix ns time of last GC,
+	// number of GC, and total pause time in nanoseconds. Here we
+	// depend on the fact that time.Duration's native unit is
+	// nanoseconds, so the pauses and the total pause time do not need
+	// any conversion.
 	readGCStats(&stats.Pause)
 	n := len(stats.Pause) - 3
 	stats.LastGC = time.Unix(0, int64(stats.Pause[n]))
 	stats.NumGC = int64(stats.Pause[n+1])
 	stats.PauseTotal = stats.Pause[n+2]
+	n /= 2 // buffer holds pauses and end times
 	stats.Pause = stats.Pause[:n]
 
+	if cap(stats.PauseEnd) < maxPause {
+		stats.PauseEnd = make([]time.Time, 0, maxPause)
+	}
+	stats.PauseEnd = stats.PauseEnd[:0]
+	for _, ns := range stats.Pause[n : n+n] {
+		stats.PauseEnd = append(stats.PauseEnd, time.Unix(0, int64(ns)))
+	}
+
 	if len(stats.PauseQuantiles) > 0 {
 		if n == 0 {
 			for i := range stats.PauseQuantiles {
@@ -91,9 +95,9 @@ func (x byDuration) Less(i, j int) bool { return x[i] < x[j] }
 // at startup, or 100 if the variable is not set.
 // A negative percentage disables garbage collection.
 func SetGCPercent(percent int) int {
-	old := setGCPercent(percent)
+	old := setGCPercent(int32(percent))
 	runtime.GC()
-	return old
+	return int(old)
 }
 
 // FreeOSMemory forces a garbage collection followed by an
@@ -145,7 +149,9 @@ func SetMaxThreads(threads int) int {
 // that the runtime trigger only a panic, not a crash.
 // SetPanicOnFault applies only to the current goroutine.
 // It returns the previous setting.
-func SetPanicOnFault(enabled bool) bool
+func SetPanicOnFault(enabled bool) bool {
+	return setPanicOnFault(enabled)
+}
 
 // WriteHeapDump writes a description of the heap and the objects in
 // it to the given file descriptor.

libgo/go/runtime/debug/garbage_test.go

@@ -71,6 +71,19 @@ func TestReadGCStats(t *testing.T) {
 			t.Errorf("stats.PauseQuantiles[%d]=%d > stats.PauseQuantiles[%d]=%d", i, q[i], i+1, q[i+1])
 		}
 	}
+
+	// compare memory stats with gc stats:
+	if len(stats.PauseEnd) != n {
+		t.Fatalf("len(stats.PauseEnd) = %d, want %d", len(stats.PauseEnd), n)
+	}
+	off := (int(mstats.NumGC) + len(mstats.PauseEnd) - 1) % len(mstats.PauseEnd)
+	for i := 0; i < n; i++ {
+		dt := stats.PauseEnd[i]
+		if dt.UnixNano() != int64(mstats.PauseEnd[off]) {
+			t.Errorf("stats.PauseEnd[%d] = %d, want %d", i, dt, mstats.PauseEnd[off])
+		}
+		off = (off + len(mstats.PauseEnd) - 1) % len(mstats.PauseEnd)
+	}
 }
 
 var big = make([]byte, 1<<20)

libgo/go/runtime/debug/stack_test.go

@@ -50,10 +50,12 @@ func TestStack(t *testing.T) {
 		check(t, lines[n], line)
 		n++
 	}
-	frame("stack_test.go", "\tmethod.N15_runtime_debug.T: return Stack()")
-	frame("stack_test.go", "\tmethod.N15_runtime_debug.T: return t.ptrmethod()")
-	frame("stack_test.go", "\tTestStack: b := T(0).method()")
-	frame("testing/testing.go", "")
+	n++
+	frame("stack.go", "runtime_debug.Stack")
+	frame("stack_test.go", "ptrmethod")
+	frame("stack_test.go", "method")
+	frame("stack_test.go", "runtime_debug_test.TestStack")
+	frame("testing.go", "")
 }
 
 func check(t *testing.T, line, has string) {

libgo/go/runtime/debug/stubs.go

@@ -0,0 +1,17 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package debug
+
+import (
+	"time"
+)
+
+// Implemented in package runtime.
+func readGCStats(*[]time.Duration)
+func freeOSMemory()
+func setMaxStack(int) int
+func setGCPercent(int32) int32
+func setPanicOnFault(bool) bool
+func setMaxThreads(int) int

libgo/go/runtime/mprof.go

@@ -623,7 +623,7 @@ func Stack(buf []byte, all bool) int {
 		gp.m.traceback = 1
 		gp.writebuf = buf[0:0:len(buf)]
 		goroutineheader(gp)
-		traceback()
+		traceback(1)
 		if all {
 			tracebackothers(gp)
 		}
@@ -653,7 +653,7 @@ func tracealloc(p unsafe.Pointer, size uintptr, typ *_type) {
 	}
 	if gp.m.curg == nil || gp == gp.m.curg {
 		goroutineheader(gp)
-		traceback()
+		traceback(1)
 	} else {
 		goroutineheader(gp.m.curg)
 		// FIXME: Can't do traceback of other g.
@@ -669,7 +669,7 @@ func tracefree(p unsafe.Pointer, size uintptr) {
 	gp.m.traceback = 2
 	print("tracefree(", p, ", ", hex(size), ")\n")
 	goroutineheader(gp)
-	traceback()
+	traceback(1)
 	print("\n")
 	gp.m.traceback = 0
 	unlock(&tracelock)

libgo/go/runtime/rdebug.go

@@ -0,0 +1,27 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import _ "unsafe" // for go:linkname
+
+// Define maxstacksize here for gccgo. For gc it is defined in
+// stack.go, but gccgo doesn't use that file. Or, for that matter,
+// maxstacksize.
+var maxstacksize uintptr = 1 << 20 // enough until runtime.main sets it for real
+
+//go:linkname setMaxStack runtime_debug.setMaxStack
+func setMaxStack(in int) (out int) {
+	out = int(maxstacksize)
+	maxstacksize = uintptr(in)
+	return out
+}
+
+//go:linkname setPanicOnFault runtime_debug.setPanicOnFault
+func setPanicOnFault(new bool) (old bool) {
+	_g_ := getg()
+	old = _g_.paniconfault
+	_g_.paniconfault = new
+	return old
+}

libgo/go/runtime/stubs.go

@@ -444,3 +444,19 @@ func setprofilebucket(p unsafe.Pointer, b *bucket)
 
 // Currently in proc.c.
 func tracebackothers(*g)
+
+// Temporary for gccgo until we port mgc.go.
+func setgcpercent(int32) int32
+
+//go:linkname setGCPercent runtime_debug.setGCPercent
+func setGCPercent(in int32) (out int32) {
+	return setgcpercent(in)
+}
+
+// Temporary for gccgo until we port proc.go.
+func setmaxthreads(int) int
+
+//go:linkname setMaxThreads runtime_debug.setMaxThreads
+func setMaxThreads(in int) (out int) {
+	return setmaxthreads(in)
+}

libgo/go/runtime/traceback_gccgo.go

@@ -67,17 +67,17 @@ func callers(skip int, locbuf []location) int {
 // traceback prints a traceback of the current goroutine.
 // This differs from the gc version, which is given pc, sp, lr and g and
 // can print a traceback of any goroutine.
-func traceback() {
+func traceback(skip int32) {
 	var locbuf [100]location
-	c := c_callers(1, &locbuf[0], int32(len(locbuf)), false)
+	c := c_callers(skip+1, &locbuf[0], int32(len(locbuf)), false)
 	printtrace(locbuf[:c], getg())
 }
 
 // printtrace prints a traceback from locbuf.
 func printtrace(locbuf []location, gp *g) {
 	for i := range locbuf {
 		if showframe(locbuf[i].function, gp) {
-			print(locbuf[i].function, "\n\t", locbuf[i].filename, ":", locbuf[i].lineno)
+			print(locbuf[i].function, "\n\t", locbuf[i].filename, ":", locbuf[i].lineno, "\n")
 		}
 	}
 }

libgo/runtime/go-signal.c

@@ -222,7 +222,7 @@ runtime_sighandler (int sig, Siginfo *info,
 	  G *g;
 
 	  g = runtime_g ();
-	  runtime_traceback ();
+	  runtime_traceback (0);
 	  runtime_tracebackothers (g);
 
 	  /* The gc library calls runtime_dumpregs here, and provides

libgo/runtime/heapdump.c

@@ -545,6 +545,8 @@ dumpmemprof_callback(Bucket *b, uintptr nstk, Location *stk, uintptr size, uintp
 	dumpint(frees);
 }
 
+static FuncVal dumpmemprof_callbackv = {(void(*)(void))dumpmemprof_callback};
+
 static void
 dumpmemprof(void)
 {
@@ -554,7 +556,7 @@ dumpmemprof(void)
 	SpecialProfile *spp;
 	byte *p;
 
-	runtime_iterate_memprof(dumpmemprof_callback);
+	runtime_iterate_memprof(&dumpmemprof_callbackv);
 
 	allspans = runtime_mheap.allspans;
 	for(spanidx=0; spanidx<runtime_mheap.nspan; spanidx++) {

libgo/runtime/malloc.h

@@ -465,7 +465,7 @@ void	runtime_MProf_Free(Bucket*, uintptr, bool)
   __asm__ (GOSYM_PREFIX "runtime.mProf_Free");
 void	runtime_MProf_GC(void)
   __asm__ (GOSYM_PREFIX "runtime.mProf_GC");
-void	runtime_iterate_memprof(void (*callback)(Bucket*, uintptr, Location*, uintptr, uintptr, uintptr))
+void	runtime_iterate_memprof(FuncVal* callback)
   __asm__ (GOSYM_PREFIX "runtime.iterate_memprof");
 int32	runtime_gcprocs(void);
 void	runtime_helpgc(int32 nproc);
@@ -535,7 +535,8 @@ void	runtime_gc_g_ptr(Eface*);
 void	runtime_gc_itab_ptr(Eface*);
 
 void	runtime_memorydump(void);
-int32	runtime_setgcpercent(int32);
+int32	runtime_setgcpercent(int32)
+  __asm__ (GOSYM_PREFIX "runtime.setgcpercent");
 
 // Value we use to mark dead pointers when GODEBUG=gcdead=1.
 #define PoisonGC ((uintptr)0xf969696969696969ULL)

libgo/runtime/mgc0.c

@@ -2392,14 +2392,16 @@ runtime_debug_readGCStats(Slice *pauses)
 	// pause_ns[(numgc-1)%nelem(pause_ns)], and then backward
 	// from there to go back farther in time. We deliver the times
 	// most recent first (in p[0]).
-	for(i=0; i<n; i++)
+	for(i=0; i<n; i++) {
 		p[i] = pmstats->pause_ns[(pmstats->numgc-1-i)%nelem(pmstats->pause_ns)];
+		p[n+i] = pmstats->pause_end[(pmstats->numgc-1-i)%nelem(pmstats->pause_ns)];
+	}
 
-	p[n] = pmstats->last_gc;
-	p[n+1] = pmstats->numgc;
-	p[n+2] = pmstats->pause_total_ns;
+	p[n+n] = pmstats->last_gc;
+	p[n+n+1] = pmstats->numgc;
+	p[n+n+2] = pmstats->pause_total_ns;
 	runtime_unlock(&runtime_mheap);
-	pauses->__count = n+3;
+	pauses->__count = n+n+3;
 }
 
 int32

libgo/runtime/panic.c

@@ -130,11 +130,11 @@ runtime_dopanic(int32 unused __attribute__ ((unused)))
 		if(g != runtime_m()->g0) {
 			runtime_printf("\n");
 			runtime_goroutineheader(g);
-			runtime_traceback();
+			runtime_traceback(0);
 			runtime_printcreatedby(g);
 		} else if(t >= 2 || runtime_m()->throwing > 0) {
 			runtime_printf("\nruntime stack:\n");
-			runtime_traceback();
+			runtime_traceback(0);
 		}
 		if(!didothers) {
 			didothers = true;

libgo/runtime/proc.c

@@ -3470,14 +3470,14 @@ runtime_testSchedLocalQueueSteal(void)
 	}
 }
 
-int32
-runtime_setmaxthreads(int32 in)
+intgo
+runtime_setmaxthreads(intgo in)
 {
-	int32 out;
+	intgo out;
 
 	runtime_lock(&runtime_sched);
-	out = runtime_sched.maxmcount;
-	runtime_sched.maxmcount = in;
+	out = (intgo)runtime_sched.maxmcount;
+	runtime_sched.maxmcount = (int32)in;
 	checkmcount();
 	runtime_unlock(&runtime_sched);
 	return out;