From 07fc6c849f00fb70a71e7db48187316cfb4df357 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 4 Jun 2019 16:40:50 -0700
Subject: [PATCH 001/126] error on escape to heap

---
 src/runtime/defs_linux_amd64.go | 139 ++++++++++++++++++++++++++++++++
 src/runtime/os_linux.go         |   6 ++
 src/runtime/signal_unix.go      |  34 ++++++--
 src/runtime/sys_linux_amd64.s   |  52 ++++++++++++
 4 files changed, 226 insertions(+), 5 deletions(-)

diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index ddad7fddd4..0880822393 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -261,3 +261,142 @@ type sockaddr_un struct {
 	family uint16
 	path   [108]byte
 }
+
+type PerfEventAttr struct {
+    Type               uint32
+    Size               uint32
+    Config             uint64
+    Sample             uint64
+    Sample_type        uint64
+    Read_format        uint64
+    Bits               uint64
+    Wakeup             uint32
+    Bp_type            uint32
+    Ext1               uint64
+    Ext2               uint64
+    Branch_sample_type uint64
+    Sample_regs_user   uint64
+    Sample_stack_user  uint32
+    Clockid            int32
+    Sample_regs_intr   uint64
+    Aux_watermark      uint32
+    _                  uint32
+}
+
+const (
+	PERF_TYPE_HARDWARE   = 0x0
+	PERF_TYPE_SOFTWARE   = 0x1
+	PERF_TYPE_TRACEPOINT = 0x2
+	PERF_TYPE_HW_CACHE   = 0x3
+	PERF_TYPE_RAW        = 0x4
+	PERF_TYPE_BREAKPOINT = 0x5
+
+	PERF_COUNT_HW_CPU_CYCLES              = 0x0
+	PERF_COUNT_HW_INSTRUCTIONS            = 0x1
+	PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
+	PERF_COUNT_HW_CACHE_MISSES            = 0x3
+	PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	PERF_COUNT_HW_BRANCH_MISSES           = 0x5
+	PERF_COUNT_HW_BUS_CYCLES              = 0x6
+	PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
+
+	PERF_COUNT_HW_CACHE_L1D  = 0x0
+	PERF_COUNT_HW_CACHE_L1I  = 0x1
+	PERF_COUNT_HW_CACHE_LL   = 0x2
+	PERF_COUNT_HW_CACHE_DTLB = 0x3
+	PERF_COUNT_HW_CACHE_ITLB = 0x4
+	PERF_COUNT_HW_CACHE_BPU  = 0x5
+	PERF_COUNT_HW_CACHE_NODE = 0x6
+
+	PERF_COUNT_HW_CACHE_OP_READ     = 0x0
+	PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
+	PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
+
+	PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
+	PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
+
+	PERF_COUNT_SW_CPU_CLOCK        = 0x0
+	PERF_COUNT_SW_TASK_CLOCK       = 0x1
+	PERF_COUNT_SW_PAGE_FAULTS      = 0x2
+	PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
+	PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
+	PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
+	PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
+	PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
+	PERF_COUNT_SW_EMULATION_FAULTS = 0x8
+	PERF_COUNT_SW_DUMMY            = 0x9
+	PERF_COUNT_SW_BPF_OUTPUT       = 0xa
+
+	PERF_SAMPLE_IP           = 0x1
+	PERF_SAMPLE_TID          = 0x2
+	PERF_SAMPLE_TIME         = 0x4
+	PERF_SAMPLE_ADDR         = 0x8
+	PERF_SAMPLE_READ         = 0x10
+	PERF_SAMPLE_CALLCHAIN    = 0x20
+	PERF_SAMPLE_ID           = 0x40
+	PERF_SAMPLE_CPU          = 0x80
+	PERF_SAMPLE_PERIOD       = 0x100
+	PERF_SAMPLE_STREAM_ID    = 0x200
+	PERF_SAMPLE_RAW          = 0x400
+	PERF_SAMPLE_BRANCH_STACK = 0x800
+
+	PERF_SAMPLE_BRANCH_USER       = 0x1
+	PERF_SAMPLE_BRANCH_KERNEL     = 0x2
+	PERF_SAMPLE_BRANCH_HV         = 0x4
+	PERF_SAMPLE_BRANCH_ANY        = 0x8
+	PERF_SAMPLE_BRANCH_ANY_CALL   = 0x10
+	PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
+	PERF_SAMPLE_BRANCH_IND_CALL   = 0x40
+	PERF_SAMPLE_BRANCH_ABORT_TX   = 0x80
+	PERF_SAMPLE_BRANCH_IN_TX      = 0x100
+	PERF_SAMPLE_BRANCH_NO_TX      = 0x200
+	PERF_SAMPLE_BRANCH_COND       = 0x400
+	PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
+	PERF_SAMPLE_BRANCH_IND_JUMP   = 0x1000
+	PERF_SAMPLE_BRANCH_CALL       = 0x2000
+	PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
+	PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
+	PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
+
+	PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
+	PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
+	PERF_FORMAT_ID                 = 0x4
+	PERF_FORMAT_GROUP              = 0x8
+
+	PERF_RECORD_MMAP            = 0x1
+	PERF_RECORD_LOST            = 0x2
+	PERF_RECORD_COMM            = 0x3
+	PERF_RECORD_EXIT            = 0x4
+	PERF_RECORD_THROTTLE        = 0x5
+	PERF_RECORD_UNTHROTTLE      = 0x6
+	PERF_RECORD_FORK            = 0x7
+	PERF_RECORD_READ            = 0x8
+	PERF_RECORD_SAMPLE          = 0x9
+	PERF_RECORD_MMAP2           = 0xa
+	PERF_RECORD_AUX             = 0xb
+	PERF_RECORD_ITRACE_START    = 0xc
+	PERF_RECORD_LOST_SAMPLES    = 0xd
+	PERF_RECORD_SWITCH          = 0xe
+	PERF_RECORD_SWITCH_CPU_WIDE = 0xf
+	PERF_RECORD_NAMESPACES      = 0x10
+
+	PERF_CONTEXT_HV     = -0x20
+	PERF_CONTEXT_KERNEL = -0x80
+	PERF_CONTEXT_USER   = -0x200
+
+	PERF_CONTEXT_GUEST        = -0x800
+	PERF_CONTEXT_GUEST_KERNEL = -0x880
+	PERF_CONTEXT_GUEST_USER   = -0xa00
+
+	PERF_FLAG_FD_NO_GROUP = 0x1
+	PERF_FLAG_FD_OUTPUT   = 0x2
+	PERF_FLAG_PID_CGROUP  = 0x4
+	PERF_FLAG_FD_CLOEXEC  = 0x8
+)
+
+type fOwnerEx struct {
+    category int
+    pid uint32
+}
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index d4a9bd4ff5..69915769b1 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -356,6 +356,12 @@ func sigaltstack(new, old *stackt)
 //go:noescape
 func setitimer(mode int32, new, old *itimerval)
 
+//go:noescape
+func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (int64, int64, int64) 
+func ioctl(fd, req, arg int64) int64
+// func fcntl(fd, cmd, arg int64) (int64, int64)
+func fcntl(fd, cmd int64, arg interface{}) (int64, int64)
+
 //go:noescape
 func rtsigprocmask(how int32, new, old *sigset, size int32)
 
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 1dd56989b4..6bcc11ecdb 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -254,14 +254,38 @@ func setProcessCPUProfiler(hz int32) {
 // setThreadCPUProfiler makes any thread-specific changes required to
 // implement profiling at a rate of hz.
 func setThreadCPUProfiler(hz int32) {
-	var it itimerval
 	if hz == 0 {
+	    var it itimerval
 		setitimer(_ITIMER_PROF, &it, nil)
 	} else {
-		it.it_interval.tv_sec = 0
-		it.it_interval.set_usec(1000000 / hz)
-		it.it_value = it.it_interval
-		setitimer(_ITIMER_PROF, &it, nil)
+		// it.it_interval.tv_sec = 0
+		// it.it_interval.set_usec(1000000 / hz)
+		// it.it_value = it.it_interval
+		// setitimer(_ITIMER_PROF, &it, nil)
+        
+        var attr PerfEventAttr
+        attr.Type = PERF_TYPE_HARDWARE
+        attr.Size = uint32(unsafe.Sizeof(attr))
+        attr.Config = PERF_COUNT_HW_CPU_CYCLES
+        attr.Sample  =  10000000
+        
+        fd, _, err := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
+        r, err := fcntl(fd, /*F_GETFL*/ 0x3, 0)
+        r, err = fcntl(fd, /*F_SETFL*/ 0x4, r | 0x2000)
+        r, err = fcntl(fd, /*F_SETSIG*/ 0xa, _SIGPROF)
+    
+        // fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, gettid()}
+        // r, err = fcntl(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx);
+        
+        printstring("r, err ")
+        printnl()
+        printint(int64(r))
+        printstring(" ")
+        printint(int64(err))
+        printnl()
+
+        // ioctl(fd, /*PERF_EVENT_IOC_RESET*/ 0x2403, 0);
+        // ioctl(fd, /*PERF_EVENT_IOC_ENABLE*/ 0x2400, 0);
 	}
 	_g_ := getg()
 	_g_.m.profilehz = hz
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 5c300f553d..0809809387 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -21,6 +21,7 @@
 #define SYS_rt_sigaction	13
 #define SYS_rt_sigprocmask	14
 #define SYS_rt_sigreturn	15
+#define SYS_ioctl       16
 #define SYS_sched_yield 	24
 #define SYS_mincore		27
 #define SYS_madvise		28
@@ -46,6 +47,7 @@
 #define SYS_faccessat		269
 #define SYS_epoll_pwait		281
 #define SYS_epoll_create1	291
+#define SYS_perfEventOpen 298
 
 TEXT runtime·exit(SB),NOSPLIT,$0-4
 	MOVL	code+0(FP), DI
@@ -166,6 +168,56 @@ TEXT runtime·setitimer(SB),NOSPLIT,$0-24
 	SYSCALL
 	RET
 
+// func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r1, r2, err int64) 
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+	MOVQ	a1+0(FP), DI
+	MOVQ	a2+8(FP), SI
+	MOVQ	a3+16(FP), DX
+	MOVQ	a4+24(FP), R10
+	MOVQ	a5+32(FP), R8
+	MOVQ	a6+40(FP), R9
+	MOVQ	$SYS_perfEventOpen, AX	// syscall entry
+	SYSCALL
+	CMPQ	AX, $0xfffffffffffff001
+	JLS	ok
+	MOVQ	$-1, r1+48(FP)
+	MOVQ	$0, r2+56(FP)
+	NEGQ	AX
+	MOVQ	AX, err+64(FP)
+	RET
+ok:
+	MOVQ	AX, r1+48(FP)
+	MOVQ	DX, r2+56(FP)
+	MOVQ	$0, err+64(FP)
+	RET
+
+// func ioctl(fd int, req uint, arg uintptr) err int64
+TEXT runtime·ioctl(SB),NOSPLIT,$0
+	MOVQ	a1+0(FP), DI 
+	MOVQ	a2+8(FP), SI
+	MOVQ	a3+16(FP), DX
+    MOVQ	$SYS_ioctl, AX
+	SYSCALL
+	RET
+
+// func fcntl(fd, cmd, arg int64) (r, err int64)
+TEXT runtime·fcntl(SB),NOSPLIT,$0
+	MOVQ	a1+0(FP), DI 
+	MOVQ	a2+8(FP), SI
+	MOVQ	a3+16(FP), DX
+    MOVQ	$SYS_fcntl, AX
+	SYSCALL
+	CMPQ	AX, $0xfffffffffffff001
+	JLS	ok
+	MOVQ	$-1, r+24(FP)
+	NEGQ	AX
+	MOVQ	AX, err+32(FP)
+	RET
+ok:
+	MOVQ	AX, r1+24(FP)
+	MOVQ	$0, err+32(FP)
+	RET
+
 TEXT runtime·mincore(SB),NOSPLIT,$0-28
 	MOVQ	addr+0(FP), DI
 	MOVQ	n+8(FP), SI

From cb3f988cbd7e813d0bf62ad52ab1eb5812d17967 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 4 Jun 2019 16:42:48 -0700
Subject: [PATCH 002/126] minor

---
 src/runtime/signal_unix.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 6bcc11ecdb..7093794765 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -274,8 +274,8 @@ func setThreadCPUProfiler(hz int32) {
         r, err = fcntl(fd, /*F_SETFL*/ 0x4, r | 0x2000)
         r, err = fcntl(fd, /*F_SETSIG*/ 0xa, _SIGPROF)
     
-        // fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, gettid()}
-        // r, err = fcntl(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx);
+        fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, gettid()}
+        r, err = fcntl(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx);
         
         printstring("r, err ")
         printnl()

From 87a6fec2048306b751cd9006d48a6f96a7a55345 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 5 Jun 2019 15:27:18 -0700
Subject: [PATCH 003/126] disable escaping to heap and deliver SIGPROF to the
 correspoind signal handler

---
 src/runtime/defs_linux_amd64.go  | 47 +++++++++++++--------------
 src/runtime/os_linux.go          | 11 +++++--
 src/runtime/signal_sighandler.go |  6 ++--
 src/runtime/signal_unix.go       | 21 +++++++------
 src/runtime/sys_linux_amd64.s    | 54 +++++++++++++++++++++-----------
 5 files changed, 83 insertions(+), 56 deletions(-)

diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 0880822393..1e4ba1e5cb 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -262,27 +262,6 @@ type sockaddr_un struct {
 	path   [108]byte
 }
 
-type PerfEventAttr struct {
-    Type               uint32
-    Size               uint32
-    Config             uint64
-    Sample             uint64
-    Sample_type        uint64
-    Read_format        uint64
-    Bits               uint64
-    Wakeup             uint32
-    Bp_type            uint32
-    Ext1               uint64
-    Ext2               uint64
-    Branch_sample_type uint64
-    Sample_regs_user   uint64
-    Sample_stack_user  uint32
-    Clockid            int32
-    Sample_regs_intr   uint64
-    Aux_watermark      uint32
-    _                  uint32
-}
-
 const (
 	PERF_TYPE_HARDWARE   = 0x0
 	PERF_TYPE_SOFTWARE   = 0x1
@@ -396,7 +375,29 @@ const (
 	PERF_FLAG_FD_CLOEXEC  = 0x8
 )
 
+type PerfEventAttr struct {
+    Type               uint32
+    Size               uint32
+    Config             uint64
+    Sample             uint64
+    Sample_type        uint64
+    Read_format        uint64
+    Bits               uint64
+    Wakeup             uint32
+    Bp_type            uint32
+    Ext1               uint64
+    Ext2               uint64
+    Branch_sample_type uint64
+    Sample_regs_user   uint64
+    Sample_stack_user  uint32
+    Clockid            int32
+    Sample_regs_intr   uint64
+    Aux_watermark      uint32
+    _                  uint32
+}
+
 type fOwnerEx struct {
-    category int
-    pid uint32
+    Type int32
+    Pid int32
+
 }
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 69915769b1..ab9b216078 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -357,10 +357,15 @@ func sigaltstack(new, old *stackt)
 func setitimer(mode int32, new, old *itimerval)
 
 //go:noescape
-func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (int64, int64, int64) 
+func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r, r2, err int64)
+
 func ioctl(fd, req, arg int64) int64
-// func fcntl(fd, cmd, arg int64) (int64, int64)
-func fcntl(fd, cmd int64, arg interface{}) (int64, int64)
+
+// func fcntl(fd, cmd int64, arg interface{}) (r int64, err int64)
+func fcntl(fd, cmd, arg int64) (r, err int64)
+
+//go:noescape
+func fcntl2(fd, cmd int64, arg *fOwnerEx) (r, err int64)
 
 //go:noescape
 func rtsigprocmask(how int32, new, old *sigset, size int32)
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index bec4653218..9c446e56f7 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -34,8 +34,10 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
 	_g_ := getg()
 	c := &sigctxt{info, ctxt}
 
-	if sig == _SIGPROF {
-		sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
+    if sig == _SIGPROF {
+        // printint(int64(info.si_signo))
+        // printnl()	
+        sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
 		return
 	}
 
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 7093794765..276210ce75 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -267,22 +267,23 @@ func setThreadCPUProfiler(hz int32) {
         attr.Type = PERF_TYPE_HARDWARE
         attr.Size = uint32(unsafe.Sizeof(attr))
         attr.Config = PERF_COUNT_HW_CPU_CYCLES
-        attr.Sample  =  10000000
+        attr.Sample = uint64(hz)
+        fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
         
-        fd, _, err := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
-        r, err := fcntl(fd, /*F_GETFL*/ 0x3, 0)
-        r, err = fcntl(fd, /*F_SETFL*/ 0x4, r | 0x2000)
-        r, err = fcntl(fd, /*F_SETSIG*/ 0xa, _SIGPROF)
-    
-        fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, gettid()}
-        r, err = fcntl(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx);
+        r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
+        fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
+        fcntl(fd, /*F_SETSIG*/ 0xa, _SIGPROF)
         
+        fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, int32(gettid())}
+        fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx);
+        
+        /*
         printstring("r, err ")
-        printnl()
         printint(int64(r))
-        printstring(" ")
+        printnl()
         printint(int64(err))
         printnl()
+        */
 
         // ioctl(fd, /*PERF_EVENT_IOC_RESET*/ 0x2403, 0);
         // ioctl(fd, /*PERF_EVENT_IOC_ENABLE*/ 0x2400, 0);
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 0809809387..5a00025b67 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -168,43 +168,44 @@ TEXT runtime·setitimer(SB),NOSPLIT,$0-24
 	SYSCALL
 	RET
 
-// func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r1, r2, err int64) 
+// func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r, r2, err int64) 
 TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
-	MOVQ	a1+0(FP), DI
-	MOVQ	a2+8(FP), SI
-	MOVQ	a3+16(FP), DX
-	MOVQ	a4+24(FP), R10
-	MOVQ	a5+32(FP), R8
-	MOVQ	a6+40(FP), R9
+	MOVQ	attr+0(FP), DI
+	MOVQ	pid+8(FP), SI
+	MOVQ	cpu+16(FP), DX
+	MOVQ	groupFd+24(FP), R10
+	MOVQ	flags+32(FP), R8
+	MOVQ	dummy+40(FP), R9
 	MOVQ	$SYS_perfEventOpen, AX	// syscall entry
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
 	JLS	ok
-	MOVQ	$-1, r1+48(FP)
+	MOVQ	$-1, r+48(FP)
 	MOVQ	$0, r2+56(FP)
 	NEGQ	AX
 	MOVQ	AX, err+64(FP)
 	RET
 ok:
-	MOVQ	AX, r1+48(FP)
+	MOVQ	AX, r+48(FP)
 	MOVQ	DX, r2+56(FP)
 	MOVQ	$0, err+64(FP)
 	RET
 
-// func ioctl(fd int, req uint, arg uintptr) err int64
+// func ioctl(fd, req, arg int64) int64 
 TEXT runtime·ioctl(SB),NOSPLIT,$0
-	MOVQ	a1+0(FP), DI 
-	MOVQ	a2+8(FP), SI
-	MOVQ	a3+16(FP), DX
+	MOVQ	fd+0(FP), DI 
+	MOVQ	req+8(FP), SI
+	MOVQ	arg+16(FP), DX
     MOVQ	$SYS_ioctl, AX
 	SYSCALL
+    MOVQ    AX, ret+24(FP)
 	RET
 
-// func fcntl(fd, cmd, arg int64) (r, err int64)
+// func fcntl(fd, cmd int64, arg interface{}) (r int64, err int64)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
-	MOVQ	a1+0(FP), DI 
-	MOVQ	a2+8(FP), SI
-	MOVQ	a3+16(FP), DX
+	MOVQ	fd+0(FP), DI 
+	MOVQ	cmd+8(FP), SI
+	MOVQ	arg+16(FP), DX
     MOVQ	$SYS_fcntl, AX
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
@@ -214,7 +215,24 @@ TEXT runtime·fcntl(SB),NOSPLIT,$0
 	MOVQ	AX, err+32(FP)
 	RET
 ok:
-	MOVQ	AX, r1+24(FP)
+	MOVQ	AX, r+24(FP)
+	MOVQ	$0, err+32(FP)
+	RET
+
+TEXT runtime·fcntl2(SB),NOSPLIT,$0
+	MOVQ	fd+0(FP), DI 
+	MOVQ	cmd+8(FP), SI
+	MOVQ	arg+16(FP), DX
+    MOVQ	$SYS_fcntl, AX
+	SYSCALL
+	CMPQ	AX, $0xfffffffffffff001
+	JLS	ok
+	MOVQ	$-1, r+24(FP)
+	NEGQ	AX
+	MOVQ	AX, err+32(FP)
+	RET
+ok:
+	MOVQ	AX, r+24(FP)
 	MOVQ	$0, err+32(FP)
 	RET
 

From 59beecdb6302e6110db5270aa4c2ed0439ac978c Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 5 Jun 2019 15:33:24 -0700
Subject: [PATCH 004/126] minor

---
 src/runtime/signal_unix.go    | 3 ---
 src/runtime/sys_linux_amd64.s | 2 +-
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 276210ce75..0dac5beb4c 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -278,11 +278,8 @@ func setThreadCPUProfiler(hz int32) {
         fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx);
         
         /*
-        printstring("r, err ")
         printint(int64(r))
         printnl()
-        printint(int64(err))
-        printnl()
         */
 
         // ioctl(fd, /*PERF_EVENT_IOC_RESET*/ 0x2403, 0);
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 5a00025b67..ee4df25f0e 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -201,7 +201,7 @@ TEXT runtime·ioctl(SB),NOSPLIT,$0
     MOVQ    AX, ret+24(FP)
 	RET
 
-// func fcntl(fd, cmd int64, arg interface{}) (r int64, err int64)
+// func fcntl(fd, cmd arg int64) (r int64, err int64)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
 	MOVQ	fd+0(FP), DI 
 	MOVQ	cmd+8(FP), SI

From ad7bef95f5520fb988e7d5f1c487e099035a506c Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 5 Jun 2019 18:44:46 -0700
Subject: [PATCH 005/126] disable/enable PMU counters in the signal handler

---
 src/runtime/defs_linux_amd64.go  | 18 +++++++++++++++++-
 src/runtime/signal_sighandler.go |  9 ++++++---
 src/runtime/signal_unix.go       |  7 +++----
 3 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 1e4ba1e5cb..c1e3144736 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -126,7 +126,9 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr uint64
+	si_addr  uint64
+    si_fd    int64 // missed out by Golang's developers
+
 }
 
 type itimerval struct {
@@ -373,8 +375,22 @@ const (
 	PERF_FLAG_FD_OUTPUT   = 0x2
 	PERF_FLAG_PID_CGROUP  = 0x4
 	PERF_FLAG_FD_CLOEXEC  = 0x8
+
+    PERF_EVENT_IOC_DISABLE               = 0x2401
+    PERF_EVENT_IOC_ENABLE                = 0x2400
+    PERF_EVENT_IOC_ID                    = 0x80082407
+    PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
+    PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
+    PERF_EVENT_IOC_PERIOD                = 0x40082404
+    PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
+    PERF_EVENT_IOC_REFRESH               = 0x2402
+    PERF_EVENT_IOC_RESET                 = 0x2403
+    PERF_EVENT_IOC_SET_BPF               = 0x40042408
+    PERF_EVENT_IOC_SET_FILTER            = 0x40082406
+    PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
 )
 
+
 type PerfEventAttr struct {
     Type               uint32
     Size               uint32
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index 9c446e56f7..f98a23b012 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -35,10 +35,13 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
 	c := &sigctxt{info, ctxt}
 
     if sig == _SIGPROF {
-        // printint(int64(info.si_signo))
-        // printnl()	
+        fd := info.si_fd
+        // printint(fd)
+        // printnl()
+        ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
         sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
-		return
+		ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
+        return
 	}
 
 	if sig == _SIGTRAP && testSigtrap != nil && testSigtrap(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp) {
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 0dac5beb4c..ec542274ab 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -267,7 +267,9 @@ func setThreadCPUProfiler(hz int32) {
         attr.Type = PERF_TYPE_HARDWARE
         attr.Size = uint32(unsafe.Sizeof(attr))
         attr.Config = PERF_COUNT_HW_CPU_CYCLES
-        attr.Sample = uint64(hz)
+        // attr.Sample = uint64(hz)
+        attr.Sample = 1000000
+        
         fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
         
         r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
@@ -281,9 +283,6 @@ func setThreadCPUProfiler(hz int32) {
         printint(int64(r))
         printnl()
         */
-
-        // ioctl(fd, /*PERF_EVENT_IOC_RESET*/ 0x2403, 0);
-        // ioctl(fd, /*PERF_EVENT_IOC_ENABLE*/ 0x2400, 0);
 	}
 	_g_ := getg()
 	_g_.m.profilehz = hz

From 014d49c777ae2d1ec9b118ec629ccb11966a728a Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 5 Jun 2019 19:49:04 -0700
Subject: [PATCH 006/126] note

---
 src/runtime/defs_linux_amd64.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index c1e3144736..9aa88cbde4 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -127,7 +127,9 @@ type siginfo struct {
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
 	si_addr  uint64
-    si_fd    int64 // missed out by Golang's developers
+    
+    // psu: an unreliable workaround and need to figure out a better solution
+    si_fd    int64 
 
 }
 

From 0b450d5295ab82b2a77c6c35ad6269e982b89a8a Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Fri, 7 Jun 2019 20:12:44 -0700
Subject: [PATCH 007/126] test cases for PMU

---
 src/runtime/signal_sighandler.go |   3 +-
 src/runtime/signal_unix.go       |  19 +--
 test/pmu/cycle/test1.go          | 185 +++++++++++++++++++++++++++++
 test/pmu/cycle/test1.out         |  10 ++
 test/pmu/cycle/test2.go          | 193 +++++++++++++++++++++++++++++++
 test/pmu/cycle/test2.out         |  10 ++
 test/pmu/cycle/test3.go          | 188 ++++++++++++++++++++++++++++++
 test/pmu/cycle/test3.out         |  10 ++
 test/run.go                      |   2 +-
 9 files changed, 602 insertions(+), 18 deletions(-)
 create mode 100644 test/pmu/cycle/test1.go
 create mode 100644 test/pmu/cycle/test1.out
 create mode 100644 test/pmu/cycle/test2.go
 create mode 100644 test/pmu/cycle/test2.out
 create mode 100644 test/pmu/cycle/test3.go
 create mode 100644 test/pmu/cycle/test3.out

diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index f98a23b012..481ba3800f 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -36,8 +36,7 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
 
     if sig == _SIGPROF {
         fd := info.si_fd
-        // printint(fd)
-        // printnl()
+        // print(fd, "\n")
         ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
         sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
 		ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index ec542274ab..3c54347f90 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -254,21 +254,13 @@ func setProcessCPUProfiler(hz int32) {
 // setThreadCPUProfiler makes any thread-specific changes required to
 // implement profiling at a rate of hz.
 func setThreadCPUProfiler(hz int32) {
-	if hz == 0 {
-	    var it itimerval
-		setitimer(_ITIMER_PROF, &it, nil)
-	} else {
-		// it.it_interval.tv_sec = 0
-		// it.it_interval.set_usec(1000000 / hz)
-		// it.it_value = it.it_interval
-		// setitimer(_ITIMER_PROF, &it, nil)
-        
+	if hz != 0 {
         var attr PerfEventAttr
         attr.Type = PERF_TYPE_HARDWARE
         attr.Size = uint32(unsafe.Sizeof(attr))
         attr.Config = PERF_COUNT_HW_CPU_CYCLES
-        // attr.Sample = uint64(hz)
-        attr.Sample = 1000000
+        attr.Sample = 3e9 / uint64(hz) // match itimer's sampling rate
+        // attr.Sample = 1e6 
         
         fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
         
@@ -279,10 +271,7 @@ func setThreadCPUProfiler(hz int32) {
         fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, int32(gettid())}
         fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx);
         
-        /*
-        printint(int64(r))
-        printnl()
-        */
+        // print(r, "\n")
 	}
 	_g_ := getg()
 	_g_.m.profilehz = hz
diff --git a/test/pmu/cycle/test1.go b/test/pmu/cycle/test1.go
new file mode 100644
index 0000000000..0a5b52dd0d
--- /dev/null
+++ b/test/pmu/cycle/test1.go
@@ -0,0 +1,185 @@
+// run
+
+package main
+
+import (
+    "fmt"
+    "log"
+    "os"
+    "runtime/pprof"
+    "sync"
+)
+
+//go:noinline
+func fun1(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+   fmt.Println(sum)
+}
+
+//go:noinline
+func fun2(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun3(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun4(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun5(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun6(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun7(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun8(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun9(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun10(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+func main() {
+    cpuf, err := os.Create("test1_profile")
+    if err != nil {
+        log.Fatal(err)
+    }
+    pprof.StartCPUProfile(cpuf)
+    defer pprof.StopCPUProfile()
+    
+    var wg sync.WaitGroup
+    wg.Add(10) // fun1-fun10
+    defer wg.Wait() // similar to pthread_join
+    
+    go fun1(&wg)
+    go fun2(&wg)
+    go fun3(&wg)
+    go fun4(&wg)
+    go fun5(&wg)
+    go fun6(&wg)
+    go fun7(&wg)
+    go fun8(&wg)
+    go fun9(&wg)
+    go fun10(&wg)
+}
diff --git a/test/pmu/cycle/test1.out b/test/pmu/cycle/test1.out
new file mode 100644
index 0000000000..9546171295
--- /dev/null
+++ b/test/pmu/cycle/test1.out
@@ -0,0 +1,10 @@
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
diff --git a/test/pmu/cycle/test2.go b/test/pmu/cycle/test2.go
new file mode 100644
index 0000000000..952f44823d
--- /dev/null
+++ b/test/pmu/cycle/test2.go
@@ -0,0 +1,193 @@
+// run
+
+package main
+
+import (
+    "fmt"
+    "log"
+    "os"
+    "runtime/pprof"
+)
+
+//go:noinline
+func fun1(c chan int) {
+    defer close(c)
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun2(c chan int) {
+    defer close(c)
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun3(c chan int) {
+    defer close(c)
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun4(c chan int) {
+    defer close(c)
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun5(c chan int) {
+    defer close(c)
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun6(c chan int) {
+    defer close(c)
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun7(c chan int) {
+    defer close(c)
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun8(c chan int) {
+    defer close(c)
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun9(c chan int) {
+    defer close(c)
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun10(c chan int) {
+    defer close(c)
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+func waitForChans(chans ...chan int) {
+    for _, v := range chans {
+		<-v
+	}
+}
+
+func main() {
+    cpuf, err := os.Create("test2_profile")
+    if err != nil {
+        log.Fatal(err)
+    }
+    pprof.StartCPUProfile(cpuf)
+    defer pprof.StopCPUProfile()
+    
+    var chans [10]chan int
+    for i := range chans {
+        chans[i] = make(chan int)
+    }
+    
+    go fun1(chans[0])
+    go fun2(chans[1])
+    go fun3(chans[2])
+    go fun4(chans[3])
+    go fun5(chans[4])
+    go fun6(chans[5])
+    go fun7(chans[6])
+    go fun8(chans[7])
+    go fun9(chans[8])
+    go fun10(chans[9])
+
+    waitForChans(chans[0], chans[1], chans[2], chans[3], chans[4], chans[5], chans[6], chans[7], chans[8], chans[9])
+}
diff --git a/test/pmu/cycle/test2.out b/test/pmu/cycle/test2.out
new file mode 100644
index 0000000000..9546171295
--- /dev/null
+++ b/test/pmu/cycle/test2.out
@@ -0,0 +1,10 @@
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
diff --git a/test/pmu/cycle/test3.go b/test/pmu/cycle/test3.go
new file mode 100644
index 0000000000..3428fd4677
--- /dev/null
+++ b/test/pmu/cycle/test3.go
@@ -0,0 +1,188 @@
+// run
+
+package main
+
+import (
+    "fmt"
+    "log"
+    "os"
+    "runtime/pprof"
+    "sync"
+)
+
+//go:noinline
+func fun1(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun2(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun3(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun4(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+func fun5(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun6(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun7(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun8(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+func fun9(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+//go:noinline
+func fun10(wg *sync.WaitGroup) {
+    defer wg.Done()
+
+    var sum int
+    for i:= 0; i < 500000000; i++ {
+        sum -= i / 2
+        sum *= i
+        sum /= i / 3 + 1
+        sum -= i / 4
+    }
+    
+    fmt.Println(sum)
+}
+
+func main() {
+    cpuf, err := os.Create("test3_profile")
+    if err != nil {
+        log.Fatal(err)
+    }
+    pprof.StartCPUProfile(cpuf)
+    defer pprof.StopCPUProfile()
+    
+    var wg [10]sync.WaitGroup
+    for i := range wg {
+        wg[i].Add(1)
+    }
+    
+    go fun1(&(wg[0]))
+    go fun2(&(wg[1]))
+    go fun3(&(wg[2]))
+    go fun4(&(wg[3]))
+    go fun5(&(wg[4]))
+    go fun6(&(wg[5]))
+    go fun7(&(wg[6]))
+    go fun8(&(wg[7]))
+    go fun9(&(wg[8]))
+    go fun10(&(wg[9]))
+    
+    for i:= range wg {
+        wg[i].Wait()
+    }
+}
diff --git a/test/pmu/cycle/test3.out b/test/pmu/cycle/test3.out
new file mode 100644
index 0000000000..9546171295
--- /dev/null
+++ b/test/pmu/cycle/test3.out
@@ -0,0 +1,10 @@
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
diff --git a/test/run.go b/test/run.go
index 28ed865c50..ff1fcef9b1 100644
--- a/test/run.go
+++ b/test/run.go
@@ -50,7 +50,7 @@ var (
 
 	// dirs are the directories to look for *.go files in.
 	// TODO(bradfitz): just use all directories?
-	dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime"}
+	dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime", "pmu/cycle"}
 
 	// ratec controls the max number of tests running at a time.
 	ratec chan bool

From 508ab840711fea0d18b8d1f8c1812fd5445a6de0 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 9 Jun 2019 19:46:00 -0700
Subject: [PATCH 008/126] test

---
 test/pmu/cycle/test3.go | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/pmu/cycle/test3.go b/test/pmu/cycle/test3.go
index 3428fd4677..e9e0e7f61d 100644
--- a/test/pmu/cycle/test3.go
+++ b/test/pmu/cycle/test3.go
@@ -4,6 +4,7 @@ package main
 
 import (
     "fmt"
+    "flag"
     "log"
     "os"
     "runtime/pprof"
@@ -158,7 +159,15 @@ func fun10(wg *sync.WaitGroup) {
     fmt.Println(sum)
 }
 
+var args = flag.String("p", "", "itimer() is used by default")
+
 func main() {
+   flag.Parse()
+
+   if *args != "" {
+       pprof.EnablePMU(*args)
+   }
+
     cpuf, err := os.Create("test3_profile")
     if err != nil {
         log.Fatal(err)

From e70dce461cfaa1fd2c4cd748ba3d41db23ed5548 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 9 Jun 2019 19:47:14 -0700
Subject: [PATCH 009/126] separete PMU from the execution path of itimer()

---
 src/runtime/cpuprof.go           | 29 +++++++++++++
 src/runtime/defs_linux_amd64.go  |  1 +
 src/runtime/proc.go              | 48 +++++++++++++++++++++-
 src/runtime/runtime2.go          |  6 ++-
 src/runtime/signal_sighandler.go |  8 +++-
 src/runtime/signal_unix.go       | 70 ++++++++++++++++++++++++--------
 6 files changed, 138 insertions(+), 24 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index 81038f5c48..9256567760 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -81,6 +81,35 @@ func SetCPUProfileRate(hz int) {
 	unlock(&cpuprof.lock)
 }
 
+func SetCPUPMUProfile(event int32, hz int) {
+    if hz < 0 {
+        hz = 0
+    }
+    if hz > 1000000 {
+        hz = 1000000
+    }
+    lock(&cpuprof.lock)
+    if hz > 0 {
+        if cpuprof.on || cpuprof.log != nil {
+            print("runtime: cannot set cpu profile rate until previous profile has finished.\n")
+            unlock(&cpuprof.lock)
+            return
+        }
+
+        cpuprof.on = true
+        cpuprof.log = newProfBuf(1, 1<<17, 1<<14)
+        hdr := [1]uint64{uint64(hz)}
+        cpuprof.log.write(nil, nanotime(), hdr[:], nil)
+        setcpupmuprofile(event, int32(hz))
+    } else if cpuprof.on {
+        setcpupmuprofile(event, 0)
+        cpuprof.on = false
+        cpuprof.addExtra()
+        cpuprof.log.close()
+    }
+    unlock(&cpuprof.lock)
+}
+
 // add adds the stack trace to the profile.
 // It is called from signal handlers and other limited environments
 // and cannot allocate memory or acquire locks that might be
diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 9aa88cbde4..00260f15a8 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -57,6 +57,7 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
+    _SIGRTMIN  = 0x22
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index e9eca23138..c8ed1cb5f8 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2134,7 +2134,7 @@ func gcstopm() {
 // acquiring a P in several places.
 //
 //go:yeswritebarrierrec
-func execute(gp *g, inheritTime bool) {
+func execute(gp *g, inheritTime bool) { // psu: is it always invoked later than setcpupmuprofile()
 	_g_ := getg()
 
 	casgstatus(gp, _Grunnable, _Grunning)
@@ -2149,8 +2149,14 @@ func execute(gp *g, inheritTime bool) {
 
 	// Check whether the profiler needs to be turned on or off.
 	hz := sched.profilehz
+    event := sched.event
+    isPMUEnabled := sched.isPMUEnabled
 	if _g_.m.profilehz != hz {
-		setThreadCPUProfiler(hz)
+        if isPMUEnabled { 
+		    setThreadCPUPMUProfiler(event, hz)
+        } else {
+		    setThreadCPUProfiler(hz)
+        }
 	}
 
 	if trace.enabled {
@@ -3887,6 +3893,7 @@ func setcpuprofilerate(hz int32) {
 	atomic.Store(&prof.signalLock, 0)
 
 	lock(&sched.lock)
+    sched.isPMUEnabled = false
 	sched.profilehz = hz
 	unlock(&sched.lock)
 
@@ -3897,6 +3904,43 @@ func setcpuprofilerate(hz int32) {
 	_g_.m.locks--
 }
 
+func setcpupmuprofile(event int32, hz int32) {
+    // Force sane arguments.
+    if hz < 0 {
+        hz = 0
+    }
+    // Disable preemption, otherwise we can be rescheduled to another thread
+    // that has profiling enabled.
+    _g_ := getg()
+    _g_.m.locks++
+
+    // Stop profiler on this thread so that it is safe to lock prof.
+    // if a profiling signal came in while we had prof locked,
+    // it would deadlock.
+    setThreadCPUPMUProfiler(event, 0)
+
+    for !atomic.Cas(&prof.signalLock, 0, 1) {
+        osyield()
+    }
+    if prof.hz != hz {
+        setProcessCPUPMUProfiler(hz)
+        prof.hz = hz
+    }
+    atomic.Store(&prof.signalLock, 0)
+
+    lock(&sched.lock)
+    sched.profilehz = hz
+    sched.isPMUEnabled = true
+    sched.event = event
+    unlock(&sched.lock)
+
+    if hz != 0 {
+        setThreadCPUPMUProfiler(event, hz)
+    }
+
+    _g_.m.locks--
+ }
+
 // init initializes pp, which may be a freshly allocated p or a
 // previously destroyed p, and transitions it to status _Pgcstop.
 func (pp *p) init(id int32) {
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index bc5b48222b..e8e579d905 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -473,7 +473,7 @@ type m struct {
 	locks         int32
 	dying         int32
 	profilehz     int32
-	spinning      bool // m is out of work and is actively looking for work
+    spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack
 	printlock     int8
@@ -673,7 +673,9 @@ type schedt struct {
 	safePointWait int32
 	safePointNote note
 
-	profilehz int32 // cpu profiling rate
+    profilehz   int32 // cpu profiling rate
+	isPMUEnabled bool
+    event       int32
 
 	procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index 481ba3800f..d850a61e0e 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -34,14 +34,18 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
 	_g_ := getg()
 	c := &sigctxt{info, ctxt}
 
-    if sig == _SIGPROF {
+    if sig == _SIGRTMIN + 3 {
         fd := info.si_fd
-        // print(fd, "\n")
         ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
         sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
 		ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
         return
 	}
+    
+    if sig == _SIGPROF {
+        sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
+        return
+	}
 
 	if sig == _SIGTRAP && testSigtrap != nil && testSigtrap(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp) {
 		return
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 3c54347f90..d872b30de6 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -149,11 +149,11 @@ func sigenable(sig uint32) {
 		return
 	}
 
-	// SIGPROF is handled specially for profiling.
-	if sig == _SIGPROF {
+	// SIGPROF and _SIGRTMIN + 3 are handled specially for profiling.
+	if sig == _SIGPROF  || sig == _SIGRTMIN + 3 {
 		return
 	}
-
+	
 	t := &sigtable[sig]
 	if t.flags&_SigNotify != 0 {
 		ensureSigM()
@@ -174,8 +174,8 @@ func sigdisable(sig uint32) {
 		return
 	}
 
-	// SIGPROF is handled specially for profiling.
-	if sig == _SIGPROF {
+	// SIGPROF and _SIGRTMIN + 3 are handled specially for profiling.
+	if sig == _SIGPROF  || sig == _SIGRTMIN + 3 {
 		return
 	}
 
@@ -203,8 +203,8 @@ func sigignore(sig uint32) {
 		return
 	}
 
-	// SIGPROF is handled specially for profiling.
-	if sig == _SIGPROF {
+	// SIGPROF and _SIGRTMIN + 3 are handled specially for profiling.
+	if sig == _SIGPROF  || sig == _SIGRTMIN + 3 {
 		return
 	}
 
@@ -251,30 +251,64 @@ func setProcessCPUProfiler(hz int32) {
 	}
 }
 
+func setProcessCPUPMUProfiler(hz int32) {
+    if hz != 0 {
+        // Enable the Go signal handler if not enabled.
+        if atomic.Cas(&handlingSig[_SIGRTMIN + 3], 0, 1) {
+            atomic.Storeuintptr(&fwdSig[_SIGRTMIN + 3], getsig(_SIGRTMIN + 3))
+            setsig(_SIGRTMIN + 3, funcPC(sighandler))
+        }
+    } else {
+        // If the Go signal handler should be disabled by default,
+        // disable it if it is enabled.
+        if !sigInstallGoHandler(_SIGRTMIN + 3) {
+            if atomic.Cas(&handlingSig[_SIGRTMIN + 3], 1, 0) {
+                setsig(_SIGRTMIN + 3, atomic.Loaduintptr(&fwdSig[_SIGRTMIN + 3]))
+            }
+        }
+    }
+}
+
 // setThreadCPUProfiler makes any thread-specific changes required to
 // implement profiling at a rate of hz.
 func setThreadCPUProfiler(hz int32) {
-	if hz != 0 {
+    var it itimerval
+    if hz == 0 {
+        setitimer(_ITIMER_PROF, &it, nil)
+    } else {
+        it.it_interval.tv_sec = 0
+        it.it_interval.set_usec(1000000 / hz)
+        it.it_value = it.it_interval
+        setitimer(_ITIMER_PROF, &it, nil)
+    }
+    _g_ := getg()
+    _g_.m.profilehz = hz
+}
+
+func setThreadCPUPMUProfiler(event int32, hz int32) {
+    // if hz == 0 {
+        // Todo: close the perf event
+
+    // } else {
+    if hz != 0 {
         var attr PerfEventAttr
         attr.Type = PERF_TYPE_HARDWARE
         attr.Size = uint32(unsafe.Sizeof(attr))
-        attr.Config = PERF_COUNT_HW_CPU_CYCLES
+        attr.Config = /*PERF_COUNT_HW_CPU_CYCLES*/ uint64(event)
         attr.Sample = 3e9 / uint64(hz) // match itimer's sampling rate
-        // attr.Sample = 1e6 
+        // attr.Sample = uint64(hz)
         
         fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
         
         r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
         fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
-        fcntl(fd, /*F_SETSIG*/ 0xa, _SIGPROF)
+        fcntl(fd, /*F_SETSIG*/ 0xa, _SIGRTMIN + 3)
         
         fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, int32(gettid())}
         fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx);
-        
-        // print(r, "\n")
-	}
-	_g_ := getg()
-	_g_.m.profilehz = hz
+    }
+    _g_ := getg()
+    _g_.m.profilehz = hz
 }
 
 func sigpipe() {
@@ -302,7 +336,7 @@ func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
 	g := getg()
 	if g == nil {
 		c := &sigctxt{info, ctx}
-		if sig == _SIGPROF {
+		if sig == _SIGPROF || sig == _SIGRTMIN + 3 {
 			sigprofNonGoPC(c.sigpc())
 			return
 		}
@@ -459,7 +493,7 @@ func dieFromSignal(sig uint32) {
 // thread, and the Go program does not want to handle it (that is, the
 // program has not called os/signal.Notify for the signal).
 func raisebadsignal(sig uint32, c *sigctxt) {
-	if sig == _SIGPROF {
+	if sig == _SIGPROF  || sig == _SIGRTMIN + 3 {
 		// Ignore profiling signals that arrive on non-Go threads.
 		return
 	}

From 51c4d159ebd5396b4cd6100d72677ec50b2965b9 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 9 Jun 2019 19:48:58 -0700
Subject: [PATCH 010/126] minor

---
 src/runtime/proc.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index c8ed1cb5f8..52ca644028 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2134,7 +2134,7 @@ func gcstopm() {
 // acquiring a P in several places.
 //
 //go:yeswritebarrierrec
-func execute(gp *g, inheritTime bool) { // psu: is it always invoked later than setcpupmuprofile()
+func execute(gp *g, inheritTime bool) { // psu: Is it always invoked later than setcpupmuprofile()?
 	_g_ := getg()
 
 	casgstatus(gp, _Grunnable, _Grunning)

From cbddb3b29ea8e9f2eb1e7839451b8d94504682d0 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 11 Jun 2019 17:08:46 -0700
Subject: [PATCH 011/126] disable ioctl and close file descriptor when go
 rountine

---
 src/runtime/runtime2.go    |  1 +
 src/runtime/signal_unix.go | 21 +++++++++++----------
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index e8e579d905..981ea1b690 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -473,6 +473,7 @@ type m struct {
 	locks         int32
 	dying         int32
 	profilehz     int32
+    eventFd       int32
     spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index d872b30de6..9306fc4f22 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -286,29 +286,30 @@ func setThreadCPUProfiler(hz int32) {
 }
 
 func setThreadCPUPMUProfiler(event int32, hz int32) {
-    // if hz == 0 {
-        // Todo: close the perf event
-
-    // } else {
-    if hz != 0 {
+    _g_ := getg()
+    _g_.m.profilehz = hz
+    
+    if hz == 0 { // Go routine is finished
+        fd := _g_.m.eventFd
+        ioctl(int64(fd), PERF_EVENT_IOC_DISABLE, 0)
+        closefd(fd)
+    } else {
         var attr PerfEventAttr
         attr.Type = PERF_TYPE_HARDWARE
         attr.Size = uint32(unsafe.Sizeof(attr))
         attr.Config = /*PERF_COUNT_HW_CPU_CYCLES*/ uint64(event)
         attr.Sample = 3e9 / uint64(hz) // match itimer's sampling rate
-        // attr.Sample = uint64(hz)
         
         fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
-        
+        _g_.m.eventFd = int32(fd)
+
         r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
         fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
         fcntl(fd, /*F_SETSIG*/ 0xa, _SIGRTMIN + 3)
         
         fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, int32(gettid())}
-        fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx);
+        fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx)
     }
-    _g_ := getg()
-    _g_.m.profilehz = hz
 }
 
 func sigpipe() {

From 1e4ffc3c1486c26334568a3cea6f58f467ef6bcc Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 12 Jun 2019 15:22:06 -0700
Subject: [PATCH 012/126] export env variabls instead of cmd arguments

---
 src/runtime/cpuprof.go     |  6 ++---
 src/runtime/pprof/pprof.go | 54 +++++++++++++++++++++++++++++++++++---
 src/runtime/proc.go        | 10 +++----
 src/runtime/runtime2.go    |  1 -
 src/runtime/signal_unix.go |  4 +--
 5 files changed, 59 insertions(+), 16 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index 9256567760..0f448243db 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -81,7 +81,7 @@ func SetCPUProfileRate(hz int) {
 	unlock(&cpuprof.lock)
 }
 
-func SetCPUPMUProfile(event int32, hz int) {
+func SetCPUPMUProfile(hz int) {
     if hz < 0 {
         hz = 0
     }
@@ -100,9 +100,9 @@ func SetCPUPMUProfile(event int32, hz int) {
         cpuprof.log = newProfBuf(1, 1<<17, 1<<14)
         hdr := [1]uint64{uint64(hz)}
         cpuprof.log.write(nil, nanotime(), hdr[:], nil)
-        setcpupmuprofile(event, int32(hz))
+        setcpupmuprofile(int32(hz))
     } else if cpuprof.on {
-        setcpupmuprofile(event, 0)
+        setcpupmuprofile(0)
         cpuprof.on = false
         cpuprof.addExtra()
         cpuprof.log.close()
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 74cdd15cfb..f686a38edd 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -73,10 +73,12 @@
 package pprof
 
 import (
-	"bufio"
+	"os"
+    "bufio"
 	"bytes"
 	"fmt"
 	"io"
+    "strconv"
 	"runtime"
 	"sort"
 	"strings"
@@ -727,6 +729,36 @@ var cpu struct {
 	done      chan bool
 }
 
+var pmuConfig struct {
+    isEnabled bool
+    event int32
+    period int32
+}
+
+func EnablePMU(str string) {
+    strs := strings.Split(str, "@")
+    
+    if len(strs) != 2 {
+        return
+    }
+    event, err := strconv.ParseInt(strs[0], 10, 32) 
+    if err != nil {
+        return
+    }
+    period, err := strconv.ParseInt(strs[1], 10, 32) 
+    if err != nil {
+        return
+    }
+    if event < 0 || period < 0 {
+        return
+    } 
+    
+    pmuConfig.isEnabled = true
+    pmuConfig.event = int32(event)
+}   
+
+var isPMUEnabled bool
+
 // StartCPUProfile enables CPU profiling for the current process.
 // While profiling, the profile will be buffered and written to w.
 // StartCPUProfile returns an error if profiling is already enabled.
@@ -760,8 +792,17 @@ func StartCPUProfile(w io.Writer) error {
 		return fmt.Errorf("cpu profiling already in use")
 	}
 	cpu.profiling = true
-	runtime.SetCPUProfileRate(hz)
-	go profileWriter(w)
+    
+    interval, err := strconv.Atoi(os.Getenv("PMU_SAPLE_INTERVAL"))
+    if err == nil && interval > 0 {
+        isPMUEnabled = true
+        runtime.SetCPUPMUProfile(hz)
+    } else {
+        isPMUEnabled = false
+        runtime.SetCPUProfileRate(hz)
+    }
+	
+    go profileWriter(w)
 	return nil
 }
 
@@ -805,7 +846,12 @@ func StopCPUProfile() {
 		return
 	}
 	cpu.profiling = false
-	runtime.SetCPUProfileRate(0)
+   
+    if isPMUEnabled {
+        runtime.SetCPUPMUProfile(0)
+    } else {
+	    runtime.SetCPUProfileRate(0)
+    }
 	<-cpu.done
 }
 
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 52ca644028..e3a7220760 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2149,11 +2149,10 @@ func execute(gp *g, inheritTime bool) { // psu: Is it always invoked later than
 
 	// Check whether the profiler needs to be turned on or off.
 	hz := sched.profilehz
-    event := sched.event
     isPMUEnabled := sched.isPMUEnabled
 	if _g_.m.profilehz != hz {
         if isPMUEnabled { 
-		    setThreadCPUPMUProfiler(event, hz)
+		    setThreadCPUPMUProfiler(hz)
         } else {
 		    setThreadCPUProfiler(hz)
         }
@@ -3904,7 +3903,7 @@ func setcpuprofilerate(hz int32) {
 	_g_.m.locks--
 }
 
-func setcpupmuprofile(event int32, hz int32) {
+func setcpupmuprofile(hz int32) {
     // Force sane arguments.
     if hz < 0 {
         hz = 0
@@ -3917,7 +3916,7 @@ func setcpupmuprofile(event int32, hz int32) {
     // Stop profiler on this thread so that it is safe to lock prof.
     // if a profiling signal came in while we had prof locked,
     // it would deadlock.
-    setThreadCPUPMUProfiler(event, 0)
+    setThreadCPUPMUProfiler(0)
 
     for !atomic.Cas(&prof.signalLock, 0, 1) {
         osyield()
@@ -3931,11 +3930,10 @@ func setcpupmuprofile(event int32, hz int32) {
     lock(&sched.lock)
     sched.profilehz = hz
     sched.isPMUEnabled = true
-    sched.event = event
     unlock(&sched.lock)
 
     if hz != 0 {
-        setThreadCPUPMUProfiler(event, hz)
+        setThreadCPUPMUProfiler(hz)
     }
 
     _g_.m.locks--
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 981ea1b690..e83fd0769a 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -676,7 +676,6 @@ type schedt struct {
 
     profilehz   int32 // cpu profiling rate
 	isPMUEnabled bool
-    event       int32
 
 	procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 9306fc4f22..1fef94d370 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -285,7 +285,7 @@ func setThreadCPUProfiler(hz int32) {
     _g_.m.profilehz = hz
 }
 
-func setThreadCPUPMUProfiler(event int32, hz int32) {
+func setThreadCPUPMUProfiler(hz int32) {
     _g_ := getg()
     _g_.m.profilehz = hz
     
@@ -297,7 +297,7 @@ func setThreadCPUPMUProfiler(event int32, hz int32) {
         var attr PerfEventAttr
         attr.Type = PERF_TYPE_HARDWARE
         attr.Size = uint32(unsafe.Sizeof(attr))
-        attr.Config = /*PERF_COUNT_HW_CPU_CYCLES*/ uint64(event)
+        attr.Config = PERF_COUNT_HW_CPU_CYCLES
         attr.Sample = 3e9 / uint64(hz) // match itimer's sampling rate
         
         fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)

From dd728345bbb74d56f5897f9f1ca113823e1e163c Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 12 Jun 2019 15:26:53 -0700
Subject: [PATCH 013/126] minor

---
 src/runtime/pprof/pprof.go | 28 ----------------------------
 1 file changed, 28 deletions(-)

diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index f686a38edd..ee02ff399e 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -729,34 +729,6 @@ var cpu struct {
 	done      chan bool
 }
 
-var pmuConfig struct {
-    isEnabled bool
-    event int32
-    period int32
-}
-
-func EnablePMU(str string) {
-    strs := strings.Split(str, "@")
-    
-    if len(strs) != 2 {
-        return
-    }
-    event, err := strconv.ParseInt(strs[0], 10, 32) 
-    if err != nil {
-        return
-    }
-    period, err := strconv.ParseInt(strs[1], 10, 32) 
-    if err != nil {
-        return
-    }
-    if event < 0 || period < 0 {
-        return
-    } 
-    
-    pmuConfig.isEnabled = true
-    pmuConfig.event = int32(event)
-}   
-
 var isPMUEnabled bool
 
 // StartCPUProfile enables CPU profiling for the current process.

From c802fafd448e1615419b6ceb76e312c1a6e48986 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 12 Jun 2019 19:10:15 -0700
Subject: [PATCH 014/126] minor

---
 src/runtime/cpuprof.go     | 17 ++++++++---------
 src/runtime/pprof/pprof.go | 24 +++++++++++++++---------
 src/runtime/proc.go        | 18 +++++++++---------
 src/runtime/signal_unix.go | 12 ++++++------
 4 files changed, 38 insertions(+), 33 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index 0f448243db..e6877bf3ef 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -81,15 +81,13 @@ func SetCPUProfileRate(hz int) {
 	unlock(&cpuprof.lock)
 }
 
-func SetCPUPMUProfile(hz int) {
-    if hz < 0 {
-        hz = 0
-    }
-    if hz > 1000000 {
-        hz = 1000000
+func SetCPUPMUProfile(interval int) {
+    if interval > 0 && interval < 300 { // Clamp hz to something reasonable.
+        interval = 300
     }
+    
     lock(&cpuprof.lock)
-    if hz > 0 {
+    if interval > 0 {
         if cpuprof.on || cpuprof.log != nil {
             print("runtime: cannot set cpu profile rate until previous profile has finished.\n")
             unlock(&cpuprof.lock)
@@ -98,9 +96,10 @@ func SetCPUPMUProfile(hz int) {
 
         cpuprof.on = true
         cpuprof.log = newProfBuf(1, 1<<17, 1<<14)
-        hdr := [1]uint64{uint64(hz)}
+        // hdr := [1]uint64{uint64(hz)}
+        hdr := [1]uint64{uint64(interval)}
         cpuprof.log.write(nil, nanotime(), hdr[:], nil)
-        setcpupmuprofile(int32(hz))
+        setcpupmuprofile(int32(interval))
     } else if cpuprof.on {
         setcpupmuprofile(0)
         cpuprof.on = false
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index ee02ff399e..d372b200e9 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -729,7 +729,7 @@ var cpu struct {
 	done      chan bool
 }
 
-var isPMUEnabled bool
+var sampleInterval int
 
 // StartCPUProfile enables CPU profiling for the current process.
 // While profiling, the profile will be buffered and written to w.
@@ -765,14 +765,20 @@ func StartCPUProfile(w io.Writer) error {
 	}
 	cpu.profiling = true
     
-    interval, err := strconv.Atoi(os.Getenv("PMU_SAPLE_INTERVAL"))
-    if err == nil && interval > 0 {
-        isPMUEnabled = true
-        runtime.SetCPUPMUProfile(hz)
-    } else {
-        isPMUEnabled = false
+    if sampleInterval == 0 { // first time StartCPUProfile() is invoked
+        interval, err := strconv.Atoi(os.Getenv("PMU_SAMPLE_INTERVAL"))
+        if err == nil && interval > 0 {
+            sampleInterval = interval
+            runtime.SetCPUPMUProfile(sampleInterval)
+        } else {
+            sampleInterval = -1
+            runtime.SetCPUProfileRate(hz)
+        }
+    } else if sampleInterval < 0 {
         runtime.SetCPUProfileRate(hz)
-    }
+    } else {
+       runtime.SetCPUPMUProfile(sampleInterval)
+    } 
 	
     go profileWriter(w)
 	return nil
@@ -819,7 +825,7 @@ func StopCPUProfile() {
 	}
 	cpu.profiling = false
    
-    if isPMUEnabled {
+    if sampleInterval > 0 {
         runtime.SetCPUPMUProfile(0)
     } else {
 	    runtime.SetCPUProfileRate(0)
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index e3a7220760..9065aa3e6d 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3903,10 +3903,10 @@ func setcpuprofilerate(hz int32) {
 	_g_.m.locks--
 }
 
-func setcpupmuprofile(hz int32) {
+func setcpupmuprofile(interval int32) {
     // Force sane arguments.
-    if hz < 0 {
-        hz = 0
+    if interval > 0 && interval < 300 {
+        interval = 300
     }
     // Disable preemption, otherwise we can be rescheduled to another thread
     // that has profiling enabled.
@@ -3921,19 +3921,19 @@ func setcpupmuprofile(hz int32) {
     for !atomic.Cas(&prof.signalLock, 0, 1) {
         osyield()
     }
-    if prof.hz != hz {
-        setProcessCPUPMUProfiler(hz)
-        prof.hz = hz
+    if prof.hz != interval {
+        setProcessCPUPMUProfiler(interval)
+        prof.hz = interval
     }
     atomic.Store(&prof.signalLock, 0)
 
     lock(&sched.lock)
-    sched.profilehz = hz
+    sched.profilehz = interval
     sched.isPMUEnabled = true
     unlock(&sched.lock)
 
-    if hz != 0 {
-        setThreadCPUPMUProfiler(hz)
+    if interval != 0 {
+        setThreadCPUPMUProfiler(interval)
     }
 
     _g_.m.locks--
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 1fef94d370..82150920d8 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -251,8 +251,8 @@ func setProcessCPUProfiler(hz int32) {
 	}
 }
 
-func setProcessCPUPMUProfiler(hz int32) {
-    if hz != 0 {
+func setProcessCPUPMUProfiler(interval int32) {
+    if interval != 0 {
         // Enable the Go signal handler if not enabled.
         if atomic.Cas(&handlingSig[_SIGRTMIN + 3], 0, 1) {
             atomic.Storeuintptr(&fwdSig[_SIGRTMIN + 3], getsig(_SIGRTMIN + 3))
@@ -285,11 +285,11 @@ func setThreadCPUProfiler(hz int32) {
     _g_.m.profilehz = hz
 }
 
-func setThreadCPUPMUProfiler(hz int32) {
+func setThreadCPUPMUProfiler(interval int32) {
     _g_ := getg()
-    _g_.m.profilehz = hz
+    _g_.m.profilehz = interval
     
-    if hz == 0 { // Go routine is finished
+    if interval == 0 { // Go routine is finished
         fd := _g_.m.eventFd
         ioctl(int64(fd), PERF_EVENT_IOC_DISABLE, 0)
         closefd(fd)
@@ -298,7 +298,7 @@ func setThreadCPUPMUProfiler(hz int32) {
         attr.Type = PERF_TYPE_HARDWARE
         attr.Size = uint32(unsafe.Sizeof(attr))
         attr.Config = PERF_COUNT_HW_CPU_CYCLES
-        attr.Sample = 3e9 / uint64(hz) // match itimer's sampling rate
+        attr.Sample = uint64(interval)
         
         fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
         _g_.m.eventFd = int32(fd)

From 456f93cd185c2200ec09153cf1727b0053815ad5 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 12 Jun 2019 23:43:55 -0700
Subject: [PATCH 015/126] sth to todo

---
 src/runtime/cpuprof.go     | 4 ++--
 src/runtime/proc.go        | 4 ++--
 src/runtime/signal_unix.go | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index e6877bf3ef..65925f1947 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -82,7 +82,8 @@ func SetCPUProfileRate(hz int) {
 }
 
 func SetCPUPMUProfile(interval int) {
-    if interval > 0 && interval < 300 { // Clamp hz to something reasonable.
+    // Clamp interval to something reasonable.
+    if interval > 0 && interval < 300 {
         interval = 300
     }
     
@@ -96,7 +97,6 @@ func SetCPUPMUProfile(interval int) {
 
         cpuprof.on = true
         cpuprof.log = newProfBuf(1, 1<<17, 1<<14)
-        // hdr := [1]uint64{uint64(hz)}
         hdr := [1]uint64{uint64(interval)}
         cpuprof.log.write(nil, nanotime(), hdr[:], nil)
         setcpupmuprofile(int32(interval))
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 9065aa3e6d..931a25d9aa 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3921,14 +3921,14 @@ func setcpupmuprofile(interval int32) {
     for !atomic.Cas(&prof.signalLock, 0, 1) {
         osyield()
     }
-    if prof.hz != interval {
+    if prof.hz != interval { // Todo: declare a new field in prof, say prof.interval, and replace prof.hz with prof.interval
         setProcessCPUPMUProfiler(interval)
         prof.hz = interval
     }
     atomic.Store(&prof.signalLock, 0)
 
     lock(&sched.lock)
-    sched.profilehz = interval
+    sched.profilehz = interval // Todo: declare a new field in sched, say sched.profileInterval, and replace sched.profilehz with sched.profileInterval
     sched.isPMUEnabled = true
     unlock(&sched.lock)
 
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 82150920d8..efb31283e0 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -287,7 +287,7 @@ func setThreadCPUProfiler(hz int32) {
 
 func setThreadCPUPMUProfiler(interval int32) {
     _g_ := getg()
-    _g_.m.profilehz = interval
+    _g_.m.profilehz = interval // Todo: declare a new field in m, say m.profileInterval, and replace m.profilehz with m.profileInterval
     
     if interval == 0 { // Go routine is finished
         fd := _g_.m.eventFd

From 825961c232b074e63246c01362121f122ee9d268 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 17 Jun 2019 15:54:55 -0700
Subject: [PATCH 016/126] merge Joshua's patch

---
 src/runtime/cpuprof.go     |  16 ++---
 src/runtime/pprof/pprof.go | 122 ++++++++++++++++++++++++++++---------
 src/runtime/proc.go        |  25 ++++----
 src/runtime/signal_unix.go |  12 ++--
 4 files changed, 120 insertions(+), 55 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index 65925f1947..2291813b5e 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -81,14 +81,14 @@ func SetCPUProfileRate(hz int) {
 	unlock(&cpuprof.lock)
 }
 
-func SetCPUPMUProfile(interval int) {
-    // Clamp interval to something reasonable.
-    if interval > 0 && interval < 300 {
-        interval = 300
+func SetPMUProfilePeriod(period int) {
+    // Clamp period to something reasonable.
+    if period > 0 && period < 300 {
+        period = 300
     }
     
     lock(&cpuprof.lock)
-    if interval > 0 {
+    if period > 0 {
         if cpuprof.on || cpuprof.log != nil {
             print("runtime: cannot set cpu profile rate until previous profile has finished.\n")
             unlock(&cpuprof.lock)
@@ -97,11 +97,11 @@ func SetCPUPMUProfile(interval int) {
 
         cpuprof.on = true
         cpuprof.log = newProfBuf(1, 1<<17, 1<<14)
-        hdr := [1]uint64{uint64(interval)}
+        hdr := [1]uint64{uint64(period)}
         cpuprof.log.write(nil, nanotime(), hdr[:], nil)
-        setcpupmuprofile(int32(interval))
+        setpmuprofileperiod(int32(period))
     } else if cpuprof.on {
-        setcpupmuprofile(0)
+        setpmuprofileperiod(0)
         cpuprof.on = false
         cpuprof.addExtra()
         cpuprof.log.close()
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index d372b200e9..70bb0be5ff 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -73,12 +73,11 @@
 package pprof
 
 import (
-	"os"
     "bufio"
 	"bytes"
-	"fmt"
+	"errors"
+    "fmt"
 	"io"
-    "strconv"
 	"runtime"
 	"sort"
 	"strings"
@@ -727,9 +726,15 @@ var cpu struct {
 	sync.Mutex
 	profiling bool
 	done      chan bool
-}
 
-var sampleInterval int
+    // config state implemented by StartCPUProfile, customized by any
+	// ProfilingOptions passed to it.
+	profileHz int
+	
+    // PMU profiling config
+    pmuProfileHz int
+    pmuProfilePeriod int
+}
 
 // StartCPUProfile enables CPU profiling for the current process.
 // While profiling, the profile will be buffered and written to w.
@@ -742,7 +747,7 @@ var sampleInterval int
 // not to the one used by Go. To make it work, call os/signal.Notify
 // for syscall.SIGPROF, but note that doing so may break any profiling
 // being done by the main program.
-func StartCPUProfile(w io.Writer) error {
+func StartCPUProfile(w io.Writer, opts ...ProfilingOption) error {
 	// The runtime routines allow a variable profiling rate,
 	// but in practice operating systems cannot trigger signals
 	// at more than about 500 Hz, and our processing of the
@@ -752,7 +757,9 @@ func StartCPUProfile(w io.Writer) error {
 	// system, and a nice round number to make it easy to
 	// convert sample counts to seconds. Instead of requiring
 	// each client to specify the frequency, we hard code it.
-	const hz = 100
+    if len(opts) == 0 {
+	    opts = []ProfilingOption{WithProfilingRate(100)}
+    }
 
 	cpu.Lock()
 	defer cpu.Unlock()
@@ -764,26 +771,76 @@ func StartCPUProfile(w io.Writer) error {
 		return fmt.Errorf("cpu profiling already in use")
 	}
 	cpu.profiling = true
-    
-    if sampleInterval == 0 { // first time StartCPUProfile() is invoked
-        interval, err := strconv.Atoi(os.Getenv("PMU_SAMPLE_INTERVAL"))
-        if err == nil && interval > 0 {
-            sampleInterval = interval
-            runtime.SetCPUPMUProfile(sampleInterval)
-        } else {
-            sampleInterval = -1
-            runtime.SetCPUProfileRate(hz)
-        }
-    } else if sampleInterval < 0 {
-        runtime.SetCPUProfileRate(hz)
-    } else {
-       runtime.SetCPUPMUProfile(sampleInterval)
-    } 
-	
+
+  	for _, opt := range opts {
+	    if err := opt.apply(); err != nil {
+			return err
+		}
+	}
+
+	if cpu.profileHz != 0 {
+		runtime.SetCPUProfileRate(cpu.profileHz)
+	}
+
+    if cpu.pmuProfilePeriod != 0 {
+		runtime.SetPMUProfilePeriod(cpu.pmuProfilePeriod)
+    }
+   
+    /* 
+    if cpu.pmuProfileHz != 0 {
+		runtime.SetPMUProfileRate(cpu.pmuProfileHz)
+    }
+	*/
+
     go profileWriter(w)
 	return nil
 }
 
+func WithProfilingRate(hz int) ProfilingOption {
+	return profilingOptionFunc(func() error {
+		cpu.profileHz = hz
+		return nil
+	})
+}
+
+func WithProfilingCycleRate(hz int) ProfilingOption {
+	return profilingOptionFunc(func() error {
+		cpu.profileHz = 0 // NOTE it disable any prior WithProfilingRate
+
+		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
+			return errors.New("not implemneted")
+		}
+        cpu.pmuProfileHz = hz
+
+		return nil
+	})
+}
+
+func WithProfilingCyclePeriod(period int) ProfilingOption {
+	return profilingOptionFunc(func() error {
+		cpu.profileHz = 0 // NOTE it disable any prior WithProfilingRate
+
+		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
+			return errors.New("not implemneted")
+		}
+        cpu.pmuProfilePeriod = period
+
+		return nil
+	})
+}
+
+// func WithProfilingCacheMisses(/* TODO */) ProfilingOption
+
+// func WithPMUFancy(w io.Writer) ProfilingOption
+
+type ProfilingOption interface {
+	apply() error
+}
+
+type profilingOptionFunc func() error
+
+func (pof profilingOptionFunc) apply() error { return pof() }
+
 // readProfile, provided by the runtime, returns the next chunk of
 // binary CPU profiling stack trace data, blocking until data is available.
 // If profiling is turned off and all the profile data accumulated while it was
@@ -825,12 +882,19 @@ func StopCPUProfile() {
 	}
 	cpu.profiling = false
    
-    if sampleInterval > 0 {
-        runtime.SetCPUPMUProfile(0)
-    } else {
-	    runtime.SetCPUProfileRate(0)
-    }
-	<-cpu.done
+	if cpu.profileHz != 0 {
+		runtime.SetCPUProfileRate(0)
+	}
+
+    if cpu.pmuProfilePeriod != 0 {
+		runtime.SetPMUProfilePeriod(0)
+	}
+    /*
+    if cpu.pmuProfileHz != 0 {
+		runtime.SetPMUProfileRate(0)
+	}
+    */
+    <-cpu.done
 }
 
 // countBlock returns the number of records in the blocking profile.
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 931a25d9aa..0b0146673a 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2134,7 +2134,7 @@ func gcstopm() {
 // acquiring a P in several places.
 //
 //go:yeswritebarrierrec
-func execute(gp *g, inheritTime bool) { // psu: Is it always invoked later than setcpupmuprofile()?
+func execute(gp *g, inheritTime bool) { // psu: Is it always invoked later than setpmuprofileperiod()?
 	_g_ := getg()
 
 	casgstatus(gp, _Grunnable, _Grunning)
@@ -2152,7 +2152,7 @@ func execute(gp *g, inheritTime bool) { // psu: Is it always invoked later than
     isPMUEnabled := sched.isPMUEnabled
 	if _g_.m.profilehz != hz {
         if isPMUEnabled { 
-		    setThreadCPUPMUProfiler(hz)
+		    setThreadPMUProfiler(hz)
         } else {
 		    setThreadCPUProfiler(hz)
         }
@@ -3903,11 +3903,12 @@ func setcpuprofilerate(hz int32) {
 	_g_.m.locks--
 }
 
-func setcpupmuprofile(interval int32) {
+func setpmuprofileperiod(period int32) {
     // Force sane arguments.
-    if interval > 0 && interval < 300 {
-        interval = 300
+    if period < 0 {
+        period = 0
     }
+
     // Disable preemption, otherwise we can be rescheduled to another thread
     // that has profiling enabled.
     _g_ := getg()
@@ -3916,24 +3917,24 @@ func setcpupmuprofile(interval int32) {
     // Stop profiler on this thread so that it is safe to lock prof.
     // if a profiling signal came in while we had prof locked,
     // it would deadlock.
-    setThreadCPUPMUProfiler(0)
+    setThreadPMUProfiler(0)
 
     for !atomic.Cas(&prof.signalLock, 0, 1) {
         osyield()
     }
-    if prof.hz != interval { // Todo: declare a new field in prof, say prof.interval, and replace prof.hz with prof.interval
-        setProcessCPUPMUProfiler(interval)
-        prof.hz = interval
+    if prof.hz != period { // Todo: declare a new field in prof, say prof.period, and replace prof.hz with prof.period
+        setProcessPMUProfiler(period)
+        prof.hz = period
     }
     atomic.Store(&prof.signalLock, 0)
 
     lock(&sched.lock)
-    sched.profilehz = interval // Todo: declare a new field in sched, say sched.profileInterval, and replace sched.profilehz with sched.profileInterval
+    sched.profilehz = period // Todo: declare a new field in sched, say sched.profilePeriod, and replace sched.profilehz with sched.profilePeriod
     sched.isPMUEnabled = true
     unlock(&sched.lock)
 
-    if interval != 0 {
-        setThreadCPUPMUProfiler(interval)
+    if period != 0 {
+        setThreadPMUProfiler(period)
     }
 
     _g_.m.locks--
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index efb31283e0..7181589a92 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -251,8 +251,8 @@ func setProcessCPUProfiler(hz int32) {
 	}
 }
 
-func setProcessCPUPMUProfiler(interval int32) {
-    if interval != 0 {
+func setProcessPMUProfiler(period int32) {
+    if period != 0 {
         // Enable the Go signal handler if not enabled.
         if atomic.Cas(&handlingSig[_SIGRTMIN + 3], 0, 1) {
             atomic.Storeuintptr(&fwdSig[_SIGRTMIN + 3], getsig(_SIGRTMIN + 3))
@@ -285,11 +285,11 @@ func setThreadCPUProfiler(hz int32) {
     _g_.m.profilehz = hz
 }
 
-func setThreadCPUPMUProfiler(interval int32) {
+func setThreadPMUProfiler(period int32) {
     _g_ := getg()
-    _g_.m.profilehz = interval // Todo: declare a new field in m, say m.profileInterval, and replace m.profilehz with m.profileInterval
+    _g_.m.profilehz = period // Todo: declare a new field in m, say m.profilePeriod, and replace m.profilehz with m.profilePeriod
     
-    if interval == 0 { // Go routine is finished
+    if period == 0 { // Go routine is finished
         fd := _g_.m.eventFd
         ioctl(int64(fd), PERF_EVENT_IOC_DISABLE, 0)
         closefd(fd)
@@ -298,7 +298,7 @@ func setThreadCPUPMUProfiler(interval int32) {
         attr.Type = PERF_TYPE_HARDWARE
         attr.Size = uint32(unsafe.Sizeof(attr))
         attr.Config = PERF_COUNT_HW_CPU_CYCLES
-        attr.Sample = uint64(interval)
+        attr.Sample = uint64(period)
         
         fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
         _g_.m.eventFd = int32(fd)

From d2fcc3bae972aaaa374c1becfb2fa728194c7ce1 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 17 Jun 2019 17:23:59 -0700
Subject: [PATCH 017/126] minor

---
 src/runtime/defs_linux_amd64.go |  3 ++-
 src/runtime/os_linux.go         | 10 +++++-----
 src/runtime/pprof/pprof.go      |  2 +-
 src/runtime/signal_unix.go      |  6 +++---
 src/runtime/sys_linux_amd64.s   | 16 ++++++++--------
 5 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 00260f15a8..1695e38a3d 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -130,7 +130,8 @@ type siginfo struct {
 	si_addr  uint64
     
     // psu: an unreliable workaround and need to figure out a better solution
-    si_fd    int64 
+    // si_fd    int64 
+    si_fd    int32 
 
 }
 
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index ab9b216078..8cc582e249 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -357,15 +357,15 @@ func sigaltstack(new, old *stackt)
 func setitimer(mode int32, new, old *itimerval)
 
 //go:noescape
-func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r, r2, err int64)
+func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r int32, r2, err int64)
 
-func ioctl(fd, req, arg int64) int64
+func ioctl(fd int32, req, arg int64) int64
 
-// func fcntl(fd, cmd int64, arg interface{}) (r int64, err int64)
-func fcntl(fd, cmd, arg int64) (r, err int64)
+// func fcntl(fd, cmd int64, arg interface{}) (r int32, err int64)
+func fcntl(fd int32, cmd, arg int64) (r int64, err int64)
 
 //go:noescape
-func fcntl2(fd, cmd int64, arg *fOwnerEx) (r, err int64)
+func fcntl2(fd int32, cmd int64, arg *fOwnerEx) (r int64, err int64)
 
 //go:noescape
 func rtsigprocmask(how int32, new, old *sigset, size int32)
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 70bb0be5ff..a3569889b6 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -821,7 +821,7 @@ func WithProfilingCyclePeriod(period int) ProfilingOption {
 		cpu.profileHz = 0 // NOTE it disable any prior WithProfilingRate
 
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
-			return errors.New("not implemneted")
+            return errors.New("not implemented")
 		}
         cpu.pmuProfilePeriod = period
 
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 7181589a92..fc65cdba5d 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -291,7 +291,7 @@ func setThreadPMUProfiler(period int32) {
     
     if period == 0 { // Go routine is finished
         fd := _g_.m.eventFd
-        ioctl(int64(fd), PERF_EVENT_IOC_DISABLE, 0)
+        // ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
         closefd(fd)
     } else {
         var attr PerfEventAttr
@@ -301,8 +301,8 @@ func setThreadPMUProfiler(period int32) {
         attr.Sample = uint64(period)
         
         fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
-        _g_.m.eventFd = int32(fd)
-
+        _g_.m.eventFd = fd
+        
         r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
         fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
         fcntl(fd, /*F_SETSIG*/ 0xa, _SIGRTMIN + 3)
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index ee4df25f0e..64dd7160d1 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -168,7 +168,7 @@ TEXT runtime·setitimer(SB),NOSPLIT,$0-24
 	SYSCALL
 	RET
 
-// func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r, r2, err int64) 
+// func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r int32, r2, err int64) 
 TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
 	MOVQ	attr+0(FP), DI
 	MOVQ	pid+8(FP), SI
@@ -180,20 +180,20 @@ TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
 	JLS	ok
-	MOVQ	$-1, r+48(FP)
+	MOVL	$-1, r+48(FP)
 	MOVQ	$0, r2+56(FP)
 	NEGQ	AX
 	MOVQ	AX, err+64(FP)
 	RET
 ok:
-	MOVQ	AX, r+48(FP)
+	MOVL	AX, r+48(FP)
 	MOVQ	DX, r2+56(FP)
 	MOVQ	$0, err+64(FP)
 	RET
 
-// func ioctl(fd, req, arg int64) int64 
+// func ioctl(fd int32, req, arg int64) int64
 TEXT runtime·ioctl(SB),NOSPLIT,$0
-	MOVQ	fd+0(FP), DI 
+	MOVL	fd+0(FP), DI 
 	MOVQ	req+8(FP), SI
 	MOVQ	arg+16(FP), DX
     MOVQ	$SYS_ioctl, AX
@@ -201,9 +201,9 @@ TEXT runtime·ioctl(SB),NOSPLIT,$0
     MOVQ    AX, ret+24(FP)
 	RET
 
-// func fcntl(fd, cmd arg int64) (r int64, err int64)
+// func fcntl(fd int32, cmd arg int64) (r int64, err int64)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
-	MOVQ	fd+0(FP), DI 
+	MOVL	fd+0(FP), DI 
 	MOVQ	cmd+8(FP), SI
 	MOVQ	arg+16(FP), DX
     MOVQ	$SYS_fcntl, AX
@@ -220,7 +220,7 @@ ok:
 	RET
 
 TEXT runtime·fcntl2(SB),NOSPLIT,$0
-	MOVQ	fd+0(FP), DI 
+	MOVL	fd+0(FP), DI 
 	MOVQ	cmd+8(FP), SI
 	MOVQ	arg+16(FP), DX
     MOVQ	$SYS_fcntl, AX

From 66654bf0f1e21af184589e232e74bb52986283d9 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 17 Jun 2019 17:25:15 -0700
Subject: [PATCH 018/126] minor

---
 src/runtime/os_linux.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 8cc582e249..334a7b4223 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -361,7 +361,7 @@ func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (
 
 func ioctl(fd int32, req, arg int64) int64
 
-// func fcntl(fd, cmd int64, arg interface{}) (r int32, err int64)
+// func fcntl(fd, cmd int64, arg interface{}) (r int64, err int64)
 func fcntl(fd int32, cmd, arg int64) (r int64, err int64)
 
 //go:noescape

From e4c59d157ab6851fcedac1ff40ad57f40dbdf37f Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 17 Jun 2019 20:52:15 -0700
Subject: [PATCH 019/126] minor

---
 src/runtime/cpuprof.go     |  2 +-
 src/runtime/proc.go        | 34 ++++++++++++++++------------------
 src/runtime/runtime2.go    |  5 +++--
 src/runtime/signal_unix.go |  2 +-
 4 files changed, 21 insertions(+), 22 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index 2291813b5e..6d4af0d36c 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -121,7 +121,7 @@ func (p *cpuProfile) add(gp *g, stk []uintptr) {
 		osyield()
 	}
 
-	if prof.hz != 0 { // implies cpuprof.log != nil
+	if prof.hz != 0 || prof.period != 0 { // implies cpuprof.log != nil
 		if p.numExtra > 0 || p.lostExtra > 0 {
 			p.addExtra()
 		}
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 0b0146673a..d3cb45af1f 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2134,7 +2134,7 @@ func gcstopm() {
 // acquiring a P in several places.
 //
 //go:yeswritebarrierrec
-func execute(gp *g, inheritTime bool) { // psu: Is it always invoked later than setpmuprofileperiod()?
+func execute(gp *g, inheritTime bool) { 
 	_g_ := getg()
 
 	casgstatus(gp, _Grunnable, _Grunning)
@@ -2149,14 +2149,14 @@ func execute(gp *g, inheritTime bool) { // psu: Is it always invoked later than
 
 	// Check whether the profiler needs to be turned on or off.
 	hz := sched.profilehz
-    isPMUEnabled := sched.isPMUEnabled
+    period := sched.profilePeriod
+
 	if _g_.m.profilehz != hz {
-        if isPMUEnabled { 
-		    setThreadPMUProfiler(hz)
-        } else {
-		    setThreadCPUProfiler(hz)
-        }
-	}
+        setThreadCPUProfiler(hz)
+    }
+    if  _g_.m.profilePeriod != period {
+        setThreadPMUProfiler(period)
+    }
 
 	if trace.enabled {
 		// GoSysExit has to happen when we have a P, but before GoStart.
@@ -3623,6 +3623,7 @@ func mcount() int32 {
 var prof struct {
 	signalLock uint32
 	hz         int32
+    period     int32
 }
 
 func _System()                    { _System() }
@@ -3639,10 +3640,9 @@ var lostAtomic64Count uint64
 // Called by the signal handler, may run during STW.
 //go:nowritebarrierrec
 func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
-	if prof.hz == 0 {
+	if prof.hz == 0 && prof.period == 0 { // psu: is it safe to do so?
 		return
 	}
-
 	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
 	// runtime/internal/atomic. If SIGPROF arrives while the program is inside
 	// the critical section, it creates a deadlock (when writing the sample).
@@ -3791,7 +3791,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 		}
 	}
 
-	if prof.hz != 0 {
+	if prof.hz != 0 || prof.period != 0 {
 		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostAtomic64Count > 0 {
 			cpuprof.addLostAtomic64(lostAtomic64Count)
 			lostAtomic64Count = 0
@@ -3814,7 +3814,7 @@ var sigprofCallersUse uint32
 //go:nosplit
 //go:nowritebarrierrec
 func sigprofNonGo() {
-	if prof.hz != 0 {
+	if prof.hz != 0 || prof.period != 0 {
 		n := 0
 		for n < len(sigprofCallers) && sigprofCallers[n] != 0 {
 			n++
@@ -3831,7 +3831,7 @@ func sigprofNonGo() {
 //go:nosplit
 //go:nowritebarrierrec
 func sigprofNonGoPC(pc uintptr) {
-	if prof.hz != 0 {
+	if prof.hz != 0 || prof.period != 0 {
 		stk := []uintptr{
 			pc,
 			funcPC(_ExternalCode) + sys.PCQuantum,
@@ -3892,7 +3892,6 @@ func setcpuprofilerate(hz int32) {
 	atomic.Store(&prof.signalLock, 0)
 
 	lock(&sched.lock)
-    sched.isPMUEnabled = false
 	sched.profilehz = hz
 	unlock(&sched.lock)
 
@@ -3922,15 +3921,14 @@ func setpmuprofileperiod(period int32) {
     for !atomic.Cas(&prof.signalLock, 0, 1) {
         osyield()
     }
-    if prof.hz != period { // Todo: declare a new field in prof, say prof.period, and replace prof.hz with prof.period
+    if prof.period != period { 
         setProcessPMUProfiler(period)
-        prof.hz = period
+        prof.period = period
     }
     atomic.Store(&prof.signalLock, 0)
 
     lock(&sched.lock)
-    sched.profilehz = period // Todo: declare a new field in sched, say sched.profilePeriod, and replace sched.profilehz with sched.profilePeriod
-    sched.isPMUEnabled = true
+    sched.profilePeriod = period 
     unlock(&sched.lock)
 
     if period != 0 {
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index e83fd0769a..226d5a053e 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -473,6 +473,7 @@ type m struct {
 	locks         int32
 	dying         int32
 	profilehz     int32
+    profilePeriod int32
     eventFd       int32
     spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
@@ -519,6 +520,7 @@ type m struct {
 	dlogPerM
 
 	mOS
+	
 }
 
 type p struct {
@@ -675,8 +677,7 @@ type schedt struct {
 	safePointNote note
 
     profilehz   int32 // cpu profiling rate
-	isPMUEnabled bool
-
+    profilePeriod int32
 	procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
 }
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index fc65cdba5d..8925f3360b 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -287,7 +287,7 @@ func setThreadCPUProfiler(hz int32) {
 
 func setThreadPMUProfiler(period int32) {
     _g_ := getg()
-    _g_.m.profilehz = period // Todo: declare a new field in m, say m.profilePeriod, and replace m.profilehz with m.profilePeriod
+    _g_.m.profilePeriod = period 
     
     if period == 0 { // Go routine is finished
         fd := _g_.m.eventFd

From 31956bfd5da2a309091bcd07357b2d822e9e5774 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 18 Jun 2019 21:29:50 -0700
Subject: [PATCH 020/126] separate PMU's output from itimer's

---
 src/runtime/pprof/pprof.go | 57 +++++++++++++++-------
 src/runtime/pprof/proto.go | 97 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 135 insertions(+), 19 deletions(-)

diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index a3569889b6..ee3e3a48e5 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -777,6 +777,10 @@ func StartCPUProfile(w io.Writer, opts ...ProfilingOption) error {
 			return err
 		}
 	}
+    
+    if cpu.profileHz != 0 && cpu.pmuProfilePeriod != 0 {
+		return fmt.Errorf("itimer- and PMU-based profilings cannot work simultaneouly")
+    }
 
 	if cpu.profileHz != 0 {
 		runtime.SetCPUProfileRate(cpu.profileHz)
@@ -785,7 +789,7 @@ func StartCPUProfile(w io.Writer, opts ...ProfilingOption) error {
     if cpu.pmuProfilePeriod != 0 {
 		runtime.SetPMUProfilePeriod(cpu.pmuProfilePeriod)
     }
-   
+    
     /* 
     if cpu.pmuProfileHz != 0 {
 		runtime.SetPMUProfileRate(cpu.pmuProfileHz)
@@ -808,7 +812,7 @@ func WithProfilingCycleRate(hz int) ProfilingOption {
 		cpu.profileHz = 0 // NOTE it disable any prior WithProfilingRate
 
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
-			return errors.New("not implemneted")
+			return errors.New("not implemented")
 		}
         cpu.pmuProfileHz = hz
 
@@ -851,22 +855,39 @@ func readProfile() (data []uint64, tags []unsafe.Pointer, eof bool)
 func profileWriter(w io.Writer) {
 	b := newProfileBuilder(w)
 	var err error
-	for {
-		time.Sleep(100 * time.Millisecond)
-		data, tags, eof := readProfile()
-		if e := b.addCPUData(data, tags); e != nil && err == nil {
-			err = e
-		}
-		if eof {
-			break
-		}
-	}
-	if err != nil {
-		// The runtime should never produce an invalid or truncated profile.
-		// It drops records that can't fit into its log buffers.
-		panic("runtime/pprof: converting profile: " + err.Error())
-	}
-	b.build()
+    if cpu.profileHz != 0 {
+	    for {
+		    time.Sleep(100 * time.Millisecond)
+		    data, tags, eof := readProfile()
+		    if e := b.addCPUData(data, tags); e != nil && err == nil {
+			    err = e
+		    }
+		    if eof {
+			    break
+		    }
+	    }
+        if err != nil {
+            // The runtime should never produce an invalid or truncated profile.
+		    // It drops records that can't fit into its log buffers.
+		    panic("runtime/pprof: converting profile: " + err.Error())
+	    }
+	    b.build()
+    } else { // i.e., cpu.pmuProfilePeriod != 0
+	    for {
+		    time.Sleep(100 * time.Millisecond)
+		    data, tags, eof := readProfile()
+		    if e := b.addPMUData(data, tags); e != nil && err == nil {
+			    err = e
+		    }
+		    if eof {
+			    break
+		    }
+	    }
+        if err != nil {
+		    panic("runtime/pprof: converting profile: " + err.Error())
+	    }
+	    b.pmuBuild()
+    }
 	cpu.done <- true
 }
 
diff --git a/src/runtime/pprof/proto.go b/src/runtime/pprof/proto.go
index 7864dd79ad..a409c83350 100644
--- a/src/runtime/pprof/proto.go
+++ b/src/runtime/pprof/proto.go
@@ -33,6 +33,7 @@ type profileBuilder struct {
 	end        time.Time
 	havePeriod bool
 	period     int64
+    isPMUEnabled bool
 	m          profMap
 
 	// encoding state
@@ -374,6 +375,47 @@ func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error
 	return nil
 }
 
+func (b *profileBuilder) addPMUData(data []uint64, tags []unsafe.Pointer) error {
+	if !b.isPMUEnabled {
+		// first record is period
+		if len(data) < 3 {
+			return fmt.Errorf("truncated profile")
+		}
+		if data[0] != 3 || data[2] == 0 {
+			return fmt.Errorf("malformed profile")
+		}
+		b.isPMUEnabled = true
+		data = data[3:]
+	}
+
+	for len(data) > 0 {
+		if len(data) < 3 || data[0] > uint64(len(data)) {
+			return fmt.Errorf("truncated profile")
+		}
+		if data[0] < 3 || tags != nil && len(tags) < 1 {
+			return fmt.Errorf("malformed profile")
+		}
+		count := data[2]
+		stk := data[3:data[0]]
+		data = data[data[0]:]
+		var tag unsafe.Pointer
+		if tags != nil {
+			tag = tags[0]
+			tags = tags[1:]
+		}
+
+		if count == 0 && len(stk) == 1 {
+			// overflow record
+			count = uint64(stk[0])
+			stk = []uint64{
+				uint64(funcPC(lostProfileEvent)),
+			}
+		}
+		b.m.lookup(stk, tag).count += int64(count)
+	}
+	return nil
+}
+
 // build completes and returns the constructed profile.
 func (b *profileBuilder) build() {
 	b.end = time.Now()
@@ -381,7 +423,7 @@ func (b *profileBuilder) build() {
 	b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano())
 	if b.havePeriod { // must be CPU profile
 		b.pbValueType(tagProfile_SampleType, "samples", "count")
-		b.pbValueType(tagProfile_SampleType, "cpu", "nanoseconds")
+        b.pbValueType(tagProfile_SampleType, "cpu", "nanoseconds")
 		b.pb.int64Opt(tagProfile_DurationNanos, b.end.Sub(b.start).Nanoseconds())
 		b.pbValueType(tagProfile_PeriodType, "cpu", "nanoseconds")
 		b.pb.int64Opt(tagProfile_Period, b.period)
@@ -435,6 +477,59 @@ func (b *profileBuilder) build() {
 	b.zw.Close()
 }
 
+func (b *profileBuilder) pmuBuild() {
+     b.end = time.Now()
+
+	b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano())
+    b.pbValueType(tagProfile_SampleType, "samples", "count")
+    b.pbValueType(tagProfile_SampleType, "cpu cycles", "count")
+    // b.pb.int64Opt(tagProfile_DurationNanos, b.end.Sub(b.start).Nanoseconds())
+	
+    values := []int64{0, 0}
+	var locs []uint64
+	for e := b.m.all; e != nil; e = e.nextAll {
+		values[0] = e.count
+		values[1] = e.count * 100
+
+		var labels func()
+		if e.tag != nil {
+			labels = func() {
+				for k, v := range *(*labelMap)(e.tag) {
+					b.pbLabel(tagSample_Label, k, v, 0)
+				}
+			}
+		}
+
+		locs = locs[:0]
+		for i, addr := range e.stk {
+			// Addresses from stack traces point to the
+			// next instruction after each call, except
+			// for the leaf, which points to where the
+			// signal occurred. locForPC expects return
+			// PCs, so increment the leaf address to look
+			// like a return PC.
+			if i == 0 {
+				addr++
+			}
+			l := b.locForPC(addr)
+			if l == 0 { // runtime.goexit
+				continue
+			}
+			locs = append(locs, l)
+		}
+		b.pbSample(values, locs, labels)
+	}
+
+	for i, m := range b.mem {
+		hasFunctions := m.funcs == lookupTried // lookupTried but not lookupFailed
+		b.pbMapping(tagProfile_Mapping, uint64(i+1), uint64(m.start), uint64(m.end), m.offset, m.file, m.buildID, hasFunctions)
+	}
+	
+    b.pb.strings(tagProfile_StringTable, b.strings)
+	b.zw.Write(b.pb.data)
+	b.zw.Close()
+}
+
 // readMapping reads /proc/self/maps and writes mappings to b.pb.
 // It saves the address ranges of the mappings in b.mem for use
 // when emitting locations.

From 4966a3a752f52ebe68cb82da656a605835be24cc Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 20 Jun 2019 14:36:24 -0700
Subject: [PATCH 021/126] precise ip

---
 src/runtime/cpuprof.go                      |  9 ++--
 src/runtime/pprof/perf_event_linux_amd64.go | 51 ++++++++++++++++++++
 src/runtime/pprof/pprof.go                  | 53 ++++++++++++++++-----
 src/runtime/pprof/proto.go                  | 12 ++---
 src/runtime/proc.go                         | 20 +++++---
 src/runtime/runtime2.go                     |  5 +-
 src/runtime/signal_unix.go                  | 30 ++++++++++--
 7 files changed, 145 insertions(+), 35 deletions(-)
 create mode 100644 src/runtime/pprof/perf_event_linux_amd64.go

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index 6d4af0d36c..ee0ae142b7 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -81,8 +81,11 @@ func SetCPUProfileRate(hz int) {
 	unlock(&cpuprof.lock)
 }
 
-func SetPMUProfilePeriod(period int) {
+func SetPMUProfilePeriod(event int, period int) {
     // Clamp period to something reasonable.
+    if period < 0 {
+        period = 0
+    }
     if period > 0 && period < 300 {
         period = 300
     }
@@ -99,9 +102,9 @@ func SetPMUProfilePeriod(period int) {
         cpuprof.log = newProfBuf(1, 1<<17, 1<<14)
         hdr := [1]uint64{uint64(period)}
         cpuprof.log.write(nil, nanotime(), hdr[:], nil)
-        setpmuprofileperiod(int32(period))
+        setpmuprofileperiod(int32(event), int32(period))
     } else if cpuprof.on {
-        setpmuprofileperiod(0)
+        setpmuprofileperiod(int32(event), 0)
         cpuprof.on = false
         cpuprof.addExtra()
         cpuprof.log.close()
diff --git a/src/runtime/pprof/perf_event_linux_amd64.go b/src/runtime/pprof/perf_event_linux_amd64.go
new file mode 100644
index 0000000000..06bccd9fa0
--- /dev/null
+++ b/src/runtime/pprof/perf_event_linux_amd64.go
@@ -0,0 +1,51 @@
+// created by cgo -cdefs and then converted to Go
+// cgo -cdefs defs_linux.go defs1_linux.go
+
+package pprof
+
+const (
+	PERF_TYPE_HARDWARE   = 0x0
+	PERF_TYPE_SOFTWARE   = 0x1
+	PERF_TYPE_TRACEPOINT = 0x2
+	PERF_TYPE_HW_CACHE   = 0x3
+	PERF_TYPE_RAW        = 0x4
+	PERF_TYPE_BREAKPOINT = 0x5
+
+	PERF_COUNT_HW_CPU_CYCLES              = 0x0
+	PERF_COUNT_HW_INSTRUCTIONS            = 0x1
+	PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
+	PERF_COUNT_HW_CACHE_MISSES            = 0x3
+	PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	PERF_COUNT_HW_BRANCH_MISSES           = 0x5
+	PERF_COUNT_HW_BUS_CYCLES              = 0x6
+	PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
+
+	PERF_COUNT_HW_CACHE_L1D  = 0x0
+	PERF_COUNT_HW_CACHE_L1I  = 0x1
+	PERF_COUNT_HW_CACHE_LL   = 0x2
+	PERF_COUNT_HW_CACHE_DTLB = 0x3
+	PERF_COUNT_HW_CACHE_ITLB = 0x4
+	PERF_COUNT_HW_CACHE_BPU  = 0x5
+	PERF_COUNT_HW_CACHE_NODE = 0x6
+
+	PERF_COUNT_HW_CACHE_OP_READ     = 0x0
+	PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
+	PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
+
+	PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
+	PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
+
+	PERF_COUNT_SW_CPU_CLOCK        = 0x0
+	PERF_COUNT_SW_TASK_CLOCK       = 0x1
+	PERF_COUNT_SW_PAGE_FAULTS      = 0x2
+	PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
+	PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
+	PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
+	PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
+	PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
+	PERF_COUNT_SW_EMULATION_FAULTS = 0x8
+	PERF_COUNT_SW_DUMMY            = 0x9
+	PERF_COUNT_SW_BPF_OUTPUT       = 0xa
+)
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index ee3e3a48e5..16c92b9463 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -733,7 +733,8 @@ var cpu struct {
 	
     // PMU profiling config
     pmuProfileHz int
-    pmuProfilePeriod int
+    pmuProfileCyclePeriod int
+    pmuProfileCacheMissPeriod int
 }
 
 // StartCPUProfile enables CPU profiling for the current process.
@@ -778,21 +779,29 @@ func StartCPUProfile(w io.Writer, opts ...ProfilingOption) error {
 		}
 	}
     
-    if cpu.profileHz != 0 && cpu.pmuProfilePeriod != 0 {
-		return fmt.Errorf("itimer- and PMU-based profilings cannot work simultaneouly")
+    if cpu.profileHz != 0 && (cpu.pmuProfileCyclePeriod != 0 || cpu.pmuProfileCacheMissPeriod != 0) {
+		return fmt.Errorf("itimer- and PMU-based profilings cannot be enabled simultaneously\n")
+    }
+    
+    if cpu.pmuProfileCyclePeriod != 0 && cpu.pmuProfileCacheMissPeriod != 0 {
+		return fmt.Errorf("Only a single PMU event can be enabled simultaneously!\n")
     }
 
 	if cpu.profileHz != 0 {
 		runtime.SetCPUProfileRate(cpu.profileHz)
 	}
 
-    if cpu.pmuProfilePeriod != 0 {
-		runtime.SetPMUProfilePeriod(cpu.pmuProfilePeriod)
+    if cpu.pmuProfileCyclePeriod != 0 {
+		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CPU_CYCLES, cpu.pmuProfileCyclePeriod)
+    }
+    
+    if cpu.pmuProfileCacheMissPeriod != 0 {
+		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_MISSES, cpu.pmuProfileCacheMissPeriod)
     }
     
     /* 
     if cpu.pmuProfileHz != 0 {
-		runtime.SetPMUProfileRate(cpu.pmuProfileHz)
+		runtime.SetPMUProfileRate(PERF_COUNT_HW_CPU_CYCLES, cpu.pmuProfileCycleHz)
     }
 	*/
 
@@ -827,13 +836,24 @@ func WithProfilingCyclePeriod(period int) ProfilingOption {
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
             return errors.New("not implemented")
 		}
-        cpu.pmuProfilePeriod = period
+        cpu.pmuProfileCyclePeriod = period
 
 		return nil
 	})
 }
 
-// func WithProfilingCacheMisses(/* TODO */) ProfilingOption
+func WithProfilingCacheMissPeriod(period int) ProfilingOption {
+	return profilingOptionFunc(func() error {
+		cpu.profileHz = 0 // NOTE it disable any prior WithProfilingRate
+
+		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
+            return errors.New("not implemented")
+		}
+        cpu.pmuProfileCacheMissPeriod = period
+
+		return nil
+	})
+}
 
 // func WithPMUFancy(w io.Writer) ProfilingOption
 
@@ -872,7 +892,7 @@ func profileWriter(w io.Writer) {
 		    panic("runtime/pprof: converting profile: " + err.Error())
 	    }
 	    b.build()
-    } else { // i.e., cpu.pmuProfilePeriod != 0
+    } else { // cpu.pmuProfileCyclePeriod != 0 or cpu.pmuProfileCacheMissPeriod != 0 
 	    for {
 		    time.Sleep(100 * time.Millisecond)
 		    data, tags, eof := readProfile()
@@ -886,7 +906,12 @@ func profileWriter(w io.Writer) {
         if err != nil {
 		    panic("runtime/pprof: converting profile: " + err.Error())
 	    }
-	    b.pmuBuild()
+        if  cpu.pmuProfileCyclePeriod != 0 {
+	        b.pmuBuild("cycles")
+        }
+        if  cpu.pmuProfileCacheMissPeriod != 0 {
+	        b.pmuBuild("cache misses")
+        }
     }
 	cpu.done <- true
 }
@@ -907,8 +932,12 @@ func StopCPUProfile() {
 		runtime.SetCPUProfileRate(0)
 	}
 
-    if cpu.pmuProfilePeriod != 0 {
-		runtime.SetPMUProfilePeriod(0)
+    if cpu.pmuProfileCyclePeriod != 0 {
+		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CPU_CYCLES, 0)
+	}
+    
+    if cpu.pmuProfileCacheMissPeriod != 0 {
+		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_MISSES, 0)
 	}
     /*
     if cpu.pmuProfileHz != 0 {
diff --git a/src/runtime/pprof/proto.go b/src/runtime/pprof/proto.go
index a409c83350..b754e197ff 100644
--- a/src/runtime/pprof/proto.go
+++ b/src/runtime/pprof/proto.go
@@ -385,6 +385,7 @@ func (b *profileBuilder) addPMUData(data []uint64, tags []unsafe.Pointer) error
 			return fmt.Errorf("malformed profile")
 		}
 		b.isPMUEnabled = true
+        b.period = int64(data[2])
 		data = data[3:]
 	}
 
@@ -477,19 +478,18 @@ func (b *profileBuilder) build() {
 	b.zw.Close()
 }
 
-func (b *profileBuilder) pmuBuild() {
-     b.end = time.Now()
-
+func (b *profileBuilder) pmuBuild(event string) {
 	b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano())
     b.pbValueType(tagProfile_SampleType, "samples", "count")
-    b.pbValueType(tagProfile_SampleType, "cpu cycles", "count")
-    // b.pb.int64Opt(tagProfile_DurationNanos, b.end.Sub(b.start).Nanoseconds())
+    b.pbValueType(tagProfile_SampleType, event, "count")
+    b.pbValueType(tagProfile_PeriodType, event, "count")
+	b.pb.int64Opt(tagProfile_Period, b.period)
 	
     values := []int64{0, 0}
 	var locs []uint64
 	for e := b.m.all; e != nil; e = e.nextAll {
 		values[0] = e.count
-		values[1] = e.count * 100
+		values[1] = e.count * b.period
 
 		var labels func()
 		if e.tag != nil {
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index d3cb45af1f..e752be7324 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2150,12 +2150,17 @@ func execute(gp *g, inheritTime bool) {
 	// Check whether the profiler needs to be turned on or off.
 	hz := sched.profilehz
     period := sched.profilePeriod
+    event := sched.profileEvent
 
-	if _g_.m.profilehz != hz {
+    if _g_.m.profilehz != hz && _g_.m.profilePeriod != period  {
+       print("should never reach here!\n")
+    }
+	
+    if _g_.m.profilehz != hz {
         setThreadCPUProfiler(hz)
     }
     if  _g_.m.profilePeriod != period {
-        setThreadPMUProfiler(period)
+        setThreadPMUProfiler(event, period)
     }
 
 	if trace.enabled {
@@ -3902,7 +3907,7 @@ func setcpuprofilerate(hz int32) {
 	_g_.m.locks--
 }
 
-func setpmuprofileperiod(period int32) {
+func setpmuprofileperiod(event int32, period int32) {
     // Force sane arguments.
     if period < 0 {
         period = 0
@@ -3916,23 +3921,24 @@ func setpmuprofileperiod(period int32) {
     // Stop profiler on this thread so that it is safe to lock prof.
     // if a profiling signal came in while we had prof locked,
     // it would deadlock.
-    setThreadPMUProfiler(0)
+    setThreadPMUProfiler(event, 0)
 
     for !atomic.Cas(&prof.signalLock, 0, 1) {
         osyield()
     }
-    if prof.period != period { 
+    if prof.period != period {
         setProcessPMUProfiler(period)
         prof.period = period
     }
     atomic.Store(&prof.signalLock, 0)
 
     lock(&sched.lock)
-    sched.profilePeriod = period 
+    sched.profilePeriod = period
+    sched.profileEvent = event
     unlock(&sched.lock)
 
     if period != 0 {
-        setThreadPMUProfiler(period)
+        setThreadPMUProfiler(event, period)
     }
 
     _g_.m.locks--
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 226d5a053e..bd0b637684 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -676,8 +676,9 @@ type schedt struct {
 	safePointWait int32
 	safePointNote note
 
-    profilehz   int32 // cpu profiling rate
-    profilePeriod int32
+    profilehz      int32 // cpu profiling rate
+    profilePeriod  int32
+    profileEvent   int32
 	procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
 }
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 8925f3360b..45ca085a82 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -285,21 +285,41 @@ func setThreadCPUProfiler(hz int32) {
     _g_.m.profilehz = hz
 }
 
-func setThreadPMUProfiler(period int32) {
+func getPreciseIP() int32 {
+    if ip, ok := atoi32(gogetenv("PMU_PRECISE_IP")); ok {
+        if ip < 0 {
+            ip = 0
+        } else if ip > 3 {
+            ip = 3
+        }
+        return ip
+    }
+    return 0 // PMU_PRECISE_IP is not set
+}
+
+var  preciseIP int32 = -1
+
+func setThreadPMUProfiler(event int32, period int32) {
     _g_ := getg()
-    _g_.m.profilePeriod = period 
+    _g_.m.profilePeriod = period
     
     if period == 0 { // Go routine is finished
         fd := _g_.m.eventFd
-        // ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
         closefd(fd)
     } else {
+        if preciseIP == -1 {
+            preciseIP = getPreciseIP() // never equals to -1 again
+        }
+        
         var attr PerfEventAttr
         attr.Type = PERF_TYPE_HARDWARE
         attr.Size = uint32(unsafe.Sizeof(attr))
-        attr.Config = PERF_COUNT_HW_CPU_CYCLES
+        attr.Config = uint64(event)
         attr.Sample = uint64(period)
-        
+        attr.Bits = uint64(preciseIP) << 15 // precise ip
+        attr.Bits += 0b100000 // don't count kernel  
+        attr.Bits += 0b1000000 // don't count hypervisor
+
         fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
         _g_.m.eventFd = fd
         

From 22805e45d958945b28b2a072848bf7a0baf9f431 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 23 Jun 2019 23:24:16 -0700
Subject: [PATCH 022/126] enable multiple PMU events

---
 src/runtime/cpuprof.go           |  40 +----
 src/runtime/pmuprof.go           | 180 +++++++++++++++++++++
 src/runtime/pprof/pprof.go       | 270 ++++++++++++++++---------------
 src/runtime/pprof/proto.go       |   6 +-
 src/runtime/proc.go              | 181 ++++++++++++++++++---
 src/runtime/runtime2.go          |  13 +-
 src/runtime/signal_sighandler.go |  12 +-
 src/runtime/signal_unix.go       |  21 ++-
 8 files changed, 516 insertions(+), 207 deletions(-)
 create mode 100644 src/runtime/pmuprof.go

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index ee0ae142b7..31a9409838 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -51,6 +51,7 @@ var cpuprof cpuProfile
 // the testing package's -test.cpuprofile flag instead of calling
 // SetCPUProfileRate directly.
 func SetCPUProfileRate(hz int) {
+// func SetCPUProfileRate(hz int) {
 	// Clamp hz to something reasonable.
 	if hz < 0 {
 		hz = 0
@@ -59,7 +60,7 @@ func SetCPUProfileRate(hz int) {
 		hz = 1000000
 	}
 
-	lock(&cpuprof.lock)
+	lock(&cpuprof.lock) // cpuprof[event].lock 
 	if hz > 0 {
 		if cpuprof.on || cpuprof.log != nil {
 			print("runtime: cannot set cpu profile rate until previous profile has finished.\n")
@@ -70,48 +71,17 @@ func SetCPUProfileRate(hz int) {
 		cpuprof.on = true
 		cpuprof.log = newProfBuf(1, 1<<17, 1<<14)
 		hdr := [1]uint64{uint64(hz)}
-		cpuprof.log.write(nil, nanotime(), hdr[:], nil)
+		cpuprof.log.write(nil, nanotime(), hdr[:], nil) 
 		setcpuprofilerate(int32(hz))
 	} else if cpuprof.on {
 		setcpuprofilerate(0)
 		cpuprof.on = false
-		cpuprof.addExtra()
+		cpuprof.addExtra() // cpuprof[event].addExtra() 
 		cpuprof.log.close()
 	}
 	unlock(&cpuprof.lock)
 }
 
-func SetPMUProfilePeriod(event int, period int) {
-    // Clamp period to something reasonable.
-    if period < 0 {
-        period = 0
-    }
-    if period > 0 && period < 300 {
-        period = 300
-    }
-    
-    lock(&cpuprof.lock)
-    if period > 0 {
-        if cpuprof.on || cpuprof.log != nil {
-            print("runtime: cannot set cpu profile rate until previous profile has finished.\n")
-            unlock(&cpuprof.lock)
-            return
-        }
-
-        cpuprof.on = true
-        cpuprof.log = newProfBuf(1, 1<<17, 1<<14)
-        hdr := [1]uint64{uint64(period)}
-        cpuprof.log.write(nil, nanotime(), hdr[:], nil)
-        setpmuprofileperiod(int32(event), int32(period))
-    } else if cpuprof.on {
-        setpmuprofileperiod(int32(event), 0)
-        cpuprof.on = false
-        cpuprof.addExtra()
-        cpuprof.log.close()
-    }
-    unlock(&cpuprof.lock)
-}
-
 // add adds the stack trace to the profile.
 // It is called from signal handlers and other limited environments
 // and cannot allocate memory or acquire locks that might be
@@ -124,7 +94,7 @@ func (p *cpuProfile) add(gp *g, stk []uintptr) {
 		osyield()
 	}
 
-	if prof.hz != 0 || prof.period != 0 { // implies cpuprof.log != nil
+	if prof.hz != 0 { // implies cpuprof.log != nil
 		if p.numExtra > 0 || p.lostExtra > 0 {
 			p.addExtra()
 		}
diff --git a/src/runtime/pmuprof.go b/src/runtime/pmuprof.go
new file mode 100644
index 0000000000..a8ed27b053
--- /dev/null
+++ b/src/runtime/pmuprof.go
@@ -0,0 +1,180 @@
+// Copyright 2011 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.
+
+// CPU profiling.
+//
+// The signal handler for the profiling clock tick adds a new stack trace
+// to a log of recent traces. The log is read by a user goroutine that
+// turns it into formatted profile data. If the reader does not keep up
+// with the log, those writes will be recorded as a count of lost records.
+// The actual profile buffer is in profbuf.go.
+
+package runtime
+
+import (
+	"runtime/internal/atomic"
+	"runtime/internal/sys"
+	"unsafe"
+)
+
+const maxPMUProfStack = 64
+const maxPMUEvents  = 10
+
+type pmuProfile struct {
+	lock mutex
+	on   bool     // profiling is on
+	log  *profBuf // profile events written here
+
+	// extra holds extra stacks accumulated in addNonGo
+	// corresponding to profiling signals arriving on
+	// non-Go-created threads. Those stacks are written
+	// to log the next time a normal Go thread gets the
+	// signal handler.
+	// Assuming the stacks are 2 words each (we don't get
+	// a full traceback from those threads), plus one word
+	// size for framing, 100 Hz profiling would generate
+	// 300 words per second.
+	// Hopefully a normal Go thread will get the profiling
+	// signal at least once every few seconds.
+	extra     [1000]uintptr
+	numExtra  int
+	lostExtra uint64 // count of frames lost because extra is full
+}
+
+var pmuprof [maxPMUEvents]pmuProfile // event -> cpuProfile
+
+func SetPMUProfilePeriod(eventId int, period int) {
+    // Clamp period to something reasonable.
+    if period < 0 {
+        period = 0
+    }
+    if period > 0 && period < 300 { // follow what hpctoolkit did
+        period = 300
+    }
+    lock(&pmuprof[eventId].lock)
+    if period > 0 {
+        if pmuprof[eventId].on || pmuprof[eventId].log != nil {
+            print("runtime: cannot set pmu profile rate until previous profile has finished.\n")
+            unlock(&pmuprof[eventId].lock)
+            return
+        }
+
+        pmuprof[eventId].on = true
+        pmuprof[eventId].log = newProfBuf(1, 1<<17, 1<<14)
+        hdr := [1]uint64{uint64(period)}
+        pmuprof[eventId].log.write(nil, nanotime(), hdr[:], nil)
+        setpmuprofileperiod(int32(eventId), int32(period))
+    } else if pmuprof[eventId].on {
+        setpmuprofileperiod(int32(eventId), 0)
+        pmuprof[eventId].on = false
+        pmuprof[eventId].addExtra(eventId)
+        pmuprof[eventId].log.close()
+    }
+    unlock(&pmuprof[eventId].lock)
+}
+
+// add adds the stack trace to the profile.
+// It is called from signal handlers and other limited environments
+// and cannot allocate memory or acquire locks that might be
+// held at the time of the signal, nor can it use substantial amounts
+// of stack.
+//go:nowritebarrierrec
+func (p *pmuProfile) add(gp *g, stk []uintptr, eventId int) {
+	// Simple cas-lock to coordinate with setpmuprofilerate.
+	for !atomic.Cas(&profs[eventId].signalLock, 0, 1) {
+		osyield()
+	}
+
+	if profs[eventId].period != 0 { // implies pmuprof[eventId].log != nil
+		if p.numExtra > 0 || p.lostExtra > 0 {
+			p.addExtra(eventId)
+		}
+		hdr := [1]uint64{1}
+		// Note: write "knows" that the argument is &gp.labels,
+		// because otherwise its write barrier behavior may not
+		// be correct. See the long comment there before
+		// changing the argument here.
+		pmuprof[eventId].log.write(&gp.labels, nanotime(), hdr[:], stk)
+	}
+
+	atomic.Store(&profs[eventId].signalLock, 0)
+}
+
+// addNonGo adds the non-Go stack trace to the profile.
+// It is called from a non-Go thread, so we cannot use much stack at all,
+// nor do anything that needs a g or an m.
+// In particular, we can't call cpuprof.log.write.
+// Instead, we copy the stack into cpuprof.extra,
+// which will be drained the next time a Go thread
+// gets the signal handling event.
+//go:nosplit
+//go:nowritebarrierrec
+func (p *pmuProfile) addNonGo(stk []uintptr, eventId int) {
+	// (Other calls to add or addNonGo should be blocked out
+	// by the fact that only one SIGPROF can be handled by the
+	// process at a time. If not, this lock will serialize those too.)
+	for !atomic.Cas(&profs[eventId].signalLock, 0, 1) {
+		osyield()
+	}
+
+	if pmuprof[eventId].numExtra+1+len(stk) < len(pmuprof[eventId].extra) {
+		i := pmuprof[eventId].numExtra
+		pmuprof[eventId].extra[i] = uintptr(1 + len(stk))
+		copy(pmuprof[eventId].extra[i+1:], stk)
+		pmuprof[eventId].numExtra += 1 + len(stk)
+	} else {
+		pmuprof[eventId].lostExtra++
+	}
+
+	atomic.Store(&profs[eventId].signalLock, 0)
+}
+
+// addExtra adds the "extra" profiling events,
+// queued by addNonGo, to the profile log.
+// addExtra is called either from a signal handler on a Go thread
+// or from an ordinary goroutine; either way it can use stack
+// and has a g. The world may be stopped, though.
+func (p *pmuProfile) addExtra(eventId int) {
+	// Copy accumulated non-Go profile events.
+	hdr := [1]uint64{1}
+	for i := 0; i < p.numExtra; {
+		p.log.write(nil, 0, hdr[:], p.extra[i+1:i+int(p.extra[i])])
+		i += int(p.extra[i])
+	}
+	p.numExtra = 0
+
+	// Report any lost events.
+	if p.lostExtra > 0 {
+		hdr := [1]uint64{p.lostExtra}
+		lostStk := [2]uintptr{
+			funcPC(_LostExternalCode) + sys.PCQuantum,
+			funcPC(_ExternalCode) + sys.PCQuantum,
+		}
+		pmuprof[eventId].log.write(nil, 0, hdr[:], lostStk[:])
+		p.lostExtra = 0
+	}
+}
+
+func (p *pmuProfile) addLostAtomic64(count uint64, eventId int) {
+	hdr := [1]uint64{count}
+	lostStk := [2]uintptr{
+		funcPC(_LostSIGPROFDuringAtomic64) + sys.PCQuantum,
+		funcPC(_System) + sys.PCQuantum,
+	}
+	pmuprof[eventId].log.write(nil, 0, hdr[:], lostStk[:])
+}
+
+//go:linkname runtime_pprof_readPMUProfile runtime/pprof.readPMUProfile
+func runtime_pprof_readPMUProfile(eventId int) ([]uint64, []unsafe.Pointer, bool) {
+	lock(&pmuprof[eventId].lock)
+	log := pmuprof[eventId].log
+	unlock(&pmuprof[eventId].lock)
+	data, tags, eof := log.read(profBufBlocking)
+	if len(data) == 0 && eof {
+		lock(&pmuprof[eventId].lock)
+		pmuprof[eventId].log = nil
+		unlock(&pmuprof[eventId].lock)
+	}
+	return data, tags, eof
+}
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 16c92b9463..00ff9fb3e8 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -726,15 +726,16 @@ var cpu struct {
 	sync.Mutex
 	profiling bool
 	done      chan bool
+    profileHz int
+}
 
-    // config state implemented by StartCPUProfile, customized by any
-	// ProfilingOptions passed to it.
-	profileHz int
-	
-    // PMU profiling config
-    pmuProfileHz int
-    pmuProfileCyclePeriod int
-    pmuProfileCacheMissPeriod int
+var pmu struct {
+	sync.Mutex
+	profiling bool
+	done      chan bool
+    profileCyclePeriod int
+    profileCacheMissPeriod int
+    profileCacheRefPeriod int
 }
 
 // StartCPUProfile enables CPU profiling for the current process.
@@ -748,115 +749,114 @@ var cpu struct {
 // not to the one used by Go. To make it work, call os/signal.Notify
 // for syscall.SIGPROF, but note that doing so may break any profiling
 // being done by the main program.
-func StartCPUProfile(w io.Writer, opts ...ProfilingOption) error {
-	// The runtime routines allow a variable profiling rate,
-	// but in practice operating systems cannot trigger signals
-	// at more than about 500 Hz, and our processing of the
-	// signal is not cheap (mostly getting the stack trace).
-	// 100 Hz is a reasonable choice: it is frequent enough to
-	// produce useful data, rare enough not to bog down the
-	// system, and a nice round number to make it easy to
-	// convert sample counts to seconds. Instead of requiring
-	// each client to specify the frequency, we hard code it.
-    if len(opts) == 0 {
-	    opts = []ProfilingOption{WithProfilingRate(100)}
+func StartCPUProfile(w io.Writer, hz ...int) error {
+    // The runtime routines allow a variable profiling rate,
+    // but in practice operating systems cannot trigger signals
+    // at more than about 500 Hz, and our processing of the
+    // signal is not cheap (mostly getting the stack trace).
+    // 100 Hz is a reasonable choice: it is frequent enough to
+    // produce useful data, rare enough not to bog down the
+    // system, and a nice round number to make it easy to
+    // convert sample counts to seconds. Instead of requiring
+    // each client to specify the frequency, we hard code it.
+    if len(hz) == 0 {
+        cpu.profileHz = 100
+    } else {
+        cpu.profileHz = hz[0]
     }
 
-	cpu.Lock()
-	defer cpu.Unlock()
-	if cpu.done == nil {
-		cpu.done = make(chan bool)
+    cpu.Lock()
+    defer cpu.Unlock()
+    if cpu.done == nil {
+        cpu.done = make(chan bool)
+    }
+    // Double-check.
+    if cpu.profiling {
+        return fmt.Errorf("cpu profiling already in use")
+    }
+    cpu.profiling = true
+    runtime.SetCPUProfileRate(cpu.profileHz)
+    go profileWriter(w)
+    return nil
+}
+
+
+func StartPMUProfile(opts ...ProfilingOption) error {
+	pmu.Lock()
+	defer pmu.Unlock()
+	if pmu.done == nil {
+        pmu.done = make(chan bool, len(opts))
 	}
 	// Double-check.
-	if cpu.profiling {
-		return fmt.Errorf("cpu profiling already in use")
+	if pmu.profiling {
+		return fmt.Errorf("pmu profiling already in use")
 	}
-	cpu.profiling = true
-
-  	for _, opt := range opts {
+	pmu.profiling = true
+  	
+    for _, opt := range opts {
 	    if err := opt.apply(); err != nil {
 			return err
 		}
 	}
-    
-    if cpu.profileHz != 0 && (cpu.pmuProfileCyclePeriod != 0 || cpu.pmuProfileCacheMissPeriod != 0) {
-		return fmt.Errorf("itimer- and PMU-based profilings cannot be enabled simultaneously\n")
-    }
-    
-    if cpu.pmuProfileCyclePeriod != 0 && cpu.pmuProfileCacheMissPeriod != 0 {
-		return fmt.Errorf("Only a single PMU event can be enabled simultaneously!\n")
-    }
-
-	if cpu.profileHz != 0 {
-		runtime.SetCPUProfileRate(cpu.profileHz)
-	}
-
-    if cpu.pmuProfileCyclePeriod != 0 {
-		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CPU_CYCLES, cpu.pmuProfileCyclePeriod)
-    }
-    
-    if cpu.pmuProfileCacheMissPeriod != 0 {
-		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_MISSES, cpu.pmuProfileCacheMissPeriod)
-    }
-    
-    /* 
-    if cpu.pmuProfileHz != 0 {
-		runtime.SetPMUProfileRate(PERF_COUNT_HW_CPU_CYCLES, cpu.pmuProfileCycleHz)
-    }
-	*/
-
-    go profileWriter(w)
 	return nil
 }
 
-func WithProfilingRate(hz int) ProfilingOption {
+func WithProfilingRate(w io.Writer, hz int) ProfilingOption {
 	return profilingOptionFunc(func() error {
-		cpu.profileHz = hz
+        if hz != 0 {
+            cpu.profileHz = hz
+		    runtime.SetCPUProfileRate(cpu.profileHz)
+            go profileWriter(w)
+        }
 		return nil
 	})
 }
 
-func WithProfilingCycleRate(hz int) ProfilingOption {
+func WithProfilingCyclePeriod(w io.Writer, period int) ProfilingOption {
 	return profilingOptionFunc(func() error {
-		cpu.profileHz = 0 // NOTE it disable any prior WithProfilingRate
-
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
-			return errors.New("not implemented")
+            return errors.New("not implemented")
 		}
-        cpu.pmuProfileHz = hz
-
+        if period <= 0 {
+            return errors.New("period should be > 0")
+        }
+        pmu.profileCyclePeriod = period
+		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CPU_CYCLES, pmu.profileCyclePeriod)
+        go pmuProfileWriter(w, PERF_COUNT_HW_CPU_CYCLES, "cycles")
 		return nil
 	})
 }
 
-func WithProfilingCyclePeriod(period int) ProfilingOption {
+func WithProfilingCacheMissPeriod(w io.Writer, period int) ProfilingOption {
 	return profilingOptionFunc(func() error {
-		cpu.profileHz = 0 // NOTE it disable any prior WithProfilingRate
-
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
             return errors.New("not implemented")
 		}
-        cpu.pmuProfileCyclePeriod = period
-
+        if period <= 0 {
+            return errors.New("period should be > 0")
+        }
+        pmu.profileCacheMissPeriod = period
+		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_MISSES, pmu.profileCacheMissPeriod)
+        go pmuProfileWriter(w, PERF_COUNT_HW_CACHE_MISSES, "cache misses")
 		return nil
 	})
 }
 
-func WithProfilingCacheMissPeriod(period int) ProfilingOption {
+func WithProfilingCacheRefPeriod(w io.Writer, period int) ProfilingOption {
 	return profilingOptionFunc(func() error {
-		cpu.profileHz = 0 // NOTE it disable any prior WithProfilingRate
-
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
             return errors.New("not implemented")
 		}
-        cpu.pmuProfileCacheMissPeriod = period
-
+        if period <= 0 {
+            return errors.New("period should be > 0")
+        }
+        pmu.profileCacheRefPeriod = period
+		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_REFERENCES, pmu.profileCacheRefPeriod)
+        go pmuProfileWriter(w, PERF_COUNT_HW_CACHE_REFERENCES, "cache references")
 		return nil
 	})
 }
 
-// func WithPMUFancy(w io.Writer) ProfilingOption
-
 type ProfilingOption interface {
 	apply() error
 }
@@ -875,76 +875,90 @@ func readProfile() (data []uint64, tags []unsafe.Pointer, eof bool)
 func profileWriter(w io.Writer) {
 	b := newProfileBuilder(w)
 	var err error
-    if cpu.profileHz != 0 {
-	    for {
-		    time.Sleep(100 * time.Millisecond)
-		    data, tags, eof := readProfile()
-		    if e := b.addCPUData(data, tags); e != nil && err == nil {
-			    err = e
-		    }
-		    if eof {
-			    break
-		    }
+	for {
+	    time.Sleep(100 * time.Millisecond)
+	    data, tags, eof := readProfile()
+	    if e := b.addCPUData(data, tags); e != nil && err == nil {
+		    err = e
 	    }
-        if err != nil {
-            // The runtime should never produce an invalid or truncated profile.
-		    // It drops records that can't fit into its log buffers.
-		    panic("runtime/pprof: converting profile: " + err.Error())
+	    if eof {
+		    break
 	    }
-	    b.build()
-    } else { // cpu.pmuProfileCyclePeriod != 0 or cpu.pmuProfileCacheMissPeriod != 0 
-	    for {
-		    time.Sleep(100 * time.Millisecond)
-		    data, tags, eof := readProfile()
-		    if e := b.addPMUData(data, tags); e != nil && err == nil {
-			    err = e
-		    }
-		    if eof {
-			    break
-		    }
+	}
+    if err != nil {
+        // The runtime should never produce an invalid or truncated profile.
+	    // It drops records that can't fit into its log buffers.
+	    panic("runtime/pprof: converting profile: " + err.Error())
+	}
+	b.build()
+	cpu.done <- true
+}
+
+func readPMUProfile(eventId int) (data []uint64, tags []unsafe.Pointer, eof bool)
+
+func pmuProfileWriter(w io.Writer, eventId int, eventName string) {
+	b := newProfileBuilder(w)
+	var err error
+	for {
+	    time.Sleep(10 * time.Millisecond)
+	    data, tags, eof := readPMUProfile(eventId)
+	    // if len(data) != 0 {
+        //    fmt.Println(eventId, " ", len(data))
+        // }
+        if e := b.addPMUData(data, tags); e != nil && err == nil {
+		    err = e
 	    }
-        if err != nil {
-		    panic("runtime/pprof: converting profile: " + err.Error())
+	    if eof {
+		    break
 	    }
-        if  cpu.pmuProfileCyclePeriod != 0 {
-	        b.pmuBuild("cycles")
-        }
-        if  cpu.pmuProfileCacheMissPeriod != 0 {
-	        b.pmuBuild("cache misses")
-        }
-    }
-	cpu.done <- true
+	}
+    if err != nil {
+	    panic("runtime/pprof: converting profile: " + err.Error())
+	}
+	b.pmuBuild(eventName)
+    pmu.done <- true
 }
 
 // StopCPUProfile stops the current CPU profile, if any.
 // StopCPUProfile only returns after all the writes for the
 // profile have completed.
 func StopCPUProfile() {
-	cpu.Lock()
-	defer cpu.Unlock()
+    cpu.Lock()
+    defer cpu.Unlock()
+
+    if !cpu.profiling {
+        return
+    }
+    cpu.profiling = false
+    runtime.SetCPUProfileRate(0)
+    <-cpu.done
+}
+
 
-	if !cpu.profiling {
+func StopPMUProfile() {
+	pmu.Lock()
+	defer pmu.Unlock()
+
+	if !pmu.profiling {
 		return
 	}
-	cpu.profiling = false
+    pmu.profiling = false
    
-	if cpu.profileHz != 0 {
-		runtime.SetCPUProfileRate(0)
-	}
-
-    if cpu.pmuProfileCyclePeriod != 0 {
+    if pmu.profileCyclePeriod != 0 {
 		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CPU_CYCLES, 0)
 	}
-    
-    if cpu.pmuProfileCacheMissPeriod != 0 {
+    if pmu.profileCacheMissPeriod != 0 {
 		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_MISSES, 0)
 	}
-    /*
-    if cpu.pmuProfileHz != 0 {
-		runtime.SetPMUProfileRate(0)
+    if pmu.profileCacheRefPeriod != 0 {
+		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_REFERENCES, 0)
 	}
-    */
-    <-cpu.done
+    
+    for i := 0; i < cap(pmu.done); i++ {
+        <-pmu.done
+    } 
+
+
 }
 
 // countBlock returns the number of records in the blocking profile.
diff --git a/src/runtime/pprof/proto.go b/src/runtime/pprof/proto.go
index b754e197ff..916c967e7e 100644
--- a/src/runtime/pprof/proto.go
+++ b/src/runtime/pprof/proto.go
@@ -478,11 +478,11 @@ func (b *profileBuilder) build() {
 	b.zw.Close()
 }
 
-func (b *profileBuilder) pmuBuild(event string) {
+func (b *profileBuilder) pmuBuild(eventName string) {
 	b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano())
     b.pbValueType(tagProfile_SampleType, "samples", "count")
-    b.pbValueType(tagProfile_SampleType, event, "count")
-    b.pbValueType(tagProfile_PeriodType, event, "count")
+    b.pbValueType(tagProfile_SampleType, eventName, "count")
+    b.pbValueType(tagProfile_PeriodType, eventName, "count")
 	b.pb.int64Opt(tagProfile_Period, b.period)
 	
     values := []int64{0, 0}
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index e752be7324..793b3333c1 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2149,20 +2149,22 @@ func execute(gp *g, inheritTime bool) {
 
 	// Check whether the profiler needs to be turned on or off.
 	hz := sched.profilehz
-    period := sched.profilePeriod
-    event := sched.profileEvent
-
-    if _g_.m.profilehz != hz && _g_.m.profilePeriod != period  {
-       print("should never reach here!\n")
-    }
+    period := sched.profilePMUPeriod
+    
+    // if _g_.m.profilehz != hz && _g_.m.profilePeriod != period  {
+    //   println("should never reach here!")
+    // }
 	
     if _g_.m.profilehz != hz {
         setThreadCPUProfiler(hz)
     }
-    if  _g_.m.profilePeriod != period {
-        setThreadPMUProfiler(event, period)
+    
+    for eventId := 0; eventId < 10; eventId++ {
+        if  _g_.m.profilePMUPeriod[eventId] != period[eventId] {
+            setThreadPMUProfiler(int32(eventId), period[eventId])
+        }
     }
-
+        
 	if trace.enabled {
 		// GoSysExit has to happen when we have a P, but before GoStart.
 		// So we emit it here.
@@ -3628,6 +3630,10 @@ func mcount() int32 {
 var prof struct {
 	signalLock uint32
 	hz         int32
+}
+
+var profs [10]struct {
+	signalLock uint32
     period     int32
 }
 
@@ -3645,7 +3651,7 @@ var lostAtomic64Count uint64
 // Called by the signal handler, may run during STW.
 //go:nowritebarrierrec
 func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
-	if prof.hz == 0 && prof.period == 0 { // psu: is it safe to do so?
+	if prof.hz == 0 {
 		return
 	}
 	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
@@ -3657,7 +3663,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 	if GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm" {
 		if f := findfunc(pc); f.valid() {
 			if hasPrefix(funcname(f), "runtime/internal/atomic") {
-				lostAtomic64Count++
+				lostAtomic64Count++ // lostAtomic64Count[event]++
 				return
 			}
 		}
@@ -3796,12 +3802,112 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 		}
 	}
 
-	if prof.hz != 0 || prof.period != 0 {
+	if prof.hz != 0 {
 		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostAtomic64Count > 0 {
 			cpuprof.addLostAtomic64(lostAtomic64Count)
-			lostAtomic64Count = 0
+			lostAtomic64Count = 0 // lostAtomic64Count[event] = 0
+		}
+		cpuprof.add(gp, stk[:n]) // cpuprof[event].add(gp, stk[:n])
+	}
+	getg().m.mallocing--
+}
+
+var lostPMUAtomic64Count[10] uint64
+
+//go:nowritebarrierrec
+func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
+	if profs[eventId].period == 0 {
+		return
+	}
+	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
+	// runtime/internal/atomic. If SIGPROF arrives while the program is inside
+	// the critical section, it creates a deadlock (when writing the sample).
+	// As a workaround, create a counter of SIGPROFs while in critical section
+	// to store the count, and pass it to sigprof.add() later when SIGPROF is
+	// received from somewhere else (with _LostSIGPROFDuringAtomic64 as pc).
+	if GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm" {
+		if f := findfunc(pc); f.valid() {
+			if hasPrefix(funcname(f), "runtime/internal/atomic") {
+				lostPMUAtomic64Count[eventId]++
+				return
+			}
+		}
+	}
+
+	// Profiling runs concurrently with GC, so it must not allocate.
+	// Set a trap in case the code does allocate.
+	// Note that on windows, one thread takes profiles of all the
+	// other threads, so mp is usually not getg().m.
+	// In fact mp may not even be stopped.
+	// See golang.org/issue/17165.
+	getg().m.mallocing++
+
+	traceback := true
+	if gp == nil || sp < gp.stack.lo || gp.stack.hi < sp || setsSP(pc) || (mp != nil && mp.vdsoSP != 0) {
+		traceback = false
+	}
+	var stk [maxPMUProfStack]uintptr
+	n := 0
+	if mp.ncgo > 0 && mp.curg != nil && mp.curg.syscallpc != 0 && mp.curg.syscallsp != 0 {
+		cgoOff := 0
+		// Check cgoCallersUse to make sure that we are not
+		// interrupting other code that is fiddling with
+		// cgoCallers.  We are running in a signal handler
+		// with all signals blocked, so we don't have to worry
+		// about any other code interrupting us.
+		if atomic.Load(&mp.cgoCallersUse) == 0 && mp.cgoCallers != nil && mp.cgoCallers[0] != 0 {
+			for cgoOff < len(mp.cgoCallers) && mp.cgoCallers[cgoOff] != 0 {
+				cgoOff++
+			}
+			copy(stk[:], mp.cgoCallers[:cgoOff])
+			mp.cgoCallers[0] = 0
+		}
+
+		// Collect Go stack that leads to the cgo call.
+		n = gentraceback(mp.curg.syscallpc, mp.curg.syscallsp, 0, mp.curg, 0, &stk[cgoOff], len(stk)-cgoOff, nil, nil, 0)
+		if n > 0 {
+			n += cgoOff
+		}
+	} else if traceback {
+		n = gentraceback(pc, sp, lr, gp, 0, &stk[0], len(stk), nil, nil, _TraceTrap|_TraceJumpStack)
+	}
+
+	if n <= 0 {
+		// Normal traceback is impossible or has failed.
+		// See if it falls into several common cases.
+		n = 0
+		if (GOOS == "windows" || GOOS == "solaris" || GOOS == "illumos" || GOOS == "darwin" || GOOS == "aix") && mp.libcallg != 0 && mp.libcallpc != 0 && mp.libcallsp != 0 {
+			// Libcall, i.e. runtime syscall on windows.
+			// Collect Go stack that leads to the call.
+			n = gentraceback(mp.libcallpc, mp.libcallsp, 0, mp.libcallg.ptr(), 0, &stk[0], len(stk), nil, nil, 0)
+		}
+		if n == 0 && mp != nil && mp.vdsoSP != 0 {
+			n = gentraceback(mp.vdsoPC, mp.vdsoSP, 0, gp, 0, &stk[0], len(stk), nil, nil, _TraceTrap|_TraceJumpStack)
+		}
+		if n == 0 {
+			// If all of the above has failed, account it against abstract "System" or "GC".
+			n = 2
+			if inVDSOPage(pc) {
+				pc = funcPC(_VDSO) + sys.PCQuantum
+			} else if pc > firstmoduledata.etext {
+				// "ExternalCode" is better than "etext".
+				pc = funcPC(_ExternalCode) + sys.PCQuantum
+			}
+			stk[0] = pc
+			if mp.preemptoff != "" {
+				stk[1] = funcPC(_GC) + sys.PCQuantum
+			} else {
+				stk[1] = funcPC(_System) + sys.PCQuantum
+			}
 		}
-		cpuprof.add(gp, stk[:n])
+	}
+
+	if profs[eventId].period != 0 {
+		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostPMUAtomic64Count[eventId] > 0 {
+			pmuprof[eventId].addLostAtomic64(lostPMUAtomic64Count[eventId], eventId)
+			lostPMUAtomic64Count[eventId] = 0
+		}
+		pmuprof[eventId].add(gp, stk[:n], eventId)
 	}
 	getg().m.mallocing--
 }
@@ -3819,7 +3925,7 @@ var sigprofCallersUse uint32
 //go:nosplit
 //go:nowritebarrierrec
 func sigprofNonGo() {
-	if prof.hz != 0 || prof.period != 0 {
+	if prof.hz != 0 {
 		n := 0
 		for n < len(sigprofCallers) && sigprofCallers[n] != 0 {
 			n++
@@ -3830,13 +3936,27 @@ func sigprofNonGo() {
 	atomic.Store(&sigprofCallersUse, 0)
 }
 
+//go:nosplit
+//go:nowritebarrierrec
+func sigpmuNonGo(eventId int) {
+	if profs[eventId].period != 0 {
+		n := 0
+		for n < len(sigprofCallers) && sigprofCallers[n] != 0 {
+			n++
+		}
+		pmuprof[eventId].addNonGo(sigprofCallers[:n], eventId)
+	}
+
+	atomic.Store(&sigprofCallersUse, 0)
+}
+
 // sigprofNonGoPC is called when a profiling signal arrived on a
 // non-Go thread and we have a single PC value, not a stack trace.
 // g is nil, and what we can do is very limited.
 //go:nosplit
 //go:nowritebarrierrec
 func sigprofNonGoPC(pc uintptr) {
-	if prof.hz != 0 || prof.period != 0 {
+	if prof.hz != 0 {
 		stk := []uintptr{
 			pc,
 			funcPC(_ExternalCode) + sys.PCQuantum,
@@ -3845,6 +3965,18 @@ func sigprofNonGoPC(pc uintptr) {
 	}
 }
 
+//go:nosplit
+//go:nowritebarrierrec
+func sigpmuNonGoPC(pc uintptr, eventId int) {
+	if profs[eventId].period != 0 {
+		stk := []uintptr{
+			pc,
+			funcPC(_ExternalCode) + sys.PCQuantum,
+		}
+		pmuprof[eventId].addNonGo(stk, eventId)
+	}
+}
+
 // Reports whether a function will set the SP
 // to an absolute value. Important that
 // we don't traceback when these are at the bottom
@@ -3907,7 +4039,7 @@ func setcpuprofilerate(hz int32) {
 	_g_.m.locks--
 }
 
-func setpmuprofileperiod(event int32, period int32) {
+func setpmuprofileperiod(eventId int32, period int32) {
     // Force sane arguments.
     if period < 0 {
         period = 0
@@ -3921,24 +4053,23 @@ func setpmuprofileperiod(event int32, period int32) {
     // Stop profiler on this thread so that it is safe to lock prof.
     // if a profiling signal came in while we had prof locked,
     // it would deadlock.
-    setThreadPMUProfiler(event, 0)
+    setThreadPMUProfiler(eventId, 0)
 
-    for !atomic.Cas(&prof.signalLock, 0, 1) {
+    for !atomic.Cas(&profs[eventId].signalLock, 0, 1) {
         osyield()
     }
-    if prof.period != period {
+    if profs[eventId].period != period {
         setProcessPMUProfiler(period)
-        prof.period = period
+        profs[eventId].period = period
     }
-    atomic.Store(&prof.signalLock, 0)
+    atomic.Store(&profs[eventId].signalLock, 0)
 
     lock(&sched.lock)
-    sched.profilePeriod = period
-    sched.profileEvent = event
+    sched.profilePMUPeriod[eventId] = period
     unlock(&sched.lock)
 
     if period != 0 {
-        setThreadPMUProfiler(event, period)
+        setThreadPMUProfiler(eventId, period)
     }
 
     _g_.m.locks--
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index bd0b637684..ab1193115a 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -473,8 +473,10 @@ type m struct {
 	locks         int32
 	dying         int32
 	profilehz     int32
-    profilePeriod int32
-    eventFd       int32
+    // profilePeriod int32
+    eventFd       [10]int32
+	profilePMUPeriod [10]int32 // event Id -> period
+    eventMap        map[int32]int32 // fd->event Id
     spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack
@@ -677,9 +679,10 @@ type schedt struct {
 	safePointNote note
 
     profilehz      int32 // cpu profiling rate
-    profilePeriod  int32
-    profileEvent   int32
-	procresizetime int64 // nanotime() of last change to gomaxprocs
+    // profilePeriod  int32
+    // profileEvent   int32
+	profilePMUPeriod [10]int32 // event Id -> period
+    procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
 }
 
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index d850a61e0e..338b28a1b1 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -35,10 +35,14 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
 	c := &sigctxt{info, ctxt}
 
     if sig == _SIGRTMIN + 3 {
-        fd := info.si_fd
-        ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
-        sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
-		ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
+        fd := info.si_fd 
+        // ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
+        if _g_.m.eventMap == nil {
+            println("should not reach here")
+        }
+        eventId := _g_.m.eventMap[fd]
+        sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, int(eventId))
+		// ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
         return
 	}
     
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 45ca085a82..b7a3a884d1 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -299,12 +299,15 @@ func getPreciseIP() int32 {
 
 var  preciseIP int32 = -1
 
-func setThreadPMUProfiler(event int32, period int32) {
+func setThreadPMUProfiler(eventId int32, period int32) {
     _g_ := getg()
-    _g_.m.profilePeriod = period
+    _g_.m.profilePMUPeriod[eventId] = period
+    if _g_.m.eventMap == nil {
+        _g_.m.eventMap = make(map[int32]int32)
+    }
     
     if period == 0 { // Go routine is finished
-        fd := _g_.m.eventFd
+        fd := _g_.m.eventFd[eventId]
         closefd(fd)
     } else {
         if preciseIP == -1 {
@@ -314,15 +317,15 @@ func setThreadPMUProfiler(event int32, period int32) {
         var attr PerfEventAttr
         attr.Type = PERF_TYPE_HARDWARE
         attr.Size = uint32(unsafe.Sizeof(attr))
-        attr.Config = uint64(event)
+        attr.Config = uint64(eventId)
         attr.Sample = uint64(period)
         attr.Bits = uint64(preciseIP) << 15 // precise ip
         attr.Bits += 0b100000 // don't count kernel  
         attr.Bits += 0b1000000 // don't count hypervisor
 
         fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
-        _g_.m.eventFd = fd
-        
+        _g_.m.eventFd[eventId] = fd
+        _g_.m.eventMap[fd] = eventId
         r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
         fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
         fcntl(fd, /*F_SETSIG*/ 0xa, _SIGRTMIN + 3)
@@ -357,9 +360,13 @@ func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
 	g := getg()
 	if g == nil {
 		c := &sigctxt{info, ctx}
-		if sig == _SIGPROF || sig == _SIGRTMIN + 3 {
+		if sig == _SIGPROF {
 			sigprofNonGoPC(c.sigpc())
 			return
+		} else if sig == _SIGRTMIN + 3 {
+			// sigpmuNonGoPC(c.sigpc())
+            println("how do I know which pmu event delivers this signal")
+			return
 		}
 		c.fixsigcode(sig)
 		badsignal(uintptr(sig), c)

From 60231ccfdee6d7e76c4b12656c0ea3485ba40b40 Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Mon, 24 Jun 2019 00:07:06 -0700
Subject: [PATCH 023/126] minor

---
 src/runtime/signal_sighandler.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index 338b28a1b1..0cc47c1242 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -36,13 +36,14 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
 
     if sig == _SIGRTMIN + 3 {
         fd := info.si_fd 
-        // ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
+        ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
         if _g_.m.eventMap == nil {
             println("should not reach here")
+            return
         }
         eventId := _g_.m.eventMap[fd]
         sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, int(eventId))
-		// ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
+		ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
         return
 	}
     

From da609e8b02ae22108280b1f1ef30f3ce8e618757 Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Mon, 24 Jun 2019 00:10:18 -0700
Subject: [PATCH 024/126] minor

---
 src/runtime/signal_sighandler.go | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index 0cc47c1242..61b88e1edf 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -37,10 +37,13 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
     if sig == _SIGRTMIN + 3 {
         fd := info.si_fd 
         ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
+        
         if _g_.m.eventMap == nil {
             println("should not reach here")
+		    ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
             return
         }
+        
         eventId := _g_.m.eventMap[fd]
         sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, int(eventId))
 		ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)

From 03afced30c6978685065299f1cbe7b4147869475 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 24 Jun 2019 17:41:13 -0700
Subject: [PATCH 025/126] minor

---
 src/runtime/pmuprof.go           |  2 +-
 src/runtime/runtime2.go          | 11 ++++-------
 src/runtime/signal_sighandler.go |  2 +-
 3 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/runtime/pmuprof.go b/src/runtime/pmuprof.go
index a8ed27b053..af783d8b1b 100644
--- a/src/runtime/pmuprof.go
+++ b/src/runtime/pmuprof.go
@@ -49,7 +49,7 @@ func SetPMUProfilePeriod(eventId int, period int) {
     if period < 0 {
         period = 0
     }
-    if period > 0 && period < 300 { // follow what hpctoolkit did
+    if period > 0 && period < 300 { // follows what hpctoolkit did
         period = 300
     }
     lock(&pmuprof[eventId].lock)
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index ab1193115a..97b4d2724e 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -473,10 +473,9 @@ type m struct {
 	locks         int32
 	dying         int32
 	profilehz     int32
-    // profilePeriod int32
-    eventFd       [10]int32
-	profilePMUPeriod [10]int32 // event Id -> period
-    eventMap        map[int32]int32 // fd->event Id
+    eventFd       [maxPMUProfStack]int32
+	profilePMUPeriod [maxPMUProfStack]int32 // event Id -> period
+    eventMap      map[int32]int32 // fd->event Id
     spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack
@@ -679,9 +678,7 @@ type schedt struct {
 	safePointNote note
 
     profilehz      int32 // cpu profiling rate
-    // profilePeriod  int32
-    // profileEvent   int32
-	profilePMUPeriod [10]int32 // event Id -> period
+	profilePMUPeriod [maxPMUProfStack]int32 // event Id -> period
     procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
 }
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index 61b88e1edf..605f58c416 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -35,7 +35,7 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
 	c := &sigctxt{info, ctxt}
 
     if sig == _SIGRTMIN + 3 {
-        fd := info.si_fd 
+        fd := info.si_fd
         ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
         
         if _g_.m.eventMap == nil {

From 37ea0212a6ab55f81e5e8bf2a2abcbb23acc5481 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 2 Jul 2019 13:14:04 -0700
Subject: [PATCH 026/126] close file descriptors when finished

---
 src/runtime/pprof/pprof.go | 26 ++++++++++++++++++++------
 src/runtime/proc.go        |  2 +-
 src/runtime/signal_unix.go |  5 ++++-
 3 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 00ff9fb3e8..e95caa78f7 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -734,6 +734,7 @@ var pmu struct {
 	profiling bool
 	done      chan bool
     profileCyclePeriod int
+    profileInstPeriod int
     profileCacheMissPeriod int
     profileCacheRefPeriod int
 }
@@ -827,6 +828,21 @@ func WithProfilingCyclePeriod(w io.Writer, period int) ProfilingOption {
 	})
 }
 
+func WithProfilingInstPeriod(w io.Writer, period int) ProfilingOption {
+	return profilingOptionFunc(func() error {
+		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
+            return errors.New("not implemented")
+		}
+        if period <= 0 {
+            return errors.New("period should be > 0")
+        }
+        pmu.profileInstPeriod = period
+		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_INSTRUCTIONS, pmu.profileInstPeriod)
+        go pmuProfileWriter(w, PERF_COUNT_HW_INSTRUCTIONS, "instructions")
+		return nil
+	})
+}
+
 func WithProfilingCacheMissPeriod(w io.Writer, period int) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
@@ -900,11 +916,8 @@ func pmuProfileWriter(w io.Writer, eventId int, eventName string) {
 	b := newProfileBuilder(w)
 	var err error
 	for {
-	    time.Sleep(10 * time.Millisecond)
+	    time.Sleep(100 * time.Millisecond)
 	    data, tags, eof := readPMUProfile(eventId)
-	    // if len(data) != 0 {
-        //    fmt.Println(eventId, " ", len(data))
-        // }
         if e := b.addPMUData(data, tags); e != nil && err == nil {
 		    err = e
 	    }
@@ -947,6 +960,9 @@ func StopPMUProfile() {
     if pmu.profileCyclePeriod != 0 {
 		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CPU_CYCLES, 0)
 	}
+    if pmu.profileInstPeriod != 0 {
+		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_INSTRUCTIONS, 0)
+	}
     if pmu.profileCacheMissPeriod != 0 {
 		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_MISSES, 0)
 	}
@@ -957,8 +973,6 @@ func StopPMUProfile() {
     for i := 0; i < cap(pmu.done); i++ {
         <-pmu.done
     } 
-
-
 }
 
 // countBlock returns the number of records in the blocking profile.
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 793b3333c1..d84b666d79 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2159,7 +2159,7 @@ func execute(gp *g, inheritTime bool) {
         setThreadCPUProfiler(hz)
     }
     
-    for eventId := 0; eventId < 10; eventId++ {
+    for eventId := 0; eventId < maxPMUEvents; eventId++ {
         if  _g_.m.profilePMUPeriod[eventId] != period[eventId] {
             setThreadPMUProfiler(int32(eventId), period[eventId])
         }
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index b7a3a884d1..a446f39635 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -308,7 +308,10 @@ func setThreadPMUProfiler(eventId int32, period int32) {
     
     if period == 0 { // Go routine is finished
         fd := _g_.m.eventFd[eventId]
-        closefd(fd)
+        if _, ok := _g_.m.eventMap[fd]; ok {
+            delete(_g_.m.eventMap, fd) // delete it from the map
+            closefd(fd)
+        }
     } else {
         if preciseIP == -1 {
             preciseIP = getPreciseIP() // never equals to -1 again

From 2b986ed49dbb2c982fa916bebe78abc726f8f539 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 2 Jul 2019 20:27:19 -0700
Subject: [PATCH 027/126] removal

---
 test/pmu/cycle/test1.go  | 185 ------------------------------------
 test/pmu/cycle/test1.out |  10 --
 test/pmu/cycle/test2.go  | 193 --------------------------------------
 test/pmu/cycle/test2.out |  10 --
 test/pmu/cycle/test3.go  | 197 ---------------------------------------
 test/pmu/cycle/test3.out |  10 --
 6 files changed, 605 deletions(-)
 delete mode 100644 test/pmu/cycle/test1.go
 delete mode 100644 test/pmu/cycle/test1.out
 delete mode 100644 test/pmu/cycle/test2.go
 delete mode 100644 test/pmu/cycle/test2.out
 delete mode 100644 test/pmu/cycle/test3.go
 delete mode 100644 test/pmu/cycle/test3.out

diff --git a/test/pmu/cycle/test1.go b/test/pmu/cycle/test1.go
deleted file mode 100644
index 0a5b52dd0d..0000000000
--- a/test/pmu/cycle/test1.go
+++ /dev/null
@@ -1,185 +0,0 @@
-// run
-
-package main
-
-import (
-    "fmt"
-    "log"
-    "os"
-    "runtime/pprof"
-    "sync"
-)
-
-//go:noinline
-func fun1(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-   fmt.Println(sum)
-}
-
-//go:noinline
-func fun2(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun3(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun4(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun5(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun6(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun7(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun8(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun9(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun10(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-func main() {
-    cpuf, err := os.Create("test1_profile")
-    if err != nil {
-        log.Fatal(err)
-    }
-    pprof.StartCPUProfile(cpuf)
-    defer pprof.StopCPUProfile()
-    
-    var wg sync.WaitGroup
-    wg.Add(10) // fun1-fun10
-    defer wg.Wait() // similar to pthread_join
-    
-    go fun1(&wg)
-    go fun2(&wg)
-    go fun3(&wg)
-    go fun4(&wg)
-    go fun5(&wg)
-    go fun6(&wg)
-    go fun7(&wg)
-    go fun8(&wg)
-    go fun9(&wg)
-    go fun10(&wg)
-}
diff --git a/test/pmu/cycle/test1.out b/test/pmu/cycle/test1.out
deleted file mode 100644
index 9546171295..0000000000
--- a/test/pmu/cycle/test1.out
+++ /dev/null
@@ -1,10 +0,0 @@
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
diff --git a/test/pmu/cycle/test2.go b/test/pmu/cycle/test2.go
deleted file mode 100644
index 952f44823d..0000000000
--- a/test/pmu/cycle/test2.go
+++ /dev/null
@@ -1,193 +0,0 @@
-// run
-
-package main
-
-import (
-    "fmt"
-    "log"
-    "os"
-    "runtime/pprof"
-)
-
-//go:noinline
-func fun1(c chan int) {
-    defer close(c)
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun2(c chan int) {
-    defer close(c)
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun3(c chan int) {
-    defer close(c)
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun4(c chan int) {
-    defer close(c)
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun5(c chan int) {
-    defer close(c)
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun6(c chan int) {
-    defer close(c)
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun7(c chan int) {
-    defer close(c)
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun8(c chan int) {
-    defer close(c)
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun9(c chan int) {
-    defer close(c)
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun10(c chan int) {
-    defer close(c)
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-func waitForChans(chans ...chan int) {
-    for _, v := range chans {
-		<-v
-	}
-}
-
-func main() {
-    cpuf, err := os.Create("test2_profile")
-    if err != nil {
-        log.Fatal(err)
-    }
-    pprof.StartCPUProfile(cpuf)
-    defer pprof.StopCPUProfile()
-    
-    var chans [10]chan int
-    for i := range chans {
-        chans[i] = make(chan int)
-    }
-    
-    go fun1(chans[0])
-    go fun2(chans[1])
-    go fun3(chans[2])
-    go fun4(chans[3])
-    go fun5(chans[4])
-    go fun6(chans[5])
-    go fun7(chans[6])
-    go fun8(chans[7])
-    go fun9(chans[8])
-    go fun10(chans[9])
-
-    waitForChans(chans[0], chans[1], chans[2], chans[3], chans[4], chans[5], chans[6], chans[7], chans[8], chans[9])
-}
diff --git a/test/pmu/cycle/test2.out b/test/pmu/cycle/test2.out
deleted file mode 100644
index 9546171295..0000000000
--- a/test/pmu/cycle/test2.out
+++ /dev/null
@@ -1,10 +0,0 @@
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
diff --git a/test/pmu/cycle/test3.go b/test/pmu/cycle/test3.go
deleted file mode 100644
index e9e0e7f61d..0000000000
--- a/test/pmu/cycle/test3.go
+++ /dev/null
@@ -1,197 +0,0 @@
-// run
-
-package main
-
-import (
-    "fmt"
-    "flag"
-    "log"
-    "os"
-    "runtime/pprof"
-    "sync"
-)
-
-//go:noinline
-func fun1(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun2(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun3(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun4(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-func fun5(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun6(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun7(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun8(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-func fun9(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-//go:noinline
-func fun10(wg *sync.WaitGroup) {
-    defer wg.Done()
-
-    var sum int
-    for i:= 0; i < 500000000; i++ {
-        sum -= i / 2
-        sum *= i
-        sum /= i / 3 + 1
-        sum -= i / 4
-    }
-    
-    fmt.Println(sum)
-}
-
-var args = flag.String("p", "", "itimer() is used by default")
-
-func main() {
-   flag.Parse()
-
-   if *args != "" {
-       pprof.EnablePMU(*args)
-   }
-
-    cpuf, err := os.Create("test3_profile")
-    if err != nil {
-        log.Fatal(err)
-    }
-    pprof.StartCPUProfile(cpuf)
-    defer pprof.StopCPUProfile()
-    
-    var wg [10]sync.WaitGroup
-    for i := range wg {
-        wg[i].Add(1)
-    }
-    
-    go fun1(&(wg[0]))
-    go fun2(&(wg[1]))
-    go fun3(&(wg[2]))
-    go fun4(&(wg[3]))
-    go fun5(&(wg[4]))
-    go fun6(&(wg[5]))
-    go fun7(&(wg[6]))
-    go fun8(&(wg[7]))
-    go fun9(&(wg[8]))
-    go fun10(&(wg[9]))
-    
-    for i:= range wg {
-        wg[i].Wait()
-    }
-}
diff --git a/test/pmu/cycle/test3.out b/test/pmu/cycle/test3.out
deleted file mode 100644
index 9546171295..0000000000
--- a/test/pmu/cycle/test3.out
+++ /dev/null
@@ -1,10 +0,0 @@
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911
-44438869911

From 14b10275962252cb3fd70a9e79e3c29b22e22242 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 2 Jul 2019 20:30:50 -0700
Subject: [PATCH 028/126] test cases

---
 test/pmu/test1.go  | 189 +++++++++++++++++++++++++++++++++++++++
 test/pmu/test1.out |  10 +++
 test/pmu/test2.go  | 218 +++++++++++++++++++++++++++++++++++++++++++++
 test/pmu/test2.out |  10 +++
 4 files changed, 427 insertions(+)
 create mode 100644 test/pmu/test1.go
 create mode 100644 test/pmu/test1.out
 create mode 100644 test/pmu/test2.go
 create mode 100644 test/pmu/test2.out

diff --git a/test/pmu/test1.go b/test/pmu/test1.go
new file mode 100644
index 0000000000..412de9e4e7
--- /dev/null
+++ b/test/pmu/test1.go
@@ -0,0 +1,189 @@
+// run
+
+package main
+
+import (
+	"fmt"
+    "log"
+	"os"
+	"sync"
+	"runtime/pprof"
+)
+
+var wg sync.WaitGroup
+
+func f1() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f2() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f3() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f4() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f5() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f6() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f7() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f8() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f9() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f10() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+
+func run() error {
+    cycle, err := os.Create("cycle_profile")
+	if err != nil {
+	 return err
+	}
+    defer cycle.Close()
+    
+    if err := pprof.StartPMUProfile(pprof.WithProfilingCyclePeriod(cycle, 20000000)); err != nil {
+        return err
+	}
+	defer pprof.StopPMUProfile()
+
+    wg.Add(10)
+	defer wg.Wait()
+
+	go f1()
+	go f2()
+	go f3()
+	go f4()
+	go f5()
+	go f6()
+	go f7()
+	go f8()
+	go f9()
+	go f10()
+
+    return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/test/pmu/test1.out b/test/pmu/test1.out
new file mode 100644
index 0000000000..9546171295
--- /dev/null
+++ b/test/pmu/test1.out
@@ -0,0 +1,10 @@
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
diff --git a/test/pmu/test2.go b/test/pmu/test2.go
new file mode 100644
index 0000000000..1e1b3ed420
--- /dev/null
+++ b/test/pmu/test2.go
@@ -0,0 +1,218 @@
+// run
+
+package main
+
+import (
+	"fmt"
+    "log"
+	"os"
+	"sync"
+	"runtime/pprof"
+)
+
+var wg sync.WaitGroup
+
+func f1() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f2() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f3() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f4() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f5() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f6() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f7() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f8() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f9() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f10() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+
+func run() error {
+	itimer, err := os.Create("itimer_profile")
+	if err != nil {
+	 return err
+	}
+    defer itimer.Close()
+    
+    cycle, err := os.Create("cycle_profile")
+	if err != nil {
+	 return err
+	}
+    defer cycle.Close()
+    
+    inst, err := os.Create("inst_profile")
+	if err != nil {
+	 return err
+	}
+    defer inst.Close()
+    
+    cacheRef, err := os.Create("cacheRef_profile")
+	if err != nil {
+	 return err
+	}
+    defer cacheRef.Close()
+	
+    cacheMiss, err := os.Create("cacheMiss_profile")
+	if err != nil {
+	 return err
+	}
+    defer cacheMiss.Close()
+	
+    if err := pprof.StartCPUProfile(itimer); err != nil {
+        return err
+	}
+	defer pprof.StopCPUProfile()
+
+    if err := pprof.StartPMUProfile(pprof.WithProfilingCyclePeriod(cycle, 20000000), pprof.WithProfilingInstPeriod(inst, 20000000), pprof.WithProfilingCacheRefPeriod(cacheRef, 1000), pprof.WithProfilingCacheMissPeriod(cacheMiss, 1)); err != nil {
+        return err
+	}
+	defer pprof.StopPMUProfile()
+
+    wg.Add(10)
+	defer wg.Wait()
+
+	go f1()
+	go f2()
+	go f3()
+	go f4()
+	go f5()
+	go f6()
+	go f7()
+	go f8()
+	go f9()
+	go f10()
+
+    return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/test/pmu/test2.out b/test/pmu/test2.out
new file mode 100644
index 0000000000..9546171295
--- /dev/null
+++ b/test/pmu/test2.out
@@ -0,0 +1,10 @@
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911

From 372160413e947090b09ad012e74f0c8c2682861b Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 3 Jul 2019 10:47:04 -0700
Subject: [PATCH 029/126] redefine the interface

---
 src/runtime/defs_user_data.go    |  11 +++
 src/runtime/pmuprof.go           |  22 ++----
 src/runtime/pprof/pprof.go       | 122 ++++++++++++++++++++++---------
 src/runtime/proc.go              |  38 +++++-----
 src/runtime/runtime2.go          |   8 +-
 src/runtime/signal_sighandler.go |   4 +-
 src/runtime/signal_unix.go       |  56 +++++---------
 7 files changed, 149 insertions(+), 112 deletions(-)
 create mode 100644 src/runtime/defs_user_data.go

diff --git a/src/runtime/defs_user_data.go b/src/runtime/defs_user_data.go
new file mode 100644
index 0000000000..988fe53de5
--- /dev/null
+++ b/src/runtime/defs_user_data.go
@@ -0,0 +1,11 @@
+// created by cgo -cdefs and then converted to Go
+// cgo -cdefs defs_linux.go defs1_linux.go
+
+package runtime
+
+type PMUEvent struct {
+    Cat       uint32 // don't use type, which is a keyword reserved in golang
+    Code      uint64
+    Period    uint64
+    PreciseIP uint8
+}
diff --git a/src/runtime/pmuprof.go b/src/runtime/pmuprof.go
index af783d8b1b..f8154a32e2 100644
--- a/src/runtime/pmuprof.go
+++ b/src/runtime/pmuprof.go
@@ -44,16 +44,10 @@ type pmuProfile struct {
 
 var pmuprof [maxPMUEvents]pmuProfile // event -> cpuProfile
 
-func SetPMUProfilePeriod(eventId int, period int) {
-    // Clamp period to something reasonable.
-    if period < 0 {
-        period = 0
-    }
-    if period > 0 && period < 300 { // follows what hpctoolkit did
-        period = 300
-    }
+func SetPMUProfile(eventId int, event *PMUEvent) {
+    
     lock(&pmuprof[eventId].lock)
-    if period > 0 {
+    if event != nil {
         if pmuprof[eventId].on || pmuprof[eventId].log != nil {
             print("runtime: cannot set pmu profile rate until previous profile has finished.\n")
             unlock(&pmuprof[eventId].lock)
@@ -62,11 +56,11 @@ func SetPMUProfilePeriod(eventId int, period int) {
 
         pmuprof[eventId].on = true
         pmuprof[eventId].log = newProfBuf(1, 1<<17, 1<<14)
-        hdr := [1]uint64{uint64(period)}
+        hdr := [1]uint64{event.Period}
         pmuprof[eventId].log.write(nil, nanotime(), hdr[:], nil)
-        setpmuprofileperiod(int32(eventId), int32(period))
+        setpmuprofile(int32(eventId), event)
     } else if pmuprof[eventId].on {
-        setpmuprofileperiod(int32(eventId), 0)
+        setpmuprofile(int32(eventId), nil)
         pmuprof[eventId].on = false
         pmuprof[eventId].addExtra(eventId)
         pmuprof[eventId].log.close()
@@ -81,12 +75,12 @@ func SetPMUProfilePeriod(eventId int, period int) {
 // of stack.
 //go:nowritebarrierrec
 func (p *pmuProfile) add(gp *g, stk []uintptr, eventId int) {
-	// Simple cas-lock to coordinate with setpmuprofilerate.
+	// Simple cas-lock to coordinate with setpmuprofile.
 	for !atomic.Cas(&profs[eventId].signalLock, 0, 1) {
 		osyield()
 	}
 
-	if profs[eventId].period != 0 { // implies pmuprof[eventId].log != nil
+	if profs[eventId].event != nil { // implies pmuprof[eventId].log != nil
 		if p.numExtra > 0 || p.lostExtra > 0 {
 			p.addExtra(eventId)
 		}
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index e95caa78f7..e7f0a96e94 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -733,10 +733,6 @@ var pmu struct {
 	sync.Mutex
 	profiling bool
 	done      chan bool
-    profileCyclePeriod int
-    profileInstPeriod int
-    profileCacheMissPeriod int
-    profileCacheRefPeriod int
 }
 
 // StartCPUProfile enables CPU profiling for the current process.
@@ -813,7 +809,18 @@ func WithProfilingRate(w io.Writer, hz int) ProfilingOption {
 	})
 }
 
-func WithProfilingCyclePeriod(w io.Writer, period int) ProfilingOption {
+func getPreciseIP(preciseIP int8) uint8 {
+    if preciseIP < 0 {
+        preciseIP = 0
+    } else if preciseIP > 3 {
+        preciseIP = 3
+    }
+    return uint8(preciseIP)
+}
+
+// type PMUEvent runtime.PMUEvent
+
+func WithProfilingCycle(w io.Writer, period int64, preciseIP ...int8) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
             return errors.New("not implemented")
@@ -821,14 +828,28 @@ func WithProfilingCyclePeriod(w io.Writer, period int) ProfilingOption {
         if period <= 0 {
             return errors.New("period should be > 0")
         }
-        pmu.profileCyclePeriod = period
-		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CPU_CYCLES, pmu.profileCyclePeriod)
-        go pmuProfileWriter(w, PERF_COUNT_HW_CPU_CYCLES, "cycles")
+        
+        // Clamp period to something reasonable
+        // Refer to hpctoolkit
+        if period < 300 {
+            period = 300
+        }
+        
+        var cycle runtime.PMUEvent
+        cycle.Cat = PERF_TYPE_HARDWARE
+        cycle.Code = PERF_COUNT_HW_CPU_CYCLES
+        cycle.Period = uint64(period)
+        if len(preciseIP) != 0 {
+            cycle.PreciseIP = getPreciseIP(preciseIP[0])
+        }
+
+		runtime.SetPMUProfile(/*event ID*/ 0, &cycle)
+        go pmuProfileWriter(w, /*event ID*/ 0, "cycles")
 		return nil
 	})
 }
 
-func WithProfilingInstPeriod(w io.Writer, period int) ProfilingOption {
+func WithProfilingInstr(w io.Writer, period int64, preciseIP ...int8) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
             return errors.New("not implemented")
@@ -836,14 +857,28 @@ func WithProfilingInstPeriod(w io.Writer, period int) ProfilingOption {
         if period <= 0 {
             return errors.New("period should be > 0")
         }
-        pmu.profileInstPeriod = period
-		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_INSTRUCTIONS, pmu.profileInstPeriod)
-        go pmuProfileWriter(w, PERF_COUNT_HW_INSTRUCTIONS, "instructions")
+        
+        // Clamp period to something reasonable
+        // Refer to hpctoolkit
+        if period < 300 {
+            period = 300
+        }
+        
+        var instr runtime.PMUEvent
+        instr.Cat = PERF_TYPE_HARDWARE
+        instr.Code = PERF_COUNT_HW_INSTRUCTIONS
+        instr.Period = uint64(period)
+        if len(preciseIP) != 0 {
+            instr.PreciseIP = getPreciseIP(preciseIP[0])
+        }
+
+		runtime.SetPMUProfile(/*event ID*/ 1, &instr)
+        go pmuProfileWriter(w, /*event ID*/ 1, "instructions")
 		return nil
 	})
 }
 
-func WithProfilingCacheMissPeriod(w io.Writer, period int) ProfilingOption {
+func WithProfilingCacheRef(w io.Writer, period int64, preciseIP ...int8) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
             return errors.New("not implemented")
@@ -851,14 +886,28 @@ func WithProfilingCacheMissPeriod(w io.Writer, period int) ProfilingOption {
         if period <= 0 {
             return errors.New("period should be > 0")
         }
-        pmu.profileCacheMissPeriod = period
-		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_MISSES, pmu.profileCacheMissPeriod)
-        go pmuProfileWriter(w, PERF_COUNT_HW_CACHE_MISSES, "cache misses")
+        
+        // Clamp period to something reasonable
+        // Refer to hpctoolkit
+        if period < 300 {
+            period = 300
+        }
+        
+        var cacheRef runtime.PMUEvent
+        cacheRef.Cat = PERF_TYPE_HARDWARE
+        cacheRef.Code = PERF_COUNT_HW_CACHE_REFERENCES
+        cacheRef.Period = uint64(period)
+        if len(preciseIP) != 0 {
+            cacheRef.PreciseIP = getPreciseIP(preciseIP[0])
+        }
+
+		runtime.SetPMUProfile(/*event ID*/ 2, &cacheRef)
+        go pmuProfileWriter(w, /*event ID*/ 2, "cache references")
 		return nil
 	})
 }
 
-func WithProfilingCacheRefPeriod(w io.Writer, period int) ProfilingOption {
+func WithProfilingCacheMiss(w io.Writer, period int64, preciseIP ...int8) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
             return errors.New("not implemented")
@@ -866,9 +915,23 @@ func WithProfilingCacheRefPeriod(w io.Writer, period int) ProfilingOption {
         if period <= 0 {
             return errors.New("period should be > 0")
         }
-        pmu.profileCacheRefPeriod = period
-		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_REFERENCES, pmu.profileCacheRefPeriod)
-        go pmuProfileWriter(w, PERF_COUNT_HW_CACHE_REFERENCES, "cache references")
+        
+        // Clamp period to something reasonable
+        // Refer to hpctoolkit
+        if period < 300 {
+            period = 300
+        }
+        
+        var cacheMiss runtime.PMUEvent
+        cacheMiss.Cat = PERF_TYPE_HARDWARE
+        cacheMiss.Code = PERF_COUNT_HW_CACHE_MISSES
+        cacheMiss.Period = uint64(period)
+        if len(preciseIP) != 0 {
+            cacheMiss.PreciseIP = getPreciseIP(preciseIP[0])
+        }
+
+		runtime.SetPMUProfile(/*event ID*/ 3, &cacheMiss)
+        go pmuProfileWriter(w, /*event ID*/ 3, "cache misses")
 		return nil
 	})
 }
@@ -916,7 +979,7 @@ func pmuProfileWriter(w io.Writer, eventId int, eventName string) {
 	b := newProfileBuilder(w)
 	var err error
 	for {
-	    time.Sleep(100 * time.Millisecond)
+	    time.Sleep(10 * time.Millisecond)
 	    data, tags, eof := readPMUProfile(eventId)
         if e := b.addPMUData(data, tags); e != nil && err == nil {
 		    err = e
@@ -947,7 +1010,6 @@ func StopCPUProfile() {
     <-cpu.done
 }
 
-
 func StopPMUProfile() {
 	pmu.Lock()
 	defer pmu.Unlock()
@@ -957,22 +1019,12 @@ func StopPMUProfile() {
 	}
     pmu.profiling = false
    
-    if pmu.profileCyclePeriod != 0 {
-		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CPU_CYCLES, 0)
-	}
-    if pmu.profileInstPeriod != 0 {
-		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_INSTRUCTIONS, 0)
-	}
-    if pmu.profileCacheMissPeriod != 0 {
-		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_MISSES, 0)
-	}
-    if pmu.profileCacheRefPeriod != 0 {
-		runtime.SetPMUProfilePeriod(PERF_COUNT_HW_CACHE_REFERENCES, 0)
+    for i := 0; i < cap(pmu.done); i++ {
+        runtime.SetPMUProfile(i, nil)
 	}
-    
     for i := 0; i < cap(pmu.done); i++ {
         <-pmu.done
-    } 
+    }
 }
 
 // countBlock returns the number of records in the blocking profile.
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index d84b666d79..38b08d8ff7 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2149,7 +2149,7 @@ func execute(gp *g, inheritTime bool) {
 
 	// Check whether the profiler needs to be turned on or off.
 	hz := sched.profilehz
-    period := sched.profilePMUPeriod
+    events := sched.events
     
     // if _g_.m.profilehz != hz && _g_.m.profilePeriod != period  {
     //   println("should never reach here!")
@@ -2160,8 +2160,8 @@ func execute(gp *g, inheritTime bool) {
     }
     
     for eventId := 0; eventId < maxPMUEvents; eventId++ {
-        if  _g_.m.profilePMUPeriod[eventId] != period[eventId] {
-            setThreadPMUProfiler(int32(eventId), period[eventId])
+        if  _g_.m.events[eventId] != events[eventId] {
+            setThreadPMUProfiler(int32(eventId), events[eventId])
         }
     }
         
@@ -3632,9 +3632,9 @@ var prof struct {
 	hz         int32
 }
 
-var profs [10]struct {
+var profs [maxPMUEvents]struct { // TODO: come up with a bettter name
 	signalLock uint32
-    period     int32
+    event     *PMUEvent
 }
 
 func _System()                    { _System() }
@@ -3816,7 +3816,7 @@ var lostPMUAtomic64Count[10] uint64
 
 //go:nowritebarrierrec
 func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
-	if profs[eventId].period == 0 {
+	if profs[eventId].event == nil {
 		return
 	}
 	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
@@ -3902,7 +3902,7 @@ func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
 		}
 	}
 
-	if profs[eventId].period != 0 {
+	if profs[eventId].event != nil {
 		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostPMUAtomic64Count[eventId] > 0 {
 			pmuprof[eventId].addLostAtomic64(lostPMUAtomic64Count[eventId], eventId)
 			lostPMUAtomic64Count[eventId] = 0
@@ -3939,7 +3939,7 @@ func sigprofNonGo() {
 //go:nosplit
 //go:nowritebarrierrec
 func sigpmuNonGo(eventId int) {
-	if profs[eventId].period != 0 {
+	if profs[eventId].event != nil {
 		n := 0
 		for n < len(sigprofCallers) && sigprofCallers[n] != 0 {
 			n++
@@ -3968,7 +3968,7 @@ func sigprofNonGoPC(pc uintptr) {
 //go:nosplit
 //go:nowritebarrierrec
 func sigpmuNonGoPC(pc uintptr, eventId int) {
-	if profs[eventId].period != 0 {
+	if profs[eventId].event != nil {
 		stk := []uintptr{
 			pc,
 			funcPC(_ExternalCode) + sys.PCQuantum,
@@ -4039,11 +4039,7 @@ func setcpuprofilerate(hz int32) {
 	_g_.m.locks--
 }
 
-func setpmuprofileperiod(eventId int32, period int32) {
-    // Force sane arguments.
-    if period < 0 {
-        period = 0
-    }
+func setpmuprofile(eventId int32, event *PMUEvent) {
 
     // Disable preemption, otherwise we can be rescheduled to another thread
     // that has profiling enabled.
@@ -4053,23 +4049,23 @@ func setpmuprofileperiod(eventId int32, period int32) {
     // Stop profiler on this thread so that it is safe to lock prof.
     // if a profiling signal came in while we had prof locked,
     // it would deadlock.
-    setThreadPMUProfiler(eventId, 0)
+    setThreadPMUProfiler(eventId, nil)
 
     for !atomic.Cas(&profs[eventId].signalLock, 0, 1) {
         osyield()
     }
-    if profs[eventId].period != period {
-        setProcessPMUProfiler(period)
-        profs[eventId].period = period
+    if profs[eventId].event != event {
+        setProcessPMUProfiler(event)
+        profs[eventId].event = event
     }
     atomic.Store(&profs[eventId].signalLock, 0)
 
     lock(&sched.lock)
-    sched.profilePMUPeriod[eventId] = period
+    sched.events[eventId] = event
     unlock(&sched.lock)
 
-    if period != 0 {
-        setThreadPMUProfiler(eventId, period)
+    if event != nil {
+        setThreadPMUProfiler(eventId, event)
     }
 
     _g_.m.locks--
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 97b4d2724e..cfda44cc3d 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -473,9 +473,9 @@ type m struct {
 	locks         int32
 	dying         int32
 	profilehz     int32
-    eventFd       [maxPMUProfStack]int32
-	profilePMUPeriod [maxPMUProfStack]int32 // event Id -> period
-    eventMap      map[int32]int32 // fd->event Id
+    fds           [maxPMUProfStack]int32
+	events       [maxPMUProfStack]*PMUEvent
+    fdToEventIdMap      map[int32]int32 // fd->event Id
     spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack
@@ -678,7 +678,7 @@ type schedt struct {
 	safePointNote note
 
     profilehz      int32 // cpu profiling rate
-	profilePMUPeriod [maxPMUProfStack]int32 // event Id -> period
+	events         [maxPMUProfStack]*PMUEvent 
     procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
 }
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index 605f58c416..0d9ed2ae00 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -38,13 +38,13 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
         fd := info.si_fd
         ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
         
-        if _g_.m.eventMap == nil {
+        if _g_.m.fdToEventIdMap == nil {
             println("should not reach here")
 		    ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
             return
         }
         
-        eventId := _g_.m.eventMap[fd]
+        eventId := _g_.m.fdToEventIdMap[fd]
         sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, int(eventId))
 		ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
         return
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index a446f39635..bb5acc147d 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -251,8 +251,8 @@ func setProcessCPUProfiler(hz int32) {
 	}
 }
 
-func setProcessPMUProfiler(period int32) {
-    if period != 0 {
+func setProcessPMUProfiler(event *PMUEvent) {
+    if event != nil {
         // Enable the Go signal handler if not enabled.
         if atomic.Cas(&handlingSig[_SIGRTMIN + 3], 0, 1) {
             atomic.Storeuintptr(&fwdSig[_SIGRTMIN + 3], getsig(_SIGRTMIN + 3))
@@ -285,50 +285,33 @@ func setThreadCPUProfiler(hz int32) {
     _g_.m.profilehz = hz
 }
 
-func getPreciseIP() int32 {
-    if ip, ok := atoi32(gogetenv("PMU_PRECISE_IP")); ok {
-        if ip < 0 {
-            ip = 0
-        } else if ip > 3 {
-            ip = 3
-        }
-        return ip
-    }
-    return 0 // PMU_PRECISE_IP is not set
-}
-
-var  preciseIP int32 = -1
-
-func setThreadPMUProfiler(eventId int32, period int32) {
+func setThreadPMUProfiler(eventId int32, event *PMUEvent) {
     _g_ := getg()
-    _g_.m.profilePMUPeriod[eventId] = period
-    if _g_.m.eventMap == nil {
-        _g_.m.eventMap = make(map[int32]int32)
+    if _g_.m.fdToEventIdMap == nil {
+        _g_.m.fdToEventIdMap = make(map[int32]int32)
     }
     
-    if period == 0 { // Go routine is finished
-        fd := _g_.m.eventFd[eventId]
-        if _, ok := _g_.m.eventMap[fd]; ok {
-            delete(_g_.m.eventMap, fd) // delete it from the map
-            closefd(fd)
-        }
+    if event == nil { // Go routine is finished
+        if _g_.m.events[eventId] != nil {
+            fd := _g_.m.fds[eventId]
+            if _, ok := _g_.m.fdToEventIdMap[fd]; ok {
+                delete(_g_.m.fdToEventIdMap, fd) // delete it from the map
+                closefd(fd)
+            }
+         }
     } else {
-        if preciseIP == -1 {
-            preciseIP = getPreciseIP() // never equals to -1 again
-        }
-        
         var attr PerfEventAttr
-        attr.Type = PERF_TYPE_HARDWARE
+        attr.Type = event.Cat
         attr.Size = uint32(unsafe.Sizeof(attr))
-        attr.Config = uint64(eventId)
-        attr.Sample = uint64(period)
-        attr.Bits = uint64(preciseIP) << 15 // precise ip
+        attr.Config = event.Code
+        attr.Sample = event.Period
+        attr.Bits = uint64(event.PreciseIP) << 15 // precise ip
         attr.Bits += 0b100000 // don't count kernel  
         attr.Bits += 0b1000000 // don't count hypervisor
 
         fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
-        _g_.m.eventFd[eventId] = fd
-        _g_.m.eventMap[fd] = eventId
+        _g_.m.fds[eventId] = fd
+        _g_.m.fdToEventIdMap[fd] = eventId
         r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
         fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
         fcntl(fd, /*F_SETSIG*/ 0xa, _SIGRTMIN + 3)
@@ -336,6 +319,7 @@ func setThreadPMUProfiler(eventId int32, period int32) {
         fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, int32(gettid())}
         fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx)
     }
+    _g_.m.events[eventId] = event
 }
 
 func sigpipe() {

From 7362ce085af4078cda11b369661f52c30fba2074 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 3 Jul 2019 10:47:38 -0700
Subject: [PATCH 030/126] test cases

---
 test/pmu/test1.go | 2 +-
 test/pmu/test2.go | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/pmu/test1.go b/test/pmu/test1.go
index 412de9e4e7..8b14f0daf2 100644
--- a/test/pmu/test1.go
+++ b/test/pmu/test1.go
@@ -160,7 +160,7 @@ func run() error {
 	}
     defer cycle.Close()
     
-    if err := pprof.StartPMUProfile(pprof.WithProfilingCyclePeriod(cycle, 20000000)); err != nil {
+    if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycle, 20000000)); err != nil {
         return err
 	}
 	defer pprof.StopPMUProfile()
diff --git a/test/pmu/test2.go b/test/pmu/test2.go
index 1e1b3ed420..d8eaa8849b 100644
--- a/test/pmu/test2.go
+++ b/test/pmu/test2.go
@@ -166,11 +166,11 @@ func run() error {
 	}
     defer cycle.Close()
     
-    inst, err := os.Create("inst_profile")
+    instr, err := os.Create("instr_profile")
 	if err != nil {
 	 return err
 	}
-    defer inst.Close()
+    defer instr.Close()
     
     cacheRef, err := os.Create("cacheRef_profile")
 	if err != nil {
@@ -189,7 +189,7 @@ func run() error {
 	}
 	defer pprof.StopCPUProfile()
 
-    if err := pprof.StartPMUProfile(pprof.WithProfilingCyclePeriod(cycle, 20000000), pprof.WithProfilingInstPeriod(inst, 20000000), pprof.WithProfilingCacheRefPeriod(cacheRef, 1000), pprof.WithProfilingCacheMissPeriod(cacheMiss, 1)); err != nil {
+    if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycle, 20000000), pprof.WithProfilingInstr(instr, 20000000), pprof.WithProfilingCacheRef(cacheRef, 1000), pprof.WithProfilingCacheMiss(cacheMiss, 1)); err != nil {
         return err
 	}
 	defer pprof.StopPMUProfile()

From 84264fe2bf842b952db6d028e72a55b5881c55fa Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 3 Jul 2019 13:11:28 -0700
Subject: [PATCH 031/126] removal

---
 src/runtime/pprof/perf_event_linux_amd64.go | 51 ---------------------
 1 file changed, 51 deletions(-)
 delete mode 100644 src/runtime/pprof/perf_event_linux_amd64.go

diff --git a/src/runtime/pprof/perf_event_linux_amd64.go b/src/runtime/pprof/perf_event_linux_amd64.go
deleted file mode 100644
index 06bccd9fa0..0000000000
--- a/src/runtime/pprof/perf_event_linux_amd64.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// created by cgo -cdefs and then converted to Go
-// cgo -cdefs defs_linux.go defs1_linux.go
-
-package pprof
-
-const (
-	PERF_TYPE_HARDWARE   = 0x0
-	PERF_TYPE_SOFTWARE   = 0x1
-	PERF_TYPE_TRACEPOINT = 0x2
-	PERF_TYPE_HW_CACHE   = 0x3
-	PERF_TYPE_RAW        = 0x4
-	PERF_TYPE_BREAKPOINT = 0x5
-
-	PERF_COUNT_HW_CPU_CYCLES              = 0x0
-	PERF_COUNT_HW_INSTRUCTIONS            = 0x1
-	PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
-	PERF_COUNT_HW_CACHE_MISSES            = 0x3
-	PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
-	PERF_COUNT_HW_BRANCH_MISSES           = 0x5
-	PERF_COUNT_HW_BUS_CYCLES              = 0x6
-	PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
-	PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
-	PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
-
-	PERF_COUNT_HW_CACHE_L1D  = 0x0
-	PERF_COUNT_HW_CACHE_L1I  = 0x1
-	PERF_COUNT_HW_CACHE_LL   = 0x2
-	PERF_COUNT_HW_CACHE_DTLB = 0x3
-	PERF_COUNT_HW_CACHE_ITLB = 0x4
-	PERF_COUNT_HW_CACHE_BPU  = 0x5
-	PERF_COUNT_HW_CACHE_NODE = 0x6
-
-	PERF_COUNT_HW_CACHE_OP_READ     = 0x0
-	PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
-	PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
-
-	PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
-	PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
-
-	PERF_COUNT_SW_CPU_CLOCK        = 0x0
-	PERF_COUNT_SW_TASK_CLOCK       = 0x1
-	PERF_COUNT_SW_PAGE_FAULTS      = 0x2
-	PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
-	PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
-	PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
-	PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
-	PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
-	PERF_COUNT_SW_EMULATION_FAULTS = 0x8
-	PERF_COUNT_SW_DUMMY            = 0x9
-	PERF_COUNT_SW_BPF_OUTPUT       = 0xa
-)

From 28ccd61de301e86c14419291b501d78fa90f0332 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 3 Jul 2019 13:11:41 -0700
Subject: [PATCH 032/126] minor

---
 src/runtime/pprof/pprof.go | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index e7f0a96e94..03ad427690 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -818,8 +818,6 @@ func getPreciseIP(preciseIP int8) uint8 {
     return uint8(preciseIP)
 }
 
-// type PMUEvent runtime.PMUEvent
-
 func WithProfilingCycle(w io.Writer, period int64, preciseIP ...int8) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
@@ -836,8 +834,8 @@ func WithProfilingCycle(w io.Writer, period int64, preciseIP ...int8) ProfilingO
         }
         
         var cycle runtime.PMUEvent
-        cycle.Cat = PERF_TYPE_HARDWARE
-        cycle.Code = PERF_COUNT_HW_CPU_CYCLES
+        cycle.Cat = runtime.PERF_TYPE_HARDWARE
+        cycle.Code = runtime.PERF_COUNT_HW_CPU_CYCLES
         cycle.Period = uint64(period)
         if len(preciseIP) != 0 {
             cycle.PreciseIP = getPreciseIP(preciseIP[0])
@@ -865,8 +863,8 @@ func WithProfilingInstr(w io.Writer, period int64, preciseIP ...int8) ProfilingO
         }
         
         var instr runtime.PMUEvent
-        instr.Cat = PERF_TYPE_HARDWARE
-        instr.Code = PERF_COUNT_HW_INSTRUCTIONS
+        instr.Cat = runtime.PERF_TYPE_HARDWARE
+        instr.Code = runtime.PERF_COUNT_HW_INSTRUCTIONS
         instr.Period = uint64(period)
         if len(preciseIP) != 0 {
             instr.PreciseIP = getPreciseIP(preciseIP[0])
@@ -894,8 +892,8 @@ func WithProfilingCacheRef(w io.Writer, period int64, preciseIP ...int8) Profili
         }
         
         var cacheRef runtime.PMUEvent
-        cacheRef.Cat = PERF_TYPE_HARDWARE
-        cacheRef.Code = PERF_COUNT_HW_CACHE_REFERENCES
+        cacheRef.Cat = runtime.PERF_TYPE_HARDWARE
+        cacheRef.Code = runtime.PERF_COUNT_HW_CACHE_REFERENCES
         cacheRef.Period = uint64(period)
         if len(preciseIP) != 0 {
             cacheRef.PreciseIP = getPreciseIP(preciseIP[0])
@@ -923,8 +921,8 @@ func WithProfilingCacheMiss(w io.Writer, period int64, preciseIP ...int8) Profil
         }
         
         var cacheMiss runtime.PMUEvent
-        cacheMiss.Cat = PERF_TYPE_HARDWARE
-        cacheMiss.Code = PERF_COUNT_HW_CACHE_MISSES
+        cacheMiss.Cat = runtime.PERF_TYPE_HARDWARE
+        cacheMiss.Code = runtime.PERF_COUNT_HW_CACHE_MISSES
         cacheMiss.Period = uint64(period)
         if len(preciseIP) != 0 {
             cacheMiss.PreciseIP = getPreciseIP(preciseIP[0])

From 020bcba2991b59020c7e89e1705e989a2ffa83f4 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 3 Jul 2019 13:37:23 -0700
Subject: [PATCH 033/126] minor

---
 src/runtime/pprof/pprof.go | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 03ad427690..d656ed3d84 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -798,17 +798,6 @@ func StartPMUProfile(opts ...ProfilingOption) error {
 	return nil
 }
 
-func WithProfilingRate(w io.Writer, hz int) ProfilingOption {
-	return profilingOptionFunc(func() error {
-        if hz != 0 {
-            cpu.profileHz = hz
-		    runtime.SetCPUProfileRate(cpu.profileHz)
-            go profileWriter(w)
-        }
-		return nil
-	})
-}
-
 func getPreciseIP(preciseIP int8) uint8 {
     if preciseIP < 0 {
         preciseIP = 0

From 697954f9c1c40ce96315651da6f3c980bb5cd5b0 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 7 Jul 2019 21:06:09 -0700
Subject: [PATCH 034/126] refactoring

---
 src/runtime/defs_linux_amd64.go  |  15 +++-
 src/runtime/defs_pmu.go          |  44 ++++++++++
 src/runtime/os_linux.go          |   2 +-
 src/runtime/pmuprof.go           |  18 ++--
 src/runtime/pprof/pprof.go       | 142 +++++++++++++------------------
 src/runtime/proc.go              |  38 ++++-----
 src/runtime/runtime2.go          |   8 +-
 src/runtime/signal_sighandler.go |  21 +++--
 src/runtime/signal_unix.go       |  82 +++++++++---------
 9 files changed, 196 insertions(+), 174 deletions(-)
 create mode 100644 src/runtime/defs_pmu.go

diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 1695e38a3d..b7924ee29c 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -57,7 +57,7 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
-    _SIGRTMIN  = 0x22
+    _SIGPMU    = 0x25
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
@@ -394,8 +394,7 @@ const (
     PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
 )
 
-
-type PerfEventAttr struct {
+type perfEventAttr struct {
     Type               uint32
     Size               uint32
     Config             uint64
@@ -421,3 +420,13 @@ type fOwnerEx struct {
     Pid int32
 
 }
+
+var perfEventOpt = []struct {
+    Type    uint32
+    Config  uint64
+} {
+    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES},
+    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS},
+    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES},
+    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES},
+}
diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
new file mode 100644
index 0000000000..6030a5061c
--- /dev/null
+++ b/src/runtime/defs_pmu.go
@@ -0,0 +1,44 @@
+// created by cgo -cdefs and then converted to Go
+// cgo -cdefs defs_linux.go defs1_linux.go
+
+package runtime
+
+const (
+	GO_COUNT_HW_CPU_CYCLES              = 0x0
+    GO_COUNT_HW_INSTRUCTIONS            = 0x1
+	GO_COUNT_HW_CACHE_REFERENCES        = 0x2
+	GO_COUNT_HW_CACHE_MISSES            = 0x3
+	GO_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	GO_COUNT_HW_BRANCH_MISSES           = 0x5
+	GO_COUNT_HW_BUS_CYCLES              = 0x6
+	GO_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	GO_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	GO_COUNT_HW_REF_CPU_CYCLES          = 0x9
+	
+    GO_COUNT_HW_CACHE_L1D  = 0xa
+	GO_COUNT_HW_CACHE_L1I  = 0xb
+	GO_COUNT_HW_CACHE_LL   = 0xc
+	GO_COUNT_HW_CACHE_DTLB = 0xd
+	GO_COUNT_HW_CACHE_ITLB = 0xe
+	GO_COUNT_HW_CACHE_BPU  = 0xf
+	GO_COUNT_HW_CACHE_NODE = 0x10
+
+	GO_COUNT_HW_CACHE_OP_READ     = 0x11
+	GO_COUNT_HW_CACHE_OP_WRITE    = 0x12
+	GO_COUNT_HW_CACHE_OP_PREFETCH = 0x13
+	
+    GO_COUNT_HW_CACHE_RESULT_ACCESS = 0x14
+	GO_COUNT_HW_CACHE_RESULT_MISS   = 0x15
+
+	GO_COUNT_SW_CPU_CLOCK        = 0x16
+	GO_COUNT_SW_TASK_CLOCK       = 0x17
+	GO_COUNT_SW_PAGE_FAULTS      = 0x18
+	GO_COUNT_SW_CONTEXT_SWITCHES = 0x19
+)
+
+type PMUEventAttr struct {
+    Period           uint64
+    PreciseIP        uint8
+    IsKernelIncluded bool
+    IsHvIncluded     bool
+}
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 334a7b4223..8f41e211e3 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -357,7 +357,7 @@ func sigaltstack(new, old *stackt)
 func setitimer(mode int32, new, old *itimerval)
 
 //go:noescape
-func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r int32, r2, err int64)
+func perfEventOpen(attr *perfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r int32, r2, err int64)
 
 func ioctl(fd int32, req, arg int64) int64
 
diff --git a/src/runtime/pmuprof.go b/src/runtime/pmuprof.go
index f8154a32e2..f0e0b9d3bb 100644
--- a/src/runtime/pmuprof.go
+++ b/src/runtime/pmuprof.go
@@ -44,10 +44,10 @@ type pmuProfile struct {
 
 var pmuprof [maxPMUEvents]pmuProfile // event -> cpuProfile
 
-func SetPMUProfile(eventId int, event *PMUEvent) {
+func SetPMUProfile(eventId int, eventAttr *PMUEventAttr) {
     
     lock(&pmuprof[eventId].lock)
-    if event != nil {
+    if eventAttr != nil {
         if pmuprof[eventId].on || pmuprof[eventId].log != nil {
             print("runtime: cannot set pmu profile rate until previous profile has finished.\n")
             unlock(&pmuprof[eventId].lock)
@@ -56,9 +56,9 @@ func SetPMUProfile(eventId int, event *PMUEvent) {
 
         pmuprof[eventId].on = true
         pmuprof[eventId].log = newProfBuf(1, 1<<17, 1<<14)
-        hdr := [1]uint64{event.Period}
+        hdr := [1]uint64{eventAttr.Period}
         pmuprof[eventId].log.write(nil, nanotime(), hdr[:], nil)
-        setpmuprofile(int32(eventId), event)
+        setpmuprofile(int32(eventId), eventAttr)
     } else if pmuprof[eventId].on {
         setpmuprofile(int32(eventId), nil)
         pmuprof[eventId].on = false
@@ -76,11 +76,11 @@ func SetPMUProfile(eventId int, event *PMUEvent) {
 //go:nowritebarrierrec
 func (p *pmuProfile) add(gp *g, stk []uintptr, eventId int) {
 	// Simple cas-lock to coordinate with setpmuprofile.
-	for !atomic.Cas(&profs[eventId].signalLock, 0, 1) {
+	for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
 		osyield()
 	}
 
-	if profs[eventId].event != nil { // implies pmuprof[eventId].log != nil
+	if pmuEvent[eventId].eventAttr != nil { // implies pmuprof[eventId].log != nil
 		if p.numExtra > 0 || p.lostExtra > 0 {
 			p.addExtra(eventId)
 		}
@@ -92,7 +92,7 @@ func (p *pmuProfile) add(gp *g, stk []uintptr, eventId int) {
 		pmuprof[eventId].log.write(&gp.labels, nanotime(), hdr[:], stk)
 	}
 
-	atomic.Store(&profs[eventId].signalLock, 0)
+	atomic.Store(&pmuEvent[eventId].signalLock, 0)
 }
 
 // addNonGo adds the non-Go stack trace to the profile.
@@ -108,7 +108,7 @@ func (p *pmuProfile) addNonGo(stk []uintptr, eventId int) {
 	// (Other calls to add or addNonGo should be blocked out
 	// by the fact that only one SIGPROF can be handled by the
 	// process at a time. If not, this lock will serialize those too.)
-	for !atomic.Cas(&profs[eventId].signalLock, 0, 1) {
+	for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
 		osyield()
 	}
 
@@ -121,7 +121,7 @@ func (p *pmuProfile) addNonGo(stk []uintptr, eventId int) {
 		pmuprof[eventId].lostExtra++
 	}
 
-	atomic.Store(&profs[eventId].signalLock, 0)
+	atomic.Store(&pmuEvent[eventId].signalLock, 0)
 }
 
 // addExtra adds the "extra" profiling events,
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index d656ed3d84..92c6a9fa46 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -729,12 +729,6 @@ var cpu struct {
     profileHz int
 }
 
-var pmu struct {
-	sync.Mutex
-	profiling bool
-	done      chan bool
-}
-
 // StartCPUProfile enables CPU profiling for the current process.
 // While profiling, the profile will be buffered and written to w.
 // StartCPUProfile returns an error if profiling is already enabled.
@@ -746,7 +740,7 @@ var pmu struct {
 // not to the one used by Go. To make it work, call os/signal.Notify
 // for syscall.SIGPROF, but note that doing so may break any profiling
 // being done by the main program.
-func StartCPUProfile(w io.Writer, hz ...int) error {
+func StartCPUProfile(w io.Writer, profileHz ...int) error {
     // The runtime routines allow a variable profiling rate,
     // but in practice operating systems cannot trigger signals
     // at more than about 500 Hz, and our processing of the
@@ -756,10 +750,10 @@ func StartCPUProfile(w io.Writer, hz ...int) error {
     // system, and a nice round number to make it easy to
     // convert sample counts to seconds. Instead of requiring
     // each client to specify the frequency, we hard code it.
-    if len(hz) == 0 {
-        cpu.profileHz = 100
-    } else {
-        cpu.profileHz = hz[0]
+    
+    var hz = 100
+    if len(profileHz) != 0 {
+        hz = profileHz[0]
     }
 
     cpu.Lock()
@@ -772,14 +766,23 @@ func StartCPUProfile(w io.Writer, hz ...int) error {
         return fmt.Errorf("cpu profiling already in use")
     }
     cpu.profiling = true
-    runtime.SetCPUProfileRate(cpu.profileHz)
+    runtime.SetCPUProfileRate(hz)
     go profileWriter(w)
     return nil
 }
 
+var pmu struct {
+	sync.Mutex
+	profiling bool
+	done      chan bool
+}
 
 func StartPMUProfile(opts ...ProfilingOption) error {
-	pmu.Lock()
+    if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
+        return errors.New("not implemented")
+    }
+	
+    pmu.Lock()
 	defer pmu.Unlock()
 	if pmu.done == nil {
         pmu.done = make(chan bool, len(opts))
@@ -798,6 +801,13 @@ func StartPMUProfile(opts ...ProfilingOption) error {
 	return nil
 }
 
+type PMUEventConfig struct {
+    Period           int64
+    PreciseIP        int8
+    IsKernelIncluded bool
+    IsHvIncluded     bool
+}
+
 func getPreciseIP(preciseIP int8) uint8 {
     if preciseIP < 0 {
         preciseIP = 0
@@ -807,57 +817,43 @@ func getPreciseIP(preciseIP int8) uint8 {
     return uint8(preciseIP)
 }
 
-func WithProfilingCycle(w io.Writer, period int64, preciseIP ...int8) ProfilingOption {
+func WithProfilingCycle(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
-		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
-            return errors.New("not implemented")
-		}
-        if period <= 0 {
-            return errors.New("period should be > 0")
+       if eventConfig.Period <= 0 {
+            return errors.New("Period should be > 0")
         }
-        
         // Clamp period to something reasonable
         // Refer to hpctoolkit
-        if period < 300 {
-            period = 300
+        if eventConfig.Period < 300 {
+            eventConfig.Period = 300
         }
         
-        var cycle runtime.PMUEvent
-        cycle.Cat = runtime.PERF_TYPE_HARDWARE
-        cycle.Code = runtime.PERF_COUNT_HW_CPU_CYCLES
-        cycle.Period = uint64(period)
-        if len(preciseIP) != 0 {
-            cycle.PreciseIP = getPreciseIP(preciseIP[0])
-        }
-
-		runtime.SetPMUProfile(/*event ID*/ 0, &cycle)
+        cycle := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
+                                      PreciseIP: getPreciseIP(eventConfig.PreciseIP),
+                                      IsKernelIncluded: eventConfig.IsKernelIncluded,
+                                      IsHvIncluded: eventConfig.IsHvIncluded}
+		
+        runtime.SetPMUProfile(/*event ID*/ 0, &cycle)
         go pmuProfileWriter(w, /*event ID*/ 0, "cycles")
 		return nil
 	})
 }
 
-func WithProfilingInstr(w io.Writer, period int64, preciseIP ...int8) ProfilingOption {
+func WithProfilingInstr(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
-		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
-            return errors.New("not implemented")
-		}
-        if period <= 0 {
-            return errors.New("period should be > 0")
+        if eventConfig.Period <= 0 {
+            return errors.New("Period should be > 0")
         }
-        
         // Clamp period to something reasonable
         // Refer to hpctoolkit
-        if period < 300 {
-            period = 300
+        if eventConfig.Period < 300 {
+            eventConfig.Period = 300
         }
         
-        var instr runtime.PMUEvent
-        instr.Cat = runtime.PERF_TYPE_HARDWARE
-        instr.Code = runtime.PERF_COUNT_HW_INSTRUCTIONS
-        instr.Period = uint64(period)
-        if len(preciseIP) != 0 {
-            instr.PreciseIP = getPreciseIP(preciseIP[0])
-        }
+        instr := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
+                                      PreciseIP: getPreciseIP(eventConfig.PreciseIP),
+                                      IsKernelIncluded: eventConfig.IsKernelIncluded,
+                                      IsHvIncluded: eventConfig.IsHvIncluded}
 
 		runtime.SetPMUProfile(/*event ID*/ 1, &instr)
         go pmuProfileWriter(w, /*event ID*/ 1, "instructions")
@@ -865,28 +861,16 @@ func WithProfilingInstr(w io.Writer, period int64, preciseIP ...int8) ProfilingO
 	})
 }
 
-func WithProfilingCacheRef(w io.Writer, period int64, preciseIP ...int8) ProfilingOption {
+func WithProfilingCacheRef(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
-		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
-            return errors.New("not implemented")
-		}
-        if period <= 0 {
-            return errors.New("period should be > 0")
+        if eventConfig.Period <= 0 {
+            return errors.New("Period should be > 0")
         }
         
-        // Clamp period to something reasonable
-        // Refer to hpctoolkit
-        if period < 300 {
-            period = 300
-        }
-        
-        var cacheRef runtime.PMUEvent
-        cacheRef.Cat = runtime.PERF_TYPE_HARDWARE
-        cacheRef.Code = runtime.PERF_COUNT_HW_CACHE_REFERENCES
-        cacheRef.Period = uint64(period)
-        if len(preciseIP) != 0 {
-            cacheRef.PreciseIP = getPreciseIP(preciseIP[0])
-        }
+        cacheRef := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
+                                         PreciseIP: getPreciseIP(eventConfig.PreciseIP),
+                                         IsKernelIncluded: eventConfig.IsKernelIncluded,
+                                         IsHvIncluded: eventConfig.IsHvIncluded}
 
 		runtime.SetPMUProfile(/*event ID*/ 2, &cacheRef)
         go pmuProfileWriter(w, /*event ID*/ 2, "cache references")
@@ -894,28 +878,16 @@ func WithProfilingCacheRef(w io.Writer, period int64, preciseIP ...int8) Profili
 	})
 }
 
-func WithProfilingCacheMiss(w io.Writer, period int64, preciseIP ...int8) ProfilingOption {
+func WithProfilingCacheMiss(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
-		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
-            return errors.New("not implemented")
-		}
-        if period <= 0 {
-            return errors.New("period should be > 0")
-        }
-        
-        // Clamp period to something reasonable
-        // Refer to hpctoolkit
-        if period < 300 {
-            period = 300
+        if eventConfig.Period <= 0 {
+            return errors.New("Period should be > 0")
         }
         
-        var cacheMiss runtime.PMUEvent
-        cacheMiss.Cat = runtime.PERF_TYPE_HARDWARE
-        cacheMiss.Code = runtime.PERF_COUNT_HW_CACHE_MISSES
-        cacheMiss.Period = uint64(period)
-        if len(preciseIP) != 0 {
-            cacheMiss.PreciseIP = getPreciseIP(preciseIP[0])
-        }
+        cacheMiss := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
+                                          PreciseIP: getPreciseIP(eventConfig.PreciseIP),
+                                          IsKernelIncluded: eventConfig.IsKernelIncluded,
+                                          IsHvIncluded: eventConfig.IsHvIncluded}
 
 		runtime.SetPMUProfile(/*event ID*/ 3, &cacheMiss)
         go pmuProfileWriter(w, /*event ID*/ 3, "cache misses")
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 38b08d8ff7..3881ea8798 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2149,7 +2149,7 @@ func execute(gp *g, inheritTime bool) {
 
 	// Check whether the profiler needs to be turned on or off.
 	hz := sched.profilehz
-    events := sched.events
+    eventAttrs := sched.eventAttrs
     
     // if _g_.m.profilehz != hz && _g_.m.profilePeriod != period  {
     //   println("should never reach here!")
@@ -2160,8 +2160,8 @@ func execute(gp *g, inheritTime bool) {
     }
     
     for eventId := 0; eventId < maxPMUEvents; eventId++ {
-        if  _g_.m.events[eventId] != events[eventId] {
-            setThreadPMUProfiler(int32(eventId), events[eventId])
+        if  _g_.m.eventAttrs[eventId] != eventAttrs[eventId] {
+            setThreadPMUProfiler(int32(eventId), eventAttrs[eventId])
         }
     }
         
@@ -3632,9 +3632,9 @@ var prof struct {
 	hz         int32
 }
 
-var profs [maxPMUEvents]struct { // TODO: come up with a bettter name
+var pmuEvent [maxPMUEvents]struct { // TODO: come up with a bettter name
 	signalLock uint32
-    event     *PMUEvent
+    eventAttr     *PMUEventAttr
 }
 
 func _System()                    { _System() }
@@ -3815,8 +3815,8 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 var lostPMUAtomic64Count[10] uint64
 
 //go:nowritebarrierrec
-func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
-	if profs[eventId].event == nil {
+func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) { // SIGRTMIN + 3
+	if pmuEvent[eventId].eventAttr == nil {
 		return
 	}
 	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
@@ -3902,7 +3902,7 @@ func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
 		}
 	}
 
-	if profs[eventId].event != nil {
+	if pmuEvent[eventId].eventAttr != nil {
 		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostPMUAtomic64Count[eventId] > 0 {
 			pmuprof[eventId].addLostAtomic64(lostPMUAtomic64Count[eventId], eventId)
 			lostPMUAtomic64Count[eventId] = 0
@@ -3939,7 +3939,7 @@ func sigprofNonGo() {
 //go:nosplit
 //go:nowritebarrierrec
 func sigpmuNonGo(eventId int) {
-	if profs[eventId].event != nil {
+	if pmuEvent[eventId].eventAttr != nil {
 		n := 0
 		for n < len(sigprofCallers) && sigprofCallers[n] != 0 {
 			n++
@@ -3968,7 +3968,7 @@ func sigprofNonGoPC(pc uintptr) {
 //go:nosplit
 //go:nowritebarrierrec
 func sigpmuNonGoPC(pc uintptr, eventId int) {
-	if profs[eventId].event != nil {
+	if pmuEvent[eventId].eventAttr != nil {
 		stk := []uintptr{
 			pc,
 			funcPC(_ExternalCode) + sys.PCQuantum,
@@ -4039,7 +4039,7 @@ func setcpuprofilerate(hz int32) {
 	_g_.m.locks--
 }
 
-func setpmuprofile(eventId int32, event *PMUEvent) {
+func setpmuprofile(eventId int32, eventAttr *PMUEventAttr) {
 
     // Disable preemption, otherwise we can be rescheduled to another thread
     // that has profiling enabled.
@@ -4051,21 +4051,21 @@ func setpmuprofile(eventId int32, event *PMUEvent) {
     // it would deadlock.
     setThreadPMUProfiler(eventId, nil)
 
-    for !atomic.Cas(&profs[eventId].signalLock, 0, 1) {
+    for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
         osyield()
     }
-    if profs[eventId].event != event {
-        setProcessPMUProfiler(event)
-        profs[eventId].event = event
+    if pmuEvent[eventId].eventAttr != eventAttr {
+        setProcessPMUProfiler(eventAttr)
+        pmuEvent[eventId].eventAttr = eventAttr
     }
-    atomic.Store(&profs[eventId].signalLock, 0)
+    atomic.Store(&pmuEvent[eventId].signalLock, 0)
 
     lock(&sched.lock)
-    sched.events[eventId] = event
+    sched.eventAttrs[eventId] = eventAttr
     unlock(&sched.lock)
 
-    if event != nil {
-        setThreadPMUProfiler(eventId, event)
+    if eventAttr != nil {
+        setThreadPMUProfiler(eventId, eventAttr)
     }
 
     _g_.m.locks--
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index cfda44cc3d..bf16320542 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -473,9 +473,8 @@ type m struct {
 	locks         int32
 	dying         int32
 	profilehz     int32
-    fds           [maxPMUProfStack]int32
-	events       [maxPMUProfStack]*PMUEvent
-    fdToEventIdMap      map[int32]int32 // fd->event Id
+    eventFds      [maxPMUProfStack]int32
+	eventAttrs    [maxPMUProfStack]*PMUEventAttr
     spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack
@@ -521,7 +520,6 @@ type m struct {
 	dlogPerM
 
 	mOS
-	
 }
 
 type p struct {
@@ -678,7 +676,7 @@ type schedt struct {
 	safePointNote note
 
     profilehz      int32 // cpu profiling rate
-	events         [maxPMUProfStack]*PMUEvent 
+	eventAttrs         [maxPMUProfStack]*PMUEventAttr
     procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
 }
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index 0d9ed2ae00..a85885064b 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -34,19 +34,22 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
 	_g_ := getg()
 	c := &sigctxt{info, ctxt}
 
-    if sig == _SIGRTMIN + 3 {
+    if sig == _SIGPMU {
         fd := info.si_fd
         ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
         
-        if _g_.m.fdToEventIdMap == nil {
-            println("should not reach here")
-		    ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
-            return
+        var eventId int = -1
+        for i := 0; i < maxPMUEvents; i++ {
+            if _g_.m.eventFds[i] == fd {
+                eventId = i
+                break
+            }
         }
-        
-        eventId := _g_.m.fdToEventIdMap[fd]
-        sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, int(eventId))
-		ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
+        if eventId != -1 {
+            sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
+        }
+
+        ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
         return
 	}
     
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index bb5acc147d..3d78dabb2d 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -149,8 +149,8 @@ func sigenable(sig uint32) {
 		return
 	}
 
-	// SIGPROF and _SIGRTMIN + 3 are handled specially for profiling.
-	if sig == _SIGPROF  || sig == _SIGRTMIN + 3 {
+	// SIGPROF and _SIGPMU are handled specially for profiling.
+	if sig == _SIGPROF  || sig == _SIGPMU {
 		return
 	}
 	
@@ -174,8 +174,8 @@ func sigdisable(sig uint32) {
 		return
 	}
 
-	// SIGPROF and _SIGRTMIN + 3 are handled specially for profiling.
-	if sig == _SIGPROF  || sig == _SIGRTMIN + 3 {
+	// SIGPROF and _SIGPMU are handled specially for profiling.
+	if sig == _SIGPROF  || sig == _SIGPMU {
 		return
 	}
 
@@ -203,8 +203,8 @@ func sigignore(sig uint32) {
 		return
 	}
 
-	// SIGPROF and _SIGRTMIN + 3 are handled specially for profiling.
-	if sig == _SIGPROF  || sig == _SIGRTMIN + 3 {
+	// SIGPROF and _SIGPMU are handled specially for profiling.
+	if sig == _SIGPROF  || sig == _SIGPMU {
 		return
 	}
 
@@ -251,19 +251,19 @@ func setProcessCPUProfiler(hz int32) {
 	}
 }
 
-func setProcessPMUProfiler(event *PMUEvent) {
-    if event != nil {
+func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
+    if eventAttr != nil {
         // Enable the Go signal handler if not enabled.
-        if atomic.Cas(&handlingSig[_SIGRTMIN + 3], 0, 1) {
-            atomic.Storeuintptr(&fwdSig[_SIGRTMIN + 3], getsig(_SIGRTMIN + 3))
-            setsig(_SIGRTMIN + 3, funcPC(sighandler))
+        if atomic.Cas(&handlingSig[_SIGPMU], 0, 1) {
+            atomic.Storeuintptr(&fwdSig[_SIGPMU], getsig(_SIGPMU))
+            setsig(_SIGPMU, funcPC(sighandler))
         }
     } else {
         // If the Go signal handler should be disabled by default,
         // disable it if it is enabled.
-        if !sigInstallGoHandler(_SIGRTMIN + 3) {
-            if atomic.Cas(&handlingSig[_SIGRTMIN + 3], 1, 0) {
-                setsig(_SIGRTMIN + 3, atomic.Loaduintptr(&fwdSig[_SIGRTMIN + 3]))
+        if !sigInstallGoHandler(_SIGPMU) {
+            if atomic.Cas(&handlingSig[_SIGPMU], 1, 0) {
+                setsig(_SIGPMU, atomic.Loaduintptr(&fwdSig[_SIGPMU]))
             }
         }
     }
@@ -285,41 +285,37 @@ func setThreadCPUProfiler(hz int32) {
     _g_.m.profilehz = hz
 }
 
-func setThreadPMUProfiler(eventId int32, event *PMUEvent) {
+func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
     _g_ := getg()
-    if _g_.m.fdToEventIdMap == nil {
-        _g_.m.fdToEventIdMap = make(map[int32]int32)
-    }
     
-    if event == nil { // Go routine is finished
-        if _g_.m.events[eventId] != nil {
-            fd := _g_.m.fds[eventId]
-            if _, ok := _g_.m.fdToEventIdMap[fd]; ok {
-                delete(_g_.m.fdToEventIdMap, fd) // delete it from the map
-                closefd(fd)
-            }
-         }
+    if eventAttr == nil {
+        if _g_.m.eventAttrs[eventId] != nil {
+            closefd(_g_.m.eventFds[eventId])
+        }
     } else {
-        var attr PerfEventAttr
-        attr.Type = event.Cat
-        attr.Size = uint32(unsafe.Sizeof(attr))
-        attr.Config = event.Code
-        attr.Sample = event.Period
-        attr.Bits = uint64(event.PreciseIP) << 15 // precise ip
-        attr.Bits += 0b100000 // don't count kernel  
-        attr.Bits += 0b1000000 // don't count hypervisor
-
-        fd, _, _ := perfEventOpen(&attr, 0, -1, -1, 0, /* dummy*/ 0)
-        _g_.m.fds[eventId] = fd
-        _g_.m.fdToEventIdMap[fd] = eventId
+        var perfAttr perfEventAttr
+        perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
+        perfAttr.Type = perfEventOpt[eventId].Type
+        perfAttr.Config = perfEventOpt[eventId].Config
+        perfAttr.Sample = eventAttr.Period
+        perfAttr.Bits = uint64(eventAttr.PreciseIP) << 15 // precise ip
+        if !eventAttr.IsKernelIncluded { // don't count kernel
+            perfAttr.Bits += 0b100000
+        }
+        if !eventAttr.IsHvIncluded { // don't count hypervisor
+            perfAttr.Bits += 0b1000000
+        }
+        
+        fd, _, _ := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy*/ 0)
+        _g_.m.eventFds[eventId] = fd
         r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
         fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
-        fcntl(fd, /*F_SETSIG*/ 0xa, _SIGRTMIN + 3)
-        
+        fcntl(fd, /*F_SETSIG*/ 0xa, _SIGPMU)
         fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, int32(gettid())}
         fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx)
     }
-    _g_.m.events[eventId] = event
+
+    _g_.m.eventAttrs[eventId] = eventAttr
 }
 
 func sigpipe() {
@@ -350,7 +346,7 @@ func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
 		if sig == _SIGPROF {
 			sigprofNonGoPC(c.sigpc())
 			return
-		} else if sig == _SIGRTMIN + 3 {
+		} else if sig == _SIGPMU {
 			// sigpmuNonGoPC(c.sigpc())
             println("how do I know which pmu event delivers this signal")
 			return
@@ -508,7 +504,7 @@ func dieFromSignal(sig uint32) {
 // thread, and the Go program does not want to handle it (that is, the
 // program has not called os/signal.Notify for the signal).
 func raisebadsignal(sig uint32, c *sigctxt) {
-	if sig == _SIGPROF  || sig == _SIGRTMIN + 3 {
+	if sig == _SIGPROF  || sig == _SIGPMU {
 		// Ignore profiling signals that arrive on non-Go threads.
 		return
 	}

From 3ca840d596871e4438174d3c2a855f8f7bb05e88 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 7 Jul 2019 21:15:04 -0700
Subject: [PATCH 035/126] test

---
 test/pmu/test1.go | 11 ++++++++---
 test/pmu/test2.go | 43 +++++++++++++++++++++++++++++--------------
 2 files changed, 37 insertions(+), 17 deletions(-)

diff --git a/test/pmu/test1.go b/test/pmu/test1.go
index 8b14f0daf2..5fcc42af72 100644
--- a/test/pmu/test1.go
+++ b/test/pmu/test1.go
@@ -154,13 +154,18 @@ func f10() {
 
 
 func run() error {
-    cycle, err := os.Create("cycle_profile")
+    cycleFile, err := os.Create("cycle_profile")
 	if err != nil {
 	 return err
 	}
-    defer cycle.Close()
+    defer cycleFile.Close()
     
-    if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycle, 20000000)); err != nil {
+    var cycle pprof.PMUEventConfig
+    cycle.Period =  20000000
+    cycle.IsKernelIncluded = false
+    cycle.IsHvIncluded = false
+    
+    if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycleFile, &cycle)); err != nil {
         return err
 	}
 	defer pprof.StopPMUProfile()
diff --git a/test/pmu/test2.go b/test/pmu/test2.go
index d8eaa8849b..2a88e173b2 100644
--- a/test/pmu/test2.go
+++ b/test/pmu/test2.go
@@ -152,44 +152,59 @@ func f10() {
 	fmt.Println(sum)
 }
 
-
 func run() error {
-	itimer, err := os.Create("itimer_profile")
+	itimerFile, err := os.Create("itimer_profile")
 	if err != nil {
 	 return err
 	}
-    defer itimer.Close()
+    defer itimerFile.Close()
     
-    cycle, err := os.Create("cycle_profile")
+    cycleFile, err := os.Create("cycle_profile")
 	if err != nil {
 	 return err
 	}
-    defer cycle.Close()
+    defer cycleFile.Close()
     
-    instr, err := os.Create("instr_profile")
+    var cycle pprof.PMUEventConfig
+    cycle.Period =  20000000
+    // cycle.PreciseIP = 2
+
+    instrFile, err := os.Create("instr_profile")
 	if err != nil {
 	 return err
 	}
-    defer instr.Close()
+    defer instrFile.Close()
     
-    cacheRef, err := os.Create("cacheRef_profile")
+    var instr pprof.PMUEventConfig
+    instr.Period =  20000000
+    // instr.PreciseIP = 2
+   
+    cacheRefFile, err := os.Create("cacheRef_profile")
 	if err != nil {
 	 return err
 	}
-    defer cacheRef.Close()
+    defer cacheRefFile.Close()
+    
+    var cacheRef pprof.PMUEventConfig
+    cacheRef.Period =  200
+    // cacheRef.PreciseIP = 2
 	
-    cacheMiss, err := os.Create("cacheMiss_profile")
+    cacheMissFile, err := os.Create("cacheMiss_profile")
 	if err != nil {
 	 return err
 	}
-    defer cacheMiss.Close()
-	
-    if err := pprof.StartCPUProfile(itimer); err != nil {
+    defer cacheMissFile.Close()
+    
+    var cacheMiss pprof.PMUEventConfig
+    cacheMiss.Period =  10
+    // cacheMiss.PreciseIP = 2
+
+    if err := pprof.StartCPUProfile(itimerFile); err != nil {
         return err
 	}
 	defer pprof.StopCPUProfile()
 
-    if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycle, 20000000), pprof.WithProfilingInstr(instr, 20000000), pprof.WithProfilingCacheRef(cacheRef, 1000), pprof.WithProfilingCacheMiss(cacheMiss, 1)); err != nil {
+    if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycleFile, &cycle), pprof.WithProfilingInstr(instrFile, &instr), pprof.WithProfilingCacheRef(cacheRefFile, &cacheRef), pprof.WithProfilingCacheMiss(cacheMissFile, &cacheMiss)); err != nil {
         return err
 	}
 	defer pprof.StopPMUProfile()

From 797cb5ad6df8a2dad061a088c1e553484fac6b6d Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 7 Jul 2019 21:15:19 -0700
Subject: [PATCH 036/126] minor

---
 src/runtime/pprof/pprof.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 92c6a9fa46..b1cbfbd0cf 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -806,6 +806,8 @@ type PMUEventConfig struct {
     PreciseIP        int8
     IsKernelIncluded bool
     IsHvIncluded     bool
+    // TODO: IsMmapEnabled bool
+    // TODO: IsLBREnabled bool
 }
 
 func getPreciseIP(preciseIP int8) uint8 {

From d46b988df3f0c9075abf76777f93377c08f81b84 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 8 Jul 2019 11:34:01 -0700
Subject: [PATCH 037/126] refactoring

---
 src/runtime/cpuprof.go           | 125 +++++++++++++++++++++++-
 src/runtime/pprof/pprof.go       |  35 ++++---
 src/runtime/proc.go              | 162 ++++++++++---------------------
 src/runtime/runtime2.go          |   6 +-
 src/runtime/signal_sighandler.go |   2 +-
 src/runtime/signal_unix.go       |  15 ++-
 6 files changed, 205 insertions(+), 140 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index 31a9409838..11e2848a20 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -19,8 +19,9 @@ import (
 )
 
 const maxCPUProfStack = 64
+const maxPMUEvent  = 10
 
-type cpuProfile struct {
+type profile struct {
 	lock mutex
 	on   bool     // profiling is on
 	log  *profBuf // profile events written here
@@ -41,7 +42,11 @@ type cpuProfile struct {
 	lostExtra uint64 // count of frames lost because extra is full
 }
 
+type pmuProfile profile
+type cpuProfile profile
+
 var cpuprof cpuProfile
+var pmuprof [maxPMUEvent]pmuProfile
 
 // SetCPUProfileRate sets the CPU profiling rate to hz samples per second.
 // If hz <= 0, SetCPUProfileRate turns off profiling.
@@ -51,7 +56,6 @@ var cpuprof cpuProfile
 // the testing package's -test.cpuprofile flag instead of calling
 // SetCPUProfileRate directly.
 func SetCPUProfileRate(hz int) {
-// func SetCPUProfileRate(hz int) {
 	// Clamp hz to something reasonable.
 	if hz < 0 {
 		hz = 0
@@ -60,7 +64,7 @@ func SetCPUProfileRate(hz int) {
 		hz = 1000000
 	}
 
-	lock(&cpuprof.lock) // cpuprof[event].lock 
+	lock(&cpuprof.lock)
 	if hz > 0 {
 		if cpuprof.on || cpuprof.log != nil {
 			print("runtime: cannot set cpu profile rate until previous profile has finished.\n")
@@ -71,17 +75,40 @@ func SetCPUProfileRate(hz int) {
 		cpuprof.on = true
 		cpuprof.log = newProfBuf(1, 1<<17, 1<<14)
 		hdr := [1]uint64{uint64(hz)}
-		cpuprof.log.write(nil, nanotime(), hdr[:], nil) 
+		cpuprof.log.write(nil, nanotime(), hdr[:], nil)
 		setcpuprofilerate(int32(hz))
 	} else if cpuprof.on {
 		setcpuprofilerate(0)
 		cpuprof.on = false
-		cpuprof.addExtra() // cpuprof[event].addExtra() 
+		cpuprof.addExtra()
 		cpuprof.log.close()
 	}
 	unlock(&cpuprof.lock)
 }
 
+func SetPMUProfile(eventId int, eventAttr *PMUEventAttr) {
+    lock(&pmuprof[eventId].lock)
+    if eventAttr != nil {
+        if pmuprof[eventId].on || pmuprof[eventId].log != nil {
+            print("runtime: cannot set pmu profile rate until previous profile has finished.\n")
+            unlock(&pmuprof[eventId].lock)
+            return
+        }
+
+        pmuprof[eventId].on = true
+        pmuprof[eventId].log = newProfBuf(1, 1<<17, 1<<14)
+        hdr := [1]uint64{eventAttr.Period}
+        pmuprof[eventId].log.write(nil, nanotime(), hdr[:], nil)
+        setpmuprofile(int32(eventId), eventAttr)
+    } else if pmuprof[eventId].on {
+        setpmuprofile(int32(eventId), nil)
+        pmuprof[eventId].on = false
+        pmuprof[eventId].addExtra(eventId)
+        pmuprof[eventId].log.close()
+    }
+    unlock(&pmuprof[eventId].lock)
+}
+
 // add adds the stack trace to the profile.
 // It is called from signal handlers and other limited environments
 // and cannot allocate memory or acquire locks that might be
@@ -109,6 +136,28 @@ func (p *cpuProfile) add(gp *g, stk []uintptr) {
 	atomic.Store(&prof.signalLock, 0)
 }
 
+//go:nowritebarrierrec
+func (p *pmuProfile) add(gp *g, stk []uintptr, eventId int) {
+	// Simple cas-lock to coordinate with setpmuprofile.
+	for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
+		osyield()
+	}
+
+	if pmuEvent[eventId].eventAttr != nil { // implies pmuprof[eventId].log != nil
+		if p.numExtra > 0 || p.lostExtra > 0 {
+			p.addExtra(eventId)
+		}
+		hdr := [1]uint64{1}
+		// Note: write "knows" that the argument is &gp.labels,
+		// because otherwise its write barrier behavior may not
+		// be correct. See the long comment there before
+		// changing the argument here.
+		pmuprof[eventId].log.write(&gp.labels, nanotime(), hdr[:], stk)
+	}
+
+	atomic.Store(&pmuEvent[eventId].signalLock, 0)
+}
+
 // addNonGo adds the non-Go stack trace to the profile.
 // It is called from a non-Go thread, so we cannot use much stack at all,
 // nor do anything that needs a g or an m.
@@ -139,6 +188,28 @@ func (p *cpuProfile) addNonGo(stk []uintptr) {
 	atomic.Store(&prof.signalLock, 0)
 }
 
+//go:nosplit
+//go:nowritebarrierrec
+func (p *pmuProfile) addNonGo(stk []uintptr, eventId int) {
+	// (Other calls to add or addNonGo should be blocked out
+	// by the fact that only one SIGPROF can be handled by the
+	// process at a time. If not, this lock will serialize those too.)
+	for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
+		osyield()
+	}
+
+	if pmuprof[eventId].numExtra+1+len(stk) < len(pmuprof[eventId].extra) {
+		i := pmuprof[eventId].numExtra
+		pmuprof[eventId].extra[i] = uintptr(1 + len(stk))
+		copy(pmuprof[eventId].extra[i+1:], stk)
+		pmuprof[eventId].numExtra += 1 + len(stk)
+	} else {
+		pmuprof[eventId].lostExtra++
+	}
+
+	atomic.Store(&pmuEvent[eventId].signalLock, 0)
+}
+
 // addExtra adds the "extra" profiling events,
 // queued by addNonGo, to the profile log.
 // addExtra is called either from a signal handler on a Go thread
@@ -165,6 +236,27 @@ func (p *cpuProfile) addExtra() {
 	}
 }
 
+func (p *pmuProfile) addExtra(eventId int) {
+	// Copy accumulated non-Go profile events.
+	hdr := [1]uint64{1}
+	for i := 0; i < p.numExtra; {
+		p.log.write(nil, 0, hdr[:], p.extra[i+1:i+int(p.extra[i])])
+		i += int(p.extra[i])
+	}
+	p.numExtra = 0
+
+	// Report any lost events.
+	if p.lostExtra > 0 {
+		hdr := [1]uint64{p.lostExtra}
+		lostStk := [2]uintptr{
+			funcPC(_LostExternalCode) + sys.PCQuantum,
+			funcPC(_ExternalCode) + sys.PCQuantum,
+		}
+		pmuprof[eventId].log.write(nil, 0, hdr[:], lostStk[:])
+		p.lostExtra = 0
+	}
+}
+
 func (p *cpuProfile) addLostAtomic64(count uint64) {
 	hdr := [1]uint64{count}
 	lostStk := [2]uintptr{
@@ -174,6 +266,15 @@ func (p *cpuProfile) addLostAtomic64(count uint64) {
 	cpuprof.log.write(nil, 0, hdr[:], lostStk[:])
 }
 
+func (p *pmuProfile) addLostAtomic64(count uint64, eventId int) {
+	hdr := [1]uint64{count}
+	lostStk := [2]uintptr{
+		funcPC(_LostSIGPMUDuringAtomic64) + sys.PCQuantum,
+		funcPC(_System) + sys.PCQuantum,
+	}
+	pmuprof[eventId].log.write(nil, 0, hdr[:], lostStk[:])
+}
+
 // CPUProfile panics.
 // It formerly provided raw access to chunks of
 // a pprof-format profile generated by the runtime.
@@ -211,3 +312,17 @@ func runtime_pprof_readProfile() ([]uint64, []unsafe.Pointer, bool) {
 	}
 	return data, tags, eof
 }
+
+//go:linkname runtime_pprof_readPMUProfile runtime/pprof.readPMUProfile
+func runtime_pprof_readPMUProfile(eventId int) ([]uint64, []unsafe.Pointer, bool) {
+	lock(&pmuprof[eventId].lock)
+	log := pmuprof[eventId].log
+	unlock(&pmuprof[eventId].lock)
+	data, tags, eof := log.read(profBufBlocking)
+	if len(data) == 0 && eof {
+		lock(&pmuprof[eventId].lock)
+		pmuprof[eventId].log = nil
+		unlock(&pmuprof[eventId].lock)
+	}
+	return data, tags, eof
+}
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index b1cbfbd0cf..0a4dab3e8a 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -726,7 +726,6 @@ var cpu struct {
 	sync.Mutex
 	profiling bool
 	done      chan bool
-    profileHz int
 }
 
 // StartCPUProfile enables CPU profiling for the current process.
@@ -771,10 +770,12 @@ func StartCPUProfile(w io.Writer, profileHz ...int) error {
     return nil
 }
 
+const maxPMUEvent = 10
 var pmu struct {
 	sync.Mutex
 	profiling bool
-	done      chan bool
+    eventOn   [maxPMUEvent]bool
+    wg        sync.WaitGroup
 }
 
 func StartPMUProfile(opts ...ProfilingOption) error {
@@ -784,10 +785,8 @@ func StartPMUProfile(opts ...ProfilingOption) error {
 	
     pmu.Lock()
 	defer pmu.Unlock()
-	if pmu.done == nil {
-        pmu.done = make(chan bool, len(opts))
-	}
-	// Double-check.
+    pmu.wg.Add(len(opts))
+    // Double-check.
 	if pmu.profiling {
 		return fmt.Errorf("pmu profiling already in use")
 	}
@@ -829,12 +828,12 @@ func WithProfilingCycle(w io.Writer, eventConfig *PMUEventConfig) ProfilingOptio
         if eventConfig.Period < 300 {
             eventConfig.Period = 300
         }
-        
+        pmu.eventOn[0] = true
+
         cycle := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
                                       PreciseIP: getPreciseIP(eventConfig.PreciseIP),
                                       IsKernelIncluded: eventConfig.IsKernelIncluded,
                                       IsHvIncluded: eventConfig.IsHvIncluded}
-		
         runtime.SetPMUProfile(/*event ID*/ 0, &cycle)
         go pmuProfileWriter(w, /*event ID*/ 0, "cycles")
 		return nil
@@ -851,12 +850,12 @@ func WithProfilingInstr(w io.Writer, eventConfig *PMUEventConfig) ProfilingOptio
         if eventConfig.Period < 300 {
             eventConfig.Period = 300
         }
+        pmu.eventOn[1] = true
         
         instr := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
                                       PreciseIP: getPreciseIP(eventConfig.PreciseIP),
                                       IsKernelIncluded: eventConfig.IsKernelIncluded,
                                       IsHvIncluded: eventConfig.IsHvIncluded}
-
 		runtime.SetPMUProfile(/*event ID*/ 1, &instr)
         go pmuProfileWriter(w, /*event ID*/ 1, "instructions")
 		return nil
@@ -868,12 +867,12 @@ func WithProfilingCacheRef(w io.Writer, eventConfig *PMUEventConfig) ProfilingOp
         if eventConfig.Period <= 0 {
             return errors.New("Period should be > 0")
         }
+        pmu.eventOn[2] = true
         
         cacheRef := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
                                          PreciseIP: getPreciseIP(eventConfig.PreciseIP),
                                          IsKernelIncluded: eventConfig.IsKernelIncluded,
                                          IsHvIncluded: eventConfig.IsHvIncluded}
-
 		runtime.SetPMUProfile(/*event ID*/ 2, &cacheRef)
         go pmuProfileWriter(w, /*event ID*/ 2, "cache references")
 		return nil
@@ -885,12 +884,12 @@ func WithProfilingCacheMiss(w io.Writer, eventConfig *PMUEventConfig) ProfilingO
         if eventConfig.Period <= 0 {
             return errors.New("Period should be > 0")
         }
+        pmu.eventOn[3] = true
         
         cacheMiss := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
                                           PreciseIP: getPreciseIP(eventConfig.PreciseIP),
                                           IsKernelIncluded: eventConfig.IsKernelIncluded,
                                           IsHvIncluded: eventConfig.IsHvIncluded}
-
 		runtime.SetPMUProfile(/*event ID*/ 3, &cacheMiss)
         go pmuProfileWriter(w, /*event ID*/ 3, "cache misses")
 		return nil
@@ -940,7 +939,7 @@ func pmuProfileWriter(w io.Writer, eventId int, eventName string) {
 	b := newProfileBuilder(w)
 	var err error
 	for {
-	    time.Sleep(10 * time.Millisecond)
+	    time.Sleep(100 * time.Millisecond)
 	    data, tags, eof := readPMUProfile(eventId)
         if e := b.addPMUData(data, tags); e != nil && err == nil {
 		    err = e
@@ -953,7 +952,7 @@ func pmuProfileWriter(w io.Writer, eventId int, eventName string) {
 	    panic("runtime/pprof: converting profile: " + err.Error())
 	}
 	b.pmuBuild(eventName)
-    pmu.done <- true
+    pmu.wg.Done()
 }
 
 // StopCPUProfile stops the current CPU profile, if any.
@@ -980,12 +979,12 @@ func StopPMUProfile() {
 	}
     pmu.profiling = false
    
-    for i := 0; i < cap(pmu.done); i++ {
-        runtime.SetPMUProfile(i, nil)
+    for i := 0; i < maxPMUEvent; i++ {
+        if pmu.eventOn[i] {
+            runtime.SetPMUProfile(i, nil)
+        }
 	}
-    for i := 0; i < cap(pmu.done); i++ {
-        <-pmu.done
-    }
+    pmu.wg.Wait()
 }
 
 // countBlock returns the number of records in the blocking profile.
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 3881ea8798..38af8647da 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2151,15 +2151,10 @@ func execute(gp *g, inheritTime bool) {
 	hz := sched.profilehz
     eventAttrs := sched.eventAttrs
     
-    // if _g_.m.profilehz != hz && _g_.m.profilePeriod != period  {
-    //   println("should never reach here!")
-    // }
-	
     if _g_.m.profilehz != hz {
         setThreadCPUProfiler(hz)
     }
-    
-    for eventId := 0; eventId < maxPMUEvents; eventId++ {
+    for eventId := 0; eventId < maxPMUEvent; eventId++ {
         if  _g_.m.eventAttrs[eventId] != eventAttrs[eventId] {
             setThreadPMUProfiler(int32(eventId), eventAttrs[eventId])
         }
@@ -3632,9 +3627,9 @@ var prof struct {
 	hz         int32
 }
 
-var pmuEvent [maxPMUEvents]struct { // TODO: come up with a bettter name
+var pmuEvent [maxPMUEvent]struct {
 	signalLock uint32
-    eventAttr     *PMUEventAttr
+    eventAttr  *PMUEventAttr
 }
 
 func _System()                    { _System() }
@@ -3642,41 +3637,10 @@ func _ExternalCode()              { _ExternalCode() }
 func _LostExternalCode()          { _LostExternalCode() }
 func _GC()                        { _GC() }
 func _LostSIGPROFDuringAtomic64() { _LostSIGPROFDuringAtomic64() }
+func _LostSIGPMUDuringAtomic64() { _LostSIGPMUDuringAtomic64() }
 func _VDSO()                      { _VDSO() }
 
-// Counts SIGPROFs received while in atomic64 critical section, on mips{,le}
-var lostAtomic64Count uint64
-
-// Called if we receive a SIGPROF signal.
-// Called by the signal handler, may run during STW.
-//go:nowritebarrierrec
-func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
-	if prof.hz == 0 {
-		return
-	}
-	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
-	// runtime/internal/atomic. If SIGPROF arrives while the program is inside
-	// the critical section, it creates a deadlock (when writing the sample).
-	// As a workaround, create a counter of SIGPROFs while in critical section
-	// to store the count, and pass it to sigprof.add() later when SIGPROF is
-	// received from somewhere else (with _LostSIGPROFDuringAtomic64 as pc).
-	if GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm" {
-		if f := findfunc(pc); f.valid() {
-			if hasPrefix(funcname(f), "runtime/internal/atomic") {
-				lostAtomic64Count++ // lostAtomic64Count[event]++
-				return
-			}
-		}
-	}
-
-	// Profiling runs concurrently with GC, so it must not allocate.
-	// Set a trap in case the code does allocate.
-	// Note that on windows, one thread takes profiles of all the
-	// other threads, so mp is usually not getg().m.
-	// In fact mp may not even be stopped.
-	// See golang.org/issue/17165.
-	getg().m.mallocing++
-
+func stackUnwinding(pc, sp, lr uintptr, gp *g, mp *m, stk []uintptr) int {
 	// Define that a "user g" is a user-created goroutine, and a "system g"
 	// is one that is m->g0 or m->gsignal.
 	//
@@ -3746,8 +3710,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 	if gp == nil || sp < gp.stack.lo || gp.stack.hi < sp || setsSP(pc) || (mp != nil && mp.vdsoSP != 0) {
 		traceback = false
 	}
-	var stk [maxCPUProfStack]uintptr
-	n := 0
+    n := 0
 	if mp.ncgo > 0 && mp.curg != nil && mp.curg.syscallpc != 0 && mp.curg.syscallsp != 0 {
 		cgoOff := 0
 		// Check cgoCallersUse to make sure that we are not
@@ -3802,21 +3765,17 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 		}
 	}
 
-	if prof.hz != 0 {
-		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostAtomic64Count > 0 {
-			cpuprof.addLostAtomic64(lostAtomic64Count)
-			lostAtomic64Count = 0 // lostAtomic64Count[event] = 0
-		}
-		cpuprof.add(gp, stk[:n]) // cpuprof[event].add(gp, stk[:n])
-	}
-	getg().m.mallocing--
+    return n
 }
 
-var lostPMUAtomic64Count[10] uint64
+// Counts SIGPROFs received while in atomic64 critical section, on mips{,le}
+var lostAtomic64Count uint64
 
+// Called if we receive a SIGPROF signal.
+// Called by the signal handler, may run during STW.
 //go:nowritebarrierrec
-func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) { // SIGRTMIN + 3
-	if pmuEvent[eventId].eventAttr == nil {
+func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
+	if prof.hz == 0 {
 		return
 	}
 	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
@@ -3828,7 +3787,7 @@ func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) { // SIGRTMIN + 3
 	if GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm" {
 		if f := findfunc(pc); f.valid() {
 			if hasPrefix(funcname(f), "runtime/internal/atomic") {
-				lostPMUAtomic64Count[eventId]++
+				lostAtomic64Count++ // lostAtomic64Count[event]++
 				return
 			}
 		}
@@ -3841,67 +3800,52 @@ func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) { // SIGRTMIN + 3
 	// In fact mp may not even be stopped.
 	// See golang.org/issue/17165.
 	getg().m.mallocing++
-
-	traceback := true
-	if gp == nil || sp < gp.stack.lo || gp.stack.hi < sp || setsSP(pc) || (mp != nil && mp.vdsoSP != 0) {
-		traceback = false
-	}
-	var stk [maxPMUProfStack]uintptr
-	n := 0
-	if mp.ncgo > 0 && mp.curg != nil && mp.curg.syscallpc != 0 && mp.curg.syscallsp != 0 {
-		cgoOff := 0
-		// Check cgoCallersUse to make sure that we are not
-		// interrupting other code that is fiddling with
-		// cgoCallers.  We are running in a signal handler
-		// with all signals blocked, so we don't have to worry
-		// about any other code interrupting us.
-		if atomic.Load(&mp.cgoCallersUse) == 0 && mp.cgoCallers != nil && mp.cgoCallers[0] != 0 {
-			for cgoOff < len(mp.cgoCallers) && mp.cgoCallers[cgoOff] != 0 {
-				cgoOff++
-			}
-			copy(stk[:], mp.cgoCallers[:cgoOff])
-			mp.cgoCallers[0] = 0
-		}
-
-		// Collect Go stack that leads to the cgo call.
-		n = gentraceback(mp.curg.syscallpc, mp.curg.syscallsp, 0, mp.curg, 0, &stk[cgoOff], len(stk)-cgoOff, nil, nil, 0)
-		if n > 0 {
-			n += cgoOff
+	stk := make([]uintptr, maxCPUProfStack)
+	n := stackUnwinding(pc, sp, lr, gp, mp, stk)
+	if prof.hz != 0 {
+		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostAtomic64Count > 0 {
+			cpuprof.addLostAtomic64(lostAtomic64Count)
+			lostAtomic64Count = 0
 		}
-	} else if traceback {
-		n = gentraceback(pc, sp, lr, gp, 0, &stk[0], len(stk), nil, nil, _TraceTrap|_TraceJumpStack)
+		cpuprof.add(gp, stk[:n])
 	}
+	getg().m.mallocing--
+}
 
-	if n <= 0 {
-		// Normal traceback is impossible or has failed.
-		// See if it falls into several common cases.
-		n = 0
-		if (GOOS == "windows" || GOOS == "solaris" || GOOS == "illumos" || GOOS == "darwin" || GOOS == "aix") && mp.libcallg != 0 && mp.libcallpc != 0 && mp.libcallsp != 0 {
-			// Libcall, i.e. runtime syscall on windows.
-			// Collect Go stack that leads to the call.
-			n = gentraceback(mp.libcallpc, mp.libcallsp, 0, mp.libcallg.ptr(), 0, &stk[0], len(stk), nil, nil, 0)
-		}
-		if n == 0 && mp != nil && mp.vdsoSP != 0 {
-			n = gentraceback(mp.vdsoPC, mp.vdsoSP, 0, gp, 0, &stk[0], len(stk), nil, nil, _TraceTrap|_TraceJumpStack)
-		}
-		if n == 0 {
-			// If all of the above has failed, account it against abstract "System" or "GC".
-			n = 2
-			if inVDSOPage(pc) {
-				pc = funcPC(_VDSO) + sys.PCQuantum
-			} else if pc > firstmoduledata.etext {
-				// "ExternalCode" is better than "etext".
-				pc = funcPC(_ExternalCode) + sys.PCQuantum
-			}
-			stk[0] = pc
-			if mp.preemptoff != "" {
-				stk[1] = funcPC(_GC) + sys.PCQuantum
-			} else {
-				stk[1] = funcPC(_System) + sys.PCQuantum
+// Counts SIGPMUs received while in atomic64 critical section, on mips{,le}
+var lostPMUAtomic64Count[maxPMUEvent] uint64
+
+// Called if we receive a SIGPMU signal.
+// Called by the signal handler, may run during STW.
+//go:nowritebarrierrec
+func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) { // SIGPMU = SIGRTMIN + 3
+	if pmuEvent[eventId].eventAttr == nil {
+		return
+	}
+	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
+	// runtime/internal/atomic. If SIGPMU arrives while the program is inside
+	// the critical section, it creates a deadlock (when writing the sample).
+	// As a workaround, create a counter of SIGPMUs while in critical section
+	// to store the count, and pass it to sigprof.add() later when SIGPMU is
+	// received from somewhere else (with _LostSIGPMUDuringAtomic64 as pc).
+	if GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm" {
+		if f := findfunc(pc); f.valid() {
+			if hasPrefix(funcname(f), "runtime/internal/atomic") {
+				lostPMUAtomic64Count[eventId]++
+				return
 			}
 		}
 	}
 
+	// Profiling runs concurrently with GC, so it must not allocate.
+	// Set a trap in case the code does allocate.
+	// Note that on windows, one thread takes profiles of all the
+	// other threads, so mp is usually not getg().m.
+	// In fact mp may not even be stopped.
+	// See golang.org/issue/17165.
+	getg().m.mallocing++
+	stk := make([]uintptr, maxCPUProfStack)
+    n := stackUnwinding(pc, sp, lr, gp, mp, stk)
 	if pmuEvent[eventId].eventAttr != nil {
 		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostPMUAtomic64Count[eventId] > 0 {
 			pmuprof[eventId].addLostAtomic64(lostPMUAtomic64Count[eventId], eventId)
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index bf16320542..c72b91eeae 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -473,8 +473,8 @@ type m struct {
 	locks         int32
 	dying         int32
 	profilehz     int32
-    eventFds      [maxPMUProfStack]int32
-	eventAttrs    [maxPMUProfStack]*PMUEventAttr
+    eventFds      [maxPMUEvent]int32
+	eventAttrs    [maxPMUEvent]*PMUEventAttr
     spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack
@@ -676,7 +676,7 @@ type schedt struct {
 	safePointNote note
 
     profilehz      int32 // cpu profiling rate
-	eventAttrs         [maxPMUProfStack]*PMUEventAttr
+	eventAttrs         [maxPMUEvent]*PMUEventAttr
     procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
 }
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index a85885064b..0bb8eef5a9 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -39,7 +39,7 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
         ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
         
         var eventId int = -1
-        for i := 0; i < maxPMUEvents; i++ {
+        for i := 0; i < maxPMUEvent; i++ {
             if _g_.m.eventFds[i] == fd {
                 eventId = i
                 break
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 3d78dabb2d..c8ae3724f8 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -141,6 +141,13 @@ func sigInstallGoHandler(sig uint32) bool {
 	return true
 }
 
+func isProfilingSignal(sig uint32) bool {
+    if sig == _SIGPROF  || sig == _SIGPMU {
+        return true
+    }
+    return false
+}
+
 // sigenable enables the Go signal handler to catch the signal sig.
 // It is only called while holding the os/signal.handlers lock,
 // via os/signal.enableSignal and signal_enable.
@@ -150,7 +157,7 @@ func sigenable(sig uint32) {
 	}
 
 	// SIGPROF and _SIGPMU are handled specially for profiling.
-	if sig == _SIGPROF  || sig == _SIGPMU {
+    if isProfilingSignal(sig) {
 		return
 	}
 	
@@ -175,7 +182,7 @@ func sigdisable(sig uint32) {
 	}
 
 	// SIGPROF and _SIGPMU are handled specially for profiling.
-	if sig == _SIGPROF  || sig == _SIGPMU {
+    if isProfilingSignal(sig) {
 		return
 	}
 
@@ -204,7 +211,7 @@ func sigignore(sig uint32) {
 	}
 
 	// SIGPROF and _SIGPMU are handled specially for profiling.
-	if sig == _SIGPROF  || sig == _SIGPMU {
+    if isProfilingSignal(sig) {
 		return
 	}
 
@@ -504,7 +511,7 @@ func dieFromSignal(sig uint32) {
 // thread, and the Go program does not want to handle it (that is, the
 // program has not called os/signal.Notify for the signal).
 func raisebadsignal(sig uint32, c *sigctxt) {
-	if sig == _SIGPROF  || sig == _SIGPMU {
+    if isProfilingSignal(sig) {
 		// Ignore profiling signals that arrive on non-Go threads.
 		return
 	}

From 1625927142f2ec0ebe49448fc9dba896a40b0fdc Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 8 Jul 2019 11:38:02 -0700
Subject: [PATCH 038/126] remove

---
 src/runtime/pmuprof.go | 174 -----------------------------------------
 1 file changed, 174 deletions(-)
 delete mode 100644 src/runtime/pmuprof.go

diff --git a/src/runtime/pmuprof.go b/src/runtime/pmuprof.go
deleted file mode 100644
index f0e0b9d3bb..0000000000
--- a/src/runtime/pmuprof.go
+++ /dev/null
@@ -1,174 +0,0 @@
-// Copyright 2011 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.
-
-// CPU profiling.
-//
-// The signal handler for the profiling clock tick adds a new stack trace
-// to a log of recent traces. The log is read by a user goroutine that
-// turns it into formatted profile data. If the reader does not keep up
-// with the log, those writes will be recorded as a count of lost records.
-// The actual profile buffer is in profbuf.go.
-
-package runtime
-
-import (
-	"runtime/internal/atomic"
-	"runtime/internal/sys"
-	"unsafe"
-)
-
-const maxPMUProfStack = 64
-const maxPMUEvents  = 10
-
-type pmuProfile struct {
-	lock mutex
-	on   bool     // profiling is on
-	log  *profBuf // profile events written here
-
-	// extra holds extra stacks accumulated in addNonGo
-	// corresponding to profiling signals arriving on
-	// non-Go-created threads. Those stacks are written
-	// to log the next time a normal Go thread gets the
-	// signal handler.
-	// Assuming the stacks are 2 words each (we don't get
-	// a full traceback from those threads), plus one word
-	// size for framing, 100 Hz profiling would generate
-	// 300 words per second.
-	// Hopefully a normal Go thread will get the profiling
-	// signal at least once every few seconds.
-	extra     [1000]uintptr
-	numExtra  int
-	lostExtra uint64 // count of frames lost because extra is full
-}
-
-var pmuprof [maxPMUEvents]pmuProfile // event -> cpuProfile
-
-func SetPMUProfile(eventId int, eventAttr *PMUEventAttr) {
-    
-    lock(&pmuprof[eventId].lock)
-    if eventAttr != nil {
-        if pmuprof[eventId].on || pmuprof[eventId].log != nil {
-            print("runtime: cannot set pmu profile rate until previous profile has finished.\n")
-            unlock(&pmuprof[eventId].lock)
-            return
-        }
-
-        pmuprof[eventId].on = true
-        pmuprof[eventId].log = newProfBuf(1, 1<<17, 1<<14)
-        hdr := [1]uint64{eventAttr.Period}
-        pmuprof[eventId].log.write(nil, nanotime(), hdr[:], nil)
-        setpmuprofile(int32(eventId), eventAttr)
-    } else if pmuprof[eventId].on {
-        setpmuprofile(int32(eventId), nil)
-        pmuprof[eventId].on = false
-        pmuprof[eventId].addExtra(eventId)
-        pmuprof[eventId].log.close()
-    }
-    unlock(&pmuprof[eventId].lock)
-}
-
-// add adds the stack trace to the profile.
-// It is called from signal handlers and other limited environments
-// and cannot allocate memory or acquire locks that might be
-// held at the time of the signal, nor can it use substantial amounts
-// of stack.
-//go:nowritebarrierrec
-func (p *pmuProfile) add(gp *g, stk []uintptr, eventId int) {
-	// Simple cas-lock to coordinate with setpmuprofile.
-	for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
-		osyield()
-	}
-
-	if pmuEvent[eventId].eventAttr != nil { // implies pmuprof[eventId].log != nil
-		if p.numExtra > 0 || p.lostExtra > 0 {
-			p.addExtra(eventId)
-		}
-		hdr := [1]uint64{1}
-		// Note: write "knows" that the argument is &gp.labels,
-		// because otherwise its write barrier behavior may not
-		// be correct. See the long comment there before
-		// changing the argument here.
-		pmuprof[eventId].log.write(&gp.labels, nanotime(), hdr[:], stk)
-	}
-
-	atomic.Store(&pmuEvent[eventId].signalLock, 0)
-}
-
-// addNonGo adds the non-Go stack trace to the profile.
-// It is called from a non-Go thread, so we cannot use much stack at all,
-// nor do anything that needs a g or an m.
-// In particular, we can't call cpuprof.log.write.
-// Instead, we copy the stack into cpuprof.extra,
-// which will be drained the next time a Go thread
-// gets the signal handling event.
-//go:nosplit
-//go:nowritebarrierrec
-func (p *pmuProfile) addNonGo(stk []uintptr, eventId int) {
-	// (Other calls to add or addNonGo should be blocked out
-	// by the fact that only one SIGPROF can be handled by the
-	// process at a time. If not, this lock will serialize those too.)
-	for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
-		osyield()
-	}
-
-	if pmuprof[eventId].numExtra+1+len(stk) < len(pmuprof[eventId].extra) {
-		i := pmuprof[eventId].numExtra
-		pmuprof[eventId].extra[i] = uintptr(1 + len(stk))
-		copy(pmuprof[eventId].extra[i+1:], stk)
-		pmuprof[eventId].numExtra += 1 + len(stk)
-	} else {
-		pmuprof[eventId].lostExtra++
-	}
-
-	atomic.Store(&pmuEvent[eventId].signalLock, 0)
-}
-
-// addExtra adds the "extra" profiling events,
-// queued by addNonGo, to the profile log.
-// addExtra is called either from a signal handler on a Go thread
-// or from an ordinary goroutine; either way it can use stack
-// and has a g. The world may be stopped, though.
-func (p *pmuProfile) addExtra(eventId int) {
-	// Copy accumulated non-Go profile events.
-	hdr := [1]uint64{1}
-	for i := 0; i < p.numExtra; {
-		p.log.write(nil, 0, hdr[:], p.extra[i+1:i+int(p.extra[i])])
-		i += int(p.extra[i])
-	}
-	p.numExtra = 0
-
-	// Report any lost events.
-	if p.lostExtra > 0 {
-		hdr := [1]uint64{p.lostExtra}
-		lostStk := [2]uintptr{
-			funcPC(_LostExternalCode) + sys.PCQuantum,
-			funcPC(_ExternalCode) + sys.PCQuantum,
-		}
-		pmuprof[eventId].log.write(nil, 0, hdr[:], lostStk[:])
-		p.lostExtra = 0
-	}
-}
-
-func (p *pmuProfile) addLostAtomic64(count uint64, eventId int) {
-	hdr := [1]uint64{count}
-	lostStk := [2]uintptr{
-		funcPC(_LostSIGPROFDuringAtomic64) + sys.PCQuantum,
-		funcPC(_System) + sys.PCQuantum,
-	}
-	pmuprof[eventId].log.write(nil, 0, hdr[:], lostStk[:])
-}
-
-//go:linkname runtime_pprof_readPMUProfile runtime/pprof.readPMUProfile
-func runtime_pprof_readPMUProfile(eventId int) ([]uint64, []unsafe.Pointer, bool) {
-	lock(&pmuprof[eventId].lock)
-	log := pmuprof[eventId].log
-	unlock(&pmuprof[eventId].lock)
-	data, tags, eof := log.read(profBufBlocking)
-	if len(data) == 0 && eof {
-		lock(&pmuprof[eventId].lock)
-		pmuprof[eventId].log = nil
-		unlock(&pmuprof[eventId].lock)
-	}
-	return data, tags, eof
-}

From 953985d6dfe83ac2719c5e0d1efa611637fb17f8 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 8 Jul 2019 13:17:27 -0700
Subject: [PATCH 039/126] refactoring

---
 src/runtime/pprof/proto.go | 169 ++++++++++++-------------------------
 1 file changed, 55 insertions(+), 114 deletions(-)

diff --git a/src/runtime/pprof/proto.go b/src/runtime/pprof/proto.go
index 916c967e7e..14c6ddea6d 100644
--- a/src/runtime/pprof/proto.go
+++ b/src/runtime/pprof/proto.go
@@ -29,22 +29,22 @@ func funcPC(f interface{}) uintptr {
 // A profileBuilder writes a profile incrementally from a
 // stream of profile samples delivered by the runtime.
 type profileBuilder struct {
-	start      time.Time
-	end        time.Time
-	havePeriod bool
-	period     int64
+	start        time.Time
+	end          time.Time
+	havePeriod   bool
+	period       int64
     isPMUEnabled bool
-	m          profMap
+	m            profMap
 
 	// encoding state
-	w         io.Writer
-	zw        *gzip.Writer
-	pb        protobuf
-	strings   []string
-	stringMap map[string]int
-	locs      map[uintptr]int
-	funcs     map[string]int // Package path-qualified function name to Function.ID
-	mem       []memMap
+	w           io.Writer
+	zw          *gzip.Writer
+	pb          protobuf
+	strings     []string
+	stringMap   map[string]int
+	locs        map[uintptr]int
+	funcs       map[string]int // Package path-qualified function name to Function.ID
+	mem         []memMap
 }
 
 type memMap struct {
@@ -313,26 +313,8 @@ func newProfileBuilder(w io.Writer) *profileBuilder {
 	return b
 }
 
-// addCPUData adds the CPU profiling data to the profile.
-// The data must be a whole number of records,
-// as delivered by the runtime.
-func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error {
-	if !b.havePeriod {
-		// first record is period
-		if len(data) < 3 {
-			return fmt.Errorf("truncated profile")
-		}
-		if data[0] != 3 || data[2] == 0 {
-			return fmt.Errorf("malformed profile")
-		}
-		// data[2] is sampling rate in Hz. Convert to sampling
-		// period in nanoseconds.
-		b.period = 1e9 / int64(data[2])
-		b.havePeriod = true
-		data = data[3:]
-	}
-
-	// Parse CPU samples from the profile.
+func (b *profileBuilder) addData(data []uint64, tags []unsafe.Pointer) error {
+	// Parse samples from the profile.
 	// Each sample is 3+n uint64s:
 	//	data[0] = 3+n
 	//	data[1] = time stamp (ignored)
@@ -375,8 +357,11 @@ func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error
 	return nil
 }
 
-func (b *profileBuilder) addPMUData(data []uint64, tags []unsafe.Pointer) error {
-	if !b.isPMUEnabled {
+// addCPUData adds the CPU profiling data to the profile.
+// The data must be a whole number of records,
+// as delivered by the runtime.
+func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error {
+	if !b.havePeriod {
 		// first record is period
 		if len(data) < 3 {
 			return fmt.Errorf("truncated profile")
@@ -384,52 +369,34 @@ func (b *profileBuilder) addPMUData(data []uint64, tags []unsafe.Pointer) error
 		if data[0] != 3 || data[2] == 0 {
 			return fmt.Errorf("malformed profile")
 		}
-		b.isPMUEnabled = true
-        b.period = int64(data[2])
+		// data[2] is sampling rate in Hz. Convert to sampling
+		// period in nanoseconds.
+		b.period = 1e9 / int64(data[2])
+		b.havePeriod = true
 		data = data[3:]
 	}
 
-	for len(data) > 0 {
-		if len(data) < 3 || data[0] > uint64(len(data)) {
+    return b.addData(data, tags)
+}
+
+func (b *profileBuilder) addPMUData(data []uint64, tags []unsafe.Pointer) error {
+	if !b.isPMUEnabled {
+		// first record is period
+		if len(data) < 3 {
 			return fmt.Errorf("truncated profile")
 		}
-		if data[0] < 3 || tags != nil && len(tags) < 1 {
+		if data[0] != 3 || data[2] == 0 {
 			return fmt.Errorf("malformed profile")
 		}
-		count := data[2]
-		stk := data[3:data[0]]
-		data = data[data[0]:]
-		var tag unsafe.Pointer
-		if tags != nil {
-			tag = tags[0]
-			tags = tags[1:]
-		}
-
-		if count == 0 && len(stk) == 1 {
-			// overflow record
-			count = uint64(stk[0])
-			stk = []uint64{
-				uint64(funcPC(lostProfileEvent)),
-			}
-		}
-		b.m.lookup(stk, tag).count += int64(count)
+		b.isPMUEnabled = true
+        b.period = int64(data[2])
+		data = data[3:]
 	}
-	return nil
-}
-
-// build completes and returns the constructed profile.
-func (b *profileBuilder) build() {
-	b.end = time.Now()
 
-	b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano())
-	if b.havePeriod { // must be CPU profile
-		b.pbValueType(tagProfile_SampleType, "samples", "count")
-        b.pbValueType(tagProfile_SampleType, "cpu", "nanoseconds")
-		b.pb.int64Opt(tagProfile_DurationNanos, b.end.Sub(b.start).Nanoseconds())
-		b.pbValueType(tagProfile_PeriodType, "cpu", "nanoseconds")
-		b.pb.int64Opt(tagProfile_Period, b.period)
-	}
+    return b.addData(data, tags)
+}
 
+func (b *profileBuilder) profileBuild() {
 	values := []int64{0, 0}
 	var locs []uint64
 	for e := b.m.all; e != nil; e = e.nextAll {
@@ -478,6 +445,22 @@ func (b *profileBuilder) build() {
 	b.zw.Close()
 }
 
+// build completes and returns the constructed profile.
+func (b *profileBuilder) build() {
+	b.end = time.Now()
+
+	b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano())
+	if b.havePeriod { // must be CPU profile
+		b.pbValueType(tagProfile_SampleType, "samples", "count")
+        b.pbValueType(tagProfile_SampleType, "cpu", "nanoseconds")
+		b.pb.int64Opt(tagProfile_DurationNanos, b.end.Sub(b.start).Nanoseconds())
+		b.pbValueType(tagProfile_PeriodType, "cpu", "nanoseconds")
+		b.pb.int64Opt(tagProfile_Period, b.period)
+	}
+    
+    b.profileBuild()
+}
+
 func (b *profileBuilder) pmuBuild(eventName string) {
 	b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano())
     b.pbValueType(tagProfile_SampleType, "samples", "count")
@@ -485,49 +468,7 @@ func (b *profileBuilder) pmuBuild(eventName string) {
     b.pbValueType(tagProfile_PeriodType, eventName, "count")
 	b.pb.int64Opt(tagProfile_Period, b.period)
 	
-    values := []int64{0, 0}
-	var locs []uint64
-	for e := b.m.all; e != nil; e = e.nextAll {
-		values[0] = e.count
-		values[1] = e.count * b.period
-
-		var labels func()
-		if e.tag != nil {
-			labels = func() {
-				for k, v := range *(*labelMap)(e.tag) {
-					b.pbLabel(tagSample_Label, k, v, 0)
-				}
-			}
-		}
-
-		locs = locs[:0]
-		for i, addr := range e.stk {
-			// Addresses from stack traces point to the
-			// next instruction after each call, except
-			// for the leaf, which points to where the
-			// signal occurred. locForPC expects return
-			// PCs, so increment the leaf address to look
-			// like a return PC.
-			if i == 0 {
-				addr++
-			}
-			l := b.locForPC(addr)
-			if l == 0 { // runtime.goexit
-				continue
-			}
-			locs = append(locs, l)
-		}
-		b.pbSample(values, locs, labels)
-	}
-
-	for i, m := range b.mem {
-		hasFunctions := m.funcs == lookupTried // lookupTried but not lookupFailed
-		b.pbMapping(tagProfile_Mapping, uint64(i+1), uint64(m.start), uint64(m.end), m.offset, m.file, m.buildID, hasFunctions)
-	}
-	
-    b.pb.strings(tagProfile_StringTable, b.strings)
-	b.zw.Write(b.pb.data)
-	b.zw.Close()
+    b.profileBuild()
 }
 
 // readMapping reads /proc/self/maps and writes mappings to b.pb.

From 5dd098118469ee5ce86f8800ac45acf3d5c0e657 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 8 Jul 2019 13:18:19 -0700
Subject: [PATCH 040/126] remove

---
 src/runtime/defs_user_data.go | 11 -----------
 1 file changed, 11 deletions(-)
 delete mode 100644 src/runtime/defs_user_data.go

diff --git a/src/runtime/defs_user_data.go b/src/runtime/defs_user_data.go
deleted file mode 100644
index 988fe53de5..0000000000
--- a/src/runtime/defs_user_data.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// created by cgo -cdefs and then converted to Go
-// cgo -cdefs defs_linux.go defs1_linux.go
-
-package runtime
-
-type PMUEvent struct {
-    Cat       uint32 // don't use type, which is a keyword reserved in golang
-    Code      uint64
-    Period    uint64
-    PreciseIP uint8
-}

From a1c64d0328deaa3f689ef0eb72eff4ddef70eb2f Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 8 Jul 2019 13:59:39 -0700
Subject: [PATCH 041/126] refactoring

---
 src/runtime/defs_linux_amd64.go  |  9 +++------
 src/runtime/defs_pmu.go          | 10 +++++-----
 src/runtime/pprof/pprof.go       | 20 ++++++++++----------
 src/runtime/proc.go              |  4 ++--
 src/runtime/signal_sighandler.go |  4 ++--
 src/runtime/signal_unix.go       |  8 ++++----
 src/runtime/sys_linux_amd64.s    |  6 +++---
 7 files changed, 29 insertions(+), 32 deletions(-)

diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index b7924ee29c..ccf28f63fa 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -57,7 +57,7 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
-    _SIGPMU    = 0x25
+	_SIGPMU    = 0x25
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
@@ -128,11 +128,8 @@ type siginfo struct {
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
 	si_addr  uint64
-    
-    // psu: an unreliable workaround and need to figure out a better solution
-    // si_fd    int64 
-    si_fd    int32 
-
+	// an unreliable workaround and need to figure out a better solution
+	si_fd    int32
 }
 
 type itimerval struct {
diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index 6030a5061c..d2b890077b 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -5,7 +5,7 @@ package runtime
 
 const (
 	GO_COUNT_HW_CPU_CYCLES              = 0x0
-    GO_COUNT_HW_INSTRUCTIONS            = 0x1
+	GO_COUNT_HW_INSTRUCTIONS            = 0x1
 	GO_COUNT_HW_CACHE_REFERENCES        = 0x2
 	GO_COUNT_HW_CACHE_MISSES            = 0x3
 	GO_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
@@ -14,8 +14,8 @@ const (
 	GO_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
 	GO_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
 	GO_COUNT_HW_REF_CPU_CYCLES          = 0x9
-	
-    GO_COUNT_HW_CACHE_L1D  = 0xa
+
+	GO_COUNT_HW_CACHE_L1D  = 0xa
 	GO_COUNT_HW_CACHE_L1I  = 0xb
 	GO_COUNT_HW_CACHE_LL   = 0xc
 	GO_COUNT_HW_CACHE_DTLB = 0xd
@@ -26,8 +26,8 @@ const (
 	GO_COUNT_HW_CACHE_OP_READ     = 0x11
 	GO_COUNT_HW_CACHE_OP_WRITE    = 0x12
 	GO_COUNT_HW_CACHE_OP_PREFETCH = 0x13
-	
-    GO_COUNT_HW_CACHE_RESULT_ACCESS = 0x14
+
+	GO_COUNT_HW_CACHE_RESULT_ACCESS = 0x14
 	GO_COUNT_HW_CACHE_RESULT_MISS   = 0x15
 
 	GO_COUNT_SW_CPU_CLOCK        = 0x16
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 0a4dab3e8a..256dfb7a53 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -73,10 +73,10 @@
 package pprof
 
 import (
-    "bufio"
+	"bufio"
 	"bytes"
 	"errors"
-    "fmt"
+	"fmt"
 	"io"
 	"runtime"
 	"sort"
@@ -774,15 +774,15 @@ const maxPMUEvent = 10
 var pmu struct {
 	sync.Mutex
 	profiling bool
-    eventOn   [maxPMUEvent]bool
-    wg        sync.WaitGroup
+	eventOn   [maxPMUEvent]bool
+	wg        sync.WaitGroup
 }
 
 func StartPMUProfile(opts ...ProfilingOption) error {
     if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
         return errors.New("not implemented")
     }
-	
+
     pmu.Lock()
 	defer pmu.Unlock()
     pmu.wg.Add(len(opts))
@@ -791,7 +791,7 @@ func StartPMUProfile(opts ...ProfilingOption) error {
 		return fmt.Errorf("pmu profiling already in use")
 	}
 	pmu.profiling = true
-  	
+
     for _, opt := range opts {
 	    if err := opt.apply(); err != nil {
 			return err
@@ -851,7 +851,7 @@ func WithProfilingInstr(w io.Writer, eventConfig *PMUEventConfig) ProfilingOptio
             eventConfig.Period = 300
         }
         pmu.eventOn[1] = true
-        
+
         instr := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
                                       PreciseIP: getPreciseIP(eventConfig.PreciseIP),
                                       IsKernelIncluded: eventConfig.IsKernelIncluded,
@@ -868,7 +868,7 @@ func WithProfilingCacheRef(w io.Writer, eventConfig *PMUEventConfig) ProfilingOp
             return errors.New("Period should be > 0")
         }
         pmu.eventOn[2] = true
-        
+
         cacheRef := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
                                          PreciseIP: getPreciseIP(eventConfig.PreciseIP),
                                          IsKernelIncluded: eventConfig.IsKernelIncluded,
@@ -885,7 +885,7 @@ func WithProfilingCacheMiss(w io.Writer, eventConfig *PMUEventConfig) ProfilingO
             return errors.New("Period should be > 0")
         }
         pmu.eventOn[3] = true
-        
+
         cacheMiss := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
                                           PreciseIP: getPreciseIP(eventConfig.PreciseIP),
                                           IsKernelIncluded: eventConfig.IsKernelIncluded,
@@ -978,7 +978,7 @@ func StopPMUProfile() {
 		return
 	}
     pmu.profiling = false
-   
+
     for i := 0; i < maxPMUEvent; i++ {
         if pmu.eventOn[i] {
             runtime.SetPMUProfile(i, nil)
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 38af8647da..1586bed3a7 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2134,7 +2134,7 @@ func gcstopm() {
 // acquiring a P in several places.
 //
 //go:yeswritebarrierrec
-func execute(gp *g, inheritTime bool) { 
+func execute(gp *g, inheritTime bool) {
 	_g_ := getg()
 
 	casgstatus(gp, _Grunnable, _Grunning)
@@ -3637,7 +3637,7 @@ func _ExternalCode()              { _ExternalCode() }
 func _LostExternalCode()          { _LostExternalCode() }
 func _GC()                        { _GC() }
 func _LostSIGPROFDuringAtomic64() { _LostSIGPROFDuringAtomic64() }
-func _LostSIGPMUDuringAtomic64() { _LostSIGPMUDuringAtomic64() }
+func _LostSIGPMUDuringAtomic64()  { _LostSIGPMUDuringAtomic64() }
 func _VDSO()                      { _VDSO() }
 
 func stackUnwinding(pc, sp, lr uintptr, gp *g, mp *m, stk []uintptr) int {
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index 0bb8eef5a9..bb7a33d0b9 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -37,7 +37,7 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
     if sig == _SIGPMU {
         fd := info.si_fd
         ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
-        
+
         var eventId int = -1
         for i := 0; i < maxPMUEvent; i++ {
             if _g_.m.eventFds[i] == fd {
@@ -52,7 +52,7 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
         ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
         return
 	}
-    
+
     if sig == _SIGPROF {
         sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
         return
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index c8ae3724f8..fcd3590eef 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -142,7 +142,7 @@ func sigInstallGoHandler(sig uint32) bool {
 }
 
 func isProfilingSignal(sig uint32) bool {
-    if sig == _SIGPROF  || sig == _SIGPMU {
+    if sig == _SIGPROF || sig == _SIGPMU {
         return true
     }
     return false
@@ -160,7 +160,7 @@ func sigenable(sig uint32) {
     if isProfilingSignal(sig) {
 		return
 	}
-	
+
 	t := &sigtable[sig]
 	if t.flags&_SigNotify != 0 {
 		ensureSigM()
@@ -294,7 +294,7 @@ func setThreadCPUProfiler(hz int32) {
 
 func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
     _g_ := getg()
-    
+
     if eventAttr == nil {
         if _g_.m.eventAttrs[eventId] != nil {
             closefd(_g_.m.eventFds[eventId])
@@ -312,7 +312,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
         if !eventAttr.IsHvIncluded { // don't count hypervisor
             perfAttr.Bits += 0b1000000
         }
-        
+
         fd, _, _ := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy*/ 0)
         _g_.m.eventFds[eventId] = fd
         r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 64dd7160d1..2a9663683a 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -193,7 +193,7 @@ ok:
 
 // func ioctl(fd int32, req, arg int64) int64
 TEXT runtime·ioctl(SB),NOSPLIT,$0
-	MOVL	fd+0(FP), DI 
+	MOVL	fd+0(FP), DI
 	MOVQ	req+8(FP), SI
 	MOVQ	arg+16(FP), DX
     MOVQ	$SYS_ioctl, AX
@@ -203,7 +203,7 @@ TEXT runtime·ioctl(SB),NOSPLIT,$0
 
 // func fcntl(fd int32, cmd arg int64) (r int64, err int64)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
-	MOVL	fd+0(FP), DI 
+	MOVL	fd+0(FP), DI
 	MOVQ	cmd+8(FP), SI
 	MOVQ	arg+16(FP), DX
     MOVQ	$SYS_fcntl, AX
@@ -220,7 +220,7 @@ ok:
 	RET
 
 TEXT runtime·fcntl2(SB),NOSPLIT,$0
-	MOVL	fd+0(FP), DI 
+	MOVL	fd+0(FP), DI
 	MOVQ	cmd+8(FP), SI
 	MOVQ	arg+16(FP), DX
     MOVQ	$SYS_fcntl, AX

From 8464003b4be4cc3a709d1ee93579cbfc7cb8a2c2 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 8 Jul 2019 14:36:00 -0700
Subject: [PATCH 042/126] refactoring

---
 src/runtime/pprof/pprof.go | 51 ++++++++++++++------------------------
 1 file changed, 19 insertions(+), 32 deletions(-)

diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 256dfb7a53..4906136d60 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -818,24 +818,28 @@ func getPreciseIP(preciseIP int8) uint8 {
     return uint8(preciseIP)
 }
 
+func helper(w io.Writer, eventConfig *PMUEventConfig, eventId int, eventName string) {
+        pmu.eventOn[eventId] = true
+        eventAttr := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
+                                      PreciseIP: getPreciseIP(eventConfig.PreciseIP),
+                                      IsKernelIncluded: eventConfig.IsKernelIncluded,
+                                      IsHvIncluded: eventConfig.IsHvIncluded}
+        runtime.SetPMUProfile(eventId, &eventAttr)
+        go pmuProfileWriter(w, eventId, eventName)
+
+}
+
 func WithProfilingCycle(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
        if eventConfig.Period <= 0 {
             return errors.New("Period should be > 0")
         }
         // Clamp period to something reasonable
-        // Refer to hpctoolkit
         if eventConfig.Period < 300 {
             eventConfig.Period = 300
         }
-        pmu.eventOn[0] = true
 
-        cycle := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
-                                      PreciseIP: getPreciseIP(eventConfig.PreciseIP),
-                                      IsKernelIncluded: eventConfig.IsKernelIncluded,
-                                      IsHvIncluded: eventConfig.IsHvIncluded}
-        runtime.SetPMUProfile(/*event ID*/ 0, &cycle)
-        go pmuProfileWriter(w, /*event ID*/ 0, "cycles")
+        helper(w, eventConfig, /*event ID*/ 0, /*event Name*/ "cycles")
 		return nil
 	})
 }
@@ -846,18 +850,11 @@ func WithProfilingInstr(w io.Writer, eventConfig *PMUEventConfig) ProfilingOptio
             return errors.New("Period should be > 0")
         }
         // Clamp period to something reasonable
-        // Refer to hpctoolkit
         if eventConfig.Period < 300 {
             eventConfig.Period = 300
         }
-        pmu.eventOn[1] = true
 
-        instr := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
-                                      PreciseIP: getPreciseIP(eventConfig.PreciseIP),
-                                      IsKernelIncluded: eventConfig.IsKernelIncluded,
-                                      IsHvIncluded: eventConfig.IsHvIncluded}
-		runtime.SetPMUProfile(/*event ID*/ 1, &instr)
-        go pmuProfileWriter(w, /*event ID*/ 1, "instructions")
+        helper(w, eventConfig, /*event ID*/ 1, /*event Name*/ "instructions")
 		return nil
 	})
 }
@@ -867,14 +864,9 @@ func WithProfilingCacheRef(w io.Writer, eventConfig *PMUEventConfig) ProfilingOp
         if eventConfig.Period <= 0 {
             return errors.New("Period should be > 0")
         }
-        pmu.eventOn[2] = true
-
-        cacheRef := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
-                                         PreciseIP: getPreciseIP(eventConfig.PreciseIP),
-                                         IsKernelIncluded: eventConfig.IsKernelIncluded,
-                                         IsHvIncluded: eventConfig.IsHvIncluded}
-		runtime.SetPMUProfile(/*event ID*/ 2, &cacheRef)
-        go pmuProfileWriter(w, /*event ID*/ 2, "cache references")
+        // TODO: Clamp period to something reasonable
+
+        helper(w, eventConfig, /*event ID*/ 2, /*event Name*/ "cache references")
 		return nil
 	})
 }
@@ -884,14 +876,9 @@ func WithProfilingCacheMiss(w io.Writer, eventConfig *PMUEventConfig) ProfilingO
         if eventConfig.Period <= 0 {
             return errors.New("Period should be > 0")
         }
-        pmu.eventOn[3] = true
-
-        cacheMiss := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
-                                          PreciseIP: getPreciseIP(eventConfig.PreciseIP),
-                                          IsKernelIncluded: eventConfig.IsKernelIncluded,
-                                          IsHvIncluded: eventConfig.IsHvIncluded}
-		runtime.SetPMUProfile(/*event ID*/ 3, &cacheMiss)
-        go pmuProfileWriter(w, /*event ID*/ 3, "cache misses")
+        // TODO: Clamp period to something reasonable
+
+        helper(w, eventConfig, /*event ID*/ 3, /*event Name*/ "cache misses")
 		return nil
 	})
 }

From 2f7b4b1b1723cd108031e23c399103f0bc5ea6d0 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 9 Jul 2019 12:19:30 -0700
Subject: [PATCH 043/126] http

---
 src/net/http/pprof/pprof.go | 70 +++++++++++++++++++++++++++++++++----
 src/runtime/pprof/pprof.go  |  2 +-
 2 files changed, 64 insertions(+), 8 deletions(-)

diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index 35b3285a08..d7faed13fe 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -54,6 +54,7 @@ package pprof
 import (
 	"bufio"
 	"bytes"
+	"errors"
 	"fmt"
 	"html/template"
 	"io"
@@ -110,6 +111,42 @@ func serveError(w http.ResponseWriter, status int, txt string) {
 	fmt.Fprintln(w, txt)
 }
 
+func pmuProfile(w http.ResponseWriter, r *http.Request) error {
+    var eventConfig pprof.PMUEventConfig
+
+    period, err := strconv.ParseInt(r.FormValue("period"), 10, 64)
+    if err == nil {
+        eventConfig.Period = period
+    }
+    preciseIP, err := strconv.ParseInt(r.FormValue("preciseIP"), 10, 8)
+    if err == nil {
+        eventConfig.PreciseIP = int8(preciseIP)
+    }
+    isKernelIncluded, err := strconv.ParseBool(r.FormValue("kernel"))
+    if err == nil {
+        eventConfig.IsKernelIncluded = isKernelIncluded
+    }
+    isHvIncluded, err := strconv.ParseBool(r.FormValue("hv"))
+    if err == nil {
+        eventConfig.IsHvIncluded = isHvIncluded
+    }
+
+    switch eventName := r.FormValue("event"); eventName {
+        case "cycles":
+            err = pprof.StartPMUProfile(pprof.WithProfilingCycle(w, &eventConfig))
+        case "instructions":
+            err = pprof.StartPMUProfile(pprof.WithProfilingInstr(w, &eventConfig))
+        case "cacheReferences":
+            err = pprof.StartPMUProfile(pprof.WithProfilingCacheRef(w, &eventConfig))
+        case "cacheMisses":
+            err = pprof.StartPMUProfile(pprof.WithProfilingCacheMiss(w, &eventConfig))
+        default:
+            return errors.New("uknown event")
+    }
+
+    return err
+}
+
 // Profile responds with the pprof-formatted cpu profile.
 // Profiling lasts for duration specified in seconds GET parameter, or for 30 seconds if not specified.
 // The package initialization registers it as /debug/pprof/profile.
@@ -129,14 +166,33 @@ func Profile(w http.ResponseWriter, r *http.Request) {
 	// because if it does it starts writing.
 	w.Header().Set("Content-Type", "application/octet-stream")
 	w.Header().Set("Content-Disposition", `attachment; filename="profile"`)
-	if err := pprof.StartCPUProfile(w); err != nil {
-		// StartCPUProfile failed, so no writes yet.
-		serveError(w, http.StatusInternalServerError,
+
+    isPMUEnabled, err := strconv.ParseBool(r.FormValue("pmu"))
+    if err != nil || isPMUEnabled == false {
+	    if err := pprof.StartCPUProfile(w); err != nil {
+		    // StartCPUProfile failed, so no writes yet.
+		    serveError(w, http.StatusInternalServerError,
 			fmt.Sprintf("Could not enable CPU profiling: %s", err))
-		return
-	}
-	sleep(w, time.Duration(sec)*time.Second)
-	pprof.StopCPUProfile()
+		    return
+	    }
+    } else if err == nil && isPMUEnabled == true {
+        if err = pmuProfile(w, r); err != nil {
+		    serveError(w, http.StatusInternalServerError,
+			fmt.Sprintf("Could not enable PMU profiling: %s", err))
+		    return
+        }
+    } else {
+		    serveError(w, http.StatusInternalServerError,
+			fmt.Sprintf("Could not enable CPU or PMU profiling: %s", err))
+		    return
+    }
+
+    sleep(w, time.Duration(sec)*time.Second)
+    if isPMUEnabled == true {
+	    pprof.StopPMUProfile()
+    } else {
+	    pprof.StopCPUProfile()
+    }
 }
 
 // Trace responds with the execution trace in binary form.
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 4906136d60..0836bfc59f 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -788,7 +788,7 @@ func StartPMUProfile(opts ...ProfilingOption) error {
     pmu.wg.Add(len(opts))
     // Double-check.
 	if pmu.profiling {
-		return fmt.Errorf("pmu profiling already in use")
+		return errors.New("pmu profiling already in use")
 	}
 	pmu.profiling = true
 

From 1ce06b9e4bb0cb27f7fabf028393a536cf2c4142 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 9 Jul 2019 12:26:31 -0700
Subject: [PATCH 044/126] test

---
 test/run.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/run.go b/test/run.go
index ff1fcef9b1..7f6edfc111 100644
--- a/test/run.go
+++ b/test/run.go
@@ -50,7 +50,7 @@ var (
 
 	// dirs are the directories to look for *.go files in.
 	// TODO(bradfitz): just use all directories?
-	dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime", "pmu/cycle"}
+	dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime", "pmu"}
 
 	// ratec controls the max number of tests running at a time.
 	ratec chan bool

From a6860bf7b239a663be84c65e2d0e26a0368e6235 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 9 Jul 2019 19:48:37 -0700
Subject: [PATCH 045/126] indentation

---
 src/net/http/pprof/pprof.go | 116 ++++++++++++++++++------------------
 1 file changed, 58 insertions(+), 58 deletions(-)

diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index d7faed13fe..9793cc7d09 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -112,39 +112,39 @@ func serveError(w http.ResponseWriter, status int, txt string) {
 }
 
 func pmuProfile(w http.ResponseWriter, r *http.Request) error {
-    var eventConfig pprof.PMUEventConfig
-
-    period, err := strconv.ParseInt(r.FormValue("period"), 10, 64)
-    if err == nil {
-        eventConfig.Period = period
-    }
-    preciseIP, err := strconv.ParseInt(r.FormValue("preciseIP"), 10, 8)
-    if err == nil {
-        eventConfig.PreciseIP = int8(preciseIP)
-    }
-    isKernelIncluded, err := strconv.ParseBool(r.FormValue("kernel"))
-    if err == nil {
-        eventConfig.IsKernelIncluded = isKernelIncluded
-    }
-    isHvIncluded, err := strconv.ParseBool(r.FormValue("hv"))
-    if err == nil {
-        eventConfig.IsHvIncluded = isHvIncluded
-    }
-
-    switch eventName := r.FormValue("event"); eventName {
-        case "cycles":
-            err = pprof.StartPMUProfile(pprof.WithProfilingCycle(w, &eventConfig))
-        case "instructions":
-            err = pprof.StartPMUProfile(pprof.WithProfilingInstr(w, &eventConfig))
-        case "cacheReferences":
-            err = pprof.StartPMUProfile(pprof.WithProfilingCacheRef(w, &eventConfig))
-        case "cacheMisses":
-            err = pprof.StartPMUProfile(pprof.WithProfilingCacheMiss(w, &eventConfig))
-        default:
-            return errors.New("uknown event")
-    }
-
-    return err
+	var eventConfig pprof.PMUEventConfig
+
+	period, err := strconv.ParseInt(r.FormValue("period"), 10, 64)
+	if err == nil {
+		eventConfig.Period = period
+	}
+	preciseIP, err := strconv.ParseInt(r.FormValue("preciseIP"), 10, 8)
+	if err == nil {
+		eventConfig.PreciseIP = int8(preciseIP)
+	}
+	isKernelIncluded, err := strconv.ParseBool(r.FormValue("kernel"))
+	if err == nil {
+		eventConfig.IsKernelIncluded = isKernelIncluded
+	}
+	isHvIncluded, err := strconv.ParseBool(r.FormValue("hv"))
+	if err == nil {
+		eventConfig.IsHvIncluded = isHvIncluded
+	}
+
+	switch eventName := r.FormValue("event"); eventName {
+		case "cycles":
+			err = pprof.StartPMUProfile(pprof.WithProfilingCycle(w, &eventConfig))
+		case "instructions":
+			err = pprof.StartPMUProfile(pprof.WithProfilingInstr(w, &eventConfig))
+		case "cacheReferences":
+			err = pprof.StartPMUProfile(pprof.WithProfilingCacheRef(w, &eventConfig))
+		case "cacheMisses":
+			err = pprof.StartPMUProfile(pprof.WithProfilingCacheMiss(w, &eventConfig))
+		default:
+			return errors.New("uknown event")
+	}
+
+	return err
 }
 
 // Profile responds with the pprof-formatted cpu profile.
@@ -167,32 +167,32 @@ func Profile(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/octet-stream")
 	w.Header().Set("Content-Disposition", `attachment; filename="profile"`)
 
-    isPMUEnabled, err := strconv.ParseBool(r.FormValue("pmu"))
-    if err != nil || isPMUEnabled == false {
-	    if err := pprof.StartCPUProfile(w); err != nil {
-		    // StartCPUProfile failed, so no writes yet.
-		    serveError(w, http.StatusInternalServerError,
-			fmt.Sprintf("Could not enable CPU profiling: %s", err))
-		    return
-	    }
-    } else if err == nil && isPMUEnabled == true {
-        if err = pmuProfile(w, r); err != nil {
-		    serveError(w, http.StatusInternalServerError,
-			fmt.Sprintf("Could not enable PMU profiling: %s", err))
-		    return
-        }
-    } else {
-		    serveError(w, http.StatusInternalServerError,
+	isPMUEnabled, err := strconv.ParseBool(r.FormValue("pmu"))
+	if err != nil || isPMUEnabled == false {
+		if err := pprof.StartCPUProfile(w); err != nil {
+			// StartCPUProfile failed, so no writes yet.
+			serveError(w, http.StatusInternalServerError,
+				fmt.Sprintf("Could not enable CPU profiling: %s", err))
+			return
+		}
+	} else if err == nil && isPMUEnabled == true {
+		if err = pmuProfile(w, r); err != nil {
+			serveError(w, http.StatusInternalServerError,
+				fmt.Sprintf("Could not enable PMU profiling: %s", err))
+			return
+		}
+	} else {
+		serveError(w, http.StatusInternalServerError,
 			fmt.Sprintf("Could not enable CPU or PMU profiling: %s", err))
-		    return
-    }
-
-    sleep(w, time.Duration(sec)*time.Second)
-    if isPMUEnabled == true {
-	    pprof.StopPMUProfile()
-    } else {
-	    pprof.StopCPUProfile()
-    }
+		return
+	}
+
+	sleep(w, time.Duration(sec)*time.Second)
+	if isPMUEnabled == true {
+		pprof.StopPMUProfile()
+	} else {
+		pprof.StopCPUProfile()
+	}
 }
 
 // Trace responds with the execution trace in binary form.

From 449a5b1727a31bb22297160208bf1180dec1926d Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 9 Jul 2019 19:48:54 -0700
Subject: [PATCH 046/126] indentation

---
 src/runtime/cpuprof.go           |  40 +++----
 src/runtime/defs_linux_amd64.go  |  77 +++++++-------
 src/runtime/defs_pmu.go          |   8 +-
 src/runtime/pprof/pprof.go       | 177 +++++++++++++++----------------
 src/runtime/pprof/proto.go       |  20 ++--
 src/runtime/proc.go              |  81 +++++++-------
 src/runtime/signal_sighandler.go |  44 ++++----
 src/runtime/signal_unix.go       | 124 +++++++++++-----------
 src/runtime/sys_linux_amd64.s    |   8 +-
 9 files changed, 288 insertions(+), 291 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index 11e2848a20..e11990e6b9 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -87,26 +87,26 @@ func SetCPUProfileRate(hz int) {
 }
 
 func SetPMUProfile(eventId int, eventAttr *PMUEventAttr) {
-    lock(&pmuprof[eventId].lock)
-    if eventAttr != nil {
-        if pmuprof[eventId].on || pmuprof[eventId].log != nil {
-            print("runtime: cannot set pmu profile rate until previous profile has finished.\n")
-            unlock(&pmuprof[eventId].lock)
-            return
-        }
-
-        pmuprof[eventId].on = true
-        pmuprof[eventId].log = newProfBuf(1, 1<<17, 1<<14)
-        hdr := [1]uint64{eventAttr.Period}
-        pmuprof[eventId].log.write(nil, nanotime(), hdr[:], nil)
-        setpmuprofile(int32(eventId), eventAttr)
-    } else if pmuprof[eventId].on {
-        setpmuprofile(int32(eventId), nil)
-        pmuprof[eventId].on = false
-        pmuprof[eventId].addExtra(eventId)
-        pmuprof[eventId].log.close()
-    }
-    unlock(&pmuprof[eventId].lock)
+	lock(&pmuprof[eventId].lock)
+	if eventAttr != nil {
+		if pmuprof[eventId].on || pmuprof[eventId].log != nil {
+		print("runtime: cannot set pmu profile rate until previous profile has finished.\n")
+		unlock(&pmuprof[eventId].lock)
+		return
+		}
+
+		pmuprof[eventId].on = true
+		pmuprof[eventId].log = newProfBuf(1, 1<<17, 1<<14)
+		hdr := [1]uint64{eventAttr.Period}
+		pmuprof[eventId].log.write(nil, nanotime(), hdr[:], nil)
+		setpmuprofile(int32(eventId), eventAttr)
+	} else if pmuprof[eventId].on {
+		setpmuprofile(int32(eventId), nil)
+		pmuprof[eventId].on = false
+		pmuprof[eventId].addExtra(eventId)
+		pmuprof[eventId].log.close()
+	}
+	unlock(&pmuprof[eventId].lock)
 }
 
 // add adds the stack trace to the profile.
diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index ccf28f63fa..1da683320d 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -377,53 +377,52 @@ const (
 	PERF_FLAG_PID_CGROUP  = 0x4
 	PERF_FLAG_FD_CLOEXEC  = 0x8
 
-    PERF_EVENT_IOC_DISABLE               = 0x2401
-    PERF_EVENT_IOC_ENABLE                = 0x2400
-    PERF_EVENT_IOC_ID                    = 0x80082407
-    PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
-    PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
-    PERF_EVENT_IOC_PERIOD                = 0x40082404
-    PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
-    PERF_EVENT_IOC_REFRESH               = 0x2402
-    PERF_EVENT_IOC_RESET                 = 0x2403
-    PERF_EVENT_IOC_SET_BPF               = 0x40042408
-    PERF_EVENT_IOC_SET_FILTER            = 0x40082406
-    PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+	PERF_EVENT_IOC_DISABLE               = 0x2401
+	PERF_EVENT_IOC_ENABLE                = 0x2400
+	PERF_EVENT_IOC_ID                    = 0x80082407
+	PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
+	PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
+	PERF_EVENT_IOC_PERIOD                = 0x40082404
+	PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
+	PERF_EVENT_IOC_REFRESH               = 0x2402
+	PERF_EVENT_IOC_RESET                 = 0x2403
+	PERF_EVENT_IOC_SET_BPF               = 0x40042408
+	PERF_EVENT_IOC_SET_FILTER            = 0x40082406
+	PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
 )
 
 type perfEventAttr struct {
-    Type               uint32
-    Size               uint32
-    Config             uint64
-    Sample             uint64
-    Sample_type        uint64
-    Read_format        uint64
-    Bits               uint64
-    Wakeup             uint32
-    Bp_type            uint32
-    Ext1               uint64
-    Ext2               uint64
-    Branch_sample_type uint64
-    Sample_regs_user   uint64
-    Sample_stack_user  uint32
-    Clockid            int32
-    Sample_regs_intr   uint64
-    Aux_watermark      uint32
-    _                  uint32
+	Type               uint32
+	Size               uint32
+	Config             uint64
+	Sample             uint64
+	Sample_type        uint64
+	Read_format        uint64
+	Bits               uint64
+	Wakeup             uint32
+	Bp_type            uint32
+	Ext1               uint64
+	Ext2               uint64
+	Branch_sample_type uint64
+	Sample_regs_user   uint64
+	Sample_stack_user  uint32
+	Clockid            int32
+	Sample_regs_intr   uint64
+	Aux_watermark      uint32
+	_                  uint32
 }
 
 type fOwnerEx struct {
-    Type int32
-    Pid int32
-
+	Type int32
+	Pid int32
 }
 
 var perfEventOpt = []struct {
-    Type    uint32
-    Config  uint64
+	Type    uint32
+	 Config  uint64
 } {
-    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES},
-    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS},
-    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES},
-    {PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES},
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES},
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS},
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES},
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES},
 }
diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index d2b890077b..32bacc56cf 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -37,8 +37,8 @@ const (
 )
 
 type PMUEventAttr struct {
-    Period           uint64
-    PreciseIP        uint8
-    IsKernelIncluded bool
-    IsHvIncluded     bool
+	Period           uint64
+	PreciseIP        uint8
+	IsKernelIncluded bool
+	IsHvIncluded     bool
 }
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 0836bfc59f..2a0bb4b913 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -740,35 +740,34 @@ var cpu struct {
 // for syscall.SIGPROF, but note that doing so may break any profiling
 // being done by the main program.
 func StartCPUProfile(w io.Writer, profileHz ...int) error {
-    // The runtime routines allow a variable profiling rate,
-    // but in practice operating systems cannot trigger signals
-    // at more than about 500 Hz, and our processing of the
-    // signal is not cheap (mostly getting the stack trace).
-    // 100 Hz is a reasonable choice: it is frequent enough to
-    // produce useful data, rare enough not to bog down the
-    // system, and a nice round number to make it easy to
-    // convert sample counts to seconds. Instead of requiring
-    // each client to specify the frequency, we hard code it.
-    
-    var hz = 100
-    if len(profileHz) != 0 {
-        hz = profileHz[0]
-    }
-
-    cpu.Lock()
-    defer cpu.Unlock()
-    if cpu.done == nil {
-        cpu.done = make(chan bool)
-    }
-    // Double-check.
-    if cpu.profiling {
-        return fmt.Errorf("cpu profiling already in use")
-    }
-    cpu.profiling = true
-    runtime.SetCPUProfileRate(hz)
-    go profileWriter(w)
-    return nil
-}
+	// The runtime routines allow a variable profiling rate,
+	// but in practice operating systems cannot trigger signals
+	// at more than about 500 Hz, and our processing of the
+	// signal is not cheap (mostly getting the stack trace).
+	// 100 Hz is a reasonable choice: it is frequent enough to
+	// produce useful data, rare enough not to bog down the
+	// system, and a nice round number to make it easy to
+	// convert sample counts to seconds. Instead of requiring
+	// each client to specify the frequency, we hard code it.
+	var hz = 100
+	if len(profileHz) != 0 {
+		hz = profileHz[0]
+	}
+
+	cpu.Lock()
+	defer cpu.Unlock()
+	if cpu.done == nil {
+		cpu.done = make(chan bool)
+	}
+	// Double-check.
+	if cpu.profiling {
+		return fmt.Errorf("cpu profiling already in use")
+	}
+	cpu.profiling = true
+	runtime.SetCPUProfileRate(hz)
+	go profileWriter(w)
+	return nil
+	}
 
 const maxPMUEvent = 10
 var pmu struct {
@@ -779,21 +778,21 @@ var pmu struct {
 }
 
 func StartPMUProfile(opts ...ProfilingOption) error {
-    if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
-        return errors.New("not implemented")
-    }
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
+		return errors.New("not implemented")
+	}
 
-    pmu.Lock()
+	pmu.Lock()
 	defer pmu.Unlock()
-    pmu.wg.Add(len(opts))
-    // Double-check.
+	pmu.wg.Add(len(opts))
+	// Double-check.
 	if pmu.profiling {
 		return errors.New("pmu profiling already in use")
 	}
 	pmu.profiling = true
 
-    for _, opt := range opts {
-	    if err := opt.apply(); err != nil {
+	for _, opt := range opts {
+		if err := opt.apply(); err != nil {
 			return err
 		}
 	}
@@ -801,21 +800,21 @@ func StartPMUProfile(opts ...ProfilingOption) error {
 }
 
 type PMUEventConfig struct {
-    Period           int64
-    PreciseIP        int8
-    IsKernelIncluded bool
-    IsHvIncluded     bool
-    // TODO: IsMmapEnabled bool
-    // TODO: IsLBREnabled bool
+	Period           int64
+	PreciseIP        int8
+	IsKernelIncluded bool
+	IsHvIncluded     bool
+	// TODO: IsMmapEnabled bool
+	// TODO: IsLBREnabled bool
 }
 
 func getPreciseIP(preciseIP int8) uint8 {
-    if preciseIP < 0 {
-        preciseIP = 0
-    } else if preciseIP > 3 {
-        preciseIP = 3
-    }
-    return uint8(preciseIP)
+	if preciseIP < 0 {
+		preciseIP = 0
+	} else if preciseIP > 3 {
+		preciseIP = 3
+	}
+	return uint8(preciseIP)
 }
 
 func helper(w io.Writer, eventConfig *PMUEventConfig, eventId int, eventName string) {
@@ -847,11 +846,11 @@ func WithProfilingCycle(w io.Writer, eventConfig *PMUEventConfig) ProfilingOptio
 func WithProfilingInstr(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
         if eventConfig.Period <= 0 {
-            return errors.New("Period should be > 0")
+		return errors.New("Period should be > 0")
         }
         // Clamp period to something reasonable
         if eventConfig.Period < 300 {
-            eventConfig.Period = 300
+		eventConfig.Period = 300
         }
 
         helper(w, eventConfig, /*event ID*/ 1, /*event Name*/ "instructions")
@@ -862,7 +861,7 @@ func WithProfilingInstr(w io.Writer, eventConfig *PMUEventConfig) ProfilingOptio
 func WithProfilingCacheRef(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
         if eventConfig.Period <= 0 {
-            return errors.New("Period should be > 0")
+		return errors.New("Period should be > 0")
         }
         // TODO: Clamp period to something reasonable
 
@@ -874,7 +873,7 @@ func WithProfilingCacheRef(w io.Writer, eventConfig *PMUEventConfig) ProfilingOp
 func WithProfilingCacheMiss(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
         if eventConfig.Period <= 0 {
-            return errors.New("Period should be > 0")
+		return errors.New("Period should be > 0")
         }
         // TODO: Clamp period to something reasonable
 
@@ -902,19 +901,19 @@ func profileWriter(w io.Writer) {
 	b := newProfileBuilder(w)
 	var err error
 	for {
-	    time.Sleep(100 * time.Millisecond)
-	    data, tags, eof := readProfile()
-	    if e := b.addCPUData(data, tags); e != nil && err == nil {
-		    err = e
-	    }
-	    if eof {
-		    break
-	    }
+		time.Sleep(100 * time.Millisecond)
+		data, tags, eof := readProfile()
+		if e := b.addCPUData(data, tags); e != nil && err == nil {
+			err = e
+		}
+		if eof {
+			break
+		}
 	}
-    if err != nil {
-        // The runtime should never produce an invalid or truncated profile.
-	    // It drops records that can't fit into its log buffers.
-	    panic("runtime/pprof: converting profile: " + err.Error())
+	if err != nil {
+		// The runtime should never produce an invalid or truncated profile.
+		// It drops records that can't fit into its log buffers.
+		 panic("runtime/pprof: converting profile: " + err.Error())
 	}
 	b.build()
 	cpu.done <- true
@@ -926,16 +925,16 @@ func pmuProfileWriter(w io.Writer, eventId int, eventName string) {
 	b := newProfileBuilder(w)
 	var err error
 	for {
-	    time.Sleep(100 * time.Millisecond)
-	    data, tags, eof := readPMUProfile(eventId)
-        if e := b.addPMUData(data, tags); e != nil && err == nil {
-		    err = e
-	    }
-	    if eof {
-		    break
-	    }
+		time.Sleep(100 * time.Millisecond)
+		data, tags, eof := readPMUProfile(eventId)
+		if e := b.addPMUData(data, tags); e != nil && err == nil {
+			err = e
+		}
+		if eof {
+			break
+		}
 	}
-    if err != nil {
+	if err != nil {
 	    panic("runtime/pprof: converting profile: " + err.Error())
 	}
 	b.pmuBuild(eventName)
@@ -946,15 +945,15 @@ func pmuProfileWriter(w io.Writer, eventId int, eventName string) {
 // StopCPUProfile only returns after all the writes for the
 // profile have completed.
 func StopCPUProfile() {
-    cpu.Lock()
-    defer cpu.Unlock()
-
-    if !cpu.profiling {
-        return
-    }
-    cpu.profiling = false
-    runtime.SetCPUProfileRate(0)
-    <-cpu.done
+	cpu.Lock()
+	defer cpu.Unlock()
+
+	if !cpu.profiling {
+		return
+	}
+	cpu.profiling = false
+	runtime.SetCPUProfileRate(0)
+	<-cpu.done
 }
 
 func StopPMUProfile() {
@@ -964,14 +963,14 @@ func StopPMUProfile() {
 	if !pmu.profiling {
 		return
 	}
-    pmu.profiling = false
+	pmu.profiling = false
 
-    for i := 0; i < maxPMUEvent; i++ {
-        if pmu.eventOn[i] {
-            runtime.SetPMUProfile(i, nil)
-        }
+	for i := 0; i < maxPMUEvent; i++ {
+		if pmu.eventOn[i] {
+		runtime.SetPMUProfile(i, nil)
+		}
 	}
-    pmu.wg.Wait()
+	pmu.wg.Wait()
 }
 
 // countBlock returns the number of records in the blocking profile.
diff --git a/src/runtime/pprof/proto.go b/src/runtime/pprof/proto.go
index 14c6ddea6d..2e83d6ac6e 100644
--- a/src/runtime/pprof/proto.go
+++ b/src/runtime/pprof/proto.go
@@ -33,7 +33,7 @@ type profileBuilder struct {
 	end          time.Time
 	havePeriod   bool
 	period       int64
-    isPMUEnabled bool
+	isPMUEnabled bool
 	m            profMap
 
 	// encoding state
@@ -389,7 +389,7 @@ func (b *profileBuilder) addPMUData(data []uint64, tags []unsafe.Pointer) error
 			return fmt.Errorf("malformed profile")
 		}
 		b.isPMUEnabled = true
-        b.period = int64(data[2])
+		b.period = int64(data[2])
 		data = data[3:]
 	}
 
@@ -452,23 +452,23 @@ func (b *profileBuilder) build() {
 	b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano())
 	if b.havePeriod { // must be CPU profile
 		b.pbValueType(tagProfile_SampleType, "samples", "count")
-        b.pbValueType(tagProfile_SampleType, "cpu", "nanoseconds")
+		b.pbValueType(tagProfile_SampleType, "cpu", "nanoseconds")
 		b.pb.int64Opt(tagProfile_DurationNanos, b.end.Sub(b.start).Nanoseconds())
 		b.pbValueType(tagProfile_PeriodType, "cpu", "nanoseconds")
 		b.pb.int64Opt(tagProfile_Period, b.period)
 	}
-    
-    b.profileBuild()
+
+	b.profileBuild()
 }
 
 func (b *profileBuilder) pmuBuild(eventName string) {
 	b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano())
-    b.pbValueType(tagProfile_SampleType, "samples", "count")
-    b.pbValueType(tagProfile_SampleType, eventName, "count")
-    b.pbValueType(tagProfile_PeriodType, eventName, "count")
+	b.pbValueType(tagProfile_SampleType, "samples", "count")
+	b.pbValueType(tagProfile_SampleType, eventName, "count")
+	b.pbValueType(tagProfile_PeriodType, eventName, "count")
 	b.pb.int64Opt(tagProfile_Period, b.period)
-	
-    b.profileBuild()
+
+	b.profileBuild()
 }
 
 // readMapping reads /proc/self/maps and writes mappings to b.pb.
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 1586bed3a7..70de478029 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2149,17 +2149,17 @@ func execute(gp *g, inheritTime bool) {
 
 	// Check whether the profiler needs to be turned on or off.
 	hz := sched.profilehz
-    eventAttrs := sched.eventAttrs
-    
-    if _g_.m.profilehz != hz {
-        setThreadCPUProfiler(hz)
-    }
-    for eventId := 0; eventId < maxPMUEvent; eventId++ {
-        if  _g_.m.eventAttrs[eventId] != eventAttrs[eventId] {
-            setThreadPMUProfiler(int32(eventId), eventAttrs[eventId])
-        }
-    }
-        
+	eventAttrs := sched.eventAttrs
+
+	if _g_.m.profilehz != hz {
+		setThreadCPUProfiler(hz)
+	}
+	for eventId := 0; eventId < maxPMUEvent; eventId++ {
+		if  _g_.m.eventAttrs[eventId] != eventAttrs[eventId] {
+			setThreadPMUProfiler(int32(eventId), eventAttrs[eventId])
+		}
+	}
+
 	if trace.enabled {
 		// GoSysExit has to happen when we have a P, but before GoStart.
 		// So we emit it here.
@@ -3629,7 +3629,7 @@ var prof struct {
 
 var pmuEvent [maxPMUEvent]struct {
 	signalLock uint32
-    eventAttr  *PMUEventAttr
+	eventAttr  *PMUEventAttr
 }
 
 func _System()                    { _System() }
@@ -3845,7 +3845,7 @@ func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) { // SIGPMU = SIGRTMI
 	// See golang.org/issue/17165.
 	getg().m.mallocing++
 	stk := make([]uintptr, maxCPUProfStack)
-    n := stackUnwinding(pc, sp, lr, gp, mp, stk)
+	n := stackUnwinding(pc, sp, lr, gp, mp, stk)
 	if pmuEvent[eventId].eventAttr != nil {
 		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostPMUAtomic64Count[eventId] > 0 {
 			pmuprof[eventId].addLostAtomic64(lostPMUAtomic64Count[eventId], eventId)
@@ -3984,35 +3984,34 @@ func setcpuprofilerate(hz int32) {
 }
 
 func setpmuprofile(eventId int32, eventAttr *PMUEventAttr) {
+	// Disable preemption, otherwise we can be rescheduled to another thread
+	// that has profiling enabled.
+	_g_ := getg()
+	_g_.m.locks++
 
-    // Disable preemption, otherwise we can be rescheduled to another thread
-    // that has profiling enabled.
-    _g_ := getg()
-    _g_.m.locks++
-
-    // Stop profiler on this thread so that it is safe to lock prof.
-    // if a profiling signal came in while we had prof locked,
-    // it would deadlock.
-    setThreadPMUProfiler(eventId, nil)
-
-    for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
-        osyield()
-    }
-    if pmuEvent[eventId].eventAttr != eventAttr {
-        setProcessPMUProfiler(eventAttr)
-        pmuEvent[eventId].eventAttr = eventAttr
-    }
-    atomic.Store(&pmuEvent[eventId].signalLock, 0)
-
-    lock(&sched.lock)
-    sched.eventAttrs[eventId] = eventAttr
-    unlock(&sched.lock)
-
-    if eventAttr != nil {
-        setThreadPMUProfiler(eventId, eventAttr)
-    }
-
-    _g_.m.locks--
+	// Stop profiler on this thread so that it is safe to lock prof.
+	// if a profiling signal came in while we had prof locked,
+	// it would deadlock.
+	setThreadPMUProfiler(eventId, nil)
+
+	for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
+		osyield()
+	}
+	if pmuEvent[eventId].eventAttr != eventAttr {
+		setProcessPMUProfiler(eventAttr)
+		pmuEvent[eventId].eventAttr = eventAttr
+	}
+	atomic.Store(&pmuEvent[eventId].signalLock, 0)
+
+	lock(&sched.lock)
+	sched.eventAttrs[eventId] = eventAttr
+	unlock(&sched.lock)
+
+	if eventAttr != nil {
+		setThreadPMUProfiler(eventId, eventAttr)
+	}
+
+	_g_.m.locks--
  }
 
 // init initializes pp, which may be a freshly allocated p or a
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index bb7a33d0b9..a27c199493 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -34,28 +34,28 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
 	_g_ := getg()
 	c := &sigctxt{info, ctxt}
 
-    if sig == _SIGPMU {
-        fd := info.si_fd
-        ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
-
-        var eventId int = -1
-        for i := 0; i < maxPMUEvent; i++ {
-            if _g_.m.eventFds[i] == fd {
-                eventId = i
-                break
-            }
-        }
-        if eventId != -1 {
-            sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
-        }
-
-        ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
-        return
-	}
-
-    if sig == _SIGPROF {
-        sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
-        return
+	if sig == _SIGPMU {
+		fd := info.si_fd
+		ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
+
+		var eventId int = -1
+		for i := 0; i < maxPMUEvent; i++ {
+			if _g_.m.eventFds[i] == fd {
+				eventId = i
+				break
+			}
+		}
+		if eventId != -1 {
+			sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
+		}
+
+		ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
+		return
+	}
+
+	if sig == _SIGPROF {
+		sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
+		return
 	}
 
 	if sig == _SIGTRAP && testSigtrap != nil && testSigtrap(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp) {
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index fcd3590eef..c2ea5f607a 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -142,10 +142,10 @@ func sigInstallGoHandler(sig uint32) bool {
 }
 
 func isProfilingSignal(sig uint32) bool {
-    if sig == _SIGPROF || sig == _SIGPMU {
-        return true
-    }
-    return false
+	if sig == _SIGPROF || sig == _SIGPMU {
+		return true
+	}
+	return false
 }
 
 // sigenable enables the Go signal handler to catch the signal sig.
@@ -182,7 +182,7 @@ func sigdisable(sig uint32) {
 	}
 
 	// SIGPROF and _SIGPMU are handled specially for profiling.
-    if isProfilingSignal(sig) {
+	if isProfilingSignal(sig) {
 		return
 	}
 
@@ -259,70 +259,70 @@ func setProcessCPUProfiler(hz int32) {
 }
 
 func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
-    if eventAttr != nil {
-        // Enable the Go signal handler if not enabled.
-        if atomic.Cas(&handlingSig[_SIGPMU], 0, 1) {
-            atomic.Storeuintptr(&fwdSig[_SIGPMU], getsig(_SIGPMU))
-            setsig(_SIGPMU, funcPC(sighandler))
-        }
-    } else {
-        // If the Go signal handler should be disabled by default,
-        // disable it if it is enabled.
-        if !sigInstallGoHandler(_SIGPMU) {
-            if atomic.Cas(&handlingSig[_SIGPMU], 1, 0) {
-                setsig(_SIGPMU, atomic.Loaduintptr(&fwdSig[_SIGPMU]))
-            }
-        }
-    }
+	if eventAttr != nil {
+		// Enable the Go signal handler if not enabled.
+		if atomic.Cas(&handlingSig[_SIGPMU], 0, 1) {
+			atomic.Storeuintptr(&fwdSig[_SIGPMU], getsig(_SIGPMU))
+			setsig(_SIGPMU, funcPC(sighandler))
+		}
+	} else {
+		// If the Go signal handler should be disabled by default,
+		// disable it if it is enabled.
+		if !sigInstallGoHandler(_SIGPMU) {
+			if atomic.Cas(&handlingSig[_SIGPMU], 1, 0) {
+				setsig(_SIGPMU, atomic.Loaduintptr(&fwdSig[_SIGPMU]))
+			}
+		}
+	}
 }
 
 // setThreadCPUProfiler makes any thread-specific changes required to
 // implement profiling at a rate of hz.
 func setThreadCPUProfiler(hz int32) {
-    var it itimerval
-    if hz == 0 {
-        setitimer(_ITIMER_PROF, &it, nil)
-    } else {
-        it.it_interval.tv_sec = 0
-        it.it_interval.set_usec(1000000 / hz)
-        it.it_value = it.it_interval
-        setitimer(_ITIMER_PROF, &it, nil)
-    }
-    _g_ := getg()
-    _g_.m.profilehz = hz
+	var it itimerval
+	if hz == 0 {
+		setitimer(_ITIMER_PROF, &it, nil)
+	} else {
+		it.it_interval.tv_sec = 0
+		it.it_interval.set_usec(1000000 / hz)
+		it.it_value = it.it_interval
+		setitimer(_ITIMER_PROF, &it, nil)
+	}
+	_g_ := getg()
+	_g_.m.profilehz = hz
 }
 
 func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
-    _g_ := getg()
-
-    if eventAttr == nil {
-        if _g_.m.eventAttrs[eventId] != nil {
-            closefd(_g_.m.eventFds[eventId])
-        }
-    } else {
-        var perfAttr perfEventAttr
-        perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
-        perfAttr.Type = perfEventOpt[eventId].Type
-        perfAttr.Config = perfEventOpt[eventId].Config
-        perfAttr.Sample = eventAttr.Period
-        perfAttr.Bits = uint64(eventAttr.PreciseIP) << 15 // precise ip
-        if !eventAttr.IsKernelIncluded { // don't count kernel
-            perfAttr.Bits += 0b100000
-        }
-        if !eventAttr.IsHvIncluded { // don't count hypervisor
-            perfAttr.Bits += 0b1000000
-        }
-
-        fd, _, _ := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy*/ 0)
-        _g_.m.eventFds[eventId] = fd
-        r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
-        fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
-        fcntl(fd, /*F_SETSIG*/ 0xa, _SIGPMU)
-        fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, int32(gettid())}
-        fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx)
-    }
-
-    _g_.m.eventAttrs[eventId] = eventAttr
+	_g_ := getg()
+
+	if eventAttr == nil {
+		if _g_.m.eventAttrs[eventId] != nil {
+			closefd(_g_.m.eventFds[eventId])
+		}
+	} else {
+		var perfAttr perfEventAttr
+		perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
+		perfAttr.Type = perfEventOpt[eventId].Type
+		perfAttr.Config = perfEventOpt[eventId].Config
+		perfAttr.Sample = eventAttr.Period
+		perfAttr.Bits = uint64(eventAttr.PreciseIP) << 15 // precise ip
+		if !eventAttr.IsKernelIncluded { // don't count kernel
+			perfAttr.Bits += 0b100000
+		}
+		if !eventAttr.IsHvIncluded { // don't count hypervisor
+			perfAttr.Bits += 0b1000000
+		}
+
+		fd, _, _ := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy*/ 0)
+		_g_.m.eventFds[eventId] = fd
+		r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
+		fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
+		fcntl(fd, /*F_SETSIG*/ 0xa, _SIGPMU)
+		fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, int32(gettid())}
+		fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx)
+	}
+
+	_g_.m.eventAttrs[eventId] = eventAttr
 }
 
 func sigpipe() {
@@ -355,7 +355,7 @@ func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
 			return
 		} else if sig == _SIGPMU {
 			// sigpmuNonGoPC(c.sigpc())
-            println("how do I know which pmu event delivers this signal")
+			println("how do I know which pmu event delivers this signal")
 			return
 		}
 		c.fixsigcode(sig)
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 2a9663683a..8e3e05429c 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -196,9 +196,9 @@ TEXT runtime·ioctl(SB),NOSPLIT,$0
 	MOVL	fd+0(FP), DI
 	MOVQ	req+8(FP), SI
 	MOVQ	arg+16(FP), DX
-    MOVQ	$SYS_ioctl, AX
+	MOVQ	$SYS_ioctl, AX
 	SYSCALL
-    MOVQ    AX, ret+24(FP)
+	MOVQ    AX, ret+24(FP)
 	RET
 
 // func fcntl(fd int32, cmd arg int64) (r int64, err int64)
@@ -206,7 +206,7 @@ TEXT runtime·fcntl(SB),NOSPLIT,$0
 	MOVL	fd+0(FP), DI
 	MOVQ	cmd+8(FP), SI
 	MOVQ	arg+16(FP), DX
-    MOVQ	$SYS_fcntl, AX
+	MOVQ	$SYS_fcntl, AX
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
 	JLS	ok
@@ -223,7 +223,7 @@ TEXT runtime·fcntl2(SB),NOSPLIT,$0
 	MOVL	fd+0(FP), DI
 	MOVQ	cmd+8(FP), SI
 	MOVQ	arg+16(FP), DX
-    MOVQ	$SYS_fcntl, AX
+	MOVQ	$SYS_fcntl, AX
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
 	JLS	ok

From 23a00c29b24d0da2502444958ccf536b548524ac Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 10 Jul 2019 15:52:36 -0700
Subject: [PATCH 047/126] separate OS-specific functions and data stuctures

---
 src/runtime/defs1_netbsd_386.go     |  1 +
 src/runtime/defs1_netbsd_amd64.go   |  1 +
 src/runtime/defs1_netbsd_arm.go     |  1 +
 src/runtime/defs1_netbsd_arm64.go   |  1 +
 src/runtime/defs1_solaris_amd64.go  |  1 +
 src/runtime/defs_aix_ppc64.go       |  1 +
 src/runtime/defs_darwin_386.go      |  1 +
 src/runtime/defs_darwin_amd64.go    |  1 +
 src/runtime/defs_darwin_arm.go      |  1 +
 src/runtime/defs_darwin_arm64.go    |  1 +
 src/runtime/defs_dragonfly_amd64.go |  1 +
 src/runtime/defs_freebsd_386.go     |  1 +
 src/runtime/defs_freebsd_amd64.go   |  1 +
 src/runtime/defs_freebsd_arm.go     |  1 +
 src/runtime/defs_linux_386.go       |  1 +
 src/runtime/defs_linux_amd64.go     |  4 +-
 src/runtime/defs_linux_arm.go       |  2 +
 src/runtime/defs_linux_arm64.go     |  1 +
 src/runtime/defs_linux_mips64x.go   |  1 +
 src/runtime/defs_linux_mipsx.go     |  1 +
 src/runtime/defs_linux_ppc64.go     |  1 +
 src/runtime/defs_linux_ppc64le.go   |  1 +
 src/runtime/defs_linux_s390x.go     |  1 +
 src/runtime/defs_openbsd_386.go     |  1 +
 src/runtime/defs_openbsd_amd64.go   |  1 +
 src/runtime/defs_openbsd_arm.go     |  1 +
 src/runtime/defs_openbsd_arm64.go   |  1 +
 src/runtime/defs_pmu.go             |  3 -
 src/runtime/os2_plan9.go            |  1 +
 src/runtime/os_darwin.go            |  6 ++
 src/runtime/os_linux.go             | 11 ----
 src/runtime/os_linux_386.go         | 11 ++++
 src/runtime/os_linux_amd64.go       | 94 +++++++++++++++++++++++++++++
 src/runtime/runtime2.go             | 10 +--
 src/runtime/signal_sighandler.go    | 22 ++-----
 src/runtime/signal_unix.go          | 53 +---------------
 36 files changed, 151 insertions(+), 91 deletions(-)
 create mode 100644 src/runtime/os_linux_386.go
 create mode 100644 src/runtime/os_linux_amd64.go

diff --git a/src/runtime/defs1_netbsd_386.go b/src/runtime/defs1_netbsd_386.go
index 3eae12eed0..669030b0af 100644
--- a/src/runtime/defs1_netbsd_386.go
+++ b/src/runtime/defs1_netbsd_386.go
@@ -53,6 +53,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs1_netbsd_amd64.go b/src/runtime/defs1_netbsd_amd64.go
index 51d55c91f9..87c4315146 100644
--- a/src/runtime/defs1_netbsd_amd64.go
+++ b/src/runtime/defs1_netbsd_amd64.go
@@ -53,6 +53,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs1_netbsd_arm.go b/src/runtime/defs1_netbsd_arm.go
index fadb3415b3..f8fc98fa58 100644
--- a/src/runtime/defs1_netbsd_arm.go
+++ b/src/runtime/defs1_netbsd_arm.go
@@ -53,6 +53,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs1_netbsd_arm64.go b/src/runtime/defs1_netbsd_arm64.go
index 41b7aaca6c..e7ea5161fa 100644
--- a/src/runtime/defs1_netbsd_arm64.go
+++ b/src/runtime/defs1_netbsd_arm64.go
@@ -53,6 +53,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs1_solaris_amd64.go b/src/runtime/defs1_solaris_amd64.go
index 64d51a7bd8..7fb2549e25 100644
--- a/src/runtime/defs1_solaris_amd64.go
+++ b/src/runtime/defs1_solaris_amd64.go
@@ -57,6 +57,7 @@ const (
 	_SIGWINCH  = 0x14
 	_SIGUSR1   = 0x10
 	_SIGUSR2   = 0x11
+	_SIGPMU    = 0x11 // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_aix_ppc64.go b/src/runtime/defs_aix_ppc64.go
index dccc3a5926..0836f82bcb 100644
--- a/src/runtime/defs_aix_ppc64.go
+++ b/src/runtime/defs_aix_ppc64.go
@@ -59,6 +59,7 @@ const (
 	_SIGTERM    = 0xf
 	_SIGEMT     = 0x7
 	_SIGWAITING = 0x27
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x14
 	_FPE_INTOVF = 0x15
diff --git a/src/runtime/defs_darwin_386.go b/src/runtime/defs_darwin_386.go
index 43dc08a078..338787e85d 100644
--- a/src/runtime/defs_darwin_386.go
+++ b/src/runtime/defs_darwin_386.go
@@ -61,6 +61,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x7
 	_FPE_INTOVF = 0x8
diff --git a/src/runtime/defs_darwin_amd64.go b/src/runtime/defs_darwin_amd64.go
index 59b0effa13..eb8f02347a 100644
--- a/src/runtime/defs_darwin_amd64.go
+++ b/src/runtime/defs_darwin_amd64.go
@@ -61,6 +61,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x7
 	_FPE_INTOVF = 0x8
diff --git a/src/runtime/defs_darwin_arm.go b/src/runtime/defs_darwin_arm.go
index 243f52a5df..08a7dc4e3d 100644
--- a/src/runtime/defs_darwin_arm.go
+++ b/src/runtime/defs_darwin_arm.go
@@ -63,6 +63,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x7
 	_FPE_INTOVF = 0x8
diff --git a/src/runtime/defs_darwin_arm64.go b/src/runtime/defs_darwin_arm64.go
index 7056074f46..e63fb7f609 100644
--- a/src/runtime/defs_darwin_arm64.go
+++ b/src/runtime/defs_darwin_arm64.go
@@ -61,6 +61,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x7
 	_FPE_INTOVF = 0x8
diff --git a/src/runtime/defs_dragonfly_amd64.go b/src/runtime/defs_dragonfly_amd64.go
index 30f1b33845..b7a1ca5f5f 100644
--- a/src/runtime/defs_dragonfly_amd64.go
+++ b/src/runtime/defs_dragonfly_amd64.go
@@ -57,6 +57,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU	   = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x2
 	_FPE_INTOVF = 0x1
diff --git a/src/runtime/defs_freebsd_386.go b/src/runtime/defs_freebsd_386.go
index c4d5c897d3..2fd586933c 100644
--- a/src/runtime/defs_freebsd_386.go
+++ b/src/runtime/defs_freebsd_386.go
@@ -71,6 +71,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU	   = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x2
 	_FPE_INTOVF = 0x1
diff --git a/src/runtime/defs_freebsd_amd64.go b/src/runtime/defs_freebsd_amd64.go
index 89d36c270d..bf2b6d7b71 100644
--- a/src/runtime/defs_freebsd_amd64.go
+++ b/src/runtime/defs_freebsd_amd64.go
@@ -71,6 +71,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x2
 	_FPE_INTOVF = 0x1
diff --git a/src/runtime/defs_freebsd_arm.go b/src/runtime/defs_freebsd_arm.go
index cc8c924c37..4b3957e478 100644
--- a/src/runtime/defs_freebsd_arm.go
+++ b/src/runtime/defs_freebsd_arm.go
@@ -71,6 +71,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x2
 	_FPE_INTOVF = 0x1
diff --git a/src/runtime/defs_linux_386.go b/src/runtime/defs_linux_386.go
index e2fcbcac71..a37c38d9c1 100644
--- a/src/runtime/defs_linux_386.go
+++ b/src/runtime/defs_linux_386.go
@@ -57,6 +57,7 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
+	_SIGPMU    = 0x25 // psu: _SIGPMU = SIGRTMIN + 3
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 1da683320d..48649d153c 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -57,7 +57,7 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
-	_SIGPMU    = 0x25
+	_SIGPMU    = 0x25 // psu: _SIGPMU = SIGRTMIN + 3
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
@@ -128,7 +128,7 @@ type siginfo struct {
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
 	si_addr  uint64
-	// an unreliable workaround and need to figure out a better solution
+	// psu: an unreliable workaround and need to figure out a better solution
 	si_fd    int32
 }
 
diff --git a/src/runtime/defs_linux_arm.go b/src/runtime/defs_linux_arm.go
index 9d10d664e1..4716d67477 100644
--- a/src/runtime/defs_linux_arm.go
+++ b/src/runtime/defs_linux_arm.go
@@ -54,6 +54,8 @@ const (
 	_SIGIO          = 0x1d
 	_SIGPWR         = 0x1e
 	_SIGSYS         = 0x1f
+	_SIGPMU		= 0xc // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
+
 	_FPE_INTDIV     = 0x1
 	_FPE_INTOVF     = 0x2
 	_FPE_FLTDIV     = 0x3
diff --git a/src/runtime/defs_linux_arm64.go b/src/runtime/defs_linux_arm64.go
index b325a229a1..39eebbc615 100644
--- a/src/runtime/defs_linux_arm64.go
+++ b/src/runtime/defs_linux_arm64.go
@@ -57,6 +57,7 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
+	_SIGPMU    = 0xc // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_mips64x.go b/src/runtime/defs_linux_mips64x.go
index a52d0d40cf..e94784391c 100644
--- a/src/runtime/defs_linux_mips64x.go
+++ b/src/runtime/defs_linux_mips64x.go
@@ -56,6 +56,7 @@ const (
 	_SIGPROF   = 0x1d
 	_SIGXCPU   = 0x1e
 	_SIGXFSZ   = 0x1f
+	_SIGPMU    = 0x11 // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_mipsx.go b/src/runtime/defs_linux_mipsx.go
index f3a1dd0cf0..5a3cc37fe5 100644
--- a/src/runtime/defs_linux_mipsx.go
+++ b/src/runtime/defs_linux_mipsx.go
@@ -60,6 +60,7 @@ const (
 	_SIGPROF   = 0x1d
 	_SIGXCPU   = 0x1e
 	_SIGXFSZ   = 0x1f
+	_SIGPMU    = 0x11 // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_ppc64.go b/src/runtime/defs_linux_ppc64.go
index f438993721..d17f9bb8fa 100644
--- a/src/runtime/defs_linux_ppc64.go
+++ b/src/runtime/defs_linux_ppc64.go
@@ -56,6 +56,7 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
+	_SIGPMU    = 0xc // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_ppc64le.go b/src/runtime/defs_linux_ppc64le.go
index f438993721..294e121d17 100644
--- a/src/runtime/defs_linux_ppc64le.go
+++ b/src/runtime/defs_linux_ppc64le.go
@@ -56,6 +56,7 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
+	_SIGPMU    = 0xc // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_s390x.go b/src/runtime/defs_linux_s390x.go
index 19b99b5bdf..25af63074d 100644
--- a/src/runtime/defs_linux_s390x.go
+++ b/src/runtime/defs_linux_s390x.go
@@ -57,6 +57,7 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
+	_SIGPMU    = 0xc // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_openbsd_386.go b/src/runtime/defs_openbsd_386.go
index 0e59a0591a..1335cf0b55 100644
--- a/src/runtime/defs_openbsd_386.go
+++ b/src/runtime/defs_openbsd_386.go
@@ -56,6 +56,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_openbsd_amd64.go b/src/runtime/defs_openbsd_amd64.go
index 5cefac5858..e6aa067a9c 100644
--- a/src/runtime/defs_openbsd_amd64.go
+++ b/src/runtime/defs_openbsd_amd64.go
@@ -56,6 +56,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_openbsd_arm.go b/src/runtime/defs_openbsd_arm.go
index b187e9776f..19e3a054c3 100644
--- a/src/runtime/defs_openbsd_arm.go
+++ b/src/runtime/defs_openbsd_arm.go
@@ -56,6 +56,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_openbsd_arm64.go b/src/runtime/defs_openbsd_arm64.go
index 6b9d60110a..0209f67267 100644
--- a/src/runtime/defs_openbsd_arm64.go
+++ b/src/runtime/defs_openbsd_arm64.go
@@ -53,6 +53,7 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
+	_SIGPMU	   = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index 32bacc56cf..ee1c3b72ac 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -1,6 +1,3 @@
-// created by cgo -cdefs and then converted to Go
-// cgo -cdefs defs_linux.go defs1_linux.go
-
 package runtime
 
 const (
diff --git a/src/runtime/os2_plan9.go b/src/runtime/os2_plan9.go
index 58fb2be91f..1778efe447 100644
--- a/src/runtime/os2_plan9.go
+++ b/src/runtime/os2_plan9.go
@@ -71,4 +71,5 @@ const (
 	_SIGTRAP   = 6
 	_SIGPROF   = 0 // dummy value defined for badsignal
 	_SIGQUIT   = 0 // dummy value defined for sighandler
+	_SIGPMU    = 0 // psu: dummy value in order to pass testing
 )
diff --git a/src/runtime/os_darwin.go b/src/runtime/os_darwin.go
index 18c15ad89e..e11d8f8c6b 100644
--- a/src/runtime/os_darwin.go
+++ b/src/runtime/os_darwin.go
@@ -355,3 +355,9 @@ func sysargs(argc int32, argv **byte) {
 		executablePath = executablePath[len(prefix):]
 	}
 }
+
+func setProcessPMUProfiler(arg ...interface{}) {/*TODO: implementation*/}
+func setThreadPMUProfiler(arg ...interface{}) {/*TODO: implementation*/}
+
+//go:nowritebarrierrec
+func sigpmuhandler(arg ...interface{}) {/*TODO: implementation*/}
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 8f41e211e3..d4a9bd4ff5 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -356,17 +356,6 @@ func sigaltstack(new, old *stackt)
 //go:noescape
 func setitimer(mode int32, new, old *itimerval)
 
-//go:noescape
-func perfEventOpen(attr *perfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r int32, r2, err int64)
-
-func ioctl(fd int32, req, arg int64) int64
-
-// func fcntl(fd, cmd int64, arg interface{}) (r int64, err int64)
-func fcntl(fd int32, cmd, arg int64) (r int64, err int64)
-
-//go:noescape
-func fcntl2(fd int32, cmd int64, arg *fOwnerEx) (r int64, err int64)
-
 //go:noescape
 func rtsigprocmask(how int32, new, old *sigset, size int32)
 
diff --git a/src/runtime/os_linux_386.go b/src/runtime/os_linux_386.go
new file mode 100644
index 0000000000..7f37fbbb61
--- /dev/null
+++ b/src/runtime/os_linux_386.go
@@ -0,0 +1,11 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+func setProcessPMUProfiler(arg ...interface{}) /*TODO: implementation*/{}
+func setThreadPMUProfiler(arg ...interface{}) {/*TODO: implementation*/}
+
+//go:nowritebarrierrec
+func sigpmuhandler(arg ...interface{}) {/*TODO: implementation*/}
diff --git a/src/runtime/os_linux_amd64.go b/src/runtime/os_linux_amd64.go
new file mode 100644
index 0000000000..f3db7b3297
--- /dev/null
+++ b/src/runtime/os_linux_amd64.go
@@ -0,0 +1,94 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package runtime
+
+import (
+	"runtime/internal/atomic"
+	"unsafe"
+)
+
+//go:noescape
+func perfEventOpen(attr *perfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r int32, r2, err int64)
+
+func ioctl(fd int32, req, arg int64) int64
+
+// func fcntl(fd, cmd int64, arg interface{}) (r int64, err int64)
+func fcntl(fd int32, cmd, arg int64) (r int64, err int64)
+
+//go:noescape
+func fcntl2(fd int32, cmd int64, arg *fOwnerEx) (r int64, err int64)
+
+func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
+	if eventAttr != nil {
+		// Enable the Go signal handler if not enabled.
+		if atomic.Cas(&handlingSig[_SIGPMU], 0, 1) {
+			atomic.Storeuintptr(&fwdSig[_SIGPMU], getsig(_SIGPMU))
+			setsig(_SIGPMU, funcPC(sighandler))
+		}
+	} else {
+		// If the Go signal handler should be disabled by default,
+		// disable it if it is enabled.
+		if !sigInstallGoHandler(_SIGPMU) {
+			if atomic.Cas(&handlingSig[_SIGPMU], 1, 0) {
+				setsig(_SIGPMU, atomic.Loaduintptr(&fwdSig[_SIGPMU]))
+			}
+		}
+	}
+}
+
+func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
+	_g_ := getg()
+
+	if eventAttr == nil {
+		if _g_.m.eventAttrs[eventId] != nil {
+			closefd(_g_.m.eventFds[eventId])
+		}
+	} else {
+		var perfAttr perfEventAttr
+		perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
+		perfAttr.Type = perfEventOpt[eventId].Type
+		perfAttr.Config = perfEventOpt[eventId].Config
+		perfAttr.Sample = eventAttr.Period
+		perfAttr.Bits = uint64(eventAttr.PreciseIP) << 15 // precise ip
+		if !eventAttr.IsKernelIncluded { // don't count kernel
+			perfAttr.Bits += 0b100000
+		}
+		if !eventAttr.IsHvIncluded { // don't count hypervisor
+			perfAttr.Bits += 0b1000000
+		}
+
+		fd, _, _ := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy*/ 0)
+		_g_.m.eventFds[eventId] = fd
+		r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
+		fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
+		fcntl(fd, /*F_SETSIG*/ 0xa, _SIGPMU)
+		fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, int32(gettid())}
+		fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx)
+	}
+
+	_g_.m.eventAttrs[eventId] = eventAttr
+}
+
+//go:nowritebarrierrec
+func sigpmuhandler(info *siginfo, ctxt unsafe.Pointer, gp *g) {
+	fd := info.si_fd
+	ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
+	_g_ := getg()
+	c := &sigctxt{info, ctxt}
+
+	var eventId int = -1
+	for i := 0; i < maxPMUEvent; i++ {
+		if _g_.m.eventFds[i] == fd {
+			eventId = i
+			break
+		}
+	}
+	if eventId != -1 {
+		sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
+	}
+
+	ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
+	return
+}
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index c72b91eeae..7d6d5b2824 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -473,9 +473,9 @@ type m struct {
 	locks         int32
 	dying         int32
 	profilehz     int32
-    eventFds      [maxPMUEvent]int32
+	eventFds      [maxPMUEvent]int32
 	eventAttrs    [maxPMUEvent]*PMUEventAttr
-    spinning      bool // m is out of work and is actively looking for work
+	spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack
 	printlock     int8
@@ -675,9 +675,9 @@ type schedt struct {
 	safePointWait int32
 	safePointNote note
 
-    profilehz      int32 // cpu profiling rate
-	eventAttrs         [maxPMUEvent]*PMUEventAttr
-    procresizetime int64 // nanotime() of last change to gomaxprocs
+	profilehz      int32 // cpu profiling rate
+	eventAttrs     [maxPMUEvent]*PMUEventAttr
+	procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
 }
 
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index a27c199493..3d5c7f6571 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -31,28 +31,14 @@ var testSigtrap func(info *siginfo, ctxt *sigctxt, gp *g) bool
 //
 //go:nowritebarrierrec
 func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
-	_g_ := getg()
-	c := &sigctxt{info, ctxt}
-
 	if sig == _SIGPMU {
-		fd := info.si_fd
-		ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
-
-		var eventId int = -1
-		for i := 0; i < maxPMUEvent; i++ {
-			if _g_.m.eventFds[i] == fd {
-				eventId = i
-				break
-			}
-		}
-		if eventId != -1 {
-			sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
-		}
-
-		ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
+		sigpmuhandler(info, ctxt, gp)
 		return
 	}
 
+	_g_ := getg()
+	c := &sigctxt{info, ctxt}
+
 	if sig == _SIGPROF {
 		sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
 		return
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index c2ea5f607a..2381e2b89b 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -157,7 +157,7 @@ func sigenable(sig uint32) {
 	}
 
 	// SIGPROF and _SIGPMU are handled specially for profiling.
-    if isProfilingSignal(sig) {
+	if isProfilingSignal(sig) {
 		return
 	}
 
@@ -258,24 +258,6 @@ func setProcessCPUProfiler(hz int32) {
 	}
 }
 
-func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
-	if eventAttr != nil {
-		// Enable the Go signal handler if not enabled.
-		if atomic.Cas(&handlingSig[_SIGPMU], 0, 1) {
-			atomic.Storeuintptr(&fwdSig[_SIGPMU], getsig(_SIGPMU))
-			setsig(_SIGPMU, funcPC(sighandler))
-		}
-	} else {
-		// If the Go signal handler should be disabled by default,
-		// disable it if it is enabled.
-		if !sigInstallGoHandler(_SIGPMU) {
-			if atomic.Cas(&handlingSig[_SIGPMU], 1, 0) {
-				setsig(_SIGPMU, atomic.Loaduintptr(&fwdSig[_SIGPMU]))
-			}
-		}
-	}
-}
-
 // setThreadCPUProfiler makes any thread-specific changes required to
 // implement profiling at a rate of hz.
 func setThreadCPUProfiler(hz int32) {
@@ -292,39 +274,6 @@ func setThreadCPUProfiler(hz int32) {
 	_g_.m.profilehz = hz
 }
 
-func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
-	_g_ := getg()
-
-	if eventAttr == nil {
-		if _g_.m.eventAttrs[eventId] != nil {
-			closefd(_g_.m.eventFds[eventId])
-		}
-	} else {
-		var perfAttr perfEventAttr
-		perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
-		perfAttr.Type = perfEventOpt[eventId].Type
-		perfAttr.Config = perfEventOpt[eventId].Config
-		perfAttr.Sample = eventAttr.Period
-		perfAttr.Bits = uint64(eventAttr.PreciseIP) << 15 // precise ip
-		if !eventAttr.IsKernelIncluded { // don't count kernel
-			perfAttr.Bits += 0b100000
-		}
-		if !eventAttr.IsHvIncluded { // don't count hypervisor
-			perfAttr.Bits += 0b1000000
-		}
-
-		fd, _, _ := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy*/ 0)
-		_g_.m.eventFds[eventId] = fd
-		r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
-		fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
-		fcntl(fd, /*F_SETSIG*/ 0xa, _SIGPMU)
-		fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, int32(gettid())}
-		fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx)
-	}
-
-	_g_.m.eventAttrs[eventId] = eventAttr
-}
-
 func sigpipe() {
 	if sigsend(_SIGPIPE) {
 		return

From 7585bd91de9c80013990d4bea577478b2f9056cc Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 10 Jul 2019 15:53:37 -0700
Subject: [PATCH 048/126] API checks

---
 api/except.txt |   1 +
 api/next.txt   | 518 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 519 insertions(+)

diff --git a/api/except.txt b/api/except.txt
index 2a1287ce90..6700cab773 100644
--- a/api/except.txt
+++ b/api/except.txt
@@ -459,3 +459,4 @@ pkg syscall (freebsd-arm-cgo), type Statfs_t struct, Mntfromname [88]int8
 pkg syscall (freebsd-arm-cgo), type Statfs_t struct, Mntonname [88]int8
 pkg text/scanner, const GoTokens = 1012
 pkg unicode, const Version = "10.0.0"
+pkg runtime/pprof, func StartCPUProfile(io.Writer) error
diff --git a/api/next.txt b/api/next.txt
index 24c4daf1ad..fda6fdefed 100644
--- a/api/next.txt
+++ b/api/next.txt
@@ -8040,3 +8040,521 @@ pkg unicode, var Makasar *RangeTable
 pkg unicode, var Medefaidrin *RangeTable
 pkg unicode, var Old_Sogdian *RangeTable
 pkg unicode, var Sogdian *RangeTable
+pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST = -2048
+pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST ideal-int
+pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST_KERNEL = -2176
+pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST_KERNEL ideal-int
+pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST_USER = -2560
+pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST_USER ideal-int
+pkg runtime (linux-amd64), const PERF_CONTEXT_HV = -32
+pkg runtime (linux-amd64), const PERF_CONTEXT_HV ideal-int
+pkg runtime (linux-amd64), const PERF_CONTEXT_KERNEL = -128
+pkg runtime (linux-amd64), const PERF_CONTEXT_KERNEL ideal-int
+pkg runtime (linux-amd64), const PERF_CONTEXT_USER = -512
+pkg runtime (linux-amd64), const PERF_CONTEXT_USER ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4
+pkg runtime (linux-amd64), const PERF_COUNT_HW_BRANCH_INSTRUCTIONS ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_BRANCH_MISSES = 5
+pkg runtime (linux-amd64), const PERF_COUNT_HW_BRANCH_MISSES ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_BUS_CYCLES = 6
+pkg runtime (linux-amd64), const PERF_COUNT_HW_BUS_CYCLES ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_BPU = 5
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_BPU ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_DTLB = 3
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_DTLB ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_ITLB = 4
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_ITLB ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_L1D = 0
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_L1D ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_L1I = 1
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_L1I ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_LL = 2
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_LL ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_MISSES = 3
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_MISSES ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_NODE = 6
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_NODE ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_PREFETCH = 2
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_PREFETCH ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_READ = 0
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_READ ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_WRITE = 1
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_WRITE ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_REFERENCES = 2
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_REFERENCES ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_RESULT_ACCESS ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_RESULT_MISS = 1
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_RESULT_MISS ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CPU_CYCLES = 0
+pkg runtime (linux-amd64), const PERF_COUNT_HW_CPU_CYCLES ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_INSTRUCTIONS = 1
+pkg runtime (linux-amd64), const PERF_COUNT_HW_INSTRUCTIONS ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_REF_CPU_CYCLES = 9
+pkg runtime (linux-amd64), const PERF_COUNT_HW_REF_CPU_CYCLES ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 8
+pkg runtime (linux-amd64), const PERF_COUNT_HW_STALLED_CYCLES_BACKEND ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 7
+pkg runtime (linux-amd64), const PERF_COUNT_HW_STALLED_CYCLES_FRONTEND ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_SW_ALIGNMENT_FAULTS = 7
+pkg runtime (linux-amd64), const PERF_COUNT_SW_ALIGNMENT_FAULTS ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_SW_BPF_OUTPUT = 10
+pkg runtime (linux-amd64), const PERF_COUNT_SW_BPF_OUTPUT ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_SW_CONTEXT_SWITCHES = 3
+pkg runtime (linux-amd64), const PERF_COUNT_SW_CONTEXT_SWITCHES ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_SW_CPU_CLOCK = 0
+pkg runtime (linux-amd64), const PERF_COUNT_SW_CPU_CLOCK ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_SW_CPU_MIGRATIONS = 4
+pkg runtime (linux-amd64), const PERF_COUNT_SW_CPU_MIGRATIONS ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_SW_DUMMY = 9
+pkg runtime (linux-amd64), const PERF_COUNT_SW_DUMMY ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_SW_EMULATION_FAULTS = 8
+pkg runtime (linux-amd64), const PERF_COUNT_SW_EMULATION_FAULTS ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS = 2
+pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6
+pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS_MAJ ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS_MIN = 5
+pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS_MIN ideal-int
+pkg runtime (linux-amd64), const PERF_COUNT_SW_TASK_CLOCK = 1
+pkg runtime (linux-amd64), const PERF_COUNT_SW_TASK_CLOCK ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_DISABLE = 9217
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_DISABLE ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_ENABLE = 9216
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_ENABLE ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_ID = 2148017159
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_ID ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 1074275339
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_MODIFY_ATTRIBUTES ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_PAUSE_OUTPUT = 1074013193
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_PAUSE_OUTPUT ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_PERIOD = 1074275332
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_PERIOD ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_QUERY_BPF = 3221758986
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_QUERY_BPF ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_REFRESH = 9218
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_REFRESH ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_RESET = 9219
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_RESET ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_BPF = 1074013192
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_BPF ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_FILTER = 1074275334
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_FILTER ideal-int
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_OUTPUT = 9221
+pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_OUTPUT ideal-int
+pkg runtime (linux-amd64), const PERF_FLAG_FD_CLOEXEC = 8
+pkg runtime (linux-amd64), const PERF_FLAG_FD_CLOEXEC ideal-int
+pkg runtime (linux-amd64), const PERF_FLAG_FD_NO_GROUP = 1
+pkg runtime (linux-amd64), const PERF_FLAG_FD_NO_GROUP ideal-int
+pkg runtime (linux-amd64), const PERF_FLAG_FD_OUTPUT = 2
+pkg runtime (linux-amd64), const PERF_FLAG_FD_OUTPUT ideal-int
+pkg runtime (linux-amd64), const PERF_FLAG_PID_CGROUP = 4
+pkg runtime (linux-amd64), const PERF_FLAG_PID_CGROUP ideal-int
+pkg runtime (linux-amd64), const PERF_FORMAT_GROUP = 8
+pkg runtime (linux-amd64), const PERF_FORMAT_GROUP ideal-int
+pkg runtime (linux-amd64), const PERF_FORMAT_ID = 4
+pkg runtime (linux-amd64), const PERF_FORMAT_ID ideal-int
+pkg runtime (linux-amd64), const PERF_FORMAT_TOTAL_TIME_ENABLED = 1
+pkg runtime (linux-amd64), const PERF_FORMAT_TOTAL_TIME_ENABLED ideal-int
+pkg runtime (linux-amd64), const PERF_FORMAT_TOTAL_TIME_RUNNING = 2
+pkg runtime (linux-amd64), const PERF_FORMAT_TOTAL_TIME_RUNNING ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_AUX = 11
+pkg runtime (linux-amd64), const PERF_RECORD_AUX ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_COMM = 3
+pkg runtime (linux-amd64), const PERF_RECORD_COMM ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_EXIT = 4
+pkg runtime (linux-amd64), const PERF_RECORD_EXIT ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_FORK = 7
+pkg runtime (linux-amd64), const PERF_RECORD_FORK ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_ITRACE_START = 12
+pkg runtime (linux-amd64), const PERF_RECORD_ITRACE_START ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_LOST = 2
+pkg runtime (linux-amd64), const PERF_RECORD_LOST ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_LOST_SAMPLES = 13
+pkg runtime (linux-amd64), const PERF_RECORD_LOST_SAMPLES ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_MMAP = 1
+pkg runtime (linux-amd64), const PERF_RECORD_MMAP ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_MMAP2 = 10
+pkg runtime (linux-amd64), const PERF_RECORD_MMAP2 ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_NAMESPACES = 16
+pkg runtime (linux-amd64), const PERF_RECORD_NAMESPACES ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_READ = 8
+pkg runtime (linux-amd64), const PERF_RECORD_READ ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_SAMPLE = 9
+pkg runtime (linux-amd64), const PERF_RECORD_SAMPLE ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_SWITCH = 14
+pkg runtime (linux-amd64), const PERF_RECORD_SWITCH ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_SWITCH_CPU_WIDE = 15
+pkg runtime (linux-amd64), const PERF_RECORD_SWITCH_CPU_WIDE ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_THROTTLE = 5
+pkg runtime (linux-amd64), const PERF_RECORD_THROTTLE ideal-int
+pkg runtime (linux-amd64), const PERF_RECORD_UNTHROTTLE = 6
+pkg runtime (linux-amd64), const PERF_RECORD_UNTHROTTLE ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_ADDR = 8
+pkg runtime (linux-amd64), const PERF_SAMPLE_ADDR ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ABORT_TX = 128
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ABORT_TX ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY = 8
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY_CALL = 16
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY_CALL ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY_RETURN = 32
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY_RETURN ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_CALL = 8192
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_CALL ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_CALL_STACK = 2048
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_CALL_STACK ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_COND = 1024
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_COND ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_HV = 4
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_HV ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IND_CALL = 64
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IND_CALL ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IND_JUMP = 4096
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IND_JUMP ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IN_TX = 256
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IN_TX ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_KERNEL = 2
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_KERNEL ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_CYCLES = 32768
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_CYCLES ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_FLAGS = 16384
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_FLAGS ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_TX = 512
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_TX ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_STACK = 2048
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_STACK ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_TYPE_SAVE = 65536
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_TYPE_SAVE ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_USER = 1
+pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_USER ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_CALLCHAIN = 32
+pkg runtime (linux-amd64), const PERF_SAMPLE_CALLCHAIN ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_CPU = 128
+pkg runtime (linux-amd64), const PERF_SAMPLE_CPU ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_ID = 64
+pkg runtime (linux-amd64), const PERF_SAMPLE_ID ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_IP = 1
+pkg runtime (linux-amd64), const PERF_SAMPLE_IP ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_PERIOD = 256
+pkg runtime (linux-amd64), const PERF_SAMPLE_PERIOD ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_RAW = 1024
+pkg runtime (linux-amd64), const PERF_SAMPLE_RAW ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_READ = 16
+pkg runtime (linux-amd64), const PERF_SAMPLE_READ ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_STREAM_ID = 512
+pkg runtime (linux-amd64), const PERF_SAMPLE_STREAM_ID ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_TID = 2
+pkg runtime (linux-amd64), const PERF_SAMPLE_TID ideal-int
+pkg runtime (linux-amd64), const PERF_SAMPLE_TIME = 4
+pkg runtime (linux-amd64), const PERF_SAMPLE_TIME ideal-int
+pkg runtime (linux-amd64), const PERF_TYPE_BREAKPOINT = 5
+pkg runtime (linux-amd64), const PERF_TYPE_BREAKPOINT ideal-int
+pkg runtime (linux-amd64), const PERF_TYPE_HARDWARE = 0
+pkg runtime (linux-amd64), const PERF_TYPE_HARDWARE ideal-int
+pkg runtime (linux-amd64), const PERF_TYPE_HW_CACHE = 3
+pkg runtime (linux-amd64), const PERF_TYPE_HW_CACHE ideal-int
+pkg runtime (linux-amd64), const PERF_TYPE_RAW = 4
+pkg runtime (linux-amd64), const PERF_TYPE_RAW ideal-int
+pkg runtime (linux-amd64), const PERF_TYPE_SOFTWARE = 1
+pkg runtime (linux-amd64), const PERF_TYPE_SOFTWARE ideal-int
+pkg runtime (linux-amd64), const PERF_TYPE_TRACEPOINT = 2
+pkg runtime (linux-amd64), const PERF_TYPE_TRACEPOINT ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST = -2048
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST_KERNEL = -2176
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST_KERNEL ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST_USER = -2560
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST_USER ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_HV = -32
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_HV ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_KERNEL = -128
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_KERNEL ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_USER = -512
+pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_USER ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BRANCH_INSTRUCTIONS ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BRANCH_MISSES = 5
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BRANCH_MISSES ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BUS_CYCLES = 6
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BUS_CYCLES ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_BPU = 5
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_BPU ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_DTLB = 3
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_DTLB ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_ITLB = 4
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_ITLB ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_L1D = 0
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_L1D ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_L1I = 1
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_L1I ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_LL = 2
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_LL ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_MISSES = 3
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_MISSES ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_NODE = 6
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_NODE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_PREFETCH = 2
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_PREFETCH ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_READ = 0
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_READ ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_WRITE = 1
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_WRITE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_REFERENCES = 2
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_REFERENCES ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_RESULT_ACCESS ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_RESULT_MISS = 1
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_RESULT_MISS ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CPU_CYCLES = 0
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CPU_CYCLES ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_INSTRUCTIONS = 1
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_INSTRUCTIONS ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_REF_CPU_CYCLES = 9
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_REF_CPU_CYCLES ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 8
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_STALLED_CYCLES_BACKEND ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 7
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_STALLED_CYCLES_FRONTEND ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_ALIGNMENT_FAULTS = 7
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_ALIGNMENT_FAULTS ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_BPF_OUTPUT = 10
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_BPF_OUTPUT ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CONTEXT_SWITCHES = 3
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CONTEXT_SWITCHES ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CPU_CLOCK = 0
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CPU_CLOCK ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CPU_MIGRATIONS = 4
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CPU_MIGRATIONS ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_DUMMY = 9
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_DUMMY ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_EMULATION_FAULTS = 8
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_EMULATION_FAULTS ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS = 2
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS_MAJ ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS_MIN = 5
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS_MIN ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_TASK_CLOCK = 1
+pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_TASK_CLOCK ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_DISABLE = 9217
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_DISABLE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_ENABLE = 9216
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_ENABLE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_ID = 2148017159
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_ID ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 1074275339
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_MODIFY_ATTRIBUTES ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_PAUSE_OUTPUT = 1074013193
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_PAUSE_OUTPUT ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_PERIOD = 1074275332
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_PERIOD ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_QUERY_BPF = 3221758986
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_QUERY_BPF ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_REFRESH = 9218
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_REFRESH ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_RESET = 9219
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_RESET ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_BPF = 1074013192
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_BPF ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_FILTER = 1074275334
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_FILTER ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_OUTPUT = 9221
+pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_OUTPUT ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_CLOEXEC = 8
+pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_CLOEXEC ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_NO_GROUP = 1
+pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_NO_GROUP ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_OUTPUT = 2
+pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_OUTPUT ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_FLAG_PID_CGROUP = 4
+pkg runtime (linux-amd64-cgo), const PERF_FLAG_PID_CGROUP ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_FORMAT_GROUP = 8
+pkg runtime (linux-amd64-cgo), const PERF_FORMAT_GROUP ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_FORMAT_ID = 4
+pkg runtime (linux-amd64-cgo), const PERF_FORMAT_ID ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_FORMAT_TOTAL_TIME_ENABLED = 1
+pkg runtime (linux-amd64-cgo), const PERF_FORMAT_TOTAL_TIME_ENABLED ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_FORMAT_TOTAL_TIME_RUNNING = 2
+pkg runtime (linux-amd64-cgo), const PERF_FORMAT_TOTAL_TIME_RUNNING ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_AUX = 11
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_AUX ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_COMM = 3
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_COMM ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_EXIT = 4
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_EXIT ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_FORK = 7
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_FORK ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_ITRACE_START = 12
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_ITRACE_START ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_LOST = 2
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_LOST ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_LOST_SAMPLES = 13
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_LOST_SAMPLES ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_MMAP = 1
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_MMAP ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_MMAP2 = 10
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_MMAP2 ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_NAMESPACES = 16
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_NAMESPACES ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_READ = 8
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_READ ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_SAMPLE = 9
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_SAMPLE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_SWITCH = 14
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_SWITCH ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_SWITCH_CPU_WIDE = 15
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_SWITCH_CPU_WIDE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_THROTTLE = 5
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_THROTTLE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_UNTHROTTLE = 6
+pkg runtime (linux-amd64-cgo), const PERF_RECORD_UNTHROTTLE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_ADDR = 8
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_ADDR ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ABORT_TX = 128
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ABORT_TX ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY = 8
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY_CALL = 16
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY_CALL ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY_RETURN = 32
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY_RETURN ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_CALL = 8192
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_CALL ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_CALL_STACK = 2048
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_CALL_STACK ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_COND = 1024
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_COND ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_HV = 4
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_HV ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IND_CALL = 64
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IND_CALL ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IND_JUMP = 4096
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IND_JUMP ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IN_TX = 256
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IN_TX ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_KERNEL = 2
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_KERNEL ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_CYCLES = 32768
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_CYCLES ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_FLAGS = 16384
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_FLAGS ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_TX = 512
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_TX ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_STACK = 2048
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_STACK ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_TYPE_SAVE = 65536
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_TYPE_SAVE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_USER = 1
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_USER ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_CALLCHAIN = 32
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_CALLCHAIN ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_CPU = 128
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_CPU ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_ID = 64
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_ID ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_IP = 1
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_IP ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_PERIOD = 256
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_PERIOD ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_RAW = 1024
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_RAW ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_READ = 16
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_READ ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_STREAM_ID = 512
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_STREAM_ID ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_TID = 2
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_TID ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_TIME = 4
+pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_TIME ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_BREAKPOINT = 5
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_BREAKPOINT ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_HARDWARE = 0
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_HARDWARE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_HW_CACHE = 3
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_HW_CACHE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_RAW = 4
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_RAW ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_SOFTWARE = 1
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_SOFTWARE ideal-int
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_TRACEPOINT = 2
+pkg runtime (linux-amd64-cgo), const PERF_TYPE_TRACEPOINT ideal-int
+pkg runtime, const GO_COUNT_HW_BRANCH_INSTRUCTIONS = 4
+pkg runtime, const GO_COUNT_HW_BRANCH_INSTRUCTIONS ideal-int
+pkg runtime, const GO_COUNT_HW_BRANCH_MISSES = 5
+pkg runtime, const GO_COUNT_HW_BRANCH_MISSES ideal-int
+pkg runtime, const GO_COUNT_HW_BUS_CYCLES = 6
+pkg runtime, const GO_COUNT_HW_BUS_CYCLES ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_BPU = 15
+pkg runtime, const GO_COUNT_HW_CACHE_BPU ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_DTLB = 13
+pkg runtime, const GO_COUNT_HW_CACHE_DTLB ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_ITLB = 14
+pkg runtime, const GO_COUNT_HW_CACHE_ITLB ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_L1D = 10
+pkg runtime, const GO_COUNT_HW_CACHE_L1D ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_L1I = 11
+pkg runtime, const GO_COUNT_HW_CACHE_L1I ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_LL = 12
+pkg runtime, const GO_COUNT_HW_CACHE_LL ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_MISSES = 3
+pkg runtime, const GO_COUNT_HW_CACHE_MISSES ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_NODE = 16
+pkg runtime, const GO_COUNT_HW_CACHE_NODE ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_OP_PREFETCH = 19
+pkg runtime, const GO_COUNT_HW_CACHE_OP_PREFETCH ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_OP_READ = 17
+pkg runtime, const GO_COUNT_HW_CACHE_OP_READ ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_OP_WRITE = 18
+pkg runtime, const GO_COUNT_HW_CACHE_OP_WRITE ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_REFERENCES = 2
+pkg runtime, const GO_COUNT_HW_CACHE_REFERENCES ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_RESULT_ACCESS = 20
+pkg runtime, const GO_COUNT_HW_CACHE_RESULT_ACCESS ideal-int
+pkg runtime, const GO_COUNT_HW_CACHE_RESULT_MISS = 21
+pkg runtime, const GO_COUNT_HW_CACHE_RESULT_MISS ideal-int
+pkg runtime, const GO_COUNT_HW_CPU_CYCLES = 0
+pkg runtime, const GO_COUNT_HW_CPU_CYCLES ideal-int
+pkg runtime, const GO_COUNT_HW_INSTRUCTIONS = 1
+pkg runtime, const GO_COUNT_HW_INSTRUCTIONS ideal-int
+pkg runtime, const GO_COUNT_HW_REF_CPU_CYCLES = 9
+pkg runtime, const GO_COUNT_HW_REF_CPU_CYCLES ideal-int
+pkg runtime, const GO_COUNT_HW_STALLED_CYCLES_BACKEND = 8
+pkg runtime, const GO_COUNT_HW_STALLED_CYCLES_BACKEND ideal-int
+pkg runtime, const GO_COUNT_HW_STALLED_CYCLES_FRONTEND = 7
+pkg runtime, const GO_COUNT_HW_STALLED_CYCLES_FRONTEND ideal-int
+pkg runtime, const GO_COUNT_SW_CONTEXT_SWITCHES = 25
+pkg runtime, const GO_COUNT_SW_CONTEXT_SWITCHES ideal-int
+pkg runtime, const GO_COUNT_SW_CPU_CLOCK = 22
+pkg runtime, const GO_COUNT_SW_CPU_CLOCK ideal-int
+pkg runtime, const GO_COUNT_SW_PAGE_FAULTS = 24
+pkg runtime, const GO_COUNT_SW_PAGE_FAULTS ideal-int
+pkg runtime, const GO_COUNT_SW_TASK_CLOCK = 23
+pkg runtime, const GO_COUNT_SW_TASK_CLOCK ideal-int
+pkg runtime, func SetPMUProfile(int, *PMUEventAttr)
+pkg runtime, type PMUEventAttr struct
+pkg runtime, type PMUEventAttr struct, IsHvIncluded bool
+pkg runtime, type PMUEventAttr struct, IsKernelIncluded bool
+pkg runtime, type PMUEventAttr struct, Period uint64
+pkg runtime, type PMUEventAttr struct, PreciseIP uint8
+pkg runtime/pprof, func StartCPUProfile(io.Writer, ...int) error
+pkg runtime/pprof, func StartPMUProfile(...ProfilingOption) error
+pkg runtime/pprof, func StopPMUProfile()
+pkg runtime/pprof, func WithProfilingCacheMiss(io.Writer, *PMUEventConfig) ProfilingOption
+pkg runtime/pprof, func WithProfilingCacheRef(io.Writer, *PMUEventConfig) ProfilingOption
+pkg runtime/pprof, func WithProfilingCycle(io.Writer, *PMUEventConfig) ProfilingOption
+pkg runtime/pprof, func WithProfilingInstr(io.Writer, *PMUEventConfig) ProfilingOption
+pkg runtime/pprof, type PMUEventConfig struct
+pkg runtime/pprof, type PMUEventConfig struct, IsHvIncluded bool
+pkg runtime/pprof, type PMUEventConfig struct, IsKernelIncluded bool
+pkg runtime/pprof, type PMUEventConfig struct, Period int64
+pkg runtime/pprof, type PMUEventConfig struct, PreciseIP int8
+pkg runtime/pprof, type ProfilingOption interface, unexported methods
+pkg crypto/tls, const Ed25519 = 2055
+pkg crypto/tls, const Ed25519 SignatureScheme
+pkg crypto/x509, const Ed25519 = 4
+pkg crypto/x509, const Ed25519 PublicKeyAlgorithm
+pkg crypto/x509, const PureEd25519 = 16
+pkg crypto/x509, const PureEd25519 SignatureAlgorithm
+pkg go/types, func CheckExpr(*token.FileSet, *Package, token.Pos, ast.Expr, *Info) error

From 6c5a609523eb3e84ebf9bf5f800fff580f9eaedf Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 10 Jul 2019 15:56:54 -0700
Subject: [PATCH 049/126] API checks

---
 api/next.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/api/next.txt b/api/next.txt
index fda6fdefed..9165e5cf45 100644
--- a/api/next.txt
+++ b/api/next.txt
@@ -8557,4 +8557,3 @@ pkg crypto/x509, const Ed25519 = 4
 pkg crypto/x509, const Ed25519 PublicKeyAlgorithm
 pkg crypto/x509, const PureEd25519 = 16
 pkg crypto/x509, const PureEd25519 SignatureAlgorithm
-pkg go/types, func CheckExpr(*token.FileSet, *Package, token.Pos, ast.Expr, *Info) error

From 4416dcfe574c6f1b7d75f804feff96e2a4964a23 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 10 Jul 2019 16:03:44 -0700
Subject: [PATCH 050/126] minor

---
 src/runtime/defs_aix_ppc64.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/defs_aix_ppc64.go b/src/runtime/defs_aix_ppc64.go
index 0836f82bcb..d284088d30 100644
--- a/src/runtime/defs_aix_ppc64.go
+++ b/src/runtime/defs_aix_ppc64.go
@@ -59,7 +59,7 @@ const (
 	_SIGTERM    = 0xf
 	_SIGEMT     = 0x7
 	_SIGWAITING = 0x27
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
+	_SIGPMU     = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x14
 	_FPE_INTOVF = 0x15

From 9edf689fae856784134976e01ec49ee345bc86a9 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 10 Jul 2019 16:08:45 -0700
Subject: [PATCH 051/126] API checks

---
 api/next.txt | 517 ---------------------------------------------------
 1 file changed, 517 deletions(-)

diff --git a/api/next.txt b/api/next.txt
index 9165e5cf45..24c4daf1ad 100644
--- a/api/next.txt
+++ b/api/next.txt
@@ -8040,520 +8040,3 @@ pkg unicode, var Makasar *RangeTable
 pkg unicode, var Medefaidrin *RangeTable
 pkg unicode, var Old_Sogdian *RangeTable
 pkg unicode, var Sogdian *RangeTable
-pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST = -2048
-pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST ideal-int
-pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST_KERNEL = -2176
-pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST_KERNEL ideal-int
-pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST_USER = -2560
-pkg runtime (linux-amd64), const PERF_CONTEXT_GUEST_USER ideal-int
-pkg runtime (linux-amd64), const PERF_CONTEXT_HV = -32
-pkg runtime (linux-amd64), const PERF_CONTEXT_HV ideal-int
-pkg runtime (linux-amd64), const PERF_CONTEXT_KERNEL = -128
-pkg runtime (linux-amd64), const PERF_CONTEXT_KERNEL ideal-int
-pkg runtime (linux-amd64), const PERF_CONTEXT_USER = -512
-pkg runtime (linux-amd64), const PERF_CONTEXT_USER ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4
-pkg runtime (linux-amd64), const PERF_COUNT_HW_BRANCH_INSTRUCTIONS ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_BRANCH_MISSES = 5
-pkg runtime (linux-amd64), const PERF_COUNT_HW_BRANCH_MISSES ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_BUS_CYCLES = 6
-pkg runtime (linux-amd64), const PERF_COUNT_HW_BUS_CYCLES ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_BPU = 5
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_BPU ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_DTLB = 3
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_DTLB ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_ITLB = 4
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_ITLB ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_L1D = 0
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_L1D ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_L1I = 1
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_L1I ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_LL = 2
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_LL ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_MISSES = 3
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_MISSES ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_NODE = 6
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_NODE ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_PREFETCH = 2
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_PREFETCH ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_READ = 0
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_READ ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_WRITE = 1
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_OP_WRITE ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_REFERENCES = 2
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_REFERENCES ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_RESULT_ACCESS ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_RESULT_MISS = 1
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CACHE_RESULT_MISS ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CPU_CYCLES = 0
-pkg runtime (linux-amd64), const PERF_COUNT_HW_CPU_CYCLES ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_INSTRUCTIONS = 1
-pkg runtime (linux-amd64), const PERF_COUNT_HW_INSTRUCTIONS ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_REF_CPU_CYCLES = 9
-pkg runtime (linux-amd64), const PERF_COUNT_HW_REF_CPU_CYCLES ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 8
-pkg runtime (linux-amd64), const PERF_COUNT_HW_STALLED_CYCLES_BACKEND ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 7
-pkg runtime (linux-amd64), const PERF_COUNT_HW_STALLED_CYCLES_FRONTEND ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_SW_ALIGNMENT_FAULTS = 7
-pkg runtime (linux-amd64), const PERF_COUNT_SW_ALIGNMENT_FAULTS ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_SW_BPF_OUTPUT = 10
-pkg runtime (linux-amd64), const PERF_COUNT_SW_BPF_OUTPUT ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_SW_CONTEXT_SWITCHES = 3
-pkg runtime (linux-amd64), const PERF_COUNT_SW_CONTEXT_SWITCHES ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_SW_CPU_CLOCK = 0
-pkg runtime (linux-amd64), const PERF_COUNT_SW_CPU_CLOCK ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_SW_CPU_MIGRATIONS = 4
-pkg runtime (linux-amd64), const PERF_COUNT_SW_CPU_MIGRATIONS ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_SW_DUMMY = 9
-pkg runtime (linux-amd64), const PERF_COUNT_SW_DUMMY ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_SW_EMULATION_FAULTS = 8
-pkg runtime (linux-amd64), const PERF_COUNT_SW_EMULATION_FAULTS ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS = 2
-pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6
-pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS_MAJ ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS_MIN = 5
-pkg runtime (linux-amd64), const PERF_COUNT_SW_PAGE_FAULTS_MIN ideal-int
-pkg runtime (linux-amd64), const PERF_COUNT_SW_TASK_CLOCK = 1
-pkg runtime (linux-amd64), const PERF_COUNT_SW_TASK_CLOCK ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_DISABLE = 9217
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_DISABLE ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_ENABLE = 9216
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_ENABLE ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_ID = 2148017159
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_ID ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 1074275339
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_MODIFY_ATTRIBUTES ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_PAUSE_OUTPUT = 1074013193
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_PAUSE_OUTPUT ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_PERIOD = 1074275332
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_PERIOD ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_QUERY_BPF = 3221758986
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_QUERY_BPF ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_REFRESH = 9218
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_REFRESH ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_RESET = 9219
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_RESET ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_BPF = 1074013192
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_BPF ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_FILTER = 1074275334
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_FILTER ideal-int
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_OUTPUT = 9221
-pkg runtime (linux-amd64), const PERF_EVENT_IOC_SET_OUTPUT ideal-int
-pkg runtime (linux-amd64), const PERF_FLAG_FD_CLOEXEC = 8
-pkg runtime (linux-amd64), const PERF_FLAG_FD_CLOEXEC ideal-int
-pkg runtime (linux-amd64), const PERF_FLAG_FD_NO_GROUP = 1
-pkg runtime (linux-amd64), const PERF_FLAG_FD_NO_GROUP ideal-int
-pkg runtime (linux-amd64), const PERF_FLAG_FD_OUTPUT = 2
-pkg runtime (linux-amd64), const PERF_FLAG_FD_OUTPUT ideal-int
-pkg runtime (linux-amd64), const PERF_FLAG_PID_CGROUP = 4
-pkg runtime (linux-amd64), const PERF_FLAG_PID_CGROUP ideal-int
-pkg runtime (linux-amd64), const PERF_FORMAT_GROUP = 8
-pkg runtime (linux-amd64), const PERF_FORMAT_GROUP ideal-int
-pkg runtime (linux-amd64), const PERF_FORMAT_ID = 4
-pkg runtime (linux-amd64), const PERF_FORMAT_ID ideal-int
-pkg runtime (linux-amd64), const PERF_FORMAT_TOTAL_TIME_ENABLED = 1
-pkg runtime (linux-amd64), const PERF_FORMAT_TOTAL_TIME_ENABLED ideal-int
-pkg runtime (linux-amd64), const PERF_FORMAT_TOTAL_TIME_RUNNING = 2
-pkg runtime (linux-amd64), const PERF_FORMAT_TOTAL_TIME_RUNNING ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_AUX = 11
-pkg runtime (linux-amd64), const PERF_RECORD_AUX ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_COMM = 3
-pkg runtime (linux-amd64), const PERF_RECORD_COMM ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_EXIT = 4
-pkg runtime (linux-amd64), const PERF_RECORD_EXIT ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_FORK = 7
-pkg runtime (linux-amd64), const PERF_RECORD_FORK ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_ITRACE_START = 12
-pkg runtime (linux-amd64), const PERF_RECORD_ITRACE_START ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_LOST = 2
-pkg runtime (linux-amd64), const PERF_RECORD_LOST ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_LOST_SAMPLES = 13
-pkg runtime (linux-amd64), const PERF_RECORD_LOST_SAMPLES ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_MMAP = 1
-pkg runtime (linux-amd64), const PERF_RECORD_MMAP ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_MMAP2 = 10
-pkg runtime (linux-amd64), const PERF_RECORD_MMAP2 ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_NAMESPACES = 16
-pkg runtime (linux-amd64), const PERF_RECORD_NAMESPACES ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_READ = 8
-pkg runtime (linux-amd64), const PERF_RECORD_READ ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_SAMPLE = 9
-pkg runtime (linux-amd64), const PERF_RECORD_SAMPLE ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_SWITCH = 14
-pkg runtime (linux-amd64), const PERF_RECORD_SWITCH ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_SWITCH_CPU_WIDE = 15
-pkg runtime (linux-amd64), const PERF_RECORD_SWITCH_CPU_WIDE ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_THROTTLE = 5
-pkg runtime (linux-amd64), const PERF_RECORD_THROTTLE ideal-int
-pkg runtime (linux-amd64), const PERF_RECORD_UNTHROTTLE = 6
-pkg runtime (linux-amd64), const PERF_RECORD_UNTHROTTLE ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_ADDR = 8
-pkg runtime (linux-amd64), const PERF_SAMPLE_ADDR ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ABORT_TX = 128
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ABORT_TX ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY = 8
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY_CALL = 16
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY_CALL ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY_RETURN = 32
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_ANY_RETURN ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_CALL = 8192
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_CALL ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_CALL_STACK = 2048
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_CALL_STACK ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_COND = 1024
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_COND ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_HV = 4
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_HV ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IND_CALL = 64
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IND_CALL ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IND_JUMP = 4096
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IND_JUMP ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IN_TX = 256
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_IN_TX ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_KERNEL = 2
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_KERNEL ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_CYCLES = 32768
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_CYCLES ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_FLAGS = 16384
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_FLAGS ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_TX = 512
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_NO_TX ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_STACK = 2048
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_STACK ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_TYPE_SAVE = 65536
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_TYPE_SAVE ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_USER = 1
-pkg runtime (linux-amd64), const PERF_SAMPLE_BRANCH_USER ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_CALLCHAIN = 32
-pkg runtime (linux-amd64), const PERF_SAMPLE_CALLCHAIN ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_CPU = 128
-pkg runtime (linux-amd64), const PERF_SAMPLE_CPU ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_ID = 64
-pkg runtime (linux-amd64), const PERF_SAMPLE_ID ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_IP = 1
-pkg runtime (linux-amd64), const PERF_SAMPLE_IP ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_PERIOD = 256
-pkg runtime (linux-amd64), const PERF_SAMPLE_PERIOD ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_RAW = 1024
-pkg runtime (linux-amd64), const PERF_SAMPLE_RAW ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_READ = 16
-pkg runtime (linux-amd64), const PERF_SAMPLE_READ ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_STREAM_ID = 512
-pkg runtime (linux-amd64), const PERF_SAMPLE_STREAM_ID ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_TID = 2
-pkg runtime (linux-amd64), const PERF_SAMPLE_TID ideal-int
-pkg runtime (linux-amd64), const PERF_SAMPLE_TIME = 4
-pkg runtime (linux-amd64), const PERF_SAMPLE_TIME ideal-int
-pkg runtime (linux-amd64), const PERF_TYPE_BREAKPOINT = 5
-pkg runtime (linux-amd64), const PERF_TYPE_BREAKPOINT ideal-int
-pkg runtime (linux-amd64), const PERF_TYPE_HARDWARE = 0
-pkg runtime (linux-amd64), const PERF_TYPE_HARDWARE ideal-int
-pkg runtime (linux-amd64), const PERF_TYPE_HW_CACHE = 3
-pkg runtime (linux-amd64), const PERF_TYPE_HW_CACHE ideal-int
-pkg runtime (linux-amd64), const PERF_TYPE_RAW = 4
-pkg runtime (linux-amd64), const PERF_TYPE_RAW ideal-int
-pkg runtime (linux-amd64), const PERF_TYPE_SOFTWARE = 1
-pkg runtime (linux-amd64), const PERF_TYPE_SOFTWARE ideal-int
-pkg runtime (linux-amd64), const PERF_TYPE_TRACEPOINT = 2
-pkg runtime (linux-amd64), const PERF_TYPE_TRACEPOINT ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST = -2048
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST_KERNEL = -2176
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST_KERNEL ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST_USER = -2560
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_GUEST_USER ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_HV = -32
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_HV ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_KERNEL = -128
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_KERNEL ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_USER = -512
-pkg runtime (linux-amd64-cgo), const PERF_CONTEXT_USER ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BRANCH_INSTRUCTIONS ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BRANCH_MISSES = 5
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BRANCH_MISSES ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BUS_CYCLES = 6
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_BUS_CYCLES ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_BPU = 5
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_BPU ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_DTLB = 3
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_DTLB ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_ITLB = 4
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_ITLB ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_L1D = 0
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_L1D ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_L1I = 1
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_L1I ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_LL = 2
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_LL ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_MISSES = 3
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_MISSES ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_NODE = 6
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_NODE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_PREFETCH = 2
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_PREFETCH ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_READ = 0
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_READ ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_WRITE = 1
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_OP_WRITE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_REFERENCES = 2
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_REFERENCES ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_RESULT_ACCESS ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_RESULT_MISS = 1
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CACHE_RESULT_MISS ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CPU_CYCLES = 0
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_CPU_CYCLES ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_INSTRUCTIONS = 1
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_INSTRUCTIONS ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_REF_CPU_CYCLES = 9
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_REF_CPU_CYCLES ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 8
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_STALLED_CYCLES_BACKEND ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 7
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_HW_STALLED_CYCLES_FRONTEND ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_ALIGNMENT_FAULTS = 7
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_ALIGNMENT_FAULTS ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_BPF_OUTPUT = 10
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_BPF_OUTPUT ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CONTEXT_SWITCHES = 3
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CONTEXT_SWITCHES ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CPU_CLOCK = 0
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CPU_CLOCK ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CPU_MIGRATIONS = 4
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_CPU_MIGRATIONS ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_DUMMY = 9
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_DUMMY ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_EMULATION_FAULTS = 8
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_EMULATION_FAULTS ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS = 2
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS_MAJ ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS_MIN = 5
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_PAGE_FAULTS_MIN ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_TASK_CLOCK = 1
-pkg runtime (linux-amd64-cgo), const PERF_COUNT_SW_TASK_CLOCK ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_DISABLE = 9217
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_DISABLE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_ENABLE = 9216
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_ENABLE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_ID = 2148017159
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_ID ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 1074275339
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_MODIFY_ATTRIBUTES ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_PAUSE_OUTPUT = 1074013193
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_PAUSE_OUTPUT ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_PERIOD = 1074275332
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_PERIOD ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_QUERY_BPF = 3221758986
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_QUERY_BPF ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_REFRESH = 9218
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_REFRESH ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_RESET = 9219
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_RESET ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_BPF = 1074013192
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_BPF ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_FILTER = 1074275334
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_FILTER ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_OUTPUT = 9221
-pkg runtime (linux-amd64-cgo), const PERF_EVENT_IOC_SET_OUTPUT ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_CLOEXEC = 8
-pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_CLOEXEC ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_NO_GROUP = 1
-pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_NO_GROUP ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_OUTPUT = 2
-pkg runtime (linux-amd64-cgo), const PERF_FLAG_FD_OUTPUT ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_FLAG_PID_CGROUP = 4
-pkg runtime (linux-amd64-cgo), const PERF_FLAG_PID_CGROUP ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_FORMAT_GROUP = 8
-pkg runtime (linux-amd64-cgo), const PERF_FORMAT_GROUP ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_FORMAT_ID = 4
-pkg runtime (linux-amd64-cgo), const PERF_FORMAT_ID ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_FORMAT_TOTAL_TIME_ENABLED = 1
-pkg runtime (linux-amd64-cgo), const PERF_FORMAT_TOTAL_TIME_ENABLED ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_FORMAT_TOTAL_TIME_RUNNING = 2
-pkg runtime (linux-amd64-cgo), const PERF_FORMAT_TOTAL_TIME_RUNNING ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_AUX = 11
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_AUX ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_COMM = 3
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_COMM ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_EXIT = 4
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_EXIT ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_FORK = 7
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_FORK ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_ITRACE_START = 12
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_ITRACE_START ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_LOST = 2
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_LOST ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_LOST_SAMPLES = 13
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_LOST_SAMPLES ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_MMAP = 1
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_MMAP ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_MMAP2 = 10
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_MMAP2 ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_NAMESPACES = 16
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_NAMESPACES ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_READ = 8
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_READ ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_SAMPLE = 9
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_SAMPLE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_SWITCH = 14
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_SWITCH ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_SWITCH_CPU_WIDE = 15
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_SWITCH_CPU_WIDE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_THROTTLE = 5
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_THROTTLE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_UNTHROTTLE = 6
-pkg runtime (linux-amd64-cgo), const PERF_RECORD_UNTHROTTLE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_ADDR = 8
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_ADDR ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ABORT_TX = 128
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ABORT_TX ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY = 8
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY_CALL = 16
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY_CALL ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY_RETURN = 32
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_ANY_RETURN ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_CALL = 8192
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_CALL ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_CALL_STACK = 2048
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_CALL_STACK ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_COND = 1024
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_COND ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_HV = 4
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_HV ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IND_CALL = 64
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IND_CALL ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IND_JUMP = 4096
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IND_JUMP ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IN_TX = 256
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_IN_TX ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_KERNEL = 2
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_KERNEL ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_CYCLES = 32768
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_CYCLES ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_FLAGS = 16384
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_FLAGS ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_TX = 512
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_NO_TX ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_STACK = 2048
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_STACK ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_TYPE_SAVE = 65536
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_TYPE_SAVE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_USER = 1
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_BRANCH_USER ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_CALLCHAIN = 32
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_CALLCHAIN ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_CPU = 128
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_CPU ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_ID = 64
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_ID ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_IP = 1
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_IP ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_PERIOD = 256
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_PERIOD ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_RAW = 1024
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_RAW ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_READ = 16
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_READ ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_STREAM_ID = 512
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_STREAM_ID ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_TID = 2
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_TID ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_TIME = 4
-pkg runtime (linux-amd64-cgo), const PERF_SAMPLE_TIME ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_BREAKPOINT = 5
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_BREAKPOINT ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_HARDWARE = 0
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_HARDWARE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_HW_CACHE = 3
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_HW_CACHE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_RAW = 4
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_RAW ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_SOFTWARE = 1
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_SOFTWARE ideal-int
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_TRACEPOINT = 2
-pkg runtime (linux-amd64-cgo), const PERF_TYPE_TRACEPOINT ideal-int
-pkg runtime, const GO_COUNT_HW_BRANCH_INSTRUCTIONS = 4
-pkg runtime, const GO_COUNT_HW_BRANCH_INSTRUCTIONS ideal-int
-pkg runtime, const GO_COUNT_HW_BRANCH_MISSES = 5
-pkg runtime, const GO_COUNT_HW_BRANCH_MISSES ideal-int
-pkg runtime, const GO_COUNT_HW_BUS_CYCLES = 6
-pkg runtime, const GO_COUNT_HW_BUS_CYCLES ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_BPU = 15
-pkg runtime, const GO_COUNT_HW_CACHE_BPU ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_DTLB = 13
-pkg runtime, const GO_COUNT_HW_CACHE_DTLB ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_ITLB = 14
-pkg runtime, const GO_COUNT_HW_CACHE_ITLB ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_L1D = 10
-pkg runtime, const GO_COUNT_HW_CACHE_L1D ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_L1I = 11
-pkg runtime, const GO_COUNT_HW_CACHE_L1I ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_LL = 12
-pkg runtime, const GO_COUNT_HW_CACHE_LL ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_MISSES = 3
-pkg runtime, const GO_COUNT_HW_CACHE_MISSES ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_NODE = 16
-pkg runtime, const GO_COUNT_HW_CACHE_NODE ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_OP_PREFETCH = 19
-pkg runtime, const GO_COUNT_HW_CACHE_OP_PREFETCH ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_OP_READ = 17
-pkg runtime, const GO_COUNT_HW_CACHE_OP_READ ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_OP_WRITE = 18
-pkg runtime, const GO_COUNT_HW_CACHE_OP_WRITE ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_REFERENCES = 2
-pkg runtime, const GO_COUNT_HW_CACHE_REFERENCES ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_RESULT_ACCESS = 20
-pkg runtime, const GO_COUNT_HW_CACHE_RESULT_ACCESS ideal-int
-pkg runtime, const GO_COUNT_HW_CACHE_RESULT_MISS = 21
-pkg runtime, const GO_COUNT_HW_CACHE_RESULT_MISS ideal-int
-pkg runtime, const GO_COUNT_HW_CPU_CYCLES = 0
-pkg runtime, const GO_COUNT_HW_CPU_CYCLES ideal-int
-pkg runtime, const GO_COUNT_HW_INSTRUCTIONS = 1
-pkg runtime, const GO_COUNT_HW_INSTRUCTIONS ideal-int
-pkg runtime, const GO_COUNT_HW_REF_CPU_CYCLES = 9
-pkg runtime, const GO_COUNT_HW_REF_CPU_CYCLES ideal-int
-pkg runtime, const GO_COUNT_HW_STALLED_CYCLES_BACKEND = 8
-pkg runtime, const GO_COUNT_HW_STALLED_CYCLES_BACKEND ideal-int
-pkg runtime, const GO_COUNT_HW_STALLED_CYCLES_FRONTEND = 7
-pkg runtime, const GO_COUNT_HW_STALLED_CYCLES_FRONTEND ideal-int
-pkg runtime, const GO_COUNT_SW_CONTEXT_SWITCHES = 25
-pkg runtime, const GO_COUNT_SW_CONTEXT_SWITCHES ideal-int
-pkg runtime, const GO_COUNT_SW_CPU_CLOCK = 22
-pkg runtime, const GO_COUNT_SW_CPU_CLOCK ideal-int
-pkg runtime, const GO_COUNT_SW_PAGE_FAULTS = 24
-pkg runtime, const GO_COUNT_SW_PAGE_FAULTS ideal-int
-pkg runtime, const GO_COUNT_SW_TASK_CLOCK = 23
-pkg runtime, const GO_COUNT_SW_TASK_CLOCK ideal-int
-pkg runtime, func SetPMUProfile(int, *PMUEventAttr)
-pkg runtime, type PMUEventAttr struct
-pkg runtime, type PMUEventAttr struct, IsHvIncluded bool
-pkg runtime, type PMUEventAttr struct, IsKernelIncluded bool
-pkg runtime, type PMUEventAttr struct, Period uint64
-pkg runtime, type PMUEventAttr struct, PreciseIP uint8
-pkg runtime/pprof, func StartCPUProfile(io.Writer, ...int) error
-pkg runtime/pprof, func StartPMUProfile(...ProfilingOption) error
-pkg runtime/pprof, func StopPMUProfile()
-pkg runtime/pprof, func WithProfilingCacheMiss(io.Writer, *PMUEventConfig) ProfilingOption
-pkg runtime/pprof, func WithProfilingCacheRef(io.Writer, *PMUEventConfig) ProfilingOption
-pkg runtime/pprof, func WithProfilingCycle(io.Writer, *PMUEventConfig) ProfilingOption
-pkg runtime/pprof, func WithProfilingInstr(io.Writer, *PMUEventConfig) ProfilingOption
-pkg runtime/pprof, type PMUEventConfig struct
-pkg runtime/pprof, type PMUEventConfig struct, IsHvIncluded bool
-pkg runtime/pprof, type PMUEventConfig struct, IsKernelIncluded bool
-pkg runtime/pprof, type PMUEventConfig struct, Period int64
-pkg runtime/pprof, type PMUEventConfig struct, PreciseIP int8
-pkg runtime/pprof, type ProfilingOption interface, unexported methods
-pkg crypto/tls, const Ed25519 = 2055
-pkg crypto/tls, const Ed25519 SignatureScheme
-pkg crypto/x509, const Ed25519 = 4
-pkg crypto/x509, const Ed25519 PublicKeyAlgorithm
-pkg crypto/x509, const PureEd25519 = 16
-pkg crypto/x509, const PureEd25519 SignatureAlgorithm

From baa16946ca2ff355f44847005e211b78d059f5b8 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 10 Jul 2019 17:00:19 -0700
Subject: [PATCH 052/126] test cases for http

---
 test/pmu/http/test1.go | 25 ++++++++++++++++++++
 test/pmu/http/test2.go | 52 ++++++++++++++++++++++++++++++++++++++++++
 test/pmu/http/test3.go | 49 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 126 insertions(+)
 create mode 100644 test/pmu/http/test1.go
 create mode 100644 test/pmu/http/test2.go
 create mode 100644 test/pmu/http/test3.go

diff --git a/test/pmu/http/test1.go b/test/pmu/http/test1.go
new file mode 100644
index 0000000000..6cfe39e45d
--- /dev/null
+++ b/test/pmu/http/test1.go
@@ -0,0 +1,25 @@
+// run
+// Example of Usage: go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=cycles\&period=10000000
+
+package main
+
+import (
+	"fmt"
+	"log"
+	// "time"
+	"net/http"
+	_ "net/http/pprof"
+)
+
+var sum int
+
+func main() {
+	go func() {
+        log.Println(http.ListenAndServe("localhost:6060", nil))
+	}()
+	// time.Sleep(2 * time.Second)
+	for i := 0; i <= 10000000000; i++ {
+		sum += i
+	}
+	fmt.Println(sum)
+}
diff --git a/test/pmu/http/test2.go b/test/pmu/http/test2.go
new file mode 100644
index 0000000000..47d52e20ba
--- /dev/null
+++ b/test/pmu/http/test2.go
@@ -0,0 +1,52 @@
+// run
+// Example of Usage: go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=cycles\&period=10000000
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"sync"
+    // "time"
+    "net/http"
+    _ "net/http/pprof"
+)
+
+var wg sync.WaitGroup
+var mux sync.Mutex
+var sum int
+
+func f(i int) {
+	defer wg.Done()
+        var local int
+	for j := i; j < 100000000; j++ {
+        local -= j / 2
+        local *= j
+        mux.Lock()
+        sum += local
+        mux.Unlock()
+    }
+}
+
+func run() error {
+	go func() {
+		log.Println(http.ListenAndServe("localhost:6060", nil))
+	}()
+
+	wg.Add(1000)
+	defer wg.Wait()
+
+	for i := 0; i < 1000; i++ {
+		go f(i)
+	}
+
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+
+    fmt.Println(sum)
+}
diff --git a/test/pmu/http/test3.go b/test/pmu/http/test3.go
new file mode 100644
index 0000000000..ed9af94112
--- /dev/null
+++ b/test/pmu/http/test3.go
@@ -0,0 +1,49 @@
+// run
+// Example of Usage: go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=cycles\&period=10000000
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"sync"
+	"time"
+	"net/http"
+	_ "net/http/pprof"
+)
+
+var wg sync.WaitGroup
+var mux sync.Mutex
+var sum int
+
+func f(i int) {
+	defer wg.Done()
+	for j := i; j < 100000000; j++ {
+        sum -= j / 2
+        sum *= j
+        time.Sleep(time.Microsecond)
+    }
+}
+
+func run() error {
+	go func() {
+		log.Println(http.ListenAndServe("localhost:6060", nil))
+	}()
+
+	wg.Add(1000)
+	defer wg.Wait()
+
+	for i := 0; i < 1000; i++ {
+		go f(i)
+	}
+
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println(sum)
+}

From d490da697b51bf4e33ba8b42f66ce243aa5c132e Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 10 Jul 2019 17:02:15 -0700
Subject: [PATCH 053/126] indention

---
 test/pmu/http/test2.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/pmu/http/test2.go b/test/pmu/http/test2.go
index 47d52e20ba..3b09b9ea1e 100644
--- a/test/pmu/http/test2.go
+++ b/test/pmu/http/test2.go
@@ -48,5 +48,5 @@ func main() {
 		log.Fatal(err)
 	}
 
-    fmt.Println(sum)
+	fmt.Println(sum)
 }

From 0e744a872c503ce10ac6f577a147770e327147b4 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 10 Jul 2019 19:51:43 -0700
Subject: [PATCH 054/126] minor

---
 src/runtime/defs_linux_amd64.go | 13 +++++++------
 src/runtime/pprof/pprof.go      |  8 ++++----
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 48649d153c..90b48d89d1 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -418,11 +418,12 @@ type fOwnerEx struct {
 }
 
 var perfEventOpt = []struct {
-	Type    uint32
-	 Config  uint64
+	Type    uint32 // type of event
+	Config  uint64 // event 
 } {
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES},
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS},
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES},
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES},
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES},	      // index: GO_COUNT_HW_CPU_CYCLES
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS},     // index: GO_COUNT_HW_INSTRUCTIONS
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES}, // index: GO_COUNT_HW_CACHE_REFERENCES
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES},     // index: GO_COUNT_HW_CACHE_MISSES
+	// TODO: add more perf events
 }
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 2a0bb4b913..2d604235ee 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -838,7 +838,7 @@ func WithProfilingCycle(w io.Writer, eventConfig *PMUEventConfig) ProfilingOptio
             eventConfig.Period = 300
         }
 
-        helper(w, eventConfig, /*event ID*/ 0, /*event Name*/ "cycles")
+        helper(w, eventConfig, /*event ID*/ runtime.GO_COUNT_HW_CPU_CYCLES, /*event Name*/ "cycles")
 		return nil
 	})
 }
@@ -853,7 +853,7 @@ func WithProfilingInstr(w io.Writer, eventConfig *PMUEventConfig) ProfilingOptio
 		eventConfig.Period = 300
         }
 
-        helper(w, eventConfig, /*event ID*/ 1, /*event Name*/ "instructions")
+        helper(w, eventConfig, /*event ID*/ runtime.GO_COUNT_HW_INSTRUCTIONS, /*event Name*/ "instructions")
 		return nil
 	})
 }
@@ -865,7 +865,7 @@ func WithProfilingCacheRef(w io.Writer, eventConfig *PMUEventConfig) ProfilingOp
         }
         // TODO: Clamp period to something reasonable
 
-        helper(w, eventConfig, /*event ID*/ 2, /*event Name*/ "cache references")
+        helper(w, eventConfig, /*event ID*/ runtime.GO_COUNT_HW_CACHE_REFERENCES, /*event Name*/ "cache references")
 		return nil
 	})
 }
@@ -877,7 +877,7 @@ func WithProfilingCacheMiss(w io.Writer, eventConfig *PMUEventConfig) ProfilingO
         }
         // TODO: Clamp period to something reasonable
 
-        helper(w, eventConfig, /*event ID*/ 3, /*event Name*/ "cache misses")
+        helper(w, eventConfig, /*event ID*/ runtime.GO_COUNT_HW_CACHE_MISSES, /*event Name*/ "cache misses")
 		return nil
 	})
 }

From 0758f5690cb41da387619520fd43dd7ab958ce85 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 10 Jul 2019 20:24:37 -0700
Subject: [PATCH 055/126] minor

---
 src/runtime/os_darwin.go      |  6 +++---
 src/runtime/os_linux_386.go   |  6 +++---
 src/runtime/os_linux_amd64.go | 12 ++++++------
 src/runtime/pprof/pprof.go    |  8 ++++----
 4 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/runtime/os_darwin.go b/src/runtime/os_darwin.go
index e11d8f8c6b..c9b6335f54 100644
--- a/src/runtime/os_darwin.go
+++ b/src/runtime/os_darwin.go
@@ -356,8 +356,8 @@ func sysargs(argc int32, argv **byte) {
 	}
 }
 
-func setProcessPMUProfiler(arg ...interface{}) {/*TODO: implementation*/}
-func setThreadPMUProfiler(arg ...interface{}) {/*TODO: implementation*/}
+func setProcessPMUProfiler(arg ...interface{}) {/* TODO: implementation */}
+func setThreadPMUProfiler(arg ...interface{}) {/* TODO: implementation */}
 
 //go:nowritebarrierrec
-func sigpmuhandler(arg ...interface{}) {/*TODO: implementation*/}
+func sigpmuhandler(arg ...interface{}) {/* TODO: implementation */}
diff --git a/src/runtime/os_linux_386.go b/src/runtime/os_linux_386.go
index 7f37fbbb61..35076520c2 100644
--- a/src/runtime/os_linux_386.go
+++ b/src/runtime/os_linux_386.go
@@ -4,8 +4,8 @@
 
 package runtime
 
-func setProcessPMUProfiler(arg ...interface{}) /*TODO: implementation*/{}
-func setThreadPMUProfiler(arg ...interface{}) {/*TODO: implementation*/}
+func setProcessPMUProfiler(arg ...interface{}) {/* TODO: implementation */}
+func setThreadPMUProfiler(arg ...interface{}) {/* TODO: implementation */}
 
 //go:nowritebarrierrec
-func sigpmuhandler(arg ...interface{}) {/*TODO: implementation*/}
+func sigpmuhandler(arg ...interface{}) {/* TODO: implementation */}
diff --git a/src/runtime/os_linux_amd64.go b/src/runtime/os_linux_amd64.go
index f3db7b3297..ada25b30fb 100644
--- a/src/runtime/os_linux_amd64.go
+++ b/src/runtime/os_linux_amd64.go
@@ -59,13 +59,13 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			perfAttr.Bits += 0b1000000
 		}
 
-		fd, _, _ := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy*/ 0)
+		fd, _, _ := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy */ 0)
 		_g_.m.eventFds[eventId] = fd
-		r, _ := fcntl(fd, /*F_GETFL*/ 0x3, 0)
-		fcntl(fd, /*F_SETFL*/ 0x4, r | /*O_ASYNC*/ 0x2000)
-		fcntl(fd, /*F_SETSIG*/ 0xa, _SIGPMU)
-		fOwnEx := fOwnerEx{/*F_OWNER_TID*/ 0, int32(gettid())}
-		fcntl2(fd, /*F_SETOWN_EX*/ 0xf, &fOwnEx)
+		r, _ := fcntl(fd, /* F_GETFL */ 0x3, 0)
+		fcntl(fd, /* F_SETFL */ 0x4, r | /* O_ASYNC */ 0x2000)
+		fcntl(fd, /* F_SETSIG */ 0xa, _SIGPMU)
+		fOwnEx := fOwnerEx{/* F_OWNER_TID */ 0, int32(gettid())}
+		fcntl2(fd, /* F_SETOWN_EX */ 0xf, &fOwnEx)
 	}
 
 	_g_.m.eventAttrs[eventId] = eventAttr
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 2d604235ee..10061c9fc9 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -838,7 +838,7 @@ func WithProfilingCycle(w io.Writer, eventConfig *PMUEventConfig) ProfilingOptio
             eventConfig.Period = 300
         }
 
-        helper(w, eventConfig, /*event ID*/ runtime.GO_COUNT_HW_CPU_CYCLES, /*event Name*/ "cycles")
+        helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CPU_CYCLES, /* event name */ "cycles")
 		return nil
 	})
 }
@@ -853,7 +853,7 @@ func WithProfilingInstr(w io.Writer, eventConfig *PMUEventConfig) ProfilingOptio
 		eventConfig.Period = 300
         }
 
-        helper(w, eventConfig, /*event ID*/ runtime.GO_COUNT_HW_INSTRUCTIONS, /*event Name*/ "instructions")
+        helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_INSTRUCTIONS, /* event name */ "instructions")
 		return nil
 	})
 }
@@ -865,7 +865,7 @@ func WithProfilingCacheRef(w io.Writer, eventConfig *PMUEventConfig) ProfilingOp
         }
         // TODO: Clamp period to something reasonable
 
-        helper(w, eventConfig, /*event ID*/ runtime.GO_COUNT_HW_CACHE_REFERENCES, /*event Name*/ "cache references")
+        helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_REFERENCES, /* event name */ "cache references")
 		return nil
 	})
 }
@@ -877,7 +877,7 @@ func WithProfilingCacheMiss(w io.Writer, eventConfig *PMUEventConfig) ProfilingO
         }
         // TODO: Clamp period to something reasonable
 
-        helper(w, eventConfig, /*event ID*/ runtime.GO_COUNT_HW_CACHE_MISSES, /*event Name*/ "cache misses")
+        helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_MISSES, /* event name */ "cache misses")
 		return nil
 	})
 }

From ce755fd7a2bea336d8760669ede67b1a2ffeefb5 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 11 Jul 2019 15:10:58 -0700
Subject: [PATCH 056/126] test cases

---
 test/pmu/test1.go | 32 +++++++++---------
 test/pmu/test2.go | 82 +++++++++++++++++++++++------------------------
 2 files changed, 57 insertions(+), 57 deletions(-)

diff --git a/test/pmu/test1.go b/test/pmu/test1.go
index 5fcc42af72..816b2fbd50 100644
--- a/test/pmu/test1.go
+++ b/test/pmu/test1.go
@@ -4,7 +4,7 @@ package main
 
 import (
 	"fmt"
-    "log"
+	"log"
 	"os"
 	"sync"
 	"runtime/pprof"
@@ -154,23 +154,23 @@ func f10() {
 
 
 func run() error {
-    cycleFile, err := os.Create("cycle_profile")
-	if err != nil {
-	 return err
-	}
-    defer cycleFile.Close()
-    
-    var cycle pprof.PMUEventConfig
-    cycle.Period =  20000000
-    cycle.IsKernelIncluded = false
-    cycle.IsHvIncluded = false
-    
-    if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycleFile, &cycle)); err != nil {
-        return err
+	cycleFile, err := os.Create("cycle_profile")
+		if err != nil {
+			return err
+		}
+	defer cycleFile.Close()
+
+	var cycle pprof.PMUEventConfig
+	cycle.Period =  10000000
+	cycle.IsKernelIncluded = false
+	cycle.IsHvIncluded = false
+
+	if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycleFile, &cycle)); err != nil {
+		return err
 	}
 	defer pprof.StopPMUProfile()
 
-    wg.Add(10)
+	wg.Add(10)
 	defer wg.Wait()
 
 	go f1()
@@ -184,7 +184,7 @@ func run() error {
 	go f9()
 	go f10()
 
-    return nil
+	return nil
 }
 
 func main() {
diff --git a/test/pmu/test2.go b/test/pmu/test2.go
index 2a88e173b2..bbc348edbf 100644
--- a/test/pmu/test2.go
+++ b/test/pmu/test2.go
@@ -155,61 +155,61 @@ func f10() {
 func run() error {
 	itimerFile, err := os.Create("itimer_profile")
 	if err != nil {
-	 return err
+		return err
 	}
-    defer itimerFile.Close()
-    
-    cycleFile, err := os.Create("cycle_profile")
+	defer itimerFile.Close()
+
+	cycleFile, err := os.Create("cycle_profile")
 	if err != nil {
-	 return err
+		return err
 	}
-    defer cycleFile.Close()
-    
-    var cycle pprof.PMUEventConfig
-    cycle.Period =  20000000
-    // cycle.PreciseIP = 2
+	defer cycleFile.Close()
+
+	var cycle pprof.PMUEventConfig
+	cycle.Period =  15000000
+	// cycle.PreciseIP = 2
 
-    instrFile, err := os.Create("instr_profile")
+	instrFile, err := os.Create("instr_profile")
 	if err != nil {
-	 return err
-	}
-    defer instrFile.Close()
-    
-    var instr pprof.PMUEventConfig
-    instr.Period =  20000000
-    // instr.PreciseIP = 2
-   
-    cacheRefFile, err := os.Create("cacheRef_profile")
+		return err
+	}
+	defer instrFile.Close()
+
+	var instr pprof.PMUEventConfig
+	instr.Period =  10000000
+	// instr.PreciseIP = 2
+
+	cacheRefFile, err := os.Create("cacheRef_profile")
 	if err != nil {
-	 return err
-	}
-    defer cacheRefFile.Close()
-    
-    var cacheRef pprof.PMUEventConfig
-    cacheRef.Period =  200
-    // cacheRef.PreciseIP = 2
-	
-    cacheMissFile, err := os.Create("cacheMiss_profile")
+		return err
+	}
+	defer cacheRefFile.Close()
+
+	var cacheRef pprof.PMUEventConfig
+	cacheRef.Period =  200
+	// cacheRef.PreciseIP = 2
+
+	cacheMissFile, err := os.Create("cacheMiss_profile")
 	if err != nil {
-	 return err
+		return err
 	}
-    defer cacheMissFile.Close()
-    
-    var cacheMiss pprof.PMUEventConfig
-    cacheMiss.Period =  10
-    // cacheMiss.PreciseIP = 2
+	defer cacheMissFile.Close()
+
+	var cacheMiss pprof.PMUEventConfig
+	cacheMiss.Period =  1
+	// cacheMiss.PreciseIP = 2
 
-    if err := pprof.StartCPUProfile(itimerFile); err != nil {
-        return err
+	if err := pprof.StartCPUProfile(itimerFile); err != nil {
+		return err
 	}
 	defer pprof.StopCPUProfile()
 
-    if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycleFile, &cycle), pprof.WithProfilingInstr(instrFile, &instr), pprof.WithProfilingCacheRef(cacheRefFile, &cacheRef), pprof.WithProfilingCacheMiss(cacheMissFile, &cacheMiss)); err != nil {
-        return err
+	if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycleFile, &cycle), pprof.WithProfilingInstr(instrFile, &instr), pprof.WithProfilingCacheRef(cacheRefFile, &cacheRef), pprof.WithProfilingCacheMiss(cacheMissFile, &cacheMiss)); err != nil {
+		return err
 	}
 	defer pprof.StopPMUProfile()
 
-    wg.Add(10)
+	wg.Add(10)
 	defer wg.Wait()
 
 	go f1()
@@ -223,7 +223,7 @@ func run() error {
 	go f9()
 	go f10()
 
-    return nil
+	return nil
 }
 
 func main() {

From f498eafdf1de15d6a49f123b52760973fea801d5 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sat, 13 Jul 2019 17:06:58 -0700
Subject: [PATCH 057/126] test cases

---
 test/pmu/test2.go  |  17 +---
 test/pmu/test3.go  | 189 +++++++++++++++++++++++++++++++++++++++++++++
 test/pmu/test3.out |  10 +++
 3 files changed, 202 insertions(+), 14 deletions(-)
 create mode 100644 test/pmu/test3.go
 create mode 100644 test/pmu/test3.out

diff --git a/test/pmu/test2.go b/test/pmu/test2.go
index bbc348edbf..50c6149f0d 100644
--- a/test/pmu/test2.go
+++ b/test/pmu/test2.go
@@ -4,7 +4,7 @@ package main
 
 import (
 	"fmt"
-    "log"
+	"log"
 	"os"
 	"sync"
 	"runtime/pprof"
@@ -153,12 +153,6 @@ func f10() {
 }
 
 func run() error {
-	itimerFile, err := os.Create("itimer_profile")
-	if err != nil {
-		return err
-	}
-	defer itimerFile.Close()
-
 	cycleFile, err := os.Create("cycle_profile")
 	if err != nil {
 		return err
@@ -199,15 +193,10 @@ func run() error {
 	cacheMiss.Period =  1
 	// cacheMiss.PreciseIP = 2
 
-	if err := pprof.StartCPUProfile(itimerFile); err != nil {
-		return err
-	}
-	defer pprof.StopCPUProfile()
-
 	if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycleFile, &cycle), pprof.WithProfilingInstr(instrFile, &instr), pprof.WithProfilingCacheRef(cacheRefFile, &cacheRef), pprof.WithProfilingCacheMiss(cacheMissFile, &cacheMiss)); err != nil {
 		return err
-	}
-	defer pprof.StopPMUProfile()
+	 }
+	 defer pprof.StopPMUProfile()
 
 	wg.Add(10)
 	defer wg.Wait()
diff --git a/test/pmu/test3.go b/test/pmu/test3.go
new file mode 100644
index 0000000000..65e6fc0cf0
--- /dev/null
+++ b/test/pmu/test3.go
@@ -0,0 +1,189 @@
+// run
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"sync"
+	"runtime/pprof"
+)
+
+var wg sync.WaitGroup
+
+func f1() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f2() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f3() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f4() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f5() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f6() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f7() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f8() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f9() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f10() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func run() error {
+	itimerFile, err := os.Create("itimer_profile")
+	if err != nil {
+		return err
+	}
+	defer itimerFile.Close()
+
+	if err := pprof.StartCPUProfile(itimerFile); err != nil {
+		return err
+	}
+	defer pprof.StopCPUProfile()
+
+
+	wg.Add(10)
+	defer wg.Wait()
+
+	go f1()
+	go f2()
+	go f3()
+	go f4()
+	go f5()
+	go f6()
+	go f7()
+	go f8()
+	go f9()
+	go f10()
+
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/test/pmu/test3.out b/test/pmu/test3.out
new file mode 100644
index 0000000000..9546171295
--- /dev/null
+++ b/test/pmu/test3.out
@@ -0,0 +1,10 @@
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911

From 621479e0b1a832a8678957eab525e2b8d35fbf00 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sat, 13 Jul 2019 17:13:12 -0700
Subject: [PATCH 058/126] remove

---
 src/runtime/os_linux_amd64.go | 94 -----------------------------------
 1 file changed, 94 deletions(-)
 delete mode 100644 src/runtime/os_linux_amd64.go

diff --git a/src/runtime/os_linux_amd64.go b/src/runtime/os_linux_amd64.go
deleted file mode 100644
index ada25b30fb..0000000000
--- a/src/runtime/os_linux_amd64.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime
-
-import (
-	"runtime/internal/atomic"
-	"unsafe"
-)
-
-//go:noescape
-func perfEventOpen(attr *perfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r int32, r2, err int64)
-
-func ioctl(fd int32, req, arg int64) int64
-
-// func fcntl(fd, cmd int64, arg interface{}) (r int64, err int64)
-func fcntl(fd int32, cmd, arg int64) (r int64, err int64)
-
-//go:noescape
-func fcntl2(fd int32, cmd int64, arg *fOwnerEx) (r int64, err int64)
-
-func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
-	if eventAttr != nil {
-		// Enable the Go signal handler if not enabled.
-		if atomic.Cas(&handlingSig[_SIGPMU], 0, 1) {
-			atomic.Storeuintptr(&fwdSig[_SIGPMU], getsig(_SIGPMU))
-			setsig(_SIGPMU, funcPC(sighandler))
-		}
-	} else {
-		// If the Go signal handler should be disabled by default,
-		// disable it if it is enabled.
-		if !sigInstallGoHandler(_SIGPMU) {
-			if atomic.Cas(&handlingSig[_SIGPMU], 1, 0) {
-				setsig(_SIGPMU, atomic.Loaduintptr(&fwdSig[_SIGPMU]))
-			}
-		}
-	}
-}
-
-func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
-	_g_ := getg()
-
-	if eventAttr == nil {
-		if _g_.m.eventAttrs[eventId] != nil {
-			closefd(_g_.m.eventFds[eventId])
-		}
-	} else {
-		var perfAttr perfEventAttr
-		perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
-		perfAttr.Type = perfEventOpt[eventId].Type
-		perfAttr.Config = perfEventOpt[eventId].Config
-		perfAttr.Sample = eventAttr.Period
-		perfAttr.Bits = uint64(eventAttr.PreciseIP) << 15 // precise ip
-		if !eventAttr.IsKernelIncluded { // don't count kernel
-			perfAttr.Bits += 0b100000
-		}
-		if !eventAttr.IsHvIncluded { // don't count hypervisor
-			perfAttr.Bits += 0b1000000
-		}
-
-		fd, _, _ := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy */ 0)
-		_g_.m.eventFds[eventId] = fd
-		r, _ := fcntl(fd, /* F_GETFL */ 0x3, 0)
-		fcntl(fd, /* F_SETFL */ 0x4, r | /* O_ASYNC */ 0x2000)
-		fcntl(fd, /* F_SETSIG */ 0xa, _SIGPMU)
-		fOwnEx := fOwnerEx{/* F_OWNER_TID */ 0, int32(gettid())}
-		fcntl2(fd, /* F_SETOWN_EX */ 0xf, &fOwnEx)
-	}
-
-	_g_.m.eventAttrs[eventId] = eventAttr
-}
-
-//go:nowritebarrierrec
-func sigpmuhandler(info *siginfo, ctxt unsafe.Pointer, gp *g) {
-	fd := info.si_fd
-	ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
-	_g_ := getg()
-	c := &sigctxt{info, ctxt}
-
-	var eventId int = -1
-	for i := 0; i < maxPMUEvent; i++ {
-		if _g_.m.eventFds[i] == fd {
-			eventId = i
-			break
-		}
-	}
-	if eventId != -1 {
-		sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
-	}
-
-	ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
-	return
-}

From 7b64868aceb09272e2ef13c1aebc1d0a44d80c7d Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sat, 13 Jul 2019 17:25:46 -0700
Subject: [PATCH 059/126] remove

---
 src/runtime/os_linux_386.go | 11 -----------
 1 file changed, 11 deletions(-)
 delete mode 100644 src/runtime/os_linux_386.go

diff --git a/src/runtime/os_linux_386.go b/src/runtime/os_linux_386.go
deleted file mode 100644
index 35076520c2..0000000000
--- a/src/runtime/os_linux_386.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package runtime
-
-func setProcessPMUProfiler(arg ...interface{}) {/* TODO: implementation */}
-func setThreadPMUProfiler(arg ...interface{}) {/* TODO: implementation */}
-
-//go:nowritebarrierrec
-func sigpmuhandler(arg ...interface{}) {/* TODO: implementation */}

From ecca1b30d7bbf8956bbe22f3ef0fbae67372dced Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sat, 13 Jul 2019 20:28:38 -0700
Subject: [PATCH 060/126] refactoring

---
 src/net/http/pprof/pprof.go         |  21 +--
 src/runtime/cpuprof.go              | 235 +++++++++++-----------------
 src/runtime/defs1_netbsd_386.go     |   1 -
 src/runtime/defs1_netbsd_amd64.go   |   1 -
 src/runtime/defs1_netbsd_arm.go     |   1 -
 src/runtime/defs1_netbsd_arm64.go   |   1 -
 src/runtime/defs1_solaris_amd64.go  |   1 -
 src/runtime/defs_aix_ppc64.go       |   1 -
 src/runtime/defs_darwin_386.go      |   1 -
 src/runtime/defs_darwin_amd64.go    |   1 -
 src/runtime/defs_darwin_arm.go      |   1 -
 src/runtime/defs_darwin_arm64.go    |   1 -
 src/runtime/defs_dragonfly_amd64.go |   1 -
 src/runtime/defs_freebsd_386.go     |   1 -
 src/runtime/defs_freebsd_amd64.go   |   1 -
 src/runtime/defs_freebsd_arm.go     |   1 -
 src/runtime/defs_linux_386.go       |   1 -
 src/runtime/defs_linux_amd64.go     |  12 --
 src/runtime/defs_linux_arm.go       |   1 -
 src/runtime/defs_linux_arm64.go     |   1 -
 src/runtime/defs_linux_mips64x.go   |   1 -
 src/runtime/defs_linux_mipsx.go     |   1 -
 src/runtime/defs_linux_ppc64.go     |   1 -
 src/runtime/defs_linux_ppc64le.go   |   1 -
 src/runtime/defs_linux_s390x.go     |   1 -
 src/runtime/defs_openbsd_386.go     |   1 -
 src/runtime/defs_openbsd_amd64.go   |   1 -
 src/runtime/defs_openbsd_arm.go     |   1 -
 src/runtime/defs_openbsd_arm64.go   |   1 -
 src/runtime/defs_pmu_linux.go       |  12 ++
 src/runtime/os2_plan9.go            |   1 -
 src/runtime/os_darwin.go            |   6 -
 src/runtime/os_linux.go             |  86 ++++++++++
 src/runtime/pprof/pprof.go          |  83 +++++-----
 src/runtime/pprof/proto.go          |  16 +-
 src/runtime/proc.go                 |  69 ++++----
 src/runtime/signal_sighandler.go    |  15 +-
 src/runtime/signal_unix.go          |  35 ++---
 src/runtime/sys_linux_amd64.s       |  11 +-
 39 files changed, 321 insertions(+), 307 deletions(-)
 create mode 100644 src/runtime/defs_pmu_linux.go

diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index 9793cc7d09..6b74d51344 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -141,7 +141,7 @@ func pmuProfile(w http.ResponseWriter, r *http.Request) error {
 		case "cacheMisses":
 			err = pprof.StartPMUProfile(pprof.WithProfilingCacheMiss(w, &eventConfig))
 		default:
-			return errors.New("uknown event")
+			return errors.New("unknown or not yet implemented event")
 	}
 
 	return err
@@ -168,27 +168,30 @@ func Profile(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Disposition", `attachment; filename="profile"`)
 
 	isPMUEnabled, err := strconv.ParseBool(r.FormValue("pmu"))
-	if err != nil || isPMUEnabled == false {
-		if err := pprof.StartCPUProfile(w); err != nil {
-			// StartCPUProfile failed, so no writes yet.
+
+	if err != nil {
+		if err = pprof.StartCPUProfile(w); err != nil {
 			serveError(w, http.StatusInternalServerError,
 				fmt.Sprintf("Could not enable CPU profiling: %s", err))
 			return
 		}
-	} else if err == nil && isPMUEnabled == true {
+	} else if isPMUEnabled {
 		if err = pmuProfile(w, r); err != nil {
 			serveError(w, http.StatusInternalServerError,
 				fmt.Sprintf("Could not enable PMU profiling: %s", err))
 			return
 		}
 	} else {
-		serveError(w, http.StatusInternalServerError,
-			fmt.Sprintf("Could not enable CPU or PMU profiling: %s", err))
-		return
+		if err = pprof.StartCPUProfile(w); err != nil {
+			serveError(w, http.StatusInternalServerError,
+				fmt.Sprintf("Could not enable CPU profiling: %s", err))
+			return
+		}
 	}
 
 	sleep(w, time.Duration(sec)*time.Second)
-	if isPMUEnabled == true {
+
+	if isPMUEnabled {
 		pprof.StopPMUProfile()
 	} else {
 		pprof.StopCPUProfile()
diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index e11990e6b9..86dffdf779 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -42,11 +42,8 @@ type profile struct {
 	lostExtra uint64 // count of frames lost because extra is full
 }
 
-type pmuProfile profile
-type cpuProfile profile
-
-var cpuprof cpuProfile
-var pmuprof [maxPMUEvent]pmuProfile
+var cpuprof profile
+var pmuprof [maxPMUEvent]profile
 
 // SetCPUProfileRate sets the CPU profiling rate to hz samples per second.
 // If hz <= 0, SetCPUProfileRate turns off profiling.
@@ -65,10 +62,10 @@ func SetCPUProfileRate(hz int) {
 	}
 
 	lock(&cpuprof.lock)
+	defer unlock(&cpuprof.lock)
 	if hz > 0 {
 		if cpuprof.on || cpuprof.log != nil {
 			print("runtime: cannot set cpu profile rate until previous profile has finished.\n")
-			unlock(&cpuprof.lock)
 			return
 		}
 
@@ -83,16 +80,15 @@ func SetCPUProfileRate(hz int) {
 		cpuprof.addExtra()
 		cpuprof.log.close()
 	}
-	unlock(&cpuprof.lock)
 }
 
 func SetPMUProfile(eventId int, eventAttr *PMUEventAttr) {
 	lock(&pmuprof[eventId].lock)
+	defer unlock(&pmuprof[eventId].lock)
 	if eventAttr != nil {
 		if pmuprof[eventId].on || pmuprof[eventId].log != nil {
-		print("runtime: cannot set pmu profile rate until previous profile has finished.\n")
-		unlock(&pmuprof[eventId].lock)
-		return
+			print("runtime: cannot set pmu profile rate until previous profile has finished.\n")
+			return
 		}
 
 		pmuprof[eventId].on = true
@@ -106,7 +102,19 @@ func SetPMUProfile(eventId int, eventAttr *PMUEventAttr) {
 		pmuprof[eventId].addExtra(eventId)
 		pmuprof[eventId].log.close()
 	}
-	unlock(&pmuprof[eventId].lock)
+}
+
+//go:nowritebarrierrec
+func (p *profile) addImpl(gp *g, stk []uintptr, prof *profile) {
+	if p.numExtra > 0 || p.lostExtra > 0 {
+		p.addExtra()
+	}
+	hdr := [1]uint64{1}
+	// Note: write "knows" that the argument is &gp.labels,
+	// because otherwise its write barrier behavior may not
+	// be correct. See the long comment there before
+	// changing the argument here.
+	prof.log.write(&gp.labels, nanotime(), hdr[:], stk)
 }
 
 // add adds the stack trace to the profile.
@@ -115,47 +123,38 @@ func SetPMUProfile(eventId int, eventAttr *PMUEventAttr) {
 // held at the time of the signal, nor can it use substantial amounts
 // of stack.
 //go:nowritebarrierrec
-func (p *cpuProfile) add(gp *g, stk []uintptr) {
-	// Simple cas-lock to coordinate with setcpuprofilerate.
-	for !atomic.Cas(&prof.signalLock, 0, 1) {
-		osyield()
-	}
-
-	if prof.hz != 0 { // implies cpuprof.log != nil
-		if p.numExtra > 0 || p.lostExtra > 0 {
-			p.addExtra()
+func (p *profile) add(gp *g, stk []uintptr, eventIds ...int) {
+	if len(eventIds) == 0 {
+		for !atomic.Cas(&itimer.signalLock, 0, 1) {
+			osyield()
+		}
+		if itimer.hz != 0 { // implies cpuprof.log != nil
+			p.addImpl(gp, stk, &cpuprof)
 		}
-		hdr := [1]uint64{1}
-		// Note: write "knows" that the argument is &gp.labels,
-		// because otherwise its write barrier behavior may not
-		// be correct. See the long comment there before
-		// changing the argument here.
-		cpuprof.log.write(&gp.labels, nanotime(), hdr[:], stk)
+		atomic.Store(&itimer.signalLock, 0)
+	} else {
+		eventId := eventIds[0]
+		for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
+			osyield()
+		}
+		if pmuEvent[eventId].eventAttr != nil { // implies pmuprof[eventId].log != nil
+			p.addImpl(gp, stk, &pmuprof[eventId])
+		}
+		atomic.Store(&pmuEvent[eventId].signalLock, 0)
 	}
-
-	atomic.Store(&prof.signalLock, 0)
 }
 
+//go:nosplit
 //go:nowritebarrierrec
-func (p *pmuProfile) add(gp *g, stk []uintptr, eventId int) {
-	// Simple cas-lock to coordinate with setpmuprofile.
-	for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
-		osyield()
-	}
-
-	if pmuEvent[eventId].eventAttr != nil { // implies pmuprof[eventId].log != nil
-		if p.numExtra > 0 || p.lostExtra > 0 {
-			p.addExtra(eventId)
-		}
-		hdr := [1]uint64{1}
-		// Note: write "knows" that the argument is &gp.labels,
-		// because otherwise its write barrier behavior may not
-		// be correct. See the long comment there before
-		// changing the argument here.
-		pmuprof[eventId].log.write(&gp.labels, nanotime(), hdr[:], stk)
+func (p *profile) addNonGoImpl(stk []uintptr, prof *profile) {
+	if prof.numExtra+1+len(stk) < len(prof.extra) {
+		i := prof.numExtra
+		prof.extra[i] = uintptr(1 + len(stk))
+		copy(prof.extra[i+1:], stk)
+		prof.numExtra += 1 + len(stk)
+	} else {
+		prof.lostExtra++
 	}
-
-	atomic.Store(&pmuEvent[eventId].signalLock, 0)
 }
 
 // addNonGo adds the non-Go stack trace to the profile.
@@ -167,47 +166,26 @@ func (p *pmuProfile) add(gp *g, stk []uintptr, eventId int) {
 // gets the signal handling event.
 //go:nosplit
 //go:nowritebarrierrec
-func (p *cpuProfile) addNonGo(stk []uintptr) {
-	// Simple cas-lock to coordinate with SetCPUProfileRate.
-	// (Other calls to add or addNonGo should be blocked out
-	// by the fact that only one SIGPROF can be handled by the
-	// process at a time. If not, this lock will serialize those too.)
-	for !atomic.Cas(&prof.signalLock, 0, 1) {
-		osyield()
-	}
-
-	if cpuprof.numExtra+1+len(stk) < len(cpuprof.extra) {
-		i := cpuprof.numExtra
-		cpuprof.extra[i] = uintptr(1 + len(stk))
-		copy(cpuprof.extra[i+1:], stk)
-		cpuprof.numExtra += 1 + len(stk)
-	} else {
-		cpuprof.lostExtra++
-	}
-
-	atomic.Store(&prof.signalLock, 0)
-}
-
-//go:nosplit
-//go:nowritebarrierrec
-func (p *pmuProfile) addNonGo(stk []uintptr, eventId int) {
-	// (Other calls to add or addNonGo should be blocked out
-	// by the fact that only one SIGPROF can be handled by the
-	// process at a time. If not, this lock will serialize those too.)
-	for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
-		osyield()
-	}
-
-	if pmuprof[eventId].numExtra+1+len(stk) < len(pmuprof[eventId].extra) {
-		i := pmuprof[eventId].numExtra
-		pmuprof[eventId].extra[i] = uintptr(1 + len(stk))
-		copy(pmuprof[eventId].extra[i+1:], stk)
-		pmuprof[eventId].numExtra += 1 + len(stk)
+func (p *profile) addNonGo(stk []uintptr, eventIds ...int) {
+	if len(eventIds) == 0 {
+		// Simple cas-lock to coordinate with SetCPUProfileRate.
+		// (Other calls to add or addNonGo should be blocked out
+		// by the fact that only one SIGPROF can be handled by the
+		// process at a time. If not, this lock will serialize those too.)
+		for !atomic.Cas(&itimer.signalLock, 0, 1) {
+			osyield()
+		}
+		p.addNonGoImpl(stk, &cpuprof)
+		atomic.Store(&itimer.signalLock, 0)
 	} else {
-		pmuprof[eventId].lostExtra++
+		eventId := eventIds[0]
+		// Only one SIGPROF for each PMU event can be handled by the process at a time.
+		for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
+			osyield()
+		}
+		p.addNonGoImpl(stk, &pmuprof[eventId])
+		atomic.Store(&pmuEvent[eventId].signalLock, 0)
 	}
-
-	atomic.Store(&pmuEvent[eventId].signalLock, 0)
 }
 
 // addExtra adds the "extra" profiling events,
@@ -215,7 +193,7 @@ func (p *pmuProfile) addNonGo(stk []uintptr, eventId int) {
 // addExtra is called either from a signal handler on a Go thread
 // or from an ordinary goroutine; either way it can use stack
 // and has a g. The world may be stopped, though.
-func (p *cpuProfile) addExtra() {
+func (p *profile) addExtra(eventIds ...int) {
 	// Copy accumulated non-Go profile events.
 	hdr := [1]uint64{1}
 	for i := 0; i < p.numExtra; {
@@ -231,48 +209,28 @@ func (p *cpuProfile) addExtra() {
 			funcPC(_LostExternalCode) + sys.PCQuantum,
 			funcPC(_ExternalCode) + sys.PCQuantum,
 		}
-		cpuprof.log.write(nil, 0, hdr[:], lostStk[:])
-		p.lostExtra = 0
-	}
-}
-
-func (p *pmuProfile) addExtra(eventId int) {
-	// Copy accumulated non-Go profile events.
-	hdr := [1]uint64{1}
-	for i := 0; i < p.numExtra; {
-		p.log.write(nil, 0, hdr[:], p.extra[i+1:i+int(p.extra[i])])
-		i += int(p.extra[i])
-	}
-	p.numExtra = 0
-
-	// Report any lost events.
-	if p.lostExtra > 0 {
-		hdr := [1]uint64{p.lostExtra}
-		lostStk := [2]uintptr{
-			funcPC(_LostExternalCode) + sys.PCQuantum,
-			funcPC(_ExternalCode) + sys.PCQuantum,
+		if len(eventIds) == 0 {
+			cpuprof.log.write(nil, 0, hdr[:], lostStk[:])
+		} else {
+			eventId := eventIds[0]
+			pmuprof[eventId].log.write(nil, 0, hdr[:], lostStk[:])
 		}
-		pmuprof[eventId].log.write(nil, 0, hdr[:], lostStk[:])
 		p.lostExtra = 0
 	}
 }
 
-func (p *cpuProfile) addLostAtomic64(count uint64) {
+func (p *profile) addLostAtomic64(count uint64, eventIds ...int) {
 	hdr := [1]uint64{count}
 	lostStk := [2]uintptr{
 		funcPC(_LostSIGPROFDuringAtomic64) + sys.PCQuantum,
 		funcPC(_System) + sys.PCQuantum,
 	}
-	cpuprof.log.write(nil, 0, hdr[:], lostStk[:])
-}
-
-func (p *pmuProfile) addLostAtomic64(count uint64, eventId int) {
-	hdr := [1]uint64{count}
-	lostStk := [2]uintptr{
-		funcPC(_LostSIGPMUDuringAtomic64) + sys.PCQuantum,
-		funcPC(_System) + sys.PCQuantum,
+	if len(eventIds) == 0 {
+		cpuprof.log.write(nil, 0, hdr[:], lostStk[:])
+	} else {
+		eventId := eventIds[0]
+		pmuprof[eventId].log.write(nil, 0, hdr[:], lostStk[:])
 	}
-	pmuprof[eventId].log.write(nil, 0, hdr[:], lostStk[:])
 }
 
 // CPUProfile panics.
@@ -293,6 +251,19 @@ func runtime_pprof_runtime_cyclesPerSecond() int64 {
 	return tickspersecond()
 }
 
+func readProfileImpl(prof *profile) ([]uint64, []unsafe.Pointer, bool) {
+	lock(&prof.lock)
+	log := prof.log
+	unlock(&prof.lock)
+	data, tags, eof := log.read(profBufBlocking)
+	if len(data) == 0 && eof {
+		lock(&prof.lock)
+		prof.log = nil
+		unlock(&prof.lock)
+	}
+	return data, tags, eof
+}
+
 // readProfile, provided to runtime/pprof, returns the next chunk of
 // binary CPU profiling stack trace data, blocking until data is available.
 // If profiling is turned off and all the profile data accumulated while it was
@@ -300,29 +271,11 @@ func runtime_pprof_runtime_cyclesPerSecond() int64 {
 // The caller must save the returned data and tags before calling readProfile again.
 //
 //go:linkname runtime_pprof_readProfile runtime/pprof.readProfile
-func runtime_pprof_readProfile() ([]uint64, []unsafe.Pointer, bool) {
-	lock(&cpuprof.lock)
-	log := cpuprof.log
-	unlock(&cpuprof.lock)
-	data, tags, eof := log.read(profBufBlocking)
-	if len(data) == 0 && eof {
-		lock(&cpuprof.lock)
-		cpuprof.log = nil
-		unlock(&cpuprof.lock)
-	}
-	return data, tags, eof
-}
-
-//go:linkname runtime_pprof_readPMUProfile runtime/pprof.readPMUProfile
-func runtime_pprof_readPMUProfile(eventId int) ([]uint64, []unsafe.Pointer, bool) {
-	lock(&pmuprof[eventId].lock)
-	log := pmuprof[eventId].log
-	unlock(&pmuprof[eventId].lock)
-	data, tags, eof := log.read(profBufBlocking)
-	if len(data) == 0 && eof {
-		lock(&pmuprof[eventId].lock)
-		pmuprof[eventId].log = nil
-		unlock(&pmuprof[eventId].lock)
+func runtime_pprof_readProfile(eventIds ...int) ([]uint64, []unsafe.Pointer, bool) {
+	if len(eventIds) == 0 {
+		return readProfileImpl(&cpuprof)
+	} else {
+		eventId := eventIds[0]
+		return readProfileImpl(&pmuprof[eventId])
 	}
-	return data, tags, eof
 }
diff --git a/src/runtime/defs1_netbsd_386.go b/src/runtime/defs1_netbsd_386.go
index 669030b0af..3eae12eed0 100644
--- a/src/runtime/defs1_netbsd_386.go
+++ b/src/runtime/defs1_netbsd_386.go
@@ -53,7 +53,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs1_netbsd_amd64.go b/src/runtime/defs1_netbsd_amd64.go
index 87c4315146..51d55c91f9 100644
--- a/src/runtime/defs1_netbsd_amd64.go
+++ b/src/runtime/defs1_netbsd_amd64.go
@@ -53,7 +53,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs1_netbsd_arm.go b/src/runtime/defs1_netbsd_arm.go
index f8fc98fa58..fadb3415b3 100644
--- a/src/runtime/defs1_netbsd_arm.go
+++ b/src/runtime/defs1_netbsd_arm.go
@@ -53,7 +53,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs1_netbsd_arm64.go b/src/runtime/defs1_netbsd_arm64.go
index e7ea5161fa..41b7aaca6c 100644
--- a/src/runtime/defs1_netbsd_arm64.go
+++ b/src/runtime/defs1_netbsd_arm64.go
@@ -53,7 +53,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs1_solaris_amd64.go b/src/runtime/defs1_solaris_amd64.go
index 7fb2549e25..64d51a7bd8 100644
--- a/src/runtime/defs1_solaris_amd64.go
+++ b/src/runtime/defs1_solaris_amd64.go
@@ -57,7 +57,6 @@ const (
 	_SIGWINCH  = 0x14
 	_SIGUSR1   = 0x10
 	_SIGUSR2   = 0x11
-	_SIGPMU    = 0x11 // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_aix_ppc64.go b/src/runtime/defs_aix_ppc64.go
index d284088d30..dccc3a5926 100644
--- a/src/runtime/defs_aix_ppc64.go
+++ b/src/runtime/defs_aix_ppc64.go
@@ -59,7 +59,6 @@ const (
 	_SIGTERM    = 0xf
 	_SIGEMT     = 0x7
 	_SIGWAITING = 0x27
-	_SIGPMU     = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x14
 	_FPE_INTOVF = 0x15
diff --git a/src/runtime/defs_darwin_386.go b/src/runtime/defs_darwin_386.go
index 338787e85d..43dc08a078 100644
--- a/src/runtime/defs_darwin_386.go
+++ b/src/runtime/defs_darwin_386.go
@@ -61,7 +61,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x7
 	_FPE_INTOVF = 0x8
diff --git a/src/runtime/defs_darwin_amd64.go b/src/runtime/defs_darwin_amd64.go
index eb8f02347a..59b0effa13 100644
--- a/src/runtime/defs_darwin_amd64.go
+++ b/src/runtime/defs_darwin_amd64.go
@@ -61,7 +61,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x7
 	_FPE_INTOVF = 0x8
diff --git a/src/runtime/defs_darwin_arm.go b/src/runtime/defs_darwin_arm.go
index 08a7dc4e3d..243f52a5df 100644
--- a/src/runtime/defs_darwin_arm.go
+++ b/src/runtime/defs_darwin_arm.go
@@ -63,7 +63,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x7
 	_FPE_INTOVF = 0x8
diff --git a/src/runtime/defs_darwin_arm64.go b/src/runtime/defs_darwin_arm64.go
index e63fb7f609..7056074f46 100644
--- a/src/runtime/defs_darwin_arm64.go
+++ b/src/runtime/defs_darwin_arm64.go
@@ -61,7 +61,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x7
 	_FPE_INTOVF = 0x8
diff --git a/src/runtime/defs_dragonfly_amd64.go b/src/runtime/defs_dragonfly_amd64.go
index b7a1ca5f5f..30f1b33845 100644
--- a/src/runtime/defs_dragonfly_amd64.go
+++ b/src/runtime/defs_dragonfly_amd64.go
@@ -57,7 +57,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU	   = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x2
 	_FPE_INTOVF = 0x1
diff --git a/src/runtime/defs_freebsd_386.go b/src/runtime/defs_freebsd_386.go
index 2fd586933c..c4d5c897d3 100644
--- a/src/runtime/defs_freebsd_386.go
+++ b/src/runtime/defs_freebsd_386.go
@@ -71,7 +71,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU	   = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x2
 	_FPE_INTOVF = 0x1
diff --git a/src/runtime/defs_freebsd_amd64.go b/src/runtime/defs_freebsd_amd64.go
index bf2b6d7b71..89d36c270d 100644
--- a/src/runtime/defs_freebsd_amd64.go
+++ b/src/runtime/defs_freebsd_amd64.go
@@ -71,7 +71,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x2
 	_FPE_INTOVF = 0x1
diff --git a/src/runtime/defs_freebsd_arm.go b/src/runtime/defs_freebsd_arm.go
index 4b3957e478..cc8c924c37 100644
--- a/src/runtime/defs_freebsd_arm.go
+++ b/src/runtime/defs_freebsd_arm.go
@@ -71,7 +71,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x2
 	_FPE_INTOVF = 0x1
diff --git a/src/runtime/defs_linux_386.go b/src/runtime/defs_linux_386.go
index a37c38d9c1..e2fcbcac71 100644
--- a/src/runtime/defs_linux_386.go
+++ b/src/runtime/defs_linux_386.go
@@ -57,7 +57,6 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
-	_SIGPMU    = 0x25 // psu: _SIGPMU = SIGRTMIN + 3
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 90b48d89d1..7ce944bb83 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -57,7 +57,6 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
-	_SIGPMU    = 0x25 // psu: _SIGPMU = SIGRTMIN + 3
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
@@ -416,14 +415,3 @@ type fOwnerEx struct {
 	Type int32
 	Pid int32
 }
-
-var perfEventOpt = []struct {
-	Type    uint32 // type of event
-	Config  uint64 // event 
-} {
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES},	      // index: GO_COUNT_HW_CPU_CYCLES
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS},     // index: GO_COUNT_HW_INSTRUCTIONS
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES}, // index: GO_COUNT_HW_CACHE_REFERENCES
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES},     // index: GO_COUNT_HW_CACHE_MISSES
-	// TODO: add more perf events
-}
diff --git a/src/runtime/defs_linux_arm.go b/src/runtime/defs_linux_arm.go
index 4716d67477..ec0b1e9935 100644
--- a/src/runtime/defs_linux_arm.go
+++ b/src/runtime/defs_linux_arm.go
@@ -54,7 +54,6 @@ const (
 	_SIGIO          = 0x1d
 	_SIGPWR         = 0x1e
 	_SIGSYS         = 0x1f
-	_SIGPMU		= 0xc // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV     = 0x1
 	_FPE_INTOVF     = 0x2
diff --git a/src/runtime/defs_linux_arm64.go b/src/runtime/defs_linux_arm64.go
index 39eebbc615..b325a229a1 100644
--- a/src/runtime/defs_linux_arm64.go
+++ b/src/runtime/defs_linux_arm64.go
@@ -57,7 +57,6 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
-	_SIGPMU    = 0xc // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_mips64x.go b/src/runtime/defs_linux_mips64x.go
index e94784391c..a52d0d40cf 100644
--- a/src/runtime/defs_linux_mips64x.go
+++ b/src/runtime/defs_linux_mips64x.go
@@ -56,7 +56,6 @@ const (
 	_SIGPROF   = 0x1d
 	_SIGXCPU   = 0x1e
 	_SIGXFSZ   = 0x1f
-	_SIGPMU    = 0x11 // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_mipsx.go b/src/runtime/defs_linux_mipsx.go
index 5a3cc37fe5..f3a1dd0cf0 100644
--- a/src/runtime/defs_linux_mipsx.go
+++ b/src/runtime/defs_linux_mipsx.go
@@ -60,7 +60,6 @@ const (
 	_SIGPROF   = 0x1d
 	_SIGXCPU   = 0x1e
 	_SIGXFSZ   = 0x1f
-	_SIGPMU    = 0x11 // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_ppc64.go b/src/runtime/defs_linux_ppc64.go
index d17f9bb8fa..f438993721 100644
--- a/src/runtime/defs_linux_ppc64.go
+++ b/src/runtime/defs_linux_ppc64.go
@@ -56,7 +56,6 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
-	_SIGPMU    = 0xc // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_ppc64le.go b/src/runtime/defs_linux_ppc64le.go
index 294e121d17..f438993721 100644
--- a/src/runtime/defs_linux_ppc64le.go
+++ b/src/runtime/defs_linux_ppc64le.go
@@ -56,7 +56,6 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
-	_SIGPMU    = 0xc // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_linux_s390x.go b/src/runtime/defs_linux_s390x.go
index 25af63074d..19b99b5bdf 100644
--- a/src/runtime/defs_linux_s390x.go
+++ b/src/runtime/defs_linux_s390x.go
@@ -57,7 +57,6 @@ const (
 	_SIGIO     = 0x1d
 	_SIGPWR    = 0x1e
 	_SIGSYS    = 0x1f
-	_SIGPMU    = 0xc // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_openbsd_386.go b/src/runtime/defs_openbsd_386.go
index 1335cf0b55..0e59a0591a 100644
--- a/src/runtime/defs_openbsd_386.go
+++ b/src/runtime/defs_openbsd_386.go
@@ -56,7 +56,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_openbsd_amd64.go b/src/runtime/defs_openbsd_amd64.go
index e6aa067a9c..5cefac5858 100644
--- a/src/runtime/defs_openbsd_amd64.go
+++ b/src/runtime/defs_openbsd_amd64.go
@@ -56,7 +56,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_openbsd_arm.go b/src/runtime/defs_openbsd_arm.go
index 19e3a054c3..b187e9776f 100644
--- a/src/runtime/defs_openbsd_arm.go
+++ b/src/runtime/defs_openbsd_arm.go
@@ -56,7 +56,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU    = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_openbsd_arm64.go b/src/runtime/defs_openbsd_arm64.go
index 0209f67267..6b9d60110a 100644
--- a/src/runtime/defs_openbsd_arm64.go
+++ b/src/runtime/defs_openbsd_arm64.go
@@ -53,7 +53,6 @@ const (
 	_SIGINFO   = 0x1d
 	_SIGUSR1   = 0x1e
 	_SIGUSR2   = 0x1f
-	_SIGPMU	   = 0x1f // psu: SIGRTMIN should not be considered constants from userland; use _SIGUSR2 instead 
 
 	_FPE_INTDIV = 0x1
 	_FPE_INTOVF = 0x2
diff --git a/src/runtime/defs_pmu_linux.go b/src/runtime/defs_pmu_linux.go
new file mode 100644
index 0000000000..a1c0b5fa82
--- /dev/null
+++ b/src/runtime/defs_pmu_linux.go
@@ -0,0 +1,12 @@
+package runtime
+
+var perfEventOpt = []struct {
+	Type    uint32 // type of event
+	Config  uint64 // event 
+} {
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES},	      // index: GO_COUNT_HW_CPU_CYCLES
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS},     // index: GO_COUNT_HW_INSTRUCTIONS
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES}, // index: GO_COUNT_HW_CACHE_REFERENCES
+	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES},     // index: GO_COUNT_HW_CACHE_MISSES
+	// TODO: add more perf events
+}
diff --git a/src/runtime/os2_plan9.go b/src/runtime/os2_plan9.go
index 1778efe447..58fb2be91f 100644
--- a/src/runtime/os2_plan9.go
+++ b/src/runtime/os2_plan9.go
@@ -71,5 +71,4 @@ const (
 	_SIGTRAP   = 6
 	_SIGPROF   = 0 // dummy value defined for badsignal
 	_SIGQUIT   = 0 // dummy value defined for sighandler
-	_SIGPMU    = 0 // psu: dummy value in order to pass testing
 )
diff --git a/src/runtime/os_darwin.go b/src/runtime/os_darwin.go
index c9b6335f54..18c15ad89e 100644
--- a/src/runtime/os_darwin.go
+++ b/src/runtime/os_darwin.go
@@ -355,9 +355,3 @@ func sysargs(argc int32, argv **byte) {
 		executablePath = executablePath[len(prefix):]
 	}
 }
-
-func setProcessPMUProfiler(arg ...interface{}) {/* TODO: implementation */}
-func setThreadPMUProfiler(arg ...interface{}) {/* TODO: implementation */}
-
-//go:nowritebarrierrec
-func sigpmuhandler(arg ...interface{}) {/* TODO: implementation */}
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index d4a9bd4ff5..40d8c4340e 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -5,6 +5,7 @@
 package runtime
 
 import (
+	"runtime/internal/atomic"
 	"runtime/internal/sys"
 	"unsafe"
 )
@@ -289,6 +290,10 @@ func getHugePageSize() uintptr {
 func osinit() {
 	ncpu = getproccount()
 	physHugePageSize = getHugePageSize()
+
+	register_setProcessPMUProfiler = setProcessPMUProfiler
+	register_setThreadPMUProfiler = setThreadPMUProfiler
+	register_sigpmuhandler = sigpmuhandler
 }
 
 var urandom_dev = []byte("/dev/urandom\x00")
@@ -452,3 +457,84 @@ func sysSigaction(sig uint32, new, old *sigactiont) {
 // rt_sigaction is implemented in assembly.
 //go:noescape
 func rt_sigaction(sig uintptr, new, old *sigactiont, size uintptr) int32
+
+func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
+	if eventAttr != nil {
+		atomic.Cas(&sigState, _UNINSTALLED, _PMU_INSTALLED)
+		// Enable the Go signal handler if not enabled.
+		if atomic.Cas(&handlingSig[_SIGPROF], 0, 1) {
+			atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF))
+			setsig(_SIGPROF, funcPC(sighandler))
+		}
+	} else {
+		atomic.Cas(&sigState, _PMU_INSTALLED, _UNINSTALLED)
+		// If the Go signal handler should be disabled by default,
+		// disable it if it is enabled.
+		if !sigInstallGoHandler(_SIGPROF) {
+			if atomic.Cas(&handlingSig[_SIGPROF], 1, 0) {
+				setsig(_SIGPROF, atomic.Loaduintptr(&fwdSig[_SIGPROF]))
+			}
+		}
+	}
+}
+
+//go:noescape
+func perfEventOpen(attr *perfEventAttr, pid, cpu, groupFd, flags, dummy int) (r int32, r2, err int)
+func fcntl(fd int32, cmd, arg int) (r, err int)
+//go:noescape
+func fcntl2(fd int32, cmd int, arg *fOwnerEx) (r, err int)
+
+func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
+	_g_ := getg()
+
+	if eventAttr == nil {
+		if _g_.m.eventAttrs[eventId] != nil {
+			closefd(_g_.m.eventFds[eventId])
+		}
+	} else {
+		var perfAttr perfEventAttr
+		perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
+		perfAttr.Type = perfEventOpt[eventId].Type
+		perfAttr.Config = perfEventOpt[eventId].Config
+		perfAttr.Sample = eventAttr.Period
+		perfAttr.Bits = uint64(eventAttr.PreciseIP) << 15 // precise ip
+		if !eventAttr.IsKernelIncluded { // don't count kernel
+			perfAttr.Bits += 0b100000
+		}
+		if !eventAttr.IsHvIncluded { // don't count hypervisor
+			perfAttr.Bits += 0b1000000
+		}
+
+		fd, _, _ := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy */ 0)
+		_g_.m.eventFds[eventId] = fd
+		r, _ := fcntl(fd, /* F_GETFL */ 0x3, 0)
+		fcntl(fd, /* F_SETFL */ 0x4, r | /* O_ASYNC */ 0x2000)
+		fcntl(fd, /* F_SETSIG */ 0xa, _SIGPROF)
+		fOwnEx := fOwnerEx{/* F_OWNER_TID */ 0, int32(gettid())}
+		fcntl2(fd, /* F_SETOWN_EX */ 0xf, &fOwnEx)
+	}
+
+	_g_.m.eventAttrs[eventId] = eventAttr
+}
+
+func ioctl(fd int32, req, arg int) int
+
+//go:nowritebarrierrec
+func sigpmuhandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
+	fd := info.si_fd
+	ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
+
+	var eventId int = -1
+	for i := 0; i < maxPMUEvent; i++ {
+		if _g_.m.eventFds[i] == fd {
+			eventId = i
+			break
+		}
+	}
+	if eventId != -1 {
+		sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
+	}
+
+	ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
+	return
+}
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 10061c9fc9..46facfb32f 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -760,6 +760,9 @@ func StartCPUProfile(w io.Writer, profileHz ...int) error {
 		cpu.done = make(chan bool)
 	}
 	// Double-check.
+	if pmu.profiling {
+		return errors.New("Please enable either cpu or pmu profiling instead of both")
+	}
 	if cpu.profiling {
 		return fmt.Errorf("cpu profiling already in use")
 	}
@@ -786,6 +789,9 @@ func StartPMUProfile(opts ...ProfilingOption) error {
 	defer pmu.Unlock()
 	pmu.wg.Add(len(opts))
 	// Double-check.
+	if cpu.profiling {
+		return errors.New("Please enable either cpu or pmu profiling instead of both")
+	}
 	if pmu.profiling {
 		return errors.New("pmu profiling already in use")
 	}
@@ -819,65 +825,66 @@ func getPreciseIP(preciseIP int8) uint8 {
 
 func helper(w io.Writer, eventConfig *PMUEventConfig, eventId int, eventName string) {
         pmu.eventOn[eventId] = true
-        eventAttr := runtime.PMUEventAttr{Period: uint64(eventConfig.Period),
-                                      PreciseIP: getPreciseIP(eventConfig.PreciseIP),
-                                      IsKernelIncluded: eventConfig.IsKernelIncluded,
-                                      IsHvIncluded: eventConfig.IsHvIncluded}
+        eventAttr := runtime.PMUEventAttr{
+		Period: uint64(eventConfig.Period),
+		PreciseIP: getPreciseIP(eventConfig.PreciseIP),
+		IsKernelIncluded: eventConfig.IsKernelIncluded,
+		IsHvIncluded: eventConfig.IsHvIncluded,
+	}
         runtime.SetPMUProfile(eventId, &eventAttr)
         go pmuProfileWriter(w, eventId, eventName)
-
 }
 
 func WithProfilingCycle(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
-       if eventConfig.Period <= 0 {
-            return errors.New("Period should be > 0")
-        }
-        // Clamp period to something reasonable
-        if eventConfig.Period < 300 {
-            eventConfig.Period = 300
-        }
-
-        helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CPU_CYCLES, /* event name */ "cycles")
+		if eventConfig.Period <= 0 {
+			return errors.New("Period should be > 0")
+		}
+		// Clamp period to something reasonable
+		if eventConfig.Period < 300 {
+			eventConfig.Period = 300
+		}
+
+		helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CPU_CYCLES, /* event name */ "cycles")
 		return nil
 	})
 }
 
 func WithProfilingInstr(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
-        if eventConfig.Period <= 0 {
-		return errors.New("Period should be > 0")
-        }
-        // Clamp period to something reasonable
-        if eventConfig.Period < 300 {
-		eventConfig.Period = 300
-        }
-
-        helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_INSTRUCTIONS, /* event name */ "instructions")
-		return nil
+		if eventConfig.Period <= 0 {
+			return errors.New("Period should be > 0")
+		}
+		// Clamp period to something reasonable
+		if eventConfig.Period < 300 {
+			eventConfig.Period = 300
+		}
+
+		helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_INSTRUCTIONS, /* event name */ "instructions")
+			return nil
 	})
 }
 
 func WithProfilingCacheRef(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
-        if eventConfig.Period <= 0 {
-		return errors.New("Period should be > 0")
-        }
-        // TODO: Clamp period to something reasonable
+		if eventConfig.Period <= 0 {
+			return errors.New("Period should be > 0")
+		}
+		// TODO: Clamp period to something reasonable
 
-        helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_REFERENCES, /* event name */ "cache references")
+		helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_REFERENCES, /* event name */ "cache references")
 		return nil
 	})
 }
 
 func WithProfilingCacheMiss(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
-        if eventConfig.Period <= 0 {
-		return errors.New("Period should be > 0")
-        }
-        // TODO: Clamp period to something reasonable
+		if eventConfig.Period <= 0 {
+			return errors.New("Period should be > 0")
+		}
+		// TODO: Clamp period to something reasonable
 
-        helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_MISSES, /* event name */ "cache misses")
+		helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_MISSES, /* event name */ "cache misses")
 		return nil
 	})
 }
@@ -895,7 +902,7 @@ func (pof profilingOptionFunc) apply() error { return pof() }
 // If profiling is turned off and all the profile data accumulated while it was
 // on has been returned, readProfile returns eof=true.
 // The caller must save the returned data and tags before calling readProfile again.
-func readProfile() (data []uint64, tags []unsafe.Pointer, eof bool)
+func readProfile(eventIds ...int) (data []uint64, tags []unsafe.Pointer, eof bool)
 
 func profileWriter(w io.Writer) {
 	b := newProfileBuilder(w)
@@ -919,14 +926,12 @@ func profileWriter(w io.Writer) {
 	cpu.done <- true
 }
 
-func readPMUProfile(eventId int) (data []uint64, tags []unsafe.Pointer, eof bool)
-
 func pmuProfileWriter(w io.Writer, eventId int, eventName string) {
 	b := newProfileBuilder(w)
 	var err error
 	for {
 		time.Sleep(100 * time.Millisecond)
-		data, tags, eof := readPMUProfile(eventId)
+		data, tags, eof := readProfile(eventId)
 		if e := b.addPMUData(data, tags); e != nil && err == nil {
 			err = e
 		}
@@ -938,7 +943,7 @@ func pmuProfileWriter(w io.Writer, eventId int, eventName string) {
 	    panic("runtime/pprof: converting profile: " + err.Error())
 	}
 	b.pmuBuild(eventName)
-    pmu.wg.Done()
+	pmu.wg.Done()
 }
 
 // StopCPUProfile stops the current CPU profile, if any.
diff --git a/src/runtime/pprof/proto.go b/src/runtime/pprof/proto.go
index 2e83d6ac6e..61e87d2846 100644
--- a/src/runtime/pprof/proto.go
+++ b/src/runtime/pprof/proto.go
@@ -37,14 +37,14 @@ type profileBuilder struct {
 	m            profMap
 
 	// encoding state
-	w           io.Writer
-	zw          *gzip.Writer
-	pb          protobuf
-	strings     []string
-	stringMap   map[string]int
-	locs        map[uintptr]int
-	funcs       map[string]int // Package path-qualified function name to Function.ID
-	mem         []memMap
+	w            io.Writer
+	zw           *gzip.Writer
+	pb           protobuf
+	strings      []string
+	stringMap    map[string]int
+	locs         map[uintptr]int
+	funcs        map[string]int // Package path-qualified function name to Function.ID
+	mem          []memMap
 }
 
 type memMap struct {
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 70de478029..eba7a6cee1 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2125,6 +2125,9 @@ func gcstopm() {
 	stopm()
 }
 
+var register_setProcessPMUProfiler func(eventAttr *PMUEventAttr)
+var register_setThreadPMUProfiler func(eventId int32, eventAttr *PMUEventAttr)
+
 // Schedules gp to run on the current M.
 // If inheritTime is true, gp inherits the remaining time in the
 // current time slice. Otherwise, it starts a new time slice.
@@ -2149,14 +2152,16 @@ func execute(gp *g, inheritTime bool) {
 
 	// Check whether the profiler needs to be turned on or off.
 	hz := sched.profilehz
-	eventAttrs := sched.eventAttrs
-
 	if _g_.m.profilehz != hz {
 		setThreadCPUProfiler(hz)
 	}
-	for eventId := 0; eventId < maxPMUEvent; eventId++ {
-		if  _g_.m.eventAttrs[eventId] != eventAttrs[eventId] {
-			setThreadPMUProfiler(int32(eventId), eventAttrs[eventId])
+
+	if register_setThreadPMUProfiler != nil {
+		eventAttrs := sched.eventAttrs
+		for eventId := 0; eventId < maxPMUEvent; eventId++ {
+			if _g_.m.eventAttrs[eventId] != eventAttrs[eventId] {
+				register_setThreadPMUProfiler(int32(eventId), eventAttrs[eventId])
+			}
 		}
 	}
 
@@ -3622,7 +3627,7 @@ func mcount() int32 {
 	return int32(sched.mnext - sched.nmfreed)
 }
 
-var prof struct {
+var itimer struct {
 	signalLock uint32
 	hz         int32
 }
@@ -3637,7 +3642,6 @@ func _ExternalCode()              { _ExternalCode() }
 func _LostExternalCode()          { _LostExternalCode() }
 func _GC()                        { _GC() }
 func _LostSIGPROFDuringAtomic64() { _LostSIGPROFDuringAtomic64() }
-func _LostSIGPMUDuringAtomic64()  { _LostSIGPMUDuringAtomic64() }
 func _VDSO()                      { _VDSO() }
 
 func stackUnwinding(pc, sp, lr uintptr, gp *g, mp *m, stk []uintptr) int {
@@ -3771,11 +3775,11 @@ func stackUnwinding(pc, sp, lr uintptr, gp *g, mp *m, stk []uintptr) int {
 // Counts SIGPROFs received while in atomic64 critical section, on mips{,le}
 var lostAtomic64Count uint64
 
-// Called if we receive a SIGPROF signal.
+// Called if we receive a SIGPROF signal and itimer is enabled.
 // Called by the signal handler, may run during STW.
 //go:nowritebarrierrec
 func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
-	if prof.hz == 0 {
+	if itimer.hz == 0 {
 		return
 	}
 	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
@@ -3802,7 +3806,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 	getg().m.mallocing++
 	stk := make([]uintptr, maxCPUProfStack)
 	n := stackUnwinding(pc, sp, lr, gp, mp, stk)
-	if prof.hz != 0 {
+	if itimer.hz != 0 {
 		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostAtomic64Count > 0 {
 			cpuprof.addLostAtomic64(lostAtomic64Count)
 			lostAtomic64Count = 0
@@ -3812,22 +3816,15 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 	getg().m.mallocing--
 }
 
-// Counts SIGPMUs received while in atomic64 critical section, on mips{,le}
 var lostPMUAtomic64Count[maxPMUEvent] uint64
 
-// Called if we receive a SIGPMU signal.
+// Called if we receive a SIGPROF  signal and PMU is enabled.
 // Called by the signal handler, may run during STW.
 //go:nowritebarrierrec
-func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) { // SIGPMU = SIGRTMIN + 3
+func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
 	if pmuEvent[eventId].eventAttr == nil {
 		return
 	}
-	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
-	// runtime/internal/atomic. If SIGPMU arrives while the program is inside
-	// the critical section, it creates a deadlock (when writing the sample).
-	// As a workaround, create a counter of SIGPMUs while in critical section
-	// to store the count, and pass it to sigprof.add() later when SIGPMU is
-	// received from somewhere else (with _LostSIGPMUDuringAtomic64 as pc).
 	if GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm" {
 		if f := findfunc(pc); f.valid() {
 			if hasPrefix(funcname(f), "runtime/internal/atomic") {
@@ -3837,12 +3834,6 @@ func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) { // SIGPMU = SIGRTMI
 		}
 	}
 
-	// Profiling runs concurrently with GC, so it must not allocate.
-	// Set a trap in case the code does allocate.
-	// Note that on windows, one thread takes profiles of all the
-	// other threads, so mp is usually not getg().m.
-	// In fact mp may not even be stopped.
-	// See golang.org/issue/17165.
 	getg().m.mallocing++
 	stk := make([]uintptr, maxCPUProfStack)
 	n := stackUnwinding(pc, sp, lr, gp, mp, stk)
@@ -3869,7 +3860,7 @@ var sigprofCallersUse uint32
 //go:nosplit
 //go:nowritebarrierrec
 func sigprofNonGo() {
-	if prof.hz != 0 {
+	if itimer.hz != 0 {
 		n := 0
 		for n < len(sigprofCallers) && sigprofCallers[n] != 0 {
 			n++
@@ -3900,7 +3891,7 @@ func sigpmuNonGo(eventId int) {
 //go:nosplit
 //go:nowritebarrierrec
 func sigprofNonGoPC(pc uintptr) {
-	if prof.hz != 0 {
+	if itimer.hz != 0 {
 		stk := []uintptr{
 			pc,
 			funcPC(_ExternalCode) + sys.PCQuantum,
@@ -3958,19 +3949,19 @@ func setcpuprofilerate(hz int32) {
 	_g_ := getg()
 	_g_.m.locks++
 
-	// Stop profiler on this thread so that it is safe to lock prof.
+	// Stop profiler on this thread so that it is safe to lock itimer.
 	// if a profiling signal came in while we had prof locked,
 	// it would deadlock.
 	setThreadCPUProfiler(0)
 
-	for !atomic.Cas(&prof.signalLock, 0, 1) {
+	for !atomic.Cas(&itimer.signalLock, 0, 1) {
 		osyield()
 	}
-	if prof.hz != hz {
+	if itimer.hz != hz {
 		setProcessCPUProfiler(hz)
-		prof.hz = hz
+		itimer.hz = hz
 	}
-	atomic.Store(&prof.signalLock, 0)
+	atomic.Store(&itimer.signalLock, 0)
 
 	lock(&sched.lock)
 	sched.profilehz = hz
@@ -3984,21 +3975,25 @@ func setcpuprofilerate(hz int32) {
 }
 
 func setpmuprofile(eventId int32, eventAttr *PMUEventAttr) {
+	if  register_setProcessPMUProfiler == nil || register_setThreadPMUProfiler == nil {
+		return
+	}
+
 	// Disable preemption, otherwise we can be rescheduled to another thread
 	// that has profiling enabled.
 	_g_ := getg()
 	_g_.m.locks++
 
-	// Stop profiler on this thread so that it is safe to lock prof.
-	// if a profiling signal came in while we had prof locked,
+	// Stop profiler on this thread so that it is safe to lock pmuEvent[eventId].
+	// if a profiling signal came in while we had pmuEvent[eventId] locked,
 	// it would deadlock.
-	setThreadPMUProfiler(eventId, nil)
+	register_setThreadPMUProfiler(eventId, nil)
 
 	for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
 		osyield()
 	}
 	if pmuEvent[eventId].eventAttr != eventAttr {
-		setProcessPMUProfiler(eventAttr)
+		register_setProcessPMUProfiler(eventAttr)
 		pmuEvent[eventId].eventAttr = eventAttr
 	}
 	atomic.Store(&pmuEvent[eventId].signalLock, 0)
@@ -4008,7 +4003,7 @@ func setpmuprofile(eventId int32, eventAttr *PMUEventAttr) {
 	unlock(&sched.lock)
 
 	if eventAttr != nil {
-		setThreadPMUProfiler(eventId, eventAttr)
+		register_setThreadPMUProfiler(eventId, eventAttr)
 	}
 
 	_g_.m.locks--
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index 3d5c7f6571..7df291b3e8 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -7,6 +7,7 @@
 package runtime
 
 import (
+	"runtime/internal/atomic"
 	"unsafe"
 )
 
@@ -19,6 +20,8 @@ var crashing int32
 // suppressed.
 var testSigtrap func(info *siginfo, ctxt *sigctxt, gp *g) bool
 
+var register_sigpmuhandler func(info *siginfo, c *sigctxt, gp *g, _g_ *g)
+
 // sighandler is invoked when a signal occurs. The global g will be
 // set to a gsignal goroutine and we will be running on the alternate
 // signal stack. The parameter g will be the value of the global g
@@ -31,16 +34,16 @@ var testSigtrap func(info *siginfo, ctxt *sigctxt, gp *g) bool
 //
 //go:nowritebarrierrec
 func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
-	if sig == _SIGPMU {
-		sigpmuhandler(info, ctxt, gp)
-		return
-	}
-
 	_g_ := getg()
 	c := &sigctxt{info, ctxt}
 
 	if sig == _SIGPROF {
-		sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
+		state := atomic.Load(&sigState)
+		if state == _ITIMER_INSTALLED {
+			sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
+		} else if state == _PMU_INSTALLED && register_sigpmuhandler != nil {
+				register_sigpmuhandler(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp, _g_)
+		}
 		return
 	}
 
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 2381e2b89b..f56813ede6 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -38,6 +38,14 @@ const (
 	_SIG_IGN uintptr = 1
 )
 
+const (
+	_UNINSTALLED      = 0
+	_ITIMER_INSTALLED = 1
+	_PMU_INSTALLED	  = 2
+)
+
+var sigState uint32
+
 // Stores the signal handlers registered before Go installed its own.
 // These signal handlers will be invoked in cases where Go doesn't want to
 // handle a particular signal (e.g., signal occurred on a non-Go thread).
@@ -141,13 +149,6 @@ func sigInstallGoHandler(sig uint32) bool {
 	return true
 }
 
-func isProfilingSignal(sig uint32) bool {
-	if sig == _SIGPROF || sig == _SIGPMU {
-		return true
-	}
-	return false
-}
-
 // sigenable enables the Go signal handler to catch the signal sig.
 // It is only called while holding the os/signal.handlers lock,
 // via os/signal.enableSignal and signal_enable.
@@ -156,8 +157,8 @@ func sigenable(sig uint32) {
 		return
 	}
 
-	// SIGPROF and _SIGPMU are handled specially for profiling.
-	if isProfilingSignal(sig) {
+	// SIGPROF is handled specially for profiling.
+	if sig == _SIGPROF {
 		return
 	}
 
@@ -181,8 +182,8 @@ func sigdisable(sig uint32) {
 		return
 	}
 
-	// SIGPROF and _SIGPMU are handled specially for profiling.
-	if isProfilingSignal(sig) {
+	// SIGPROF is handled specially for profiling.
+	if sig == _SIGPROF {
 		return
 	}
 
@@ -210,8 +211,8 @@ func sigignore(sig uint32) {
 		return
 	}
 
-	// SIGPROF and _SIGPMU are handled specially for profiling.
-    if isProfilingSignal(sig) {
+	// SIGPROF is handled specially for profiling.
+	if sig == _SIGPROF {
 		return
 	}
 
@@ -242,12 +243,14 @@ func clearSignalHandlers() {
 // required for -buildmode=c-archive.
 func setProcessCPUProfiler(hz int32) {
 	if hz != 0 {
+		atomic.Cas(&sigState, _UNINSTALLED, _ITIMER_INSTALLED)
 		// Enable the Go signal handler if not enabled.
 		if atomic.Cas(&handlingSig[_SIGPROF], 0, 1) {
 			atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF))
 			setsig(_SIGPROF, funcPC(sighandler))
 		}
 	} else {
+		atomic.Cas(&sigState, _ITIMER_INSTALLED, _UNINSTALLED)
 		// If the Go signal handler should be disabled by default,
 		// disable it if it is enabled.
 		if !sigInstallGoHandler(_SIGPROF) {
@@ -302,10 +305,6 @@ func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
 		if sig == _SIGPROF {
 			sigprofNonGoPC(c.sigpc())
 			return
-		} else if sig == _SIGPMU {
-			// sigpmuNonGoPC(c.sigpc())
-			println("how do I know which pmu event delivers this signal")
-			return
 		}
 		c.fixsigcode(sig)
 		badsignal(uintptr(sig), c)
@@ -460,7 +459,7 @@ func dieFromSignal(sig uint32) {
 // thread, and the Go program does not want to handle it (that is, the
 // program has not called os/signal.Notify for the signal).
 func raisebadsignal(sig uint32, c *sigctxt) {
-    if isProfilingSignal(sig) {
+	if sig == _SIGPROF {
 		// Ignore profiling signals that arrive on non-Go threads.
 		return
 	}
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 8e3e05429c..d6e876acbd 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -47,7 +47,7 @@
 #define SYS_faccessat		269
 #define SYS_epoll_pwait		281
 #define SYS_epoll_create1	291
-#define SYS_perfEventOpen 298
+#define SYS_perfEventOpen 	298
 
 TEXT runtime·exit(SB),NOSPLIT,$0-4
 	MOVL	code+0(FP), DI
@@ -168,7 +168,6 @@ TEXT runtime·setitimer(SB),NOSPLIT,$0-24
 	SYSCALL
 	RET
 
-// func perfEventOpen(attr *PerfEventAttr, pid, cpu, groupFd, flags, dummy int64) (r int32, r2, err int64) 
 TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
 	MOVQ	attr+0(FP), DI
 	MOVQ	pid+8(FP), SI
@@ -191,21 +190,25 @@ ok:
 	MOVQ	$0, err+64(FP)
 	RET
 
-// func ioctl(fd int32, req, arg int64) int64
 TEXT runtime·ioctl(SB),NOSPLIT,$0
 	MOVL	fd+0(FP), DI
 	MOVQ	req+8(FP), SI
 	MOVQ	arg+16(FP), DX
+	MOVQ    $0, R10
+        MOVQ    $0, R8
+        MOVQ    $0, R9
 	MOVQ	$SYS_ioctl, AX
 	SYSCALL
 	MOVQ    AX, ret+24(FP)
 	RET
 
-// func fcntl(fd int32, cmd arg int64) (r int64, err int64)
 TEXT runtime·fcntl(SB),NOSPLIT,$0
 	MOVL	fd+0(FP), DI
 	MOVQ	cmd+8(FP), SI
 	MOVQ	arg+16(FP), DX
+	MOVQ    $0, R10
+        MOVQ    $0, R8
+        MOVQ    $0, R9
 	MOVQ	$SYS_fcntl, AX
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001

From 58fa80db73fb1aba588825ec5aa8fbfdc7ca99dd Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 14 Jul 2019 18:03:48 -0700
Subject: [PATCH 061/126] data race detection

---
 src/runtime/os_linux.go          | 28 ++++++++++++++++++----------
 src/runtime/signal_sighandler.go |  4 ++--
 2 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 40d8c4340e..c2b8208ec1 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -460,18 +460,26 @@ func rt_sigaction(sig uintptr, new, old *sigactiont, size uintptr) int32
 
 func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
 	if eventAttr != nil {
-		atomic.Cas(&sigState, _UNINSTALLED, _PMU_INSTALLED)
-		// Enable the Go signal handler if not enabled.
-		if atomic.Cas(&handlingSig[_SIGPROF], 0, 1) {
-			atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF))
-			setsig(_SIGPROF, funcPC(sighandler))
+		oldVal := atomic.Load(&handlingSig[_SIGPROF])
+		if oldVal != _PMU_INSTALLED {
+			// Enable the Go signal handler if not enabled.
+			if atomic.Cas(&handlingSig[_SIGPROF], oldVal, _PMU_INSTALLED) {
+				atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF))
+				setsig(_SIGPROF, funcPC(sighandler))
+			} else {
+				racyUpdatedVal := atomic.Load(&handlingSig[_SIGPROF])
+				if racyUpdatedVal != _UNINSTALLED {
+					panic("never reach here since pprof should have protected us")
+				} else {
+					println("sombody else did the job for us")
+				}
+			}
 		}
 	} else {
-		atomic.Cas(&sigState, _PMU_INSTALLED, _UNINSTALLED)
 		// If the Go signal handler should be disabled by default,
 		// disable it if it is enabled.
 		if !sigInstallGoHandler(_SIGPROF) {
-			if atomic.Cas(&handlingSig[_SIGPROF], 1, 0) {
+			if atomic.Cas(&handlingSig[_SIGPROF], _PMU_INSTALLED, _UNINSTALLED) {
 				setsig(_SIGPROF, atomic.Loaduintptr(&fwdSig[_SIGPROF]))
 			}
 		}
@@ -517,12 +525,12 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 	_g_.m.eventAttrs[eventId] = eventAttr
 }
 
-func ioctl(fd int32, req, arg int) int
+func ioctl(fd int32, req, arg int) (r, err int)
 
 //go:nowritebarrierrec
 func sigpmuhandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 	fd := info.si_fd
-	ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)
+	ioctl(fd, _PERF_EVENT_IOC_DISABLE, 0)
 
 	var eventId int = -1
 	for i := 0; i < maxPMUEvent; i++ {
@@ -535,6 +543,6 @@ func sigpmuhandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 		sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
 	}
 
-	ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)
+	ioctl(fd, _PERF_EVENT_IOC_ENABLE, 0)
 	return
 }
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index 7df291b3e8..7628d4575c 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -38,11 +38,11 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
 	c := &sigctxt{info, ctxt}
 
 	if sig == _SIGPROF {
-		state := atomic.Load(&sigState)
+		state := atomic.Load(&handlingSig[_SIGPROF])
 		if state == _ITIMER_INSTALLED {
 			sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
 		} else if state == _PMU_INSTALLED && register_sigpmuhandler != nil {
-				register_sigpmuhandler(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp, _g_)
+			register_sigpmuhandler(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp, _g_)
 		}
 		return
 	}

From 617f3f510fdba1a0343b2e79773880807fcbcd8d Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 14 Jul 2019 20:56:50 -0700
Subject: [PATCH 062/126] assembly code of perf_event_open, ioctl, fcntl on
 different linux vendors

---
 src/runtime/defs_linux_386.go     | 157 ++++++++++++++++++
 src/runtime/defs_linux_amd64.go   | 257 +++++++++++++++---------------
 src/runtime/defs_linux_arm.go     | 157 ++++++++++++++++++
 src/runtime/defs_linux_arm64.go   | 157 ++++++++++++++++++
 src/runtime/defs_linux_mips64x.go | 158 ++++++++++++++++++
 src/runtime/defs_linux_mipsx.go   | 157 ++++++++++++++++++
 src/runtime/defs_linux_ppc64.go   | 157 ++++++++++++++++++
 src/runtime/defs_linux_ppc64le.go | 157 ++++++++++++++++++
 src/runtime/defs_linux_s390x.go   | 157 ++++++++++++++++++
 src/runtime/defs_pmu_linux.go     |   8 +-
 src/runtime/signal_unix.go        |  21 ++-
 src/runtime/sys_linux_386.s       |  85 ++++++++++
 src/runtime/sys_linux_amd64.s     | 157 +++++++++---------
 src/runtime/sys_linux_arm.s       | 101 ++++++++++++
 src/runtime/sys_linux_arm64.s     |  92 +++++++++++
 src/runtime/sys_linux_mips64x.s   |  85 ++++++++++
 src/runtime/sys_linux_ppc64x.s    |  84 ++++++++++
 src/runtime/sys_linux_s390x.s     |  88 ++++++++++
 18 files changed, 2023 insertions(+), 212 deletions(-)

diff --git a/src/runtime/defs_linux_386.go b/src/runtime/defs_linux_386.go
index e2fcbcac71..f03fcb8bce 100644
--- a/src/runtime/defs_linux_386.go
+++ b/src/runtime/defs_linux_386.go
@@ -97,6 +97,132 @@ const (
 	_SOCK_DGRAM = 0x2
 )
 
+const (
+	_PERF_TYPE_HARDWARE   = 0x0
+	_PERF_TYPE_SOFTWARE   = 0x1
+	_PERF_TYPE_TRACEPOINT = 0x2
+	_PERF_TYPE_HW_CACHE   = 0x3
+	_PERF_TYPE_RAW        = 0x4
+	_PERF_TYPE_BREAKPOINT = 0x5
+
+	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
+	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
+	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
+	_PERF_COUNT_HW_CACHE_MISSES            = 0x3
+	_PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	_PERF_COUNT_HW_BRANCH_MISSES           = 0x5
+	_PERF_COUNT_HW_BUS_CYCLES              = 0x6
+	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
+         
+	_PERF_COUNT_HW_CACHE_L1D  = 0x0
+	_PERF_COUNT_HW_CACHE_L1I  = 0x1
+	_PERF_COUNT_HW_CACHE_LL   = 0x2
+	_PERF_COUNT_HW_CACHE_DTLB = 0x3
+	_PERF_COUNT_HW_CACHE_ITLB = 0x4
+	_PERF_COUNT_HW_CACHE_BPU  = 0x5
+	_PERF_COUNT_HW_CACHE_NODE = 0x6
+         
+	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
+	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
+	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
+         
+	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
+	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
+         
+	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
+	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
+	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
+	_PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
+	_PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
+	_PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
+	_PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
+	_PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
+	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
+	_PERF_COUNT_SW_DUMMY            = 0x9
+	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
+         
+	_PERF_SAMPLE_IP           = 0x1
+	_PERF_SAMPLE_TID          = 0x2
+	_PERF_SAMPLE_TIME         = 0x4
+	_PERF_SAMPLE_ADDR         = 0x8
+	_PERF_SAMPLE_READ         = 0x10
+	_PERF_SAMPLE_CALLCHAIN    = 0x20
+	_PERF_SAMPLE_ID           = 0x40
+	_PERF_SAMPLE_CPU          = 0x80
+	_PERF_SAMPLE_PERIOD       = 0x100
+	_PERF_SAMPLE_STREAM_ID    = 0x200
+	_PERF_SAMPLE_RAW          = 0x400
+	_PERF_SAMPLE_BRANCH_STACK = 0x800
+         
+	_PERF_SAMPLE_BRANCH_USER       = 0x1
+	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
+	_PERF_SAMPLE_BRANCH_HV         = 0x4
+	_PERF_SAMPLE_BRANCH_ANY        = 0x8
+	_PERF_SAMPLE_BRANCH_ANY_CALL   = 0x10
+	_PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
+	_PERF_SAMPLE_BRANCH_IND_CALL   = 0x40
+	_PERF_SAMPLE_BRANCH_ABORT_TX   = 0x80
+	_PERF_SAMPLE_BRANCH_IN_TX      = 0x100
+	_PERF_SAMPLE_BRANCH_NO_TX      = 0x200
+	_PERF_SAMPLE_BRANCH_COND       = 0x400
+	_PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
+	_PERF_SAMPLE_BRANCH_IND_JUMP   = 0x1000
+	_PERF_SAMPLE_BRANCH_CALL       = 0x2000
+	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
+	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
+	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
+         
+	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
+	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
+	_PERF_FORMAT_ID                 = 0x4
+	_PERF_FORMAT_GROUP              = 0x8
+         
+	_PERF_RECORD_MMAP            = 0x1
+	_PERF_RECORD_LOST            = 0x2
+	_PERF_RECORD_COMM            = 0x3
+	_PERF_RECORD_EXIT            = 0x4
+	_PERF_RECORD_THROTTLE        = 0x5
+	_PERF_RECORD_UNTHROTTLE      = 0x6
+	_PERF_RECORD_FORK            = 0x7
+	_PERF_RECORD_READ            = 0x8
+	_PERF_RECORD_SAMPLE          = 0x9
+	_PERF_RECORD_MMAP2           = 0xa
+	_PERF_RECORD_AUX             = 0xb
+	_PERF_RECORD_ITRACE_START    = 0xc
+	_PERF_RECORD_LOST_SAMPLES    = 0xd
+	_PERF_RECORD_SWITCH          = 0xe
+	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
+	_PERF_RECORD_NAMESPACES      = 0x10
+         
+	_PERF_CONTEXT_HV     = -0x20
+	_PERF_CONTEXT_KERNEL = -0x80
+	_PERF_CONTEXT_USER   = -0x200
+         
+	_PERF_CONTEXT_GUEST        = -0x800
+	_PERF_CONTEXT_GUEST_KERNEL = -0x880
+	_PERF_CONTEXT_GUEST_USER   = -0xa00
+         
+	_PERF_FLAG_FD_NO_GROUP = 0x1
+	_PERF_FLAG_FD_OUTPUT   = 0x2
+	_PERF_FLAG_PID_CGROUP  = 0x4
+	_PERF_FLAG_FD_CLOEXEC  = 0x8
+         
+	_PERF_EVENT_IOC_DISABLE               = 0x2401
+	_PERF_EVENT_IOC_ENABLE                = 0x2400
+	_PERF_EVENT_IOC_ID                    = 0x80042407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4004240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
+	_PERF_EVENT_IOC_PERIOD                = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF             = 0xc004240a
+	_PERF_EVENT_IOC_REFRESH               = 0x2402
+	_PERF_EVENT_IOC_RESET                 = 0x2403
+	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER            = 0x40042406
+	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+)
+
 type fpreg struct {
 	significand [4]uint16
 	exponent    uint16
@@ -164,6 +290,9 @@ type siginfo struct {
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
 	si_addr uint32
+	// psu: an unreliable workaround and need to figure out a better solution
+	// psu: only tested on amd64
+	si_fd    int32
 }
 
 type stackt struct {
@@ -225,3 +354,31 @@ type sockaddr_un struct {
 	family uint16
 	path   [108]byte
 }
+
+type perfEventAttr struct {
+	Type               uint32
+	Size               uint32
+	Config             uint64
+	Sample             uint64
+	Sample_type        uint64
+	Read_format        uint64
+	Bits               uint64
+	Wakeup             uint32
+	Bp_type            uint32
+	Ext1               uint64
+	Ext2               uint64
+	Branch_sample_type uint64
+	Sample_regs_user   uint64
+	Sample_stack_user  uint32
+	Clockid            int32
+	Sample_regs_intr   uint64
+	Aux_watermark      uint32
+	Sample_max_stack   uint16
+	_                  uint16
+}
+
+// psu: only tested on amd64 
+type fOwnerEx struct {
+	Type int32
+	Pid  int32
+}
diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 7ce944bb83..888f7363a0 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -94,6 +94,132 @@ const (
 	_SOCK_DGRAM = 0x2
 )
 
+const (
+	_PERF_TYPE_HARDWARE   = 0x0
+	_PERF_TYPE_SOFTWARE   = 0x1
+	_PERF_TYPE_TRACEPOINT = 0x2
+	_PERF_TYPE_HW_CACHE   = 0x3
+	_PERF_TYPE_RAW        = 0x4
+	_PERF_TYPE_BREAKPOINT = 0x5
+
+	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
+	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
+	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
+	_PERF_COUNT_HW_CACHE_MISSES            = 0x3
+	_PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	_PERF_COUNT_HW_BRANCH_MISSES           = 0x5
+	_PERF_COUNT_HW_BUS_CYCLES              = 0x6
+	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
+
+	_PERF_COUNT_HW_CACHE_L1D  = 0x0
+	_PERF_COUNT_HW_CACHE_L1I  = 0x1
+	_PERF_COUNT_HW_CACHE_LL   = 0x2
+	_PERF_COUNT_HW_CACHE_DTLB = 0x3
+	_PERF_COUNT_HW_CACHE_ITLB = 0x4
+	_PERF_COUNT_HW_CACHE_BPU  = 0x5
+	_PERF_COUNT_HW_CACHE_NODE = 0x6
+
+	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
+	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
+	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
+
+	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
+	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
+
+	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
+	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
+	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
+	_PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
+	_PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
+	_PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
+	_PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
+	_PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
+	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
+	_PERF_COUNT_SW_DUMMY            = 0x9
+	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
+
+	_PERF_SAMPLE_IP           = 0x1
+	_PERF_SAMPLE_TID          = 0x2
+	_PERF_SAMPLE_TIME         = 0x4
+	_PERF_SAMPLE_ADDR         = 0x8
+	_PERF_SAMPLE_READ         = 0x10
+	_PERF_SAMPLE_CALLCHAIN    = 0x20
+	_PERF_SAMPLE_ID           = 0x40
+	_PERF_SAMPLE_CPU          = 0x80
+	_PERF_SAMPLE_PERIOD       = 0x100
+	_PERF_SAMPLE_STREAM_ID    = 0x200
+	_PERF_SAMPLE_RAW          = 0x400
+	_PERF_SAMPLE_BRANCH_STACK = 0x800
+
+	_PERF_SAMPLE_BRANCH_USER       = 0x1
+	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
+	_PERF_SAMPLE_BRANCH_HV         = 0x4
+	_PERF_SAMPLE_BRANCH_ANY        = 0x8
+	_PERF_SAMPLE_BRANCH_ANY_CALL   = 0x10
+	_PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
+	_PERF_SAMPLE_BRANCH_IND_CALL   = 0x40
+	_PERF_SAMPLE_BRANCH_ABORT_TX   = 0x80
+	_PERF_SAMPLE_BRANCH_IN_TX      = 0x100
+	_PERF_SAMPLE_BRANCH_NO_TX      = 0x200
+	_PERF_SAMPLE_BRANCH_COND       = 0x400
+	_PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
+	_PERF_SAMPLE_BRANCH_IND_JUMP   = 0x1000
+	_PERF_SAMPLE_BRANCH_CALL       = 0x2000
+	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
+	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
+	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
+
+	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
+	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
+	_PERF_FORMAT_ID                 = 0x4
+	_PERF_FORMAT_GROUP              = 0x8
+
+	_PERF_RECORD_MMAP            = 0x1
+	_PERF_RECORD_LOST            = 0x2
+	_PERF_RECORD_COMM            = 0x3
+	_PERF_RECORD_EXIT            = 0x4
+	_PERF_RECORD_THROTTLE        = 0x5
+	_PERF_RECORD_UNTHROTTLE      = 0x6
+	_PERF_RECORD_FORK            = 0x7
+	_PERF_RECORD_READ            = 0x8
+	_PERF_RECORD_SAMPLE          = 0x9
+	_PERF_RECORD_MMAP2           = 0xa
+	_PERF_RECORD_AUX             = 0xb
+	_PERF_RECORD_ITRACE_START    = 0xc
+	_PERF_RECORD_LOST_SAMPLES    = 0xd
+	_PERF_RECORD_SWITCH          = 0xe
+	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
+	_PERF_RECORD_NAMESPACES      = 0x10
+
+	_PERF_CONTEXT_HV     = -0x20
+	_PERF_CONTEXT_KERNEL = -0x80
+	_PERF_CONTEXT_USER   = -0x200
+
+	_PERF_CONTEXT_GUEST        = -0x800
+	_PERF_CONTEXT_GUEST_KERNEL = -0x880
+	_PERF_CONTEXT_GUEST_USER   = -0xa00
+
+	_PERF_FLAG_FD_NO_GROUP = 0x1
+	_PERF_FLAG_FD_OUTPUT   = 0x2
+	_PERF_FLAG_PID_CGROUP  = 0x4
+	_PERF_FLAG_FD_CLOEXEC  = 0x8
+
+	_PERF_EVENT_IOC_DISABLE               = 0x2401
+	_PERF_EVENT_IOC_ENABLE                = 0x2400
+	_PERF_EVENT_IOC_ID                    = 0x80082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
+	_PERF_EVENT_IOC_PERIOD                = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH               = 0x2402
+	_PERF_EVENT_IOC_RESET                 = 0x2403
+	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER            = 0x40082406
+	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+)
+
 type timespec struct {
 	tv_sec  int64
 	tv_nsec int64
@@ -264,132 +390,6 @@ type sockaddr_un struct {
 	path   [108]byte
 }
 
-const (
-	PERF_TYPE_HARDWARE   = 0x0
-	PERF_TYPE_SOFTWARE   = 0x1
-	PERF_TYPE_TRACEPOINT = 0x2
-	PERF_TYPE_HW_CACHE   = 0x3
-	PERF_TYPE_RAW        = 0x4
-	PERF_TYPE_BREAKPOINT = 0x5
-
-	PERF_COUNT_HW_CPU_CYCLES              = 0x0
-	PERF_COUNT_HW_INSTRUCTIONS            = 0x1
-	PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
-	PERF_COUNT_HW_CACHE_MISSES            = 0x3
-	PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
-	PERF_COUNT_HW_BRANCH_MISSES           = 0x5
-	PERF_COUNT_HW_BUS_CYCLES              = 0x6
-	PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
-	PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
-	PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
-
-	PERF_COUNT_HW_CACHE_L1D  = 0x0
-	PERF_COUNT_HW_CACHE_L1I  = 0x1
-	PERF_COUNT_HW_CACHE_LL   = 0x2
-	PERF_COUNT_HW_CACHE_DTLB = 0x3
-	PERF_COUNT_HW_CACHE_ITLB = 0x4
-	PERF_COUNT_HW_CACHE_BPU  = 0x5
-	PERF_COUNT_HW_CACHE_NODE = 0x6
-
-	PERF_COUNT_HW_CACHE_OP_READ     = 0x0
-	PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
-	PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
-
-	PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
-	PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
-
-	PERF_COUNT_SW_CPU_CLOCK        = 0x0
-	PERF_COUNT_SW_TASK_CLOCK       = 0x1
-	PERF_COUNT_SW_PAGE_FAULTS      = 0x2
-	PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
-	PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
-	PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
-	PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
-	PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
-	PERF_COUNT_SW_EMULATION_FAULTS = 0x8
-	PERF_COUNT_SW_DUMMY            = 0x9
-	PERF_COUNT_SW_BPF_OUTPUT       = 0xa
-
-	PERF_SAMPLE_IP           = 0x1
-	PERF_SAMPLE_TID          = 0x2
-	PERF_SAMPLE_TIME         = 0x4
-	PERF_SAMPLE_ADDR         = 0x8
-	PERF_SAMPLE_READ         = 0x10
-	PERF_SAMPLE_CALLCHAIN    = 0x20
-	PERF_SAMPLE_ID           = 0x40
-	PERF_SAMPLE_CPU          = 0x80
-	PERF_SAMPLE_PERIOD       = 0x100
-	PERF_SAMPLE_STREAM_ID    = 0x200
-	PERF_SAMPLE_RAW          = 0x400
-	PERF_SAMPLE_BRANCH_STACK = 0x800
-
-	PERF_SAMPLE_BRANCH_USER       = 0x1
-	PERF_SAMPLE_BRANCH_KERNEL     = 0x2
-	PERF_SAMPLE_BRANCH_HV         = 0x4
-	PERF_SAMPLE_BRANCH_ANY        = 0x8
-	PERF_SAMPLE_BRANCH_ANY_CALL   = 0x10
-	PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
-	PERF_SAMPLE_BRANCH_IND_CALL   = 0x40
-	PERF_SAMPLE_BRANCH_ABORT_TX   = 0x80
-	PERF_SAMPLE_BRANCH_IN_TX      = 0x100
-	PERF_SAMPLE_BRANCH_NO_TX      = 0x200
-	PERF_SAMPLE_BRANCH_COND       = 0x400
-	PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
-	PERF_SAMPLE_BRANCH_IND_JUMP   = 0x1000
-	PERF_SAMPLE_BRANCH_CALL       = 0x2000
-	PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
-	PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
-	PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
-
-	PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
-	PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
-	PERF_FORMAT_ID                 = 0x4
-	PERF_FORMAT_GROUP              = 0x8
-
-	PERF_RECORD_MMAP            = 0x1
-	PERF_RECORD_LOST            = 0x2
-	PERF_RECORD_COMM            = 0x3
-	PERF_RECORD_EXIT            = 0x4
-	PERF_RECORD_THROTTLE        = 0x5
-	PERF_RECORD_UNTHROTTLE      = 0x6
-	PERF_RECORD_FORK            = 0x7
-	PERF_RECORD_READ            = 0x8
-	PERF_RECORD_SAMPLE          = 0x9
-	PERF_RECORD_MMAP2           = 0xa
-	PERF_RECORD_AUX             = 0xb
-	PERF_RECORD_ITRACE_START    = 0xc
-	PERF_RECORD_LOST_SAMPLES    = 0xd
-	PERF_RECORD_SWITCH          = 0xe
-	PERF_RECORD_SWITCH_CPU_WIDE = 0xf
-	PERF_RECORD_NAMESPACES      = 0x10
-
-	PERF_CONTEXT_HV     = -0x20
-	PERF_CONTEXT_KERNEL = -0x80
-	PERF_CONTEXT_USER   = -0x200
-
-	PERF_CONTEXT_GUEST        = -0x800
-	PERF_CONTEXT_GUEST_KERNEL = -0x880
-	PERF_CONTEXT_GUEST_USER   = -0xa00
-
-	PERF_FLAG_FD_NO_GROUP = 0x1
-	PERF_FLAG_FD_OUTPUT   = 0x2
-	PERF_FLAG_PID_CGROUP  = 0x4
-	PERF_FLAG_FD_CLOEXEC  = 0x8
-
-	PERF_EVENT_IOC_DISABLE               = 0x2401
-	PERF_EVENT_IOC_ENABLE                = 0x2400
-	PERF_EVENT_IOC_ID                    = 0x80082407
-	PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
-	PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
-	PERF_EVENT_IOC_PERIOD                = 0x40082404
-	PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
-	PERF_EVENT_IOC_REFRESH               = 0x2402
-	PERF_EVENT_IOC_RESET                 = 0x2403
-	PERF_EVENT_IOC_SET_BPF               = 0x40042408
-	PERF_EVENT_IOC_SET_FILTER            = 0x40082406
-	PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
-)
-
 type perfEventAttr struct {
 	Type               uint32
 	Size               uint32
@@ -408,10 +408,11 @@ type perfEventAttr struct {
 	Clockid            int32
 	Sample_regs_intr   uint64
 	Aux_watermark      uint32
-	_                  uint32
+	Sample_max_stack   uint16
+	_                  uint16
 }
 
 type fOwnerEx struct {
 	Type int32
-	Pid int32
+	Pid  int32
 }
diff --git a/src/runtime/defs_linux_arm.go b/src/runtime/defs_linux_arm.go
index ec0b1e9935..e6e3327cf0 100644
--- a/src/runtime/defs_linux_arm.go
+++ b/src/runtime/defs_linux_arm.go
@@ -90,6 +90,132 @@ const (
 	_SOCK_DGRAM = 0x2
 )
 
+const (
+	_PERF_TYPE_HARDWARE   = 0x0
+	_PERF_TYPE_SOFTWARE   = 0x1
+	_PERF_TYPE_TRACEPOINT = 0x2
+	_PERF_TYPE_HW_CACHE   = 0x3
+	_PERF_TYPE_RAW        = 0x4
+	_PERF_TYPE_BREAKPOINT = 0x5
+         
+	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
+	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
+	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
+	_PERF_COUNT_HW_CACHE_MISSES            = 0x3
+	_PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	_PERF_COUNT_HW_BRANCH_MISSES           = 0x5
+	_PERF_COUNT_HW_BUS_CYCLES              = 0x6
+	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
+         
+	_PERF_COUNT_HW_CACHE_L1D  = 0x0
+	_PERF_COUNT_HW_CACHE_L1I  = 0x1
+	_PERF_COUNT_HW_CACHE_LL   = 0x2
+	_PERF_COUNT_HW_CACHE_DTLB = 0x3
+	_PERF_COUNT_HW_CACHE_ITLB = 0x4
+	_PERF_COUNT_HW_CACHE_BPU  = 0x5
+	_PERF_COUNT_HW_CACHE_NODE = 0x6
+         
+	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
+	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
+	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
+         
+	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
+	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
+         
+	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
+	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
+	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
+	_PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
+	_PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
+	_PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
+	_PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
+	_PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
+	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
+	_PERF_COUNT_SW_DUMMY            = 0x9
+	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
+         
+	_PERF_SAMPLE_IP           = 0x1
+	_PERF_SAMPLE_TID          = 0x2
+	_PERF_SAMPLE_TIME         = 0x4
+	_PERF_SAMPLE_ADDR         = 0x8
+	_PERF_SAMPLE_READ         = 0x10
+	_PERF_SAMPLE_CALLCHAIN    = 0x20
+	_PERF_SAMPLE_ID           = 0x40
+	_PERF_SAMPLE_CPU          = 0x80
+	_PERF_SAMPLE_PERIOD       = 0x100
+	_PERF_SAMPLE_STREAM_ID    = 0x200
+	_PERF_SAMPLE_RAW          = 0x400
+	_PERF_SAMPLE_BRANCH_STACK = 0x800
+         
+	_PERF_SAMPLE_BRANCH_USER       = 0x1
+	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
+	_PERF_SAMPLE_BRANCH_HV         = 0x4
+	_PERF_SAMPLE_BRANCH_ANY        = 0x8
+	_PERF_SAMPLE_BRANCH_ANY_CALL   = 0x10
+	_PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
+	_PERF_SAMPLE_BRANCH_IND_CALL   = 0x40
+	_PERF_SAMPLE_BRANCH_ABORT_TX   = 0x80
+	_PERF_SAMPLE_BRANCH_IN_TX      = 0x100
+	_PERF_SAMPLE_BRANCH_NO_TX      = 0x200
+	_PERF_SAMPLE_BRANCH_COND       = 0x400
+	_PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
+	_PERF_SAMPLE_BRANCH_IND_JUMP   = 0x1000
+	_PERF_SAMPLE_BRANCH_CALL       = 0x2000
+	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
+	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
+	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
+         
+	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
+	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
+	_PERF_FORMAT_ID                 = 0x4
+	_PERF_FORMAT_GROUP              = 0x8
+         
+	_PERF_RECORD_MMAP            = 0x1
+	_PERF_RECORD_LOST            = 0x2
+	_PERF_RECORD_COMM            = 0x3
+	_PERF_RECORD_EXIT            = 0x4
+	_PERF_RECORD_THROTTLE        = 0x5
+	_PERF_RECORD_UNTHROTTLE      = 0x6
+	_PERF_RECORD_FORK            = 0x7
+	_PERF_RECORD_READ            = 0x8
+	_PERF_RECORD_SAMPLE          = 0x9
+	_PERF_RECORD_MMAP2           = 0xa
+	_PERF_RECORD_AUX             = 0xb
+	_PERF_RECORD_ITRACE_START    = 0xc
+	_PERF_RECORD_LOST_SAMPLES    = 0xd
+	_PERF_RECORD_SWITCH          = 0xe
+	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
+	_PERF_RECORD_NAMESPACES      = 0x10
+         
+	_PERF_CONTEXT_HV     = -0x20
+	_PERF_CONTEXT_KERNEL = -0x80
+	_PERF_CONTEXT_USER   = -0x200
+         
+	_PERF_CONTEXT_GUEST        = -0x800
+	_PERF_CONTEXT_GUEST_KERNEL = -0x880
+	_PERF_CONTEXT_GUEST_USER   = -0xa00
+         
+	_PERF_FLAG_FD_NO_GROUP = 0x1
+	_PERF_FLAG_FD_OUTPUT   = 0x2
+	_PERF_FLAG_PID_CGROUP  = 0x4
+	_PERF_FLAG_FD_CLOEXEC  = 0x8
+         
+	_PERF_EVENT_IOC_DISABLE               = 0x2401
+	_PERF_EVENT_IOC_ENABLE                = 0x2400
+	_PERF_EVENT_IOC_ID                    = 0x80042407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4004240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
+	_PERF_EVENT_IOC_PERIOD                = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF             = 0xc004240a
+	_PERF_EVENT_IOC_REFRESH               = 0x2402
+	_PERF_EVENT_IOC_RESET                 = 0x2403
+	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER            = 0x40042406
+	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+)
+
 type timespec struct {
 	tv_sec  int32
 	tv_nsec int32
@@ -160,6 +286,9 @@ type siginfo struct {
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
 	si_addr uint32
+	// psu: an unreliable workaround and need to figure out a better solution
+	// psu: only tested on amd64
+	si_fd    int32
 }
 
 type sigactiont struct {
@@ -179,3 +308,31 @@ type sockaddr_un struct {
 	family uint16
 	path   [108]byte
 }
+
+type perfEventAttr struct {
+	Type               uint32
+	Size               uint32
+	Config             uint64
+	Sample             uint64
+	Sample_type        uint64
+	Read_format        uint64
+	Bits               uint64
+	Wakeup             uint32
+	Bp_type            uint32
+	Ext1               uint64
+	Ext2               uint64
+	Branch_sample_type uint64
+	Sample_regs_user   uint64
+	Sample_stack_user  uint32
+	Clockid            int32
+	Sample_regs_intr   uint64
+	Aux_watermark      uint32
+	Sample_max_stack   uint16
+	_                  uint16
+}
+
+// psu: only tested on amd64 
+type fOwnerEx struct {
+	Type int32
+	Pid  int32
+}
diff --git a/src/runtime/defs_linux_arm64.go b/src/runtime/defs_linux_arm64.go
index b325a229a1..a39d5b6699 100644
--- a/src/runtime/defs_linux_arm64.go
+++ b/src/runtime/defs_linux_arm64.go
@@ -94,6 +94,132 @@ const (
 	_SOCK_DGRAM = 0x2
 )
 
+const (
+	_PERF_TYPE_HARDWARE   = 0x0
+	_PERF_TYPE_SOFTWARE   = 0x1
+	_PERF_TYPE_TRACEPOINT = 0x2
+	_PERF_TYPE_HW_CACHE   = 0x3
+	_PERF_TYPE_RAW        = 0x4
+	_PERF_TYPE_BREAKPOINT = 0x5
+         
+	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
+	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
+	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
+	_PERF_COUNT_HW_CACHE_MISSES            = 0x3
+	_PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	_PERF_COUNT_HW_BRANCH_MISSES           = 0x5
+	_PERF_COUNT_HW_BUS_CYCLES              = 0x6
+	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
+         
+	_PERF_COUNT_HW_CACHE_L1D  = 0x0
+	_PERF_COUNT_HW_CACHE_L1I  = 0x1
+	_PERF_COUNT_HW_CACHE_LL   = 0x2
+	_PERF_COUNT_HW_CACHE_DTLB = 0x3
+	_PERF_COUNT_HW_CACHE_ITLB = 0x4
+	_PERF_COUNT_HW_CACHE_BPU  = 0x5
+	_PERF_COUNT_HW_CACHE_NODE = 0x6
+         
+	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
+	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
+	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
+         
+	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
+	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
+         
+	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
+	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
+	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
+	_PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
+	_PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
+	_PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
+	_PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
+	_PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
+	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
+	_PERF_COUNT_SW_DUMMY            = 0x9
+	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
+         
+	_PERF_SAMPLE_IP           = 0x1
+	_PERF_SAMPLE_TID          = 0x2
+	_PERF_SAMPLE_TIME         = 0x4
+	_PERF_SAMPLE_ADDR         = 0x8
+	_PERF_SAMPLE_READ         = 0x10
+	_PERF_SAMPLE_CALLCHAIN    = 0x20
+	_PERF_SAMPLE_ID           = 0x40
+	_PERF_SAMPLE_CPU          = 0x80
+	_PERF_SAMPLE_PERIOD       = 0x100
+	_PERF_SAMPLE_STREAM_ID    = 0x200
+	_PERF_SAMPLE_RAW          = 0x400
+	_PERF_SAMPLE_BRANCH_STACK = 0x800
+         
+	_PERF_SAMPLE_BRANCH_USER       = 0x1
+	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
+	_PERF_SAMPLE_BRANCH_HV         = 0x4
+	_PERF_SAMPLE_BRANCH_ANY        = 0x8
+	_PERF_SAMPLE_BRANCH_ANY_CALL   = 0x10
+	_PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
+	_PERF_SAMPLE_BRANCH_IND_CALL   = 0x40
+	_PERF_SAMPLE_BRANCH_ABORT_TX   = 0x80
+	_PERF_SAMPLE_BRANCH_IN_TX      = 0x100
+	_PERF_SAMPLE_BRANCH_NO_TX      = 0x200
+	_PERF_SAMPLE_BRANCH_COND       = 0x400
+	_PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
+	_PERF_SAMPLE_BRANCH_IND_JUMP   = 0x1000
+	_PERF_SAMPLE_BRANCH_CALL       = 0x2000
+	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
+	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
+	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
+         
+	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
+	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
+	_PERF_FORMAT_ID                 = 0x4
+	_PERF_FORMAT_GROUP              = 0x8
+         
+	_PERF_RECORD_MMAP            = 0x1
+	_PERF_RECORD_LOST            = 0x2
+	_PERF_RECORD_COMM            = 0x3
+	_PERF_RECORD_EXIT            = 0x4
+	_PERF_RECORD_THROTTLE        = 0x5
+	_PERF_RECORD_UNTHROTTLE      = 0x6
+	_PERF_RECORD_FORK            = 0x7
+	_PERF_RECORD_READ            = 0x8
+	_PERF_RECORD_SAMPLE          = 0x9
+	_PERF_RECORD_MMAP2           = 0xa
+	_PERF_RECORD_AUX             = 0xb
+	_PERF_RECORD_ITRACE_START    = 0xc
+	_PERF_RECORD_LOST_SAMPLES    = 0xd
+	_PERF_RECORD_SWITCH          = 0xe
+	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
+	_PERF_RECORD_NAMESPACES      = 0x10
+         
+	_PERF_CONTEXT_HV     = -0x20
+	_PERF_CONTEXT_KERNEL = -0x80
+	_PERF_CONTEXT_USER   = -0x200
+         
+	_PERF_CONTEXT_GUEST        = -0x800
+	_PERF_CONTEXT_GUEST_KERNEL = -0x880
+	_PERF_CONTEXT_GUEST_USER   = -0xa00
+         
+	_PERF_FLAG_FD_NO_GROUP = 0x1
+	_PERF_FLAG_FD_OUTPUT   = 0x2
+	_PERF_FLAG_PID_CGROUP  = 0x4
+	_PERF_FLAG_FD_CLOEXEC  = 0x8
+         
+	_PERF_EVENT_IOC_DISABLE               = 0x2401
+	_PERF_EVENT_IOC_ENABLE                = 0x2400
+	_PERF_EVENT_IOC_ID                    = 0x80082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
+	_PERF_EVENT_IOC_PERIOD                = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH               = 0x2402
+	_PERF_EVENT_IOC_RESET                 = 0x2403
+	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER            = 0x40082406
+	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+)
+
 type timespec struct {
 	tv_sec  int64
 	tv_nsec int64
@@ -127,6 +253,9 @@ type siginfo struct {
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
 	si_addr uint64
+	// psu: an unreliable workaround and need to figure out a better solution
+	// psu: only tested on amd64
+	si_fd    int32
 }
 
 type itimerval struct {
@@ -184,3 +313,31 @@ type ucontext struct {
 	_pad2       [8]byte // sigcontext must be aligned to 16-byte
 	uc_mcontext sigcontext
 }
+
+type perfEventAttr struct {
+	Type               uint32
+	Size               uint32
+	Config             uint64
+	Sample             uint64
+	Sample_type        uint64
+	Read_format        uint64
+	Bits               uint64
+	Wakeup             uint32
+	Bp_type            uint32
+	Ext1               uint64
+	Ext2               uint64
+	Branch_sample_type uint64
+	Sample_regs_user   uint64
+	Sample_stack_user  uint32
+	Clockid            int32
+	Sample_regs_intr   uint64
+	Aux_watermark      uint32
+	Sample_max_stack   uint16
+	_                  uint16
+}
+
+// psu: only test it on amd64 
+type fOwnerEx struct {
+	Type int32
+	Pid  int32
+}
diff --git a/src/runtime/defs_linux_mips64x.go b/src/runtime/defs_linux_mips64x.go
index a52d0d40cf..d2b21cd997 100644
--- a/src/runtime/defs_linux_mips64x.go
+++ b/src/runtime/defs_linux_mips64x.go
@@ -89,6 +89,132 @@ const (
 	_EPOLL_CTL_MOD = 0x3
 )
 
+const (
+	_PERF_TYPE_HARDWARE   = 0x0
+	_PERF_TYPE_SOFTWARE   = 0x1
+	_PERF_TYPE_TRACEPOINT = 0x2
+	_PERF_TYPE_HW_CACHE   = 0x3
+	_PERF_TYPE_RAW        = 0x4
+	_PERF_TYPE_BREAKPOINT = 0x5
+         
+	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
+	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
+	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
+	_PERF_COUNT_HW_CACHE_MISSES            = 0x3
+	_PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	_PERF_COUNT_HW_BRANCH_MISSES           = 0x5
+	_PERF_COUNT_HW_BUS_CYCLES              = 0x6
+	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
+         
+	_PERF_COUNT_HW_CACHE_L1D  = 0x0
+	_PERF_COUNT_HW_CACHE_L1I  = 0x1
+	_PERF_COUNT_HW_CACHE_LL   = 0x2
+	_PERF_COUNT_HW_CACHE_DTLB = 0x3
+	_PERF_COUNT_HW_CACHE_ITLB = 0x4
+	_PERF_COUNT_HW_CACHE_BPU  = 0x5
+	_PERF_COUNT_HW_CACHE_NODE = 0x6
+         
+	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
+	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
+	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
+         
+	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
+	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
+         
+	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
+	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
+	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
+	_PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
+	_PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
+	_PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
+	_PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
+	_PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
+	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
+	_PERF_COUNT_SW_DUMMY            = 0x9
+	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
+         
+	_PERF_SAMPLE_IP           = 0x1
+	_PERF_SAMPLE_TID          = 0x2
+	_PERF_SAMPLE_TIME         = 0x4
+	_PERF_SAMPLE_ADDR         = 0x8
+	_PERF_SAMPLE_READ         = 0x10
+	_PERF_SAMPLE_CALLCHAIN    = 0x20
+	_PERF_SAMPLE_ID           = 0x40
+	_PERF_SAMPLE_CPU          = 0x80
+	_PERF_SAMPLE_PERIOD       = 0x100
+	_PERF_SAMPLE_STREAM_ID    = 0x200
+	_PERF_SAMPLE_RAW          = 0x400
+	_PERF_SAMPLE_BRANCH_STACK = 0x800
+         
+	_PERF_SAMPLE_BRANCH_USER       = 0x1
+	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
+	_PERF_SAMPLE_BRANCH_HV         = 0x4
+	_PERF_SAMPLE_BRANCH_ANY        = 0x8
+	_PERF_SAMPLE_BRANCH_ANY_CALL   = 0x10
+	_PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
+	_PERF_SAMPLE_BRANCH_IND_CALL   = 0x40
+	_PERF_SAMPLE_BRANCH_ABORT_TX   = 0x80
+	_PERF_SAMPLE_BRANCH_IN_TX      = 0x100
+	_PERF_SAMPLE_BRANCH_NO_TX      = 0x200
+	_PERF_SAMPLE_BRANCH_COND       = 0x400
+	_PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
+	_PERF_SAMPLE_BRANCH_IND_JUMP   = 0x1000
+	_PERF_SAMPLE_BRANCH_CALL       = 0x2000
+	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
+	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
+	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
+         
+	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
+	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
+	_PERF_FORMAT_ID                 = 0x4
+	_PERF_FORMAT_GROUP              = 0x8
+         
+	_PERF_RECORD_MMAP            = 0x1
+	_PERF_RECORD_LOST            = 0x2
+	_PERF_RECORD_COMM            = 0x3
+	_PERF_RECORD_EXIT            = 0x4
+	_PERF_RECORD_THROTTLE        = 0x5
+	_PERF_RECORD_UNTHROTTLE      = 0x6
+	_PERF_RECORD_FORK            = 0x7
+	_PERF_RECORD_READ            = 0x8
+	_PERF_RECORD_SAMPLE          = 0x9
+	_PERF_RECORD_MMAP2           = 0xa
+	_PERF_RECORD_AUX             = 0xb
+	_PERF_RECORD_ITRACE_START    = 0xc
+	_PERF_RECORD_LOST_SAMPLES    = 0xd
+	_PERF_RECORD_SWITCH          = 0xe
+	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
+	_PERF_RECORD_NAMESPACES      = 0x10
+         
+	_PERF_CONTEXT_HV     = -0x20
+	_PERF_CONTEXT_KERNEL = -0x80
+	_PERF_CONTEXT_USER   = -0x200
+         
+	_PERF_CONTEXT_GUEST        = -0x800
+	_PERF_CONTEXT_GUEST_KERNEL = -0x880
+	_PERF_CONTEXT_GUEST_USER   = -0xa00
+         
+	_PERF_FLAG_FD_NO_GROUP = 0x1
+	_PERF_FLAG_FD_OUTPUT   = 0x2
+	_PERF_FLAG_PID_CGROUP  = 0x4
+	_PERF_FLAG_FD_CLOEXEC  = 0x8
+         
+	_PERF_EVENT_IOC_DISABLE               = 0x20002401
+	_PERF_EVENT_IOC_ENABLE                = 0x20002400
+	_PERF_EVENT_IOC_ID                    = 0x40082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x8008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x80042409
+	_PERF_EVENT_IOC_PERIOD                = 0x80082404
+	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH               = 0x20002402
+	_PERF_EVENT_IOC_RESET                 = 0x20002403
+	_PERF_EVENT_IOC_SET_BPF               = 0x80042408
+	_PERF_EVENT_IOC_SET_FILTER            = 0x80082406
+	_PERF_EVENT_IOC_SET_OUTPUT            = 0x20002405
+)
+
 //struct Sigset {
 //	uint64	sig[1];
 //};
@@ -130,6 +256,9 @@ type siginfo struct {
 	__pad0   [1]int32
 	// below here is a union; si_addr is the only field we use
 	si_addr uint64
+	// psu: an unreliable workaround and need to figure out a better solution
+	// psu: only tested on amd64
+	si_fd    int32
 }
 
 type itimerval struct {
@@ -180,3 +309,32 @@ type ucontext struct {
 	uc_mcontext sigcontext
 	uc_sigmask  uint64
 }
+
+type perfEventAttr struct {
+	Type               uint32
+	Size               uint32
+	Config             uint64
+	Sample             uint64
+	Sample_type        uint64
+	Read_format        uint64
+	Bits               uint64
+	Wakeup             uint32
+	Bp_type            uint32
+	Ext1               uint64
+	Ext2               uint64
+	Branch_sample_type uint64
+	Sample_regs_user   uint64
+	Sample_stack_user  uint32
+	Clockid            int32
+	Sample_regs_intr   uint64
+	Aux_watermark      uint32
+	Sample_max_stack   uint16
+	_                  uint16
+}
+
+// psu: only test it on amd64 
+type fOwnerEx struct {
+	Type int32
+	Pid  int32
+}
+
diff --git a/src/runtime/defs_linux_mipsx.go b/src/runtime/defs_linux_mipsx.go
index f3a1dd0cf0..2bffac0c9a 100644
--- a/src/runtime/defs_linux_mipsx.go
+++ b/src/runtime/defs_linux_mipsx.go
@@ -93,6 +93,132 @@ const (
 	_EPOLL_CTL_MOD = 0x3
 )
 
+const (
+	_PERF_TYPE_HARDWARE   = 0x0
+	_PERF_TYPE_SOFTWARE   = 0x1
+	_PERF_TYPE_TRACEPOINT = 0x2
+	_PERF_TYPE_HW_CACHE   = 0x3
+	_PERF_TYPE_RAW        = 0x4
+	_PERF_TYPE_BREAKPOINT = 0x5
+         
+	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
+	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
+	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
+	_PERF_COUNT_HW_CACHE_MISSES            = 0x3
+	_PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	_PERF_COUNT_HW_BRANCH_MISSES           = 0x5
+	_PERF_COUNT_HW_BUS_CYCLES              = 0x6
+	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
+         
+	_PERF_COUNT_HW_CACHE_L1D  = 0x0
+	_PERF_COUNT_HW_CACHE_L1I  = 0x1
+	_PERF_COUNT_HW_CACHE_LL   = 0x2
+	_PERF_COUNT_HW_CACHE_DTLB = 0x3
+	_PERF_COUNT_HW_CACHE_ITLB = 0x4
+	_PERF_COUNT_HW_CACHE_BPU  = 0x5
+	_PERF_COUNT_HW_CACHE_NODE = 0x6
+         
+	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
+	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
+	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
+         
+	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
+	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
+         
+	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
+	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
+	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
+	_PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
+	_PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
+	_PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
+	_PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
+	_PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
+	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
+	_PERF_COUNT_SW_DUMMY            = 0x9
+	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
+         
+	_PERF_SAMPLE_IP           = 0x1
+	_PERF_SAMPLE_TID          = 0x2
+	_PERF_SAMPLE_TIME         = 0x4
+	_PERF_SAMPLE_ADDR         = 0x8
+	_PERF_SAMPLE_READ         = 0x10
+	_PERF_SAMPLE_CALLCHAIN    = 0x20
+	_PERF_SAMPLE_ID           = 0x40
+	_PERF_SAMPLE_CPU          = 0x80
+	_PERF_SAMPLE_PERIOD       = 0x100
+	_PERF_SAMPLE_STREAM_ID    = 0x200
+	_PERF_SAMPLE_RAW          = 0x400
+	_PERF_SAMPLE_BRANCH_STACK = 0x800
+         
+	_PERF_SAMPLE_BRANCH_USER       = 0x1
+	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
+	_PERF_SAMPLE_BRANCH_HV         = 0x4
+	_PERF_SAMPLE_BRANCH_ANY        = 0x8
+	_PERF_SAMPLE_BRANCH_ANY_CALL   = 0x10
+	_PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
+	_PERF_SAMPLE_BRANCH_IND_CALL   = 0x40
+	_PERF_SAMPLE_BRANCH_ABORT_TX   = 0x80
+	_PERF_SAMPLE_BRANCH_IN_TX      = 0x100
+	_PERF_SAMPLE_BRANCH_NO_TX      = 0x200
+	_PERF_SAMPLE_BRANCH_COND       = 0x400
+	_PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
+	_PERF_SAMPLE_BRANCH_IND_JUMP   = 0x1000
+	_PERF_SAMPLE_BRANCH_CALL       = 0x2000
+	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
+	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
+	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
+         
+	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
+	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
+	_PERF_FORMAT_ID                 = 0x4
+	_PERF_FORMAT_GROUP              = 0x8
+         
+	_PERF_RECORD_MMAP            = 0x1
+	_PERF_RECORD_LOST            = 0x2
+	_PERF_RECORD_COMM            = 0x3
+	_PERF_RECORD_EXIT            = 0x4
+	_PERF_RECORD_THROTTLE        = 0x5
+	_PERF_RECORD_UNTHROTTLE      = 0x6
+	_PERF_RECORD_FORK            = 0x7
+	_PERF_RECORD_READ            = 0x8
+	_PERF_RECORD_SAMPLE          = 0x9
+	_PERF_RECORD_MMAP2           = 0xa
+	_PERF_RECORD_AUX             = 0xb
+	_PERF_RECORD_ITRACE_START    = 0xc
+	_PERF_RECORD_LOST_SAMPLES    = 0xd
+	_PERF_RECORD_SWITCH          = 0xe
+	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
+	_PERF_RECORD_NAMESPACES      = 0x10
+         
+	_PERF_CONTEXT_HV     = -0x20
+	_PERF_CONTEXT_KERNEL = -0x80
+	_PERF_CONTEXT_USER   = -0x200
+         
+	_PERF_CONTEXT_GUEST        = -0x800
+	_PERF_CONTEXT_GUEST_KERNEL = -0x880
+	_PERF_CONTEXT_GUEST_USER   = -0xa00
+         
+	_PERF_FLAG_FD_NO_GROUP = 0x1
+	_PERF_FLAG_FD_OUTPUT   = 0x2
+	_PERF_FLAG_PID_CGROUP  = 0x4
+	_PERF_FLAG_FD_CLOEXEC  = 0x8
+         
+	_PERF_EVENT_IOC_DISABLE               = 0x20002401
+	_PERF_EVENT_IOC_ENABLE                = 0x20002400
+	_PERF_EVENT_IOC_ID                    = 0x40042407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x8004240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x80042409
+	_PERF_EVENT_IOC_PERIOD                = 0x80082404
+	_PERF_EVENT_IOC_QUERY_BPF             = 0xc004240a
+	_PERF_EVENT_IOC_REFRESH               = 0x20002402
+	_PERF_EVENT_IOC_RESET                 = 0x20002403
+	_PERF_EVENT_IOC_SET_BPF               = 0x80042408
+	_PERF_EVENT_IOC_SET_FILTER            = 0x80042406
+	_PERF_EVENT_IOC_SET_OUTPUT            = 0x20002405
+)
+
 type timespec struct {
 	tv_sec  int32
 	tv_nsec int32
@@ -128,6 +254,9 @@ type siginfo struct {
 	si_errno int32
 	// below here is a union; si_addr is the only field we use
 	si_addr uint32
+	// psu: an unreliable workaround and need to figure out a better solution
+	// psu: only tested on amd64
+	si_fd    int32
 }
 
 type itimerval struct {
@@ -182,3 +311,31 @@ type ucontext struct {
 	uc_mcontext sigcontext
 	uc_sigmask  [4]uint32
 }
+
+type perfEventAttr struct {
+	Type               uint32
+	Size               uint32
+	Config             uint64
+	Sample             uint64
+	Sample_type        uint64
+	Read_format        uint64
+	Bits               uint64
+	Wakeup             uint32
+	Bp_type            uint32
+	Ext1               uint64
+	Ext2               uint64
+	Branch_sample_type uint64
+	Sample_regs_user   uint64
+	Sample_stack_user  uint32
+	Clockid            int32
+	Sample_regs_intr   uint64
+	Aux_watermark      uint32
+	Sample_max_stack   uint16
+	_                  uint16
+}
+
+// psu: only test it on amd64 
+type fOwnerEx struct {
+	Type int32
+	Pid  int32
+}
diff --git a/src/runtime/defs_linux_ppc64.go b/src/runtime/defs_linux_ppc64.go
index f438993721..15867d6795 100644
--- a/src/runtime/defs_linux_ppc64.go
+++ b/src/runtime/defs_linux_ppc64.go
@@ -89,6 +89,132 @@ const (
 	_EPOLL_CTL_MOD = 0x3
 )
 
+const (
+	_PERF_TYPE_HARDWARE   = 0x0
+	_PERF_TYPE_SOFTWARE   = 0x1
+	_PERF_TYPE_TRACEPOINT = 0x2
+	_PERF_TYPE_HW_CACHE   = 0x3
+	_PERF_TYPE_RAW        = 0x4
+	_PERF_TYPE_BREAKPOINT = 0x5
+         
+	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
+	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
+	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
+	_PERF_COUNT_HW_CACHE_MISSES            = 0x3
+	_PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	_PERF_COUNT_HW_BRANCH_MISSES           = 0x5
+	_PERF_COUNT_HW_BUS_CYCLES              = 0x6
+	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
+         
+	_PERF_COUNT_HW_CACHE_L1D  = 0x0
+	_PERF_COUNT_HW_CACHE_L1I  = 0x1
+	_PERF_COUNT_HW_CACHE_LL   = 0x2
+	_PERF_COUNT_HW_CACHE_DTLB = 0x3
+	_PERF_COUNT_HW_CACHE_ITLB = 0x4
+	_PERF_COUNT_HW_CACHE_BPU  = 0x5
+	_PERF_COUNT_HW_CACHE_NODE = 0x6
+         
+	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
+	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
+	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
+         
+	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
+	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
+         
+	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
+	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
+	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
+	_PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
+	_PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
+	_PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
+	_PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
+	_PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
+	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
+	_PERF_COUNT_SW_DUMMY            = 0x9
+	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
+         
+	_PERF_SAMPLE_IP           = 0x1
+	_PERF_SAMPLE_TID          = 0x2
+	_PERF_SAMPLE_TIME         = 0x4
+	_PERF_SAMPLE_ADDR         = 0x8
+	_PERF_SAMPLE_READ         = 0x10
+	_PERF_SAMPLE_CALLCHAIN    = 0x20
+	_PERF_SAMPLE_ID           = 0x40
+	_PERF_SAMPLE_CPU          = 0x80
+	_PERF_SAMPLE_PERIOD       = 0x100
+	_PERF_SAMPLE_STREAM_ID    = 0x200
+	_PERF_SAMPLE_RAW          = 0x400
+	_PERF_SAMPLE_BRANCH_STACK = 0x800
+         
+	_PERF_SAMPLE_BRANCH_USER       = 0x1
+	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
+	_PERF_SAMPLE_BRANCH_HV         = 0x4
+	_PERF_SAMPLE_BRANCH_ANY        = 0x8
+	_PERF_SAMPLE_BRANCH_ANY_CALL   = 0x10
+	_PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
+	_PERF_SAMPLE_BRANCH_IND_CALL   = 0x40
+	_PERF_SAMPLE_BRANCH_ABORT_TX   = 0x80
+	_PERF_SAMPLE_BRANCH_IN_TX      = 0x100
+	_PERF_SAMPLE_BRANCH_NO_TX      = 0x200
+	_PERF_SAMPLE_BRANCH_COND       = 0x400
+	_PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
+	_PERF_SAMPLE_BRANCH_IND_JUMP   = 0x1000
+	_PERF_SAMPLE_BRANCH_CALL       = 0x2000
+	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
+	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
+	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
+         
+	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
+	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
+	_PERF_FORMAT_ID                 = 0x4
+	_PERF_FORMAT_GROUP              = 0x8
+         
+	_PERF_RECORD_MMAP            = 0x1
+	_PERF_RECORD_LOST            = 0x2
+	_PERF_RECORD_COMM            = 0x3
+	_PERF_RECORD_EXIT            = 0x4
+	_PERF_RECORD_THROTTLE        = 0x5
+	_PERF_RECORD_UNTHROTTLE      = 0x6
+	_PERF_RECORD_FORK            = 0x7
+	_PERF_RECORD_READ            = 0x8
+	_PERF_RECORD_SAMPLE          = 0x9
+	_PERF_RECORD_MMAP2           = 0xa
+	_PERF_RECORD_AUX             = 0xb
+	_PERF_RECORD_ITRACE_START    = 0xc
+	_PERF_RECORD_LOST_SAMPLES    = 0xd
+	_PERF_RECORD_SWITCH          = 0xe
+	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
+	_PERF_RECORD_NAMESPACES      = 0x10
+         
+	_PERF_CONTEXT_HV     = -0x20
+	_PERF_CONTEXT_KERNEL = -0x80
+	_PERF_CONTEXT_USER   = -0x200
+         
+	_PERF_CONTEXT_GUEST        = -0x800
+	_PERF_CONTEXT_GUEST_KERNEL = -0x880
+	_PERF_CONTEXT_GUEST_USER   = -0xa00
+         
+	_PERF_FLAG_FD_NO_GROUP = 0x1
+	_PERF_FLAG_FD_OUTPUT   = 0x2
+	_PERF_FLAG_PID_CGROUP  = 0x4
+	_PERF_FLAG_FD_CLOEXEC  = 0x8
+         
+	_PERF_EVENT_IOC_DISABLE               = 0x2401
+	_PERF_EVENT_IOC_ENABLE                = 0x2400
+	_PERF_EVENT_IOC_ID                    = 0x80082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
+	_PERF_EVENT_IOC_PERIOD                = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH               = 0x2402
+	_PERF_EVENT_IOC_RESET                 = 0x2403
+	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER            = 0x40082406
+	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+)
+
 //struct Sigset {
 //	uint64	sig[1];
 //};
@@ -127,6 +253,9 @@ type siginfo struct {
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
 	si_addr uint64
+	// psu: an unreliable workaround and need to figure out a better solution
+	// psu: only tested on amd64
+	si_fd    int32
 }
 
 type itimerval struct {
@@ -197,3 +326,31 @@ type ucontext struct {
 	__unused    [15]uint64
 	uc_mcontext sigcontext
 }
+
+type perfEventAttr struct {
+	Type               uint32
+	Size               uint32
+	Config             uint64
+	Sample             uint64
+	Sample_type        uint64
+	Read_format        uint64
+	Bits               uint64
+	Wakeup             uint32
+	Bp_type            uint32
+	Ext1               uint64
+	Ext2               uint64
+	Branch_sample_type uint64
+	Sample_regs_user   uint64
+	Sample_stack_user  uint32
+	Clockid            int32
+	Sample_regs_intr   uint64
+	Aux_watermark      uint32
+	Sample_max_stack   uint16
+	_                  uint16
+}
+
+// psu: only test it on amd64 
+type fOwnerEx struct {
+	Type int32
+	Pid  int32
+}
diff --git a/src/runtime/defs_linux_ppc64le.go b/src/runtime/defs_linux_ppc64le.go
index f438993721..5e51f2398d 100644
--- a/src/runtime/defs_linux_ppc64le.go
+++ b/src/runtime/defs_linux_ppc64le.go
@@ -89,6 +89,132 @@ const (
 	_EPOLL_CTL_MOD = 0x3
 )
 
+const (
+	_PERF_TYPE_HARDWARE   = 0x0
+	_PERF_TYPE_SOFTWARE   = 0x1
+	_PERF_TYPE_TRACEPOINT = 0x2
+	_PERF_TYPE_HW_CACHE   = 0x3
+	_PERF_TYPE_RAW        = 0x4
+	_PERF_TYPE_BREAKPOINT = 0x5
+         
+	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
+	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
+	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
+	_PERF_COUNT_HW_CACHE_MISSES            = 0x3
+	_PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	_PERF_COUNT_HW_BRANCH_MISSES           = 0x5
+	_PERF_COUNT_HW_BUS_CYCLES              = 0x6
+	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
+         
+	_PERF_COUNT_HW_CACHE_L1D  = 0x0
+	_PERF_COUNT_HW_CACHE_L1I  = 0x1
+	_PERF_COUNT_HW_CACHE_LL   = 0x2
+	_PERF_COUNT_HW_CACHE_DTLB = 0x3
+	_PERF_COUNT_HW_CACHE_ITLB = 0x4
+	_PERF_COUNT_HW_CACHE_BPU  = 0x5
+	_PERF_COUNT_HW_CACHE_NODE = 0x6
+         
+	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
+	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
+	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
+         
+	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
+	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
+         
+	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
+	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
+	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
+	_PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
+	_PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
+	_PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
+	_PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
+	_PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
+	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
+	_PERF_COUNT_SW_DUMMY            = 0x9
+	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
+         
+	_PERF_SAMPLE_IP           = 0x1
+	_PERF_SAMPLE_TID          = 0x2
+	_PERF_SAMPLE_TIME         = 0x4
+	_PERF_SAMPLE_ADDR         = 0x8
+	_PERF_SAMPLE_READ         = 0x10
+	_PERF_SAMPLE_CALLCHAIN    = 0x20
+	_PERF_SAMPLE_ID           = 0x40
+	_PERF_SAMPLE_CPU          = 0x80
+	_PERF_SAMPLE_PERIOD       = 0x100
+	_PERF_SAMPLE_STREAM_ID    = 0x200
+	_PERF_SAMPLE_RAW          = 0x400
+	_PERF_SAMPLE_BRANCH_STACK = 0x800
+         
+	_PERF_SAMPLE_BRANCH_USER       = 0x1
+	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
+	_PERF_SAMPLE_BRANCH_HV         = 0x4
+	_PERF_SAMPLE_BRANCH_ANY        = 0x8
+	_PERF_SAMPLE_BRANCH_ANY_CALL   = 0x10
+	_PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
+	_PERF_SAMPLE_BRANCH_IND_CALL   = 0x40
+	_PERF_SAMPLE_BRANCH_ABORT_TX   = 0x80
+	_PERF_SAMPLE_BRANCH_IN_TX      = 0x100
+	_PERF_SAMPLE_BRANCH_NO_TX      = 0x200
+	_PERF_SAMPLE_BRANCH_COND       = 0x400
+	_PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
+	_PERF_SAMPLE_BRANCH_IND_JUMP   = 0x1000
+	_PERF_SAMPLE_BRANCH_CALL       = 0x2000
+	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
+	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
+	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
+         
+	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
+	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
+	_PERF_FORMAT_ID                 = 0x4
+	_PERF_FORMAT_GROUP              = 0x8
+         
+	_PERF_RECORD_MMAP            = 0x1
+	_PERF_RECORD_LOST            = 0x2
+	_PERF_RECORD_COMM            = 0x3
+	_PERF_RECORD_EXIT            = 0x4
+	_PERF_RECORD_THROTTLE        = 0x5
+	_PERF_RECORD_UNTHROTTLE      = 0x6
+	_PERF_RECORD_FORK            = 0x7
+	_PERF_RECORD_READ            = 0x8
+	_PERF_RECORD_SAMPLE          = 0x9
+	_PERF_RECORD_MMAP2           = 0xa
+	_PERF_RECORD_AUX             = 0xb
+	_PERF_RECORD_ITRACE_START    = 0xc
+	_PERF_RECORD_LOST_SAMPLES    = 0xd
+	_PERF_RECORD_SWITCH          = 0xe
+	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
+	_PERF_RECORD_NAMESPACES      = 0x10
+         
+	_PERF_CONTEXT_HV     = -0x20
+	_PERF_CONTEXT_KERNEL = -0x80
+	_PERF_CONTEXT_USER   = -0x200
+         
+	_PERF_CONTEXT_GUEST        = -0x800
+	_PERF_CONTEXT_GUEST_KERNEL = -0x880
+	_PERF_CONTEXT_GUEST_USER   = -0xa00
+         
+	_PERF_FLAG_FD_NO_GROUP = 0x1
+	_PERF_FLAG_FD_OUTPUT   = 0x2
+	_PERF_FLAG_PID_CGROUP  = 0x4
+	_PERF_FLAG_FD_CLOEXEC  = 0x8
+	 
+	_PERF_EVENT_IOC_DISABLE               = 0x20002401
+	_PERF_EVENT_IOC_ENABLE                = 0x20002400
+	_PERF_EVENT_IOC_ID                    = 0x40082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x8008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x80042409
+	_PERF_EVENT_IOC_PERIOD                = 0x80082404
+	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH               = 0x20002402
+	_PERF_EVENT_IOC_RESET                 = 0x20002403
+	_PERF_EVENT_IOC_SET_BPF               = 0x80042408
+	_PERF_EVENT_IOC_SET_FILTER            = 0x80082406
+	_PERF_EVENT_IOC_SET_OUTPUT            = 0x20002405
+)
+
 //struct Sigset {
 //	uint64	sig[1];
 //};
@@ -127,6 +253,9 @@ type siginfo struct {
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
 	si_addr uint64
+	// psu: an unreliable workaround and need to figure out a better solution
+	// psu: only tested on amd64
+	si_fd    int32
 }
 
 type itimerval struct {
@@ -197,3 +326,31 @@ type ucontext struct {
 	__unused    [15]uint64
 	uc_mcontext sigcontext
 }
+
+type perfEventAttr struct {
+	Type               uint32
+	Size               uint32
+	Config             uint64
+	Sample             uint64
+	Sample_type        uint64
+	Read_format        uint64
+	Bits               uint64
+	Wakeup             uint32
+	Bp_type            uint32
+	Ext1               uint64
+	Ext2               uint64
+	Branch_sample_type uint64
+	Sample_regs_user   uint64
+	Sample_stack_user  uint32
+	Clockid            int32
+	Sample_regs_intr   uint64
+	Aux_watermark      uint32
+	Sample_max_stack   uint16
+	_                  uint16
+}
+
+// psu: only test it on amd64 
+type fOwnerEx struct {
+	Type int32
+	Pid  int32
+}
diff --git a/src/runtime/defs_linux_s390x.go b/src/runtime/defs_linux_s390x.go
index 19b99b5bdf..0f3b134341 100644
--- a/src/runtime/defs_linux_s390x.go
+++ b/src/runtime/defs_linux_s390x.go
@@ -90,6 +90,132 @@ const (
 	_EPOLL_CTL_MOD = 0x3
 )
 
+const (
+	_PERF_TYPE_HARDWARE   = 0x0
+	_PERF_TYPE_SOFTWARE   = 0x1
+	_PERF_TYPE_TRACEPOINT = 0x2
+	_PERF_TYPE_HW_CACHE   = 0x3
+	_PERF_TYPE_RAW        = 0x4
+	_PERF_TYPE_BREAKPOINT = 0x5
+         
+	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
+	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
+	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
+	_PERF_COUNT_HW_CACHE_MISSES            = 0x3
+	_PERF_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
+	_PERF_COUNT_HW_BRANCH_MISSES           = 0x5
+	_PERF_COUNT_HW_BUS_CYCLES              = 0x6
+	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
+	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
+	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
+         
+	_PERF_COUNT_HW_CACHE_L1D  = 0x0
+	_PERF_COUNT_HW_CACHE_L1I  = 0x1
+	_PERF_COUNT_HW_CACHE_LL   = 0x2
+	_PERF_COUNT_HW_CACHE_DTLB = 0x3
+	_PERF_COUNT_HW_CACHE_ITLB = 0x4
+	_PERF_COUNT_HW_CACHE_BPU  = 0x5
+	_PERF_COUNT_HW_CACHE_NODE = 0x6
+         
+	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
+	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
+	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
+         
+	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
+	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
+         
+	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
+	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
+	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
+	_PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
+	_PERF_COUNT_SW_CPU_MIGRATIONS   = 0x4
+	_PERF_COUNT_SW_PAGE_FAULTS_MIN  = 0x5
+	_PERF_COUNT_SW_PAGE_FAULTS_MAJ  = 0x6
+	_PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
+	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
+	_PERF_COUNT_SW_DUMMY            = 0x9
+	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
+         
+	_PERF_SAMPLE_IP           = 0x1
+	_PERF_SAMPLE_TID          = 0x2
+	_PERF_SAMPLE_TIME         = 0x4
+	_PERF_SAMPLE_ADDR         = 0x8
+	_PERF_SAMPLE_READ         = 0x10
+	_PERF_SAMPLE_CALLCHAIN    = 0x20
+	_PERF_SAMPLE_ID           = 0x40
+	_PERF_SAMPLE_CPU          = 0x80
+	_PERF_SAMPLE_PERIOD       = 0x100
+	_PERF_SAMPLE_STREAM_ID    = 0x200
+	_PERF_SAMPLE_RAW          = 0x400
+	_PERF_SAMPLE_BRANCH_STACK = 0x800
+         
+	_PERF_SAMPLE_BRANCH_USER       = 0x1
+	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
+	_PERF_SAMPLE_BRANCH_HV         = 0x4
+	_PERF_SAMPLE_BRANCH_ANY        = 0x8
+	_PERF_SAMPLE_BRANCH_ANY_CALL   = 0x10
+	_PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
+	_PERF_SAMPLE_BRANCH_IND_CALL   = 0x40
+	_PERF_SAMPLE_BRANCH_ABORT_TX   = 0x80
+	_PERF_SAMPLE_BRANCH_IN_TX      = 0x100
+	_PERF_SAMPLE_BRANCH_NO_TX      = 0x200
+	_PERF_SAMPLE_BRANCH_COND       = 0x400
+	_PERF_SAMPLE_BRANCH_CALL_STACK = 0x800
+	_PERF_SAMPLE_BRANCH_IND_JUMP   = 0x1000
+	_PERF_SAMPLE_BRANCH_CALL       = 0x2000
+	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
+	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
+	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
+         
+	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
+	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
+	_PERF_FORMAT_ID                 = 0x4
+	_PERF_FORMAT_GROUP              = 0x8
+         
+	_PERF_RECORD_MMAP            = 0x1
+	_PERF_RECORD_LOST            = 0x2
+	_PERF_RECORD_COMM            = 0x3
+	_PERF_RECORD_EXIT            = 0x4
+	_PERF_RECORD_THROTTLE        = 0x5
+	_PERF_RECORD_UNTHROTTLE      = 0x6
+	_PERF_RECORD_FORK            = 0x7
+	_PERF_RECORD_READ            = 0x8
+	_PERF_RECORD_SAMPLE          = 0x9
+	_PERF_RECORD_MMAP2           = 0xa
+	_PERF_RECORD_AUX             = 0xb
+	_PERF_RECORD_ITRACE_START    = 0xc
+	_PERF_RECORD_LOST_SAMPLES    = 0xd
+	_PERF_RECORD_SWITCH          = 0xe
+	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
+	_PERF_RECORD_NAMESPACES      = 0x10
+         
+	_PERF_CONTEXT_HV     = -0x20
+	_PERF_CONTEXT_KERNEL = -0x80
+	_PERF_CONTEXT_USER   = -0x200
+         
+	_PERF_CONTEXT_GUEST        = -0x800
+	_PERF_CONTEXT_GUEST_KERNEL = -0x880
+	_PERF_CONTEXT_GUEST_USER   = -0xa00
+         
+	_PERF_FLAG_FD_NO_GROUP = 0x1
+	_PERF_FLAG_FD_OUTPUT   = 0x2
+	_PERF_FLAG_PID_CGROUP  = 0x4
+	_PERF_FLAG_FD_CLOEXEC  = 0x8
+         
+	_PERF_EVENT_IOC_DISABLE               = 0x2401
+	_PERF_EVENT_IOC_ENABLE                = 0x2400
+	_PERF_EVENT_IOC_ID                    = 0x80082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
+	_PERF_EVENT_IOC_PERIOD                = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH               = 0x2402
+	_PERF_EVENT_IOC_RESET                 = 0x2403
+	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER            = 0x40082406
+	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+)
+
 type timespec struct {
 	tv_sec  int64
 	tv_nsec int64
@@ -123,6 +249,9 @@ type siginfo struct {
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
 	si_addr uint64
+	// psu: an unreliable workaround and need to figure out a better solution
+	// psu: only tested on amd64
+	si_fd    int32
 }
 
 type itimerval struct {
@@ -164,3 +293,31 @@ type ucontext struct {
 	uc_mcontext sigcontext
 	uc_sigmask  uint64
 }
+
+type perfEventAttr struct {
+	Type               uint32
+	Size               uint32
+	Config             uint64
+	Sample             uint64
+	Sample_type        uint64
+	Read_format        uint64
+	Bits               uint64
+	Wakeup             uint32
+	Bp_type            uint32
+	Ext1               uint64
+	Ext2               uint64
+	Branch_sample_type uint64
+	Sample_regs_user   uint64
+	Sample_stack_user  uint32
+	Clockid            int32
+	Sample_regs_intr   uint64
+	Aux_watermark      uint32
+	Sample_max_stack   uint16
+	_                  uint16
+}
+
+// psu: only test it on amd64 
+type fOwnerEx struct {
+	Type int32
+	Pid  int32
+}
diff --git a/src/runtime/defs_pmu_linux.go b/src/runtime/defs_pmu_linux.go
index a1c0b5fa82..53e9de244a 100644
--- a/src/runtime/defs_pmu_linux.go
+++ b/src/runtime/defs_pmu_linux.go
@@ -4,9 +4,9 @@ var perfEventOpt = []struct {
 	Type    uint32 // type of event
 	Config  uint64 // event 
 } {
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES},	      // index: GO_COUNT_HW_CPU_CYCLES
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS},     // index: GO_COUNT_HW_INSTRUCTIONS
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES}, // index: GO_COUNT_HW_CACHE_REFERENCES
-	{PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES},     // index: GO_COUNT_HW_CACHE_MISSES
+	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},	      // index: GO_COUNT_HW_CPU_CYCLES
+	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},     // index: GO_COUNT_HW_INSTRUCTIONS
+	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_REFERENCES}, // index: GO_COUNT_HW_CACHE_REFERENCES
+	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_MISSES},     // index: GO_COUNT_HW_CACHE_MISSES
 	// TODO: add more perf events
 }
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index f56813ede6..5a618483e8 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -243,18 +243,25 @@ func clearSignalHandlers() {
 // required for -buildmode=c-archive.
 func setProcessCPUProfiler(hz int32) {
 	if hz != 0 {
-		atomic.Cas(&sigState, _UNINSTALLED, _ITIMER_INSTALLED)
-		// Enable the Go signal handler if not enabled.
-		if atomic.Cas(&handlingSig[_SIGPROF], 0, 1) {
-			atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF))
-			setsig(_SIGPROF, funcPC(sighandler))
+		oldVal := atomic.Load(&handlingSig[_SIGPROF])
+		if oldVal != _ITIMER_INSTALLED {
+			if atomic.Cas(&handlingSig[_SIGPROF], oldVal, _ITIMER_INSTALLED) {
+				atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF))
+				setsig(_SIGPROF, funcPC(sighandler))
+			} else {
+				racyUpdatedVal := atomic.Load(&handlingSig[_SIGPROF])
+				if racyUpdatedVal != _UNINSTALLED {
+					panic("never reach here since pprof should have protected us")
+				} else {
+					println("sombody else did the job for us")
+				}
+			}
 		}
 	} else {
-		atomic.Cas(&sigState, _ITIMER_INSTALLED, _UNINSTALLED)
 		// If the Go signal handler should be disabled by default,
 		// disable it if it is enabled.
 		if !sigInstallGoHandler(_SIGPROF) {
-			if atomic.Cas(&handlingSig[_SIGPROF], 1, 0) {
+			if atomic.Cas(&handlingSig[_SIGPROF], _ITIMER_INSTALLED, _UNINSTALLED) {
 				setsig(_SIGPROF, atomic.Loaduintptr(&fwdSig[_SIGPROF]))
 			}
 		}
diff --git a/src/runtime/sys_linux_386.s b/src/runtime/sys_linux_386.s
index 72c43bd9da..dc8509c115 100644
--- a/src/runtime/sys_linux_386.s
+++ b/src/runtime/sys_linux_386.s
@@ -33,6 +33,7 @@
 #define SYS_access		33
 #define SYS_kill		37
 #define SYS_brk 		45
+#define SYS_ioctl       	54
 #define SYS_fcntl		55
 #define SYS_munmap		91
 #define SYS_socketcall		102
@@ -58,6 +59,7 @@
 #define SYS_clock_gettime	265
 #define SYS_tgkill		270
 #define SYS_epoll_create1	329
+#define SYS_perf_event_open 	336
 
 TEXT runtime·exit(SB),NOSPLIT,$0
 	MOVL	$SYS_exit_group, AX
@@ -734,3 +736,86 @@ TEXT runtime·sbrk0(SB),NOSPLIT,$0-4
 	INVOKE_SYSCALL
 	MOVL	AX, ret+0(FP)
 	RET
+
+// psu: not tested
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+	MOVL	attr+0(FP), BX
+	MOVL	pid+4(FP), CX
+	MOVL	cpu+8(FP), DX
+	MOVL	groupFd+12(FP), SI
+	MOVL	flags+16(FP), DI
+	MOVL	dummy+20(FP), BP
+	MOVL	$SYS_perf_event_open, AX
+	INVOKE_SYSCALL
+	CMPL	AX, $0xfffff001
+	JLS	ok
+	MOVL	$-1, r+24(FP)
+	MOVL	$0, r2+28(FP)
+	NEGL	AX
+	MOVL	AX, err+32(FP)
+	RET
+ok:
+	MOVL	AX, r+24(FP)
+	MOVL	DX, r2+28(FP)
+	MOVL	$0, err+32(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·ioctl(SB),NOSPLIT,$0
+	MOVL	fd+0(FP), BX
+	MOVL	req+4(FP), CX
+	MOVL	arg+8(FP), DX
+	MOVL    $0, SI
+        MOVL    $0, DI
+	MOVL	$SYS_ioctl, AX
+	INVOKE_SYSCALL
+	CMPL	AX, $0xfffff001
+	JLS	ok
+	MOVL	$-1, r+12(FP)
+	NEGL	AX
+	MOVL	AX, err+16(FP)
+	RET
+ok:
+	MOVL	AX, r+12(FP)
+	MOVL	$0, err+16(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl(SB),NOSPLIT,$0
+	MOVL	fd+0(FP), BX
+	MOVL	cmd+4(FP), CX
+	MOVL	arg+8(FP), DX
+	MOVL    $0, SI
+        MOVL    $0, DI
+	MOVL	$SYS_fcntl, AX
+	INVOKE_SYSCALL
+	CMPL	AX, $0xfffff001
+	JLS	ok
+	MOVL	$-1, r+12(FP)
+	NEGL	AX
+	MOVL	AX, err+16(FP)
+	RET
+ok:
+	MOVL	AX, r+12(FP)
+	MOVL	$0, err+16(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl2(SB),NOSPLIT,$0
+	MOVL	fd+0(FP), BX
+	MOVL	cmd+4(FP), CX
+	MOVL	arg+8(FP), DX
+	MOVL    $0, SI
+        MOVL    $0, DI
+	MOVL	$SYS_fcntl, AX
+	INVOKE_SYSCALL
+	CMPL	AX, $0xfffff001
+	JLS	ok
+	MOVL	$-1, r+12(FP)
+	NEGL	AX
+	MOVL	AX, err+16(FP)
+	RET
+ok:
+	MOVL	AX, r+12(FP)
+	MOVL	$0, err+16(FP)
+	RET
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index d6e876acbd..477f018e2e 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -21,7 +21,7 @@
 #define SYS_rt_sigaction	13
 #define SYS_rt_sigprocmask	14
 #define SYS_rt_sigreturn	15
-#define SYS_ioctl       16
+#define SYS_ioctl       	16
 #define SYS_sched_yield 	24
 #define SYS_mincore		27
 #define SYS_madvise		28
@@ -47,7 +47,7 @@
 #define SYS_faccessat		269
 #define SYS_epoll_pwait		281
 #define SYS_epoll_create1	291
-#define SYS_perfEventOpen 	298
+#define SYS_perf_event_open 	298
 
 TEXT runtime·exit(SB),NOSPLIT,$0-4
 	MOVL	code+0(FP), DI
@@ -168,77 +168,6 @@ TEXT runtime·setitimer(SB),NOSPLIT,$0-24
 	SYSCALL
 	RET
 
-TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
-	MOVQ	attr+0(FP), DI
-	MOVQ	pid+8(FP), SI
-	MOVQ	cpu+16(FP), DX
-	MOVQ	groupFd+24(FP), R10
-	MOVQ	flags+32(FP), R8
-	MOVQ	dummy+40(FP), R9
-	MOVQ	$SYS_perfEventOpen, AX	// syscall entry
-	SYSCALL
-	CMPQ	AX, $0xfffffffffffff001
-	JLS	ok
-	MOVL	$-1, r+48(FP)
-	MOVQ	$0, r2+56(FP)
-	NEGQ	AX
-	MOVQ	AX, err+64(FP)
-	RET
-ok:
-	MOVL	AX, r+48(FP)
-	MOVQ	DX, r2+56(FP)
-	MOVQ	$0, err+64(FP)
-	RET
-
-TEXT runtime·ioctl(SB),NOSPLIT,$0
-	MOVL	fd+0(FP), DI
-	MOVQ	req+8(FP), SI
-	MOVQ	arg+16(FP), DX
-	MOVQ    $0, R10
-        MOVQ    $0, R8
-        MOVQ    $0, R9
-	MOVQ	$SYS_ioctl, AX
-	SYSCALL
-	MOVQ    AX, ret+24(FP)
-	RET
-
-TEXT runtime·fcntl(SB),NOSPLIT,$0
-	MOVL	fd+0(FP), DI
-	MOVQ	cmd+8(FP), SI
-	MOVQ	arg+16(FP), DX
-	MOVQ    $0, R10
-        MOVQ    $0, R8
-        MOVQ    $0, R9
-	MOVQ	$SYS_fcntl, AX
-	SYSCALL
-	CMPQ	AX, $0xfffffffffffff001
-	JLS	ok
-	MOVQ	$-1, r+24(FP)
-	NEGQ	AX
-	MOVQ	AX, err+32(FP)
-	RET
-ok:
-	MOVQ	AX, r+24(FP)
-	MOVQ	$0, err+32(FP)
-	RET
-
-TEXT runtime·fcntl2(SB),NOSPLIT,$0
-	MOVL	fd+0(FP), DI
-	MOVQ	cmd+8(FP), SI
-	MOVQ	arg+16(FP), DX
-	MOVQ	$SYS_fcntl, AX
-	SYSCALL
-	CMPQ	AX, $0xfffffffffffff001
-	JLS	ok
-	MOVQ	$-1, r+24(FP)
-	NEGQ	AX
-	MOVQ	AX, err+32(FP)
-	RET
-ok:
-	MOVQ	AX, r+24(FP)
-	MOVQ	$0, err+32(FP)
-	RET
-
 TEXT runtime·mincore(SB),NOSPLIT,$0-28
 	MOVQ	addr+0(FP), DI
 	MOVQ	n+8(FP), SI
@@ -796,3 +725,85 @@ TEXT runtime·sbrk0(SB),NOSPLIT,$0-8
 	SYSCALL
 	MOVQ	AX, ret+0(FP)
 	RET
+
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+	MOVQ	attr+0(FP), DI
+	MOVQ	pid+8(FP), SI
+	MOVQ	cpu+16(FP), DX
+	MOVQ	groupFd+24(FP), R10
+	MOVQ	flags+32(FP), R8
+	MOVQ	dummy+40(FP), R9
+	MOVQ	$SYS_perf_event_open, AX
+	SYSCALL
+	CMPQ	AX, $0xfffffffffffff001
+	JLS	ok
+	MOVL	$-1, r+48(FP)
+	MOVQ	$0, r2+56(FP)
+	NEGQ	AX
+	MOVQ	AX, err+64(FP)
+	RET
+ok:
+	MOVL	AX, r+48(FP)
+	MOVQ	DX, r2+56(FP)
+	MOVQ	$0, err+64(FP)
+	RET
+
+TEXT runtime·ioctl(SB),NOSPLIT,$0
+	MOVL	fd+0(FP), DI
+	MOVQ	req+8(FP), SI
+	MOVQ	arg+16(FP), DX
+	MOVQ    $0, R10
+        MOVQ    $0, R8
+        MOVQ    $0, R9
+	MOVQ	$SYS_ioctl, AX
+	SYSCALL
+	CMPQ    AX, $0xfffffffffffff001
+	JLS	ok
+	MOVQ	$-1, r+24(FP)
+	NEGQ	AX
+	MOVQ	AX, err+32(FP)
+	RET
+ok:
+	MOVQ	AX, r+24(FP)
+	MOVQ	$0, err+32(FP)
+	RET
+
+TEXT runtime·fcntl(SB),NOSPLIT,$0
+	MOVL	fd+0(FP), DI
+	MOVQ	cmd+8(FP), SI
+	MOVQ	arg+16(FP), DX
+	MOVQ    $0, R10
+        MOVQ    $0, R8
+        MOVQ    $0, R9
+	MOVQ	$SYS_fcntl, AX
+	SYSCALL
+	CMPQ	AX, $0xfffffffffffff001
+	JLS	ok
+	MOVQ	$-1, r+24(FP)
+	NEGQ	AX
+	MOVQ	AX, err+32(FP)
+	RET
+ok:
+	MOVQ	AX, r+24(FP)
+	MOVQ	$0, err+32(FP)
+	RET
+
+TEXT runtime·fcntl2(SB),NOSPLIT,$0
+	MOVL	fd+0(FP), DI
+	MOVQ	cmd+8(FP), SI
+	MOVQ	arg+16(FP), DX
+	MOVQ    $0, R10
+        MOVQ    $0, R8
+        MOVQ    $0, R9
+	MOVQ	$SYS_fcntl, AX
+	SYSCALL
+	CMPQ	AX, $0xfffffffffffff001
+	JLS	ok
+	MOVQ	$-1, r+24(FP)
+	NEGQ	AX
+	MOVQ	AX, err+32(FP)
+	RET
+ok:
+	MOVQ	AX, r+24(FP)
+	MOVQ	$0, err+32(FP)
+	RET
diff --git a/src/runtime/sys_linux_arm.s b/src/runtime/sys_linux_arm.s
index 9c7398451c..7eb71cd456 100644
--- a/src/runtime/sys_linux_arm.s
+++ b/src/runtime/sys_linux_arm.s
@@ -45,11 +45,13 @@
 #define SYS_epoll_ctl (SYS_BASE + 251)
 #define SYS_epoll_wait (SYS_BASE + 252)
 #define SYS_epoll_create1 (SYS_BASE + 357)
+#define SYS_ioctl (SYS_BASE + 54)
 #define SYS_fcntl (SYS_BASE + 55)
 #define SYS_access (SYS_BASE + 33)
 #define SYS_connect (SYS_BASE + 283)
 #define SYS_socket (SYS_BASE + 281)
 #define SYS_brk (SYS_BASE + 45)
+#define SYS_perf_event_open (SYS_BASE + 364)
 
 #define ARM_BASE (SYS_BASE + 0x0f0000)
 
@@ -609,3 +611,102 @@ TEXT runtime·sbrk0(SB),NOSPLIT,$0-4
 
 TEXT runtime·sigreturn(SB),NOSPLIT,$0-0
 	RET
+
+// psu: not tested
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+	MOVW	attr+0(FP), R0
+	MOVW	pid+4((FP), R1
+	MOVW	cpu+8(FP), R2
+	MOVW	groupFd+12(FP), R3
+	MOVW	flags+16(FP), R4
+	MOVW	dummy+20(FP), R5
+	MOVW	$SYS_perf_event_open, R7
+	SWI     $0
+	MOVW    $0xfffff001, R6 
+	CMP     R6, R0
+	BLS     ok
+	MOVW	$-1, R1
+	MOVW	R1, r+24(FP)
+	MOVW    $0, R2
+	MOVW	R2, r2+28(FP)
+	RSB     $0, R0, R0
+        MOVW    R0, err+32(FP) 
+	RET
+ok:
+	MOVW	R0, r+24(FP)
+	MOVW	R1, r2+28(FP)
+	MOVW    $0, R0
+	MOVW	R0, err+32(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·ioctl(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R0
+	MOVW	req+4(FP), R1
+	MOVW	arg+8(FP), R2
+	MOVW	$0, R3
+	MOVW	$0, R4
+	MOVW	$0, R5
+	MOVW	$SYS_ioctl, R7
+	SWI     $0
+	MOVW    $0xfffff001, R1
+	CMP     R1, R0
+	BLS     ok
+	MOVW	$-1, R1
+	MOVW	R1, r+12(FP)
+	RSB     $0, R0, R0
+	MOVW    R0, err+16(FP)
+	RET
+ok:
+	MOVW	R0, r+12(FP)
+	MOVW    $0, R0
+	MOVW	R0, err+16(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R0
+	MOVW	cmd+4(FP), R1
+	MOVW	arg+8(FP), R2
+	MOVW	$0, R3
+	MOVW	$0, R4
+	MOVW	$0, R5
+	MOVW	$SYS_fcntl, R7
+	SWI     $0
+	MOVW    $0xfffff001, R1
+	CMP     R1, R0
+	BLS     ok
+	MOVW	$-1, R1
+	MOVW	R1, r+12(FP)
+	RSB     $0, R0, R0
+	MOVW    R0, err+16(FP)
+	RET
+ok:
+	MOVW	R0, r+12(FP)
+	MOVW    $0, R0
+	MOVW	R0, err+16(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl2(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R0
+	MOVW	cmd+4(FP), R1
+	MOVW	arg+8(FP), R2
+	MOVW	$0, R3
+	MOVW	$0, R4
+	MOVW	$0, R5
+	MOVW	$SYS_fcntl, R7
+	SWI     $0
+	MOVW    $0xfffff001, R1
+	CMP     R1, R0
+	BLS     ok
+	MOVW	$-1, R1
+	MOVW	R1, r+12(FP)
+	RSB     $0, R0, R0
+	MOVW    R0, err+16(FP)
+	RET
+ok:
+	MOVW	R0, r+12(FP)
+	MOVW    $0, R0
+	MOVW	R0, err+16(FP)
+	RET
diff --git a/src/runtime/sys_linux_arm64.s b/src/runtime/sys_linux_arm64.s
index 321d74254c..b136bd6a0a 100644
--- a/src/runtime/sys_linux_arm64.s
+++ b/src/runtime/sys_linux_arm64.s
@@ -21,6 +21,7 @@
 #define SYS_openat		56
 #define SYS_close		57
 #define SYS_fcntl		25
+#define SYS_ioctl       	29
 #define SYS_nanosleep		101
 #define SYS_mmap		222
 #define SYS_munmap		215
@@ -48,6 +49,7 @@
 #define SYS_socket		198
 #define SYS_connect		203
 #define SYS_brk			214
+#define SYS_perf_event_open 	241
 
 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
 	MOVW	code+0(FP), R0
@@ -602,3 +604,93 @@ TEXT runtime·sbrk0(SB),NOSPLIT,$0-8
 
 TEXT runtime·sigreturn(SB),NOSPLIT,$0-0
 	RET
+
+// psu: not tested
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+	MOVD	attr+0(FP), R0
+	MOVD	pid+8((FP), R1
+	MOVD	cpu+16(FP), R2
+	MOVD	groupFd+24(FP), R3
+	MOVD	flags+32(FP), R4
+	MOVD	dummy+40(FP), R5
+	MOVD	$SYS_perf_event_open, R8
+	SVC
+	CMN	$4095, R0
+	BCC	ok
+	MOVD	$-1, R4
+	MOVW	R4, r+48(FP)
+	MOVD	ZR, r2+56(FP)
+	NEG	R0, R0
+	MOVD	R0, err+64(FP)
+	RET
+ok:
+	MOVW	R0, r+48(FP)
+	MOVD	R1, r2+56(FP)
+	MOVD	ZR, err+64(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·ioctl(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R0
+	MOVD	req+8(FP), R1
+	MOVD	arg+16(FP), R2
+	MOVD	$0, R3
+	MOVD	$0, R4
+	MOVD	$0, R5
+	MOVD	$SYS_ioctl, R8
+	SVC
+	CMN	$4095, R0
+	BCC	ok
+	MOVD	$-1, R4
+	MOVD	R4, r+24(FP)
+	NEG	R0, R0
+	MOVD	R0, err+32(FP)
+	RET
+ok:
+	MOVD	R0, r+24(FP)
+	MOVD	ZR, err+32(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R0
+	MOVD	cmd+8(FP), R1
+	MOVD	arg+16(FP), R2
+	MOVD	$0, R3
+	MOVD	$0, R4
+	MOVD	$0, R5
+	MOVD	$SYS_fcntl, R8
+	SVC
+	CMN	$4095, R0
+	BCC	ok
+	MOVD	$-1, R4
+	MOVD	R4, r+24(FP)
+	NEG	R0, R0
+	MOVD	R0, err+32(FP)
+	RET
+ok:
+	MOVD	R0, r+24(FP)
+	MOVD	ZR, err+32(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl2(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R0
+	MOVD	cmd+8(FP), R1
+	MOVD	arg+16(FP), R2
+	MOVD	$0, R3
+	MOVD	$0, R4
+	MOVD	$0, R5
+	MOVD	$SYS_fcntl, R8
+	SVC
+	CMN	$4095, R0
+	BCC	ok
+	MOVD	$-1, R4
+	MOVD	R4, r+24(FP)
+	NEG	R0, R0
+	MOVD	R0, err+32(FP)
+	RET
+ok:
+	MOVD	R0, r+24(FP)
+	MOVD	ZR, err+32(FP)
+	RET
diff --git a/src/runtime/sys_linux_mips64x.s b/src/runtime/sys_linux_mips64x.s
index 33ed1050c2..1b6c3138a3 100644
--- a/src/runtime/sys_linux_mips64x.s
+++ b/src/runtime/sys_linux_mips64x.s
@@ -31,6 +31,7 @@
 #define SYS_rt_sigreturn	5211
 #define SYS_rt_sigaction	5013
 #define SYS_rt_sigprocmask	5014
+#define SYS_ioctl       	5015
 #define SYS_sigaltstack		5129
 #define SYS_madvise		5027
 #define SYS_mincore		5026
@@ -46,6 +47,8 @@
 #define SYS_clock_gettime	5222
 #define SYS_epoll_create1	5285
 #define SYS_brk			5012
+#define SYS_perf_event_open	5292
+
 
 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
 	MOVW	code+0(FP), R4
@@ -477,3 +480,85 @@ TEXT runtime·socket(SB),$0-20
 	MOVV	R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go
 	MOVW	R0, ret+16(FP) // for vet
 	RET
+
+// psu: not tested
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+	MOVV	attr+0(FP), R4
+	MOVV	pid+8(FP), R5
+	MOVV	cpu+16(FP), R6
+	MOVV	groupFd+24(FP), R7
+	MOVV	flags+32(FP), R8
+	MOVV	dummp+40(FP), R9
+	MOVV	$SYS_perf_event_open, R2
+	SYSCALL
+	BEQ	R7, ok
+	MOVV	$-1, R1
+	MOVV	R1, r+48(FP)
+	MOVV	R0, r2+56(FP)
+	MOVV	R2, err+64(FP)
+	RET
+ok:
+	MOVV	R2, r+48(FP)
+	MOVV	R3, r2+56(FP)
+	MOVV	R0, err+64(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·ioctl,NOSPLIT,$0
+	MOVV	fd+0(FP), R4
+	MOVV	req+8(FP), R5
+	MOVV	arg+16(FP), R6
+	MOVV	R0, R7
+	MOVV	R0, R8
+	MOVV	R0, R9
+	MOVV	$SYS_ioctl, R2
+	SYSCALL
+	BEQ	R7, ok
+	MOVV	$-1, R1
+	MOVV	R1, r+24(FP)	
+	MOVV	R2, err+32(FP)	
+	RET
+ok:
+	MOVV	R2, r+24(FP)	
+	MOVV	R0, err+32(FP)	
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl,NOSPLIT,$0
+	MOVV	fd+0(FP), R4
+	MOVV	cmd+8(FP), R5
+	MOVV	arg+16(FP), R6
+	MOVV	R0, R7
+	MOVV	R0, R8
+	MOVV	R0, R9
+	MOVV	$SYS_fcntl, R2
+	SYSCALL
+	BEQ	R7, ok
+	MOVV	$-1, R1
+	MOVV	R1, r+24(FP)	
+	MOVV	R2, err+32(FP)	
+	RET
+ok:
+	MOVV	R2, r+24(FP)	
+	MOVV	R0, err+32(FP)	
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl2,NOSPLIT,$0
+	MOVV	fd+0(FP), R4
+	MOVV	cmd+8(FP), R5
+	MOVV	arg+16(FP), R6
+	MOVV	R0, R7
+	MOVV	R0, R8
+	MOVV	R0, R9
+	MOVV	$SYS_fcntl, R2
+	SYSCALL
+	BEQ	R7, ok
+	MOVV	$-1, R1
+	MOVV	R1, r+24(FP)	
+	MOVV	R2, err+32(FP)	
+	RET
+ok:
+	MOVV	R2, r+24(FP)	
+	MOVV	R0, err+32(FP)	
+	RET
diff --git a/src/runtime/sys_linux_ppc64x.s b/src/runtime/sys_linux_ppc64x.s
index 13d23156bd..2feefe6f79 100644
--- a/src/runtime/sys_linux_ppc64x.s
+++ b/src/runtime/sys_linux_ppc64x.s
@@ -22,6 +22,7 @@
 #define SYS_getpid		 20
 #define SYS_kill		 37
 #define SYS_brk			 45
+#define SYS_ioctl		 54
 #define SYS_fcntl		 55
 #define SYS_mmap		 90
 #define SYS_munmap		 91
@@ -45,6 +46,7 @@
 #define SYS_clock_gettime	246
 #define SYS_tgkill		250
 #define SYS_epoll_create1	315
+#define SYS_perf_event_open	319
 
 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
 	MOVW	code+0(FP), R3
@@ -634,3 +636,85 @@ TEXT runtime·socket(SB),$0-20
 	MOVD	R0, 0(R0) // unimplemented, only needed for android; declared in stubs_linux.go
 	MOVW	R0, ret+16(FP) // for vet
 	RET
+
+// psu: not tested
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+	MOVD	attr+0(FP), R3
+	MOVD	pid+8(FP), R4
+	MOVD	cpu+16(FP), R5
+	MOVD	groupFd+24(FP), R6
+	MOVD	flags+32(FP), R7
+	MOVD	dummy+40(FP), R8
+	MOVD	$SYS_perf_event_open, R9	
+	SYSCALL R9
+	BVC	ok
+	MOVD	$-1, R4
+	MOVW	R4, r+48(FP)	
+	MOVD	R0, r2+56(FP)	
+	MOVD	R3, err+64(FP)	
+	RET
+ok:
+	MOVW	R3, r+48(FP)	
+	MOVD	R4, r2+56(FP)	
+	MOVD	R0, err+64(FP)	
+	RET
+
+// psu: not tested
+TEXT runtime·ioctl(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R3
+	MOVD	req+8(FP), R4
+	MOVD	arg+16(FP), R5
+	MOVD	R0, R6
+	MOVD	R0, R7
+	MOVD	R0, R8
+	MOVD	$SYS_ioctl, R9	
+	SYSCALL R9
+	BVC	ok
+	MOVD	$-1, R4
+	MOVD	R4, r+24(FP)	
+	MOVD	R3, err+32(FP)	
+	RET
+ok:
+	MOVD	R3, r+24(FP)	
+	MOVD	R0, err+32(FP)	
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R3
+	MOVD	cmd+8(FP), R4
+	MOVD	arg+16(FP), R5
+	MOVD	R0, R6
+	MOVD	R0, R7
+	MOVD	R0, R8
+	MOVD	$SYS_fcntl, R9	
+	SYSCALL R9
+	BVC	ok
+	MOVD	$-1, R4
+	MOVD	R4, r+24(FP)	
+	MOVD	R3, err+32(FP)	
+	RET
+ok:
+	MOVD	R3, r+24(FP)	
+	MOVD	R0, err+32(FP)	
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl2(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R3
+	MOVD	cmd+8(FP), R4
+	MOVD	arg+16(FP), R5
+	MOVD	R0, R6
+	MOVD	R0, R7
+	MOVD	R0, R8
+	MOVD	$SYS_fcntl, R9	
+	SYSCALL R9
+	BVC	ok
+	MOVD	$-1, R4
+	MOVD	R4, r+24(FP)	
+	MOVD	R3, err+32(FP)	
+	RET
+ok:
+	MOVD	R3, r+24(FP)	
+	MOVD	R0, err+32(FP)	
+	RET
diff --git a/src/runtime/sys_linux_s390x.s b/src/runtime/sys_linux_s390x.s
index 58b36dff0a..0c8e95da6a 100644
--- a/src/runtime/sys_linux_s390x.s
+++ b/src/runtime/sys_linux_s390x.s
@@ -17,6 +17,7 @@
 #define SYS_getpid               20
 #define SYS_kill                 37
 #define SYS_brk			 45
+#define SYS_ioctl		 54
 #define SYS_fcntl                55
 #define SYS_mmap                 90
 #define SYS_munmap               91
@@ -40,6 +41,7 @@
 #define SYS_epoll_wait          251
 #define SYS_clock_gettime       260
 #define SYS_epoll_create1       327
+#define SYS_perf_event_open 	331
 
 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
 	MOVW	code+0(FP), R2
@@ -464,3 +466,89 @@ TEXT runtime·socket(SB),$0-20
 	MOVD	$0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go
 	MOVW	R0, ret+16(FP)
 	RET
+
+// psu: not tested
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+	MOVD	attr+0(FP), R2
+	MOVD	pid+8(FP), R3
+	MOVD	cpu+16(FP), R4
+	MOVD	groupFd+24(FP), R5
+	MOVD	flags+32(FP), R6
+	MOVD	dummy+40(FP), R7
+	MOVD	SYS_perf_event_open, R1	
+	SYSCALL
+	MOVD	$0xfffffffffffff001, R8
+	CMPUBLT	R2, R8, ok
+	MOVW	$-1, r+48(FP)
+	MOVD	$0, r2+56(FP)
+	NEG	R2, R2
+	MOVD	R2, err+64(FP)
+	RET
+ok:
+	MOVW	R2, r+48(FP)
+	MOVD	R3, r2+56(FP)
+	MOVD	$0, err+64(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·ioctl(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R2
+	MOVD	req+8(FP), R3
+	MOVD	arg+16(FP), R4
+	MOVD	$0, R5
+	MOVD	$0, R6
+	MOVD	$0, R7
+	MOVD	$SYS_ioctl, R1
+	SYSCALL
+	MOVD	$0xfffffffffffff001, R8
+	CMPUBLT	R2, R8, ok
+	MOVD	$-1, r+24(FP)
+	NEG	R2, R2
+	MOVD	R2, err+32(FP)
+	RET
+ok:
+	MOVD	R2, r+24(FP)
+	MOVD	$0, err+32(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R2
+	MOVD	cmd+8(FP), R3
+	MOVD	arg+16(FP), R4
+	MOVD	$0, R5
+	MOVD	$0, R6
+	MOVD	$0, R7
+	MOVD	$SYS_fcntl, R1
+	SYSCALL
+	MOVD	$0xfffffffffffff001, R8
+	CMPUBLT	R2, R8, ok
+	MOVD	$-1, r+24(FP)
+	NEG	R2, R2
+	MOVD	R2, err+32(FP)
+	RET
+ok:
+	MOVD	R2, r+24(FP)
+	MOVD	$0, err+32(FP)
+	RET
+
+// psu: not tested
+TEXT runtime·fcntl2(SB),NOSPLIT,$0
+	MOVW	fd+0(FP), R2
+	MOVD	cmd+8(FP), R3
+	MOVD	arg+16(FP), R4
+	MOVD	$0, R5
+	MOVD	$0, R6
+	MOVD	$0, R7
+	MOVD	$SYS_fcntl, R1
+	SYSCALL
+	MOVD	$0xfffffffffffff001, R8
+	CMPUBLT	R2, R8, ok
+	MOVD	$-1, r+24(FP)
+	NEG	R2, R2
+	MOVD	R2, err+32(FP)
+	RET
+ok:
+	MOVD	R2, r+24(FP)
+	MOVD	$0, err+32(FP)
+	RET

From 63bab352d9b5f70a8c3e2892f06d2502a5d381ee Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 14 Jul 2019 21:13:31 -0700
Subject: [PATCH 063/126] minor

---
 src/runtime/sys_linux_386.s     | 8 ++++----
 src/runtime/sys_linux_amd64.s   | 8 ++++----
 src/runtime/sys_linux_arm.s     | 8 ++++----
 src/runtime/sys_linux_arm64.s   | 8 ++++----
 src/runtime/sys_linux_mips64x.s | 8 ++++----
 src/runtime/sys_linux_ppc64x.s  | 8 ++++----
 src/runtime/sys_linux_s390x.s   | 8 ++++----
 7 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/src/runtime/sys_linux_386.s b/src/runtime/sys_linux_386.s
index dc8509c115..c9d10cdaad 100644
--- a/src/runtime/sys_linux_386.s
+++ b/src/runtime/sys_linux_386.s
@@ -738,7 +738,7 @@ TEXT runtime·sbrk0(SB),NOSPLIT,$0-4
 	RET
 
 // psu: not tested
-TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0-36
 	MOVL	attr+0(FP), BX
 	MOVL	pid+4(FP), CX
 	MOVL	cpu+8(FP), DX
@@ -761,7 +761,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·ioctl(SB),NOSPLIT,$0
+TEXT runtime·ioctl(SB),NOSPLIT,$0-20
 	MOVL	fd+0(FP), BX
 	MOVL	req+4(FP), CX
 	MOVL	arg+8(FP), DX
@@ -781,7 +781,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl(SB),NOSPLIT,$0
+TEXT runtime·fcntl(SB),NOSPLIT,$0-20
 	MOVL	fd+0(FP), BX
 	MOVL	cmd+4(FP), CX
 	MOVL	arg+8(FP), DX
@@ -801,7 +801,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl2(SB),NOSPLIT,$0
+TEXT runtime·fcntl2(SB),NOSPLIT,$0-20
 	MOVL	fd+0(FP), BX
 	MOVL	cmd+4(FP), CX
 	MOVL	arg+8(FP), DX
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 477f018e2e..6a2aa60867 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -726,7 +726,7 @@ TEXT runtime·sbrk0(SB),NOSPLIT,$0-8
 	MOVQ	AX, ret+0(FP)
 	RET
 
-TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0-72
 	MOVQ	attr+0(FP), DI
 	MOVQ	pid+8(FP), SI
 	MOVQ	cpu+16(FP), DX
@@ -748,7 +748,7 @@ ok:
 	MOVQ	$0, err+64(FP)
 	RET
 
-TEXT runtime·ioctl(SB),NOSPLIT,$0
+TEXT runtime·ioctl(SB),NOSPLIT,$0-40
 	MOVL	fd+0(FP), DI
 	MOVQ	req+8(FP), SI
 	MOVQ	arg+16(FP), DX
@@ -768,7 +768,7 @@ ok:
 	MOVQ	$0, err+32(FP)
 	RET
 
-TEXT runtime·fcntl(SB),NOSPLIT,$0
+TEXT runtime·fcntl(SB),NOSPLIT,$0-40
 	MOVL	fd+0(FP), DI
 	MOVQ	cmd+8(FP), SI
 	MOVQ	arg+16(FP), DX
@@ -788,7 +788,7 @@ ok:
 	MOVQ	$0, err+32(FP)
 	RET
 
-TEXT runtime·fcntl2(SB),NOSPLIT,$0
+TEXT runtime·fcntl2(SB),NOSPLIT,$0-40
 	MOVL	fd+0(FP), DI
 	MOVQ	cmd+8(FP), SI
 	MOVQ	arg+16(FP), DX
diff --git a/src/runtime/sys_linux_arm.s b/src/runtime/sys_linux_arm.s
index 7eb71cd456..a1fea01cd5 100644
--- a/src/runtime/sys_linux_arm.s
+++ b/src/runtime/sys_linux_arm.s
@@ -613,7 +613,7 @@ TEXT runtime·sigreturn(SB),NOSPLIT,$0-0
 	RET
 
 // psu: not tested
-TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0-36
 	MOVW	attr+0(FP), R0
 	MOVW	pid+4((FP), R1
 	MOVW	cpu+8(FP), R2
@@ -640,7 +640,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·ioctl(SB),NOSPLIT,$0
+TEXT runtime·ioctl(SB),NOSPLIT,$0-20
 	MOVW	fd+0(FP), R0
 	MOVW	req+4(FP), R1
 	MOVW	arg+8(FP), R2
@@ -664,7 +664,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl(SB),NOSPLIT,$0
+TEXT runtime·fcntl(SB),NOSPLIT,$0-20
 	MOVW	fd+0(FP), R0
 	MOVW	cmd+4(FP), R1
 	MOVW	arg+8(FP), R2
@@ -688,7 +688,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl2(SB),NOSPLIT,$0
+TEXT runtime·fcntl2(SB),NOSPLIT,$0-20
 	MOVW	fd+0(FP), R0
 	MOVW	cmd+4(FP), R1
 	MOVW	arg+8(FP), R2
diff --git a/src/runtime/sys_linux_arm64.s b/src/runtime/sys_linux_arm64.s
index b136bd6a0a..7a3672039d 100644
--- a/src/runtime/sys_linux_arm64.s
+++ b/src/runtime/sys_linux_arm64.s
@@ -606,7 +606,7 @@ TEXT runtime·sigreturn(SB),NOSPLIT,$0-0
 	RET
 
 // psu: not tested
-TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0-72
 	MOVD	attr+0(FP), R0
 	MOVD	pid+8((FP), R1
 	MOVD	cpu+16(FP), R2
@@ -630,7 +630,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·ioctl(SB),NOSPLIT,$0
+TEXT runtime·ioctl(SB),NOSPLIT,$0-40
 	MOVW	fd+0(FP), R0
 	MOVD	req+8(FP), R1
 	MOVD	arg+16(FP), R2
@@ -652,7 +652,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl(SB),NOSPLIT,$0
+TEXT runtime·fcntl(SB),NOSPLIT,$0-40
 	MOVW	fd+0(FP), R0
 	MOVD	cmd+8(FP), R1
 	MOVD	arg+16(FP), R2
@@ -674,7 +674,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl2(SB),NOSPLIT,$0
+TEXT runtime·fcntl2(SB),NOSPLIT,$0-40
 	MOVW	fd+0(FP), R0
 	MOVD	cmd+8(FP), R1
 	MOVD	arg+16(FP), R2
diff --git a/src/runtime/sys_linux_mips64x.s b/src/runtime/sys_linux_mips64x.s
index 1b6c3138a3..245982ca9a 100644
--- a/src/runtime/sys_linux_mips64x.s
+++ b/src/runtime/sys_linux_mips64x.s
@@ -482,7 +482,7 @@ TEXT runtime·socket(SB),$0-20
 	RET
 
 // psu: not tested
-TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0-72
 	MOVV	attr+0(FP), R4
 	MOVV	pid+8(FP), R5
 	MOVV	cpu+16(FP), R6
@@ -504,7 +504,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·ioctl,NOSPLIT,$0
+TEXT runtime·ioctl,NOSPLIT,$0-40
 	MOVV	fd+0(FP), R4
 	MOVV	req+8(FP), R5
 	MOVV	arg+16(FP), R6
@@ -524,7 +524,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl,NOSPLIT,$0
+TEXT runtime·fcntl,NOSPLIT,$0-40
 	MOVV	fd+0(FP), R4
 	MOVV	cmd+8(FP), R5
 	MOVV	arg+16(FP), R6
@@ -544,7 +544,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl2,NOSPLIT,$0
+TEXT runtime·fcntl2,NOSPLIT,$0-40
 	MOVV	fd+0(FP), R4
 	MOVV	cmd+8(FP), R5
 	MOVV	arg+16(FP), R6
diff --git a/src/runtime/sys_linux_ppc64x.s b/src/runtime/sys_linux_ppc64x.s
index 2feefe6f79..e030320aab 100644
--- a/src/runtime/sys_linux_ppc64x.s
+++ b/src/runtime/sys_linux_ppc64x.s
@@ -638,7 +638,7 @@ TEXT runtime·socket(SB),$0-20
 	RET
 
 // psu: not tested
-TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0-72
 	MOVD	attr+0(FP), R3
 	MOVD	pid+8(FP), R4
 	MOVD	cpu+16(FP), R5
@@ -660,7 +660,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·ioctl(SB),NOSPLIT,$0
+TEXT runtime·ioctl(SB),NOSPLIT,$0-40
 	MOVW	fd+0(FP), R3
 	MOVD	req+8(FP), R4
 	MOVD	arg+16(FP), R5
@@ -680,7 +680,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl(SB),NOSPLIT,$0
+TEXT runtime·fcntl(SB),NOSPLIT,$0-40
 	MOVW	fd+0(FP), R3
 	MOVD	cmd+8(FP), R4
 	MOVD	arg+16(FP), R5
@@ -700,7 +700,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl2(SB),NOSPLIT,$0
+TEXT runtime·fcntl2(SB),NOSPLIT,$0-40
 	MOVW	fd+0(FP), R3
 	MOVD	cmd+8(FP), R4
 	MOVD	arg+16(FP), R5
diff --git a/src/runtime/sys_linux_s390x.s b/src/runtime/sys_linux_s390x.s
index 0c8e95da6a..3c85b3cd9e 100644
--- a/src/runtime/sys_linux_s390x.s
+++ b/src/runtime/sys_linux_s390x.s
@@ -468,7 +468,7 @@ TEXT runtime·socket(SB),$0-20
 	RET
 
 // psu: not tested
-TEXT runtime·perfEventOpen(SB),NOSPLIT,$0
+TEXT runtime·perfEventOpen(SB),NOSPLIT,$0-72
 	MOVD	attr+0(FP), R2
 	MOVD	pid+8(FP), R3
 	MOVD	cpu+16(FP), R4
@@ -491,7 +491,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·ioctl(SB),NOSPLIT,$0
+TEXT runtime·ioctl(SB),NOSPLIT,$0-40
 	MOVW	fd+0(FP), R2
 	MOVD	req+8(FP), R3
 	MOVD	arg+16(FP), R4
@@ -512,7 +512,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl(SB),NOSPLIT,$0
+TEXT runtime·fcntl(SB),NOSPLIT,$0-40
 	MOVW	fd+0(FP), R2
 	MOVD	cmd+8(FP), R3
 	MOVD	arg+16(FP), R4
@@ -533,7 +533,7 @@ ok:
 	RET
 
 // psu: not tested
-TEXT runtime·fcntl2(SB),NOSPLIT,$0
+TEXT runtime·fcntl2(SB),NOSPLIT,$0-40
 	MOVW	fd+0(FP), R2
 	MOVD	cmd+8(FP), R3
 	MOVD	arg+16(FP), R4

From 82040ab9b2c1f3ef218299959d8ddb60644883bc Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 14 Jul 2019 21:20:21 -0700
Subject: [PATCH 064/126] removal

---
 src/runtime/defs_pmu_linux.go | 12 ------------
 1 file changed, 12 deletions(-)
 delete mode 100644 src/runtime/defs_pmu_linux.go

diff --git a/src/runtime/defs_pmu_linux.go b/src/runtime/defs_pmu_linux.go
deleted file mode 100644
index 53e9de244a..0000000000
--- a/src/runtime/defs_pmu_linux.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package runtime
-
-var perfEventOpt = []struct {
-	Type    uint32 // type of event
-	Config  uint64 // event 
-} {
-	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},	      // index: GO_COUNT_HW_CPU_CYCLES
-	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},     // index: GO_COUNT_HW_INSTRUCTIONS
-	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_REFERENCES}, // index: GO_COUNT_HW_CACHE_REFERENCES
-	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_MISSES},     // index: GO_COUNT_HW_CACHE_MISSES
-	// TODO: add more perf events
-}

From 87dbdacd1d5c00c3f1de28393c7715855e8483e0 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 14 Jul 2019 21:23:06 -0700
Subject: [PATCH 065/126] delete redundant code

---
 src/runtime/defs_linux_386.go     | 22 --------------------
 src/runtime/defs_linux_amd64.go   | 22 --------------------
 src/runtime/defs_linux_arm.go     | 22 --------------------
 src/runtime/defs_linux_arm64.go   | 22 --------------------
 src/runtime/defs_linux_mips64x.go | 22 --------------------
 src/runtime/defs_linux_mipsx.go   | 22 --------------------
 src/runtime/defs_linux_ppc64.go   | 22 --------------------
 src/runtime/defs_linux_ppc64le.go | 22 --------------------
 src/runtime/defs_linux_s390x.go   | 22 --------------------
 src/runtime/defs_perf_linux.go    | 34 +++++++++++++++++++++++++++++++
 10 files changed, 34 insertions(+), 198 deletions(-)
 create mode 100644 src/runtime/defs_perf_linux.go

diff --git a/src/runtime/defs_linux_386.go b/src/runtime/defs_linux_386.go
index f03fcb8bce..f9d3808636 100644
--- a/src/runtime/defs_linux_386.go
+++ b/src/runtime/defs_linux_386.go
@@ -355,28 +355,6 @@ type sockaddr_un struct {
 	path   [108]byte
 }
 
-type perfEventAttr struct {
-	Type               uint32
-	Size               uint32
-	Config             uint64
-	Sample             uint64
-	Sample_type        uint64
-	Read_format        uint64
-	Bits               uint64
-	Wakeup             uint32
-	Bp_type            uint32
-	Ext1               uint64
-	Ext2               uint64
-	Branch_sample_type uint64
-	Sample_regs_user   uint64
-	Sample_stack_user  uint32
-	Clockid            int32
-	Sample_regs_intr   uint64
-	Aux_watermark      uint32
-	Sample_max_stack   uint16
-	_                  uint16
-}
-
 // psu: only tested on amd64 
 type fOwnerEx struct {
 	Type int32
diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 888f7363a0..0ba2bf1c01 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -390,28 +390,6 @@ type sockaddr_un struct {
 	path   [108]byte
 }
 
-type perfEventAttr struct {
-	Type               uint32
-	Size               uint32
-	Config             uint64
-	Sample             uint64
-	Sample_type        uint64
-	Read_format        uint64
-	Bits               uint64
-	Wakeup             uint32
-	Bp_type            uint32
-	Ext1               uint64
-	Ext2               uint64
-	Branch_sample_type uint64
-	Sample_regs_user   uint64
-	Sample_stack_user  uint32
-	Clockid            int32
-	Sample_regs_intr   uint64
-	Aux_watermark      uint32
-	Sample_max_stack   uint16
-	_                  uint16
-}
-
 type fOwnerEx struct {
 	Type int32
 	Pid  int32
diff --git a/src/runtime/defs_linux_arm.go b/src/runtime/defs_linux_arm.go
index e6e3327cf0..dfbf75c3b4 100644
--- a/src/runtime/defs_linux_arm.go
+++ b/src/runtime/defs_linux_arm.go
@@ -309,28 +309,6 @@ type sockaddr_un struct {
 	path   [108]byte
 }
 
-type perfEventAttr struct {
-	Type               uint32
-	Size               uint32
-	Config             uint64
-	Sample             uint64
-	Sample_type        uint64
-	Read_format        uint64
-	Bits               uint64
-	Wakeup             uint32
-	Bp_type            uint32
-	Ext1               uint64
-	Ext2               uint64
-	Branch_sample_type uint64
-	Sample_regs_user   uint64
-	Sample_stack_user  uint32
-	Clockid            int32
-	Sample_regs_intr   uint64
-	Aux_watermark      uint32
-	Sample_max_stack   uint16
-	_                  uint16
-}
-
 // psu: only tested on amd64 
 type fOwnerEx struct {
 	Type int32
diff --git a/src/runtime/defs_linux_arm64.go b/src/runtime/defs_linux_arm64.go
index a39d5b6699..2861279eb7 100644
--- a/src/runtime/defs_linux_arm64.go
+++ b/src/runtime/defs_linux_arm64.go
@@ -314,28 +314,6 @@ type ucontext struct {
 	uc_mcontext sigcontext
 }
 
-type perfEventAttr struct {
-	Type               uint32
-	Size               uint32
-	Config             uint64
-	Sample             uint64
-	Sample_type        uint64
-	Read_format        uint64
-	Bits               uint64
-	Wakeup             uint32
-	Bp_type            uint32
-	Ext1               uint64
-	Ext2               uint64
-	Branch_sample_type uint64
-	Sample_regs_user   uint64
-	Sample_stack_user  uint32
-	Clockid            int32
-	Sample_regs_intr   uint64
-	Aux_watermark      uint32
-	Sample_max_stack   uint16
-	_                  uint16
-}
-
 // psu: only test it on amd64 
 type fOwnerEx struct {
 	Type int32
diff --git a/src/runtime/defs_linux_mips64x.go b/src/runtime/defs_linux_mips64x.go
index d2b21cd997..15d0a251dc 100644
--- a/src/runtime/defs_linux_mips64x.go
+++ b/src/runtime/defs_linux_mips64x.go
@@ -310,28 +310,6 @@ type ucontext struct {
 	uc_sigmask  uint64
 }
 
-type perfEventAttr struct {
-	Type               uint32
-	Size               uint32
-	Config             uint64
-	Sample             uint64
-	Sample_type        uint64
-	Read_format        uint64
-	Bits               uint64
-	Wakeup             uint32
-	Bp_type            uint32
-	Ext1               uint64
-	Ext2               uint64
-	Branch_sample_type uint64
-	Sample_regs_user   uint64
-	Sample_stack_user  uint32
-	Clockid            int32
-	Sample_regs_intr   uint64
-	Aux_watermark      uint32
-	Sample_max_stack   uint16
-	_                  uint16
-}
-
 // psu: only test it on amd64 
 type fOwnerEx struct {
 	Type int32
diff --git a/src/runtime/defs_linux_mipsx.go b/src/runtime/defs_linux_mipsx.go
index 2bffac0c9a..68bab01e00 100644
--- a/src/runtime/defs_linux_mipsx.go
+++ b/src/runtime/defs_linux_mipsx.go
@@ -312,28 +312,6 @@ type ucontext struct {
 	uc_sigmask  [4]uint32
 }
 
-type perfEventAttr struct {
-	Type               uint32
-	Size               uint32
-	Config             uint64
-	Sample             uint64
-	Sample_type        uint64
-	Read_format        uint64
-	Bits               uint64
-	Wakeup             uint32
-	Bp_type            uint32
-	Ext1               uint64
-	Ext2               uint64
-	Branch_sample_type uint64
-	Sample_regs_user   uint64
-	Sample_stack_user  uint32
-	Clockid            int32
-	Sample_regs_intr   uint64
-	Aux_watermark      uint32
-	Sample_max_stack   uint16
-	_                  uint16
-}
-
 // psu: only test it on amd64 
 type fOwnerEx struct {
 	Type int32
diff --git a/src/runtime/defs_linux_ppc64.go b/src/runtime/defs_linux_ppc64.go
index 15867d6795..ef7f654e22 100644
--- a/src/runtime/defs_linux_ppc64.go
+++ b/src/runtime/defs_linux_ppc64.go
@@ -327,28 +327,6 @@ type ucontext struct {
 	uc_mcontext sigcontext
 }
 
-type perfEventAttr struct {
-	Type               uint32
-	Size               uint32
-	Config             uint64
-	Sample             uint64
-	Sample_type        uint64
-	Read_format        uint64
-	Bits               uint64
-	Wakeup             uint32
-	Bp_type            uint32
-	Ext1               uint64
-	Ext2               uint64
-	Branch_sample_type uint64
-	Sample_regs_user   uint64
-	Sample_stack_user  uint32
-	Clockid            int32
-	Sample_regs_intr   uint64
-	Aux_watermark      uint32
-	Sample_max_stack   uint16
-	_                  uint16
-}
-
 // psu: only test it on amd64 
 type fOwnerEx struct {
 	Type int32
diff --git a/src/runtime/defs_linux_ppc64le.go b/src/runtime/defs_linux_ppc64le.go
index 5e51f2398d..8cd3624ebc 100644
--- a/src/runtime/defs_linux_ppc64le.go
+++ b/src/runtime/defs_linux_ppc64le.go
@@ -327,28 +327,6 @@ type ucontext struct {
 	uc_mcontext sigcontext
 }
 
-type perfEventAttr struct {
-	Type               uint32
-	Size               uint32
-	Config             uint64
-	Sample             uint64
-	Sample_type        uint64
-	Read_format        uint64
-	Bits               uint64
-	Wakeup             uint32
-	Bp_type            uint32
-	Ext1               uint64
-	Ext2               uint64
-	Branch_sample_type uint64
-	Sample_regs_user   uint64
-	Sample_stack_user  uint32
-	Clockid            int32
-	Sample_regs_intr   uint64
-	Aux_watermark      uint32
-	Sample_max_stack   uint16
-	_                  uint16
-}
-
 // psu: only test it on amd64 
 type fOwnerEx struct {
 	Type int32
diff --git a/src/runtime/defs_linux_s390x.go b/src/runtime/defs_linux_s390x.go
index 0f3b134341..e679758ba9 100644
--- a/src/runtime/defs_linux_s390x.go
+++ b/src/runtime/defs_linux_s390x.go
@@ -294,28 +294,6 @@ type ucontext struct {
 	uc_sigmask  uint64
 }
 
-type perfEventAttr struct {
-	Type               uint32
-	Size               uint32
-	Config             uint64
-	Sample             uint64
-	Sample_type        uint64
-	Read_format        uint64
-	Bits               uint64
-	Wakeup             uint32
-	Bp_type            uint32
-	Ext1               uint64
-	Ext2               uint64
-	Branch_sample_type uint64
-	Sample_regs_user   uint64
-	Sample_stack_user  uint32
-	Clockid            int32
-	Sample_regs_intr   uint64
-	Aux_watermark      uint32
-	Sample_max_stack   uint16
-	_                  uint16
-}
-
 // psu: only test it on amd64 
 type fOwnerEx struct {
 	Type int32
diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
new file mode 100644
index 0000000000..5caef3ef10
--- /dev/null
+++ b/src/runtime/defs_perf_linux.go
@@ -0,0 +1,34 @@
+package runtime
+
+var perfEventOpt = []struct {
+	Type    uint32 // type of event
+	Config  uint64 // event 
+} {
+	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},	      // index: GO_COUNT_HW_CPU_CYCLES
+	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},     // index: GO_COUNT_HW_INSTRUCTIONS
+	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_REFERENCES}, // index: GO_COUNT_HW_CACHE_REFERENCES
+	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_MISSES},     // index: GO_COUNT_HW_CACHE_MISSES
+	// TODO: add more perf events
+}
+
+type perfEventAttr struct {
+	Type               uint32
+	Size               uint32
+	Config             uint64
+	Sample             uint64
+	Sample_type        uint64
+	Read_format        uint64
+	Bits               uint64
+	Wakeup             uint32
+	Bp_type            uint32
+	Ext1               uint64
+	Ext2               uint64
+	Branch_sample_type uint64
+	Sample_regs_user   uint64
+	Sample_stack_user  uint32
+	Clockid            int32
+	Sample_regs_intr   uint64
+	Aux_watermark      uint32
+	Sample_max_stack   uint16
+	_                  uint16
+}

From d6a1b0dcf738306ec2c129e1917d41adfb197d4d Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 15 Jul 2019 13:24:34 -0700
Subject: [PATCH 066/126] tests

---
 test/pmu/http/test2.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/test/pmu/http/test2.go b/test/pmu/http/test2.go
index 3b09b9ea1e..e2b42d820c 100644
--- a/test/pmu/http/test2.go
+++ b/test/pmu/http/test2.go
@@ -7,9 +7,8 @@ import (
 	"fmt"
 	"log"
 	"sync"
-    // "time"
-    "net/http"
-    _ "net/http/pprof"
+	"net/http"
+	_ "net/http/pprof"
 )
 
 var wg sync.WaitGroup

From 83ffbb86d3ce0c00595fe95383a33153cbf94278 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 15 Jul 2019 13:25:16 -0700
Subject: [PATCH 067/126] indention

---
 src/runtime/defs_linux_386.go     | 26 +++++++++++++-------------
 src/runtime/defs_linux_arm.go     | 28 ++++++++++++++--------------
 src/runtime/defs_linux_arm64.go   | 28 ++++++++++++++--------------
 src/runtime/defs_linux_mips64x.go | 29 ++++++++++++++---------------
 src/runtime/defs_linux_mipsx.go   | 28 ++++++++++++++--------------
 src/runtime/defs_linux_ppc64.go   | 28 ++++++++++++++--------------
 src/runtime/defs_linux_ppc64le.go | 28 ++++++++++++++--------------
 src/runtime/defs_linux_s390x.go   | 28 ++++++++++++++--------------
 src/runtime/defs_perf_linux.go    |  4 ++--
 src/runtime/pprof/pprof.go        | 26 +++++++++++++++++---------
 src/runtime/proc.go               |  7 +++----
 src/runtime/signal_unix.go        |  2 --
 src/runtime/sys_linux_386.s       |  6 +++---
 src/runtime/sys_linux_amd64.s     | 12 ++++++------
 src/runtime/sys_linux_arm.s       |  4 ++--
 src/runtime/sys_linux_arm64.s     |  2 +-
 src/runtime/sys_linux_mips64x.s   |  8 ++++----
 src/runtime/sys_linux_s390x.s     |  2 +-
 18 files changed, 150 insertions(+), 146 deletions(-)

diff --git a/src/runtime/defs_linux_386.go b/src/runtime/defs_linux_386.go
index f9d3808636..5e078b3b26 100644
--- a/src/runtime/defs_linux_386.go
+++ b/src/runtime/defs_linux_386.go
@@ -115,7 +115,7 @@ const (
 	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
 	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
 	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
-         
+
 	_PERF_COUNT_HW_CACHE_L1D  = 0x0
 	_PERF_COUNT_HW_CACHE_L1I  = 0x1
 	_PERF_COUNT_HW_CACHE_LL   = 0x2
@@ -123,14 +123,14 @@ const (
 	_PERF_COUNT_HW_CACHE_ITLB = 0x4
 	_PERF_COUNT_HW_CACHE_BPU  = 0x5
 	_PERF_COUNT_HW_CACHE_NODE = 0x6
-         
+
 	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
 	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
 	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
-         
+
 	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
 	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
-         
+
 	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
 	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
 	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
@@ -142,7 +142,7 @@ const (
 	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
 	_PERF_COUNT_SW_DUMMY            = 0x9
 	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
-         
+
 	_PERF_SAMPLE_IP           = 0x1
 	_PERF_SAMPLE_TID          = 0x2
 	_PERF_SAMPLE_TIME         = 0x4
@@ -155,7 +155,7 @@ const (
 	_PERF_SAMPLE_STREAM_ID    = 0x200
 	_PERF_SAMPLE_RAW          = 0x400
 	_PERF_SAMPLE_BRANCH_STACK = 0x800
-         
+
 	_PERF_SAMPLE_BRANCH_USER       = 0x1
 	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
 	_PERF_SAMPLE_BRANCH_HV         = 0x4
@@ -173,12 +173,12 @@ const (
 	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
 	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
 	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
-         
+
 	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
 	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
-         
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
@@ -195,20 +195,20 @@ const (
 	_PERF_RECORD_SWITCH          = 0xe
 	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
 	_PERF_RECORD_NAMESPACES      = 0x10
-         
+
 	_PERF_CONTEXT_HV     = -0x20
 	_PERF_CONTEXT_KERNEL = -0x80
 	_PERF_CONTEXT_USER   = -0x200
-         
+
 	_PERF_CONTEXT_GUEST        = -0x800
 	_PERF_CONTEXT_GUEST_KERNEL = -0x880
 	_PERF_CONTEXT_GUEST_USER   = -0xa00
-         
+
 	_PERF_FLAG_FD_NO_GROUP = 0x1
 	_PERF_FLAG_FD_OUTPUT   = 0x2
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
-         
+
 	_PERF_EVENT_IOC_DISABLE               = 0x2401
 	_PERF_EVENT_IOC_ENABLE                = 0x2400
 	_PERF_EVENT_IOC_ID                    = 0x80042407
@@ -355,7 +355,7 @@ type sockaddr_un struct {
 	path   [108]byte
 }
 
-// psu: only tested on amd64 
+// psu: only tested on amd64
 type fOwnerEx struct {
 	Type int32
 	Pid  int32
diff --git a/src/runtime/defs_linux_arm.go b/src/runtime/defs_linux_arm.go
index dfbf75c3b4..e27ce80c9a 100644
--- a/src/runtime/defs_linux_arm.go
+++ b/src/runtime/defs_linux_arm.go
@@ -97,7 +97,7 @@ const (
 	_PERF_TYPE_HW_CACHE   = 0x3
 	_PERF_TYPE_RAW        = 0x4
 	_PERF_TYPE_BREAKPOINT = 0x5
-         
+
 	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
 	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
 	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
@@ -108,7 +108,7 @@ const (
 	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
 	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
 	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
-         
+
 	_PERF_COUNT_HW_CACHE_L1D  = 0x0
 	_PERF_COUNT_HW_CACHE_L1I  = 0x1
 	_PERF_COUNT_HW_CACHE_LL   = 0x2
@@ -116,14 +116,14 @@ const (
 	_PERF_COUNT_HW_CACHE_ITLB = 0x4
 	_PERF_COUNT_HW_CACHE_BPU  = 0x5
 	_PERF_COUNT_HW_CACHE_NODE = 0x6
-         
+
 	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
 	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
 	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
-         
+
 	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
 	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
-         
+
 	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
 	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
 	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
@@ -135,7 +135,7 @@ const (
 	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
 	_PERF_COUNT_SW_DUMMY            = 0x9
 	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
-         
+
 	_PERF_SAMPLE_IP           = 0x1
 	_PERF_SAMPLE_TID          = 0x2
 	_PERF_SAMPLE_TIME         = 0x4
@@ -148,7 +148,7 @@ const (
 	_PERF_SAMPLE_STREAM_ID    = 0x200
 	_PERF_SAMPLE_RAW          = 0x400
 	_PERF_SAMPLE_BRANCH_STACK = 0x800
-         
+
 	_PERF_SAMPLE_BRANCH_USER       = 0x1
 	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
 	_PERF_SAMPLE_BRANCH_HV         = 0x4
@@ -166,12 +166,12 @@ const (
 	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
 	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
 	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
-         
+
 	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
 	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
-         
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
@@ -188,20 +188,20 @@ const (
 	_PERF_RECORD_SWITCH          = 0xe
 	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
 	_PERF_RECORD_NAMESPACES      = 0x10
-         
+
 	_PERF_CONTEXT_HV     = -0x20
 	_PERF_CONTEXT_KERNEL = -0x80
 	_PERF_CONTEXT_USER   = -0x200
-         
+
 	_PERF_CONTEXT_GUEST        = -0x800
 	_PERF_CONTEXT_GUEST_KERNEL = -0x880
 	_PERF_CONTEXT_GUEST_USER   = -0xa00
-         
+
 	_PERF_FLAG_FD_NO_GROUP = 0x1
 	_PERF_FLAG_FD_OUTPUT   = 0x2
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
-         
+
 	_PERF_EVENT_IOC_DISABLE               = 0x2401
 	_PERF_EVENT_IOC_ENABLE                = 0x2400
 	_PERF_EVENT_IOC_ID                    = 0x80042407
@@ -309,7 +309,7 @@ type sockaddr_un struct {
 	path   [108]byte
 }
 
-// psu: only tested on amd64 
+// psu: only tested on amd64
 type fOwnerEx struct {
 	Type int32
 	Pid  int32
diff --git a/src/runtime/defs_linux_arm64.go b/src/runtime/defs_linux_arm64.go
index 2861279eb7..ba754fa6a5 100644
--- a/src/runtime/defs_linux_arm64.go
+++ b/src/runtime/defs_linux_arm64.go
@@ -101,7 +101,7 @@ const (
 	_PERF_TYPE_HW_CACHE   = 0x3
 	_PERF_TYPE_RAW        = 0x4
 	_PERF_TYPE_BREAKPOINT = 0x5
-         
+
 	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
 	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
 	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
@@ -112,7 +112,7 @@ const (
 	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
 	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
 	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
-         
+
 	_PERF_COUNT_HW_CACHE_L1D  = 0x0
 	_PERF_COUNT_HW_CACHE_L1I  = 0x1
 	_PERF_COUNT_HW_CACHE_LL   = 0x2
@@ -120,14 +120,14 @@ const (
 	_PERF_COUNT_HW_CACHE_ITLB = 0x4
 	_PERF_COUNT_HW_CACHE_BPU  = 0x5
 	_PERF_COUNT_HW_CACHE_NODE = 0x6
-         
+
 	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
 	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
 	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
-         
+
 	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
 	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
-         
+
 	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
 	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
 	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
@@ -139,7 +139,7 @@ const (
 	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
 	_PERF_COUNT_SW_DUMMY            = 0x9
 	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
-         
+
 	_PERF_SAMPLE_IP           = 0x1
 	_PERF_SAMPLE_TID          = 0x2
 	_PERF_SAMPLE_TIME         = 0x4
@@ -152,7 +152,7 @@ const (
 	_PERF_SAMPLE_STREAM_ID    = 0x200
 	_PERF_SAMPLE_RAW          = 0x400
 	_PERF_SAMPLE_BRANCH_STACK = 0x800
-         
+
 	_PERF_SAMPLE_BRANCH_USER       = 0x1
 	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
 	_PERF_SAMPLE_BRANCH_HV         = 0x4
@@ -170,12 +170,12 @@ const (
 	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
 	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
 	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
-         
+
 	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
 	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
-         
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
@@ -192,20 +192,20 @@ const (
 	_PERF_RECORD_SWITCH          = 0xe
 	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
 	_PERF_RECORD_NAMESPACES      = 0x10
-         
+
 	_PERF_CONTEXT_HV     = -0x20
 	_PERF_CONTEXT_KERNEL = -0x80
 	_PERF_CONTEXT_USER   = -0x200
-         
+
 	_PERF_CONTEXT_GUEST        = -0x800
 	_PERF_CONTEXT_GUEST_KERNEL = -0x880
 	_PERF_CONTEXT_GUEST_USER   = -0xa00
-         
+
 	_PERF_FLAG_FD_NO_GROUP = 0x1
 	_PERF_FLAG_FD_OUTPUT   = 0x2
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
-         
+
 	_PERF_EVENT_IOC_DISABLE               = 0x2401
 	_PERF_EVENT_IOC_ENABLE                = 0x2400
 	_PERF_EVENT_IOC_ID                    = 0x80082407
@@ -314,7 +314,7 @@ type ucontext struct {
 	uc_mcontext sigcontext
 }
 
-// psu: only test it on amd64 
+// psu: only tested on amd64
 type fOwnerEx struct {
 	Type int32
 	Pid  int32
diff --git a/src/runtime/defs_linux_mips64x.go b/src/runtime/defs_linux_mips64x.go
index 15d0a251dc..da591ad867 100644
--- a/src/runtime/defs_linux_mips64x.go
+++ b/src/runtime/defs_linux_mips64x.go
@@ -96,7 +96,7 @@ const (
 	_PERF_TYPE_HW_CACHE   = 0x3
 	_PERF_TYPE_RAW        = 0x4
 	_PERF_TYPE_BREAKPOINT = 0x5
-         
+
 	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
 	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
 	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
@@ -107,7 +107,7 @@ const (
 	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
 	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
 	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
-         
+
 	_PERF_COUNT_HW_CACHE_L1D  = 0x0
 	_PERF_COUNT_HW_CACHE_L1I  = 0x1
 	_PERF_COUNT_HW_CACHE_LL   = 0x2
@@ -115,14 +115,14 @@ const (
 	_PERF_COUNT_HW_CACHE_ITLB = 0x4
 	_PERF_COUNT_HW_CACHE_BPU  = 0x5
 	_PERF_COUNT_HW_CACHE_NODE = 0x6
-         
+
 	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
 	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
 	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
-         
+
 	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
 	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
-         
+
 	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
 	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
 	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
@@ -134,7 +134,7 @@ const (
 	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
 	_PERF_COUNT_SW_DUMMY            = 0x9
 	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
-         
+
 	_PERF_SAMPLE_IP           = 0x1
 	_PERF_SAMPLE_TID          = 0x2
 	_PERF_SAMPLE_TIME         = 0x4
@@ -147,7 +147,7 @@ const (
 	_PERF_SAMPLE_STREAM_ID    = 0x200
 	_PERF_SAMPLE_RAW          = 0x400
 	_PERF_SAMPLE_BRANCH_STACK = 0x800
-         
+
 	_PERF_SAMPLE_BRANCH_USER       = 0x1
 	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
 	_PERF_SAMPLE_BRANCH_HV         = 0x4
@@ -165,12 +165,12 @@ const (
 	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
 	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
 	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
-         
+
 	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
 	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
-         
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
@@ -187,20 +187,20 @@ const (
 	_PERF_RECORD_SWITCH          = 0xe
 	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
 	_PERF_RECORD_NAMESPACES      = 0x10
-         
+
 	_PERF_CONTEXT_HV     = -0x20
 	_PERF_CONTEXT_KERNEL = -0x80
 	_PERF_CONTEXT_USER   = -0x200
-         
+
 	_PERF_CONTEXT_GUEST        = -0x800
 	_PERF_CONTEXT_GUEST_KERNEL = -0x880
 	_PERF_CONTEXT_GUEST_USER   = -0xa00
-         
+
 	_PERF_FLAG_FD_NO_GROUP = 0x1
 	_PERF_FLAG_FD_OUTPUT   = 0x2
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
-         
+
 	_PERF_EVENT_IOC_DISABLE               = 0x20002401
 	_PERF_EVENT_IOC_ENABLE                = 0x20002400
 	_PERF_EVENT_IOC_ID                    = 0x40082407
@@ -310,9 +310,8 @@ type ucontext struct {
 	uc_sigmask  uint64
 }
 
-// psu: only test it on amd64 
+// psu: only tested on amd64
 type fOwnerEx struct {
 	Type int32
 	Pid  int32
 }
-
diff --git a/src/runtime/defs_linux_mipsx.go b/src/runtime/defs_linux_mipsx.go
index 68bab01e00..957d57ba36 100644
--- a/src/runtime/defs_linux_mipsx.go
+++ b/src/runtime/defs_linux_mipsx.go
@@ -100,7 +100,7 @@ const (
 	_PERF_TYPE_HW_CACHE   = 0x3
 	_PERF_TYPE_RAW        = 0x4
 	_PERF_TYPE_BREAKPOINT = 0x5
-         
+
 	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
 	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
 	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
@@ -111,7 +111,7 @@ const (
 	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
 	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
 	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
-         
+
 	_PERF_COUNT_HW_CACHE_L1D  = 0x0
 	_PERF_COUNT_HW_CACHE_L1I  = 0x1
 	_PERF_COUNT_HW_CACHE_LL   = 0x2
@@ -119,14 +119,14 @@ const (
 	_PERF_COUNT_HW_CACHE_ITLB = 0x4
 	_PERF_COUNT_HW_CACHE_BPU  = 0x5
 	_PERF_COUNT_HW_CACHE_NODE = 0x6
-         
+
 	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
 	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
 	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
-         
+
 	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
 	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
-         
+
 	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
 	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
 	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
@@ -138,7 +138,7 @@ const (
 	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
 	_PERF_COUNT_SW_DUMMY            = 0x9
 	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
-         
+
 	_PERF_SAMPLE_IP           = 0x1
 	_PERF_SAMPLE_TID          = 0x2
 	_PERF_SAMPLE_TIME         = 0x4
@@ -151,7 +151,7 @@ const (
 	_PERF_SAMPLE_STREAM_ID    = 0x200
 	_PERF_SAMPLE_RAW          = 0x400
 	_PERF_SAMPLE_BRANCH_STACK = 0x800
-         
+
 	_PERF_SAMPLE_BRANCH_USER       = 0x1
 	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
 	_PERF_SAMPLE_BRANCH_HV         = 0x4
@@ -169,12 +169,12 @@ const (
 	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
 	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
 	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
-         
+
 	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
 	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
-         
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
@@ -191,20 +191,20 @@ const (
 	_PERF_RECORD_SWITCH          = 0xe
 	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
 	_PERF_RECORD_NAMESPACES      = 0x10
-         
+
 	_PERF_CONTEXT_HV     = -0x20
 	_PERF_CONTEXT_KERNEL = -0x80
 	_PERF_CONTEXT_USER   = -0x200
-         
+
 	_PERF_CONTEXT_GUEST        = -0x800
 	_PERF_CONTEXT_GUEST_KERNEL = -0x880
 	_PERF_CONTEXT_GUEST_USER   = -0xa00
-         
+
 	_PERF_FLAG_FD_NO_GROUP = 0x1
 	_PERF_FLAG_FD_OUTPUT   = 0x2
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
-         
+
 	_PERF_EVENT_IOC_DISABLE               = 0x20002401
 	_PERF_EVENT_IOC_ENABLE                = 0x20002400
 	_PERF_EVENT_IOC_ID                    = 0x40042407
@@ -312,7 +312,7 @@ type ucontext struct {
 	uc_sigmask  [4]uint32
 }
 
-// psu: only test it on amd64 
+// psu: only tested on amd64
 type fOwnerEx struct {
 	Type int32
 	Pid  int32
diff --git a/src/runtime/defs_linux_ppc64.go b/src/runtime/defs_linux_ppc64.go
index ef7f654e22..3810ccb0b3 100644
--- a/src/runtime/defs_linux_ppc64.go
+++ b/src/runtime/defs_linux_ppc64.go
@@ -96,7 +96,7 @@ const (
 	_PERF_TYPE_HW_CACHE   = 0x3
 	_PERF_TYPE_RAW        = 0x4
 	_PERF_TYPE_BREAKPOINT = 0x5
-         
+
 	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
 	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
 	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
@@ -107,7 +107,7 @@ const (
 	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
 	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
 	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
-         
+
 	_PERF_COUNT_HW_CACHE_L1D  = 0x0
 	_PERF_COUNT_HW_CACHE_L1I  = 0x1
 	_PERF_COUNT_HW_CACHE_LL   = 0x2
@@ -115,14 +115,14 @@ const (
 	_PERF_COUNT_HW_CACHE_ITLB = 0x4
 	_PERF_COUNT_HW_CACHE_BPU  = 0x5
 	_PERF_COUNT_HW_CACHE_NODE = 0x6
-         
+
 	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
 	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
 	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
-         
+
 	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
 	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
-         
+
 	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
 	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
 	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
@@ -134,7 +134,7 @@ const (
 	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
 	_PERF_COUNT_SW_DUMMY            = 0x9
 	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
-         
+
 	_PERF_SAMPLE_IP           = 0x1
 	_PERF_SAMPLE_TID          = 0x2
 	_PERF_SAMPLE_TIME         = 0x4
@@ -147,7 +147,7 @@ const (
 	_PERF_SAMPLE_STREAM_ID    = 0x200
 	_PERF_SAMPLE_RAW          = 0x400
 	_PERF_SAMPLE_BRANCH_STACK = 0x800
-         
+
 	_PERF_SAMPLE_BRANCH_USER       = 0x1
 	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
 	_PERF_SAMPLE_BRANCH_HV         = 0x4
@@ -165,12 +165,12 @@ const (
 	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
 	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
 	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
-         
+
 	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
 	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
-         
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
@@ -187,20 +187,20 @@ const (
 	_PERF_RECORD_SWITCH          = 0xe
 	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
 	_PERF_RECORD_NAMESPACES      = 0x10
-         
+
 	_PERF_CONTEXT_HV     = -0x20
 	_PERF_CONTEXT_KERNEL = -0x80
 	_PERF_CONTEXT_USER   = -0x200
-         
+
 	_PERF_CONTEXT_GUEST        = -0x800
 	_PERF_CONTEXT_GUEST_KERNEL = -0x880
 	_PERF_CONTEXT_GUEST_USER   = -0xa00
-         
+
 	_PERF_FLAG_FD_NO_GROUP = 0x1
 	_PERF_FLAG_FD_OUTPUT   = 0x2
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
-         
+
 	_PERF_EVENT_IOC_DISABLE               = 0x2401
 	_PERF_EVENT_IOC_ENABLE                = 0x2400
 	_PERF_EVENT_IOC_ID                    = 0x80082407
@@ -327,7 +327,7 @@ type ucontext struct {
 	uc_mcontext sigcontext
 }
 
-// psu: only test it on amd64 
+// psu: only tested on amd64
 type fOwnerEx struct {
 	Type int32
 	Pid  int32
diff --git a/src/runtime/defs_linux_ppc64le.go b/src/runtime/defs_linux_ppc64le.go
index 8cd3624ebc..adf6111eae 100644
--- a/src/runtime/defs_linux_ppc64le.go
+++ b/src/runtime/defs_linux_ppc64le.go
@@ -96,7 +96,7 @@ const (
 	_PERF_TYPE_HW_CACHE   = 0x3
 	_PERF_TYPE_RAW        = 0x4
 	_PERF_TYPE_BREAKPOINT = 0x5
-         
+
 	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
 	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
 	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
@@ -107,7 +107,7 @@ const (
 	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
 	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
 	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
-         
+
 	_PERF_COUNT_HW_CACHE_L1D  = 0x0
 	_PERF_COUNT_HW_CACHE_L1I  = 0x1
 	_PERF_COUNT_HW_CACHE_LL   = 0x2
@@ -115,14 +115,14 @@ const (
 	_PERF_COUNT_HW_CACHE_ITLB = 0x4
 	_PERF_COUNT_HW_CACHE_BPU  = 0x5
 	_PERF_COUNT_HW_CACHE_NODE = 0x6
-         
+
 	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
 	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
 	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
-         
+
 	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
 	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
-         
+
 	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
 	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
 	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
@@ -134,7 +134,7 @@ const (
 	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
 	_PERF_COUNT_SW_DUMMY            = 0x9
 	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
-         
+
 	_PERF_SAMPLE_IP           = 0x1
 	_PERF_SAMPLE_TID          = 0x2
 	_PERF_SAMPLE_TIME         = 0x4
@@ -147,7 +147,7 @@ const (
 	_PERF_SAMPLE_STREAM_ID    = 0x200
 	_PERF_SAMPLE_RAW          = 0x400
 	_PERF_SAMPLE_BRANCH_STACK = 0x800
-         
+
 	_PERF_SAMPLE_BRANCH_USER       = 0x1
 	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
 	_PERF_SAMPLE_BRANCH_HV         = 0x4
@@ -165,12 +165,12 @@ const (
 	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
 	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
 	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
-         
+
 	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
 	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
-         
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
@@ -187,20 +187,20 @@ const (
 	_PERF_RECORD_SWITCH          = 0xe
 	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
 	_PERF_RECORD_NAMESPACES      = 0x10
-         
+
 	_PERF_CONTEXT_HV     = -0x20
 	_PERF_CONTEXT_KERNEL = -0x80
 	_PERF_CONTEXT_USER   = -0x200
-         
+
 	_PERF_CONTEXT_GUEST        = -0x800
 	_PERF_CONTEXT_GUEST_KERNEL = -0x880
 	_PERF_CONTEXT_GUEST_USER   = -0xa00
-         
+
 	_PERF_FLAG_FD_NO_GROUP = 0x1
 	_PERF_FLAG_FD_OUTPUT   = 0x2
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
-	 
+
 	_PERF_EVENT_IOC_DISABLE               = 0x20002401
 	_PERF_EVENT_IOC_ENABLE                = 0x20002400
 	_PERF_EVENT_IOC_ID                    = 0x40082407
@@ -327,7 +327,7 @@ type ucontext struct {
 	uc_mcontext sigcontext
 }
 
-// psu: only test it on amd64 
+// psu: only tested on amd64
 type fOwnerEx struct {
 	Type int32
 	Pid  int32
diff --git a/src/runtime/defs_linux_s390x.go b/src/runtime/defs_linux_s390x.go
index e679758ba9..b93148ff65 100644
--- a/src/runtime/defs_linux_s390x.go
+++ b/src/runtime/defs_linux_s390x.go
@@ -97,7 +97,7 @@ const (
 	_PERF_TYPE_HW_CACHE   = 0x3
 	_PERF_TYPE_RAW        = 0x4
 	_PERF_TYPE_BREAKPOINT = 0x5
-         
+
 	_PERF_COUNT_HW_CPU_CYCLES              = 0x0
 	_PERF_COUNT_HW_INSTRUCTIONS            = 0x1
 	_PERF_COUNT_HW_CACHE_REFERENCES        = 0x2
@@ -108,7 +108,7 @@ const (
 	_PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
 	_PERF_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
 	_PERF_COUNT_HW_REF_CPU_CYCLES          = 0x9
-         
+
 	_PERF_COUNT_HW_CACHE_L1D  = 0x0
 	_PERF_COUNT_HW_CACHE_L1I  = 0x1
 	_PERF_COUNT_HW_CACHE_LL   = 0x2
@@ -116,14 +116,14 @@ const (
 	_PERF_COUNT_HW_CACHE_ITLB = 0x4
 	_PERF_COUNT_HW_CACHE_BPU  = 0x5
 	_PERF_COUNT_HW_CACHE_NODE = 0x6
-         
+
 	_PERF_COUNT_HW_CACHE_OP_READ     = 0x0
 	_PERF_COUNT_HW_CACHE_OP_WRITE    = 0x1
 	_PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
-         
+
 	_PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
 	_PERF_COUNT_HW_CACHE_RESULT_MISS   = 0x1
-         
+
 	_PERF_COUNT_SW_CPU_CLOCK        = 0x0
 	_PERF_COUNT_SW_TASK_CLOCK       = 0x1
 	_PERF_COUNT_SW_PAGE_FAULTS      = 0x2
@@ -135,7 +135,7 @@ const (
 	_PERF_COUNT_SW_EMULATION_FAULTS = 0x8
 	_PERF_COUNT_SW_DUMMY            = 0x9
 	_PERF_COUNT_SW_BPF_OUTPUT       = 0xa
-         
+
 	_PERF_SAMPLE_IP           = 0x1
 	_PERF_SAMPLE_TID          = 0x2
 	_PERF_SAMPLE_TIME         = 0x4
@@ -148,7 +148,7 @@ const (
 	_PERF_SAMPLE_STREAM_ID    = 0x200
 	_PERF_SAMPLE_RAW          = 0x400
 	_PERF_SAMPLE_BRANCH_STACK = 0x800
-         
+
 	_PERF_SAMPLE_BRANCH_USER       = 0x1
 	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
 	_PERF_SAMPLE_BRANCH_HV         = 0x4
@@ -166,12 +166,12 @@ const (
 	_PERF_SAMPLE_BRANCH_NO_FLAGS   = 0x4000
 	_PERF_SAMPLE_BRANCH_NO_CYCLES  = 0x8000
 	_PERF_SAMPLE_BRANCH_TYPE_SAVE  = 0x10000
-         
+
 	_PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
 	_PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
-         
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
@@ -188,20 +188,20 @@ const (
 	_PERF_RECORD_SWITCH          = 0xe
 	_PERF_RECORD_SWITCH_CPU_WIDE = 0xf
 	_PERF_RECORD_NAMESPACES      = 0x10
-         
+
 	_PERF_CONTEXT_HV     = -0x20
 	_PERF_CONTEXT_KERNEL = -0x80
 	_PERF_CONTEXT_USER   = -0x200
-         
+
 	_PERF_CONTEXT_GUEST        = -0x800
 	_PERF_CONTEXT_GUEST_KERNEL = -0x880
 	_PERF_CONTEXT_GUEST_USER   = -0xa00
-         
+
 	_PERF_FLAG_FD_NO_GROUP = 0x1
 	_PERF_FLAG_FD_OUTPUT   = 0x2
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
-         
+
 	_PERF_EVENT_IOC_DISABLE               = 0x2401
 	_PERF_EVENT_IOC_ENABLE                = 0x2400
 	_PERF_EVENT_IOC_ID                    = 0x80082407
@@ -294,7 +294,7 @@ type ucontext struct {
 	uc_sigmask  uint64
 }
 
-// psu: only test it on amd64 
+// psu: only tested on amd64
 type fOwnerEx struct {
 	Type int32
 	Pid  int32
diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index 5caef3ef10..b2f3c775e9 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -2,9 +2,9 @@ package runtime
 
 var perfEventOpt = []struct {
 	Type    uint32 // type of event
-	Config  uint64 // event 
+	Config  uint64 // event
 } {
-	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},	      // index: GO_COUNT_HW_CPU_CYCLES
+	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},	// index: GO_COUNT_HW_CPU_CYCLES
 	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},     // index: GO_COUNT_HW_INSTRUCTIONS
 	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_REFERENCES}, // index: GO_COUNT_HW_CACHE_REFERENCES
 	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_MISSES},     // index: GO_COUNT_HW_CACHE_MISSES
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 46facfb32f..033cc3e1a1 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -740,6 +740,13 @@ var cpu struct {
 // for syscall.SIGPROF, but note that doing so may break any profiling
 // being done by the main program.
 func StartCPUProfile(w io.Writer, profileHz ...int) error {
+	pmu.Lock()
+	if pmu.profiling {
+		pmu.Unlock()
+		return errors.New("Please disable pmu profiling before enabling cpu profiling")
+	}
+	pmu.Unlock()
+
 	// The runtime routines allow a variable profiling rate,
 	// but in practice operating systems cannot trigger signals
 	// at more than about 500 Hz, and our processing of the
@@ -760,9 +767,6 @@ func StartCPUProfile(w io.Writer, profileHz ...int) error {
 		cpu.done = make(chan bool)
 	}
 	// Double-check.
-	if pmu.profiling {
-		return errors.New("Please enable either cpu or pmu profiling instead of both")
-	}
 	if cpu.profiling {
 		return fmt.Errorf("cpu profiling already in use")
 	}
@@ -781,17 +785,21 @@ var pmu struct {
 }
 
 func StartPMUProfile(opts ...ProfilingOption) error {
-	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" /* TODO GOOS is not linux amd64 */ {
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
 		return errors.New("not implemented")
 	}
 
+	cpu.Lock()
+	if cpu.profiling {
+		cpu.Unlock()
+		return errors.New("Please disable cpu profiling before enabling pmu profiling")
+	}
+	cpu.Unlock()
+
 	pmu.Lock()
 	defer pmu.Unlock()
 	pmu.wg.Add(len(opts))
 	// Double-check.
-	if cpu.profiling {
-		return errors.New("Please enable either cpu or pmu profiling instead of both")
-	}
 	if pmu.profiling {
 		return errors.New("pmu profiling already in use")
 	}
@@ -920,7 +928,7 @@ func profileWriter(w io.Writer) {
 	if err != nil {
 		// The runtime should never produce an invalid or truncated profile.
 		// It drops records that can't fit into its log buffers.
-		 panic("runtime/pprof: converting profile: " + err.Error())
+		panic("runtime/pprof: converting profile: " + err.Error())
 	}
 	b.build()
 	cpu.done <- true
@@ -972,7 +980,7 @@ func StopPMUProfile() {
 
 	for i := 0; i < maxPMUEvent; i++ {
 		if pmu.eventOn[i] {
-		runtime.SetPMUProfile(i, nil)
+			runtime.SetPMUProfile(i, nil)
 		}
 	}
 	pmu.wg.Wait()
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index eba7a6cee1..ed7da9fe30 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3714,7 +3714,7 @@ func stackUnwinding(pc, sp, lr uintptr, gp *g, mp *m, stk []uintptr) int {
 	if gp == nil || sp < gp.stack.lo || gp.stack.hi < sp || setsSP(pc) || (mp != nil && mp.vdsoSP != 0) {
 		traceback = false
 	}
-    n := 0
+	n := 0
 	if mp.ncgo > 0 && mp.curg != nil && mp.curg.syscallpc != 0 && mp.curg.syscallsp != 0 {
 		cgoOff := 0
 		// Check cgoCallersUse to make sure that we are not
@@ -3768,8 +3768,7 @@ func stackUnwinding(pc, sp, lr uintptr, gp *g, mp *m, stk []uintptr) int {
 			}
 		}
 	}
-
-    return n
+	return n
 }
 
 // Counts SIGPROFs received while in atomic64 critical section, on mips{,le}
@@ -3818,7 +3817,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 
 var lostPMUAtomic64Count[maxPMUEvent] uint64
 
-// Called if we receive a SIGPROF  signal and PMU is enabled.
+// Called if we receive a SIGPROF signal and PMU is enabled.
 // Called by the signal handler, may run during STW.
 //go:nowritebarrierrec
 func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 5a618483e8..335b06a185 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -44,8 +44,6 @@ const (
 	_PMU_INSTALLED	  = 2
 )
 
-var sigState uint32
-
 // Stores the signal handlers registered before Go installed its own.
 // These signal handlers will be invoked in cases where Go doesn't want to
 // handle a particular signal (e.g., signal occurred on a non-Go thread).
diff --git a/src/runtime/sys_linux_386.s b/src/runtime/sys_linux_386.s
index c9d10cdaad..5b5e85c067 100644
--- a/src/runtime/sys_linux_386.s
+++ b/src/runtime/sys_linux_386.s
@@ -766,7 +766,7 @@ TEXT runtime·ioctl(SB),NOSPLIT,$0-20
 	MOVL	req+4(FP), CX
 	MOVL	arg+8(FP), DX
 	MOVL    $0, SI
-        MOVL    $0, DI
+	MOVL    $0, DI
 	MOVL	$SYS_ioctl, AX
 	INVOKE_SYSCALL
 	CMPL	AX, $0xfffff001
@@ -786,7 +786,7 @@ TEXT runtime·fcntl(SB),NOSPLIT,$0-20
 	MOVL	cmd+4(FP), CX
 	MOVL	arg+8(FP), DX
 	MOVL    $0, SI
-        MOVL    $0, DI
+	MOVL    $0, DI
 	MOVL	$SYS_fcntl, AX
 	INVOKE_SYSCALL
 	CMPL	AX, $0xfffff001
@@ -806,7 +806,7 @@ TEXT runtime·fcntl2(SB),NOSPLIT,$0-20
 	MOVL	cmd+4(FP), CX
 	MOVL	arg+8(FP), DX
 	MOVL    $0, SI
-        MOVL    $0, DI
+	MOVL    $0, DI
 	MOVL	$SYS_fcntl, AX
 	INVOKE_SYSCALL
 	CMPL	AX, $0xfffff001
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 6a2aa60867..40a2bd1f7f 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -753,8 +753,8 @@ TEXT runtime·ioctl(SB),NOSPLIT,$0-40
 	MOVQ	req+8(FP), SI
 	MOVQ	arg+16(FP), DX
 	MOVQ    $0, R10
-        MOVQ    $0, R8
-        MOVQ    $0, R9
+	MOVQ    $0, R8
+	MOVQ    $0, R9
 	MOVQ	$SYS_ioctl, AX
 	SYSCALL
 	CMPQ    AX, $0xfffffffffffff001
@@ -773,8 +773,8 @@ TEXT runtime·fcntl(SB),NOSPLIT,$0-40
 	MOVQ	cmd+8(FP), SI
 	MOVQ	arg+16(FP), DX
 	MOVQ    $0, R10
-        MOVQ    $0, R8
-        MOVQ    $0, R9
+	MOVQ    $0, R8
+	MOVQ    $0, R9
 	MOVQ	$SYS_fcntl, AX
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
@@ -793,8 +793,8 @@ TEXT runtime·fcntl2(SB),NOSPLIT,$0-40
 	MOVQ	cmd+8(FP), SI
 	MOVQ	arg+16(FP), DX
 	MOVQ    $0, R10
-        MOVQ    $0, R8
-        MOVQ    $0, R9
+	MOVQ    $0, R8
+	MOVQ    $0, R9
 	MOVQ	$SYS_fcntl, AX
 	SYSCALL
 	CMPQ	AX, $0xfffffffffffff001
diff --git a/src/runtime/sys_linux_arm.s b/src/runtime/sys_linux_arm.s
index a1fea01cd5..72cbfd2030 100644
--- a/src/runtime/sys_linux_arm.s
+++ b/src/runtime/sys_linux_arm.s
@@ -622,7 +622,7 @@ TEXT runtime·perfEventOpen(SB),NOSPLIT,$0-36
 	MOVW	dummy+20(FP), R5
 	MOVW	$SYS_perf_event_open, R7
 	SWI     $0
-	MOVW    $0xfffff001, R6 
+	MOVW    $0xfffff001, R6
 	CMP     R6, R0
 	BLS     ok
 	MOVW	$-1, R1
@@ -630,7 +630,7 @@ TEXT runtime·perfEventOpen(SB),NOSPLIT,$0-36
 	MOVW    $0, R2
 	MOVW	R2, r2+28(FP)
 	RSB     $0, R0, R0
-        MOVW    R0, err+32(FP) 
+	MOVW    R0, err+32(FP)
 	RET
 ok:
 	MOVW	R0, r+24(FP)
diff --git a/src/runtime/sys_linux_arm64.s b/src/runtime/sys_linux_arm64.s
index 7a3672039d..2af3c8a0d1 100644
--- a/src/runtime/sys_linux_arm64.s
+++ b/src/runtime/sys_linux_arm64.s
@@ -49,7 +49,7 @@
 #define SYS_socket		198
 #define SYS_connect		203
 #define SYS_brk			214
-#define SYS_perf_event_open 	241
+#define SYS_perf_event_open	241
 
 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
 	MOVW	code+0(FP), R0
diff --git a/src/runtime/sys_linux_mips64x.s b/src/runtime/sys_linux_mips64x.s
index 245982ca9a..5bcf7b5407 100644
--- a/src/runtime/sys_linux_mips64x.s
+++ b/src/runtime/sys_linux_mips64x.s
@@ -31,7 +31,7 @@
 #define SYS_rt_sigreturn	5211
 #define SYS_rt_sigaction	5013
 #define SYS_rt_sigprocmask	5014
-#define SYS_ioctl       	5015
+#define SYS_ioctl		5015
 #define SYS_sigaltstack		5129
 #define SYS_madvise		5027
 #define SYS_mincore		5026
@@ -515,12 +515,12 @@ TEXT runtime·ioctl,NOSPLIT,$0-40
 	SYSCALL
 	BEQ	R7, ok
 	MOVV	$-1, R1
-	MOVV	R1, r+24(FP)	
+	MOVV	R1, r+24(FP)
 	MOVV	R2, err+32(FP)	
 	RET
 ok:
-	MOVV	R2, r+24(FP)	
-	MOVV	R0, err+32(FP)	
+	MOVV	R2, r+24(FP)
+	MOVV	R0, err+32(FP)
 	RET
 
 // psu: not tested
diff --git a/src/runtime/sys_linux_s390x.s b/src/runtime/sys_linux_s390x.s
index 3c85b3cd9e..4f75286ba5 100644
--- a/src/runtime/sys_linux_s390x.s
+++ b/src/runtime/sys_linux_s390x.s
@@ -41,7 +41,7 @@
 #define SYS_epoll_wait          251
 #define SYS_clock_gettime       260
 #define SYS_epoll_create1       327
-#define SYS_perf_event_open 	331
+#define SYS_perf_event_open	331
 
 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
 	MOVW	code+0(FP), R2

From 9b86a34af7a88b7832a7cb5dbd4fa830020b9ab8 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 15 Jul 2019 20:05:17 -0700
Subject: [PATCH 068/126] refactoring

---
 src/net/http/pprof/pprof.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index 6b74d51344..e58f82568c 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -133,13 +133,13 @@ func pmuProfile(w http.ResponseWriter, r *http.Request) error {
 
 	switch eventName := r.FormValue("event"); eventName {
 		case "cycles":
-			err = pprof.StartPMUProfile(pprof.WithProfilingCycle(w, &eventConfig))
+			err = pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
 		case "instructions":
-			err = pprof.StartPMUProfile(pprof.WithProfilingInstr(w, &eventConfig))
+			err = pprof.StartPMUProfile(pprof.WithProfilingPMUInstructions(w, &eventConfig))
 		case "cacheReferences":
-			err = pprof.StartPMUProfile(pprof.WithProfilingCacheRef(w, &eventConfig))
+			err = pprof.StartPMUProfile(pprof.WithProfilingPMUCacheReferences(w, &eventConfig))
 		case "cacheMisses":
-			err = pprof.StartPMUProfile(pprof.WithProfilingCacheMiss(w, &eventConfig))
+			err = pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
 		default:
 			return errors.New("unknown or not yet implemented event")
 	}

From 5130c9bef482bfbb361ec9bfb6531c24954d6ccf Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 16 Jul 2019 11:26:49 -0700
Subject: [PATCH 069/126] refactoring

---
 src/runtime/os_linux.go | 63 ++++++++++++++++++++++++++++++-----------
 1 file changed, 47 insertions(+), 16 deletions(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index c2b8208ec1..a957df0242 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -8,6 +8,7 @@ import (
 	"runtime/internal/atomic"
 	"runtime/internal/sys"
 	"unsafe"
+	// "sync/atomic"
 )
 
 type mOS struct{}
@@ -290,10 +291,12 @@ func getHugePageSize() uintptr {
 func osinit() {
 	ncpu = getproccount()
 	physHugePageSize = getHugePageSize()
-
-	register_setProcessPMUProfiler = setProcessPMUProfiler
-	register_setThreadPMUProfiler = setThreadPMUProfiler
-	register_sigpmuhandler = sigpmuhandler
+	
+	// following the same convention as other write once variables in this function and 
+	// assuming that there exists a memory fence before anybody reads these values
+	setProcessPMUProfilerFptr = setProcessPMUProfiler
+	setThreadPMUProfilerFptr = setThreadPMUProfiler
+	sigprofPMUHandlerFptr = sigprofPMUHandler
 }
 
 var urandom_dev = []byte("/dev/urandom\x00")
@@ -471,7 +474,7 @@ func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
 				if racyUpdatedVal != _UNINSTALLED {
 					panic("never reach here since pprof should have protected us")
 				} else {
-					println("sombody else did the job for us")
+					// Sombody else did the job for us
 				}
 			}
 		}
@@ -481,6 +484,9 @@ func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
 		if !sigInstallGoHandler(_SIGPROF) {
 			if atomic.Cas(&handlingSig[_SIGPROF], _PMU_INSTALLED, _UNINSTALLED) {
 				setsig(_SIGPROF, atomic.Loaduintptr(&fwdSig[_SIGPROF]))
+			} else {
+				// Some other thread already replaced _PMU_INSTALLED with some other value.
+				// Ideally this should not happen in correctly written user code.
 			}
 		}
 	}
@@ -513,13 +519,36 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			perfAttr.Bits += 0b1000000
 		}
 
-		fd, _, _ := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy */ 0)
-		_g_.m.eventFds[eventId] = fd
-		r, _ := fcntl(fd, /* F_GETFL */ 0x3, 0)
-		fcntl(fd, /* F_SETFL */ 0x4, r | /* O_ASYNC */ 0x2000)
-		fcntl(fd, /* F_SETSIG */ 0xa, _SIGPROF)
+		fd, _, err := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy */ 0)
+		if err != 0 {
+			println("Linux perf event open failed")
+			return
+		}
+
+		flag, _ := fcntl(fd, /* F_GETFL */ 0x3, 0)
+		_, err = fcntl(fd, /* F_SETFL */ 0x4, flag | /* O_ASYNC */ 0x2000)
+		if err != 0 {
+			println("Failed to set notification for the PMU event")
+			closefd(fd)
+			return
+		}
+
+		_, err = fcntl(fd, /* F_SETSIG */ 0xa, _SIGPROF)
+		if err != 0 {
+			println("Failed to set signal for the PMU event")
+			closefd(fd)
+			return
+		}
+
 		fOwnEx := fOwnerEx{/* F_OWNER_TID */ 0, int32(gettid())}
-		fcntl2(fd, /* F_SETOWN_EX */ 0xf, &fOwnEx)
+		_, err = fcntl2(fd, /* F_SETOWN_EX */ 0xf, &fOwnEx)
+		if err != 0 {
+			println("Failed to set the owner of the perf event file")
+			closefd(fd)
+			return
+		}
+
+		_g_.m.eventFds[eventId] = fd
 	}
 
 	_g_.m.eventAttrs[eventId] = eventAttr
@@ -528,21 +557,23 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 func ioctl(fd int32, req, arg int) (r, err int)
 
 //go:nowritebarrierrec
-func sigpmuhandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
+func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 	fd := info.si_fd
-	ioctl(fd, _PERF_EVENT_IOC_DISABLE, 0)
+	ioctl(fd, _PERF_EVENT_IOC_DISABLE, 0) // we don't care about failing ioctl
 
 	var eventId int = -1
-	for i := 0; i < maxPMUEvent; i++ {
+	for i := 0; i < MaxPMUEvent; i++ {
 		if _g_.m.eventFds[i] == fd {
 			eventId = i
 			break
 		}
 	}
 	if eventId != -1 {
-		sigpmu(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
+		sigprofPMU(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
+	} else {
+		println("should never reach here")
 	}
 
-	ioctl(fd, _PERF_EVENT_IOC_ENABLE, 0)
+	ioctl(fd, _PERF_EVENT_IOC_ENABLE, 0) // we don't care about failing ioctl
 	return
 }

From 938c5f2f9798179ed1bf1f72192efa3410314572 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 16 Jul 2019 13:40:02 -0700
Subject: [PATCH 070/126] refactoring

---
 src/runtime/cpuprof.go           | 19 ++++----
 src/runtime/os_linux.go          | 23 +++-------
 src/runtime/pprof/pprof.go       | 77 +++++++++++++++-----------------
 src/runtime/proc.go              | 54 +++++++++++-----------
 src/runtime/runtime2.go          |  6 +--
 src/runtime/signal_sighandler.go |  8 ++--
 src/runtime/signal_unix.go       | 23 ++++------
 7 files changed, 97 insertions(+), 113 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index 86dffdf779..dfa8c830a0 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -19,7 +19,8 @@ import (
 )
 
 const maxCPUProfStack = 64
-const maxPMUEvent  = 10
+// MaxPMUEvent is a small number and cannot be >= 10 because we do a linear search on it
+const MaxPMUEvent = 10
 
 type profile struct {
 	lock mutex
@@ -43,7 +44,7 @@ type profile struct {
 }
 
 var cpuprof profile
-var pmuprof [maxPMUEvent]profile
+var pmuprof [MaxPMUEvent]profile
 
 // SetCPUProfileRate sets the CPU profiling rate to hz samples per second.
 // If hz <= 0, SetCPUProfileRate turns off profiling.
@@ -105,7 +106,7 @@ func SetPMUProfile(eventId int, eventAttr *PMUEventAttr) {
 }
 
 //go:nowritebarrierrec
-func (p *profile) addImpl(gp *g, stk []uintptr, prof *profile) {
+func (p *profile) addImpl(gp *g, stk []uintptr, cpuorpmuprof *profile) {
 	if p.numExtra > 0 || p.lostExtra > 0 {
 		p.addExtra()
 	}
@@ -114,7 +115,7 @@ func (p *profile) addImpl(gp *g, stk []uintptr, prof *profile) {
 	// because otherwise its write barrier behavior may not
 	// be correct. See the long comment there before
 	// changing the argument here.
-	prof.log.write(&gp.labels, nanotime(), hdr[:], stk)
+	cpuorpmuprof.log.write(&gp.labels, nanotime(), hdr[:], stk)
 }
 
 // add adds the stack trace to the profile.
@@ -125,13 +126,13 @@ func (p *profile) addImpl(gp *g, stk []uintptr, prof *profile) {
 //go:nowritebarrierrec
 func (p *profile) add(gp *g, stk []uintptr, eventIds ...int) {
 	if len(eventIds) == 0 {
-		for !atomic.Cas(&itimer.signalLock, 0, 1) {
+		for !atomic.Cas(&prof.signalLock, 0, 1) {
 			osyield()
 		}
-		if itimer.hz != 0 { // implies cpuprof.log != nil
+		if prof.hz != 0 { // implies cpuprof.log != nil
 			p.addImpl(gp, stk, &cpuprof)
 		}
-		atomic.Store(&itimer.signalLock, 0)
+		atomic.Store(&prof.signalLock, 0)
 	} else {
 		eventId := eventIds[0]
 		for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
@@ -172,11 +173,11 @@ func (p *profile) addNonGo(stk []uintptr, eventIds ...int) {
 		// (Other calls to add or addNonGo should be blocked out
 		// by the fact that only one SIGPROF can be handled by the
 		// process at a time. If not, this lock will serialize those too.)
-		for !atomic.Cas(&itimer.signalLock, 0, 1) {
+		for !atomic.Cas(&prof.signalLock, 0, 1) {
 			osyield()
 		}
 		p.addNonGoImpl(stk, &cpuprof)
-		atomic.Store(&itimer.signalLock, 0)
+		atomic.Store(&prof.signalLock, 0)
 	} else {
 		eventId := eventIds[0]
 		// Only one SIGPROF for each PMU event can be handled by the process at a time.
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index a957df0242..49dca654c4 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -463,30 +463,19 @@ func rt_sigaction(sig uintptr, new, old *sigactiont, size uintptr) int32
 
 func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
 	if eventAttr != nil {
-		oldVal := atomic.Load(&handlingSig[_SIGPROF])
-		if oldVal != _PMU_INSTALLED {
-			// Enable the Go signal handler if not enabled.
-			if atomic.Cas(&handlingSig[_SIGPROF], oldVal, _PMU_INSTALLED) {
-				atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF))
-				setsig(_SIGPROF, funcPC(sighandler))
-			} else {
-				racyUpdatedVal := atomic.Load(&handlingSig[_SIGPROF])
-				if racyUpdatedVal != _UNINSTALLED {
-					panic("never reach here since pprof should have protected us")
-				} else {
-					// Sombody else did the job for us
-				}
-			}
+		atomic.Cas(&cpuorpmuprofiler, _UNINSTALLED, _PMU_INSTALLED)
+		// Enable the Go signal handler if not enabled.
+		if atomic.Cas(&handlingSig[_SIGPROF], _UNINSTALLED, _PMU_INSTALLED) {
+			atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF))
+			setsig(_SIGPROF, funcPC(sighandler))
 		}
 	} else {
+		atomic.Cas(&cpuorpmuprofiler, _PMU_INSTALLED, _UNINSTALLED)
 		// If the Go signal handler should be disabled by default,
 		// disable it if it is enabled.
 		if !sigInstallGoHandler(_SIGPROF) {
 			if atomic.Cas(&handlingSig[_SIGPROF], _PMU_INSTALLED, _UNINSTALLED) {
 				setsig(_SIGPROF, atomic.Loaduintptr(&fwdSig[_SIGPROF]))
-			} else {
-				// Some other thread already replaced _PMU_INSTALLED with some other value.
-				// Ideally this should not happen in correctly written user code.
 			}
 		}
 	}
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 033cc3e1a1..5c2f82e1ec 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -722,11 +722,17 @@ type runtimeProfile []runtime.StackRecord
 func (p runtimeProfile) Len() int              { return len(p) }
 func (p runtimeProfile) Stack(i int) []uintptr { return p[i].Stack() }
 
+var mux sync.Mutex
+
 var cpu struct {
-	sync.Mutex
 	profiling bool
 	done      chan bool
 }
+var pmu struct {
+	profiling bool
+	eventOn   [runtime.MaxPMUEvent]bool
+	wg        sync.WaitGroup
+}
 
 // StartCPUProfile enables CPU profiling for the current process.
 // While profiling, the profile will be buffered and written to w.
@@ -740,12 +746,12 @@ var cpu struct {
 // for syscall.SIGPROF, but note that doing so may break any profiling
 // being done by the main program.
 func StartCPUProfile(w io.Writer, profileHz ...int) error {
-	pmu.Lock()
+	mux.Lock()
+	defer mux.Unlock()
+
 	if pmu.profiling {
-		pmu.Unlock()
 		return errors.New("Please disable pmu profiling before enabling cpu profiling")
 	}
-	pmu.Unlock()
 
 	// The runtime routines allow a variable profiling rate,
 	// but in practice operating systems cannot trigger signals
@@ -761,8 +767,6 @@ func StartCPUProfile(w io.Writer, profileHz ...int) error {
 		hz = profileHz[0]
 	}
 
-	cpu.Lock()
-	defer cpu.Unlock()
 	if cpu.done == nil {
 		cpu.done = make(chan bool)
 	}
@@ -776,28 +780,17 @@ func StartCPUProfile(w io.Writer, profileHz ...int) error {
 	return nil
 	}
 
-const maxPMUEvent = 10
-var pmu struct {
-	sync.Mutex
-	profiling bool
-	eventOn   [maxPMUEvent]bool
-	wg        sync.WaitGroup
-}
-
 func StartPMUProfile(opts ...ProfilingOption) error {
-	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" { // enabling only on Linux AMD64
 		return errors.New("not implemented")
 	}
+	mux.Lock()
+	defer mux.Unlock()
 
-	cpu.Lock()
 	if cpu.profiling {
-		cpu.Unlock()
 		return errors.New("Please disable cpu profiling before enabling pmu profiling")
 	}
-	cpu.Unlock()
 
-	pmu.Lock()
-	defer pmu.Unlock()
 	pmu.wg.Add(len(opts))
 	// Double-check.
 	if pmu.profiling {
@@ -831,7 +824,7 @@ func getPreciseIP(preciseIP int8) uint8 {
 	return uint8(preciseIP)
 }
 
-func helper(w io.Writer, eventConfig *PMUEventConfig, eventId int, eventName string) {
+func populatePMUProfiler(w io.Writer, eventConfig *PMUEventConfig, eventId int, eventName string) {
         pmu.eventOn[eventId] = true
         eventAttr := runtime.PMUEventAttr{
 		Period: uint64(eventConfig.Period),
@@ -843,56 +836,60 @@ func helper(w io.Writer, eventConfig *PMUEventConfig, eventId int, eventName str
         go pmuProfileWriter(w, eventId, eventName)
 }
 
-func WithProfilingCycle(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
+func WithProfilingPMUCycles(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if eventConfig.Period <= 0 {
 			return errors.New("Period should be > 0")
 		}
+		// TODO: create a table of standard clamp values
 		// Clamp period to something reasonable
-		if eventConfig.Period < 300 {
-			eventConfig.Period = 300
+		if eventConfig.Period < 1000 {
+			eventConfig.Period = 1000
 		}
 
-		helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CPU_CYCLES, /* event name */ "cycles")
+		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CPU_CYCLES, /* event name */ "cycles")
 		return nil
 	})
 }
 
-func WithProfilingInstr(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
+func WithProfilingPMUInstructions(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if eventConfig.Period <= 0 {
 			return errors.New("Period should be > 0")
 		}
+		// TODO: create a table of standard clamp values
 		// Clamp period to something reasonable
-		if eventConfig.Period < 300 {
-			eventConfig.Period = 300
+		if eventConfig.Period < 1000 {
+			eventConfig.Period = 1000
 		}
 
-		helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_INSTRUCTIONS, /* event name */ "instructions")
+		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_INSTRUCTIONS, /* event name */ "instructions")
 			return nil
 	})
 }
 
-func WithProfilingCacheRef(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
+func WithProfilingPMUCacheReferences(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if eventConfig.Period <= 0 {
 			return errors.New("Period should be > 0")
 		}
-		// TODO: Clamp period to something reasonable
+		// TODO: create a table of standard clamp values
+		// TODO: clamp period to something reasonable
 
-		helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_REFERENCES, /* event name */ "cache references")
+		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_REFERENCES, /* event name */ "cache references")
 		return nil
 	})
 }
 
-func WithProfilingCacheMiss(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
+func WithProfilingPMUCacheMisses(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if eventConfig.Period <= 0 {
 			return errors.New("Period should be > 0")
 		}
-		// TODO: Clamp period to something reasonable
+		// TODO: create a table of standard clamp values
+		// TODO: clamp period to something reasonable
 
-		helper(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_MISSES, /* event name */ "cache misses")
+		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_MISSES, /* event name */ "cache misses")
 		return nil
 	})
 }
@@ -958,8 +955,8 @@ func pmuProfileWriter(w io.Writer, eventId int, eventName string) {
 // StopCPUProfile only returns after all the writes for the
 // profile have completed.
 func StopCPUProfile() {
-	cpu.Lock()
-	defer cpu.Unlock()
+	mux.Lock()
+	defer mux.Unlock()
 
 	if !cpu.profiling {
 		return
@@ -970,15 +967,15 @@ func StopCPUProfile() {
 }
 
 func StopPMUProfile() {
-	pmu.Lock()
-	defer pmu.Unlock()
+	mux.Lock()
+	defer mux.Unlock()
 
 	if !pmu.profiling {
 		return
 	}
 	pmu.profiling = false
 
-	for i := 0; i < maxPMUEvent; i++ {
+	for i := 0; i < runtime.MaxPMUEvent; i++ {
 		if pmu.eventOn[i] {
 			runtime.SetPMUProfile(i, nil)
 		}
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index ed7da9fe30..546f55db64 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2125,8 +2125,8 @@ func gcstopm() {
 	stopm()
 }
 
-var register_setProcessPMUProfiler func(eventAttr *PMUEventAttr)
-var register_setThreadPMUProfiler func(eventId int32, eventAttr *PMUEventAttr)
+var setProcessPMUProfilerFptr func(eventAttr *PMUEventAttr)
+var setThreadPMUProfilerFptr func(eventId int32, eventAttr *PMUEventAttr)
 
 // Schedules gp to run on the current M.
 // If inheritTime is true, gp inherits the remaining time in the
@@ -2156,11 +2156,11 @@ func execute(gp *g, inheritTime bool) {
 		setThreadCPUProfiler(hz)
 	}
 
-	if register_setThreadPMUProfiler != nil {
+	if setThreadPMUProfilerFptr != nil {
 		eventAttrs := sched.eventAttrs
-		for eventId := 0; eventId < maxPMUEvent; eventId++ {
+		for eventId := 0; eventId < MaxPMUEvent; eventId++ {
 			if _g_.m.eventAttrs[eventId] != eventAttrs[eventId] {
-				register_setThreadPMUProfiler(int32(eventId), eventAttrs[eventId])
+				setThreadPMUProfilerFptr(int32(eventId), eventAttrs[eventId])
 			}
 		}
 	}
@@ -3627,12 +3627,12 @@ func mcount() int32 {
 	return int32(sched.mnext - sched.nmfreed)
 }
 
-var itimer struct {
+var prof struct {
 	signalLock uint32
 	hz         int32
 }
 
-var pmuEvent [maxPMUEvent]struct {
+var pmuEvent [MaxPMUEvent]struct {
 	signalLock uint32
 	eventAttr  *PMUEventAttr
 }
@@ -3774,11 +3774,11 @@ func stackUnwinding(pc, sp, lr uintptr, gp *g, mp *m, stk []uintptr) int {
 // Counts SIGPROFs received while in atomic64 critical section, on mips{,le}
 var lostAtomic64Count uint64
 
-// Called if we receive a SIGPROF signal and itimer is enabled.
+// Called if we receive a SIGPROF signal and prof is enabled.
 // Called by the signal handler, may run during STW.
 //go:nowritebarrierrec
 func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
-	if itimer.hz == 0 {
+	if prof.hz == 0 {
 		return
 	}
 	// On mips{,le}, 64bit atomics are emulated with spinlocks, in
@@ -3805,7 +3805,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 	getg().m.mallocing++
 	stk := make([]uintptr, maxCPUProfStack)
 	n := stackUnwinding(pc, sp, lr, gp, mp, stk)
-	if itimer.hz != 0 {
+	if prof.hz != 0 {
 		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostAtomic64Count > 0 {
 			cpuprof.addLostAtomic64(lostAtomic64Count)
 			lostAtomic64Count = 0
@@ -3815,12 +3815,12 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 	getg().m.mallocing--
 }
 
-var lostPMUAtomic64Count[maxPMUEvent] uint64
+var lostPMUAtomic64Count[MaxPMUEvent] uint64
 
 // Called if we receive a SIGPROF signal and PMU is enabled.
 // Called by the signal handler, may run during STW.
 //go:nowritebarrierrec
-func sigpmu(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
+func sigprofPMU(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
 	if pmuEvent[eventId].eventAttr == nil {
 		return
 	}
@@ -3859,7 +3859,7 @@ var sigprofCallersUse uint32
 //go:nosplit
 //go:nowritebarrierrec
 func sigprofNonGo() {
-	if itimer.hz != 0 {
+	if prof.hz != 0 {
 		n := 0
 		for n < len(sigprofCallers) && sigprofCallers[n] != 0 {
 			n++
@@ -3872,7 +3872,7 @@ func sigprofNonGo() {
 
 //go:nosplit
 //go:nowritebarrierrec
-func sigpmuNonGo(eventId int) {
+func sigprofPMUNonGo(eventId int) {
 	if pmuEvent[eventId].eventAttr != nil {
 		n := 0
 		for n < len(sigprofCallers) && sigprofCallers[n] != 0 {
@@ -3890,7 +3890,7 @@ func sigpmuNonGo(eventId int) {
 //go:nosplit
 //go:nowritebarrierrec
 func sigprofNonGoPC(pc uintptr) {
-	if itimer.hz != 0 {
+	if prof.hz != 0 {
 		stk := []uintptr{
 			pc,
 			funcPC(_ExternalCode) + sys.PCQuantum,
@@ -3901,7 +3901,7 @@ func sigprofNonGoPC(pc uintptr) {
 
 //go:nosplit
 //go:nowritebarrierrec
-func sigpmuNonGoPC(pc uintptr, eventId int) {
+func sigprofPMUNonGoPC(pc uintptr, eventId int) {
 	if pmuEvent[eventId].eventAttr != nil {
 		stk := []uintptr{
 			pc,
@@ -3948,19 +3948,19 @@ func setcpuprofilerate(hz int32) {
 	_g_ := getg()
 	_g_.m.locks++
 
-	// Stop profiler on this thread so that it is safe to lock itimer.
+	// Stop profiler on this thread so that it is safe to lock prof.
 	// if a profiling signal came in while we had prof locked,
 	// it would deadlock.
 	setThreadCPUProfiler(0)
 
-	for !atomic.Cas(&itimer.signalLock, 0, 1) {
+	for !atomic.Cas(&prof.signalLock, 0, 1) {
 		osyield()
 	}
-	if itimer.hz != hz {
+	if prof.hz != hz {
 		setProcessCPUProfiler(hz)
-		itimer.hz = hz
+		prof.hz = hz
 	}
-	atomic.Store(&itimer.signalLock, 0)
+	atomic.Store(&prof.signalLock, 0)
 
 	lock(&sched.lock)
 	sched.profilehz = hz
@@ -3974,7 +3974,9 @@ func setcpuprofilerate(hz int32) {
 }
 
 func setpmuprofile(eventId int32, eventAttr *PMUEventAttr) {
-	if  register_setProcessPMUProfiler == nil || register_setThreadPMUProfiler == nil {
+	// setProcessPMUProfilerFptr and setProcessPMUProfilerFptr are write once variables. 
+	// Hence, there cannot be any race from checking non-nil to invoking them.
+	if  setProcessPMUProfilerFptr == nil || setThreadPMUProfilerFptr == nil {
 		return
 	}
 
@@ -3986,23 +3988,23 @@ func setpmuprofile(eventId int32, eventAttr *PMUEventAttr) {
 	// Stop profiler on this thread so that it is safe to lock pmuEvent[eventId].
 	// if a profiling signal came in while we had pmuEvent[eventId] locked,
 	// it would deadlock.
-	register_setThreadPMUProfiler(eventId, nil)
+	setThreadPMUProfilerFptr(eventId, nil)
 
 	for !atomic.Cas(&pmuEvent[eventId].signalLock, 0, 1) {
 		osyield()
 	}
 	if pmuEvent[eventId].eventAttr != eventAttr {
-		register_setProcessPMUProfiler(eventAttr)
+		setProcessPMUProfilerFptr(eventAttr)
 		pmuEvent[eventId].eventAttr = eventAttr
 	}
 	atomic.Store(&pmuEvent[eventId].signalLock, 0)
 
-	lock(&sched.lock)
+	lock(&sched.lock) // don't know why we lock scheduler, simply following the code pattern in prof
 	sched.eventAttrs[eventId] = eventAttr
 	unlock(&sched.lock)
 
 	if eventAttr != nil {
-		register_setThreadPMUProfiler(eventId, eventAttr)
+		setThreadPMUProfilerFptr(eventId, eventAttr)
 	}
 
 	_g_.m.locks--
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 7d6d5b2824..7670ba8733 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -473,8 +473,8 @@ type m struct {
 	locks         int32
 	dying         int32
 	profilehz     int32
-	eventFds      [maxPMUEvent]int32
-	eventAttrs    [maxPMUEvent]*PMUEventAttr
+	eventFds      [MaxPMUEvent]int32
+	eventAttrs    [MaxPMUEvent]*PMUEventAttr
 	spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack
@@ -676,7 +676,7 @@ type schedt struct {
 	safePointNote note
 
 	profilehz      int32 // cpu profiling rate
-	eventAttrs     [maxPMUEvent]*PMUEventAttr
+	eventAttrs     [MaxPMUEvent]*PMUEventAttr
 	procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
 }
diff --git a/src/runtime/signal_sighandler.go b/src/runtime/signal_sighandler.go
index 7628d4575c..d9456e9ba2 100644
--- a/src/runtime/signal_sighandler.go
+++ b/src/runtime/signal_sighandler.go
@@ -20,7 +20,7 @@ var crashing int32
 // suppressed.
 var testSigtrap func(info *siginfo, ctxt *sigctxt, gp *g) bool
 
-var register_sigpmuhandler func(info *siginfo, c *sigctxt, gp *g, _g_ *g)
+var sigprofPMUHandlerFptr func(info *siginfo, c *sigctxt, gp *g, _g_ *g)
 
 // sighandler is invoked when a signal occurs. The global g will be
 // set to a gsignal goroutine and we will be running on the alternate
@@ -38,11 +38,11 @@ func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
 	c := &sigctxt{info, ctxt}
 
 	if sig == _SIGPROF {
-		state := atomic.Load(&handlingSig[_SIGPROF])
+		state := atomic.Load(&cpuorpmuprofiler)
 		if state == _ITIMER_INSTALLED {
 			sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
-		} else if state == _PMU_INSTALLED && register_sigpmuhandler != nil {
-			register_sigpmuhandler(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp, _g_)
+		} else if state == _PMU_INSTALLED {
+			sigprofPMUHandlerFptr(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp, _g_)
 		}
 		return
 	}
diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go
index 335b06a185..9e3de40954 100644
--- a/src/runtime/signal_unix.go
+++ b/src/runtime/signal_unix.go
@@ -41,7 +41,7 @@ const (
 const (
 	_UNINSTALLED      = 0
 	_ITIMER_INSTALLED = 1
-	_PMU_INSTALLED	  = 2
+	_PMU_INSTALLED    = 2
 )
 
 // Stores the signal handlers registered before Go installed its own.
@@ -235,27 +235,22 @@ func clearSignalHandlers() {
 	}
 }
 
+var cpuorpmuprofiler uint32
+
 // setProcessCPUProfiler is called when the profiling timer changes.
 // It is called with prof.lock held. hz is the new timer, and is 0 if
 // profiling is being disabled. Enable or disable the signal as
 // required for -buildmode=c-archive.
 func setProcessCPUProfiler(hz int32) {
 	if hz != 0 {
-		oldVal := atomic.Load(&handlingSig[_SIGPROF])
-		if oldVal != _ITIMER_INSTALLED {
-			if atomic.Cas(&handlingSig[_SIGPROF], oldVal, _ITIMER_INSTALLED) {
-				atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF))
-				setsig(_SIGPROF, funcPC(sighandler))
-			} else {
-				racyUpdatedVal := atomic.Load(&handlingSig[_SIGPROF])
-				if racyUpdatedVal != _UNINSTALLED {
-					panic("never reach here since pprof should have protected us")
-				} else {
-					println("sombody else did the job for us")
-				}
-			}
+		atomic.Cas(&cpuorpmuprofiler, _UNINSTALLED, _ITIMER_INSTALLED)
+		// Enable the Go signal handler if not enabled.
+		if atomic.Cas(&handlingSig[_SIGPROF], _UNINSTALLED, _ITIMER_INSTALLED) {
+			atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF))
+			setsig(_SIGPROF, funcPC(sighandler))
 		}
 	} else {
+		atomic.Cas(&cpuorpmuprofiler, _ITIMER_INSTALLED, _UNINSTALLED)
 		// If the Go signal handler should be disabled by default,
 		// disable it if it is enabled.
 		if !sigInstallGoHandler(_SIGPROF) {

From 11f08769a5b37af089b6a2368cef20f3207cdb8d Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 16 Jul 2019 19:15:15 -0700
Subject: [PATCH 071/126] fix a bug on the file desriptor leaks

---
 src/runtime/os_linux.go | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 49dca654c4..7adf83d8dc 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -495,6 +495,9 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			closefd(_g_.m.eventFds[eventId])
 		}
 	} else {
+		if _g_.m.eventAttrs[eventId] != nil {
+			closefd(_g_.m.eventFds[eventId])
+		}
 		var perfAttr perfEventAttr
 		perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
 		perfAttr.Type = perfEventOpt[eventId].Type
@@ -536,10 +539,8 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			closefd(fd)
 			return
 		}
-
 		_g_.m.eventFds[eventId] = fd
 	}
-
 	_g_.m.eventAttrs[eventId] = eventAttr
 }
 
@@ -559,8 +560,8 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 	}
 	if eventId != -1 {
 		sigprofPMU(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
-	} else {
-		println("should never reach here")
+	} else { // should never be taken
+		println("File descriptor generated by perfEventOpen() not found in _g_.m.eventFds")
 	}
 
 	ioctl(fd, _PERF_EVENT_IOC_ENABLE, 0) // we don't care about failing ioctl

From 5cd77aef167d239a3e128c0c23e5bef4f949aa06 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 16 Jul 2019 22:43:17 -0700
Subject: [PATCH 072/126] output

---
 src/runtime/pprof/pprof.go | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 5c2f82e1ec..30441411c0 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -75,7 +75,6 @@ package pprof
 import (
 	"bufio"
 	"bytes"
-	"errors"
 	"fmt"
 	"io"
 	"runtime"
@@ -750,7 +749,7 @@ func StartCPUProfile(w io.Writer, profileHz ...int) error {
 	defer mux.Unlock()
 
 	if pmu.profiling {
-		return errors.New("Please disable pmu profiling before enabling cpu profiling")
+		return fmt.Errorf("Please disable pmu profiling before enabling cpu profiling")
 	}
 
 	// The runtime routines allow a variable profiling rate,
@@ -782,19 +781,19 @@ func StartCPUProfile(w io.Writer, profileHz ...int) error {
 
 func StartPMUProfile(opts ...ProfilingOption) error {
 	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" { // enabling only on Linux AMD64
-		return errors.New("not implemented")
+		return fmt.Errorf("not implemented")
 	}
 	mux.Lock()
 	defer mux.Unlock()
 
 	if cpu.profiling {
-		return errors.New("Please disable cpu profiling before enabling pmu profiling")
+		return fmt.Errorf("Please disable cpu profiling before enabling pmu profiling")
 	}
 
 	pmu.wg.Add(len(opts))
 	// Double-check.
 	if pmu.profiling {
-		return errors.New("pmu profiling already in use")
+		return fmt.Errorf("pmu profiling already in use")
 	}
 	pmu.profiling = true
 
@@ -839,7 +838,7 @@ func populatePMUProfiler(w io.Writer, eventConfig *PMUEventConfig, eventId int,
 func WithProfilingPMUCycles(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if eventConfig.Period <= 0 {
-			return errors.New("Period should be > 0")
+			return fmt.Errorf("Period should be > 0")
 		}
 		// TODO: create a table of standard clamp values
 		// Clamp period to something reasonable
@@ -855,7 +854,7 @@ func WithProfilingPMUCycles(w io.Writer, eventConfig *PMUEventConfig) ProfilingO
 func WithProfilingPMUInstructions(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if eventConfig.Period <= 0 {
-			return errors.New("Period should be > 0")
+			return fmt.Errorf("Period should be > 0")
 		}
 		// TODO: create a table of standard clamp values
 		// Clamp period to something reasonable
@@ -871,7 +870,7 @@ func WithProfilingPMUInstructions(w io.Writer, eventConfig *PMUEventConfig) Prof
 func WithProfilingPMUCacheReferences(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if eventConfig.Period <= 0 {
-			return errors.New("Period should be > 0")
+			return fmt.Errorf("Period should be > 0")
 		}
 		// TODO: create a table of standard clamp values
 		// TODO: clamp period to something reasonable
@@ -884,7 +883,7 @@ func WithProfilingPMUCacheReferences(w io.Writer, eventConfig *PMUEventConfig) P
 func WithProfilingPMUCacheMisses(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if eventConfig.Period <= 0 {
-			return errors.New("Period should be > 0")
+			return fmt.Errorf("Period should be > 0")
 		}
 		// TODO: create a table of standard clamp values
 		// TODO: clamp period to something reasonable

From 5efcfcbc2daa7df1c987ea514f121c502dc5c07f Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 16 Jul 2019 23:43:58 -0700
Subject: [PATCH 073/126] minor

---
 src/runtime/os_linux.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 7adf83d8dc..bc77e5e7bc 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -498,6 +498,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		if _g_.m.eventAttrs[eventId] != nil {
 			closefd(_g_.m.eventFds[eventId])
 		}
+
 		var perfAttr perfEventAttr
 		perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
 		perfAttr.Type = perfEventOpt[eventId].Type
@@ -516,6 +517,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			println("Linux perf event open failed")
 			return
 		}
+		_g_.m.eventFds[eventId] = fd
 
 		flag, _ := fcntl(fd, /* F_GETFL */ 0x3, 0)
 		_, err = fcntl(fd, /* F_SETFL */ 0x4, flag | /* O_ASYNC */ 0x2000)
@@ -539,7 +541,6 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			closefd(fd)
 			return
 		}
-		_g_.m.eventFds[eventId] = fd
 	}
 	_g_.m.eventAttrs[eventId] = eventAttr
 }
@@ -561,7 +562,7 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 	if eventId != -1 {
 		sigprofPMU(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
 	} else { // should never be taken
-		println("File descriptor generated by perfEventOpen() not found in _g_.m.eventFds")
+		println("File descriptor ", fd, " not found in _g_.m.eventFds")
 	}
 
 	ioctl(fd, _PERF_EVENT_IOC_ENABLE, 0) // we don't care about failing ioctl

From 9d0af5bba27425b3992d87b67d400717b026c18b Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 16 Jul 2019 23:59:37 -0700
Subject: [PATCH 074/126] minor

---
 src/runtime/os_linux.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index bc77e5e7bc..7889fe0265 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -8,7 +8,6 @@ import (
 	"runtime/internal/atomic"
 	"runtime/internal/sys"
 	"unsafe"
-	// "sync/atomic"
 )
 
 type mOS struct{}

From 9bbe0fcb9929ed2d913c4b9553e31577308c2a96 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 17 Jul 2019 16:03:55 -0700
Subject: [PATCH 075/126] minor

---
 src/net/http/pprof/pprof.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index e58f82568c..48617ec994 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -54,7 +54,6 @@ package pprof
 import (
 	"bufio"
 	"bytes"
-	"errors"
 	"fmt"
 	"html/template"
 	"io"
@@ -141,7 +140,7 @@ func pmuProfile(w http.ResponseWriter, r *http.Request) error {
 		case "cacheMisses":
 			err = pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
 		default:
-			return errors.New("unknown or not yet implemented event")
+			return fmt.Errorf("unknown or not yet implemented event")
 	}
 
 	return err

From d330857a1ab219efd8d98c97c36b405d2fde03b3 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 17 Jul 2019 18:06:27 -0700
Subject: [PATCH 076/126] comments

---
 src/runtime/cpuprof.go | 6 ++++--
 src/runtime/profbuf.go | 3 +++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index dfa8c830a0..cdd72a1247 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -71,7 +71,8 @@ func SetCPUProfileRate(hz int) {
 		}
 
 		cpuprof.on = true
-		cpuprof.log = newProfBuf(1, 1<<17, 1<<14)
+		// Enlarging the buffer words and tags reduces the number of samples lost at the cost of larger amounts of memory 
+		cpuprof.log = newProfBuf(/* head size */ 1, /* buffer words */ 1<<17, /* tags */ 1<<14)
 		hdr := [1]uint64{uint64(hz)}
 		cpuprof.log.write(nil, nanotime(), hdr[:], nil)
 		setcpuprofilerate(int32(hz))
@@ -93,7 +94,8 @@ func SetPMUProfile(eventId int, eventAttr *PMUEventAttr) {
 		}
 
 		pmuprof[eventId].on = true
-		pmuprof[eventId].log = newProfBuf(1, 1<<17, 1<<14)
+		// Enlarging the buffer words and tags reduces the number of samples lost at the cost of larger amounts of memory 
+		pmuprof[eventId].log = newProfBuf(/* head size */ 1, /* buffer words */ 1<<17, /* tags */ 1<<14)
 		hdr := [1]uint64{eventAttr.Period}
 		pmuprof[eventId].log.write(nil, nanotime(), hdr[:], nil)
 		setpmuprofile(int32(eventId), eventAttr)
diff --git a/src/runtime/profbuf.go b/src/runtime/profbuf.go
index f40881aed5..b68e8444a0 100644
--- a/src/runtime/profbuf.go
+++ b/src/runtime/profbuf.go
@@ -253,6 +253,9 @@ func (b *profBuf) canWriteRecord(nstk int) bool {
 		// Skip over that and start over at beginning of slice.
 		nd -= len(b.data) - i
 	}
+	if nd < want {
+		println("there")
+	}
 	return nd >= want
 }
 

From f024a8f4de2a5a7779d4eecc8da0bcafbd79a9cf Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 17 Jul 2019 18:07:29 -0700
Subject: [PATCH 077/126] comments

---
 src/runtime/cpuprof.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index cdd72a1247..ff9628c5af 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -72,7 +72,7 @@ func SetCPUProfileRate(hz int) {
 
 		cpuprof.on = true
 		// Enlarging the buffer words and tags reduces the number of samples lost at the cost of larger amounts of memory 
-		cpuprof.log = newProfBuf(/* head size */ 1, /* buffer words */ 1<<17, /* tags */ 1<<14)
+		cpuprof.log = newProfBuf(/* header size */ 1, /* buffer words */ 1<<17, /* tags */ 1<<14)
 		hdr := [1]uint64{uint64(hz)}
 		cpuprof.log.write(nil, nanotime(), hdr[:], nil)
 		setcpuprofilerate(int32(hz))
@@ -95,7 +95,7 @@ func SetPMUProfile(eventId int, eventAttr *PMUEventAttr) {
 
 		pmuprof[eventId].on = true
 		// Enlarging the buffer words and tags reduces the number of samples lost at the cost of larger amounts of memory 
-		pmuprof[eventId].log = newProfBuf(/* head size */ 1, /* buffer words */ 1<<17, /* tags */ 1<<14)
+		pmuprof[eventId].log = newProfBuf(/* header size */ 1, /* buffer words */ 1<<17, /* tags */ 1<<14)
 		hdr := [1]uint64{eventAttr.Period}
 		pmuprof[eventId].log.write(nil, nanotime(), hdr[:], nil)
 		setpmuprofile(int32(eventId), eventAttr)

From a775e8c3eaa10d3ec59dfc06c06541c99e586dd6 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Wed, 17 Jul 2019 18:08:23 -0700
Subject: [PATCH 078/126] minor

---
 src/runtime/profbuf.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/runtime/profbuf.go b/src/runtime/profbuf.go
index b68e8444a0..f40881aed5 100644
--- a/src/runtime/profbuf.go
+++ b/src/runtime/profbuf.go
@@ -253,9 +253,6 @@ func (b *profBuf) canWriteRecord(nstk int) bool {
 		// Skip over that and start over at beginning of slice.
 		nd -= len(b.data) - i
 	}
-	if nd < want {
-		println("there")
-	}
 	return nd >= want
 }
 

From 4d064c142b329390725ffc55eced9e9f40b4e91e Mon Sep 17 00:00:00 2001
From: Milind Chabbi <milind@uber.com>
Date: Thu, 18 Jul 2019 10:22:31 -0700
Subject: [PATCH 079/126] Added support for raw events

---
 src/net/http/pprof/pprof.go    | 15 ++++++++++++---
 src/runtime/defs_perf_linux.go | 11 ++++++-----
 src/runtime/defs_pmu.go        |  2 ++
 src/runtime/os_linux.go        |  6 +++++-
 src/runtime/pprof/pprof.go     | 17 +++++++++++++++++
 5 files changed, 42 insertions(+), 9 deletions(-)

diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index 48617ec994..bfbd91d993 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -140,9 +140,18 @@ func pmuProfile(w http.ResponseWriter, r *http.Request) error {
 		case "cacheMisses":
 			err = pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
 		default:
-			return fmt.Errorf("unknown or not yet implemented event")
-	}
-
+			// is this a Raw event?
+			if strings.HasPrefix(eventName, "r") {
+				rawHexEvent, err := strconv.ParseUint(eventName[1:], 16, 64)
+				if err != nil {
+					return fmt.Errorf("Incorrect hex format for raw event")
+				}
+				eventConfig.RawEvent = rawHexEvent
+				err = pprof.StartPMUProfile(pprof.WithProfilingPMURaw(w, &eventConfig))
+			} else {
+				return fmt.Errorf("unknown or not yet implemented event")
+			}
+		}
 	return err
 }
 
diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index b2f3c775e9..e66b757d83 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -1,13 +1,14 @@
 package runtime
 
-var perfEventOpt = []struct {
+var perfEventOpt = map[int32]struct {
 	Type    uint32 // type of event
 	Config  uint64 // event
 } {
-	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},	// index: GO_COUNT_HW_CPU_CYCLES
-	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},     // index: GO_COUNT_HW_INSTRUCTIONS
-	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_REFERENCES}, // index: GO_COUNT_HW_CACHE_REFERENCES
-	{_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_MISSES},     // index: GO_COUNT_HW_CACHE_MISSES
+	GO_COUNT_HW_CPU_CYCLES : {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},	// index: GO_COUNT_HW_CPU_CYCLES
+	GO_COUNT_HW_INSTRUCTIONS: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},     // index: GO_COUNT_HW_INSTRUCTIONS
+	GO_COUNT_HW_CACHE_REFERENCES: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_REFERENCES}, // index: GO_COUNT_HW_CACHE_REFERENCES
+	GO_COUNT_HW_CACHE_MISSES: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_MISSES},     // index: GO_COUNT_HW_CACHE_MISSES
+	GO_COUNT_HW_RAW: {_PERF_TYPE_RAW, 0 /* will not be used*/},     // index: GO_COUNT_HW_RAW
 	// TODO: add more perf events
 }
 
diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index ee1c3b72ac..2b3d7573c4 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -31,10 +31,12 @@ const (
 	GO_COUNT_SW_TASK_CLOCK       = 0x17
 	GO_COUNT_SW_PAGE_FAULTS      = 0x18
 	GO_COUNT_SW_CONTEXT_SWITCHES = 0x19
+	GO_COUNT_HW_RAW= 0x1a
 )
 
 type PMUEventAttr struct {
 	Period           uint64
+	RawEvent         uint64
 	PreciseIP        uint8
 	IsKernelIncluded bool
 	IsHvIncluded     bool
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 7889fe0265..fb9d1c31b8 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -501,7 +501,11 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		var perfAttr perfEventAttr
 		perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
 		perfAttr.Type = perfEventOpt[eventId].Type
-		perfAttr.Config = perfEventOpt[eventId].Config
+		if (eventId == GO_COUNT_HW_RAW) {
+			perfAttr.Config = eventAttr.RawEvent
+		} else {
+			perfAttr.Config = perfEventOpt[eventId].Config
+		}
 		perfAttr.Sample = eventAttr.Period
 		perfAttr.Bits = uint64(eventAttr.PreciseIP) << 15 // precise ip
 		if !eventAttr.IsKernelIncluded { // don't count kernel
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 30441411c0..a9b43cce80 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -84,6 +84,7 @@ import (
 	"text/tabwriter"
 	"time"
 	"unsafe"
+	"strconv"
 )
 
 // BUG(rsc): Profiles are only as good as the kernel support used to generate them.
@@ -807,6 +808,7 @@ func StartPMUProfile(opts ...ProfilingOption) error {
 
 type PMUEventConfig struct {
 	Period           int64
+	RawEvent 	 uint64
 	PreciseIP        int8
 	IsKernelIncluded bool
 	IsHvIncluded     bool
@@ -827,6 +829,7 @@ func populatePMUProfiler(w io.Writer, eventConfig *PMUEventConfig, eventId int,
         pmu.eventOn[eventId] = true
         eventAttr := runtime.PMUEventAttr{
 		Period: uint64(eventConfig.Period),
+		RawEvent: uint64(eventConfig.RawEvent),
 		PreciseIP: getPreciseIP(eventConfig.PreciseIP),
 		IsKernelIncluded: eventConfig.IsKernelIncluded,
 		IsHvIncluded: eventConfig.IsHvIncluded,
@@ -893,6 +896,20 @@ func WithProfilingPMUCacheMisses(w io.Writer, eventConfig *PMUEventConfig) Profi
 	})
 }
 
+func WithProfilingPMURaw(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
+	return profilingOptionFunc(func() error {
+		if eventConfig.Period <= 0 {
+			return fmt.Errorf("Period should be > 0")
+		}
+		// TODO: create a table of standard clamp values
+		// TODO: clamp period to something reasonable
+
+		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_RAW, /* event name */ "r" + strconv.FormatUint(eventConfig.RawEvent, 16))
+		return nil
+	})
+}
+
+
 type ProfilingOption interface {
 	apply() error
 }

From f0c7da3b6903514a1e68b64c9cf91de07226c834 Mon Sep 17 00:00:00 2001
From: Milind Chabbi <milind@uber.com>
Date: Thu, 18 Jul 2019 11:14:02 -0700
Subject: [PATCH 080/126] Replaced MaxPMUEvent with GO_COUNT_PMU_EVENTS_MAX

---
 src/runtime/cpuprof.go     |  4 +---
 src/runtime/defs_pmu.go    | 29 ++---------------------------
 src/runtime/os_linux.go    |  2 +-
 src/runtime/pprof/pprof.go |  4 ++--
 src/runtime/proc.go        |  6 +++---
 src/runtime/runtime2.go    |  6 +++---
 6 files changed, 12 insertions(+), 39 deletions(-)

diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index ff9628c5af..affb650189 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -19,8 +19,6 @@ import (
 )
 
 const maxCPUProfStack = 64
-// MaxPMUEvent is a small number and cannot be >= 10 because we do a linear search on it
-const MaxPMUEvent = 10
 
 type profile struct {
 	lock mutex
@@ -44,7 +42,7 @@ type profile struct {
 }
 
 var cpuprof profile
-var pmuprof [MaxPMUEvent]profile
+var pmuprof [GO_COUNT_PMU_EVENTS_MAX]profile
 
 // SetCPUProfileRate sets the CPU profiling rate to hz samples per second.
 // If hz <= 0, SetCPUProfileRate turns off profiling.
diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index 2b3d7573c4..a13804f638 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -5,33 +5,8 @@ const (
 	GO_COUNT_HW_INSTRUCTIONS            = 0x1
 	GO_COUNT_HW_CACHE_REFERENCES        = 0x2
 	GO_COUNT_HW_CACHE_MISSES            = 0x3
-	GO_COUNT_HW_BRANCH_INSTRUCTIONS     = 0x4
-	GO_COUNT_HW_BRANCH_MISSES           = 0x5
-	GO_COUNT_HW_BUS_CYCLES              = 0x6
-	GO_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
-	GO_COUNT_HW_STALLED_CYCLES_BACKEND  = 0x8
-	GO_COUNT_HW_REF_CPU_CYCLES          = 0x9
-
-	GO_COUNT_HW_CACHE_L1D  = 0xa
-	GO_COUNT_HW_CACHE_L1I  = 0xb
-	GO_COUNT_HW_CACHE_LL   = 0xc
-	GO_COUNT_HW_CACHE_DTLB = 0xd
-	GO_COUNT_HW_CACHE_ITLB = 0xe
-	GO_COUNT_HW_CACHE_BPU  = 0xf
-	GO_COUNT_HW_CACHE_NODE = 0x10
-
-	GO_COUNT_HW_CACHE_OP_READ     = 0x11
-	GO_COUNT_HW_CACHE_OP_WRITE    = 0x12
-	GO_COUNT_HW_CACHE_OP_PREFETCH = 0x13
-
-	GO_COUNT_HW_CACHE_RESULT_ACCESS = 0x14
-	GO_COUNT_HW_CACHE_RESULT_MISS   = 0x15
-
-	GO_COUNT_SW_CPU_CLOCK        = 0x16
-	GO_COUNT_SW_TASK_CLOCK       = 0x17
-	GO_COUNT_SW_PAGE_FAULTS      = 0x18
-	GO_COUNT_SW_CONTEXT_SWITCHES = 0x19
-	GO_COUNT_HW_RAW= 0x1a
+	GO_COUNT_HW_RAW			    = 0x4
+	GO_COUNT_PMU_EVENTS_MAX 	    = 0x5
 )
 
 type PMUEventAttr struct {
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index fb9d1c31b8..fecc9febdb 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -556,7 +556,7 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 	ioctl(fd, _PERF_EVENT_IOC_DISABLE, 0) // we don't care about failing ioctl
 
 	var eventId int = -1
-	for i := 0; i < MaxPMUEvent; i++ {
+	for i := 0; i < GO_COUNT_PMU_EVENTS_MAX; i++ {
 		if _g_.m.eventFds[i] == fd {
 			eventId = i
 			break
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index a9b43cce80..ce6fa83304 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -730,7 +730,7 @@ var cpu struct {
 }
 var pmu struct {
 	profiling bool
-	eventOn   [runtime.MaxPMUEvent]bool
+	eventOn   [runtime.GO_COUNT_PMU_EVENTS_MAX]bool
 	wg        sync.WaitGroup
 }
 
@@ -991,7 +991,7 @@ func StopPMUProfile() {
 	}
 	pmu.profiling = false
 
-	for i := 0; i < runtime.MaxPMUEvent; i++ {
+	for i := 0; i < runtime.GO_COUNT_PMU_EVENTS_MAX; i++ {
 		if pmu.eventOn[i] {
 			runtime.SetPMUProfile(i, nil)
 		}
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 546f55db64..18c363f19e 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -2158,7 +2158,7 @@ func execute(gp *g, inheritTime bool) {
 
 	if setThreadPMUProfilerFptr != nil {
 		eventAttrs := sched.eventAttrs
-		for eventId := 0; eventId < MaxPMUEvent; eventId++ {
+		for eventId := 0; eventId < GO_COUNT_PMU_EVENTS_MAX; eventId++ {
 			if _g_.m.eventAttrs[eventId] != eventAttrs[eventId] {
 				setThreadPMUProfilerFptr(int32(eventId), eventAttrs[eventId])
 			}
@@ -3632,7 +3632,7 @@ var prof struct {
 	hz         int32
 }
 
-var pmuEvent [MaxPMUEvent]struct {
+var pmuEvent [GO_COUNT_PMU_EVENTS_MAX]struct {
 	signalLock uint32
 	eventAttr  *PMUEventAttr
 }
@@ -3815,7 +3815,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 	getg().m.mallocing--
 }
 
-var lostPMUAtomic64Count[MaxPMUEvent] uint64
+var lostPMUAtomic64Count[GO_COUNT_PMU_EVENTS_MAX] uint64
 
 // Called if we receive a SIGPROF signal and PMU is enabled.
 // Called by the signal handler, may run during STW.
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 7670ba8733..7dd61dfd60 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -473,8 +473,8 @@ type m struct {
 	locks         int32
 	dying         int32
 	profilehz     int32
-	eventFds      [MaxPMUEvent]int32
-	eventAttrs    [MaxPMUEvent]*PMUEventAttr
+	eventFds      [GO_COUNT_PMU_EVENTS_MAX]int32
+	eventAttrs    [GO_COUNT_PMU_EVENTS_MAX]*PMUEventAttr
 	spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack
@@ -676,7 +676,7 @@ type schedt struct {
 	safePointNote note
 
 	profilehz      int32 // cpu profiling rate
-	eventAttrs     [MaxPMUEvent]*PMUEventAttr
+	eventAttrs     [GO_COUNT_PMU_EVENTS_MAX]*PMUEventAttr
 	procresizetime int64 // nanotime() of last change to gomaxprocs
 	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
 }

From 960c83378707863122aef7665aa3fc0dbaf0436a Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 12:23:18 -0700
Subject: [PATCH 081/126] benchmark profiling with pmu

---
 src/cmd/go/internal/test/test.go      | 20 +++++++++++++++++
 src/cmd/go/internal/test/testflag.go  |  8 ++++++-
 src/runtime/cpuprof.go                |  2 +-
 src/runtime/pprof/pprof.go            |  2 +-
 src/testing/internal/testdeps/deps.go | 26 ++++++++++++++++++++++
 src/testing/testing.go                | 32 +++++++++++++++++++++++++++
 6 files changed, 87 insertions(+), 3 deletions(-)

diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 8440a83951..85ba0a1ebb 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -312,6 +312,26 @@ profile the tests during execution:
 	-cpuprofile cpu.out
 	    Write a CPU profile to the specified file before exiting.
 	    Writes test binary as -c would.
+	
+	-pmurofile pmu.out
+	    Write a PMU profile to the specified file before exiting.
+	    Writes test binary as -c would.
+	
+    	-pmuevent event
+	    Specify which pmu event to sample.
+	    To sample PMU cycles, use -test.memprofilerate=1.  
+    	
+	-pmuperiod n
+	    Set the sampling period for the pmu event specified by -pmuevent.
+	
+	-pmupreciseip n
+	    Set the precise ip level for the pmu event specified by -pmuevent.
+	
+	-pmukernelincl 
+	    Count the kernel or not.
+
+	-pmuhvincl 
+	    Count the hypervisor or not.
 
 	-memprofile mem.out
 	    Write an allocation profile to the file after all tests have passed.
diff --git a/src/cmd/go/internal/test/testflag.go b/src/cmd/go/internal/test/testflag.go
index 138e1f9d2a..7570235d44 100644
--- a/src/cmd/go/internal/test/testflag.go
+++ b/src/cmd/go/internal/test/testflag.go
@@ -46,6 +46,12 @@ var testFlagDefn = []*cmdflag.Defn{
 	{Name: "coverprofile", PassToTest: true},
 	{Name: "cpu", PassToTest: true},
 	{Name: "cpuprofile", PassToTest: true},
+	{Name: "pmuprofile", PassToTest: true},
+	{Name: "pmuevent", PassToTest: true},
+	{Name: "pmuperiod", PassToTest: true},
+	{Name: "pmupreciseip", PassToTest: true},
+	{Name: "pmukernelincl", BoolVar: new(bool), PassToTest: true},
+	{Name: "pmuhvincl", BoolVar: new(bool),PassToTest: true},
 	{Name: "failfast", BoolVar: new(bool), PassToTest: true},
 	{Name: "list", PassToTest: true},
 	{Name: "memprofile", PassToTest: true},
@@ -157,7 +163,7 @@ func testFlags(usage func(), args []string) (packageNames, passToTest []string)
 				testList = true
 			case "timeout":
 				testTimeout = value
-			case "blockprofile", "cpuprofile", "memprofile", "mutexprofile":
+			case "blockprofile", "cpuprofile", "pmuprofile", "memprofile", "mutexprofile":
 				testProfile = "-" + f.Name
 				testNeedBinary = true
 			case "trace":
diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index ff9628c5af..69aa4c639c 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -18,9 +18,9 @@ import (
 	"unsafe"
 )
 
-const maxCPUProfStack = 64
 // MaxPMUEvent is a small number and cannot be >= 10 because we do a linear search on it
 const MaxPMUEvent = 10
+const maxCPUProfStack = 64
 
 type profile struct {
 	lock mutex
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 30441411c0..6e35420c28 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -825,7 +825,7 @@ func getPreciseIP(preciseIP int8) uint8 {
 
 func populatePMUProfiler(w io.Writer, eventConfig *PMUEventConfig, eventId int, eventName string) {
         pmu.eventOn[eventId] = true
-        eventAttr := runtime.PMUEventAttr{
+        eventAttr := runtime.PMUEventAttr {
 		Period: uint64(eventConfig.Period),
 		PreciseIP: getPreciseIP(eventConfig.PreciseIP),
 		IsKernelIncluded: eventConfig.IsKernelIncluded,
diff --git a/src/testing/internal/testdeps/deps.go b/src/testing/internal/testdeps/deps.go
index 14512e9632..5669d6e65b 100644
--- a/src/testing/internal/testdeps/deps.go
+++ b/src/testing/internal/testdeps/deps.go
@@ -12,6 +12,7 @@ package testdeps
 
 import (
 	"bufio"
+	"fmt"
 	"internal/testlog"
 	"io"
 	"regexp"
@@ -46,6 +47,31 @@ func (TestDeps) StopCPUProfile() {
 	pprof.StopCPUProfile()
 }
 
+func (TestDeps) StartPMUProfile(w io.Writer, event string, period int64, preciseIP int8, isKernelIncluded bool, isHvIncluded bool) error {
+	eventConfig := pprof.PMUEventConfig {
+		Period: period,
+		PreciseIP: preciseIP,
+		IsKernelIncluded: isKernelIncluded,
+		IsHvIncluded: isHvIncluded,
+	}
+	switch event {
+		case "cycles":
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
+		case "instructions":
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUInstructions(w, &eventConfig))
+		case "cacheReferences":
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheReferences(w, &eventConfig))
+		case "cacheMisses":
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
+		default:
+			return fmt.Errorf("unknown or not yet implemented event")
+	}
+}
+
+func (TestDeps) StopPMUProfile() {
+	pprof.StopPMUProfile()
+}
+
 func (TestDeps) WriteProfileTo(name string, w io.Writer, debug int) error {
 	return pprof.Lookup(name).WriteTo(w, debug)
 }
diff --git a/src/testing/testing.go b/src/testing/testing.go
index 339df13f43..027c3ceb98 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -285,6 +285,12 @@ func Init() {
 	memProfile = flag.String("test.memprofile", "", "write an allocation profile to `file`")
 	memProfileRate = flag.Int("test.memprofilerate", 0, "set memory allocation profiling `rate` (see runtime.MemProfileRate)")
 	cpuProfile = flag.String("test.cpuprofile", "", "write a cpu profile to `file`")
+	pmuProfile = flag.String("test.pmuprofile", "", "write a pmu profile to `file`")
+	pmuEvent = flag.String("test.pmuevent", "cycle", "select a pmu event from the events: cycles, instructions, cacheReferences, cacheMisses")
+	pmuPeriod = flag.Int64("test.pmuperiod", 10000000, "specify the sampling period for a PMU event")
+	pmuPreciseIP = flag.Int("test.pmupreciseip", 0, "specify the precise IP level (0-3) for a PMU event")
+	pmuKernelIncluded = flag.Bool("test.pmukernelincl", false, "count the kernel")
+	pmuHvIncluded = flag.Bool("test.pmuhvincl", false, "count the hypervisor")
 	blockProfile = flag.String("test.blockprofile", "", "write a goroutine blocking profile to `file`")
 	blockProfileRate = flag.Int("test.blockprofilerate", 1, "set blocking profile `rate` (see runtime.SetBlockProfileRate)")
 	mutexProfile = flag.String("test.mutexprofile", "", "write a mutex contention profile to the named file after execution")
@@ -311,6 +317,12 @@ var (
 	memProfile           *string
 	memProfileRate       *int
 	cpuProfile           *string
+	pmuProfile	     *string
+	pmuEvent	     *string
+	pmuPeriod            *int64
+	pmuPreciseIP         *int
+	pmuKernelIncluded   *bool
+	pmuHvIncluded	     *bool
 	blockProfile         *string
 	blockProfileRate     *int
 	mutexProfile         *string
@@ -1029,6 +1041,8 @@ type matchStringOnly func(pat, str string) (bool, error)
 func (f matchStringOnly) MatchString(pat, str string) (bool, error)   { return f(pat, str) }
 func (f matchStringOnly) StartCPUProfile(w io.Writer) error           { return errMain }
 func (f matchStringOnly) StopCPUProfile()                             {}
+func (f matchStringOnly) StartPMUProfile(w io.Writer, event string, period int64, preciseIP int8, isKernelIncluded bool, isHvIncluded bool) error { return errMain }
+func (f matchStringOnly) StopPMUProfile()                             {}
 func (f matchStringOnly) WriteProfileTo(string, io.Writer, int) error { return errMain }
 func (f matchStringOnly) ImportPath() string                          { return "" }
 func (f matchStringOnly) StartTestLog(io.Writer)                      {}
@@ -1066,6 +1080,8 @@ type testDeps interface {
 	MatchString(pat, str string) (bool, error)
 	StartCPUProfile(io.Writer) error
 	StopCPUProfile()
+	StartPMUProfile(io.Writer, string, int64, int8, bool, bool) error
+	StopPMUProfile()
 	StartTestLog(io.Writer)
 	StopTestLog() error
 	WriteProfileTo(string, io.Writer, int) error
@@ -1236,6 +1252,19 @@ func (m *M) before() {
 		}
 		// Could save f so after can call f.Close; not worth the effort.
 	}
+	if *pmuProfile != "" {
+		f, err := os.Create(toOutputDir(*pmuProfile))
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "testing: %s\n", err)
+			return
+		}
+		if err := m.deps.StartPMUProfile(f, *pmuEvent, *pmuPeriod, int8(*pmuPreciseIP), *pmuKernelIncluded, *pmuHvIncluded); err != nil {
+			fmt.Fprintf(os.Stderr, "testing: can't start pmu profile: %s\n", err)
+			f.Close()
+			return
+		}
+		// Could save f so after can call f.Close; not worth the effort.
+	}
 	if *traceFile != "" {
 		f, err := os.Create(toOutputDir(*traceFile))
 		if err != nil {
@@ -1302,6 +1331,9 @@ func (m *M) writeProfiles() {
 	if *cpuProfile != "" {
 		m.deps.StopCPUProfile() // flushes profile to disk
 	}
+	if *pmuProfile != "" {
+		m.deps.StopPMUProfile() // flushes profile to disk
+	} 
 	if *traceFile != "" {
 		trace.Stop() // flushes trace to disk
 	}

From 67d3536a23edddfe4765555c775d124c05a6874b Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 15:10:08 -0700
Subject: [PATCH 082/126] test cases

---
 test/pmu/http/test4.go |  25 ++++++
 test/pmu/test1.go      |   8 +-
 test/pmu/test2.go      |  77 +++++++++++-----
 test/pmu/test4.go      | 195 +++++++++++++++++++++++++++++++++++++++++
 test/pmu/test4.out     |  10 +++
 5 files changed, 287 insertions(+), 28 deletions(-)
 create mode 100644 test/pmu/http/test4.go
 create mode 100644 test/pmu/test4.go
 create mode 100644 test/pmu/test4.out

diff --git a/test/pmu/http/test4.go b/test/pmu/http/test4.go
new file mode 100644
index 0000000000..3fca566a7c
--- /dev/null
+++ b/test/pmu/http/test4.go
@@ -0,0 +1,25 @@
+// run
+// Example of Usage: go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=r53010e\&period=1000000
+
+package main
+
+import (
+	"fmt"
+	"log"
+	// "time"
+	"net/http"
+	_ "net/http/pprof"
+)
+
+var sum int
+
+func main() {
+	go func() {
+        log.Println(http.ListenAndServe("localhost:6060", nil))
+	}()
+	// time.Sleep(2 * time.Second)
+	for i := 0; i <= 10000000000; i++ {
+		sum += i
+	}
+	fmt.Println(sum)
+}
diff --git a/test/pmu/test1.go b/test/pmu/test1.go
index 816b2fbd50..3f35f52f5d 100644
--- a/test/pmu/test1.go
+++ b/test/pmu/test1.go
@@ -155,9 +155,9 @@ func f10() {
 
 func run() error {
 	cycleFile, err := os.Create("cycle_profile")
-		if err != nil {
-			return err
-		}
+	if err != nil {
+		return err
+	}
 	defer cycleFile.Close()
 
 	var cycle pprof.PMUEventConfig
@@ -165,7 +165,7 @@ func run() error {
 	cycle.IsKernelIncluded = false
 	cycle.IsHvIncluded = false
 
-	if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycleFile, &cycle)); err != nil {
+	f err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle)); err != nil {
 		return err
 	}
 	defer pprof.StopPMUProfile()
diff --git a/test/pmu/test2.go b/test/pmu/test2.go
index 50c6149f0d..2faf7ec7de 100644
--- a/test/pmu/test2.go
+++ b/test/pmu/test2.go
@@ -7,20 +7,28 @@ import (
 	"log"
 	"os"
 	"sync"
+	"sync/atomic"
+	_"time"
 	"runtime/pprof"
 )
 
 var wg sync.WaitGroup
 
+var racy int32
+
 func f1() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 500000000; i++ {
+	for i := 0; i < 50000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
+		/*if i % 100 == 0 {
+			time.Sleep(time.Nanosecond)
+		}*/
+		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -30,11 +38,15 @@ func f2() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 500000000; i++ {
+	for i := 0; i < 50000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
+		/*if i % 100 == 0 {
+			time.Sleep(time.Nanosecond)
+		}*/
+		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -44,11 +56,15 @@ func f3() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 500000000; i++ {
+	for i := 0; i < 50000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
+		/*if i % 100 == 0 {
+			time.Sleep(time.Nanosecond)
+		}*/
+		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -58,11 +74,15 @@ func f4() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 500000000; i++ {
+	for i := 0; i < 50000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
+		/*if i % 100 == 0 {
+			time.Sleep(time.Nanosecond)
+		}*/
+		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -72,11 +92,12 @@ func f5() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 500000000; i++ {
+	for i := 0; i < 50000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
+		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -86,11 +107,12 @@ func f6() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 500000000; i++ {
+	for i := 0; i < 50000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
+		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -100,11 +122,12 @@ func f7() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 500000000; i++ {
+	for i := 0; i < 50000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
+		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -114,11 +137,12 @@ func f8() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 500000000; i++ {
+	for i := 0; i < 50000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
+		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -128,11 +152,12 @@ func f9() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 500000000; i++ {
+	for i := 0; i < 50000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
+		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -142,11 +167,12 @@ func f10() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 500000000; i++ {
+	for i := 0; i < 50000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
+		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -160,7 +186,7 @@ func run() error {
 	defer cycleFile.Close()
 
 	var cycle pprof.PMUEventConfig
-	cycle.Period =  15000000
+	cycle.Period =  1000000
 	// cycle.PreciseIP = 2
 
 	instrFile, err := os.Create("instr_profile")
@@ -170,33 +196,36 @@ func run() error {
 	defer instrFile.Close()
 
 	var instr pprof.PMUEventConfig
-	instr.Period =  10000000
+	instr.Period =  1000000
 	// instr.PreciseIP = 2
 
-	cacheRefFile, err := os.Create("cacheRef_profile")
+	cacheMissFile, err := os.Create("cacheMiss_profile")
 	if err != nil {
 		return err
 	}
-	defer cacheRefFile.Close()
+	defer cacheMissFile.Close()
 
-	var cacheRef pprof.PMUEventConfig
-	cacheRef.Period =  200
-	// cacheRef.PreciseIP = 2
+	var cacheMiss pprof.PMUEventConfig
+	cacheMiss.Period = 10
+	// cacheMiss.PreciseIP = 2
 
-	cacheMissFile, err := os.Create("cacheMiss_profile")
+
+	cacheRefFile, err := os.Create("cacheRef_profile")
 	if err != nil {
 		return err
 	}
-	defer cacheMissFile.Close()
+	defer cacheRefFile.Close()
 
-	var cacheMiss pprof.PMUEventConfig
-	cacheMiss.Period =  1
-	// cacheMiss.PreciseIP = 2
+	var cacheRef pprof.PMUEventConfig
+	cacheRef.Period =  1000000
+	// cacheRef.PreciseIP = 2
 
-	if err := pprof.StartPMUProfile(pprof.WithProfilingCycle(cycleFile, &cycle), pprof.WithProfilingInstr(instrFile, &instr), pprof.WithProfilingCacheRef(cacheRefFile, &cacheRef), pprof.WithProfilingCacheMiss(cacheMissFile, &cacheMiss)); err != nil {
+
+	if err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle), pprof.WithProfilingPMUInstructions(instrFile, &instr), pprof.WithProfilingPMUCacheReferences(cacheRefFile, &cacheRef), pprof.WithProfilingPMUCacheMisses(cacheMissFile, &cacheMiss)); err != nil {
 		return err
 	 }
-	 defer pprof.StopPMUProfile()
+
+	defer pprof.StopPMUProfile()
 
 	wg.Add(10)
 	defer wg.Wait()
diff --git a/test/pmu/test4.go b/test/pmu/test4.go
new file mode 100644
index 0000000000..fab30e9736
--- /dev/null
+++ b/test/pmu/test4.go
@@ -0,0 +1,195 @@
+// run
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"sync"
+	"runtime/pprof"
+)
+
+var wg sync.WaitGroup
+
+func f1() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f2() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f3() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f4() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f5() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f6() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f7() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f8() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f9() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+func f10() {
+	defer wg.Done()
+
+	var sum int
+	for i := 0; i < 500000000; i++ {
+		sum -= i / 2
+		sum *= i
+		sum /= i/3 + 1
+		sum -= i / 4
+	}
+
+	fmt.Println(sum)
+}
+
+
+func run() error {
+	rawFile, err := os.Create("raw_profile")
+	if err != nil {
+		return err
+	}
+	defer rawFile.Close()
+
+	var raw pprof.PMUEventConfig
+	raw.RawEvent = /* UOPS_ISSUED */ 0x53010e
+	raw.Period =  1000000
+	raw.IsKernelIncluded = false
+	raw.IsHvIncluded = false
+
+	if err := pprof.StartPMUProfile(pprof.WithProfilingPMURaw(rawFile, &raw)); err != nil {
+		return err
+	}
+	defer pprof.StopPMUProfile()
+
+	wg.Add(10)
+	defer wg.Wait()
+
+	go f1()
+	go f2()
+	go f3()
+	go f4()
+	go f5()
+	go f6()
+	go f7()
+	go f8()
+	go f9()
+	go f10()
+
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/test/pmu/test4.out b/test/pmu/test4.out
new file mode 100644
index 0000000000..9546171295
--- /dev/null
+++ b/test/pmu/test4.out
@@ -0,0 +1,10 @@
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911
+44438869911

From 496e0fff358a5668bc83b9e07b8e039174575162 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 15:10:52 -0700
Subject: [PATCH 083/126] fix a if-else bug caused by me

---
 src/net/http/pprof/pprof.go | 36 +++++++++++++++---------------------
 1 file changed, 15 insertions(+), 21 deletions(-)

diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index bfbd91d993..115c6c48b5 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -113,46 +113,40 @@ func serveError(w http.ResponseWriter, status int, txt string) {
 func pmuProfile(w http.ResponseWriter, r *http.Request) error {
 	var eventConfig pprof.PMUEventConfig
 
-	period, err := strconv.ParseInt(r.FormValue("period"), 10, 64)
-	if err == nil {
+	if period, err := strconv.ParseInt(r.FormValue("period"), 10, 64); err == nil {
 		eventConfig.Period = period
 	}
-	preciseIP, err := strconv.ParseInt(r.FormValue("preciseIP"), 10, 8)
-	if err == nil {
+	if preciseIP, err := strconv.ParseInt(r.FormValue("preciseIP"), 10, 8); err == nil {
 		eventConfig.PreciseIP = int8(preciseIP)
 	}
-	isKernelIncluded, err := strconv.ParseBool(r.FormValue("kernel"))
-	if err == nil {
+	if isKernelIncluded, err := strconv.ParseBool(r.FormValue("kernel")); err == nil {
 		eventConfig.IsKernelIncluded = isKernelIncluded
 	}
-	isHvIncluded, err := strconv.ParseBool(r.FormValue("hv"))
-	if err == nil {
+	if isHvIncluded, err := strconv.ParseBool(r.FormValue("hv")); err == nil {
 		eventConfig.IsHvIncluded = isHvIncluded
 	}
 
 	switch eventName := r.FormValue("event"); eventName {
 		case "cycles":
-			err = pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
 		case "instructions":
-			err = pprof.StartPMUProfile(pprof.WithProfilingPMUInstructions(w, &eventConfig))
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUInstructions(w, &eventConfig))
 		case "cacheReferences":
-			err = pprof.StartPMUProfile(pprof.WithProfilingPMUCacheReferences(w, &eventConfig))
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheReferences(w, &eventConfig))
 		case "cacheMisses":
-			err = pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
 		default:
-			// is this a Raw event?
+			// Is this a raw event?
 			if strings.HasPrefix(eventName, "r") {
-				rawHexEvent, err := strconv.ParseUint(eventName[1:], 16, 64)
-				if err != nil {
-					return fmt.Errorf("Incorrect hex format for raw event")
+				if rawHexEvent, err := strconv.ParseInt(eventName[1:], 16, 64); err == nil {
+					eventConfig.RawEvent = rawHexEvent
+					return pprof.StartPMUProfile(pprof.WithProfilingPMURaw(w, &eventConfig))
 				}
-				eventConfig.RawEvent = rawHexEvent
-				err = pprof.StartPMUProfile(pprof.WithProfilingPMURaw(w, &eventConfig))
+				return fmt.Errorf("Incorrect hex format for raw event")
 			} else {
-				return fmt.Errorf("unknown or not yet implemented event")
+				return fmt.Errorf("Unknown or not yet implemented event")
 			}
-		}
-	return err
+	}
 }
 
 // Profile responds with the pprof-formatted cpu profile.

From 689c12292cd11c8b6cc3306e19517a70cacc19d0 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 15:11:28 -0700
Subject: [PATCH 084/126] minor

---
 src/runtime/defs_pmu.go    | 2 +-
 src/runtime/pprof/pprof.go | 8 ++++++--
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index a13804f638..4cf04ca3a6 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -6,7 +6,7 @@ const (
 	GO_COUNT_HW_CACHE_REFERENCES        = 0x2
 	GO_COUNT_HW_CACHE_MISSES            = 0x3
 	GO_COUNT_HW_RAW			    = 0x4
-	GO_COUNT_PMU_EVENTS_MAX 	    = 0x5
+	GO_COUNT_PMU_EVENTS_MAX		    = 0x5
 )
 
 type PMUEventAttr struct {
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index c1da50e4e5..34ac75ca31 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -808,7 +808,7 @@ func StartPMUProfile(opts ...ProfilingOption) error {
 
 type PMUEventConfig struct {
 	Period           int64
-	RawEvent 	 uint64
+	RawEvent	 int64
 	PreciseIP        int8
 	IsKernelIncluded bool
 	IsHvIncluded     bool
@@ -904,7 +904,11 @@ func WithProfilingPMURaw(w io.Writer, eventConfig *PMUEventConfig) ProfilingOpti
 		// TODO: create a table of standard clamp values
 		// TODO: clamp period to something reasonable
 
-		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_RAW, /* event name */ "r" + strconv.FormatUint(eventConfig.RawEvent, 16))
+		if  eventConfig.RawEvent < 0 {
+			return fmt.Errorf("RawEvent should be >= 0")
+		}
+
+		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_RAW, /* event name */ "r" + strconv.FormatInt(eventConfig.RawEvent, 16))
 		return nil
 	})
 }

From 3e2a5bcd414116cf1af50c871f79a5e5e5bef769 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 15:26:11 -0700
Subject: [PATCH 085/126] test cases

---
 test/pmu/http/test1.go | 4 +++-
 test/pmu/http/test2.go | 4 +++-
 test/pmu/http/test3.go | 4 +++-
 test/pmu/http/test4.go | 6 +++---
 test/pmu/test1.go      | 3 ++-
 test/pmu/test2.go      | 3 ++-
 test/pmu/test3.go      | 1 +
 test/pmu/test4.go      | 1 +
 8 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/test/pmu/http/test1.go b/test/pmu/http/test1.go
index 6cfe39e45d..cf337ffa9a 100644
--- a/test/pmu/http/test1.go
+++ b/test/pmu/http/test1.go
@@ -1,5 +1,7 @@
 // run
-// Example of Usage: go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=cycles\&period=10000000
+// Example of usage: 
+// 1. go run test1.go
+// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=cycles\&period=10000000
 
 package main
 
diff --git a/test/pmu/http/test2.go b/test/pmu/http/test2.go
index e2b42d820c..cbe16e09fe 100644
--- a/test/pmu/http/test2.go
+++ b/test/pmu/http/test2.go
@@ -1,5 +1,7 @@
 // run
-// Example of Usage: go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=cycles\&period=10000000
+// Example of usage: 
+// 1. go run test2.go
+// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=instructions\&period=10000000
 
 package main
 
diff --git a/test/pmu/http/test3.go b/test/pmu/http/test3.go
index ed9af94112..ececca4108 100644
--- a/test/pmu/http/test3.go
+++ b/test/pmu/http/test3.go
@@ -1,5 +1,7 @@
 // run
-// Example of Usage: go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=cycles\&period=10000000
+// Example of usage: 
+// 1. go run test3.go
+// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=cacheMisses\&period=10000000
 
 package main
 
diff --git a/test/pmu/http/test4.go b/test/pmu/http/test4.go
index 3fca566a7c..b7ab6cfb2f 100644
--- a/test/pmu/http/test4.go
+++ b/test/pmu/http/test4.go
@@ -1,12 +1,13 @@
 // run
-// Example of Usage: go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=r53010e\&period=1000000
+// Example of Usage: 
+// 1. go run test4.go
+// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=r53010e\&period=1000000
 
 package main
 
 import (
 	"fmt"
 	"log"
-	// "time"
 	"net/http"
 	_ "net/http/pprof"
 )
@@ -17,7 +18,6 @@ func main() {
 	go func() {
         log.Println(http.ListenAndServe("localhost:6060", nil))
 	}()
-	// time.Sleep(2 * time.Second)
 	for i := 0; i <= 10000000000; i++ {
 		sum += i
 	}
diff --git a/test/pmu/test1.go b/test/pmu/test1.go
index 3f35f52f5d..3391ac80cb 100644
--- a/test/pmu/test1.go
+++ b/test/pmu/test1.go
@@ -1,4 +1,5 @@
 // run
+// Example of usage: go run test1.go
 
 package main
 
@@ -165,7 +166,7 @@ func run() error {
 	cycle.IsKernelIncluded = false
 	cycle.IsHvIncluded = false
 
-	f err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle)); err != nil {
+	if err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle)); err != nil {
 		return err
 	}
 	defer pprof.StopPMUProfile()
diff --git a/test/pmu/test2.go b/test/pmu/test2.go
index 2faf7ec7de..f065cec929 100644
--- a/test/pmu/test2.go
+++ b/test/pmu/test2.go
@@ -1,4 +1,5 @@
 // run
+// Example of usage: go run test2.go
 
 package main
 
@@ -217,7 +218,7 @@ func run() error {
 	defer cacheRefFile.Close()
 
 	var cacheRef pprof.PMUEventConfig
-	cacheRef.Period =  1000000
+	cacheRef.Period = 1000000
 	// cacheRef.PreciseIP = 2
 
 
diff --git a/test/pmu/test3.go b/test/pmu/test3.go
index 65e6fc0cf0..44c4754a26 100644
--- a/test/pmu/test3.go
+++ b/test/pmu/test3.go
@@ -1,4 +1,5 @@
 // run
+// Example of usage: go run test3.go
 
 package main
 
diff --git a/test/pmu/test4.go b/test/pmu/test4.go
index fab30e9736..cc55510389 100644
--- a/test/pmu/test4.go
+++ b/test/pmu/test4.go
@@ -1,4 +1,5 @@
 // run
+// Example of usage: go run test4.go
 
 package main
 

From d4ae34ee36341ac86340e24bad4811cb7cc963b2 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 15:39:53 -0700
Subject: [PATCH 086/126] more test cases

---
 test/pmu/leak/cacheMiss_profile | Bin 0 -> 17545 bytes
 test/pmu/leak/cacheRef_profile  | Bin 0 -> 43243 bytes
 test/pmu/leak/cycle_profile     | Bin 0 -> 3561 bytes
 test/pmu/leak/instr_profile     | Bin 0 -> 5731 bytes
 test/pmu/leak/itimer_profile    |   0
 test/pmu/leak/test1.go          |  39 +++++++++++++++++
 test/pmu/leak/test2.go          |  43 +++++++++++++++++++
 test/pmu/leak/test3.go          |  57 +++++++++++++++++++++++++
 test/pmu/leak/test4.go          |  64 ++++++++++++++++++++++++++++
 test/pmu/leak/test5.go          |  72 ++++++++++++++++++++++++++++++++
 test/pmu/leak/test6.go          |  68 ++++++++++++++++++++++++++++++
 11 files changed, 343 insertions(+)
 create mode 100644 test/pmu/leak/cacheMiss_profile
 create mode 100644 test/pmu/leak/cacheRef_profile
 create mode 100644 test/pmu/leak/cycle_profile
 create mode 100644 test/pmu/leak/instr_profile
 create mode 100644 test/pmu/leak/itimer_profile
 create mode 100644 test/pmu/leak/test1.go
 create mode 100644 test/pmu/leak/test2.go
 create mode 100644 test/pmu/leak/test3.go
 create mode 100644 test/pmu/leak/test4.go
 create mode 100644 test/pmu/leak/test5.go
 create mode 100644 test/pmu/leak/test6.go

diff --git a/test/pmu/leak/cacheMiss_profile b/test/pmu/leak/cacheMiss_profile
new file mode 100644
index 0000000000000000000000000000000000000000..79e6d0a243118b848877e6098b93767dbb34045c
GIT binary patch
literal 17545
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

literal 0
HcmV?d00001

diff --git a/test/pmu/leak/cacheRef_profile b/test/pmu/leak/cacheRef_profile
new file mode 100644
index 0000000000000000000000000000000000000000..19592bc29488a7774b8902e8a87fdbd991dc4a94
GIT binary patch
literal 43243
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

literal 0
HcmV?d00001

diff --git a/test/pmu/leak/cycle_profile b/test/pmu/leak/cycle_profile
new file mode 100644
index 0000000000000000000000000000000000000000..87f7cd4af610d650d086e16cbc51e3ee5cdbb188
GIT binary patch
literal 3561
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

literal 0
HcmV?d00001

diff --git a/test/pmu/leak/instr_profile b/test/pmu/leak/instr_profile
new file mode 100644
index 0000000000000000000000000000000000000000..8f353bffb31f3de8c8f30759955029862f7fe24e
GIT binary patch
literal 5731
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
VjCg$J{|^8F|NlWo?w|`S008<+Fo^&F

literal 0
HcmV?d00001

diff --git a/test/pmu/leak/itimer_profile b/test/pmu/leak/itimer_profile
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/test/pmu/leak/test1.go b/test/pmu/leak/test1.go
new file mode 100644
index 0000000000..ee9911e7fb
--- /dev/null
+++ b/test/pmu/leak/test1.go
@@ -0,0 +1,39 @@
+// run
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"runtime/pprof"
+)
+
+var sum int
+
+func run() error {
+	for /*i := 0; i < 10; i++*/ {
+		itimerFile, err := os.Create("itimer_profile")
+		if err != nil {
+			return err
+		}
+
+		if err = pprof.StartCPUProfile(itimerFile); err != nil {
+			return err
+		}
+		for j := 0; j < 100; j++ {
+			sum += j
+		}
+		pprof.StopCPUProfile()
+		itimerFile.Close()
+	}
+	fmt.Println(sum)
+
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/test/pmu/leak/test2.go b/test/pmu/leak/test2.go
new file mode 100644
index 0000000000..3b04ecf6c8
--- /dev/null
+++ b/test/pmu/leak/test2.go
@@ -0,0 +1,43 @@
+// run
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"runtime/pprof"
+)
+
+var sum int
+
+func run() error {
+	for /*i := 0; i < 100000; i++*/ {
+		cycleFile, err := os.Create("cycle_profile")
+		if err != nil {
+			return err
+		}
+
+		var cycle pprof.PMUEventConfig
+		cycle.Period =  100000
+		cycle.IsKernelIncluded = false
+		cycle.IsHvIncluded = false
+		if err = pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle)); err != nil {
+			return err
+		}
+		for j := 0; j < 10000000; j++ {
+			sum += j
+		}
+		pprof.StopPMUProfile()
+		cycleFile.Close()
+	}
+	fmt.Println(sum)
+
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/test/pmu/leak/test3.go b/test/pmu/leak/test3.go
new file mode 100644
index 0000000000..b5e34d911d
--- /dev/null
+++ b/test/pmu/leak/test3.go
@@ -0,0 +1,57 @@
+// run
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"runtime/pprof"
+)
+
+var sum int
+
+func run() error {
+	for /*i := 0; i < 10; i++*/ {
+		itimerFile, err := os.Create("itimer_profile")
+		if err != nil {
+			return err
+		}
+
+		if err = pprof.StartCPUProfile(itimerFile); err != nil {
+			return err
+		}
+		for j := 0; j < 10000000; j++ {
+			sum += j
+		}
+		pprof.StopCPUProfile()
+		itimerFile.Close()
+
+		cycleFile, err := os.Create("cycle_profile")
+		if err != nil {
+			return err
+		}
+
+		var cycle pprof.PMUEventConfig
+		cycle.Period =  100000
+		cycle.IsKernelIncluded = false
+		cycle.IsHvIncluded = false
+		if err = pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle)); err != nil {
+			return err
+		}
+		for j := 0; j < 10000000; j++ {
+			sum += j
+		}
+		pprof.StopPMUProfile()
+		cycleFile.Close()
+	}
+	fmt.Println(sum)
+
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/test/pmu/leak/test4.go b/test/pmu/leak/test4.go
new file mode 100644
index 0000000000..cb12c65136
--- /dev/null
+++ b/test/pmu/leak/test4.go
@@ -0,0 +1,64 @@
+// run
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"runtime/pprof"
+)
+
+var sum int
+
+func run() error {
+	for /*i := 0; i < 100; i++*/ {
+		cycleFile, err := os.Create("cycle_profile")
+		if err != nil {
+			return err
+		}
+		instrFile, err := os.Create("instr_profile")
+		if err != nil {
+			return err
+		}
+		cacheRefFile, err := os.Create("cacheRef_profile")
+		if err != nil {
+			return err
+		}
+		cacheMissFile, err := os.Create("cacheMiss_profile")
+		if err != nil {
+			return err
+		}
+
+		var cycle pprof.PMUEventConfig
+		cycle.Period = 1000000
+		var instr pprof.PMUEventConfig
+		instr.Period = 1000000
+		var cacheRef pprof.PMUEventConfig
+		cacheRef.Period = 100
+		var cacheMiss pprof.PMUEventConfig
+		cacheMiss.Period = 100
+
+		if err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle), pprof.WithProfilingPMUInstructions(instrFile, &instr), pprof.WithProfilingPMUCacheReferences(cacheRefFile, &cacheRef), pprof.WithProfilingPMUCacheMisses(cacheMissFile, &cacheMiss)); err != nil {
+			return err
+		}
+		for j := 0; j < 10000000; j++ {
+			sum += j
+		}
+		pprof.StopPMUProfile()
+
+		cycleFile.Close()
+		instrFile.Close()
+		cacheRefFile.Close()
+		cacheMissFile.Close()
+	}
+	fmt.Println(sum)
+
+	return nil
+}
+
+func main() {
+	if err := run(); err != nil {
+		log.Fatal(err)
+	}
+}
diff --git a/test/pmu/leak/test5.go b/test/pmu/leak/test5.go
new file mode 100644
index 0000000000..7ef22515d7
--- /dev/null
+++ b/test/pmu/leak/test5.go
@@ -0,0 +1,72 @@
+// run
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"log"
+	"sync"
+	"runtime/pprof"
+)
+
+var wg sync.WaitGroup
+var sum int
+
+func run() {
+	defer wg.Done()
+	for i := 0; i < 10000000; i++ {
+		sum += i
+	}
+}
+
+func main() {
+	wg.Add(1000)
+
+	cycleFile, err := os.Create("cycle_profile")
+	if err != nil {
+		log.Fatal(err)
+		return
+	}
+	instrFile, err := os.Create("instr_profile")
+	if err != nil {
+		log.Fatal(err)
+		return
+	}
+	cacheRefFile, err := os.Create("cacheRef_profile")
+	if err != nil {
+		log.Fatal(err)
+		return
+	}
+	cacheMissFile, err := os.Create("cacheMiss_profile")
+	if err != nil {
+		log.Fatal(err)
+		return
+	}
+
+	var cycle pprof.PMUEventConfig
+	cycle.Period = 1000000
+	var instr pprof.PMUEventConfig
+	instr.Period = 1000000
+	var cacheRef pprof.PMUEventConfig
+	cacheRef.Period = 100
+	var cacheMiss pprof.PMUEventConfig
+	cacheMiss.Period = 1
+
+	if err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle), pprof.WithProfilingPMUInstructions(instrFile, &instr), pprof.WithProfilingPMUCacheReferences(cacheRefFile, &cacheRef), pprof.WithProfilingPMUCacheMisses(cacheMissFile, &cacheMiss)); err != nil {
+			log.Fatal(err)
+		}
+
+	for i := 0; i < 1000; i++ {
+		go run()
+	}
+
+	wg.Wait()
+	fmt.Println(sum)
+	pprof.StopPMUProfile()
+
+	cycleFile.Close()
+	instrFile.Close()
+	cacheRefFile.Close()
+	cacheMissFile.Close()
+}
diff --git a/test/pmu/leak/test6.go b/test/pmu/leak/test6.go
new file mode 100644
index 0000000000..0bd4c341f6
--- /dev/null
+++ b/test/pmu/leak/test6.go
@@ -0,0 +1,68 @@
+// run
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"time"
+	"runtime/pprof"
+)
+
+var sum int
+
+func run() {
+	for {
+		cycleFile, err := os.Create("cycle_profile")
+		if err != nil {
+			return
+		}
+
+		instrFile, err := os.Create("instr_profile")
+		if err != nil {
+			return
+		}
+
+		cacheRefFile, err := os.Create("cacheRef_profile")
+		if err != nil {
+			return
+		}
+
+		cacheMissFile, err := os.Create("cacheMiss_profile")
+		if err != nil {
+			return
+		}
+
+		var cycle pprof.PMUEventConfig
+		cycle.Period = 1000000
+		var instr pprof.PMUEventConfig
+		instr.Period = 1000000
+		var cacheRef pprof.PMUEventConfig
+		cacheRef.Period = 100
+		var cacheMiss pprof.PMUEventConfig
+		cacheMiss.Period = 1
+
+		if err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle), pprof.WithProfilingPMUInstructions(instrFile, &instr), pprof.WithProfilingPMUCacheReferences(cacheRefFile, &cacheRef), pprof.WithProfilingPMUCacheMisses(cacheMissFile, &cacheMiss)); err != nil {
+			return
+		}
+
+		for i := 0; i < 100000000; i++ {
+			sum += i
+		}
+		pprof.StopPMUProfile()
+
+		cycleFile.Close()
+		instrFile.Close()
+		cacheRefFile.Close()
+		cacheMissFile.Close()
+	}
+}
+
+func main() {
+	for i := 0; i < 100; i++ {
+		go run()
+	}
+
+	time.Sleep(time.Hour)
+	fmt.Println(sum)
+}

From 1d9c12c11eea38e25d8d8129c123defe9eebbf17 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 15:41:33 -0700
Subject: [PATCH 087/126] remove

---
 test/pmu/leak/cacheMiss_profile | Bin 17545 -> 0 bytes
 test/pmu/leak/cacheRef_profile  | Bin 43243 -> 0 bytes
 test/pmu/leak/cycle_profile     | Bin 3561 -> 0 bytes
 test/pmu/leak/instr_profile     | Bin 5731 -> 0 bytes
 test/pmu/leak/itimer_profile    |   0
 5 files changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 test/pmu/leak/cacheMiss_profile
 delete mode 100644 test/pmu/leak/cacheRef_profile
 delete mode 100644 test/pmu/leak/cycle_profile
 delete mode 100644 test/pmu/leak/instr_profile
 delete mode 100644 test/pmu/leak/itimer_profile

diff --git a/test/pmu/leak/cacheMiss_profile b/test/pmu/leak/cacheMiss_profile
deleted file mode 100644
index 79e6d0a243118b848877e6098b93767dbb34045c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 17545
zcmV*DKy1GsiwFP!00004|CGIVd>lpcIQqJ07LO&_s$F9!z`(L3TY!WG2ge<E9Qn8-
z_%IxoeQRkY3#47KyTX`DvMuMFbIv*EoU?JxIpBnia}MuQ)jcyS$@bU3`{Uf2uCA_J
z)zvf0Z~JZ;Uvg;7@a<KTOiO@FGA#q-U-<w3DFUgM!2S(K%K%MQ29ai20!%dh9^ZW+
zKv*IGmc)xKTF8LMlF&MtVI<s#_xURXz%p=1JDxLOYBJ9mV4=lxCJw#OoYtAJv?9-$
zP!TKgoCg~o;W-bStiW>~NWvtZyANBf?M&<LgUJ@p-3Q5-%ySj6OZzS~R{_pSo~r;U
znBuP#0L#K-KQc}WCaHB6RL07@t|DHY+=SLugj<5wRfJSb^+O=lO2R&)nve*R;7guL
z0xx>~5CAI~7x(97$<RzKO9mhM{8a*ArQnuBjR<85EWD4`rNI4ozrSh#tV+23BF|NV
zor=9m@Blu*bCq%HO`fX^yA+v~;X!=RUp0_wrQ(^HgNc+>C}5PSfQbHw0$>3yT`-uo
z1K6WT0eBc6<~c78oX&Gz7_Ow^g-7raf3*NuK3v&oG_CVNA2sKLNAXdAwLq#>1^d$+
zDIY-ikW`-JlZNTJuYy%EDLJK5<y7$ch}-+I@5J_mrV4aa994nG@G<}60kEp#X`7>+
z7Ldt2fa~TlK>+InKY0*Oj~+?u?}yHcjQhclekKEP0nM3KRd|rOt_n}!6aGK|tcS40
z(owYR0a$JF+yn3=KIwld0M^5}cqY$12zw2ldk~(+r+MxX+&h5h5T>i`5T3zjc&-}u
z-NB?h1hW(?55cqetiQSsSO7`)SAD?yAU^c)BP63oam1;1q>_i>N#5jPsDU;7X@OMh
zF&sR908KptKjW!K;5mHG|9l|TdK~92;;CxzE>Bg17w`q1^5XzC^(g#?ryhlLO!sF5
zz<L7vDzQBVEtQTRgBS5df6V|`0h~Bji*&I7;Y$SxGO6ODk3H^xBA|5iB#!9KI(i%q
zDq%einV88sdJ4O4??{65!)7HAKfHu5`Ckrz^)#*+$LpSeGs=>mfS=*dc-=F&avIN7
zfu2gY&*H@+Y`-Zm{XQUVSI2$BS`qF5Y*n}e@Cv@-e>IS5)xgWw+mei)gcx)CB>WtI
z?td+iYNg@Oc1>yODX7C!Pr)zn7yj1*U_FN|Xv$+f4J%dXcp83*zx2Nz0PA_&^%L)3
z38q`F)js*u)6YCxsdDuiY0o|HSnUfqrEOcH>=`)yEbs9Q{0e{Ne>DJBIu1~C&%&ao
zdG1;GHU66CGO+E+*0ioV4D<3_b$A2c;JFvE&32xv0Y|IwTn+dQ{)Xpj;?jdWmj-L@
z=eaa^6W`>yOzd=&=bnROYVJ9B3*X|om+<IRE#($U$}i)o4jky7hXu;GpNF^cZGR<S
zWj0dlh4hRUYi7Pg`uiES+TMYveF0`E{k;J1;5+_z17N*^%jWZ3It=zOMd|P!zQ=Q~
z;*w1~mjPYXx(s+9-{-lX<Em{;(TmVmY2ZcpE&i5m;x!!9hvy!L^Ck#iHKyo+pS|+x
z&tJQp7Jh-n+jyTBV4Sj;U*g#H{G=u{Q#;p$5AXxt`E}fLKwByWI^V;L{r+FP^2^t6
zqv2oSD%(E$k~LIi=+s}8GlgH{zAM^nP7@KS)*E=j_UxJ<e83Ks^y@bgJnA>tZJ_4#
z263t*<Zo`r<(oM13TrGAjwvt5gx}%s{J#%?^%jmD!+4&6J+wJkZ{zMJoLOFiktzti
z1Rvsu{*MA+y@MrZHK|uBfbc!YJbB-I>zTLTDP`cP*1Onr0mqp~;8hT|ZM^Hog!gd$
zI^O4Hn6IdM89v63{htKDdLK8;=8%#KLn)-B@ILpw_ddt`RO`2R`dABc(4WD}Y&t)K
zT3E~fhX7a~;1ZhhSg$}A6{%i<Pw`WK?LeyaJ8XJ&5G{KZp5tY&!e{uI|MNhq^?N*3
z%=zu-@CHx)9R7%Z^nVcm>qG2f6Vr`|No8Ux{`Q04{r*Fy2ds~<%}Fhnl_VDc1B|4k
zj}kTZF>V~fl70==D|>$p{)B&GyZr=@+gdnupDWjoKPfNQTDWg+BjVu~@N*{g7w~8N
zv;QxFRO=5o(=HdnAbeh?Gr86u60_x}*h^9IOIW0+_$B-m|H@R<#?>|z2bC>+hHXj`
zQgk5I`Wz27)>YZ#E}@^+E=A~Pp9jGDBThZ4WwL{Ks>I|}_@fg7zraI%Ss;%?UymCu
zzj*5DQph;T{|S2}1`FRqjI7F^$n(mW9$0_IX>Gew)Oj7wsciE){0;x+|9c?S`U`fL
zuf_LwP7!~_(|x&4{1q&&!~*>l`~&~Nwb|eB!bq<7ehmXvsQWe4!8&ZBf5)L)wD}G&
zTxtLLFMs`8g}*C11?wL;|0*MY1CA*KZ@@qCpKOeEaNiGX!@q$j@B14FVvwi)iTf^V
zJAIak4B~2%x<{8vfmEw54x}ekAU(_>LV!q0s`ZaL|0JUf)(wD_g*z^5w_hb)U1gPX
zR<N>hWGV4J!sx1ItFT#4z#%-hlY``&uvP`hH=!=p<sg}Z?RW6p3oxJ5u2F?@I7*g7
zm5U`8*h=1lz6#Y_kcC-XkJiJ*mw2ucY_Gs_$ir5|wa1mim$=_96sx*nCbu40S>Bfc
zu)e~%1Yj@mS;U(4l|`jvK2EpO6BWvKy2#h*q8zaWIP@G7^cD<N4id&~>PaP7K#s3{
zt{|M~`4PM_jiZ?=f_)W<gd`)vmR*Qrf7Cch06s5=j^x5p7{10%iFwM-JYU~lrcs=p
zXmxhLiq>J<$on#oYQ=EJ0(OJ9A)k%!ZOF!K|6c-N#c@tkcFT95m5R&nKnOz|A&PKA
z8=iX?epGYsLJsEe+&6f96wf^YbCq!F<MeTC{qMmRb%c8laxs@(>sxGmtb}~@edw<A
z{yx;hdYok%;GC)KS{0$WWW9ff=k2_+r~(MvsABP=Z=R|DZG)ubl<yJ+{x7^TJYi$s
z11xa(7eiLkknAJ>#uK(BuOVxFlp!Ddx3X4+y3~UI;IzaTX`}v68Dp^vcH1F2BK{Y5
z*;%3uRRp@I|F0&9&EbF8Xb@MdzlAv}V*D2JFwg&Gz-tu?yf%<01F%8~rlG*4SGkJ)
z0N!UsegI$LSN_)mUaOJ7RnvQtjDKer?Z1P3%=Z@rz-laT__~plM}7}~;Dx`3FoyjF
z0k2gea0JbHtPi1+QqG4E!HB<l0IVhg=QY<E-~|xA`&nX@|5q$(G!%_QV^JcSh=A8>
zDsaFFHtb3;j&!CCyQy&5^;*pY?%S@9JTnQZ0->{-QSshf;Fw)phJOULn8c5u5DWcZ
z2fS7bf%^|PCEh-U9!gFhLlmPt*;3%)b9~-5p?5{sT$+m(qNON%g7jLg1oofFG3yf;
ztrEs35W|@N-GJ9>EwJq@o~#86)nqM*W1J`32;4VCmxNrX=z_DAXf4`^az&xnYAdiy
zN3Q$-0F9If{Q-)w$p1~iYqb-2wF6In3hka@jz5L^Sl|C@z-zS^czp>gzczGNnY%W8
zi{J8O2Z7B_a;EwWW+}9vK?7{SlN|-FQfBix%v6(~!*}={*Y}+Sp1Q^c^hc=8TmBLL
zh5up$>MU@6Njnnq7qC#(QeVKo@!x(r2z3#7@(M5f6THO>{{;WR|M0@D0)L#tmiK4a
ztQP(m{)_)*>*^+O>ujF<3(QrMe}Vtu|9G;yz(s4>9zNs{>wBE+A?cyEqMc|jI*1A#
zMJLf&bP-)eH_=^LS`UFo+Hj)#D|90MlB~Z%vA|;CuN3fFJq7k3+J?CJ8%(bTA}z`K
z8#ENyQ21Z<B@ue7hp>8*&Gr&_{3a{lNoY=`o;L1Yf{t#^(c5eF7FgV$asD07Kg>A)
z4vhph5-jmP0!O#u>3_hshj{uQ&{$w&HQiU>o@=bFIxt5~*MSm&C2G2#z&@>c^*>>@
zn*Jv=5!ggc_ZK*H8k>F)E>gvkWCfwAz^20gdcbQ95V)m1Pd^Q(DsuE3D6rM6!Q|_y
z5O>|7x9B7KiVFQie=$HjUwNS5V%BR75;*av)+DgHu&^pqUl*DQY^L@fEO7Q|p3Z_s
z5AbvrG#A)hO%D;c`8-c&!z4AG4J`z=plPs%3M|>f=YkMC4<aqu3PDSOErq`o`TQ_}
zGZ*vpqwo$0`_ME<3>HJgP%%u{9fjcnx7qDMIwMt}v}p||93up_u=^Ol24NSTBlKFY
zHBw;lZ0*up=<uYyb|m}kZG!$NfkT%SlK^u_fN9BA4zw27TKL<L*^Cz0X=o=BST5`)
z15CDZp{>BS!rzYO#|T_Cgy-u)4{EF>S@od3!1luba=>ei71*Rb>-!(jj*7X*`Mmeg
zC^1@$5o2$oBe2E^JTb8&QRIiZ;1mSo#M9;J_gdoxZraSb`9(NN0Z}tNUeKwy9K&8~
zg1|*vIoRYuAIbnpRvvT^*nyPjwI&KYF@bgbCF}(@fiIz>z>aEqlECF#c)A93xF1La
zlLfBc%a6W-xzuAwvc7^&0z0V{Qv|kb$1a=?b4h|pRz7qV*je~1*~i}rVxpKNCW|SA
zZ>qql_7*Mg2VtKOr`iD11WsMYK2`unl*|jDi@+|zUm@VNrVE^>ro%9hx(G>D7`h7V
zs-|ZMY-^{N76x-LQ{e7>j4%QliNs_p0^J056aMZ*(JX;eSG6P~D1`NDz7To{?4jpp
z3%oI(=f8&46!wy>uc4>Fo_c<cz#eOK<m*hO$P*Nrk{+2Rri&Szwp8D9rl>GW%ocN0
z?3*ia!U!&PqOgo=tRyQ6y#)4Be9RNLK~290yDEcoZkj9RiSotJe1Rhlu=B;>7wnrc
z=q<3f@b@7O7YMv;*RjLsK#{_Bdf$ApK=`Tzyw*a2E6%YNGhwW1t}YT-Y_|bkaZgDL
z#Uf#M0=(8@fyGOQkm%w-VK*(=ibG$4eTBatIrI{NhkxSuRRlh!s|flF>@WNSh_0mq
zyMC`FN5*RR8WxKsVkwCUtYrchp6NpFl1Zm#yG&nJij3s~j~(NR<+m_PDSd^&i|SD&
zD5mnH3M-}3a<L+zi~(z<z=fx|7yAwTnf>7#7$|U{@TUd5)+&K**Ko$G4||pB>%$;{
zgM@!DF|b--pA|g+Ev!}Z-@*`qL-hO_fqNG6d;=&}^9^9Az@d76t-$fN{8~`j()I32
zu}Z8KYs6Yt5Z?>zKbGUhcaX`1eh0$@4pWh6oxqZz94B6bjUG1p^#bRg<XXytvD5(c
zS{nooS;gekhl8|TfQ3@+d$CS@^2~a{?fEx0l-}BFZ4|g|6C-~Su2T@w%QkWly5q7<
z0*_DQWmQxk&Ck0%JV9&{cU-ht;N&ArwFd@MsjU~qHjDf8{XrQ5?Ls5LGs<uP))s;7
z=W!bN7g<qSvh^<*E^xT;k03MMD)8Vjp8hwy#Af<$7%6b1@Q)%bZxguA7TX~bn{L@{
z5nIK!vclRfa9pXI3$L|9;I4JU$V>hMCCUo^1EU3wW-swtI|XiD#A;~(oe94#Ubc%J
zVy9~ZUTc@YE~Sp>`p~mW-2U9_wRQ{Kw23p+f1$|}Y&QReF#^Y^=)Fha<R(1*KNx~M
z{XZBha4b#xti1yFUG6Lc_gTdP&eA<fGL6Ow9H#*G37pxe4FNP1a7F<%6fj=kcm=Ru
z;JNFq380aH?h2rhfC&O85CB*Q1Rk@iiZ|VKxLfQIdqstPV!t?`YKLImfY&-GaLw%+
zxd(5TJ$=?8fg1)jq1_u3QLNd<0wxNaDEt)n4hvjui>L7uZrk~gI9!eZKIHu%aN#@-
zw2#1xd}Bi0n~Fa;G0|ro5x9IvbK0~-z%V-Dq|j)Rz)8YCnau5|z*|F_P)tjrZl>+@
zN5oN)?3`IY`#j*ajtSg%OP94B$TEDqU&=92>cn<j;MOx7|0;2JH{i2Q2rS+_lBj4R
zxQmyTOrt3RrwBd`{wT0}(}dGtCB|IgxTt(W{74v13LLnbb=y?H2C|)G8d3fx)%mPb
z0!w<cZkq`xq3e!h8ch>8O#%EQaAz+DXfB{>DvQ6lfawCKD}d7i+c)PeS_oJ{_Loef
z83JceiLX!DC&el8lQ>P~gU>o6@ItGu#8*oJo#<4TOrx0sXA1w{177Q_z+O!_TelMM
z8i=$M8q5+nOZaD#^v?;LuuykU3OQ1q7dZJEr{Xu@8g&G96h0%)igV(;P~8_!lotff
zv^(-AD3j`&gbU)WGSwLO4K4~?Wt$7ty843cqGK*z>yp6LTXezJnz}Du>$1T42e{-)
zgJr4;yCU$GeH}ZL_SLevBrc20m#&DsF9Sa7s=yu_S?8?<tf1mAnMQL2&QUtQCU8fS
z1f8oh)Ky_!qcC?};BuR{Q?!TX?Rq)hxB+uR;CQ<Y`nBr{H^e`wkC{hpkDCHd*awa#
z54eYd3F2m{LxI=2C2*taCRTzSl&-Zo-qPmiwTdOS|3N2)qtsLMSq&x5clcdNl~+|Z
z;?!bk=ZeY=<u#{hh}o)S;u=X@G?WD&fStsyt`Hi@8l{}8vBb7^JA6BBqDgBkm8W>E
z5{XN0viqs)ce|u5k+eH?UL+2(%^<@SRTKF*-LtZ%H<frT@xs$CbehT<Y0o{+Yy`Yk
zGl`8>7E>l^Bj7)5+-(HR6*yP;=aJJkm)Nys2Xc?L0_LmWLnDFng})s^w2-)e1w*tG
zuuVa<6R<$w0u9kp;sOQHUcg>zSR~VEp}>X0|1Nc1ByLMQ75ScIu|L{OHkU1AOW8`^
z?&#yST1#xPnC-fQfPZi}=pbN`z(vAeJK(k2NNlC%tHTs8%Zcx!Tgx``MSXl|EAhe#
z#!(%H5{$mOtku>5X(w@W;vwC>>uM*<pP1WA9Datond;6g;IleNY~PZDQbz$p=oFt!
zqs0OjQ`GWW9VIsH!b$TVu;U?c3Xt~loyr|#M_K-4?z1{c?C;2Q58avQ)ZOV0((+lI
zCH82+ifSvMAB81-uIPMMA$O5@)b3SwqO#9tb(MH@dQ&orP6E2qStFT7O9U<v{?~oU
ztUXT`S-GnW_^fUcH%@Lv(47TrAp=RK(Ncj+7608OPPO^pMf_J|H9b(Po9uoY=Dk)A
ziQU_3ftAoPS>FNmxDB+=>M3zmaeLaoi-45^D06iYuuR}G;eR~fwR%ZB*rYu<!8_2D
znyEgkx5Rx{xlrjUV1&|HR{_ffE+?9ORv(GC9HkB?qIC`1Q}&WYy=9*}=&i5B@l$MJ
zY$qjD1G*r5AlCN|%=VMm$L<MqOklR(ZJ701{Ur{!Wx12cdW2<Jb%N-BTlfJIk1o>Y
z-=EB12crRw^$(OdwSyM+5ZYfG8uj4@-WKN|iCt}XZbv1zzW5n*2R9xpu~@}wb@LPO
zT0<o6Kga#XZ(s_YAAQzPiN_tuZ6(R+N`A1cH$)D-gY<?;9AoF8qoiA}HC$pJ8~1Fg
zfgWdjeQ1~*etR@Fzy)y!fPmK;A#rV~kgZbT2x+kojFh-_9eYeSq534rG+H5Wh2UP@
zD2Y4mUfpRr66wNhq#PxkhMdnDEpeZNXCJ)}<zxM(jFzR~#z^ec+OBGPnp~BPmAJ8l
z3z_bMPbDcdSSfHN7cxF;oW$MB8<C^*p!m&>(nG*1fvbf7F9Dx5UgG$b4A4`+HU-dA
zz-oc36~F|EU4CTi?j@i*^;(i?v_{|>avQHTQR2=Hx+U2t$!$Q6kz?gJIbKeX6(%O~
zJ4xdHVH`Vq3z$PK+hiK86}XlPIwj;ul6tm2YqG>2OPJ|C0=lZkOCJH>3;do+IiEE}
z;<aT=e-8n(NcB2!OqNs1ZSJ+EO1wUq<3bfUr7DDJ5?k!!im0!E-SkdGGL6;=T&F6c
z=@O6F&B&MCTgVAws+=aLQ#hO<anNx-L-Z3cT7|=Y0@e#$uS{X4#HJm!jM|Wlv?<Jx
zGhNYmtyvPUUuLlW0^a7--Cw{4fg6N>Bl*y5iI;6W!xQk#lCxbrK5LG|)BBo{)&~ff
znZ$?&2-qZWlSVXG;td<oxCBIV<lIC=^CT|+o)HZce1VykOry;LH&YABXU&(mUI7de
zu$NkGDKy$5a0~C`vld7kbAV9{5U`N8(v|Z(IbSX)z1>2I#mh>F?!f|1Ds2xIuvOqz
z;r}S$vldA_wckcIpOD?pzEXLiT$G5)Yb}=8;uhEILj?7S(~@bhP2e`+|3koMEs@ye
z44d^(0kf1@4;8Ro;C3==pS4tC=h2)lh6$KUGEAn?4uLzAPM1ks)QOe#G|VAV9^{zg
zT`ZT#rLw}ZL^&>(*xxy14pYHzg~a9S*bjyanCfTO94=s|z@3VMl@j-#v`Jh-L06mh
za=AjTEVsuhi5q6JY(@w;cONT#gn(TFcWG6umUwF_voun`NtNSA3fL`hH?ici)<~Q^
zi$hu`0sE+<s8h!(xms3OL#Dn~;+kUKWt4z^6faU}v`63`z03C!_fBSr5ds=hovvT0
zSu4MH(5#bKGSl8^CGDiH2G`LZ>m{~a!)7pAz-3ijjux<2;9g~Q8zgR6$^e4}AF%>H
zYoo*?^Lg7bf_qtMDKy$AaGxe@lf<3P7-Fn|Yl`%-0`?2suOT)|T+@&tMhO@|!9?qH
zz1$!-%1v@}0t;Ito-DPYuL_u8CRN%}25_syWe(tI(xW~_Y%K%0O=4@u{7=zwqbe5?
zsoTnJzFp#Y2bA7OwvRR2%Yp8Y*rc(|)KFqdV_nFgI}%vhDe<V1>u3Qdr~=je@4OBF
zyCjw@V7y}lj8|+?*;8p(8MbyyTrs0LdG$B}gDE<u(CC1`1Hylh!rC5*>qqgqZM=XY
zw%qXo4hcNO06uH4#1>;2#RLIUmFgx4I4tn6hS(>u*;=M%kbrY^Gv>4QOKiE2pN$bP
zjwsYs%Wk<x?v?xG{xXyvkT}QD)EHWzReGQd;6aJ=%K}o9r_#YPfQKZGUz2F5ww?~L
z@DuInu*A*|&Jk*J#(B65&L1Rhb^xhsYunQgWdM&zY^ydOE#Qh$Cuzug<TmO&Dsi%d
zb)?#!PF9tUmce>VVp9ijNCMz7xv7*j9hZ2}0ZgRxco~c*B(7fDg$!h(fNLt$P89Hi
zz#r(67pxy8PM^b91pI!weV#iZf0RHy7oT-f;>~%sss}5gh}B9b%Mf)+;xLD(L@A#t
zL)1?aXF7n1Ui(ubplu+uI?<C(OPs%$^*&m_QEImPtTPf9sArP|@XI&JG&&;ih{|qf
zC6=hPJz2m6l0yoOjtV@=0m^Hglep4u;&rBj8(8Nh-rDQF>Jji+7bFhYV;3}gC;)4-
zKP}J5v+|s*T%EfY=j8=ezFd^p&0%$l5*}OL#Y9#EKI@Xi{VG085ztQs<|zV>2|T6(
z^JR(a6@X^jPFa`a<+3(sx2J09x7vJF0zT`C#5Fg$lA0=@kJ@3Xfa3y>Q;PChS0zs0
z$%mU7u&Ih$ja`vfB_IEN)-{Q%+ORE56Tt6Fq|oSuz!NM+pLJd0ktPf=N`(`jezWVE
zyq*vaZ%Dk{iovD{SV!?#gWV_vc2nZiQv2CpH(fAa73ECi%ZYY!OX3gC7Heq>UHsR&
z<t`5RtYQO;9Tz!}1f=JN1|IIt<V_c_U&Ynw0)7<uqvo@bfg5IV!k^)^nP&(%De$C*
zXl&rr4vb@_fT0S<OaZ3^o?-~ERbt>8`vvA})O++<O$@v`mTT@=0`^gvmO`VS1pXxa
zrzxN}HE`6GL3I3{Er3d!6dIfnct-foQn#y_fei`3v|i=+jPwDt*l1`pGAcASN{l8(
zQ=^$dZ9-oaTY6-ViPCFsVArKg{Tu;JRHJu}fO7)RDUWJl;5r2`SHM-O@=|DYUf_9V
z&u6tXa8YYUF--tn@7n>oxzWOCX(XCMD+9NWV9<F2Mv!f$(CC7|3mRE#12^pEifz7t
zi&TOo^GM)DRnoOFu=h+>$O5XnIMXc<a7o}LjiRlA3mwy>&W24-E2Fj1#%OD}HB>tT
zn>x&0NO0SBWe9I?;Nk-<D84Qf&|mVd3k6&jcv<+bkSTRA@Yr^yYmtB*impWht_r-W
zAvzk^Wgp{MEYvk-3XQG_yrv;K88~Gwi)V@8vsGFOjjjv4u6gTh;DD|SF<n40y_)ef
z$C<|$%JxPFqodKu=zKf%2Ygl+1DiN%q6>K2$GVhKQC9;;IAGhzowUbxEd|!iz(J1W
zZY4;rTcYI3$F4-%>u%tgCCtoR0p}8MbWg+)@L4?!Jl~`pNq?!}uaeS|X>>#24dJIZ
z`Fa|-vX~nqPpS(XeL(7A^fc0*d;SgQy8xfn%fKzS4K=+=@z>kHK2AW_NshB&Z=-aI
z?qlHgsm+PDWdhDA%UCAhrofxJuIg*xc}J`JD49IYI(w*((f5wp>Sy3YC#p?TYM@#o
zxnC(V`y04u9E)(dfC1z#DKxqz@Rqii0S1nq&33s$z+&ZcD+ClvES7X4_E`fB>^+!q
z%oDJTYMjTIKFojR)t~n_1{hBbEay0b4D9Mi@t`7)@?G+vQsfObaJ(bM#ENKe87U4i
zaQOtLVYz@&6eGbJYT(6j`YQe-4%fpBT;x!?iYV2Rq&j?vF~AsV3@b<Ka053uq*5-k
z4SIMfQb!m#v?1$pr2u++BQ1qS4J9^|{zhblBMn@0i)mabU?g?TeAXxfe;mTkRte~%
zw7*I~V~LIRs?i26Q4sS4Y$KX=DKWwrX^b*Pm!a2djWMv(@@5qHR}1)#&$O!rlt?U*
ze1IQoU`Lw2&srm3Jms5Y8a0vFL;;L5u!-YVm#D<?S>p|yJ%{OBBA^ku+LLTfkB%|M
z8sm)dceKL^29Dm(@p!F(QL44GRzOpUO{M?UfX|v};0PyRU!jW|eLFP4m{=y-PBL)z
zYHm4yFJK|1l4Ke+lh{o9AE#E8foldbmGcBlBw6X>`baU!m|R*?cEwKT3OA^LHO0Vn
zi7$TX<JT0Uyb(_|u*U%2Zk>Qbl>1U>)Lde7?HbbzoHd0ZMhKWsuB#8?Q;lhceV(6g
z;38GA4Hj^md_hZKx<LnCmpGp_!@!%48jce_owaA&K>=QCrh#)yeR`msbEfg?ZJpEJ
zTpf7b&Arwv19#gm>TXoc&)Ehp-lbp9Ehfsfyk{A+ZzHcc2KJlIp=6|h;#3g6$JmI_
zcE5x`F~^{0hu4~G;1!$v=A=<g{@go}uRXfm9c|KU%`>p?3{5q?AZzP*-fd`}Z{Uti
zY`^OTT%z!oOrsVOTPXWoVBn=)3@~57`2_o&Z!9QdzY7hV@8rDJ)Q;A~F1!n|iwrz8
zm*1sKhxQ}@E#gJSFJCWjl8X%-G?5K%xlr%->UKW0`u5AkrK7Pe<Ru37x4+YvM=WT%
zmKb-4;5HH66A7m;LiqN5se$XaaEJFr*iCHew;`7rx6KA#Yng#VH|hmz5*94G{Q{r0
z+`tX1`D`~>UAhH))(Qj9JJRh+SoB5Qa$`jznTb_xz-O&Au)7L}a|K5`o41vTiyYoo
z8Q3lHYg*fOR+Y6K-$UR5Pg0d`w?(tsz#cRCE_#FDkBd`i&{ASc>2F2JVvT`a=W;sP
zDEM9`Ermv{CAOB-vGG}J4eULfRXtBY2hy6hjMc^(W33bHSjWDH*wLz#@(Rt9&-&iL
z&PsA?1dOFSAbq{{ed*Ay7kI682ClXv!5S(e_0H>z#4yV{2Yl9g0|zMd`iS6rgiE2S
z>x~w-70w0&*Vtd<Oe4nh8x9+cR}yVr;rCh_4J@`lW~Hww?3lRGC>!9^3ZJ#fz#fVs
zyKvMDY`P6SU~M+A=|cS~%C~&!v&F!Rjk#X@f_q^BpS9J%8(p}ax=BE9s^61o)J9?(
z$u;IS1NRaDec8-Lu3t~vY-};M8ruxF%Je<KUCc+y$fu0qZa1)%Vq%SeF-mJxLRH;<
z2d(We@Vc$FEeTrNQ7Ty5GTLe2S*M*dkTSk*neHr8dhIf>?`*ciB?6iepiY^)+??cC
z&Ta!|%-7M3K1#O3`R?-JToK~6_82(W&M`NrcdF6vN$@xY>$CP6*wU#NhY~HC=)I+g
z_FDT4Tw=eW{sZMQpS9n>woY!nM!8kLFR?Gds`r=U$!8rfaOEs^)o}vm(tE8w>!5){
z=JT`70?tyAl|rMo65DF`J!D|}X$-MUU9{MusCB?NXdFr`?X~oL)?ov;Ut&>j5wL`8
zEQLnxB(~Gl;tvLX?{tJGkN~Q)Q3MVfKNwWuIw|&coE$N*-B`|LTLmm7s*`EdUSfO6
zA4nZFu!Vh2>Q1`Q=cFUX(NgCmyNGaepwf`nI%eQ;+qY+tZ)Y%lHI9`_H3<ZkvHar(
zUfsg4Tx=6C<UTHOw+ZMVv4i9{UrrdfyVUFWx@b6VoG6=76kR^+M+0Z7TeR&0dQl;s
zOrwqxJF2Sqq=9o3z#swJDZS{-`lE5uxMOBLWneEmvn{7ZIu)KOONS~3z1B|#_P(8i
z{B&mrIc?yTO*(rvp<6J$$LX?r*u0)GaE6K;a|JXfs&sldbDQwzwaywiW&!)`4#6KY
zrqH01#7@%RSyD^Xz)cDuT~*!sgmTt6SE@*{_djpo=BaGPBLoa4PfLYVNKLBP%{Xt^
zKo<<0<`CIP5lP{#%7yYo`ck0+R7k3LAz}SR1LrvFnMn<F(FU>~EHuvRTHI@0GO#OE
z10FgveFxOnr&DvKOMJ|6sk?087zaDIFH$*XSG=46bj84i4$wJrMxAD^lxKn73pDV8
zbM9jBRNlPeRU4--6)Hl-q>AmF2fC+8w+Sm8Hhk7K14lSJYx0PXiq~u)8}~{Fl~!7r
z<D3(Ft{b>>m0fbt#jw5Ldg<~?EwIHwvSp3>yeyyOg-j<u3izxW25xrfq~@Sa){O)@
zndMCmomwcQYvnXP>!yL1%Sw*!0W022SVi5Jif3%R0iSit!1>GA4Ce~yMi!<IXSbYH
zT3@B=bHyMvgiUNiw!#PLag=~{r>oc;=U_;M``|uh**3KeP3)_fw(BAN<z_>(g}pA|
zvl^LrcoCDgQ>dTHNTyL2iCv_>LcnJ=Ht~o8m@8m8nU~(bk=fXEO|`_tRcgDrLY+D^
zn<b{Uds|uE?cHq|lbtcuzEmYXg0LTuGqU;cgMiO!V&d7-^3=(fB4m>Uikh0(<^VS`
z7pgZ(?24_a*`ag`QpwsTSbtyr+2=NWq)pqDnwhw@cWdgSH5bq_mCLl|ChnQXHx<?4
zppU(osIElsjW;u!oBXz-jh)27$ZRoE9i_!+^G{aD?Ai~=HTglnXSFc#u;U?}66~Rc
z>G-DYuyh<Fk=Scnn%Kn&i5(~;>TCa&CWF{CQAucPO&jOM^1;LwylT$a@Y*`a!CkhJ
zAvuXdB5xD$S*=WL-kE!)yVQ+KS~88gO6;oY*w!X4uxsCmR0HVh{Df>}wl>RDvf5cG
z?67PDKC6w1lN@{Gz^?7FO@fKEHSw||kK<G)XnC|XZ9MHv-0Fy%1Cl<qwlmAMvXvdt
zN4_R5o~kWkd%}x(?X@jv8L22`i==~zot#VD>vRU!hTXy3;D$4s4axxa%8n+^DBar8
z8+2roU{>r$%G~UgolM-(qb-^9ZUN`$TjgXLb(7dl^&L8!xTQA(>=7{PSuTS12<R@c
zI{|pDE+%d%#j4)AliAtqqS@8zxnkQ0y@hIG8^?<;QB=|D>1u}ydim7EJ<~ZhjS$c+
z!CbpJ>gjIcz!^43ZvxSEJLM{+pzft@n@*eBR;g!i;uVJu{>WU@(IbJ5o+e&(q;%;S
z_xrb=E|b)=H*vrLJK%JqK9yErFAg}Gj)2eVZQ?@b?HdXr`kk2GW&o@{CY~w%t3eb@
zlKPnT?SOrvOSnR-OdtJz_Ibc(^)+!?sg{LZKlZ(ixzZ|M6<cF;59SJ{pNZ2Z^1)%R
zP(P@aLZcoMd+4J@e-jru7Y09(=(T6`Gy9u&y51RJVx#Gt-}k8(Z_-j|)Kg+l>F-5l
z-ar!@w&2eI_Y3$PUt#SR&|6|}>F+}TgG}7mlmQM1`bsD*g$8{k_SFD`O<d4-6t$)i
z#*!MeN(Yz&%|Yg1vzq;Y^0x8>uQkNPb@q4p-PASyP!remW7}FM;EFoF4Ks0oW0IqZ
zX|3Z4Vu(4^9Hwk7;IoFCILW!k{Yl;9jxh0RCp+kEA<DF|4mU^GK~2XHpEc6N3s?D+
zbWp%ldPg9cM*SrABhT|$qf8t#miwHC1hh|P*E~eme%N37U#Is?O}yHRdj*FDv`_$t
z1q_flKmm*~vG*JX=p<kSbxO6QMw+9{3Zu<2X255SHSyFuHiRDp{79#@6dDbbI8YnH
zI1_I<rqV;*IE**3>0FlG5}{hi`nWLG9A}Pq%|qK@z-LV`ap-lM-!)16!arGl#R(2E
zUTdO>>-O-=en$k*7n&(F7$k9!RQH>cOgwPN_Q9znVn1Vfc%nIpy)fbC(cOEpiGwCH
zk4J_26{{2)4VE}q^Ek!C4r5r@#{>*aW?>%_Fht@ICCjNMZga^0p2*jRG1;7APIXxD
zS<_5B@9agtW@iIVD+TDarkl9nEGLmH7*5~IXoS;E=M(y1-GI-UVdD3tSPuBCnI>LU
z?=&70&?%X(rDmCUs3WUnrci~XR>=%=rcL22vqXu7G0!%!xFf%=b6mhOQhhRwhDsbN
z`8OHnm{_uze-h_}0Q#gWg$BbU4wL@j<g0T{Tr`Y*^+)w`W(o~PNE{*kBMD%hiI--u
zuRaKSsF=~8GR-#Um~+i}<|EYtUTeOI+rQ^;w!_e$-uUub3rsw<-rkws4$)`t`Q{A%
z$hw01%DVCb8;j3cXyX1IEhyKW6mZ!D3LGZ|jFLD?`bU$`E;4cFHikGQxZ{|XLZdMf
z$7qPfCU#rK9`loc4)n=<GL6Pc9IMP=iHRd7u$`P1usDV7<g|cs62~ckr6yh($QaHD
zSfl{X2pBJMyaHHe;@rLra9F^|6u!P7Kfs0NB6G31#H_H?TvkR=%T2sgiZ%PnWBHxe
ztT6GKvxcIZ?=fyA<BB`4S!v=#XU#ck?rE{Fyz`n>Ca!RVx{}sZ<5SZEtM0_jY7@^p
zyO5%MkMX$xSKoP;H6|V{yM`L$xaQ7l)|xoTS#y>s)7-4R^P2BXT;g!Eg4Sp!`u<Mb
ztTXZGVAkgu0oO>M`rd6_IW?{~abRZ-LuV<pu!Wu#FhSx3Ngs>)tPLh!9?Ne{oztzk
zWExGBI8pk6UXC^K_&^3YFQ6Co?viOVN#Z2wr!c$8#KVIaps{)*D&Vs=n|NUo8|?)F
z{pq(zl4&$q;$&r$TTC1`%;tdrd{41WKDOT6U~V)wne>|SX0yVUax85%ao%ap_ZI~;
zR~NGv1x%4RMK!#(nYgc;%`^Rgpzj$*?cZu{`@fKHH*tPP_SZ`S+A3eVBw(t<sp{;y
z!^Gt!e3g4yz)mHN%L1lJoTjdFcba&!1p{0WFoq<aOrz-%rz?P6CZ2P|HI2?8n)B`E
z4s)lu>&~3-Hu1=0Chn@>PgT-VXf#9O4C$Xq;bxDChvqTFH35@p^AsA*k~m94>@~4O
zL0qRm#RhR*z-)=LHN-v>Cp(%MQVE=X$!>Fxx!2rRP9ghE968_KbS5Q8eZbp)Tkr!W
z&T;Iir{F|#(8Rfu*<5Z2n5@j@hJZN|=O}YIWa4!Na8tk}1#nZqT#0iPz+n@&J5*03
zs&$q=U~V!Gnp4d~W`)D$NdLjauH)Er&(UYwAbk3>tsmG1@30Q6BPJePpf6Tp%)wC;
zFKlEEZV70oYO7lU=1H8V4Ck1MGp@5$7E8ENk;8bgg!vNZD}duB9+}9rG?Z{rSyn>{
z3nVU3j(EbvA-x#GS;4P(Q}@@zMdP`7&`81>l|33sSSWEJm2_U~q=^f6amud&b1186
z29KCW&12?q^Mv+@!=jn_qj}P-nfcPo^zF5YE1jq?QVE9oaMe!TO)x&|ClgOP)<2qT
zK{wieGIy2T<FtuW9Yg3rduWxNzMIO<m^h#@``2Zmer#29bcUVh4l46mXH7iT!ImCh
z$7r`Zt0i#9mFG-6(UNz(B485nr0-{A=geJqSZ1?AY~K;_c@s}}8BFCvV+qp@Hi^a(
z7D-$r{a*yU)&&zgZ?H=e`Yjt>%A7YZ*hL6f7frk{pI_pw3iO4a{zcS_CjS_;*Sch4
z^Je^le2JvaF#TMBgvAmUOaBrom@b>Rp(z72k@UrSS_%!8N?gh*!fRbIaYhLPG?nlH
zhm58YmPuSj0QQEL%**B#D(|nF*rJ=w)|`Y2?5az)*Scn6{~gR*GYRx*ehLkiOI$Af
zD~PP?CaxN87kclyZ|hz&ud6D~XWcMy<6hQja|shwDrhcYrNouWr*4`!d=~?>ko-MK
zS~87RNnAw$Uh9^LgHAAO9yqAJ=_>YM?}o!kD=j4)B|l7|(Q1jSrJuiJY3RYL=Z6tQ
zD+%<o3G^EP64pvwt05YBu)|<}jk>jj!3sxf3ExZno*}$eV-KDl#N4%!5MY_Mk+4qU
zI$g$=c<_o-=Y9afzSO&6-ZXESb~XA&v8SP@k*Bez#G@<QCLZj4ihpXSt%Q#maa#%N
zC9aqL4J6m59-LwSZp#d6ljstqiKnSY{Xk1OoXtGg&B6H*$GhepJalyw$)KI&OWCw!
z8f}!gQTm^vrlJQsU1osx5;jn6oJ^xl5;qZm*J|m(JxjSxe}F4vpKixBv*{Qjn|oS#
zT6!LSq?%7h5&p&6gy;0JxCi_H!~w1@%&Q9Y261Z-mh2utr}Yk!e-<c(2Ad^rmi|^0
zHQRWw$Jzlzd`Ahp)VnbqC2WznMfx)WKC7(<=QLvz?j&KB(qAVDTP1Fl{%w?L+j+2=
zg6J$^2tg#%XuHJi<hwqry$AOVWE5Sb`a!>B8tss{L;4>Ic&!c|oJ0T~tE+OmWE$+0
zxKsM81$<UV4>rEZR@P0z_q0O_jdn@gCCLuGRwoaxA}jNd={)5ouU4MHVu)z%Y2#_@
zY3FJ0>EP+;>Ev2SXAhn_$=7b(CFHP$beFJO;%-Tw@O!N;9=tkVYo@p9_NM5!jXHa}
zkV2^6=D{D%3?d=+kkD1p*F(Y{iF>4fFUhEz2e&t25%iR>TS4@cuutMX4bk0$#}q_o
z2^}c~Xd~$A>E`KPp7b6bJT<O6X||VyUoq*uB<z>CU-}P_argA#;01}K>+Wk0PfsS>
zYxVNr)PXjNFM)mpjuKmiUK+w@_4Z)%N!^LD-V*p*ixe6ilz33@(#M0v<82(jVw>yh
z!5Itn#{EfVsa$hb?Ct5}>8rQy=fMGv8+`)wE_;6uPO|?y0(2nPcHYnSfj9blIE;fe
zz=Lad>fgM4i(PP_2OFJeN_6&-utcSgJ`xT|JS6>J2Yl8b4|Xc%!mO`^WvV9WE8(!j
z!xa5|)?g1Vy20VGpM*gQpr3>vB>tcPhIsJCLau81OXy2ZoI;}`5|8LE#!wHQTf`^^
zNa(5{21qz6@hC%htzjPA<z$bK+#l%};2G!{<QeQ4;;AsyGt5H`E)UMw+=dt$D52{U
zoDT;|I41F!DrQD_aONid_WZwa!|z^;4EK!iG_$Wo=x6*q*l~ChGLs}|NEN2n8s)(?
zXZgjKZ(y8yG}?o$R`Jg!4U+IF8`B^O$0Z(@^y^|iYm5gEEoToLEMYIDmlPVEka&V2
zz#8kpsiz0iFYOd@e%8&mk)Gs~N~1iZJ!3p$Jxl3_#(dT|56+oaOw0|D&`vqS5D7m@
z{87@cM0u_89_+n<f2L`u?UzF(oRoM{`Ug|kn&83H%ZCt(VUj;FOiQ8BDT${vJrg~6
z@r<UYn)}1q<2>qzq{e$DcqS@>yw)TSwzJ==p`R}ec&*7Eyf9e*9AR^djckes=N{(*
zbGU@-^!t3tH2O*6PtyOY{WaAj&t%UO&lDnZst0$gU!u^z|6vy`Q$6&{9R&5T*Ah@%
zOmAZMA1$k&mOmE{SG6P*7w_4>|JLJJJfHuqenvk0h-DDuwOjN*fyMppVfC{z^Z(1N
z5DOL*=7(aLo~%ewIG&l370jv^@)zXAVxd^3RS?Vzr$>vznduqzA_bw0!dOv8ZX`b#
z&dtb;ypUBdHzOX3#WM;EiZb#;!LKsnp;-Kt^xR11<I$pUJg*>>UOla#UMN^tBR!TC
z{3aC64Sg8N`YM#2`Fuvb+arucvoiGJi~?Gko*T)0RzE3^?t`3<L!s<Y_J<Kh>n{fw
z%+HTx)h-N%H3Z%sqE10(wcF36=M;srYGzikXJZXw@lZi59?beGGviKTN#r6JE2tAJ
z$bRMJ^jPKtHkRsX%v=pcUn#1xLg9Ecm|r73HyWvbZ(G=FNLG&~Y~i3{wUQJ{??lS3
zksb}@<mKmQzHl$h6!03_=i$VC6rynG+xUCYQ0N{}v1$kv*r?Q_+^kHm{UjW!AF2Cg
zC@Y?s6p7Ja@8#u(GM~E}sgYPlPF{YfPEk1TTgD!VrAG=wVOsfdBtMdynH-6wf1;mc
zK64Ma2u;OEEdA|hC>Rg9^oB$Al_5NTHzb;u3<f1s74-g&GBOGaqmi8SP=3x^MS1zz
zAH0+K;=Lf`RT-iD976iIy$wH2FAPRwp<2;MR_#!J&PTz*SZ3zEqb!U@;t@jnTxq1$
z(}>Qz{1B5FijwUFvp)(J7UqR>%Tf>y)vpzeBtU0ARvKGjL6HXdBAOQuMgN~DBtnQn
z$5IM{Uxi}%d0C-*R0e?(f=6NvVp+lb{PedP#6z{|>3h*gLG5^ySW3T}%=AM0Uqbef
ze#XdZ#iI$RD%(?Ji@|v2FYg8QcY0Bs{Je0{w>pgEMlw_Mb2j75m+u9YUZF4%4kw}o
zv%f5g#dD&;f>7rDT1Dx(9EGw%bt%r>lQqVp8k~?jYRQTeHekbdQ3tcWF3O9BY8Pck
za_{cSni#T24ipZ_u~31=QuE$0&;p{%r%@(g$V|1L<!0562cz-Kw7bbu17{TEGD%hS
z-|5xUa{o{iDhky|FN_qrl;-9~>PCygU+0G6t^{)O!r9THa5z{uKOvgLvg(Dhi}FJW
zizEE(gMz~R#D|5^P^h3VUZ=nnb3r5;QesZA35vx-h4&VTV+{)8!MY?KM-+uw-vslE
z5=be`$_~bZWgg~+;<YIeeiTgLnDS+;FguhV54!jYLInkpZ$g<b-IHh)ur~Kt=7Tm%
zR1dtB7mw8r#XoCM7`nTA>O~m^b@So{L9Qbl>#iM&zn2#d=I4DEir$-y3UUaZWaJ<T
zhvJ2i{QRu^NGx=BAGAr)E9!)39pQRBFB}g=!@>Lvexl*(&>wFz+PelI4Q`_)gpZX*
zSUrtUy%UOM)kx0^=fyK$znlC^t<A{EW;*KVT?jjtf=I8P_TD=+(mx=)cMU<MRuNu1
zH9MkIAt*bP6N<)M3(k*ZeU(}BZWL?UG6=FxPEkC>k<D>(g*GexZQQlQNUT9#C_g*%
zXZM0P)*z+=reli<Bxkcpun9TEP@-Y6CuF*FN*QmfT8WFFvg*?8u-vIYaXE>Gg4y2$
zqj}+kC}Nje?*(J=%*uLgdQq5!;glBX92K}g({-LB9iCBiIDs`Bs{c_i`V~1@=0i40
z+wItdxQcWtHXVfv?yXMM2y2opRf{zUXE_|#b^`iGq{Yk!c(!^P|5bx6p>}?xerAok
zX^qxo6wrFwz(;?&D5(B-iep_Qak#Jb(dW7h$$VN9m|i_C9t{NxKaOOFYNQtxW(VV;
z55gq>U^pJTH(m>Jv+{${T;(?|-h$5vagFqXqBxb3PH3Z)P!OT;PjR-;l`u_ENOeK0
zr{xyqh2w?sXpQu&;60L~Daa(rI8mMwQ(;j&vyz@=Gi%`HwA={UT?01cn(i|F*o9-L
zFY@B`KFcde$QiLvK{S*f3dTY;GaqDa=zU1tdL|Qj!qK!cU)J^grDr}5vtc{=EjN-I
zacQbko6lt~E4ew8avehrhw2wbBUv?FqV<!q%<0GOaWFUQtz7a6HkL0U(XUFys95lu
zkbA6)hC&q3b*<$Fi&9TPPp8*bmFFvWk3|}q&yk5`U@Ws@L8u_~b=^pIgUnyt%`cqz
zTem?x6wJ@f2z^}?%y&YXQ>)br#%fWJ`1amXVvK8KGAJif<i(U4-j75hMe)3F$c;8x
z!B}oA9*h^oT&0D+4P_O@LvHXY3`W1Ilc2-`s?6P3=A4>iAr*(7(FWzta6F?JMgAVj
z*4lN>-QiGu&NBQw^WKgMg~4!M7O|OVOpL`99sfxN=A44aO|vMDz8MXLgEi9Q(FSi)
zFCw$5qYi4G<VSK<5r5apsO*vqT9zBhtejI2C!T6iW(Y+ytKZEGath)Zg#<_|lW66;
z(P$)^bN8T1t3m`9qh*e*P;-LMP>!3{ibV2jq!;Fe*?I3u2|0E~VI;yO3(#Nb)!p@F
zp1dE5yRpwXWU#<vnNMj0a3vIsM+)+?(rd>f(U1<4nQz=pEO)@b{$}@WI7pR3T`R&m
zxx4Gys1;3h3e_5tV=9TC&Iajhi8Wo@(iyeT$yMp0Z}Z|h2;>A~@j8Wh+4-S6PHTKl
zVkxuQP4x*AnNMg+$&a{JsF7Y64HX8Xq4y%u+Vw-BLf6N$L)k@HaenxAG?bkezvp}y
zBSge~n%+*QVagmT1?PoxYkl<j2jN&eT9g&fi-cpY#bwnCWqp+$3TC@0prBOpip3*^
z1qm_N72At$THqql6$1ZRKloLssPNv{i0Fcl*l>(bbtB5M@pgkOYOPkv3ulMErO?Zf
z`qy`}MYbtA4iGp+YG<uuicS!s!XR9fpYH~@+=vRv;Rv0&6CjJiS>a$oC^7f((S?o#
zp+tEG^K%o>>BOgUo*T7;`T4oQ>}(g13rTWk4!&;4Cv@5zoeC&7>(fvy6xRtgo{%6|
z6|sD>wMVplq=zH%P@JFDu|?yecPHIsO*ZgZz0entXnr>7gX&6G`E~yIPVG-zxrBq^
zNSrDbyY;ITSvwvnOsEQ<wW+C|mYel<Bpi=M^7BK{+El>RAm*cSR<-LQxmm>Dr;$j!
zmhz&^dpgGz<YpBFquf79kQbr)EHA9GN6a<d!eDOb12U~oa$K3@MnesB!_=ws$xuE~
zO;o4y(<f0kio~e%@mX2PIo%E28ewf_x~M7RMMJT??@D!1-iZeD!j4d#0!rDDM&Xz-
zaU6|A5>7C&!eIE59M|z<S;25!uKlXony?qW#g83axuG~UMjB+^tGMe&qAYHwJ|Gnn
zo%*=!Z0J6xkmG>oW^wECtza~o7mB(;m*}J1|6U~eW_EVMgwn9v)pnE=q$+{cnOW23
zk~V$2ti6#oKh?dX_unR3Ls6Gb+L)wC6;Q%;LvGfau~=R#&J{>a*S|_VXU!xO$fYJ-
z)5(g2zxnKym+!51%F796@e$|&+kaK3BNUB>Bkx9|nXlecIHWEHRUzSs(>rif<D5?G
z=EY;KK*?&fCpbk5J>y{Ih6H+)5c6#LX<0bu;`(*pD$02;zbIC(=Diii1@-IJE#eNf
z<H{}$jonecJCk6`S?oq1yNqT9!_>x9-BUN%kd=@b)JU%z%nydMLarGSbKKV@J5RJv
znqWa_N*o&N=7odN2DL-MXjZ+?=ql%)uDA+vvlO=6h?5l4tEcg^+F8M{4wZHJa)Uya
zo5F+H*$F1+=#qLHt}M8>8I9+<`iRww=7qoF4P16}vsgoK<?6b`;VLT_i$`)b({uuH
zs-x;@`8kZGMtWgUtlqr^4!wl9bwW>Jkq$kMQr*+9>pS&=;p|9GPU1Z!@17u}!lHPs
zc+>&*0}1>sWAr&$b<3UYD5X=Qz%>K1Tnahqc`?cuq3i_UU@RUDhO_U@Wn=N8x?Jl!
zLQ(<w^DtLnq3ld2Jy%a7gQPrHBRxCxHMPIpU8%W{8x7WV-H)Ec=mhF&#x>q}v;kH6
zPJb=lpfHrJJHhv8g>_XJCcRY4iWC$^L$O#!?ss{G>DALXPDgcEziUsi)JnBHH&Pbi
z$D#TP<A<SdLisM!Ig#kQ!K`|<Tn<$&@J=KgVx`q|4aA*spT(mMazpW)Qe|EBG>#8+
z*%k}MU5&f4%g&1xQWM%~L%OKdrs*|Zf}E>@I^l?FjYeYB%FW9U)u4`8{O&g@kr-WM
z#+^9q%Zp^>(P2M7{nJn|o6y`{T@JjxEH~m3S6CFy4e<#io0<i&dknS=ONborV;ub0
z?Jg*(xF>Y=_h+GKL0&jWrwt`6SHk50+{|A+t$^I3MmisAT%6U@+*|jeFjGOf*sX>L
zK(&CiXTO=B?=CO5Ba`$}qRZ)h`GpP6=cOiTvk&uPakBJSC>nRu2L~Fe(sL-TJF$@;
zGevc>@<YLd$WuM7Zc)}(p?Hn-g2H<X9R>EStkV!GpmSXv4$G<`<A(5rDfj$&d;VWe
zulaw8=w%nc=@Jp6BoCHhf?CS~l-3U4eCF41mb>Ab(j1*JA1YnUsC$t2$l6@a$vgRw
z{8mwpx)Z#o3wTPUbWGO8gA?%iVI-W8OX}wGv&<^&zBzgMAxg6~(rZ&Se%BWgBC!mL
zt}(}l6W<x36ilHeD?gZ5@OHhTaKc@JBe<xV&P=6qYK-sR`Re@cp@V@l>K5hXgg8jw
z&kxe8r@h6G^cyebp1x1-!FZjp!QEzZ8vE2nmy22X(T^j)4FwBzU*;ZPcPI$aO6P3t
zG;Gv?zWnPB!EF0&hj+vAXoIqijJqw!Ow~OcyY1^<;#2$F{fnaL-MfJrk^Qfu#@k-c
zF}lPM&$}f)U<fR$3wlbgFSr)X?LGpF>pnx->&xnCIobNcCR(3QW<R_4>OLpCj&pTW
z?RNe}bW;q;^v2>*I)tRx3Pxk0&*@I=t}g^>aO%S4QI5D@KS(bMXNRJ(tVlHU$?x5O
zSlzj!$x{*3ezS&Vly}&Hg~%yg4<!J66bu&y^WEUgiy{S~FX|TM#B@liY9IAVO}eL(
z`gu`my-~A}qA@v6jr98Twv2v3#iynU3u~ljN4N`|<IwANlT`mPoqM9Myj-TgTB|6o
z`pDH84N;O1@gmeldolCrjCesIz4XU5d}ih=ul}s&Yp=bSQTN3cYi5ML4RJ5~mCXD8
k`b~B$^7qW7zkU;I5X%bY=l}ix4*&rF|9o=rmyV7A0P2z!ng9R*

diff --git a/test/pmu/leak/cacheRef_profile b/test/pmu/leak/cacheRef_profile
deleted file mode 100644
index 19592bc29488a7774b8902e8a87fdbd991dc4a94..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 43243
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

diff --git a/test/pmu/leak/cycle_profile b/test/pmu/leak/cycle_profile
deleted file mode 100644
index 87f7cd4af610d650d086e16cbc51e3ee5cdbb188..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3561
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

diff --git a/test/pmu/leak/instr_profile b/test/pmu/leak/instr_profile
deleted file mode 100644
index 8f353bffb31f3de8c8f30759955029862f7fe24e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5731
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
VjCg$J{|^8F|NlWo?w|`S008<+Fo^&F

diff --git a/test/pmu/leak/itimer_profile b/test/pmu/leak/itimer_profile
deleted file mode 100644
index e69de29bb2..0000000000

From 18a9d26a0b529172f703e0bbd219f11fdf05c38b Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 15:49:36 -0700
Subject: [PATCH 088/126] minor

---
 test/pmu/leak/test2.go | 1 +
 test/pmu/leak/test3.go | 1 +
 2 files changed, 2 insertions(+)

diff --git a/test/pmu/leak/test2.go b/test/pmu/leak/test2.go
index 3b04ecf6c8..44f2d77875 100644
--- a/test/pmu/leak/test2.go
+++ b/test/pmu/leak/test2.go
@@ -22,6 +22,7 @@ func run() error {
 		cycle.Period =  100000
 		cycle.IsKernelIncluded = false
 		cycle.IsHvIncluded = false
+
 		if err = pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle)); err != nil {
 			return err
 		}
diff --git a/test/pmu/leak/test3.go b/test/pmu/leak/test3.go
index b5e34d911d..89b4bd3477 100644
--- a/test/pmu/leak/test3.go
+++ b/test/pmu/leak/test3.go
@@ -36,6 +36,7 @@ func run() error {
 		cycle.Period =  100000
 		cycle.IsKernelIncluded = false
 		cycle.IsHvIncluded = false
+
 		if err = pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle)); err != nil {
 			return err
 		}

From a42f3ce033954df92dfcafb816b449eb7dafed07 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 15:59:49 -0700
Subject: [PATCH 089/126] minor

---
 src/runtime/defs_perf_linux.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index e66b757d83..2a1bf1eeab 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -4,11 +4,11 @@ var perfEventOpt = map[int32]struct {
 	Type    uint32 // type of event
 	Config  uint64 // event
 } {
-	GO_COUNT_HW_CPU_CYCLES : {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},	// index: GO_COUNT_HW_CPU_CYCLES
-	GO_COUNT_HW_INSTRUCTIONS: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},     // index: GO_COUNT_HW_INSTRUCTIONS
-	GO_COUNT_HW_CACHE_REFERENCES: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_REFERENCES}, // index: GO_COUNT_HW_CACHE_REFERENCES
-	GO_COUNT_HW_CACHE_MISSES: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_MISSES},     // index: GO_COUNT_HW_CACHE_MISSES
-	GO_COUNT_HW_RAW: {_PERF_TYPE_RAW, 0 /* will not be used*/},     // index: GO_COUNT_HW_RAW
+	GO_COUNT_HW_CPU_CYCLES : {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},
+	GO_COUNT_HW_INSTRUCTIONS: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},
+	GO_COUNT_HW_CACHE_REFERENCES: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_REFERENCES},
+	GO_COUNT_HW_CACHE_MISSES: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_MISSES},
+	GO_COUNT_HW_RAW: {_PERF_TYPE_RAW, 0 /* will not be used */},
 	// TODO: add more perf events
 }
 

From 7c0fd97bea2cefd034939f7b698b8ac4bffa8018 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 16:05:31 -0700
Subject: [PATCH 090/126] minor

---
 src/cmd/go/internal/test/test.go | 2 +-
 src/testing/testing.go           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 85ba0a1ebb..84ae49f8ba 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -313,7 +313,7 @@ profile the tests during execution:
 	    Write a CPU profile to the specified file before exiting.
 	    Writes test binary as -c would.
 	
-	-pmurofile pmu.out
+	-pmuprofile pmu.out
 	    Write a PMU profile to the specified file before exiting.
 	    Writes test binary as -c would.
 	
diff --git a/src/testing/testing.go b/src/testing/testing.go
index 027c3ceb98..07613d5531 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -321,7 +321,7 @@ var (
 	pmuEvent	     *string
 	pmuPeriod            *int64
 	pmuPreciseIP         *int
-	pmuKernelIncluded   *bool
+	pmuKernelIncluded    *bool
 	pmuHvIncluded	     *bool
 	blockProfile         *string
 	blockProfileRate     *int

From f43107436ac75d9b4942ccb8b2f7f202b2496ca1 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 18:17:38 -0700
Subject: [PATCH 091/126] fix a configuration error by regenerating alldocs.go

---
 src/cmd/go/alldocs.go             | 20 ++++++++++++++++++++
 src/cmd/go/internal/test/test.go  | 16 ++++++++--------
 src/runtime/defs_linux_386.go     |  6 +++---
 src/runtime/defs_linux_amd64.go   |  3 ++-
 src/runtime/defs_linux_arm.go     |  6 +++---
 src/runtime/defs_linux_arm64.go   |  6 +++---
 src/runtime/defs_linux_mips64x.go |  6 +++---
 src/runtime/defs_linux_mipsx.go   |  6 +++---
 src/runtime/defs_linux_ppc64.go   |  6 +++---
 src/runtime/defs_linux_ppc64le.go |  6 +++---
 src/runtime/defs_linux_s390x.go   |  6 +++---
 src/runtime/defs_perf_linux.go    |  1 +
 src/runtime/defs_pmu.go           |  2 ++
 13 files changed, 57 insertions(+), 33 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 26fb337f86..fc62ada3ff 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -2958,6 +2958,26 @@
 // 	    Write a CPU profile to the specified file before exiting.
 // 	    Writes test binary as -c would.
 //
+// 	-pmuprofile pmu.out
+// 	    Write a PMU profile to the specified file before exiting.
+// 	    Writes test binary as -c would.
+//
+//     	-pmuevent event
+// 	    Specify which pmu event to sample.
+// 	    To sample PMU cycles, use -test.memprofilerate=1.
+//
+// 	-pmuperiod n
+// 	    Set the sampling period for the pmu event specified by -pmuevent.
+//
+// 	-pmupreciseip n
+// 	    Set the precise ip level for the pmu event specified by -pmuevent.
+//
+// 	-pmukernelincl
+// 	    Count the kernel or not.
+//
+// 	-pmuhvincl
+// 	    Count the hypervisor or not.
+//
 // 	-memprofile mem.out
 // 	    Write an allocation profile to the file after all tests have passed.
 // 	    Writes test binary as -c would.
diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 84ae49f8ba..79235ef948 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -312,25 +312,25 @@ profile the tests during execution:
 	-cpuprofile cpu.out
 	    Write a CPU profile to the specified file before exiting.
 	    Writes test binary as -c would.
-	
+
 	-pmuprofile pmu.out
 	    Write a PMU profile to the specified file before exiting.
 	    Writes test binary as -c would.
-	
+
     	-pmuevent event
 	    Specify which pmu event to sample.
-	    To sample PMU cycles, use -test.memprofilerate=1.  
-    	
+	    To sample PMU cycles, use -test.memprofilerate=1.
+
 	-pmuperiod n
 	    Set the sampling period for the pmu event specified by -pmuevent.
-	
+
 	-pmupreciseip n
 	    Set the precise ip level for the pmu event specified by -pmuevent.
-	
-	-pmukernelincl 
+
+	-pmukernelincl
 	    Count the kernel or not.
 
-	-pmuhvincl 
+	-pmuhvincl
 	    Count the hypervisor or not.
 
 	-memprofile mem.out
diff --git a/src/runtime/defs_linux_386.go b/src/runtime/defs_linux_386.go
index 5e078b3b26..d9f49662e7 100644
--- a/src/runtime/defs_linux_386.go
+++ b/src/runtime/defs_linux_386.go
@@ -97,6 +97,7 @@ const (
 	_SOCK_DGRAM = 0x2
 )
 
+// The replication is because constants could be different on different architecture
 const (
 	_PERF_TYPE_HARDWARE   = 0x0
 	_PERF_TYPE_SOFTWARE   = 0x1
@@ -289,9 +290,8 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr uint32
-	// psu: an unreliable workaround and need to figure out a better solution
-	// psu: only tested on amd64
+	si_addr  uint32
+	// si_fd is the field right after the union
 	si_fd    int32
 }
 
diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 0ba2bf1c01..a64501e9e4 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -94,6 +94,7 @@ const (
 	_SOCK_DGRAM = 0x2
 )
 
+// The replication is because constants could be different on different architecture
 const (
 	_PERF_TYPE_HARDWARE   = 0x0
 	_PERF_TYPE_SOFTWARE   = 0x1
@@ -253,7 +254,7 @@ type siginfo struct {
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
 	si_addr  uint64
-	// psu: an unreliable workaround and need to figure out a better solution
+	// si_fd is the field right after the union
 	si_fd    int32
 }
 
diff --git a/src/runtime/defs_linux_arm.go b/src/runtime/defs_linux_arm.go
index e27ce80c9a..e82a2a94cb 100644
--- a/src/runtime/defs_linux_arm.go
+++ b/src/runtime/defs_linux_arm.go
@@ -90,6 +90,7 @@ const (
 	_SOCK_DGRAM = 0x2
 )
 
+// The replication is because constants could be different on different architecture
 const (
 	_PERF_TYPE_HARDWARE   = 0x0
 	_PERF_TYPE_SOFTWARE   = 0x1
@@ -285,9 +286,8 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr uint32
-	// psu: an unreliable workaround and need to figure out a better solution
-	// psu: only tested on amd64
+	si_addr  uint32
+	// si_fd is the field right after the union
 	si_fd    int32
 }
 
diff --git a/src/runtime/defs_linux_arm64.go b/src/runtime/defs_linux_arm64.go
index ba754fa6a5..d9f6c1d343 100644
--- a/src/runtime/defs_linux_arm64.go
+++ b/src/runtime/defs_linux_arm64.go
@@ -94,6 +94,7 @@ const (
 	_SOCK_DGRAM = 0x2
 )
 
+// The replication is because constants could be different on different architecture
 const (
 	_PERF_TYPE_HARDWARE   = 0x0
 	_PERF_TYPE_SOFTWARE   = 0x1
@@ -252,9 +253,8 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr uint64
-	// psu: an unreliable workaround and need to figure out a better solution
-	// psu: only tested on amd64
+	si_addr  uint64
+	// si_fd is the next field.
 	si_fd    int32
 }
 
diff --git a/src/runtime/defs_linux_mips64x.go b/src/runtime/defs_linux_mips64x.go
index da591ad867..a631d7aaca 100644
--- a/src/runtime/defs_linux_mips64x.go
+++ b/src/runtime/defs_linux_mips64x.go
@@ -89,6 +89,7 @@ const (
 	_EPOLL_CTL_MOD = 0x3
 )
 
+// The replication is because constants could be different on different architecture
 const (
 	_PERF_TYPE_HARDWARE   = 0x0
 	_PERF_TYPE_SOFTWARE   = 0x1
@@ -255,9 +256,8 @@ type siginfo struct {
 	si_errno int32
 	__pad0   [1]int32
 	// below here is a union; si_addr is the only field we use
-	si_addr uint64
-	// psu: an unreliable workaround and need to figure out a better solution
-	// psu: only tested on amd64
+	si_addr  uint64
+	// si_fd is the field right after the union
 	si_fd    int32
 }
 
diff --git a/src/runtime/defs_linux_mipsx.go b/src/runtime/defs_linux_mipsx.go
index 957d57ba36..306a2adf0f 100644
--- a/src/runtime/defs_linux_mipsx.go
+++ b/src/runtime/defs_linux_mipsx.go
@@ -93,6 +93,7 @@ const (
 	_EPOLL_CTL_MOD = 0x3
 )
 
+// The replication is because constants could be different on different architecture
 const (
 	_PERF_TYPE_HARDWARE   = 0x0
 	_PERF_TYPE_SOFTWARE   = 0x1
@@ -253,9 +254,8 @@ type siginfo struct {
 	si_code  int32
 	si_errno int32
 	// below here is a union; si_addr is the only field we use
-	si_addr uint32
-	// psu: an unreliable workaround and need to figure out a better solution
-	// psu: only tested on amd64
+	si_addr  uint32
+	// si_fd is the field right after the union
 	si_fd    int32
 }
 
diff --git a/src/runtime/defs_linux_ppc64.go b/src/runtime/defs_linux_ppc64.go
index 3810ccb0b3..620c1b88e7 100644
--- a/src/runtime/defs_linux_ppc64.go
+++ b/src/runtime/defs_linux_ppc64.go
@@ -89,6 +89,7 @@ const (
 	_EPOLL_CTL_MOD = 0x3
 )
 
+// The replication is because constants could be different on different architecture
 const (
 	_PERF_TYPE_HARDWARE   = 0x0
 	_PERF_TYPE_SOFTWARE   = 0x1
@@ -252,9 +253,8 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr uint64
-	// psu: an unreliable workaround and need to figure out a better solution
-	// psu: only tested on amd64
+	si_addr  uint64
+	// si_fd is the field right after the union
 	si_fd    int32
 }
 
diff --git a/src/runtime/defs_linux_ppc64le.go b/src/runtime/defs_linux_ppc64le.go
index adf6111eae..ffaf6e5713 100644
--- a/src/runtime/defs_linux_ppc64le.go
+++ b/src/runtime/defs_linux_ppc64le.go
@@ -89,6 +89,7 @@ const (
 	_EPOLL_CTL_MOD = 0x3
 )
 
+// The replication is because constants could be different on different architecture
 const (
 	_PERF_TYPE_HARDWARE   = 0x0
 	_PERF_TYPE_SOFTWARE   = 0x1
@@ -252,9 +253,8 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr uint64
-	// psu: an unreliable workaround and need to figure out a better solution
-	// psu: only tested on amd64
+	si_addr  uint64
+	// si_fd is the field right after the union
 	si_fd    int32
 }
 
diff --git a/src/runtime/defs_linux_s390x.go b/src/runtime/defs_linux_s390x.go
index b93148ff65..025d6dbf4d 100644
--- a/src/runtime/defs_linux_s390x.go
+++ b/src/runtime/defs_linux_s390x.go
@@ -90,6 +90,7 @@ const (
 	_EPOLL_CTL_MOD = 0x3
 )
 
+// The replication is because constants could be different on different architecture
 const (
 	_PERF_TYPE_HARDWARE   = 0x0
 	_PERF_TYPE_SOFTWARE   = 0x1
@@ -248,9 +249,8 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr uint64
-	// psu: an unreliable workaround and need to figure out a better solution
-	// psu: only tested on amd64
+	si_addr  uint64
+	// si_fd is the field right after the union
 	si_fd    int32
 }
 
diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index 2a1bf1eeab..34c08e8724 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -1,5 +1,6 @@
 package runtime
 
+// Convert platform-agnostic pmu events to Linux perf events
 var perfEventOpt = map[int32]struct {
 	Type    uint32 // type of event
 	Config  uint64 // event
diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index 4cf04ca3a6..033d94848d 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -1,5 +1,7 @@
 package runtime
 
+// These Constants are platform agnostic and exposed to pprof.
+// We use perfEventOpt to map these to the underlying OS and HW.
 const (
 	GO_COUNT_HW_CPU_CYCLES              = 0x0
 	GO_COUNT_HW_INSTRUCTIONS            = 0x1

From ca0f3fc49559adbb2b0b251ebde2bc4d190727a6 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 18:22:40 -0700
Subject: [PATCH 092/126] test cases

---
 test/pmu/test2.go | 25 ++++++++++---------------
 test/run.go       |  3 ++-
 2 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/test/pmu/test2.go b/test/pmu/test2.go
index f065cec929..0b53df24d5 100644
--- a/test/pmu/test2.go
+++ b/test/pmu/test2.go
@@ -21,7 +21,7 @@ func f1() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 50000000; i++ {
+	for i := 0; i < 500000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
@@ -29,7 +29,6 @@ func f1() {
 		/*if i % 100 == 0 {
 			time.Sleep(time.Nanosecond)
 		}*/
-		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -39,7 +38,7 @@ func f2() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 50000000; i++ {
+	for i := 0; i < 500000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
@@ -47,7 +46,6 @@ func f2() {
 		/*if i % 100 == 0 {
 			time.Sleep(time.Nanosecond)
 		}*/
-		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -57,7 +55,7 @@ func f3() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 50000000; i++ {
+	for i := 0; i < 500000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
@@ -65,7 +63,6 @@ func f3() {
 		/*if i % 100 == 0 {
 			time.Sleep(time.Nanosecond)
 		}*/
-		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -75,7 +72,7 @@ func f4() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 50000000; i++ {
+	for i := 0; i < 500000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
@@ -83,7 +80,6 @@ func f4() {
 		/*if i % 100 == 0 {
 			time.Sleep(time.Nanosecond)
 		}*/
-		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -93,12 +89,11 @@ func f5() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 50000000; i++ {
+	for i := 0; i < 500000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
-		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -108,7 +103,7 @@ func f6() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 50000000; i++ {
+	for i := 0; i < 500000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
@@ -123,7 +118,7 @@ func f7() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 50000000; i++ {
+	for i := 0; i < 500000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
@@ -138,7 +133,7 @@ func f8() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 50000000; i++ {
+	for i := 0; i < 500000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
@@ -153,7 +148,7 @@ func f9() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 50000000; i++ {
+	for i := 0; i < 500000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
@@ -168,7 +163,7 @@ func f10() {
 	defer wg.Done()
 
 	var sum int
-	for i := 0; i < 50000000; i++ {
+	for i := 0; i < 500000000; i++ {
 		sum -= i / 2
 		sum *= i
 		sum /= i/3 + 1
diff --git a/test/run.go b/test/run.go
index 7f6edfc111..f6c42fe1c0 100644
--- a/test/run.go
+++ b/test/run.go
@@ -50,7 +50,8 @@ var (
 
 	// dirs are the directories to look for *.go files in.
 	// TODO(bradfitz): just use all directories?
-	dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime", "pmu"}
+	// dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime", "pmu"}
+	dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "codegen", "runtime"}
 
 	// ratec controls the max number of tests running at a time.
 	ratec chan bool

From 16feaf6c9d34822a228187f64c2657ff40d1f3d7 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 18 Jul 2019 23:33:37 -0700
Subject: [PATCH 093/126] minor

---
 src/testing/testing.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/testing/testing.go b/src/testing/testing.go
index 07613d5531..27ad3beea5 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -286,7 +286,7 @@ func Init() {
 	memProfileRate = flag.Int("test.memprofilerate", 0, "set memory allocation profiling `rate` (see runtime.MemProfileRate)")
 	cpuProfile = flag.String("test.cpuprofile", "", "write a cpu profile to `file`")
 	pmuProfile = flag.String("test.pmuprofile", "", "write a pmu profile to `file`")
-	pmuEvent = flag.String("test.pmuevent", "cycle", "select a pmu event from the events: cycles, instructions, cacheReferences, cacheMisses")
+	pmuEvent = flag.String("test.pmuevent", "cycles", "select a pmu event from the events: cycles, instructions, cacheReferences, cacheMisses")
 	pmuPeriod = flag.Int64("test.pmuperiod", 10000000, "specify the sampling period for a PMU event")
 	pmuPreciseIP = flag.Int("test.pmupreciseip", 0, "specify the precise IP level (0-3) for a PMU event")
 	pmuKernelIncluded = flag.Bool("test.pmukernelincl", false, "count the kernel")

From 151680a6327333fa03337e67938c53e07c23853e Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Fri, 19 Jul 2019 16:09:22 -0700
Subject: [PATCH 094/126] replace slice with array

---
 src/runtime/os_linux.go | 1 -
 src/runtime/proc.go     | 8 ++++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index fecc9febdb..73f218470c 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -514,7 +514,6 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		if !eventAttr.IsHvIncluded { // don't count hypervisor
 			perfAttr.Bits += 0b1000000
 		}
-
 		fd, _, err := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy */ 0)
 		if err != 0 {
 			println("Linux perf event open failed")
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 18c363f19e..5f0c2e6793 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3803,8 +3803,8 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 	// In fact mp may not even be stopped.
 	// See golang.org/issue/17165.
 	getg().m.mallocing++
-	stk := make([]uintptr, maxCPUProfStack)
-	n := stackUnwinding(pc, sp, lr, gp, mp, stk)
+	var stk [maxCPUProfStack]uintptr
+	n := stackUnwinding(pc, sp, lr, gp, mp, stk[:])
 	if prof.hz != 0 {
 		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostAtomic64Count > 0 {
 			cpuprof.addLostAtomic64(lostAtomic64Count)
@@ -3834,8 +3834,8 @@ func sigprofPMU(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
 	}
 
 	getg().m.mallocing++
-	stk := make([]uintptr, maxCPUProfStack)
-	n := stackUnwinding(pc, sp, lr, gp, mp, stk)
+	var stk [maxCPUProfStack]uintptr
+	n := stackUnwinding(pc, sp, lr, gp, mp, stk[:])
 	if pmuEvent[eventId].eventAttr != nil {
 		if (GOARCH == "mips" || GOARCH == "mipsle" || GOARCH == "arm") && lostPMUAtomic64Count[eventId] > 0 {
 			pmuprof[eventId].addLostAtomic64(lostPMUAtomic64Count[eventId], eventId)

From eb4565f78ecdd76e50b17a256cfba2e5b9e6c651 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Fri, 19 Jul 2019 16:12:33 -0700
Subject: [PATCH 095/126] minor

---
 src/runtime/os_linux.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 73f218470c..fecc9febdb 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -514,6 +514,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		if !eventAttr.IsHvIncluded { // don't count hypervisor
 			perfAttr.Bits += 0b1000000
 		}
+
 		fd, _, err := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy */ 0)
 		if err != 0 {
 			println("Linux perf event open failed")

From 9e5ca00a84386c551203e57196384efb52abfd52 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 22 Jul 2019 17:36:32 -0700
Subject: [PATCH 096/126] minor

---
 src/runtime/os_linux.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index fecc9febdb..5d2612b842 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -400,6 +400,9 @@ func setsig(i uint32, fn uintptr) {
 	}
 	sa.sa_handler = fn
 	sigaction(i, &sa, nil)
+	if i == _SIGPROF {
+		unblocksig(i)
+	}
 }
 
 //go:nosplit
@@ -501,7 +504,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		var perfAttr perfEventAttr
 		perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
 		perfAttr.Type = perfEventOpt[eventId].Type
-		if (eventId == GO_COUNT_HW_RAW) {
+		if eventId == GO_COUNT_HW_RAW {
 			perfAttr.Config = eventAttr.RawEvent
 		} else {
 			perfAttr.Config = perfEventOpt[eventId].Config

From c7454d5b3c2d251574170141c372af57f5309337 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Mon, 22 Jul 2019 17:37:40 -0700
Subject: [PATCH 097/126] minor

---
 src/runtime/os_linux.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 5d2612b842..e6d997d98b 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -400,9 +400,6 @@ func setsig(i uint32, fn uintptr) {
 	}
 	sa.sa_handler = fn
 	sigaction(i, &sa, nil)
-	if i == _SIGPROF {
-		unblocksig(i)
-	}
 }
 
 //go:nosplit

From 0294127bb7070b941f8d35277a4a3b5843ba6a4a Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Fri, 26 Jul 2019 12:10:28 -0700
Subject: [PATCH 098/126] minor

---
 src/cmd/go/alldocs.go            | 4 +++-
 src/cmd/go/internal/test/test.go | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index fc62ada3ff..74cf3af0da 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -2964,7 +2964,9 @@
 //
 //     	-pmuevent event
 // 	    Specify which pmu event to sample.
-// 	    To sample PMU cycles, use -test.memprofilerate=1.
+// 	    To sample PMU cycles, use -test.pmuevent=cycles.
+// 	    To sample PMU instructions, use -test.pmuevent=instructions.
+// 	    To sample PMU cache misses, use -test.pmuevent=cacheMisses.
 //
 // 	-pmuperiod n
 // 	    Set the sampling period for the pmu event specified by -pmuevent.
diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 79235ef948..0d31dcc207 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -319,7 +319,9 @@ profile the tests during execution:
 
     	-pmuevent event
 	    Specify which pmu event to sample.
-	    To sample PMU cycles, use -test.memprofilerate=1.
+	    To sample PMU cycles, use -test.pmuevent=cycles.
+	    To sample PMU instructions, use -test.pmuevent=instructions.
+	    To sample PMU cache misses, use -test.pmuevent=cacheMisses.
 
 	-pmuperiod n
 	    Set the sampling period for the pmu event specified by -pmuevent.

From e8e5462decea4ca86cbe1bec8597947afe58b8ff Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 28 Jul 2019 12:51:45 -0700
Subject: [PATCH 099/126] tests

---
 test/pmu/http/test1.go | 4 ++--
 test/pmu/http/test2.go | 2 +-
 test/pmu/http/test3.go | 2 +-
 test/pmu/http/test4.go | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/pmu/http/test1.go b/test/pmu/http/test1.go
index cf337ffa9a..cbdec6303b 100644
--- a/test/pmu/http/test1.go
+++ b/test/pmu/http/test1.go
@@ -1,14 +1,14 @@
 // run
 // Example of usage: 
 // 1. go run test1.go
-// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=cycles\&period=10000000
+// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&pmuevent=cycles\&pmuperiod=10000000
 
 package main
 
 import (
 	"fmt"
 	"log"
-	// "time"
+	_"time"
 	"net/http"
 	_ "net/http/pprof"
 )
diff --git a/test/pmu/http/test2.go b/test/pmu/http/test2.go
index cbe16e09fe..4b96c4e381 100644
--- a/test/pmu/http/test2.go
+++ b/test/pmu/http/test2.go
@@ -1,7 +1,7 @@
 // run
 // Example of usage: 
 // 1. go run test2.go
-// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=instructions\&period=10000000
+// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&pmuevent=instructions\&pmuperiod=10000000
 
 package main
 
diff --git a/test/pmu/http/test3.go b/test/pmu/http/test3.go
index ececca4108..eb1a04dbf8 100644
--- a/test/pmu/http/test3.go
+++ b/test/pmu/http/test3.go
@@ -1,7 +1,7 @@
 // run
 // Example of usage: 
 // 1. go run test3.go
-// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=cacheMisses\&period=10000000
+// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&pmuevent=cacheMisses\&pmuperiod=10000000
 
 package main
 
diff --git a/test/pmu/http/test4.go b/test/pmu/http/test4.go
index b7ab6cfb2f..07225076e8 100644
--- a/test/pmu/http/test4.go
+++ b/test/pmu/http/test4.go
@@ -1,7 +1,7 @@
 // run
 // Example of Usage: 
 // 1. go run test4.go
-// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&event=r53010e\&period=1000000
+// 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&pmuevent=r53010e\&pmuperiod=1000000
 
 package main
 

From d3daccec11aa1e13385c5321d40dc8e7c9623c30 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Sun, 28 Jul 2019 12:56:21 -0700
Subject: [PATCH 100/126] support raw events for benchmarks

---
 src/net/http/pprof/pprof.go           | 10 +++++-----
 src/testing/internal/testdeps/deps.go | 12 +++++++++++-
 2 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index 115c6c48b5..afeff9df95 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -113,20 +113,20 @@ func serveError(w http.ResponseWriter, status int, txt string) {
 func pmuProfile(w http.ResponseWriter, r *http.Request) error {
 	var eventConfig pprof.PMUEventConfig
 
-	if period, err := strconv.ParseInt(r.FormValue("period"), 10, 64); err == nil {
+	if period, err := strconv.ParseInt(r.FormValue("pmuperiod"), 10, 64); err == nil {
 		eventConfig.Period = period
 	}
-	if preciseIP, err := strconv.ParseInt(r.FormValue("preciseIP"), 10, 8); err == nil {
+	if preciseIP, err := strconv.ParseInt(r.FormValue("pmupreciseip"), 10, 8); err == nil {
 		eventConfig.PreciseIP = int8(preciseIP)
 	}
-	if isKernelIncluded, err := strconv.ParseBool(r.FormValue("kernel")); err == nil {
+	if isKernelIncluded, err := strconv.ParseBool(r.FormValue("pmukernelincl")); err == nil {
 		eventConfig.IsKernelIncluded = isKernelIncluded
 	}
-	if isHvIncluded, err := strconv.ParseBool(r.FormValue("hv")); err == nil {
+	if isHvIncluded, err := strconv.ParseBool(r.FormValue("pmuhvincl")); err == nil {
 		eventConfig.IsHvIncluded = isHvIncluded
 	}
 
-	switch eventName := r.FormValue("event"); eventName {
+	switch eventName := r.FormValue("pmuevent"); eventName {
 		case "cycles":
 			return pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
 		case "instructions":
diff --git a/src/testing/internal/testdeps/deps.go b/src/testing/internal/testdeps/deps.go
index 5669d6e65b..f24342276a 100644
--- a/src/testing/internal/testdeps/deps.go
+++ b/src/testing/internal/testdeps/deps.go
@@ -17,6 +17,7 @@ import (
 	"io"
 	"regexp"
 	"runtime/pprof"
+	"strconv"
 	"strings"
 	"sync"
 )
@@ -64,7 +65,16 @@ func (TestDeps) StartPMUProfile(w io.Writer, event string, period int64, precise
 		case "cacheMisses":
 			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
 		default:
-			return fmt.Errorf("unknown or not yet implemented event")
+			// Is this a raw event?
+			if strings.HasPrefix(event, "r") {
+				if rawHexEvent, err := strconv.ParseInt(event[1:], 16, 64); err == nil {
+					eventConfig.RawEvent = rawHexEvent
+					return pprof.StartPMUProfile(pprof.WithProfilingPMURaw(w, &eventConfig))
+				}
+				return fmt.Errorf("Incorrect hex format for raw event")
+			} else {
+				return fmt.Errorf("Unknown or not yet implemented event")
+			}
 	}
 }
 

From dc539dada3e5e8e9e579a48e3e9939c206344db5 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Tue, 30 Jul 2019 11:34:04 -0700
Subject: [PATCH 101/126] add two new events: LLC_load_accesses and
 LLC_load_misses

---
 src/cmd/go/alldocs.go                 |  2 ++
 src/cmd/go/internal/test/test.go      |  2 ++
 src/net/http/pprof/pprof.go           |  7 +++++++
 src/runtime/defs_perf_linux.go        |  2 ++
 src/runtime/defs_pmu.go               |  6 ++++--
 src/runtime/pprof/pprof.go            | 26 ++++++++++++++++++++++++++
 src/testing/internal/testdeps/deps.go |  4 ++++
 src/testing/testing.go                |  2 +-
 8 files changed, 48 insertions(+), 3 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 74cf3af0da..079cecc1ff 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -2967,6 +2967,8 @@
 // 	    To sample PMU cycles, use -test.pmuevent=cycles.
 // 	    To sample PMU instructions, use -test.pmuevent=instructions.
 // 	    To sample PMU cache misses, use -test.pmuevent=cacheMisses.
+// 	    To sample PMU last-level cache read accesses, use -test.pmuevent=cacheLLReadAccesses.
+// 	    To sample PMU last-level cache read misses, use -test.pmuevent=cacheLLReadMisses.
 //
 // 	-pmuperiod n
 // 	    Set the sampling period for the pmu event specified by -pmuevent.
diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 0d31dcc207..055f5b4d58 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -322,6 +322,8 @@ profile the tests during execution:
 	    To sample PMU cycles, use -test.pmuevent=cycles.
 	    To sample PMU instructions, use -test.pmuevent=instructions.
 	    To sample PMU cache misses, use -test.pmuevent=cacheMisses.
+	    To sample PMU last-level cache read accesses, use -test.pmuevent=cacheLLReadAccesses.
+	    To sample PMU last-level cache read misses, use -test.pmuevent=cacheLLReadMisses.
 
 	-pmuperiod n
 	    Set the sampling period for the pmu event specified by -pmuevent.
diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index afeff9df95..8df11d919a 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -112,6 +112,7 @@ func serveError(w http.ResponseWriter, status int, txt string) {
 
 func pmuProfile(w http.ResponseWriter, r *http.Request) error {
 	var eventConfig pprof.PMUEventConfig
+	eventConfig.Period = 1e7 // default value
 
 	if period, err := strconv.ParseInt(r.FormValue("pmuperiod"), 10, 64); err == nil {
 		eventConfig.Period = period
@@ -127,6 +128,8 @@ func pmuProfile(w http.ResponseWriter, r *http.Request) error {
 	}
 
 	switch eventName := r.FormValue("pmuevent"); eventName {
+		case "":
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
 		case "cycles":
 			return pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
 		case "instructions":
@@ -135,6 +138,10 @@ func pmuProfile(w http.ResponseWriter, r *http.Request) error {
 			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheReferences(w, &eventConfig))
 		case "cacheMisses":
 			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
+		case "cacheLLReadAccesses":
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadAccesses(w, &eventConfig))
+		case "cacheLLReadMisses":
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadMisses(w, &eventConfig))
 		default:
 			// Is this a raw event?
 			if strings.HasPrefix(eventName, "r") {
diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index 34c08e8724..adfe8a929e 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -9,6 +9,8 @@ var perfEventOpt = map[int32]struct {
 	GO_COUNT_HW_INSTRUCTIONS: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},
 	GO_COUNT_HW_CACHE_REFERENCES: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_REFERENCES},
 	GO_COUNT_HW_CACHE_MISSES: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_MISSES},
+	GO_COUNT_HW_CACHE_LL_READ_ACCESSES: {_PERF_TYPE_HW_CACHE, (_PERF_COUNT_HW_CACHE_LL) | (_PERF_COUNT_HW_CACHE_OP_READ << 8) | (_PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16)},
+	GO_COUNT_HW_CACHE_LL_READ_MISSES: {_PERF_TYPE_HW_CACHE, (_PERF_COUNT_HW_CACHE_LL) | (_PERF_COUNT_HW_CACHE_OP_READ << 8) | (_PERF_COUNT_HW_CACHE_RESULT_MISS << 16)},
 	GO_COUNT_HW_RAW: {_PERF_TYPE_RAW, 0 /* will not be used */},
 	// TODO: add more perf events
 }
diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index 033d94848d..858605f734 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -7,8 +7,10 @@ const (
 	GO_COUNT_HW_INSTRUCTIONS            = 0x1
 	GO_COUNT_HW_CACHE_REFERENCES        = 0x2
 	GO_COUNT_HW_CACHE_MISSES            = 0x3
-	GO_COUNT_HW_RAW			    = 0x4
-	GO_COUNT_PMU_EVENTS_MAX		    = 0x5
+	GO_COUNT_HW_CACHE_LL_READ_ACCESSES  = 0x4
+	GO_COUNT_HW_CACHE_LL_READ_MISSES    = 0x5
+	GO_COUNT_HW_RAW			    = 0x6
+	GO_COUNT_PMU_EVENTS_MAX		    = 0x7
 )
 
 type PMUEventAttr struct {
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 34ac75ca31..6505819e8a 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -896,6 +896,32 @@ func WithProfilingPMUCacheMisses(w io.Writer, eventConfig *PMUEventConfig) Profi
 	})
 }
 
+func WithProfilingPMUCacheLLReadAccesses(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
+	return profilingOptionFunc(func() error {
+		if eventConfig.Period <= 0 {
+			return fmt.Errorf("Period should be > 0")
+		}
+		// TODO: create a table of standard clamp values
+		// TODO: clamp period to something reasonable
+
+		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_LL_READ_ACCESSES, /* event name */ "last-level cache read accesses")
+		return nil
+	})
+}
+
+func WithProfilingPMUCacheLLReadMisses(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
+	return profilingOptionFunc(func() error {
+		if eventConfig.Period <= 0 {
+			return fmt.Errorf("Period should be > 0")
+		}
+		// TODO: create a table of standard clamp values
+		// TODO: clamp period to something reasonable
+
+		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_LL_READ_MISSES, /* event name */ "last-level cache read misses")
+		return nil
+	})
+}
+
 func WithProfilingPMURaw(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
 	return profilingOptionFunc(func() error {
 		if eventConfig.Period <= 0 {
diff --git a/src/testing/internal/testdeps/deps.go b/src/testing/internal/testdeps/deps.go
index f24342276a..a379244b1e 100644
--- a/src/testing/internal/testdeps/deps.go
+++ b/src/testing/internal/testdeps/deps.go
@@ -64,6 +64,10 @@ func (TestDeps) StartPMUProfile(w io.Writer, event string, period int64, precise
 			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheReferences(w, &eventConfig))
 		case "cacheMisses":
 			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
+		case "cacheLLReadAccesses":
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadAccesses(w, &eventConfig))
+		case "cacheLLReadMisses":
+			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadMisses(w, &eventConfig))
 		default:
 			// Is this a raw event?
 			if strings.HasPrefix(event, "r") {
diff --git a/src/testing/testing.go b/src/testing/testing.go
index 27ad3beea5..3a778c3b7a 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -286,7 +286,7 @@ func Init() {
 	memProfileRate = flag.Int("test.memprofilerate", 0, "set memory allocation profiling `rate` (see runtime.MemProfileRate)")
 	cpuProfile = flag.String("test.cpuprofile", "", "write a cpu profile to `file`")
 	pmuProfile = flag.String("test.pmuprofile", "", "write a pmu profile to `file`")
-	pmuEvent = flag.String("test.pmuevent", "cycles", "select a pmu event from the events: cycles, instructions, cacheReferences, cacheMisses")
+	pmuEvent = flag.String("test.pmuevent", "cycles", "select a pmu event from the events: cycles, instructions, cacheReferences, cacheMisses, cacheLLReadAccesses, cacheLLReadMisses")
 	pmuPeriod = flag.Int64("test.pmuperiod", 10000000, "specify the sampling period for a PMU event")
 	pmuPreciseIP = flag.Int("test.pmupreciseip", 0, "specify the precise IP level (0-3) for a PMU event")
 	pmuKernelIncluded = flag.Bool("test.pmukernelincl", false, "count the kernel")

From c56ebe131e35f70982ed17296d4bbdce3ef1997d Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 1 Aug 2019 13:04:02 -0700
Subject: [PATCH 102/126] minor

---
 test/pmu/test2.go | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/test/pmu/test2.go b/test/pmu/test2.go
index 0b53df24d5..bc9ffb6f22 100644
--- a/test/pmu/test2.go
+++ b/test/pmu/test2.go
@@ -8,7 +8,6 @@ import (
 	"log"
 	"os"
 	"sync"
-	"sync/atomic"
 	_"time"
 	"runtime/pprof"
 )
@@ -108,7 +107,6 @@ func f6() {
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
-		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -123,7 +121,6 @@ func f7() {
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
-		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -138,7 +135,6 @@ func f8() {
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
-		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -153,7 +149,6 @@ func f9() {
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
-		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -168,7 +163,6 @@ func f10() {
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
-		atomic.StoreInt32(&racy, 42)
 	}
 
 	fmt.Println(sum)
@@ -182,7 +176,7 @@ func run() error {
 	defer cycleFile.Close()
 
 	var cycle pprof.PMUEventConfig
-	cycle.Period =  1000000
+	cycle.Period =  100000000
 	// cycle.PreciseIP = 2
 
 	instrFile, err := os.Create("instr_profile")
@@ -192,7 +186,7 @@ func run() error {
 	defer instrFile.Close()
 
 	var instr pprof.PMUEventConfig
-	instr.Period =  1000000
+	instr.Period =  100000000
 	// instr.PreciseIP = 2
 
 	cacheMissFile, err := os.Create("cacheMiss_profile")
@@ -213,7 +207,7 @@ func run() error {
 	defer cacheRefFile.Close()
 
 	var cacheRef pprof.PMUEventConfig
-	cacheRef.Period = 1000000
+	cacheRef.Period = 10000
 	// cacheRef.PreciseIP = 2
 
 

From 39f49cefc47dc98c01153bb89b3e60df47b70c64 Mon Sep 17 00:00:00 2001
From: psu-wm <psu@email.wm.edu>
Date: Thu, 1 Aug 2019 13:22:05 -0700
Subject: [PATCH 103/126] tests

---
 test/pmu/test1.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/pmu/test1.go b/test/pmu/test1.go
index 3391ac80cb..4edb27d22e 100644
--- a/test/pmu/test1.go
+++ b/test/pmu/test1.go
@@ -1,6 +1,6 @@
 // run
 // Example of usage: go run test1.go
-
+// Flamegraph: go tool pprof -relative_percentages -http=":8081" cycle_profile 
 package main
 
 import (

From 37f5a20880804898872da0c12c16e03968838d14 Mon Sep 17 00:00:00 2001
From: Milind Chabbi <milind@uber.com>
Date: Thu, 1 Aug 2019 13:29:54 -0700
Subject: [PATCH 104/126] Simplified the logic to check whether PMU is enabled
 and dropped replicated code

---
 src/net/http/pprof/pprof.go | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index 8df11d919a..395604e661 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -178,25 +178,20 @@ func Profile(w http.ResponseWriter, r *http.Request) {
 
 	isPMUEnabled, err := strconv.ParseBool(r.FormValue("pmu"))
 
-	if err != nil {
+	if (err != nil)  || (!isPMUEnabled) {
 		if err = pprof.StartCPUProfile(w); err != nil {
 			serveError(w, http.StatusInternalServerError,
 				fmt.Sprintf("Could not enable CPU profiling: %s", err))
 			return
 		}
-	} else if isPMUEnabled {
+	} else {
+		// err == nil and isPMUEnabled == true 
 		if err = pmuProfile(w, r); err != nil {
 			serveError(w, http.StatusInternalServerError,
 				fmt.Sprintf("Could not enable PMU profiling: %s", err))
 			return
 		}
-	} else {
-		if err = pprof.StartCPUProfile(w); err != nil {
-			serveError(w, http.StatusInternalServerError,
-				fmt.Sprintf("Could not enable CPU profiling: %s", err))
-			return
-		}
-	}
+	} 
 
 	sleep(w, time.Duration(sec)*time.Second)
 

From 0440673be74c2e3129756b204b07827552e912e4 Mon Sep 17 00:00:00 2001
From: Joshua T Corbin <joshua@uber.com>
Date: Fri, 2 Aug 2019 08:55:28 -0700
Subject: [PATCH 105/126] Fix Go formatting on all modified files

---
 src/cmd/go/internal/test/testflag.go  |  2 +-
 src/net/http/pprof/pprof.go           | 54 +++++++--------
 src/runtime/cpuprof.go                |  8 +--
 src/runtime/defs_linux_386.go         | 28 ++++----
 src/runtime/defs_linux_amd64.go       | 28 ++++----
 src/runtime/defs_linux_arm.go         | 96 +++++++++++++--------------
 src/runtime/defs_linux_arm64.go       | 28 ++++----
 src/runtime/defs_linux_mips64x.go     | 28 ++++----
 src/runtime/defs_linux_mipsx.go       | 28 ++++----
 src/runtime/defs_linux_ppc64.go       | 28 ++++----
 src/runtime/defs_linux_ppc64le.go     | 28 ++++----
 src/runtime/defs_linux_s390x.go       | 28 ++++----
 src/runtime/defs_perf_linux.go        | 18 ++---
 src/runtime/defs_pmu.go               | 16 ++---
 src/runtime/pprof/pprof.go            | 43 ++++++------
 src/runtime/pprof/proto.go            | 20 +++---
 src/runtime/proc.go                   |  8 +--
 src/testing/internal/testdeps/deps.go | 52 +++++++--------
 src/testing/testing.go                | 18 ++---
 test/pmu/http/test1.go                |  6 +-
 test/pmu/http/test2.go                | 18 ++---
 test/pmu/http/test3.go                | 14 ++--
 test/pmu/http/test4.go                |  4 +-
 test/pmu/leak/test2.go                |  2 +-
 test/pmu/leak/test3.go                |  2 +-
 test/pmu/leak/test5.go                |  8 +--
 test/pmu/leak/test6.go                |  2 +-
 test/pmu/test1.go                     |  7 +-
 test/pmu/test2.go                     | 12 ++--
 test/pmu/test3.go                     |  3 +-
 test/pmu/test4.go                     |  5 +-
 31 files changed, 319 insertions(+), 323 deletions(-)

diff --git a/src/cmd/go/internal/test/testflag.go b/src/cmd/go/internal/test/testflag.go
index 7570235d44..02075026f8 100644
--- a/src/cmd/go/internal/test/testflag.go
+++ b/src/cmd/go/internal/test/testflag.go
@@ -51,7 +51,7 @@ var testFlagDefn = []*cmdflag.Defn{
 	{Name: "pmuperiod", PassToTest: true},
 	{Name: "pmupreciseip", PassToTest: true},
 	{Name: "pmukernelincl", BoolVar: new(bool), PassToTest: true},
-	{Name: "pmuhvincl", BoolVar: new(bool),PassToTest: true},
+	{Name: "pmuhvincl", BoolVar: new(bool), PassToTest: true},
 	{Name: "failfast", BoolVar: new(bool), PassToTest: true},
 	{Name: "list", PassToTest: true},
 	{Name: "memprofile", PassToTest: true},
diff --git a/src/net/http/pprof/pprof.go b/src/net/http/pprof/pprof.go
index 395604e661..db2f6fa690 100644
--- a/src/net/http/pprof/pprof.go
+++ b/src/net/http/pprof/pprof.go
@@ -128,31 +128,31 @@ func pmuProfile(w http.ResponseWriter, r *http.Request) error {
 	}
 
 	switch eventName := r.FormValue("pmuevent"); eventName {
-		case "":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
-		case "cycles":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
-		case "instructions":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUInstructions(w, &eventConfig))
-		case "cacheReferences":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheReferences(w, &eventConfig))
-		case "cacheMisses":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
-		case "cacheLLReadAccesses":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadAccesses(w, &eventConfig))
-		case "cacheLLReadMisses":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadMisses(w, &eventConfig))
-		default:
-			// Is this a raw event?
-			if strings.HasPrefix(eventName, "r") {
-				if rawHexEvent, err := strconv.ParseInt(eventName[1:], 16, 64); err == nil {
-					eventConfig.RawEvent = rawHexEvent
-					return pprof.StartPMUProfile(pprof.WithProfilingPMURaw(w, &eventConfig))
-				}
-				return fmt.Errorf("Incorrect hex format for raw event")
-			} else {
-				return fmt.Errorf("Unknown or not yet implemented event")
+	case "":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
+	case "cycles":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
+	case "instructions":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUInstructions(w, &eventConfig))
+	case "cacheReferences":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheReferences(w, &eventConfig))
+	case "cacheMisses":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
+	case "cacheLLReadAccesses":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadAccesses(w, &eventConfig))
+	case "cacheLLReadMisses":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadMisses(w, &eventConfig))
+	default:
+		// Is this a raw event?
+		if strings.HasPrefix(eventName, "r") {
+			if rawHexEvent, err := strconv.ParseInt(eventName[1:], 16, 64); err == nil {
+				eventConfig.RawEvent = rawHexEvent
+				return pprof.StartPMUProfile(pprof.WithProfilingPMURaw(w, &eventConfig))
 			}
+			return fmt.Errorf("Incorrect hex format for raw event")
+		} else {
+			return fmt.Errorf("Unknown or not yet implemented event")
+		}
 	}
 }
 
@@ -178,20 +178,20 @@ func Profile(w http.ResponseWriter, r *http.Request) {
 
 	isPMUEnabled, err := strconv.ParseBool(r.FormValue("pmu"))
 
-	if (err != nil)  || (!isPMUEnabled) {
+	if (err != nil) || (!isPMUEnabled) {
 		if err = pprof.StartCPUProfile(w); err != nil {
 			serveError(w, http.StatusInternalServerError,
 				fmt.Sprintf("Could not enable CPU profiling: %s", err))
 			return
 		}
 	} else {
-		// err == nil and isPMUEnabled == true 
+		// err == nil and isPMUEnabled == true
 		if err = pmuProfile(w, r); err != nil {
 			serveError(w, http.StatusInternalServerError,
 				fmt.Sprintf("Could not enable PMU profiling: %s", err))
 			return
 		}
-	} 
+	}
 
 	sleep(w, time.Duration(sec)*time.Second)
 
diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go
index affb650189..8b7162356b 100644
--- a/src/runtime/cpuprof.go
+++ b/src/runtime/cpuprof.go
@@ -69,8 +69,8 @@ func SetCPUProfileRate(hz int) {
 		}
 
 		cpuprof.on = true
-		// Enlarging the buffer words and tags reduces the number of samples lost at the cost of larger amounts of memory 
-		cpuprof.log = newProfBuf(/* header size */ 1, /* buffer words */ 1<<17, /* tags */ 1<<14)
+		// Enlarging the buffer words and tags reduces the number of samples lost at the cost of larger amounts of memory
+		cpuprof.log = newProfBuf( /* header size */ 1 /* buffer words */, 1<<17 /* tags */, 1<<14)
 		hdr := [1]uint64{uint64(hz)}
 		cpuprof.log.write(nil, nanotime(), hdr[:], nil)
 		setcpuprofilerate(int32(hz))
@@ -92,8 +92,8 @@ func SetPMUProfile(eventId int, eventAttr *PMUEventAttr) {
 		}
 
 		pmuprof[eventId].on = true
-		// Enlarging the buffer words and tags reduces the number of samples lost at the cost of larger amounts of memory 
-		pmuprof[eventId].log = newProfBuf(/* header size */ 1, /* buffer words */ 1<<17, /* tags */ 1<<14)
+		// Enlarging the buffer words and tags reduces the number of samples lost at the cost of larger amounts of memory
+		pmuprof[eventId].log = newProfBuf( /* header size */ 1 /* buffer words */, 1<<17 /* tags */, 1<<14)
 		hdr := [1]uint64{eventAttr.Period}
 		pmuprof[eventId].log.write(nil, nanotime(), hdr[:], nil)
 		setpmuprofile(int32(eventId), eventAttr)
diff --git a/src/runtime/defs_linux_386.go b/src/runtime/defs_linux_386.go
index d9f49662e7..e2ec4ab39e 100644
--- a/src/runtime/defs_linux_386.go
+++ b/src/runtime/defs_linux_386.go
@@ -210,18 +210,18 @@ const (
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
 
-	_PERF_EVENT_IOC_DISABLE               = 0x2401
-	_PERF_EVENT_IOC_ENABLE                = 0x2400
-	_PERF_EVENT_IOC_ID                    = 0x80042407
-	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4004240b
-	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
-	_PERF_EVENT_IOC_PERIOD                = 0x40082404
-	_PERF_EVENT_IOC_QUERY_BPF             = 0xc004240a
-	_PERF_EVENT_IOC_REFRESH               = 0x2402
-	_PERF_EVENT_IOC_RESET                 = 0x2403
-	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
-	_PERF_EVENT_IOC_SET_FILTER            = 0x40042406
-	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+	_PERF_EVENT_IOC_DISABLE           = 0x2401
+	_PERF_EVENT_IOC_ENABLE            = 0x2400
+	_PERF_EVENT_IOC_ID                = 0x80042407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x4004240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT      = 0x40042409
+	_PERF_EVENT_IOC_PERIOD            = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF         = 0xc004240a
+	_PERF_EVENT_IOC_REFRESH           = 0x2402
+	_PERF_EVENT_IOC_RESET             = 0x2403
+	_PERF_EVENT_IOC_SET_BPF           = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER        = 0x40042406
+	_PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 )
 
 type fpreg struct {
@@ -290,9 +290,9 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr  uint32
+	si_addr uint32
 	// si_fd is the field right after the union
-	si_fd    int32
+	si_fd int32
 }
 
 type stackt struct {
diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index a64501e9e4..9ee04b7224 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -207,18 +207,18 @@ const (
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
 
-	_PERF_EVENT_IOC_DISABLE               = 0x2401
-	_PERF_EVENT_IOC_ENABLE                = 0x2400
-	_PERF_EVENT_IOC_ID                    = 0x80082407
-	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
-	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
-	_PERF_EVENT_IOC_PERIOD                = 0x40082404
-	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
-	_PERF_EVENT_IOC_REFRESH               = 0x2402
-	_PERF_EVENT_IOC_RESET                 = 0x2403
-	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
-	_PERF_EVENT_IOC_SET_FILTER            = 0x40082406
-	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+	_PERF_EVENT_IOC_DISABLE           = 0x2401
+	_PERF_EVENT_IOC_ENABLE            = 0x2400
+	_PERF_EVENT_IOC_ID                = 0x80082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x4008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT      = 0x40042409
+	_PERF_EVENT_IOC_PERIOD            = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF         = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH           = 0x2402
+	_PERF_EVENT_IOC_RESET             = 0x2403
+	_PERF_EVENT_IOC_SET_BPF           = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER        = 0x40082406
+	_PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 )
 
 type timespec struct {
@@ -253,9 +253,9 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr  uint64
+	si_addr uint64
 	// si_fd is the field right after the union
-	si_fd    int32
+	si_fd int32
 }
 
 type itimerval struct {
diff --git a/src/runtime/defs_linux_arm.go b/src/runtime/defs_linux_arm.go
index e82a2a94cb..0529299b96 100644
--- a/src/runtime/defs_linux_arm.go
+++ b/src/runtime/defs_linux_arm.go
@@ -20,40 +20,40 @@ const (
 	_MADV_HUGEPAGE   = 0xe
 	_MADV_NOHUGEPAGE = 0xf
 
-	_SA_RESTART     = 0x10000000
-	_SA_ONSTACK     = 0x8000000
-	_SA_RESTORER    = 0 // unused on ARM
-	_SA_SIGINFO     = 0x4
-	_SIGHUP         = 0x1
-	_SIGINT         = 0x2
-	_SIGQUIT        = 0x3
-	_SIGILL         = 0x4
-	_SIGTRAP        = 0x5
-	_SIGABRT        = 0x6
-	_SIGBUS         = 0x7
-	_SIGFPE         = 0x8
-	_SIGKILL        = 0x9
-	_SIGUSR1        = 0xa
-	_SIGSEGV        = 0xb
-	_SIGUSR2        = 0xc
-	_SIGPIPE        = 0xd
-	_SIGALRM        = 0xe
-	_SIGSTKFLT      = 0x10
-	_SIGCHLD        = 0x11
-	_SIGCONT        = 0x12
-	_SIGSTOP        = 0x13
-	_SIGTSTP        = 0x14
-	_SIGTTIN        = 0x15
-	_SIGTTOU        = 0x16
-	_SIGURG         = 0x17
-	_SIGXCPU        = 0x18
-	_SIGXFSZ        = 0x19
-	_SIGVTALRM      = 0x1a
-	_SIGPROF        = 0x1b
-	_SIGWINCH       = 0x1c
-	_SIGIO          = 0x1d
-	_SIGPWR         = 0x1e
-	_SIGSYS         = 0x1f
+	_SA_RESTART  = 0x10000000
+	_SA_ONSTACK  = 0x8000000
+	_SA_RESTORER = 0 // unused on ARM
+	_SA_SIGINFO  = 0x4
+	_SIGHUP      = 0x1
+	_SIGINT      = 0x2
+	_SIGQUIT     = 0x3
+	_SIGILL      = 0x4
+	_SIGTRAP     = 0x5
+	_SIGABRT     = 0x6
+	_SIGBUS      = 0x7
+	_SIGFPE      = 0x8
+	_SIGKILL     = 0x9
+	_SIGUSR1     = 0xa
+	_SIGSEGV     = 0xb
+	_SIGUSR2     = 0xc
+	_SIGPIPE     = 0xd
+	_SIGALRM     = 0xe
+	_SIGSTKFLT   = 0x10
+	_SIGCHLD     = 0x11
+	_SIGCONT     = 0x12
+	_SIGSTOP     = 0x13
+	_SIGTSTP     = 0x14
+	_SIGTTIN     = 0x15
+	_SIGTTOU     = 0x16
+	_SIGURG      = 0x17
+	_SIGXCPU     = 0x18
+	_SIGXFSZ     = 0x19
+	_SIGVTALRM   = 0x1a
+	_SIGPROF     = 0x1b
+	_SIGWINCH    = 0x1c
+	_SIGIO       = 0x1d
+	_SIGPWR      = 0x1e
+	_SIGSYS      = 0x1f
 
 	_FPE_INTDIV     = 0x1
 	_FPE_INTOVF     = 0x2
@@ -203,18 +203,18 @@ const (
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
 
-	_PERF_EVENT_IOC_DISABLE               = 0x2401
-	_PERF_EVENT_IOC_ENABLE                = 0x2400
-	_PERF_EVENT_IOC_ID                    = 0x80042407
-	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4004240b
-	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
-	_PERF_EVENT_IOC_PERIOD                = 0x40082404
-	_PERF_EVENT_IOC_QUERY_BPF             = 0xc004240a
-	_PERF_EVENT_IOC_REFRESH               = 0x2402
-	_PERF_EVENT_IOC_RESET                 = 0x2403
-	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
-	_PERF_EVENT_IOC_SET_FILTER            = 0x40042406
-	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+	_PERF_EVENT_IOC_DISABLE           = 0x2401
+	_PERF_EVENT_IOC_ENABLE            = 0x2400
+	_PERF_EVENT_IOC_ID                = 0x80042407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x4004240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT      = 0x40042409
+	_PERF_EVENT_IOC_PERIOD            = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF         = 0xc004240a
+	_PERF_EVENT_IOC_REFRESH           = 0x2402
+	_PERF_EVENT_IOC_RESET             = 0x2403
+	_PERF_EVENT_IOC_SET_BPF           = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER        = 0x40042406
+	_PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 )
 
 type timespec struct {
@@ -286,9 +286,9 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr  uint32
+	si_addr uint32
 	// si_fd is the field right after the union
-	si_fd    int32
+	si_fd int32
 }
 
 type sigactiont struct {
diff --git a/src/runtime/defs_linux_arm64.go b/src/runtime/defs_linux_arm64.go
index d9f6c1d343..fd197db902 100644
--- a/src/runtime/defs_linux_arm64.go
+++ b/src/runtime/defs_linux_arm64.go
@@ -207,18 +207,18 @@ const (
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
 
-	_PERF_EVENT_IOC_DISABLE               = 0x2401
-	_PERF_EVENT_IOC_ENABLE                = 0x2400
-	_PERF_EVENT_IOC_ID                    = 0x80082407
-	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
-	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
-	_PERF_EVENT_IOC_PERIOD                = 0x40082404
-	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
-	_PERF_EVENT_IOC_REFRESH               = 0x2402
-	_PERF_EVENT_IOC_RESET                 = 0x2403
-	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
-	_PERF_EVENT_IOC_SET_FILTER            = 0x40082406
-	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+	_PERF_EVENT_IOC_DISABLE           = 0x2401
+	_PERF_EVENT_IOC_ENABLE            = 0x2400
+	_PERF_EVENT_IOC_ID                = 0x80082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x4008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT      = 0x40042409
+	_PERF_EVENT_IOC_PERIOD            = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF         = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH           = 0x2402
+	_PERF_EVENT_IOC_RESET             = 0x2403
+	_PERF_EVENT_IOC_SET_BPF           = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER        = 0x40082406
+	_PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 )
 
 type timespec struct {
@@ -253,9 +253,9 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr  uint64
+	si_addr uint64
 	// si_fd is the next field.
-	si_fd    int32
+	si_fd int32
 }
 
 type itimerval struct {
diff --git a/src/runtime/defs_linux_mips64x.go b/src/runtime/defs_linux_mips64x.go
index a631d7aaca..3456be278f 100644
--- a/src/runtime/defs_linux_mips64x.go
+++ b/src/runtime/defs_linux_mips64x.go
@@ -202,18 +202,18 @@ const (
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
 
-	_PERF_EVENT_IOC_DISABLE               = 0x20002401
-	_PERF_EVENT_IOC_ENABLE                = 0x20002400
-	_PERF_EVENT_IOC_ID                    = 0x40082407
-	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x8008240b
-	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x80042409
-	_PERF_EVENT_IOC_PERIOD                = 0x80082404
-	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
-	_PERF_EVENT_IOC_REFRESH               = 0x20002402
-	_PERF_EVENT_IOC_RESET                 = 0x20002403
-	_PERF_EVENT_IOC_SET_BPF               = 0x80042408
-	_PERF_EVENT_IOC_SET_FILTER            = 0x80082406
-	_PERF_EVENT_IOC_SET_OUTPUT            = 0x20002405
+	_PERF_EVENT_IOC_DISABLE           = 0x20002401
+	_PERF_EVENT_IOC_ENABLE            = 0x20002400
+	_PERF_EVENT_IOC_ID                = 0x40082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x8008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT      = 0x80042409
+	_PERF_EVENT_IOC_PERIOD            = 0x80082404
+	_PERF_EVENT_IOC_QUERY_BPF         = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH           = 0x20002402
+	_PERF_EVENT_IOC_RESET             = 0x20002403
+	_PERF_EVENT_IOC_SET_BPF           = 0x80042408
+	_PERF_EVENT_IOC_SET_FILTER        = 0x80082406
+	_PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
 )
 
 //struct Sigset {
@@ -256,9 +256,9 @@ type siginfo struct {
 	si_errno int32
 	__pad0   [1]int32
 	// below here is a union; si_addr is the only field we use
-	si_addr  uint64
+	si_addr uint64
 	// si_fd is the field right after the union
-	si_fd    int32
+	si_fd int32
 }
 
 type itimerval struct {
diff --git a/src/runtime/defs_linux_mipsx.go b/src/runtime/defs_linux_mipsx.go
index 306a2adf0f..e994b6aa5a 100644
--- a/src/runtime/defs_linux_mipsx.go
+++ b/src/runtime/defs_linux_mipsx.go
@@ -206,18 +206,18 @@ const (
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
 
-	_PERF_EVENT_IOC_DISABLE               = 0x20002401
-	_PERF_EVENT_IOC_ENABLE                = 0x20002400
-	_PERF_EVENT_IOC_ID                    = 0x40042407
-	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x8004240b
-	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x80042409
-	_PERF_EVENT_IOC_PERIOD                = 0x80082404
-	_PERF_EVENT_IOC_QUERY_BPF             = 0xc004240a
-	_PERF_EVENT_IOC_REFRESH               = 0x20002402
-	_PERF_EVENT_IOC_RESET                 = 0x20002403
-	_PERF_EVENT_IOC_SET_BPF               = 0x80042408
-	_PERF_EVENT_IOC_SET_FILTER            = 0x80042406
-	_PERF_EVENT_IOC_SET_OUTPUT            = 0x20002405
+	_PERF_EVENT_IOC_DISABLE           = 0x20002401
+	_PERF_EVENT_IOC_ENABLE            = 0x20002400
+	_PERF_EVENT_IOC_ID                = 0x40042407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x8004240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT      = 0x80042409
+	_PERF_EVENT_IOC_PERIOD            = 0x80082404
+	_PERF_EVENT_IOC_QUERY_BPF         = 0xc004240a
+	_PERF_EVENT_IOC_REFRESH           = 0x20002402
+	_PERF_EVENT_IOC_RESET             = 0x20002403
+	_PERF_EVENT_IOC_SET_BPF           = 0x80042408
+	_PERF_EVENT_IOC_SET_FILTER        = 0x80042406
+	_PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
 )
 
 type timespec struct {
@@ -254,9 +254,9 @@ type siginfo struct {
 	si_code  int32
 	si_errno int32
 	// below here is a union; si_addr is the only field we use
-	si_addr  uint32
+	si_addr uint32
 	// si_fd is the field right after the union
-	si_fd    int32
+	si_fd int32
 }
 
 type itimerval struct {
diff --git a/src/runtime/defs_linux_ppc64.go b/src/runtime/defs_linux_ppc64.go
index 620c1b88e7..27c7a97c89 100644
--- a/src/runtime/defs_linux_ppc64.go
+++ b/src/runtime/defs_linux_ppc64.go
@@ -202,18 +202,18 @@ const (
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
 
-	_PERF_EVENT_IOC_DISABLE               = 0x2401
-	_PERF_EVENT_IOC_ENABLE                = 0x2400
-	_PERF_EVENT_IOC_ID                    = 0x80082407
-	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
-	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
-	_PERF_EVENT_IOC_PERIOD                = 0x40082404
-	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
-	_PERF_EVENT_IOC_REFRESH               = 0x2402
-	_PERF_EVENT_IOC_RESET                 = 0x2403
-	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
-	_PERF_EVENT_IOC_SET_FILTER            = 0x40082406
-	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+	_PERF_EVENT_IOC_DISABLE           = 0x2401
+	_PERF_EVENT_IOC_ENABLE            = 0x2400
+	_PERF_EVENT_IOC_ID                = 0x80082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x4008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT      = 0x40042409
+	_PERF_EVENT_IOC_PERIOD            = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF         = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH           = 0x2402
+	_PERF_EVENT_IOC_RESET             = 0x2403
+	_PERF_EVENT_IOC_SET_BPF           = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER        = 0x40082406
+	_PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 )
 
 //struct Sigset {
@@ -253,9 +253,9 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr  uint64
+	si_addr uint64
 	// si_fd is the field right after the union
-	si_fd    int32
+	si_fd int32
 }
 
 type itimerval struct {
diff --git a/src/runtime/defs_linux_ppc64le.go b/src/runtime/defs_linux_ppc64le.go
index ffaf6e5713..429c0a408e 100644
--- a/src/runtime/defs_linux_ppc64le.go
+++ b/src/runtime/defs_linux_ppc64le.go
@@ -202,18 +202,18 @@ const (
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
 
-	_PERF_EVENT_IOC_DISABLE               = 0x20002401
-	_PERF_EVENT_IOC_ENABLE                = 0x20002400
-	_PERF_EVENT_IOC_ID                    = 0x40082407
-	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x8008240b
-	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x80042409
-	_PERF_EVENT_IOC_PERIOD                = 0x80082404
-	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
-	_PERF_EVENT_IOC_REFRESH               = 0x20002402
-	_PERF_EVENT_IOC_RESET                 = 0x20002403
-	_PERF_EVENT_IOC_SET_BPF               = 0x80042408
-	_PERF_EVENT_IOC_SET_FILTER            = 0x80082406
-	_PERF_EVENT_IOC_SET_OUTPUT            = 0x20002405
+	_PERF_EVENT_IOC_DISABLE           = 0x20002401
+	_PERF_EVENT_IOC_ENABLE            = 0x20002400
+	_PERF_EVENT_IOC_ID                = 0x40082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x8008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT      = 0x80042409
+	_PERF_EVENT_IOC_PERIOD            = 0x80082404
+	_PERF_EVENT_IOC_QUERY_BPF         = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH           = 0x20002402
+	_PERF_EVENT_IOC_RESET             = 0x20002403
+	_PERF_EVENT_IOC_SET_BPF           = 0x80042408
+	_PERF_EVENT_IOC_SET_FILTER        = 0x80082406
+	_PERF_EVENT_IOC_SET_OUTPUT        = 0x20002405
 )
 
 //struct Sigset {
@@ -253,9 +253,9 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr  uint64
+	si_addr uint64
 	// si_fd is the field right after the union
-	si_fd    int32
+	si_fd int32
 }
 
 type itimerval struct {
diff --git a/src/runtime/defs_linux_s390x.go b/src/runtime/defs_linux_s390x.go
index 025d6dbf4d..783d01eb62 100644
--- a/src/runtime/defs_linux_s390x.go
+++ b/src/runtime/defs_linux_s390x.go
@@ -203,18 +203,18 @@ const (
 	_PERF_FLAG_PID_CGROUP  = 0x4
 	_PERF_FLAG_FD_CLOEXEC  = 0x8
 
-	_PERF_EVENT_IOC_DISABLE               = 0x2401
-	_PERF_EVENT_IOC_ENABLE                = 0x2400
-	_PERF_EVENT_IOC_ID                    = 0x80082407
-	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES     = 0x4008240b
-	_PERF_EVENT_IOC_PAUSE_OUTPUT          = 0x40042409
-	_PERF_EVENT_IOC_PERIOD                = 0x40082404
-	_PERF_EVENT_IOC_QUERY_BPF             = 0xc008240a
-	_PERF_EVENT_IOC_REFRESH               = 0x2402
-	_PERF_EVENT_IOC_RESET                 = 0x2403
-	_PERF_EVENT_IOC_SET_BPF               = 0x40042408
-	_PERF_EVENT_IOC_SET_FILTER            = 0x40082406
-	_PERF_EVENT_IOC_SET_OUTPUT            = 0x2405
+	_PERF_EVENT_IOC_DISABLE           = 0x2401
+	_PERF_EVENT_IOC_ENABLE            = 0x2400
+	_PERF_EVENT_IOC_ID                = 0x80082407
+	_PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x4008240b
+	_PERF_EVENT_IOC_PAUSE_OUTPUT      = 0x40042409
+	_PERF_EVENT_IOC_PERIOD            = 0x40082404
+	_PERF_EVENT_IOC_QUERY_BPF         = 0xc008240a
+	_PERF_EVENT_IOC_REFRESH           = 0x2402
+	_PERF_EVENT_IOC_RESET             = 0x2403
+	_PERF_EVENT_IOC_SET_BPF           = 0x40042408
+	_PERF_EVENT_IOC_SET_FILTER        = 0x40082406
+	_PERF_EVENT_IOC_SET_OUTPUT        = 0x2405
 )
 
 type timespec struct {
@@ -249,9 +249,9 @@ type siginfo struct {
 	si_errno int32
 	si_code  int32
 	// below here is a union; si_addr is the only field we use
-	si_addr  uint64
+	si_addr uint64
 	// si_fd is the field right after the union
-	si_fd    int32
+	si_fd int32
 }
 
 type itimerval struct {
diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index adfe8a929e..7aecf70465 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -2,16 +2,16 @@ package runtime
 
 // Convert platform-agnostic pmu events to Linux perf events
 var perfEventOpt = map[int32]struct {
-	Type    uint32 // type of event
-	Config  uint64 // event
-} {
-	GO_COUNT_HW_CPU_CYCLES : {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},
-	GO_COUNT_HW_INSTRUCTIONS: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},
-	GO_COUNT_HW_CACHE_REFERENCES: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_REFERENCES},
-	GO_COUNT_HW_CACHE_MISSES: {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_MISSES},
+	Type   uint32 // type of event
+	Config uint64 // event
+}{
+	GO_COUNT_HW_CPU_CYCLES:             {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},
+	GO_COUNT_HW_INSTRUCTIONS:           {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},
+	GO_COUNT_HW_CACHE_REFERENCES:       {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_REFERENCES},
+	GO_COUNT_HW_CACHE_MISSES:           {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CACHE_MISSES},
 	GO_COUNT_HW_CACHE_LL_READ_ACCESSES: {_PERF_TYPE_HW_CACHE, (_PERF_COUNT_HW_CACHE_LL) | (_PERF_COUNT_HW_CACHE_OP_READ << 8) | (_PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16)},
-	GO_COUNT_HW_CACHE_LL_READ_MISSES: {_PERF_TYPE_HW_CACHE, (_PERF_COUNT_HW_CACHE_LL) | (_PERF_COUNT_HW_CACHE_OP_READ << 8) | (_PERF_COUNT_HW_CACHE_RESULT_MISS << 16)},
-	GO_COUNT_HW_RAW: {_PERF_TYPE_RAW, 0 /* will not be used */},
+	GO_COUNT_HW_CACHE_LL_READ_MISSES:   {_PERF_TYPE_HW_CACHE, (_PERF_COUNT_HW_CACHE_LL) | (_PERF_COUNT_HW_CACHE_OP_READ << 8) | (_PERF_COUNT_HW_CACHE_RESULT_MISS << 16)},
+	GO_COUNT_HW_RAW:                    {_PERF_TYPE_RAW, 0 /* will not be used */},
 	// TODO: add more perf events
 }
 
diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index 858605f734..3c285117c0 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -3,14 +3,14 @@ package runtime
 // These Constants are platform agnostic and exposed to pprof.
 // We use perfEventOpt to map these to the underlying OS and HW.
 const (
-	GO_COUNT_HW_CPU_CYCLES              = 0x0
-	GO_COUNT_HW_INSTRUCTIONS            = 0x1
-	GO_COUNT_HW_CACHE_REFERENCES        = 0x2
-	GO_COUNT_HW_CACHE_MISSES            = 0x3
-	GO_COUNT_HW_CACHE_LL_READ_ACCESSES  = 0x4
-	GO_COUNT_HW_CACHE_LL_READ_MISSES    = 0x5
-	GO_COUNT_HW_RAW			    = 0x6
-	GO_COUNT_PMU_EVENTS_MAX		    = 0x7
+	GO_COUNT_HW_CPU_CYCLES             = 0x0
+	GO_COUNT_HW_INSTRUCTIONS           = 0x1
+	GO_COUNT_HW_CACHE_REFERENCES       = 0x2
+	GO_COUNT_HW_CACHE_MISSES           = 0x3
+	GO_COUNT_HW_CACHE_LL_READ_ACCESSES = 0x4
+	GO_COUNT_HW_CACHE_LL_READ_MISSES   = 0x5
+	GO_COUNT_HW_RAW                    = 0x6
+	GO_COUNT_PMU_EVENTS_MAX            = 0x7
 )
 
 type PMUEventAttr struct {
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 6505819e8a..ae35a1eb29 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -79,12 +79,12 @@ import (
 	"io"
 	"runtime"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"text/tabwriter"
 	"time"
 	"unsafe"
-	"strconv"
 )
 
 // BUG(rsc): Profiles are only as good as the kernel support used to generate them.
@@ -778,7 +778,7 @@ func StartCPUProfile(w io.Writer, profileHz ...int) error {
 	runtime.SetCPUProfileRate(hz)
 	go profileWriter(w)
 	return nil
-	}
+}
 
 func StartPMUProfile(opts ...ProfilingOption) error {
 	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" { // enabling only on Linux AMD64
@@ -808,7 +808,7 @@ func StartPMUProfile(opts ...ProfilingOption) error {
 
 type PMUEventConfig struct {
 	Period           int64
-	RawEvent	 int64
+	RawEvent         int64
 	PreciseIP        int8
 	IsKernelIncluded bool
 	IsHvIncluded     bool
@@ -826,16 +826,16 @@ func getPreciseIP(preciseIP int8) uint8 {
 }
 
 func populatePMUProfiler(w io.Writer, eventConfig *PMUEventConfig, eventId int, eventName string) {
-        pmu.eventOn[eventId] = true
-        eventAttr := runtime.PMUEventAttr {
-		Period: uint64(eventConfig.Period),
-		RawEvent: uint64(eventConfig.RawEvent),
-		PreciseIP: getPreciseIP(eventConfig.PreciseIP),
+	pmu.eventOn[eventId] = true
+	eventAttr := runtime.PMUEventAttr{
+		Period:           uint64(eventConfig.Period),
+		RawEvent:         uint64(eventConfig.RawEvent),
+		PreciseIP:        getPreciseIP(eventConfig.PreciseIP),
 		IsKernelIncluded: eventConfig.IsKernelIncluded,
-		IsHvIncluded: eventConfig.IsHvIncluded,
+		IsHvIncluded:     eventConfig.IsHvIncluded,
 	}
-        runtime.SetPMUProfile(eventId, &eventAttr)
-        go pmuProfileWriter(w, eventId, eventName)
+	runtime.SetPMUProfile(eventId, &eventAttr)
+	go pmuProfileWriter(w, eventId, eventName)
 }
 
 func WithProfilingPMUCycles(w io.Writer, eventConfig *PMUEventConfig) ProfilingOption {
@@ -849,7 +849,7 @@ func WithProfilingPMUCycles(w io.Writer, eventConfig *PMUEventConfig) ProfilingO
 			eventConfig.Period = 1000
 		}
 
-		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CPU_CYCLES, /* event name */ "cycles")
+		populatePMUProfiler(w, eventConfig /* event ID */, runtime.GO_COUNT_HW_CPU_CYCLES /* event name */, "cycles")
 		return nil
 	})
 }
@@ -865,8 +865,8 @@ func WithProfilingPMUInstructions(w io.Writer, eventConfig *PMUEventConfig) Prof
 			eventConfig.Period = 1000
 		}
 
-		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_INSTRUCTIONS, /* event name */ "instructions")
-			return nil
+		populatePMUProfiler(w, eventConfig /* event ID */, runtime.GO_COUNT_HW_INSTRUCTIONS /* event name */, "instructions")
+		return nil
 	})
 }
 
@@ -878,7 +878,7 @@ func WithProfilingPMUCacheReferences(w io.Writer, eventConfig *PMUEventConfig) P
 		// TODO: create a table of standard clamp values
 		// TODO: clamp period to something reasonable
 
-		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_REFERENCES, /* event name */ "cache references")
+		populatePMUProfiler(w, eventConfig /* event ID */, runtime.GO_COUNT_HW_CACHE_REFERENCES /* event name */, "cache references")
 		return nil
 	})
 }
@@ -891,7 +891,7 @@ func WithProfilingPMUCacheMisses(w io.Writer, eventConfig *PMUEventConfig) Profi
 		// TODO: create a table of standard clamp values
 		// TODO: clamp period to something reasonable
 
-		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_MISSES, /* event name */ "cache misses")
+		populatePMUProfiler(w, eventConfig /* event ID */, runtime.GO_COUNT_HW_CACHE_MISSES /* event name */, "cache misses")
 		return nil
 	})
 }
@@ -904,7 +904,7 @@ func WithProfilingPMUCacheLLReadAccesses(w io.Writer, eventConfig *PMUEventConfi
 		// TODO: create a table of standard clamp values
 		// TODO: clamp period to something reasonable
 
-		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_LL_READ_ACCESSES, /* event name */ "last-level cache read accesses")
+		populatePMUProfiler(w, eventConfig /* event ID */, runtime.GO_COUNT_HW_CACHE_LL_READ_ACCESSES /* event name */, "last-level cache read accesses")
 		return nil
 	})
 }
@@ -917,7 +917,7 @@ func WithProfilingPMUCacheLLReadMisses(w io.Writer, eventConfig *PMUEventConfig)
 		// TODO: create a table of standard clamp values
 		// TODO: clamp period to something reasonable
 
-		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_CACHE_LL_READ_MISSES, /* event name */ "last-level cache read misses")
+		populatePMUProfiler(w, eventConfig /* event ID */, runtime.GO_COUNT_HW_CACHE_LL_READ_MISSES /* event name */, "last-level cache read misses")
 		return nil
 	})
 }
@@ -930,16 +930,15 @@ func WithProfilingPMURaw(w io.Writer, eventConfig *PMUEventConfig) ProfilingOpti
 		// TODO: create a table of standard clamp values
 		// TODO: clamp period to something reasonable
 
-		if  eventConfig.RawEvent < 0 {
+		if eventConfig.RawEvent < 0 {
 			return fmt.Errorf("RawEvent should be >= 0")
 		}
 
-		populatePMUProfiler(w, eventConfig, /* event ID */ runtime.GO_COUNT_HW_RAW, /* event name */ "r" + strconv.FormatInt(eventConfig.RawEvent, 16))
+		populatePMUProfiler(w, eventConfig /* event ID */, runtime.GO_COUNT_HW_RAW /* event name */, "r"+strconv.FormatInt(eventConfig.RawEvent, 16))
 		return nil
 	})
 }
 
-
 type ProfilingOption interface {
 	apply() error
 }
@@ -991,7 +990,7 @@ func pmuProfileWriter(w io.Writer, eventId int, eventName string) {
 		}
 	}
 	if err != nil {
-	    panic("runtime/pprof: converting profile: " + err.Error())
+		panic("runtime/pprof: converting profile: " + err.Error())
 	}
 	b.pmuBuild(eventName)
 	pmu.wg.Done()
diff --git a/src/runtime/pprof/proto.go b/src/runtime/pprof/proto.go
index 61e87d2846..29b4c2ebe6 100644
--- a/src/runtime/pprof/proto.go
+++ b/src/runtime/pprof/proto.go
@@ -37,14 +37,14 @@ type profileBuilder struct {
 	m            profMap
 
 	// encoding state
-	w            io.Writer
-	zw           *gzip.Writer
-	pb           protobuf
-	strings      []string
-	stringMap    map[string]int
-	locs         map[uintptr]int
-	funcs        map[string]int // Package path-qualified function name to Function.ID
-	mem          []memMap
+	w         io.Writer
+	zw        *gzip.Writer
+	pb        protobuf
+	strings   []string
+	stringMap map[string]int
+	locs      map[uintptr]int
+	funcs     map[string]int // Package path-qualified function name to Function.ID
+	mem       []memMap
 }
 
 type memMap struct {
@@ -376,7 +376,7 @@ func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error
 		data = data[3:]
 	}
 
-    return b.addData(data, tags)
+	return b.addData(data, tags)
 }
 
 func (b *profileBuilder) addPMUData(data []uint64, tags []unsafe.Pointer) error {
@@ -393,7 +393,7 @@ func (b *profileBuilder) addPMUData(data []uint64, tags []unsafe.Pointer) error
 		data = data[3:]
 	}
 
-    return b.addData(data, tags)
+	return b.addData(data, tags)
 }
 
 func (b *profileBuilder) profileBuild() {
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 5f0c2e6793..50d081c85f 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3815,7 +3815,7 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
 	getg().m.mallocing--
 }
 
-var lostPMUAtomic64Count[GO_COUNT_PMU_EVENTS_MAX] uint64
+var lostPMUAtomic64Count [GO_COUNT_PMU_EVENTS_MAX]uint64
 
 // Called if we receive a SIGPROF signal and PMU is enabled.
 // Called by the signal handler, may run during STW.
@@ -3974,9 +3974,9 @@ func setcpuprofilerate(hz int32) {
 }
 
 func setpmuprofile(eventId int32, eventAttr *PMUEventAttr) {
-	// setProcessPMUProfilerFptr and setProcessPMUProfilerFptr are write once variables. 
+	// setProcessPMUProfilerFptr and setProcessPMUProfilerFptr are write once variables.
 	// Hence, there cannot be any race from checking non-nil to invoking them.
-	if  setProcessPMUProfilerFptr == nil || setThreadPMUProfilerFptr == nil {
+	if setProcessPMUProfilerFptr == nil || setThreadPMUProfilerFptr == nil {
 		return
 	}
 
@@ -4008,7 +4008,7 @@ func setpmuprofile(eventId int32, eventAttr *PMUEventAttr) {
 	}
 
 	_g_.m.locks--
- }
+}
 
 // init initializes pp, which may be a freshly allocated p or a
 // previously destroyed p, and transitions it to status _Pgcstop.
diff --git a/src/testing/internal/testdeps/deps.go b/src/testing/internal/testdeps/deps.go
index a379244b1e..546a92fef1 100644
--- a/src/testing/internal/testdeps/deps.go
+++ b/src/testing/internal/testdeps/deps.go
@@ -49,36 +49,36 @@ func (TestDeps) StopCPUProfile() {
 }
 
 func (TestDeps) StartPMUProfile(w io.Writer, event string, period int64, preciseIP int8, isKernelIncluded bool, isHvIncluded bool) error {
-	eventConfig := pprof.PMUEventConfig {
-		Period: period,
-		PreciseIP: preciseIP,
+	eventConfig := pprof.PMUEventConfig{
+		Period:           period,
+		PreciseIP:        preciseIP,
 		IsKernelIncluded: isKernelIncluded,
-		IsHvIncluded: isHvIncluded,
+		IsHvIncluded:     isHvIncluded,
 	}
 	switch event {
-		case "cycles":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
-		case "instructions":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUInstructions(w, &eventConfig))
-		case "cacheReferences":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheReferences(w, &eventConfig))
-		case "cacheMisses":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
-		case "cacheLLReadAccesses":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadAccesses(w, &eventConfig))
-		case "cacheLLReadMisses":
-			return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadMisses(w, &eventConfig))
-		default:
-			// Is this a raw event?
-			if strings.HasPrefix(event, "r") {
-				if rawHexEvent, err := strconv.ParseInt(event[1:], 16, 64); err == nil {
-					eventConfig.RawEvent = rawHexEvent
-					return pprof.StartPMUProfile(pprof.WithProfilingPMURaw(w, &eventConfig))
-				}
-				return fmt.Errorf("Incorrect hex format for raw event")
-			} else {
-				return fmt.Errorf("Unknown or not yet implemented event")
+	case "cycles":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(w, &eventConfig))
+	case "instructions":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUInstructions(w, &eventConfig))
+	case "cacheReferences":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheReferences(w, &eventConfig))
+	case "cacheMisses":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheMisses(w, &eventConfig))
+	case "cacheLLReadAccesses":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadAccesses(w, &eventConfig))
+	case "cacheLLReadMisses":
+		return pprof.StartPMUProfile(pprof.WithProfilingPMUCacheLLReadMisses(w, &eventConfig))
+	default:
+		// Is this a raw event?
+		if strings.HasPrefix(event, "r") {
+			if rawHexEvent, err := strconv.ParseInt(event[1:], 16, 64); err == nil {
+				eventConfig.RawEvent = rawHexEvent
+				return pprof.StartPMUProfile(pprof.WithProfilingPMURaw(w, &eventConfig))
 			}
+			return fmt.Errorf("Incorrect hex format for raw event")
+		} else {
+			return fmt.Errorf("Unknown or not yet implemented event")
+		}
 	}
 }
 
diff --git a/src/testing/testing.go b/src/testing/testing.go
index 3a778c3b7a..a5e38fd7a6 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -317,12 +317,12 @@ var (
 	memProfile           *string
 	memProfileRate       *int
 	cpuProfile           *string
-	pmuProfile	     *string
-	pmuEvent	     *string
+	pmuProfile           *string
+	pmuEvent             *string
 	pmuPeriod            *int64
 	pmuPreciseIP         *int
 	pmuKernelIncluded    *bool
-	pmuHvIncluded	     *bool
+	pmuHvIncluded        *bool
 	blockProfile         *string
 	blockProfileRate     *int
 	mutexProfile         *string
@@ -1038,10 +1038,12 @@ var errMain = errors.New("testing: unexpected use of func Main")
 
 type matchStringOnly func(pat, str string) (bool, error)
 
-func (f matchStringOnly) MatchString(pat, str string) (bool, error)   { return f(pat, str) }
-func (f matchStringOnly) StartCPUProfile(w io.Writer) error           { return errMain }
-func (f matchStringOnly) StopCPUProfile()                             {}
-func (f matchStringOnly) StartPMUProfile(w io.Writer, event string, period int64, preciseIP int8, isKernelIncluded bool, isHvIncluded bool) error { return errMain }
+func (f matchStringOnly) MatchString(pat, str string) (bool, error) { return f(pat, str) }
+func (f matchStringOnly) StartCPUProfile(w io.Writer) error         { return errMain }
+func (f matchStringOnly) StopCPUProfile()                           {}
+func (f matchStringOnly) StartPMUProfile(w io.Writer, event string, period int64, preciseIP int8, isKernelIncluded bool, isHvIncluded bool) error {
+	return errMain
+}
 func (f matchStringOnly) StopPMUProfile()                             {}
 func (f matchStringOnly) WriteProfileTo(string, io.Writer, int) error { return errMain }
 func (f matchStringOnly) ImportPath() string                          { return "" }
@@ -1333,7 +1335,7 @@ func (m *M) writeProfiles() {
 	}
 	if *pmuProfile != "" {
 		m.deps.StopPMUProfile() // flushes profile to disk
-	} 
+	}
 	if *traceFile != "" {
 		trace.Stop() // flushes trace to disk
 	}
diff --git a/test/pmu/http/test1.go b/test/pmu/http/test1.go
index cbdec6303b..7edf4d1641 100644
--- a/test/pmu/http/test1.go
+++ b/test/pmu/http/test1.go
@@ -1,5 +1,5 @@
 // run
-// Example of usage: 
+// Example of usage:
 // 1. go run test1.go
 // 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&pmuevent=cycles\&pmuperiod=10000000
 
@@ -8,16 +8,16 @@ package main
 import (
 	"fmt"
 	"log"
-	_"time"
 	"net/http"
 	_ "net/http/pprof"
+	_ "time"
 )
 
 var sum int
 
 func main() {
 	go func() {
-        log.Println(http.ListenAndServe("localhost:6060", nil))
+		log.Println(http.ListenAndServe("localhost:6060", nil))
 	}()
 	// time.Sleep(2 * time.Second)
 	for i := 0; i <= 10000000000; i++ {
diff --git a/test/pmu/http/test2.go b/test/pmu/http/test2.go
index 4b96c4e381..ce0b62cd38 100644
--- a/test/pmu/http/test2.go
+++ b/test/pmu/http/test2.go
@@ -1,5 +1,5 @@
 // run
-// Example of usage: 
+// Example of usage:
 // 1. go run test2.go
 // 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&pmuevent=instructions\&pmuperiod=10000000
 
@@ -8,9 +8,9 @@ package main
 import (
 	"fmt"
 	"log"
-	"sync"
 	"net/http"
 	_ "net/http/pprof"
+	"sync"
 )
 
 var wg sync.WaitGroup
@@ -19,14 +19,14 @@ var sum int
 
 func f(i int) {
 	defer wg.Done()
-        var local int
+	var local int
 	for j := i; j < 100000000; j++ {
-        local -= j / 2
-        local *= j
-        mux.Lock()
-        sum += local
-        mux.Unlock()
-    }
+		local -= j / 2
+		local *= j
+		mux.Lock()
+		sum += local
+		mux.Unlock()
+	}
 }
 
 func run() error {
diff --git a/test/pmu/http/test3.go b/test/pmu/http/test3.go
index eb1a04dbf8..65e37bc07e 100644
--- a/test/pmu/http/test3.go
+++ b/test/pmu/http/test3.go
@@ -1,5 +1,5 @@
 // run
-// Example of usage: 
+// Example of usage:
 // 1. go run test3.go
 // 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&pmuevent=cacheMisses\&pmuperiod=10000000
 
@@ -8,10 +8,10 @@ package main
 import (
 	"fmt"
 	"log"
-	"sync"
-	"time"
 	"net/http"
 	_ "net/http/pprof"
+	"sync"
+	"time"
 )
 
 var wg sync.WaitGroup
@@ -21,10 +21,10 @@ var sum int
 func f(i int) {
 	defer wg.Done()
 	for j := i; j < 100000000; j++ {
-        sum -= j / 2
-        sum *= j
-        time.Sleep(time.Microsecond)
-    }
+		sum -= j / 2
+		sum *= j
+		time.Sleep(time.Microsecond)
+	}
 }
 
 func run() error {
diff --git a/test/pmu/http/test4.go b/test/pmu/http/test4.go
index 07225076e8..dd4c4950c3 100644
--- a/test/pmu/http/test4.go
+++ b/test/pmu/http/test4.go
@@ -1,5 +1,5 @@
 // run
-// Example of Usage: 
+// Example of Usage:
 // 1. go run test4.go
 // 2. go tool pprof http://localhost:6060/debug/pprof/profile?seconds=6\&pmu=true\&pmuevent=r53010e\&pmuperiod=1000000
 
@@ -16,7 +16,7 @@ var sum int
 
 func main() {
 	go func() {
-        log.Println(http.ListenAndServe("localhost:6060", nil))
+		log.Println(http.ListenAndServe("localhost:6060", nil))
 	}()
 	for i := 0; i <= 10000000000; i++ {
 		sum += i
diff --git a/test/pmu/leak/test2.go b/test/pmu/leak/test2.go
index 44f2d77875..a5dbf84e83 100644
--- a/test/pmu/leak/test2.go
+++ b/test/pmu/leak/test2.go
@@ -19,7 +19,7 @@ func run() error {
 		}
 
 		var cycle pprof.PMUEventConfig
-		cycle.Period =  100000
+		cycle.Period = 100000
 		cycle.IsKernelIncluded = false
 		cycle.IsHvIncluded = false
 
diff --git a/test/pmu/leak/test3.go b/test/pmu/leak/test3.go
index 89b4bd3477..bea689905f 100644
--- a/test/pmu/leak/test3.go
+++ b/test/pmu/leak/test3.go
@@ -33,7 +33,7 @@ func run() error {
 		}
 
 		var cycle pprof.PMUEventConfig
-		cycle.Period =  100000
+		cycle.Period = 100000
 		cycle.IsKernelIncluded = false
 		cycle.IsHvIncluded = false
 
diff --git a/test/pmu/leak/test5.go b/test/pmu/leak/test5.go
index 7ef22515d7..5fb8a323d7 100644
--- a/test/pmu/leak/test5.go
+++ b/test/pmu/leak/test5.go
@@ -4,10 +4,10 @@ package main
 
 import (
 	"fmt"
-	"os"
 	"log"
-	"sync"
+	"os"
 	"runtime/pprof"
+	"sync"
 )
 
 var wg sync.WaitGroup
@@ -54,8 +54,8 @@ func main() {
 	cacheMiss.Period = 1
 
 	if err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle), pprof.WithProfilingPMUInstructions(instrFile, &instr), pprof.WithProfilingPMUCacheReferences(cacheRefFile, &cacheRef), pprof.WithProfilingPMUCacheMisses(cacheMissFile, &cacheMiss)); err != nil {
-			log.Fatal(err)
-		}
+		log.Fatal(err)
+	}
 
 	for i := 0; i < 1000; i++ {
 		go run()
diff --git a/test/pmu/leak/test6.go b/test/pmu/leak/test6.go
index 0bd4c341f6..cd15c08e49 100644
--- a/test/pmu/leak/test6.go
+++ b/test/pmu/leak/test6.go
@@ -5,8 +5,8 @@ package main
 import (
 	"fmt"
 	"os"
-	"time"
 	"runtime/pprof"
+	"time"
 )
 
 var sum int
diff --git a/test/pmu/test1.go b/test/pmu/test1.go
index 4edb27d22e..59654d6497 100644
--- a/test/pmu/test1.go
+++ b/test/pmu/test1.go
@@ -1,14 +1,14 @@
 // run
 // Example of usage: go run test1.go
-// Flamegraph: go tool pprof -relative_percentages -http=":8081" cycle_profile 
+// Flamegraph: go tool pprof -relative_percentages -http=":8081" cycle_profile
 package main
 
 import (
 	"fmt"
 	"log"
 	"os"
-	"sync"
 	"runtime/pprof"
+	"sync"
 )
 
 var wg sync.WaitGroup
@@ -153,7 +153,6 @@ func f10() {
 	fmt.Println(sum)
 }
 
-
 func run() error {
 	cycleFile, err := os.Create("cycle_profile")
 	if err != nil {
@@ -162,7 +161,7 @@ func run() error {
 	defer cycleFile.Close()
 
 	var cycle pprof.PMUEventConfig
-	cycle.Period =  10000000
+	cycle.Period = 10000000
 	cycle.IsKernelIncluded = false
 	cycle.IsHvIncluded = false
 
diff --git a/test/pmu/test2.go b/test/pmu/test2.go
index bc9ffb6f22..ee7b281bde 100644
--- a/test/pmu/test2.go
+++ b/test/pmu/test2.go
@@ -7,9 +7,9 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"sync"
-	_"time"
 	"runtime/pprof"
+	"sync"
+	_ "time"
 )
 
 var wg sync.WaitGroup
@@ -176,7 +176,7 @@ func run() error {
 	defer cycleFile.Close()
 
 	var cycle pprof.PMUEventConfig
-	cycle.Period =  100000000
+	cycle.Period = 100000000
 	// cycle.PreciseIP = 2
 
 	instrFile, err := os.Create("instr_profile")
@@ -186,7 +186,7 @@ func run() error {
 	defer instrFile.Close()
 
 	var instr pprof.PMUEventConfig
-	instr.Period =  100000000
+	instr.Period = 100000000
 	// instr.PreciseIP = 2
 
 	cacheMissFile, err := os.Create("cacheMiss_profile")
@@ -199,7 +199,6 @@ func run() error {
 	cacheMiss.Period = 10
 	// cacheMiss.PreciseIP = 2
 
-
 	cacheRefFile, err := os.Create("cacheRef_profile")
 	if err != nil {
 		return err
@@ -210,10 +209,9 @@ func run() error {
 	cacheRef.Period = 10000
 	// cacheRef.PreciseIP = 2
 
-
 	if err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle), pprof.WithProfilingPMUInstructions(instrFile, &instr), pprof.WithProfilingPMUCacheReferences(cacheRefFile, &cacheRef), pprof.WithProfilingPMUCacheMisses(cacheMissFile, &cacheMiss)); err != nil {
 		return err
-	 }
+	}
 
 	defer pprof.StopPMUProfile()
 
diff --git a/test/pmu/test3.go b/test/pmu/test3.go
index 44c4754a26..2558eb05bc 100644
--- a/test/pmu/test3.go
+++ b/test/pmu/test3.go
@@ -7,8 +7,8 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"sync"
 	"runtime/pprof"
+	"sync"
 )
 
 var wg sync.WaitGroup
@@ -165,7 +165,6 @@ func run() error {
 	}
 	defer pprof.StopCPUProfile()
 
-
 	wg.Add(10)
 	defer wg.Wait()
 
diff --git a/test/pmu/test4.go b/test/pmu/test4.go
index cc55510389..ce9f0b80ee 100644
--- a/test/pmu/test4.go
+++ b/test/pmu/test4.go
@@ -7,8 +7,8 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"sync"
 	"runtime/pprof"
+	"sync"
 )
 
 var wg sync.WaitGroup
@@ -153,7 +153,6 @@ func f10() {
 	fmt.Println(sum)
 }
 
-
 func run() error {
 	rawFile, err := os.Create("raw_profile")
 	if err != nil {
@@ -163,7 +162,7 @@ func run() error {
 
 	var raw pprof.PMUEventConfig
 	raw.RawEvent = /* UOPS_ISSUED */ 0x53010e
-	raw.Period =  1000000
+	raw.Period = 1000000
 	raw.IsKernelIncluded = false
 	raw.IsHvIncluded = false
 

From 428f949466555761b3bfc025deee96a6ddccc99e Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Sun, 22 Sep 2019 19:12:26 -0400
Subject: [PATCH 106/126] Enable PEBS

---
 src/runtime/defs_linux_amd64.go |   8 +-
 src/runtime/defs_perf_linux.go  |  79 +++++++++---
 src/runtime/defs_pmu.go         |  17 ++-
 src/runtime/os_linux.go         |  98 +++++++++++----
 src/runtime/perf_linux.go       | 216 ++++++++++++++++++++++++++++++++
 src/runtime/pprof/pprof.go      |  37 ++++--
 src/runtime/proc.go             |   2 +-
 src/runtime/runtime2.go         |   1 +
 8 files changed, 394 insertions(+), 64 deletions(-)
 create mode 100644 src/runtime/perf_linux.go

diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 9ee04b7224..87b3711f05 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -13,9 +13,11 @@ const (
 	_PROT_WRITE = 0x2
 	_PROT_EXEC  = 0x4
 
-	_MAP_ANON    = 0x20
-	_MAP_PRIVATE = 0x2
-	_MAP_FIXED   = 0x10
+	_MAP_SHARED	     = 0x1
+	_MAP_PRIVATE	     = 0x2
+	_MAP_SHARED_VALIDATE = 0x3
+	_MAP_FIXED	     = 0x10
+	_MAP_ANON	     = 0x20
 
 	_MADV_DONTNEED   = 0x4
 	_MADV_FREE       = 0x8
diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index 7aecf70465..f1c207c774 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -2,8 +2,9 @@ package runtime
 
 // Convert platform-agnostic pmu events to Linux perf events
 var perfEventOpt = map[int32]struct {
+	// The lower-case type is reserved for Go
 	Type   uint32 // type of event
-	Config uint64 // event
+	config uint64 // event
 }{
 	GO_COUNT_HW_CPU_CYCLES:             {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_CPU_CYCLES},
 	GO_COUNT_HW_INSTRUCTIONS:           {_PERF_TYPE_HARDWARE, _PERF_COUNT_HW_INSTRUCTIONS},
@@ -16,23 +17,65 @@ var perfEventOpt = map[int32]struct {
 }
 
 type perfEventAttr struct {
+	// The lower-case type is reserved for Go
 	Type               uint32
-	Size               uint32
-	Config             uint64
-	Sample             uint64
-	Sample_type        uint64
-	Read_format        uint64
-	Bits               uint64
-	Wakeup             uint32
-	Bp_type            uint32
-	Ext1               uint64
-	Ext2               uint64
-	Branch_sample_type uint64
-	Sample_regs_user   uint64
-	Sample_stack_user  uint32
-	Clockid            int32
-	Sample_regs_intr   uint64
-	Aux_watermark      uint32
-	Sample_max_stack   uint16
+	size               uint32
+	config             uint64
+	sample             uint64
+	sample_type        uint64
+	read_format        uint64
+	bits               uint64
+	wakeup             uint32
+	bp_type            uint32
+	ext1               uint64
+	ext2               uint64
+	branch_sample_type uint64
+	sample_regs_user   uint64
+	sample_stack_user  uint32
+	clockid            int32
+	sample_regs_intr   uint64
+	aux_watermark      uint32
+	sample_max_stack   uint16
 	_                  uint16
 }
+
+type perfEventMmapPage struct {
+	version        uint32
+	compat_version uint32
+	lock           uint32
+	index          uint32
+	offset         int64
+	time_enabled   uint64
+	Time_running   uint64
+	capabilities   uint64
+	pmc_width      uint16
+	time_shift     uint16
+	time_mult      uint32
+	time_offset    uint64
+	time_zero      uint64
+	size           uint32
+	_              [948]uint8
+	data_head      uint64
+	data_tail      uint64
+	data_offset    uint64
+	data_size      uint64
+	aux_head       uint64
+	aux_tail       uint64
+	aux_offset     uint64
+	aux_size       uint64
+}
+
+type perfEventHeader struct {
+	// The lower-case type is reserved for Go
+	Type uint32
+	misc uint16
+	size uint16
+}
+
+type perfSampleData struct {
+	ip   uint64 // if _PERF_SAMPLE_IP
+	addr uint64 // if _PERF_SAMPLE_ADDR
+	pid  uint32 // if _PERF_SAMPLE_TID 
+	tid  uint32 // if _PERF_SAMPLE_TID
+	// TODO: More fields can be added if needed
+}
diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index 3c285117c0..38d663337e 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -14,9 +14,16 @@ const (
 )
 
 type PMUEventAttr struct {
-	Period           uint64
-	RawEvent         uint64
-	PreciseIP        uint8
-	IsKernelIncluded bool
-	IsHvIncluded     bool
+	Period                    uint64
+	RawEvent                  uint64
+	PreciseIP                 uint8
+	IsSampleIPIncluded        bool
+	IsSampleAddrIncluded	  bool
+	IsSampleCallchainIncluded bool
+	IsSampleThreadIDIncluded  bool
+	IsKernelIncluded          bool
+	IsHvIncluded              bool
+	IsIdleIncluded            bool
+	IsCallchainKernelIncluded bool
+	IsCallchainUserIncluded   bool
 }
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index e6d997d98b..fcab4db43e 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -480,8 +480,6 @@ func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
 	}
 }
 
-//go:noescape
-func perfEventOpen(attr *perfEventAttr, pid, cpu, groupFd, flags, dummy int) (r int32, r2, err int)
 func fcntl(fd int32, cmd, arg int) (r, err int)
 //go:noescape
 func fcntl2(fd int32, cmd int, arg *fOwnerEx) (r, err int)
@@ -492,40 +490,44 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 	if eventAttr == nil {
 		if _g_.m.eventAttrs[eventId] != nil {
 			closefd(_g_.m.eventFds[eventId])
+			_g_.m.eventAttrs[eventId] = nil
+		}
+		if _g_.m.eventMmapBufs[eventId] != nil {
+			perfUnsetMmap(_g_.m.eventMmapBufs[eventId])
+			_g_.m.eventMmapBufs[eventId] = nil
 		}
 	} else {
 		if _g_.m.eventAttrs[eventId] != nil {
 			closefd(_g_.m.eventFds[eventId])
+			_g_.m.eventAttrs[eventId] = nil
+		}
+		if _g_.m.eventMmapBufs[eventId] != nil {
+			perfUnsetMmap(_g_.m.eventMmapBufs[eventId])
+			_g_.m.eventMmapBufs[eventId] = nil
 		}
 
 		var perfAttr perfEventAttr
-		perfAttr.Size = uint32(unsafe.Sizeof(perfAttr))
-		perfAttr.Type = perfEventOpt[eventId].Type
-		if eventId == GO_COUNT_HW_RAW {
-			perfAttr.Config = eventAttr.RawEvent
-		} else {
-			perfAttr.Config = perfEventOpt[eventId].Config
-		}
-		perfAttr.Sample = eventAttr.Period
-		perfAttr.Bits = uint64(eventAttr.PreciseIP) << 15 // precise ip
-		if !eventAttr.IsKernelIncluded { // don't count kernel
-			perfAttr.Bits += 0b100000
-		}
-		if !eventAttr.IsHvIncluded { // don't count hypervisor
-			perfAttr.Bits += 0b1000000
-		}
+		perfAttrInit(eventId, eventAttr, &perfAttr)
 
 		fd, _, err := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy */ 0)
 		if err != 0 {
 			println("Linux perf event open failed")
 			return
 		}
-		_g_.m.eventFds[eventId] = fd
+
+		// create mmap buffer for this file 
+		perfMmap := perfSetMmap(fd)
+		if perfMmap == nil {
+			println("Fail to set perf mmap")
+			closefd(fd)
+			return
+		}
 
 		flag, _ := fcntl(fd, /* F_GETFL */ 0x3, 0)
 		_, err = fcntl(fd, /* F_SETFL */ 0x4, flag | /* O_ASYNC */ 0x2000)
 		if err != 0 {
 			println("Failed to set notification for the PMU event")
+			perfUnsetMmap(perfMmap)
 			closefd(fd)
 			return
 		}
@@ -533,6 +535,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		_, err = fcntl(fd, /* F_SETSIG */ 0xa, _SIGPROF)
 		if err != 0 {
 			println("Failed to set signal for the PMU event")
+			perfUnsetMmap(perfMmap)
 			closefd(fd)
 			return
 		}
@@ -541,19 +544,39 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		_, err = fcntl2(fd, /* F_SETOWN_EX */ 0xf, &fOwnEx)
 		if err != 0 {
 			println("Failed to set the owner of the perf event file")
+			perfUnsetMmap(perfMmap)
+			closefd(fd)
+			return
+		}
+
+		_g_.m.eventAttrs[eventId] = eventAttr
+		_g_.m.eventMmapBufs[eventId] = perfMmap
+		_g_.m.eventFds[eventId] = fd
+
+		if !perfResetCounter(fd) {
+			_g_.m.eventAttrs[eventId] = nil
+			perfUnsetMmap(perfMmap)
+			_g_.m.eventMmapBufs[eventId] = nil
+			closefd(fd)
+			return
+		}
+		if !perfStartCounter(fd) {
+			_g_.m.eventAttrs[eventId] = nil
+			perfUnsetMmap(perfMmap)
+			_g_.m.eventMmapBufs[eventId] = nil
 			closefd(fd)
 			return
 		}
 	}
-	_g_.m.eventAttrs[eventId] = eventAttr
 }
 
-func ioctl(fd int32, req, arg int) (r, err int)
-
 //go:nowritebarrierrec
 func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 	fd := info.si_fd
-	ioctl(fd, _PERF_EVENT_IOC_DISABLE, 0) // we don't care about failing ioctl
+
+	if !perfStopCounter(fd) {
+		return
+	}
 
 	var eventId int = -1
 	for i := 0; i < GO_COUNT_PMU_EVENTS_MAX; i++ {
@@ -563,11 +586,36 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 		}
 	}
 	if eventId != -1 {
-		sigprofPMU(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId)
+		mmapBuf := _g_.m.eventMmapBufs[eventId]
+		remains := mmapBuf.data_head - mmapBuf.data_tail
+		for remains > 0 {
+			var hdr perfEventHeader
+			if remains < uint64(unsafe.Sizeof(hdr)) {
+				perfSkipAll(mmapBuf)
+				break
+			}
+			if !perfReadHeader(mmapBuf, &hdr) {
+				println("Failed to read the mmap header")
+				break
+			}
+			if hdr.Type == _PERF_RECORD_SAMPLE {
+				var sampleData perfSampleData
+				// sampleData.isPrecise = (hdr.misc & _PERF_RECORD_MISC_EXACT_IP) ? true : false
+				perfRecordSample(mmapBuf, _g_.m.eventAttrs[eventId], &sampleData)
+				sigprofPMU(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId, &sampleData)
+			} else if hdr.size == 0 {
+				perfSkipAll(mmapBuf)
+			} else {
+				perfSkipRecord(mmapBuf, &hdr)
+			}
+			remains = mmapBuf.data_head - mmapBuf.data_tail
+		}
+
 	} else { // should never be taken
 		println("File descriptor ", fd, " not found in _g_.m.eventFds")
 	}
 
-	ioctl(fd, _PERF_EVENT_IOC_ENABLE, 0) // we don't care about failing ioctl
-	return
+	if !perfStartCounter(fd) {
+		return
+	}
 }
diff --git a/src/runtime/perf_linux.go b/src/runtime/perf_linux.go
new file mode 100644
index 0000000000..6e7db7c9fb
--- /dev/null
+++ b/src/runtime/perf_linux.go
@@ -0,0 +1,216 @@
+package runtime
+
+import (
+	"unsafe"
+)
+
+func ioctl(fd int32, req, arg int) (r, err int)
+//go:noescape
+func perfEventOpen(attr *perfEventAttr, pid, cpu, groupFd, flags, dummy int) (r int32, r2, err int)
+
+const perfDataPages = 2
+var perfPageSize uint64
+var perfPageMask uint64
+
+func perfAttrInit(eventId int32, eventAttr *PMUEventAttr, perfAttr *perfEventAttr) {
+	perfAttr.Type = perfEventOpt[eventId].Type
+	perfAttr.size = uint32(unsafe.Sizeof(*perfAttr))
+
+	if eventId == GO_COUNT_HW_RAW {
+		perfAttr.config = eventAttr.RawEvent
+	} else {
+		perfAttr.config = perfEventOpt[eventId].config
+	}
+
+	perfAttr.sample = eventAttr.Period
+	if perfAttr.sample == 0 {
+		perfAttr.read_format = _PERF_FORMAT_TOTAL_TIME_ENABLED | _PERF_FORMAT_TOTAL_TIME_RUNNING
+	}
+
+	if eventAttr.IsSampleIPIncluded {
+		perfAttr.sample_type = _PERF_SAMPLE_IP
+	}
+	if eventAttr.IsSampleAddrIncluded {
+		perfAttr.sample_type |= _PERF_SAMPLE_ADDR
+	}
+	if eventAttr.IsSampleCallchainIncluded {
+		perfAttr.sample_type |= _PERF_SAMPLE_CALLCHAIN
+	}
+	if eventAttr.IsSampleThreadIDIncluded {
+		perfAttr.sample_type |= _PERF_SAMPLE_TID
+	}
+
+	perfAttr.bits = 1 // the counter is disabled and will be enabled later
+	perfAttr.bits |= uint64(eventAttr.PreciseIP) << 15 // precise ip
+	if !eventAttr.IsKernelIncluded { // don't count kernel
+		perfAttr.bits |= 1 << 5
+	}
+	if !eventAttr.IsHvIncluded { // don't count hypervisor
+		perfAttr.bits |= 1 << 6
+	}
+	if !eventAttr.IsIdleIncluded { // don't count when idle
+		perfAttr.bits |= 1 << 7
+	}
+	if !eventAttr.IsCallchainKernelIncluded {
+		perfAttr.bits |= 1 << 21
+	}
+	if !eventAttr.IsCallchainUserIncluded {
+		perfAttr.bits |= 1 << 22
+	}
+
+}
+
+func perfMmapInit() {
+	perfPageSize = uint64(physPageSize)
+	perfPageMask = perfPageSize * perfDataPages - 1
+}
+
+func perfMmapSize() uintptr {
+	if perfPageSize == 0 {
+		println("The perf page size has been unknown!")
+	}
+	return uintptr(perfPageSize * (perfDataPages + /* metadata page */ 1))
+}
+
+func perfSetMmap(fd int32) *perfEventMmapPage {
+	if perfPageSize == 0 {
+		perfMmapInit()
+	}
+
+	size := perfMmapSize()
+	r, err := mmap(nil, size, _PROT_WRITE | _PROT_READ, _MAP_SHARED, fd, /* page offset */ 0)
+	if err != 0 {
+		return nil
+        }
+
+	perfMmap := (*perfEventMmapPage)(r)
+	// There is no memset available in Go runime
+	// We instead employ the following approach to initialize all bytes in perfMmap to zeros
+	var temp perfEventMmapPage
+	memmove(unsafe.Pointer(perfMmap), unsafe.Pointer(&temp), unsafe.Sizeof(temp))
+
+	return perfMmap
+}
+
+func perfUnsetMmap(mmapBuf *perfEventMmapPage) {
+	size := perfMmapSize()
+	munmap(unsafe.Pointer(mmapBuf), size)
+}
+
+func perfSkipNBytes(mmapBuf *perfEventMmapPage, n uint64 ) {
+	head := mmapBuf.data_head
+	tail := mmapBuf.data_tail
+	if tail + n > head {
+		n = head - tail
+	}
+	mmapBuf.data_tail += n
+}
+
+func perfSkipRecord(mmapBuf *perfEventMmapPage, hdr *perfEventHeader) {
+	if mmapBuf == nil {
+		return
+	}
+	remains := uint64(hdr.size) - uint64(unsafe.Sizeof(hdr))
+	if remains > 0 {
+		perfSkipNBytes(mmapBuf, remains)
+	}
+}
+
+func perfSkipAll(mmapBuf *perfEventMmapPage) {
+	if mmapBuf == nil {
+		return
+	}
+	remains := mmapBuf.data_head - mmapBuf.data_tail
+	if remains > 0 {
+		perfSkipNBytes(mmapBuf, remains)
+	}
+}
+
+func perfReadNbytes(mmapBuf *perfEventMmapPage, buf unsafe.Pointer, n uint64) bool {
+	if mmapBuf == nil {
+		return false
+	}
+
+	// front of the circular data buffer	
+	data := unsafe.Pointer(uintptr(unsafe.Pointer(mmapBuf)) + uintptr(perfPageSize))
+
+	tail := mmapBuf.data_tail
+	head := mmapBuf.data_head
+
+	// compute bytes available in the circular buffer
+	byteAvailable := head - tail
+	if n > byteAvailable {
+		return false
+	}
+
+	// compute offset of tail in the circular buffer
+	tail &= perfPageMask
+
+	bytesAtRight := (perfPageMask + 1) - tail
+
+	// bytes to copy to the right of tail
+	var right uint64
+	if bytesAtRight < n {
+		right = bytesAtRight
+	} else {
+		right = n
+	}
+
+	// copy bytes from tail position 
+	memmove(buf, unsafe.Pointer(uintptr(data) + uintptr(tail)), uintptr(right))
+
+	// if necessary, wrap and continue copy from left edge of buf
+	if n > right {
+		left := n - right
+		memmove(unsafe.Pointer(uintptr(buf) + uintptr(right)) , data, uintptr(left))
+	}
+
+	// update tail after consuming n bytes
+	mmapBuf.data_tail += n
+
+	return true
+}
+
+func perfReadHeader(mmapBuf *perfEventMmapPage, hdr *perfEventHeader) bool {
+	return perfReadNbytes(mmapBuf, unsafe.Pointer(hdr), uint64(unsafe.Sizeof(hdr)))
+}
+
+func perfRecordSample(mmapBuf *perfEventMmapPage, eventAttr *PMUEventAttr, sampleData *perfSampleData) {
+	if eventAttr.IsSampleIPIncluded {
+		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.ip)), uint64(unsafe.Sizeof(sampleData.ip)))
+	}
+	if eventAttr.IsSampleAddrIncluded {
+		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.addr)), uint64(unsafe.Sizeof(sampleData.addr)))
+	}
+	if eventAttr.IsSampleThreadIDIncluded {
+		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.pid)), uint64(unsafe.Sizeof(sampleData.pid)))
+		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.tid)), uint64(unsafe.Sizeof(sampleData.tid)))
+	}
+}
+
+func perfStartCounter(fd int32) bool {
+	_, err := ioctl(fd, _PERF_EVENT_IOC_ENABLE, 0)
+	if err != 0 {
+		println("Failed to enable the event count")
+		return false
+	}
+	return true
+}
+
+func perfStopCounter(fd int32) bool {
+	_, err := ioctl(fd, _PERF_EVENT_IOC_DISABLE, 0)
+	if err != 0 {
+		println("Failed to disable the event count")
+		return false
+	}
+	return true
+}
+
+func perfResetCounter(fd int32) bool {
+	_, err := ioctl(fd, _PERF_EVENT_IOC_RESET, 0)
+	if err != 0 {
+		println("Failed to reset the event count")
+		return false
+	}
+	return true
+}
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index ae35a1eb29..2a05a7dfa3 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -807,13 +807,19 @@ func StartPMUProfile(opts ...ProfilingOption) error {
 }
 
 type PMUEventConfig struct {
-	Period           int64
-	RawEvent         int64
-	PreciseIP        int8
-	IsKernelIncluded bool
-	IsHvIncluded     bool
-	// TODO: IsMmapEnabled bool
-	// TODO: IsLBREnabled bool
+	Period                    int64
+	RawEvent                  int64
+	PreciseIP	          int8
+	IsSampleIPIncluded        bool
+	IsSampleAddrIncluded	  bool
+	IsSampleCallchainIncluded bool
+	IsSampleThreadIDIncluded  bool
+	IsKernelIncluded          bool
+	IsHvIncluded              bool
+	IsIdleIncluded            bool
+	IsCallchainKernelIncluded bool
+	IsCallchainUserIncluded   bool
+	// TODO: IsLBREnabled     bool
 }
 
 func getPreciseIP(preciseIP int8) uint8 {
@@ -828,11 +834,18 @@ func getPreciseIP(preciseIP int8) uint8 {
 func populatePMUProfiler(w io.Writer, eventConfig *PMUEventConfig, eventId int, eventName string) {
 	pmu.eventOn[eventId] = true
 	eventAttr := runtime.PMUEventAttr{
-		Period:           uint64(eventConfig.Period),
-		RawEvent:         uint64(eventConfig.RawEvent),
-		PreciseIP:        getPreciseIP(eventConfig.PreciseIP),
-		IsKernelIncluded: eventConfig.IsKernelIncluded,
-		IsHvIncluded:     eventConfig.IsHvIncluded,
+		Period:                    uint64(eventConfig.Period),
+		RawEvent:                  uint64(eventConfig.RawEvent),
+		PreciseIP:                 getPreciseIP(eventConfig.PreciseIP),
+		IsSampleIPIncluded:        eventConfig.IsSampleIPIncluded,
+		IsSampleAddrIncluded:      eventConfig.IsSampleAddrIncluded,
+		IsSampleCallchainIncluded: eventConfig.IsSampleCallchainIncluded,
+		IsSampleThreadIDIncluded:  eventConfig.IsSampleThreadIDIncluded,
+		IsKernelIncluded:          eventConfig.IsKernelIncluded,
+		IsHvIncluded:              eventConfig.IsHvIncluded,
+		IsIdleIncluded:            eventConfig.IsIdleIncluded,
+		IsCallchainKernelIncluded: eventConfig.IsCallchainKernelIncluded,
+		IsCallchainUserIncluded:   eventConfig.IsCallchainUserIncluded,
 	}
 	runtime.SetPMUProfile(eventId, &eventAttr)
 	go pmuProfileWriter(w, eventId, eventName)
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 50d081c85f..65afb6d5b0 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3820,7 +3820,7 @@ var lostPMUAtomic64Count [GO_COUNT_PMU_EVENTS_MAX]uint64
 // Called if we receive a SIGPROF signal and PMU is enabled.
 // Called by the signal handler, may run during STW.
 //go:nowritebarrierrec
-func sigprofPMU(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
+func sigprofPMU(pc, sp, lr uintptr, gp *g, mp *m, eventId int, sampleData *perfSampleData) {
 	if pmuEvent[eventId].eventAttr == nil {
 		return
 	}
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 7dd61dfd60..e5b5dc4932 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -475,6 +475,7 @@ type m struct {
 	profilehz     int32
 	eventFds      [GO_COUNT_PMU_EVENTS_MAX]int32
 	eventAttrs    [GO_COUNT_PMU_EVENTS_MAX]*PMUEventAttr
+	eventMmapBufs [GO_COUNT_PMU_EVENTS_MAX]*perfEventMmapPage
 	spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack

From 61f6d7aa1e02bc8948a0a7c6b6dec92c165f6161 Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Sun, 22 Sep 2019 19:43:29 -0400
Subject: [PATCH 107/126] Remove the extra blank line

---
 src/runtime/perf_linux.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/runtime/perf_linux.go b/src/runtime/perf_linux.go
index 6e7db7c9fb..d7e3c2f948 100644
--- a/src/runtime/perf_linux.go
+++ b/src/runtime/perf_linux.go
@@ -57,7 +57,6 @@ func perfAttrInit(eventId int32, eventAttr *PMUEventAttr, perfAttr *perfEventAtt
 	if !eventAttr.IsCallchainUserIncluded {
 		perfAttr.bits |= 1 << 22
 	}
-
 }
 
 func perfMmapInit() {

From 6950c9d2d2c821aaab9c82adb084da9567a2d437 Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Sun, 22 Sep 2019 21:30:38 -0400
Subject: [PATCH 108/126] Read PMU counters

---
 src/runtime/perf_linux.go | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/runtime/perf_linux.go b/src/runtime/perf_linux.go
index d7e3c2f948..dfe1bcaa56 100644
--- a/src/runtime/perf_linux.go
+++ b/src/runtime/perf_linux.go
@@ -109,7 +109,7 @@ func perfSkipRecord(mmapBuf *perfEventMmapPage, hdr *perfEventHeader) {
 	if mmapBuf == nil {
 		return
 	}
-	remains := uint64(hdr.size) - uint64(unsafe.Sizeof(hdr))
+	remains := uint64(hdr.size) - uint64(unsafe.Sizeof(*hdr))
 	if remains > 0 {
 		perfSkipNBytes(mmapBuf, remains)
 	}
@@ -171,7 +171,7 @@ func perfReadNbytes(mmapBuf *perfEventMmapPage, buf unsafe.Pointer, n uint64) bo
 }
 
 func perfReadHeader(mmapBuf *perfEventMmapPage, hdr *perfEventHeader) bool {
-	return perfReadNbytes(mmapBuf, unsafe.Pointer(hdr), uint64(unsafe.Sizeof(hdr)))
+	return perfReadNbytes(mmapBuf, unsafe.Pointer(hdr), uint64(unsafe.Sizeof(*hdr)))
 }
 
 func perfRecordSample(mmapBuf *perfEventMmapPage, eventAttr *PMUEventAttr, sampleData *perfSampleData) {
@@ -213,3 +213,7 @@ func perfResetCounter(fd int32) bool {
 	}
 	return true
 }
+
+func perfReadCounter(fd int32, val *uint64) bool {
+	return read(fd, unsafe.Pointer(val), int32(unsafe.Sizeof(*val))) != -1
+}

From 9b22f725ae0bca9c4e54841192c6df10c93d6ba3 Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Mon, 23 Sep 2019 13:35:57 -0400
Subject: [PATCH 109/126] change the order where values are accessed in the
 ring buffer

---
 src/runtime/defs_pmu.go    | 2 +-
 src/runtime/perf_linux.go  | 9 +++++----
 src/runtime/pprof/pprof.go | 4 ++--
 3 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index 38d663337e..9fbd12c72e 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -18,9 +18,9 @@ type PMUEventAttr struct {
 	RawEvent                  uint64
 	PreciseIP                 uint8
 	IsSampleIPIncluded        bool
+	IsSampleThreadIDIncluded  bool
 	IsSampleAddrIncluded	  bool
 	IsSampleCallchainIncluded bool
-	IsSampleThreadIDIncluded  bool
 	IsKernelIncluded          bool
 	IsHvIncluded              bool
 	IsIdleIncluded            bool
diff --git a/src/runtime/perf_linux.go b/src/runtime/perf_linux.go
index dfe1bcaa56..04f26613be 100644
--- a/src/runtime/perf_linux.go
+++ b/src/runtime/perf_linux.go
@@ -8,7 +8,7 @@ func ioctl(fd int32, req, arg int) (r, err int)
 //go:noescape
 func perfEventOpen(attr *perfEventAttr, pid, cpu, groupFd, flags, dummy int) (r int32, r2, err int)
 
-const perfDataPages = 2
+const perfDataPages = 2 // use 2^n data pages
 var perfPageSize uint64
 var perfPageMask uint64
 
@@ -174,17 +174,18 @@ func perfReadHeader(mmapBuf *perfEventMmapPage, hdr *perfEventHeader) bool {
 	return perfReadNbytes(mmapBuf, unsafe.Pointer(hdr), uint64(unsafe.Sizeof(*hdr)))
 }
 
+// The order where values are read has to match the ring-buffer mmap layout
 func perfRecordSample(mmapBuf *perfEventMmapPage, eventAttr *PMUEventAttr, sampleData *perfSampleData) {
 	if eventAttr.IsSampleIPIncluded {
 		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.ip)), uint64(unsafe.Sizeof(sampleData.ip)))
 	}
-	if eventAttr.IsSampleAddrIncluded {
-		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.addr)), uint64(unsafe.Sizeof(sampleData.addr)))
-	}
 	if eventAttr.IsSampleThreadIDIncluded {
 		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.pid)), uint64(unsafe.Sizeof(sampleData.pid)))
 		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.tid)), uint64(unsafe.Sizeof(sampleData.tid)))
 	}
+	if eventAttr.IsSampleAddrIncluded {
+		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.addr)), uint64(unsafe.Sizeof(sampleData.addr)))
+	}
 }
 
 func perfStartCounter(fd int32) bool {
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 2a05a7dfa3..650b3ef0ab 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -811,9 +811,9 @@ type PMUEventConfig struct {
 	RawEvent                  int64
 	PreciseIP	          int8
 	IsSampleIPIncluded        bool
+	IsSampleThreadIDIncluded  bool
 	IsSampleAddrIncluded	  bool
 	IsSampleCallchainIncluded bool
-	IsSampleThreadIDIncluded  bool
 	IsKernelIncluded          bool
 	IsHvIncluded              bool
 	IsIdleIncluded            bool
@@ -838,9 +838,9 @@ func populatePMUProfiler(w io.Writer, eventConfig *PMUEventConfig, eventId int,
 		RawEvent:                  uint64(eventConfig.RawEvent),
 		PreciseIP:                 getPreciseIP(eventConfig.PreciseIP),
 		IsSampleIPIncluded:        eventConfig.IsSampleIPIncluded,
+		IsSampleThreadIDIncluded:  eventConfig.IsSampleThreadIDIncluded,
 		IsSampleAddrIncluded:      eventConfig.IsSampleAddrIncluded,
 		IsSampleCallchainIncluded: eventConfig.IsSampleCallchainIncluded,
-		IsSampleThreadIDIncluded:  eventConfig.IsSampleThreadIDIncluded,
 		IsKernelIncluded:          eventConfig.IsKernelIncluded,
 		IsHvIncluded:              eventConfig.IsHvIncluded,
 		IsIdleIncluded:            eventConfig.IsIdleIncluded,

From 602c0e362af0a15a4b58b490959e4056dda23a18 Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Mon, 23 Sep 2019 13:42:34 -0400
Subject: [PATCH 110/126] fixed error about data type

---
 src/runtime/defs_perf_linux.go | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index f1c207c774..0a2b0c5d6a 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -72,10 +72,14 @@ type perfEventHeader struct {
 	size uint16
 }
 
+// The order where values are saved in a sample has to match the ring-buffer mmap layout
 type perfSampleData struct {
 	ip   uint64 // if _PERF_SAMPLE_IP
-	addr uint64 // if _PERF_SAMPLE_ADDR
 	pid  uint32 // if _PERF_SAMPLE_TID 
 	tid  uint32 // if _PERF_SAMPLE_TID
-	// TODO: More fields can be added if needed
+	addr uint64 // if _PERF_SAMPLE_ADDR
+	// TODO: More fields can be added in order if needed
+
+	/*********** auxiliary fields ***********/
+	isPrecise bool // whether the obtained ip is precise or not
 }

From a55e11de1e34f351cceaf2c8d5819dc5bc096fe1 Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Mon, 23 Sep 2019 16:27:32 -0400
Subject: [PATCH 111/126] Guarantee per-sample overflow notifications

---
 src/runtime/defs_linux_amd64.go | 1 +
 src/runtime/defs_perf_linux.go  | 2 +-
 src/runtime/perf_linux.go       | 4 +++-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 87b3711f05..336862a62e 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -155,6 +155,7 @@ const (
 	_PERF_SAMPLE_STREAM_ID    = 0x200
 	_PERF_SAMPLE_RAW          = 0x400
 	_PERF_SAMPLE_BRANCH_STACK = 0x800
+	_PERF_SAMPLE_IDENTIFIER   = 0x10000
 
 	_PERF_SAMPLE_BRANCH_USER       = 0x1
 	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index 0a2b0c5d6a..27ec826805 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -72,7 +72,7 @@ type perfEventHeader struct {
 	size uint16
 }
 
-// The order where values are saved in a sample has to match the ring-buffer mmap layout
+// The order where values are saved in a sample has to match the mmap ring buffer layout
 type perfSampleData struct {
 	ip   uint64 // if _PERF_SAMPLE_IP
 	pid  uint32 // if _PERF_SAMPLE_TID 
diff --git a/src/runtime/perf_linux.go b/src/runtime/perf_linux.go
index 04f26613be..17b2410e8c 100644
--- a/src/runtime/perf_linux.go
+++ b/src/runtime/perf_linux.go
@@ -57,6 +57,8 @@ func perfAttrInit(eventId int32, eventAttr *PMUEventAttr, perfAttr *perfEventAtt
 	if !eventAttr.IsCallchainUserIncluded {
 		perfAttr.bits |= 1 << 22
 	}
+
+	perfAttr.wakeup = 1 // counter overflow notifications happen after wakeup_events samples
 }
 
 func perfMmapInit() {
@@ -174,7 +176,7 @@ func perfReadHeader(mmapBuf *perfEventMmapPage, hdr *perfEventHeader) bool {
 	return perfReadNbytes(mmapBuf, unsafe.Pointer(hdr), uint64(unsafe.Sizeof(*hdr)))
 }
 
-// The order where values are read has to match the ring-buffer mmap layout
+// The order where values are read has to match the mmap ring buffer layout
 func perfRecordSample(mmapBuf *perfEventMmapPage, eventAttr *PMUEventAttr, sampleData *perfSampleData) {
 	if eventAttr.IsSampleIPIncluded {
 		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.ip)), uint64(unsafe.Sizeof(sampleData.ip)))

From 89fdba21ae53fa857ac43b270da39b7f515511f8 Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Mon, 23 Sep 2019 20:26:43 -0400
Subject: [PATCH 112/126] Check whether the obtained sample ip is precise

---
 src/runtime/defs_linux_386.go     |  2 ++
 src/runtime/defs_linux_amd64.go   |  3 ++-
 src/runtime/defs_linux_arm.go     |  2 ++
 src/runtime/defs_linux_arm64.go   |  2 ++
 src/runtime/defs_linux_mips64x.go |  2 ++
 src/runtime/defs_linux_mipsx.go   |  2 ++
 src/runtime/defs_linux_ppc64.go   |  2 ++
 src/runtime/defs_linux_ppc64le.go |  2 ++
 src/runtime/defs_linux_s390x.go   |  2 ++
 src/runtime/defs_perf_linux.go    |  2 +-
 src/runtime/os_linux.go           | 10 ++++++++--
 11 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/src/runtime/defs_linux_386.go b/src/runtime/defs_linux_386.go
index e2ec4ab39e..21758918fe 100644
--- a/src/runtime/defs_linux_386.go
+++ b/src/runtime/defs_linux_386.go
@@ -180,6 +180,8 @@ const (
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
 
+	_PERF_RECORD_MISC_EXACT_IP = 0x4000
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 336862a62e..1e9977a392 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -155,7 +155,6 @@ const (
 	_PERF_SAMPLE_STREAM_ID    = 0x200
 	_PERF_SAMPLE_RAW          = 0x400
 	_PERF_SAMPLE_BRANCH_STACK = 0x800
-	_PERF_SAMPLE_IDENTIFIER   = 0x10000
 
 	_PERF_SAMPLE_BRANCH_USER       = 0x1
 	_PERF_SAMPLE_BRANCH_KERNEL     = 0x2
@@ -180,6 +179,8 @@ const (
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
 
+	_PERF_RECORD_MISC_EXACT_IP = 0x4000
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
diff --git a/src/runtime/defs_linux_arm.go b/src/runtime/defs_linux_arm.go
index 0529299b96..944aeac4f4 100644
--- a/src/runtime/defs_linux_arm.go
+++ b/src/runtime/defs_linux_arm.go
@@ -173,6 +173,8 @@ const (
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
 
+	_PERF_RECORD_MISC_EXACT_IP = 0x4000
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
diff --git a/src/runtime/defs_linux_arm64.go b/src/runtime/defs_linux_arm64.go
index fd197db902..b1f788aa83 100644
--- a/src/runtime/defs_linux_arm64.go
+++ b/src/runtime/defs_linux_arm64.go
@@ -177,6 +177,8 @@ const (
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
 
+	_PERF_RECORD_MISC_EXACT_IP = 0x4000
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
diff --git a/src/runtime/defs_linux_mips64x.go b/src/runtime/defs_linux_mips64x.go
index 3456be278f..96499ad219 100644
--- a/src/runtime/defs_linux_mips64x.go
+++ b/src/runtime/defs_linux_mips64x.go
@@ -172,6 +172,8 @@ const (
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
 
+	_PERF_RECORD_MISC_EXACT_IP = 0x4000
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
diff --git a/src/runtime/defs_linux_mipsx.go b/src/runtime/defs_linux_mipsx.go
index e994b6aa5a..bb63a95ce8 100644
--- a/src/runtime/defs_linux_mipsx.go
+++ b/src/runtime/defs_linux_mipsx.go
@@ -176,6 +176,8 @@ const (
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
 
+	_PERF_RECORD_MISC_EXACT_IP = 0x4000
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
diff --git a/src/runtime/defs_linux_ppc64.go b/src/runtime/defs_linux_ppc64.go
index 27c7a97c89..4388b24f73 100644
--- a/src/runtime/defs_linux_ppc64.go
+++ b/src/runtime/defs_linux_ppc64.go
@@ -172,6 +172,8 @@ const (
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
 
+	_PERF_RECORD_MISC_EXACT_IP = 0x4000
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
diff --git a/src/runtime/defs_linux_ppc64le.go b/src/runtime/defs_linux_ppc64le.go
index 429c0a408e..90aaacecf2 100644
--- a/src/runtime/defs_linux_ppc64le.go
+++ b/src/runtime/defs_linux_ppc64le.go
@@ -172,6 +172,8 @@ const (
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
 
+	_PERF_RECORD_MISC_EXACT_IP = 0x4000
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
diff --git a/src/runtime/defs_linux_s390x.go b/src/runtime/defs_linux_s390x.go
index 783d01eb62..bd411f3726 100644
--- a/src/runtime/defs_linux_s390x.go
+++ b/src/runtime/defs_linux_s390x.go
@@ -173,6 +173,8 @@ const (
 	_PERF_FORMAT_ID                 = 0x4
 	_PERF_FORMAT_GROUP              = 0x8
 
+	_PERF_RECORD_MISC_EXACT_IP = 0x4000
+
 	_PERF_RECORD_MMAP            = 0x1
 	_PERF_RECORD_LOST            = 0x2
 	_PERF_RECORD_COMM            = 0x3
diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index 27ec826805..8b00ae845b 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -81,5 +81,5 @@ type perfSampleData struct {
 	// TODO: More fields can be added in order if needed
 
 	/*********** auxiliary fields ***********/
-	isPrecise bool // whether the obtained ip is precise or not
+	isPreciseIP bool // whether the obtained ip is precise or not
 }
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index fcab4db43e..0211b0d235 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -590,27 +590,33 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 		remains := mmapBuf.data_head - mmapBuf.data_tail
 		for remains > 0 {
 			var hdr perfEventHeader
+
 			if remains < uint64(unsafe.Sizeof(hdr)) {
 				perfSkipAll(mmapBuf)
 				break
 			}
+
 			if !perfReadHeader(mmapBuf, &hdr) {
 				println("Failed to read the mmap header")
 				break
 			}
+
 			if hdr.Type == _PERF_RECORD_SAMPLE {
 				var sampleData perfSampleData
-				// sampleData.isPrecise = (hdr.misc & _PERF_RECORD_MISC_EXACT_IP) ? true : false
+
+				sampleData.isPreciseIP = (hdr.misc & _PERF_RECORD_MISC_EXACT_IP) != 0
+
 				perfRecordSample(mmapBuf, _g_.m.eventAttrs[eventId], &sampleData)
+
 				sigprofPMU(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId, &sampleData)
 			} else if hdr.size == 0 {
 				perfSkipAll(mmapBuf)
 			} else {
 				perfSkipRecord(mmapBuf, &hdr)
 			}
+
 			remains = mmapBuf.data_head - mmapBuf.data_tail
 		}
-
 	} else { // should never be taken
 		println("File descriptor ", fd, " not found in _g_.m.eventFds")
 	}

From e7dde74bf86a33253332dc4576ddcb7ecf7f723f Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Mon, 23 Sep 2019 23:46:38 -0400
Subject: [PATCH 113/126] Update test cases

---
 test/pmu/test1.go | 2 --
 test/pmu/test2.go | 6 +-----
 test/pmu/test4.go | 2 --
 3 files changed, 1 insertion(+), 9 deletions(-)

diff --git a/test/pmu/test1.go b/test/pmu/test1.go
index 59654d6497..2cde966075 100644
--- a/test/pmu/test1.go
+++ b/test/pmu/test1.go
@@ -162,8 +162,6 @@ func run() error {
 
 	var cycle pprof.PMUEventConfig
 	cycle.Period = 10000000
-	cycle.IsKernelIncluded = false
-	cycle.IsHvIncluded = false
 
 	if err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle)); err != nil {
 		return err
diff --git a/test/pmu/test2.go b/test/pmu/test2.go
index ee7b281bde..660e16313e 100644
--- a/test/pmu/test2.go
+++ b/test/pmu/test2.go
@@ -177,7 +177,6 @@ func run() error {
 
 	var cycle pprof.PMUEventConfig
 	cycle.Period = 100000000
-	// cycle.PreciseIP = 2
 
 	instrFile, err := os.Create("instr_profile")
 	if err != nil {
@@ -187,7 +186,6 @@ func run() error {
 
 	var instr pprof.PMUEventConfig
 	instr.Period = 100000000
-	// instr.PreciseIP = 2
 
 	cacheMissFile, err := os.Create("cacheMiss_profile")
 	if err != nil {
@@ -197,7 +195,6 @@ func run() error {
 
 	var cacheMiss pprof.PMUEventConfig
 	cacheMiss.Period = 10
-	// cacheMiss.PreciseIP = 2
 
 	cacheRefFile, err := os.Create("cacheRef_profile")
 	if err != nil {
@@ -206,8 +203,7 @@ func run() error {
 	defer cacheRefFile.Close()
 
 	var cacheRef pprof.PMUEventConfig
-	cacheRef.Period = 10000
-	// cacheRef.PreciseIP = 2
+	cacheRef.Period = 1000
 
 	if err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle), pprof.WithProfilingPMUInstructions(instrFile, &instr), pprof.WithProfilingPMUCacheReferences(cacheRefFile, &cacheRef), pprof.WithProfilingPMUCacheMisses(cacheMissFile, &cacheMiss)); err != nil {
 		return err
diff --git a/test/pmu/test4.go b/test/pmu/test4.go
index ce9f0b80ee..21b72160bc 100644
--- a/test/pmu/test4.go
+++ b/test/pmu/test4.go
@@ -163,8 +163,6 @@ func run() error {
 	var raw pprof.PMUEventConfig
 	raw.RawEvent = /* UOPS_ISSUED */ 0x53010e
 	raw.Period = 1000000
-	raw.IsKernelIncluded = false
-	raw.IsHvIncluded = false
 
 	if err := pprof.StartPMUProfile(pprof.WithProfilingPMURaw(rawFile, &raw)); err != nil {
 		return err

From 42e020407c591c31368ecc33e51408c5b9fa5009 Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 24 Sep 2019 13:26:54 -0400
Subject: [PATCH 114/126] implement mb(), rmb() and wmb() in Go-style ASM

---
 src/runtime/asm_386.s      | 12 ++++++++++++
 src/runtime/asm_amd64.s    | 12 ++++++++++++
 src/runtime/mem_barrier.go | 13 +++++++++++++
 src/runtime/os_linux.go    | 28 ++++++++++++++++++---------
 src/runtime/perf_linux.go  | 39 ++++++++++++++++++++------------------
 5 files changed, 77 insertions(+), 27 deletions(-)
 create mode 100644 src/runtime/mem_barrier.go

diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index b98843e73e..d94cdf1fb4 100644
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -1566,6 +1566,18 @@ TEXT runtime·panicExtendSlice3CU(SB),NOSPLIT,$0-12
 	MOVL	CX, y+8(FP)
 	JMP	runtime·goPanicExtendSlice3CU(SB)
 
+TEXT runtime·mb(SB),NOSPLIT,$0-0
+	MFENCE
+	RET
+
+TEXT runtime·rmb(SB),NOSPLIT,$0-0
+	LFENCE
+	RET
+
+TEXT runtime·wmb(SB),NOSPLIT,$0-0
+	SFENCE
+	RET
+
 #ifdef GOOS_android
 // Use the free TLS_SLOT_APP slot #2 on Android Q.
 // Earlier androids are set up in gcc_android.c.
diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index fd3a9c3127..160223d6e2 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -1721,6 +1721,18 @@ TEXT runtime·panicSlice3CU(SB),NOSPLIT,$0-16
 	MOVQ	CX, y+8(FP)
 	JMP	runtime·goPanicSlice3CU(SB)
 
+TEXT runtime·mb(SB),NOSPLIT,$0-0
+	MFENCE
+	RET
+
+TEXT runtime·rmb(SB),NOSPLIT,$0-0
+	LFENCE
+	RET
+
+TEXT runtime·wmb(SB),NOSPLIT,$0-0
+	SFENCE
+	RET
+
 #ifdef GOOS_android
 // Use the free TLS_SLOT_APP slot #2 on Android Q.
 // Earlier androids are set up in gcc_android.c.
diff --git a/src/runtime/mem_barrier.go b/src/runtime/mem_barrier.go
new file mode 100644
index 0000000000..44f3bf3883
--- /dev/null
+++ b/src/runtime/mem_barrier.go
@@ -0,0 +1,13 @@
+package runtime
+
+// a hardware memory barrier that prevents any memory write access from 
+// being moved and executed on the other side of the barrier
+func mb()
+
+// a hardware memory barrier that prevents any memory read access from 
+// being moved and executed on the other side of the barrier
+func rmb()
+
+// A hardware memory barrier that prevents any memory write access from 
+// being moved and executed on the other side of the barrier
+func wmb()
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 0211b0d235..62933c3475 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -587,16 +587,28 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 	}
 	if eventId != -1 {
 		mmapBuf := _g_.m.eventMmapBufs[eventId]
-		remains := mmapBuf.data_head - mmapBuf.data_tail
-		for remains > 0 {
+		head := mmapBuf.data_head
+
+		rmb() // on SMP-capable platforms, after reading the data_head value, user space should issue a memory barrier
+
+		for {
+			tail := mmapBuf.data_tail
+			remains := head - tail
+			if remains <= 0 {
+				break;
+			}
+
 			var hdr perfEventHeader
 
+			// the causes of passing 'mmapBuf.data_head' by value to functions perfSkipAll, perfReadHeader, perfRecordSample, perfSkipAll and perfSkipRecord:
+			// 1. it remains unchanged across these function calls
+			// 2. more importantly, avoid frequenly reading it from the mmap ring buffer => avoid frequenly calling rmb()
 			if remains < uint64(unsafe.Sizeof(hdr)) {
-				perfSkipAll(mmapBuf)
+				perfSkipAll(head, mmapBuf)
 				break
 			}
 
-			if !perfReadHeader(mmapBuf, &hdr) {
+			if !perfReadHeader(head, mmapBuf, &hdr) {
 				println("Failed to read the mmap header")
 				break
 			}
@@ -606,16 +618,14 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 
 				sampleData.isPreciseIP = (hdr.misc & _PERF_RECORD_MISC_EXACT_IP) != 0
 
-				perfRecordSample(mmapBuf, _g_.m.eventAttrs[eventId], &sampleData)
+				perfRecordSample(head, mmapBuf, _g_.m.eventAttrs[eventId], &sampleData)
 
 				sigprofPMU(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId, &sampleData)
 			} else if hdr.size == 0 {
-				perfSkipAll(mmapBuf)
+				perfSkipAll(head, mmapBuf)
 			} else {
-				perfSkipRecord(mmapBuf, &hdr)
+				perfSkipRecord(head, mmapBuf, &hdr)
 			}
-
-			remains = mmapBuf.data_head - mmapBuf.data_tail
 		}
 	} else { // should never be taken
 		println("File descriptor ", fd, " not found in _g_.m.eventFds")
diff --git a/src/runtime/perf_linux.go b/src/runtime/perf_linux.go
index 17b2410e8c..1d9ce69caf 100644
--- a/src/runtime/perf_linux.go
+++ b/src/runtime/perf_linux.go
@@ -98,36 +98,40 @@ func perfUnsetMmap(mmapBuf *perfEventMmapPage) {
 	munmap(unsafe.Pointer(mmapBuf), size)
 }
 
-func perfSkipNBytes(mmapBuf *perfEventMmapPage, n uint64 ) {
-	head := mmapBuf.data_head
+func perfSkipNBytes(head uint64, mmapBuf *perfEventMmapPage, n uint64 ) {
 	tail := mmapBuf.data_tail
-	if tail + n > head {
-		n = head - tail
+
+	remains := head - tail
+	if n > remains {
+		n = remains
 	}
 	mmapBuf.data_tail += n
 }
 
-func perfSkipRecord(mmapBuf *perfEventMmapPage, hdr *perfEventHeader) {
+func perfSkipRecord(head uint64, mmapBuf *perfEventMmapPage, hdr *perfEventHeader) {
 	if mmapBuf == nil {
 		return
 	}
 	remains := uint64(hdr.size) - uint64(unsafe.Sizeof(*hdr))
 	if remains > 0 {
-		perfSkipNBytes(mmapBuf, remains)
+		perfSkipNBytes(head, mmapBuf, remains)
 	}
 }
 
-func perfSkipAll(mmapBuf *perfEventMmapPage) {
+func perfSkipAll(head uint64, mmapBuf *perfEventMmapPage) {
 	if mmapBuf == nil {
 		return
 	}
-	remains := mmapBuf.data_head - mmapBuf.data_tail
+
+	tail := mmapBuf.data_tail
+
+	remains := head - tail
 	if remains > 0 {
-		perfSkipNBytes(mmapBuf, remains)
+		perfSkipNBytes(head, mmapBuf, remains)
 	}
 }
 
-func perfReadNbytes(mmapBuf *perfEventMmapPage, buf unsafe.Pointer, n uint64) bool {
+func perfReadNbytes(head uint64, mmapBuf *perfEventMmapPage, buf unsafe.Pointer, n uint64) bool {
 	if mmapBuf == nil {
 		return false
 	}
@@ -136,7 +140,6 @@ func perfReadNbytes(mmapBuf *perfEventMmapPage, buf unsafe.Pointer, n uint64) bo
 	data := unsafe.Pointer(uintptr(unsafe.Pointer(mmapBuf)) + uintptr(perfPageSize))
 
 	tail := mmapBuf.data_tail
-	head := mmapBuf.data_head
 
 	// compute bytes available in the circular buffer
 	byteAvailable := head - tail
@@ -172,21 +175,21 @@ func perfReadNbytes(mmapBuf *perfEventMmapPage, buf unsafe.Pointer, n uint64) bo
 	return true
 }
 
-func perfReadHeader(mmapBuf *perfEventMmapPage, hdr *perfEventHeader) bool {
-	return perfReadNbytes(mmapBuf, unsafe.Pointer(hdr), uint64(unsafe.Sizeof(*hdr)))
+func perfReadHeader(head uint64, mmapBuf *perfEventMmapPage, hdr *perfEventHeader) bool {
+	return perfReadNbytes(head, mmapBuf, unsafe.Pointer(hdr), uint64(unsafe.Sizeof(*hdr)))
 }
 
 // The order where values are read has to match the mmap ring buffer layout
-func perfRecordSample(mmapBuf *perfEventMmapPage, eventAttr *PMUEventAttr, sampleData *perfSampleData) {
+func perfRecordSample(head uint64, mmapBuf *perfEventMmapPage, eventAttr *PMUEventAttr, sampleData *perfSampleData) {
 	if eventAttr.IsSampleIPIncluded {
-		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.ip)), uint64(unsafe.Sizeof(sampleData.ip)))
+		perfReadNbytes(head, mmapBuf, unsafe.Pointer(&(sampleData.ip)), uint64(unsafe.Sizeof(sampleData.ip)))
 	}
 	if eventAttr.IsSampleThreadIDIncluded {
-		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.pid)), uint64(unsafe.Sizeof(sampleData.pid)))
-		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.tid)), uint64(unsafe.Sizeof(sampleData.tid)))
+		perfReadNbytes(head, mmapBuf, unsafe.Pointer(&(sampleData.pid)), uint64(unsafe.Sizeof(sampleData.pid)))
+		perfReadNbytes(head, mmapBuf, unsafe.Pointer(&(sampleData.tid)), uint64(unsafe.Sizeof(sampleData.tid)))
 	}
 	if eventAttr.IsSampleAddrIncluded {
-		perfReadNbytes(mmapBuf, unsafe.Pointer(&(sampleData.addr)), uint64(unsafe.Sizeof(sampleData.addr)))
+		perfReadNbytes(head, mmapBuf, unsafe.Pointer(&(sampleData.addr)), uint64(unsafe.Sizeof(sampleData.addr)))
 	}
 }
 

From 2cce77b768abe2714ec14f6842e85541ff3df222 Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 24 Sep 2019 13:35:24 -0400
Subject: [PATCH 115/126] comments

---
 src/runtime/os_linux.go | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 62933c3475..b67f21c25c 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -587,12 +587,13 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 	}
 	if eventId != -1 {
 		mmapBuf := _g_.m.eventMmapBufs[eventId]
-		head := mmapBuf.data_head
 
+		head := mmapBuf.data_head
 		rmb() // on SMP-capable platforms, after reading the data_head value, user space should issue a memory barrier
 
 		for {
 			tail := mmapBuf.data_tail
+
 			remains := head - tail
 			if remains <= 0 {
 				break;
@@ -600,7 +601,8 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 
 			var hdr perfEventHeader
 
-			// the causes of passing 'mmapBuf.data_head' by value to functions perfSkipAll, perfReadHeader, perfRecordSample, perfSkipAll and perfSkipRecord:
+			// the causes of passing 'mmapBuf.data_head' by value to functions 
+			// perfSkipAll, perfReadHeader, perfRecordSample, perfSkipAll and perfSkipRecord:
 			// 1. it remains unchanged across these function calls
 			// 2. more importantly, avoid frequenly reading it from the mmap ring buffer => avoid frequenly calling rmb()
 			if remains < uint64(unsafe.Sizeof(hdr)) {

From 2a1b55884a3faf86b1e463dcfa6eb5f04695621e Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 24 Sep 2019 14:53:02 -0400
Subject: [PATCH 116/126] Format code using gofmt

---
 src/math/cmplx/cmath_test.go    |  2 +-
 src/runtime/defs_linux_amd64.go |  8 ++++----
 src/runtime/defs_perf_linux.go  |  2 +-
 src/runtime/defs_pmu.go         |  2 +-
 src/runtime/mem_barrier.go      |  6 +++---
 src/runtime/os_linux.go         | 23 ++++++++++++-----------
 src/runtime/perf_linux.go       | 21 +++++++++++----------
 src/runtime/pprof/pprof.go      |  4 ++--
 8 files changed, 35 insertions(+), 33 deletions(-)

diff --git a/src/math/cmplx/cmath_test.go b/src/math/cmplx/cmath_test.go
index fbb49fdd5b..57ba76a767 100644
--- a/src/math/cmplx/cmath_test.go
+++ b/src/math/cmplx/cmath_test.go
@@ -222,7 +222,7 @@ var pow = []complex128{
 	(-2.499956739197529585028819e+00 + 1.759751724335650228957144e+00i),
 	(7.357094338218116311191939e+04 - 5.089973412479151648145882e+04i),
 	(1.320777296067768517259592e+01 - 3.165621914333901498921986e+01i),
-	(-3.123287828297300934072149e-07 - 1.9849567521490553032502223E-7i),
+	(-3.123287828297300934072149e-07 - 1.9849567521490553032502223e-7i),
 	(8.0622651468477229614813e+04 - 7.80028727944573092944363e+04i),
 	(-1.0268824572103165858577141e+00 - 4.716844738244989776610672e-01i),
 	(-4.35953819012244175753187e+01 + 2.2036445974645306917648585e+02i),
diff --git a/src/runtime/defs_linux_amd64.go b/src/runtime/defs_linux_amd64.go
index 1e9977a392..d49d9c8bdf 100644
--- a/src/runtime/defs_linux_amd64.go
+++ b/src/runtime/defs_linux_amd64.go
@@ -13,11 +13,11 @@ const (
 	_PROT_WRITE = 0x2
 	_PROT_EXEC  = 0x4
 
-	_MAP_SHARED	     = 0x1
-	_MAP_PRIVATE	     = 0x2
+	_MAP_SHARED          = 0x1
+	_MAP_PRIVATE         = 0x2
 	_MAP_SHARED_VALIDATE = 0x3
-	_MAP_FIXED	     = 0x10
-	_MAP_ANON	     = 0x20
+	_MAP_FIXED           = 0x10
+	_MAP_ANON            = 0x20
 
 	_MADV_DONTNEED   = 0x4
 	_MADV_FREE       = 0x8
diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index 8b00ae845b..f4735d4fc4 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -75,7 +75,7 @@ type perfEventHeader struct {
 // The order where values are saved in a sample has to match the mmap ring buffer layout
 type perfSampleData struct {
 	ip   uint64 // if _PERF_SAMPLE_IP
-	pid  uint32 // if _PERF_SAMPLE_TID 
+	pid  uint32 // if _PERF_SAMPLE_TID
 	tid  uint32 // if _PERF_SAMPLE_TID
 	addr uint64 // if _PERF_SAMPLE_ADDR
 	// TODO: More fields can be added in order if needed
diff --git a/src/runtime/defs_pmu.go b/src/runtime/defs_pmu.go
index 9fbd12c72e..450852c250 100644
--- a/src/runtime/defs_pmu.go
+++ b/src/runtime/defs_pmu.go
@@ -19,7 +19,7 @@ type PMUEventAttr struct {
 	PreciseIP                 uint8
 	IsSampleIPIncluded        bool
 	IsSampleThreadIDIncluded  bool
-	IsSampleAddrIncluded	  bool
+	IsSampleAddrIncluded      bool
 	IsSampleCallchainIncluded bool
 	IsKernelIncluded          bool
 	IsHvIncluded              bool
diff --git a/src/runtime/mem_barrier.go b/src/runtime/mem_barrier.go
index 44f3bf3883..39035b3529 100644
--- a/src/runtime/mem_barrier.go
+++ b/src/runtime/mem_barrier.go
@@ -1,13 +1,13 @@
 package runtime
 
-// a hardware memory barrier that prevents any memory write access from 
+// a hardware memory barrier that prevents any memory write access from
 // being moved and executed on the other side of the barrier
 func mb()
 
-// a hardware memory barrier that prevents any memory read access from 
+// a hardware memory barrier that prevents any memory read access from
 // being moved and executed on the other side of the barrier
 func rmb()
 
-// A hardware memory barrier that prevents any memory write access from 
+// A hardware memory barrier that prevents any memory write access from
 // being moved and executed on the other side of the barrier
 func wmb()
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index b67f21c25c..83d3899b61 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -290,8 +290,8 @@ func getHugePageSize() uintptr {
 func osinit() {
 	ncpu = getproccount()
 	physHugePageSize = getHugePageSize()
-	
-	// following the same convention as other write once variables in this function and 
+
+	// following the same convention as other write once variables in this function and
 	// assuming that there exists a memory fence before anybody reads these values
 	setProcessPMUProfilerFptr = setProcessPMUProfiler
 	setThreadPMUProfilerFptr = setThreadPMUProfiler
@@ -481,6 +481,7 @@ func setProcessPMUProfiler(eventAttr *PMUEventAttr) {
 }
 
 func fcntl(fd int32, cmd, arg int) (r, err int)
+
 //go:noescape
 func fcntl2(fd int32, cmd int, arg *fOwnerEx) (r, err int)
 
@@ -509,13 +510,13 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		var perfAttr perfEventAttr
 		perfAttrInit(eventId, eventAttr, &perfAttr)
 
-		fd, _, err := perfEventOpen(&perfAttr, 0, -1, -1, 0, /* dummy */ 0)
+		fd, _, err := perfEventOpen(&perfAttr, 0, -1, -1, 0 /* dummy */, 0)
 		if err != 0 {
 			println("Linux perf event open failed")
 			return
 		}
 
-		// create mmap buffer for this file 
+		// create mmap buffer for this file
 		perfMmap := perfSetMmap(fd)
 		if perfMmap == nil {
 			println("Fail to set perf mmap")
@@ -523,8 +524,8 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			return
 		}
 
-		flag, _ := fcntl(fd, /* F_GETFL */ 0x3, 0)
-		_, err = fcntl(fd, /* F_SETFL */ 0x4, flag | /* O_ASYNC */ 0x2000)
+		flag, _ := fcntl(fd /* F_GETFL */, 0x3, 0)
+		_, err = fcntl(fd /* F_SETFL */, 0x4, flag| /* O_ASYNC */ 0x2000)
 		if err != 0 {
 			println("Failed to set notification for the PMU event")
 			perfUnsetMmap(perfMmap)
@@ -532,7 +533,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			return
 		}
 
-		_, err = fcntl(fd, /* F_SETSIG */ 0xa, _SIGPROF)
+		_, err = fcntl(fd /* F_SETSIG */, 0xa, _SIGPROF)
 		if err != 0 {
 			println("Failed to set signal for the PMU event")
 			perfUnsetMmap(perfMmap)
@@ -540,8 +541,8 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			return
 		}
 
-		fOwnEx := fOwnerEx{/* F_OWNER_TID */ 0, int32(gettid())}
-		_, err = fcntl2(fd, /* F_SETOWN_EX */ 0xf, &fOwnEx)
+		fOwnEx := fOwnerEx{ /* F_OWNER_TID */ 0, int32(gettid())}
+		_, err = fcntl2(fd /* F_SETOWN_EX */, 0xf, &fOwnEx)
 		if err != 0 {
 			println("Failed to set the owner of the perf event file")
 			perfUnsetMmap(perfMmap)
@@ -596,12 +597,12 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 
 			remains := head - tail
 			if remains <= 0 {
-				break;
+				break
 			}
 
 			var hdr perfEventHeader
 
-			// the causes of passing 'mmapBuf.data_head' by value to functions 
+			// the causes of passing 'mmapBuf.data_head' by value to functions
 			// perfSkipAll, perfReadHeader, perfRecordSample, perfSkipAll and perfSkipRecord:
 			// 1. it remains unchanged across these function calls
 			// 2. more importantly, avoid frequenly reading it from the mmap ring buffer => avoid frequenly calling rmb()
diff --git a/src/runtime/perf_linux.go b/src/runtime/perf_linux.go
index 1d9ce69caf..68136ae55e 100644
--- a/src/runtime/perf_linux.go
+++ b/src/runtime/perf_linux.go
@@ -5,6 +5,7 @@ import (
 )
 
 func ioctl(fd int32, req, arg int) (r, err int)
+
 //go:noescape
 func perfEventOpen(attr *perfEventAttr, pid, cpu, groupFd, flags, dummy int) (r int32, r2, err int)
 
@@ -40,9 +41,9 @@ func perfAttrInit(eventId int32, eventAttr *PMUEventAttr, perfAttr *perfEventAtt
 		perfAttr.sample_type |= _PERF_SAMPLE_TID
 	}
 
-	perfAttr.bits = 1 // the counter is disabled and will be enabled later
+	perfAttr.bits = 1                                  // the counter is disabled and will be enabled later
 	perfAttr.bits |= uint64(eventAttr.PreciseIP) << 15 // precise ip
-	if !eventAttr.IsKernelIncluded { // don't count kernel
+	if !eventAttr.IsKernelIncluded {                   // don't count kernel
 		perfAttr.bits |= 1 << 5
 	}
 	if !eventAttr.IsHvIncluded { // don't count hypervisor
@@ -63,7 +64,7 @@ func perfAttrInit(eventId int32, eventAttr *PMUEventAttr, perfAttr *perfEventAtt
 
 func perfMmapInit() {
 	perfPageSize = uint64(physPageSize)
-	perfPageMask = perfPageSize * perfDataPages - 1
+	perfPageMask = perfPageSize*perfDataPages - 1
 }
 
 func perfMmapSize() uintptr {
@@ -79,10 +80,10 @@ func perfSetMmap(fd int32) *perfEventMmapPage {
 	}
 
 	size := perfMmapSize()
-	r, err := mmap(nil, size, _PROT_WRITE | _PROT_READ, _MAP_SHARED, fd, /* page offset */ 0)
+	r, err := mmap(nil, size, _PROT_WRITE|_PROT_READ, _MAP_SHARED, fd /* page offset */, 0)
 	if err != 0 {
 		return nil
-        }
+	}
 
 	perfMmap := (*perfEventMmapPage)(r)
 	// There is no memset available in Go runime
@@ -98,7 +99,7 @@ func perfUnsetMmap(mmapBuf *perfEventMmapPage) {
 	munmap(unsafe.Pointer(mmapBuf), size)
 }
 
-func perfSkipNBytes(head uint64, mmapBuf *perfEventMmapPage, n uint64 ) {
+func perfSkipNBytes(head uint64, mmapBuf *perfEventMmapPage, n uint64) {
 	tail := mmapBuf.data_tail
 
 	remains := head - tail
@@ -136,7 +137,7 @@ func perfReadNbytes(head uint64, mmapBuf *perfEventMmapPage, buf unsafe.Pointer,
 		return false
 	}
 
-	// front of the circular data buffer	
+	// front of the circular data buffer
 	data := unsafe.Pointer(uintptr(unsafe.Pointer(mmapBuf)) + uintptr(perfPageSize))
 
 	tail := mmapBuf.data_tail
@@ -160,13 +161,13 @@ func perfReadNbytes(head uint64, mmapBuf *perfEventMmapPage, buf unsafe.Pointer,
 		right = n
 	}
 
-	// copy bytes from tail position 
-	memmove(buf, unsafe.Pointer(uintptr(data) + uintptr(tail)), uintptr(right))
+	// copy bytes from tail position
+	memmove(buf, unsafe.Pointer(uintptr(data)+uintptr(tail)), uintptr(right))
 
 	// if necessary, wrap and continue copy from left edge of buf
 	if n > right {
 		left := n - right
-		memmove(unsafe.Pointer(uintptr(buf) + uintptr(right)) , data, uintptr(left))
+		memmove(unsafe.Pointer(uintptr(buf)+uintptr(right)), data, uintptr(left))
 	}
 
 	// update tail after consuming n bytes
diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index 650b3ef0ab..2a78ca525e 100644
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -809,10 +809,10 @@ func StartPMUProfile(opts ...ProfilingOption) error {
 type PMUEventConfig struct {
 	Period                    int64
 	RawEvent                  int64
-	PreciseIP	          int8
+	PreciseIP                 int8
 	IsSampleIPIncluded        bool
 	IsSampleThreadIDIncluded  bool
-	IsSampleAddrIncluded	  bool
+	IsSampleAddrIncluded      bool
 	IsSampleCallchainIncluded bool
 	IsKernelIncluded          bool
 	IsHvIncluded              bool

From 98957d8623c8f447feb670a1d25744702c662c0c Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 24 Sep 2019 15:07:21 -0400
Subject: [PATCH 117/126] Format code using gofmt

---
 src/runtime/os_linux.go   | 12 ++++++------
 src/runtime/perf_linux.go |  4 ++--
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 83d3899b61..e9a00bdfbb 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -510,7 +510,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		var perfAttr perfEventAttr
 		perfAttrInit(eventId, eventAttr, &perfAttr)
 
-		fd, _, err := perfEventOpen(&perfAttr, 0, -1, -1, 0 /* dummy */, 0)
+		fd, _, err := perfEventOpen(&perfAttr, 0, -1, -1, 0, 0 /* dummy */)
 		if err != 0 {
 			println("Linux perf event open failed")
 			return
@@ -524,8 +524,8 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			return
 		}
 
-		flag, _ := fcntl(fd /* F_GETFL */, 0x3, 0)
-		_, err = fcntl(fd /* F_SETFL */, 0x4, flag| /* O_ASYNC */ 0x2000)
+		flag, _ := fcntl(fd, 0x3 /* F_GETFL */, 0)
+		_, err = fcntl(fd, 0x4 /* F_SETFL */, flag|0x2000 /* O_ASYNC */)
 		if err != 0 {
 			println("Failed to set notification for the PMU event")
 			perfUnsetMmap(perfMmap)
@@ -533,7 +533,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			return
 		}
 
-		_, err = fcntl(fd /* F_SETSIG */, 0xa, _SIGPROF)
+		_, err = fcntl(fd, 0xa /* F_SETSIG */, _SIGPROF)
 		if err != 0 {
 			println("Failed to set signal for the PMU event")
 			perfUnsetMmap(perfMmap)
@@ -541,8 +541,8 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 			return
 		}
 
-		fOwnEx := fOwnerEx{ /* F_OWNER_TID */ 0, int32(gettid())}
-		_, err = fcntl2(fd /* F_SETOWN_EX */, 0xf, &fOwnEx)
+		fOwnEx := fOwnerEx{0 /* F_OWNER_TID */, int32(gettid())}
+		_, err = fcntl2(fd, 0xf /* F_SETOWN_EX */, &fOwnEx)
 		if err != 0 {
 			println("Failed to set the owner of the perf event file")
 			perfUnsetMmap(perfMmap)
diff --git a/src/runtime/perf_linux.go b/src/runtime/perf_linux.go
index 68136ae55e..3b3a9293ee 100644
--- a/src/runtime/perf_linux.go
+++ b/src/runtime/perf_linux.go
@@ -71,7 +71,7 @@ func perfMmapSize() uintptr {
 	if perfPageSize == 0 {
 		println("The perf page size has been unknown!")
 	}
-	return uintptr(perfPageSize * (perfDataPages + /* metadata page */ 1))
+	return uintptr(perfPageSize * (perfDataPages + 1 /* metadata page */))
 }
 
 func perfSetMmap(fd int32) *perfEventMmapPage {
@@ -80,7 +80,7 @@ func perfSetMmap(fd int32) *perfEventMmapPage {
 	}
 
 	size := perfMmapSize()
-	r, err := mmap(nil, size, _PROT_WRITE|_PROT_READ, _MAP_SHARED, fd /* page offset */, 0)
+	r, err := mmap(nil, size, _PROT_WRITE|_PROT_READ, _MAP_SHARED, fd, 0 /* page offset */)
 	if err != 0 {
 		return nil
 	}

From 30d740e953417faa94cf8bacf0f96d2a8fb05c09 Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 24 Sep 2019 15:16:21 -0400
Subject: [PATCH 118/126] Format test cases using gofmt

---
 test/235.go                            |    4 +-
 test/64bit.go                          |   48 +-
 test/align.go                          |    2 +-
 test/assign1.go                        |    5 +-
 test/bigmap.go                         |    7 +-
 test/blank1.go                         |   12 +-
 test/char_lit.go                       |    3 +-
 test/closedchan.go                     |   15 +-
 test/closure1.go                       |    2 +-
 test/closure2.go                       |    4 +-
 test/cmplxdivide1.go                   |    6 +-
 test/complit1.go                       |   12 +-
 test/const1.go                         |    8 +-
 test/const3.go                         |    2 +-
 test/const5.go                         |   12 +-
 test/const6.go                         |   30 +-
 test/convT2X.go                        |    4 +-
 test/convlit1.go                       |    8 +-
 test/ddd2.dir/ddd2.go                  |    1 -
 test/deferfin.go                       |    1 -
 test/deferprint.go                     |    2 +-
 test/divmod.go                         |   45 +-
 test/dwarf/dwarf.dir/main.go           |   41 +-
 test/dwarf/dwarf.dir/z1.go             |    3 +-
 test/dwarf/dwarf.dir/z10.go            |    4 +-
 test/dwarf/dwarf.dir/z11.go            |    2 +-
 test/dwarf/dwarf.dir/z12.go            |    2 +-
 test/dwarf/dwarf.dir/z13.go            |    2 +-
 test/dwarf/dwarf.dir/z14.go            |    2 +-
 test/dwarf/dwarf.dir/z15.go            |    2 +-
 test/dwarf/dwarf.dir/z16.go            |    2 +-
 test/dwarf/dwarf.dir/z17.go            |    2 +-
 test/dwarf/dwarf.dir/z18.go            |    3 +-
 test/dwarf/dwarf.dir/z19.go            |    2 +-
 test/dwarf/dwarf.dir/z2.go             |    2 +-
 test/dwarf/dwarf.dir/z20.go            |    2 +-
 test/dwarf/dwarf.dir/z3.go             |    2 +-
 test/dwarf/dwarf.dir/z4.go             |    2 +-
 test/dwarf/dwarf.dir/z5.go             |    2 +-
 test/dwarf/dwarf.dir/z6.go             |    2 +-
 test/dwarf/dwarf.dir/z7.go             |    2 +-
 test/dwarf/dwarf.dir/z8.go             |    2 +-
 test/dwarf/dwarf.dir/z9.go             |    2 +-
 test/dwarf/linedirectives.go           |    6 +-
 test/empty.go                          |   11 +-
 test/eof.go                            |    2 +-
 test/eof1.go                           |    2 +-
 test/escape2.go                        |   42 +-
 test/escape2n.go                       |   42 +-
 test/escape4.go                        |    4 +-
 test/escape_closure.go                 |    4 +-
 test/escape_field.go                   |    8 +-
 test/escape_iface.go                   |   32 +-
 test/escape_indir.go                   |   12 +-
 test/escape_level.go                   |   20 +-
 test/escape_map.go                     |   22 +-
 test/escape_param.go                   |   52 +-
 test/escape_slice.go                   |   14 +-
 test/escape_struct_param1.go           |   98 +-
 test/escape_struct_param2.go           |   98 +-
 test/finprofiled.go                    |    2 +-
 test/fixedbugs/bug000.go               |    8 +-
 test/fixedbugs/bug002.go               |    3 +-
 test/fixedbugs/bug003.go               |    8 +-
 test/fixedbugs/bug004.go               |    5 +-
 test/fixedbugs/bug005.go               |    8 +-
 test/fixedbugs/bug008.go               |   17 +-
 test/fixedbugs/bug009.go               |    5 +-
 test/fixedbugs/bug010.go               |    1 -
 test/fixedbugs/bug011.go               |    2 +-
 test/fixedbugs/bug012.go               |   26 +-
 test/fixedbugs/bug013.go               |    7 +-
 test/fixedbugs/bug015.go               |    4 +-
 test/fixedbugs/bug017.go               |    5 +-
 test/fixedbugs/bug020.go               |    4 +-
 test/fixedbugs/bug021.go               |    6 +-
 test/fixedbugs/bug022.go               |   12 +-
 test/fixedbugs/bug023.go               |   11 +-
 test/fixedbugs/bug024.go               |   13 +-
 test/fixedbugs/bug026.go               |    8 +-
 test/fixedbugs/bug028.go               |   13 +-
 test/fixedbugs/bug030.go               |    6 +-
 test/fixedbugs/bug031.go               |   34 +-
 test/fixedbugs/bug037.go               |    2 +-
 test/fixedbugs/bug039.go               |    4 +-
 test/fixedbugs/bug040.go               |    4 +-
 test/fixedbugs/bug045.go               |    7 +-
 test/fixedbugs/bug046.go               |    4 +-
 test/fixedbugs/bug048.go               |    6 +-
 test/fixedbugs/bug049.go               |    4 +-
 test/fixedbugs/bug051.go               |    4 +-
 test/fixedbugs/bug052.go               |   10 +-
 test/fixedbugs/bug053.go               |    4 +-
 test/fixedbugs/bug054.go               |   26 +-
 test/fixedbugs/bug056.go               |    4 +-
 test/fixedbugs/bug057.go               |   13 +-
 test/fixedbugs/bug058.go               |   13 +-
 test/fixedbugs/bug059.go               |   26 +-
 test/fixedbugs/bug060.go               |    8 +-
 test/fixedbugs/bug061.go               |    6 +-
 test/fixedbugs/bug062.go               |    2 +-
 test/fixedbugs/bug063.go               |    1 +
 test/fixedbugs/bug064.go               |   14 +-
 test/fixedbugs/bug065.go               |    4 +-
 test/fixedbugs/bug066.go               |   11 +-
 test/fixedbugs/bug067.go               |    4 +-
 test/fixedbugs/bug069.go               |   20 +-
 test/fixedbugs/bug071.go               |   12 +-
 test/fixedbugs/bug072.go               |    2 +-
 test/fixedbugs/bug074.go               |    4 +-
 test/fixedbugs/bug075.go               |   15 +-
 test/fixedbugs/bug076.go               |    3 +-
 test/fixedbugs/bug078.go               |    2 +-
 test/fixedbugs/bug083.dir/bug1.go      |    3 +-
 test/fixedbugs/bug085.go               |    2 +-
 test/fixedbugs/bug086.go               |    4 +-
 test/fixedbugs/bug087.go               |    6 +-
 test/fixedbugs/bug088.dir/bug0.go      |    6 +-
 test/fixedbugs/bug088.dir/bug1.go      |    8 +-
 test/fixedbugs/bug089.go               |   15 +-
 test/fixedbugs/bug090.go               |   40 +-
 test/fixedbugs/bug092.go               |    6 +-
 test/fixedbugs/bug093.go               |    9 +-
 test/fixedbugs/bug094.go               |   12 +-
 test/fixedbugs/bug096.go               |    8 +-
 test/fixedbugs/bug098.go               |   10 +-
 test/fixedbugs/bug099.go               |   12 +-
 test/fixedbugs/bug101.go               |   10 +-
 test/fixedbugs/bug103.go               |    5 +-
 test/fixedbugs/bug104.go               |    3 +-
 test/fixedbugs/bug106.dir/bug1.go      |    1 -
 test/fixedbugs/bug107.go               |   11 +-
 test/fixedbugs/bug108.go               |    3 +-
 test/fixedbugs/bug111.go               |   12 +-
 test/fixedbugs/bug112.go               |    3 +-
 test/fixedbugs/bug113.go               |    2 +-
 test/fixedbugs/bug115.go               |    6 +-
 test/fixedbugs/bug118.go               |    4 +-
 test/fixedbugs/bug122.go               |    2 +-
 test/fixedbugs/bug123.go               |    8 +-
 test/fixedbugs/bug126.go               |    4 +-
 test/fixedbugs/bug127.go               |    7 +-
 test/fixedbugs/bug128.go               |   11 +-
 test/fixedbugs/bug129.go               |    7 +-
 test/fixedbugs/bug130.go               |   17 +-
 test/fixedbugs/bug131.go               |    4 +-
 test/fixedbugs/bug132.go               |    2 +-
 test/fixedbugs/bug133.dir/bug0.go      |    2 +-
 test/fixedbugs/bug133.dir/bug1.go      |    2 +-
 test/fixedbugs/bug133.dir/bug2.go      |    4 +-
 test/fixedbugs/bug135.go               |   13 +-
 test/fixedbugs/bug136.go               |   14 +-
 test/fixedbugs/bug139.go               |   14 +-
 test/fixedbugs/bug141.go               |   16 +-
 test/fixedbugs/bug142.go               |    8 +-
 test/fixedbugs/bug143.go               |   28 +-
 test/fixedbugs/bug144.go               |    6 +-
 test/fixedbugs/bug145.go               |    4 +-
 test/fixedbugs/bug146.go               |   10 +-
 test/fixedbugs/bug148.go               |   22 +-
 test/fixedbugs/bug149.go               |   16 +-
 test/fixedbugs/bug150.go               |    7 +-
 test/fixedbugs/bug151.go               |    4 +-
 test/fixedbugs/bug152.go               |    6 +-
 test/fixedbugs/bug154.go               |   24 +-
 test/fixedbugs/bug155.go               |    2 +-
 test/fixedbugs/bug156.go               |    6 +-
 test/fixedbugs/bug157.go               |   15 +-
 test/fixedbugs/bug158.go               |    3 +-
 test/fixedbugs/bug159.go               |   20 +-
 test/fixedbugs/bug160.dir/y.go         |    8 +-
 test/fixedbugs/bug161.go               |    4 +-
 test/fixedbugs/bug165.go               |    4 +-
 test/fixedbugs/bug170.go               |   11 +-
 test/fixedbugs/bug171.go               |    4 +-
 test/fixedbugs/bug172.go               |    4 +-
 test/fixedbugs/bug173.go               |    5 +-
 test/fixedbugs/bug174.go               |    4 +-
 test/fixedbugs/bug175.go               |    2 +-
 test/fixedbugs/bug176.go               |    5 +-
 test/fixedbugs/bug181.go               |    2 +-
 test/fixedbugs/bug182.go               |    4 +-
 test/fixedbugs/bug183.go               |   21 +-
 test/fixedbugs/bug186.go               |    8 +-
 test/fixedbugs/bug187.go               |   10 +-
 test/fixedbugs/bug188.go               |    6 +-
 test/fixedbugs/bug189.go               |    8 +-
 test/fixedbugs/bug190.go               |   26 +-
 test/fixedbugs/bug191.dir/a.go         |    3 +-
 test/fixedbugs/bug191.dir/b.go         |    2 +-
 test/fixedbugs/bug192.go               |    4 +-
 test/fixedbugs/bug195.go               |   12 +-
 test/fixedbugs/bug197.go               |   14 +-
 test/fixedbugs/bug198.go               |    7 +-
 test/fixedbugs/bug200.go               |    4 +-
 test/fixedbugs/bug202.go               |    9 +-
 test/fixedbugs/bug203.go               |    8 +-
 test/fixedbugs/bug205.go               |   11 +-
 test/fixedbugs/bug206.go               |   17 +-
 test/fixedbugs/bug207.go               |    4 +-
 test/fixedbugs/bug208.go               |    8 +-
 test/fixedbugs/bug209.go               |    4 +-
 test/fixedbugs/bug211.go               |    9 +-
 test/fixedbugs/bug212.go               |   10 +-
 test/fixedbugs/bug213.go               |    7 +-
 test/fixedbugs/bug214.go               |    4 +-
 test/fixedbugs/bug215.go               |    6 +-
 test/fixedbugs/bug216.go               |    2 +-
 test/fixedbugs/bug217.go               |    5 +-
 test/fixedbugs/bug218.go               |    4 +-
 test/fixedbugs/bug219.go               |   14 +-
 test/fixedbugs/bug222.dir/chanbug.go   |    3 +-
 test/fixedbugs/bug222.dir/chanbug2.go  |    1 +
 test/fixedbugs/bug224.go               |    3 +-
 test/fixedbugs/bug225.go               |   10 +-
 test/fixedbugs/bug229.go               |    8 +-
 test/fixedbugs/bug231.go               |   11 +-
 test/fixedbugs/bug232.go               |    3 +-
 test/fixedbugs/bug233.go               |    2 +
 test/fixedbugs/bug235.go               |    1 -
 test/fixedbugs/bug237.go               |    1 +
 test/fixedbugs/bug238.go               |    1 -
 test/fixedbugs/bug240.go               |    2 +-
 test/fixedbugs/bug241.go               |    2 +-
 test/fixedbugs/bug245.go               |    1 +
 test/fixedbugs/bug249.go               |   62 +-
 test/fixedbugs/bug251.go               |    1 -
 test/fixedbugs/bug252.go               |    2 +-
 test/fixedbugs/bug256.go               |    6 +-
 test/fixedbugs/bug258.go               |    2 +-
 test/fixedbugs/bug259.go               |    2 +-
 test/fixedbugs/bug261.go               |    2 +-
 test/fixedbugs/bug266.go               |    4 +-
 test/fixedbugs/bug269.go               |    4 +-
 test/fixedbugs/bug271.go               |    2 +-
 test/fixedbugs/bug272.go               |    6 +-
 test/fixedbugs/bug276.go               |    6 +-
 test/fixedbugs/bug277.go               |    2 +-
 test/fixedbugs/bug278.go               |    8 +-
 test/fixedbugs/bug279.go               |    3 +-
 test/fixedbugs/bug280.go               |    4 +-
 test/fixedbugs/bug281.go               |    8 +-
 test/fixedbugs/bug282.dir/p1.go        |    1 -
 test/fixedbugs/bug282.dir/p2.go        |    1 -
 test/fixedbugs/bug284.go               |    2 +-
 test/fixedbugs/bug285.go               |    4 +-
 test/fixedbugs/bug287.go               |    2 +-
 test/fixedbugs/bug289.go               |    6 +-
 test/fixedbugs/bug290.go               |    4 +-
 test/fixedbugs/bug293.go               |    4 +-
 test/fixedbugs/bug294.go               |    1 -
 test/fixedbugs/bug295.go               |    4 +-
 test/fixedbugs/bug297.go               |    5 +-
 test/fixedbugs/bug302.dir/main.go      |    1 -
 test/fixedbugs/bug302.dir/p.go         | 1998 ++++++++++++------------
 test/fixedbugs/bug304.go               |    4 +-
 test/fixedbugs/bug306.dir/p1.go        |    2 +-
 test/fixedbugs/bug306.dir/p2.go        |    1 -
 test/fixedbugs/bug311.go               |    4 +-
 test/fixedbugs/bug314.go               |    5 +-
 test/fixedbugs/bug317.go               |    2 +-
 test/fixedbugs/bug319.go               |    2 +-
 test/fixedbugs/bug320.go               |    1 -
 test/fixedbugs/bug322.dir/lib.go       |    2 +-
 test/fixedbugs/bug322.dir/main.go      |    2 +-
 test/fixedbugs/bug324.dir/prog.go      |    9 +-
 test/fixedbugs/bug325.go               |    4 +-
 test/fixedbugs/bug330.go               |    4 +-
 test/fixedbugs/bug332.go               |    2 +-
 test/fixedbugs/bug333.go               |    6 +-
 test/fixedbugs/bug337.go               |    5 +-
 test/fixedbugs/bug341.go               |    1 +
 test/fixedbugs/bug343.go               |   18 +-
 test/fixedbugs/bug344.go               |    4 +-
 test/fixedbugs/bug347.go               |    4 +-
 test/fixedbugs/bug348.go               |    6 +-
 test/fixedbugs/bug356.go               |   13 +-
 test/fixedbugs/bug357.go               |    2 +-
 test/fixedbugs/bug361.go               |    2 +-
 test/fixedbugs/bug362.go               |    6 +-
 test/fixedbugs/bug363.go               |    8 +-
 test/fixedbugs/bug364.go               |    2 +-
 test/fixedbugs/bug366.go               |   40 +-
 test/fixedbugs/bug368.go               |    2 +-
 test/fixedbugs/bug369.dir/pkg.go       |    1 -
 test/fixedbugs/bug372.go               |    4 +-
 test/fixedbugs/bug373.go               |    2 +-
 test/fixedbugs/bug374.go               |    4 +-
 test/fixedbugs/bug376.go               |    4 +-
 test/fixedbugs/bug377.dir/one.go       |    1 -
 test/fixedbugs/bug377.dir/two.go       |    1 -
 test/fixedbugs/bug378.go               |    5 +-
 test/fixedbugs/bug379.go               |    2 +-
 test/fixedbugs/bug380.go               |    2 +
 test/fixedbugs/bug381.go               |    2 +-
 test/fixedbugs/bug382.dir/pkg.go       |    4 +-
 test/fixedbugs/bug383.go               |    7 +-
 test/fixedbugs/bug384.go               |    2 +-
 test/fixedbugs/bug385_32.go            |    3 +-
 test/fixedbugs/bug385_64.go            |  620 +++++---
 test/fixedbugs/bug386.go               |    4 +-
 test/fixedbugs/bug387.go               |   15 +-
 test/fixedbugs/bug389.go               |    2 +-
 test/fixedbugs/bug391.go               |    7 +-
 test/fixedbugs/bug392.dir/one.go       |   13 +-
 test/fixedbugs/bug396.dir/one.go       |    2 +-
 test/fixedbugs/bug396.dir/two.go       |    2 +-
 test/fixedbugs/bug397.go               |    6 +-
 test/fixedbugs/bug398.go               |   12 +-
 test/fixedbugs/bug399.go               |    2 +-
 test/fixedbugs/bug405.go               |    2 +-
 test/fixedbugs/bug407.dir/one.go       |    5 +-
 test/fixedbugs/bug410.go               |   18 +-
 test/fixedbugs/bug411.go               |    3 +-
 test/fixedbugs/bug412.go               |    6 +-
 test/fixedbugs/bug413.go               |    2 +-
 test/fixedbugs/bug415.dir/p.go         |    5 +-
 test/fixedbugs/bug415.dir/prog.go      |    4 +-
 test/fixedbugs/bug417.go               |   16 +-
 test/fixedbugs/bug420.go               |    2 +-
 test/fixedbugs/bug421.go               |    4 +-
 test/fixedbugs/bug424.dir/main.go      |    6 +-
 test/fixedbugs/bug424.go               |    1 -
 test/fixedbugs/bug425.go               |    2 +-
 test/fixedbugs/bug427.go               |    4 +-
 test/fixedbugs/bug439.go               |    2 +-
 test/fixedbugs/bug441.go               |    6 +-
 test/fixedbugs/bug442.go               |    2 +-
 test/fixedbugs/bug443.go               |    4 +-
 test/fixedbugs/bug444.go               |    8 +-
 test/fixedbugs/bug446.go               |    1 -
 test/fixedbugs/bug447.go               |   10 +-
 test/fixedbugs/bug448.dir/pkg2.go      |    1 -
 test/fixedbugs/bug460.go               |    1 -
 test/fixedbugs/bug462.go               |    2 +-
 test/fixedbugs/bug466.dir/a.go         |    2 +-
 test/fixedbugs/bug466.go               |    1 -
 test/fixedbugs/bug468.dir/p1.go        |    2 +-
 test/fixedbugs/bug468.dir/p2.go        |    2 +-
 test/fixedbugs/bug470.go               |    4 +-
 test/fixedbugs/bug479.dir/a.go         |    2 +-
 test/fixedbugs/bug480.dir/a.go         |    2 +-
 test/fixedbugs/bug486.go               |    2 +-
 test/fixedbugs/bug487.go               |    6 +-
 test/fixedbugs/bug488.dir/a.go         |    2 +-
 test/fixedbugs/bug490.go               |    2 +-
 test/fixedbugs/bug491.go               |    2 +-
 test/fixedbugs/bug500.go               |    2 +-
 test/fixedbugs/gcc61264.go             |    2 +-
 test/fixedbugs/gcc67968.dir/b.go       |    6 +-
 test/fixedbugs/issue10607a.go          |    2 +-
 test/fixedbugs/issue11326.go           |   16 +-
 test/fixedbugs/issue11361.go           |    2 +-
 test/fixedbugs/issue11362.go           |    1 -
 test/fixedbugs/issue12677.dir/p.go     |    3 +-
 test/fixedbugs/issue12677.dir/q.go     |    2 +
 test/fixedbugs/issue13261.go           |   24 +-
 test/fixedbugs/issue13265.go           |    6 +-
 test/fixedbugs/issue13337.go           |    1 +
 test/fixedbugs/issue13415.go           |   12 +-
 test/fixedbugs/issue13485.go           |    2 +-
 test/fixedbugs/issue14136.go           |    2 +-
 test/fixedbugs/issue14321.go           |    4 +-
 test/fixedbugs/issue14540.go           |    5 +-
 test/fixedbugs/issue14651.go           |    6 +-
 test/fixedbugs/issue14729.go           |    4 +-
 test/fixedbugs/issue15039.go           |    2 +-
 test/fixedbugs/issue15042.go           |    2 +-
 test/fixedbugs/issue15311.go           |    8 +-
 test/fixedbugs/issue15439.go           |    4 +-
 test/fixedbugs/issue15470.dir/a.go     |    6 +-
 test/fixedbugs/issue15548.dir/c.go     |    2 +-
 test/fixedbugs/issue15646.go           |    2 +-
 test/fixedbugs/issue15926.go           |    2 +-
 test/fixedbugs/issue16515.go           |    5 +-
 test/fixedbugs/issue16948.go           |    1 +
 test/fixedbugs/issue17449.go           |   16 +-
 test/fixedbugs/issue17588.go           |    8 +-
 test/fixedbugs/issue17645.go           |    3 +-
 test/fixedbugs/issue18231.go           |    2 +-
 test/fixedbugs/issue18808.go           |    8 +-
 test/fixedbugs/issue19028.dir/main.go  |   16 +-
 test/fixedbugs/issue19515.go           |    1 -
 test/fixedbugs/issue19764.dir/a.go     |    3 +-
 test/fixedbugs/issue20602.go           |    4 +-
 test/fixedbugs/issue20811.go           |    1 -
 test/fixedbugs/issue22429.go           |    4 +-
 test/fixedbugs/issue22458.go           |   12 +-
 test/fixedbugs/issue22662.go           |   20 +-
 test/fixedbugs/issue24339.go           |   10 +-
 test/fixedbugs/issue24799.go           |   42 +-
 test/fixedbugs/issue25727.go           |    8 +-
 test/fixedbugs/issue26335.go           |    2 +-
 test/fixedbugs/issue26340.go           |    6 +-
 test/fixedbugs/issue26407.go           |    2 +-
 test/fixedbugs/issue27278.go           |    2 +-
 test/fixedbugs/issue27356.go           |    5 +-
 test/fixedbugs/issue29215.go           |   16 +-
 test/fixedbugs/issue29402.go           |    2 +-
 test/fixedbugs/issue31747.go           |    8 +-
 test/fixedbugs/issue3552.dir/one.go    |   11 +-
 test/fixedbugs/issue3783.go            |    1 -
 test/fixedbugs/issue3925.go            |    3 +-
 test/fixedbugs/issue4097.go            |    2 +-
 test/fixedbugs/issue4099.go            |    2 +-
 test/fixedbugs/issue4162.go            |    8 +-
 test/fixedbugs/issue4251.go            |    6 +-
 test/fixedbugs/issue4264.go            |    8 +-
 test/fixedbugs/issue4283.go            |    4 +-
 test/fixedbugs/issue4313.go            |    5 +-
 test/fixedbugs/issue4326.dir/q1.go     |    8 +-
 test/fixedbugs/issue4326.dir/q2.go     |   10 +-
 test/fixedbugs/issue4365.go            |    8 +-
 test/fixedbugs/issue4396a.go           |    2 +-
 test/fixedbugs/issue4396b.go           |    2 +-
 test/fixedbugs/issue4429.go            |    6 +-
 test/fixedbugs/issue4463.go            |   66 +-
 test/fixedbugs/issue4470.go            |    2 +-
 test/fixedbugs/issue4495.go            |    1 -
 test/fixedbugs/issue4562.go            |    2 +-
 test/fixedbugs/issue4610.go            |    1 -
 test/fixedbugs/issue4618.go            |    2 +-
 test/fixedbugs/issue4620.go            |    2 +-
 test/fixedbugs/issue4654.go            |   82 +-
 test/fixedbugs/issue4663.go            |    4 +-
 test/fixedbugs/issue4748.go            |    8 +-
 test/fixedbugs/issue4879.dir/a.go      |    1 -
 test/fixedbugs/issue4879.dir/b.go      |    6 +-
 test/fixedbugs/issue5056.go            |    4 +-
 test/fixedbugs/issue5172.go            |    4 +-
 test/fixedbugs/issue5493.go            |    2 +-
 test/fixedbugs/issue5515.go            |   18 +-
 test/fixedbugs/issue5614.dir/x.go      |    2 -
 test/fixedbugs/issue5753.go            |    2 +-
 test/fixedbugs/issue5809.go            |    6 +-
 test/fixedbugs/issue5957.dir/b.go      |    1 -
 test/fixedbugs/issue5957.dir/c.go      |   10 +-
 test/fixedbugs/issue6004.go            |    7 +-
 test/fixedbugs/issue6406.go            |    2 +-
 test/fixedbugs/issue6703g.go           |    2 +-
 test/fixedbugs/issue6703h.go           |    2 +-
 test/fixedbugs/issue6703i.go           |    2 +-
 test/fixedbugs/issue6703o.go           |    2 +-
 test/fixedbugs/issue6703p.go           |    2 +-
 test/fixedbugs/issue6703q.go           |    2 +-
 test/fixedbugs/issue6703r.go           |    2 +-
 test/fixedbugs/issue6703y.go           |    2 +-
 test/fixedbugs/issue6703z.go           |    2 +-
 test/fixedbugs/issue6789.dir/a.go      |    6 +-
 test/fixedbugs/issue6847.go            |    2 +-
 test/fixedbugs/issue7223.go            |    7 +-
 test/fixedbugs/issue7310.go            |    2 +-
 test/fixedbugs/issue7550.go            |   20 +-
 test/fixedbugs/issue7590.go            |    2 +-
 test/fixedbugs/issue7648.dir/a.go      |    3 +-
 test/fixedbugs/issue7760.go            |    6 +-
 test/fixedbugs/issue7921.go            |    2 +-
 test/fixedbugs/issue8155.go            |    2 +-
 test/fixedbugs/issue8961.go            |    3 +-
 test/fixedbugs/issue9076.go            |    3 +-
 test/fixedbugs/issue9083.go            |   10 +-
 test/fixedbugs/issue9537.dir/b.go      |    4 +-
 test/fixedbugs/issue9634.go            |    2 +-
 test/float_lit.go                      |   48 +-
 test/for.go                            |    4 +-
 test/func.go                           |    3 -
 test/func1.go                          |    1 -
 test/func4.go                          |    4 +-
 test/func5.go                          |    4 +-
 test/func6.go                          |   10 +-
 test/funcdup.go                        |   20 +-
 test/funcdup2.go                       |    8 +-
 test/gcstring.go                       |    9 +-
 test/goprint.go                        |    2 +-
 test/import1.go                        |   10 +-
 test/import2.dir/import2.go            |   61 +-
 test/import2.dir/import3.go            |   25 +-
 test/import4.dir/empty.go              |   11 +-
 test/import4.dir/import4.go            |   13 +-
 test/indirect1.go                      |   52 +-
 test/initcomma.go                      |    8 +-
 test/initialize.go                     |   38 +-
 test/initializerr.go                   |   22 +-
 test/inline_sync.go                    |   13 +-
 test/int_lit.go                        |    6 +-
 test/intcvt.go                         |    2 +-
 test/interface/bigdata.go              |   34 +-
 test/interface/convert1.go             |    9 +-
 test/interface/convert2.go             |    9 +-
 test/interface/embed.go                |    9 +-
 test/interface/embed1.dir/embed0.go    |    5 +-
 test/interface/embed1.dir/embed1.go    |    9 +-
 test/interface/pointer.go              |    3 +-
 test/interface/private.dir/private1.go |    1 -
 test/interface/private.dir/prog.go     |    6 +-
 test/interface/recursive.go            |    1 +
 test/interface/returntype.go           |   10 +-
 test/interface/struct.go               |   36 +-
 test/iota.go                           |    6 +-
 test/ken/complit.go                    |  181 ++-
 test/ken/convert.go                    |  689 +++++---
 test/ken/cplx2.go                      |    4 +-
 test/ken/cplx3.go                      |    4 +-
 test/ken/embed.go                      |    1 -
 test/ken/for.go                        |   13 +-
 test/ken/interfun.go                   |   67 +-
 test/ken/intervar.go                   |   53 +-
 test/ken/litfun.go                     |   25 +-
 test/ken/mfunc.go                      |   16 +-
 test/ken/ptrfun.go                     |   51 +-
 test/ken/ptrvar.go                     |   79 +-
 test/ken/robfor.go                     |   44 +-
 test/ken/robfunc.go                    |    3 -
 test/ken/shift.go                      |  168 +-
 test/ken/simparray.go                  |   51 +-
 test/ken/simpbool.go                   |  257 ++-
 test/ken/simpfun.go                    |   24 +-
 test/ken/simpvar.go                    |   24 +-
 test/ken/strvar.go                     |  124 +-
 test/literal2.go                       |    4 +-
 test/live1.go                          |    1 -
 test/live_syscall.go                   |    2 +-
 test/map1.go                           |   18 +-
 test/method5.go                        |   44 +-
 test/named.go                          |    1 -
 test/nilptr2.go                        |   10 +-
 test/oldescape2.go                     |   42 +-
 test/oldescape2n.go                    |   42 +-
 test/oldescape5.go                     |    6 +-
 test/oldescape_field.go                |    8 +-
 test/oldescape_iface.go                |   32 +-
 test/oldescape_param.go                |   52 +-
 test/parentype.go                      |   10 +-
 test/pmu/test1.go                      |    1 +
 test/pmu/test2.go                      |   12 -
 test/pmu/test4.go                      |    2 +-
 test/printbig.go                       |    2 +-
 test/recover1.go                       |   14 +-
 test/return.go                         |  284 ++--
 test/rune.go                           |   20 +-
 test/runtime.go                        |    2 +-
 test/shift1.go                         |   12 +-
 test/stack.go                          |    2 +-
 test/switch5.go                        |    2 +-
 test/switch7.go                        |    1 -
 test/tinyfin.go                        |    2 +-
 test/typecheck.go                      |    8 +-
 test/typeswitch2.go                    |    2 +-
 test/undef.go                          |   14 +-
 test/varerr.go                         |    5 +-
 550 files changed, 4888 insertions(+), 4200 deletions(-)

diff --git a/test/235.go b/test/235.go
index 6745dde41a..a62d384a65 100644
--- a/test/235.go
+++ b/test/235.go
@@ -16,13 +16,12 @@ func M(f uint64) (in, out T) {
 	out = make(T, 100)
 	go func(in, out T, f uint64) {
 		for {
-			out <- f*<-in
+			out <- f * <-in
 		}
 	}(in, out, f)
 	return in, out
 }
 
-
 func min(xs []uint64) uint64 {
 	m := xs[0]
 	for i := 1; i < len(xs); i++ {
@@ -33,7 +32,6 @@ func min(xs []uint64) uint64 {
 	return m
 }
 
-
 func main() {
 	F := []uint64{2, 3, 5}
 	var n = len(F)
diff --git a/test/64bit.go b/test/64bit.go
index d99d8e83f0..9eaac1409a 100644
--- a/test/64bit.go
+++ b/test/64bit.go
@@ -25,13 +25,13 @@ var bout *bufio.Writer
 // if the compiler has buggy or missing 64-bit support.
 
 type Uint64 struct {
-	hi	uint32
-	lo	uint32
+	hi uint32
+	lo uint32
 }
 
 type Int64 struct {
-	hi	int32
-	lo	uint32
+	hi int32
+	lo uint32
 }
 
 func (a Uint64) Int64() (c Int64) {
@@ -170,7 +170,7 @@ func (a Uint64) DivMod(b Uint64) (quo, rem Uint64) {
 		b = b.LeftShift(uint(n))
 		for i := 0; i <= n; i++ {
 			quo = quo.LeftShift(1)
-			if b.Cmp(a) <= 0 {	// b <= a
+			if b.Cmp(a) <= 0 { // b <= a
 				quo.lo |= 1
 				a = a.Minus(b)
 			}
@@ -205,7 +205,7 @@ func (a Uint64) Xor(b Uint64) (c Uint64) {
 	return
 }
 
-func (a Uint64) String() string	{ return fmt.Sprintf("%#x%08x", a.hi, a.lo) }
+func (a Uint64) String() string { return fmt.Sprintf("%#x%08x", a.hi, a.lo) }
 
 func (a Int64) Uint64() (c Uint64) {
 	c.hi = uint32(a.hi)
@@ -230,15 +230,15 @@ func (a Int64) Cmp(b Int64) int {
 	return 0
 }
 
-func (a Int64) LeftShift(b uint) (c Int64)	{ return a.Uint64().LeftShift(b).Int64() }
+func (a Int64) LeftShift(b uint) (c Int64) { return a.Uint64().LeftShift(b).Int64() }
 
 func (a Int64) RightShift(b uint) (c Int64) {
 	switch {
 	case b >= 64:
-		c.hi = a.hi >> 31	// sign extend
+		c.hi = a.hi >> 31 // sign extend
 		c.lo = uint32(c.hi)
 	case b >= 32:
-		c.hi = a.hi >> 31	// sign extend
+		c.hi = a.hi >> 31 // sign extend
 		c.lo = uint32(a.hi >> (b - 32))
 	default:
 		c.hi = a.hi >> b
@@ -261,15 +261,15 @@ func (a Int64) RightShift64(b Uint64) (c Int64) {
 	return a.RightShift(uint(b.lo))
 }
 
-func (a Int64) Plus(b Int64) (c Int64)	{ return a.Uint64().Plus(b.Uint64()).Int64() }
+func (a Int64) Plus(b Int64) (c Int64) { return a.Uint64().Plus(b.Uint64()).Int64() }
 
-func (a Int64) Minus(b Int64) (c Int64)	{ return a.Uint64().Minus(b.Uint64()).Int64() }
+func (a Int64) Minus(b Int64) (c Int64) { return a.Uint64().Minus(b.Uint64()).Int64() }
 
-func (a Int64) Neg() (c Int64)	{ return a.Uint64().Neg().Int64() }
+func (a Int64) Neg() (c Int64) { return a.Uint64().Neg().Int64() }
 
-func (a Int64) Com() (c Int64)	{ return a.Uint64().Com().Int64() }
+func (a Int64) Com() (c Int64) { return a.Uint64().Com().Int64() }
 
-func (a Int64) Times(b Int64) (c Int64)	{ return a.Uint64().Times(b.Uint64()).Int64() }
+func (a Int64) Times(b Int64) (c Int64) { return a.Uint64().Times(b.Uint64()).Int64() }
 
 func (a Int64) DivMod(b Int64) (quo Int64, rem Int64) {
 	var zero Int64
@@ -299,13 +299,13 @@ func (a Int64) DivMod(b Int64) (quo Int64, rem Int64) {
 	return
 }
 
-func (a Int64) And(b Int64) (c Int64)	{ return a.Uint64().And(b.Uint64()).Int64() }
+func (a Int64) And(b Int64) (c Int64) { return a.Uint64().And(b.Uint64()).Int64() }
 
-func (a Int64) AndNot(b Int64) (c Int64)	{ return a.Uint64().AndNot(b.Uint64()).Int64() }
+func (a Int64) AndNot(b Int64) (c Int64) { return a.Uint64().AndNot(b.Uint64()).Int64() }
 
-func (a Int64) Or(b Int64) (c Int64)	{ return a.Uint64().Or(b.Uint64()).Int64() }
+func (a Int64) Or(b Int64) (c Int64) { return a.Uint64().Or(b.Uint64()).Int64() }
 
-func (a Int64) Xor(b Int64) (c Int64)	{ return a.Uint64().Xor(b.Uint64()).Int64() }
+func (a Int64) Xor(b Int64) (c Int64) { return a.Uint64().Xor(b.Uint64()).Int64() }
 
 func (a Int64) String() string {
 	if a.hi < 0 {
@@ -514,11 +514,11 @@ func varTests() {
 			var div, mod Int64
 			dodiv := false
 			var zero Int64
-			if b.Cmp(zero) != 0 {	// b != 0
+			if b.Cmp(zero) != 0 { // b != 0
 				// Can't divide by zero but also can't divide -0x8000...000 by -1.
 				var bigneg = Int64{-0x80000000, 0}
 				var minus1 = Int64{-1, ^uint32(0)}
-				if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 {	// a != -1<<63 || b != -1
+				if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 { // a != -1<<63 || b != -1
 					div, mod = a.DivMod(b)
 					dodiv = true
 				}
@@ -542,7 +542,7 @@ func varTests() {
 			var div, mod Uint64
 			dodiv := false
 			var zero Uint64
-			if b.Cmp(zero) != 0 {	// b != 0
+			if b.Cmp(zero) != 0 { // b != 0
 				div, mod = a.DivMod(b)
 				dodiv = true
 			}
@@ -661,11 +661,11 @@ func constTests() {
 			var div, mod Int64
 			dodiv := false
 			var zero Int64
-			if b.Cmp(zero) != 0 {	// b != 0
+			if b.Cmp(zero) != 0 { // b != 0
 				// Can't divide by zero but also can't divide -0x8000...000 by -1.
 				var bigneg = Int64{-0x80000000, 0}
 				var minus1 = Int64{-1, ^uint32(0)}
-				if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 {	// a != -1<<63 || b != -1
+				if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 { // a != -1<<63 || b != -1
 					div, mod = a.DivMod(b)
 					dodiv = true
 				}
@@ -692,7 +692,7 @@ func constTests() {
 			var div, mod Uint64
 			dodiv := false
 			var zero Uint64
-			if b.Cmp(zero) != 0 {	// b != 0
+			if b.Cmp(zero) != 0 { // b != 0
 				div, mod = a.DivMod(b)
 				dodiv = true
 			}
diff --git a/test/align.go b/test/align.go
index 61d07c49b8..6e33983275 100644
--- a/test/align.go
+++ b/test/align.go
@@ -13,7 +13,7 @@ package main
 // introduced by CL 102036.
 type T struct {
 	pad uint32
-	f float64
+	f   float64
 }
 
 //go:noinline
diff --git a/test/assign1.go b/test/assign1.go
index b9e0325ce8..eabf10062d 100644
--- a/test/assign1.go
+++ b/test/assign1.go
@@ -214,7 +214,6 @@ func main() {
 	ps1 = ps0 // ERROR "cannot use|incompatible"
 	ps1 = ps  // ERROR "cannot use|incompatible"
 
-
 	a0 = [10]int(a)
 	a0 = [10]int(a1)
 	a = A(a0)
@@ -236,8 +235,8 @@ func main() {
 	c1 = C1(c0)
 	c1 = C1(c)
 
-	f0 = func() int(f)
-	f0 = func() int(f1)
+	f0 = (func() int)(f)
+	f0 = (func() int)(f1)
 	f = F(f0)
 	f = F(f1)
 	f1 = F1(f0)
diff --git a/test/bigmap.go b/test/bigmap.go
index c5e4f91e11..77ff8243c5 100644
--- a/test/bigmap.go
+++ b/test/bigmap.go
@@ -35,7 +35,6 @@ func main() {
 	cmp(m[1], seq(11, 13))
 	cmp(m[2], seq(2, 9))
 	cmp(m[3], seq(3, 17))
-	
 
 	{
 		type T [1]byte
@@ -47,7 +46,7 @@ func main() {
 			println(x, y)
 			panic("bad map")
 		}
-  	}
+	}
 	{
 		type T [100]byte
 		type V [1]byte
@@ -134,6 +133,6 @@ func main() {
 		if x, y := m[T{}][0], m[T{1}][0]; x != 1 || y != 2 {
 			println(x, y)
 			panic("bad map")
-  		}
-  	}
+		}
+	}
 }
diff --git a/test/blank1.go b/test/blank1.go
index bf94d1a0fb..a29992c367 100644
--- a/test/blank1.go
+++ b/test/blank1.go
@@ -7,7 +7,7 @@
 // Test that incorrect uses of the blank identifer are caught.
 // Does not compile.
 
-package _	// ERROR "invalid package name _"
+package _ // ERROR "invalid package name _"
 
 var t struct {
 	_ int
@@ -18,15 +18,15 @@ func (x int) _() { // ERROR "cannot define new methods on non-local type"
 }
 
 type T struct {
-      _ []int
+	_ []int
 }
 
 func main() {
-	_()	// ERROR "cannot use _ as value"
-	x := _+1	// ERROR "cannot use _ as value"
+	_()        // ERROR "cannot use _ as value"
+	x := _ + 1 // ERROR "cannot use _ as value"
 	_ = x
 	_ = t._ // ERROR "cannot refer to blank field|invalid use of"
 
-      var v1, v2 T
-      _ = v1 == v2 // ERROR "cannot be compared|non-comparable"
+	var v1, v2 T
+	_ = v1 == v2 // ERROR "cannot be compared|non-comparable"
 }
diff --git a/test/char_lit.go b/test/char_lit.go
index 836c3c1a2d..e452db952e 100644
--- a/test/char_lit.go
+++ b/test/char_lit.go
@@ -11,8 +11,7 @@ package main
 import "os"
 
 func main() {
-	var i uint64 =
-		' ' +
+	var i uint64 = ' ' +
 		'a' +
 		'ä' +
 		'本' +
diff --git a/test/closedchan.go b/test/closedchan.go
index 043a92d388..5221d257b4 100644
--- a/test/closedchan.go
+++ b/test/closedchan.go
@@ -18,7 +18,7 @@ var failed bool
 type Chan interface {
 	Send(int)
 	Nbsend(int) bool
-	Recv() (int)
+	Recv() int
 	Nbrecv() (int, bool)
 	Recv2() (int, bool)
 	Nbrecv2() (int, bool, bool)
@@ -214,7 +214,6 @@ func (c SSChan) Impl() string {
 	return "(select)"
 }
 
-
 func shouldPanic(f func()) {
 	defer func() {
 		if recover() == nil {
@@ -318,13 +317,13 @@ func closedasync() chan int {
 	return c
 }
 
-var mks = []func(chan int) Chan {
+var mks = []func(chan int) Chan{
 	func(c chan int) Chan { return XChan(c) },
 	func(c chan int) Chan { return SChan(c) },
 	func(c chan int) Chan { return SSChan(c) },
 }
 
-var testcloseds = []func(Chan) {
+var testcloseds = []func(Chan){
 	testasync1,
 	testasync2,
 	testasync3,
@@ -335,18 +334,18 @@ func main() {
 	for _, mk := range mks {
 		test1(mk(closedsync()))
 	}
-	
+
 	for _, testclosed := range testcloseds {
 		for _, mk := range mks {
 			testclosed(mk(closedasync()))
 		}
 	}
-	
-	var ch chan int	
+
+	var ch chan int
 	shouldPanic(func() {
 		close(ch)
 	})
-	
+
 	ch = make(chan int)
 	close(ch)
 	shouldPanic(func() {
diff --git a/test/closure1.go b/test/closure1.go
index 586998203a..ff78f8af8f 100644
--- a/test/closure1.go
+++ b/test/closure1.go
@@ -16,4 +16,4 @@ func main() {
 			panic("x != 1")
 		}
 	}()
-}
\ No newline at end of file
+}
diff --git a/test/closure2.go b/test/closure2.go
index 4d61b45d3f..3254775fcc 100644
--- a/test/closure2.go
+++ b/test/closure2.go
@@ -90,7 +90,7 @@ func main() {
 			q++
 			g = func() int {
 				return q // test that we capture by ref here
-					 // q++ must on a different decldepth than q declaration
+				// q++ must on a different decldepth than q declaration
 			}
 		}
 		if g() != 2 {
@@ -108,7 +108,7 @@ func main() {
 		}()] = range [2]int{} {
 			g = func() int {
 				return q // test that we capture by ref here
-					 // q++ must on a different decldepth than q declaration
+				// q++ must on a different decldepth than q declaration
 			}
 		}
 		if g() != 2 {
diff --git a/test/cmplxdivide1.go b/test/cmplxdivide1.go
index a52fb6fbcf..eac84d763d 100644
--- a/test/cmplxdivide1.go
+++ b/test/cmplxdivide1.go
@@ -6,9 +6,9 @@ package main
 import "math"
 
 var (
-	nan     = math.NaN()
-	inf     = math.Inf(1)
-	zero    = 0.0
+	nan  = math.NaN()
+	inf  = math.Inf(1)
+	zero = 0.0
 )
 
 var tests = []struct {
diff --git a/test/complit1.go b/test/complit1.go
index 83695a9e88..3c01fe95cb 100644
--- a/test/complit1.go
+++ b/test/complit1.go
@@ -53,13 +53,13 @@ var (
 type M map[T]T
 
 var (
-	_ = M{{i:1}: {i:2}}
-	_ = M{T{i:1}: {i:2}}
-	_ = M{{i:1}: T{i:2}}
-	_ = M{T{i:1}: T{i:2}}
+	_ = M{{i: 1}: {i: 2}}
+	_ = M{T{i: 1}: {i: 2}}
+	_ = M{{i: 1}: T{i: 2}}
+	_ = M{T{i: 1}: T{i: 2}}
 )
 
-type S struct { s [1]*M1 }
+type S struct{ s [1]*M1 }
 type M1 map[S]int
-var _ = M1{{s:[1]*M1{&M1{{}:1}}}:2}
 
+var _ = M1{{s: [1]*M1{&M1{{}: 1}}}: 2}
diff --git a/test/const1.go b/test/const1.go
index 3fd5b55522..f393026a2a 100644
--- a/test/const1.go
+++ b/test/const1.go
@@ -87,8 +87,8 @@ func main() {
 	f(Bool)             // ERROR "convert|wrong type|cannot|incompatible"
 }
 
-const ptr = nil // ERROR "const.*nil"
-const _ = string([]byte(nil)) // ERROR "is not a? ?constant"
+const ptr = nil                                // ERROR "const.*nil"
+const _ = string([]byte(nil))                  // ERROR "is not a? ?constant"
 const _ = uintptr(unsafe.Pointer((*int)(nil))) // ERROR "is not a? ?constant"
-const _ = unsafe.Pointer((*int)(nil)) // ERROR "cannot be nil|invalid constant type|is not a constant"
-const _ = (*int)(nil) // ERROR "cannot be nil|invalid constant type|is not a constant"
+const _ = unsafe.Pointer((*int)(nil))          // ERROR "cannot be nil|invalid constant type|is not a constant"
+const _ = (*int)(nil)                          // ERROR "cannot be nil|invalid constant type|is not a constant"
diff --git a/test/const3.go b/test/const3.go
index 3f4e3d1ae6..28cce0e6d6 100644
--- a/test/const3.go
+++ b/test/const3.go
@@ -29,7 +29,7 @@ func main() {
 		panic("fail")
 	}
 	x := uint(5)
-	y := float64(uint64(1)<<x)	// used to fail to compile
+	y := float64(uint64(1) << x) // used to fail to compile
 	if y != 32 {
 		println("wrong y", y)
 		panic("fail")
diff --git a/test/const5.go b/test/const5.go
index 51e46cbb2f..0f878dcd83 100644
--- a/test/const5.go
+++ b/test/const5.go
@@ -9,7 +9,7 @@
 package p
 
 var b struct {
-	a[10]int
+	a [10]int
 }
 
 var m map[string][20]int
@@ -17,6 +17,7 @@ var m map[string][20]int
 var s [][30]int
 
 func f() *[40]int
+
 var c chan *[50]int
 var z complex128
 
@@ -25,13 +26,12 @@ const (
 	n2 = len(m[""])
 	n3 = len(s[10])
 
-	n4 = len(f())  // ERROR "is not a constant|is not constant"
+	n4 = len(f()) // ERROR "is not a constant|is not constant"
 	n5 = len(<-c) // ERROR "is not a constant|is not constant"
 
-	n6 = cap(f())  // ERROR "is not a constant|is not constant"
-	n7 = cap(<-c) // ERROR "is not a constant|is not constant"
-	n8 = real(z) // ERROR "is not a constant|is not constant"
+	n6 = cap(f())                 // ERROR "is not a constant|is not constant"
+	n7 = cap(<-c)                 // ERROR "is not a constant|is not constant"
+	n8 = real(z)                  // ERROR "is not a constant|is not constant"
 	n9 = len([4]float64{real(z)}) // ERROR "is not a constant|is not constant"
 
 )
-
diff --git a/test/const6.go b/test/const6.go
index b340e589d5..1484bc4b04 100644
--- a/test/const6.go
+++ b/test/const6.go
@@ -12,19 +12,19 @@ type mybool bool
 type mybool1 bool
 
 var (
-	x, y int = 1, 2
-	c1 bool = x < y
-	c2 mybool = x < y
-	c3 mybool = c2 == (x < y)
-	c4 mybool = c2 == (1 < 2)
-	c5 mybool = 1 < 2
-	c6 mybool1 = x < y
-	c7 = c1 == c2 // ERROR "mismatched types|incompatible types"
-	c8 = c2 == c6 // ERROR "mismatched types|incompatible types"
-	c9 = c1 == c6 // ERROR "mismatched types|incompatible types"
-	_ = c2 && (x < y)
-	_ = c2 && (1 < 2)
-	_ = c1 && c2 // ERROR "mismatched types|incompatible types"
-	_ = c2 && c6 // ERROR "mismatched types|incompatible types"
-	_ = c1 && c6 // ERROR "mismatched types|incompatible types"
+	x, y int     = 1, 2
+	c1   bool    = x < y
+	c2   mybool  = x < y
+	c3   mybool  = c2 == (x < y)
+	c4   mybool  = c2 == (1 < 2)
+	c5   mybool  = 1 < 2
+	c6   mybool1 = x < y
+	c7           = c1 == c2 // ERROR "mismatched types|incompatible types"
+	c8           = c2 == c6 // ERROR "mismatched types|incompatible types"
+	c9           = c1 == c6 // ERROR "mismatched types|incompatible types"
+	_            = c2 && (x < y)
+	_            = c2 && (1 < 2)
+	_            = c1 && c2 // ERROR "mismatched types|incompatible types"
+	_            = c2 && c6 // ERROR "mismatched types|incompatible types"
+	_            = c1 && c6 // ERROR "mismatched types|incompatible types"
 )
diff --git a/test/convT2X.go b/test/convT2X.go
index 7e27f06b0c..57fb50fe52 100644
--- a/test/convT2X.go
+++ b/test/convT2X.go
@@ -84,8 +84,8 @@ var (
 	jb    J = b
 	jm    J = m
 	jc    J = c
-	jz J = z
-	jp J = p // The method set for *T contains the methods for T.
+	jz    J = z
+	jp    J = p // The method set for *T contains the methods for T.
 	// pp does not implement error.
 )
 
diff --git a/test/convlit1.go b/test/convlit1.go
index c06bd74438..18222d4eff 100644
--- a/test/convlit1.go
+++ b/test/convlit1.go
@@ -9,12 +9,12 @@
 
 package main
 
-var a = []int { "a" };	// ERROR "conver|incompatible|cannot"
-var b = int { 1 };	// ERROR "compos"
-
+var a = []int{"a"} // ERROR "conver|incompatible|cannot"
+var b = int{1}     // ERROR "compos"
 
 func f() int
 
 func main() {
-	if f < 1 { }	// ERROR "conver|incompatible|invalid"
+	if f < 1 {
+	} // ERROR "conver|incompatible|invalid"
 }
diff --git a/test/ddd2.dir/ddd2.go b/test/ddd2.dir/ddd2.go
index f3f863c83f..79d45337c8 100644
--- a/test/ddd2.dir/ddd2.go
+++ b/test/ddd2.dir/ddd2.go
@@ -13,4 +13,3 @@ func Sum(args ...int) int {
 	}
 	return s
 }
-
diff --git a/test/deferfin.go b/test/deferfin.go
index 80372916d2..6c75485cfa 100644
--- a/test/deferfin.go
+++ b/test/deferfin.go
@@ -60,4 +60,3 @@ func main() {
 		panic("not all finalizers are called")
 	}
 }
-
diff --git a/test/deferprint.go b/test/deferprint.go
index b74677ac59..6f0573e6de 100644
--- a/test/deferprint.go
+++ b/test/deferprint.go
@@ -10,7 +10,7 @@ package main
 
 func main() {
 	defer println(42, true, false, true, 1.5, "world", (chan int)(nil), []int(nil), (map[string]int)(nil), (func())(nil), byte(255))
-	defer println(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)
+	defer println(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
 	// Disabled so the test doesn't crash but left here for reference.
 	// defer panic("dead")
 	defer print("printing: ")
diff --git a/test/divmod.go b/test/divmod.go
index ab85b7f149..52a8a73eda 100644
--- a/test/divmod.go
+++ b/test/divmod.go
@@ -103,8 +103,7 @@ func checkdiv3(x, y uint64) {
 	if (uint64(uint8(x)) == x || uint64(uint8(^x)) == ^x) && (uint64(uint8(y)) == y || uint64(uint8(^y)) == ^y) {
 		checkuint8(uint8(x), uint8(y))
 	}
-	
-	
+
 	sx := int64(x)
 	sy := int64(y)
 	checkint64(sx, sy)
@@ -128,8 +127,8 @@ func checkuint(x, y uint) {
 		return
 	}
 	q, r := udiv(uint64(x), uint64(y))
-	q1 := x/y
-	r1 := x%y
+	q1 := x / y
+	r1 := x % y
 	if q1 != uint(q) {
 		print("uint(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -145,8 +144,8 @@ func checkuint64(x, y uint64) {
 		return
 	}
 	q, r := udiv(x, y)
-	q1 := x/y
-	r1 := x%y
+	q1 := x / y
+	r1 := x % y
 	if q1 != q {
 		print("uint64(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -162,8 +161,8 @@ func checkuint32(x, y uint32) {
 		return
 	}
 	q, r := udiv(uint64(x), uint64(y))
-	q1 := x/y
-	r1 := x%y
+	q1 := x / y
+	r1 := x % y
 	if q1 != uint32(q) {
 		print("uint32(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -179,8 +178,8 @@ func checkuint16(x, y uint16) {
 		return
 	}
 	q, r := udiv(uint64(x), uint64(y))
-	q1 := x/y
-	r1 := x%y
+	q1 := x / y
+	r1 := x % y
 	if q1 != uint16(q) {
 		print("uint16(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -196,8 +195,8 @@ func checkuint8(x, y uint8) {
 		return
 	}
 	q, r := udiv(uint64(x), uint64(y))
-	q1 := x/y
-	r1 := x%y
+	q1 := x / y
+	r1 := x % y
 	if q1 != uint8(q) {
 		print("uint8(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -213,8 +212,8 @@ func checkint(x, y int) {
 		return
 	}
 	q, r := idiv(int64(x), int64(y))
-	q1 := x/y
-	r1 := x%y
+	q1 := x / y
+	r1 := x % y
 	if q1 != int(q) {
 		print("int(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -230,8 +229,8 @@ func checkint64(x, y int64) {
 		return
 	}
 	q, r := idiv(x, y)
-	q1 := x/y
-	r1 := x%y
+	q1 := x / y
+	r1 := x % y
 	if q1 != q {
 		print("int64(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -247,8 +246,8 @@ func checkint32(x, y int32) {
 		return
 	}
 	q, r := idiv(int64(x), int64(y))
-	q1 := x/y
-	r1 := x%y
+	q1 := x / y
+	r1 := x % y
 	if q1 != int32(q) {
 		print("int32(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -264,8 +263,8 @@ func checkint16(x, y int16) {
 		return
 	}
 	q, r := idiv(int64(x), int64(y))
-	q1 := x/y
-	r1 := x%y
+	q1 := x / y
+	r1 := x % y
 	if q1 != int16(q) {
 		print("int16(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -281,8 +280,8 @@ func checkint8(x, y int8) {
 		return
 	}
 	q, r := idiv(int64(x), int64(y))
-	q1 := x/y
-	r1 := x%y
+	q1 := x / y
+	r1 := x % y
 	if q1 != int8(q) {
 		print("int8(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -430,7 +429,7 @@ func udiv(x, y uint64) (q, r uint64) {
 		}
 		y >>= 1
 	}
-	return q, x	
+	return q, x
 }
 
 // signed divide and mod: do unsigned and adjust signs.
diff --git a/test/dwarf/dwarf.dir/main.go b/test/dwarf/dwarf.dir/main.go
index 175a09c779..732be1c180 100644
--- a/test/dwarf/dwarf.dir/main.go
+++ b/test/dwarf/dwarf.dir/main.go
@@ -8,25 +8,26 @@
 // license that can be found in the LICENSE file.
 
 package main
+
 func main() {
-F1()
-F2()
-F3()
-F4()
-F5()
-F6()
-F7()
-F8()
-F9()
-F10()
-F11()
-F12()
-F13()
-F14()
-F15()
-F16()
-F17()
-F18()
-F19()
-F20()
+	F1()
+	F2()
+	F3()
+	F4()
+	F5()
+	F6()
+	F7()
+	F8()
+	F9()
+	F10()
+	F11()
+	F12()
+	F13()
+	F14()
+	F15()
+	F16()
+	F17()
+	F18()
+	F19()
+	F20()
 }
diff --git a/test/dwarf/dwarf.dir/z1.go b/test/dwarf/dwarf.dir/z1.go
index 7f163e9a1d..1cda10aa65 100644
--- a/test/dwarf/dwarf.dir/z1.go
+++ b/test/dwarf/dwarf.dir/z1.go
@@ -1,5 +1,4 @@
-
-
 //line x1.go:4
 package main
+
 func F1() {}
diff --git a/test/dwarf/dwarf.dir/z10.go b/test/dwarf/dwarf.dir/z10.go
index 19c70020e0..1217cbffd8 100644
--- a/test/dwarf/dwarf.dir/z10.go
+++ b/test/dwarf/dwarf.dir/z10.go
@@ -1,6 +1,4 @@
-
-
-
 //line x10.go:4
 package main
+
 func F10() {}
diff --git a/test/dwarf/dwarf.dir/z11.go b/test/dwarf/dwarf.dir/z11.go
index c1d2f9180f..c0350e2e9d 100644
--- a/test/dwarf/dwarf.dir/z11.go
+++ b/test/dwarf/dwarf.dir/z11.go
@@ -1,4 +1,4 @@
-
 //line x11.go:4
 package main
+
 func F11() {}
diff --git a/test/dwarf/dwarf.dir/z12.go b/test/dwarf/dwarf.dir/z12.go
index 7455f18946..07d8fde60f 100644
--- a/test/dwarf/dwarf.dir/z12.go
+++ b/test/dwarf/dwarf.dir/z12.go
@@ -1,4 +1,4 @@
-
 //line x12.go:4
 package main
+
 func F12() {}
diff --git a/test/dwarf/dwarf.dir/z13.go b/test/dwarf/dwarf.dir/z13.go
index ecb3c4c8c7..2986c6ba1a 100644
--- a/test/dwarf/dwarf.dir/z13.go
+++ b/test/dwarf/dwarf.dir/z13.go
@@ -1,4 +1,4 @@
-
 //line x13.go:4
 package main
+
 func F13() {}
diff --git a/test/dwarf/dwarf.dir/z14.go b/test/dwarf/dwarf.dir/z14.go
index 134b39b64e..742e1eecf1 100644
--- a/test/dwarf/dwarf.dir/z14.go
+++ b/test/dwarf/dwarf.dir/z14.go
@@ -1,4 +1,4 @@
-
 //line x14.go:4
 package main
+
 func F14() {}
diff --git a/test/dwarf/dwarf.dir/z15.go b/test/dwarf/dwarf.dir/z15.go
index d73819b443..971ad7e8bf 100644
--- a/test/dwarf/dwarf.dir/z15.go
+++ b/test/dwarf/dwarf.dir/z15.go
@@ -1,4 +1,4 @@
-
 //line x15.go:4
 package main
+
 func F15() {}
diff --git a/test/dwarf/dwarf.dir/z16.go b/test/dwarf/dwarf.dir/z16.go
index 6c31651baa..3a00057740 100644
--- a/test/dwarf/dwarf.dir/z16.go
+++ b/test/dwarf/dwarf.dir/z16.go
@@ -1,4 +1,4 @@
-
 //line x16.go:4
 package main
+
 func F16() {}
diff --git a/test/dwarf/dwarf.dir/z17.go b/test/dwarf/dwarf.dir/z17.go
index b742d16726..d5fbd62531 100644
--- a/test/dwarf/dwarf.dir/z17.go
+++ b/test/dwarf/dwarf.dir/z17.go
@@ -1,4 +1,4 @@
-
 //line x17.go:4
 package main
+
 func F17() {}
diff --git a/test/dwarf/dwarf.dir/z18.go b/test/dwarf/dwarf.dir/z18.go
index 84150ff0a3..16750d9f37 100644
--- a/test/dwarf/dwarf.dir/z18.go
+++ b/test/dwarf/dwarf.dir/z18.go
@@ -1,5 +1,4 @@
-
-
 //line x18.go:4
 package main
+
 func F18() {}
diff --git a/test/dwarf/dwarf.dir/z19.go b/test/dwarf/dwarf.dir/z19.go
index bb2e296841..ae57364790 100644
--- a/test/dwarf/dwarf.dir/z19.go
+++ b/test/dwarf/dwarf.dir/z19.go
@@ -1,4 +1,4 @@
-
 //line x19.go:4
 package main
+
 func F19() {}
diff --git a/test/dwarf/dwarf.dir/z2.go b/test/dwarf/dwarf.dir/z2.go
index 68bd58257d..daba026c10 100644
--- a/test/dwarf/dwarf.dir/z2.go
+++ b/test/dwarf/dwarf.dir/z2.go
@@ -1,4 +1,4 @@
-
 //line x2.go:4
 package main
+
 func F2() {}
diff --git a/test/dwarf/dwarf.dir/z20.go b/test/dwarf/dwarf.dir/z20.go
index 03111e1845..15ad35c3e7 100644
--- a/test/dwarf/dwarf.dir/z20.go
+++ b/test/dwarf/dwarf.dir/z20.go
@@ -1,4 +1,4 @@
-
 //line x20.go:4
 package main
+
 func F20() {}
diff --git a/test/dwarf/dwarf.dir/z3.go b/test/dwarf/dwarf.dir/z3.go
index 5e4ad3ae25..46f05b92ff 100644
--- a/test/dwarf/dwarf.dir/z3.go
+++ b/test/dwarf/dwarf.dir/z3.go
@@ -1,4 +1,4 @@
-
 //line x3.go:4
 package main
+
 func F3() {}
diff --git a/test/dwarf/dwarf.dir/z4.go b/test/dwarf/dwarf.dir/z4.go
index 1f28465c57..c3fd6e37b8 100644
--- a/test/dwarf/dwarf.dir/z4.go
+++ b/test/dwarf/dwarf.dir/z4.go
@@ -1,4 +1,4 @@
-
 //line x4.go:4
 package main
+
 func F4() {}
diff --git a/test/dwarf/dwarf.dir/z5.go b/test/dwarf/dwarf.dir/z5.go
index 7f4eeb419a..3b6f8b7a63 100644
--- a/test/dwarf/dwarf.dir/z5.go
+++ b/test/dwarf/dwarf.dir/z5.go
@@ -1,4 +1,4 @@
-
 //line x5.go:4
 package main
+
 func F5() {}
diff --git a/test/dwarf/dwarf.dir/z6.go b/test/dwarf/dwarf.dir/z6.go
index 241791dff2..d18a067aae 100644
--- a/test/dwarf/dwarf.dir/z6.go
+++ b/test/dwarf/dwarf.dir/z6.go
@@ -1,4 +1,4 @@
-
 //line x6.go:4
 package main
+
 func F6() {}
diff --git a/test/dwarf/dwarf.dir/z7.go b/test/dwarf/dwarf.dir/z7.go
index 68c1ad0c24..10bc1a9e56 100644
--- a/test/dwarf/dwarf.dir/z7.go
+++ b/test/dwarf/dwarf.dir/z7.go
@@ -1,4 +1,4 @@
-
 //line x7.go:4
 package main
+
 func F7() {}
diff --git a/test/dwarf/dwarf.dir/z8.go b/test/dwarf/dwarf.dir/z8.go
index 16eed32a28..3b17a9d88b 100644
--- a/test/dwarf/dwarf.dir/z8.go
+++ b/test/dwarf/dwarf.dir/z8.go
@@ -1,4 +1,4 @@
-
 //line x8.go:4
 package main
+
 func F8() {}
diff --git a/test/dwarf/dwarf.dir/z9.go b/test/dwarf/dwarf.dir/z9.go
index cbb94b4d2b..3af6b317b5 100644
--- a/test/dwarf/dwarf.dir/z9.go
+++ b/test/dwarf/dwarf.dir/z9.go
@@ -1,4 +1,4 @@
-
 //line x9.go:4
 package main
+
 func F9() {}
diff --git a/test/dwarf/linedirectives.go b/test/dwarf/linedirectives.go
index cc4ffb000f..3fae427ac4 100644
--- a/test/dwarf/linedirectives.go
+++ b/test/dwarf/linedirectives.go
@@ -6,8 +6,9 @@
 
 //line foo/bar.y:4
 package main
+
 //line foo/bar.y:60
-func main() { 
+func main() {
 //line foo/bar.y:297
 	f, l := 0, 0
 //line yacctab:1
@@ -71,7 +72,7 @@ func main() {
 //line foo/bar.y:272
 	if l == f {
 //line foo/bar.y:277
-	panic("aie!")
+		panic("aie!")
 //line foo/bar.y:281
 	}
 //line foo/bar.y:285
@@ -79,5 +80,6 @@ func main() {
 //line foo/bar.y:288
 //line foo/bar.y:290
 }
+
 //line foo/bar.y:293
 //line foo/bar.y:295
diff --git a/test/empty.go b/test/empty.go
index 92a79a4e0d..8ac3907106 100644
--- a/test/empty.go
+++ b/test/empty.go
@@ -9,7 +9,10 @@
 
 package P
 
-import ( )
-const ( )
-var ( )
-type ( )
+import ()
+
+const ()
+
+var ()
+
+type ()
diff --git a/test/eof.go b/test/eof.go
index d051f33bf7..b142dd83c9 100644
--- a/test/eof.go
+++ b/test/eof.go
@@ -9,4 +9,4 @@
 
 // No newline at the end of this file.
 
-package main
\ No newline at end of file
+package main
diff --git a/test/eof1.go b/test/eof1.go
index 90792ca76e..192f207bfc 100644
--- a/test/eof1.go
+++ b/test/eof1.go
@@ -9,4 +9,4 @@
 
 package eof1
 
-// No newline at the end of this comment.
\ No newline at end of file
+// No newline at the end of this comment.
diff --git a/test/escape2.go b/test/escape2.go
index f682621c25..758da81a6d 100644
--- a/test/escape2.go
+++ b/test/escape2.go
@@ -146,13 +146,13 @@ func (b Bar) AlsoLeak() *int { // ERROR "leaking param: b to result ~r0 level=0$
 }
 
 func (b Bar) LeaksToo() *int { // ERROR "leaking param: b to result ~r0 level=0$"
-	v := 0    // ERROR "moved to heap: v$"
+	v := 0 // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
 
 func (b *Bar) LeaksABit() *int { // ERROR "leaking param: b to result ~r0 level=1$"
-	v := 0    // ERROR "moved to heap: v$"
+	v := 0 // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
@@ -522,7 +522,7 @@ func foo72a() {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
 		// escapes its scope
-		x := i    // ERROR "moved to heap: x$"
+		x := i // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return
@@ -531,7 +531,7 @@ func foo72a() {
 func foo72b() [10]*int {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
-		x := i    // ERROR "moved to heap: x$"
+		x := i // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return y
@@ -739,11 +739,11 @@ func tee(p *int) (x, y *int) { return p, p } // ERROR "leaking param: p to resul
 func noop(x, y *int) {} // ERROR "noop x does not escape$" "noop y does not escape$"
 
 func foo82() {
-	var x, y, z int  // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
+	var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
 	go noop(tee(&z))
 	go noop(&x, &y)
 	for {
-		var u, v, w int     // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
+		var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
 		defer noop(tee(&u))
 		defer noop(&v, &w)
 	}
@@ -916,10 +916,10 @@ func foo115(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$"
 
 func foo116(b bool) *int {
 	if b {
-		x := 1    // ERROR "moved to heap: x$"
+		x := 1 // ERROR "moved to heap: x$"
 		return &x
 	} else {
-		y := 1    // ERROR "moved to heap: y$"
+		y := 1 // ERROR "moved to heap: y$"
 		return &y
 	}
 	return nil
@@ -931,7 +931,7 @@ func foo117(unknown func(interface{})) { // ERROR "foo117 unknown does not escap
 }
 
 func foo118(unknown func(*int)) { // ERROR "foo118 unknown does not escape$"
-	x := 1      // ERROR "moved to heap: x$"
+	x := 1 // ERROR "moved to heap: x$"
 	unknown(&x)
 }
 
@@ -1185,7 +1185,7 @@ L1:
 func foo124(x **int) { // ERROR "foo124 x does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo124 func literal does not escape$"
+	func() { // ERROR "foo124 func literal does not escape$"
 		*x = p
 	}()
 }
@@ -1193,7 +1193,7 @@ func foo124(x **int) { // ERROR "foo124 x does not escape$"
 func foo125(ch chan *int) { // ERROR "foo125 ch does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo125 func literal does not escape$"
+	func() { // ERROR "foo125 func literal does not escape$"
 		ch <- p
 	}()
 }
@@ -1229,7 +1229,7 @@ func foo128() {
 func foo129() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo129 func literal does not escape$"
+	func() { // ERROR "foo129 func literal does not escape$"
 		q := p
 		func() { // ERROR "foo129.func1 func literal does not escape$"
 			r := q
@@ -1281,7 +1281,7 @@ func foo134() {
 }
 
 func foo135() {
-	var i int   // ERROR "moved to heap: i$"
+	var i int // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1293,7 +1293,7 @@ func foo135() {
 }
 
 func foo136() {
-	var i int   // ERROR "moved to heap: i$"
+	var i int // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1307,7 +1307,7 @@ func foo136() {
 func foo137() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo137 func literal does not escape$"
+	func() { // ERROR "foo137 func literal does not escape$"
 		q := p
 		go func() { // ERROR "func literal escapes to heap$"
 			r := q
@@ -1320,7 +1320,7 @@ func foo138() *byte {
 	type T struct {
 		x [1]byte
 	}
-	t := new(T)    // ERROR "new\(T\) escapes to heap$"
+	t := new(T) // ERROR "new\(T\) escapes to heap$"
 	return &t.x[0]
 }
 
@@ -1330,7 +1330,7 @@ func foo139() *byte {
 			y byte
 		}
 	}
-	t := new(T)   // ERROR "new\(T\) escapes to heap$"
+	t := new(T) // ERROR "new\(T\) escapes to heap$"
 	return &t.x.y
 }
 
@@ -1498,7 +1498,7 @@ func bar151() {
 }
 
 func bar151b() {
-	var a [10]int      // ERROR "moved to heap: a$"
+	var a [10]int // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8][0])
 }
@@ -1510,7 +1510,7 @@ func bar151c() {
 }
 
 func bar151d() {
-	var a [10]int        // ERROR "moved to heap: a$"
+	var a [10]int // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8:8][0])
 }
@@ -1534,7 +1534,7 @@ func NewV(u U) *V { // ERROR "leaking param: u$"
 }
 
 func foo152() {
-	a := "a"   // ERROR "moved to heap: a$"
+	a := "a" // ERROR "moved to heap: a$"
 	u := U{&a}
 	v := NewV(u)
 	println(v)
@@ -1642,7 +1642,7 @@ type StructWithString struct {
 // to just x, and thus &i looks escaping.
 func fieldFlowTracking() {
 	var x StructWithString
-	i := 0     // ERROR "moved to heap: i$"
+	i := 0 // ERROR "moved to heap: i$"
 	x.p = &i
 	sink = x.s // ERROR "x.s escapes to heap$"
 }
diff --git a/test/escape2n.go b/test/escape2n.go
index 2fd26f7c5c..c6cf4b4e15 100644
--- a/test/escape2n.go
+++ b/test/escape2n.go
@@ -146,13 +146,13 @@ func (b Bar) AlsoLeak() *int { // ERROR "leaking param: b to result ~r0 level=0$
 }
 
 func (b Bar) LeaksToo() *int { // ERROR "leaking param: b to result ~r0 level=0$"
-	v := 0    // ERROR "moved to heap: v$"
+	v := 0 // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
 
 func (b *Bar) LeaksABit() *int { // ERROR "leaking param: b to result ~r0 level=1$"
-	v := 0    // ERROR "moved to heap: v$"
+	v := 0 // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
@@ -522,7 +522,7 @@ func foo72a() {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
 		// escapes its scope
-		x := i    // ERROR "moved to heap: x$"
+		x := i // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return
@@ -531,7 +531,7 @@ func foo72a() {
 func foo72b() [10]*int {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
-		x := i    // ERROR "moved to heap: x$"
+		x := i // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return y
@@ -739,11 +739,11 @@ func tee(p *int) (x, y *int) { return p, p } // ERROR "leaking param: p to resul
 func noop(x, y *int) {} // ERROR "noop x does not escape$" "noop y does not escape$"
 
 func foo82() {
-	var x, y, z int  // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
+	var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
 	go noop(tee(&z))
 	go noop(&x, &y)
 	for {
-		var u, v, w int     // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
+		var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
 		defer noop(tee(&u))
 		defer noop(&v, &w)
 	}
@@ -916,10 +916,10 @@ func foo115(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$"
 
 func foo116(b bool) *int {
 	if b {
-		x := 1    // ERROR "moved to heap: x$"
+		x := 1 // ERROR "moved to heap: x$"
 		return &x
 	} else {
-		y := 1    // ERROR "moved to heap: y$"
+		y := 1 // ERROR "moved to heap: y$"
 		return &y
 	}
 	return nil
@@ -931,7 +931,7 @@ func foo117(unknown func(interface{})) { // ERROR "foo117 unknown does not escap
 }
 
 func foo118(unknown func(*int)) { // ERROR "foo118 unknown does not escape$"
-	x := 1      // ERROR "moved to heap: x$"
+	x := 1 // ERROR "moved to heap: x$"
 	unknown(&x)
 }
 
@@ -1185,7 +1185,7 @@ L1:
 func foo124(x **int) { // ERROR "foo124 x does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo124 func literal does not escape$"
+	func() { // ERROR "foo124 func literal does not escape$"
 		*x = p
 	}()
 }
@@ -1193,7 +1193,7 @@ func foo124(x **int) { // ERROR "foo124 x does not escape$"
 func foo125(ch chan *int) { // ERROR "foo125 ch does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo125 func literal does not escape$"
+	func() { // ERROR "foo125 func literal does not escape$"
 		ch <- p
 	}()
 }
@@ -1229,7 +1229,7 @@ func foo128() {
 func foo129() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo129 func literal does not escape$"
+	func() { // ERROR "foo129 func literal does not escape$"
 		q := p
 		func() { // ERROR "foo129.func1 func literal does not escape$"
 			r := q
@@ -1281,7 +1281,7 @@ func foo134() {
 }
 
 func foo135() {
-	var i int   // ERROR "moved to heap: i$"
+	var i int // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1293,7 +1293,7 @@ func foo135() {
 }
 
 func foo136() {
-	var i int   // ERROR "moved to heap: i$"
+	var i int // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1307,7 +1307,7 @@ func foo136() {
 func foo137() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo137 func literal does not escape$"
+	func() { // ERROR "foo137 func literal does not escape$"
 		q := p
 		go func() { // ERROR "func literal escapes to heap$"
 			r := q
@@ -1320,7 +1320,7 @@ func foo138() *byte {
 	type T struct {
 		x [1]byte
 	}
-	t := new(T)    // ERROR "new\(T\) escapes to heap$"
+	t := new(T) // ERROR "new\(T\) escapes to heap$"
 	return &t.x[0]
 }
 
@@ -1330,7 +1330,7 @@ func foo139() *byte {
 			y byte
 		}
 	}
-	t := new(T)   // ERROR "new\(T\) escapes to heap$"
+	t := new(T) // ERROR "new\(T\) escapes to heap$"
 	return &t.x.y
 }
 
@@ -1498,7 +1498,7 @@ func bar151() {
 }
 
 func bar151b() {
-	var a [10]int      // ERROR "moved to heap: a$"
+	var a [10]int // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8][0])
 }
@@ -1510,7 +1510,7 @@ func bar151c() {
 }
 
 func bar151d() {
-	var a [10]int        // ERROR "moved to heap: a$"
+	var a [10]int // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8:8][0])
 }
@@ -1534,7 +1534,7 @@ func NewV(u U) *V { // ERROR "leaking param: u$"
 }
 
 func foo152() {
-	a := "a"   // ERROR "moved to heap: a$"
+	a := "a" // ERROR "moved to heap: a$"
 	u := U{&a}
 	v := NewV(u)
 	println(v)
@@ -1642,7 +1642,7 @@ type StructWithString struct {
 // to just x, and thus &i looks escaping.
 func fieldFlowTracking() {
 	var x StructWithString
-	i := 0     // ERROR "moved to heap: i$"
+	i := 0 // ERROR "moved to heap: i$"
 	x.p = &i
 	sink = x.s // ERROR "x.s escapes to heap$"
 }
diff --git a/test/escape4.go b/test/escape4.go
index a4a9c14a3e..0c95426915 100644
--- a/test/escape4.go
+++ b/test/escape4.go
@@ -42,7 +42,7 @@ func f5() *byte {
 	type T struct {
 		x [1]byte
 	}
-	t := new(T)    // ERROR "new.T. escapes to heap"
+	t := new(T) // ERROR "new.T. escapes to heap"
 	return &t.x[0]
 }
 
@@ -52,6 +52,6 @@ func f6() *byte {
 			y byte
 		}
 	}
-	t := new(T)   // ERROR "new.T. escapes to heap"
+	t := new(T) // ERROR "new.T. escapes to heap"
 	return &t.x.y
 }
diff --git a/test/escape_closure.go b/test/escape_closure.go
index cf055d3b34..d0406c4268 100644
--- a/test/escape_closure.go
+++ b/test/escape_closure.go
@@ -50,7 +50,7 @@ func ClosureCallArgs4() {
 }
 
 func ClosureCallArgs5() {
-	x := 0                     // ERROR "moved to heap: x"
+	x := 0 // ERROR "moved to heap: x"
 	// TODO(mdempsky): We get "leaking param: p" here because the new escape analysis pass
 	// can tell that p flows directly to sink, but it's a little weird. Re-evaluate.
 	sink = func(p *int) *int { // ERROR "leaking param: p" "func literal does not escape" "\(func literal\)\(&x\) escapes to heap"
@@ -132,7 +132,7 @@ func ClosureCallArgs14() {
 }
 
 func ClosureCallArgs15() {
-	x := 0                      // ERROR "moved to heap: x"
+	x := 0 // ERROR "moved to heap: x"
 	p := &x
 	sink = func(p **int) *int { // ERROR "leaking param content: p" "func literal does not escape" "\(func literal\)\(&p\) escapes to heap"
 		return *p
diff --git a/test/escape_field.go b/test/escape_field.go
index 5d5a6f36b4..7eefeebe71 100644
--- a/test/escape_field.go
+++ b/test/escape_field.go
@@ -39,7 +39,7 @@ func field3() {
 	i := 0 // ERROR "moved to heap: i$"
 	var x X
 	x.p1 = &i
-	sink = x  // ERROR "x escapes to heap"
+	sink = x // ERROR "x escapes to heap"
 }
 
 func field4() {
@@ -113,16 +113,16 @@ func field10() {
 }
 
 func field11() {
-	i := 0         // ERROR "moved to heap: i$"
+	i := 0 // ERROR "moved to heap: i$"
 	x := X{p1: &i}
-	sink = x.p1    // ERROR "x\.p1 escapes to heap"
+	sink = x.p1 // ERROR "x\.p1 escapes to heap"
 }
 
 func field12() {
 	i := 0 // ERROR "moved to heap: i$"
 	// BAD: &i should not escape
 	x := X{p1: &i}
-	sink = x.p2    // ERROR "x\.p2 escapes to heap"
+	sink = x.p2 // ERROR "x\.p2 escapes to heap"
 }
 
 func field13() {
diff --git a/test/escape_iface.go b/test/escape_iface.go
index 50c69cd5c1..772e7e23e6 100644
--- a/test/escape_iface.go
+++ b/test/escape_iface.go
@@ -37,7 +37,7 @@ func efaceEscape0() {
 		_ = x
 	}
 	{
-		i := 0      // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M0{&i}
 		var x M = v // ERROR "v escapes to heap"
 		sink = x    // ERROR "x escapes to heap"
@@ -50,7 +50,7 @@ func efaceEscape0() {
 		_ = v1
 	}
 	{
-		i := 0      // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M0{&i}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
@@ -58,14 +58,14 @@ func efaceEscape0() {
 		sink = v1 // ERROR "v1 escapes to heap"
 	}
 	{
-		i := 0      // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M0{&i}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
 		x.M()
 	}
 	{
-		i := 0      // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M0{&i}
 		var x M = v // ERROR "v escapes to heap"
 		mescapes(x)
@@ -91,46 +91,46 @@ func efaceEscape1() {
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v    // ERROR "v does not escape"
+		var x M = v // ERROR "v does not escape"
 		_ = x
 	}
 	{
-		i := 0         // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M1{&i, 0}
-		var x M = v    // ERROR "v escapes to heap"
-		sink = x       // ERROR "x escapes to heap"
+		var x M = v // ERROR "v escapes to heap"
+		sink = x    // ERROR "x escapes to heap"
 	}
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v    // ERROR "v does not escape"
+		var x M = v // ERROR "v does not escape"
 		v1 := x.(M1)
 		_ = v1
 	}
 	{
-		i := 0         // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M1{&i, 0}
 		var x M = v // ERROR "efaceEscape1 v does not escape"
 		v1 := x.(M1)
 		sink = v1 // ERROR "v1 escapes to heap"
 	}
 	{
-		i := 0         // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M1{&i, 0}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
 		x.M()
 	}
 	{
-		i := 0         // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M1{&i, 0}
-		var x M = v    // ERROR "v escapes to heap"
+		var x M = v // ERROR "v escapes to heap"
 		mescapes(x)
 	}
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v    // ERROR "v does not escape"
+		var x M = v // ERROR "v does not escape"
 		mdoesnotescape(x)
 	}
 }
@@ -244,7 +244,7 @@ func dotTypeEscape2() { // #13805, #15796
 		var x interface{} = i // ERROR "i does not escape"
 		var y interface{} = j // ERROR "j does not escape"
 
-		sink = x.(int)        // ERROR "x.\(int\) escapes to heap"
+		sink = x.(int) // ERROR "x.\(int\) escapes to heap"
 		sink, *(&ok) = y.(int)
 	}
 	{
@@ -254,7 +254,7 @@ func dotTypeEscape2() { // #13805, #15796
 		var x interface{} = &i // ERROR "&i escapes to heap"
 		var y interface{} = &j // ERROR "&j escapes to heap"
 
-		sink = x.(*int)        // ERROR "x.\(\*int\) escapes to heap"
+		sink = x.(*int) // ERROR "x.\(\*int\) escapes to heap"
 		sink, *(&ok) = y.(*int)
 	}
 }
diff --git a/test/escape_indir.go b/test/escape_indir.go
index ce21ea821f..cb6a2205c7 100644
--- a/test/escape_indir.go
+++ b/test/escape_indir.go
@@ -54,14 +54,14 @@ func constptr1() {
 	i := 0           // ERROR "moved to heap: i"
 	x := &ConstPtr{} // ERROR "&ConstPtr literal escapes to heap"
 	x.p = &i
-	sink = x         // ERROR "x escapes to heap"
+	sink = x // ERROR "x escapes to heap"
 }
 
 func constptr2() {
 	i := 0           // ERROR "moved to heap: i"
 	x := &ConstPtr{} // ERROR "&ConstPtr literal does not escape"
 	x.p = &i
-	sink = *x        // ERROR "\*x escapes to heap"
+	sink = *x // ERROR "\*x escapes to heap"
 }
 
 func constptr4() *ConstPtr {
@@ -102,7 +102,7 @@ func constptr8() *ConstPtr {
 func constptr9() ConstPtr {
 	p := new(ConstPtr) // ERROR "new\(ConstPtr\) does not escape"
 	var p1 ConstPtr2
-	i := 0    // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	p1.p = &i
 	p.c = p1
 	return *p
@@ -134,7 +134,7 @@ func foo(p **int) { // ERROR "foo p does not escape"
 }
 
 func foo1(p *int) { // ERROR "p does not escape"
-	i := 0  // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	y := &p
 	*y = &i
 }
@@ -148,13 +148,13 @@ func foo2() {
 	var z Z
 	z.f = &x
 	p := z.f
-	i := 0  // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	*p = &i
 }
 
 var global *byte
 
 func f() {
-	var x byte    // ERROR "moved to heap: x"
+	var x byte // ERROR "moved to heap: x"
 	global = &*&x
 }
diff --git a/test/escape_level.go b/test/escape_level.go
index 44a23e5a4d..e5a0f50273 100644
--- a/test/escape_level.go
+++ b/test/escape_level.go
@@ -27,15 +27,15 @@ func level1() {
 }
 
 func level2() {
-	i := 0     // ERROR "moved to heap: i"
-	p0 := &i   // ERROR "moved to heap: p0"
+	i := 0   // ERROR "moved to heap: i"
+	p0 := &i // ERROR "moved to heap: p0"
 	p1 := &p0
 	p2 := &p1
 	sink = *p2 // ERROR "\*p2 escapes to heap"
 }
 
 func level3() {
-	i := 0      // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	p0 := &i
 	p1 := &p0
 	p2 := &p1
@@ -43,23 +43,23 @@ func level3() {
 }
 
 func level4() {
-	i := 0     // ERROR "moved to heap: i"
-	p0 := &i   // ERROR "moved to heap: p0"
+	i := 0   // ERROR "moved to heap: i"
+	p0 := &i // ERROR "moved to heap: p0"
 	p1 := &p0
 	p2 := p1   // ERROR "moved to heap: p2"
 	sink = &p2 // ERROR "&p2 escapes to heap"
 }
 
 func level5() {
-	i := 0    // ERROR "moved to heap: i"
-	p0 := &i  // ERROR "moved to heap: p0"
+	i := 0   // ERROR "moved to heap: i"
+	p0 := &i // ERROR "moved to heap: p0"
 	p1 := &p0
 	p2 := p1
 	sink = p2 // ERROR "p2 escapes to heap"
 }
 
 func level6() {
-	i := 0    // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	p0 := &i
 	p1 := &p0
 	p2 := p1
@@ -67,7 +67,7 @@ func level6() {
 }
 
 func level7() {
-	i := 0    // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	p0 := &i
 	p1 := &p0
 	// note *p1 == &i
@@ -76,7 +76,7 @@ func level7() {
 }
 
 func level8() {
-	i := 0    // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	p0 := &i
 	p1 := &p0
 	p2 := *p1
diff --git a/test/escape_map.go b/test/escape_map.go
index 9912b55a35..d17c457ec7 100644
--- a/test/escape_map.go
+++ b/test/escape_map.go
@@ -15,7 +15,7 @@ func map0() {
 	// BAD: i should not escape
 	i := 0 // ERROR "moved to heap: i"
 	// BAD: j should not escape
-	j := 0     // ERROR "moved to heap: j"
+	j := 0 // ERROR "moved to heap: j"
 	m[&i] = &j
 	_ = m
 }
@@ -23,8 +23,8 @@ func map0() {
 func map1() *int {
 	m := make(map[*int]*int) // ERROR "make\(map\[\*int\]\*int\) does not escape"
 	// BAD: i should not escape
-	i := 0       // ERROR "moved to heap: i"
-	j := 0       // ERROR "moved to heap: j"
+	i := 0 // ERROR "moved to heap: i"
+	j := 0 // ERROR "moved to heap: j"
 	m[&i] = &j
 	return m[&i]
 }
@@ -41,7 +41,7 @@ func map3() []*int {
 	m := make(map[*int]*int) // ERROR "make\(map\[\*int\]\*int\) does not escape"
 	i := 0                   // ERROR "moved to heap: i"
 	// BAD: j should not escape
-	j := 0     // ERROR "moved to heap: j"
+	j := 0 // ERROR "moved to heap: j"
 	m[&i] = &j
 	var r []*int
 	for k := range m {
@@ -53,8 +53,8 @@ func map3() []*int {
 func map4() []*int {
 	m := make(map[*int]*int) // ERROR "make\(map\[\*int\]\*int\) does not escape"
 	// BAD: i should not escape
-	i := 0     // ERROR "moved to heap: i"
-	j := 0     // ERROR "moved to heap: j"
+	i := 0 // ERROR "moved to heap: i"
+	j := 0 // ERROR "moved to heap: j"
 	m[&i] = &j
 	var r []*int
 	for k, v := range m {
@@ -68,8 +68,8 @@ func map4() []*int {
 }
 
 func map5(m map[*int]*int) { // ERROR "m does not escape"
-	i := 0     // ERROR "moved to heap: i"
-	j := 0     // ERROR "moved to heap: j"
+	i := 0 // ERROR "moved to heap: i"
+	j := 0 // ERROR "moved to heap: j"
 	m[&i] = &j
 }
 
@@ -77,8 +77,8 @@ func map6(m map[*int]*int) { // ERROR "m does not escape"
 	if m != nil {
 		m = make(map[*int]*int) // ERROR "make\(map\[\*int\]\*int\) does not escape"
 	}
-	i := 0     // ERROR "moved to heap: i"
-	j := 0     // ERROR "moved to heap: j"
+	i := 0 // ERROR "moved to heap: i"
+	j := 0 // ERROR "moved to heap: j"
 	m[&i] = &j
 }
 
@@ -95,7 +95,7 @@ func map8() {
 	i := 0                     // ERROR "moved to heap: i"
 	j := 0                     // ERROR "moved to heap: j"
 	m := map[*int]*int{&i: &j} // ERROR "literal escapes to heap"
-	sink = m // ERROR "m escapes to heap"
+	sink = m                   // ERROR "m escapes to heap"
 }
 
 func map9() *int {
diff --git a/test/escape_param.go b/test/escape_param.go
index 2097556744..b063d9c3d3 100644
--- a/test/escape_param.go
+++ b/test/escape_param.go
@@ -57,7 +57,7 @@ func caller2b() {
 	i := 0 // ERROR "moved to heap: i$"
 	var p *int
 	param2(&i, &p)
-	sink = p       // ERROR "p escapes to heap$"
+	sink = p // ERROR "p escapes to heap$"
 }
 
 func paramArraySelfAssign(p *PairOfPairs) { // ERROR "p does not escape"
@@ -150,11 +150,11 @@ func caller3a() {
 }
 
 func caller3b() {
-	i := 0            // ERROR "moved to heap: i$"
-	j := 0            // ERROR "moved to heap: j$"
+	i := 0 // ERROR "moved to heap: i$"
+	j := 0 // ERROR "moved to heap: j$"
 	p := Pair{&i, &j}
 	param3(&p)
-	sink = p          // ERROR "p escapes to heap$"
+	sink = p // ERROR "p escapes to heap$"
 }
 
 // in -> rcvr
@@ -173,7 +173,7 @@ func caller4b() {
 	i := 0 // ERROR "moved to heap: i$"
 	p := Pair{}
 	p.param4(&i)
-	sink = p     // ERROR "p escapes to heap$"
+	sink = p // ERROR "p escapes to heap$"
 }
 
 // in -> heap
@@ -182,7 +182,7 @@ func param5(i *int) { // ERROR "leaking param: i$"
 }
 
 func caller5() {
-	i := 0     // ERROR "moved to heap: i$"
+	i := 0 // ERROR "moved to heap: i$"
 	param5(&i)
 }
 
@@ -192,8 +192,8 @@ func param6(i ***int) { // ERROR "leaking param content: i$"
 }
 
 func caller6a() {
-	i := 0      // ERROR "moved to heap: i$"
-	p := &i     // ERROR "moved to heap: p$"
+	i := 0  // ERROR "moved to heap: i$"
+	p := &i // ERROR "moved to heap: p$"
 	p2 := &p
 	param6(&p2)
 }
@@ -204,8 +204,8 @@ func param7(i ***int) { // ERROR "leaking param content: i$"
 }
 
 func caller7() {
-	i := 0      // ERROR "moved to heap: i$"
-	p := &i     // ERROR "moved to heap: p$"
+	i := 0  // ERROR "moved to heap: i$"
+	p := &i // ERROR "moved to heap: p$"
 	p2 := &p
 	param7(&p2)
 }
@@ -234,8 +234,8 @@ func caller9a() {
 }
 
 func caller9b() {
-	i := 0             // ERROR "moved to heap: i$"
-	p := &i            // ERROR "moved to heap: p$"
+	i := 0  // ERROR "moved to heap: i$"
+	p := &i // ERROR "moved to heap: p$"
 	p2 := &p
 	sink = param9(&p2) // ERROR  "param9\(&p2\) escapes to heap"
 }
@@ -253,7 +253,7 @@ func caller10a() {
 }
 
 func caller10b() {
-	i := 0              // ERROR "moved to heap: i$"
+	i := 0 // ERROR "moved to heap: i$"
 	p := &i
 	p2 := &p
 	sink = param10(&p2) // ERROR "param10\(&p2\) escapes to heap"
@@ -265,8 +265,8 @@ func param11(i **int) ***int { // ERROR "moved to heap: i$"
 }
 
 func caller11a() {
-	i := 0          // ERROR "moved to heap: i"
-	p := &i         // ERROR "moved to heap: p"
+	i := 0  // ERROR "moved to heap: i"
+	p := &i // ERROR "moved to heap: p"
 	_ = param11(&p)
 }
 
@@ -283,8 +283,8 @@ func caller11c() { // GOOD
 }
 
 func caller11d() {
-	i := 0             // ERROR "moved to heap: i$"
-	p := &i            // ERROR "moved to heap: p"
+	i := 0  // ERROR "moved to heap: i$"
+	p := &i // ERROR "moved to heap: p"
 	p2 := &p
 	sink = param11(p2) // ERROR "param11\(p2\) escapes to heap"
 }
@@ -319,7 +319,7 @@ func caller12c() {
 	p := &i // ERROR "moved to heap: p$"
 	r := Indir{}
 	r.param12(&p)
-	sink = r      // ERROR "r escapes to heap$"
+	sink = r // ERROR "r escapes to heap$"
 }
 
 func caller12d() {
@@ -327,7 +327,7 @@ func caller12d() {
 	p := &i // ERROR "moved to heap: p$"
 	r := Indir{}
 	r.param12(&p)
-	sink = **r.p  // ERROR "\* \(\*r\.p\) escapes to heap"
+	sink = **r.p // ERROR "\* \(\*r\.p\) escapes to heap"
 }
 
 // in -> value rcvr
@@ -370,15 +370,15 @@ func caller13d() {
 	var v Val
 	v.p = &p
 	v.param13(&i)
-	sink = v      // ERROR "v escapes to heap$"
+	sink = v // ERROR "v escapes to heap$"
 }
 
 func caller13e() {
-	i := 0        // ERROR "moved to heap: i$"
-	var p *int    // ERROR "moved to heap: p$"
+	i := 0     // ERROR "moved to heap: i$"
+	var p *int // ERROR "moved to heap: p$"
 	v := Val{&p}
 	v.param13(&i)
-	sink = v      // ERROR "v escapes to heap$"
+	sink = v // ERROR "v escapes to heap$"
 }
 
 func caller13f() {
@@ -386,7 +386,7 @@ func caller13f() {
 	var p *int    // ERROR "moved to heap: p$"
 	v := &Val{&p} // ERROR "&Val literal escapes to heap$"
 	v.param13(&i)
-	sink = v      // ERROR "v escapes to heap$"
+	sink = v // ERROR "v escapes to heap$"
 }
 
 func caller13g() {
@@ -394,7 +394,7 @@ func caller13g() {
 	var p *int
 	v := Val{&p}
 	v.param13(&i)
-	sink = *v.p   // ERROR "\*v\.p escapes to heap"
+	sink = *v.p // ERROR "\*v\.p escapes to heap"
 }
 
 func caller13h() {
@@ -402,7 +402,7 @@ func caller13h() {
 	var p *int
 	v := &Val{&p} // ERROR "caller13h &Val literal does not escape$"
 	v.param13(&i)
-	sink = **v.p  // ERROR "\* \(\*v\.p\) escapes to heap"
+	sink = **v.p // ERROR "\* \(\*v\.p\) escapes to heap"
 }
 
 type Node struct {
diff --git a/test/escape_slice.go b/test/escape_slice.go
index 03053cf326..40a5ad372c 100644
--- a/test/escape_slice.go
+++ b/test/escape_slice.go
@@ -18,28 +18,28 @@ var sink interface{}
 func slice0() {
 	var s []*int
 	// BAD: i should not escape
-	i := 0            // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	s = append(s, &i)
 	_ = s
 }
 
 func slice1() *int {
 	var s []*int
-	i := 0            // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	s = append(s, &i)
 	return s[0]
 }
 
 func slice2() []*int {
 	var s []*int
-	i := 0            // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	s = append(s, &i)
 	return s
 }
 
 func slice3() *int {
 	var s []*int
-	i := 0            // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	s = append(s, &i)
 	for _, p := range s {
 		return p
@@ -48,7 +48,7 @@ func slice3() *int {
 }
 
 func slice4(s []*int) { // ERROR "s does not escape"
-	i := 0    // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	s[0] = &i
 }
 
@@ -56,14 +56,14 @@ func slice5(s []*int) { // ERROR "s does not escape"
 	if s != nil {
 		s = make([]*int, 10) // ERROR "make\(\[\]\*int, 10\) does not escape"
 	}
-	i := 0    // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	s[0] = &i
 }
 
 func slice6() {
 	s := make([]*int, 10) // ERROR "make\(\[\]\*int, 10\) does not escape"
 	// BAD: i should not escape
-	i := 0    // ERROR "moved to heap: i"
+	i := 0 // ERROR "moved to heap: i"
 	s[0] = &i
 	_ = s
 }
diff --git a/test/escape_struct_param1.go b/test/escape_struct_param1.go
index 7004946e2f..5242a507c7 100644
--- a/test/escape_struct_param1.go
+++ b/test/escape_struct_param1.go
@@ -35,7 +35,7 @@ func (u *U) SPPi() *string { // ERROR "leaking param: u to result ~r0 level=2$"
 }
 
 func tSPPi() {
-	s := "cat"        // ERROR "moved to heap: s$"
+	s := "cat" // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tSPPi &U literal does not escape$"
@@ -43,7 +43,7 @@ func tSPPi() {
 }
 
 func tiSPP() {
-	s := "cat"        // ERROR "moved to heap: s$"
+	s := "cat" // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tiSPP &U literal does not escape$"
@@ -52,8 +52,8 @@ func tiSPP() {
 
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of ps
 func tSP() {
-	s := "cat"        // ERROR "moved to heap: s$"
-	ps := &s          // ERROR "moved to heap: ps$"
+	s := "cat" // ERROR "moved to heap: s$"
+	ps := &s   // ERROR "moved to heap: ps$"
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tSP &U literal does not escape$"
 	Ssink = pu.SP()
@@ -114,14 +114,14 @@ func (v *V) UPiSPd() *string { // ERROR "leaking param: v to result ~r0 level=2$
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPa() {
 	s1 := "ant"
-	s2 := "bat"          // ERROR "moved to heap: s2$"
-	s3 := "cat"          // ERROR "moved to heap: s3$"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s2 := "bat" // ERROR "moved to heap: s2$"
+	s3 := "cat" // ERROR "moved to heap: s3$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4           // ERROR "moved to heap: ps4$"
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps4 := &s4 // ERROR "moved to heap: ps4$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPa &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -132,14 +132,14 @@ func tUPiSPa() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPb() {
 	s1 := "ant"
-	s2 := "bat"          // ERROR "moved to heap: s2$"
-	s3 := "cat"          // ERROR "moved to heap: s3$"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s2 := "bat" // ERROR "moved to heap: s2$"
+	s3 := "cat" // ERROR "moved to heap: s3$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4           // ERROR "moved to heap: ps4$"
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps4 := &s4 // ERROR "moved to heap: ps4$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPb &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -150,14 +150,14 @@ func tUPiSPb() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPc() {
 	s1 := "ant"
-	s2 := "bat"          // ERROR "moved to heap: s2$"
-	s3 := "cat"          // ERROR "moved to heap: s3$"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s2 := "bat" // ERROR "moved to heap: s2$"
+	s3 := "cat" // ERROR "moved to heap: s3$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4           // ERROR "moved to heap: ps4$"
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps4 := &s4 // ERROR "moved to heap: ps4$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPc &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -168,14 +168,14 @@ func tUPiSPc() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPd() {
 	s1 := "ant"
-	s2 := "bat"          // ERROR "moved to heap: s2$"
-	s3 := "cat"          // ERROR "moved to heap: s3$"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s2 := "bat" // ERROR "moved to heap: s2$"
+	s3 := "cat" // ERROR "moved to heap: s3$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4           // ERROR "moved to heap: ps4$"
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps4 := &s4 // ERROR "moved to heap: ps4$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPd &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -204,12 +204,12 @@ func tUPiSPPia() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPia &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPia &U literal does not escape$"
@@ -222,12 +222,12 @@ func tUPiSPPib() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPib &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPib &U literal does not escape$"
@@ -240,12 +240,12 @@ func tUPiSPPic() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPic &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPic &U literal does not escape$"
@@ -258,12 +258,12 @@ func tUPiSPPid() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPid &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPid &U literal does not escape$"
@@ -286,7 +286,7 @@ func tUPPiSPPia() {
 	s3 := "cat"
 	s4 := "dog"
 	s5 := "emu"
-	s6 := "fox"           // ERROR "moved to heap: s6$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
 	ps6 := &s6
diff --git a/test/escape_struct_param2.go b/test/escape_struct_param2.go
index 5a9b271958..76dc35ccf0 100644
--- a/test/escape_struct_param2.go
+++ b/test/escape_struct_param2.go
@@ -35,7 +35,7 @@ func (u U) SPPi() *string { // ERROR "leaking param: u to result ~r0 level=1$"
 }
 
 func tSPPi() {
-	s := "cat"        // ERROR "moved to heap: s$"
+	s := "cat" // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tSPPi &U literal does not escape$"
@@ -43,7 +43,7 @@ func tSPPi() {
 }
 
 func tiSPP() {
-	s := "cat"        // ERROR "moved to heap: s$"
+	s := "cat" // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tiSPP &U literal does not escape$"
@@ -52,8 +52,8 @@ func tiSPP() {
 
 // BAD: need fine-grained analysis to avoid spurious escape of ps
 func tSP() {
-	s := "cat"        // ERROR "moved to heap: s$"
-	ps := &s          // ERROR "moved to heap: ps$"
+	s := "cat" // ERROR "moved to heap: s$"
+	ps := &s   // ERROR "moved to heap: ps$"
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tSP &U literal does not escape$"
 	Ssink = pu.SP()
@@ -114,14 +114,14 @@ func (v V) UPiSPd() *string { // ERROR "leaking param: v to result ~r0 level=1$"
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPa() {
 	s1 := "ant"
-	s2 := "bat"          // ERROR "moved to heap: s2$"
-	s3 := "cat"          // ERROR "moved to heap: s3$"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s2 := "bat" // ERROR "moved to heap: s2$"
+	s3 := "cat" // ERROR "moved to heap: s3$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4           // ERROR "moved to heap: ps4$"
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps4 := &s4 // ERROR "moved to heap: ps4$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPa &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -132,14 +132,14 @@ func tUPiSPa() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPb() {
 	s1 := "ant"
-	s2 := "bat"          // ERROR "moved to heap: s2$"
-	s3 := "cat"          // ERROR "moved to heap: s3$"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s2 := "bat" // ERROR "moved to heap: s2$"
+	s3 := "cat" // ERROR "moved to heap: s3$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4           // ERROR "moved to heap: ps4$"
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps4 := &s4 // ERROR "moved to heap: ps4$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPb &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -150,14 +150,14 @@ func tUPiSPb() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPc() {
 	s1 := "ant"
-	s2 := "bat"          // ERROR "moved to heap: s2$"
-	s3 := "cat"          // ERROR "moved to heap: s3$"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s2 := "bat" // ERROR "moved to heap: s2$"
+	s3 := "cat" // ERROR "moved to heap: s3$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4           // ERROR "moved to heap: ps4$"
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps4 := &s4 // ERROR "moved to heap: ps4$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPc &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -168,14 +168,14 @@ func tUPiSPc() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPd() {
 	s1 := "ant"
-	s2 := "bat"          // ERROR "moved to heap: s2$"
-	s3 := "cat"          // ERROR "moved to heap: s3$"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s2 := "bat" // ERROR "moved to heap: s2$"
+	s3 := "cat" // ERROR "moved to heap: s3$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4           // ERROR "moved to heap: ps4$"
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps4 := &s4 // ERROR "moved to heap: ps4$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPd &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -204,12 +204,12 @@ func tUPiSPPia() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPia &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPia &U literal does not escape$"
@@ -222,12 +222,12 @@ func tUPiSPPib() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPib &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPib &U literal does not escape$"
@@ -240,12 +240,12 @@ func tUPiSPPic() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPic &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPic &U literal does not escape$"
@@ -258,12 +258,12 @@ func tUPiSPPid() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog"          // ERROR "moved to heap: s4$"
-	s5 := "emu"          // ERROR "moved to heap: s5$"
-	s6 := "fox"          // ERROR "moved to heap: s6$"
+	s4 := "dog" // ERROR "moved to heap: s4$"
+	s5 := "emu" // ERROR "moved to heap: s5$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6           // ERROR "moved to heap: ps6$"
+	ps6 := &s6 // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPid &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPid &U literal does not escape$"
@@ -286,7 +286,7 @@ func tUPPiSPPia() { // This test is sensitive to the level cap in function summa
 	s3 := "cat"
 	s4 := "dog"
 	s5 := "emu"
-	s6 := "fox"           // ERROR "moved to heap: s6$"
+	s6 := "fox" // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
 	ps6 := &s6
diff --git a/test/finprofiled.go b/test/finprofiled.go
index 0eb801a4bd..267e15b9af 100644
--- a/test/finprofiled.go
+++ b/test/finprofiled.go
@@ -23,7 +23,7 @@ func main() {
 	// only for middle bytes. The finalizer resurrects that object.
 	// As the result, all allocated memory must stay alive.
 	const (
-		N = 1 << 20
+		N             = 1 << 20
 		tinyBlockSize = 16 // runtime._TinySize
 	)
 	hold := make([]*int32, 0, N)
diff --git a/test/fixedbugs/bug000.go b/test/fixedbugs/bug000.go
index 9104a57aaf..a0a9a654ad 100644
--- a/test/fixedbugs/bug000.go
+++ b/test/fixedbugs/bug000.go
@@ -7,14 +7,16 @@
 package main
 
 func main() {
-	var x int;
+	var x int
 	switch x {
 	case 0:
-		{}
+		{
+		}
 	case 1:
-		x = 0;
+		x = 0
 	}
 }
+
 /*
 bug0.go:8: case statement out of place
 */
diff --git a/test/fixedbugs/bug002.go b/test/fixedbugs/bug002.go
index 3493426d37..89b989cb85 100644
--- a/test/fixedbugs/bug002.go
+++ b/test/fixedbugs/bug002.go
@@ -7,5 +7,6 @@
 package main
 
 func main() {
-	if ; false {}  // compiles; should be an error (should be simplevardecl before ;)
+	if false {
+	} // compiles; should be an error (should be simplevardecl before ;)
 }
diff --git a/test/fixedbugs/bug003.go b/test/fixedbugs/bug003.go
index 7165d9d209..1602630c39 100644
--- a/test/fixedbugs/bug003.go
+++ b/test/fixedbugs/bug003.go
@@ -7,8 +7,14 @@
 package main
 
 func main() {
-	switch ; { case true: return; default: return }
+	switch {
+	case true:
+		return
+	default:
+		return
+	}
 }
+
 /*
 bug003.go:6: fatal error: walkswitch: not case EMPTY
 */
diff --git a/test/fixedbugs/bug004.go b/test/fixedbugs/bug004.go
index fb207e9bc8..4864afacb6 100644
--- a/test/fixedbugs/bug004.go
+++ b/test/fixedbugs/bug004.go
@@ -7,5 +7,8 @@
 package main
 
 func main() {
-	switch ; { case false: return; }  // compiles; should be an error (should be simplevardecl before ;)
+	switch {
+	case false:
+		return
+	} // compiles; should be an error (should be simplevardecl before ;)
 }
diff --git a/test/fixedbugs/bug005.go b/test/fixedbugs/bug005.go
index 3798f8321a..d57ef6ac2d 100644
--- a/test/fixedbugs/bug005.go
+++ b/test/fixedbugs/bug005.go
@@ -7,11 +7,13 @@
 package main
 
 func main() {
-	Foo: {
-		return;
+Foo:
+	{
+		return
 	}
-	goto Foo;
+	goto Foo
 }
+
 /*
 bug5.go:4: Foo undefined
 bug5.go:4: fatal error: walktype: switch 1 unknown op GOTO l(4)
diff --git a/test/fixedbugs/bug008.go b/test/fixedbugs/bug008.go
index 48f74a52d9..4468d74a20 100644
--- a/test/fixedbugs/bug008.go
+++ b/test/fixedbugs/bug008.go
@@ -7,14 +7,21 @@
 package main
 
 func main() {
-	i5 := 5;
+	i5 := 5
 
-	switch {  // compiler crash fixable with 'switch true'
-	case i5 < 5: dummy := 0; _ = dummy;
-	case i5 == 5: dummy := 0; _ = dummy;
-	case i5 > 5: dummy := 0; _ = dummy;
+	switch { // compiler crash fixable with 'switch true'
+	case i5 < 5:
+		dummy := 0
+		_ = dummy
+	case i5 == 5:
+		dummy := 0
+		_ = dummy
+	case i5 > 5:
+		dummy := 0
+		_ = dummy
 	}
 }
+
 /*
 Segmentation fault
 */
diff --git a/test/fixedbugs/bug009.go b/test/fixedbugs/bug009.go
index 0467b297a2..3db245e64e 100644
--- a/test/fixedbugs/bug009.go
+++ b/test/fixedbugs/bug009.go
@@ -6,10 +6,11 @@
 
 package main
 
-
 func main() {
-	fired := false; _ = fired;
+	fired := false
+	_ = fired
 }
+
 /*
 bug9.go:5: defaultlit: unknown literal: LITERAL-B0 a(1)
 bug9.go:5: fatal error: addvar: n=NAME-fired G0 a(1) l(5) t=<N> nil
diff --git a/test/fixedbugs/bug010.go b/test/fixedbugs/bug010.go
index f54b1d54a8..a8d3ed4cbb 100644
--- a/test/fixedbugs/bug010.go
+++ b/test/fixedbugs/bug010.go
@@ -6,7 +6,6 @@
 
 package main
 
-
 func f(i int, f float64) {
 	i = 8
 	f = 8.0
diff --git a/test/fixedbugs/bug011.go b/test/fixedbugs/bug011.go
index 519c3585f0..95c91a1ff9 100644
--- a/test/fixedbugs/bug011.go
+++ b/test/fixedbugs/bug011.go
@@ -6,7 +6,6 @@
 
 package main
 
-
 type T struct {
 	x, y int
 }
@@ -22,6 +21,7 @@ func main() {
 	r10 := t.m(1, 3.0)
 	_ = r10
 }
+
 /*
 bug11.go:16: fatal error: walktype: switch 1 unknown op CALLMETH l(16) <int32>INT32
 */
diff --git a/test/fixedbugs/bug012.go b/test/fixedbugs/bug012.go
index 38efb6d979..d4ccc973a5 100644
--- a/test/fixedbugs/bug012.go
+++ b/test/fixedbugs/bug012.go
@@ -6,18 +6,24 @@
 
 package main
 
-
 func main() {
-	var u30 uint64 = 0;
-	var u31 uint64 = 1;
-	_, _ = u30, u31;
-	var u32 uint64 = 18446744073709551615;
-	var u33 uint64 = +18446744073709551615;
-	if u32 != (1<<64)-1 { panic("u32\n"); }
-	if u33 != (1<<64)-1 { panic("u33\n"); }
-	var i34 int64 = ^0;  // note: 2's complement means ^0 == -1
-	if i34 != -1 { panic("i34") }
+	var u30 uint64 = 0
+	var u31 uint64 = 1
+	_, _ = u30, u31
+	var u32 uint64 = 18446744073709551615
+	var u33 uint64 = +18446744073709551615
+	if u32 != (1<<64)-1 {
+		panic("u32\n")
+	}
+	if u33 != (1<<64)-1 {
+		panic("u33\n")
+	}
+	var i34 int64 = ^0 // note: 2's complement means ^0 == -1
+	if i34 != -1 {
+		panic("i34")
+	}
 }
+
 /*
 bug12.go:5: overflow converting constant to <uint64>UINT64
 bug12.go:6: overflow converting constant to <uint64>UINT64
diff --git a/test/fixedbugs/bug013.go b/test/fixedbugs/bug013.go
index 045786bf7a..c80fe67c5a 100644
--- a/test/fixedbugs/bug013.go
+++ b/test/fixedbugs/bug013.go
@@ -7,10 +7,11 @@
 package main
 
 func main() {
-	var cu0 uint16 = '\u1234';
-	var cU1 uint32 = '\U00101234';
-	_, _ = cu0, cU1;
+	var cu0 uint16 = '\u1234'
+	var cU1 uint32 = '\U00101234'
+	_, _ = cu0, cU1
 }
+
 /*
 bug13.go:4: missing '
 bug13.go:4: syntax error
diff --git a/test/fixedbugs/bug015.go b/test/fixedbugs/bug015.go
index d3a9f22ed0..b00071e590 100644
--- a/test/fixedbugs/bug015.go
+++ b/test/fixedbugs/bug015.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	var i33 int64;
-	if i33 == (1<<64) -1 {  // ERROR "overflow"
+	var i33 int64
+	if i33 == (1<<64)-1 { // ERROR "overflow"
 	}
 }
diff --git a/test/fixedbugs/bug017.go b/test/fixedbugs/bug017.go
index 2f5960d104..6201124932 100644
--- a/test/fixedbugs/bug017.go
+++ b/test/fixedbugs/bug017.go
@@ -7,9 +7,10 @@
 package main
 
 func main() {
-	var s2 string = "\a\b\f\n\r\t\v";  // \r is miscompiled
-	_ = s2;
+	var s2 string = "\a\b\f\n\r\t\v" // \r is miscompiled
+	_ = s2
 }
+
 /*
 main.go.c: In function ‘main_main’:
 main.go.c:20: error: missing terminating " character
diff --git a/test/fixedbugs/bug020.go b/test/fixedbugs/bug020.go
index cde3f8679b..1dd2106b24 100644
--- a/test/fixedbugs/bug020.go
+++ b/test/fixedbugs/bug020.go
@@ -6,10 +6,10 @@
 
 package main
 
-var digits string;
+var digits string
 
 func putint(buf []byte, i, base, val int, digits string) {
-		buf[i] = digits[val];
+	buf[i] = digits[val]
 }
 
 func main() {
diff --git a/test/fixedbugs/bug021.go b/test/fixedbugs/bug021.go
index bf936e875c..fcbebc7397 100644
--- a/test/fixedbugs/bug021.go
+++ b/test/fixedbugs/bug021.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	s1 := "hi";
-	s2 := "ho";
-	s1 += s2;
+	s1 := "hi"
+	s2 := "ho"
+	s1 += s2
 }
diff --git a/test/fixedbugs/bug022.go b/test/fixedbugs/bug022.go
index 65a8bfe9a1..8395ab36a1 100644
--- a/test/fixedbugs/bug022.go
+++ b/test/fixedbugs/bug022.go
@@ -7,15 +7,15 @@
 package main
 
 func putint(digits *string) {
-	var i byte;
-	i = (*digits)[7];  // compiles
-	i = digits[7];  // ERROR "illegal|is not|invalid"
-	_ = i;
+	var i byte
+	i = (*digits)[7] // compiles
+	i = digits[7]    // ERROR "illegal|is not|invalid"
+	_ = i
 }
 
 func main() {
-	s := "asdfasdfasdfasdf";
-	putint(&s);
+	s := "asdfasdfasdfasdf"
+	putint(&s)
 }
 
 /*
diff --git a/test/fixedbugs/bug023.go b/test/fixedbugs/bug023.go
index 9b211cd54f..c3c77f7243 100644
--- a/test/fixedbugs/bug023.go
+++ b/test/fixedbugs/bug023.go
@@ -7,7 +7,7 @@
 package main
 
 type Type interface {
-	TypeName() string;
+	TypeName() string
 }
 
 type TInt struct {
@@ -15,14 +15,13 @@ type TInt struct {
 
 // TInt
 func (i *TInt) TypeName() string {
-	return "int";
+	return "int"
 }
 
-
 func main() {
-	var t Type;
-	t = nil;
-	_ = t;
+	var t Type
+	t = nil
+	_ = t
 }
 
 /*
diff --git a/test/fixedbugs/bug024.go b/test/fixedbugs/bug024.go
index 2e235b7b46..6e3af02f2c 100644
--- a/test/fixedbugs/bug024.go
+++ b/test/fixedbugs/bug024.go
@@ -7,13 +7,14 @@
 package main
 
 func main() {
-	var i int;
-	i = '\'';
-	i = '\\';
-	var s string;
-	s = "\"";
-	_, _ = i, s;
+	var i int
+	i = '\''
+	i = '\\'
+	var s string
+	s = "\""
+	_, _ = i, s
 }
+
 /*
 bug.go:5: unknown escape sequence: '
 bug.go:6: unknown escape sequence: \
diff --git a/test/fixedbugs/bug026.go b/test/fixedbugs/bug026.go
index bfd03cc955..edb2b5685e 100644
--- a/test/fixedbugs/bug026.go
+++ b/test/fixedbugs/bug026.go
@@ -15,12 +15,12 @@ type Vector struct {
 func (v *Vector) Insert(i int, e Element) {
 }
 
-
 func main() {
-	type I struct { val int; };  // BUG: can't be local; works if global
-	v := new(Vector);
-	v.Insert(0, new(I));
+	type I struct{ val int } // BUG: can't be local; works if global
+	v := new(Vector)
+	v.Insert(0, new(I))
 }
+
 /*
 check: main_sigs_I: not defined
 */
diff --git a/test/fixedbugs/bug028.go b/test/fixedbugs/bug028.go
index 2edf5a9106..cd41b09de3 100644
--- a/test/fixedbugs/bug028.go
+++ b/test/fixedbugs/bug028.go
@@ -6,22 +6,23 @@
 
 package main
 
-
 func Alloc(i int) int {
 	switch i {
 	default:
-		return 5;
+		return 5
 	case 1:
-		return 1;
+		return 1
 	case 10:
-		return 10;
+		return 10
 	}
 	return 0
 }
 
 func main() {
-	s := Alloc(7);
-	if s != 5 { panic("bad") }
+	s := Alloc(7)
+	if s != 5 {
+		panic("bad")
+	}
 }
 
 /*
diff --git a/test/fixedbugs/bug030.go b/test/fixedbugs/bug030.go
index ffd29e057a..93bb2e9e3b 100644
--- a/test/fixedbugs/bug030.go
+++ b/test/fixedbugs/bug030.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	var x int;
-	x := 0; // ERROR "declar|:="
-	_ = x;
+	var x int
+	x := 0 // ERROR "declar|:="
+	_ = x
 }
diff --git a/test/fixedbugs/bug031.go b/test/fixedbugs/bug031.go
index 529e5ce84c..10028c5d1d 100644
--- a/test/fixedbugs/bug031.go
+++ b/test/fixedbugs/bug031.go
@@ -7,23 +7,23 @@
 package main
 
 func main() {
-prog := "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
-"xxxxxxxxxx"+
-"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
-"xxxxxxxxxxxxxxxxxxxxxx"+
-"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
-"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
-"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
-"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
-"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
-"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
-"xxxxxxxxxxxxxxxxxxx"+
-"xxxxxx"+
-"xxxxxxxxxxxxxxxxxxxx"+
-"xxxxxxxx"+
-"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-;
-_ = prog;
+	prog := "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
+		"xxxxxxxxxx" +
+		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
+		"xxxxxxxxxxxxxxxxxxxxxx" +
+		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
+		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
+		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
+		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
+		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
+		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
+		"xxxxxxxxxxxxxxxxxxx" +
+		"xxxxxx" +
+		"xxxxxxxxxxxxxxxxxxxx" +
+		"xxxxxxxx" +
+		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+
+	_ = prog
 }
 
 /* Segmentation fault */
diff --git a/test/fixedbugs/bug037.go b/test/fixedbugs/bug037.go
index f17fb3fd74..e66349a2b7 100644
--- a/test/fixedbugs/bug037.go
+++ b/test/fixedbugs/bug037.go
@@ -7,5 +7,5 @@
 package main
 
 func main() {
-	s := vlong(0);  // ERROR "undef"
+	s := vlong(0) // ERROR "undef"
 }
diff --git a/test/fixedbugs/bug039.go b/test/fixedbugs/bug039.go
index d34f5e62e4..847ac241db 100644
--- a/test/fixedbugs/bug039.go
+++ b/test/fixedbugs/bug039.go
@@ -6,6 +6,6 @@
 
 package main
 
-func f (x int) {	// GCCGO_ERROR "previous"
-	var x int;	// ERROR "redecl|redefinition"
+func f(x int) { // GCCGO_ERROR "previous"
+	var x int // ERROR "redecl|redefinition"
 }
diff --git a/test/fixedbugs/bug040.go b/test/fixedbugs/bug040.go
index d2cf88afcb..cb1e35f3e3 100644
--- a/test/fixedbugs/bug040.go
+++ b/test/fixedbugs/bug040.go
@@ -6,6 +6,6 @@
 
 package main
 
-func f (x,		// GCCGO_ERROR "previous"
-	x int) {	// ERROR "duplicate argument|redefinition"
+func f(x, // GCCGO_ERROR "previous"
+	x int) { // ERROR "duplicate argument|redefinition"
 }
diff --git a/test/fixedbugs/bug045.go b/test/fixedbugs/bug045.go
index c66a2411a8..a15e16343e 100644
--- a/test/fixedbugs/bug045.go
+++ b/test/fixedbugs/bug045.go
@@ -11,11 +11,12 @@ type T struct {
 }
 
 func main() {
-	var ta []*T;
+	var ta []*T
 
-	ta = new([1]*T)[0:];
-	ta[0] = nil;
+	ta = new([1]*T)[0:]
+	ta[0] = nil
 }
+
 /*
 bug045.go:13: fatal error: goc: exit 1
 */
diff --git a/test/fixedbugs/bug046.go b/test/fixedbugs/bug046.go
index 219e91d537..2ef98177de 100644
--- a/test/fixedbugs/bug046.go
+++ b/test/fixedbugs/bug046.go
@@ -6,9 +6,9 @@
 
 package main
 
-type T *struct {}
+type T *struct{}
 
-func (x T) M () {}  // ERROR "pointer|receiver"
+func (x T) M() {} // ERROR "pointer|receiver"
 
 /*
 bug046.go:7: illegal <this> pointer
diff --git a/test/fixedbugs/bug048.go b/test/fixedbugs/bug048.go
index 48ad751e2c..112343c77f 100644
--- a/test/fixedbugs/bug048.go
+++ b/test/fixedbugs/bug048.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	type M map[int] int;
-	m1 := M{7 : 8};
-	_ = m1;
+	type M map[int]int
+	m1 := M{7: 8}
+	_ = m1
 }
diff --git a/test/fixedbugs/bug049.go b/test/fixedbugs/bug049.go
index 51990f2dfb..7de429c80c 100644
--- a/test/fixedbugs/bug049.go
+++ b/test/fixedbugs/bug049.go
@@ -7,8 +7,8 @@
 package main
 
 func atom(s string) {
-	if s == nil {	// ERROR "nil|incompatible"
-		return;
+	if s == nil { // ERROR "nil|incompatible"
+		return
 	}
 }
 
diff --git a/test/fixedbugs/bug051.go b/test/fixedbugs/bug051.go
index c4ba2eff67..e337f960d7 100644
--- a/test/fixedbugs/bug051.go
+++ b/test/fixedbugs/bug051.go
@@ -7,9 +7,9 @@
 package main
 
 func f() int {
-	return 0;
+	return 0
 }
 
 func main() {
-	const n = f();	// ERROR "const"
+	const n = f() // ERROR "const"
 }
diff --git a/test/fixedbugs/bug052.go b/test/fixedbugs/bug052.go
index 440a00ebeb..ec372b33cc 100644
--- a/test/fixedbugs/bug052.go
+++ b/test/fixedbugs/bug052.go
@@ -7,14 +7,14 @@
 package main
 
 func main() {
-	c := 10;
-	d := 7;
-	var x [10]int;
-	i := 0;
+	c := 10
+	d := 7
+	var x [10]int
+	i := 0
 	/* this works:
 	q := c/d;
 	x[i] = q;
 	*/
 	// this doesn't:
-	x[i] = c/d;	// BUG segmentation fault
+	x[i] = c / d // BUG segmentation fault
 }
diff --git a/test/fixedbugs/bug053.go b/test/fixedbugs/bug053.go
index 00625fd7c3..8a8b4be5cf 100644
--- a/test/fixedbugs/bug053.go
+++ b/test/fixedbugs/bug053.go
@@ -7,6 +7,6 @@
 package main
 
 func main() {
-	var len int;	// len should not be a keyword - this doesn't compile
-	_ = len;
+	var len int // len should not be a keyword - this doesn't compile
+	_ = len
 }
diff --git a/test/fixedbugs/bug054.go b/test/fixedbugs/bug054.go
index 01590585c5..064696bd5c 100644
--- a/test/fixedbugs/bug054.go
+++ b/test/fixedbugs/bug054.go
@@ -10,31 +10,31 @@ type Element interface {
 }
 
 type Vector struct {
-	elem []Element;
+	elem []Element
 }
 
 func (v *Vector) At(i int) Element {
-	return v.elem[i];
+	return v.elem[i]
 }
 
 type TStruct struct {
-	name string;
-	fields *Vector;
+	name   string
+	fields *Vector
 }
 
 func (s *TStruct) field(i int) *TStruct {
-	return s.fields.At(i).(*TStruct);
+	return s.fields.At(i).(*TStruct)
 }
 
 func main() {
-	v := new(Vector);
-	v.elem = make([]Element, 10);
-	t := new(TStruct);
-	t.name = "hi";
-	v.elem[0] = t;
-	s := new(TStruct);
-	s.name = "foo";
-	s.fields = v;
+	v := new(Vector)
+	v.elem = make([]Element, 10)
+	t := new(TStruct)
+	t.name = "hi"
+	v.elem[0] = t
+	s := new(TStruct)
+	s.name = "foo"
+	s.fields = v
 	if s.field(0).name != "hi" {
 		panic("bad name")
 	}
diff --git a/test/fixedbugs/bug056.go b/test/fixedbugs/bug056.go
index 13eac29204..dfee21b8bf 100644
--- a/test/fixedbugs/bug056.go
+++ b/test/fixedbugs/bug056.go
@@ -11,8 +11,8 @@ func frexp() (a int, b float64) {
 }
 
 func main() {
-	a, b := frexp();
-	_, _ = a, b;
+	a, b := frexp()
+	_, _ = a, b
 }
 
 /*
diff --git a/test/fixedbugs/bug057.go b/test/fixedbugs/bug057.go
index 19b8651a54..9df1acd077 100644
--- a/test/fixedbugs/bug057.go
+++ b/test/fixedbugs/bug057.go
@@ -7,16 +7,15 @@
 package main
 
 type T struct {
-	s string;
+	s string
 }
 
-
 func main() {
-	s := "";
-	l1 := len(s);
-	var t T;
-	l2 := len(t.s);	// BUG: cannot take len() of a string field
-	_, _ = l1, l2;
+	s := ""
+	l1 := len(s)
+	var t T
+	l2 := len(t.s) // BUG: cannot take len() of a string field
+	_, _ = l1, l2
 }
 
 /*
diff --git a/test/fixedbugs/bug058.go b/test/fixedbugs/bug058.go
index 2b97dbf7c0..ec58317ff5 100644
--- a/test/fixedbugs/bug058.go
+++ b/test/fixedbugs/bug058.go
@@ -6,14 +6,15 @@
 
 package main
 
-type Box struct {};
-var m map[string] *Box;
+type Box struct{}
+
+var m map[string]*Box
 
 func main() {
-	m := make(map[string] *Box);
-	s := "foo";
-	var x *Box = nil;
-	m[s] = x;
+	m := make(map[string]*Box)
+	s := "foo"
+	var x *Box = nil
+	m[s] = x
 }
 
 /*
diff --git a/test/fixedbugs/bug059.go b/test/fixedbugs/bug059.go
index 6f64b9e0b1..4dbd297bc7 100644
--- a/test/fixedbugs/bug059.go
+++ b/test/fixedbugs/bug059.go
@@ -9,28 +9,28 @@ package main
 import "os"
 
 func P(a []string) string {
-	s := "{";
+	s := "{"
 	for i := 0; i < 2; i++ {
 		if i > 0 {
 			s += ","
 		}
-		s += `"` + a[i] + `"`;
+		s += `"` + a[i] + `"`
 	}
-	s +="}";
-	return s;
+	s += "}"
+	return s
 }
 
 func main() {
-	m := make(map[string] []string);
-	as := new([2]string);
-	as[0] = "0";
-	as[1] = "1";
-	m["0"] = as[0:];
+	m := make(map[string][]string)
+	as := new([2]string)
+	as[0] = "0"
+	as[1] = "1"
+	m["0"] = as[0:]
 
-	a := m["0"];
-	a[0] = "x";
-	m["0"][0] = "deleted";
+	a := m["0"]
+	a[0] = "x"
+	m["0"][0] = "deleted"
 	if m["0"][0] != "deleted" {
-		os.Exit(1);
+		os.Exit(1)
 	}
 }
diff --git a/test/fixedbugs/bug060.go b/test/fixedbugs/bug060.go
index 8260729056..a97c1cd2fd 100644
--- a/test/fixedbugs/bug060.go
+++ b/test/fixedbugs/bug060.go
@@ -9,11 +9,11 @@ package main
 import "os"
 
 func main() {
-	m := make(map[int]int);
-	m[0] = 0;
-	m[0]++;
+	m := make(map[int]int)
+	m[0] = 0
+	m[0]++
 	if m[0] != 1 {
-		print("map does not increment\n");
+		print("map does not increment\n")
 		os.Exit(1)
 	}
 }
diff --git a/test/fixedbugs/bug061.go b/test/fixedbugs/bug061.go
index ae99b186d8..295d6f3b45 100644
--- a/test/fixedbugs/bug061.go
+++ b/test/fixedbugs/bug061.go
@@ -7,9 +7,9 @@
 package main
 
 func main() {
-	var s string;
-	s = "0000000000000000000000000000000000000000000000000000000000"[0:7];
-	_ = s;
+	var s string
+	s = "0000000000000000000000000000000000000000000000000000000000"[0:7]
+	_ = s
 }
 
 /*
diff --git a/test/fixedbugs/bug062.go b/test/fixedbugs/bug062.go
index 1cc5003655..1008f1af9c 100644
--- a/test/fixedbugs/bug062.go
+++ b/test/fixedbugs/bug062.go
@@ -7,5 +7,5 @@
 package main
 
 func main() {
-	var s string = nil;	// ERROR "illegal|invalid|incompatible|cannot"
+	var s string = nil // ERROR "illegal|invalid|incompatible|cannot"
 }
diff --git a/test/fixedbugs/bug063.go b/test/fixedbugs/bug063.go
index a3ae3f0962..8e586ac781 100644
--- a/test/fixedbugs/bug063.go
+++ b/test/fixedbugs/bug063.go
@@ -5,4 +5,5 @@
 // license that can be found in the LICENSE file.
 
 package bug063
+
 const c = 0 ^ 0
diff --git a/test/fixedbugs/bug064.go b/test/fixedbugs/bug064.go
index d8b3bea9a6..b186bfe6b5 100644
--- a/test/fixedbugs/bug064.go
+++ b/test/fixedbugs/bug064.go
@@ -6,17 +6,15 @@
 
 package main
 
-func
-swap(x, y int) (u, v int) {
+func swap(x, y int) (u, v int) {
 	return y, x
 }
 
-func
-main() {
-	a := 1;
-	b := 2;
-	a, b = swap(swap(a, b));
+func main() {
+	a := 1
+	b := 2
+	a, b = swap(swap(a, b))
 	if a != 2 || b != 1 {
-		panic("bad swap");
+		panic("bad swap")
 	}
 }
diff --git a/test/fixedbugs/bug065.go b/test/fixedbugs/bug065.go
index a1e3b08bba..78b98d9621 100644
--- a/test/fixedbugs/bug065.go
+++ b/test/fixedbugs/bug065.go
@@ -7,6 +7,6 @@
 package main
 
 func main() {
-	k, l, m := 0,0,0;
-	_, _, _ = k, l, m;
+	k, l, m := 0, 0, 0
+	_, _, _ = k, l, m
 }
diff --git a/test/fixedbugs/bug066.go b/test/fixedbugs/bug066.go
index db3d7f8602..0d43d4c910 100644
--- a/test/fixedbugs/bug066.go
+++ b/test/fixedbugs/bug066.go
@@ -7,20 +7,17 @@
 package bug066
 
 type Scope struct {
-	entries map[string] *Object;
+	entries map[string]*Object
 }
 
-
 type Type struct {
-	scope *Scope;
+	scope *Scope
 }
 
-
 type Object struct {
-	typ *Type;
+	typ *Type
 }
 
-
 func Lookup(scope *Scope) *Object {
-	return scope.entries["foo"];
+	return scope.entries["foo"]
 }
diff --git a/test/fixedbugs/bug067.go b/test/fixedbugs/bug067.go
index aaeefb0ba1..f1aadb7c64 100644
--- a/test/fixedbugs/bug067.go
+++ b/test/fixedbugs/bug067.go
@@ -9,7 +9,7 @@ package main
 var c chan int
 
 func main() {
-	c = make(chan int);
-	go func() { c <- 0 } ();
+	c = make(chan int)
+	go func() { c <- 0 }()
 	<-c
 }
diff --git a/test/fixedbugs/bug069.go b/test/fixedbugs/bug069.go
index 7b07b773d4..4dff02f474 100644
--- a/test/fixedbugs/bug069.go
+++ b/test/fixedbugs/bug069.go
@@ -7,14 +7,14 @@
 package main
 
 func main() {
-	c := make(chan int);
-	ok := false;
-	var i int;
-	
-	i, ok = <-c;  // works
-	_, _ = i, ok;
-	
-	ca := new([2]chan int);
-	i, ok = <-(ca[0]);  // fails: c.go:11: bad shape across assignment - cr=1 cl=2
-	_, _ = i, ok;
+	c := make(chan int)
+	ok := false
+	var i int
+
+	i, ok = <-c // works
+	_, _ = i, ok
+
+	ca := new([2]chan int)
+	i, ok = <-(ca[0]) // fails: c.go:11: bad shape across assignment - cr=1 cl=2
+	_, _ = i, ok
 }
diff --git a/test/fixedbugs/bug071.go b/test/fixedbugs/bug071.go
index ec38f7a979..caae01c6ec 100644
--- a/test/fixedbugs/bug071.go
+++ b/test/fixedbugs/bug071.go
@@ -6,18 +6,18 @@
 
 package bug071
 
-type rat struct  {
-	den  int;
+type rat struct {
+	den int
 }
 
 func (u *rat) pr() {
 }
 
 type dch struct {
-	dat chan  *rat;
+	dat chan *rat
 }
 
-func dosplit(in *dch){
-	dat := <-in.dat;
-	_ = dat;
+func dosplit(in *dch) {
+	dat := <-in.dat
+	_ = dat
 }
diff --git a/test/fixedbugs/bug072.go b/test/fixedbugs/bug072.go
index 05ad93dac2..b6f46045b2 100644
--- a/test/fixedbugs/bug072.go
+++ b/test/fixedbugs/bug072.go
@@ -7,5 +7,5 @@
 package main
 
 func main() {
-	s := string(bug);  // ERROR "undef"
+	s := string(bug) // ERROR "undef"
 }
diff --git a/test/fixedbugs/bug074.go b/test/fixedbugs/bug074.go
index fb789cb4c1..e632e9bf4e 100644
--- a/test/fixedbugs/bug074.go
+++ b/test/fixedbugs/bug074.go
@@ -7,6 +7,6 @@
 package main
 
 func main() {
-	x := string{'a', 'b', '\n'};	// ERROR "composite"
-	print(x);
+	x := string{'a', 'b', '\n'} // ERROR "composite"
+	print(x)
 }
diff --git a/test/fixedbugs/bug075.go b/test/fixedbugs/bug075.go
index d0b7d14e71..a568b5fa70 100644
--- a/test/fixedbugs/bug075.go
+++ b/test/fixedbugs/bug075.go
@@ -6,12 +6,13 @@
 
 package main
 
-type T struct { m map[int]int }
+type T struct{ m map[int]int }
+
 func main() {
-	t := new(T);
-	t.m = make(map[int]int);
-	var x int;
-	var ok bool;
-	x, ok = t.m[0];  //bug075.go:11: bad shape across assignment - cr=1 cl=2
-	_, _ = x, ok;
+	t := new(T)
+	t.m = make(map[int]int)
+	var x int
+	var ok bool
+	x, ok = t.m[0] //bug075.go:11: bad shape across assignment - cr=1 cl=2
+	_, _ = x, ok
 }
diff --git a/test/fixedbugs/bug076.go b/test/fixedbugs/bug076.go
index 60aaa97608..57401318c0 100644
--- a/test/fixedbugs/bug076.go
+++ b/test/fixedbugs/bug076.go
@@ -12,7 +12,6 @@ exit:
 	goto exit
 }
 
-
 func main() {
 exit:
 	; // this should be legal (labels not properly scoped?)
@@ -20,6 +19,6 @@ exit:
 }
 
 /*
-uetli:~/Source/go/test/bugs gri$ 6g bug076.go 
+uetli:~/Source/go/test/bugs gri$ 6g bug076.go
 bug076.go:11: label redeclared: exit
 */
diff --git a/test/fixedbugs/bug078.go b/test/fixedbugs/bug078.go
index 1041b858c8..2a191dc24e 100644
--- a/test/fixedbugs/bug078.go
+++ b/test/fixedbugs/bug078.go
@@ -6,7 +6,7 @@
 
 package main
 
-func dosplit(wait chan int ){
+func dosplit(wait chan int) {
 	select {
 	case <-wait:
 	}
diff --git a/test/fixedbugs/bug083.dir/bug1.go b/test/fixedbugs/bug083.dir/bug1.go
index ea5bcfe205..778688e072 100644
--- a/test/fixedbugs/bug083.dir/bug1.go
+++ b/test/fixedbugs/bug083.dir/bug1.go
@@ -10,5 +10,4 @@ import "./bug0"
 // visible here in package bug1.  The test for failure is in
 // ../bug083.go.
 
-var v1 bug0.t0;	// ERROR "bug0"
-
+var v1 bug0.t0 // ERROR "bug0"
diff --git a/test/fixedbugs/bug085.go b/test/fixedbugs/bug085.go
index dae83f8a49..6182c6a645 100644
--- a/test/fixedbugs/bug085.go
+++ b/test/fixedbugs/bug085.go
@@ -9,7 +9,7 @@ package P
 var x int
 
 func foo() {
-	print(P.x);  // ERROR "undefined"
+	print(P.x) // ERROR "undefined"
 }
 
 /*
diff --git a/test/fixedbugs/bug086.go b/test/fixedbugs/bug086.go
index 40d2362066..97aaa60f91 100644
--- a/test/fixedbugs/bug086.go
+++ b/test/fixedbugs/bug086.go
@@ -8,13 +8,13 @@ package main
 
 func f() int {
 	if false {
-		return 0;
+		return 0
 	}
 	// we should not be able to return successfully w/o a return statement
 } // ERROR "return"
 
 func main() {
-	print(f(), "\n");
+	print(f(), "\n")
 }
 
 /*
diff --git a/test/fixedbugs/bug087.go b/test/fixedbugs/bug087.go
index 67e7210cdb..a973f8b348 100644
--- a/test/fixedbugs/bug087.go
+++ b/test/fixedbugs/bug087.go
@@ -6,11 +6,11 @@
 
 package main
 
-const s string = "foo";
+const s string = "foo"
 
 func main() {
-	i := len(s);  // should be legal to take len() of a constant
-	_ = i;
+	i := len(s) // should be legal to take len() of a constant
+	_ = i
 }
 
 /*
diff --git a/test/fixedbugs/bug088.dir/bug0.go b/test/fixedbugs/bug088.dir/bug0.go
index 7a6e34747f..8bfda6a279 100644
--- a/test/fixedbugs/bug088.dir/bug0.go
+++ b/test/fixedbugs/bug088.dir/bug0.go
@@ -4,6 +4,6 @@
 
 package bug0
 
-var V0 func() int;
-var V1 func() (a int);
-var V2 func() (a, b int);
+var V0 func() int
+var V1 func() (a int)
+var V2 func() (a, b int)
diff --git a/test/fixedbugs/bug088.dir/bug1.go b/test/fixedbugs/bug088.dir/bug1.go
index 2568e37d02..98a4e7cfe4 100644
--- a/test/fixedbugs/bug088.dir/bug1.go
+++ b/test/fixedbugs/bug088.dir/bug1.go
@@ -7,10 +7,10 @@ package main
 import P "./bug0"
 
 func main() {
-	a0 := P.V0();  // works
-	a1 := P.V1();  // works
-	a2, b2 := P.V2();  // doesn't work
-	_, _, _, _ = a0, a1, a2, b2;
+	a0 := P.V0()     // works
+	a1 := P.V1()     // works
+	a2, b2 := P.V2() // doesn't work
+	_, _, _, _ = a0, a1, a2, b2
 }
 
 /*
diff --git a/test/fixedbugs/bug089.go b/test/fixedbugs/bug089.go
index e88f17babb..e1a87801f0 100644
--- a/test/fixedbugs/bug089.go
+++ b/test/fixedbugs/bug089.go
@@ -6,16 +6,15 @@
 
 package main
 
-type	I1	interface {}
-type	I2	interface { pr() }
+type I1 interface{}
+type I2 interface{ pr() }
 
-func	e()	I1;
+func e() I1
 
-var	i1	I1;
-var	i2	I2;
+var i1 I1
+var i2 I2
 
-func
-main() {
+func main() {
 
-	i2 = e().(I2);	// bug089.go:16: fatal error: agen_inter i2i
+	i2 = e().(I2) // bug089.go:16: fatal error: agen_inter i2i
 }
diff --git a/test/fixedbugs/bug090.go b/test/fixedbugs/bug090.go
index 320bd57f5c..d074b30880 100644
--- a/test/fixedbugs/bug090.go
+++ b/test/fixedbugs/bug090.go
@@ -7,8 +7,8 @@
 package main
 
 const (
-	c3div2 = 3/2;
-	f3div2 = 3./2.;
+	c3div2 = 3 / 2
+	f3div2 = 3. / 2.
 )
 
 func assert(t bool, s string) {
@@ -18,29 +18,29 @@ func assert(t bool, s string) {
 }
 
 func main() {
-	var i int;
-	var f float64;
+	var i int
+	var f float64
 
-	assert(c3div2 == 1, "3/2");
-	assert(f3div2 == 1.5, "3/2");
+	assert(c3div2 == 1, "3/2")
+	assert(f3div2 == 1.5, "3/2")
 
-	i = c3div2;
-	assert(i == c3div2, "i == c3div2");
+	i = c3div2
+	assert(i == c3div2, "i == c3div2")
 
-	f = c3div2;
-	assert(f == c3div2, "f == c3div2");
+	f = c3div2
+	assert(f == c3div2, "f == c3div2")
 
-	f = f3div2;
-	assert(f == f3div2, "f == f3div2");
+	f = f3div2
+	assert(f == f3div2, "f == f3div2")
 
-	i = f3div2;	// ERROR "truncate"
-	assert(i == c3div2, "i == c3div2 from f3div2");
-	assert(i != f3div2, "i != f3div2");	// ERROR "truncate"
+	i = f3div2 // ERROR "truncate"
+	assert(i == c3div2, "i == c3div2 from f3div2")
+	assert(i != f3div2, "i != f3div2") // ERROR "truncate"
 
-	const g float64 = 1.0;
-	i = g;  // ERROR "convert|incompatible|cannot"
+	const g float64 = 1.0
+	i = g // ERROR "convert|incompatible|cannot"
 
-	const h float64 = 3.14;
-	i = h;  // ERROR "convert|incompatible|cannot"
-	i = int(h);	// ERROR "truncate"
+	const h float64 = 3.14
+	i = h      // ERROR "convert|incompatible|cannot"
+	i = int(h) // ERROR "truncate"
 }
diff --git a/test/fixedbugs/bug092.go b/test/fixedbugs/bug092.go
index 8027d941ea..b34969afd3 100644
--- a/test/fixedbugs/bug092.go
+++ b/test/fixedbugs/bug092.go
@@ -7,9 +7,9 @@
 package main
 
 func main() {
-	var a [1000] int64;  // this alone works
-	var b [10000] int64;  // this causes a runtime crash
-	_, _ = a, b;
+	var a [1000]int64  // this alone works
+	var b [10000]int64 // this causes a runtime crash
+	_, _ = a, b
 }
 
 /*
diff --git a/test/fixedbugs/bug093.go b/test/fixedbugs/bug093.go
index acd94466f5..a3a626a1b0 100644
--- a/test/fixedbugs/bug093.go
+++ b/test/fixedbugs/bug093.go
@@ -13,16 +13,15 @@ func (p *S) M() {
 }
 
 type I interface {
-	M();
+	M()
 }
 
 func main() {
-	var p *S = nil;
-	var i I = p;  // this should be possible even though p is nil: we still know the type
-	i.M();  // should be possible since we know the type, and don't ever use the receiver
+	var p *S = nil
+	var i I = p // this should be possible even though p is nil: we still know the type
+	i.M()       // should be possible since we know the type, and don't ever use the receiver
 }
 
-
 /*
 throw: ifaces2i: nil pointer
 SIGSEGV: segmentation violation
diff --git a/test/fixedbugs/bug094.go b/test/fixedbugs/bug094.go
index 3ef11da3d3..4456237302 100644
--- a/test/fixedbugs/bug094.go
+++ b/test/fixedbugs/bug094.go
@@ -7,19 +7,17 @@
 package main
 
 func f0() {
-	const x = 0;
+	const x = 0
 }
 
-
 func f1() {
-	x := 0;
-	_ = x;
+	x := 0
+	_ = x
 }
 
-
 func main() {
-	f0();
-	f1();
+	f0()
+	f1()
 }
 
 /*
diff --git a/test/fixedbugs/bug096.go b/test/fixedbugs/bug096.go
index 411ba74e0c..39ce017bb7 100644
--- a/test/fixedbugs/bug096.go
+++ b/test/fixedbugs/bug096.go
@@ -6,12 +6,12 @@
 
 package main
 
-type A []int;
+type A []int
 
 func main() {
-	a := &A{0};
-	b := &A{0, 1};
-	_, _ = a, b;
+	a := &A{0}
+	b := &A{0, 1}
+	_, _ = a, b
 }
 
 /*
diff --git a/test/fixedbugs/bug098.go b/test/fixedbugs/bug098.go
index eb4ee4de03..b872b50fa7 100644
--- a/test/fixedbugs/bug098.go
+++ b/test/fixedbugs/bug098.go
@@ -6,13 +6,13 @@
 
 package main
 
-type A []int;
-type M map[int] int;
+type A []int
+type M map[int]int
 
 func main() {
-	var a *A = &A{0};
-	var m *M = &M{0 : 0};  // should be legal to use & here for consistency with other composite constructors (prev. line)
-	_, _ = a, m;
+	var a *A = &A{0}
+	var m *M = &M{0: 0} // should be legal to use & here for consistency with other composite constructors (prev. line)
+	_, _ = a, m
 }
 
 /*
diff --git a/test/fixedbugs/bug099.go b/test/fixedbugs/bug099.go
index 03a5c454b0..51b667bca8 100644
--- a/test/fixedbugs/bug099.go
+++ b/test/fixedbugs/bug099.go
@@ -7,10 +7,11 @@
 package main
 
 // Interface
-type I interface { F() int }
+type I interface{ F() int }
 
 // Implements interface
-type S struct { }
+type S struct{}
+
 func (s *S) F() int { return 1 }
 
 // Allocates S but returns I
@@ -27,11 +28,10 @@ func Use(x I) {
 }
 
 func main() {
-	i := NewI(0);
-	Use(i);
+	i := NewI(0)
+	Use(i)
 
 	// Again, without temporary
 	// Crashes because x.F is 0.
-	Use(NewI(0));
+	Use(NewI(0))
 }
-
diff --git a/test/fixedbugs/bug101.go b/test/fixedbugs/bug101.go
index 82e496a8a6..5afc4b6dda 100644
--- a/test/fixedbugs/bug101.go
+++ b/test/fixedbugs/bug101.go
@@ -6,10 +6,14 @@
 
 package main
 
-var a = []int { 1, 2, 3 }
+var a = []int{1, 2, 3}
 
 func main() {
-	if len(a) != 3 { panic("array len") }
+	if len(a) != 3 {
+		panic("array len")
+	}
 	// print(a[0], " ", a[1], " ", a[2], "\n")
-	if a[0] != 1 || a[1] != 2 || a[2] != 3 { panic("array contents") }
+	if a[0] != 1 || a[1] != 2 || a[2] != 3 {
+		panic("array contents")
+	}
 }
diff --git a/test/fixedbugs/bug103.go b/test/fixedbugs/bug103.go
index 1cb710e368..c79ebf25cb 100644
--- a/test/fixedbugs/bug103.go
+++ b/test/fixedbugs/bug103.go
@@ -6,9 +6,8 @@
 
 package main
 
-func f() /* no return type */ {}
+func f()/* no return type */ {}
 
 func main() {
-	x := f();  // ERROR "mismatch|as value|no type"
+	x := f() // ERROR "mismatch|as value|no type"
 }
-
diff --git a/test/fixedbugs/bug104.go b/test/fixedbugs/bug104.go
index f0c19a8aa7..0e32d94262 100644
--- a/test/fixedbugs/bug104.go
+++ b/test/fixedbugs/bug104.go
@@ -5,6 +5,7 @@
 // license that can be found in the LICENSE file.
 
 package main
+
 func f() string {
-	return 0	// ERROR "conversion|type"
+	return 0 // ERROR "conversion|type"
 }
diff --git a/test/fixedbugs/bug106.dir/bug1.go b/test/fixedbugs/bug106.dir/bug1.go
index eff0d36ed2..eae2abbbaa 100644
--- a/test/fixedbugs/bug106.dir/bug1.go
+++ b/test/fixedbugs/bug106.dir/bug1.go
@@ -5,4 +5,3 @@
 package bug1
 
 import _ "./bug0"
-
diff --git a/test/fixedbugs/bug107.go b/test/fixedbugs/bug107.go
index dcd8e9d113..198a1f40f3 100644
--- a/test/fixedbugs/bug107.go
+++ b/test/fixedbugs/bug107.go
@@ -5,11 +5,14 @@
 // license that can be found in the LICENSE file.
 
 package main
+
 import os "os"
+
 type _ os.FileInfo
+
 func f() (os int) {
-	 // In the next line "os" should refer to the result variable, not
-	 // to the package.
-	 v := os.Open("", 0, 0);	// ERROR "undefined"
-	 return 0
+	// In the next line "os" should refer to the result variable, not
+	// to the package.
+	v := os.Open("", 0, 0) // ERROR "undefined"
+	return 0
 }
diff --git a/test/fixedbugs/bug108.go b/test/fixedbugs/bug108.go
index cfec4c9f1f..a0f979c3ea 100644
--- a/test/fixedbugs/bug108.go
+++ b/test/fixedbugs/bug108.go
@@ -5,7 +5,8 @@
 // license that can be found in the LICENSE file.
 
 package main
+
 func f() {
-	v := 1 << 1025;		// ERROR "overflow|shift count too large"
+	v := 1 << 1025 // ERROR "overflow|shift count too large"
 	_ = v
 }
diff --git a/test/fixedbugs/bug111.go b/test/fixedbugs/bug111.go
index d977bd54fb..c30afbb6d2 100644
--- a/test/fixedbugs/bug111.go
+++ b/test/fixedbugs/bug111.go
@@ -6,7 +6,7 @@
 
 package main
 
-var ncall int;
+var ncall int
 
 type Iffy interface {
 	Me() Iffy
@@ -17,15 +17,15 @@ type Stucky struct {
 }
 
 func (s *Stucky) Me() Iffy {
-	ncall++;
+	ncall++
 	return s
 }
 
 func main() {
-	s := new(Stucky);
-	i := s.Me();
-	j := i.Me();
-	j.Me();
+	s := new(Stucky)
+	i := s.Me()
+	j := i.Me()
+	j.Me()
 	if ncall != 3 {
 		panic("bug111")
 	}
diff --git a/test/fixedbugs/bug112.go b/test/fixedbugs/bug112.go
index e2ed5c0d41..2928bc15b5 100644
--- a/test/fixedbugs/bug112.go
+++ b/test/fixedbugs/bug112.go
@@ -6,7 +6,8 @@
 
 package main
 
-type T struct { s string }
+type T struct{ s string }
+
 var t = T{"hi"}
 
 func main() {}
diff --git a/test/fixedbugs/bug113.go b/test/fixedbugs/bug113.go
index a1e61cb36f..03e22c0558 100644
--- a/test/fixedbugs/bug113.go
+++ b/test/fixedbugs/bug113.go
@@ -21,7 +21,7 @@ func main() {
 	if foo2(v2) != 1 {
 		panic(2)
 	}
-	
+
 	shouldPanic(p1)
 }
 
diff --git a/test/fixedbugs/bug115.go b/test/fixedbugs/bug115.go
index 7cc3dc40a6..726d33c124 100644
--- a/test/fixedbugs/bug115.go
+++ b/test/fixedbugs/bug115.go
@@ -6,9 +6,9 @@
 
 package main
 
-func isuint(i uint) { }
+func isuint(i uint) {}
 
 func main() {
-	i := ^uint(0);
-	isuint(i);
+	i := ^uint(0)
+	isuint(i)
 }
diff --git a/test/fixedbugs/bug118.go b/test/fixedbugs/bug118.go
index 198b8ff280..ca7fdbba5d 100644
--- a/test/fixedbugs/bug118.go
+++ b/test/fixedbugs/bug118.go
@@ -9,7 +9,7 @@ package bug118
 func Send(c chan int) int {
 	select {
 	default:
-		return 1;
+		return 1
 	}
-	return 2;
+	return 2
 }
diff --git a/test/fixedbugs/bug122.go b/test/fixedbugs/bug122.go
index fb4eb9f3ad..9ae597462d 100644
--- a/test/fixedbugs/bug122.go
+++ b/test/fixedbugs/bug122.go
@@ -8,5 +8,5 @@ package main
 
 func main() {
 	// should allow at most 2 sizes
-	a := make([]int, 10, 20, 30, 40); // ERROR "too many"
+	a := make([]int, 10, 20, 30, 40) // ERROR "too many"
 }
diff --git a/test/fixedbugs/bug123.go b/test/fixedbugs/bug123.go
index f38551a914..8c4f323761 100644
--- a/test/fixedbugs/bug123.go
+++ b/test/fixedbugs/bug123.go
@@ -5,9 +5,13 @@
 // license that can be found in the LICENSE file.
 
 package main
-const ( F = 1 )
+
+const (
+	F = 1
+)
+
 func fn(i int) int {
-	if i == F() {		// ERROR "func"
+	if i == F() { // ERROR "func"
 		return 0
 	}
 	return 1
diff --git a/test/fixedbugs/bug126.go b/test/fixedbugs/bug126.go
index f5d9763412..8274c1e931 100644
--- a/test/fixedbugs/bug126.go
+++ b/test/fixedbugs/bug126.go
@@ -7,5 +7,5 @@
 package main
 
 // same const identifier declared twice should not be accepted
-const none = 0  // GCCGO_ERROR "previous"
-const none = 1;  // ERROR "redeclared|redef"
+const none = 0 // GCCGO_ERROR "previous"
+const none = 1 // ERROR "redeclared|redef"
diff --git a/test/fixedbugs/bug127.go b/test/fixedbugs/bug127.go
index f8ea99470c..573c40c681 100644
--- a/test/fixedbugs/bug127.go
+++ b/test/fixedbugs/bug127.go
@@ -5,8 +5,9 @@
 // license that can be found in the LICENSE file.
 
 package main
+
 func main() {
-	var x int64 = 0;
-	println(x != nil);	// ERROR "illegal|incompatible|nil"
-	println(0 != nil);	// ERROR "illegal|incompatible|nil"
+	var x int64 = 0
+	println(x != nil) // ERROR "illegal|incompatible|nil"
+	println(0 != nil) // ERROR "illegal|incompatible|nil"
 }
diff --git a/test/fixedbugs/bug128.go b/test/fixedbugs/bug128.go
index e8cbea079f..7389426c57 100644
--- a/test/fixedbugs/bug128.go
+++ b/test/fixedbugs/bug128.go
@@ -5,19 +5,20 @@
 // license that can be found in the LICENSE file.
 
 package main
+
 func main() {
 	switch {
-		// empty switch is allowed according to syntax
-		// unclear why it shouldn't be allowed
+	// empty switch is allowed according to syntax
+	// unclear why it shouldn't be allowed
 	}
 	switch tag := 0; tag {
-		// empty switch is allowed according to syntax
-		// unclear why it shouldn't be allowed
+	// empty switch is allowed according to syntax
+	// unclear why it shouldn't be allowed
 	}
 }
 
 /*
-uetli:~/Source/go1/test/bugs gri$ 6g bug127.go 
+uetli:~/Source/go1/test/bugs gri$ 6g bug127.go
 bug127.go:5: switch statement must have case labels
 bug127.go:9: switch statement must have case labels
 */
diff --git a/test/fixedbugs/bug129.go b/test/fixedbugs/bug129.go
index 157ce78ff7..64666e9377 100644
--- a/test/fixedbugs/bug129.go
+++ b/test/fixedbugs/bug129.go
@@ -5,10 +5,11 @@
 // license that can be found in the LICENSE file.
 
 package foo
+
 import "fmt"
 
 func f() {
-	fmt.Println();
-	fmt := 1;
-	_ = fmt;
+	fmt.Println()
+	fmt := 1
+	_ = fmt
 }
diff --git a/test/fixedbugs/bug130.go b/test/fixedbugs/bug130.go
index 16b029af34..ba38bb5551 100644
--- a/test/fixedbugs/bug130.go
+++ b/test/fixedbugs/bug130.go
@@ -8,15 +8,16 @@ package main
 
 import "os"
 
-type I interface { send(chan <- int) }
+type I interface{ send(chan<- int) }
 
-type S struct { v int }
-func (p *S) send(c chan <- int) { c <- p.v }
+type S struct{ v int }
+
+func (p *S) send(c chan<- int) { c <- p.v }
 
 func main() {
-	s := S{0};
-	var i I = &s;
-	c := make(chan int);
-	go i.send(c);
-	os.Exit(<-c);
+	s := S{0}
+	var i I = &s
+	c := make(chan int)
+	go i.send(c)
+	os.Exit(<-c)
 }
diff --git a/test/fixedbugs/bug131.go b/test/fixedbugs/bug131.go
index 0ebbd26069..de606da167 100644
--- a/test/fixedbugs/bug131.go
+++ b/test/fixedbugs/bug131.go
@@ -7,6 +7,6 @@
 package main
 
 func main() {
-	const a uint64 = 10;
-	var b int64 = a;	// ERROR "convert|cannot|incompatible"
+	const a uint64 = 10
+	var b int64 = a // ERROR "convert|cannot|incompatible"
 }
diff --git a/test/fixedbugs/bug132.go b/test/fixedbugs/bug132.go
index e334566c79..b9b9e6712b 100644
--- a/test/fixedbugs/bug132.go
+++ b/test/fixedbugs/bug132.go
@@ -7,5 +7,5 @@
 package main
 
 type T struct {
-	x, x int  // ERROR "duplicate"
+	x, x int // ERROR "duplicate"
 }
diff --git a/test/fixedbugs/bug133.dir/bug0.go b/test/fixedbugs/bug133.dir/bug0.go
index 19a2bfbd4b..052de3d7ac 100644
--- a/test/fixedbugs/bug133.dir/bug0.go
+++ b/test/fixedbugs/bug133.dir/bug0.go
@@ -4,4 +4,4 @@
 
 package bug0
 
-type T struct { i int }
+type T struct{ i int }
diff --git a/test/fixedbugs/bug133.dir/bug1.go b/test/fixedbugs/bug133.dir/bug1.go
index dd59b2f2ec..d47746e4b5 100644
--- a/test/fixedbugs/bug133.dir/bug1.go
+++ b/test/fixedbugs/bug133.dir/bug1.go
@@ -6,4 +6,4 @@ package bug1
 
 import "./bug0"
 
-type T struct { t bug0.T }
+type T struct{ t bug0.T }
diff --git a/test/fixedbugs/bug133.dir/bug2.go b/test/fixedbugs/bug133.dir/bug2.go
index b6184c2e75..4449ded991 100644
--- a/test/fixedbugs/bug133.dir/bug2.go
+++ b/test/fixedbugs/bug133.dir/bug2.go
@@ -7,10 +7,10 @@ package bug2
 import _ "./bug1"
 import "./bug0"
 
-type T2 struct { t bug0.T }
+type T2 struct{ t bug0.T }
 
 func fn(p *T2) int {
 	// This reference should be invalid, because bug0.T.i is local
 	// to package bug0 and should not be visible in package bug1.
-	return p.t.i;	// ERROR "field|undef"
+	return p.t.i // ERROR "field|undef"
 }
diff --git a/test/fixedbugs/bug135.go b/test/fixedbugs/bug135.go
index 34d234e224..5cca2b252d 100644
--- a/test/fixedbugs/bug135.go
+++ b/test/fixedbugs/bug135.go
@@ -6,14 +6,15 @@
 
 package main
 
-type Foo interface { }
+type Foo interface{}
+
+type T struct{}
 
-type T struct {}
 func (t *T) foo() {}
 
 func main() {
-	t := new(T);
-	var i interface {};
-	f, ok := i.(Foo);
-	_, _, _ = t, f, ok;
+	t := new(T)
+	var i interface{}
+	f, ok := i.(Foo)
+	_, _, _ = t, f, ok
 }
diff --git a/test/fixedbugs/bug136.go b/test/fixedbugs/bug136.go
index bea9bac083..2964176afd 100644
--- a/test/fixedbugs/bug136.go
+++ b/test/fixedbugs/bug136.go
@@ -7,16 +7,18 @@
 package main
 
 func main() {
-	L: ;  // ';' terminates empty statement => L does not apply to for loop
+L:
+	; // ';' terminates empty statement => L does not apply to for loop
 	for i := 0; i < 10; i++ {
-		println(i);
-		break L;  // ERROR "L"
+		println(i)
+		break L // ERROR "L"
 	}
 
-	L1: { // L1 labels block => L1 does not apply to for loop
+L1:
+	{ // L1 labels block => L1 does not apply to for loop
 		for i := 0; i < 10; i++ {
-			println(i);
-			break L1;  // ERROR "L1"
+			println(i)
+			break L1 // ERROR "L1"
 		}
 	}
 }
diff --git a/test/fixedbugs/bug139.go b/test/fixedbugs/bug139.go
index 095e5c93cc..610a2b87a2 100644
--- a/test/fixedbugs/bug139.go
+++ b/test/fixedbugs/bug139.go
@@ -7,9 +7,17 @@
 package main
 
 func main() {
-	x := false;
-	func () { if x          { println(1); } }();  // this does not compile
-	func () { if x == false { println(2); } }();  // this works as expected
+	x := false
+	func() {
+		if x {
+			println(1)
+		}
+	}() // this does not compile
+	func() {
+		if x == false {
+			println(2)
+		}
+	}() // this works as expected
 }
 
 /*
diff --git a/test/fixedbugs/bug141.go b/test/fixedbugs/bug141.go
index 81ba6f1b56..f905681b6a 100644
--- a/test/fixedbugs/bug141.go
+++ b/test/fixedbugs/bug141.go
@@ -8,25 +8,29 @@ package main
 
 import "os"
 
-type S struct { i int }
+type S struct{ i int }
+
 func (p *S) Get() int { return p.i }
 
 type Empty interface {
 }
 
 type Getter interface {
-	Get() int;
+	Get() int
 }
 
 func f1(p Empty) {
 	switch x := p.(type) {
-	default: println("failed to match interface", x); os.Exit(1);
-	case Getter: break;
+	default:
+		println("failed to match interface", x)
+		os.Exit(1)
+	case Getter:
+		break
 	}
 
 }
 
 func main() {
-	var s S;
-	f1(&s);
+	var s S
+	f1(&s)
 }
diff --git a/test/fixedbugs/bug142.go b/test/fixedbugs/bug142.go
index e28d889a93..083b6ac8ac 100644
--- a/test/fixedbugs/bug142.go
+++ b/test/fixedbugs/bug142.go
@@ -7,12 +7,12 @@
 package main
 
 func panic1(s string) bool {
-	panic(s);
+	panic(s)
 }
 
 func main() {
-	x := false && panic1("first") && panic1("second");
-	x = x == true && panic1("first") && panic1("second");
+	x := false && panic1("first") && panic1("second")
+	x = x == true && panic1("first") && panic1("second")
 }
 
 /*
@@ -27,5 +27,5 @@ mainstart+0xf /Users/rsc/goX/src/runtime/amd64/asm.s:53
 	mainstart()
 sys·Goexit /Users/rsc/goX/src/runtime/proc.c:124
 	sys·Goexit()
-; 
+;
 */
diff --git a/test/fixedbugs/bug143.go b/test/fixedbugs/bug143.go
index a43e406676..c4378f27ad 100644
--- a/test/fixedbugs/bug143.go
+++ b/test/fixedbugs/bug143.go
@@ -6,34 +6,34 @@
 
 package main
 
-type myMap map[string] int;
+type myMap map[string]int
 
 func f() myMap {
-	m := make(map[string] int);
+	m := make(map[string]int)
 	return m
 }
 
 func main() {
-	m := make(myMap);
-	mp := &m;
+	m := make(myMap)
+	mp := &m
 
 	{
-		x, ok := m["key"];
-		_, _ = x, ok;
+		x, ok := m["key"]
+		_, _ = x, ok
 	}
 	{
-		x, ok := (*mp)["key"];
-		_, _ = x, ok;
+		x, ok := (*mp)["key"]
+		_, _ = x, ok
 	}
 	{
-		x, ok := f()["key"];
-		_, _ = x, ok;
+		x, ok := f()["key"]
+		_, _ = x, ok
 	}
 	{
-		var x int;
-		var ok bool;
-		x, ok = f()["key"];
-		_, _ = x, ok;
+		var x int
+		var ok bool
+		x, ok = f()["key"]
+		_, _ = x, ok
 	}
 }
 
diff --git a/test/fixedbugs/bug144.go b/test/fixedbugs/bug144.go
index 9f8ec7667c..f42e64ee98 100644
--- a/test/fixedbugs/bug144.go
+++ b/test/fixedbugs/bug144.go
@@ -6,11 +6,11 @@
 
 package main
 
-const c = 1;
+const c = 1
 
 func main() {
-	c := 0;
-	_ = c;
+	c := 0
+	_ = c
 }
 
 /*
diff --git a/test/fixedbugs/bug145.go b/test/fixedbugs/bug145.go
index 602fe7426d..44bce2a610 100644
--- a/test/fixedbugs/bug145.go
+++ b/test/fixedbugs/bug145.go
@@ -9,8 +9,8 @@ package main
 type t int
 
 func main() {
-	t := 0;
-	_ = t;
+	t := 0
+	_ = t
 }
 
 /*
diff --git a/test/fixedbugs/bug146.go b/test/fixedbugs/bug146.go
index e29f910ba5..fcdeb4ce42 100644
--- a/test/fixedbugs/bug146.go
+++ b/test/fixedbugs/bug146.go
@@ -7,9 +7,9 @@
 package main
 
 func main() {
-	type Slice []byte;
-	a := [...]byte{ 0 };
-	b := Slice(a[0:]);	// This should be OK.
-	c := Slice(a);		// ERROR "invalid|illegal|cannot"
-	_, _ = b, c;
+	type Slice []byte
+	a := [...]byte{0}
+	b := Slice(a[0:]) // This should be OK.
+	c := Slice(a)     // ERROR "invalid|illegal|cannot"
+	_, _ = b, c
 }
diff --git a/test/fixedbugs/bug148.go b/test/fixedbugs/bug148.go
index b67870b12a..e7b544439e 100644
--- a/test/fixedbugs/bug148.go
+++ b/test/fixedbugs/bug148.go
@@ -6,32 +6,32 @@
 
 package main
 
-type T struct {a, b int};
+type T struct{ a, b int }
 
-func println(x, y int) { }
+func println(x, y int) {}
 
 func f(x interface{}) interface{} {
-	type T struct {a, b int};
+	type T struct{ a, b int }
 
 	if x == nil {
-		return T{2, 3};
+		return T{2, 3}
 	}
 
-	t := x.(T);
-	println(t.a, t.b);
-	return x;
+	t := x.(T)
+	println(t.a, t.b)
+	return x
 }
 
 func main() {
-	inner_T := f(nil);
-	f(inner_T);
+	inner_T := f(nil)
+	f(inner_T)
 
 	shouldPanic(p1)
 }
 
 func p1() {
-	outer_T := T{5, 7};
-	f(outer_T);
+	outer_T := T{5, 7}
+	f(outer_T)
 }
 
 func shouldPanic(f func()) {
diff --git a/test/fixedbugs/bug149.go b/test/fixedbugs/bug149.go
index 78b687e971..d18c7479ba 100644
--- a/test/fixedbugs/bug149.go
+++ b/test/fixedbugs/bug149.go
@@ -7,16 +7,16 @@
 package main
 
 func main() {
-	var b1 []byte;
-	s1 := string(b1);
-	println(len(s1));  // prints 0
+	var b1 []byte
+	s1 := string(b1)
+	println(len(s1)) // prints 0
 
-	b2 := ([]byte)(nil);
-	s2 := string(b2);
-	println(len(s2));  // prints 0
+	b2 := ([]byte)(nil)
+	s2 := string(b2)
+	println(len(s2)) // prints 0
 
-	s3 := string(([]byte)(nil));  // does not compile (literal substitution of b2)
-	println(len(s3));
+	s3 := string(([]byte)(nil)) // does not compile (literal substitution of b2)
+	println(len(s3))
 }
 
 /*
diff --git a/test/fixedbugs/bug150.go b/test/fixedbugs/bug150.go
index b565ef73dd..b2c4f15dc4 100644
--- a/test/fixedbugs/bug150.go
+++ b/test/fixedbugs/bug150.go
@@ -7,15 +7,16 @@
 package bug150
 
 type T int
+
 func (t T) M()
 
-type M interface { M() } 
+type M interface{ M() }
 
 func g() (T, T)
 
 func f() (a, b M) {
-	a, b = g();
-	return;
+	a, b = g()
+	return
 }
 
 /*
diff --git a/test/fixedbugs/bug151.go b/test/fixedbugs/bug151.go
index d9f5e021c9..87a9c0201d 100644
--- a/test/fixedbugs/bug151.go
+++ b/test/fixedbugs/bug151.go
@@ -8,10 +8,10 @@ package bug151
 
 type S string
 
-type Empty interface {}
+type Empty interface{}
 
 func (v S) Less(e Empty) bool {
-	return v < e.(S);
+	return v < e.(S)
 }
 
 /*
diff --git a/test/fixedbugs/bug152.go b/test/fixedbugs/bug152.go
index 45b9b3d530..2f297656e4 100644
--- a/test/fixedbugs/bug152.go
+++ b/test/fixedbugs/bug152.go
@@ -7,11 +7,11 @@
 package main
 
 func main() {
-	s := 0;
+	s := 0
 	for _, v := range []int{1} {
-		s += v;
+		s += v
 	}
 	if s != 1 {
-		println("BUG: s =", s);
+		println("BUG: s =", s)
 	}
 }
diff --git a/test/fixedbugs/bug154.go b/test/fixedbugs/bug154.go
index a2cfd4accd..3162e80a4f 100644
--- a/test/fixedbugs/bug154.go
+++ b/test/fixedbugs/bug154.go
@@ -9,25 +9,23 @@ package main
 import "fmt"
 
 func f0() string {
-	const f = 3.141592;
-	return fmt.Sprintf("%v", float64(f));
+	const f = 3.141592
+	return fmt.Sprintf("%v", float64(f))
 }
 
-
 func f1() string {
-	const f = 3.141592;
-	x := float64(float32(f));  // appears to change the precision of f
-	_ = x;
-	return fmt.Sprintf("%v", float64(f));
+	const f = 3.141592
+	x := float64(float32(f)) // appears to change the precision of f
+	_ = x
+	return fmt.Sprintf("%v", float64(f))
 }
 
-
 func main() {
-	r0 := f0();
-	r1 := f1();
+	r0 := f0()
+	r1 := f1()
 	if r0 != r1 {
-		println("r0 =", r0);
-		println("r1 =", r1);
-		panic("r0 and r1 should be the same");
+		println("r0 =", r0)
+		println("r1 =", r1)
+		panic("r0 and r1 should be the same")
 	}
 }
diff --git a/test/fixedbugs/bug155.go b/test/fixedbugs/bug155.go
index 8872e978da..ba2f1c04ca 100644
--- a/test/fixedbugs/bug155.go
+++ b/test/fixedbugs/bug155.go
@@ -6,7 +6,7 @@
 
 package main
 
-const big uint64 = 1<<63
+const big uint64 = 1 << 63
 
 func f(a uint64) uint64 {
 	return a << big
diff --git a/test/fixedbugs/bug156.go b/test/fixedbugs/bug156.go
index f26658729f..7b6825fe83 100644
--- a/test/fixedbugs/bug156.go
+++ b/test/fixedbugs/bug156.go
@@ -7,9 +7,9 @@
 package main
 
 func f(a int64) int64 {
-	const b int64 = 0;
-	n := a &^ b;
-	return n;
+	const b int64 = 0
+	n := a &^ b
+	return n
 }
 
 func main() {
diff --git a/test/fixedbugs/bug157.go b/test/fixedbugs/bug157.go
index 1072d7df49..160762c1cc 100644
--- a/test/fixedbugs/bug157.go
+++ b/test/fixedbugs/bug157.go
@@ -9,23 +9,26 @@ package main
 func f() {}
 
 func main() {
-	x := 0;
+	x := 0
 
 	// this compiles
 	switch x {
-	case 0: f();
-	default: f();
+	case 0:
+		f()
+	default:
+		f()
 	}
 
 	// this doesn't but it should
 	// (semicolons are not needed at the end of a statement list)
 	switch x {
-	case 0: f()
-	default: f()
+	case 0:
+		f()
+	default:
+		f()
 	}
 }
 
-
 /*
 bug157.go:20: syntax error near default
 bug157.go:20: first switch statement must be a case
diff --git a/test/fixedbugs/bug158.go b/test/fixedbugs/bug158.go
index 496d7e0db0..3e5c0eab29 100644
--- a/test/fixedbugs/bug158.go
+++ b/test/fixedbugs/bug158.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	x := 0;
+	x := 0
 
 	// this compiles
 	switch x {
@@ -20,7 +20,6 @@ func main() {
 	}
 }
 
-
 /*
 bug158.go:14: fatal error: dowidth: unknown type: E-33
 */
diff --git a/test/fixedbugs/bug159.go b/test/fixedbugs/bug159.go
index 92d5345635..7dd0497135 100644
--- a/test/fixedbugs/bug159.go
+++ b/test/fixedbugs/bug159.go
@@ -9,9 +9,9 @@ package main
 import "os"
 
 func main() {
-	ok := true;
-	var a, b, c, x, y, z int;
-	f := func() int { b--; return -b };
+	ok := true
+	var a, b, c, x, y, z int
+	f := func() int { b--; return -b }
 
 	// this fails on 6g: apparently it rewrites
 	// the list into
@@ -19,21 +19,21 @@ func main() {
 	//	y = f();
 	//	x = f();
 	// so that the values come out backward.
-	x, y, z = f(), f(), f();
+	x, y, z = f(), f(), f()
 	if x != 1 || y != 2 || z != 3 {
-		println("xyz: expected 1 2 3 got", x, y, z);
-		ok = false;
+		println("xyz: expected 1 2 3 got", x, y, z)
+		ok = false
 	}
 
 	// this fails on 6g too.  one of the function calls
 	// happens after assigning to b.
-	a, b, c = f(), f(), f();
+	a, b, c = f(), f(), f()
 	if a != 4 || b != 5 || c != 6 {
-		println("abc: expected 4 5 6 got", a, b, c);
-		ok = false;
+		println("abc: expected 4 5 6 got", a, b, c)
+		ok = false
 	}
 
 	if !ok {
-		os.Exit(1);
+		os.Exit(1)
 	}
 }
diff --git a/test/fixedbugs/bug160.dir/y.go b/test/fixedbugs/bug160.dir/y.go
index 428808dd19..87039c98bc 100644
--- a/test/fixedbugs/bug160.dir/y.go
+++ b/test/fixedbugs/bug160.dir/y.go
@@ -9,11 +9,11 @@ import "./x"
 
 func main() {
 	if x.Zero != 0 {
-		println("x.Zero = ", x.Zero);
-		os.Exit(1);
+		println("x.Zero = ", x.Zero)
+		os.Exit(1)
 	}
 	if x.Ten != 10 {
-		println("x.Ten = ", x.Ten);
-		os.Exit(1);
+		println("x.Ten = ", x.Ten)
+		os.Exit(1)
 	}
 }
diff --git a/test/fixedbugs/bug161.go b/test/fixedbugs/bug161.go
index aab58ee895..bf3c91eb82 100644
--- a/test/fixedbugs/bug161.go
+++ b/test/fixedbugs/bug161.go
@@ -6,10 +6,10 @@
 
 package P
 
-const a = 0;
+const a = 0
 
 func f(a int) {
-	a = 0;
+	a = 0
 }
 
 /*
diff --git a/test/fixedbugs/bug165.go b/test/fixedbugs/bug165.go
index f8d50af13f..487ee992b9 100644
--- a/test/fixedbugs/bug165.go
+++ b/test/fixedbugs/bug165.go
@@ -7,9 +7,9 @@
 package main
 
 type I interface {
-	m(map[I] bool);	// ok
+	m(map[I]bool) // ok
 }
 
 type S struct {
-	m map[S] bool;	// ERROR "map key type"
+	m map[S]bool // ERROR "map key type"
 }
diff --git a/test/fixedbugs/bug170.go b/test/fixedbugs/bug170.go
index 11ff5ff3c7..3255a04b85 100644
--- a/test/fixedbugs/bug170.go
+++ b/test/fixedbugs/bug170.go
@@ -5,10 +5,11 @@
 // license that can be found in the LICENSE file.
 
 package main
-var v1 = ([10]int)(nil);	// ERROR "illegal|nil|invalid"
-var v2 [10]int = nil;		// ERROR "illegal|nil|incompatible"
-var v3 [10]int;
-var v4 = nil;	// ERROR "nil"
+
+var v1 = ([10]int)(nil) // ERROR "illegal|nil|invalid"
+var v2 [10]int = nil    // ERROR "illegal|nil|incompatible"
+var v3 [10]int
+var v4 = nil // ERROR "nil"
 func main() {
-	v3 = nil;		// ERROR "illegal|nil|incompatible"
+	v3 = nil // ERROR "illegal|nil|incompatible"
 }
diff --git a/test/fixedbugs/bug171.go b/test/fixedbugs/bug171.go
index 49bbb3b892..9284b686f4 100644
--- a/test/fixedbugs/bug171.go
+++ b/test/fixedbugs/bug171.go
@@ -6,5 +6,5 @@
 
 package main
 
-func f() int { }	// ERROR "return|control"
-func g() (foo int) { }	// ERROR "return|control"
+func f() int       {} // ERROR "return|control"
+func g() (foo int) {} // ERROR "return|control"
diff --git a/test/fixedbugs/bug172.go b/test/fixedbugs/bug172.go
index 4dbe7930f9..a4ee045ba5 100644
--- a/test/fixedbugs/bug172.go
+++ b/test/fixedbugs/bug172.go
@@ -7,6 +7,6 @@
 package main
 
 func f() {
-	a := true;
-	a |= a;	// ERROR "illegal.*OR|bool|expected"
+	a := true
+	a |= a // ERROR "illegal.*OR|bool|expected"
 }
diff --git a/test/fixedbugs/bug173.go b/test/fixedbugs/bug173.go
index 3515c649bb..20813cec99 100644
--- a/test/fixedbugs/bug173.go
+++ b/test/fixedbugs/bug173.go
@@ -11,9 +11,10 @@
 package main
 
 type T string
+
 func main() {
-	var t T = "hello";
-	println(t[0:4], t[4]);
+	var t T = "hello"
+	println(t[0:4], t[4])
 	for _, _ = range t {
 	}
 	for _ = range t {
diff --git a/test/fixedbugs/bug174.go b/test/fixedbugs/bug174.go
index 448f630867..c06670859d 100644
--- a/test/fixedbugs/bug174.go
+++ b/test/fixedbugs/bug174.go
@@ -7,6 +7,6 @@
 package main
 
 func main() {
-	var x uint;
-	println(1<<x);
+	var x uint
+	println(1 << x)
 }
diff --git a/test/fixedbugs/bug175.go b/test/fixedbugs/bug175.go
index 5fca4b22bc..55a161910b 100644
--- a/test/fixedbugs/bug175.go
+++ b/test/fixedbugs/bug175.go
@@ -9,6 +9,6 @@ package main
 func f() (int, bool) { return 0, true }
 
 func main() {
-	x, y := f(), 2;	// ERROR "multi"
+	x, y := f(), 2 // ERROR "multi"
 	_, _ = x, y
 }
diff --git a/test/fixedbugs/bug176.go b/test/fixedbugs/bug176.go
index ea3a909747..82b6033090 100644
--- a/test/fixedbugs/bug176.go
+++ b/test/fixedbugs/bug176.go
@@ -8,7 +8,6 @@ package main
 
 var x int
 
-var a = []int{ x: 1}	// ERROR "constant"
+var a = []int{x: 1} // ERROR "constant"
 var b = [...]int{x: 1}
-var c = map[int]int{ x: 1}
-
+var c = map[int]int{x: 1}
diff --git a/test/fixedbugs/bug181.go b/test/fixedbugs/bug181.go
index 4827e9cf03..b854cfd7ca 100644
--- a/test/fixedbugs/bug181.go
+++ b/test/fixedbugs/bug181.go
@@ -7,5 +7,5 @@
 package main
 
 type T *struct {
-	T;	// ERROR "embed.*pointer"
+	T // ERROR "embed.*pointer"
 }
diff --git a/test/fixedbugs/bug182.go b/test/fixedbugs/bug182.go
index e02dc59f86..fad2bb612d 100644
--- a/test/fixedbugs/bug182.go
+++ b/test/fixedbugs/bug182.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	x := 0;
-	if x {	// ERROR "x.*int|bool"
+	x := 0
+	if x { // ERROR "x.*int|bool"
 	}
 }
diff --git a/test/fixedbugs/bug183.go b/test/fixedbugs/bug183.go
index dc9f5356e0..d746981dd0 100644
--- a/test/fixedbugs/bug183.go
+++ b/test/fixedbugs/bug183.go
@@ -9,19 +9,18 @@ package main
 type T int
 
 func f() {
-	var x struct { T };
-	var y struct { T T };
-	x = y;	// ERROR "cannot|incompatible"
-	_ = x;
+	var x struct{ T }
+	var y struct{ T T }
+	x = y // ERROR "cannot|incompatible"
+	_ = x
 }
 
-type T1 struct { T }
-type T2 struct { T T }
+type T1 struct{ T }
+type T2 struct{ T T }
 
 func g() {
-	var x T1;
-	var y T2;
-	x = y;	// ERROR "cannot|incompatible"
-	_ = x;
+	var x T1
+	var y T2
+	x = y // ERROR "cannot|incompatible"
+	_ = x
 }
-
diff --git a/test/fixedbugs/bug186.go b/test/fixedbugs/bug186.go
index 5aefd7e5cf..5f37cc4044 100644
--- a/test/fixedbugs/bug186.go
+++ b/test/fixedbugs/bug186.go
@@ -8,10 +8,10 @@ package main
 
 const X = iota
 
-func f(x int) { }
+func f(x int) {}
 
 func main() {
-	f(X);
-	f(iota);	// ERROR "iota"
-	f(X);
+	f(X)
+	f(iota) // ERROR "iota"
+	f(X)
 }
diff --git a/test/fixedbugs/bug187.go b/test/fixedbugs/bug187.go
index 5c3c2bb1e1..fe7c450967 100644
--- a/test/fixedbugs/bug187.go
+++ b/test/fixedbugs/bug187.go
@@ -10,13 +10,13 @@ import "os"
 
 func main() {
 	// This bug doesn't arise with [...]int, or []interface{} or [3]interface{}.
-	a := [...]interface{} { 1, 2, 3 };
-	n := 1;
+	a := [...]interface{}{1, 2, 3}
+	n := 1
 	for _, v := range a {
 		if v.(int) != n {
-			println("BUG:", n, v.(int));
-			os.Exit(0);
+			println("BUG:", n, v.(int))
+			os.Exit(0)
 		}
-		n++;
+		n++
 	}
 }
diff --git a/test/fixedbugs/bug188.go b/test/fixedbugs/bug188.go
index 5506147894..8d5a58928b 100644
--- a/test/fixedbugs/bug188.go
+++ b/test/fixedbugs/bug188.go
@@ -9,7 +9,7 @@ package main
 import "sort"
 
 func main() {
-	sort.Sort(nil);
-	var x int;
-	sort(x);	// ERROR "package"
+	sort.Sort(nil)
+	var x int
+	sort(x) // ERROR "package"
 }
diff --git a/test/fixedbugs/bug189.go b/test/fixedbugs/bug189.go
index 9e412c66d8..cde34c14ba 100644
--- a/test/fixedbugs/bug189.go
+++ b/test/fixedbugs/bug189.go
@@ -11,8 +11,8 @@ type S struct {
 }
 
 func main() {
-	s1 := S{a: 7};	// ok - field is named
-	s3 := S{7, 11};	// ok - all fields have values
-	s2 := S{7};	// ERROR "too few"
-	_, _, _ = s1, s3, s2;
+	s1 := S{a: 7}  // ok - field is named
+	s3 := S{7, 11} // ok - all fields have values
+	s2 := S{7}     // ERROR "too few"
+	_, _, _ = s1, s3, s2
 }
diff --git a/test/fixedbugs/bug190.go b/test/fixedbugs/bug190.go
index bb2d81cbb9..4442609c47 100644
--- a/test/fixedbugs/bug190.go
+++ b/test/fixedbugs/bug190.go
@@ -7,20 +7,20 @@
 package main
 
 type S struct {
-	p *S;
-	s []S;
-	m map[int] S;
-	c chan S;
-	i interface { f(S); };
-	f func(S) S;
+	p *S
+	s []S
+	m map[int]S
+	c chan S
+	i interface{ f(S) }
+	f func(S) S
 }
 
 func main() {
-	var s S;
-	s.p = &s;
-	s.s = make([]S, 1);
-	s.s[0] = s;
-	s.m[0] = s;
-	s.c <- s;
-	s.i.f(s);
+	var s S
+	s.p = &s
+	s.s = make([]S, 1)
+	s.s[0] = s
+	s.m[0] = s
+	s.c <- s
+	s.i.f(s)
 }
diff --git a/test/fixedbugs/bug191.dir/a.go b/test/fixedbugs/bug191.dir/a.go
index 139a8a3a23..b39256b9b9 100644
--- a/test/fixedbugs/bug191.dir/a.go
+++ b/test/fixedbugs/bug191.dir/a.go
@@ -10,5 +10,4 @@ func init() {
 	A = 1
 }
 
-type T int;
-
+type T int
diff --git a/test/fixedbugs/bug191.dir/b.go b/test/fixedbugs/bug191.dir/b.go
index 36770f6fc9..1af37e1353 100644
--- a/test/fixedbugs/bug191.dir/b.go
+++ b/test/fixedbugs/bug191.dir/b.go
@@ -10,4 +10,4 @@ func init() {
 	B = 2
 }
 
-type V int;
+type V int
diff --git a/test/fixedbugs/bug192.go b/test/fixedbugs/bug192.go
index 679aaed1f2..fd22e87dee 100644
--- a/test/fixedbugs/bug192.go
+++ b/test/fixedbugs/bug192.go
@@ -6,6 +6,6 @@
 
 package main
 
-import "fmt"	// GCCGO_ERROR "previous"
+import "fmt" // GCCGO_ERROR "previous"
 
-var fmt int	// ERROR "redecl|redefinition"
+var fmt int // ERROR "redecl|redefinition"
diff --git a/test/fixedbugs/bug195.go b/test/fixedbugs/bug195.go
index 8d392bda71..660f20a5b2 100644
--- a/test/fixedbugs/bug195.go
+++ b/test/fixedbugs/bug195.go
@@ -6,22 +6,22 @@
 
 package main
 
-type I1 interface { I2 }	// ERROR "interface"
+type I1 interface{ I2 } // ERROR "interface"
 type I2 int
 
-type I3 interface { int }	// ERROR "interface"
+type I3 interface{ int } // ERROR "interface"
 
 type S struct {
-	x interface{ S }	// ERROR "interface"
+	x interface{ S } // ERROR "interface"
 }
 type I4 interface { // GC_ERROR "invalid recursive type"
-	I4	// GCCGO_ERROR "interface"
+	I4 // GCCGO_ERROR "interface"
 }
 
 type I5 interface {
-	I6	// GCCGO_ERROR "interface"
+	I6 // GCCGO_ERROR "interface"
 }
 
 type I6 interface { // GC_ERROR "invalid recursive type"
-	I5	// GCCGO_ERROR "interface"
+	I5 // GCCGO_ERROR "interface"
 }
diff --git a/test/fixedbugs/bug197.go b/test/fixedbugs/bug197.go
index 4a9f103ea0..bbeece81b1 100644
--- a/test/fixedbugs/bug197.go
+++ b/test/fixedbugs/bug197.go
@@ -11,18 +11,19 @@ type U int
 
 var x int
 
-var t T = int(0)	// ERROR "cannot use|incompatible"
-var t1 T = int(x)	// ERROR "cannot use|incompatible"
-var u U = int(0)	// ERROR "cannot use|incompatible"
-var u1 U = int(x)	// ERROR "cannot use|incompatible"
+var t T = int(0)  // ERROR "cannot use|incompatible"
+var t1 T = int(x) // ERROR "cannot use|incompatible"
+var u U = int(0)  // ERROR "cannot use|incompatible"
+var u1 U = int(x) // ERROR "cannot use|incompatible"
 
 type S string
+
 var s S
 
 var s1 = s + "hello"
 var s2 = "hello" + s
-var s3 = s + string("hello")	// ERROR "invalid operation|incompatible"
-var s4 = string("hello") + s	// ERROR "invalid operation|incompatible"
+var s3 = s + string("hello") // ERROR "invalid operation|incompatible"
+var s4 = string("hello") + s // ERROR "invalid operation|incompatible"
 
 var r string
 
@@ -30,4 +31,3 @@ var r1 = r + "hello"
 var r2 = "hello" + r
 var r3 = r + string("hello")
 var r4 = string("hello") + r
-
diff --git a/test/fixedbugs/bug198.go b/test/fixedbugs/bug198.go
index 73bb64688a..7f13234400 100644
--- a/test/fixedbugs/bug198.go
+++ b/test/fixedbugs/bug198.go
@@ -5,8 +5,9 @@
 // license that can be found in the LICENSE file.
 
 package main
-func f(a T) T { return a }	// ERROR "undefined"
+
+func f(a T) T { return a } // ERROR "undefined"
 func main() {
-	x := f(0);
-	_ = x;
+	x := f(0)
+	_ = x
 }
diff --git a/test/fixedbugs/bug200.go b/test/fixedbugs/bug200.go
index da628faf5d..c4d71893cc 100644
--- a/test/fixedbugs/bug200.go
+++ b/test/fixedbugs/bug200.go
@@ -11,9 +11,9 @@ func main() {
 	// hash codes so it missed the duplication
 	// and worse, compiled the wrong code
 	// for one of them.
-	var x interface{};
+	var x interface{}
 	switch x.(type) {
 	case func(int):
-	case func(f int):	// ERROR "duplicate"
+	case func(f int): // ERROR "duplicate"
 	}
 }
diff --git a/test/fixedbugs/bug202.go b/test/fixedbugs/bug202.go
index 49871e3e06..892501e5d4 100644
--- a/test/fixedbugs/bug202.go
+++ b/test/fixedbugs/bug202.go
@@ -5,12 +5,11 @@
 // license that can be found in the LICENSE file.
 
 package main
+
 func f() {
-	v := [...]string{"a", "b"};
-	_ = v;
+	v := [...]string{"a", "b"}
+	_ = v
 }
 func main() {
-	f();
+	f()
 }
-
-
diff --git a/test/fixedbugs/bug203.go b/test/fixedbugs/bug203.go
index 68647ec372..b3917c453f 100644
--- a/test/fixedbugs/bug203.go
+++ b/test/fixedbugs/bug203.go
@@ -8,11 +8,9 @@ package main
 
 var s [8]string
 
-func
-init() {
-       s = [...]string{ "now", "is", "the", "time", "to", "fix", "this", "bug"}
+func init() {
+	s = [...]string{"now", "is", "the", "time", "to", "fix", "this", "bug"}
 }
 
-func
-main() {
+func main() {
 }
diff --git a/test/fixedbugs/bug205.go b/test/fixedbugs/bug205.go
index 1e0d9d1f34..b6e54a9adf 100644
--- a/test/fixedbugs/bug205.go
+++ b/test/fixedbugs/bug205.go
@@ -7,12 +7,11 @@
 package main
 
 var t []int
-var s string;
-var m map[string]int;
+var s string
+var m map[string]int
 
 func main() {
-	println(t["hi"]); // ERROR "non-integer slice index|must be integer"
-	println(s["hi"]); // ERROR "non-integer string index|must be integer"
-	println(m[0]);    // ERROR "cannot use.*as type string"
+	println(t["hi"]) // ERROR "non-integer slice index|must be integer"
+	println(s["hi"]) // ERROR "non-integer string index|must be integer"
+	println(m[0])    // ERROR "cannot use.*as type string"
 }
-
diff --git a/test/fixedbugs/bug206.go b/test/fixedbugs/bug206.go
index 91efa3ff79..7f35f15ecb 100644
--- a/test/fixedbugs/bug206.go
+++ b/test/fixedbugs/bug206.go
@@ -6,28 +6,25 @@
 
 package main
 
-import "go/ast";
+import "go/ast"
 
 func g(list []ast.Expr) {
-	n := len(list)-1;
-	println(list[n].Pos());
+	n := len(list) - 1
+	println(list[n].Pos())
 }
 
-
 // f is the same as g except that the expression assigned to n is inlined.
 func f(list []ast.Expr) {
 	// n := len(list)-1;
-	println(list[len(list)-1 /* n */].Pos());
+	println(list[len(list)-1 /* n */].Pos())
 }
 
-
 func main() {
-	list := []ast.Expr{&ast.Ident{}};
-	g(list);  // this works
-	f(list);  // this doesn't
+	list := []ast.Expr{&ast.Ident{}}
+	g(list) // this works
+	f(list) // this doesn't
 }
 
-
 /*
 0
 throw: index out of range
diff --git a/test/fixedbugs/bug207.go b/test/fixedbugs/bug207.go
index 50923df1c2..4a6d5b19b8 100644
--- a/test/fixedbugs/bug207.go
+++ b/test/fixedbugs/bug207.go
@@ -12,12 +12,12 @@ package main
 import "fmt"
 
 type T struct {
-	a, b, c, d, e []int;
+	a, b, c, d, e []int
 }
 
 var t T
 
 func main() {
-	if fmt.Sprint("xxx", t) != "yyy" { 
+	if fmt.Sprint("xxx", t) != "yyy" {
 	}
 }
diff --git a/test/fixedbugs/bug208.go b/test/fixedbugs/bug208.go
index 09ec0afbed..d9def8ea3d 100644
--- a/test/fixedbugs/bug208.go
+++ b/test/fixedbugs/bug208.go
@@ -6,15 +6,13 @@
 
 package main
 
-type	T struct
-{
-	f int;
+type T struct {
+	f int
 }
 
 // 6g used to get confused by the f:1 above
 // and allow uses of f that would be silently
 // dropped during the compilation.
-var _ = f;	// ERROR "undefined"
+var _ = f // ERROR "undefined"
 
 var _ = T{f: 1}
-
diff --git a/test/fixedbugs/bug209.go b/test/fixedbugs/bug209.go
index 52faf1fb92..6b5fad99da 100644
--- a/test/fixedbugs/bug209.go
+++ b/test/fixedbugs/bug209.go
@@ -7,8 +7,8 @@
 package main
 
 func main() {
-	var buf [10]int;
-	for ; len(buf); {  // ERROR "bool"
+	var buf [10]int
+	for len(buf) { // ERROR "bool"
 	}
 }
 
diff --git a/test/fixedbugs/bug211.go b/test/fixedbugs/bug211.go
index b150479276..b18887292d 100644
--- a/test/fixedbugs/bug211.go
+++ b/test/fixedbugs/bug211.go
@@ -6,9 +6,12 @@
 
 package main
 
-type R interface { duplicate() }
-type S interface { duplicate() }
-type T interface { R; S }	// ERROR "duplicate"
+type R interface{ duplicate() }
+type S interface{ duplicate() }
+type T interface {
+	R
+	S
+} // ERROR "duplicate"
 
 func main() {
 }
diff --git a/test/fixedbugs/bug212.go b/test/fixedbugs/bug212.go
index 4e58b91ec0..b3c8b1598e 100644
--- a/test/fixedbugs/bug212.go
+++ b/test/fixedbugs/bug212.go
@@ -5,8 +5,10 @@
 // license that can be found in the LICENSE file.
 
 package main
+
 type I int
-type S struct { f map[I]int }
-var v1 = S{ make(map[int]int) }		// ERROR "cannot|illegal|incompatible|wrong"
-var v2 map[I]int = map[int]int{}	// ERROR "cannot|illegal|incompatible|wrong"
-var v3 = S{ make(map[uint]int) }	// ERROR "cannot|illegal|incompatible|wrong"
+type S struct{ f map[I]int }
+
+var v1 = S{make(map[int]int)}    // ERROR "cannot|illegal|incompatible|wrong"
+var v2 map[I]int = map[int]int{} // ERROR "cannot|illegal|incompatible|wrong"
+var v3 = S{make(map[uint]int)}   // ERROR "cannot|illegal|incompatible|wrong"
diff --git a/test/fixedbugs/bug213.go b/test/fixedbugs/bug213.go
index 7f4786b52b..adb9b756d2 100644
--- a/test/fixedbugs/bug213.go
+++ b/test/fixedbugs/bug213.go
@@ -5,12 +5,13 @@
 // license that can be found in the LICENSE file.
 
 package main
+
 func main() {
-	var v interface{} = 0;
+	var v interface{} = 0
 	switch v.(type) {
 	case int:
-		fallthrough;		// ERROR "fallthrough"
+		fallthrough // ERROR "fallthrough"
 	default:
-		panic("fell through");
+		panic("fell through")
 	}
 }
diff --git a/test/fixedbugs/bug214.go b/test/fixedbugs/bug214.go
index f3c25e727f..ac4df4010d 100644
--- a/test/fixedbugs/bug214.go
+++ b/test/fixedbugs/bug214.go
@@ -10,6 +10,6 @@
 package main
 
 func main() {
-	x := make(map[int]int, 10);
-	x[0], x[1] = 2, 6;
+	x := make(map[int]int, 10)
+	x[0], x[1] = 2, 6
 }
diff --git a/test/fixedbugs/bug215.go b/test/fixedbugs/bug215.go
index b27cc7db1a..16bfb15979 100644
--- a/test/fixedbugs/bug215.go
+++ b/test/fixedbugs/bug215.go
@@ -9,6 +9,6 @@
 
 package main
 
-type A struct {	a A }	// ERROR "recursive"
-func foo()		{ new(A).bar() }
-func (a A) bar()	{}
+type A struct{ a A } // ERROR "recursive"
+func foo()           { new(A).bar() }
+func (a A) bar()     {}
diff --git a/test/fixedbugs/bug216.go b/test/fixedbugs/bug216.go
index 470369a6a8..25b777fb5a 100644
--- a/test/fixedbugs/bug216.go
+++ b/test/fixedbugs/bug216.go
@@ -9,7 +9,7 @@
 
 package main
 
-func complexSqrt(i int) (int, int)	{ return 0, 1 }
+func complexSqrt(i int) (int, int) { return 0, 1 }
 
 var re, im = complexSqrt(-1)
 
diff --git a/test/fixedbugs/bug217.go b/test/fixedbugs/bug217.go
index ea836b9b6d..5e89310439 100644
--- a/test/fixedbugs/bug217.go
+++ b/test/fixedbugs/bug217.go
@@ -9,9 +9,8 @@
 
 package main
 
-func () x()	// ERROR "no receiver"
+func () x() // ERROR "no receiver"
 
-func (a b, c d) x()	// ERROR "multiple receiver"
+func (a b, c d) x() // ERROR "multiple receiver"
 
 type b int
-
diff --git a/test/fixedbugs/bug218.go b/test/fixedbugs/bug218.go
index f159f05fa8..85bc38e49b 100644
--- a/test/fixedbugs/bug218.go
+++ b/test/fixedbugs/bug218.go
@@ -10,7 +10,7 @@
 package main
 
 func main() {
-	bar := make(chan bool);
+	bar := make(chan bool)
 	select {
 	case _ = <-bar:
 		return
@@ -18,6 +18,6 @@ func main() {
 }
 
 /*
-6g bug218.go 
+6g bug218.go
 <epoch>: fatal error: dowidth: unknown type: blank
 */
diff --git a/test/fixedbugs/bug219.go b/test/fixedbugs/bug219.go
index 290c691eab..0d5afd70f5 100644
--- a/test/fixedbugs/bug219.go
+++ b/test/fixedbugs/bug219.go
@@ -12,9 +12,10 @@ func f(func()) int { return 0 }
 // bug219.go:16: syntax error near if
 func g1() {
 	if x := f(func() {
-		if true {}
+		if true {
+		}
 	}); true {
-		_ = x;
+		_ = x
 	}
 }
 
@@ -23,16 +24,17 @@ func g2() {
 	if x := f(func() {
 		//if true {}
 	}); true {
-		_ = x;
+		_ = x
 	}
 }
 
 // this works
 func g3() {
 	x := f(func() {
-		if true {}
-	});
+		if true {
+		}
+	})
 	if true {
-		_ = x;
+		_ = x
 	}
 }
diff --git a/test/fixedbugs/bug222.dir/chanbug.go b/test/fixedbugs/bug222.dir/chanbug.go
index 16920246e0..75332d86c4 100644
--- a/test/fixedbugs/bug222.dir/chanbug.go
+++ b/test/fixedbugs/bug222.dir/chanbug.go
@@ -3,7 +3,8 @@
 // license that can be found in the LICENSE file
 
 package chanbug
+
 var C chan<- (chan int)
 var D chan<- func()
 var E func() chan int
-var F func() (func())
+var F func() func()
diff --git a/test/fixedbugs/bug222.dir/chanbug2.go b/test/fixedbugs/bug222.dir/chanbug2.go
index 109581dc30..f481082ede 100644
--- a/test/fixedbugs/bug222.dir/chanbug2.go
+++ b/test/fixedbugs/bug222.dir/chanbug2.go
@@ -3,4 +3,5 @@
 // license that can be found in the LICENSE file
 
 package Bar
+
 import _ "chanbug"
diff --git a/test/fixedbugs/bug224.go b/test/fixedbugs/bug224.go
index d2fd67cf32..107924a6ae 100644
--- a/test/fixedbugs/bug224.go
+++ b/test/fixedbugs/bug224.go
@@ -6,5 +6,4 @@
 
 package main
 
-type T T		// ERROR "recursive"
-
+type T T // ERROR "recursive"
diff --git a/test/fixedbugs/bug225.go b/test/fixedbugs/bug225.go
index 1bda9ab4b6..42c432c845 100644
--- a/test/fixedbugs/bug225.go
+++ b/test/fixedbugs/bug225.go
@@ -6,17 +6,17 @@
 
 package main
 
-func main() {	
-	c := make(chan bool, 1);
+func main() {
+	c := make(chan bool, 1)
 	select {
 	case _ = <-c:
-		panic("BUG: recv should not");
+		panic("BUG: recv should not")
 	default:
 	}
-	c <- true;
+	c <- true
 	select {
 	case _ = <-c:
 	default:
-		panic("BUG: recv should");
+		panic("BUG: recv should")
 	}
 }
diff --git a/test/fixedbugs/bug229.go b/test/fixedbugs/bug229.go
index 4baf65e48b..2dd10c2dac 100644
--- a/test/fixedbugs/bug229.go
+++ b/test/fixedbugs/bug229.go
@@ -10,11 +10,11 @@ import "testing"
 
 func main() {
 	var t testing.T
-	
+
 	// make sure error mentions that
 	// name is unexported, not just "name not found".
 
-	t.common.name = nil	// ERROR "unexported"
-	
-	println(testing.anyLowercaseName("asdf"))	// ERROR "unexported" "undefined: testing.anyLowercaseName"
+	t.common.name = nil // ERROR "unexported"
+
+	println(testing.anyLowercaseName("asdf")) // ERROR "unexported" "undefined: testing.anyLowercaseName"
 }
diff --git a/test/fixedbugs/bug231.go b/test/fixedbugs/bug231.go
index f64ddc3e75..8b054edebd 100644
--- a/test/fixedbugs/bug231.go
+++ b/test/fixedbugs/bug231.go
@@ -6,17 +6,18 @@
 
 package main
 
-type I interface { m() }
-type T struct { m func() }
-type M struct {}
+type I interface{ m() }
+type T struct{ m func() }
+type M struct{}
+
 func (M) m() {}
 
 func main() {
 	var t T
 	var m M
 	var i I
-	
+
 	i = m
-	i = t	// ERROR "not a method|has no methods" "does not implement I"
+	i = t // ERROR "not a method|has no methods" "does not implement I"
 	_ = i
 }
diff --git a/test/fixedbugs/bug232.go b/test/fixedbugs/bug232.go
index 10b0c521a4..d7a33a24e5 100644
--- a/test/fixedbugs/bug232.go
+++ b/test/fixedbugs/bug232.go
@@ -5,4 +5,5 @@
 // license that can be found in the LICENSE file.
 
 package bug232
-type I interface { X(...int) }
+
+type I interface{ X(...int) }
diff --git a/test/fixedbugs/bug233.go b/test/fixedbugs/bug233.go
index d4e1e07816..9f2d8d1e3d 100644
--- a/test/fixedbugs/bug233.go
+++ b/test/fixedbugs/bug233.go
@@ -5,6 +5,8 @@
 // license that can be found in the LICENSE file.
 
 package bug233
+
 import p "fmt"
+
 var _ = p.Print
 var fmt = 10
diff --git a/test/fixedbugs/bug235.go b/test/fixedbugs/bug235.go
index a33092bdb6..8dcebca66e 100644
--- a/test/fixedbugs/bug235.go
+++ b/test/fixedbugs/bug235.go
@@ -14,4 +14,3 @@ type T struct {
 
 var p *T
 var v = *p
-
diff --git a/test/fixedbugs/bug237.go b/test/fixedbugs/bug237.go
index 75d6132df9..f736b9a93d 100644
--- a/test/fixedbugs/bug237.go
+++ b/test/fixedbugs/bug237.go
@@ -9,6 +9,7 @@ package main
 import "fmt"
 
 var indent uint = 10
+
 func main() {
 	const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " +
 		". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
diff --git a/test/fixedbugs/bug238.go b/test/fixedbugs/bug238.go
index cc47189e16..3b5995dd77 100644
--- a/test/fixedbugs/bug238.go
+++ b/test/fixedbugs/bug238.go
@@ -18,4 +18,3 @@ const g interface{} = 7 // ERROR "constant|wrong|invalid"
 const h bool = false
 const i int = 2
 const j float64 = 5
-
diff --git a/test/fixedbugs/bug240.go b/test/fixedbugs/bug240.go
index 478b5b2eaf..ae9dc35062 100644
--- a/test/fixedbugs/bug240.go
+++ b/test/fixedbugs/bug240.go
@@ -6,7 +6,7 @@
 
 package main
 
-import . "unsafe"	// ERROR "not used"
+import . "unsafe" // ERROR "not used"
 
 func main() {
 	var x int
diff --git a/test/fixedbugs/bug241.go b/test/fixedbugs/bug241.go
index 1f4440147b..ab7d0ce643 100644
--- a/test/fixedbugs/bug241.go
+++ b/test/fixedbugs/bug241.go
@@ -7,5 +7,5 @@
 package main
 
 const c = 3
-var x = c.String()	// ERROR "String"
 
+var x = c.String() // ERROR "String"
diff --git a/test/fixedbugs/bug245.go b/test/fixedbugs/bug245.go
index adf62f98b5..9763349e25 100644
--- a/test/fixedbugs/bug245.go
+++ b/test/fixedbugs/bug245.go
@@ -7,6 +7,7 @@
 package main
 
 type T []int
+
 func (t T) m()
 
 func main() {
diff --git a/test/fixedbugs/bug249.go b/test/fixedbugs/bug249.go
index ec9699a894..1de59536bd 100644
--- a/test/fixedbugs/bug249.go
+++ b/test/fixedbugs/bug249.go
@@ -6,34 +6,34 @@
 
 package main
 
-var c1 chan <- chan int = (chan<- (chan int))(nil)
-var c2 chan <- chan int = (chan (<-chan int))(nil)  // ERROR "chan|incompatible"
-var c3 <- chan chan int = (<-chan (chan int))(nil)
-var c4 chan chan <- int = (chan (chan<- int))(nil)
-
-var c5 <- chan <- chan int = (<-chan (<-chan int))(nil)
-var c6 chan <- <- chan int = (chan<- (<-chan int))(nil)
-var c7 chan <- chan <- int = (chan<- (chan<- int))(nil)
-
-var c8 <- chan <- chan chan int = (<-chan (<-chan (chan int)))(nil)
-var c9 <- chan chan <- chan int = (<-chan (chan<- (chan int)))(nil)
-var c10 chan <- <- chan chan int = (chan<- (<-chan (chan int)))(nil)
-var c11 chan <- chan <- chan int = (chan<- (chan<- (chan int)))(nil)
-var c12 chan chan <- <- chan int = (chan (chan<- (<-chan int)))(nil)
-var c13 chan chan <- chan <- int = (chan (chan<- (chan<- int)))(nil)
-
-var r1 chan<- (chan int) = (chan <- chan int)(nil)
-var r2 chan (<-chan int) = (chan <- chan int)(nil)  // ERROR "chan|incompatible"
-var r3 <-chan (chan int) = (<- chan chan int)(nil)
-var r4 chan (chan<- int) = (chan chan <- int)(nil)
-
-var r5 <-chan (<-chan int) = (<- chan <- chan int)(nil)
-var r6 chan<- (<-chan int) = (chan <- <- chan int)(nil)
-var r7 chan<- (chan<- int) = (chan <- chan <- int)(nil)
-
-var r8 <-chan (<-chan (chan int)) = (<- chan <- chan chan int)(nil)
-var r9 <-chan (chan<- (chan int)) = (<- chan chan <- chan int)(nil)
-var r10 chan<- (<-chan (chan int)) = (chan <- <- chan chan int)(nil)
-var r11 chan<- (chan<- (chan int)) = (chan <- chan <- chan int)(nil)
-var r12 chan (chan<- (<-chan int)) = (chan chan <- <- chan int)(nil)
-var r13 chan (chan<- (chan<- int)) = (chan chan <- chan <- int)(nil)
+var c1 chan<- chan int = (chan<- (chan int))(nil)
+var c2 chan<- chan int = (chan (<-chan int))(nil) // ERROR "chan|incompatible"
+var c3 <-chan chan int = (<-chan (chan int))(nil)
+var c4 chan chan<- int = (chan (chan<- int))(nil)
+
+var c5 <-chan <-chan int = (<-chan (<-chan int))(nil)
+var c6 chan<- <-chan int = (chan<- (<-chan int))(nil)
+var c7 chan<- chan<- int = (chan<- (chan<- int))(nil)
+
+var c8 <-chan <-chan chan int = (<-chan (<-chan (chan int)))(nil)
+var c9 <-chan chan<- chan int = (<-chan (chan<- (chan int)))(nil)
+var c10 chan<- <-chan chan int = (chan<- (<-chan (chan int)))(nil)
+var c11 chan<- chan<- chan int = (chan<- (chan<- (chan int)))(nil)
+var c12 chan chan<- <-chan int = (chan (chan<- (<-chan int)))(nil)
+var c13 chan chan<- chan<- int = (chan (chan<- (chan<- int)))(nil)
+
+var r1 chan<- (chan int) = (chan<- chan int)(nil)
+var r2 chan (<-chan int) = (chan<- chan int)(nil) // ERROR "chan|incompatible"
+var r3 <-chan (chan int) = (<-chan chan int)(nil)
+var r4 chan (chan<- int) = (chan chan<- int)(nil)
+
+var r5 <-chan (<-chan int) = (<-chan <-chan int)(nil)
+var r6 chan<- (<-chan int) = (chan<- <-chan int)(nil)
+var r7 chan<- (chan<- int) = (chan<- chan<- int)(nil)
+
+var r8 <-chan (<-chan (chan int)) = (<-chan <-chan chan int)(nil)
+var r9 <-chan (chan<- (chan int)) = (<-chan chan<- chan int)(nil)
+var r10 chan<- (<-chan (chan int)) = (chan<- <-chan chan int)(nil)
+var r11 chan<- (chan<- (chan int)) = (chan<- chan<- chan int)(nil)
+var r12 chan (chan<- (<-chan int)) = (chan chan<- <-chan int)(nil)
+var r13 chan (chan<- (chan<- int)) = (chan chan<- chan<- int)(nil)
diff --git a/test/fixedbugs/bug251.go b/test/fixedbugs/bug251.go
index 05e111a61f..a0c04319b3 100644
--- a/test/fixedbugs/bug251.go
+++ b/test/fixedbugs/bug251.go
@@ -19,7 +19,6 @@ type I2 interface {
 	I1 // GCCGO_ERROR "loop|interface"
 }
 
-
 var i1 I1 = i2
 var i2 I2
 var i2a I2 = i1
diff --git a/test/fixedbugs/bug252.go b/test/fixedbugs/bug252.go
index f678925fbb..19b37b00d0 100644
--- a/test/fixedbugs/bug252.go
+++ b/test/fixedbugs/bug252.go
@@ -11,5 +11,5 @@ func f(args ...int) {
 }
 
 func g(args ...interface{}) {
-	f(args)	// ERROR "cannot use|incompatible"
+	f(args) // ERROR "cannot use|incompatible"
 }
diff --git a/test/fixedbugs/bug256.go b/test/fixedbugs/bug256.go
index 705a0321b4..3a6df90969 100644
--- a/test/fixedbugs/bug256.go
+++ b/test/fixedbugs/bug256.go
@@ -6,11 +6,9 @@
 
 package main
 
-type T U	// bogus "invalid recursive type T" from 6g
+type T U // bogus "invalid recursive type T" from 6g
 type U int
 
 const x T = 123
 
-type V V	// ERROR "invalid recursive type"
-
-
+type V V // ERROR "invalid recursive type"
diff --git a/test/fixedbugs/bug258.go b/test/fixedbugs/bug258.go
index 075da87577..d4b993ab00 100644
--- a/test/fixedbugs/bug258.go
+++ b/test/fixedbugs/bug258.go
@@ -25,7 +25,7 @@ func main() {
 		} else {
 			println("BUG 2")
 		}
-		
+
 		if math.Pow(2, 3) != 8 {
 			println("BUG 3")
 		}
diff --git a/test/fixedbugs/bug259.go b/test/fixedbugs/bug259.go
index 857b442010..4946a3d4dc 100644
--- a/test/fixedbugs/bug259.go
+++ b/test/fixedbugs/bug259.go
@@ -9,7 +9,7 @@ package main
 import "fmt"
 
 var x = uint32(0x01020304)
-var y = [...]uint32{1,2,3,4,5}
+var y = [...]uint32{1, 2, 3, 4, 5}
 
 func main() {
 	fmt.Sprint(y[byte(x)])
diff --git a/test/fixedbugs/bug261.go b/test/fixedbugs/bug261.go
index abe6431b51..3645d27d05 100644
--- a/test/fixedbugs/bug261.go
+++ b/test/fixedbugs/bug261.go
@@ -14,7 +14,7 @@ func f() int {
 }
 
 func main() {
-	x := []int{0,1,2,3,4,5,6,7,8,9,10}
+	x := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 	n = 5
 	y := x[f():f()]
 	if len(y) != 1 || y[0] != 6 {
diff --git a/test/fixedbugs/bug266.go b/test/fixedbugs/bug266.go
index 5d2334c05a..b51c5acdad 100644
--- a/test/fixedbugs/bug266.go
+++ b/test/fixedbugs/bug266.go
@@ -13,12 +13,12 @@ func f() int {
 	panic("oops")
 }
 
-func g() int {	
+func g() int {
 	return 12345
 }
 
 func main() {
-	g()	// leave 12345 on stack
+	g() // leave 12345 on stack
 	x := f()
 	if x != 0 {
 		panic(x)
diff --git a/test/fixedbugs/bug269.go b/test/fixedbugs/bug269.go
index ec0dbc6c34..4241faf9b5 100644
--- a/test/fixedbugs/bug269.go
+++ b/test/fixedbugs/bug269.go
@@ -13,6 +13,6 @@ func f() (ok bool) { return false }
 func main() {
 	var i interface{}
 	i = f
-	_ = i.(func()bool)
-	_ = i.(func()(bool))
+	_ = i.(func() bool)
+	_ = i.(func() bool)
 }
diff --git a/test/fixedbugs/bug271.go b/test/fixedbugs/bug271.go
index a6abbfef7e..d285f29be0 100644
--- a/test/fixedbugs/bug271.go
+++ b/test/fixedbugs/bug271.go
@@ -14,7 +14,7 @@ func f() (int, int) { return 1, 2 }
 
 func main() {
 	s := fmt.Sprint(f())
-	if s != "1 2" {	// with bug, was "{1 2}"
+	if s != "1 2" { // with bug, was "{1 2}"
 		println("BUG")
 	}
 }
diff --git a/test/fixedbugs/bug272.go b/test/fixedbugs/bug272.go
index 6b8862f697..ca39cbb4ce 100644
--- a/test/fixedbugs/bug272.go
+++ b/test/fixedbugs/bug272.go
@@ -8,15 +8,15 @@
 
 package main
 
-func main() {	
+func main() {
 	n := int64(100)
 	x := make([]int, n)
-	x[99] = 234;	
+	x[99] = 234
 	z := x[n-1]
 	if z != 234 {
 		println("BUG")
 	}
-	n |= 1<<32
+	n |= 1 << 32
 	defer func() {
 		recover()
 	}()
diff --git a/test/fixedbugs/bug276.go b/test/fixedbugs/bug276.go
index dc2308ea6b..a9af72cf63 100644
--- a/test/fixedbugs/bug276.go
+++ b/test/fixedbugs/bug276.go
@@ -13,10 +13,10 @@ func main() {
 	x := 0
 
 	a := (x & 1) << uint(1-i)
-	
-	s := uint(1-i)
+
+	s := uint(1 - i)
 	b := (x & 1) << s
-	
+
 	if a != b {
 		panic(0)
 	}
diff --git a/test/fixedbugs/bug277.go b/test/fixedbugs/bug277.go
index 207556493e..fe87a07006 100644
--- a/test/fixedbugs/bug277.go
+++ b/test/fixedbugs/bug277.go
@@ -43,7 +43,7 @@ func main() {
 		x int
 	}(s)
 	p = (*S)(p)
-	f = func(x int) int(f)
+	f = (func(x int) int)(f)
 	i = (interface {
 		m(x int) int
 	})(s) // this is accepted by 6g
diff --git a/test/fixedbugs/bug278.go b/test/fixedbugs/bug278.go
index 4817ebfee4..592aac9190 100644
--- a/test/fixedbugs/bug278.go
+++ b/test/fixedbugs/bug278.go
@@ -15,9 +15,9 @@ func f() [10]int {
 var m map[int][10]int
 
 func main() {
-	f()[1] = 2	// ERROR "cannot|invalid"
-	f()[2:3][0] = 4	// ERROR "cannot|addressable"
+	f()[1] = 2      // ERROR "cannot|invalid"
+	f()[2:3][0] = 4 // ERROR "cannot|addressable"
 	var x = "abc"
-	x[2] = 3	// ERROR "cannot|invalid"
-	m[0][5] = 6  // ERROR "cannot|invalid"
+	x[2] = 3    // ERROR "cannot|invalid"
+	m[0][5] = 6 // ERROR "cannot|invalid"
 }
diff --git a/test/fixedbugs/bug279.go b/test/fixedbugs/bug279.go
index 3b1df3b8fe..c2a9a533d6 100644
--- a/test/fixedbugs/bug279.go
+++ b/test/fixedbugs/bug279.go
@@ -21,7 +21,7 @@ func main() {
 		println("BUG alignof 0", n)
 		return
 	}
-	
+
 	n = unsafe.Sizeof("")
 	if n != 8 && n != 16 {
 		println("BUG sizeof \"\"", n)
@@ -33,4 +33,3 @@ func main() {
 		return
 	}
 }
-
diff --git a/test/fixedbugs/bug280.go b/test/fixedbugs/bug280.go
index afec57f037..c23642ea20 100644
--- a/test/fixedbugs/bug280.go
+++ b/test/fixedbugs/bug280.go
@@ -8,6 +8,4 @@
 
 package main
 
-type A [...]int	// ERROR "outside of array literal"
-
-
+type A [...]int // ERROR "outside of array literal"
diff --git a/test/fixedbugs/bug281.go b/test/fixedbugs/bug281.go
index c65530f7dd..d52d932e32 100644
--- a/test/fixedbugs/bug281.go
+++ b/test/fixedbugs/bug281.go
@@ -17,7 +17,7 @@ type Rect struct {
 }
 
 func (p Point) Sub(q Point) Point {
-	return Point{p.X-q.X, p.Y-q.Y}
+	return Point{p.X - q.X, p.Y - q.Y}
 }
 
 type Obj struct {
@@ -28,7 +28,7 @@ func (o *Obj) Bbox() Rect {
 	return o.bbox
 }
 
-func (o *Obj) Points() [2]Point{
+func (o *Obj) Points() [2]Point {
 	return [2]Point{o.bbox.Min, o.bbox.Max}
 }
 
@@ -42,12 +42,12 @@ func main() {
 		println("BUG dot: ", q.X, q.Y)
 		return
 	}
-	
+
 	q = p.Sub(o.Points()[0])
 	if q.X != 0 || q.Y != 300 {
 		println("BUG index const: ", q.X, q.Y)
 	}
-	
+
 	q = p.Sub(o.Points()[x])
 	if q.X != 0 || q.Y != 300 {
 		println("BUG index var: ", q.X, q.Y)
diff --git a/test/fixedbugs/bug282.dir/p1.go b/test/fixedbugs/bug282.dir/p1.go
index 0f7422c0ba..1fbfa3aa74 100644
--- a/test/fixedbugs/bug282.dir/p1.go
+++ b/test/fixedbugs/bug282.dir/p1.go
@@ -7,4 +7,3 @@ package p1
 type T struct {
 	f func() "x"
 }
-
diff --git a/test/fixedbugs/bug282.dir/p2.go b/test/fixedbugs/bug282.dir/p2.go
index f614507946..6e72020dcf 100644
--- a/test/fixedbugs/bug282.dir/p2.go
+++ b/test/fixedbugs/bug282.dir/p2.go
@@ -5,4 +5,3 @@
 package p2
 
 import _ "./p1"
-
diff --git a/test/fixedbugs/bug284.go b/test/fixedbugs/bug284.go
index 68208085fa..589eec15eb 100644
--- a/test/fixedbugs/bug284.go
+++ b/test/fixedbugs/bug284.go
@@ -108,7 +108,7 @@ func main() {
 	var f2 F2
 	f0 = f0
 	f0 = f1
-	f0 = func(x NewInt) int(f2) // ERROR "cannot|invalid"
+	f0 = (func(x NewInt) int)(f2) // ERROR "cannot|invalid"
 	f1 = f0
 	f1 = f1
 	f1 = F1(f2) // ERROR "cannot|invalid"
diff --git a/test/fixedbugs/bug285.go b/test/fixedbugs/bug285.go
index 0632ab4ba7..5b33ab7d42 100644
--- a/test/fixedbugs/bug285.go
+++ b/test/fixedbugs/bug285.go
@@ -66,7 +66,7 @@ func main() {
 	m0[z] = 42 // this should work: z is assignment-compatible with interface{}
 	m0[new(struct {
 		x int
-	})] = 42       // this should work: *struct{x int} is assignment-compatible with interface{}
+	})] = 42 // this should work: *struct{x int} is assignment-compatible with interface{}
 	m0[p] = 42     // this should work: p is assignment-compatible with interface{}
 	m0[false] = 42 // this should work: false is assignment-compatible with interface{}
 	m0[17] = 42    // this should work: 17 is assignment-compatible with interface{}
@@ -76,7 +76,7 @@ func main() {
 	m1[i1] = 42
 	m1[new(struct {
 		x int
-	})] = 42       // this should work: *struct{x int} is assignment-compatible with I1
+	})] = 42 // this should work: *struct{x int} is assignment-compatible with I1
 	m1[false] = 42 // this should work: false is assignment-compatible with I1
 	m1[17] = 42    // this should work: 17 is assignment-compatible with I1
 	m1["foo"] = 42 // this should work: "foo" is assignment-compatible with I1
diff --git a/test/fixedbugs/bug287.go b/test/fixedbugs/bug287.go
index 94582a8695..5ca280f6fa 100644
--- a/test/fixedbugs/bug287.go
+++ b/test/fixedbugs/bug287.go
@@ -8,4 +8,4 @@
 
 package main
 
-var mult [3][...]byte = [3][5]byte{}	// ERROR "\.\.\."
+var mult [3][...]byte = [3][5]byte{} // ERROR "\.\.\."
diff --git a/test/fixedbugs/bug289.go b/test/fixedbugs/bug289.go
index 3fc7fb2eef..8334b8f5ed 100644
--- a/test/fixedbugs/bug289.go
+++ b/test/fixedbugs/bug289.go
@@ -9,18 +9,18 @@
 package main
 
 func f1() {
-	a, b := f()	// ERROR "assignment mismatch|does not match"
+	a, b := f() // ERROR "assignment mismatch|does not match"
 	_ = a
 	_ = b
 }
 
 func f2() {
 	var a, b int
-	a, b = f()	// ERROR "assignment mismatch|does not match"
+	a, b = f() // ERROR "assignment mismatch|does not match"
 	_ = a
 	_ = b
 }
 
 func f() int {
-	return 1;
+	return 1
 }
diff --git a/test/fixedbugs/bug290.go b/test/fixedbugs/bug290.go
index 4eee285a35..ae648d2531 100644
--- a/test/fixedbugs/bug290.go
+++ b/test/fixedbugs/bug290.go
@@ -8,8 +8,8 @@
 
 package main
 
-type X struct { x []X }
+type X struct{ x []X }
 
 func main() {
-	type Y struct { x []Y }	// used to get invalid recursive type
+	type Y struct{ x []Y } // used to get invalid recursive type
 }
diff --git a/test/fixedbugs/bug293.go b/test/fixedbugs/bug293.go
index ae7cc1fd1c..e834a4bc85 100644
--- a/test/fixedbugs/bug293.go
+++ b/test/fixedbugs/bug293.go
@@ -9,7 +9,7 @@
 package main
 
 func x() (a int, b bool) {
-	defer func(){
+	defer func() {
 		a++
 	}()
 	a, b = y()
@@ -17,7 +17,7 @@ func x() (a int, b bool) {
 }
 
 func x2() (a int, b bool) {
-	defer func(){
+	defer func() {
 		a++
 	}()
 	return y()
diff --git a/test/fixedbugs/bug294.go b/test/fixedbugs/bug294.go
index b35b771916..26e922df6b 100644
--- a/test/fixedbugs/bug294.go
+++ b/test/fixedbugs/bug294.go
@@ -76,4 +76,3 @@ func main() {
 		bad()
 	}
 }
-
diff --git a/test/fixedbugs/bug295.go b/test/fixedbugs/bug295.go
index d1c961ce1d..691aa92c7f 100644
--- a/test/fixedbugs/bug295.go
+++ b/test/fixedbugs/bug295.go
@@ -6,7 +6,7 @@
 
 package main
 
-import . "testing"  // defines file-level T
+import . "testing" // defines file-level T
 
 type _ B // make use of package "testing" (but don't refer to T)
 
@@ -15,5 +15,5 @@ type S struct {
 }
 
 func main() {
-	_ = &S{T: 1}	// should work
+	_ = &S{T: 1} // should work
 }
diff --git a/test/fixedbugs/bug297.go b/test/fixedbugs/bug297.go
index c2bd253d05..4d14ad2475 100644
--- a/test/fixedbugs/bug297.go
+++ b/test/fixedbugs/bug297.go
@@ -9,7 +9,8 @@
 package main
 
 type ByteSize float64
+
 const (
-	_ = iota;   // ignore first value by assigning to blank identifier
-	KB ByteSize = 1<<(10*X) // ERROR "undefined"
+	_           = iota          // ignore first value by assigning to blank identifier
+	KB ByteSize = 1 << (10 * X) // ERROR "undefined"
 )
diff --git a/test/fixedbugs/bug302.dir/main.go b/test/fixedbugs/bug302.dir/main.go
index 52c054fb4c..9d3356f387 100644
--- a/test/fixedbugs/bug302.dir/main.go
+++ b/test/fixedbugs/bug302.dir/main.go
@@ -9,4 +9,3 @@ import _ "p"
 
 // Check that it's still correct in pp.a (which contains p.6).
 import _ "pp"
-
diff --git a/test/fixedbugs/bug302.dir/p.go b/test/fixedbugs/bug302.dir/p.go
index 0be521b4f8..1f3cfcbb3c 100644
--- a/test/fixedbugs/bug302.dir/p.go
+++ b/test/fixedbugs/bug302.dir/p.go
@@ -5,1005 +5,1005 @@
 package p
 
 type T struct {
-	x1 int
-	x2 int
-	x3 int
-	x4 int
-	x5 int
-	x6 int
-	x7 int
-	x8 int
-	x9 int
-	x10 int
-	x11 int
-	x12 int
-	x13 int
-	x14 int
-	x15 int
-	x16 int
-	x17 int
-	x18 int
-	x19 int
-	x20 int
-	x21 int
-	x22 int
-	x23 int
-	x24 int
-	x25 int
-	x26 int
-	x27 int
-	x28 int
-	x29 int
-	x30 int
-	x31 int
-	x32 int
-	x33 int
-	x34 int
-	x35 int
-	x36 int
-	x37 int
-	x38 int
-	x39 int
-	x40 int
-	x41 int
-	x42 int
-	x43 int
-	x44 int
-	x45 int
-	x46 int
-	x47 int
-	x48 int
-	x49 int
-	x50 int
-	x51 int
-	x52 int
-	x53 int
-	x54 int
-	x55 int
-	x56 int
-	x57 int
-	x58 int
-	x59 int
-	x60 int
-	x61 int
-	x62 int
-	x63 int
-	x64 int
-	x65 int
-	x66 int
-	x67 int
-	x68 int
-	x69 int
-	x70 int
-	x71 int
-	x72 int
-	x73 int
-	x74 int
-	x75 int
-	x76 int
-	x77 int
-	x78 int
-	x79 int
-	x80 int
-	x81 int
-	x82 int
-	x83 int
-	x84 int
-	x85 int
-	x86 int
-	x87 int
-	x88 int
-	x89 int
-	x90 int
-	x91 int
-	x92 int
-	x93 int
-	x94 int
-	x95 int
-	x96 int
-	x97 int
-	x98 int
-	x99 int
-	x100 int
-	x101 int
-	x102 int
-	x103 int
-	x104 int
-	x105 int
-	x106 int
-	x107 int
-	x108 int
-	x109 int
-	x110 int
-	x111 int
-	x112 int
-	x113 int
-	x114 int
-	x115 int
-	x116 int
-	x117 int
-	x118 int
-	x119 int
-	x120 int
-	x121 int
-	x122 int
-	x123 int
-	x124 int
-	x125 int
-	x126 int
-	x127 int
-	x128 int
-	x129 int
-	x130 int
-	x131 int
-	x132 int
-	x133 int
-	x134 int
-	x135 int
-	x136 int
-	x137 int
-	x138 int
-	x139 int
-	x140 int
-	x141 int
-	x142 int
-	x143 int
-	x144 int
-	x145 int
-	x146 int
-	x147 int
-	x148 int
-	x149 int
-	x150 int
-	x151 int
-	x152 int
-	x153 int
-	x154 int
-	x155 int
-	x156 int
-	x157 int
-	x158 int
-	x159 int
-	x160 int
-	x161 int
-	x162 int
-	x163 int
-	x164 int
-	x165 int
-	x166 int
-	x167 int
-	x168 int
-	x169 int
-	x170 int
-	x171 int
-	x172 int
-	x173 int
-	x174 int
-	x175 int
-	x176 int
-	x177 int
-	x178 int
-	x179 int
-	x180 int
-	x181 int
-	x182 int
-	x183 int
-	x184 int
-	x185 int
-	x186 int
-	x187 int
-	x188 int
-	x189 int
-	x190 int
-	x191 int
-	x192 int
-	x193 int
-	x194 int
-	x195 int
-	x196 int
-	x197 int
-	x198 int
-	x199 int
-	x200 int
-	x201 int
-	x202 int
-	x203 int
-	x204 int
-	x205 int
-	x206 int
-	x207 int
-	x208 int
-	x209 int
-	x210 int
-	x211 int
-	x212 int
-	x213 int
-	x214 int
-	x215 int
-	x216 int
-	x217 int
-	x218 int
-	x219 int
-	x220 int
-	x221 int
-	x222 int
-	x223 int
-	x224 int
-	x225 int
-	x226 int
-	x227 int
-	x228 int
-	x229 int
-	x230 int
-	x231 int
-	x232 int
-	x233 int
-	x234 int
-	x235 int
-	x236 int
-	x237 int
-	x238 int
-	x239 int
-	x240 int
-	x241 int
-	x242 int
-	x243 int
-	x244 int
-	x245 int
-	x246 int
-	x247 int
-	x248 int
-	x249 int
-	x250 int
-	x251 int
-	x252 int
-	x253 int
-	x254 int
-	x255 int
-	x256 int
-	x257 int
-	x258 int
-	x259 int
-	x260 int
-	x261 int
-	x262 int
-	x263 int
-	x264 int
-	x265 int
-	x266 int
-	x267 int
-	x268 int
-	x269 int
-	x270 int
-	x271 int
-	x272 int
-	x273 int
-	x274 int
-	x275 int
-	x276 int
-	x277 int
-	x278 int
-	x279 int
-	x280 int
-	x281 int
-	x282 int
-	x283 int
-	x284 int
-	x285 int
-	x286 int
-	x287 int
-	x288 int
-	x289 int
-	x290 int
-	x291 int
-	x292 int
-	x293 int
-	x294 int
-	x295 int
-	x296 int
-	x297 int
-	x298 int
-	x299 int
-	x300 int
-	x301 int
-	x302 int
-	x303 int
-	x304 int
-	x305 int
-	x306 int
-	x307 int
-	x308 int
-	x309 int
-	x310 int
-	x311 int
-	x312 int
-	x313 int
-	x314 int
-	x315 int
-	x316 int
-	x317 int
-	x318 int
-	x319 int
-	x320 int
-	x321 int
-	x322 int
-	x323 int
-	x324 int
-	x325 int
-	x326 int
-	x327 int
-	x328 int
-	x329 int
-	x330 int
-	x331 int
-	x332 int
-	x333 int
-	x334 int
-	x335 int
-	x336 int
-	x337 int
-	x338 int
-	x339 int
-	x340 int
-	x341 int
-	x342 int
-	x343 int
-	x344 int
-	x345 int
-	x346 int
-	x347 int
-	x348 int
-	x349 int
-	x350 int
-	x351 int
-	x352 int
-	x353 int
-	x354 int
-	x355 int
-	x356 int
-	x357 int
-	x358 int
-	x359 int
-	x360 int
-	x361 int
-	x362 int
-	x363 int
-	x364 int
-	x365 int
-	x366 int
-	x367 int
-	x368 int
-	x369 int
-	x370 int
-	x371 int
-	x372 int
-	x373 int
-	x374 int
-	x375 int
-	x376 int
-	x377 int
-	x378 int
-	x379 int
-	x380 int
-	x381 int
-	x382 int
-	x383 int
-	x384 int
-	x385 int
-	x386 int
-	x387 int
-	x388 int
-	x389 int
-	x390 int
-	x391 int
-	x392 int
-	x393 int
-	x394 int
-	x395 int
-	x396 int
-	x397 int
-	x398 int
-	x399 int
-	x400 int
-	x401 int
-	x402 int
-	x403 int
-	x404 int
-	x405 int
-	x406 int
-	x407 int
-	x408 int
-	x409 int
-	x410 int
-	x411 int
-	x412 int
-	x413 int
-	x414 int
-	x415 int
-	x416 int
-	x417 int
-	x418 int
-	x419 int
-	x420 int
-	x421 int
-	x422 int
-	x423 int
-	x424 int
-	x425 int
-	x426 int
-	x427 int
-	x428 int
-	x429 int
-	x430 int
-	x431 int
-	x432 int
-	x433 int
-	x434 int
-	x435 int
-	x436 int
-	x437 int
-	x438 int
-	x439 int
-	x440 int
-	x441 int
-	x442 int
-	x443 int
-	x444 int
-	x445 int
-	x446 int
-	x447 int
-	x448 int
-	x449 int
-	x450 int
-	x451 int
-	x452 int
-	x453 int
-	x454 int
-	x455 int
-	x456 int
-	x457 int
-	x458 int
-	x459 int
-	x460 int
-	x461 int
-	x462 int
-	x463 int
-	x464 int
-	x465 int
-	x466 int
-	x467 int
-	x468 int
-	x469 int
-	x470 int
-	x471 int
-	x472 int
-	x473 int
-	x474 int
-	x475 int
-	x476 int
-	x477 int
-	x478 int
-	x479 int
-	x480 int
-	x481 int
-	x482 int
-	x483 int
-	x484 int
-	x485 int
-	x486 int
-	x487 int
-	x488 int
-	x489 int
-	x490 int
-	x491 int
-	x492 int
-	x493 int
-	x494 int
-	x495 int
-	x496 int
-	x497 int
-	x498 int
-	x499 int
-	x500 int
-	x501 int
-	x502 int
-	x503 int
-	x504 int
-	x505 int
-	x506 int
-	x507 int
-	x508 int
-	x509 int
-	x510 int
-	x511 int
-	x512 int
-	x513 int
-	x514 int
-	x515 int
-	x516 int
-	x517 int
-	x518 int
-	x519 int
-	x520 int
-	x521 int
-	x522 int
-	x523 int
-	x524 int
-	x525 int
-	x526 int
-	x527 int
-	x528 int
-	x529 int
-	x530 int
-	x531 int
-	x532 int
-	x533 int
-	x534 int
-	x535 int
-	x536 int
-	x537 int
-	x538 int
-	x539 int
-	x540 int
-	x541 int
-	x542 int
-	x543 int
-	x544 int
-	x545 int
-	x546 int
-	x547 int
-	x548 int
-	x549 int
-	x550 int
-	x551 int
-	x552 int
-	x553 int
-	x554 int
-	x555 int
-	x556 int
-	x557 int
-	x558 int
-	x559 int
-	x560 int
-	x561 int
-	x562 int
-	x563 int
-	x564 int
-	x565 int
-	x566 int
-	x567 int
-	x568 int
-	x569 int
-	x570 int
-	x571 int
-	x572 int
-	x573 int
-	x574 int
-	x575 int
-	x576 int
-	x577 int
-	x578 int
-	x579 int
-	x580 int
-	x581 int
-	x582 int
-	x583 int
-	x584 int
-	x585 int
-	x586 int
-	x587 int
-	x588 int
-	x589 int
-	x590 int
-	x591 int
-	x592 int
-	x593 int
-	x594 int
-	x595 int
-	x596 int
-	x597 int
-	x598 int
-	x599 int
-	x600 int
-	x601 int
-	x602 int
-	x603 int
-	x604 int
-	x605 int
-	x606 int
-	x607 int
-	x608 int
-	x609 int
-	x610 int
-	x611 int
-	x612 int
-	x613 int
-	x614 int
-	x615 int
-	x616 int
-	x617 int
-	x618 int
-	x619 int
-	x620 int
-	x621 int
-	x622 int
-	x623 int
-	x624 int
-	x625 int
-	x626 int
-	x627 int
-	x628 int
-	x629 int
-	x630 int
-	x631 int
-	x632 int
-	x633 int
-	x634 int
-	x635 int
-	x636 int
-	x637 int
-	x638 int
-	x639 int
-	x640 int
-	x641 int
-	x642 int
-	x643 int
-	x644 int
-	x645 int
-	x646 int
-	x647 int
-	x648 int
-	x649 int
-	x650 int
-	x651 int
-	x652 int
-	x653 int
-	x654 int
-	x655 int
-	x656 int
-	x657 int
-	x658 int
-	x659 int
-	x660 int
-	x661 int
-	x662 int
-	x663 int
-	x664 int
-	x665 int
-	x666 int
-	x667 int
-	x668 int
-	x669 int
-	x670 int
-	x671 int
-	x672 int
-	x673 int
-	x674 int
-	x675 int
-	x676 int
-	x677 int
-	x678 int
-	x679 int
-	x680 int
-	x681 int
-	x682 int
-	x683 int
-	x684 int
-	x685 int
-	x686 int
-	x687 int
-	x688 int
-	x689 int
-	x690 int
-	x691 int
-	x692 int
-	x693 int
-	x694 int
-	x695 int
-	x696 int
-	x697 int
-	x698 int
-	x699 int
-	x700 int
-	x701 int
-	x702 int
-	x703 int
-	x704 int
-	x705 int
-	x706 int
-	x707 int
-	x708 int
-	x709 int
-	x710 int
-	x711 int
-	x712 int
-	x713 int
-	x714 int
-	x715 int
-	x716 int
-	x717 int
-	x718 int
-	x719 int
-	x720 int
-	x721 int
-	x722 int
-	x723 int
-	x724 int
-	x725 int
-	x726 int
-	x727 int
-	x728 int
-	x729 int
-	x730 int
-	x731 int
-	x732 int
-	x733 int
-	x734 int
-	x735 int
-	x736 int
-	x737 int
-	x738 int
-	x739 int
-	x740 int
-	x741 int
-	x742 int
-	x743 int
-	x744 int
-	x745 int
-	x746 int
-	x747 int
-	x748 int
-	x749 int
-	x750 int
-	x751 int
-	x752 int
-	x753 int
-	x754 int
-	x755 int
-	x756 int
-	x757 int
-	x758 int
-	x759 int
-	x760 int
-	x761 int
-	x762 int
-	x763 int
-	x764 int
-	x765 int
-	x766 int
-	x767 int
-	x768 int
-	x769 int
-	x770 int
-	x771 int
-	x772 int
-	x773 int
-	x774 int
-	x775 int
-	x776 int
-	x777 int
-	x778 int
-	x779 int
-	x780 int
-	x781 int
-	x782 int
-	x783 int
-	x784 int
-	x785 int
-	x786 int
-	x787 int
-	x788 int
-	x789 int
-	x790 int
-	x791 int
-	x792 int
-	x793 int
-	x794 int
-	x795 int
-	x796 int
-	x797 int
-	x798 int
-	x799 int
-	x800 int
-	x801 int
-	x802 int
-	x803 int
-	x804 int
-	x805 int
-	x806 int
-	x807 int
-	x808 int
-	x809 int
-	x810 int
-	x811 int
-	x812 int
-	x813 int
-	x814 int
-	x815 int
-	x816 int
-	x817 int
-	x818 int
-	x819 int
-	x820 int
-	x821 int
-	x822 int
-	x823 int
-	x824 int
-	x825 int
-	x826 int
-	x827 int
-	x828 int
-	x829 int
-	x830 int
-	x831 int
-	x832 int
-	x833 int
-	x834 int
-	x835 int
-	x836 int
-	x837 int
-	x838 int
-	x839 int
-	x840 int
-	x841 int
-	x842 int
-	x843 int
-	x844 int
-	x845 int
-	x846 int
-	x847 int
-	x848 int
-	x849 int
-	x850 int
-	x851 int
-	x852 int
-	x853 int
-	x854 int
-	x855 int
-	x856 int
-	x857 int
-	x858 int
-	x859 int
-	x860 int
-	x861 int
-	x862 int
-	x863 int
-	x864 int
-	x865 int
-	x866 int
-	x867 int
-	x868 int
-	x869 int
-	x870 int
-	x871 int
-	x872 int
-	x873 int
-	x874 int
-	x875 int
-	x876 int
-	x877 int
-	x878 int
-	x879 int
-	x880 int
-	x881 int
-	x882 int
-	x883 int
-	x884 int
-	x885 int
-	x886 int
-	x887 int
-	x888 int
-	x889 int
-	x890 int
-	x891 int
-	x892 int
-	x893 int
-	x894 int
-	x895 int
-	x896 int
-	x897 int
-	x898 int
-	x899 int
-	x900 int
-	x901 int
-	x902 int
-	x903 int
-	x904 int
-	x905 int
-	x906 int
-	x907 int
-	x908 int
-	x909 int
-	x910 int
-	x911 int
-	x912 int
-	x913 int
-	x914 int
-	x915 int
-	x916 int
-	x917 int
-	x918 int
-	x919 int
-	x920 int
-	x921 int
-	x922 int
-	x923 int
-	x924 int
-	x925 int
-	x926 int
-	x927 int
-	x928 int
-	x929 int
-	x930 int
-	x931 int
-	x932 int
-	x933 int
-	x934 int
-	x935 int
-	x936 int
-	x937 int
-	x938 int
-	x939 int
-	x940 int
-	x941 int
-	x942 int
-	x943 int
-	x944 int
-	x945 int
-	x946 int
-	x947 int
-	x948 int
-	x949 int
-	x950 int
-	x951 int
-	x952 int
-	x953 int
-	x954 int
-	x955 int
-	x956 int
-	x957 int
-	x958 int
-	x959 int
-	x960 int
-	x961 int
-	x962 int
-	x963 int
-	x964 int
-	x965 int
-	x966 int
-	x967 int
-	x968 int
-	x969 int
-	x970 int
-	x971 int
-	x972 int
-	x973 int
-	x974 int
-	x975 int
-	x976 int
-	x977 int
-	x978 int
-	x979 int
-	x980 int
-	x981 int
-	x982 int
-	x983 int
-	x984 int
-	x985 int
-	x986 int
-	x987 int
-	x988 int
-	x989 int
-	x990 int
-	x991 int
-	x992 int
-	x993 int
-	x994 int
-	x995 int
-	x996 int
-	x997 int
-	x998 int
-	x999 int
+	x1    int
+	x2    int
+	x3    int
+	x4    int
+	x5    int
+	x6    int
+	x7    int
+	x8    int
+	x9    int
+	x10   int
+	x11   int
+	x12   int
+	x13   int
+	x14   int
+	x15   int
+	x16   int
+	x17   int
+	x18   int
+	x19   int
+	x20   int
+	x21   int
+	x22   int
+	x23   int
+	x24   int
+	x25   int
+	x26   int
+	x27   int
+	x28   int
+	x29   int
+	x30   int
+	x31   int
+	x32   int
+	x33   int
+	x34   int
+	x35   int
+	x36   int
+	x37   int
+	x38   int
+	x39   int
+	x40   int
+	x41   int
+	x42   int
+	x43   int
+	x44   int
+	x45   int
+	x46   int
+	x47   int
+	x48   int
+	x49   int
+	x50   int
+	x51   int
+	x52   int
+	x53   int
+	x54   int
+	x55   int
+	x56   int
+	x57   int
+	x58   int
+	x59   int
+	x60   int
+	x61   int
+	x62   int
+	x63   int
+	x64   int
+	x65   int
+	x66   int
+	x67   int
+	x68   int
+	x69   int
+	x70   int
+	x71   int
+	x72   int
+	x73   int
+	x74   int
+	x75   int
+	x76   int
+	x77   int
+	x78   int
+	x79   int
+	x80   int
+	x81   int
+	x82   int
+	x83   int
+	x84   int
+	x85   int
+	x86   int
+	x87   int
+	x88   int
+	x89   int
+	x90   int
+	x91   int
+	x92   int
+	x93   int
+	x94   int
+	x95   int
+	x96   int
+	x97   int
+	x98   int
+	x99   int
+	x100  int
+	x101  int
+	x102  int
+	x103  int
+	x104  int
+	x105  int
+	x106  int
+	x107  int
+	x108  int
+	x109  int
+	x110  int
+	x111  int
+	x112  int
+	x113  int
+	x114  int
+	x115  int
+	x116  int
+	x117  int
+	x118  int
+	x119  int
+	x120  int
+	x121  int
+	x122  int
+	x123  int
+	x124  int
+	x125  int
+	x126  int
+	x127  int
+	x128  int
+	x129  int
+	x130  int
+	x131  int
+	x132  int
+	x133  int
+	x134  int
+	x135  int
+	x136  int
+	x137  int
+	x138  int
+	x139  int
+	x140  int
+	x141  int
+	x142  int
+	x143  int
+	x144  int
+	x145  int
+	x146  int
+	x147  int
+	x148  int
+	x149  int
+	x150  int
+	x151  int
+	x152  int
+	x153  int
+	x154  int
+	x155  int
+	x156  int
+	x157  int
+	x158  int
+	x159  int
+	x160  int
+	x161  int
+	x162  int
+	x163  int
+	x164  int
+	x165  int
+	x166  int
+	x167  int
+	x168  int
+	x169  int
+	x170  int
+	x171  int
+	x172  int
+	x173  int
+	x174  int
+	x175  int
+	x176  int
+	x177  int
+	x178  int
+	x179  int
+	x180  int
+	x181  int
+	x182  int
+	x183  int
+	x184  int
+	x185  int
+	x186  int
+	x187  int
+	x188  int
+	x189  int
+	x190  int
+	x191  int
+	x192  int
+	x193  int
+	x194  int
+	x195  int
+	x196  int
+	x197  int
+	x198  int
+	x199  int
+	x200  int
+	x201  int
+	x202  int
+	x203  int
+	x204  int
+	x205  int
+	x206  int
+	x207  int
+	x208  int
+	x209  int
+	x210  int
+	x211  int
+	x212  int
+	x213  int
+	x214  int
+	x215  int
+	x216  int
+	x217  int
+	x218  int
+	x219  int
+	x220  int
+	x221  int
+	x222  int
+	x223  int
+	x224  int
+	x225  int
+	x226  int
+	x227  int
+	x228  int
+	x229  int
+	x230  int
+	x231  int
+	x232  int
+	x233  int
+	x234  int
+	x235  int
+	x236  int
+	x237  int
+	x238  int
+	x239  int
+	x240  int
+	x241  int
+	x242  int
+	x243  int
+	x244  int
+	x245  int
+	x246  int
+	x247  int
+	x248  int
+	x249  int
+	x250  int
+	x251  int
+	x252  int
+	x253  int
+	x254  int
+	x255  int
+	x256  int
+	x257  int
+	x258  int
+	x259  int
+	x260  int
+	x261  int
+	x262  int
+	x263  int
+	x264  int
+	x265  int
+	x266  int
+	x267  int
+	x268  int
+	x269  int
+	x270  int
+	x271  int
+	x272  int
+	x273  int
+	x274  int
+	x275  int
+	x276  int
+	x277  int
+	x278  int
+	x279  int
+	x280  int
+	x281  int
+	x282  int
+	x283  int
+	x284  int
+	x285  int
+	x286  int
+	x287  int
+	x288  int
+	x289  int
+	x290  int
+	x291  int
+	x292  int
+	x293  int
+	x294  int
+	x295  int
+	x296  int
+	x297  int
+	x298  int
+	x299  int
+	x300  int
+	x301  int
+	x302  int
+	x303  int
+	x304  int
+	x305  int
+	x306  int
+	x307  int
+	x308  int
+	x309  int
+	x310  int
+	x311  int
+	x312  int
+	x313  int
+	x314  int
+	x315  int
+	x316  int
+	x317  int
+	x318  int
+	x319  int
+	x320  int
+	x321  int
+	x322  int
+	x323  int
+	x324  int
+	x325  int
+	x326  int
+	x327  int
+	x328  int
+	x329  int
+	x330  int
+	x331  int
+	x332  int
+	x333  int
+	x334  int
+	x335  int
+	x336  int
+	x337  int
+	x338  int
+	x339  int
+	x340  int
+	x341  int
+	x342  int
+	x343  int
+	x344  int
+	x345  int
+	x346  int
+	x347  int
+	x348  int
+	x349  int
+	x350  int
+	x351  int
+	x352  int
+	x353  int
+	x354  int
+	x355  int
+	x356  int
+	x357  int
+	x358  int
+	x359  int
+	x360  int
+	x361  int
+	x362  int
+	x363  int
+	x364  int
+	x365  int
+	x366  int
+	x367  int
+	x368  int
+	x369  int
+	x370  int
+	x371  int
+	x372  int
+	x373  int
+	x374  int
+	x375  int
+	x376  int
+	x377  int
+	x378  int
+	x379  int
+	x380  int
+	x381  int
+	x382  int
+	x383  int
+	x384  int
+	x385  int
+	x386  int
+	x387  int
+	x388  int
+	x389  int
+	x390  int
+	x391  int
+	x392  int
+	x393  int
+	x394  int
+	x395  int
+	x396  int
+	x397  int
+	x398  int
+	x399  int
+	x400  int
+	x401  int
+	x402  int
+	x403  int
+	x404  int
+	x405  int
+	x406  int
+	x407  int
+	x408  int
+	x409  int
+	x410  int
+	x411  int
+	x412  int
+	x413  int
+	x414  int
+	x415  int
+	x416  int
+	x417  int
+	x418  int
+	x419  int
+	x420  int
+	x421  int
+	x422  int
+	x423  int
+	x424  int
+	x425  int
+	x426  int
+	x427  int
+	x428  int
+	x429  int
+	x430  int
+	x431  int
+	x432  int
+	x433  int
+	x434  int
+	x435  int
+	x436  int
+	x437  int
+	x438  int
+	x439  int
+	x440  int
+	x441  int
+	x442  int
+	x443  int
+	x444  int
+	x445  int
+	x446  int
+	x447  int
+	x448  int
+	x449  int
+	x450  int
+	x451  int
+	x452  int
+	x453  int
+	x454  int
+	x455  int
+	x456  int
+	x457  int
+	x458  int
+	x459  int
+	x460  int
+	x461  int
+	x462  int
+	x463  int
+	x464  int
+	x465  int
+	x466  int
+	x467  int
+	x468  int
+	x469  int
+	x470  int
+	x471  int
+	x472  int
+	x473  int
+	x474  int
+	x475  int
+	x476  int
+	x477  int
+	x478  int
+	x479  int
+	x480  int
+	x481  int
+	x482  int
+	x483  int
+	x484  int
+	x485  int
+	x486  int
+	x487  int
+	x488  int
+	x489  int
+	x490  int
+	x491  int
+	x492  int
+	x493  int
+	x494  int
+	x495  int
+	x496  int
+	x497  int
+	x498  int
+	x499  int
+	x500  int
+	x501  int
+	x502  int
+	x503  int
+	x504  int
+	x505  int
+	x506  int
+	x507  int
+	x508  int
+	x509  int
+	x510  int
+	x511  int
+	x512  int
+	x513  int
+	x514  int
+	x515  int
+	x516  int
+	x517  int
+	x518  int
+	x519  int
+	x520  int
+	x521  int
+	x522  int
+	x523  int
+	x524  int
+	x525  int
+	x526  int
+	x527  int
+	x528  int
+	x529  int
+	x530  int
+	x531  int
+	x532  int
+	x533  int
+	x534  int
+	x535  int
+	x536  int
+	x537  int
+	x538  int
+	x539  int
+	x540  int
+	x541  int
+	x542  int
+	x543  int
+	x544  int
+	x545  int
+	x546  int
+	x547  int
+	x548  int
+	x549  int
+	x550  int
+	x551  int
+	x552  int
+	x553  int
+	x554  int
+	x555  int
+	x556  int
+	x557  int
+	x558  int
+	x559  int
+	x560  int
+	x561  int
+	x562  int
+	x563  int
+	x564  int
+	x565  int
+	x566  int
+	x567  int
+	x568  int
+	x569  int
+	x570  int
+	x571  int
+	x572  int
+	x573  int
+	x574  int
+	x575  int
+	x576  int
+	x577  int
+	x578  int
+	x579  int
+	x580  int
+	x581  int
+	x582  int
+	x583  int
+	x584  int
+	x585  int
+	x586  int
+	x587  int
+	x588  int
+	x589  int
+	x590  int
+	x591  int
+	x592  int
+	x593  int
+	x594  int
+	x595  int
+	x596  int
+	x597  int
+	x598  int
+	x599  int
+	x600  int
+	x601  int
+	x602  int
+	x603  int
+	x604  int
+	x605  int
+	x606  int
+	x607  int
+	x608  int
+	x609  int
+	x610  int
+	x611  int
+	x612  int
+	x613  int
+	x614  int
+	x615  int
+	x616  int
+	x617  int
+	x618  int
+	x619  int
+	x620  int
+	x621  int
+	x622  int
+	x623  int
+	x624  int
+	x625  int
+	x626  int
+	x627  int
+	x628  int
+	x629  int
+	x630  int
+	x631  int
+	x632  int
+	x633  int
+	x634  int
+	x635  int
+	x636  int
+	x637  int
+	x638  int
+	x639  int
+	x640  int
+	x641  int
+	x642  int
+	x643  int
+	x644  int
+	x645  int
+	x646  int
+	x647  int
+	x648  int
+	x649  int
+	x650  int
+	x651  int
+	x652  int
+	x653  int
+	x654  int
+	x655  int
+	x656  int
+	x657  int
+	x658  int
+	x659  int
+	x660  int
+	x661  int
+	x662  int
+	x663  int
+	x664  int
+	x665  int
+	x666  int
+	x667  int
+	x668  int
+	x669  int
+	x670  int
+	x671  int
+	x672  int
+	x673  int
+	x674  int
+	x675  int
+	x676  int
+	x677  int
+	x678  int
+	x679  int
+	x680  int
+	x681  int
+	x682  int
+	x683  int
+	x684  int
+	x685  int
+	x686  int
+	x687  int
+	x688  int
+	x689  int
+	x690  int
+	x691  int
+	x692  int
+	x693  int
+	x694  int
+	x695  int
+	x696  int
+	x697  int
+	x698  int
+	x699  int
+	x700  int
+	x701  int
+	x702  int
+	x703  int
+	x704  int
+	x705  int
+	x706  int
+	x707  int
+	x708  int
+	x709  int
+	x710  int
+	x711  int
+	x712  int
+	x713  int
+	x714  int
+	x715  int
+	x716  int
+	x717  int
+	x718  int
+	x719  int
+	x720  int
+	x721  int
+	x722  int
+	x723  int
+	x724  int
+	x725  int
+	x726  int
+	x727  int
+	x728  int
+	x729  int
+	x730  int
+	x731  int
+	x732  int
+	x733  int
+	x734  int
+	x735  int
+	x736  int
+	x737  int
+	x738  int
+	x739  int
+	x740  int
+	x741  int
+	x742  int
+	x743  int
+	x744  int
+	x745  int
+	x746  int
+	x747  int
+	x748  int
+	x749  int
+	x750  int
+	x751  int
+	x752  int
+	x753  int
+	x754  int
+	x755  int
+	x756  int
+	x757  int
+	x758  int
+	x759  int
+	x760  int
+	x761  int
+	x762  int
+	x763  int
+	x764  int
+	x765  int
+	x766  int
+	x767  int
+	x768  int
+	x769  int
+	x770  int
+	x771  int
+	x772  int
+	x773  int
+	x774  int
+	x775  int
+	x776  int
+	x777  int
+	x778  int
+	x779  int
+	x780  int
+	x781  int
+	x782  int
+	x783  int
+	x784  int
+	x785  int
+	x786  int
+	x787  int
+	x788  int
+	x789  int
+	x790  int
+	x791  int
+	x792  int
+	x793  int
+	x794  int
+	x795  int
+	x796  int
+	x797  int
+	x798  int
+	x799  int
+	x800  int
+	x801  int
+	x802  int
+	x803  int
+	x804  int
+	x805  int
+	x806  int
+	x807  int
+	x808  int
+	x809  int
+	x810  int
+	x811  int
+	x812  int
+	x813  int
+	x814  int
+	x815  int
+	x816  int
+	x817  int
+	x818  int
+	x819  int
+	x820  int
+	x821  int
+	x822  int
+	x823  int
+	x824  int
+	x825  int
+	x826  int
+	x827  int
+	x828  int
+	x829  int
+	x830  int
+	x831  int
+	x832  int
+	x833  int
+	x834  int
+	x835  int
+	x836  int
+	x837  int
+	x838  int
+	x839  int
+	x840  int
+	x841  int
+	x842  int
+	x843  int
+	x844  int
+	x845  int
+	x846  int
+	x847  int
+	x848  int
+	x849  int
+	x850  int
+	x851  int
+	x852  int
+	x853  int
+	x854  int
+	x855  int
+	x856  int
+	x857  int
+	x858  int
+	x859  int
+	x860  int
+	x861  int
+	x862  int
+	x863  int
+	x864  int
+	x865  int
+	x866  int
+	x867  int
+	x868  int
+	x869  int
+	x870  int
+	x871  int
+	x872  int
+	x873  int
+	x874  int
+	x875  int
+	x876  int
+	x877  int
+	x878  int
+	x879  int
+	x880  int
+	x881  int
+	x882  int
+	x883  int
+	x884  int
+	x885  int
+	x886  int
+	x887  int
+	x888  int
+	x889  int
+	x890  int
+	x891  int
+	x892  int
+	x893  int
+	x894  int
+	x895  int
+	x896  int
+	x897  int
+	x898  int
+	x899  int
+	x900  int
+	x901  int
+	x902  int
+	x903  int
+	x904  int
+	x905  int
+	x906  int
+	x907  int
+	x908  int
+	x909  int
+	x910  int
+	x911  int
+	x912  int
+	x913  int
+	x914  int
+	x915  int
+	x916  int
+	x917  int
+	x918  int
+	x919  int
+	x920  int
+	x921  int
+	x922  int
+	x923  int
+	x924  int
+	x925  int
+	x926  int
+	x927  int
+	x928  int
+	x929  int
+	x930  int
+	x931  int
+	x932  int
+	x933  int
+	x934  int
+	x935  int
+	x936  int
+	x937  int
+	x938  int
+	x939  int
+	x940  int
+	x941  int
+	x942  int
+	x943  int
+	x944  int
+	x945  int
+	x946  int
+	x947  int
+	x948  int
+	x949  int
+	x950  int
+	x951  int
+	x952  int
+	x953  int
+	x954  int
+	x955  int
+	x956  int
+	x957  int
+	x958  int
+	x959  int
+	x960  int
+	x961  int
+	x962  int
+	x963  int
+	x964  int
+	x965  int
+	x966  int
+	x967  int
+	x968  int
+	x969  int
+	x970  int
+	x971  int
+	x972  int
+	x973  int
+	x974  int
+	x975  int
+	x976  int
+	x977  int
+	x978  int
+	x979  int
+	x980  int
+	x981  int
+	x982  int
+	x983  int
+	x984  int
+	x985  int
+	x986  int
+	x987  int
+	x988  int
+	x989  int
+	x990  int
+	x991  int
+	x992  int
+	x993  int
+	x994  int
+	x995  int
+	x996  int
+	x997  int
+	x998  int
+	x999  int
 	x1000 int
 }
 
diff --git a/test/fixedbugs/bug304.go b/test/fixedbugs/bug304.go
index 4073073eec..69cb9e4d38 100644
--- a/test/fixedbugs/bug304.go
+++ b/test/fixedbugs/bug304.go
@@ -9,10 +9,12 @@
 // bug304.go:15:2: internal compiler error: in copy_tree_r, at tree-inline.c:4114
 
 package p
+
 type S struct {
 	v interface{}
 }
-func g(e interface{}) { }
+
+func g(e interface{}) {}
 func f(s S) {
 	g(s.v.(*int))
 }
diff --git a/test/fixedbugs/bug306.dir/p1.go b/test/fixedbugs/bug306.dir/p1.go
index b28551807d..b7a3579d04 100644
--- a/test/fixedbugs/bug306.dir/p1.go
+++ b/test/fixedbugs/bug306.dir/p1.go
@@ -5,5 +5,5 @@
 package p1
 
 type T <-chan int
-var x = make(chan T)
 
+var x = make(chan T)
diff --git a/test/fixedbugs/bug306.dir/p2.go b/test/fixedbugs/bug306.dir/p2.go
index f614507946..6e72020dcf 100644
--- a/test/fixedbugs/bug306.dir/p2.go
+++ b/test/fixedbugs/bug306.dir/p2.go
@@ -5,4 +5,3 @@
 package p2
 
 import _ "./p1"
-
diff --git a/test/fixedbugs/bug311.go b/test/fixedbugs/bug311.go
index f5cab44c7e..3bf8426af0 100644
--- a/test/fixedbugs/bug311.go
+++ b/test/fixedbugs/bug311.go
@@ -9,9 +9,9 @@ package main
 func main() {
 	m := make(map[string][1000]byte)
 	m["hi"] = [1000]byte{1}
-	
+
 	v := m["hi"]
-	
+
 	for k, vv := range m {
 		if k != "hi" || string(v[:]) != string(vv[:]) {
 			panic("bad iter")
diff --git a/test/fixedbugs/bug314.go b/test/fixedbugs/bug314.go
index 6e26d14e1f..ad8b364765 100644
--- a/test/fixedbugs/bug314.go
+++ b/test/fixedbugs/bug314.go
@@ -10,10 +10,11 @@ package main
 
 type S struct {
 }
-func (S) a() int{
+
+func (S) a() int {
 	return 0
 }
-func (S) b() int{
+func (S) b() int {
 	return 1
 }
 
diff --git a/test/fixedbugs/bug317.go b/test/fixedbugs/bug317.go
index 4cd9ec2813..226b7fe9ad 100644
--- a/test/fixedbugs/bug317.go
+++ b/test/fixedbugs/bug317.go
@@ -12,5 +12,5 @@ func main() {
 }
 
 func f() uint {
-	return 1<<31 // doesn't panic with 1<<31 - 1
+	return 1 << 31 // doesn't panic with 1<<31 - 1
 }
diff --git a/test/fixedbugs/bug319.go b/test/fixedbugs/bug319.go
index b93106d4bd..d837af9a06 100644
--- a/test/fixedbugs/bug319.go
+++ b/test/fixedbugs/bug319.go
@@ -10,7 +10,7 @@ import "unsafe"
 
 func main() {
 	var x int
-	
+
 	a := uint64(uintptr(unsafe.Pointer(&x)))
 	b := uint32(uintptr(unsafe.Pointer(&x)))
 	c := uint16(uintptr(unsafe.Pointer(&x)))
diff --git a/test/fixedbugs/bug320.go b/test/fixedbugs/bug320.go
index 0406b96561..c6bcc0f5c0 100644
--- a/test/fixedbugs/bug320.go
+++ b/test/fixedbugs/bug320.go
@@ -42,4 +42,3 @@ func escape(*int) {
 
 func f(int) {
 }
-
diff --git a/test/fixedbugs/bug322.dir/lib.go b/test/fixedbugs/bug322.dir/lib.go
index 0de56d3d64..c338781925 100644
--- a/test/fixedbugs/bug322.dir/lib.go
+++ b/test/fixedbugs/bug322.dir/lib.go
@@ -5,7 +5,7 @@
 package lib
 
 type T struct {
-	x int  // non-exported field
+	x int // non-exported field
 }
 
 func (t T) M() {
diff --git a/test/fixedbugs/bug322.dir/main.go b/test/fixedbugs/bug322.dir/main.go
index f403c7d32e..0b6984c6d2 100644
--- a/test/fixedbugs/bug322.dir/main.go
+++ b/test/fixedbugs/bug322.dir/main.go
@@ -22,7 +22,7 @@ func main() {
 	// This is still an error.
 	// var i1 I = t
 	// i1.M()
-	
+
 	// This combination is illegal because
 	// PM requires a pointer receiver.
 	// var pi1 PI = t
diff --git a/test/fixedbugs/bug324.dir/prog.go b/test/fixedbugs/bug324.dir/prog.go
index 3ab61f3eb5..4e415758cb 100644
--- a/test/fixedbugs/bug324.dir/prog.go
+++ b/test/fixedbugs/bug324.dir/prog.go
@@ -16,17 +16,16 @@ type Implementation struct{}
 
 func (p *Implementation) private() {}
 
-
 func main() {
 	// nothing unusual here
 	var x Exported
 	x = new(Implementation)
-	x.private()  //  main.Implementation.private()
+	x.private() //  main.Implementation.private()
 
 	// same here - should be and is legal
 	var px p.Exported
 	px = p.X
-	
+
 	// this assignment is correctly illegal:
 	//	px.private undefined (cannot refer to unexported field or method private)
 	// px.private()
@@ -44,10 +43,10 @@ func main() {
 		recover()
 	}()
 	x = px.(Exported)
-	
+
 	println("should not get this far")
 
 	// this is a legitimate call, but because of the previous assignment,
 	// it invokes the method private in p!
-	x.private()  // p.Implementation.private()
+	x.private() // p.Implementation.private()
 }
diff --git a/test/fixedbugs/bug325.go b/test/fixedbugs/bug325.go
index e6528ae46a..50d79d521d 100644
--- a/test/fixedbugs/bug325.go
+++ b/test/fixedbugs/bug325.go
@@ -10,6 +10,6 @@ import "unsafe"
 
 func main() {
 	var x unsafe.Pointer
-	println(*x) // ERROR "invalid indirect.*unsafe.Pointer"
-	var _ = (unsafe.Pointer)(nil).foo  // ERROR "foo"
+	println(*x)                       // ERROR "invalid indirect.*unsafe.Pointer"
+	var _ = (unsafe.Pointer)(nil).foo // ERROR "foo"
 }
diff --git a/test/fixedbugs/bug330.go b/test/fixedbugs/bug330.go
index 2f33feb4b6..6c1cb1394b 100644
--- a/test/fixedbugs/bug330.go
+++ b/test/fixedbugs/bug330.go
@@ -8,6 +8,6 @@ package main
 
 func main() {
 	x := ""
-	x = +"hello"  // ERROR "invalid operation.*string|expected numeric"
-	x = +x  // ERROR "invalid operation.*string|expected numeric"
+	x = +"hello" // ERROR "invalid operation.*string|expected numeric"
+	x = +x       // ERROR "invalid operation.*string|expected numeric"
 }
diff --git a/test/fixedbugs/bug332.go b/test/fixedbugs/bug332.go
index d43c2ddcff..faa445fb5a 100644
--- a/test/fixedbugs/bug332.go
+++ b/test/fixedbugs/bug332.go
@@ -14,4 +14,4 @@ func main() {}
 
 // important: no newline on end of next line.
 // 6g used to print <epoch> instead of bug332.go:111
-func (t *T) F() {} // ERROR "undefined: T"
\ No newline at end of file
+func (t *T) F() {} // ERROR "undefined: T"
diff --git a/test/fixedbugs/bug333.go b/test/fixedbugs/bug333.go
index 149843a3b0..86927b26ed 100644
--- a/test/fixedbugs/bug333.go
+++ b/test/fixedbugs/bug333.go
@@ -9,9 +9,9 @@
 package main
 
 func main() {
-       type Ts string
-       var ts Ts
-       _ = []byte(ts)
+	type Ts string
+	var ts Ts
+	_ = []byte(ts)
 }
 
 /*
diff --git a/test/fixedbugs/bug337.go b/test/fixedbugs/bug337.go
index 1a0616f70a..8021c8b910 100644
--- a/test/fixedbugs/bug337.go
+++ b/test/fixedbugs/bug337.go
@@ -6,7 +6,7 @@
 
 // Issue 1722.
 
-// Check that the error messages says 
+// Check that the error messages says
 //	bug337.go:16: len("foo") not used
 // and not
 //	bug337.go:16: 3 not used
@@ -14,6 +14,5 @@
 package main
 
 func main() {
-	len("foo")	// ERROR "len|value computed is not used"
+	len("foo") // ERROR "len|value computed is not used"
 }
-
diff --git a/test/fixedbugs/bug341.go b/test/fixedbugs/bug341.go
index baab28216f..7e478f3742 100644
--- a/test/fixedbugs/bug341.go
+++ b/test/fixedbugs/bug341.go
@@ -15,6 +15,7 @@ func main() {
 	_ = uint64(x)
 	_ = float32(0)
 }
+
 /*
 panic: runtime error: floating point error
 
diff --git a/test/fixedbugs/bug343.go b/test/fixedbugs/bug343.go
index fd8bd76bbf..e63347cd44 100644
--- a/test/fixedbugs/bug343.go
+++ b/test/fixedbugs/bug343.go
@@ -9,22 +9,22 @@
 package main
 
 func getArgs(data map[string]interface{}, keys ...string) map[string]string {
-       ret := map[string]string{}
-       var ok bool
-       for _, k := range keys {
-               ret[k], ok = data[k].(string)
-               if !ok {}
-       }
-       return ret
+	ret := map[string]string{}
+	var ok bool
+	for _, k := range keys {
+		ret[k], ok = data[k].(string)
+		if !ok {
+		}
+	}
+	return ret
 }
 
 func main() {
-	x := getArgs(map[string]interface{}{"x":"y"}, "x")
+	x := getArgs(map[string]interface{}{"x": "y"}, "x")
 	if x["x"] != "y" {
 		println("BUG bug343", x)
 	}
 }
-	
 
 /*
 typecheck [1008592b0]
diff --git a/test/fixedbugs/bug344.go b/test/fixedbugs/bug344.go
index b53abd26e3..42aace6ab6 100644
--- a/test/fixedbugs/bug344.go
+++ b/test/fixedbugs/bug344.go
@@ -14,10 +14,10 @@ func main() {
 	i := 42
 	a := []*int{&i, &i, &i, &i}
 	x := a[0]
-	goto start  // ERROR "jumps into block"
+	goto start // ERROR "jumps into block"
 	z := 1
 	_ = z
-	for _, x = range a {	// GCCGO_ERROR "block"
+	for _, x = range a { // GCCGO_ERROR "block"
 	start:
 		fmt.Sprint(*x)
 	}
diff --git a/test/fixedbugs/bug347.go b/test/fixedbugs/bug347.go
index 92afb2e704..6ea0419c39 100644
--- a/test/fixedbugs/bug347.go
+++ b/test/fixedbugs/bug347.go
@@ -19,7 +19,7 @@ var c chan int
 
 func f() {
 	select {
-	case <-t.c:  // THIS IS LINE 22
+	case <-t.c: // THIS IS LINE 22
 		break
 	case <-c:
 		break
@@ -29,7 +29,7 @@ func f() {
 func main() {
 	defer func() {
 		recover()
-		for i := 0;; i++ {
+		for i := 0; ; i++ {
 			pc, file, line, ok := runtime.Caller(i)
 			if !ok {
 				print("BUG: bug347: cannot find caller\n")
diff --git a/test/fixedbugs/bug348.go b/test/fixedbugs/bug348.go
index c7f1346159..8d7dc0a3bd 100644
--- a/test/fixedbugs/bug348.go
+++ b/test/fixedbugs/bug348.go
@@ -13,8 +13,8 @@ import (
 
 func f() {
 	var x *string
-	
-	for _, i := range *x {  // THIS IS LINE 17
+
+	for _, i := range *x { // THIS IS LINE 17
 		println(i)
 	}
 }
@@ -24,7 +24,7 @@ func g() {
 
 func main() {
 	defer func() {
-		for i := 0;; i++ {
+		for i := 0; ; i++ {
 			pc, file, line, ok := runtime.Caller(i)
 			if !ok {
 				print("BUG: bug348: cannot find caller\n")
diff --git a/test/fixedbugs/bug356.go b/test/fixedbugs/bug356.go
index 6d93860be9..2dcd8675d0 100644
--- a/test/fixedbugs/bug356.go
+++ b/test/fixedbugs/bug356.go
@@ -12,27 +12,26 @@ func main() {
 	var i uint64
 	var x int = 12345
 
-	if y := x << (i&5); y != 12345<<0 {
+	if y := x << (i & 5); y != 12345<<0 {
 		println("BUG bug344", y)
 		return
 	}
-	
+
 	i++
-	if y := x << (i&5); y != 12345<<1 {
+	if y := x << (i & 5); y != 12345<<1 {
 		println("BUG bug344a", y)
 	}
-	
+
 	i = 70
 	if y := x << i; y != 0 {
 		println("BUG bug344b", y)
 	}
-	
-	i = 1<<32
+
+	i = 1 << 32
 	if y := x << i; y != 0 {
 		println("BUG bug344c", y)
 	}
 }
-	
 
 /*
 typecheck [1008592b0]
diff --git a/test/fixedbugs/bug357.go b/test/fixedbugs/bug357.go
index e9db50e88e..16f3abb002 100644
--- a/test/fixedbugs/bug357.go
+++ b/test/fixedbugs/bug357.go
@@ -15,7 +15,7 @@ func bla1() bool {
 
 func bla5() bool {
 	_ = 1
-	false  // ERROR "false evaluated but not used|value computed is not used"
+	false // ERROR "false evaluated but not used|value computed is not used"
 	_ = 2
 	return false
 }
diff --git a/test/fixedbugs/bug361.go b/test/fixedbugs/bug361.go
index 8e282431eb..57e933658d 100644
--- a/test/fixedbugs/bug361.go
+++ b/test/fixedbugs/bug361.go
@@ -10,6 +10,6 @@
 package test
 
 func main() {
-	buf := [1<<30]byte{}
+	buf := [1 << 30]byte{}
 	_ = buf[:]
 }
diff --git a/test/fixedbugs/bug362.go b/test/fixedbugs/bug362.go
index 771d13d435..cc73c947a3 100644
--- a/test/fixedbugs/bug362.go
+++ b/test/fixedbugs/bug362.go
@@ -10,7 +10,7 @@
 package main
 
 var (
-	a = iota  // ERROR "undefined: iota|iota is only defined in const"
-	b = iota  // ERROR "undefined: iota|iota is only defined in const"
-	c = iota  // ERROR "undefined: iota|iota is only defined in const"
+	a = iota // ERROR "undefined: iota|iota is only defined in const"
+	b = iota // ERROR "undefined: iota|iota is only defined in const"
+	c = iota // ERROR "undefined: iota|iota is only defined in const"
 )
diff --git a/test/fixedbugs/bug363.go b/test/fixedbugs/bug363.go
index 1bd1400987..4c10a3a334 100644
--- a/test/fixedbugs/bug363.go
+++ b/test/fixedbugs/bug363.go
@@ -10,12 +10,12 @@ package main
 
 func main() {
 	var i uint = 33
-	var a = (1<<i) + 4.5  // ERROR "shift of type float64|invalid.*shift"
+	var a = (1 << i) + 4.5 // ERROR "shift of type float64|invalid.*shift"
 	println(a)
-	
-	var b = (1<<i) + 4.0  // ERROR "shift of type float64|invalid.*shift"
+
+	var b = (1 << i) + 4.0 // ERROR "shift of type float64|invalid.*shift"
 	println(b)
 
-	var c int64 = (1<<i) + 4.0  // ok - it's all int64
+	var c int64 = (1 << i) + 4.0 // ok - it's all int64
 	println(c)
 }
diff --git a/test/fixedbugs/bug364.go b/test/fixedbugs/bug364.go
index 64120d1643..b6d1377372 100644
--- a/test/fixedbugs/bug364.go
+++ b/test/fixedbugs/bug364.go
@@ -14,7 +14,7 @@ func accum(args ...interface{}) {
 	s += fmt.Sprintln(args...)
 }
 
-func f(){
+func f() {
 	v := 0.0
 	for i := 0; i < 3; i++ {
 		v += 0.1
diff --git a/test/fixedbugs/bug366.go b/test/fixedbugs/bug366.go
index 3af5beaaf0..2f937b91b5 100644
--- a/test/fixedbugs/bug366.go
+++ b/test/fixedbugs/bug366.go
@@ -15,23 +15,23 @@ func five(x int64) {
 }
 
 func main() {
-       // 5
-       five(int64(5 / (5 / 3)))
-
-       // 5
-       five(int64(byte(5) / (byte(5) / byte(3))))
-
-       // 5
-       var a, b byte = 5, 3
-       five(int64(a / (a / b)))
-       
-       // integer divide by zero in golang.org sandbox
-       // 0 on windows/amd64
-       x := [3]byte{2, 3, 5}
-       five(int64(x[2] / (x[2] / x[1])))
-
-       // integer divide by zero in golang.org sandbox
-       // crash on windows/amd64
-       y := x[1:3]
-       five(int64(y[1] / (y[1] / y[0])))
-}
\ No newline at end of file
+	// 5
+	five(int64(5 / (5 / 3)))
+
+	// 5
+	five(int64(byte(5) / (byte(5) / byte(3))))
+
+	// 5
+	var a, b byte = 5, 3
+	five(int64(a / (a / b)))
+
+	// integer divide by zero in golang.org sandbox
+	// 0 on windows/amd64
+	x := [3]byte{2, 3, 5}
+	five(int64(x[2] / (x[2] / x[1])))
+
+	// integer divide by zero in golang.org sandbox
+	// crash on windows/amd64
+	y := x[1:3]
+	five(int64(y[1] / (y[1] / y[0])))
+}
diff --git a/test/fixedbugs/bug368.go b/test/fixedbugs/bug368.go
index 353ea5a0b1..60f3628b4b 100644
--- a/test/fixedbugs/bug368.go
+++ b/test/fixedbugs/bug368.go
@@ -12,7 +12,7 @@ package main
 func f(n int) int {
 	s := 0
 	for i := 0; i < n; i++ {
-		s += i>>1
+		s += i >> 1
 	}
 	return s
 }
diff --git a/test/fixedbugs/bug369.dir/pkg.go b/test/fixedbugs/bug369.dir/pkg.go
index 9964347250..c46acff79b 100644
--- a/test/fixedbugs/bug369.dir/pkg.go
+++ b/test/fixedbugs/bug369.dir/pkg.go
@@ -12,4 +12,3 @@ func NonASCII(b []byte, i int) int {
 	}
 	return i
 }
-
diff --git a/test/fixedbugs/bug372.go b/test/fixedbugs/bug372.go
index 5fba131d7a..caf5b54447 100644
--- a/test/fixedbugs/bug372.go
+++ b/test/fixedbugs/bug372.go
@@ -7,7 +7,8 @@
 // Issue 2355
 package main
 
-type T struct {}
+type T struct{}
+
 func (T) m() string { return "T" }
 
 type TT struct {
@@ -15,7 +16,6 @@ type TT struct {
 	m func() string
 }
 
-
 func ff() string { return "ff" }
 
 func main() {
diff --git a/test/fixedbugs/bug373.go b/test/fixedbugs/bug373.go
index aa0f5d1efa..6efdfad58b 100644
--- a/test/fixedbugs/bug373.go
+++ b/test/fixedbugs/bug373.go
@@ -9,7 +9,7 @@
 package foo
 
 func f(x interface{}) {
-	switch t := x.(type) {  // ERROR "declared and not used"
+	switch t := x.(type) { // ERROR "declared and not used"
 	case int:
 	}
 }
diff --git a/test/fixedbugs/bug374.go b/test/fixedbugs/bug374.go
index 2d604cbd3c..b659b46e39 100644
--- a/test/fixedbugs/bug374.go
+++ b/test/fixedbugs/bug374.go
@@ -13,8 +13,8 @@ type I interface {
 
 type T int
 
-var _ I = T(0)	// GCCGO_ERROR "incompatible"
+var _ I = T(0) // GCCGO_ERROR "incompatible"
 
-func (T) m(buf []byte) (a int, b xxxx) {  // ERROR "xxxx"
+func (T) m(buf []byte) (a int, b xxxx) { // ERROR "xxxx"
 	return 0, nil
 }
diff --git a/test/fixedbugs/bug376.go b/test/fixedbugs/bug376.go
index cd700124fe..d4f28c33ce 100644
--- a/test/fixedbugs/bug376.go
+++ b/test/fixedbugs/bug376.go
@@ -6,5 +6,7 @@
 
 // issue 1951
 package foo
+
 import "unsafe"
-var v = unsafe.Sizeof  // ERROR "not in function call|must be called"
+
+var v = unsafe.Sizeof // ERROR "not in function call|must be called"
diff --git a/test/fixedbugs/bug377.dir/one.go b/test/fixedbugs/bug377.dir/one.go
index e29b813a48..d0829473d6 100644
--- a/test/fixedbugs/bug377.dir/one.go
+++ b/test/fixedbugs/bug377.dir/one.go
@@ -7,4 +7,3 @@ package one
 func Foo() (n int64, _ *int) {
 	return 42, nil
 }
-
diff --git a/test/fixedbugs/bug377.dir/two.go b/test/fixedbugs/bug377.dir/two.go
index 2a10812d56..9e016462c2 100644
--- a/test/fixedbugs/bug377.dir/two.go
+++ b/test/fixedbugs/bug377.dir/two.go
@@ -5,4 +5,3 @@
 package two
 
 import _ "./one"
-
diff --git a/test/fixedbugs/bug378.go b/test/fixedbugs/bug378.go
index c7b0dac313..d382e198b0 100644
--- a/test/fixedbugs/bug378.go
+++ b/test/fixedbugs/bug378.go
@@ -9,11 +9,12 @@
 package main
 
 type Header struct{}
+
 func (h Header) Method() {}
 
 var _ interface{} = Header{}
 
 func main() {
-  	type X Header
-  	var _ interface{} = X{}
+	type X Header
+	var _ interface{} = X{}
 }
diff --git a/test/fixedbugs/bug379.go b/test/fixedbugs/bug379.go
index 5638123d50..bef19ddbed 100644
--- a/test/fixedbugs/bug379.go
+++ b/test/fixedbugs/bug379.go
@@ -6,7 +6,7 @@
 
 // Issue 2452.
 
-// Check that the error messages says 
+// Check that the error messages says
 //	bug378.go:17: 1 + 2 not used
 // and not
 //	bug378.go:17: 1 not used
diff --git a/test/fixedbugs/bug380.go b/test/fixedbugs/bug380.go
index 0cb3487327..cacaec6d09 100644
--- a/test/fixedbugs/bug380.go
+++ b/test/fixedbugs/bug380.go
@@ -7,5 +7,7 @@
 // Used to cause a typechecking loop error.
 
 package pkg
+
 type T map[int]string
+
 var q = &T{}
diff --git a/test/fixedbugs/bug381.go b/test/fixedbugs/bug381.go
index a0a1c8aaa4..b04617cd8b 100644
--- a/test/fixedbugs/bug381.go
+++ b/test/fixedbugs/bug381.go
@@ -6,7 +6,7 @@
 
 // Issue 2276.
 
-// Check that the error messages says 
+// Check that the error messages says
 //	bug381.go:29: unsafe.Alignof(0) not used
 // and not
 //	bug381.go:29: 4 not used
diff --git a/test/fixedbugs/bug382.dir/pkg.go b/test/fixedbugs/bug382.dir/pkg.go
index 92fe4e335a..d66ba8a3c6 100644
--- a/test/fixedbugs/bug382.dir/pkg.go
+++ b/test/fixedbugs/bug382.dir/pkg.go
@@ -3,5 +3,7 @@
 // license that can be found in the LICENSE file.
 
 package pkg
-type T struct {}
+
+type T struct{}
+
 var E T
diff --git a/test/fixedbugs/bug383.go b/test/fixedbugs/bug383.go
index dc2ecd61fb..2520736745 100644
--- a/test/fixedbugs/bug383.go
+++ b/test/fixedbugs/bug383.go
@@ -7,7 +7,10 @@
 // Issue 2520
 
 package main
+
 func main() {
-	if 2e9 { }      // ERROR "2e.09|expected bool"
-	if 3.14+1i { }  // ERROR "3.14 . 1i|expected bool"
+	if 2e9 {
+	} // ERROR "2e.09|expected bool"
+	if 3.14 + 1i {
+	} // ERROR "3.14 . 1i|expected bool"
 }
diff --git a/test/fixedbugs/bug384.go b/test/fixedbugs/bug384.go
index d02352b478..a84dcf488a 100644
--- a/test/fixedbugs/bug384.go
+++ b/test/fixedbugs/bug384.go
@@ -9,4 +9,4 @@
 package foo
 
 // Check that we only get root cause message, no further complaints about r undefined
-func (r *indexWriter) foo() {}  // ERROR "undefined.*indexWriter"
+func (r *indexWriter) foo() {} // ERROR "undefined.*indexWriter"
diff --git a/test/fixedbugs/bug385_32.go b/test/fixedbugs/bug385_32.go
index 73a1311f32..3747141de1 100644
--- a/test/fixedbugs/bug385_32.go
+++ b/test/fixedbugs/bug385_32.go
@@ -8,8 +8,9 @@
 // Issue 2444
 
 package main
+
 func main() {
-	var arr [1000200030]int   // GC_ERROR "type .* too large"
+	var arr [1000200030]int // GC_ERROR "type .* too large"
 	arr_bkup := arr
 	_ = arr_bkup
 }
diff --git a/test/fixedbugs/bug385_64.go b/test/fixedbugs/bug385_64.go
index 0f941ca2f4..3c3790145b 100644
--- a/test/fixedbugs/bug385_64.go
+++ b/test/fixedbugs/bug385_64.go
@@ -10,214 +10,420 @@
 
 package main
 
-var z [10<<20]byte
+var z [10 << 20]byte
 
 func main() { // GC_ERROR "stack frame too large"
 	// seq 1 206 | sed 's/.*/	var x& [10<<20]byte; z = x&/'
-	var x1 [10<<20]byte; z = x1
-	var x2 [10<<20]byte; z = x2
-	var x3 [10<<20]byte; z = x3
-	var x4 [10<<20]byte; z = x4
-	var x5 [10<<20]byte; z = x5
-	var x6 [10<<20]byte; z = x6
-	var x7 [10<<20]byte; z = x7
-	var x8 [10<<20]byte; z = x8
-	var x9 [10<<20]byte; z = x9
-	var x10 [10<<20]byte; z = x10
-	var x11 [10<<20]byte; z = x11
-	var x12 [10<<20]byte; z = x12
-	var x13 [10<<20]byte; z = x13
-	var x14 [10<<20]byte; z = x14
-	var x15 [10<<20]byte; z = x15
-	var x16 [10<<20]byte; z = x16
-	var x17 [10<<20]byte; z = x17
-	var x18 [10<<20]byte; z = x18
-	var x19 [10<<20]byte; z = x19
-	var x20 [10<<20]byte; z = x20
-	var x21 [10<<20]byte; z = x21
-	var x22 [10<<20]byte; z = x22
-	var x23 [10<<20]byte; z = x23
-	var x24 [10<<20]byte; z = x24
-	var x25 [10<<20]byte; z = x25
-	var x26 [10<<20]byte; z = x26
-	var x27 [10<<20]byte; z = x27
-	var x28 [10<<20]byte; z = x28
-	var x29 [10<<20]byte; z = x29
-	var x30 [10<<20]byte; z = x30
-	var x31 [10<<20]byte; z = x31
-	var x32 [10<<20]byte; z = x32
-	var x33 [10<<20]byte; z = x33
-	var x34 [10<<20]byte; z = x34
-	var x35 [10<<20]byte; z = x35
-	var x36 [10<<20]byte; z = x36
-	var x37 [10<<20]byte; z = x37
-	var x38 [10<<20]byte; z = x38
-	var x39 [10<<20]byte; z = x39
-	var x40 [10<<20]byte; z = x40
-	var x41 [10<<20]byte; z = x41
-	var x42 [10<<20]byte; z = x42
-	var x43 [10<<20]byte; z = x43
-	var x44 [10<<20]byte; z = x44
-	var x45 [10<<20]byte; z = x45
-	var x46 [10<<20]byte; z = x46
-	var x47 [10<<20]byte; z = x47
-	var x48 [10<<20]byte; z = x48
-	var x49 [10<<20]byte; z = x49
-	var x50 [10<<20]byte; z = x50
-	var x51 [10<<20]byte; z = x51
-	var x52 [10<<20]byte; z = x52
-	var x53 [10<<20]byte; z = x53
-	var x54 [10<<20]byte; z = x54
-	var x55 [10<<20]byte; z = x55
-	var x56 [10<<20]byte; z = x56
-	var x57 [10<<20]byte; z = x57
-	var x58 [10<<20]byte; z = x58
-	var x59 [10<<20]byte; z = x59
-	var x60 [10<<20]byte; z = x60
-	var x61 [10<<20]byte; z = x61
-	var x62 [10<<20]byte; z = x62
-	var x63 [10<<20]byte; z = x63
-	var x64 [10<<20]byte; z = x64
-	var x65 [10<<20]byte; z = x65
-	var x66 [10<<20]byte; z = x66
-	var x67 [10<<20]byte; z = x67
-	var x68 [10<<20]byte; z = x68
-	var x69 [10<<20]byte; z = x69
-	var x70 [10<<20]byte; z = x70
-	var x71 [10<<20]byte; z = x71
-	var x72 [10<<20]byte; z = x72
-	var x73 [10<<20]byte; z = x73
-	var x74 [10<<20]byte; z = x74
-	var x75 [10<<20]byte; z = x75
-	var x76 [10<<20]byte; z = x76
-	var x77 [10<<20]byte; z = x77
-	var x78 [10<<20]byte; z = x78
-	var x79 [10<<20]byte; z = x79
-	var x80 [10<<20]byte; z = x80
-	var x81 [10<<20]byte; z = x81
-	var x82 [10<<20]byte; z = x82
-	var x83 [10<<20]byte; z = x83
-	var x84 [10<<20]byte; z = x84
-	var x85 [10<<20]byte; z = x85
-	var x86 [10<<20]byte; z = x86
-	var x87 [10<<20]byte; z = x87
-	var x88 [10<<20]byte; z = x88
-	var x89 [10<<20]byte; z = x89
-	var x90 [10<<20]byte; z = x90
-	var x91 [10<<20]byte; z = x91
-	var x92 [10<<20]byte; z = x92
-	var x93 [10<<20]byte; z = x93
-	var x94 [10<<20]byte; z = x94
-	var x95 [10<<20]byte; z = x95
-	var x96 [10<<20]byte; z = x96
-	var x97 [10<<20]byte; z = x97
-	var x98 [10<<20]byte; z = x98
-	var x99 [10<<20]byte; z = x99
-	var x100 [10<<20]byte; z = x100
-	var x101 [10<<20]byte; z = x101
-	var x102 [10<<20]byte; z = x102
-	var x103 [10<<20]byte; z = x103
-	var x104 [10<<20]byte; z = x104
-	var x105 [10<<20]byte; z = x105
-	var x106 [10<<20]byte; z = x106
-	var x107 [10<<20]byte; z = x107
-	var x108 [10<<20]byte; z = x108
-	var x109 [10<<20]byte; z = x109
-	var x110 [10<<20]byte; z = x110
-	var x111 [10<<20]byte; z = x111
-	var x112 [10<<20]byte; z = x112
-	var x113 [10<<20]byte; z = x113
-	var x114 [10<<20]byte; z = x114
-	var x115 [10<<20]byte; z = x115
-	var x116 [10<<20]byte; z = x116
-	var x117 [10<<20]byte; z = x117
-	var x118 [10<<20]byte; z = x118
-	var x119 [10<<20]byte; z = x119
-	var x120 [10<<20]byte; z = x120
-	var x121 [10<<20]byte; z = x121
-	var x122 [10<<20]byte; z = x122
-	var x123 [10<<20]byte; z = x123
-	var x124 [10<<20]byte; z = x124
-	var x125 [10<<20]byte; z = x125
-	var x126 [10<<20]byte; z = x126
-	var x127 [10<<20]byte; z = x127
-	var x128 [10<<20]byte; z = x128
-	var x129 [10<<20]byte; z = x129
-	var x130 [10<<20]byte; z = x130
-	var x131 [10<<20]byte; z = x131
-	var x132 [10<<20]byte; z = x132
-	var x133 [10<<20]byte; z = x133
-	var x134 [10<<20]byte; z = x134
-	var x135 [10<<20]byte; z = x135
-	var x136 [10<<20]byte; z = x136
-	var x137 [10<<20]byte; z = x137
-	var x138 [10<<20]byte; z = x138
-	var x139 [10<<20]byte; z = x139
-	var x140 [10<<20]byte; z = x140
-	var x141 [10<<20]byte; z = x141
-	var x142 [10<<20]byte; z = x142
-	var x143 [10<<20]byte; z = x143
-	var x144 [10<<20]byte; z = x144
-	var x145 [10<<20]byte; z = x145
-	var x146 [10<<20]byte; z = x146
-	var x147 [10<<20]byte; z = x147
-	var x148 [10<<20]byte; z = x148
-	var x149 [10<<20]byte; z = x149
-	var x150 [10<<20]byte; z = x150
-	var x151 [10<<20]byte; z = x151
-	var x152 [10<<20]byte; z = x152
-	var x153 [10<<20]byte; z = x153
-	var x154 [10<<20]byte; z = x154
-	var x155 [10<<20]byte; z = x155
-	var x156 [10<<20]byte; z = x156
-	var x157 [10<<20]byte; z = x157
-	var x158 [10<<20]byte; z = x158
-	var x159 [10<<20]byte; z = x159
-	var x160 [10<<20]byte; z = x160
-	var x161 [10<<20]byte; z = x161
-	var x162 [10<<20]byte; z = x162
-	var x163 [10<<20]byte; z = x163
-	var x164 [10<<20]byte; z = x164
-	var x165 [10<<20]byte; z = x165
-	var x166 [10<<20]byte; z = x166
-	var x167 [10<<20]byte; z = x167
-	var x168 [10<<20]byte; z = x168
-	var x169 [10<<20]byte; z = x169
-	var x170 [10<<20]byte; z = x170
-	var x171 [10<<20]byte; z = x171
-	var x172 [10<<20]byte; z = x172
-	var x173 [10<<20]byte; z = x173
-	var x174 [10<<20]byte; z = x174
-	var x175 [10<<20]byte; z = x175
-	var x176 [10<<20]byte; z = x176
-	var x177 [10<<20]byte; z = x177
-	var x178 [10<<20]byte; z = x178
-	var x179 [10<<20]byte; z = x179
-	var x180 [10<<20]byte; z = x180
-	var x181 [10<<20]byte; z = x181
-	var x182 [10<<20]byte; z = x182
-	var x183 [10<<20]byte; z = x183
-	var x184 [10<<20]byte; z = x184
-	var x185 [10<<20]byte; z = x185
-	var x186 [10<<20]byte; z = x186
-	var x187 [10<<20]byte; z = x187
-	var x188 [10<<20]byte; z = x188
-	var x189 [10<<20]byte; z = x189
-	var x190 [10<<20]byte; z = x190
-	var x191 [10<<20]byte; z = x191
-	var x192 [10<<20]byte; z = x192
-	var x193 [10<<20]byte; z = x193
-	var x194 [10<<20]byte; z = x194
-	var x195 [10<<20]byte; z = x195
-	var x196 [10<<20]byte; z = x196
-	var x197 [10<<20]byte; z = x197
-	var x198 [10<<20]byte; z = x198
-	var x199 [10<<20]byte; z = x199
-	var x200 [10<<20]byte; z = x200
-	var x201 [10<<20]byte; z = x201
-	var x202 [10<<20]byte; z = x202
-	var x203 [10<<20]byte; z = x203
-	var x204 [10<<20]byte; z = x204
-	var x205 [10<<20]byte; z = x205
-	var x206 [10<<20]byte; z = x206
+	var x1 [10 << 20]byte
+	z = x1
+	var x2 [10 << 20]byte
+	z = x2
+	var x3 [10 << 20]byte
+	z = x3
+	var x4 [10 << 20]byte
+	z = x4
+	var x5 [10 << 20]byte
+	z = x5
+	var x6 [10 << 20]byte
+	z = x6
+	var x7 [10 << 20]byte
+	z = x7
+	var x8 [10 << 20]byte
+	z = x8
+	var x9 [10 << 20]byte
+	z = x9
+	var x10 [10 << 20]byte
+	z = x10
+	var x11 [10 << 20]byte
+	z = x11
+	var x12 [10 << 20]byte
+	z = x12
+	var x13 [10 << 20]byte
+	z = x13
+	var x14 [10 << 20]byte
+	z = x14
+	var x15 [10 << 20]byte
+	z = x15
+	var x16 [10 << 20]byte
+	z = x16
+	var x17 [10 << 20]byte
+	z = x17
+	var x18 [10 << 20]byte
+	z = x18
+	var x19 [10 << 20]byte
+	z = x19
+	var x20 [10 << 20]byte
+	z = x20
+	var x21 [10 << 20]byte
+	z = x21
+	var x22 [10 << 20]byte
+	z = x22
+	var x23 [10 << 20]byte
+	z = x23
+	var x24 [10 << 20]byte
+	z = x24
+	var x25 [10 << 20]byte
+	z = x25
+	var x26 [10 << 20]byte
+	z = x26
+	var x27 [10 << 20]byte
+	z = x27
+	var x28 [10 << 20]byte
+	z = x28
+	var x29 [10 << 20]byte
+	z = x29
+	var x30 [10 << 20]byte
+	z = x30
+	var x31 [10 << 20]byte
+	z = x31
+	var x32 [10 << 20]byte
+	z = x32
+	var x33 [10 << 20]byte
+	z = x33
+	var x34 [10 << 20]byte
+	z = x34
+	var x35 [10 << 20]byte
+	z = x35
+	var x36 [10 << 20]byte
+	z = x36
+	var x37 [10 << 20]byte
+	z = x37
+	var x38 [10 << 20]byte
+	z = x38
+	var x39 [10 << 20]byte
+	z = x39
+	var x40 [10 << 20]byte
+	z = x40
+	var x41 [10 << 20]byte
+	z = x41
+	var x42 [10 << 20]byte
+	z = x42
+	var x43 [10 << 20]byte
+	z = x43
+	var x44 [10 << 20]byte
+	z = x44
+	var x45 [10 << 20]byte
+	z = x45
+	var x46 [10 << 20]byte
+	z = x46
+	var x47 [10 << 20]byte
+	z = x47
+	var x48 [10 << 20]byte
+	z = x48
+	var x49 [10 << 20]byte
+	z = x49
+	var x50 [10 << 20]byte
+	z = x50
+	var x51 [10 << 20]byte
+	z = x51
+	var x52 [10 << 20]byte
+	z = x52
+	var x53 [10 << 20]byte
+	z = x53
+	var x54 [10 << 20]byte
+	z = x54
+	var x55 [10 << 20]byte
+	z = x55
+	var x56 [10 << 20]byte
+	z = x56
+	var x57 [10 << 20]byte
+	z = x57
+	var x58 [10 << 20]byte
+	z = x58
+	var x59 [10 << 20]byte
+	z = x59
+	var x60 [10 << 20]byte
+	z = x60
+	var x61 [10 << 20]byte
+	z = x61
+	var x62 [10 << 20]byte
+	z = x62
+	var x63 [10 << 20]byte
+	z = x63
+	var x64 [10 << 20]byte
+	z = x64
+	var x65 [10 << 20]byte
+	z = x65
+	var x66 [10 << 20]byte
+	z = x66
+	var x67 [10 << 20]byte
+	z = x67
+	var x68 [10 << 20]byte
+	z = x68
+	var x69 [10 << 20]byte
+	z = x69
+	var x70 [10 << 20]byte
+	z = x70
+	var x71 [10 << 20]byte
+	z = x71
+	var x72 [10 << 20]byte
+	z = x72
+	var x73 [10 << 20]byte
+	z = x73
+	var x74 [10 << 20]byte
+	z = x74
+	var x75 [10 << 20]byte
+	z = x75
+	var x76 [10 << 20]byte
+	z = x76
+	var x77 [10 << 20]byte
+	z = x77
+	var x78 [10 << 20]byte
+	z = x78
+	var x79 [10 << 20]byte
+	z = x79
+	var x80 [10 << 20]byte
+	z = x80
+	var x81 [10 << 20]byte
+	z = x81
+	var x82 [10 << 20]byte
+	z = x82
+	var x83 [10 << 20]byte
+	z = x83
+	var x84 [10 << 20]byte
+	z = x84
+	var x85 [10 << 20]byte
+	z = x85
+	var x86 [10 << 20]byte
+	z = x86
+	var x87 [10 << 20]byte
+	z = x87
+	var x88 [10 << 20]byte
+	z = x88
+	var x89 [10 << 20]byte
+	z = x89
+	var x90 [10 << 20]byte
+	z = x90
+	var x91 [10 << 20]byte
+	z = x91
+	var x92 [10 << 20]byte
+	z = x92
+	var x93 [10 << 20]byte
+	z = x93
+	var x94 [10 << 20]byte
+	z = x94
+	var x95 [10 << 20]byte
+	z = x95
+	var x96 [10 << 20]byte
+	z = x96
+	var x97 [10 << 20]byte
+	z = x97
+	var x98 [10 << 20]byte
+	z = x98
+	var x99 [10 << 20]byte
+	z = x99
+	var x100 [10 << 20]byte
+	z = x100
+	var x101 [10 << 20]byte
+	z = x101
+	var x102 [10 << 20]byte
+	z = x102
+	var x103 [10 << 20]byte
+	z = x103
+	var x104 [10 << 20]byte
+	z = x104
+	var x105 [10 << 20]byte
+	z = x105
+	var x106 [10 << 20]byte
+	z = x106
+	var x107 [10 << 20]byte
+	z = x107
+	var x108 [10 << 20]byte
+	z = x108
+	var x109 [10 << 20]byte
+	z = x109
+	var x110 [10 << 20]byte
+	z = x110
+	var x111 [10 << 20]byte
+	z = x111
+	var x112 [10 << 20]byte
+	z = x112
+	var x113 [10 << 20]byte
+	z = x113
+	var x114 [10 << 20]byte
+	z = x114
+	var x115 [10 << 20]byte
+	z = x115
+	var x116 [10 << 20]byte
+	z = x116
+	var x117 [10 << 20]byte
+	z = x117
+	var x118 [10 << 20]byte
+	z = x118
+	var x119 [10 << 20]byte
+	z = x119
+	var x120 [10 << 20]byte
+	z = x120
+	var x121 [10 << 20]byte
+	z = x121
+	var x122 [10 << 20]byte
+	z = x122
+	var x123 [10 << 20]byte
+	z = x123
+	var x124 [10 << 20]byte
+	z = x124
+	var x125 [10 << 20]byte
+	z = x125
+	var x126 [10 << 20]byte
+	z = x126
+	var x127 [10 << 20]byte
+	z = x127
+	var x128 [10 << 20]byte
+	z = x128
+	var x129 [10 << 20]byte
+	z = x129
+	var x130 [10 << 20]byte
+	z = x130
+	var x131 [10 << 20]byte
+	z = x131
+	var x132 [10 << 20]byte
+	z = x132
+	var x133 [10 << 20]byte
+	z = x133
+	var x134 [10 << 20]byte
+	z = x134
+	var x135 [10 << 20]byte
+	z = x135
+	var x136 [10 << 20]byte
+	z = x136
+	var x137 [10 << 20]byte
+	z = x137
+	var x138 [10 << 20]byte
+	z = x138
+	var x139 [10 << 20]byte
+	z = x139
+	var x140 [10 << 20]byte
+	z = x140
+	var x141 [10 << 20]byte
+	z = x141
+	var x142 [10 << 20]byte
+	z = x142
+	var x143 [10 << 20]byte
+	z = x143
+	var x144 [10 << 20]byte
+	z = x144
+	var x145 [10 << 20]byte
+	z = x145
+	var x146 [10 << 20]byte
+	z = x146
+	var x147 [10 << 20]byte
+	z = x147
+	var x148 [10 << 20]byte
+	z = x148
+	var x149 [10 << 20]byte
+	z = x149
+	var x150 [10 << 20]byte
+	z = x150
+	var x151 [10 << 20]byte
+	z = x151
+	var x152 [10 << 20]byte
+	z = x152
+	var x153 [10 << 20]byte
+	z = x153
+	var x154 [10 << 20]byte
+	z = x154
+	var x155 [10 << 20]byte
+	z = x155
+	var x156 [10 << 20]byte
+	z = x156
+	var x157 [10 << 20]byte
+	z = x157
+	var x158 [10 << 20]byte
+	z = x158
+	var x159 [10 << 20]byte
+	z = x159
+	var x160 [10 << 20]byte
+	z = x160
+	var x161 [10 << 20]byte
+	z = x161
+	var x162 [10 << 20]byte
+	z = x162
+	var x163 [10 << 20]byte
+	z = x163
+	var x164 [10 << 20]byte
+	z = x164
+	var x165 [10 << 20]byte
+	z = x165
+	var x166 [10 << 20]byte
+	z = x166
+	var x167 [10 << 20]byte
+	z = x167
+	var x168 [10 << 20]byte
+	z = x168
+	var x169 [10 << 20]byte
+	z = x169
+	var x170 [10 << 20]byte
+	z = x170
+	var x171 [10 << 20]byte
+	z = x171
+	var x172 [10 << 20]byte
+	z = x172
+	var x173 [10 << 20]byte
+	z = x173
+	var x174 [10 << 20]byte
+	z = x174
+	var x175 [10 << 20]byte
+	z = x175
+	var x176 [10 << 20]byte
+	z = x176
+	var x177 [10 << 20]byte
+	z = x177
+	var x178 [10 << 20]byte
+	z = x178
+	var x179 [10 << 20]byte
+	z = x179
+	var x180 [10 << 20]byte
+	z = x180
+	var x181 [10 << 20]byte
+	z = x181
+	var x182 [10 << 20]byte
+	z = x182
+	var x183 [10 << 20]byte
+	z = x183
+	var x184 [10 << 20]byte
+	z = x184
+	var x185 [10 << 20]byte
+	z = x185
+	var x186 [10 << 20]byte
+	z = x186
+	var x187 [10 << 20]byte
+	z = x187
+	var x188 [10 << 20]byte
+	z = x188
+	var x189 [10 << 20]byte
+	z = x189
+	var x190 [10 << 20]byte
+	z = x190
+	var x191 [10 << 20]byte
+	z = x191
+	var x192 [10 << 20]byte
+	z = x192
+	var x193 [10 << 20]byte
+	z = x193
+	var x194 [10 << 20]byte
+	z = x194
+	var x195 [10 << 20]byte
+	z = x195
+	var x196 [10 << 20]byte
+	z = x196
+	var x197 [10 << 20]byte
+	z = x197
+	var x198 [10 << 20]byte
+	z = x198
+	var x199 [10 << 20]byte
+	z = x199
+	var x200 [10 << 20]byte
+	z = x200
+	var x201 [10 << 20]byte
+	z = x201
+	var x202 [10 << 20]byte
+	z = x202
+	var x203 [10 << 20]byte
+	z = x203
+	var x204 [10 << 20]byte
+	z = x204
+	var x205 [10 << 20]byte
+	z = x205
+	var x206 [10 << 20]byte
+	z = x206
 }
diff --git a/test/fixedbugs/bug386.go b/test/fixedbugs/bug386.go
index 889c8b0c12..92fc33bb36 100644
--- a/test/fixedbugs/bug386.go
+++ b/test/fixedbugs/bug386.go
@@ -4,9 +4,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Issue 2451, 2452 
+// Issue 2451, 2452
 package foo
 
 func f() error { return 0 } // ERROR "cannot use 0 .type int.|has no methods"
 
-func g() error { return -1 }  // ERROR "cannot use -1 .type int.|has no methods"
+func g() error { return -1 } // ERROR "cannot use -1 .type int.|has no methods"
diff --git a/test/fixedbugs/bug387.go b/test/fixedbugs/bug387.go
index d885445744..2e30bc42a3 100644
--- a/test/fixedbugs/bug387.go
+++ b/test/fixedbugs/bug387.go
@@ -12,19 +12,18 @@ missing typecheck: [7f5bf07b4438]
 .   AS l(45)
 .   .   NAME-main.autotmp_0017 u(1) a(1) l(45) x(0+0) class(PAUTO)
 esc(N) tc(1) used(1) ARRAY-[2]string
-internal compiler error: missing typecheck 
+internal compiler error: missing typecheck
 */
 package main
 
 import (
-        "fmt"
-        "path/filepath"
+	"fmt"
+	"path/filepath"
 )
 
 func main() {
-        switch _, err := filepath.Glob(filepath.Join(".", "vnc")); {
-        case err != nil:
-                fmt.Println(err)
-        }
+	switch _, err := filepath.Glob(filepath.Join(".", "vnc")); {
+	case err != nil:
+		fmt.Println(err)
+	}
 }
-
diff --git a/test/fixedbugs/bug389.go b/test/fixedbugs/bug389.go
index 14804c8471..8f40c0e215 100644
--- a/test/fixedbugs/bug389.go
+++ b/test/fixedbugs/bug389.go
@@ -9,4 +9,4 @@ package foo
 
 func fn(a float32) {}
 
-var f func(arg int) = fn  // ERROR "cannot use fn .type func.float32.. as type func.int. in assignment|different parameter types"
+var f func(arg int) = fn // ERROR "cannot use fn .type func.float32.. as type func.int. in assignment|different parameter types"
diff --git a/test/fixedbugs/bug391.go b/test/fixedbugs/bug391.go
index 9211b1c2cf..00b84103bc 100644
--- a/test/fixedbugs/bug391.go
+++ b/test/fixedbugs/bug391.go
@@ -7,8 +7,9 @@
 // Issue 2576
 package bug
 
-type T struct { a int }
+type T struct{ a int }
 
 func f(t T) {
-        switch _, _ = t.a, t.a; {}
-}
\ No newline at end of file
+	switch _, _ = t.a, t.a; {
+	}
+}
diff --git a/test/fixedbugs/bug392.dir/one.go b/test/fixedbugs/bug392.dir/one.go
index aba8649b5b..081e25c532 100644
--- a/test/fixedbugs/bug392.dir/one.go
+++ b/test/fixedbugs/bug392.dir/one.go
@@ -18,26 +18,25 @@ func F2(c chan int) bool { return c == (<-chan int)(nil) }
 func F3() (ret []int) { return append(ret, 1) }
 
 // Call of inlined method with blank receiver.
-func (_ *T) M() int { return 1 }
+func (_ *T) M() int  { return 1 }
 func (t *T) MM() int { return t.M() }
 
-
 // One more like issue 2678
-type S struct { x, y int }
+type S struct{ x, y int }
 type U []S
 
-func F4(S int) U { return U{{S,S}} }
+func F4(S int) U { return U{{S, S}} }
 
 func F5() []*S {
-	return []*S{ {1,2}, { 3, 4} }
+	return []*S{{1, 2}, {3, 4}}
 }
 
 func F6(S int) *U {
-	return &U{{S,S}}
+	return &U{{S, S}}
 }
 
 // Bug in the fix.
 
-type PB struct { x int }
+type PB struct{ x int }
 
 func (t *PB) Reset() { *t = PB{} }
diff --git a/test/fixedbugs/bug396.dir/one.go b/test/fixedbugs/bug396.dir/one.go
index 66eba63f5c..f599959e10 100644
--- a/test/fixedbugs/bug396.dir/one.go
+++ b/test/fixedbugs/bug396.dir/one.go
@@ -5,6 +5,6 @@
 package one
 
 // Issue 2687
-type T struct { int }
+type T struct{ int }
 
 func New(i int) T { return T{i} }
diff --git a/test/fixedbugs/bug396.dir/two.go b/test/fixedbugs/bug396.dir/two.go
index 9152bec254..4e30bfab9c 100644
--- a/test/fixedbugs/bug396.dir/two.go
+++ b/test/fixedbugs/bug396.dir/two.go
@@ -11,4 +11,4 @@ import "./one"
 
 func use() {
 	_ = one.New(1)
-}
\ No newline at end of file
+}
diff --git a/test/fixedbugs/bug397.go b/test/fixedbugs/bug397.go
index 6188e3ee0c..339da2eb4b 100644
--- a/test/fixedbugs/bug397.go
+++ b/test/fixedbugs/bug397.go
@@ -7,7 +7,7 @@
 package main
 
 // Issue 2623
-var m = map[string]int {
-	"abc":1,
-	1:2, // ERROR "cannot use 1.*as type string in map key|incompatible type"
+var m = map[string]int{
+	"abc": 1,
+	1:     2, // ERROR "cannot use 1.*as type string in map key|incompatible type"
 }
diff --git a/test/fixedbugs/bug398.go b/test/fixedbugs/bug398.go
index a1583bd774..3848cd4061 100644
--- a/test/fixedbugs/bug398.go
+++ b/test/fixedbugs/bug398.go
@@ -12,33 +12,33 @@ package p
 // exported interfaces
 
 type I1 interface {
-      F() interface{I1}
+	F() interface{ I1 }
 }
 
 type I2 interface {
-      F() interface{I2}
+	F() interface{ I2 }
 }
 
 var V1 I1
 var V2 I2
 
 func F() bool {
-       return V1 == V2
+	return V1 == V2
 }
 
 // non-exported interfaces
 
 type i1 interface {
-      F() interface{i1}
+	F() interface{ i1 }
 }
 
 type i2 interface {
-      F() interface{i2}
+	F() interface{ i2 }
 }
 
 var v1 i1
 var v2 i2
 
 func f() bool {
-       return v1 == v2
+	return v1 == v2
 }
diff --git a/test/fixedbugs/bug399.go b/test/fixedbugs/bug399.go
index e460d81227..343add59da 100644
--- a/test/fixedbugs/bug399.go
+++ b/test/fixedbugs/bug399.go
@@ -7,9 +7,9 @@
 // Issue 2674
 
 package main
+
 const dow = "\000\003"
 
 func main() {
 	println(int(dow[1]))
 }
-
diff --git a/test/fixedbugs/bug405.go b/test/fixedbugs/bug405.go
index e8ecc4d034..f0c3081976 100644
--- a/test/fixedbugs/bug405.go
+++ b/test/fixedbugs/bug405.go
@@ -8,7 +8,7 @@
 
 package main
 
-type S struct {}
+type S struct{}
 
 func (_ S) F(i int) int {
 	return i
diff --git a/test/fixedbugs/bug407.dir/one.go b/test/fixedbugs/bug407.dir/one.go
index c85b077b66..fd900ef4ad 100644
--- a/test/fixedbugs/bug407.dir/one.go
+++ b/test/fixedbugs/bug407.dir/one.go
@@ -11,10 +11,7 @@ type T struct {
 }
 
 func (t *T) foo(arg int) {}
-func (t T) goo(arg int) {}
+func (t T) goo(arg int)  {}
 
 func (t *T) F() { t.f = (*T).foo }
 func (t *T) G() { t.g = T.goo }
-
-
-
diff --git a/test/fixedbugs/bug410.go b/test/fixedbugs/bug410.go
index a4eef64d8e..f0761febfa 100644
--- a/test/fixedbugs/bug410.go
+++ b/test/fixedbugs/bug410.go
@@ -12,13 +12,13 @@ type y struct {
 	num int
 }
 
-func zzz () {
-    k := make([]byte, 10)
-	arr := make ([]*y, 0)
-    for s := range arr {
-        x := make([]byte, 10)
-        for i := 0; i < 100 ; i++ {
-            x[i] ^= k[i-arr[s].num%3]
-        }
-    }
+func zzz() {
+	k := make([]byte, 10)
+	arr := make([]*y, 0)
+	for s := range arr {
+		x := make([]byte, 10)
+		for i := 0; i < 100; i++ {
+			x[i] ^= k[i-arr[s].num%3]
+		}
+	}
 }
diff --git a/test/fixedbugs/bug411.go b/test/fixedbugs/bug411.go
index a1c36f617c..7f90ae0e93 100644
--- a/test/fixedbugs/bug411.go
+++ b/test/fixedbugs/bug411.go
@@ -14,6 +14,5 @@ func f1(a int64) {
 	f2(float64(a), float64(a))
 }
 
-func f2(a,b float64) {
+func f2(a, b float64) {
 }
-
diff --git a/test/fixedbugs/bug412.go b/test/fixedbugs/bug412.go
index 183fb7e4af..a39abf17e1 100644
--- a/test/fixedbugs/bug412.go
+++ b/test/fixedbugs/bug412.go
@@ -7,10 +7,10 @@
 package p
 
 type t struct {
-	x int  // GCCGO_ERROR "duplicate field name .x."
-	x int  // GC_ERROR "duplicate field x"
+	x int // GCCGO_ERROR "duplicate field name .x."
+	x int // GC_ERROR "duplicate field x"
 }
 
 func f(t *t) int {
-	return t.x  // GC_ERROR "ambiguous selector t.x"
+	return t.x // GC_ERROR "ambiguous selector t.x"
 }
diff --git a/test/fixedbugs/bug413.go b/test/fixedbugs/bug413.go
index 819bd1a984..12e1e5e58b 100644
--- a/test/fixedbugs/bug413.go
+++ b/test/fixedbugs/bug413.go
@@ -8,4 +8,4 @@ package p
 
 func f(i int) int { return i }
 
-var i = func() int {a := f(i); return a}()  // ERROR "initialization loop|depends upon itself"
+var i = func() int { a := f(i); return a }() // ERROR "initialization loop|depends upon itself"
diff --git a/test/fixedbugs/bug415.dir/p.go b/test/fixedbugs/bug415.dir/p.go
index e86a697643..fca0124014 100644
--- a/test/fixedbugs/bug415.dir/p.go
+++ b/test/fixedbugs/bug415.dir/p.go
@@ -5,10 +5,9 @@
 package p
 
 type A struct {
-	s struct{int}
+	s struct{ int }
 }
 
 func (a *A) f() {
-	a.s = struct{int}{0}
+	a.s = struct{ int }{0}
 }
-
diff --git a/test/fixedbugs/bug415.dir/prog.go b/test/fixedbugs/bug415.dir/prog.go
index 1ffde188b7..f2a4e6dd0d 100644
--- a/test/fixedbugs/bug415.dir/prog.go
+++ b/test/fixedbugs/bug415.dir/prog.go
@@ -3,7 +3,9 @@
 // license that can be found in the LICENSE file.
 
 package main
+
 import "./p"
+
 func main() {}
-var _ p.A
 
+var _ p.A
diff --git a/test/fixedbugs/bug417.go b/test/fixedbugs/bug417.go
index a9acb42386..1b44aa927c 100644
--- a/test/fixedbugs/bug417.go
+++ b/test/fixedbugs/bug417.go
@@ -14,17 +14,19 @@ type S1 struct {
 	s [][1]S3
 	m map[int][1]S3
 	c chan [1]S3
-	i interface { f([1]S3) [1]S3 }
+	i interface{ f([1]S3) [1]S3 }
 	f func([1]S3) [1]S3
 }
 
 type S2 struct {
-	p *struct { F S3 }
-	s []struct { F S3 }
-	m map[int]struct { F S3 }
-	c chan struct { F S3 }
-	i interface { f(struct { F S3 }) struct { F S3 } }
-	f func(struct { F S3 } ) struct { F S3 }
+	p *struct{ F S3 }
+	s []struct{ F S3 }
+	m map[int]struct{ F S3 }
+	c chan struct{ F S3 }
+	i interface {
+		f(struct{ F S3 }) struct{ F S3 }
+	}
+	f func(struct{ F S3 }) struct{ F S3 }
 }
 
 type S3 struct {
diff --git a/test/fixedbugs/bug420.go b/test/fixedbugs/bug420.go
index 02b4349d80..6601597cad 100644
--- a/test/fixedbugs/bug420.go
+++ b/test/fixedbugs/bug420.go
@@ -10,5 +10,5 @@
 package main
 
 func main() {
-     (_) = 0
+	(_) = 0
 }
diff --git a/test/fixedbugs/bug421.go b/test/fixedbugs/bug421.go
index 1fe02375ab..b1f1c56275 100644
--- a/test/fixedbugs/bug421.go
+++ b/test/fixedbugs/bug421.go
@@ -10,8 +10,8 @@
 package main
 
 func main() {
-	println(int(1) == uint(1))	// ERROR "types"
+	println(int(1) == uint(1)) // ERROR "types"
 	var x int = 1
 	var y uint = 1
-	println(x == y)			// ERROR "types"
+	println(x == y) // ERROR "types"
 }
diff --git a/test/fixedbugs/bug424.dir/main.go b/test/fixedbugs/bug424.dir/main.go
index 28b41e68a7..adf01fc112 100644
--- a/test/fixedbugs/bug424.dir/main.go
+++ b/test/fixedbugs/bug424.dir/main.go
@@ -59,7 +59,7 @@ func main() {
 	if t3.m() != "main.localT.m" {
 		println("BUG: t3:", t3.m(), "called")
 	}
-	
+
 	i = new(myT3)
 	if i.m() != "main.localT.m" {
 		t := reflect.TypeOf(i)
@@ -70,7 +70,7 @@ func main() {
 		}
 		println("BUG: myT3:", i.m(), "called")
 	}
-	
+
 	var t4 struct {
 		localT
 		lib.T
@@ -82,7 +82,7 @@ func main() {
 	if i.m() != "main.localT.m" {
 		println("BUG: myT4:", i.m(), "called")
 	}
-	
+
 	var t5 struct {
 		lib.T
 		localT
diff --git a/test/fixedbugs/bug424.go b/test/fixedbugs/bug424.go
index 9c59abe802..6423961fe0 100644
--- a/test/fixedbugs/bug424.go
+++ b/test/fixedbugs/bug424.go
@@ -10,4 +10,3 @@
 // embedding is done.
 
 package ignored
-
diff --git a/test/fixedbugs/bug425.go b/test/fixedbugs/bug425.go
index c3035f6a91..a13a82c0f8 100644
--- a/test/fixedbugs/bug425.go
+++ b/test/fixedbugs/bug425.go
@@ -13,5 +13,5 @@ import "fmt"
 func main() {
 	s := "hello"
 	fmt.Println(s == "")
-	fmt.Println(s + "world" == "world")
+	fmt.Println(s+"world" == "world")
 }
diff --git a/test/fixedbugs/bug427.go b/test/fixedbugs/bug427.go
index c13bb815ca..a1b3f5b7fa 100644
--- a/test/fixedbugs/bug427.go
+++ b/test/fixedbugs/bug427.go
@@ -9,10 +9,10 @@
 package main
 
 // struct with four fields of basic type
-type S struct {a, b, c, d int}
+type S struct{ a, b, c, d int }
 
 // struct with five fields of basic type
-type T struct {a, b, c, d, e int}
+type T struct{ a, b, c, d, e int }
 
 // array with four elements
 type A [4]int
diff --git a/test/fixedbugs/bug439.go b/test/fixedbugs/bug439.go
index 87d4ae0373..1ad7b7f443 100644
--- a/test/fixedbugs/bug439.go
+++ b/test/fixedbugs/bug439.go
@@ -14,7 +14,7 @@ func (e E) P() *E { return &e }
 
 const (
 	C1 E = 0
-	C2 = C1
+	C2   = C1
 )
 
 func F() *E {
diff --git a/test/fixedbugs/bug441.go b/test/fixedbugs/bug441.go
index b67125b1e8..a0b051e62f 100644
--- a/test/fixedbugs/bug441.go
+++ b/test/fixedbugs/bug441.go
@@ -23,11 +23,13 @@ func main() {
 	}
 }
 
-func foo(_ int) {}
+func foo(_ int)     {}
 func foo2(_, _ int) {}
 func foo3(int, int) {}
+
 type T int
-func (_ T) m1() {}
+
+func (_ T) m1()      {}
 func (t T) m2(_ int) {}
 
 func side() int {
diff --git a/test/fixedbugs/bug442.go b/test/fixedbugs/bug442.go
index 684d54ffbb..c3e1d5b20f 100644
--- a/test/fixedbugs/bug442.go
+++ b/test/fixedbugs/bug442.go
@@ -20,7 +20,7 @@ func main() {
 	m := map[T]int{}
 	m[T{X: 1, Y: 2}] = 1
 	m[T{X: 2, Y: 3}] = 2
-	m[T{X: 1, Y: 2}] = 3  // overwrites first entry
+	m[T{X: 1, Y: 2}] = 3 // overwrites first entry
 	if len(m) != 2 {
 		println("BUG")
 	}
diff --git a/test/fixedbugs/bug443.go b/test/fixedbugs/bug443.go
index 9abd2548a5..eaa3d55823 100644
--- a/test/fixedbugs/bug443.go
+++ b/test/fixedbugs/bug443.go
@@ -9,9 +9,9 @@
 
 package p
 
-type T1 struct { F *T2 }
+type T1 struct{ F *T2 }
 type T2 T1
 
 type T3 T2
-func (*T3) M()  // was invalid receiver
 
+func (*T3) M() // was invalid receiver
diff --git a/test/fixedbugs/bug444.go b/test/fixedbugs/bug444.go
index 29a60f590f..69c5bd8e59 100644
--- a/test/fixedbugs/bug444.go
+++ b/test/fixedbugs/bug444.go
@@ -12,14 +12,14 @@ package main
 
 import "reflect"
 
-type T interface {}
+type T interface{}
 
 var x bool
 
 func main() {
-        reflect.TypeOf(nil)
-        reflect.TypeOf(T(nil)) // used to miscompile
-        shouldPanic()
+	reflect.TypeOf(nil)
+	reflect.TypeOf(T(nil)) // used to miscompile
+	shouldPanic()
 }
 
 func f() byte {
diff --git a/test/fixedbugs/bug446.go b/test/fixedbugs/bug446.go
index 1e435e1109..580415c181 100644
--- a/test/fixedbugs/bug446.go
+++ b/test/fixedbugs/bug446.go
@@ -33,4 +33,3 @@ func main() {
 		panic("dummy2 != 2")
 	}
 }
-
diff --git a/test/fixedbugs/bug447.go b/test/fixedbugs/bug447.go
index 8358f0034f..db3b8404ec 100644
--- a/test/fixedbugs/bug447.go
+++ b/test/fixedbugs/bug447.go
@@ -16,8 +16,8 @@ import (
 )
 
 var (
-	intWidths = []int{8, 16, 32, 64} // int%d and uint%d
-	floatWidths = []int{32, 64} // float%d
+	intWidths   = []int{8, 16, 32, 64} // int%d and uint%d
+	floatWidths = []int{32, 64}        // float%d
 )
 
 func main() {
@@ -59,8 +59,7 @@ const testSegment = `
 		}
 	}`
 
-const testFunc =
-`func test$I(f float64, i int64) {
+const testFunc = `func test$I(f float64, i int64) {
 	if i != int64($I(i))$TEST {
 		return
 	}
@@ -68,8 +67,7 @@ $TESTSEGMENTS
 }
 `
 
-var program =
-`package main
+var program = `package main
 
 import (
 	"fmt"
diff --git a/test/fixedbugs/bug448.dir/pkg2.go b/test/fixedbugs/bug448.dir/pkg2.go
index 20d850915d..8eee8e88dd 100644
--- a/test/fixedbugs/bug448.dir/pkg2.go
+++ b/test/fixedbugs/bug448.dir/pkg2.go
@@ -11,4 +11,3 @@ import "./pkg1"
 func F() {
 	pkg1.Do()
 }
-
diff --git a/test/fixedbugs/bug460.go b/test/fixedbugs/bug460.go
index a1b6f477ff..130d190cb3 100644
--- a/test/fixedbugs/bug460.go
+++ b/test/fixedbugs/bug460.go
@@ -7,4 +7,3 @@
 // part one of issue 4124. Make sure that the compiler rejects access attempts.
 
 package ignored
-
diff --git a/test/fixedbugs/bug462.go b/test/fixedbugs/bug462.go
index 3df63b091d..4765e18afd 100644
--- a/test/fixedbugs/bug462.go
+++ b/test/fixedbugs/bug462.go
@@ -13,7 +13,7 @@ type T struct {
 }
 
 func main() {
-	_ = T {
+	_ = T{
 		os.File: 1, // ERROR "unknown T? ?field"
 	}
 }
diff --git a/test/fixedbugs/bug466.dir/a.go b/test/fixedbugs/bug466.dir/a.go
index e27699c2ef..21fe0a6062 100644
--- a/test/fixedbugs/bug466.dir/a.go
+++ b/test/fixedbugs/bug466.dir/a.go
@@ -4,7 +4,7 @@
 
 package a
 
-const N = 2+3i
+const N = 2 + 3i
 
 func Func() []complex128 {
 	return []complex128{1, complex(2, 3), complex(4, 5)}
diff --git a/test/fixedbugs/bug466.go b/test/fixedbugs/bug466.go
index dc909d483c..c2a15ef707 100644
--- a/test/fixedbugs/bug466.go
+++ b/test/fixedbugs/bug466.go
@@ -8,4 +8,3 @@
 // complex literals "a+bi" to "a+b".
 
 package ignored
-
diff --git a/test/fixedbugs/bug468.dir/p1.go b/test/fixedbugs/bug468.dir/p1.go
index cdda735e96..b35e08acb4 100644
--- a/test/fixedbugs/bug468.dir/p1.go
+++ b/test/fixedbugs/bug468.dir/p1.go
@@ -4,4 +4,4 @@
 
 package p1
 
-type S struct { X, Y int }
+type S struct{ X, Y int }
diff --git a/test/fixedbugs/bug468.dir/p2.go b/test/fixedbugs/bug468.dir/p2.go
index dbb46931b8..42deea8bd5 100644
--- a/test/fixedbugs/bug468.dir/p2.go
+++ b/test/fixedbugs/bug468.dir/p2.go
@@ -12,7 +12,7 @@ import (
 
 func main() {
 	var v1 = p1.S{1, 2}
-	var v2 = struct { X, Y int }{1, 2}
+	var v2 = struct{ X, Y int }{1, 2}
 	v1 = v2
 	t1 := reflect.TypeOf(v1)
 	t2 := reflect.TypeOf(v2)
diff --git a/test/fixedbugs/bug470.go b/test/fixedbugs/bug470.go
index c21663f3f3..72326b6e85 100644
--- a/test/fixedbugs/bug470.go
+++ b/test/fixedbugs/bug470.go
@@ -11,8 +11,8 @@ package main
 import "fmt"
 
 const (
-    F32 = 0.00999999977648258209228515625
-    F64 = 0.01000000000000000020816681711721685132943093776702880859375
+	F32 = 0.00999999977648258209228515625
+	F64 = 0.01000000000000000020816681711721685132943093776702880859375
 )
 
 var F = float64(float32(0.01))
diff --git a/test/fixedbugs/bug479.dir/a.go b/test/fixedbugs/bug479.dir/a.go
index eddb4cf078..424fc45d30 100644
--- a/test/fixedbugs/bug479.dir/a.go
+++ b/test/fixedbugs/bug479.dir/a.go
@@ -6,7 +6,7 @@ package p
 
 import "unsafe"
 
-type S2 struct {}
+type S2 struct{}
 
 const C = unsafe.Sizeof(S2{})
 
diff --git a/test/fixedbugs/bug480.dir/a.go b/test/fixedbugs/bug480.dir/a.go
index 26a8d11669..cd87d87f2d 100644
--- a/test/fixedbugs/bug480.dir/a.go
+++ b/test/fixedbugs/bug480.dir/a.go
@@ -4,7 +4,7 @@
 
 package a
 
-type S interface{
+type S interface {
 	F() T
 }
 
diff --git a/test/fixedbugs/bug486.go b/test/fixedbugs/bug486.go
index 9ad23b3cfc..dce43f4b0e 100644
--- a/test/fixedbugs/bug486.go
+++ b/test/fixedbugs/bug486.go
@@ -11,4 +11,4 @@
 package main
 
 /*// comment
-*/
+ */
diff --git a/test/fixedbugs/bug487.go b/test/fixedbugs/bug487.go
index ab61a19a94..c61dcb0f31 100644
--- a/test/fixedbugs/bug487.go
+++ b/test/fixedbugs/bug487.go
@@ -14,11 +14,11 @@ func G() (int, int, int) {
 }
 
 func F() {
-	a, b := G()	// ERROR "assignment mismatch"
-	a, b = G()	// ERROR "assignment mismatch"
+	a, b := G() // ERROR "assignment mismatch"
+	a, b = G()  // ERROR "assignment mismatch"
 	_, _ = a, b
 }
 
 func H() (int, int) {
-	return G()	// ERROR "too many|mismatch"
+	return G() // ERROR "too many|mismatch"
 }
diff --git a/test/fixedbugs/bug488.dir/a.go b/test/fixedbugs/bug488.dir/a.go
index fc494207a1..798011414e 100644
--- a/test/fixedbugs/bug488.dir/a.go
+++ b/test/fixedbugs/bug488.dir/a.go
@@ -4,4 +4,4 @@
 
 package a
 
-var p2 = Printf		// ERROR "undefined"
+var p2 = Printf // ERROR "undefined"
diff --git a/test/fixedbugs/bug490.go b/test/fixedbugs/bug490.go
index 387a680aee..1d8b29d037 100644
--- a/test/fixedbugs/bug490.go
+++ b/test/fixedbugs/bug490.go
@@ -8,7 +8,7 @@
 // interface and an empty struct literal.
 
 package p
- 
+
 type S struct{}
 
 func F(v interface{}) bool {
diff --git a/test/fixedbugs/bug491.go b/test/fixedbugs/bug491.go
index 39a3509c69..6bc7b470f0 100644
--- a/test/fixedbugs/bug491.go
+++ b/test/fixedbugs/bug491.go
@@ -107,4 +107,4 @@ func bug() {
 		println("BUG")
 		bugged = true
 	}
-}
\ No newline at end of file
+}
diff --git a/test/fixedbugs/bug500.go b/test/fixedbugs/bug500.go
index 2dd5df13b0..e57de98b60 100644
--- a/test/fixedbugs/bug500.go
+++ b/test/fixedbugs/bug500.go
@@ -35,7 +35,7 @@ func init() {
 
 func main() {
 	runtime.GC()
-	if a[0].str != b + c {
+	if a[0].str != b+c {
 		panic(a[0].str)
 	}
 }
diff --git a/test/fixedbugs/gcc61264.go b/test/fixedbugs/gcc61264.go
index a4092f5bec..569f601bc8 100644
--- a/test/fixedbugs/gcc61264.go
+++ b/test/fixedbugs/gcc61264.go
@@ -9,5 +9,5 @@
 package main
 
 func main() {
-        map[int]int{}[0]++
+	map[int]int{}[0]++
 }
diff --git a/test/fixedbugs/gcc67968.dir/b.go b/test/fixedbugs/gcc67968.dir/b.go
index 41b62d2088..dd9eddae31 100644
--- a/test/fixedbugs/gcc67968.dir/b.go
+++ b/test/fixedbugs/gcc67968.dir/b.go
@@ -6,7 +6,7 @@ package b
 
 import "./a"
 
-func F() (interface{}) {
-     var v *a.T
-     return v.Foo()
+func F() interface{} {
+	var v *a.T
+	return v.Foo()
 }
diff --git a/test/fixedbugs/issue10607a.go b/test/fixedbugs/issue10607a.go
index 51399e4ecf..92a7474fa1 100644
--- a/test/fixedbugs/issue10607a.go
+++ b/test/fixedbugs/issue10607a.go
@@ -54,7 +54,7 @@ func main() {
 
 			// 3 == NT_GNU_BUILD_ID
 			if typ == 3 && namesz == 4 && bytes.Equal(d[12:16], []byte("GNU\000")) {
-				id := string(d[12+an:12+an+descsz])
+				id := string(d[12+an : 12+an+descsz])
 				if id == "\x12\x34\x56\x78" {
 					c++
 				} else {
diff --git a/test/fixedbugs/issue11326.go b/test/fixedbugs/issue11326.go
index 82754c73fb..178f1335b6 100644
--- a/test/fixedbugs/issue11326.go
+++ b/test/fixedbugs/issue11326.go
@@ -18,14 +18,14 @@ func main() {
 
 	// Any implementation must be able to handle these constants at
 	// compile time (even though they cannot be assigned to a float64).
-	var _ = 1e646456992  // ERROR "1e\+646456992 overflows float64"
-	var _ = 1e64645699   // ERROR "1e\+64645699 overflows float64"
-	var _ = 1e6464569    // ERROR "1e\+6464569 overflows float64"
-	var _ = 1e646456     // ERROR "1e\+646456 overflows float64"
-	var _ = 1e64645      // ERROR "1e\+64645 overflows float64"
-	var _ = 1e6464       // ERROR "1e\+6464 overflows float64"
-	var _ = 1e646        // ERROR "1e\+646 overflows float64"
-	var _ = 1e309        // ERROR "1e\+309 overflows float64"
+	var _ = 1e646456992 // ERROR "1e\+646456992 overflows float64"
+	var _ = 1e64645699  // ERROR "1e\+64645699 overflows float64"
+	var _ = 1e6464569   // ERROR "1e\+6464569 overflows float64"
+	var _ = 1e646456    // ERROR "1e\+646456 overflows float64"
+	var _ = 1e64645     // ERROR "1e\+64645 overflows float64"
+	var _ = 1e6464      // ERROR "1e\+6464 overflows float64"
+	var _ = 1e646       // ERROR "1e\+646 overflows float64"
+	var _ = 1e309       // ERROR "1e\+309 overflows float64"
 
 	var _ = 1e308
 }
diff --git a/test/fixedbugs/issue11361.go b/test/fixedbugs/issue11361.go
index 1260ea89c9..f9fa6a4ea3 100644
--- a/test/fixedbugs/issue11361.go
+++ b/test/fixedbugs/issue11361.go
@@ -6,6 +6,6 @@
 
 package a
 
-import "fmt"  // ERROR "imported and not used"
+import "fmt" // ERROR "imported and not used"
 
 const n = fmt // ERROR "fmt without selector"
diff --git a/test/fixedbugs/issue11362.go b/test/fixedbugs/issue11362.go
index 9e9e599595..2c14e9e318 100644
--- a/test/fixedbugs/issue11362.go
+++ b/test/fixedbugs/issue11362.go
@@ -12,4 +12,3 @@ import _ "unicode//utf8" // ERROR "non-canonical import path .unicode//utf8. \(s
 
 func main() {
 }
-
diff --git a/test/fixedbugs/issue12677.dir/p.go b/test/fixedbugs/issue12677.dir/p.go
index e395071f8d..40cd872158 100644
--- a/test/fixedbugs/issue12677.dir/p.go
+++ b/test/fixedbugs/issue12677.dir/p.go
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 package p
+
 func Baz(f int) float64 {
-    return 1 / float64(int(1)<<(uint(f)))
+	return 1 / float64(int(1)<<(uint(f)))
 }
diff --git a/test/fixedbugs/issue12677.dir/q.go b/test/fixedbugs/issue12677.dir/q.go
index fd39c8a9ca..ae4fb8aa84 100644
--- a/test/fixedbugs/issue12677.dir/q.go
+++ b/test/fixedbugs/issue12677.dir/q.go
@@ -3,5 +3,7 @@
 // license that can be found in the LICENSE file.
 
 package q
+
 import "./p"
+
 func f() { println(p.Baz(2)) }
diff --git a/test/fixedbugs/issue13261.go b/test/fixedbugs/issue13261.go
index a944f3a9b5..1b39f08ce8 100644
--- a/test/fixedbugs/issue13261.go
+++ b/test/fixedbugs/issue13261.go
@@ -13,17 +13,23 @@ type T struct{}
 func main() {
 	_ = &T{}
 	_ = &(T{})
-	_ = &((T{}))
+	_ = &(T{})
 
 	_ = &struct{}{}
 	_ = &(struct{}{})
-	_ = &((struct{}{}))
-
-	switch (&T{}) {}
-	switch &(T{}) {}
-	switch &((T{})) {}
+	_ = &(struct{}{})
 
-	switch &struct{}{} {}
-	switch &(struct{}{}) {}
-	switch &((struct{}{})) {}
+	switch (&T{}) {
+	}
+	switch &(T{}) {
+	}
+	switch &(T{}) {
+	}
+
+	switch &struct{}{} {
+	}
+	switch &(struct{}{}) {
+	}
+	switch &(struct{}{}) {
+	}
 }
diff --git a/test/fixedbugs/issue13265.go b/test/fixedbugs/issue13265.go
index 3e16cee6e7..9086ccda63 100644
--- a/test/fixedbugs/issue13265.go
+++ b/test/fixedbugs/issue13265.go
@@ -10,7 +10,7 @@
 package p
 
 func f() {
-    var c chan chan chan int
-    for ; ; <-<-<-c {
-    }
+	var c chan chan chan int
+	for ; ; <-<-<-c {
+	}
 }
diff --git a/test/fixedbugs/issue13337.go b/test/fixedbugs/issue13337.go
index 81f984b732..4138eaf583 100644
--- a/test/fixedbugs/issue13337.go
+++ b/test/fixedbugs/issue13337.go
@@ -10,6 +10,7 @@
 package s
 
 type S0 struct{ f int }
+
 func (S0) m() {}
 
 type S1 struct{ S0 }
diff --git a/test/fixedbugs/issue13415.go b/test/fixedbugs/issue13415.go
index 989a1ed50f..20085a3f49 100644
--- a/test/fixedbugs/issue13415.go
+++ b/test/fixedbugs/issue13415.go
@@ -10,10 +10,10 @@
 package p
 
 func f() {
-    select {
-    case x, x := <-func() chan int { // ERROR "x repeated on left side of :="
-            c := make(chan int)
-            return c
-    }():
-    }
+	select {
+	case x, x := <-func() chan int { // ERROR "x repeated on left side of :="
+		c := make(chan int)
+		return c
+	}():
+	}
 }
diff --git a/test/fixedbugs/issue13485.go b/test/fixedbugs/issue13485.go
index a9beea1f7d..982dba494c 100644
--- a/test/fixedbugs/issue13485.go
+++ b/test/fixedbugs/issue13485.go
@@ -9,7 +9,7 @@ package p
 var (
 	_ [10]int
 	_ [10.0]int
-	_ [float64(10)]int                // ERROR "invalid array bound"
+	_ [float64(10)]int // ERROR "invalid array bound"
 	_ [10 + 0i]int
 	_ [complex(10, 0)]int
 	_ [complex128(complex(10, 0))]int // ERROR "invalid array bound"
diff --git a/test/fixedbugs/issue14136.go b/test/fixedbugs/issue14136.go
index f9efd05f96..12d18c37b1 100644
--- a/test/fixedbugs/issue14136.go
+++ b/test/fixedbugs/issue14136.go
@@ -15,5 +15,5 @@ type T struct{}
 
 func main() {
 	t := T{X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1} // ERROR "unknown field 'X' in struct literal of type T"
-	var s string = 1 // ERROR "cannot use 1"
+	var s string = 1                                                   // ERROR "cannot use 1"
 }
diff --git a/test/fixedbugs/issue14321.go b/test/fixedbugs/issue14321.go
index 058008c386..dbef63179b 100644
--- a/test/fixedbugs/issue14321.go
+++ b/test/fixedbugs/issue14321.go
@@ -8,14 +8,14 @@
 
 package p
 
-type A struct{
+type A struct {
 	H int
 }
 
 func (A) F() {}
 func (A) G() {}
 
-type B struct{
+type B struct {
 	G int
 	H int
 }
diff --git a/test/fixedbugs/issue14540.go b/test/fixedbugs/issue14540.go
index 62b17a04c4..cc55c7f522 100644
--- a/test/fixedbugs/issue14540.go
+++ b/test/fixedbugs/issue14540.go
@@ -10,10 +10,11 @@ func f(x int) {
 	switch x {
 	case 0:
 		fallthrough
-		; // ok
+		// ok
 	case 1:
 		fallthrough // ERROR "fallthrough statement out of place"
-		{}
+		{
+		}
 	case 2:
 		fallthrough // ERROR "cannot fallthrough"
 	}
diff --git a/test/fixedbugs/issue14651.go b/test/fixedbugs/issue14651.go
index 4c756e502e..49eb816554 100644
--- a/test/fixedbugs/issue14651.go
+++ b/test/fixedbugs/issue14651.go
@@ -18,9 +18,9 @@ import (
 )
 
 const (
-	p149 = 1.0 / (1 << 149) // 1p-149
-	p500 = 1.0 / (1 << 500) // 1p-500
-	p1074 = p500 * p500 / (1<<74) // 1p-1074
+	p149  = 1.0 / (1 << 149)        // 1p-149
+	p500  = 1.0 / (1 << 500)        // 1p-500
+	p1074 = p500 * p500 / (1 << 74) // 1p-1074
 )
 
 const (
diff --git a/test/fixedbugs/issue14729.go b/test/fixedbugs/issue14729.go
index 88e01f9e16..50b615e2cf 100644
--- a/test/fixedbugs/issue14729.go
+++ b/test/fixedbugs/issue14729.go
@@ -10,5 +10,5 @@ package main
 
 import "unsafe"
 
-type s struct { unsafe.Pointer } // ERROR "embedded type cannot be a pointer"
-type s1 struct { p unsafe.Pointer }
+type s struct{ unsafe.Pointer } // ERROR "embedded type cannot be a pointer"
+type s1 struct{ p unsafe.Pointer }
diff --git a/test/fixedbugs/issue15039.go b/test/fixedbugs/issue15039.go
index 85d9e8340a..243653e3f0 100644
--- a/test/fixedbugs/issue15039.go
+++ b/test/fixedbugs/issue15039.go
@@ -18,7 +18,7 @@ func main() {
 	}
 
 	// cmd/compile used to require integer constants to fit into an "int".
-	const huge = string(1<<100)
+	const huge = string(1 << 100)
 	if huge != fffd {
 		panic("huge != bad")
 	}
diff --git a/test/fixedbugs/issue15042.go b/test/fixedbugs/issue15042.go
index 85d5d6c361..7941bd7157 100644
--- a/test/fixedbugs/issue15042.go
+++ b/test/fixedbugs/issue15042.go
@@ -22,6 +22,6 @@ func F(c bool, s1, s2 S) (int, int) {
 func main() {
 	i, j := F(true, S{1}, S{20})
 	if i != 20 || j != 1 {
-		panic(i+j)
+		panic(i + j)
 	}
 }
diff --git a/test/fixedbugs/issue15311.go b/test/fixedbugs/issue15311.go
index 81fa541325..6f4ad85feb 100644
--- a/test/fixedbugs/issue15311.go
+++ b/test/fixedbugs/issue15311.go
@@ -10,11 +10,11 @@
 package p
 
 type T struct {
-        toInt    map[string]int
-        toString map[int]string
+	toInt    map[string]int
+	toString map[int]string
 }
 
 var t = T{
-        foo.toInt:    make(map[string]int), // ERROR "field name"
-        bar.toString: make(map[int]string), // ERROR "field name"
+	foo.toInt:    make(map[string]int), // ERROR "field name"
+	bar.toString: make(map[int]string), // ERROR "field name"
 }
diff --git a/test/fixedbugs/issue15439.go b/test/fixedbugs/issue15439.go
index 840a3c02a8..d53077d11a 100644
--- a/test/fixedbugs/issue15439.go
+++ b/test/fixedbugs/issue15439.go
@@ -10,7 +10,9 @@ import "reflect"
 
 func main() {
 	a := &struct{ x int }{}
-	b := &struct{ x int "" }{}
+	b := &struct {
+		x int ""
+	}{}
 
 	ta := reflect.TypeOf(a)
 	tb := reflect.TypeOf(b)
diff --git a/test/fixedbugs/issue15470.dir/a.go b/test/fixedbugs/issue15470.dir/a.go
index 1fcf3ea6e0..69b63530ba 100644
--- a/test/fixedbugs/issue15470.dir/a.go
+++ b/test/fixedbugs/issue15470.dir/a.go
@@ -10,10 +10,10 @@ type T interface {
 
 type S struct{}
 
-func (S) M0(_ int) {}
-func (S) M1(x, _ int) {}
+func (S) M0(_ int)       {}
+func (S) M1(x, _ int)    {}
 func (S) M2() (x, _ int) { return }
-func (_ S) M3() {}
+func (_ S) M3()          {}
 
 // Snippet from x/tools/godoc/analysis/analysis.go.
 // Offending code from #5470.
diff --git a/test/fixedbugs/issue15548.dir/c.go b/test/fixedbugs/issue15548.dir/c.go
index 6d3f3be53e..ce6e3204b3 100644
--- a/test/fixedbugs/issue15548.dir/c.go
+++ b/test/fixedbugs/issue15548.dir/c.go
@@ -5,6 +5,6 @@
 package c
 
 import (
-	_ "./b"
 	_ "./a"
+	_ "./b"
 )
diff --git a/test/fixedbugs/issue15646.go b/test/fixedbugs/issue15646.go
index cd4ba9d4e5..53ccd4096e 100644
--- a/test/fixedbugs/issue15646.go
+++ b/test/fixedbugs/issue15646.go
@@ -6,4 +6,4 @@
 
 // Test that method expressions are correctly encoded
 // in binary export data and can be imported again.
-package ignore
\ No newline at end of file
+package ignore
diff --git a/test/fixedbugs/issue15926.go b/test/fixedbugs/issue15926.go
index 76e25eb640..8004545e14 100644
--- a/test/fixedbugs/issue15926.go
+++ b/test/fixedbugs/issue15926.go
@@ -16,5 +16,5 @@ func (s S) def() {}
 var I = S.def
 
 func main() {
-    I(S{})
+	I(S{})
 }
diff --git a/test/fixedbugs/issue16515.go b/test/fixedbugs/issue16515.go
index 6b67436383..cacff54bfa 100644
--- a/test/fixedbugs/issue16515.go
+++ b/test/fixedbugs/issue16515.go
@@ -34,7 +34,10 @@ func g() {
 }
 
 func main() {
-	var s struct { a T; b [8192-62]int } // allocate 64K, hopefully it's in a new span and a few bytes before it is garbage
+	var s struct {
+		a T
+		b [8192 - 62]int
+	} // allocate 64K, hopefully it's in a new span and a few bytes before it is garbage
 	sink = &s // force heap allocation
 	s.a[0] = 2
 	zero(&s.a)
diff --git a/test/fixedbugs/issue16948.go b/test/fixedbugs/issue16948.go
index c986024896..65c87c3f05 100644
--- a/test/fixedbugs/issue16948.go
+++ b/test/fixedbugs/issue16948.go
@@ -18,6 +18,7 @@ func main() {
 var x int32
 
 type T [10]int
+
 var sink *T
 
 func f() (t T) {
diff --git a/test/fixedbugs/issue17449.go b/test/fixedbugs/issue17449.go
index 51cc8eaa06..8c8bd4844f 100644
--- a/test/fixedbugs/issue17449.go
+++ b/test/fixedbugs/issue17449.go
@@ -11,25 +11,25 @@
 package master
 
 type PriorityList struct {
-    elems []interface{}
+	elems []interface{}
 }
 
 func (x *PriorityList) Len() int { return len(x.elems) }
 
 func (l *PriorityList) remove(i int) interface{} {
-    elem := l.elems[i]
-    l.elems = append(l.elems[:i], l.elems[i+1:]...)
-    return elem
+	elem := l.elems[i]
+	l.elems = append(l.elems[:i], l.elems[i+1:]...)
+	return elem
 }
 
 func (l *PriorityList) Next() interface{} {
-    return l.remove(l.Len() - 1)
+	return l.remove(l.Len() - 1)
 }
 
 var l *PriorityList
 
 func Foo() {
-    // It would fail here if instrumented code (including inline-label) was copied.
-    for elem := l.Next(); elem != nil; elem = l.Next() {
-    }
+	// It would fail here if instrumented code (including inline-label) was copied.
+	for elem := l.Next(); elem != nil; elem = l.Next() {
+	}
 }
diff --git a/test/fixedbugs/issue17588.go b/test/fixedbugs/issue17588.go
index 1be57c6292..23af6f613b 100644
--- a/test/fixedbugs/issue17588.go
+++ b/test/fixedbugs/issue17588.go
@@ -11,10 +11,10 @@
 
 package p
 
-type F func(b T)  // ERROR "T is not a type"
+type F func(b T) // ERROR "T is not a type"
 
 func T(fn F) {
-    func() {
-        fn(nil)  // If Decldepth is not initialized properly, typecheckclosure() Fatals here.
-    }()
+	func() {
+		fn(nil) // If Decldepth is not initialized properly, typecheckclosure() Fatals here.
+	}()
 }
diff --git a/test/fixedbugs/issue17645.go b/test/fixedbugs/issue17645.go
index ed92c54cfa..0fc495c851 100644
--- a/test/fixedbugs/issue17645.go
+++ b/test/fixedbugs/issue17645.go
@@ -12,6 +12,5 @@ type Foo struct {
 
 func main() {
 	var s []int
-	var _ string = append(s, Foo{""})  // ERROR "cannot use .. \(type string\) as type int in field value" "cannot use Foo literal \(type Foo\) as type int in append" "cannot use append\(s\, Foo literal\) \(type \[\]int\) as type string in assignment"
+	var _ string = append(s, Foo{""}) // ERROR "cannot use .. \(type string\) as type int in field value" "cannot use Foo literal \(type Foo\) as type int in append" "cannot use append\(s\, Foo literal\) \(type \[\]int\) as type string in assignment"
 }
-
diff --git a/test/fixedbugs/issue18231.go b/test/fixedbugs/issue18231.go
index adfd2277ff..972c0f28a7 100644
--- a/test/fixedbugs/issue18231.go
+++ b/test/fixedbugs/issue18231.go
@@ -14,7 +14,7 @@ type T struct {
 }
 
 var _ = T{
-	f: {                // ERROR "missing type in composite literal"
+	f: { // ERROR "missing type in composite literal"
 		"a": "b",
 	},
 }
diff --git a/test/fixedbugs/issue18808.go b/test/fixedbugs/issue18808.go
index c98386ee78..8e1a55471d 100644
--- a/test/fixedbugs/issue18808.go
+++ b/test/fixedbugs/issue18808.go
@@ -56,8 +56,8 @@ func lte(x uint32) {
 func main() {
 	eq(lim)
 	neq(lim)
-	gt(lim+1)
-	gte(lim+1)
-	lt(lim+1)
-	lte(lim+1)
+	gt(lim + 1)
+	gte(lim + 1)
+	lt(lim + 1)
+	lte(lim + 1)
 }
diff --git a/test/fixedbugs/issue19028.dir/main.go b/test/fixedbugs/issue19028.dir/main.go
index 627e926f93..ca2cf8c694 100644
--- a/test/fixedbugs/issue19028.dir/main.go
+++ b/test/fixedbugs/issue19028.dir/main.go
@@ -5,12 +5,12 @@
 package main
 
 import (
-        "reflect"
-        fake "./reflect" // 2nd package with name "reflect"
+	fake "./reflect" // 2nd package with name "reflect"
+	"reflect"
 )
 
 type T struct {
-        _ fake.Type
+	_ fake.Type
 }
 
 func (T) f()            {}
@@ -18,9 +18,9 @@ func (T) G() (_ int)    { return }
 func (T) H() (_, _ int) { return }
 
 func main() {
-        var x T
-        typ := reflect.TypeOf(x)
-        for i := 0; i < typ.NumMethod(); i++ {
-                _ = typ.Method(i) // must not crash
-        }
+	var x T
+	typ := reflect.TypeOf(x)
+	for i := 0; i < typ.NumMethod(); i++ {
+		_ = typ.Method(i) // must not crash
+	}
 }
diff --git a/test/fixedbugs/issue19515.go b/test/fixedbugs/issue19515.go
index a1605bec96..8a230485f5 100644
--- a/test/fixedbugs/issue19515.go
+++ b/test/fixedbugs/issue19515.go
@@ -48,4 +48,3 @@ func (v *VScrollPanel) Draw() {
 	BoxGradient(x+x-2, y-1, 0, 0, 0, Color{}, Color{})
 	BoxGradient(x+y-2, y-1, 0, 0, 0, Color{}, Color{})
 }
-
diff --git a/test/fixedbugs/issue19764.dir/a.go b/test/fixedbugs/issue19764.dir/a.go
index 64538e5bdf..7467d03a40 100644
--- a/test/fixedbugs/issue19764.dir/a.go
+++ b/test/fixedbugs/issue19764.dir/a.go
@@ -5,9 +5,10 @@
 package a
 
 type T struct{ _ int }
+
 func (t T) M() {}
 
-type I interface { M() }
+type I interface{ M() }
 
 func F() {
 	var t I = &T{}
diff --git a/test/fixedbugs/issue20602.go b/test/fixedbugs/issue20602.go
index ca4ce095aa..c938ca3006 100644
--- a/test/fixedbugs/issue20602.go
+++ b/test/fixedbugs/issue20602.go
@@ -10,5 +10,5 @@
 package p
 
 var p = &[1]complex128{0}
-var _ = real(p)  // ERROR "type \*\[1\]complex128"
-var _ = imag(p)	 // ERROR "type \*\[1\]complex128"
+var _ = real(p) // ERROR "type \*\[1\]complex128"
+var _ = imag(p) // ERROR "type \*\[1\]complex128"
diff --git a/test/fixedbugs/issue20811.go b/test/fixedbugs/issue20811.go
index 96b61ec728..2ccf453a14 100644
--- a/test/fixedbugs/issue20811.go
+++ b/test/fixedbugs/issue20811.go
@@ -20,4 +20,3 @@ func main() {
 func g() int64 {
 	return 4398046511104
 }
-
diff --git a/test/fixedbugs/issue22429.go b/test/fixedbugs/issue22429.go
index 289b434a74..03c007f2aa 100644
--- a/test/fixedbugs/issue22429.go
+++ b/test/fixedbugs/issue22429.go
@@ -9,10 +9,10 @@
 package p
 
 type T struct {
-	a,b,c,d float32
+	a, b, c, d float32
 }
 
-func f(a *[8]T, i,j,k int) float32 {
+func f(a *[8]T, i, j, k int) float32 {
 	b := *a
 	return b[i].a + b[j].b + b[k].c
 }
diff --git a/test/fixedbugs/issue22458.go b/test/fixedbugs/issue22458.go
index 5c89929577..9317bcfdbd 100644
--- a/test/fixedbugs/issue22458.go
+++ b/test/fixedbugs/issue22458.go
@@ -11,16 +11,16 @@ package main
 import "runtime"
 
 type node struct {
-        next *node
+	next *node
 }
 
 var x bool
 
 func main() {
-        var head *node
-        for x {
-                head = &node{head}
-        }
+	var head *node
+	for x {
+		head = &node{head}
+	}
 
-        runtime.KeepAlive(head)
+	runtime.KeepAlive(head)
 }
diff --git a/test/fixedbugs/issue22662.go b/test/fixedbugs/issue22662.go
index a1f00bfac3..03830de862 100644
--- a/test/fixedbugs/issue22662.go
+++ b/test/fixedbugs/issue22662.go
@@ -25,7 +25,7 @@ func check(file string, line int) {
 }
 
 func main() {
-//-style line directives
+	//-style line directives
 //line :1
 	check("??", 1) // no file specified
 //line foo.go:1
@@ -35,12 +35,16 @@ func main() {
 //line :11:22
 	check("bar.go", 11) // no file, but column specified => keep old filename
 
-/*-style line directives */
-/*line :1*/ check("??", 1) // no file specified
-/*line foo.go:1*/ check("foo.go", 1)
-/*line bar.go:10:20*/ check("bar.go", 10)
-/*line :11:22*/ check("bar.go", 11) // no file, but column specified => keep old filename
-
-	/*line :10*/ check("??", 10); /*line foo.go:20*/ check("foo.go", 20); /*line :30:1*/ check("foo.go", 30)
+	/*-style line directives */
+	/*line :1*/
+	check("??", 1) // no file specified
+	/*line foo.go:1*/ check("foo.go", 1)
+	/*line bar.go:10:20*/ check("bar.go", 10)
+	/*line :11:22*/ check("bar.go", 11) // no file, but column specified => keep old filename
+
+	/*line :10*/
+	check("??", 10)     /*line foo.go:20*/
+	check("foo.go", 20) /*line :30:1*/
+	check("foo.go", 30)
 	check("foo.go", 31)
 }
diff --git a/test/fixedbugs/issue24339.go b/test/fixedbugs/issue24339.go
index 0670becdfe..308fa75825 100644
--- a/test/fixedbugs/issue24339.go
+++ b/test/fixedbugs/issue24339.go
@@ -9,12 +9,6 @@ package p
 // Use a diffent line number for each token so we can
 // check that the error message appears at the correct
 // position.
-var _ = struct{}{ /*line :20:1*/foo /*line :21:1*/: /*line :22:1*/0 }
+var _ = struct{}{ /*line :20:1*/ foo /*line :21:1*/ : /*line :22:1*/ 0}
 
-
-
-
-
-
-
-// ERROR "unknown field 'foo'"
\ No newline at end of file
+// ERROR "unknown field 'foo'"
diff --git a/test/fixedbugs/issue24799.go b/test/fixedbugs/issue24799.go
index c805c86dda..70f8def24d 100644
--- a/test/fixedbugs/issue24799.go
+++ b/test/fixedbugs/issue24799.go
@@ -10,7 +10,7 @@
 package main
 
 import (
-        "fmt"
+	"fmt"
 )
 
 type Level string
@@ -20,39 +20,39 @@ type Level string
 // not aligned to 4 bytes due to the type of relocation that
 // is generated for the instruction. A fix was made to avoid
 // generating an instruction with DS relocation for go.strings
-// since their alignment is not known until link time. 
+// since their alignment is not known until link time.
 
 // This problem only affects go.string since other types have
 // correct alignment.
 
 const (
-        LevelBad Level = "badvals"
-        LevelNone Level = "No"
-        LevelMetadata Level = "Metadata"
-        LevelRequest Level = "Request"
-        LevelRequestResponse Level = "RequestResponse"
+	LevelBad             Level = "badvals"
+	LevelNone            Level = "No"
+	LevelMetadata        Level = "Metadata"
+	LevelRequest         Level = "Request"
+	LevelRequestResponse Level = "RequestResponse"
 )
 
 func ordLevel(l Level) int {
-        switch l {
-        case LevelMetadata:
-                return 1
-        case LevelRequest:
-                return 2
-        case LevelRequestResponse:
-                return 3
-        default:
-                return 0
-        }
+	switch l {
+	case LevelMetadata:
+		return 1
+	case LevelRequest:
+		return 2
+	case LevelRequestResponse:
+		return 3
+	default:
+		return 0
+	}
 }
 
 //go:noinline
 func test(l Level) {
-        if ordLevel(l) < ordLevel(LevelMetadata) {
-                fmt.Printf("OK\n")
-        }
+	if ordLevel(l) < ordLevel(LevelMetadata) {
+		fmt.Printf("OK\n")
+	}
 }
 
 func main() {
-        test(LevelMetadata)
+	test(LevelMetadata)
 }
diff --git a/test/fixedbugs/issue25727.go b/test/fixedbugs/issue25727.go
index 9b7c804a0e..da7c94cc12 100644
--- a/test/fixedbugs/issue25727.go
+++ b/test/fixedbugs/issue25727.go
@@ -9,13 +9,13 @@ package main
 import "net/http"
 
 var s = http.Server{}
-var _ = s.doneChan // ERROR "s.doneChan undefined .cannot refer to unexported field or method doneChan.$"
-var _ = s.DoneChan // ERROR "s.DoneChan undefined .type http.Server has no field or method DoneChan.$"
+var _ = s.doneChan                  // ERROR "s.doneChan undefined .cannot refer to unexported field or method doneChan.$"
+var _ = s.DoneChan                  // ERROR "s.DoneChan undefined .type http.Server has no field or method DoneChan.$"
 var _ = http.Server{tlsConfig: nil} // ERROR "unknown field 'tlsConfig' in struct literal.+ .but does have TLSConfig.$"
-var _ = http.Server{DoneChan: nil} // ERROR "unknown field 'DoneChan' in struct literal of type http.Server$"
+var _ = http.Server{DoneChan: nil}  // ERROR "unknown field 'DoneChan' in struct literal of type http.Server$"
 
 type foo struct {
-    bar int
+	bar int
 }
 
 var _ = &foo{bAr: 10} // ERROR "unknown field 'bAr' in struct literal.+ .but does have bar.$"
diff --git a/test/fixedbugs/issue26335.go b/test/fixedbugs/issue26335.go
index a97b4b6c72..97174ea11d 100644
--- a/test/fixedbugs/issue26335.go
+++ b/test/fixedbugs/issue26335.go
@@ -15,7 +15,7 @@ import (
 
 type Empty struct {
 	f1, f2 *byte
-	empty struct{}
+	empty  struct{}
 }
 
 func F(e Empty, s []string) {
diff --git a/test/fixedbugs/issue26340.go b/test/fixedbugs/issue26340.go
index f973ce2237..afa32c8881 100644
--- a/test/fixedbugs/issue26340.go
+++ b/test/fixedbugs/issue26340.go
@@ -10,12 +10,12 @@
 package p
 
 type S []T
-type T struct { x int }
+type T struct{ x int }
 
 var _ = map[string]*S{
 	"a": {
-		{ 1 },
+		{1},
 	},
 }
 
-var _ = [1]*S{ { {1}, } }
+var _ = [1]*S{{{1}}}
diff --git a/test/fixedbugs/issue26407.go b/test/fixedbugs/issue26407.go
index aa8e79c1e6..02c1c19334 100644
--- a/test/fixedbugs/issue26407.go
+++ b/test/fixedbugs/issue26407.go
@@ -55,4 +55,4 @@ func grow() {
 }
 
 //go:noinline
-func use(_ []uintptr) { }
+func use(_ []uintptr) {}
diff --git a/test/fixedbugs/issue27278.go b/test/fixedbugs/issue27278.go
index 73f7c755e1..321b85cb63 100644
--- a/test/fixedbugs/issue27278.go
+++ b/test/fixedbugs/issue27278.go
@@ -50,7 +50,7 @@ func grow(n int) {
 	if n == 0 {
 		return
 	}
-	grow(n-1)
+	grow(n - 1)
 }
 
 // put some junk on stack, which cannot be valid address
diff --git a/test/fixedbugs/issue27356.go b/test/fixedbugs/issue27356.go
index 42784876a5..18530bf6a9 100644
--- a/test/fixedbugs/issue27356.go
+++ b/test/fixedbugs/issue27356.go
@@ -8,12 +8,11 @@
 
 package p
 
-var a = []int{1,2,3}
+var a = []int{1, 2, 3}
 
 func _(len int) {
-	_ =  len(a) // ERROR "cannot call non-function"
+	_ = len(a) // ERROR "cannot call non-function"
 }
 
 var cap = false
 var _ = cap(a) // ERROR "cannot call non-function"
-
diff --git a/test/fixedbugs/issue29215.go b/test/fixedbugs/issue29215.go
index 4e8f107aee..69bbdc3be4 100644
--- a/test/fixedbugs/issue29215.go
+++ b/test/fixedbugs/issue29215.go
@@ -7,14 +7,14 @@
 package main
 
 func f() {
-        var s string
-        var p, q bool
-        s = "a"
-        for p {
-                p = false == (true != q)
-                s = ""
-        }
-        _ = s == "bbb"
+	var s string
+	var p, q bool
+	s = "a"
+	for p {
+		p = false == (true != q)
+		s = ""
+	}
+	_ = s == "bbb"
 }
 
 // Another case: load from negative offset of a symbol
diff --git a/test/fixedbugs/issue29402.go b/test/fixedbugs/issue29402.go
index 8a1f959d84..fed779bc5f 100644
--- a/test/fixedbugs/issue29402.go
+++ b/test/fixedbugs/issue29402.go
@@ -1,5 +1,5 @@
 // run
-  
+
 // Copyright 2018 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.
diff --git a/test/fixedbugs/issue31747.go b/test/fixedbugs/issue31747.go
index dfb585c613..81bd111d44 100644
--- a/test/fixedbugs/issue31747.go
+++ b/test/fixedbugs/issue31747.go
@@ -14,10 +14,10 @@ const (
 	_ = 0xabc // ok
 	_ = 0x0p1 // ERROR "hexadecimal floating-point literals only supported as of -lang=go1.13"
 
-	_ = 0B111 // ERROR "binary"
-	_ = 0O567 // ERROR "octal"
-	_ = 0Xabc // ok
-	_ = 0X0P1 // ERROR "hexadecimal floating-point"
+	_ = 0b111 // ERROR "binary"
+	_ = 0o567 // ERROR "octal"
+	_ = 0xabc // ok
+	_ = 0x0p1 // ERROR "hexadecimal floating-point"
 
 	_ = 1_000i // ERROR "underscores"
 	_ = 0b111i // ERROR "binary"
diff --git a/test/fixedbugs/issue3552.dir/one.go b/test/fixedbugs/issue3552.dir/one.go
index e594db7478..dacd2565da 100644
--- a/test/fixedbugs/issue3552.dir/one.go
+++ b/test/fixedbugs/issue3552.dir/one.go
@@ -6,23 +6,20 @@ package one
 
 // Issue 3552
 
-type T struct { int }
+type T struct{ int }
 
 func (t T) F() int { return t.int }
 
-type U struct { int int }
+type U struct{ int int }
 
 func (u U) F() int { return u.int }
 
 type lint int
 
-type V struct { lint }
+type V struct{ lint }
 
 func (v V) F() int { return int(v.lint) }
 
-type W struct { lint lint }
+type W struct{ lint lint }
 
 func (w W) F() int { return int(w.lint) }
-
-
-
diff --git a/test/fixedbugs/issue3783.go b/test/fixedbugs/issue3783.go
index 7db06d1881..b60b4b3ee0 100644
--- a/test/fixedbugs/issue3783.go
+++ b/test/fixedbugs/issue3783.go
@@ -9,4 +9,3 @@ package foo
 var i int
 
 func (*i) bar() // ERROR "not a type|expected type"
-
diff --git a/test/fixedbugs/issue3925.go b/test/fixedbugs/issue3925.go
index 628c222685..a8c73a3d65 100644
--- a/test/fixedbugs/issue3925.go
+++ b/test/fixedbugs/issue3925.go
@@ -11,7 +11,7 @@
 package foo
 
 var _ = map[string]string{
-	"1": "2",
+	"1":      "2",
 	"3", "4", // ERROR "missing key|must have keys"
 }
 
@@ -20,4 +20,3 @@ var _ = []string{
 	"bar",
 	20, // ERROR "cannot use|incompatible type"
 }
-
diff --git a/test/fixedbugs/issue4097.go b/test/fixedbugs/issue4097.go
index 30b65bce83..a3c9fea8cb 100644
--- a/test/fixedbugs/issue4097.go
+++ b/test/fixedbugs/issue4097.go
@@ -7,5 +7,5 @@
 package foo
 
 var s [][10]int
-const m = len(s[len(s)-1]) // ERROR "is not a constant|is not constant" 
 
+const m = len(s[len(s)-1]) // ERROR "is not a constant|is not constant"
diff --git a/test/fixedbugs/issue4099.go b/test/fixedbugs/issue4099.go
index 5a4ea7c998..c02e337f37 100644
--- a/test/fixedbugs/issue4099.go
+++ b/test/fixedbugs/issue4099.go
@@ -20,7 +20,7 @@ func F2([]byte)
 func G() {
 	var buf1 [10]byte
 	F1(buf1[:])
-	
+
 	var buf2 [10]byte // ERROR "moved to heap: buf2"
 	F2(buf2[:])
 }
diff --git a/test/fixedbugs/issue4162.go b/test/fixedbugs/issue4162.go
index f236bd0f6a..23b93e5841 100644
--- a/test/fixedbugs/issue4162.go
+++ b/test/fixedbugs/issue4162.go
@@ -10,8 +10,8 @@ package p
 
 // All these are valid now.
 var (
-	_ = int(1.0,)      // comma was always permitted (like function call)
-	_ = []byte("foo",) // was syntax error: unexpected comma
-	_ = chan int(nil,) // was syntax error: unexpected comma
-	_ = (func())(nil,) // was syntax error: unexpected comma
+	_ = int(1.0)      // comma was always permitted (like function call)
+	_ = []byte("foo") // was syntax error: unexpected comma
+	_ = chan int(nil) // was syntax error: unexpected comma
+	_ = (func())(nil) // was syntax error: unexpected comma
 )
diff --git a/test/fixedbugs/issue4251.go b/test/fixedbugs/issue4251.go
index d11ce51b97..b3434d7ff6 100644
--- a/test/fixedbugs/issue4251.go
+++ b/test/fixedbugs/issue4251.go
@@ -9,13 +9,13 @@
 package p
 
 func F1(s []byte) []byte {
-	return s[2:1]		// ERROR "invalid slice index|inverted slice range"
+	return s[2:1] // ERROR "invalid slice index|inverted slice range"
 }
 
 func F2(a [10]byte) []byte {
-	return a[2:1]		// ERROR "invalid slice index|inverted slice range"
+	return a[2:1] // ERROR "invalid slice index|inverted slice range"
 }
 
 func F3(s string) string {
-	return s[2:1]		// ERROR "invalid slice index|inverted slice range"
+	return s[2:1] // ERROR "invalid slice index|inverted slice range"
 }
diff --git a/test/fixedbugs/issue4264.go b/test/fixedbugs/issue4264.go
index 627393211e..f550c95e71 100644
--- a/test/fixedbugs/issue4264.go
+++ b/test/fixedbugs/issue4264.go
@@ -13,7 +13,7 @@ func main() {
 	var y float64
 	var z complex128
 
-	println(x/0) // ERROR "division by zero"
-	println(y/0)
-	println(z/0)
-}
\ No newline at end of file
+	println(x / 0) // ERROR "division by zero"
+	println(y / 0)
+	println(z / 0)
+}
diff --git a/test/fixedbugs/issue4283.go b/test/fixedbugs/issue4283.go
index fa5629b20a..5d69538843 100644
--- a/test/fixedbugs/issue4283.go
+++ b/test/fixedbugs/issue4283.go
@@ -9,9 +9,9 @@
 package p
 
 func F1() bool {
-	return nil == nil	// ERROR "invalid"
+	return nil == nil // ERROR "invalid"
 }
 
 func F2() bool {
-	return nil != nil	// ERROR "invalid"
+	return nil != nil // ERROR "invalid"
 }
diff --git a/test/fixedbugs/issue4313.go b/test/fixedbugs/issue4313.go
index 2494b83b03..ad45f60a5b 100644
--- a/test/fixedbugs/issue4313.go
+++ b/test/fixedbugs/issue4313.go
@@ -22,7 +22,10 @@ func main() {
 }
 
 func makec(px *int) chan bool {
-	if false { for {} }
+	if false {
+		for {
+		}
+	}
 	*px = 42
 	return make(chan bool, 0)
 }
diff --git a/test/fixedbugs/issue4326.dir/q1.go b/test/fixedbugs/issue4326.dir/q1.go
index f118eb0925..f1a0d18ea8 100644
--- a/test/fixedbugs/issue4326.dir/q1.go
+++ b/test/fixedbugs/issue4326.dir/q1.go
@@ -1,8 +1,8 @@
 package q1
 
 func Deref(typ interface{}) interface{} {
-      if typ, ok := typ.(*int); ok {
-            return *typ
-      }
-      return typ
+	if typ, ok := typ.(*int); ok {
+		return *typ
+	}
+	return typ
 }
diff --git a/test/fixedbugs/issue4326.dir/q2.go b/test/fixedbugs/issue4326.dir/q2.go
index 075e2b21e7..2bcc0e224d 100644
--- a/test/fixedbugs/issue4326.dir/q2.go
+++ b/test/fixedbugs/issue4326.dir/q2.go
@@ -3,9 +3,9 @@ package main
 import "./q1"
 
 func main() {
-      x := 1
-      y := q1.Deref(&x)
-      if y != 1 {
-            panic("y != 1")
-      }
+	x := 1
+	y := q1.Deref(&x)
+	if y != 1 {
+		panic("y != 1")
+	}
 }
diff --git a/test/fixedbugs/issue4365.go b/test/fixedbugs/issue4365.go
index 09ff1bf8f7..9b4a7641b1 100644
--- a/test/fixedbugs/issue4365.go
+++ b/test/fixedbugs/issue4365.go
@@ -10,7 +10,7 @@
 package main
 
 type T interface {
-        M()
+	M()
 }
 
 type M struct{}
@@ -18,10 +18,10 @@ type M struct{}
 func (M) M() {}
 
 type Foo struct {
-        M
+	M
 }
 
 func main() {
-        var v T = Foo{} // ERROR "has no methods|not a method|cannot use"
-        _ = v
+	var v T = Foo{} // ERROR "has no methods|not a method|cannot use"
+	_ = v
 }
diff --git a/test/fixedbugs/issue4396a.go b/test/fixedbugs/issue4396a.go
index 38dd4b8cfb..12f4212d76 100644
--- a/test/fixedbugs/issue4396a.go
+++ b/test/fixedbugs/issue4396a.go
@@ -8,7 +8,7 @@
 // word aligned. 5g should use MOVB to load the address
 // of s.g[0] for its nil check.
 //
-// This test _may_ fail on arm, but requires the host to 
+// This test _may_ fail on arm, but requires the host to
 // trap unaligned loads. This is generally done with
 //
 // echo "4" > /proc/cpu/alignment
diff --git a/test/fixedbugs/issue4396b.go b/test/fixedbugs/issue4396b.go
index 1284870ece..1281284d17 100644
--- a/test/fixedbugs/issue4396b.go
+++ b/test/fixedbugs/issue4396b.go
@@ -17,7 +17,7 @@ type T struct {
 }
 
 type T2 struct {
-	pad    [4096]byte
+	pad  [4096]byte
 	A, B byte
 }
 
diff --git a/test/fixedbugs/issue4429.go b/test/fixedbugs/issue4429.go
index 9eb2e0f9c2..7b2c92a7bc 100644
--- a/test/fixedbugs/issue4429.go
+++ b/test/fixedbugs/issue4429.go
@@ -7,10 +7,10 @@
 package p
 
 type a struct {
-  a int
+	a int
 }
 
 func main() {
-  av := a{};
-  _ = *a(av); // ERROR "invalid indirect|expected pointer"
+	av := a{}
+	_ = *a(av) // ERROR "invalid indirect|expected pointer"
 }
diff --git a/test/fixedbugs/issue4463.go b/test/fixedbugs/issue4463.go
index 6ad1952d67..500b4975e6 100644
--- a/test/fixedbugs/issue4463.go
+++ b/test/fixedbugs/issue4463.go
@@ -17,17 +17,17 @@ func F() {
 	var m map[int]int
 	var s struct{ f int }
 
-	append(a, 0)			// ERROR "not used"
-	cap(a)				// ERROR "not used"
-	complex(1, 2)			// ERROR "not used"
-	imag(1i)			// ERROR "not used"
-	len(a)				// ERROR "not used"
-	make([]int, 10)			// ERROR "not used"
-	new(int)			// ERROR "not used"
-	real(1i)			// ERROR "not used"
-	unsafe.Alignof(a)		// ERROR "not used"
-	unsafe.Offsetof(s.f)		// ERROR "not used"
-	unsafe.Sizeof(a)		// ERROR "not used"
+	append(a, 0)         // ERROR "not used"
+	cap(a)               // ERROR "not used"
+	complex(1, 2)        // ERROR "not used"
+	imag(1i)             // ERROR "not used"
+	len(a)               // ERROR "not used"
+	make([]int, 10)      // ERROR "not used"
+	new(int)             // ERROR "not used"
+	real(1i)             // ERROR "not used"
+	unsafe.Alignof(a)    // ERROR "not used"
+	unsafe.Offsetof(s.f) // ERROR "not used"
+	unsafe.Sizeof(a)     // ERROR "not used"
 
 	close(c)
 	copy(a, a)
@@ -45,17 +45,17 @@ func F() {
 	(println("bar"))
 	(recover())
 
-	go append(a, 0)			// ERROR "not used|discards result"
-	go cap(a)			// ERROR "not used|discards result"
-	go complex(1, 2)		// ERROR "not used|discards result"
-	go imag(1i)			// ERROR "not used|discards result"
-	go len(a)			// ERROR "not used|discards result"
-	go make([]int, 10)		// ERROR "not used|discards result"
-	go new(int)			// ERROR "not used|discards result"
-	go real(1i)			// ERROR "not used|discards result"
-	go unsafe.Alignof(a)		// ERROR "not used|discards result"
-	go unsafe.Offsetof(s.f)		// ERROR "not used|discards result"
-	go unsafe.Sizeof(a)		// ERROR "not used|discards result"
+	go append(a, 0)         // ERROR "not used|discards result"
+	go cap(a)               // ERROR "not used|discards result"
+	go complex(1, 2)        // ERROR "not used|discards result"
+	go imag(1i)             // ERROR "not used|discards result"
+	go len(a)               // ERROR "not used|discards result"
+	go make([]int, 10)      // ERROR "not used|discards result"
+	go new(int)             // ERROR "not used|discards result"
+	go real(1i)             // ERROR "not used|discards result"
+	go unsafe.Alignof(a)    // ERROR "not used|discards result"
+	go unsafe.Offsetof(s.f) // ERROR "not used|discards result"
+	go unsafe.Sizeof(a)     // ERROR "not used|discards result"
 
 	go close(c)
 	go copy(a, a)
@@ -65,17 +65,17 @@ func F() {
 	go println("bar")
 	go recover()
 
-	defer append(a, 0)		// ERROR "not used|discards result"
-	defer cap(a)			// ERROR "not used|discards result"
-	defer complex(1, 2)		// ERROR "not used|discards result"
-	defer imag(1i)			// ERROR "not used|discards result"
-	defer len(a)			// ERROR "not used|discards result"
-	defer make([]int, 10)		// ERROR "not used|discards result"
-	defer new(int)			// ERROR "not used|discards result"
-	defer real(1i)			// ERROR "not used|discards result"
-	defer unsafe.Alignof(a)		// ERROR "not used|discards result"
-	defer unsafe.Offsetof(s.f)	// ERROR "not used|discards result"
-	defer unsafe.Sizeof(a)		// ERROR "not used|discards result"
+	defer append(a, 0)         // ERROR "not used|discards result"
+	defer cap(a)               // ERROR "not used|discards result"
+	defer complex(1, 2)        // ERROR "not used|discards result"
+	defer imag(1i)             // ERROR "not used|discards result"
+	defer len(a)               // ERROR "not used|discards result"
+	defer make([]int, 10)      // ERROR "not used|discards result"
+	defer new(int)             // ERROR "not used|discards result"
+	defer real(1i)             // ERROR "not used|discards result"
+	defer unsafe.Alignof(a)    // ERROR "not used|discards result"
+	defer unsafe.Offsetof(s.f) // ERROR "not used|discards result"
+	defer unsafe.Sizeof(a)     // ERROR "not used|discards result"
 
 	defer close(c)
 	defer copy(a, a)
diff --git a/test/fixedbugs/issue4470.go b/test/fixedbugs/issue4470.go
index d922478455..f84a5409b7 100644
--- a/test/fixedbugs/issue4470.go
+++ b/test/fixedbugs/issue4470.go
@@ -10,7 +10,7 @@ package main
 
 func main() {
 	var i interface{}
-	switch (i.(type)) { // ERROR "outside type switch"
+	switch i.(type) { // ERROR "outside type switch"
 	default:
 	}
 }
diff --git a/test/fixedbugs/issue4495.go b/test/fixedbugs/issue4495.go
index 308acc2280..8f90809501 100644
--- a/test/fixedbugs/issue4495.go
+++ b/test/fixedbugs/issue4495.go
@@ -26,4 +26,3 @@ func main() {
 		panic("ret != 3")
 	}
 }
-
diff --git a/test/fixedbugs/issue4562.go b/test/fixedbugs/issue4562.go
index 8c958f5725..94280359b0 100644
--- a/test/fixedbugs/issue4562.go
+++ b/test/fixedbugs/issue4562.go
@@ -34,7 +34,7 @@ func expectError(expectLine int) {
 	if recover() == nil {
 		panic("did not crash")
 	}
-	for i := 1;; i++ {
+	for i := 1; ; i++ {
 		_, file, line, ok := runtime.Caller(i)
 		if !ok {
 			panic("cannot find issue4562.go on stack")
diff --git a/test/fixedbugs/issue4610.go b/test/fixedbugs/issue4610.go
index d56c6d3e8c..8993f9882b 100644
--- a/test/fixedbugs/issue4610.go
+++ b/test/fixedbugs/issue4610.go
@@ -14,4 +14,3 @@ func main() {
 	var foo bar
 	_ = &foo{} // ERROR "is not a type|expected .;."
 } // GCCGO_ERROR "expected declaration"
-
diff --git a/test/fixedbugs/issue4618.go b/test/fixedbugs/issue4618.go
index 0ba95230cf..fe43aa828d 100644
--- a/test/fixedbugs/issue4618.go
+++ b/test/fixedbugs/issue4618.go
@@ -13,7 +13,7 @@ import (
 	"testing"
 )
 
-type T struct { int }
+type T struct{ int }
 
 var globl *T
 
diff --git a/test/fixedbugs/issue4620.go b/test/fixedbugs/issue4620.go
index 5aa29086f7..20d641d3f4 100644
--- a/test/fixedbugs/issue4620.go
+++ b/test/fixedbugs/issue4620.go
@@ -11,7 +11,7 @@ package main
 import "fmt"
 
 func main() {
-	m := map[int]int{0:1}
+	m := map[int]int{0: 1}
 	i := 0
 	i, m[i] = 1, 2
 	if m[0] != 2 {
diff --git a/test/fixedbugs/issue4654.go b/test/fixedbugs/issue4654.go
index 76aff76a67..595782f953 100644
--- a/test/fixedbugs/issue4654.go
+++ b/test/fixedbugs/issue4654.go
@@ -12,60 +12,60 @@ package p
 import "unsafe"
 
 func f() {
-	defer int(0) // ERROR "defer requires function call, not conversion|is not used"
+	defer int(0)             // ERROR "defer requires function call, not conversion|is not used"
 	go string([]byte("abc")) // ERROR "go requires function call, not conversion|is not used"
-	
+
 	var c complex128
 	var f float64
-	var t struct {X int}
+	var t struct{ X int }
 
 	var x []int
-	defer append(x, 1) // ERROR "defer discards result of append|is not used"
-	defer cap(x) // ERROR "defer discards result of cap|is not used"
-	defer complex(1, 2) // ERROR "defer discards result of complex|is not used"
-	defer complex(f, 1) // ERROR "defer discards result of complex|is not used"
-	defer imag(1i) // ERROR "defer discards result of imag|is not used"
-	defer imag(c) // ERROR "defer discards result of imag|is not used"
-	defer len(x) // ERROR "defer discards result of len|is not used"
-	defer make([]int, 1) // ERROR "defer discards result of make|is not used"
-	defer make(chan bool) // ERROR "defer discards result of make|is not used"
+	defer append(x, 1)         // ERROR "defer discards result of append|is not used"
+	defer cap(x)               // ERROR "defer discards result of cap|is not used"
+	defer complex(1, 2)        // ERROR "defer discards result of complex|is not used"
+	defer complex(f, 1)        // ERROR "defer discards result of complex|is not used"
+	defer imag(1i)             // ERROR "defer discards result of imag|is not used"
+	defer imag(c)              // ERROR "defer discards result of imag|is not used"
+	defer len(x)               // ERROR "defer discards result of len|is not used"
+	defer make([]int, 1)       // ERROR "defer discards result of make|is not used"
+	defer make(chan bool)      // ERROR "defer discards result of make|is not used"
 	defer make(map[string]int) // ERROR "defer discards result of make|is not used"
-	defer new(int) // ERROR "defer discards result of new|is not used"
-	defer real(1i) // ERROR "defer discards result of real|is not used"
-	defer real(c) // ERROR "defer discards result of real|is not used"
-	defer append(x, 1) // ERROR "defer discards result of append|is not used"
-	defer append(x, 1) // ERROR "defer discards result of append|is not used"
-	defer unsafe.Alignof(t.X) // ERROR "defer discards result of unsafe.Alignof|is not used"
+	defer new(int)             // ERROR "defer discards result of new|is not used"
+	defer real(1i)             // ERROR "defer discards result of real|is not used"
+	defer real(c)              // ERROR "defer discards result of real|is not used"
+	defer append(x, 1)         // ERROR "defer discards result of append|is not used"
+	defer append(x, 1)         // ERROR "defer discards result of append|is not used"
+	defer unsafe.Alignof(t.X)  // ERROR "defer discards result of unsafe.Alignof|is not used"
 	defer unsafe.Offsetof(t.X) // ERROR "defer discards result of unsafe.Offsetof|is not used"
-	defer unsafe.Sizeof(t) // ERROR "defer discards result of unsafe.Sizeof|is not used"
-	
+	defer unsafe.Sizeof(t)     // ERROR "defer discards result of unsafe.Sizeof|is not used"
+
 	defer copy(x, x) // ok
 	m := make(map[int]int)
 	defer delete(m, 1) // ok
-	defer panic(1) // ok
-	defer print(1) // ok
-	defer println(1) // ok
-	defer recover() // ok
+	defer panic(1)     // ok
+	defer print(1)     // ok
+	defer println(1)   // ok
+	defer recover()    // ok
 
-	int(0) // ERROR "int\(0\) evaluated but not used|is not used"
+	int(0)                // ERROR "int\(0\) evaluated but not used|is not used"
 	string([]byte("abc")) // ERROR "string\(.*\) evaluated but not used|is not used"
 
-	append(x, 1) // ERROR "not used"
-	cap(x) // ERROR "not used"
-	complex(1, 2) // ERROR "not used"
-	complex(f, 1) // ERROR "not used"
-	imag(1i) // ERROR "not used"
-	imag(c) // ERROR "not used"
-	len(x) // ERROR "not used"
-	make([]int, 1) // ERROR "not used"
-	make(chan bool) // ERROR "not used"
+	append(x, 1)         // ERROR "not used"
+	cap(x)               // ERROR "not used"
+	complex(1, 2)        // ERROR "not used"
+	complex(f, 1)        // ERROR "not used"
+	imag(1i)             // ERROR "not used"
+	imag(c)              // ERROR "not used"
+	len(x)               // ERROR "not used"
+	make([]int, 1)       // ERROR "not used"
+	make(chan bool)      // ERROR "not used"
 	make(map[string]int) // ERROR "not used"
-	new(int) // ERROR "not used"
-	real(1i) // ERROR "not used"
-	real(c) // ERROR "not used"
-	append(x, 1) // ERROR "not used"
-	append(x, 1) // ERROR "not used"
-	unsafe.Alignof(t.X) // ERROR "not used"
+	new(int)             // ERROR "not used"
+	real(1i)             // ERROR "not used"
+	real(c)              // ERROR "not used"
+	append(x, 1)         // ERROR "not used"
+	append(x, 1)         // ERROR "not used"
+	unsafe.Alignof(t.X)  // ERROR "not used"
 	unsafe.Offsetof(t.X) // ERROR "not used"
-	unsafe.Sizeof(t) // ERROR "not used"
+	unsafe.Sizeof(t)     // ERROR "not used"
 }
diff --git a/test/fixedbugs/issue4663.go b/test/fixedbugs/issue4663.go
index 971290d8dd..2533f0f269 100644
--- a/test/fixedbugs/issue4663.go
+++ b/test/fixedbugs/issue4663.go
@@ -10,6 +10,6 @@
 package main
 
 func a(b int) int64 {
-  b // ERROR "not used"
-  return 0
+	b // ERROR "not used"
+	return 0
 }
diff --git a/test/fixedbugs/issue4748.go b/test/fixedbugs/issue4748.go
index f7c77cf882..7a9deca039 100644
--- a/test/fixedbugs/issue4748.go
+++ b/test/fixedbugs/issue4748.go
@@ -10,11 +10,11 @@
 package main
 
 func jump() {
-        goto exit
+	goto exit
 exit:
-        return
+	return
 }
 func main() {
-        jump()
-        jump()
+	jump()
+	jump()
 }
diff --git a/test/fixedbugs/issue4879.dir/a.go b/test/fixedbugs/issue4879.dir/a.go
index 7ee7c48604..9bfb0c7d4f 100644
--- a/test/fixedbugs/issue4879.dir/a.go
+++ b/test/fixedbugs/issue4879.dir/a.go
@@ -30,4 +30,3 @@ func MakePrivateCollection3() *Collection {
 		root: unsafe.Pointer(&maptype{}),
 	}
 }
-
diff --git a/test/fixedbugs/issue4879.dir/b.go b/test/fixedbugs/issue4879.dir/b.go
index d8fb5693db..62dcb36e21 100644
--- a/test/fixedbugs/issue4879.dir/b.go
+++ b/test/fixedbugs/issue4879.dir/b.go
@@ -3,7 +3,7 @@ package b
 import "./a"
 
 func F() {
-      a.MakePrivateCollection()
-      a.MakePrivateCollection2()
-      a.MakePrivateCollection3()
+	a.MakePrivateCollection()
+	a.MakePrivateCollection2()
+	a.MakePrivateCollection3()
 }
diff --git a/test/fixedbugs/issue5056.go b/test/fixedbugs/issue5056.go
index 6fb444aa67..d43bbbee1f 100644
--- a/test/fixedbugs/issue5056.go
+++ b/test/fixedbugs/issue5056.go
@@ -10,7 +10,7 @@ package main
 
 type Foo int16
 
-func (f Foo) Esc() *int{
+func (f Foo) Esc() *int {
 	x := int(f)
 	return &x
 }
@@ -24,7 +24,7 @@ var bar, foobar *int
 func main() {
 	var quux iface
 	var x Foo
-	
+
 	quux = x
 	bar = quux.Esc()
 	foobar = quux.Esc()
diff --git a/test/fixedbugs/issue5172.go b/test/fixedbugs/issue5172.go
index a6acbd3db7..4a29dd1812 100644
--- a/test/fixedbugs/issue5172.go
+++ b/test/fixedbugs/issue5172.go
@@ -14,6 +14,6 @@ type foo struct {
 
 func main() {
 	var f foo
-	go f.bar()	// GCCGO_ERROR "undefined"
-	defer f.bar()	// GCCGO_ERROR "undefined"
+	go f.bar()    // GCCGO_ERROR "undefined"
+	defer f.bar() // GCCGO_ERROR "undefined"
 }
diff --git a/test/fixedbugs/issue5493.go b/test/fixedbugs/issue5493.go
index 2ee0398af2..ee7a0dc071 100644
--- a/test/fixedbugs/issue5493.go
+++ b/test/fixedbugs/issue5493.go
@@ -14,6 +14,7 @@ import (
 )
 
 const N = 10
+
 var count int64
 
 func run() error {
@@ -56,4 +57,3 @@ func main() {
 		panic("not all finalizers are called")
 	}
 }
-
diff --git a/test/fixedbugs/issue5515.go b/test/fixedbugs/issue5515.go
index 053abf6f7c..2dab1eaab3 100644
--- a/test/fixedbugs/issue5515.go
+++ b/test/fixedbugs/issue5515.go
@@ -11,24 +11,24 @@ package main
 type T uint32
 
 func main() {
-        b := make([]T, 8)
-        b[0] = 0xdeadbeef
-        rs := Slice(b)
-        sort(rs)
+	b := make([]T, 8)
+	b[0] = 0xdeadbeef
+	rs := Slice(b)
+	sort(rs)
 }
 
 type Slice []T
 
 func (s Slice) Swap(i, j int) {
-        tmp := s[i]
-        s[i] = s[j]
-        s[j] = tmp
+	tmp := s[i]
+	s[i] = s[j]
+	s[j] = tmp
 }
 
 type Interface interface {
-        Swap(i, j int)
+	Swap(i, j int)
 }
 
 func sort(data Interface) {
-        data.Swap(0, 4)
+	data.Swap(0, 4)
 }
diff --git a/test/fixedbugs/issue5614.dir/x.go b/test/fixedbugs/issue5614.dir/x.go
index 7e4f3a7e6b..6cd0969db8 100644
--- a/test/fixedbugs/issue5614.dir/x.go
+++ b/test/fixedbugs/issue5614.dir/x.go
@@ -3,5 +3,3 @@ package x
 import "./rethinkgo"
 
 var S *rethinkgo.Session
-
-
diff --git a/test/fixedbugs/issue5753.go b/test/fixedbugs/issue5753.go
index 230a1e8c3b..597fd2f58c 100644
--- a/test/fixedbugs/issue5753.go
+++ b/test/fixedbugs/issue5753.go
@@ -25,5 +25,5 @@ func main() {
 	if s[0] != "foo" {
 		panic(`s[0] != "foo"`)
 	}
-	
+
 }
diff --git a/test/fixedbugs/issue5809.go b/test/fixedbugs/issue5809.go
index fc8eeef82f..e63515f678 100644
--- a/test/fixedbugs/issue5809.go
+++ b/test/fixedbugs/issue5809.go
@@ -14,13 +14,13 @@ func main() {
 	const d16 = "0123456789ABCDEF"
 	k := 0x1234
 	var x [4]byte
-	
+
 	x[0] = d16[k>>12&0xf]
 	x[1] = d16[k>>8&0xf]
 	x[2] = d16[k>>4&0xf]
 	x[3] = d16[k&0xf]
-	
-	if x != [4]byte{'1','2','3','4'} {
+
+	if x != [4]byte{'1', '2', '3', '4'} {
 		fmt.Println(x)
 		panic("x != [4]byte{'1','2','3','4'}")
 	}
diff --git a/test/fixedbugs/issue5957.dir/b.go b/test/fixedbugs/issue5957.dir/b.go
index 9bc561b9ce..674bcbc006 100644
--- a/test/fixedbugs/issue5957.dir/b.go
+++ b/test/fixedbugs/issue5957.dir/b.go
@@ -1,2 +1 @@
 package surprise2
-
diff --git a/test/fixedbugs/issue5957.dir/c.go b/test/fixedbugs/issue5957.dir/c.go
index d115eacdd5..28f6e84a59 100644
--- a/test/fixedbugs/issue5957.dir/c.go
+++ b/test/fixedbugs/issue5957.dir/c.go
@@ -1,12 +1,12 @@
 package p
 
 import (
-	"./a" // ERROR "imported and not used: \x22a\x22 as surprise|imported and not used: surprise"
-	"./b" // ERROR "imported and not used: \x22b\x22 as surprise2|imported and not used: surprise2"
-	b "./b" // ERROR "imported and not used: \x22b\x22$|imported and not used: surprise2"
+	"./a"      // ERROR "imported and not used: \x22a\x22 as surprise|imported and not used: surprise"
+	"./b"      // ERROR "imported and not used: \x22b\x22 as surprise2|imported and not used: surprise2"
+	b "./b"    // ERROR "imported and not used: \x22b\x22$|imported and not used: surprise2"
+	"fmt"      // actually used
 	foo "math" // ERROR "imported and not used: \x22math\x22 as foo|imported and not used: math"
-	"fmt" // actually used
-	"strings" // ERROR "imported and not used: \x22strings\x22|imported and not used: strings"
+	"strings"  // ERROR "imported and not used: \x22strings\x22|imported and not used: strings"
 )
 
 var _ = fmt.Printf
diff --git a/test/fixedbugs/issue6004.go b/test/fixedbugs/issue6004.go
index 2b3dcd923d..4a4a43cf94 100644
--- a/test/fixedbugs/issue6004.go
+++ b/test/fixedbugs/issue6004.go
@@ -7,9 +7,8 @@
 package main
 
 func main() {
-	_ = nil // ERROR "use of untyped nil"
-	_, _ = nil, 1 // ERROR "use of untyped nil"
-	_, _ = 1, nil // ERROR "use of untyped nil"
+	_ = nil                  // ERROR "use of untyped nil"
+	_, _ = nil, 1            // ERROR "use of untyped nil"
+	_, _ = 1, nil            // ERROR "use of untyped nil"
 	_ = append(nil, 1, 2, 3) // ERROR "untyped nil"
 }
-
diff --git a/test/fixedbugs/issue6406.go b/test/fixedbugs/issue6406.go
index 5491193ef3..429aa7f5f3 100644
--- a/test/fixedbugs/issue6406.go
+++ b/test/fixedbugs/issue6406.go
@@ -8,5 +8,5 @@ package main
 
 func main() {
 	s = "bob" // ERROR "undefined.*s"
-	_ = s // ERROR "undefined.*s"
+	_ = s     // ERROR "undefined.*s"
 }
diff --git a/test/fixedbugs/issue6703g.go b/test/fixedbugs/issue6703g.go
index 05ec7405f3..1762d0bc42 100644
--- a/test/fixedbugs/issue6703g.go
+++ b/test/fixedbugs/issue6703g.go
@@ -17,4 +17,4 @@ func (T) m() int {
 
 type E struct{ T }
 
-var x = E.m // ERROR "initialization loop|depends upon itself" 
+var x = E.m // ERROR "initialization loop|depends upon itself"
diff --git a/test/fixedbugs/issue6703h.go b/test/fixedbugs/issue6703h.go
index f6b69e1b70..af0cdfbbdd 100644
--- a/test/fixedbugs/issue6703h.go
+++ b/test/fixedbugs/issue6703h.go
@@ -17,4 +17,4 @@ func (T) m() int {
 
 type E struct{ T }
 
-var x = E.m(E{0}) // ERROR "initialization loop|depends upon itself" 
+var x = E.m(E{0}) // ERROR "initialization loop|depends upon itself"
diff --git a/test/fixedbugs/issue6703i.go b/test/fixedbugs/issue6703i.go
index fb580a2461..c412268d7e 100644
--- a/test/fixedbugs/issue6703i.go
+++ b/test/fixedbugs/issue6703i.go
@@ -17,4 +17,4 @@ func (T) m() int {
 
 type E struct{ T }
 
-var x = E{}.m // ERROR "initialization loop|depends upon itself" 
+var x = E{}.m // ERROR "initialization loop|depends upon itself"
diff --git a/test/fixedbugs/issue6703o.go b/test/fixedbugs/issue6703o.go
index a11fdfd858..e87e5ecec4 100644
--- a/test/fixedbugs/issue6703o.go
+++ b/test/fixedbugs/issue6703o.go
@@ -19,5 +19,5 @@ type E struct{ T }
 
 var (
 	e E
-	x = e.m // ERROR "initialization loop|depends upon itself" 
+	x = e.m // ERROR "initialization loop|depends upon itself"
 )
diff --git a/test/fixedbugs/issue6703p.go b/test/fixedbugs/issue6703p.go
index 3ac7a63de8..79c6a5f41c 100644
--- a/test/fixedbugs/issue6703p.go
+++ b/test/fixedbugs/issue6703p.go
@@ -19,5 +19,5 @@ type E struct{ T }
 
 var (
 	e E
-	x = e.m() // ERROR "initialization loop|depends upon itself" 
+	x = e.m() // ERROR "initialization loop|depends upon itself"
 )
diff --git a/test/fixedbugs/issue6703q.go b/test/fixedbugs/issue6703q.go
index b087c15d37..743a6ae3df 100644
--- a/test/fixedbugs/issue6703q.go
+++ b/test/fixedbugs/issue6703q.go
@@ -24,5 +24,5 @@ type E struct{ T }
 
 var (
 	e E
-	x = g().m // ERROR "initialization loop|depends upon itself" 
+	x = g().m // ERROR "initialization loop|depends upon itself"
 )
diff --git a/test/fixedbugs/issue6703r.go b/test/fixedbugs/issue6703r.go
index de514f1802..a22f9a2122 100644
--- a/test/fixedbugs/issue6703r.go
+++ b/test/fixedbugs/issue6703r.go
@@ -24,5 +24,5 @@ type E struct{ T }
 
 var (
 	e E
-	x = g().m() // ERROR "initialization loop|depends upon itself" 
+	x = g().m() // ERROR "initialization loop|depends upon itself"
 )
diff --git a/test/fixedbugs/issue6703y.go b/test/fixedbugs/issue6703y.go
index 278dfcdb5e..f679933f8e 100644
--- a/test/fixedbugs/issue6703y.go
+++ b/test/fixedbugs/issue6703y.go
@@ -20,4 +20,4 @@ func pf() *T {
 	return nil
 }
 
-var x = pf().pm // ERROR "initialization loop|depends upon itself" 
+var x = pf().pm // ERROR "initialization loop|depends upon itself"
diff --git a/test/fixedbugs/issue6703z.go b/test/fixedbugs/issue6703z.go
index f81a3a8c34..658d05a2af 100644
--- a/test/fixedbugs/issue6703z.go
+++ b/test/fixedbugs/issue6703z.go
@@ -20,4 +20,4 @@ func pf() *T {
 	return nil
 }
 
-var x = pf().pm() // ERROR "initialization loop|depends upon itself" 
+var x = pf().pm() // ERROR "initialization loop|depends upon itself"
diff --git a/test/fixedbugs/issue6789.dir/a.go b/test/fixedbugs/issue6789.dir/a.go
index 9c90e0740c..9e076fec71 100644
--- a/test/fixedbugs/issue6789.dir/a.go
+++ b/test/fixedbugs/issue6789.dir/a.go
@@ -5,10 +5,10 @@
 package a
 
 type unexported struct {
-        a int
-        b bool
+	a int
+	b bool
 }
 
 type Struct struct {
-        unexported
+	unexported
 }
diff --git a/test/fixedbugs/issue6847.go b/test/fixedbugs/issue6847.go
index da300bcd01..58ebb636f4 100644
--- a/test/fixedbugs/issue6847.go
+++ b/test/fixedbugs/issue6847.go
@@ -56,7 +56,7 @@ func F() {
 	case cs, ok = <-cc:
 	case c = <-cc:
 	}
-      // Interfaces.
+	// Interfaces.
 	var (
 		c1 chan I1
 		c2 chan I2
diff --git a/test/fixedbugs/issue7223.go b/test/fixedbugs/issue7223.go
index 0ec3476403..e03d6f703d 100644
--- a/test/fixedbugs/issue7223.go
+++ b/test/fixedbugs/issue7223.go
@@ -7,14 +7,15 @@
 package main
 
 var bits1 uint = 10
+
 const bits2 uint = 10
 
 func main() {
 	_ = make([]byte, 1<<bits1)
 	_ = make([]byte, 1<<bits2)
-	_ = make([]byte, nil) // ERROR "non-integer.*len"
+	_ = make([]byte, nil)    // ERROR "non-integer.*len"
 	_ = make([]byte, nil, 2) // ERROR "non-integer.*len"
 	_ = make([]byte, 1, nil) // ERROR "non-integer.*cap"
-	_ = make([]byte, true) // ERROR "non-integer.*len"
-	_ = make([]byte, "abc") // ERROR "non-integer.*len"
+	_ = make([]byte, true)   // ERROR "non-integer.*len"
+	_ = make([]byte, "abc")  // ERROR "non-integer.*len"
 }
diff --git a/test/fixedbugs/issue7310.go b/test/fixedbugs/issue7310.go
index 1169fcfbf0..4183b0b4eb 100644
--- a/test/fixedbugs/issue7310.go
+++ b/test/fixedbugs/issue7310.go
@@ -11,5 +11,5 @@ package main
 func main() {
 	_ = copy(nil, []int{}) // ERROR "use of untyped nil"
 	_ = copy([]int{}, nil) // ERROR "use of untyped nil"
-	_ = 1+true // ERROR "cannot convert true" "mismatched types int and bool"
+	_ = 1 + true           // ERROR "cannot convert true" "mismatched types int and bool"
 }
diff --git a/test/fixedbugs/issue7550.go b/test/fixedbugs/issue7550.go
index 0c4cf93079..794b95fcba 100644
--- a/test/fixedbugs/issue7550.go
+++ b/test/fixedbugs/issue7550.go
@@ -7,19 +7,19 @@
 package main
 
 func shouldPanic(f func()) {
-        defer func() {
-                if recover() == nil {
-                        panic("not panicking")
-                }
-        }()
-        f()
+	defer func() {
+		if recover() == nil {
+			panic("not panicking")
+		}
+	}()
+	f()
 }
 
 func f() {
-        length := int(^uint(0) >> 1)
-        a := make([]struct{}, length)
-        b := make([]struct{}, length)
-        _ = append(a, b...)
+	length := int(^uint(0) >> 1)
+	a := make([]struct{}, length)
+	b := make([]struct{}, length)
+	_ = append(a, b...)
 }
 
 func main() {
diff --git a/test/fixedbugs/issue7590.go b/test/fixedbugs/issue7590.go
index 607a3ae606..e67e393dfb 100644
--- a/test/fixedbugs/issue7590.go
+++ b/test/fixedbugs/issue7590.go
@@ -13,7 +13,7 @@ type S struct {
 }
 
 var M = map[string]S{
-	"a": { F: 1 },
+	"a": {F: 1},
 }
 
 var P = M["a"]
diff --git a/test/fixedbugs/issue7648.dir/a.go b/test/fixedbugs/issue7648.dir/a.go
index c76aaa675f..9139dc279f 100644
--- a/test/fixedbugs/issue7648.dir/a.go
+++ b/test/fixedbugs/issue7648.dir/a.go
@@ -6,6 +6,5 @@ package a
 
 const (
 	sinPi4 = 0.70710678118654752440084436210484903928483593768847
-	A = complex(sinPi4, -sinPi4)
+	A      = complex(sinPi4, -sinPi4)
 )
-
diff --git a/test/fixedbugs/issue7760.go b/test/fixedbugs/issue7760.go
index cccae48910..cf99ac1cc9 100644
--- a/test/fixedbugs/issue7760.go
+++ b/test/fixedbugs/issue7760.go
@@ -13,13 +13,13 @@ import "unsafe"
 type myPointer unsafe.Pointer
 
 const _ = unsafe.Pointer(uintptr(1)) // ERROR "is not (a )?constant"
-const _ = myPointer(uintptr(1)) // ERROR "is not (a )?constant"
+const _ = myPointer(uintptr(1))      // ERROR "is not (a )?constant"
 
 const _ = (*int)(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant"
-const _ = (*int)(myPointer(uintptr(1))) // ERROR "is not (a )?constant"
+const _ = (*int)(myPointer(uintptr(1)))      // ERROR "is not (a )?constant"
 
 const _ = uintptr(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant"
-const _ = uintptr(myPointer(uintptr(1))) // ERROR "is not (a )?constant"
+const _ = uintptr(myPointer(uintptr(1)))      // ERROR "is not (a )?constant"
 
 const _ = []byte("") // ERROR "is not (a )?constant"
 const _ = []rune("") // ERROR "is not (a )?constant"
diff --git a/test/fixedbugs/issue7921.go b/test/fixedbugs/issue7921.go
index e19b113062..2eb6d4ecd0 100644
--- a/test/fixedbugs/issue7921.go
+++ b/test/fixedbugs/issue7921.go
@@ -41,7 +41,7 @@ func bufferNoEscape3(xs []string) string { // ERROR "bufferNoEscape3 xs does not
 
 func bufferNoEscape4() []byte {
 	var b bytes.Buffer
-	b.Grow(64)       // ERROR "bufferNoEscape4 ignoring self-assignment in bytes.b.buf = bytes.b.buf\[:bytes.m·3\]$" "inlining call to bytes.\(\*Buffer\).Grow$"
+	b.Grow(64) // ERROR "bufferNoEscape4 ignoring self-assignment in bytes.b.buf = bytes.b.buf\[:bytes.m·3\]$" "inlining call to bytes.\(\*Buffer\).Grow$"
 	useBuffer(&b)
 	return b.Bytes() // ERROR "inlining call to bytes.\(\*Buffer\).Bytes$"
 }
diff --git a/test/fixedbugs/issue8155.go b/test/fixedbugs/issue8155.go
index 56a6738920..5450d04bc8 100644
--- a/test/fixedbugs/issue8155.go
+++ b/test/fixedbugs/issue8155.go
@@ -36,7 +36,7 @@ func poison() uintptr {
 	var x [20]uintptr
 	var s uintptr
 	for i := range x {
-		x[i] = uintptr(i+1)
+		x[i] = uintptr(i + 1)
 		s += x[i]
 	}
 	return s
diff --git a/test/fixedbugs/issue8961.go b/test/fixedbugs/issue8961.go
index 22b0f0410a..144bbb2cf7 100644
--- a/test/fixedbugs/issue8961.go
+++ b/test/fixedbugs/issue8961.go
@@ -7,7 +7,8 @@
 // Issue 8961. Empty composite literals to small globals were not filled in
 package main
 
-type small struct { a int }
+type small struct{ a int }
+
 var foo small
 
 func main() {
diff --git a/test/fixedbugs/issue9076.go b/test/fixedbugs/issue9076.go
index 8daf12fee8..dd2a474148 100644
--- a/test/fixedbugs/issue9076.go
+++ b/test/fixedbugs/issue9076.go
@@ -11,5 +11,6 @@ package main
 import "unsafe"
 
 const Hundred = 100
-var _ int32 = 100/unsafe.Sizeof(int(0)) + 1 // GC_ERROR "100 \/ unsafe.Sizeof\(int\(0\)\) \+ 1"
+
+var _ int32 = 100/unsafe.Sizeof(int(0)) + 1     // GC_ERROR "100 \/ unsafe.Sizeof\(int\(0\)\) \+ 1"
 var _ int32 = Hundred/unsafe.Sizeof(int(0)) + 1 // GC_ERROR "Hundred \/ unsafe.Sizeof\(int\(0\)\) \+ 1"
diff --git a/test/fixedbugs/issue9083.go b/test/fixedbugs/issue9083.go
index 8fbd78be7a..ea53e7a69a 100644
--- a/test/fixedbugs/issue9083.go
+++ b/test/fixedbugs/issue9083.go
@@ -13,10 +13,10 @@ const zero = 0
 
 func main() {
 	var x int
-	x = make(map[int]int) // ERROR "cannot use make\(map\[int\]int\)|incompatible"
-	x = make(map[int]int, 0) // ERROR "cannot use make\(map\[int\]int, 0\)|incompatible"
+	x = make(map[int]int)       // ERROR "cannot use make\(map\[int\]int\)|incompatible"
+	x = make(map[int]int, 0)    // ERROR "cannot use make\(map\[int\]int, 0\)|incompatible"
 	x = make(map[int]int, zero) // ERROR "cannot use make\(map\[int\]int, zero\)|incompatible"
-	x = make(chan int) // ERROR "cannot use make\(chan int\)|incompatible"
-	x = make(chan int, 0) // ERROR "cannot use make\(chan int, 0\)|incompatible"
-	x = make(chan int, zero) // ERROR "cannot use make\(chan int, zero\)|incompatible"
+	x = make(chan int)          // ERROR "cannot use make\(chan int\)|incompatible"
+	x = make(chan int, 0)       // ERROR "cannot use make\(chan int, 0\)|incompatible"
+	x = make(chan int, zero)    // ERROR "cannot use make\(chan int, zero\)|incompatible"
 }
diff --git a/test/fixedbugs/issue9537.dir/b.go b/test/fixedbugs/issue9537.dir/b.go
index 52e64c81f1..c8dce22c14 100644
--- a/test/fixedbugs/issue9537.dir/b.go
+++ b/test/fixedbugs/issue9537.dir/b.go
@@ -15,8 +15,8 @@ type X struct {
 }
 
 type Intf interface {
-	Get()        []byte
-	RetPtr(int)  *int
+	Get() []byte
+	RetPtr(int) *int
 	RetRPtr(int) (int, *int)
 }
 
diff --git a/test/fixedbugs/issue9634.go b/test/fixedbugs/issue9634.go
index 2d5aae4a30..cc3e7484eb 100644
--- a/test/fixedbugs/issue9634.go
+++ b/test/fixedbugs/issue9634.go
@@ -10,7 +10,7 @@
 package main
 
 func main() {
-	s := struct{
+	s := struct {
 		t []int
 		u int
 	}{}
diff --git a/test/float_lit.go b/test/float_lit.go
index 4efae2362d..f78c933f99 100644
--- a/test/float_lit.go
+++ b/test/float_lit.go
@@ -77,8 +77,8 @@ func main() {
 		print("-210.012 is ", -210.012, "\n")
 	}
 
-	if !close(0E+1, 0, 1, 0) {
-		print("0E+1 is ", 0E+1, "\n")
+	if !close(0e+1, 0, 1, 0) {
+		print("0E+1 is ", 0e+1, "\n")
 	}
 	if !close(+10e2, 10, 1, 2) {
 		print("+10e2 is ", +10e2, "\n")
@@ -87,8 +87,8 @@ func main() {
 		print("-210e3 is ", -210e3, "\n")
 	}
 
-	if !close(0E-1, 0, 1, 0) {
-		print("0E-1 is ", 0E-1, "\n")
+	if !close(0e-1, 0, 1, 0) {
+		print("0E-1 is ", 0e-1, "\n")
 	}
 	if !close(+0e23, 0, 1, 1) {
 		print("+0e23 is ", +0e23, "\n")
@@ -97,8 +97,8 @@ func main() {
 		print("-0e345 is ", -0e345, "\n")
 	}
 
-	if !close(0E1, 0, 1, 1) {
-		print("0E1 is ", 0E1, "\n")
+	if !close(0e1, 0, 1, 1) {
+		print("0E1 is ", 0e1, "\n")
 	}
 	if !close(+10e23, 10, 1, 23) {
 		print("+10e23 is ", +10e23, "\n")
@@ -107,8 +107,8 @@ func main() {
 		print("-210e34 is ", -210e34, "\n")
 	}
 
-	if !close(0.E1, 0, 1, 1) {
-		print("0.E1 is ", 0.E1, "\n")
+	if !close(0.e1, 0, 1, 1) {
+		print("0.E1 is ", 0.e1, "\n")
 	}
 	if !close(+10.e+2, 10, 1, 2) {
 		print("+10.e+2 is ", +10.e+2, "\n")
@@ -117,8 +117,8 @@ func main() {
 		print("-210.e-3 is ", -210.e-3, "\n")
 	}
 
-	if !close(.0E1, 0, 1, 1) {
-		print(".0E1 is ", .0E1, "\n")
+	if !close(.0e1, 0, 1, 1) {
+		print(".0E1 is ", .0e1, "\n")
 	}
 	if !close(+.01e2, 1, 100, 2) {
 		print("+.01e2 is ", +.01e2, "\n")
@@ -127,8 +127,8 @@ func main() {
 		print("-.012e3 is ", -.012e3, "\n")
 	}
 
-	if !close(0.0E1, 0, 1, 0) {
-		print("0.0E1 is ", 0.0E1, "\n")
+	if !close(0.0e1, 0, 1, 0) {
+		print("0.0E1 is ", 0.0e1, "\n")
 	}
 	if !close(+10.01e2, 1001, 100, 2) {
 		print("+10.01e2 is ", +10.01e2, "\n")
@@ -137,8 +137,8 @@ func main() {
 		print("-210.012e3 is ", -210.012e3, "\n")
 	}
 
-	if !close(0.E+12, 0, 1, 0) {
-		print("0.E+12 is ", 0.E+12, "\n")
+	if !close(0.e+12, 0, 1, 0) {
+		print("0.E+12 is ", 0.e+12, "\n")
 	}
 	if !close(+10.e23, 10, 1, 23) {
 		print("+10.e23 is ", +10.e23, "\n")
@@ -147,8 +147,8 @@ func main() {
 		print("-210.e33 is ", -210.e33, "\n")
 	}
 
-	if !close(.0E-12, 0, 1, 0) {
-		print(".0E-12 is ", .0E-12, "\n")
+	if !close(.0e-12, 0, 1, 0) {
+		print(".0E-12 is ", .0e-12, "\n")
 	}
 	if !close(+.01e23, 1, 100, 23) {
 		print("+.01e23 is ", +.01e23, "\n")
@@ -157,8 +157,8 @@ func main() {
 		print("-.012e34 is ", -.012e34, "\n")
 	}
 
-	if !close(0.0E12, 0, 1, 12) {
-		print("0.0E12 is ", 0.0E12, "\n")
+	if !close(0.0e12, 0, 1, 12) {
+		print("0.0E12 is ", 0.0e12, "\n")
 	}
 	if !close(+10.01e23, 1001, 100, 23) {
 		print("+10.01e23 is ", +10.01e23, "\n")
@@ -167,8 +167,8 @@ func main() {
 		print("-210.012e33 is ", -210.012e33, "\n")
 	}
 
-	if !close(0.E123, 0, 1, 123) {
-		print("0.E123 is ", 0.E123, "\n")
+	if !close(0.e123, 0, 1, 123) {
+		print("0.E123 is ", 0.e123, "\n")
 	}
 	if !close(+10.e+23, 10, 1, 23) {
 		print("+10.e+234 is ", +10.e+234, "\n")
@@ -177,8 +177,8 @@ func main() {
 		print("-210.e-35 is ", -210.e-35, "\n")
 	}
 
-	if !close(.0E123, 0, 1, 123) {
-		print(".0E123 is ", .0E123, "\n")
+	if !close(.0e123, 0, 1, 123) {
+		print(".0E123 is ", .0e123, "\n")
 	}
 	if !close(+.01e29, 1, 100, 29) {
 		print("+.01e29 is ", +.01e29, "\n")
@@ -187,8 +187,8 @@ func main() {
 		print("-.012e29 is ", -.012e29, "\n")
 	}
 
-	if !close(0.0E123, 0, 1, 123) {
-		print("0.0E123 is ", 0.0E123, "\n")
+	if !close(0.0e123, 0, 1, 123) {
+		print("0.0E123 is ", 0.0e123, "\n")
 	}
 	if !close(+10.01e31, 1001, 100, 31) {
 		print("+10.01e31 is ", +10.01e31, "\n")
diff --git a/test/for.go b/test/for.go
index 8a50090657..14d516bf71 100644
--- a/test/for.go
+++ b/test/for.go
@@ -44,11 +44,11 @@ func main() {
 	for sum < 100 {
 		sum = sum + 9
 	}
-	assertequal(sum, 99 + 9, "only one")
+	assertequal(sum, 99+9, "only one")
 
 	sum = 0
 	for i := 0; i <= 10; i++ {
-		if i % 2 == 0 {
+		if i%2 == 0 {
 			continue
 		}
 		sum = sum + i
diff --git a/test/func.go b/test/func.go
index 246cb56fd9..9a31b4f300 100644
--- a/test/func.go
+++ b/test/func.go
@@ -41,7 +41,6 @@ func f7(a int) (x int, y float32) {
 	return 7, 7.0
 }
 
-
 func f8(a int) (x int, y float32) {
 	return 8, 8.0
 }
@@ -54,14 +53,12 @@ func (t *T) m10(a int, b float32) int {
 	return (t.x + a) * (t.y + int(b))
 }
 
-
 func f9(a int) (i int, f float32) {
 	i = 9
 	f = 9.0
 	return
 }
 
-
 func main() {
 	f1()
 	f2(1)
diff --git a/test/func1.go b/test/func1.go
index fb6f56184f..8ab4b70989 100644
--- a/test/func1.go
+++ b/test/func1.go
@@ -13,7 +13,6 @@ func f1(a int) (int, float32) {
 	return 7, 7.0
 }
 
-
 func f2(a int) (a int, b float32) { // ERROR "duplicate argument a|definition"
 	return 8, 8.0
 }
diff --git a/test/func4.go b/test/func4.go
index 85f1e4b81e..53e69cf0a9 100644
--- a/test/func4.go
+++ b/test/func4.go
@@ -12,7 +12,7 @@ package main
 var notmain func()
 
 func main() {
-	var x = &main		// ERROR "address of|invalid"
-	main = notmain	// ERROR "assign to|invalid"
+	var x = &main  // ERROR "address of|invalid"
+	main = notmain // ERROR "assign to|invalid"
 	_ = x
 }
diff --git a/test/func5.go b/test/func5.go
index 2e058be7e6..367b683e30 100644
--- a/test/func5.go
+++ b/test/func5.go
@@ -39,7 +39,7 @@ func fn() func(int, int) int {
 var fc func(int, int, chan int)
 
 func addc(x, y int, c chan int) {
-	c <- x+y
+	c <- x + y
 }
 
 func fnc() func(int, int, chan int) {
@@ -79,7 +79,7 @@ func main() {
 	three(<-c)
 	go fnc()(1, 2, c)
 	three(<-c)
-	go func(a, b int, c chan int) { c <- a+b }(1, 2, c)
+	go func(a, b int, c chan int) { c <- a + b }(1, 2, c)
 	three(<-c)
 
 	emptyresults()
diff --git a/test/func6.go b/test/func6.go
index 5b2f9f273e..9b2a10846a 100644
--- a/test/func6.go
+++ b/test/func6.go
@@ -9,8 +9,10 @@
 package main
 
 func main() {
-	if func() bool { return true }() {}  // gc used to say this was a syntax error
-	if (func() bool { return true })() {}
-	if (func() bool { return true }()) {}
+	if func() bool { return true }() {
+	} // gc used to say this was a syntax error
+	if (func() bool { return true })() {
+	}
+	if func() bool { return true }() {
+	}
 }
-
diff --git a/test/funcdup.go b/test/funcdup.go
index 7b05d12606..468f255b86 100644
--- a/test/funcdup.go
+++ b/test/funcdup.go
@@ -8,20 +8,20 @@ package p
 
 type T interface {
 	F1(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-	F2(i, i int) // ERROR "duplicate argument i|redefinition|previous"
-	F3() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
+	F2(i, i int)      // ERROR "duplicate argument i|redefinition|previous"
+	F3() (i, i int)   // ERROR "duplicate argument i|redefinition|previous"
 }
 
-type T1 func(i, i int) // ERROR "duplicate argument i|redefinition|previous"
+type T1 func(i, i int)      // ERROR "duplicate argument i|redefinition|previous"
 type T2 func(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-type T3 func() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
+type T3 func() (i, i int)   // ERROR "duplicate argument i|redefinition|previous"
 
 type R struct{}
 
-func (i *R) F1(i int)         {} // ERROR "duplicate argument i|redefinition|previous"
-func (i *R) F2() (i int)      {return 0} // ERROR "duplicate argument i|redefinition|previous"
-func (i *R) F3(j int) (j int) {return 0} // ERROR "duplicate argument j|redefinition|previous"
+func (i *R) F1(i int)         {}           // ERROR "duplicate argument i|redefinition|previous"
+func (i *R) F2() (i int)      { return 0 } // ERROR "duplicate argument i|redefinition|previous"
+func (i *R) F3(j int) (j int) { return 0 } // ERROR "duplicate argument j|redefinition|previous"
 
-func F1(i, i int)      {} // ERROR "duplicate argument i|redefinition|previous"
-func F2(i int) (i int) {return 0} // ERROR "duplicate argument i|redefinition|previous"
-func F3() (i, i int)   {return 0, 0} // ERROR "duplicate argument i|redefinition|previous"
+func F1(i, i int)      {}              // ERROR "duplicate argument i|redefinition|previous"
+func F2(i int) (i int) { return 0 }    // ERROR "duplicate argument i|redefinition|previous"
+func F3() (i, i int)   { return 0, 0 } // ERROR "duplicate argument i|redefinition|previous"
diff --git a/test/funcdup2.go b/test/funcdup2.go
index 9513ef46bd..fde2c9604f 100644
--- a/test/funcdup2.go
+++ b/test/funcdup2.go
@@ -8,10 +8,10 @@ package p
 
 var T interface {
 	F1(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-	F2(i, i int) // ERROR "duplicate argument i|redefinition|previous"
-	F3() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
+	F2(i, i int)      // ERROR "duplicate argument i|redefinition|previous"
+	F3() (i, i int)   // ERROR "duplicate argument i|redefinition|previous"
 }
 
-var T1 func(i, i int) // ERROR "duplicate argument i|redefinition|previous"
+var T1 func(i, i int)      // ERROR "duplicate argument i|redefinition|previous"
 var T2 func(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-var T3 func() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
+var T3 func() (i, i int)   // ERROR "duplicate argument i|redefinition|previous"
diff --git a/test/gcstring.go b/test/gcstring.go
index 7633d5da55..4b2499a604 100644
--- a/test/gcstring.go
+++ b/test/gcstring.go
@@ -25,16 +25,16 @@ func main() {
 	setup()
 	runtime.GC()
 	runtime.GC()
-	time.Sleep(10*time.Millisecond)
+	time.Sleep(10 * time.Millisecond)
 	runtime.GC()
 	runtime.GC()
-	time.Sleep(10*time.Millisecond)
+	time.Sleep(10 * time.Millisecond)
 }
 
 func setup() {
 	var Ts []interface{}
 	buf := make([]byte, 128)
-	
+
 	for i := 0; i < 10000; i++ {
 		s := string(buf)
 		t := &T{ptr: new(*int)}
@@ -42,7 +42,6 @@ func setup() {
 		Ts = append(Ts, t)
 		things = append(things, s[len(s):])
 	}
-	
+
 	things = append(things, Ts...)
 }
-
diff --git a/test/goprint.go b/test/goprint.go
index 57eeac53a8..84dc28e51c 100644
--- a/test/goprint.go
+++ b/test/goprint.go
@@ -16,6 +16,6 @@ import (
 func main() {
 	go println(42, true, false, true, 1.5, "world", (chan int)(nil), []int(nil), (map[string]int)(nil), (func())(nil), byte(255))
 	for runtime.NumGoroutine() > 1 {
-		time.Sleep(10*time.Millisecond)
+		time.Sleep(10 * time.Millisecond)
 	}
 }
diff --git a/test/import1.go b/test/import1.go
index 2433b5f2ad..19e766fd6f 100644
--- a/test/import1.go
+++ b/test/import1.go
@@ -9,11 +9,11 @@
 
 package main
 
-import "bufio"	// GCCGO_ERROR "previous|not used"
-import bufio "os"	// ERROR "redeclared|redefinition|incompatible" "imported and not used"
+import "bufio"    // GCCGO_ERROR "previous|not used"
+import bufio "os" // ERROR "redeclared|redefinition|incompatible" "imported and not used"
 
 import (
-	"fmt"	// GCCGO_ERROR "previous|not used"
-	fmt "math"	// ERROR "redeclared|redefinition|incompatible" "imported and not used: \x22math\x22 as fmt"
-	. "math"	// GC_ERROR "imported and not used: \x22math\x22$"
+	"fmt"      // GCCGO_ERROR "previous|not used"
+	. "math"   // GC_ERROR "imported and not used: \x22math\x22$"
+	fmt "math" // ERROR "redeclared|redefinition|incompatible" "imported and not used: \x22math\x22 as fmt"
 )
diff --git a/test/import2.dir/import2.go b/test/import2.dir/import2.go
index 9c54a1b87e..aaaa7336e1 100644
--- a/test/import2.dir/import2.go
+++ b/test/import2.dir/import2.go
@@ -6,37 +6,38 @@
 
 package p
 
-var C1 chan <- chan int = (chan<- (chan int))(nil)
-var C2 chan (<- chan int) = (chan (<-chan int))(nil)
-var C3 <- chan chan int = (<-chan (chan int))(nil)
-var C4 chan chan <- int = (chan (chan<- int))(nil)
-
-var C5 <- chan <- chan int = (<-chan (<-chan int))(nil)
-var C6 chan <- <- chan int = (chan<- (<-chan int))(nil)
-var C7 chan <- chan <- int = (chan<- (chan<- int))(nil)
-
-var C8 <- chan <- chan chan int = (<-chan (<-chan (chan int)))(nil)
-var C9 <- chan chan <- chan int = (<-chan (chan<- (chan int)))(nil)
-var C10 chan <- <- chan chan int = (chan<- (<-chan (chan int)))(nil)
-var C11 chan <- chan <- chan int = (chan<- (chan<- (chan int)))(nil)
-var C12 chan chan <- <- chan int = (chan (chan<- (<-chan int)))(nil)
-var C13 chan chan <- chan <- int = (chan (chan<- (chan<- int)))(nil)
-
-var R1 chan<- (chan int) = (chan <- chan int)(nil)
-var R3 <-chan (chan int) = (<- chan chan int)(nil)
-var R4 chan (chan<- int) = (chan chan <- int)(nil)
-
-var R5 <-chan (<-chan int) = (<- chan <- chan int)(nil)
-var R6 chan<- (<-chan int) = (chan <- <- chan int)(nil)
-var R7 chan<- (chan<- int) = (chan <- chan <- int)(nil)
-
-var R8 <-chan (<-chan (chan int)) = (<- chan <- chan chan int)(nil)
-var R9 <-chan (chan<- (chan int)) = (<- chan chan <- chan int)(nil)
-var R10 chan<- (<-chan (chan int)) = (chan <- <- chan chan int)(nil)
-var R11 chan<- (chan<- (chan int)) = (chan <- chan <- chan int)(nil)
-var R12 chan (chan<- (<-chan int)) = (chan chan <- <- chan int)(nil)
-var R13 chan (chan<- (chan<- int)) = (chan chan <- chan <- int)(nil)
+var C1 chan<- chan int = (chan<- (chan int))(nil)
+var C2 chan (<-chan int) = (chan (<-chan int))(nil)
+var C3 <-chan chan int = (<-chan (chan int))(nil)
+var C4 chan chan<- int = (chan (chan<- int))(nil)
+
+var C5 <-chan <-chan int = (<-chan (<-chan int))(nil)
+var C6 chan<- <-chan int = (chan<- (<-chan int))(nil)
+var C7 chan<- chan<- int = (chan<- (chan<- int))(nil)
+
+var C8 <-chan <-chan chan int = (<-chan (<-chan (chan int)))(nil)
+var C9 <-chan chan<- chan int = (<-chan (chan<- (chan int)))(nil)
+var C10 chan<- <-chan chan int = (chan<- (<-chan (chan int)))(nil)
+var C11 chan<- chan<- chan int = (chan<- (chan<- (chan int)))(nil)
+var C12 chan chan<- <-chan int = (chan (chan<- (<-chan int)))(nil)
+var C13 chan chan<- chan<- int = (chan (chan<- (chan<- int)))(nil)
+
+var R1 chan<- (chan int) = (chan<- chan int)(nil)
+var R3 <-chan (chan int) = (<-chan chan int)(nil)
+var R4 chan (chan<- int) = (chan chan<- int)(nil)
+
+var R5 <-chan (<-chan int) = (<-chan <-chan int)(nil)
+var R6 chan<- (<-chan int) = (chan<- <-chan int)(nil)
+var R7 chan<- (chan<- int) = (chan<- chan<- int)(nil)
+
+var R8 <-chan (<-chan (chan int)) = (<-chan <-chan chan int)(nil)
+var R9 <-chan (chan<- (chan int)) = (<-chan chan<- chan int)(nil)
+var R10 chan<- (<-chan (chan int)) = (chan<- <-chan chan int)(nil)
+var R11 chan<- (chan<- (chan int)) = (chan<- chan<- chan int)(nil)
+var R12 chan (chan<- (<-chan int)) = (chan chan<- <-chan int)(nil)
+var R13 chan (chan<- (chan<- int)) = (chan chan<- chan<- int)(nil)
 
 var F1 func() func() int
+
 func F2() func() func() int
 func F3(func() func() int)
diff --git a/test/import2.dir/import3.go b/test/import2.dir/import3.go
index 3bf9cb0c3c..461251d489 100644
--- a/test/import2.dir/import3.go
+++ b/test/import2.dir/import3.go
@@ -33,20 +33,19 @@ func main() {
 	p.C12 = (chan (chan<- (<-chan int)))(nil)
 	p.C13 = (chan (chan<- (chan<- int)))(nil)
 
-	p.R1 = (chan <- chan int)(nil)
-	p.R3 = (<- chan chan int)(nil)
-	p.R4 = (chan chan <- int)(nil)
+	p.R1 = (chan<- chan int)(nil)
+	p.R3 = (<-chan chan int)(nil)
+	p.R4 = (chan chan<- int)(nil)
 
-	p.R5 = (<- chan <- chan int)(nil)
-	p.R6 = (chan <- <- chan int)(nil)
-	p.R7 = (chan <- chan <- int)(nil)
+	p.R5 = (<-chan <-chan int)(nil)
+	p.R6 = (chan<- <-chan int)(nil)
+	p.R7 = (chan<- chan<- int)(nil)
 
-	p.R8 = (<- chan <- chan chan int)(nil)
-	p.R9 = (<- chan chan <- chan int)(nil)
-	p.R10 = (chan <- <- chan chan int)(nil)
-	p.R11 = (chan <- chan <- chan int)(nil)
-	p.R12 = (chan chan <- <- chan int)(nil)
-	p.R13 = (chan chan <- chan <- int)(nil)
+	p.R8 = (<-chan <-chan chan int)(nil)
+	p.R9 = (<-chan chan<- chan int)(nil)
+	p.R10 = (chan<- <-chan chan int)(nil)
+	p.R11 = (chan<- chan<- chan int)(nil)
+	p.R12 = (chan chan<- <-chan int)(nil)
+	p.R13 = (chan chan<- chan<- int)(nil)
 
 }
-
diff --git a/test/import4.dir/empty.go b/test/import4.dir/empty.go
index 1dffa170df..398c260d0f 100644
--- a/test/import4.dir/empty.go
+++ b/test/import4.dir/empty.go
@@ -4,7 +4,10 @@
 
 package empty
 
-import ( )
-const ( )
-var ( )
-type ( )
+import ()
+
+const ()
+
+var ()
+
+type ()
diff --git a/test/import4.dir/import4.go b/test/import4.dir/import4.go
index b9f973f172..f174b70be4 100644
--- a/test/import4.dir/import4.go
+++ b/test/import4.dir/import4.go
@@ -9,16 +9,15 @@
 package main
 
 // standard
-import "fmt"	// ERROR "imported and not used.*fmt"
+import "fmt" // ERROR "imported and not used.*fmt"
 
 // renamed
-import X "math"	// ERROR "imported and not used.*math"
+import X "math" // ERROR "imported and not used.*math"
 
 // import dot
-import . "bufio"	// ERROR "imported and not used.*bufio"
+import . "bufio" // ERROR "imported and not used.*bufio"
 
 // again, package without anything in it
-import "./empty"	// ERROR "imported and not used.*empty"
-import Z "./empty"	// ERROR "imported and not used.*empty"
-import . "./empty"	// ERROR "imported and not used.*empty"
-
+import "./empty"   // ERROR "imported and not used.*empty"
+import Z "./empty" // ERROR "imported and not used.*empty"
+import . "./empty" // ERROR "imported and not used.*empty"
diff --git a/test/indirect1.go b/test/indirect1.go
index 51da4cc7c4..1395eacaf8 100644
--- a/test/indirect1.go
+++ b/test/indirect1.go
@@ -37,36 +37,36 @@ func f() {
 	// line number for each len call when
 	// it decides there are type errors.
 	x :=
-		len(m0)+
-		len(m1)+	// ERROR "illegal|invalid|must be"
-		len(m2)+	// ERROR "illegal|invalid|must be"
-		len(m3)+
-		len(m4)+	// ERROR "illegal|invalid|must be"
+		len(m0) +
+			len(m1) + // ERROR "illegal|invalid|must be"
+			len(m2) + // ERROR "illegal|invalid|must be"
+			len(m3) +
+			len(m4) + // ERROR "illegal|invalid|must be"
 
-		len(s0)+
-		len(s1)+	// ERROR "illegal|invalid|must be"
-		len(s2)+	// ERROR "illegal|invalid|must be"
-		len(s3)+
-		len(s4)+	// ERROR "illegal|invalid|must be"
+			len(s0) +
+			len(s1) + // ERROR "illegal|invalid|must be"
+			len(s2) + // ERROR "illegal|invalid|must be"
+			len(s3) +
+			len(s4) + // ERROR "illegal|invalid|must be"
 
-		len(a0)+
-		len(a1)+
-		len(a2)+
+			len(a0) +
+			len(a1) +
+			len(a2) +
 
-		cap(a0)+
-		cap(a1)+
-		cap(a2)+
+			cap(a0) +
+			cap(a1) +
+			cap(a2) +
 
-		len(b0)+
-		len(b1)+	// ERROR "illegal|invalid|must be"
-		len(b2)+	// ERROR "illegal|invalid|must be"
-		len(b3)+
-		len(b4)+	// ERROR "illegal|invalid|must be"
+			len(b0) +
+			len(b1) + // ERROR "illegal|invalid|must be"
+			len(b2) + // ERROR "illegal|invalid|must be"
+			len(b3) +
+			len(b4) + // ERROR "illegal|invalid|must be"
 
-		cap(b0)+
-		cap(b1)+	// ERROR "illegal|invalid|must be"
-		cap(b2)+	// ERROR "illegal|invalid|must be"
-		cap(b3)+
-		cap(b4)	// ERROR "illegal|invalid|must be"
+			cap(b0) +
+			cap(b1) + // ERROR "illegal|invalid|must be"
+			cap(b2) + // ERROR "illegal|invalid|must be"
+			cap(b3) +
+			cap(b4) // ERROR "illegal|invalid|must be"
 	_ = x
 }
diff --git a/test/initcomma.go b/test/initcomma.go
index a54fce4280..e6cfffda3a 100644
--- a/test/initcomma.go
+++ b/test/initcomma.go
@@ -8,10 +8,10 @@
 
 package main
 
-var a = []int{1, 2, }
-var b = [5]int{1, 2, 3, }
-var c = []int{1, }
-var d = [...]int{1, 2, 3, }
+var a = []int{1, 2}
+var b = [5]int{1, 2, 3}
+var c = []int{1}
+var d = [...]int{1, 2, 3}
 
 func main() {
 	if len(a) != 2 {
diff --git a/test/initialize.go b/test/initialize.go
index 1307e02096..0cf7fe2f5c 100644
--- a/test/initialize.go
+++ b/test/initialize.go
@@ -19,35 +19,35 @@ type T struct {
 	S
 }
 
-var a1 = S { 0, 0, 0, 1, 2, 3 }
-var b1 = S { X: 1, Z: 3, Y: 2 }
+var a1 = S{0, 0, 0, 1, 2, 3}
+var b1 = S{X: 1, Z: 3, Y: 2}
 
-var a2 = S { 0, 0, 0, 0, 0, 0, }
-var b2 = S { }
+var a2 = S{0, 0, 0, 0, 0, 0}
+var b2 = S{}
 
-var a3 = T { S { 1, 2, 3, 0, 0, 0, } }
-var b3 = T { S: S{ A: 1, B: 2, C: 3 } }
+var a3 = T{S{1, 2, 3, 0, 0, 0}}
+var b3 = T{S: S{A: 1, B: 2, C: 3}}
 
-var a4 = &[16]byte { 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, }
-var b4 = &[16]byte { 4: 1, 1, 1, 1, 12: 1, 1, }
+var a4 = &[16]byte{0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0}
+var b4 = &[16]byte{4: 1, 1, 1, 1, 12: 1, 1}
 
-var a5 = &[16]byte { 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, }
-var b5 = &[16]byte { 1, 4: 1, 1, 1, 1, 12: 1, 1, }
+var a5 = &[16]byte{1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0}
+var b5 = &[16]byte{1, 4: 1, 1, 1, 1, 12: 1, 1}
 
-var a6 = &[16]byte { 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, }
-var b6 = &[...]byte { 1, 4: 1, 1, 1, 1, 12: 1, 1, 0, 0,}
+var a6 = &[16]byte{1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0}
+var b6 = &[...]byte{1, 4: 1, 1, 1, 1, 12: 1, 1, 0, 0}
 
 type Same struct {
 	a, b interface{}
 }
 
-var same = []Same {
-	Same{ a1, b1 },
-	Same{ a2, b2 },
-	Same{ a3, b3 },
-	Same{ a4, b4 },
-	Same{ a5, b5 },
-	Same{ a6, b6 },
+var same = []Same{
+	Same{a1, b1},
+	Same{a2, b2},
+	Same{a3, b3},
+	Same{a4, b4},
+	Same{a5, b5},
+	Same{a6, b6},
 }
 
 func main() {
diff --git a/test/initializerr.go b/test/initializerr.go
index 990ab60f96..11f1941629 100644
--- a/test/initializerr.go
+++ b/test/initializerr.go
@@ -18,24 +18,24 @@ type T struct {
 }
 
 var x = 1
-var a1 = S { 0, X: 1 }	// ERROR "mixture|undefined"
-var a2 = S { Y: 3, Z: 2, Y: 3 } // ERROR "duplicate"
-var a3 = T { S{}, 2, 3, 4, 5, 6 }	// ERROR "convert|too many"
-var a4 = [5]byte{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }	// ERROR "index|too many"
-var a5 = []byte { x: 2 }	// ERROR "index"
-var a6 = []byte{1: 1, 2: 2, 1: 3}	// ERROR "duplicate index"
+var a1 = S{0, X: 1}                             // ERROR "mixture|undefined"
+var a2 = S{Y: 3, Z: 2, Y: 3}                    // ERROR "duplicate"
+var a3 = T{S{}, 2, 3, 4, 5, 6}                  // ERROR "convert|too many"
+var a4 = [5]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} // ERROR "index|too many"
+var a5 = []byte{x: 2}                           // ERROR "index"
+var a6 = []byte{1: 1, 2: 2, 1: 3}               // ERROR "duplicate index"
 
-var ok1 = S { }	// should be ok
-var ok2 = T { S: ok1 }	// should be ok
+var ok1 = S{}       // should be ok
+var ok2 = T{S: ok1} // should be ok
 
 // These keys can be computed at compile time but they are
 // not constants as defined by the spec, so they do not trigger
 // compile-time errors about duplicate key values.
 // See issue 4555.
 
-type Key struct {X, Y int}
+type Key struct{ X, Y int }
 
 var _ = map[Key]string{
-	Key{1,2}: "hello",
-	Key{1,2}: "world",
+	Key{1, 2}: "hello",
+	Key{1, 2}: "world",
 }
diff --git a/test/inline_sync.go b/test/inline_sync.go
index 30b436af41..27913c1ccc 100644
--- a/test/inline_sync.go
+++ b/test/inline_sync.go
@@ -35,19 +35,18 @@ func small6() { // ERROR "can inline small6"
 var once *sync.Once
 
 func small7() { // ERROR "can inline small7"
-        // the Do fast path should be inlined
-        once.Do(small5) // ERROR "inlining call to sync\.\(\*Once\)\.Do"
+	// the Do fast path should be inlined
+	once.Do(small5) // ERROR "inlining call to sync\.\(\*Once\)\.Do"
 }
 
 var rwmutex *sync.RWMutex
 
 func small8() { // ERROR "can inline small8"
-        // the RUnlock fast path should be inlined
-        rwmutex.RUnlock() // ERROR "inlining call to sync\.\(\*RWMutex\)\.RUnlock"
+	// the RUnlock fast path should be inlined
+	rwmutex.RUnlock() // ERROR "inlining call to sync\.\(\*RWMutex\)\.RUnlock"
 }
 
 func small9() { // ERROR "can inline small9"
-        // the RLock fast path should be inlined
-        rwmutex.RLock() // ERROR "inlining call to sync\.\(\*RWMutex\)\.RLock"
+	// the RLock fast path should be inlined
+	rwmutex.RLock() // ERROR "inlining call to sync\.\(\*RWMutex\)\.RLock"
 }
-
diff --git a/test/int_lit.go b/test/int_lit.go
index 78deaea130..cb24c6cb16 100644
--- a/test/int_lit.go
+++ b/test/int_lit.go
@@ -11,14 +11,14 @@ package main
 import "os"
 
 func main() {
-	s := 	0 +
+	s := 0 +
 		123 +
 		0123 +
 		0000 +
 		0x0 +
 		0x123 +
-		0X0 +
-		0X123
+		0x0 +
+		0x123
 	if s != 788 {
 		print("s is ", s, "; should be 788\n")
 		os.Exit(1)
diff --git a/test/intcvt.go b/test/intcvt.go
index 3920528a40..d9477617ae 100644
--- a/test/intcvt.go
+++ b/test/intcvt.go
@@ -86,6 +86,7 @@ func chku64(i, v uint64) {
 		panic("fail")
 	}
 }
+
 //func chkf32(f, v float32) { if f != v { println(f, "!=", v); panic("fail") } }
 //func chkf64(f, v float64) { if f != v { println(f, "!=", v); panic("fail") } }
 
@@ -134,7 +135,6 @@ func main() {
 	//	chki64(int64(f32), 0)
 	//	chki64(int64(f64), 0)
 
-
 	chku8(uint8(i8), ci8&0xff)
 	chku8(uint8(i16), ci16&0xff)
 	chku8(uint8(i32), ci32&0xff)
diff --git a/test/interface/bigdata.go b/test/interface/bigdata.go
index 0f2e9a990e..f194f75b08 100644
--- a/test/interface/bigdata.go
+++ b/test/interface/bigdata.go
@@ -8,15 +8,18 @@
 
 package main
 
-type I interface { M() int64 }
+type I interface{ M() int64 }
 
-type BigPtr struct { a, b, c, d int64 }
-func (z *BigPtr) M() int64 { return z.a+z.b+z.c+z.d }
+type BigPtr struct{ a, b, c, d int64 }
+
+func (z *BigPtr) M() int64 { return z.a + z.b + z.c + z.d }
+
+type SmallPtr struct{ a int32 }
 
-type SmallPtr struct { a int32 }
 func (z *SmallPtr) M() int64 { return int64(z.a) }
 
 type IntPtr int32
+
 func (z *IntPtr) M() int64 { return int64(*z) }
 
 var bad bool
@@ -30,30 +33,33 @@ func test(name string, i I) {
 }
 
 func ptrs() {
-	var bigptr BigPtr = BigPtr{ 10000, 2000, 300, 45 }
-	var smallptr SmallPtr = SmallPtr{ 12345 }
+	var bigptr BigPtr = BigPtr{10000, 2000, 300, 45}
+	var smallptr SmallPtr = SmallPtr{12345}
 	var intptr IntPtr = 12345
 
-//	test("bigptr", bigptr)
+	//	test("bigptr", bigptr)
 	test("&bigptr", &bigptr)
-//	test("smallptr", smallptr)
+	//	test("smallptr", smallptr)
 	test("&smallptr", &smallptr)
-//	test("intptr", intptr)
+	//	test("intptr", intptr)
 	test("&intptr", &intptr)
 }
 
-type Big struct { a, b, c, d int64 }
-func (z Big) M() int64 { return z.a+z.b+z.c+z.d }
+type Big struct{ a, b, c, d int64 }
+
+func (z Big) M() int64 { return z.a + z.b + z.c + z.d }
+
+type Small struct{ a int32 }
 
-type Small struct { a int32 }
 func (z Small) M() int64 { return int64(z.a) }
 
 type Int int32
+
 func (z Int) M() int64 { return int64(z) }
 
 func nonptrs() {
-	var big Big = Big{ 10000, 2000, 300, 45 }
-	var small Small = Small{ 12345 }
+	var big Big = Big{10000, 2000, 300, 45}
+	var small Small = Small{12345}
 	var int Int = 12345
 
 	test("big", big)
diff --git a/test/interface/convert1.go b/test/interface/convert1.go
index 4a3ec8a375..98261edf9b 100644
--- a/test/interface/convert1.go
+++ b/test/interface/convert1.go
@@ -8,10 +8,13 @@
 
 package main
 
-type R interface { R() }
-type RW interface { R(); W() }
+type R interface{ R() }
+type RW interface {
+	R()
+	W()
+}
 
-var e interface {}
+var e interface{}
 var r R
 var rw RW
 
diff --git a/test/interface/convert2.go b/test/interface/convert2.go
index 4a3ec8a375..98261edf9b 100644
--- a/test/interface/convert2.go
+++ b/test/interface/convert2.go
@@ -8,10 +8,13 @@
 
 package main
 
-type R interface { R() }
-type RW interface { R(); W() }
+type R interface{ R() }
+type RW interface {
+	R()
+	W()
+}
 
-var e interface {}
+var e interface{}
 var r R
 var rw RW
 
diff --git a/test/interface/embed.go b/test/interface/embed.go
index 5c52ac0232..993c532b2a 100644
--- a/test/interface/embed.go
+++ b/test/interface/embed.go
@@ -12,16 +12,19 @@ import "os"
 
 const Value = 1e12
 
-type Inter interface { M() int64 }
+type Inter interface{ M() int64 }
 
 type T int64
+
 func (t T) M() int64 { return int64(t) }
+
 var t = T(Value)
 var pt = &t
 var ti Inter = t
 
-type S struct { Inter }
-var s = S{ ti }
+type S struct{ Inter }
+
+var s = S{ti}
 var ps = &s
 
 var i Inter
diff --git a/test/interface/embed1.dir/embed0.go b/test/interface/embed1.dir/embed0.go
index 728bec74e8..4aed391b63 100644
--- a/test/interface/embed1.dir/embed0.go
+++ b/test/interface/embed1.dir/embed0.go
@@ -7,10 +7,11 @@
 package p
 
 type T int
+
 func (t T) m() {}
 
-type I interface { m() }
-type J interface { I }
+type I interface{ m() }
+type J interface{ I }
 
 func main() {
 	var i I
diff --git a/test/interface/embed1.dir/embed1.go b/test/interface/embed1.dir/embed1.go
index 7dfb1dbc0a..54754f3069 100644
--- a/test/interface/embed1.dir/embed1.go
+++ b/test/interface/embed1.dir/embed1.go
@@ -9,13 +9,14 @@ package main
 import "./embed0"
 
 type T int
+
 func (t T) m() {}
 
-type I interface { m() }
-type J interface { I }
+type I interface{ m() }
+type J interface{ I }
 
-type PI interface { p.I }
-type PJ interface { p.J }
+type PI interface{ p.I }
+type PJ interface{ p.J }
 
 func main() {
 	var i I
diff --git a/test/interface/pointer.go b/test/interface/pointer.go
index 2927050669..23e8ec285c 100644
--- a/test/interface/pointer.go
+++ b/test/interface/pointer.go
@@ -24,7 +24,6 @@ type Start struct {
 
 func (start *Start) Next() *Inst { return nil }
 
-
 func AddInst(Inst) *Inst {
 	print("ok in addinst\n")
 	return nil
@@ -34,5 +33,5 @@ func main() {
 	print("call addinst\n")
 	var x Inst = AddInst(new(Start)) // ERROR "pointer to interface"
 	print("return from  addinst\n")
-	var y *Inst = new(Start)  // ERROR "pointer to interface|incompatible type"
+	var y *Inst = new(Start) // ERROR "pointer to interface|incompatible type"
 }
diff --git a/test/interface/private.dir/private1.go b/test/interface/private.dir/private1.go
index 75eee51f5a..8743ddb352 100644
--- a/test/interface/private.dir/private1.go
+++ b/test/interface/private.dir/private1.go
@@ -15,4 +15,3 @@ type Implementation struct{}
 func (p *Implementation) private() {}
 
 var X = new(Implementation)
-
diff --git a/test/interface/private.dir/prog.go b/test/interface/private.dir/prog.go
index abea7d625c..e20c188eda 100644
--- a/test/interface/private.dir/prog.go
+++ b/test/interface/private.dir/prog.go
@@ -25,9 +25,9 @@ func main() {
 	var px p.Exported
 	px = p.X
 
-	px.private()			// ERROR "private"
+	px.private() // ERROR "private"
 
-	px = new(Implementation)	// ERROR "private"
+	px = new(Implementation) // ERROR "private"
 
-	x = px				// ERROR "private"
+	x = px // ERROR "private"
 }
diff --git a/test/interface/recursive.go b/test/interface/recursive.go
index fcc88331e0..bfb517bdcc 100644
--- a/test/interface/recursive.go
+++ b/test/interface/recursive.go
@@ -17,5 +17,6 @@ type I2 interface {
 }
 
 type T int
+
 func (t T) foo() I2 { return t }
 func (t T) bar() I1 { return t }
diff --git a/test/interface/returntype.go b/test/interface/returntype.go
index 4d86f39184..d94b2ed68b 100644
--- a/test/interface/returntype.go
+++ b/test/interface/returntype.go
@@ -8,14 +8,14 @@
 
 package main
 
-type S struct { a int }
-type T struct { b string }
+type S struct{ a int }
+type T struct{ b string }
 
-func (s *S) Name() int8 { return 1 }
+func (s *S) Name() int8  { return 1 }
 func (t *T) Name() int64 { return 64 }
 
-type I1 interface { Name() int8 }
-type I2 interface { Name() int64 }
+type I1 interface{ Name() int8 }
+type I2 interface{ Name() int64 }
 
 func main() {
 	shouldPanic(p1)
diff --git a/test/interface/struct.go b/test/interface/struct.go
index f60819ca81..628e5de5e3 100644
--- a/test/interface/struct.go
+++ b/test/interface/struct.go
@@ -13,16 +13,20 @@ import "os"
 var fail int
 
 func check(b bool, msg string) {
-	if (!b) {
+	if !b {
 		println("failure in", msg)
 		fail++
 	}
 }
 
-type I1 interface { Get() int; Put(int) }
+type I1 interface {
+	Get() int
+	Put(int)
+}
+
+type S1 struct{ i int }
 
-type S1 struct { i int }
-func (p S1) Get() int { return p.i }
+func (p S1) Get() int  { return p.i }
 func (p S1) Put(i int) { p.i = i }
 
 func f1() {
@@ -49,8 +53,9 @@ func f3() {
 	check(s.i == 1, "f3 s")
 }
 
-type S2 struct { i int }
-func (p *S2) Get() int { return p.i }
+type S2 struct{ i int }
+
+func (p *S2) Get() int  { return p.i }
 func (p *S2) Put(i int) { p.i = i }
 
 // Disallowed by restriction of values going to pointer receivers
@@ -78,10 +83,14 @@ func f6() {
 	check(s.i == 2, "f6 s")
 }
 
-type I2 interface { Get() int64; Put(int64) }
+type I2 interface {
+	Get() int64
+	Put(int64)
+}
+
+type S3 struct{ i, j, k, l int64 }
 
-type S3 struct { i, j, k, l int64 }
-func (p S3) Get() int64 { return p.l }
+func (p S3) Get() int64  { return p.l }
 func (p S3) Put(i int64) { p.l = i }
 
 func f7() {
@@ -108,8 +117,9 @@ func f9() {
 	check(s.l == 4, "f9 s")
 }
 
-type S4 struct { i, j, k, l int64 }
-func (p *S4) Get() int64 { return p.l }
+type S4 struct{ i, j, k, l int64 }
+
+func (p *S4) Get() int64  { return p.l }
 func (p *S4) Put(i int64) { p.l = i }
 
 // Disallowed by restriction of values going to pointer receivers
@@ -141,13 +151,13 @@ func main() {
 	f1()
 	f2()
 	f3()
-//	f4()
+	//	f4()
 	f5()
 	f6()
 	f7()
 	f8()
 	f9()
-//	f10()
+	//	f10()
 	f11()
 	f12()
 	if fail > 0 {
diff --git a/test/iota.go b/test/iota.go
index 7187dbe335..490b27d238 100644
--- a/test/iota.go
+++ b/test/iota.go
@@ -16,9 +16,9 @@ func assert(cond bool, msg string) {
 }
 
 const (
-	x int = iota
-	y = iota
-	z = 1 << iota
+	x int     = iota
+	y         = iota
+	z         = 1 << iota
 	f float32 = 2 * iota
 	g float32 = 4.5 * float32(iota)
 )
diff --git a/test/ken/complit.go b/test/ken/complit.go
index bc50bbe224..99d9d7713f 100644
--- a/test/ken/complit.go
+++ b/test/ken/complit.go
@@ -8,118 +8,115 @@
 
 package main
 
-type	M	map[int]int
-type	S	struct{ a,b,c int };
-type	SS	struct{ aa,bb,cc S };
-type	SA	struct{ a,b,c [3]int };
-type	SC	struct{ a,b,c []int };
-type	SM	struct{ a,b,c M };
-
-func
-main() {
-	test("s.a", s.a);
-	test("s.b", s.b);
-	test("s.c", s.c);
-
-	test("ss.aa.a", ss.aa.a);
-	test("ss.aa.b", ss.aa.b);
-	test("ss.aa.c", ss.aa.c);
-
-	test("ss.bb.a", ss.bb.a);
-	test("ss.bb.b", ss.bb.b);
-	test("ss.bb.c", ss.bb.c);
-
-	test("ss.cc.a", ss.cc.a);
-	test("ss.cc.b", ss.cc.b);
-	test("ss.cc.c", ss.cc.c);
-
-	for i:=0; i<3; i++ {
-		test("a[i]", a[i]);
-		test("c[i]", c[i]);
-		test("m[i]", m[i]);
-
-		test("as[i].a", as[i].a);
-		test("as[i].b", as[i].b);
-		test("as[i].c", as[i].c);
-
-		test("cs[i].a", cs[i].a);
-		test("cs[i].b", cs[i].b);
-		test("cs[i].c", cs[i].c);
-
-		test("ms[i].a", ms[i].a);
-		test("ms[i].b", ms[i].b);
-		test("ms[i].c", ms[i].c);
-
-		test("sa.a[i]", sa.a[i]);
-		test("sa.b[i]", sa.b[i]);
-		test("sa.c[i]", sa.c[i]);
-
-		test("sc.a[i]", sc.a[i]);
-		test("sc.b[i]", sc.b[i]);
-		test("sc.c[i]", sc.c[i]);
-
-		test("sm.a[i]", sm.a[i]);
-		test("sm.b[i]", sm.b[i]);
-		test("sm.c[i]", sm.c[i]);
-
-		for j:=0; j<3; j++ {
-			test("aa[i][j]", aa[i][j]);
-			test("ac[i][j]", ac[i][j]);
-			test("am[i][j]", am[i][j]);
-			test("ca[i][j]", ca[i][j]);
-			test("cc[i][j]", cc[i][j]);
-			test("cm[i][j]", cm[i][j]);
-			test("ma[i][j]", ma[i][j]);
-			test("mc[i][j]", mc[i][j]);
-			test("mm[i][j]", mm[i][j]);
+type M map[int]int
+type S struct{ a, b, c int }
+type SS struct{ aa, bb, cc S }
+type SA struct{ a, b, c [3]int }
+type SC struct{ a, b, c []int }
+type SM struct{ a, b, c M }
+
+func main() {
+	test("s.a", s.a)
+	test("s.b", s.b)
+	test("s.c", s.c)
+
+	test("ss.aa.a", ss.aa.a)
+	test("ss.aa.b", ss.aa.b)
+	test("ss.aa.c", ss.aa.c)
+
+	test("ss.bb.a", ss.bb.a)
+	test("ss.bb.b", ss.bb.b)
+	test("ss.bb.c", ss.bb.c)
+
+	test("ss.cc.a", ss.cc.a)
+	test("ss.cc.b", ss.cc.b)
+	test("ss.cc.c", ss.cc.c)
+
+	for i := 0; i < 3; i++ {
+		test("a[i]", a[i])
+		test("c[i]", c[i])
+		test("m[i]", m[i])
+
+		test("as[i].a", as[i].a)
+		test("as[i].b", as[i].b)
+		test("as[i].c", as[i].c)
+
+		test("cs[i].a", cs[i].a)
+		test("cs[i].b", cs[i].b)
+		test("cs[i].c", cs[i].c)
+
+		test("ms[i].a", ms[i].a)
+		test("ms[i].b", ms[i].b)
+		test("ms[i].c", ms[i].c)
+
+		test("sa.a[i]", sa.a[i])
+		test("sa.b[i]", sa.b[i])
+		test("sa.c[i]", sa.c[i])
+
+		test("sc.a[i]", sc.a[i])
+		test("sc.b[i]", sc.b[i])
+		test("sc.c[i]", sc.c[i])
+
+		test("sm.a[i]", sm.a[i])
+		test("sm.b[i]", sm.b[i])
+		test("sm.c[i]", sm.c[i])
+
+		for j := 0; j < 3; j++ {
+			test("aa[i][j]", aa[i][j])
+			test("ac[i][j]", ac[i][j])
+			test("am[i][j]", am[i][j])
+			test("ca[i][j]", ca[i][j])
+			test("cc[i][j]", cc[i][j])
+			test("cm[i][j]", cm[i][j])
+			test("ma[i][j]", ma[i][j])
+			test("mc[i][j]", mc[i][j])
+			test("mm[i][j]", mm[i][j])
 		}
 	}
 
 }
 
-var	ref	= 0;
+var ref = 0
 
-func
-test(xs string, x int) {
+func test(xs string, x int) {
 
 	if ref >= len(answers) {
-		println(xs, x);
-		return;
+		println(xs, x)
+		return
 	}
 
 	if x != answers[ref] {
 		println(xs, "is", x, "should be", answers[ref])
 	}
-	ref++;
+	ref++
 }
 
+var a = [3]int{1001, 1002, 1003}
+var s = S{1101, 1102, 1103}
+var c = []int{1201, 1202, 1203}
+var m = M{0: 1301, 1: 1302, 2: 1303}
 
-var	a	= [3]int{1001, 1002, 1003}
-var	s	= S{1101, 1102, 1103}
-var	c	= []int{1201, 1202, 1203}
-var	m	= M{0:1301, 1:1302, 2:1303}
+var aa = [3][3]int{[3]int{2001, 2002, 2003}, [3]int{2004, 2005, 2006}, [3]int{2007, 2008, 2009}}
+var as = [3]S{S{2101, 2102, 2103}, S{2104, 2105, 2106}, S{2107, 2108, 2109}}
+var ac = [3][]int{[]int{2201, 2202, 2203}, []int{2204, 2205, 2206}, []int{2207, 2208, 2209}}
+var am = [3]M{M{0: 2301, 1: 2302, 2: 2303}, M{0: 2304, 1: 2305, 2: 2306}, M{0: 2307, 1: 2308, 2: 2309}}
 
-var	aa	= [3][3]int{[3]int{2001,2002,2003}, [3]int{2004,2005,2006}, [3]int{2007,2008,2009}}
-var	as	= [3]S{S{2101,2102,2103},S{2104,2105,2106},S{2107,2108,2109}}
-var	ac	= [3][]int{[]int{2201,2202,2203}, []int{2204,2205,2206}, []int{2207,2208,2209}}
-var	am	= [3]M{M{0:2301,1:2302,2:2303}, M{0:2304,1:2305,2:2306}, M{0:2307,1:2308,2:2309}}
+var sa = SA{[3]int{3001, 3002, 3003}, [3]int{3004, 3005, 3006}, [3]int{3007, 3008, 3009}}
+var ss = SS{S{3101, 3102, 3103}, S{3104, 3105, 3106}, S{3107, 3108, 3109}}
+var sc = SC{[]int{3201, 3202, 3203}, []int{3204, 3205, 3206}, []int{3207, 3208, 3209}}
+var sm = SM{M{0: 3301, 1: 3302, 2: 3303}, M{0: 3304, 1: 3305, 2: 3306}, M{0: 3307, 1: 3308, 2: 3309}}
 
-var	sa	= SA{[3]int{3001,3002,3003},[3]int{3004,3005,3006},[3]int{3007,3008,3009}}
-var	ss	= SS{S{3101,3102,3103},S{3104,3105,3106},S{3107,3108,3109}}
-var	sc	= SC{[]int{3201,3202,3203},[]int{3204,3205,3206},[]int{3207,3208,3209}}
-var	sm	= SM{M{0:3301,1:3302,2:3303}, M{0:3304,1:3305,2:3306}, M{0:3307,1:3308,2:3309}}
+var ca = [][3]int{[3]int{4001, 4002, 4003}, [3]int{4004, 4005, 4006}, [3]int{4007, 4008, 4009}}
+var cs = []S{S{4101, 4102, 4103}, S{4104, 4105, 4106}, S{4107, 4108, 4109}}
+var cc = [][]int{[]int{4201, 4202, 4203}, []int{4204, 4205, 4206}, []int{4207, 4208, 4209}}
+var cm = []M{M{0: 4301, 1: 4302, 2: 4303}, M{0: 4304, 1: 4305, 2: 4306}, M{0: 4307, 1: 4308, 2: 4309}}
 
-var	ca	= [][3]int{[3]int{4001,4002,4003}, [3]int{4004,4005,4006}, [3]int{4007,4008,4009}}
-var	cs	= []S{S{4101,4102,4103},S{4104,4105,4106},S{4107,4108,4109}}
-var	cc	= [][]int{[]int{4201,4202,4203}, []int{4204,4205,4206}, []int{4207,4208,4209}}
-var	cm	= []M{M{0:4301,1:4302,2:4303}, M{0:4304,1:4305,2:4306}, M{0:4307,1:4308,2:4309}}
+var ma = map[int][3]int{0: [3]int{5001, 5002, 5003}, 1: [3]int{5004, 5005, 5006}, 2: [3]int{5007, 5008, 5009}}
+var ms = map[int]S{0: S{5101, 5102, 5103}, 1: S{5104, 5105, 5106}, 2: S{5107, 5108, 5109}}
+var mc = map[int][]int{0: []int{5201, 5202, 5203}, 1: []int{5204, 5205, 5206}, 2: []int{5207, 5208, 5209}}
+var mm = map[int]M{0: M{0: 5301, 1: 5302, 2: 5303}, 1: M{0: 5304, 1: 5305, 2: 5306}, 2: M{0: 5307, 1: 5308, 2: 5309}}
 
-var	ma	= map[int][3]int{0:[3]int{5001,5002,5003}, 1:[3]int{5004,5005,5006}, 2:[3]int{5007,5008,5009}}
-var	ms	= map[int]S{0:S{5101,5102,5103},1:S{5104,5105,5106},2:S{5107,5108,5109}}
-var	mc	= map[int][]int{0:[]int{5201,5202,5203}, 1:[]int{5204,5205,5206}, 2:[]int{5207,5208,5209}}
-var	mm	= map[int]M{0:M{0:5301,1:5302,2:5303}, 1:M{0:5304,1:5305,2:5306}, 2:M{0:5307,1:5308,2:5309}}
-
-var	answers	= [...]int {
+var answers = [...]int{
 	// s
 	1101, 1102, 1103,
 
diff --git a/test/ken/convert.go b/test/ken/convert.go
index 33acbd8cd2..f3b08edbc2 100644
--- a/test/ken/convert.go
+++ b/test/ken/convert.go
@@ -9,26 +9,26 @@
 
 package main
 
-var i8 int8;
-var u8 uint8;
-var i16 int16;
-var u16 uint16;
-var i32 int32;
-var u32 uint32;
-var i64 int64;
-var u64 uint64;
-var f32 float32;
-var f64 float64;
-
-type	big	float64
-
-type	t	struct {
-	from, to	int
-	val		big
+var i8 int8
+var u8 uint8
+var i16 int16
+var u16 uint16
+var i32 int32
+var u32 uint32
+var i64 int64
+var u64 uint64
+var f32 float32
+var f64 float64
+
+type big float64
+
+type t struct {
+	from, to int
+	val      big
 }
 
 const (
-	ti8	= iota+1
+	ti8 = iota + 1
 	tu8
 	ti16
 	tu16
@@ -40,177 +40,184 @@ const (
 	tf64
 )
 
-var	x = []t{
+var x = []t{
 
 	/* value good in all types (10) */
-	{ ti8,  ti8,  10 }, { ti8,  tu8,  10 }, { ti8,  ti16, 10 }, { ti8,  tu16, 10 },
-	{ ti8,  ti32, 10 }, { ti8,  tu32, 10 }, { ti8,  ti64, 10 }, { ti8,  tu64, 10 },
-	{ ti8,  tf32, 10 }, { ti8,  tf64, 10 },
+	{ti8, ti8, 10}, {ti8, tu8, 10}, {ti8, ti16, 10}, {ti8, tu16, 10},
+	{ti8, ti32, 10}, {ti8, tu32, 10}, {ti8, ti64, 10}, {ti8, tu64, 10},
+	{ti8, tf32, 10}, {ti8, tf64, 10},
 
-	{ tu8,  ti8,  10 }, { tu8,  tu8,  10 }, { tu8,  ti16, 10 }, { tu8,  tu16, 10 },
-	{ tu8,  ti32, 10 }, { tu8,  tu32, 10 }, { tu8,  ti64, 10 }, { tu8,  tu64, 10 },
-	{ tu8,  tf32, 10 }, { tu8,  tf64, 10 },
+	{tu8, ti8, 10}, {tu8, tu8, 10}, {tu8, ti16, 10}, {tu8, tu16, 10},
+	{tu8, ti32, 10}, {tu8, tu32, 10}, {tu8, ti64, 10}, {tu8, tu64, 10},
+	{tu8, tf32, 10}, {tu8, tf64, 10},
 
-	{ ti16, ti8,  10 }, { ti16, tu8,  10 }, { ti16, ti16, 10 }, { ti16, tu16, 10 },
-	{ ti16, ti32, 10 }, { ti16, tu32, 10 }, { ti16, ti64, 10 }, { ti16, tu64, 10 },
-	{ ti16, tf32, 10 }, { ti16, tf64, 10 },
+	{ti16, ti8, 10}, {ti16, tu8, 10}, {ti16, ti16, 10}, {ti16, tu16, 10},
+	{ti16, ti32, 10}, {ti16, tu32, 10}, {ti16, ti64, 10}, {ti16, tu64, 10},
+	{ti16, tf32, 10}, {ti16, tf64, 10},
 
-	{ tu16, ti8,  10 }, { tu16, tu8,  10 }, { tu16, ti16, 10 }, { tu16, tu16, 10 },
-	{ tu16, ti32, 10 }, { tu16, tu32, 10 }, { tu16, ti64, 10 }, { tu16, tu64, 10 },
-	{ tu16, tf32, 10 }, { tu16, tf64, 10 },
+	{tu16, ti8, 10}, {tu16, tu8, 10}, {tu16, ti16, 10}, {tu16, tu16, 10},
+	{tu16, ti32, 10}, {tu16, tu32, 10}, {tu16, ti64, 10}, {tu16, tu64, 10},
+	{tu16, tf32, 10}, {tu16, tf64, 10},
 
-	{ ti32, ti8,  10 }, { ti32, tu8,  10 }, { ti32, ti16, 10 }, { ti32, tu16, 10 },
-	{ ti32, ti32, 10 }, { ti32, tu32, 10 }, { ti32, ti64, 10 }, { ti32, tu64, 10 },
-	{ ti32, tf32, 10 }, { ti32, tf64, 10 },
+	{ti32, ti8, 10}, {ti32, tu8, 10}, {ti32, ti16, 10}, {ti32, tu16, 10},
+	{ti32, ti32, 10}, {ti32, tu32, 10}, {ti32, ti64, 10}, {ti32, tu64, 10},
+	{ti32, tf32, 10}, {ti32, tf64, 10},
 
-	{ tu32, ti8,  10 }, { tu32, tu8,  10 }, { tu32, ti16, 10 }, { tu32, tu16, 10 },
-	{ tu32, ti32, 10 }, { tu32, tu32, 10 }, { tu32, ti64, 10 }, { tu32, tu64, 10 },
-	{ tu32, tf32, 10 }, { tu32, tf64, 10 },
+	{tu32, ti8, 10}, {tu32, tu8, 10}, {tu32, ti16, 10}, {tu32, tu16, 10},
+	{tu32, ti32, 10}, {tu32, tu32, 10}, {tu32, ti64, 10}, {tu32, tu64, 10},
+	{tu32, tf32, 10}, {tu32, tf64, 10},
 
-	{ ti64, ti8,  10 }, { ti64, tu8,  10 }, { ti64, ti16, 10 }, { ti64, tu16, 10 },
-	{ ti64, ti32, 10 }, { ti64, tu32, 10 }, { ti64, ti64, 10 }, { ti64, tu64, 10 },
-	{ ti64, tf32, 10 }, { ti64, tf64, 10 },
+	{ti64, ti8, 10}, {ti64, tu8, 10}, {ti64, ti16, 10}, {ti64, tu16, 10},
+	{ti64, ti32, 10}, {ti64, tu32, 10}, {ti64, ti64, 10}, {ti64, tu64, 10},
+	{ti64, tf32, 10}, {ti64, tf64, 10},
 
-	{ tu64, ti8,  10 }, { tu64, tu8,  10 }, { tu64, ti16, 10 }, { tu64, tu16, 10 },
-	{ tu64, ti32, 10 }, { tu64, tu32, 10 }, { tu64, ti64, 10 }, { tu64, tu64, 10 },
-	{ tu64, tf32, 10 }, { tu64, tf64, 10 },
+	{tu64, ti8, 10}, {tu64, tu8, 10}, {tu64, ti16, 10}, {tu64, tu16, 10},
+	{tu64, ti32, 10}, {tu64, tu32, 10}, {tu64, ti64, 10}, {tu64, tu64, 10},
+	{tu64, tf32, 10}, {tu64, tf64, 10},
 
-	{ tf32, ti8,  10 }, { tf32, tu8,  10 }, { tf32, ti16, 10 }, { tf32, tu16, 10 },
-	{ tf32, ti32, 10 }, { tf32, tu32, 10 }, { tf32, ti64, 10 }, { tf32, tu64, 10 },
-	{ tf32, tf32, 10 }, { tf32, tf64, 10 },
+	{tf32, ti8, 10}, {tf32, tu8, 10}, {tf32, ti16, 10}, {tf32, tu16, 10},
+	{tf32, ti32, 10}, {tf32, tu32, 10}, {tf32, ti64, 10}, {tf32, tu64, 10},
+	{tf32, tf32, 10}, {tf32, tf64, 10},
 
-	{ tf64, ti8,  10 }, { tf64, tu8,  10 }, { tf64, ti16, 10 }, { tf64, tu16, 10 },
-	{ tf64, ti32, 10 }, { tf64, tu32, 10 }, { tf64, ti64, 10 }, { tf64, tu64, 10 },
-	{ tf64, tf32, 10 }, { tf64, tf64, 10 },
+	{tf64, ti8, 10}, {tf64, tu8, 10}, {tf64, ti16, 10}, {tf64, tu16, 10},
+	{tf64, ti32, 10}, {tf64, tu32, 10}, {tf64, ti64, 10}, {tf64, tu64, 10},
+	{tf64, tf32, 10}, {tf64, tf64, 10},
 
 	/* value good in all signed types (-4) */
-	{ ti8,  ti8,  -4 }, { ti8,  ti16, -4 },
-	{ ti8,  ti32, -4 }, { ti8,  ti64, -4 },
-	{ ti8,  tf32, -4 }, { ti8,  tf64, -4 },
+	{ti8, ti8, -4}, {ti8, ti16, -4},
+	{ti8, ti32, -4}, {ti8, ti64, -4},
+	{ti8, tf32, -4}, {ti8, tf64, -4},
 
-	{ ti16, ti8,  -4 }, { ti16, ti16, -4 },
-	{ ti16, ti32, -4 }, { ti16, ti64, -4 },
-	{ ti16, tf32, -4 },
+	{ti16, ti8, -4}, {ti16, ti16, -4},
+	{ti16, ti32, -4}, {ti16, ti64, -4},
+	{ti16, tf32, -4},
 
-	{ ti32, ti8,  -4 }, { ti32, ti16, -4 },
-	{ ti32, ti32, -4 }, { ti32, ti64, -4 },
-	{ ti32, tf32, -4 }, { ti32, tf64, -4 },
+	{ti32, ti8, -4}, {ti32, ti16, -4},
+	{ti32, ti32, -4}, {ti32, ti64, -4},
+	{ti32, tf32, -4}, {ti32, tf64, -4},
 
-	{ ti64, ti8,  -4 }, { ti64, ti16, -4 },
-	{ ti64, ti32, -4 }, { ti64, ti64, -4 },
-	{ ti64, tf32, -4 },
+	{ti64, ti8, -4}, {ti64, ti16, -4},
+	{ti64, ti32, -4}, {ti64, ti64, -4},
+	{ti64, tf32, -4},
 
-	{ tf32, ti8,  -4 }, { tf32, ti16, -4 },
-	{ tf32, ti32, -4 }, { tf32, ti64, -4 },
-	{ tf32, tf32, -4 },
+	{tf32, ti8, -4}, {tf32, ti16, -4},
+	{tf32, ti32, -4}, {tf32, ti64, -4},
+	{tf32, tf32, -4},
 
-	{ tf64, ti8,  -4 }, { tf64, ti16, -4 },
-	{ tf64, ti32, -4 }, { tf64, ti64, -4 },
-	{ tf64, tf32, -4 }, { tf64, tf64, -4 },
+	{tf64, ti8, -4}, {tf64, ti16, -4},
+	{tf64, ti32, -4}, {tf64, ti64, -4},
+	{tf64, tf32, -4}, {tf64, tf64, -4},
 
 	/* value good in u8 and up (175) */
-	{ tu8,  tu8,  175 }, { tu8,  ti16, 175 }, { tu8,  tu16, 175 },
-	{ tu8,  ti32, 175 }, { tu8,  tu32, 175 }, { tu8,  ti64, 175 }, { tu8,  tu64, 175 },
-	{ tu8,  tf32, 175 }, { tu8,  tf64, 175 },
+	{tu8, tu8, 175}, {tu8, ti16, 175}, {tu8, tu16, 175},
+	{tu8, ti32, 175}, {tu8, tu32, 175}, {tu8, ti64, 175}, {tu8, tu64, 175},
+	{tu8, tf32, 175}, {tu8, tf64, 175},
 
-	{ ti16, tu8,  175 }, { ti16, ti16, 175 }, { ti16, tu16, 175 },
-	{ ti16, ti32, 175 }, { ti16, tu32, 175 }, { ti16, ti64, 175 }, { ti16, tu64, 175 },
-	{ ti16, tf32, 175 }, { ti16, tf64, 175 },
+	{ti16, tu8, 175}, {ti16, ti16, 175}, {ti16, tu16, 175},
+	{ti16, ti32, 175}, {ti16, tu32, 175}, {ti16, ti64, 175}, {ti16, tu64, 175},
+	{ti16, tf32, 175}, {ti16, tf64, 175},
 
-	{ tu16, tu8,  175 }, { tu16, ti16, 175 }, { tu16, tu16, 175 },
-	{ tu16, ti32, 175 }, { tu16, tu32, 175 }, { tu16, ti64, 175 }, { tu16, tu64, 175 },
-	{ tu16, tf32, 175 }, { tu16, tf64, 175 },
+	{tu16, tu8, 175}, {tu16, ti16, 175}, {tu16, tu16, 175},
+	{tu16, ti32, 175}, {tu16, tu32, 175}, {tu16, ti64, 175}, {tu16, tu64, 175},
+	{tu16, tf32, 175}, {tu16, tf64, 175},
 
-	{ ti32, tu8,  175 }, { ti32, ti16, 175 }, { ti32, tu16, 175 },
-	{ ti32, ti32, 175 }, { ti32, tu32, 175 }, { ti32, ti64, 175 }, { ti32, tu64, 175 },
-	{ ti32, tf32, 175 }, { ti32, tf64, 175 },
+	{ti32, tu8, 175}, {ti32, ti16, 175}, {ti32, tu16, 175},
+	{ti32, ti32, 175}, {ti32, tu32, 175}, {ti32, ti64, 175}, {ti32, tu64, 175},
+	{ti32, tf32, 175}, {ti32, tf64, 175},
 
-	{ tu32, tu8,  175 }, { tu32, ti16, 175 }, { tu32, tu16, 175 },
-	{ tu32, ti32, 175 }, { tu32, tu32, 175 }, { tu32, ti64, 175 }, { tu32, tu64, 175 },
-	{ tu32, tf32, 175 }, { tu32, tf64, 175 },
+	{tu32, tu8, 175}, {tu32, ti16, 175}, {tu32, tu16, 175},
+	{tu32, ti32, 175}, {tu32, tu32, 175}, {tu32, ti64, 175}, {tu32, tu64, 175},
+	{tu32, tf32, 175}, {tu32, tf64, 175},
 
-	{ ti64, tu8,  175 }, { ti64, ti16, 175 }, { ti64, tu16, 175 },
-	{ ti64, ti32, 175 }, { ti64, tu32, 175 }, { ti64, ti64, 175 }, { ti64, tu64, 175 },
-	{ ti64, tf32, 175 }, { ti64, tf64, 175 },
+	{ti64, tu8, 175}, {ti64, ti16, 175}, {ti64, tu16, 175},
+	{ti64, ti32, 175}, {ti64, tu32, 175}, {ti64, ti64, 175}, {ti64, tu64, 175},
+	{ti64, tf32, 175}, {ti64, tf64, 175},
 
-	{ tu64, tu8,  175 }, { tu64, ti16, 175 }, { tu64, tu16, 175 },
-	{ tu64, ti32, 175 }, { tu64, tu32, 175 }, { tu64, ti64, 175 }, { tu64, tu64, 175 },
-	{ tu64, tf32, 175 }, { tu64, tf64, 175 },
+	{tu64, tu8, 175}, {tu64, ti16, 175}, {tu64, tu16, 175},
+	{tu64, ti32, 175}, {tu64, tu32, 175}, {tu64, ti64, 175}, {tu64, tu64, 175},
+	{tu64, tf32, 175}, {tu64, tf64, 175},
 
-	{ tf32, tu8,  175 }, { tf32, ti16, 175 }, { tf32, tu16, 175 },
-	{ tf32, ti32, 175 }, { tf32, tu32, 175 }, { tf32, ti64, 175 }, { tf32, tu64, 175 },
-	{ tf32, tf32, 175 }, { tf32, tf64, 175 },
+	{tf32, tu8, 175}, {tf32, ti16, 175}, {tf32, tu16, 175},
+	{tf32, ti32, 175}, {tf32, tu32, 175}, {tf32, ti64, 175}, {tf32, tu64, 175},
+	{tf32, tf32, 175}, {tf32, tf64, 175},
 
-	{ tf64, tu8,  175 }, { tf64, ti16, 175 }, { tf64, tu16, 175 },
-	{ tf64, ti32, 175 }, { tf64, tu32, 175 }, { tf64, ti64, 175 }, { tf64, tu64, 175 },
-	{ tf64, tf32, 175 }, { tf64, tf64, 175 },
+	{tf64, tu8, 175}, {tf64, ti16, 175}, {tf64, tu16, 175},
+	{tf64, ti32, 175}, {tf64, tu32, 175}, {tf64, ti64, 175}, {tf64, tu64, 175},
+	{tf64, tf32, 175}, {tf64, tf64, 175},
 
 	/* value good in u16 and up (41259) */
-	{ tu16, tu16, 41259 },
-	{ tu16, ti32, 41259 }, { tu16, ti64, 41259 }, { tu16, tu64, 41259 },
-	{ tu16, tf32, 41259 }, { tu16, tf64, 41259 },
+	{tu16, tu16, 41259},
+	{tu16, ti32, 41259}, {tu16, ti64, 41259}, {tu16, tu64, 41259},
+	{tu16, tf32, 41259}, {tu16, tf64, 41259},
 
-	{ ti32, tu16, 41259 },
-	{ ti32, ti32, 41259 }, { ti32, tu32, 41259 }, { ti32, ti64, 41259 }, { ti32, tu64, 41259 },
-	{ ti32, tf32, 41259 }, { ti32, tf64, 41259 },
+	{ti32, tu16, 41259},
+	{ti32, ti32, 41259}, {ti32, tu32, 41259}, {ti32, ti64, 41259}, {ti32, tu64, 41259},
+	{ti32, tf32, 41259}, {ti32, tf64, 41259},
 
-	{ tu32, tu16, 41259 },
-	{ tu32, ti32, 41259 }, { tu32, tu32, 41259 }, { tu32, ti64, 41259 }, { tu32, tu64, 41259 },
-	{ tu32, tf32, 41259 }, { tu32, tf64, 41259 },
+	{tu32, tu16, 41259},
+	{tu32, ti32, 41259}, {tu32, tu32, 41259}, {tu32, ti64, 41259}, {tu32, tu64, 41259},
+	{tu32, tf32, 41259}, {tu32, tf64, 41259},
 
-	{ ti64, tu16, 41259 },
-	{ ti64, ti32, 41259 }, { ti64, tu32, 41259 }, { ti64, ti64, 41259 }, { ti64, tu64, 41259 },
-	{ ti64, tf32, 41259 }, { ti64, tf64, 41259 },
+	{ti64, tu16, 41259},
+	{ti64, ti32, 41259}, {ti64, tu32, 41259}, {ti64, ti64, 41259}, {ti64, tu64, 41259},
+	{ti64, tf32, 41259}, {ti64, tf64, 41259},
 
-	{ tu64, tu16, 41259 },
-	{ tu64, ti32, 41259 }, { tu64, tu32, 41259 }, { tu64, ti64, 41259 }, { tu64, tu64, 41259 },
-	{ tu64, tf32, 41259 }, { tu64, tf64, 41259 },
+	{tu64, tu16, 41259},
+	{tu64, ti32, 41259}, {tu64, tu32, 41259}, {tu64, ti64, 41259}, {tu64, tu64, 41259},
+	{tu64, tf32, 41259}, {tu64, tf64, 41259},
 
-	{ tf32, tu16, 41259 },
-	{ tf32, ti32, 41259 }, { tf32, tu32, 41259 }, { tf32, ti64, 41259 }, { tf32, tu64, 41259 },
-	{ tf32, tf32, 41259 }, { tf32, tf64, 41259 },
+	{tf32, tu16, 41259},
+	{tf32, ti32, 41259}, {tf32, tu32, 41259}, {tf32, ti64, 41259}, {tf32, tu64, 41259},
+	{tf32, tf32, 41259}, {tf32, tf64, 41259},
 
-	{ tf64, tu16, 41259 },
-	{ tf64, ti32, 41259 }, { tf64, tu32, 41259 }, { tf64, ti64, 41259 }, { tf64, tu64, 41259 },
-	{ tf64, tf32, 41259 }, { tf64, tf64, 41259 },
+	{tf64, tu16, 41259},
+	{tf64, ti32, 41259}, {tf64, tu32, 41259}, {tf64, ti64, 41259}, {tf64, tu64, 41259},
+	{tf64, tf32, 41259}, {tf64, tf64, 41259},
 
 	/* value good in u32 and up (3758096384) */
-	{ tu32, tu32, 3758096384 }, { tu32, ti64, 3758096384 }, { tu32, tu64, 3758096384 },
-	{ tu32, tf32, 3758096384 }, { tu32, tf64, 3758096384 },
+	{tu32, tu32, 3758096384}, {tu32, ti64, 3758096384}, {tu32, tu64, 3758096384},
+	{tu32, tf32, 3758096384}, {tu32, tf64, 3758096384},
 
-	{ ti64, tu32, 3758096384 }, { ti64, ti64, 3758096384 }, { ti64, tu64, 3758096384 },
-	{ ti64, tf32, 3758096384 }, { ti64, tf64, 3758096384 },
+	{ti64, tu32, 3758096384}, {ti64, ti64, 3758096384}, {ti64, tu64, 3758096384},
+	{ti64, tf32, 3758096384}, {ti64, tf64, 3758096384},
 
-	{ tu64, tu32, 3758096384 }, { tu64, ti64, 3758096384 }, { tu64, tu64, 3758096384 },
-	{ tu64, tf32, 3758096384 }, { tu64, tf64, 3758096384 },
+	{tu64, tu32, 3758096384}, {tu64, ti64, 3758096384}, {tu64, tu64, 3758096384},
+	{tu64, tf32, 3758096384}, {tu64, tf64, 3758096384},
 
-	{ tf32, tu32, 3758096384 }, { tf32, ti64, 3758096384 }, { tf32, tu64, 3758096384 },
-	{ tf32, tf32, 3758096384 }, { tf32, tf64, 3758096384 },
+	{tf32, tu32, 3758096384}, {tf32, ti64, 3758096384}, {tf32, tu64, 3758096384},
+	{tf32, tf32, 3758096384}, {tf32, tf64, 3758096384},
 
-	{ tf64, tu32, 3758096384 }, { tf64, ti64, 3758096384 }, { tf64, tu64, 3758096384 },
-	{ tf64, tf32, 3758096384 }, { tf64, tf64, 3758096384 },
+	{tf64, tu32, 3758096384}, {tf64, ti64, 3758096384}, {tf64, tu64, 3758096384},
+	{tf64, tf32, 3758096384}, {tf64, tf64, 3758096384},
 
 	/* value good in u64 and up (16717361816799281152) */
-	{ tu64, tu64, 16717361816799281152 },
-	{ tu64, tf32, 16717361816799281152 }, { tu64, tf64, 16717361816799281152 },
+	{tu64, tu64, 16717361816799281152},
+	{tu64, tf32, 16717361816799281152}, {tu64, tf64, 16717361816799281152},
 
-	{ tf32, tu64, 16717361816799281152 },
-	{ tf32, tf32, 16717361816799281152 }, { tf32, tf64, 16717361816799281152 },
+	{tf32, tu64, 16717361816799281152},
+	{tf32, tf32, 16717361816799281152}, {tf32, tf64, 16717361816799281152},
 
-	{ tf64, tu64, 16717361816799281152 },
-	{ tf64, tf32, 16717361816799281152 }, { tf64, tf64, 16717361816799281152 },
+	{tf64, tu64, 16717361816799281152},
+	{tf64, tf32, 16717361816799281152}, {tf64, tf64, 16717361816799281152},
 }
 
 func main() {
-	for i:=0; i<len(x); i++ {
-		v := x[i].val		// input value
-		w := big(0)		// output value
-		f := x[i].from		// input type
-		t := x[i].to		// output type
-
-		i8  = 0; u8  = 0; i16 = 0; u16 = 0
-		i32 = 0; u32 = 0; i64 = 0; u64 = 0
-		f32 = 0; f64 = 0
+	for i := 0; i < len(x); i++ {
+		v := x[i].val  // input value
+		w := big(0)    // output value
+		f := x[i].from // input type
+		t := x[i].to   // output type
+
+		i8 = 0
+		u8 = 0
+		i16 = 0
+		u16 = 0
+		i32 = 0
+		u32 = 0
+		i64 = 0
+		u64 = 0
+		f32 = 0
+		f64 = 0
 
 		switch f*100 + t {
 		default:
@@ -218,215 +225,417 @@ func main() {
 			w = v
 
 		case ti8*100 + ti8:
-			i8 = int8(v); i8 = int8(i8); w = big(i8)
+			i8 = int8(v)
+			i8 = int8(i8)
+			w = big(i8)
 		case ti8*100 + tu8:
-			i8 = int8(v); u8 = uint8(i8); w = big(u8)
+			i8 = int8(v)
+			u8 = uint8(i8)
+			w = big(u8)
 		case ti8*100 + ti16:
-			i8 = int8(v); i16 = int16(i8); w = big(i16)
+			i8 = int8(v)
+			i16 = int16(i8)
+			w = big(i16)
 		case ti8*100 + tu16:
-			i8 = int8(v); u16 = uint16(i8); w = big(u16)
+			i8 = int8(v)
+			u16 = uint16(i8)
+			w = big(u16)
 		case ti8*100 + ti32:
-			i8 = int8(v); i32 = int32(i8); w = big(i32)
+			i8 = int8(v)
+			i32 = int32(i8)
+			w = big(i32)
 		case ti8*100 + tu32:
-			i8 = int8(v); u32 = uint32(i8); w = big(u32)
+			i8 = int8(v)
+			u32 = uint32(i8)
+			w = big(u32)
 		case ti8*100 + ti64:
-			i8 = int8(v); i64 = int64(i8); w = big(i64)
+			i8 = int8(v)
+			i64 = int64(i8)
+			w = big(i64)
 		case ti8*100 + tu64:
-			i8 = int8(v); u64 = uint64(i8); w = big(u64)
+			i8 = int8(v)
+			u64 = uint64(i8)
+			w = big(u64)
 		case ti8*100 + tf32:
-			i8 = int8(v); f32 = float32(i8); w = big(f32)
+			i8 = int8(v)
+			f32 = float32(i8)
+			w = big(f32)
 		case ti8*100 + tf64:
-			i8 = int8(v); f64 = float64(i8); w = big(f64)
+			i8 = int8(v)
+			f64 = float64(i8)
+			w = big(f64)
 
 		case tu8*100 + ti8:
-			u8 = uint8(v); i8 = int8(u8); w = big(i8)
+			u8 = uint8(v)
+			i8 = int8(u8)
+			w = big(i8)
 		case tu8*100 + tu8:
-			u8 = uint8(v); u8 = uint8(u8); w = big(u8)
+			u8 = uint8(v)
+			u8 = uint8(u8)
+			w = big(u8)
 		case tu8*100 + ti16:
-			u8 = uint8(v); i16 = int16(u8); w = big(i16)
+			u8 = uint8(v)
+			i16 = int16(u8)
+			w = big(i16)
 		case tu8*100 + tu16:
-			u8 = uint8(v); u16 = uint16(u8); w = big(u16)
+			u8 = uint8(v)
+			u16 = uint16(u8)
+			w = big(u16)
 		case tu8*100 + ti32:
-			u8 = uint8(v); i32 = int32(u8); w = big(i32)
+			u8 = uint8(v)
+			i32 = int32(u8)
+			w = big(i32)
 		case tu8*100 + tu32:
-			u8 = uint8(v); u32 = uint32(u8); w = big(u32)
+			u8 = uint8(v)
+			u32 = uint32(u8)
+			w = big(u32)
 		case tu8*100 + ti64:
-			u8 = uint8(v); i64 = int64(u8); w = big(i64)
+			u8 = uint8(v)
+			i64 = int64(u8)
+			w = big(i64)
 		case tu8*100 + tu64:
-			u8 = uint8(v); u64 = uint64(u8); w = big(u64)
+			u8 = uint8(v)
+			u64 = uint64(u8)
+			w = big(u64)
 		case tu8*100 + tf32:
-			u8 = uint8(v); f32 = float32(u8); w = big(f32)
+			u8 = uint8(v)
+			f32 = float32(u8)
+			w = big(f32)
 		case tu8*100 + tf64:
-			u8 = uint8(v); f64 = float64(u8); w = big(f64)
+			u8 = uint8(v)
+			f64 = float64(u8)
+			w = big(f64)
 
 		case ti16*100 + ti8:
-			i16 = int16(v); i8 = int8(i16); w = big(i8)
+			i16 = int16(v)
+			i8 = int8(i16)
+			w = big(i8)
 		case ti16*100 + tu8:
-			i16 = int16(v); u8 = uint8(i16); w = big(u8)
+			i16 = int16(v)
+			u8 = uint8(i16)
+			w = big(u8)
 		case ti16*100 + ti16:
-			i16 = int16(v); i16 = int16(i16); w = big(i16)
+			i16 = int16(v)
+			i16 = int16(i16)
+			w = big(i16)
 		case ti16*100 + tu16:
-			i16 = int16(v); u16 = uint16(i16); w = big(u16)
+			i16 = int16(v)
+			u16 = uint16(i16)
+			w = big(u16)
 		case ti16*100 + ti32:
-			i16 = int16(v); i32 = int32(i16); w = big(i32)
+			i16 = int16(v)
+			i32 = int32(i16)
+			w = big(i32)
 		case ti16*100 + tu32:
-			i16 = int16(v); u32 = uint32(i16); w = big(u32)
+			i16 = int16(v)
+			u32 = uint32(i16)
+			w = big(u32)
 		case ti16*100 + ti64:
-			i16 = int16(v); i64 = int64(i16); w = big(i64)
+			i16 = int16(v)
+			i64 = int64(i16)
+			w = big(i64)
 		case ti16*100 + tu64:
-			i16 = int16(v); u64 = uint64(i16); w = big(u64)
+			i16 = int16(v)
+			u64 = uint64(i16)
+			w = big(u64)
 		case ti16*100 + tf32:
-			i16 = int16(v); f32 = float32(i16); w = big(f32)
+			i16 = int16(v)
+			f32 = float32(i16)
+			w = big(f32)
 		case ti16*100 + tf64:
-			i16 = int16(v); f64 = float64(i16); w = big(f64)
+			i16 = int16(v)
+			f64 = float64(i16)
+			w = big(f64)
 
 		case tu16*100 + ti8:
-			u16 = uint16(v); i8 = int8(u16); w = big(i8)
+			u16 = uint16(v)
+			i8 = int8(u16)
+			w = big(i8)
 		case tu16*100 + tu8:
-			u16 = uint16(v); u8 = uint8(u16); w = big(u8)
+			u16 = uint16(v)
+			u8 = uint8(u16)
+			w = big(u8)
 		case tu16*100 + ti16:
-			u16 = uint16(v); i16 = int16(u16); w = big(i16)
+			u16 = uint16(v)
+			i16 = int16(u16)
+			w = big(i16)
 		case tu16*100 + tu16:
-			u16 = uint16(v); u16 = uint16(u16); w = big(u16)
+			u16 = uint16(v)
+			u16 = uint16(u16)
+			w = big(u16)
 		case tu16*100 + ti32:
-			u16 = uint16(v); i32 = int32(u16); w = big(i32)
+			u16 = uint16(v)
+			i32 = int32(u16)
+			w = big(i32)
 		case tu16*100 + tu32:
-			u16 = uint16(v); u32 = uint32(u16); w = big(u32)
+			u16 = uint16(v)
+			u32 = uint32(u16)
+			w = big(u32)
 		case tu16*100 + ti64:
-			u16 = uint16(v); i64 = int64(u16); w = big(i64)
+			u16 = uint16(v)
+			i64 = int64(u16)
+			w = big(i64)
 		case tu16*100 + tu64:
-			u16 = uint16(v); u64 = uint64(u16); w = big(u64)
+			u16 = uint16(v)
+			u64 = uint64(u16)
+			w = big(u64)
 		case tu16*100 + tf32:
-			u16 = uint16(v); f32 = float32(u16); w = big(f32)
+			u16 = uint16(v)
+			f32 = float32(u16)
+			w = big(f32)
 		case tu16*100 + tf64:
-			u16 = uint16(v); f64 = float64(u16); w = big(f64)
+			u16 = uint16(v)
+			f64 = float64(u16)
+			w = big(f64)
 
 		case ti32*100 + ti8:
-			i32 = int32(v); i8 = int8(i32); w = big(i8)
+			i32 = int32(v)
+			i8 = int8(i32)
+			w = big(i8)
 		case ti32*100 + tu8:
-			i32 = int32(v); u8 = uint8(i32); w = big(u8)
+			i32 = int32(v)
+			u8 = uint8(i32)
+			w = big(u8)
 		case ti32*100 + ti16:
-			i32 = int32(v); i16 = int16(i32); w = big(i16)
+			i32 = int32(v)
+			i16 = int16(i32)
+			w = big(i16)
 		case ti32*100 + tu16:
-			i32 = int32(v); u16 = uint16(i32); w = big(u16)
+			i32 = int32(v)
+			u16 = uint16(i32)
+			w = big(u16)
 		case ti32*100 + ti32:
-			i32 = int32(v); i32 = int32(i32); w = big(i32)
+			i32 = int32(v)
+			i32 = int32(i32)
+			w = big(i32)
 		case ti32*100 + tu32:
-			i32 = int32(v); u32 = uint32(i32); w = big(u32)
+			i32 = int32(v)
+			u32 = uint32(i32)
+			w = big(u32)
 		case ti32*100 + ti64:
-			i32 = int32(v); i64 = int64(i32); w = big(i64)
+			i32 = int32(v)
+			i64 = int64(i32)
+			w = big(i64)
 		case ti32*100 + tu64:
-			i32 = int32(v); u64 = uint64(i32); w = big(u64)
+			i32 = int32(v)
+			u64 = uint64(i32)
+			w = big(u64)
 		case ti32*100 + tf32:
-			i32 = int32(v); f32 = float32(i32); w = big(f32)
+			i32 = int32(v)
+			f32 = float32(i32)
+			w = big(f32)
 		case ti32*100 + tf64:
-			i32 = int32(v); f64 = float64(i32); w = big(f64)
+			i32 = int32(v)
+			f64 = float64(i32)
+			w = big(f64)
 
 		case tu32*100 + ti8:
-			u32 = uint32(v); i8 = int8(u32); w = big(i8)
+			u32 = uint32(v)
+			i8 = int8(u32)
+			w = big(i8)
 		case tu32*100 + tu8:
-			u32 = uint32(v); u8 = uint8(u32); w = big(u8)
+			u32 = uint32(v)
+			u8 = uint8(u32)
+			w = big(u8)
 		case tu32*100 + ti16:
-			u32 = uint32(v); i16 = int16(u32); w = big(i16)
+			u32 = uint32(v)
+			i16 = int16(u32)
+			w = big(i16)
 		case tu32*100 + tu16:
-			u32 = uint32(v); u16 = uint16(u32); w = big(u16)
+			u32 = uint32(v)
+			u16 = uint16(u32)
+			w = big(u16)
 		case tu32*100 + ti32:
-			u32 = uint32(v); i32 = int32(u32); w = big(i32)
+			u32 = uint32(v)
+			i32 = int32(u32)
+			w = big(i32)
 		case tu32*100 + tu32:
-			u32 = uint32(v); u32 = uint32(u32); w = big(u32)
+			u32 = uint32(v)
+			u32 = uint32(u32)
+			w = big(u32)
 		case tu32*100 + ti64:
-			u32 = uint32(v); i64 = int64(u32); w = big(i64)
+			u32 = uint32(v)
+			i64 = int64(u32)
+			w = big(i64)
 		case tu32*100 + tu64:
-			u32 = uint32(v); u64 = uint64(u32); w = big(u64)
+			u32 = uint32(v)
+			u64 = uint64(u32)
+			w = big(u64)
 		case tu32*100 + tf32:
-			u32 = uint32(v); f32 = float32(u32); w = big(f32)
+			u32 = uint32(v)
+			f32 = float32(u32)
+			w = big(f32)
 		case tu32*100 + tf64:
-			u32 = uint32(v); f64 = float64(u32); w = big(f64)
+			u32 = uint32(v)
+			f64 = float64(u32)
+			w = big(f64)
 
 		case ti64*100 + ti8:
-			i64 = int64(v); i8 = int8(i64); w = big(i8)
+			i64 = int64(v)
+			i8 = int8(i64)
+			w = big(i8)
 		case ti64*100 + tu8:
-			i64 = int64(v); u8 = uint8(i64); w = big(u8)
+			i64 = int64(v)
+			u8 = uint8(i64)
+			w = big(u8)
 		case ti64*100 + ti16:
-			i64 = int64(v); i16 = int16(i64); w = big(i16)
+			i64 = int64(v)
+			i16 = int16(i64)
+			w = big(i16)
 		case ti64*100 + tu16:
-			i64 = int64(v); u16 = uint16(i64); w = big(u16)
+			i64 = int64(v)
+			u16 = uint16(i64)
+			w = big(u16)
 		case ti64*100 + ti32:
-			i64 = int64(v); i32 = int32(i64); w = big(i32)
+			i64 = int64(v)
+			i32 = int32(i64)
+			w = big(i32)
 		case ti64*100 + tu32:
-			i64 = int64(v); u32 = uint32(i64); w = big(u32)
+			i64 = int64(v)
+			u32 = uint32(i64)
+			w = big(u32)
 		case ti64*100 + ti64:
-			i64 = int64(v); i64 = int64(i64); w = big(i64)
+			i64 = int64(v)
+			i64 = int64(i64)
+			w = big(i64)
 		case ti64*100 + tu64:
-			i64 = int64(v); u64 = uint64(i64); w = big(u64)
+			i64 = int64(v)
+			u64 = uint64(i64)
+			w = big(u64)
 		case ti64*100 + tf32:
-			i64 = int64(v); f32 = float32(i64); w = big(f32)
+			i64 = int64(v)
+			f32 = float32(i64)
+			w = big(f32)
 		case ti64*100 + tf64:
-			i64 = int64(v); f64 = float64(i64); w = big(f64)
+			i64 = int64(v)
+			f64 = float64(i64)
+			w = big(f64)
 
 		case tu64*100 + ti8:
-			u64 = uint64(v); i8 = int8(u64); w = big(i8)
+			u64 = uint64(v)
+			i8 = int8(u64)
+			w = big(i8)
 		case tu64*100 + tu8:
-			u64 = uint64(v); u8 = uint8(u64); w = big(u8)
+			u64 = uint64(v)
+			u8 = uint8(u64)
+			w = big(u8)
 		case tu64*100 + ti16:
-			u64 = uint64(v); i16 = int16(u64); w = big(i16)
+			u64 = uint64(v)
+			i16 = int16(u64)
+			w = big(i16)
 		case tu64*100 + tu16:
-			u64 = uint64(v); u16 = uint16(u64); w = big(u16)
+			u64 = uint64(v)
+			u16 = uint16(u64)
+			w = big(u16)
 		case tu64*100 + ti32:
-			u64 = uint64(v); i32 = int32(u64); w = big(i32)
+			u64 = uint64(v)
+			i32 = int32(u64)
+			w = big(i32)
 		case tu64*100 + tu32:
-			u64 = uint64(v); u32 = uint32(u64); w = big(u32)
+			u64 = uint64(v)
+			u32 = uint32(u64)
+			w = big(u32)
 		case tu64*100 + ti64:
-			u64 = uint64(v); i64 = int64(u64); w = big(i64)
+			u64 = uint64(v)
+			i64 = int64(u64)
+			w = big(i64)
 		case tu64*100 + tu64:
-			u64 = uint64(v); u64 = uint64(u64); w = big(u64)
+			u64 = uint64(v)
+			u64 = uint64(u64)
+			w = big(u64)
 		case tu64*100 + tf32:
-			u64 = uint64(v); f32 = float32(u64); w = big(f32)
+			u64 = uint64(v)
+			f32 = float32(u64)
+			w = big(f32)
 		case tu64*100 + tf64:
-			u64 = uint64(v); f64 = float64(u64); w = big(f64)
+			u64 = uint64(v)
+			f64 = float64(u64)
+			w = big(f64)
 
 		case tf32*100 + ti8:
-			f32 = float32(v); i8 = int8(f32); w = big(i8)
+			f32 = float32(v)
+			i8 = int8(f32)
+			w = big(i8)
 		case tf32*100 + tu8:
-			f32 = float32(v); u8 = uint8(f32); w = big(u8)
+			f32 = float32(v)
+			u8 = uint8(f32)
+			w = big(u8)
 		case tf32*100 + ti16:
-			f32 = float32(v); i16 = int16(f32); w = big(i16)
+			f32 = float32(v)
+			i16 = int16(f32)
+			w = big(i16)
 		case tf32*100 + tu16:
-			f32 = float32(v); u16 = uint16(f32); w = big(u16)
+			f32 = float32(v)
+			u16 = uint16(f32)
+			w = big(u16)
 		case tf32*100 + ti32:
-			f32 = float32(v); i32 = int32(f32); w = big(i32)
+			f32 = float32(v)
+			i32 = int32(f32)
+			w = big(i32)
 		case tf32*100 + tu32:
-			f32 = float32(v); u32 = uint32(f32); w = big(u32)
+			f32 = float32(v)
+			u32 = uint32(f32)
+			w = big(u32)
 		case tf32*100 + ti64:
-			f32 = float32(v); i64 = int64(f32); w = big(i64)
+			f32 = float32(v)
+			i64 = int64(f32)
+			w = big(i64)
 		case tf32*100 + tu64:
-			f32 = float32(v); u64 = uint64(f32); w = big(u64)
+			f32 = float32(v)
+			u64 = uint64(f32)
+			w = big(u64)
 		case tf32*100 + tf32:
-			f32 = float32(v); f32 = float32(f32); w = big(f32)
+			f32 = float32(v)
+			f32 = float32(f32)
+			w = big(f32)
 		case tf32*100 + tf64:
-			f32 = float32(v); f64 = float64(f32); w = big(f64)
+			f32 = float32(v)
+			f64 = float64(f32)
+			w = big(f64)
 
 		case tf64*100 + ti8:
-			f64 = float64(v); i8 = int8(f64); w = big(i8)
+			f64 = float64(v)
+			i8 = int8(f64)
+			w = big(i8)
 		case tf64*100 + tu8:
-			f64 = float64(v); u8 = uint8(f64); w = big(u8)
+			f64 = float64(v)
+			u8 = uint8(f64)
+			w = big(u8)
 		case tf64*100 + ti16:
-			f64 = float64(v); i16 = int16(f64); w = big(i16)
+			f64 = float64(v)
+			i16 = int16(f64)
+			w = big(i16)
 		case tf64*100 + tu16:
-			f64 = float64(v); u16 = uint16(f64); w = big(u16)
+			f64 = float64(v)
+			u16 = uint16(f64)
+			w = big(u16)
 		case tf64*100 + ti32:
-			f64 = float64(v); i32 = int32(f64); w = big(i32)
+			f64 = float64(v)
+			i32 = int32(f64)
+			w = big(i32)
 		case tf64*100 + tu32:
-			f64 = float64(v); u32 = uint32(f64); w = big(u32)
+			f64 = float64(v)
+			u32 = uint32(f64)
+			w = big(u32)
 		case tf64*100 + ti64:
-			f64 = float64(v); i64 = int64(f64); w = big(i64)
+			f64 = float64(v)
+			i64 = int64(f64)
+			w = big(i64)
 		case tf64*100 + tu64:
-			f64 = float64(v); u64 = uint64(f64); w = big(u64)
+			f64 = float64(v)
+			u64 = uint64(f64)
+			w = big(u64)
 		case tf64*100 + tf32:
-			f64 = float64(v); f32 = float32(f64); w = big(f32)
+			f64 = float64(v)
+			f32 = float32(f64)
+			w = big(f32)
 		case tf64*100 + tf64:
-			f64 = float64(v); f64 = float64(f64); w = big(f64)
+			f64 = float64(v)
+			f64 = float64(f64)
+			w = big(f64)
+		}
+		if v != w {
+			println(i, v, w, f, t)
 		}
-		if v != w { println(i, v, w, f, t) }
 	}
 }
diff --git a/test/ken/cplx2.go b/test/ken/cplx2.go
index eb1da7b8c0..45d9bc613e 100644
--- a/test/ken/cplx2.go
+++ b/test/ken/cplx2.go
@@ -107,13 +107,13 @@ func main() {
 		println("opcode x", ce, Ce)
 		panic("fail")
 	}
-	
+
 	r32 := real(complex64(ce))
 	if r32 != float32(real(Ce)) {
 		println("real(complex64(ce))", r32, real(Ce))
 		panic("fail")
 	}
-	
+
 	r64 := real(complex128(ce))
 	if r64 != real(Ce) {
 		println("real(complex128(ce))", r64, real(Ce))
diff --git a/test/ken/cplx3.go b/test/ken/cplx3.go
index be0b8646ab..8ae567e219 100644
--- a/test/ken/cplx3.go
+++ b/test/ken/cplx3.go
@@ -24,7 +24,7 @@ func main() {
 	r, i := real(c0), imag(c0)
 	d := r - 1.292308
 	if d < 0 {
-		d = - d
+		d = -d
 	}
 	if d > 1e-6 {
 		println(r, "!= 1.292308")
@@ -32,7 +32,7 @@ func main() {
 	}
 	d = i + 0.1384615
 	if d < 0 {
-		d = - d
+		d = -d
 	}
 	if d > 1e-6 {
 		println(i, "!= -0.1384615")
diff --git a/test/ken/embed.go b/test/ken/embed.go
index f7ca0665e2..2e46c34590 100644
--- a/test/ken/embed.go
+++ b/test/ken/embed.go
@@ -8,7 +8,6 @@
 
 package main
 
-
 type I interface {
 	test1() int
 	test2() int
diff --git a/test/ken/for.go b/test/ken/for.go
index db35548db8..4c257ffcc9 100644
--- a/test/ken/for.go
+++ b/test/ken/for.go
@@ -8,12 +8,13 @@
 
 package main
 
-func
-main() {
-	var t,i int;
+func main() {
+	var t, i int
 
-	for i=0; i<100; i=i+1 {
-		t = t+i;
+	for i = 0; i < 100; i = i + 1 {
+		t = t + i
+	}
+	if t != 50*99 {
+		panic(t)
 	}
-	if t != 50*99  { panic(t); }
 }
diff --git a/test/ken/interfun.go b/test/ken/interfun.go
index 9432181df2..47955c610f 100644
--- a/test/ken/interfun.go
+++ b/test/ken/interfun.go
@@ -9,51 +9,64 @@
 package main
 
 type S struct {
-	a,b	int;
+	a, b int
 }
 
 type I1 interface {
-	f	()int;
+	f() int
 }
 
 type I2 interface {
-	g() int;
-	f() int;
+	g() int
+	f() int
 }
 
-func (this *S) f()int {
-	return this.a;
+func (this *S) f() int {
+	return this.a
 }
 
-func (this *S) g()int {
-	return this.b;
+func (this *S) g() int {
+	return this.b
 }
 
-func
-main() {
-	var i1 I1;
-	var i2 I2;
-	var g *S;
+func main() {
+	var i1 I1
+	var i2 I2
+	var g *S
 
-	s := new(S);
-	s.a = 5;
-	s.b = 6;
+	s := new(S)
+	s.a = 5
+	s.b = 6
 
 	// call structure
-	if s.f() != 5 { panic(11); }
-	if s.g() != 6 { panic(12); }
+	if s.f() != 5 {
+		panic(11)
+	}
+	if s.g() != 6 {
+		panic(12)
+	}
 
-	i1 = s;		// convert S to I1
-	i2 = i1.(I2);	// convert I1 to I2
+	i1 = s       // convert S to I1
+	i2 = i1.(I2) // convert I1 to I2
 
 	// call interface
-	if i1.f() != 5 { panic(21); }
-	if i2.f() != 5 { panic(22); }
-	if i2.g() != 6 { panic(23); }
+	if i1.f() != 5 {
+		panic(21)
+	}
+	if i2.f() != 5 {
+		panic(22)
+	}
+	if i2.g() != 6 {
+		panic(23)
+	}
 
-	g = i1.(*S);		// convert I1 to S
-	if g != s { panic(31); }
+	g = i1.(*S) // convert I1 to S
+	if g != s {
+		panic(31)
+	}
 
-	g = i2.(*S);		// convert I2 to S
-	if g != s { panic(32); }
+	g = i2.(*S) // convert I2 to S
+	if g != s {
+		panic(32)
+	}
 }
diff --git a/test/ken/intervar.go b/test/ken/intervar.go
index 8a2fca0d4b..9ae98d92d8 100644
--- a/test/ken/intervar.go
+++ b/test/ken/intervar.go
@@ -8,60 +8,59 @@
 
 package main
 
-type	Iputs	interface {
-	puts	(s string) string;
+type Iputs interface {
+	puts(s string) string
 }
 
 // ---------
 
-type	Print	struct {
-	whoami	int;
-	put	Iputs;
+type Print struct {
+	whoami int
+	put    Iputs
 }
 
 func (p *Print) dop() string {
-	r := " print " + string(p.whoami + '0')
-	return r + p.put.puts("abc");
+	r := " print " + string(p.whoami+'0')
+	return r + p.put.puts("abc")
 }
 
 // ---------
 
-type	Bio	struct {
-	whoami	int;
-	put	Iputs;
+type Bio struct {
+	whoami int
+	put    Iputs
 }
 
 func (b *Bio) puts(s string) string {
-	r := " bio " + string(b.whoami + '0')
-	return r + b.put.puts(s);
+	r := " bio " + string(b.whoami+'0')
+	return r + b.put.puts(s)
 }
 
 // ---------
 
-type	File	struct {
-	whoami	int;
-	put	Iputs;
+type File struct {
+	whoami int
+	put    Iputs
 }
 
 func (f *File) puts(s string) string {
-	return " file " + string(f.whoami + '0') + " -- " + s
+	return " file " + string(f.whoami+'0') + " -- " + s
 }
 
-func
-main() {
-	p := new(Print);
-	b := new(Bio);
-	f := new(File);
+func main() {
+	p := new(Print)
+	b := new(Bio)
+	f := new(File)
 
-	p.whoami = 1;
-	p.put = b;
+	p.whoami = 1
+	p.put = b
 
-	b.whoami = 2;
-	b.put = f;
+	b.whoami = 2
+	b.put = f
 
-	f.whoami = 3;
+	f.whoami = 3
 
-	r := p.dop();
+	r := p.dop()
 	expected := " print 1 bio 2 file 3 -- abc"
 	if r != expected {
 		panic(r + " != " + expected)
diff --git a/test/ken/litfun.go b/test/ken/litfun.go
index e241d4edb7..ba19ccf305 100644
--- a/test/ken/litfun.go
+++ b/test/ken/litfun.go
@@ -8,16 +8,17 @@
 
 package main
 
-func
-main() {
-	x := func(a int)int {
-		x := func(a int)int {
-			x := func(a int)int {
-				return a+5;
-			};
-			return x(a)+7;
-		};
-		return x(a)+11;
-	};
-	if x(3) != 3+5+7+11 { panic(x(3)); }
+func main() {
+	x := func(a int) int {
+		x := func(a int) int {
+			x := func(a int) int {
+				return a + 5
+			}
+			return x(a) + 7
+		}
+		return x(a) + 11
+	}
+	if x(3) != 3+5+7+11 {
+		panic(x(3))
+	}
 }
diff --git a/test/ken/mfunc.go b/test/ken/mfunc.go
index ef2499194f..3754bbf6a2 100644
--- a/test/ken/mfunc.go
+++ b/test/ken/mfunc.go
@@ -8,15 +8,15 @@
 
 package main
 
-func
-main() {
-	var x,y int;
+func main() {
+	var x, y int
 
-	x,y = simple(10,20,30);
-	if x+y != 65 { panic(x+y); }
+	x, y = simple(10, 20, 30)
+	if x+y != 65 {
+		panic(x + y)
+	}
 }
 
-func
-simple(ia,ib,ic int) (oa,ob int) {
-	return ia+5, ib+ic;
+func simple(ia, ib, ic int) (oa, ob int) {
+	return ia + 5, ib + ic
 }
diff --git a/test/ken/ptrfun.go b/test/ken/ptrfun.go
index af806cfd92..2fc13a7ebb 100644
--- a/test/ken/ptrfun.go
+++ b/test/ken/ptrfun.go
@@ -9,37 +9,44 @@
 package main
 
 type C struct {
-	a	int;
-	x	func(p *C)int;
+	a int
+	x func(p *C) int
 }
 
-func (this *C) f()int {
-	return this.a;
+func (this *C) f() int {
+	return this.a
 }
 
-func
-main() {
-	var v int;
-	var c *C;
+func main() {
+	var v int
+	var c *C
 
-	c = new(C);
-	c.a = 6;
-	c.x = g;
+	c = new(C)
+	c.a = 6
+	c.x = g
 
-	v = g(c);
-	if v != 6 { panic(v); }
+	v = g(c)
+	if v != 6 {
+		panic(v)
+	}
 
-	v = c.x(c);
-	if v != 6 { panic(v); }
+	v = c.x(c)
+	if v != 6 {
+		panic(v)
+	}
 
-	v = c.f();
-	if v != 6 { panic(v); }
+	v = c.f()
+	if v != 6 {
+		panic(v)
+	}
 }
 
-func g(p *C)int {
-	var v int;
+func g(p *C) int {
+	var v int
 
-	v = p.a;
-	if v != 6 { panic(v); }
-	return p.a;
+	v = p.a
+	if v != 6 {
+		panic(v)
+	}
+	return p.a
 }
diff --git a/test/ken/ptrvar.go b/test/ken/ptrvar.go
index d78170c9d2..4d1b9eb794 100644
--- a/test/ken/ptrvar.go
+++ b/test/ken/ptrvar.go
@@ -8,36 +8,49 @@
 
 package main
 
-type	x2	struct { a,b,c int; d int; };
-var	g1	x2;
-var	g2	struct { a,b,c int; d x2; };
-
-func
-main() {
-	var x int;
-	var s1 *x2;
-	var s2 *struct { a,b,c int; d x2; };
-
-	s1 = &g1;
-	s2 = &g2;
-
-	s1.a = 1;
-	s1.b = 2;
-	s1.c = 3;
-	s1.d = 5;
-
-	s2.a = 7;
-	s2.b = 11;
-	s2.c = 13;
-	s2.d.a = 17;
-	s2.d.b = 19;
-	s2.d.c = 23;
-	s2.d.d = 20;
-
-	if(s2.d.c != 23) { panic(1); }
-	if(g2.d.c != 23) { panic(2); }
-
-	x =	s1.a +
+type x2 struct {
+	a, b, c int
+	d       int
+}
+
+var g1 x2
+var g2 struct {
+	a, b, c int
+	d       x2
+}
+
+func main() {
+	var x int
+	var s1 *x2
+	var s2 *struct {
+		a, b, c int
+		d       x2
+	}
+
+	s1 = &g1
+	s2 = &g2
+
+	s1.a = 1
+	s1.b = 2
+	s1.c = 3
+	s1.d = 5
+
+	s2.a = 7
+	s2.b = 11
+	s2.c = 13
+	s2.d.a = 17
+	s2.d.b = 19
+	s2.d.c = 23
+	s2.d.d = 20
+
+	if s2.d.c != 23 {
+		panic(1)
+	}
+	if g2.d.c != 23 {
+		panic(2)
+	}
+
+	x = s1.a +
 		s1.b +
 		s1.c +
 		s1.d +
@@ -48,7 +61,9 @@ main() {
 		s2.d.a +
 		s2.d.b +
 		s2.d.c +
-		s2.d.d;
+		s2.d.d
 
-	if(x != 121) { panic(x); }
+	if x != 121 {
+		panic(x)
+	}
 }
diff --git a/test/ken/robfor.go b/test/ken/robfor.go
index c6a420b39d..3269c0714b 100644
--- a/test/ken/robfor.go
+++ b/test/ken/robfor.go
@@ -10,49 +10,49 @@ package main
 
 func assertequal(is, shouldbe int, msg string) {
 	if is != shouldbe {
-		print("assertion fail" + msg + "\n");
-		panic(1);
+		print("assertion fail" + msg + "\n")
+		panic(1)
 	}
 }
 
 func main() {
-	var i, sum int;
+	var i, sum int
 
-	i = 0;
+	i = 0
 	for {
-		i = i + 1;
+		i = i + 1
 		if i > 5 {
-			break;
+			break
 		}
 	}
-	assertequal(i, 6, "break");
+	assertequal(i, 6, "break")
 
-	sum = 0;
+	sum = 0
 	for i := 0; i <= 10; i++ {
-		sum = sum + i;
+		sum = sum + i
 	}
-	assertequal(sum, 55, "all three");
+	assertequal(sum, 55, "all three")
 
-	sum = 0;
+	sum = 0
 	for i := 0; i <= 10; {
-		sum = sum + i;
-		i++;
+		sum = sum + i
+		i++
 	}
-	assertequal(sum, 55, "only two");
+	assertequal(sum, 55, "only two")
 
-	sum = 0;
+	sum = 0
 	for sum < 100 {
-		sum = sum + 9;
+		sum = sum + 9
 	}
-	assertequal(sum, 99 + 9, "only one");
+	assertequal(sum, 99+9, "only one")
 
-	sum = 0;
+	sum = 0
 	for i := 0; i <= 10; i++ {
-		if i % 2 == 0 {
-			continue;
+		if i%2 == 0 {
+			continue
 		}
-		sum = sum + i;
+		sum = sum + i
 	}
-	assertequal(sum, 1+3+5+7+9, "continue");
+	assertequal(sum, 1+3+5+7+9, "continue")
 
 }
diff --git a/test/ken/robfunc.go b/test/ken/robfunc.go
index 885267e30c..6a417c073f 100644
--- a/test/ken/robfunc.go
+++ b/test/ken/robfunc.go
@@ -41,7 +41,6 @@ func f7(a int) (x int, y float64) {
 	return 7, 7.0
 }
 
-
 func f8(a int) (x int, y float64) {
 	return 8, 8.0
 }
@@ -54,14 +53,12 @@ func (t *T) m10(a int, b float64) int {
 	return (t.x + a) * (t.y + int(b))
 }
 
-
 func f9(a int) (in int, fl float64) {
 	i := 9
 	f := float64(9)
 	return i, f
 }
 
-
 func main() {
 	f1()
 	f2(1)
diff --git a/test/ken/shift.go b/test/ken/shift.go
index af8789615e..895e7e90aa 100644
--- a/test/ken/shift.go
+++ b/test/ken/shift.go
@@ -8,114 +8,122 @@
 
 package main
 
-var	ians	[18]int;
-var	uans	[18]uint;
-var	pass	string;
+var ians [18]int
+var uans [18]uint
+var pass string
 
-func
-testi(i int, t1,t2,t3 int) {
-	n := ((t1*3) + t2)*2 + t3;
+func testi(i int, t1, t2, t3 int) {
+	n := ((t1*3)+t2)*2 + t3
 	if i != ians[n] {
-		print("itest ", t1,t2,t3,pass,
-			" is ", i, " sb ", ians[n], "\n");
+		print("itest ", t1, t2, t3, pass,
+			" is ", i, " sb ", ians[n], "\n")
 	}
 }
 
-func
-index(t1,t2,t3 int) int {
-	return ((t1*3) + t2)*2 + t3;
+func index(t1, t2, t3 int) int {
+	return ((t1*3)+t2)*2 + t3
 }
 
-func
-testu(u uint, t1,t2,t3 int) {
-	n := index(t1,t2,t3);
+func testu(u uint, t1, t2, t3 int) {
+	n := index(t1, t2, t3)
 	if u != uans[n] {
-		print("utest ", t1,t2,t3,pass,
-			" is ", u, " sb ", uans[n], "\n");
+		print("utest ", t1, t2, t3, pass,
+			" is ", u, " sb ", uans[n], "\n")
 	}
 }
 
-func
-main() {
-	var i int;
-	var u,c uint;
+func main() {
+	var i int
+	var u, c uint
 
 	/*
 	 * test constant evaluations
 	 */
-	pass = "con";	// constant part
+	pass = "con" // constant part
 
-	testi( int(1234) <<    0, 0,0,0);
-	testi( int(1234) >>    0, 0,0,1);
-	testi( int(1234) <<    5, 0,1,0);
-	testi( int(1234) >>    5, 0,1,1);
+	testi(int(1234)<<0, 0, 0, 0)
+	testi(int(1234)>>0, 0, 0, 1)
+	testi(int(1234)<<5, 0, 1, 0)
+	testi(int(1234)>>5, 0, 1, 1)
 
-	testi(int(-1234) <<    0, 1,0,0);
-	testi(int(-1234) >>    0, 1,0,1);
-	testi(int(-1234) <<    5, 1,1,0);
-	testi(int(-1234) >>    5, 1,1,1);
+	testi(int(-1234)<<0, 1, 0, 0)
+	testi(int(-1234)>>0, 1, 0, 1)
+	testi(int(-1234)<<5, 1, 1, 0)
+	testi(int(-1234)>>5, 1, 1, 1)
 
-	testu(uint(5678) <<    0, 2,0,0);
-	testu(uint(5678) >>    0, 2,0,1);
-	testu(uint(5678) <<    5, 2,1,0);
-	testu(uint(5678) >>    5, 2,1,1);
+	testu(uint(5678)<<0, 2, 0, 0)
+	testu(uint(5678)>>0, 2, 0, 1)
+	testu(uint(5678)<<5, 2, 1, 0)
+	testu(uint(5678)>>5, 2, 1, 1)
 
 	/*
 	 * test variable evaluations
 	 */
-	pass = "var";	// variable part
-
-	for t1:=0; t1<3; t1++ {	// +int, -int, uint
-	for t2:=0; t2<3; t2++ {	// 0, +small, +large
-	for t3:=0; t3<2; t3++ {	// <<, >>
-		switch t1 {
-		case 0:	i =  1234;
-		case 1:	i = -1234;
-		case 2:	u =  5678;
+	pass = "var" // variable part
+
+	for t1 := 0; t1 < 3; t1++ { // +int, -int, uint
+		for t2 := 0; t2 < 3; t2++ { // 0, +small, +large
+			for t3 := 0; t3 < 2; t3++ { // <<, >>
+				switch t1 {
+				case 0:
+					i = 1234
+				case 1:
+					i = -1234
+				case 2:
+					u = 5678
+				}
+				switch t2 {
+				case 0:
+					c = 0
+				case 1:
+					c = 5
+				case 2:
+					c = 1025
+				}
+				switch t3 {
+				case 0:
+					i <<= c
+					u <<= c
+				case 1:
+					i >>= c
+					u >>= c
+				}
+				switch t1 {
+				case 0:
+					testi(i, t1, t2, t3)
+				case 1:
+					testi(i, t1, t2, t3)
+				case 2:
+					testu(u, t1, t2, t3)
+				}
+			}
 		}
-		switch t2 {
-		case 0:	c =    0;
-		case 1:	c =    5;
-		case 2:	c = 1025;
-		}
-		switch t3 {
-		case 0:	i <<= c; u <<= c;
-		case 1:	i >>= c; u >>= c;
-		}
-		switch t1 {
-		case 0:	testi(i,t1,t2,t3);
-		case 1:	testi(i,t1,t2,t3);
-		case 2:	testu(u,t1,t2,t3);
-		}
-	}
-	}
 	}
 }
 
-func
-init() {
+func init() {
 	/*
 	 * set the 'correct' answer
 	 */
 
-	ians[index(0,0,0)] =   1234;
-	ians[index(0,0,1)] =   1234;
-	ians[index(0,1,0)] =  39488;
-	ians[index(0,1,1)] =     38;
-	ians[index(0,2,0)] =      0;
-	ians[index(0,2,1)] =      0;
-
-	ians[index(1,0,0)] =  -1234;
-	ians[index(1,0,1)] =  -1234;
-	ians[index(1,1,0)] = -39488;
-	ians[index(1,1,1)] =    -39;
-	ians[index(1,2,0)] =      0;
-	ians[index(1,2,1)] =     -1;
-
-	uans[index(2,0,0)] =   5678;
-	uans[index(2,0,1)] =   5678;
-	uans[index(2,1,0)] = 181696;
-	uans[index(2,1,1)] =    177;
-	uans[index(2,2,0)] =      0;
-	uans[index(2,2,1)] =      0;
+	ians[index(0, 0, 0)] = 1234
+	ians[index(0, 0, 1)] = 1234
+	ians[index(0, 1, 0)] = 39488
+	ians[index(0, 1, 1)] = 38
+	ians[index(0, 2, 0)] = 0
+	ians[index(0, 2, 1)] = 0
+
+	ians[index(1, 0, 0)] = -1234
+	ians[index(1, 0, 1)] = -1234
+	ians[index(1, 1, 0)] = -39488
+	ians[index(1, 1, 1)] = -39
+	ians[index(1, 2, 0)] = 0
+	ians[index(1, 2, 1)] = -1
+
+	uans[index(2, 0, 0)] = 5678
+	uans[index(2, 0, 1)] = 5678
+	uans[index(2, 1, 0)] = 181696
+	uans[index(2, 1, 1)] = 177
+	uans[index(2, 2, 0)] = 0
+	uans[index(2, 2, 1)] = 0
 }
diff --git a/test/ken/simparray.go b/test/ken/simparray.go
index 0e81a341b8..51bbeaae83 100644
--- a/test/ken/simparray.go
+++ b/test/ken/simparray.go
@@ -8,43 +8,48 @@
 
 package main
 
-var b[10] float32;
+var b [10]float32
 
-func
-main() {
-	var a[10] float32;
+func main() {
+	var a [10]float32
 
-	for i:=int16(5); i<10; i=i+1 {
-		a[i] = float32(i);
+	for i := int16(5); i < 10; i = i + 1 {
+		a[i] = float32(i)
 	}
 
-	s1 := float32(0);
-	for i:=5; i<10; i=i+1 {
-		s1 = s1 + a[i];
+	s1 := float32(0)
+	for i := 5; i < 10; i = i + 1 {
+		s1 = s1 + a[i]
 	}
 
-	if s1 != 35 { panic(s1); }
+	if s1 != 35 {
+		panic(s1)
+	}
 
-	for i:=int16(5); i<10; i=i+1 {
-		b[i] = float32(i);
+	for i := int16(5); i < 10; i = i + 1 {
+		b[i] = float32(i)
 	}
 
-	s2 := float32(0);
-	for i:=5; i<10; i=i+1 {
-		s2 = s2 + b[i];
+	s2 := float32(0)
+	for i := 5; i < 10; i = i + 1 {
+		s2 = s2 + b[i]
 	}
 
-	if s2 != 35 { panic(s2); }
+	if s2 != 35 {
+		panic(s2)
+	}
 
-	b := new([100]int);
-	for i:=0; i<100; i=i+1 {
-		b[i] = i;
+	b := new([100]int)
+	for i := 0; i < 100; i = i + 1 {
+		b[i] = i
 	}
 
-	s3 := 0;
-	for i:=0; i<100; i=i+1 {
-		s3 = s3+b[i];
+	s3 := 0
+	for i := 0; i < 100; i = i + 1 {
+		s3 = s3 + b[i]
 	}
 
-	if s3 != 4950 { panic(s3); }
+	if s3 != 4950 {
+		panic(s3)
+	}
 }
diff --git a/test/ken/simpbool.go b/test/ken/simpbool.go
index ab2ecc21aa..25c10cfcfe 100644
--- a/test/ken/simpbool.go
+++ b/test/ken/simpbool.go
@@ -9,99 +9,186 @@
 package main
 
 type s struct {
-	a	bool;
-	b	bool;
+	a bool
+	b bool
 }
 
-func
-main() {
-	var a,b bool;
-
-	a = true;
-	b = false;
-
-	if !a { panic(1); }
-	if b { panic(2); }
-	if !!!a { panic(3); }
-	if !!b { panic(4); }
-
-	a = !b;
-	if !a { panic(5); }
-	if !!!a { panic(6); }
-
-	var x *s;
-	x = new(s);
-	x.a = true;
-	x.b = false;
-
-	if !x.a { panic(7); }
-	if x.b { panic(8); }
-	if !!!x.a { panic(9); }
-	if !!x.b { panic(10); }
-
-	x.a = !x.b;
-	if !x.a { panic(11); }
-	if !!!x.a { panic(12); }
+func main() {
+	var a, b bool
+
+	a = true
+	b = false
+
+	if !a {
+		panic(1)
+	}
+	if b {
+		panic(2)
+	}
+	if !!!a {
+		panic(3)
+	}
+	if !!b {
+		panic(4)
+	}
+
+	a = !b
+	if !a {
+		panic(5)
+	}
+	if !!!a {
+		panic(6)
+	}
+
+	var x *s
+	x = new(s)
+	x.a = true
+	x.b = false
+
+	if !x.a {
+		panic(7)
+	}
+	if x.b {
+		panic(8)
+	}
+	if !!!x.a {
+		panic(9)
+	}
+	if !!x.b {
+		panic(10)
+	}
+
+	x.a = !x.b
+	if !x.a {
+		panic(11)
+	}
+	if !!!x.a {
+		panic(12)
+	}
 
 	/*
 	 * test &&
 	 */
-	a = true;
-	b = true;
-	if !(a && b) { panic(21); }
-	if a && !b { panic(22); }
-	if !a && b { panic(23); }
-	if !a && !b { panic(24); }
-
-	a = false;
-	b = true;
-	if !(!a && b) { panic(31); }
-	if !a && !b { panic(32); }
-	if a && b { panic(33); }
-	if a && !b { panic(34); }
-
-	a = true;
-	b = false;
-	if !(a && !b) { panic(41); }
-	if a && b { panic(41); }
-	if !a && !b { panic(41); }
-	if !a && b { panic(44); }
-
-	a = false;
-	b = false;
-	if !(!a && !b) { panic(51); }
-	if !a && b { panic(52); }
-	if a && !b { panic(53); }
-	if a && b { panic(54); }
+	a = true
+	b = true
+	if !(a && b) {
+		panic(21)
+	}
+	if a && !b {
+		panic(22)
+	}
+	if !a && b {
+		panic(23)
+	}
+	if !a && !b {
+		panic(24)
+	}
+
+	a = false
+	b = true
+	if !(!a && b) {
+		panic(31)
+	}
+	if !a && !b {
+		panic(32)
+	}
+	if a && b {
+		panic(33)
+	}
+	if a && !b {
+		panic(34)
+	}
+
+	a = true
+	b = false
+	if !(a && !b) {
+		panic(41)
+	}
+	if a && b {
+		panic(41)
+	}
+	if !a && !b {
+		panic(41)
+	}
+	if !a && b {
+		panic(44)
+	}
+
+	a = false
+	b = false
+	if !(!a && !b) {
+		panic(51)
+	}
+	if !a && b {
+		panic(52)
+	}
+	if a && !b {
+		panic(53)
+	}
+	if a && b {
+		panic(54)
+	}
 
 	/*
 	 * test ||
 	 */
-	a = true;
-	b = true;
-	if !(a || b) { panic(61); }
-	if !(a || !b) { panic(62); }
-	if !(!a || b) { panic(63); }
-	if !a || !b { panic(64); }
-
-	a = false;
-	b = true;
-	if !(!a || b) { panic(71); }
-	if !(!a || !b) { panic(72); }
-	if !(a || b) { panic(73); }
-	if a || !b { panic(74); }
-
-	a = true;
-	b = false;
-	if !(a || !b) { panic(81); }
-	if !(a || b) { panic(82); }
-	if !(!a || !b) { panic(83); }
-	if !a || b { panic(84); }
-
-	a = false;
-	b = false;
-	if !(!a || !b) { panic(91); }
-	if !(!a || b) { panic(92); }
-	if !(a || !b) { panic(93); }
-	if a || b { panic(94); }
+	a = true
+	b = true
+	if !(a || b) {
+		panic(61)
+	}
+	if !(a || !b) {
+		panic(62)
+	}
+	if !(!a || b) {
+		panic(63)
+	}
+	if !a || !b {
+		panic(64)
+	}
+
+	a = false
+	b = true
+	if !(!a || b) {
+		panic(71)
+	}
+	if !(!a || !b) {
+		panic(72)
+	}
+	if !(a || b) {
+		panic(73)
+	}
+	if a || !b {
+		panic(74)
+	}
+
+	a = true
+	b = false
+	if !(a || !b) {
+		panic(81)
+	}
+	if !(a || b) {
+		panic(82)
+	}
+	if !(!a || !b) {
+		panic(83)
+	}
+	if !a || b {
+		panic(84)
+	}
+
+	a = false
+	b = false
+	if !(!a || !b) {
+		panic(91)
+	}
+	if !(!a || b) {
+		panic(92)
+	}
+	if !(a || !b) {
+		panic(93)
+	}
+	if a || b {
+		panic(94)
+	}
 }
diff --git a/test/ken/simpfun.go b/test/ken/simpfun.go
index e5dc2b2495..1d5534b9fa 100644
--- a/test/ken/simpfun.go
+++ b/test/ken/simpfun.go
@@ -8,19 +8,21 @@
 
 package main
 
-func
-main() {
-	var x int;
+func main() {
+	var x int
 
-	x = fun(10,20,30);
-	if x != 60 { panic(x); }
+	x = fun(10, 20, 30)
+	if x != 60 {
+		panic(x)
+	}
 }
 
-func
-fun(ia,ib,ic int)int {
-	var o int;
+func fun(ia, ib, ic int) int {
+	var o int
 
-	o = ia+ib+ic;
-	if o != 60 { panic(o); }
-	return o;
+	o = ia + ib + ic
+	if o != 60 {
+		panic(o)
+	}
+	return o
 }
diff --git a/test/ken/simpvar.go b/test/ken/simpvar.go
index c6eefbb5ad..039d32c94e 100644
--- a/test/ken/simpvar.go
+++ b/test/ken/simpvar.go
@@ -6,22 +6,22 @@
 
 // Test scoping of variables.
 
-
 package main
 
-var	x,y	int;
+var x, y int
 
-func
-main() {
+func main() {
 
-	x = 15;
-	y = 20;
+	x = 15
+	y = 20
 	{
-		var x int;
-		x = 25;
-		y = 25;
-		_ = x;
+		var x int
+		x = 25
+		y = 25
+		_ = x
+	}
+	x = x + y
+	if x != 40 {
+		panic(x)
 	}
-	x = x+y;
-	if(x != 40) { panic(x); }
 }
diff --git a/test/ken/strvar.go b/test/ken/strvar.go
index 4d511fe673..826d796e01 100644
--- a/test/ken/strvar.go
+++ b/test/ken/strvar.go
@@ -8,40 +8,60 @@
 
 package main
 
-type	x2	struct { a,b,c int; d int; };
-var	g1	x2;
-var	g2	struct { a,b,c int; d x2; };
-
-func
-main() {
-	var x int;
-	var s1 *x2;
-	var s2 *struct { a,b,c int; d x2; };
-	var s3 struct { a,b,c int; d x2; };
-
-	s1 = &g1;
-	s2 = &g2;
-
-	s1.a = 1;
-	s1.b = 2;
-	s1.c = 3;
-	s1.d = 5;
-
-	if(s1.c != 3) { panic(s1.c); }
-	if(g1.c != 3) { panic(g1.c); }
-
-	s2.a = 7;
-	s2.b = 11;
-	s2.c = 13;
-	s2.d.a = 17;
-	s2.d.b = 19;
-	s2.d.c = 23;
-	s2.d.d = 29;
-
-	if(s2.d.c != 23) { panic(s2.d.c); }
-	if(g2.d.c != 23) { panic(g2.d.c); }
-
-	x =	s1.a +
+type x2 struct {
+	a, b, c int
+	d       int
+}
+
+var g1 x2
+var g2 struct {
+	a, b, c int
+	d       x2
+}
+
+func main() {
+	var x int
+	var s1 *x2
+	var s2 *struct {
+		a, b, c int
+		d       x2
+	}
+	var s3 struct {
+		a, b, c int
+		d       x2
+	}
+
+	s1 = &g1
+	s2 = &g2
+
+	s1.a = 1
+	s1.b = 2
+	s1.c = 3
+	s1.d = 5
+
+	if s1.c != 3 {
+		panic(s1.c)
+	}
+	if g1.c != 3 {
+		panic(g1.c)
+	}
+
+	s2.a = 7
+	s2.b = 11
+	s2.c = 13
+	s2.d.a = 17
+	s2.d.b = 19
+	s2.d.c = 23
+	s2.d.d = 29
+
+	if s2.d.c != 23 {
+		panic(s2.d.c)
+	}
+	if g2.d.c != 23 {
+		panic(g2.d.c)
+	}
+
+	x = s1.a +
 		s1.b +
 		s1.c +
 		s1.d +
@@ -52,28 +72,34 @@ main() {
 		s2.d.a +
 		s2.d.b +
 		s2.d.c +
-		s2.d.d;
+		s2.d.d
 
-	if(x != 130) { panic(x); }
+	if x != 130 {
+		panic(x)
+	}
 
 	// test an automatic struct
-	s3.a = 7;
-	s3.b = 11;
-	s3.c = 13;
-	s3.d.a = 17;
-	s3.d.b = 19;
-	s3.d.c = 23;
-	s3.d.d = 29;
-
-	if(s3.d.c != 23) { panic(s3.d.c); }
-
-	x =	s3.a +
+	s3.a = 7
+	s3.b = 11
+	s3.c = 13
+	s3.d.a = 17
+	s3.d.b = 19
+	s3.d.c = 23
+	s3.d.d = 29
+
+	if s3.d.c != 23 {
+		panic(s3.d.c)
+	}
+
+	x = s3.a +
 		s3.b +
 		s3.c +
 		s3.d.a +
 		s3.d.b +
 		s3.d.c +
-		s3.d.d;
+		s3.d.d
 
-	if(x != 119) { panic(x); }
+	if x != 119 {
+		panic(x)
+	}
 }
diff --git a/test/literal2.go b/test/literal2.go
index f552e33ada..064d47f726 100644
--- a/test/literal2.go
+++ b/test/literal2.go
@@ -31,8 +31,8 @@ func main() {
 	assert(0_1 == 01)
 	assert(012 == 012)
 	assert(0_1_2 == 012)
-	assert(0_1_2i == complex(0, 12)) // decimal digits despite leading 0 for backward-compatibility
-	assert(00089i == complex(0, 89)) // decimal digits despite leading 0 for backward-compatibility
+	assert(1_2i == complex(0, 12)) // decimal digits despite leading 0 for backward-compatibility
+	assert(89i == complex(0, 89))  // decimal digits despite leading 0 for backward-compatibility
 
 	// decimals
 	assert(1_000_000 == 1000000)
diff --git a/test/live1.go b/test/live1.go
index 87c8c97c41..3d37b9ec53 100644
--- a/test/live1.go
+++ b/test/live1.go
@@ -43,4 +43,3 @@ func f1(pkg, typ, meth string) {
 func f2() interface{} {
 	return new(int)
 }
-
diff --git a/test/live_syscall.go b/test/live_syscall.go
index 2d1ef14de7..1f9a2c2668 100644
--- a/test/live_syscall.go
+++ b/test/live_syscall.go
@@ -30,7 +30,7 @@ func h() { // ERROR "can inline h"
 func i() { // ERROR "can inline i"
 	var t int
 	p := unsafe.Pointer(&t)
-	f(uintptr(p))           // ERROR "live at call to f: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
+	f(uintptr(p)) // ERROR "live at call to f: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
 }
 
 func j() { // ERROR "can inline j"
diff --git a/test/map1.go b/test/map1.go
index 498c2ec45b..91589a7c48 100644
--- a/test/map1.go
+++ b/test/map1.go
@@ -39,10 +39,10 @@ var (
 	_ map[[]int]v       // ERROR "invalid map key"
 	_ map[func()]v      // ERROR "invalid map key"
 	_ map[map[int]int]v // ERROR "invalid map key"
-	_ map[T1]v    // ERROR "invalid map key"
-	_ map[T2]v    // ERROR "invalid map key"
-	_ map[T3]v    // ERROR "invalid map key"
-	_ map[T4]v    // ERROR "invalid map key"
+	_ map[T1]v          // ERROR "invalid map key"
+	_ map[T2]v          // ERROR "invalid map key"
+	_ map[T3]v          // ERROR "invalid map key"
+	_ map[T4]v          // ERROR "invalid map key"
 	_ map[T5]v
 	_ map[T6]v
 	_ map[T7]v
@@ -50,14 +50,14 @@ var (
 )
 
 type T1 []int
-type T2 struct { F T1 }
+type T2 struct{ F T1 }
 type T3 []T4
-type T4 struct { F T3 }
+type T4 struct{ F T3 }
 
 type T5 *int
-type T6 struct { F T5 }
+type T6 struct{ F T5 }
 type T7 *T4
-type T8 struct { F *T7 }
+type T8 struct{ F *T7 }
 
 func main() {
 	m := make(map[int]int)
@@ -65,4 +65,4 @@ func main() {
 	delete(m)       // ERROR "missing second \(key\) argument"
 	delete(m, 2, 3) // ERROR "too many arguments"
 	delete(1, m)    // ERROR "first argument to delete must be map"
-}
\ No newline at end of file
+}
diff --git a/test/method5.go b/test/method5.go
index d87bb6f5b2..e48baf4ccc 100644
--- a/test/method5.go
+++ b/test/method5.go
@@ -16,53 +16,53 @@ type Tinter interface {
 
 type Tsmallv byte
 
-func (v Tsmallv) M(x int, b byte) (byte, int) { return b, x+int(v) }
+func (v Tsmallv) M(x int, b byte) (byte, int) { return b, x + int(v) }
 
 type Tsmallp byte
 
-func (p *Tsmallp) M(x int, b byte) (byte, int) { return b, x+int(*p) }
+func (p *Tsmallp) M(x int, b byte) (byte, int) { return b, x + int(*p) }
 
 type Twordv uintptr
 
-func (v Twordv) M(x int, b byte) (byte, int) { return b, x+int(v) }
+func (v Twordv) M(x int, b byte) (byte, int) { return b, x + int(v) }
 
 type Twordp uintptr
 
-func (p *Twordp) M(x int, b byte) (byte, int) { return b, x+int(*p) }
+func (p *Twordp) M(x int, b byte) (byte, int) { return b, x + int(*p) }
 
 type Tbigv [2]uintptr
 
-func (v Tbigv) M(x int, b byte) (byte, int) { return b, x+int(v[0])+int(v[1]) }
+func (v Tbigv) M(x int, b byte) (byte, int) { return b, x + int(v[0]) + int(v[1]) }
 
 type Tbigp [2]uintptr
 
-func (p *Tbigp) M(x int, b byte) (byte, int) { return b, x+int(p[0])+int(p[1]) }
+func (p *Tbigp) M(x int, b byte) (byte, int) { return b, x + int(p[0]) + int(p[1]) }
 
 // Again, with an unexported method.
 
 type tsmallv byte
 
-func (v tsmallv) m(x int, b byte) (byte, int) { return b, x+int(v) }
+func (v tsmallv) m(x int, b byte) (byte, int) { return b, x + int(v) }
 
 type tsmallp byte
 
-func (p *tsmallp) m(x int, b byte) (byte, int) { return b, x+int(*p) }
+func (p *tsmallp) m(x int, b byte) (byte, int) { return b, x + int(*p) }
 
 type twordv uintptr
 
-func (v twordv) m(x int, b byte) (byte, int) { return b, x+int(v) }
+func (v twordv) m(x int, b byte) (byte, int) { return b, x + int(v) }
 
 type twordp uintptr
 
-func (p *twordp) m(x int, b byte) (byte, int) { return b, x+int(*p) }
+func (p *twordp) m(x int, b byte) (byte, int) { return b, x + int(*p) }
 
 type tbigv [2]uintptr
 
-func (v tbigv) m(x int, b byte) (byte, int) { return b, x+int(v[0])+int(v[1]) }
+func (v tbigv) m(x int, b byte) (byte, int) { return b, x + int(v[0]) + int(v[1]) }
 
 type tbigp [2]uintptr
 
-func (p *tbigp) m(x int, b byte) (byte, int) { return b, x+int(p[0])+int(p[1]) }
+func (p *tbigp) m(x int, b byte) (byte, int) { return b, x + int(p[0]) + int(p[1]) }
 
 type tinter interface {
 	m(int, byte) (byte, int)
@@ -85,7 +85,7 @@ type T3 struct {
 type T4 struct {
 }
 
-func (t4 T4) M(x int, b byte) (byte, int) { return b, x+40 }
+func (t4 T4) M(x int, b byte) (byte, int) { return b, x + 40 }
 
 var failed = false
 
@@ -95,7 +95,7 @@ func CheckI(name string, i Tinter, inc int) {
 		failed = true
 		print(name, ".M(1000, 99) = ", b, ", ", x, " want 99, ", 1000+inc, "\n")
 	}
-	
+
 	CheckF("(i="+name+")", i.M, inc)
 }
 
@@ -113,7 +113,7 @@ func checkI(name string, i tinter, inc int) {
 		failed = true
 		print(name, ".m(1000, 99) = ", b, ", ", x, " want 99, ", 1000+inc, "\n")
 	}
-	
+
 	checkF("(i="+name+")", i.m, inc)
 }
 
@@ -183,8 +183,8 @@ func main() {
 	CheckI("pbv", pbv, 11)
 	CheckF("pbv.M", pbv.M, 11)
 	CheckF("(*pbv).M", (*pbv).M, 11)
-	
-	bp := Tbigp([2]uintptr{7,8})
+
+	bp := Tbigp([2]uintptr{7, 8})
 	CheckI("&bp", &bp, 15)
 	CheckF("bp.M", bp.M, 15)
 	CheckF("(&bp).M", (&bp).M, 15)
@@ -237,8 +237,8 @@ func main() {
 	checkI("_pbv", _pbv, 11)
 	checkF("_pbv.m", _pbv.m, 11)
 	checkF("(*_pbv).m", (*_pbv).m, 11)
-	
-	_bp := tbigp([2]uintptr{7,8})
+
+	_bp := tbigp([2]uintptr{7, 8})
 	checkI("&_bp", &_bp, 15)
 	checkF("_bp.m", _bp.m, 15)
 	checkF("(&_bp).m", (&_bp).m, 15)
@@ -246,7 +246,7 @@ func main() {
 	checkI("_pbp", _pbp, 15)
 	checkF("_pbp.m", _pbp.m, 15)
 	checkF("(*_pbp).m", (*_pbp).m, 15)
-	
+
 	t4 := T4{}
 	t3 := T3{&t4}
 	t2 := T2{&t3}
@@ -259,7 +259,7 @@ func main() {
 	CheckI("&t2", &t2, 40)
 	CheckI("t1", t1, 40)
 	CheckI("&t1", &t1, 40)
-	
+
 	// x.M panics if x is an interface type and is nil,
 	// or if x.M expands to (*x).M where x is nil,
 	// or if x.M expands to x.y.z.w.M where something
@@ -281,7 +281,7 @@ func main() {
 	if f != nil {
 		panic("something set f")
 	}
-	
+
 	// x.M does not panic if x is a nil pointer and
 	// M is a method with a pointer receiver.
 	shouldNotPanic(func() { psp = nil; f = psp.M })
diff --git a/test/named.go b/test/named.go
index 9763c76bfd..60a88c542b 100644
--- a/test/named.go
+++ b/test/named.go
@@ -31,7 +31,6 @@ func asString(String) {}
 
 func (Map) M() {}
 
-
 // These functions check at run time that the default type
 // (in the absence of any implicit conversion hints)
 // is the given type.
diff --git a/test/nilptr2.go b/test/nilptr2.go
index 8a85b6dbcb..8e3be659bb 100644
--- a/test/nilptr2.go
+++ b/test/nilptr2.go
@@ -27,7 +27,7 @@ func main() {
 var intp *int
 var slicep *[]byte
 var a10p *[10]int
-var a10Mp *[1<<20]int
+var a10Mp *[1 << 20]int
 var structp *Struct
 var bigstructp *BigStruct
 var i int
@@ -41,9 +41,9 @@ func use(x interface{}) {
 	V = x
 }
 
-var tests = []struct{
+var tests = []struct {
 	name string
-	fn func()
+	fn   func()
 }{
 	// Edit .+1,/^}/s/^[^	].+/	{"&", func() { println(&) }},\n	{"\&&", func() { println(\&&) }},/g
 	{"*intp", func() { println(*intp) }},
@@ -112,14 +112,14 @@ type BigStruct struct {
 	i int
 	j float64
 	k string
-	x [128<<20]byte
+	x [128 << 20]byte
 	l []byte
 }
 
 type M struct {
 }
 
-func (m *M) F() int {return 0}
+func (m *M) F() int { return 0 }
 
 type M1 struct {
 	M
diff --git a/test/oldescape2.go b/test/oldescape2.go
index 864a956164..fc686cb921 100644
--- a/test/oldescape2.go
+++ b/test/oldescape2.go
@@ -146,13 +146,13 @@ func (b Bar) AlsoLeak() *int { // ERROR "leaking param: b to result ~r0 level=0$
 }
 
 func (b Bar) LeaksToo() *int { // ERROR "leaking param: b to result ~r0 level=0$"
-	v := 0    // ERROR "moved to heap: v$"
+	v := 0 // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
 
 func (b *Bar) LeaksABit() *int { // ERROR "leaking param: b to result ~r0 level=1$"
-	v := 0    // ERROR "moved to heap: v$"
+	v := 0 // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
@@ -522,7 +522,7 @@ func foo72a() {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
 		// escapes its scope
-		x := i    // ERROR "moved to heap: x$"
+		x := i // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return
@@ -531,7 +531,7 @@ func foo72a() {
 func foo72b() [10]*int {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
-		x := i    // ERROR "moved to heap: x$"
+		x := i // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return y
@@ -739,11 +739,11 @@ func tee(p *int) (x, y *int) { return p, p } // ERROR "leaking param: p to resul
 func noop(x, y *int) {} // ERROR "noop x does not escape$" "noop y does not escape$"
 
 func foo82() {
-	var x, y, z int  // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
+	var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
 	go noop(tee(&z))
 	go noop(&x, &y)
 	for {
-		var u, v, w int     // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
+		var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
 		defer noop(tee(&u))
 		defer noop(&v, &w)
 	}
@@ -916,10 +916,10 @@ func foo115(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$"
 
 func foo116(b bool) *int {
 	if b {
-		x := 1    // ERROR "moved to heap: x$"
+		x := 1 // ERROR "moved to heap: x$"
 		return &x
 	} else {
-		y := 1    // ERROR "moved to heap: y$"
+		y := 1 // ERROR "moved to heap: y$"
 		return &y
 	}
 	return nil
@@ -931,7 +931,7 @@ func foo117(unknown func(interface{})) { // ERROR "foo117 unknown does not escap
 }
 
 func foo118(unknown func(*int)) { // ERROR "foo118 unknown does not escape$"
-	x := 1      // ERROR "moved to heap: x$"
+	x := 1 // ERROR "moved to heap: x$"
 	unknown(&x)
 }
 
@@ -1185,7 +1185,7 @@ L1:
 func foo124(x **int) { // ERROR "foo124 x does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo124 func literal does not escape$"
+	func() { // ERROR "foo124 func literal does not escape$"
 		*x = p
 	}()
 }
@@ -1193,7 +1193,7 @@ func foo124(x **int) { // ERROR "foo124 x does not escape$"
 func foo125(ch chan *int) { // ERROR "foo125 ch does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo125 func literal does not escape$"
+	func() { // ERROR "foo125 func literal does not escape$"
 		ch <- p
 	}()
 }
@@ -1229,7 +1229,7 @@ func foo128() {
 func foo129() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo129 func literal does not escape$"
+	func() { // ERROR "foo129 func literal does not escape$"
 		q := p
 		func() { // ERROR "foo129.func1 func literal does not escape$"
 			r := q
@@ -1281,7 +1281,7 @@ func foo134() {
 }
 
 func foo135() {
-	var i int   // ERROR "moved to heap: i$"
+	var i int // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1293,7 +1293,7 @@ func foo135() {
 }
 
 func foo136() {
-	var i int   // ERROR "moved to heap: i$"
+	var i int // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1307,7 +1307,7 @@ func foo136() {
 func foo137() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo137 func literal does not escape$"
+	func() { // ERROR "foo137 func literal does not escape$"
 		q := p
 		go func() { // ERROR "func literal escapes to heap$"
 			r := q
@@ -1320,7 +1320,7 @@ func foo138() *byte {
 	type T struct {
 		x [1]byte
 	}
-	t := new(T)    // ERROR "new\(T\) escapes to heap$"
+	t := new(T) // ERROR "new\(T\) escapes to heap$"
 	return &t.x[0]
 }
 
@@ -1330,7 +1330,7 @@ func foo139() *byte {
 			y byte
 		}
 	}
-	t := new(T)   // ERROR "new\(T\) escapes to heap$"
+	t := new(T) // ERROR "new\(T\) escapes to heap$"
 	return &t.x.y
 }
 
@@ -1498,7 +1498,7 @@ func bar151() {
 }
 
 func bar151b() {
-	var a [10]int      // ERROR "moved to heap: a$"
+	var a [10]int // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8][0])
 }
@@ -1510,7 +1510,7 @@ func bar151c() {
 }
 
 func bar151d() {
-	var a [10]int        // ERROR "moved to heap: a$"
+	var a [10]int // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8:8][0])
 }
@@ -1535,7 +1535,7 @@ func NewV(u U) *V { // ERROR "leaking param: u to result ~r1 level=-1"
 }
 
 func foo152() {
-	a := "a"   // ERROR "moved to heap: a$"
+	a := "a" // ERROR "moved to heap: a$"
 	u := U{&a}
 	v := NewV(u)
 	println(v)
@@ -1643,7 +1643,7 @@ type StructWithString struct {
 // to just x, and thus &i looks escaping.
 func fieldFlowTracking() {
 	var x StructWithString
-	i := 0     // ERROR "moved to heap: i$"
+	i := 0 // ERROR "moved to heap: i$"
 	x.p = &i
 	sink = x.s // ERROR "x.s escapes to heap$"
 }
diff --git a/test/oldescape2n.go b/test/oldescape2n.go
index fb2a956618..a9edec5f92 100644
--- a/test/oldescape2n.go
+++ b/test/oldescape2n.go
@@ -146,13 +146,13 @@ func (b Bar) AlsoLeak() *int { // ERROR "leaking param: b to result ~r0 level=0$
 }
 
 func (b Bar) LeaksToo() *int { // ERROR "leaking param: b to result ~r0 level=0$"
-	v := 0    // ERROR "moved to heap: v$"
+	v := 0 // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
 
 func (b *Bar) LeaksABit() *int { // ERROR "leaking param: b to result ~r0 level=1$"
-	v := 0    // ERROR "moved to heap: v$"
+	v := 0 // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
@@ -522,7 +522,7 @@ func foo72a() {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
 		// escapes its scope
-		x := i    // ERROR "moved to heap: x$"
+		x := i // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return
@@ -531,7 +531,7 @@ func foo72a() {
 func foo72b() [10]*int {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
-		x := i    // ERROR "moved to heap: x$"
+		x := i // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return y
@@ -739,11 +739,11 @@ func tee(p *int) (x, y *int) { return p, p } // ERROR "leaking param: p to resul
 func noop(x, y *int) {} // ERROR "noop x does not escape$" "noop y does not escape$"
 
 func foo82() {
-	var x, y, z int  // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
+	var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
 	go noop(tee(&z))
 	go noop(&x, &y)
 	for {
-		var u, v, w int     // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
+		var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
 		defer noop(tee(&u))
 		defer noop(&v, &w)
 	}
@@ -916,10 +916,10 @@ func foo115(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$"
 
 func foo116(b bool) *int {
 	if b {
-		x := 1    // ERROR "moved to heap: x$"
+		x := 1 // ERROR "moved to heap: x$"
 		return &x
 	} else {
-		y := 1    // ERROR "moved to heap: y$"
+		y := 1 // ERROR "moved to heap: y$"
 		return &y
 	}
 	return nil
@@ -931,7 +931,7 @@ func foo117(unknown func(interface{})) { // ERROR "foo117 unknown does not escap
 }
 
 func foo118(unknown func(*int)) { // ERROR "foo118 unknown does not escape$"
-	x := 1      // ERROR "moved to heap: x$"
+	x := 1 // ERROR "moved to heap: x$"
 	unknown(&x)
 }
 
@@ -1185,7 +1185,7 @@ L1:
 func foo124(x **int) { // ERROR "foo124 x does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo124 func literal does not escape$"
+	func() { // ERROR "foo124 func literal does not escape$"
 		*x = p
 	}()
 }
@@ -1193,7 +1193,7 @@ func foo124(x **int) { // ERROR "foo124 x does not escape$"
 func foo125(ch chan *int) { // ERROR "foo125 ch does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo125 func literal does not escape$"
+	func() { // ERROR "foo125 func literal does not escape$"
 		ch <- p
 	}()
 }
@@ -1229,7 +1229,7 @@ func foo128() {
 func foo129() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo129 func literal does not escape$"
+	func() { // ERROR "foo129 func literal does not escape$"
 		q := p
 		func() { // ERROR "foo129.func1 func literal does not escape$"
 			r := q
@@ -1281,7 +1281,7 @@ func foo134() {
 }
 
 func foo135() {
-	var i int   // ERROR "moved to heap: i$"
+	var i int // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1293,7 +1293,7 @@ func foo135() {
 }
 
 func foo136() {
-	var i int   // ERROR "moved to heap: i$"
+	var i int // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1307,7 +1307,7 @@ func foo136() {
 func foo137() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() {  // ERROR "foo137 func literal does not escape$"
+	func() { // ERROR "foo137 func literal does not escape$"
 		q := p
 		go func() { // ERROR "func literal escapes to heap$"
 			r := q
@@ -1320,7 +1320,7 @@ func foo138() *byte {
 	type T struct {
 		x [1]byte
 	}
-	t := new(T)    // ERROR "new\(T\) escapes to heap$"
+	t := new(T) // ERROR "new\(T\) escapes to heap$"
 	return &t.x[0]
 }
 
@@ -1330,7 +1330,7 @@ func foo139() *byte {
 			y byte
 		}
 	}
-	t := new(T)   // ERROR "new\(T\) escapes to heap$"
+	t := new(T) // ERROR "new\(T\) escapes to heap$"
 	return &t.x.y
 }
 
@@ -1498,7 +1498,7 @@ func bar151() {
 }
 
 func bar151b() {
-	var a [10]int      // ERROR "moved to heap: a$"
+	var a [10]int // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8][0])
 }
@@ -1510,7 +1510,7 @@ func bar151c() {
 }
 
 func bar151d() {
-	var a [10]int        // ERROR "moved to heap: a$"
+	var a [10]int // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8:8][0])
 }
@@ -1535,7 +1535,7 @@ func NewV(u U) *V { // ERROR "leaking param: u to result ~r1 level=-1"
 }
 
 func foo152() {
-	a := "a"   // ERROR "moved to heap: a$"
+	a := "a" // ERROR "moved to heap: a$"
 	u := U{&a}
 	v := NewV(u)
 	println(v)
@@ -1643,7 +1643,7 @@ type StructWithString struct {
 // to just x, and thus &i looks escaping.
 func fieldFlowTracking() {
 	var x StructWithString
-	i := 0     // ERROR "moved to heap: i$"
+	i := 0 // ERROR "moved to heap: i$"
 	x.p = &i
 	sink = x.s // ERROR "x.s escapes to heap$"
 }
diff --git a/test/oldescape5.go b/test/oldescape5.go
index 53d0ff801d..972b9ed8a8 100644
--- a/test/oldescape5.go
+++ b/test/oldescape5.go
@@ -71,13 +71,13 @@ func f2() {
 }
 
 func f3() {
-	var x int          // ERROR "moved to heap: x"
+	var x int // ERROR "moved to heap: x"
 	p := leaktoret(&x)
 	gp = p
 }
 
 func f4() {
-	var x int              // ERROR "moved to heap: x"
+	var x int // ERROR "moved to heap: x"
 	p, q := leaktoret2(&x)
 	gp = p
 	gp = q
@@ -89,7 +89,7 @@ func f5() {
 }
 
 func f6() {
-	var x int                               // ERROR "moved to heap: x"
+	var x int // ERROR "moved to heap: x"
 	px1, px2 := leaktoret22(leaktoret2(&x))
 	gp = px1
 	_ = px2
diff --git a/test/oldescape_field.go b/test/oldescape_field.go
index e4213aaf59..09f1ea7758 100644
--- a/test/oldescape_field.go
+++ b/test/oldescape_field.go
@@ -39,7 +39,7 @@ func field3() {
 	i := 0 // ERROR "moved to heap: i$"
 	var x X
 	x.p1 = &i
-	sink = x  // ERROR "x escapes to heap"
+	sink = x // ERROR "x escapes to heap"
 }
 
 func field4() {
@@ -113,16 +113,16 @@ func field10() {
 }
 
 func field11() {
-	i := 0         // ERROR "moved to heap: i$"
+	i := 0 // ERROR "moved to heap: i$"
 	x := X{p1: &i}
-	sink = x.p1    // ERROR "x\.p1 escapes to heap"
+	sink = x.p1 // ERROR "x\.p1 escapes to heap"
 }
 
 func field12() {
 	i := 0 // ERROR "moved to heap: i$"
 	// BAD: &i should not escape
 	x := X{p1: &i}
-	sink = x.p2    // ERROR "x\.p2 escapes to heap"
+	sink = x.p2 // ERROR "x\.p2 escapes to heap"
 }
 
 func field13() {
diff --git a/test/oldescape_iface.go b/test/oldescape_iface.go
index 88502df99b..ca5aa1187f 100644
--- a/test/oldescape_iface.go
+++ b/test/oldescape_iface.go
@@ -37,7 +37,7 @@ func efaceEscape0() {
 		_ = x
 	}
 	{
-		i := 0      // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M0{&i}
 		var x M = v // ERROR "v escapes to heap"
 		sink = x    // ERROR "x escapes to heap"
@@ -50,7 +50,7 @@ func efaceEscape0() {
 		_ = v1
 	}
 	{
-		i := 0      // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M0{&i}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
@@ -58,14 +58,14 @@ func efaceEscape0() {
 		sink = v1 // ERROR "v1 escapes to heap"
 	}
 	{
-		i := 0      // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M0{&i}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
 		x.M()
 	}
 	{
-		i := 0      // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M0{&i}
 		var x M = v // ERROR "v escapes to heap"
 		mescapes(x)
@@ -91,24 +91,24 @@ func efaceEscape1() {
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v    // ERROR "v does not escape"
+		var x M = v // ERROR "v does not escape"
 		_ = x
 	}
 	{
-		i := 0         // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M1{&i, 0}
-		var x M = v    // ERROR "v escapes to heap"
-		sink = x       // ERROR "x escapes to heap"
+		var x M = v // ERROR "v escapes to heap"
+		sink = x    // ERROR "x escapes to heap"
 	}
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v    // ERROR "v does not escape"
+		var x M = v // ERROR "v does not escape"
 		v1 := x.(M1)
 		_ = v1
 	}
 	{
-		i := 0         // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M1{&i, 0}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
@@ -116,22 +116,22 @@ func efaceEscape1() {
 		sink = v1 // ERROR "v1 escapes to heap"
 	}
 	{
-		i := 0         // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M1{&i, 0}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
 		x.M()
 	}
 	{
-		i := 0         // ERROR "moved to heap: i"
+		i := 0 // ERROR "moved to heap: i"
 		v := M1{&i, 0}
-		var x M = v    // ERROR "v escapes to heap"
+		var x M = v // ERROR "v escapes to heap"
 		mescapes(x)
 	}
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v    // ERROR "v does not escape"
+		var x M = v // ERROR "v does not escape"
 		mdoesnotescape(x)
 	}
 }
@@ -245,7 +245,7 @@ func dotTypeEscape2() { // #13805, #15796
 		var x interface{} = i // ERROR "i does not escape"
 		var y interface{} = j // ERROR "j does not escape"
 
-		sink = x.(int)        // ERROR "x.\(int\) escapes to heap"
+		sink = x.(int) // ERROR "x.\(int\) escapes to heap"
 		sink, *(&ok) = y.(int)
 	}
 	{
@@ -255,7 +255,7 @@ func dotTypeEscape2() { // #13805, #15796
 		var x interface{} = &i // ERROR "&i escapes to heap"
 		var y interface{} = &j // ERROR "&j escapes to heap"
 
-		sink = x.(*int)        // ERROR "x.\(\*int\) escapes to heap"
+		sink = x.(*int) // ERROR "x.\(\*int\) escapes to heap"
 		sink, *(&ok) = y.(*int)
 	}
 }
diff --git a/test/oldescape_param.go b/test/oldescape_param.go
index 3a3eee2a5b..cf85d745cb 100644
--- a/test/oldescape_param.go
+++ b/test/oldescape_param.go
@@ -57,7 +57,7 @@ func caller2b() {
 	i := 0 // ERROR "moved to heap: i$"
 	var p *int
 	param2(&i, &p)
-	sink = p       // ERROR "p escapes to heap$"
+	sink = p // ERROR "p escapes to heap$"
 }
 
 func paramArraySelfAssign(p *PairOfPairs) { // ERROR "p does not escape"
@@ -150,11 +150,11 @@ func caller3a() {
 }
 
 func caller3b() {
-	i := 0            // ERROR "moved to heap: i$"
-	j := 0            // ERROR "moved to heap: j$"
+	i := 0 // ERROR "moved to heap: i$"
+	j := 0 // ERROR "moved to heap: j$"
 	p := Pair{&i, &j}
 	param3(&p)
-	sink = p          // ERROR "p escapes to heap$"
+	sink = p // ERROR "p escapes to heap$"
 }
 
 // in -> rcvr
@@ -173,7 +173,7 @@ func caller4b() {
 	i := 0 // ERROR "moved to heap: i$"
 	p := Pair{}
 	p.param4(&i)
-	sink = p     // ERROR "p escapes to heap$"
+	sink = p // ERROR "p escapes to heap$"
 }
 
 // in -> heap
@@ -182,7 +182,7 @@ func param5(i *int) { // ERROR "leaking param: i$"
 }
 
 func caller5() {
-	i := 0     // ERROR "moved to heap: i$"
+	i := 0 // ERROR "moved to heap: i$"
 	param5(&i)
 }
 
@@ -192,8 +192,8 @@ func param6(i ***int) { // ERROR "leaking param content: i$"
 }
 
 func caller6a() {
-	i := 0      // ERROR "moved to heap: i$"
-	p := &i     // ERROR "moved to heap: p$"
+	i := 0  // ERROR "moved to heap: i$"
+	p := &i // ERROR "moved to heap: p$"
 	p2 := &p
 	param6(&p2)
 }
@@ -204,8 +204,8 @@ func param7(i ***int) { // ERROR "leaking param content: i$"
 }
 
 func caller7() {
-	i := 0      // ERROR "moved to heap: i$"
-	p := &i     // ERROR "moved to heap: p$"
+	i := 0  // ERROR "moved to heap: i$"
+	p := &i // ERROR "moved to heap: p$"
 	p2 := &p
 	param7(&p2)
 }
@@ -234,8 +234,8 @@ func caller9a() {
 }
 
 func caller9b() {
-	i := 0             // ERROR "moved to heap: i$"
-	p := &i            // ERROR "moved to heap: p$"
+	i := 0  // ERROR "moved to heap: i$"
+	p := &i // ERROR "moved to heap: p$"
 	p2 := &p
 	sink = param9(&p2) // ERROR  "param9\(&p2\) escapes to heap"
 }
@@ -253,7 +253,7 @@ func caller10a() {
 }
 
 func caller10b() {
-	i := 0              // ERROR "moved to heap: i$"
+	i := 0 // ERROR "moved to heap: i$"
 	p := &i
 	p2 := &p
 	sink = param10(&p2) // ERROR "param10\(&p2\) escapes to heap"
@@ -265,8 +265,8 @@ func param11(i **int) ***int { // ERROR "moved to heap: i$"
 }
 
 func caller11a() {
-	i := 0          // ERROR "moved to heap: i"
-	p := &i         // ERROR "moved to heap: p"
+	i := 0  // ERROR "moved to heap: i"
+	p := &i // ERROR "moved to heap: p"
 	_ = param11(&p)
 }
 
@@ -283,8 +283,8 @@ func caller11c() { // GOOD
 }
 
 func caller11d() {
-	i := 0             // ERROR "moved to heap: i$"
-	p := &i            // ERROR "moved to heap: p"
+	i := 0  // ERROR "moved to heap: i$"
+	p := &i // ERROR "moved to heap: p"
 	p2 := &p
 	sink = param11(p2) // ERROR "param11\(p2\) escapes to heap"
 }
@@ -319,7 +319,7 @@ func caller12c() {
 	p := &i // ERROR "moved to heap: p$"
 	r := Indir{}
 	r.param12(&p)
-	sink = r      // ERROR "r escapes to heap$"
+	sink = r // ERROR "r escapes to heap$"
 }
 
 func caller12d() {
@@ -327,7 +327,7 @@ func caller12d() {
 	p := &i // ERROR "moved to heap: p$"
 	r := Indir{}
 	r.param12(&p)
-	sink = **r.p  // ERROR "\* \(\*r\.p\) escapes to heap"
+	sink = **r.p // ERROR "\* \(\*r\.p\) escapes to heap"
 }
 
 // in -> value rcvr
@@ -370,15 +370,15 @@ func caller13d() {
 	var v Val
 	v.p = &p
 	v.param13(&i)
-	sink = v      // ERROR "v escapes to heap$"
+	sink = v // ERROR "v escapes to heap$"
 }
 
 func caller13e() {
-	i := 0        // ERROR "moved to heap: i$"
-	var p *int    // ERROR "moved to heap: p$"
+	i := 0     // ERROR "moved to heap: i$"
+	var p *int // ERROR "moved to heap: p$"
 	v := Val{&p}
 	v.param13(&i)
-	sink = v      // ERROR "v escapes to heap$"
+	sink = v // ERROR "v escapes to heap$"
 }
 
 func caller13f() {
@@ -386,7 +386,7 @@ func caller13f() {
 	var p *int    // ERROR "moved to heap: p$"
 	v := &Val{&p} // ERROR "&Val literal escapes to heap$"
 	v.param13(&i)
-	sink = v      // ERROR "v escapes to heap$"
+	sink = v // ERROR "v escapes to heap$"
 }
 
 func caller13g() {
@@ -394,7 +394,7 @@ func caller13g() {
 	var p *int
 	v := Val{&p}
 	v.param13(&i)
-	sink = *v.p   // ERROR "\*v\.p escapes to heap"
+	sink = *v.p // ERROR "\*v\.p escapes to heap"
 }
 
 func caller13h() {
@@ -402,7 +402,7 @@ func caller13h() {
 	var p *int
 	v := &Val{&p} // ERROR "caller13h &Val literal does not escape$"
 	v.param13(&i)
-	sink = **v.p  // ERROR "\* \(\*v\.p\) escapes to heap"
+	sink = **v.p // ERROR "\* \(\*v\.p\) escapes to heap"
 }
 
 type Node struct {
diff --git a/test/parentype.go b/test/parentype.go
index eafa076481..d7881129c5 100644
--- a/test/parentype.go
+++ b/test/parentype.go
@@ -11,9 +11,9 @@ package main
 func f(interface{})
 func g() {}
 func main() {
-	f(map[string]string{"a":"b","c":"d"})
-	f([...]int{1,2,3})
-	f(map[string]func(){"a":g,"c":g})
-	f(make(chan(<-chan int)))
-	f(make(chan<-(chan int)))
+	f(map[string]string{"a": "b", "c": "d"})
+	f([...]int{1, 2, 3})
+	f(map[string]func(){"a": g, "c": g})
+	f(make(chan (<-chan int)))
+	f(make(chan<- (chan int)))
 }
diff --git a/test/pmu/test1.go b/test/pmu/test1.go
index 2cde966075..c28c4cbd7d 100644
--- a/test/pmu/test1.go
+++ b/test/pmu/test1.go
@@ -162,6 +162,7 @@ func run() error {
 
 	var cycle pprof.PMUEventConfig
 	cycle.Period = 10000000
+	cycle.PreciseIP = 2
 
 	if err := pprof.StartPMUProfile(pprof.WithProfilingPMUCycles(cycleFile, &cycle)); err != nil {
 		return err
diff --git a/test/pmu/test2.go b/test/pmu/test2.go
index 660e16313e..3d138bbeff 100644
--- a/test/pmu/test2.go
+++ b/test/pmu/test2.go
@@ -25,9 +25,6 @@ func f1() {
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
-		/*if i % 100 == 0 {
-			time.Sleep(time.Nanosecond)
-		}*/
 	}
 
 	fmt.Println(sum)
@@ -42,9 +39,6 @@ func f2() {
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
-		/*if i % 100 == 0 {
-			time.Sleep(time.Nanosecond)
-		}*/
 	}
 
 	fmt.Println(sum)
@@ -59,9 +53,6 @@ func f3() {
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
-		/*if i % 100 == 0 {
-			time.Sleep(time.Nanosecond)
-		}*/
 	}
 
 	fmt.Println(sum)
@@ -76,9 +67,6 @@ func f4() {
 		sum *= i
 		sum /= i/3 + 1
 		sum -= i / 4
-		/*if i % 100 == 0 {
-			time.Sleep(time.Nanosecond)
-		}*/
 	}
 
 	fmt.Println(sum)
diff --git a/test/pmu/test4.go b/test/pmu/test4.go
index 21b72160bc..b2d33b0eab 100644
--- a/test/pmu/test4.go
+++ b/test/pmu/test4.go
@@ -161,7 +161,7 @@ func run() error {
 	defer rawFile.Close()
 
 	var raw pprof.PMUEventConfig
-	raw.RawEvent = /* UOPS_ISSUED */ 0x53010e
+	raw.RawEvent = 0x53010e /* UOPS_ISSUED */
 	raw.Period = 1000000
 
 	if err := pprof.StartPMUProfile(pprof.WithProfilingPMURaw(rawFile, &raw)); err != nil {
diff --git a/test/printbig.go b/test/printbig.go
index 9e08c39adc..a4af1fc9e1 100644
--- a/test/printbig.go
+++ b/test/printbig.go
@@ -9,6 +9,6 @@
 package main
 
 func main() {
-	print(-(1<<63), "\n")
+	print(-(1 << 63), "\n")
 	print((1<<63)-1, "\n")
 }
diff --git a/test/recover1.go b/test/recover1.go
index c14a607c6b..7e7c2c5968 100644
--- a/test/recover1.go
+++ b/test/recover1.go
@@ -22,21 +22,21 @@ func main() {
 }
 
 func die() {
-	runtime.Breakpoint()	// can't depend on panic
+	runtime.Breakpoint() // can't depend on panic
 }
 
 func mustRecover(x interface{}) {
-	mustNotRecover()	// because it's not a defer call
+	mustNotRecover() // because it's not a defer call
 	v := recover()
 	if v == nil {
 		println("missing recover")
-		die()	// panic is useless here
+		die() // panic is useless here
 	}
 	if v != x {
 		println("wrong value", v, x)
 		die()
 	}
-	
+
 	// the value should be gone now regardless
 	v = recover()
 	if v != nil {
@@ -54,7 +54,7 @@ func mustNotRecover() {
 }
 
 func withoutRecover() {
-	mustNotRecover()	// because it's a sub-call
+	mustNotRecover() // because it's a sub-call
 }
 
 func test1() {
@@ -116,7 +116,7 @@ func test6() {
 	// Like test3, but changed recover to defer (same change as test4 → test5).
 	defer mustNotRecover()
 	defer func() {
-		defer recover()	// like a normal call from this func; runs because mustRecover stops the panic
+		defer recover() // like a normal call from this func; runs because mustRecover stops the panic
 		defer mustRecover(3)
 		panic(3)
 	}()
@@ -134,7 +134,7 @@ func test7() {
 	defer mustRecover(2)
 	defer func() {
 		defer mustRecover(3)
-		defer recover()	// now a no-op, unlike in test6.
+		defer recover() // now a no-op, unlike in test6.
 		panic(3)
 	}()
 	panic(2)
diff --git a/test/return.go b/test/return.go
index 95f94b9276..20f648cf46 100644
--- a/test/return.go
+++ b/test/return.go
@@ -151,27 +151,31 @@ func _() int {
 func _() int {
 	print(1)
 	return 2
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 func _() int {
 L:
 	print(1)
 	goto L
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 func _() int {
 	print(1)
 	panic(2)
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 func _() int {
 	{
 		print(1)
 		return 2
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
@@ -180,7 +184,8 @@ L:
 	{
 		print(1)
 		goto L
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
@@ -188,7 +193,8 @@ func _() int {
 	print(1)
 	{
 		panic(2)
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
@@ -197,7 +203,8 @@ func _() int {
 		print(1)
 		return 2
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 func _() int {
@@ -206,7 +213,8 @@ L:
 		print(1)
 		goto L
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 func _() int {
@@ -214,7 +222,8 @@ func _() int {
 	{
 		panic(2)
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 // if-else chain with final else and all terminating is okay
@@ -282,12 +291,12 @@ func _() int {
 	}
 } // ERROR "missing return"
 
-
 // for { loops that never break are okay.
 
 func _() int {
 	print(1)
-	for {}
+	for {
+	}
 }
 
 func _() int {
@@ -300,7 +309,7 @@ func _() int {
 
 func _() int {
 	for {
-		L:
+	L:
 		for {
 			break L
 		}
@@ -311,7 +320,9 @@ func _() int {
 
 func _() int {
 	print(1)
-	for { break }
+	for {
+		break
+	}
 } // ERROR "missing return"
 
 func _() int {
@@ -335,7 +346,8 @@ L:
 
 func _() int {
 	print(1)
-	for x == nil {}
+	for x == nil {
+	}
 } // ERROR "missing return"
 
 func _() int {
@@ -348,16 +360,17 @@ func _() int {
 
 func _() int {
 	for x == nil {
-		L:
+	L:
 		for {
 			break L
 		}
-	}	
+	}
 } // ERROR "missing return"
 
 func _() int {
 	print(1)
-	for true {}
+	for true {
+	}
 } // ERROR "missing return"
 
 func _() int {
@@ -370,7 +383,7 @@ func _() int {
 
 func _() int {
 	for true {
-		L:
+	L:
 		for {
 			break L
 		}
@@ -381,7 +394,7 @@ func _() int {
 
 func _() int {
 	print(1)
-	select{}
+	select {}
 }
 
 func _() int {
@@ -398,7 +411,8 @@ func _() int {
 	select {
 	case <-c:
 		print(2)
-		for{}
+		for {
+		}
 	}
 }
 
@@ -422,7 +436,7 @@ func _() int {
 		print(2)
 		panic("abc")
 	default:
-		select{}
+		select {}
 	}
 }
 
@@ -449,7 +463,6 @@ L:
 	}
 } // ERROR "missing return"
 
-
 func _() int {
 	print(1)
 	select {
@@ -461,12 +474,14 @@ func _() int {
 	}
 } // ERROR "missing return"
 
-
 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
 
 func _() int {
 	print(1)
-	select{ default: break }
+	select {
+	default:
+		break
+	}
 } // ERROR "missing return"
 
 func _() int {
@@ -485,7 +500,9 @@ L:
 	select {
 	case <-c:
 		print(2)
-		for{ break L }
+		for {
+			break L
+		}
 	}
 } // ERROR "missing return"
 
@@ -509,7 +526,7 @@ func _() int {
 		print(1)
 		panic("abc")
 	default:
-		select{}
+		select {}
 		break
 	}
 } // ERROR "missing return"
@@ -557,7 +574,6 @@ func _() int {
 	}
 } // ERROR "missing return"
 
-
 func _() int {
 	print(1)
 	switch x {
@@ -673,7 +689,6 @@ func _() int {
 	}
 } // ERROR "missing return"
 
-
 func _() int {
 	print(1)
 	switch x.(type) {
@@ -863,24 +878,28 @@ func _() int {
 
 func _() int {
 	return 2
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 func _() int {
 L:
 	goto L
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 func _() int {
 	panic(2)
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 func _() int {
 	{
 		return 2
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
@@ -888,14 +907,16 @@ func _() int {
 L:
 	{
 		goto L
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
 func _() int {
 	{
 		panic(2)
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
@@ -903,7 +924,8 @@ func _() int {
 	{
 		return 2
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 func _() int {
@@ -911,14 +933,16 @@ L:
 	{
 		goto L
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 func _() int {
 	{
 		panic(2)
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 // if-else chain with final else and all terminating is okay
@@ -980,11 +1004,11 @@ func _() int {
 	}
 } // ERROR "missing return"
 
-
 // for { loops that never break are okay.
 
 func _() int {
-	for {}
+	for {
+	}
 }
 
 func _() int {
@@ -997,7 +1021,7 @@ func _() int {
 
 func _() int {
 	for {
-		L:
+	L:
 		for {
 			break L
 		}
@@ -1007,7 +1031,9 @@ func _() int {
 // for { loops that break are not okay.
 
 func _() int {
-	for { break }
+	for {
+		break
+	}
 } // ERROR "missing return"
 
 func _() int {
@@ -1030,7 +1056,8 @@ L:
 // if there's a condition - even "true" - the loops are no longer syntactically terminating
 
 func _() int {
-	for x == nil {}
+	for x == nil {
+	}
 } // ERROR "missing return"
 
 func _() int {
@@ -1043,15 +1070,16 @@ func _() int {
 
 func _() int {
 	for x == nil {
-		L:
+	L:
 		for {
 			break L
 		}
-	}	
+	}
 } // ERROR "missing return"
 
 func _() int {
-	for true {}
+	for true {
+	}
 } // ERROR "missing return"
 
 func _() int {
@@ -1064,7 +1092,7 @@ func _() int {
 
 func _() int {
 	for true {
-		L:
+	L:
 		for {
 			break L
 		}
@@ -1074,7 +1102,7 @@ func _() int {
 // select in which all cases terminate and none break are okay.
 
 func _() int {
-	select{}
+	select {}
 }
 
 func _() int {
@@ -1089,7 +1117,8 @@ func _() int {
 	select {
 	case <-c:
 		print(2)
-		for{}
+		for {
+		}
 	}
 }
 
@@ -1111,7 +1140,7 @@ func _() int {
 		print(2)
 		panic("abc")
 	default:
-		select{}
+		select {}
 	}
 }
 
@@ -1136,7 +1165,6 @@ L:
 	}
 } // ERROR "missing return"
 
-
 func _() int {
 	select {
 	case <-c:
@@ -1147,11 +1175,13 @@ func _() int {
 	}
 } // ERROR "missing return"
 
-
 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
 
 func _() int {
-	select{ default: break }
+	select {
+	default:
+		break
+	}
 } // ERROR "missing return"
 
 func _() int {
@@ -1168,7 +1198,9 @@ L:
 	select {
 	case <-c:
 		print(2)
-		for{ break L }
+		for {
+			break L
+		}
 	}
 } // ERROR "missing return"
 
@@ -1189,7 +1221,7 @@ func _() int {
 	case <-c:
 		panic("abc")
 	default:
-		select{}
+		select {}
 		break
 	}
 } // ERROR "missing return"
@@ -1233,7 +1265,6 @@ func _() int {
 	}
 } // ERROR "missing return"
 
-
 func _() int {
 	switch x {
 	case 1:
@@ -1339,7 +1370,6 @@ func _() int {
 	}
 } // ERROR "missing return"
 
-
 func _() int {
 	switch x.(type) {
 	case int:
@@ -1553,27 +1583,31 @@ var _ = func() int {
 var _ = func() int {
 	print(1)
 	return 2
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
 L:
 	print(1)
 	goto L
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
 	print(1)
 	panic(2)
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
 	{
 		print(1)
 		return 2
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
@@ -1582,7 +1616,8 @@ L:
 	{
 		print(1)
 		goto L
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
@@ -1590,7 +1625,8 @@ var _ = func() int {
 	print(1)
 	{
 		panic(2)
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
@@ -1599,7 +1635,8 @@ var _ = func() int {
 		print(1)
 		return 2
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1608,7 +1645,8 @@ L:
 		print(1)
 		goto L
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1616,7 +1654,8 @@ var _ = func() int {
 	{
 		panic(2)
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 // if-else chain with final else and all terminating is okay
@@ -1684,12 +1723,12 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
-
 // for { loops that never break are okay.
 
 var _ = func() int {
 	print(1)
-	for {}
+	for {
+	}
 }
 
 var _ = func() int {
@@ -1702,7 +1741,7 @@ var _ = func() int {
 
 var _ = func() int {
 	for {
-		L:
+	L:
 		for {
 			break L
 		}
@@ -1713,7 +1752,9 @@ var _ = func() int {
 
 var _ = func() int {
 	print(1)
-	for { break }
+	for {
+		break
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1737,7 +1778,8 @@ L:
 
 var _ = func() int {
 	print(1)
-	for x == nil {}
+	for x == nil {
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1750,16 +1792,17 @@ var _ = func() int {
 
 var _ = func() int {
 	for x == nil {
-		L:
+	L:
 		for {
 			break L
 		}
-	}	
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
 	print(1)
-	for true {}
+	for true {
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1772,7 +1815,7 @@ var _ = func() int {
 
 var _ = func() int {
 	for true {
-		L:
+	L:
 		for {
 			break L
 		}
@@ -1783,7 +1826,7 @@ var _ = func() int {
 
 var _ = func() int {
 	print(1)
-	select{}
+	select {}
 }
 
 var _ = func() int {
@@ -1800,7 +1843,8 @@ var _ = func() int {
 	select {
 	case <-c:
 		print(2)
-		for{}
+		for {
+		}
 	}
 }
 
@@ -1824,7 +1868,7 @@ var _ = func() int {
 		print(2)
 		panic("abc")
 	default:
-		select{}
+		select {}
 	}
 }
 
@@ -1851,7 +1895,6 @@ L:
 	}
 } // ERROR "missing return"
 
-
 var _ = func() int {
 	print(1)
 	select {
@@ -1863,12 +1906,14 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
-
 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
 
 var _ = func() int {
 	print(1)
-	select{ default: break }
+	select {
+	default:
+		break
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1887,7 +1932,9 @@ L:
 	select {
 	case <-c:
 		print(2)
-		for{ break L }
+		for {
+			break L
+		}
 	}
 } // ERROR "missing return"
 
@@ -1911,7 +1958,7 @@ var _ = func() int {
 		print(1)
 		panic("abc")
 	default:
-		select{}
+		select {}
 		break
 	}
 } // ERROR "missing return"
@@ -1959,7 +2006,6 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
-
 var _ = func() int {
 	print(1)
 	switch x {
@@ -2075,7 +2121,6 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
-
 var _ = func() int {
 	print(1)
 	switch x.(type) {
@@ -2265,24 +2310,28 @@ var _ = func() int {
 
 var _ = func() int {
 	return 2
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
 L:
 	goto L
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
 	panic(2)
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
 	{
 		return 2
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
@@ -2290,14 +2339,16 @@ var _ = func() int {
 L:
 	{
 		goto L
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
 var _ = func() int {
 	{
 		panic(2)
-		{}
+		{
+		}
 	}
 } // ERROR "missing return"
 
@@ -2305,7 +2356,8 @@ var _ = func() int {
 	{
 		return 2
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -2313,14 +2365,16 @@ L:
 	{
 		goto L
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
 	{
 		panic(2)
 	}
-	{}
+	{
+	}
 } // ERROR "missing return"
 
 // if-else chain with final else and all terminating is okay
@@ -2382,11 +2436,11 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
-
 // for { loops that never break are okay.
 
 var _ = func() int {
-	for {}
+	for {
+	}
 }
 
 var _ = func() int {
@@ -2399,7 +2453,7 @@ var _ = func() int {
 
 var _ = func() int {
 	for {
-		L:
+	L:
 		for {
 			break L
 		}
@@ -2409,7 +2463,9 @@ var _ = func() int {
 // for { loops that break are not okay.
 
 var _ = func() int {
-	for { break }
+	for {
+		break
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -2432,7 +2488,8 @@ L:
 // if there's a condition - even "true" - the loops are no longer syntactically terminating
 
 var _ = func() int {
-	for x == nil {}
+	for x == nil {
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -2445,15 +2502,16 @@ var _ = func() int {
 
 var _ = func() int {
 	for x == nil {
-		L:
+	L:
 		for {
 			break L
 		}
-	}	
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
-	for true {}
+	for true {
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -2466,7 +2524,7 @@ var _ = func() int {
 
 var _ = func() int {
 	for true {
-		L:
+	L:
 		for {
 			break L
 		}
@@ -2476,7 +2534,7 @@ var _ = func() int {
 // select in which all cases terminate and none break are okay.
 
 var _ = func() int {
-	select{}
+	select {}
 }
 
 var _ = func() int {
@@ -2491,7 +2549,8 @@ var _ = func() int {
 	select {
 	case <-c:
 		print(2)
-		for{}
+		for {
+		}
 	}
 }
 
@@ -2513,7 +2572,7 @@ var _ = func() int {
 		print(2)
 		panic("abc")
 	default:
-		select{}
+		select {}
 	}
 }
 
@@ -2538,7 +2597,6 @@ L:
 	}
 } // ERROR "missing return"
 
-
 var _ = func() int {
 	select {
 	case <-c:
@@ -2549,11 +2607,13 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
-
 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
 
 var _ = func() int {
-	select{ default: break }
+	select {
+	default:
+		break
+	}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -2570,7 +2630,9 @@ L:
 	select {
 	case <-c:
 		print(2)
-		for{ break L }
+		for {
+			break L
+		}
 	}
 } // ERROR "missing return"
 
@@ -2591,7 +2653,7 @@ var _ = func() int {
 	case <-c:
 		panic("abc")
 	default:
-		select{}
+		select {}
 		break
 	}
 } // ERROR "missing return"
@@ -2635,7 +2697,6 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
-
 var _ = func() int {
 	switch x {
 	case 1:
@@ -2741,7 +2802,6 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
-
 var _ = func() int {
 	switch x.(type) {
 	case int:
diff --git a/test/rune.go b/test/rune.go
index 73a5aa23f8..3509876910 100644
--- a/test/rune.go
+++ b/test/rune.go
@@ -11,12 +11,12 @@ package rune
 
 var (
 	r0 = 'a'
-	r1 = 'a'+1
-	r2 = 1+'a'
-	r3 = 'a'*2
-	r4 = 'a'/2
-	r5 = 'a'<<1
-	r6 = 'b'<<2
+	r1 = 'a' + 1
+	r2 = 1 + 'a'
+	r3 = 'a' * 2
+	r4 = 'a' / 2
+	r5 = 'a' << 1
+	r6 = 'b' << 2
 	r7 int32
 
 	r = []rune{r0, r1, r2, r3, r4, r5, r6, r7}
@@ -24,15 +24,15 @@ var (
 
 var (
 	f0 = 1.2
-	f1 = 1.2/'a'
+	f1 = 1.2 / 'a'
 
 	f = []float64{f0, f1}
 )
 
 var (
 	i0 = 1
-	i1 = 1<<'\x01'
-	
+	i1 = 1 << '\x01'
+
 	i = []int{i0, i1}
 )
 
@@ -42,6 +42,6 @@ const (
 
 var (
 	b0 = maxRune < r0
-	
+
 	b = []bool{b0}
 )
diff --git a/test/runtime.go b/test/runtime.go
index 0cf781b814..09862acf50 100644
--- a/test/runtime.go
+++ b/test/runtime.go
@@ -17,5 +17,5 @@ package main
 import "runtime"
 
 func main() {
-	runtime.printbool(true)	// ERROR "unexported" "undefined"
+	runtime.printbool(true) // ERROR "unexported" "undefined"
 }
diff --git a/test/shift1.go b/test/shift1.go
index 01ecbed53a..dd990fa929 100644
--- a/test/shift1.go
+++ b/test/shift1.go
@@ -61,12 +61,12 @@ func _() {
 		o       = 1<<s == 2<<s   // 1 and 2 have type int; o == true if ints are 32bits in size
 		// next test only fails on 32bit systems
 		// p = 1<<s == 1<<33  // illegal if ints are 32bits in size: 1 has type int, but 1<<33 overflows int
-		u          = 1.0 << s    // ERROR "non-integer|float64"
-		u1         = 1.0<<s != 0 // ERROR "non-integer|float64"
-		u2         = 1<<s != 1.0 // ERROR "non-integer|float64"
-		v  float32 = 1 << s      // ERROR "non-integer|float32"
-		w  int64   = 1.0 << 33   // 1.0<<33 is a constant shift expression
-		_, _, _, _, _, _, _, _, _, _ = j, k, m, n, o, u, u1, u2, v, w
+		u                                    = 1.0 << s    // ERROR "non-integer|float64"
+		u1                                   = 1.0<<s != 0 // ERROR "non-integer|float64"
+		u2                                   = 1<<s != 1.0 // ERROR "non-integer|float64"
+		v                            float32 = 1 << s      // ERROR "non-integer|float32"
+		w                            int64   = 1.0 << 33   // 1.0<<33 is a constant shift expression
+		_, _, _, _, _, _, _, _, _, _         = j, k, m, n, o, u, u1, u2, v, w
 	)
 
 	// non constants arguments trigger a different path
diff --git a/test/stack.go b/test/stack.go
index b62febd48d..4c56276e1f 100644
--- a/test/stack.go
+++ b/test/stack.go
@@ -46,7 +46,7 @@ func f1() [3000]byte {
 	// does not pass the frame size, the new
 	// stack (default size 5k) will not be big
 	// enough for the frame, and the morestack
-	// check in f2 will die, if we get that far 
+	// check in f2 will die, if we get that far
 	// without faulting.
 	f2()
 	return [3000]byte{}
diff --git a/test/switch5.go b/test/switch5.go
index ce95bf8d7b..705fd9a958 100644
--- a/test/switch5.go
+++ b/test/switch5.go
@@ -86,7 +86,7 @@ func f8(r rune) {
 	case 34, '"': // ERROR "duplicate case '"' .value 34. in switch"
 	case 35, rune('#'): // ERROR "duplicate case rune.'#'. .value 35. in switch"
 	case 36, rune(36): // ERROR "duplicate case rune.36. .value 36. in switch"
-	case 37, '$'+1: // ERROR "duplicate case '\$' \+ 1 .value 37. in switch"
+	case 37, '$' + 1: // ERROR "duplicate case '\$' \+ 1 .value 37. in switch"
 	case 'b':
 	case 'a', 'b', 'c', 'd': // ERROR "duplicate case 'b' .value 98."
 	case x, x: // ERROR "duplicate case x .value 10."
diff --git a/test/switch7.go b/test/switch7.go
index 75060669b3..d9cc7a81da 100644
--- a/test/switch7.go
+++ b/test/switch7.go
@@ -32,4 +32,3 @@ func f4(e interface{}) {
 	}:
 	}
 }
-
diff --git a/test/tinyfin.go b/test/tinyfin.go
index 5171dfc72e..215b3d1b73 100644
--- a/test/tinyfin.go
+++ b/test/tinyfin.go
@@ -32,7 +32,7 @@ func main() {
 	runtime.GC()
 	count := 0
 	done := make([]bool, N)
-	timeout := time.After(5*time.Second)
+	timeout := time.After(5 * time.Second)
 	for {
 		select {
 		case <-timeout:
diff --git a/test/typecheck.go b/test/typecheck.go
index 6f1204289a..3c225ad346 100644
--- a/test/typecheck.go
+++ b/test/typecheck.go
@@ -8,11 +8,11 @@
 
 package main
 
-func mine(int b) int {	// ERROR "undefined.*b"
-	return b + 2	// ERROR "undefined.*b"
+func mine(int b) int { // ERROR "undefined.*b"
+	return b + 2 // ERROR "undefined.*b"
 }
 
 func main() {
-	mine()		// GCCGO_ERROR "not enough arguments"
-	c = mine()	// ERROR "undefined.*c|not enough arguments"
+	mine()     // GCCGO_ERROR "not enough arguments"
+	c = mine() // ERROR "undefined.*c|not enough arguments"
 }
diff --git a/test/typeswitch2.go b/test/typeswitch2.go
index 5958b7db8e..b6c78e8251 100644
--- a/test/typeswitch2.go
+++ b/test/typeswitch2.go
@@ -26,7 +26,7 @@ func whatis(x interface{}) string {
 		w()
 	}:
 		return "rw"
-	case interface {	// ERROR "duplicate"
+	case interface { // ERROR "duplicate"
 		w()
 		r()
 	}:
diff --git a/test/undef.go b/test/undef.go
index 61524f3d4c..14cefa93d7 100644
--- a/test/undef.go
+++ b/test/undef.go
@@ -10,24 +10,26 @@
 package main
 
 var (
-	_ = x	// ERROR "undefined.*x"
-	_ = x	// ERROR "undefined.*x"
-	_ = x	// ERROR "undefined.*x"
+	_ = x // ERROR "undefined.*x"
+	_ = x // ERROR "undefined.*x"
+	_ = x // ERROR "undefined.*x"
 )
 
 type T struct {
 	y int
 }
 
-func foo() *T { return &T{y: 99} }
-func bar() int { return y }	// ERROR "undefined.*y"
+func foo() *T  { return &T{y: 99} }
+func bar() int { return y } // ERROR "undefined.*y"
 
 type T1 struct {
 	y1 int
 }
 
 func foo1() *T1 { return &T1{y1: 99} }
+
 var y1 = 2
+
 func bar1() int { return y1 }
 
 func f1(val interface{}) {
@@ -40,6 +42,6 @@ func f1(val interface{}) {
 func f2(val interface{}) {
 	switch val.(type) {
 	default:
-		println(v)	// ERROR "undefined.*v"
+		println(v) // ERROR "undefined.*v"
 	}
 }
diff --git a/test/varerr.go b/test/varerr.go
index 82ab814197..95a03fd8c5 100644
--- a/test/varerr.go
+++ b/test/varerr.go
@@ -10,8 +10,7 @@
 package main
 
 func main() {
-	_ = asdf	// ERROR "undefined.*asdf"
+	_ = asdf // ERROR "undefined.*asdf"
 
-	new = 1	// ERROR "use of builtin new not in function call|invalid left hand side"
+	new = 1 // ERROR "use of builtin new not in function call|invalid left hand side"
 }
-

From 01e39fc689c8fd0b97683a9359726190d820722f Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 24 Sep 2019 21:05:19 -0400
Subject: [PATCH 119/126] Update test cases

---
 test/235.go                            |    4 +-
 test/64bit.go                          |   48 +-
 test/align.go                          |    2 +-
 test/assign1.go                        |    5 +-
 test/bigmap.go                         |    7 +-
 test/blank1.go                         |   12 +-
 test/char_lit.go                       |    3 +-
 test/closedchan.go                     |   15 +-
 test/closure1.go                       |    2 +-
 test/closure2.go                       |    4 +-
 test/cmplxdivide1.go                   |    6 +-
 test/complit1.go                       |   12 +-
 test/const1.go                         |    8 +-
 test/const3.go                         |    2 +-
 test/const5.go                         |   12 +-
 test/const6.go                         |   30 +-
 test/convT2X.go                        |    4 +-
 test/convlit1.go                       |    8 +-
 test/ddd2.dir/ddd2.go                  |    1 +
 test/deferfin.go                       |    1 +
 test/deferprint.go                     |    2 +-
 test/divmod.go                         |   45 +-
 test/dwarf/dwarf.dir/main.go           |   41 +-
 test/dwarf/dwarf.dir/z1.go             |    3 +-
 test/dwarf/dwarf.dir/z10.go            |    4 +-
 test/dwarf/dwarf.dir/z11.go            |    2 +-
 test/dwarf/dwarf.dir/z12.go            |    2 +-
 test/dwarf/dwarf.dir/z13.go            |    2 +-
 test/dwarf/dwarf.dir/z14.go            |    2 +-
 test/dwarf/dwarf.dir/z15.go            |    2 +-
 test/dwarf/dwarf.dir/z16.go            |    2 +-
 test/dwarf/dwarf.dir/z17.go            |    2 +-
 test/dwarf/dwarf.dir/z18.go            |    3 +-
 test/dwarf/dwarf.dir/z19.go            |    2 +-
 test/dwarf/dwarf.dir/z2.go             |    2 +-
 test/dwarf/dwarf.dir/z20.go            |    2 +-
 test/dwarf/dwarf.dir/z3.go             |    2 +-
 test/dwarf/dwarf.dir/z4.go             |    2 +-
 test/dwarf/dwarf.dir/z5.go             |    2 +-
 test/dwarf/dwarf.dir/z6.go             |    2 +-
 test/dwarf/dwarf.dir/z7.go             |    2 +-
 test/dwarf/dwarf.dir/z8.go             |    2 +-
 test/dwarf/dwarf.dir/z9.go             |    2 +-
 test/dwarf/linedirectives.go           |    6 +-
 test/empty.go                          |   11 +-
 test/eof.go                            |    2 +-
 test/eof1.go                           |    2 +-
 test/escape2.go                        |   42 +-
 test/escape2n.go                       |   42 +-
 test/escape4.go                        |    4 +-
 test/escape_closure.go                 |    4 +-
 test/escape_field.go                   |    8 +-
 test/escape_iface.go                   |   32 +-
 test/escape_indir.go                   |   12 +-
 test/escape_level.go                   |   20 +-
 test/escape_map.go                     |   22 +-
 test/escape_param.go                   |   52 +-
 test/escape_slice.go                   |   14 +-
 test/escape_struct_param1.go           |   98 +-
 test/escape_struct_param2.go           |   98 +-
 test/finprofiled.go                    |    2 +-
 test/fixedbugs/bug000.go               |    8 +-
 test/fixedbugs/bug002.go               |    3 +-
 test/fixedbugs/bug003.go               |    8 +-
 test/fixedbugs/bug004.go               |    5 +-
 test/fixedbugs/bug005.go               |    8 +-
 test/fixedbugs/bug008.go               |   17 +-
 test/fixedbugs/bug009.go               |    5 +-
 test/fixedbugs/bug010.go               |    1 +
 test/fixedbugs/bug011.go               |    2 +-
 test/fixedbugs/bug012.go               |   26 +-
 test/fixedbugs/bug013.go               |    7 +-
 test/fixedbugs/bug015.go               |    4 +-
 test/fixedbugs/bug017.go               |    5 +-
 test/fixedbugs/bug020.go               |    4 +-
 test/fixedbugs/bug021.go               |    6 +-
 test/fixedbugs/bug022.go               |   12 +-
 test/fixedbugs/bug023.go               |   11 +-
 test/fixedbugs/bug024.go               |   13 +-
 test/fixedbugs/bug026.go               |    8 +-
 test/fixedbugs/bug028.go               |   13 +-
 test/fixedbugs/bug030.go               |    6 +-
 test/fixedbugs/bug031.go               |   34 +-
 test/fixedbugs/bug037.go               |    2 +-
 test/fixedbugs/bug039.go               |    4 +-
 test/fixedbugs/bug040.go               |    4 +-
 test/fixedbugs/bug045.go               |    7 +-
 test/fixedbugs/bug046.go               |    4 +-
 test/fixedbugs/bug048.go               |    6 +-
 test/fixedbugs/bug049.go               |    4 +-
 test/fixedbugs/bug051.go               |    4 +-
 test/fixedbugs/bug052.go               |   10 +-
 test/fixedbugs/bug053.go               |    4 +-
 test/fixedbugs/bug054.go               |   26 +-
 test/fixedbugs/bug056.go               |    4 +-
 test/fixedbugs/bug057.go               |   13 +-
 test/fixedbugs/bug058.go               |   13 +-
 test/fixedbugs/bug059.go               |   26 +-
 test/fixedbugs/bug060.go               |    8 +-
 test/fixedbugs/bug061.go               |    6 +-
 test/fixedbugs/bug062.go               |    2 +-
 test/fixedbugs/bug063.go               |    1 -
 test/fixedbugs/bug064.go               |   14 +-
 test/fixedbugs/bug065.go               |    4 +-
 test/fixedbugs/bug066.go               |   11 +-
 test/fixedbugs/bug067.go               |    4 +-
 test/fixedbugs/bug069.go               |   20 +-
 test/fixedbugs/bug071.go               |   12 +-
 test/fixedbugs/bug072.go               |    2 +-
 test/fixedbugs/bug074.go               |    4 +-
 test/fixedbugs/bug075.go               |   15 +-
 test/fixedbugs/bug076.go               |    3 +-
 test/fixedbugs/bug078.go               |    2 +-
 test/fixedbugs/bug083.dir/bug1.go      |    3 +-
 test/fixedbugs/bug085.go               |    2 +-
 test/fixedbugs/bug086.go               |    4 +-
 test/fixedbugs/bug087.go               |    6 +-
 test/fixedbugs/bug088.dir/bug0.go      |    6 +-
 test/fixedbugs/bug088.dir/bug1.go      |    8 +-
 test/fixedbugs/bug089.go               |   15 +-
 test/fixedbugs/bug090.go               |   40 +-
 test/fixedbugs/bug092.go               |    6 +-
 test/fixedbugs/bug093.go               |    9 +-
 test/fixedbugs/bug094.go               |   12 +-
 test/fixedbugs/bug096.go               |    8 +-
 test/fixedbugs/bug098.go               |   10 +-
 test/fixedbugs/bug099.go               |   12 +-
 test/fixedbugs/bug101.go               |   10 +-
 test/fixedbugs/bug103.go               |    5 +-
 test/fixedbugs/bug104.go               |    3 +-
 test/fixedbugs/bug106.dir/bug1.go      |    1 +
 test/fixedbugs/bug107.go               |   11 +-
 test/fixedbugs/bug108.go               |    3 +-
 test/fixedbugs/bug111.go               |   12 +-
 test/fixedbugs/bug112.go               |    3 +-
 test/fixedbugs/bug113.go               |    2 +-
 test/fixedbugs/bug115.go               |    6 +-
 test/fixedbugs/bug118.go               |    4 +-
 test/fixedbugs/bug122.go               |    2 +-
 test/fixedbugs/bug123.go               |    8 +-
 test/fixedbugs/bug126.go               |    4 +-
 test/fixedbugs/bug127.go               |    7 +-
 test/fixedbugs/bug128.go               |   11 +-
 test/fixedbugs/bug129.go               |    7 +-
 test/fixedbugs/bug130.go               |   17 +-
 test/fixedbugs/bug131.go               |    4 +-
 test/fixedbugs/bug132.go               |    2 +-
 test/fixedbugs/bug133.dir/bug0.go      |    2 +-
 test/fixedbugs/bug133.dir/bug1.go      |    2 +-
 test/fixedbugs/bug133.dir/bug2.go      |    4 +-
 test/fixedbugs/bug135.go               |   13 +-
 test/fixedbugs/bug136.go               |   14 +-
 test/fixedbugs/bug139.go               |   14 +-
 test/fixedbugs/bug141.go               |   16 +-
 test/fixedbugs/bug142.go               |    8 +-
 test/fixedbugs/bug143.go               |   28 +-
 test/fixedbugs/bug144.go               |    6 +-
 test/fixedbugs/bug145.go               |    4 +-
 test/fixedbugs/bug146.go               |   10 +-
 test/fixedbugs/bug148.go               |   22 +-
 test/fixedbugs/bug149.go               |   16 +-
 test/fixedbugs/bug150.go               |    7 +-
 test/fixedbugs/bug151.go               |    4 +-
 test/fixedbugs/bug152.go               |    6 +-
 test/fixedbugs/bug154.go               |   24 +-
 test/fixedbugs/bug155.go               |    2 +-
 test/fixedbugs/bug156.go               |    6 +-
 test/fixedbugs/bug157.go               |   15 +-
 test/fixedbugs/bug158.go               |    3 +-
 test/fixedbugs/bug159.go               |   20 +-
 test/fixedbugs/bug160.dir/y.go         |    8 +-
 test/fixedbugs/bug161.go               |    4 +-
 test/fixedbugs/bug165.go               |    4 +-
 test/fixedbugs/bug170.go               |   11 +-
 test/fixedbugs/bug171.go               |    4 +-
 test/fixedbugs/bug172.go               |    4 +-
 test/fixedbugs/bug173.go               |    5 +-
 test/fixedbugs/bug174.go               |    4 +-
 test/fixedbugs/bug175.go               |    2 +-
 test/fixedbugs/bug176.go               |    5 +-
 test/fixedbugs/bug181.go               |    2 +-
 test/fixedbugs/bug182.go               |    4 +-
 test/fixedbugs/bug183.go               |   21 +-
 test/fixedbugs/bug186.go               |    8 +-
 test/fixedbugs/bug187.go               |   10 +-
 test/fixedbugs/bug188.go               |    6 +-
 test/fixedbugs/bug189.go               |    8 +-
 test/fixedbugs/bug190.go               |   26 +-
 test/fixedbugs/bug191.dir/a.go         |    3 +-
 test/fixedbugs/bug191.dir/b.go         |    2 +-
 test/fixedbugs/bug192.go               |    4 +-
 test/fixedbugs/bug195.go               |   12 +-
 test/fixedbugs/bug197.go               |   14 +-
 test/fixedbugs/bug198.go               |    7 +-
 test/fixedbugs/bug200.go               |    4 +-
 test/fixedbugs/bug202.go               |    9 +-
 test/fixedbugs/bug203.go               |    8 +-
 test/fixedbugs/bug205.go               |   11 +-
 test/fixedbugs/bug206.go               |   17 +-
 test/fixedbugs/bug207.go               |    4 +-
 test/fixedbugs/bug208.go               |    8 +-
 test/fixedbugs/bug209.go               |    4 +-
 test/fixedbugs/bug211.go               |    9 +-
 test/fixedbugs/bug212.go               |   10 +-
 test/fixedbugs/bug213.go               |    7 +-
 test/fixedbugs/bug214.go               |    4 +-
 test/fixedbugs/bug215.go               |    6 +-
 test/fixedbugs/bug216.go               |    2 +-
 test/fixedbugs/bug217.go               |    5 +-
 test/fixedbugs/bug218.go               |    4 +-
 test/fixedbugs/bug219.go               |   14 +-
 test/fixedbugs/bug222.dir/chanbug.go   |    3 +-
 test/fixedbugs/bug222.dir/chanbug2.go  |    1 -
 test/fixedbugs/bug224.go               |    3 +-
 test/fixedbugs/bug225.go               |   10 +-
 test/fixedbugs/bug229.go               |    8 +-
 test/fixedbugs/bug231.go               |   11 +-
 test/fixedbugs/bug232.go               |    3 +-
 test/fixedbugs/bug233.go               |    2 -
 test/fixedbugs/bug235.go               |    1 +
 test/fixedbugs/bug237.go               |    1 -
 test/fixedbugs/bug238.go               |    1 +
 test/fixedbugs/bug240.go               |    2 +-
 test/fixedbugs/bug241.go               |    2 +-
 test/fixedbugs/bug245.go               |    1 -
 test/fixedbugs/bug249.go               |   62 +-
 test/fixedbugs/bug251.go               |    1 +
 test/fixedbugs/bug252.go               |    2 +-
 test/fixedbugs/bug256.go               |    6 +-
 test/fixedbugs/bug258.go               |    2 +-
 test/fixedbugs/bug259.go               |    2 +-
 test/fixedbugs/bug261.go               |    2 +-
 test/fixedbugs/bug266.go               |    4 +-
 test/fixedbugs/bug269.go               |    4 +-
 test/fixedbugs/bug271.go               |    2 +-
 test/fixedbugs/bug272.go               |    6 +-
 test/fixedbugs/bug276.go               |    6 +-
 test/fixedbugs/bug277.go               |    2 +-
 test/fixedbugs/bug278.go               |    8 +-
 test/fixedbugs/bug279.go               |    3 +-
 test/fixedbugs/bug280.go               |    4 +-
 test/fixedbugs/bug281.go               |    8 +-
 test/fixedbugs/bug282.dir/p1.go        |    1 +
 test/fixedbugs/bug282.dir/p2.go        |    1 +
 test/fixedbugs/bug284.go               |    2 +-
 test/fixedbugs/bug285.go               |    4 +-
 test/fixedbugs/bug287.go               |    2 +-
 test/fixedbugs/bug289.go               |    6 +-
 test/fixedbugs/bug290.go               |    4 +-
 test/fixedbugs/bug293.go               |    4 +-
 test/fixedbugs/bug294.go               |    1 +
 test/fixedbugs/bug295.go               |    4 +-
 test/fixedbugs/bug297.go               |    5 +-
 test/fixedbugs/bug302.dir/main.go      |    1 +
 test/fixedbugs/bug302.dir/p.go         | 1998 ++++++++++++------------
 test/fixedbugs/bug304.go               |    4 +-
 test/fixedbugs/bug306.dir/p1.go        |    2 +-
 test/fixedbugs/bug306.dir/p2.go        |    1 +
 test/fixedbugs/bug311.go               |    4 +-
 test/fixedbugs/bug314.go               |    5 +-
 test/fixedbugs/bug317.go               |    2 +-
 test/fixedbugs/bug319.go               |    2 +-
 test/fixedbugs/bug320.go               |    1 +
 test/fixedbugs/bug322.dir/lib.go       |    2 +-
 test/fixedbugs/bug322.dir/main.go      |    2 +-
 test/fixedbugs/bug324.dir/prog.go      |    9 +-
 test/fixedbugs/bug325.go               |    4 +-
 test/fixedbugs/bug330.go               |    4 +-
 test/fixedbugs/bug332.go               |    2 +-
 test/fixedbugs/bug333.go               |    6 +-
 test/fixedbugs/bug337.go               |    5 +-
 test/fixedbugs/bug341.go               |    1 -
 test/fixedbugs/bug343.go               |   18 +-
 test/fixedbugs/bug344.go               |    4 +-
 test/fixedbugs/bug347.go               |    4 +-
 test/fixedbugs/bug348.go               |    6 +-
 test/fixedbugs/bug356.go               |   13 +-
 test/fixedbugs/bug357.go               |    2 +-
 test/fixedbugs/bug361.go               |    2 +-
 test/fixedbugs/bug362.go               |    6 +-
 test/fixedbugs/bug363.go               |    8 +-
 test/fixedbugs/bug364.go               |    2 +-
 test/fixedbugs/bug366.go               |   40 +-
 test/fixedbugs/bug368.go               |    2 +-
 test/fixedbugs/bug369.dir/pkg.go       |    1 +
 test/fixedbugs/bug372.go               |    4 +-
 test/fixedbugs/bug373.go               |    2 +-
 test/fixedbugs/bug374.go               |    4 +-
 test/fixedbugs/bug376.go               |    4 +-
 test/fixedbugs/bug377.dir/one.go       |    1 +
 test/fixedbugs/bug377.dir/two.go       |    1 +
 test/fixedbugs/bug378.go               |    5 +-
 test/fixedbugs/bug379.go               |    2 +-
 test/fixedbugs/bug380.go               |    2 -
 test/fixedbugs/bug381.go               |    2 +-
 test/fixedbugs/bug382.dir/pkg.go       |    4 +-
 test/fixedbugs/bug383.go               |    7 +-
 test/fixedbugs/bug384.go               |    2 +-
 test/fixedbugs/bug385_32.go            |    3 +-
 test/fixedbugs/bug385_64.go            |  620 +++-----
 test/fixedbugs/bug386.go               |    4 +-
 test/fixedbugs/bug387.go               |   15 +-
 test/fixedbugs/bug389.go               |    2 +-
 test/fixedbugs/bug391.go               |    7 +-
 test/fixedbugs/bug392.dir/one.go       |   13 +-
 test/fixedbugs/bug396.dir/one.go       |    2 +-
 test/fixedbugs/bug396.dir/two.go       |    2 +-
 test/fixedbugs/bug397.go               |    6 +-
 test/fixedbugs/bug398.go               |   12 +-
 test/fixedbugs/bug399.go               |    2 +-
 test/fixedbugs/bug405.go               |    2 +-
 test/fixedbugs/bug407.dir/one.go       |    5 +-
 test/fixedbugs/bug410.go               |   18 +-
 test/fixedbugs/bug411.go               |    3 +-
 test/fixedbugs/bug412.go               |    6 +-
 test/fixedbugs/bug413.go               |    2 +-
 test/fixedbugs/bug415.dir/p.go         |    5 +-
 test/fixedbugs/bug415.dir/prog.go      |    4 +-
 test/fixedbugs/bug417.go               |   16 +-
 test/fixedbugs/bug420.go               |    2 +-
 test/fixedbugs/bug421.go               |    4 +-
 test/fixedbugs/bug424.dir/main.go      |    6 +-
 test/fixedbugs/bug424.go               |    1 +
 test/fixedbugs/bug425.go               |    2 +-
 test/fixedbugs/bug427.go               |    4 +-
 test/fixedbugs/bug439.go               |    2 +-
 test/fixedbugs/bug441.go               |    6 +-
 test/fixedbugs/bug442.go               |    2 +-
 test/fixedbugs/bug443.go               |    4 +-
 test/fixedbugs/bug444.go               |    8 +-
 test/fixedbugs/bug446.go               |    1 +
 test/fixedbugs/bug447.go               |   10 +-
 test/fixedbugs/bug448.dir/pkg2.go      |    1 +
 test/fixedbugs/bug460.go               |    1 +
 test/fixedbugs/bug462.go               |    2 +-
 test/fixedbugs/bug466.dir/a.go         |    2 +-
 test/fixedbugs/bug466.go               |    1 +
 test/fixedbugs/bug468.dir/p1.go        |    2 +-
 test/fixedbugs/bug468.dir/p2.go        |    2 +-
 test/fixedbugs/bug470.go               |    4 +-
 test/fixedbugs/bug479.dir/a.go         |    2 +-
 test/fixedbugs/bug480.dir/a.go         |    2 +-
 test/fixedbugs/bug486.go               |    2 +-
 test/fixedbugs/bug487.go               |    6 +-
 test/fixedbugs/bug488.dir/a.go         |    2 +-
 test/fixedbugs/bug490.go               |    2 +-
 test/fixedbugs/bug491.go               |    2 +-
 test/fixedbugs/bug500.go               |    2 +-
 test/fixedbugs/gcc61264.go             |    2 +-
 test/fixedbugs/gcc67968.dir/b.go       |    6 +-
 test/fixedbugs/issue10607a.go          |    2 +-
 test/fixedbugs/issue11326.go           |   16 +-
 test/fixedbugs/issue11361.go           |    2 +-
 test/fixedbugs/issue11362.go           |    1 +
 test/fixedbugs/issue12677.dir/p.go     |    3 +-
 test/fixedbugs/issue12677.dir/q.go     |    2 -
 test/fixedbugs/issue13261.go           |   24 +-
 test/fixedbugs/issue13265.go           |    6 +-
 test/fixedbugs/issue13337.go           |    1 -
 test/fixedbugs/issue13415.go           |   12 +-
 test/fixedbugs/issue13485.go           |    2 +-
 test/fixedbugs/issue14136.go           |    2 +-
 test/fixedbugs/issue14321.go           |    4 +-
 test/fixedbugs/issue14540.go           |    5 +-
 test/fixedbugs/issue14651.go           |    6 +-
 test/fixedbugs/issue14729.go           |    4 +-
 test/fixedbugs/issue15039.go           |    2 +-
 test/fixedbugs/issue15042.go           |    2 +-
 test/fixedbugs/issue15311.go           |    8 +-
 test/fixedbugs/issue15439.go           |    4 +-
 test/fixedbugs/issue15470.dir/a.go     |    6 +-
 test/fixedbugs/issue15548.dir/c.go     |    2 +-
 test/fixedbugs/issue15646.go           |    2 +-
 test/fixedbugs/issue15926.go           |    2 +-
 test/fixedbugs/issue16515.go           |    5 +-
 test/fixedbugs/issue16948.go           |    1 -
 test/fixedbugs/issue17449.go           |   16 +-
 test/fixedbugs/issue17588.go           |    8 +-
 test/fixedbugs/issue17645.go           |    3 +-
 test/fixedbugs/issue18231.go           |    2 +-
 test/fixedbugs/issue18808.go           |    8 +-
 test/fixedbugs/issue19028.dir/main.go  |   16 +-
 test/fixedbugs/issue19515.go           |    1 +
 test/fixedbugs/issue19764.dir/a.go     |    3 +-
 test/fixedbugs/issue20602.go           |    4 +-
 test/fixedbugs/issue20811.go           |    1 +
 test/fixedbugs/issue22429.go           |    4 +-
 test/fixedbugs/issue22458.go           |   12 +-
 test/fixedbugs/issue22662.go           |   20 +-
 test/fixedbugs/issue24339.go           |   10 +-
 test/fixedbugs/issue24799.go           |   42 +-
 test/fixedbugs/issue25727.go           |    8 +-
 test/fixedbugs/issue26335.go           |    2 +-
 test/fixedbugs/issue26340.go           |    6 +-
 test/fixedbugs/issue26407.go           |    2 +-
 test/fixedbugs/issue27278.go           |    2 +-
 test/fixedbugs/issue27356.go           |    5 +-
 test/fixedbugs/issue29215.go           |   16 +-
 test/fixedbugs/issue29402.go           |    2 +-
 test/fixedbugs/issue31747.go           |    8 +-
 test/fixedbugs/issue3552.dir/one.go    |   11 +-
 test/fixedbugs/issue3783.go            |    1 +
 test/fixedbugs/issue3925.go            |    3 +-
 test/fixedbugs/issue4097.go            |    2 +-
 test/fixedbugs/issue4099.go            |    2 +-
 test/fixedbugs/issue4162.go            |    8 +-
 test/fixedbugs/issue4251.go            |    6 +-
 test/fixedbugs/issue4264.go            |    8 +-
 test/fixedbugs/issue4283.go            |    4 +-
 test/fixedbugs/issue4313.go            |    5 +-
 test/fixedbugs/issue4326.dir/q1.go     |    8 +-
 test/fixedbugs/issue4326.dir/q2.go     |   10 +-
 test/fixedbugs/issue4365.go            |    8 +-
 test/fixedbugs/issue4396a.go           |    2 +-
 test/fixedbugs/issue4396b.go           |    2 +-
 test/fixedbugs/issue4429.go            |    6 +-
 test/fixedbugs/issue4463.go            |   66 +-
 test/fixedbugs/issue4470.go            |    2 +-
 test/fixedbugs/issue4495.go            |    1 +
 test/fixedbugs/issue4562.go            |    2 +-
 test/fixedbugs/issue4610.go            |    1 +
 test/fixedbugs/issue4618.go            |    2 +-
 test/fixedbugs/issue4620.go            |    2 +-
 test/fixedbugs/issue4654.go            |   82 +-
 test/fixedbugs/issue4663.go            |    4 +-
 test/fixedbugs/issue4748.go            |    8 +-
 test/fixedbugs/issue4879.dir/a.go      |    1 +
 test/fixedbugs/issue4879.dir/b.go      |    6 +-
 test/fixedbugs/issue5056.go            |    4 +-
 test/fixedbugs/issue5172.go            |    4 +-
 test/fixedbugs/issue5493.go            |    2 +-
 test/fixedbugs/issue5515.go            |   18 +-
 test/fixedbugs/issue5614.dir/x.go      |    2 +
 test/fixedbugs/issue5753.go            |    2 +-
 test/fixedbugs/issue5809.go            |    6 +-
 test/fixedbugs/issue5957.dir/b.go      |    1 +
 test/fixedbugs/issue5957.dir/c.go      |   10 +-
 test/fixedbugs/issue6004.go            |    7 +-
 test/fixedbugs/issue6406.go            |    2 +-
 test/fixedbugs/issue6703g.go           |    2 +-
 test/fixedbugs/issue6703h.go           |    2 +-
 test/fixedbugs/issue6703i.go           |    2 +-
 test/fixedbugs/issue6703o.go           |    2 +-
 test/fixedbugs/issue6703p.go           |    2 +-
 test/fixedbugs/issue6703q.go           |    2 +-
 test/fixedbugs/issue6703r.go           |    2 +-
 test/fixedbugs/issue6703y.go           |    2 +-
 test/fixedbugs/issue6703z.go           |    2 +-
 test/fixedbugs/issue6789.dir/a.go      |    6 +-
 test/fixedbugs/issue6847.go            |    2 +-
 test/fixedbugs/issue7223.go            |    7 +-
 test/fixedbugs/issue7310.go            |    2 +-
 test/fixedbugs/issue7550.go            |   20 +-
 test/fixedbugs/issue7590.go            |    2 +-
 test/fixedbugs/issue7648.dir/a.go      |    3 +-
 test/fixedbugs/issue7760.go            |    6 +-
 test/fixedbugs/issue7921.go            |    2 +-
 test/fixedbugs/issue8155.go            |    2 +-
 test/fixedbugs/issue8961.go            |    3 +-
 test/fixedbugs/issue9076.go            |    3 +-
 test/fixedbugs/issue9083.go            |   10 +-
 test/fixedbugs/issue9537.dir/b.go      |    4 +-
 test/fixedbugs/issue9634.go            |    2 +-
 test/float_lit.go                      |   48 +-
 test/for.go                            |    4 +-
 test/func.go                           |    3 +
 test/func1.go                          |    1 +
 test/func4.go                          |    4 +-
 test/func5.go                          |    4 +-
 test/func6.go                          |   10 +-
 test/funcdup.go                        |   20 +-
 test/funcdup2.go                       |    8 +-
 test/gcstring.go                       |    9 +-
 test/goprint.go                        |    2 +-
 test/import1.go                        |   10 +-
 test/import2.dir/import2.go            |   61 +-
 test/import2.dir/import3.go            |   25 +-
 test/import4.dir/empty.go              |   11 +-
 test/import4.dir/import4.go            |   13 +-
 test/indirect1.go                      |   52 +-
 test/initcomma.go                      |    8 +-
 test/initialize.go                     |   38 +-
 test/initializerr.go                   |   22 +-
 test/inline_sync.go                    |   13 +-
 test/int_lit.go                        |    6 +-
 test/intcvt.go                         |    2 +-
 test/interface/bigdata.go              |   34 +-
 test/interface/convert1.go             |    9 +-
 test/interface/convert2.go             |    9 +-
 test/interface/embed.go                |    9 +-
 test/interface/embed1.dir/embed0.go    |    5 +-
 test/interface/embed1.dir/embed1.go    |    9 +-
 test/interface/pointer.go              |    3 +-
 test/interface/private.dir/private1.go |    1 +
 test/interface/private.dir/prog.go     |    6 +-
 test/interface/recursive.go            |    1 -
 test/interface/returntype.go           |   10 +-
 test/interface/struct.go               |   36 +-
 test/iota.go                           |    6 +-
 test/ken/complit.go                    |  181 +--
 test/ken/convert.go                    |  689 +++-----
 test/ken/cplx2.go                      |    4 +-
 test/ken/cplx3.go                      |    4 +-
 test/ken/embed.go                      |    1 +
 test/ken/for.go                        |   13 +-
 test/ken/interfun.go                   |   67 +-
 test/ken/intervar.go                   |   53 +-
 test/ken/litfun.go                     |   25 +-
 test/ken/mfunc.go                      |   16 +-
 test/ken/ptrfun.go                     |   51 +-
 test/ken/ptrvar.go                     |   79 +-
 test/ken/robfor.go                     |   44 +-
 test/ken/robfunc.go                    |    3 +
 test/ken/shift.go                      |  168 +-
 test/ken/simparray.go                  |   51 +-
 test/ken/simpbool.go                   |  257 +--
 test/ken/simpfun.go                    |   24 +-
 test/ken/simpvar.go                    |   24 +-
 test/ken/strvar.go                     |  124 +-
 test/literal2.go                       |    4 +-
 test/live1.go                          |    1 +
 test/live_syscall.go                   |    2 +-
 test/map1.go                           |   18 +-
 test/method5.go                        |   44 +-
 test/named.go                          |    1 +
 test/nilptr2.go                        |   10 +-
 test/oldescape2.go                     |   42 +-
 test/oldescape2n.go                    |   42 +-
 test/oldescape5.go                     |    6 +-
 test/oldescape_field.go                |    8 +-
 test/oldescape_iface.go                |   32 +-
 test/oldescape_param.go                |   52 +-
 test/parentype.go                      |   10 +-
 test/printbig.go                       |    2 +-
 test/recover1.go                       |   14 +-
 test/return.go                         |  284 ++--
 test/rune.go                           |   20 +-
 test/runtime.go                        |    2 +-
 test/shift1.go                         |   12 +-
 test/stack.go                          |    2 +-
 test/switch5.go                        |    2 +-
 test/switch7.go                        |    1 +
 test/tinyfin.go                        |    2 +-
 test/typecheck.go                      |    8 +-
 test/typeswitch2.go                    |    2 +-
 test/undef.go                          |   14 +-
 test/varerr.go                         |    5 +-
 547 files changed, 4187 insertions(+), 4886 deletions(-)

diff --git a/test/235.go b/test/235.go
index a62d384a65..6745dde41a 100644
--- a/test/235.go
+++ b/test/235.go
@@ -16,12 +16,13 @@ func M(f uint64) (in, out T) {
 	out = make(T, 100)
 	go func(in, out T, f uint64) {
 		for {
-			out <- f * <-in
+			out <- f*<-in
 		}
 	}(in, out, f)
 	return in, out
 }
 
+
 func min(xs []uint64) uint64 {
 	m := xs[0]
 	for i := 1; i < len(xs); i++ {
@@ -32,6 +33,7 @@ func min(xs []uint64) uint64 {
 	return m
 }
 
+
 func main() {
 	F := []uint64{2, 3, 5}
 	var n = len(F)
diff --git a/test/64bit.go b/test/64bit.go
index 9eaac1409a..d99d8e83f0 100644
--- a/test/64bit.go
+++ b/test/64bit.go
@@ -25,13 +25,13 @@ var bout *bufio.Writer
 // if the compiler has buggy or missing 64-bit support.
 
 type Uint64 struct {
-	hi uint32
-	lo uint32
+	hi	uint32
+	lo	uint32
 }
 
 type Int64 struct {
-	hi int32
-	lo uint32
+	hi	int32
+	lo	uint32
 }
 
 func (a Uint64) Int64() (c Int64) {
@@ -170,7 +170,7 @@ func (a Uint64) DivMod(b Uint64) (quo, rem Uint64) {
 		b = b.LeftShift(uint(n))
 		for i := 0; i <= n; i++ {
 			quo = quo.LeftShift(1)
-			if b.Cmp(a) <= 0 { // b <= a
+			if b.Cmp(a) <= 0 {	// b <= a
 				quo.lo |= 1
 				a = a.Minus(b)
 			}
@@ -205,7 +205,7 @@ func (a Uint64) Xor(b Uint64) (c Uint64) {
 	return
 }
 
-func (a Uint64) String() string { return fmt.Sprintf("%#x%08x", a.hi, a.lo) }
+func (a Uint64) String() string	{ return fmt.Sprintf("%#x%08x", a.hi, a.lo) }
 
 func (a Int64) Uint64() (c Uint64) {
 	c.hi = uint32(a.hi)
@@ -230,15 +230,15 @@ func (a Int64) Cmp(b Int64) int {
 	return 0
 }
 
-func (a Int64) LeftShift(b uint) (c Int64) { return a.Uint64().LeftShift(b).Int64() }
+func (a Int64) LeftShift(b uint) (c Int64)	{ return a.Uint64().LeftShift(b).Int64() }
 
 func (a Int64) RightShift(b uint) (c Int64) {
 	switch {
 	case b >= 64:
-		c.hi = a.hi >> 31 // sign extend
+		c.hi = a.hi >> 31	// sign extend
 		c.lo = uint32(c.hi)
 	case b >= 32:
-		c.hi = a.hi >> 31 // sign extend
+		c.hi = a.hi >> 31	// sign extend
 		c.lo = uint32(a.hi >> (b - 32))
 	default:
 		c.hi = a.hi >> b
@@ -261,15 +261,15 @@ func (a Int64) RightShift64(b Uint64) (c Int64) {
 	return a.RightShift(uint(b.lo))
 }
 
-func (a Int64) Plus(b Int64) (c Int64) { return a.Uint64().Plus(b.Uint64()).Int64() }
+func (a Int64) Plus(b Int64) (c Int64)	{ return a.Uint64().Plus(b.Uint64()).Int64() }
 
-func (a Int64) Minus(b Int64) (c Int64) { return a.Uint64().Minus(b.Uint64()).Int64() }
+func (a Int64) Minus(b Int64) (c Int64)	{ return a.Uint64().Minus(b.Uint64()).Int64() }
 
-func (a Int64) Neg() (c Int64) { return a.Uint64().Neg().Int64() }
+func (a Int64) Neg() (c Int64)	{ return a.Uint64().Neg().Int64() }
 
-func (a Int64) Com() (c Int64) { return a.Uint64().Com().Int64() }
+func (a Int64) Com() (c Int64)	{ return a.Uint64().Com().Int64() }
 
-func (a Int64) Times(b Int64) (c Int64) { return a.Uint64().Times(b.Uint64()).Int64() }
+func (a Int64) Times(b Int64) (c Int64)	{ return a.Uint64().Times(b.Uint64()).Int64() }
 
 func (a Int64) DivMod(b Int64) (quo Int64, rem Int64) {
 	var zero Int64
@@ -299,13 +299,13 @@ func (a Int64) DivMod(b Int64) (quo Int64, rem Int64) {
 	return
 }
 
-func (a Int64) And(b Int64) (c Int64) { return a.Uint64().And(b.Uint64()).Int64() }
+func (a Int64) And(b Int64) (c Int64)	{ return a.Uint64().And(b.Uint64()).Int64() }
 
-func (a Int64) AndNot(b Int64) (c Int64) { return a.Uint64().AndNot(b.Uint64()).Int64() }
+func (a Int64) AndNot(b Int64) (c Int64)	{ return a.Uint64().AndNot(b.Uint64()).Int64() }
 
-func (a Int64) Or(b Int64) (c Int64) { return a.Uint64().Or(b.Uint64()).Int64() }
+func (a Int64) Or(b Int64) (c Int64)	{ return a.Uint64().Or(b.Uint64()).Int64() }
 
-func (a Int64) Xor(b Int64) (c Int64) { return a.Uint64().Xor(b.Uint64()).Int64() }
+func (a Int64) Xor(b Int64) (c Int64)	{ return a.Uint64().Xor(b.Uint64()).Int64() }
 
 func (a Int64) String() string {
 	if a.hi < 0 {
@@ -514,11 +514,11 @@ func varTests() {
 			var div, mod Int64
 			dodiv := false
 			var zero Int64
-			if b.Cmp(zero) != 0 { // b != 0
+			if b.Cmp(zero) != 0 {	// b != 0
 				// Can't divide by zero but also can't divide -0x8000...000 by -1.
 				var bigneg = Int64{-0x80000000, 0}
 				var minus1 = Int64{-1, ^uint32(0)}
-				if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 { // a != -1<<63 || b != -1
+				if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 {	// a != -1<<63 || b != -1
 					div, mod = a.DivMod(b)
 					dodiv = true
 				}
@@ -542,7 +542,7 @@ func varTests() {
 			var div, mod Uint64
 			dodiv := false
 			var zero Uint64
-			if b.Cmp(zero) != 0 { // b != 0
+			if b.Cmp(zero) != 0 {	// b != 0
 				div, mod = a.DivMod(b)
 				dodiv = true
 			}
@@ -661,11 +661,11 @@ func constTests() {
 			var div, mod Int64
 			dodiv := false
 			var zero Int64
-			if b.Cmp(zero) != 0 { // b != 0
+			if b.Cmp(zero) != 0 {	// b != 0
 				// Can't divide by zero but also can't divide -0x8000...000 by -1.
 				var bigneg = Int64{-0x80000000, 0}
 				var minus1 = Int64{-1, ^uint32(0)}
-				if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 { // a != -1<<63 || b != -1
+				if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 {	// a != -1<<63 || b != -1
 					div, mod = a.DivMod(b)
 					dodiv = true
 				}
@@ -692,7 +692,7 @@ func constTests() {
 			var div, mod Uint64
 			dodiv := false
 			var zero Uint64
-			if b.Cmp(zero) != 0 { // b != 0
+			if b.Cmp(zero) != 0 {	// b != 0
 				div, mod = a.DivMod(b)
 				dodiv = true
 			}
diff --git a/test/align.go b/test/align.go
index 6e33983275..61d07c49b8 100644
--- a/test/align.go
+++ b/test/align.go
@@ -13,7 +13,7 @@ package main
 // introduced by CL 102036.
 type T struct {
 	pad uint32
-	f   float64
+	f float64
 }
 
 //go:noinline
diff --git a/test/assign1.go b/test/assign1.go
index eabf10062d..b9e0325ce8 100644
--- a/test/assign1.go
+++ b/test/assign1.go
@@ -214,6 +214,7 @@ func main() {
 	ps1 = ps0 // ERROR "cannot use|incompatible"
 	ps1 = ps  // ERROR "cannot use|incompatible"
 
+
 	a0 = [10]int(a)
 	a0 = [10]int(a1)
 	a = A(a0)
@@ -235,8 +236,8 @@ func main() {
 	c1 = C1(c0)
 	c1 = C1(c)
 
-	f0 = (func() int)(f)
-	f0 = (func() int)(f1)
+	f0 = func() int(f)
+	f0 = func() int(f1)
 	f = F(f0)
 	f = F(f1)
 	f1 = F1(f0)
diff --git a/test/bigmap.go b/test/bigmap.go
index 77ff8243c5..c5e4f91e11 100644
--- a/test/bigmap.go
+++ b/test/bigmap.go
@@ -35,6 +35,7 @@ func main() {
 	cmp(m[1], seq(11, 13))
 	cmp(m[2], seq(2, 9))
 	cmp(m[3], seq(3, 17))
+	
 
 	{
 		type T [1]byte
@@ -46,7 +47,7 @@ func main() {
 			println(x, y)
 			panic("bad map")
 		}
-	}
+  	}
 	{
 		type T [100]byte
 		type V [1]byte
@@ -133,6 +134,6 @@ func main() {
 		if x, y := m[T{}][0], m[T{1}][0]; x != 1 || y != 2 {
 			println(x, y)
 			panic("bad map")
-		}
-	}
+  		}
+  	}
 }
diff --git a/test/blank1.go b/test/blank1.go
index a29992c367..bf94d1a0fb 100644
--- a/test/blank1.go
+++ b/test/blank1.go
@@ -7,7 +7,7 @@
 // Test that incorrect uses of the blank identifer are caught.
 // Does not compile.
 
-package _ // ERROR "invalid package name _"
+package _	// ERROR "invalid package name _"
 
 var t struct {
 	_ int
@@ -18,15 +18,15 @@ func (x int) _() { // ERROR "cannot define new methods on non-local type"
 }
 
 type T struct {
-	_ []int
+      _ []int
 }
 
 func main() {
-	_()        // ERROR "cannot use _ as value"
-	x := _ + 1 // ERROR "cannot use _ as value"
+	_()	// ERROR "cannot use _ as value"
+	x := _+1	// ERROR "cannot use _ as value"
 	_ = x
 	_ = t._ // ERROR "cannot refer to blank field|invalid use of"
 
-	var v1, v2 T
-	_ = v1 == v2 // ERROR "cannot be compared|non-comparable"
+      var v1, v2 T
+      _ = v1 == v2 // ERROR "cannot be compared|non-comparable"
 }
diff --git a/test/char_lit.go b/test/char_lit.go
index e452db952e..836c3c1a2d 100644
--- a/test/char_lit.go
+++ b/test/char_lit.go
@@ -11,7 +11,8 @@ package main
 import "os"
 
 func main() {
-	var i uint64 = ' ' +
+	var i uint64 =
+		' ' +
 		'a' +
 		'ä' +
 		'本' +
diff --git a/test/closedchan.go b/test/closedchan.go
index 5221d257b4..043a92d388 100644
--- a/test/closedchan.go
+++ b/test/closedchan.go
@@ -18,7 +18,7 @@ var failed bool
 type Chan interface {
 	Send(int)
 	Nbsend(int) bool
-	Recv() int
+	Recv() (int)
 	Nbrecv() (int, bool)
 	Recv2() (int, bool)
 	Nbrecv2() (int, bool, bool)
@@ -214,6 +214,7 @@ func (c SSChan) Impl() string {
 	return "(select)"
 }
 
+
 func shouldPanic(f func()) {
 	defer func() {
 		if recover() == nil {
@@ -317,13 +318,13 @@ func closedasync() chan int {
 	return c
 }
 
-var mks = []func(chan int) Chan{
+var mks = []func(chan int) Chan {
 	func(c chan int) Chan { return XChan(c) },
 	func(c chan int) Chan { return SChan(c) },
 	func(c chan int) Chan { return SSChan(c) },
 }
 
-var testcloseds = []func(Chan){
+var testcloseds = []func(Chan) {
 	testasync1,
 	testasync2,
 	testasync3,
@@ -334,18 +335,18 @@ func main() {
 	for _, mk := range mks {
 		test1(mk(closedsync()))
 	}
-
+	
 	for _, testclosed := range testcloseds {
 		for _, mk := range mks {
 			testclosed(mk(closedasync()))
 		}
 	}
-
-	var ch chan int
+	
+	var ch chan int	
 	shouldPanic(func() {
 		close(ch)
 	})
-
+	
 	ch = make(chan int)
 	close(ch)
 	shouldPanic(func() {
diff --git a/test/closure1.go b/test/closure1.go
index ff78f8af8f..586998203a 100644
--- a/test/closure1.go
+++ b/test/closure1.go
@@ -16,4 +16,4 @@ func main() {
 			panic("x != 1")
 		}
 	}()
-}
+}
\ No newline at end of file
diff --git a/test/closure2.go b/test/closure2.go
index 3254775fcc..4d61b45d3f 100644
--- a/test/closure2.go
+++ b/test/closure2.go
@@ -90,7 +90,7 @@ func main() {
 			q++
 			g = func() int {
 				return q // test that we capture by ref here
-				// q++ must on a different decldepth than q declaration
+					 // q++ must on a different decldepth than q declaration
 			}
 		}
 		if g() != 2 {
@@ -108,7 +108,7 @@ func main() {
 		}()] = range [2]int{} {
 			g = func() int {
 				return q // test that we capture by ref here
-				// q++ must on a different decldepth than q declaration
+					 // q++ must on a different decldepth than q declaration
 			}
 		}
 		if g() != 2 {
diff --git a/test/cmplxdivide1.go b/test/cmplxdivide1.go
index eac84d763d..a52fb6fbcf 100644
--- a/test/cmplxdivide1.go
+++ b/test/cmplxdivide1.go
@@ -6,9 +6,9 @@ package main
 import "math"
 
 var (
-	nan  = math.NaN()
-	inf  = math.Inf(1)
-	zero = 0.0
+	nan     = math.NaN()
+	inf     = math.Inf(1)
+	zero    = 0.0
 )
 
 var tests = []struct {
diff --git a/test/complit1.go b/test/complit1.go
index 3c01fe95cb..83695a9e88 100644
--- a/test/complit1.go
+++ b/test/complit1.go
@@ -53,13 +53,13 @@ var (
 type M map[T]T
 
 var (
-	_ = M{{i: 1}: {i: 2}}
-	_ = M{T{i: 1}: {i: 2}}
-	_ = M{{i: 1}: T{i: 2}}
-	_ = M{T{i: 1}: T{i: 2}}
+	_ = M{{i:1}: {i:2}}
+	_ = M{T{i:1}: {i:2}}
+	_ = M{{i:1}: T{i:2}}
+	_ = M{T{i:1}: T{i:2}}
 )
 
-type S struct{ s [1]*M1 }
+type S struct { s [1]*M1 }
 type M1 map[S]int
+var _ = M1{{s:[1]*M1{&M1{{}:1}}}:2}
 
-var _ = M1{{s: [1]*M1{&M1{{}: 1}}}: 2}
diff --git a/test/const1.go b/test/const1.go
index f393026a2a..3fd5b55522 100644
--- a/test/const1.go
+++ b/test/const1.go
@@ -87,8 +87,8 @@ func main() {
 	f(Bool)             // ERROR "convert|wrong type|cannot|incompatible"
 }
 
-const ptr = nil                                // ERROR "const.*nil"
-const _ = string([]byte(nil))                  // ERROR "is not a? ?constant"
+const ptr = nil // ERROR "const.*nil"
+const _ = string([]byte(nil)) // ERROR "is not a? ?constant"
 const _ = uintptr(unsafe.Pointer((*int)(nil))) // ERROR "is not a? ?constant"
-const _ = unsafe.Pointer((*int)(nil))          // ERROR "cannot be nil|invalid constant type|is not a constant"
-const _ = (*int)(nil)                          // ERROR "cannot be nil|invalid constant type|is not a constant"
+const _ = unsafe.Pointer((*int)(nil)) // ERROR "cannot be nil|invalid constant type|is not a constant"
+const _ = (*int)(nil) // ERROR "cannot be nil|invalid constant type|is not a constant"
diff --git a/test/const3.go b/test/const3.go
index 28cce0e6d6..3f4e3d1ae6 100644
--- a/test/const3.go
+++ b/test/const3.go
@@ -29,7 +29,7 @@ func main() {
 		panic("fail")
 	}
 	x := uint(5)
-	y := float64(uint64(1) << x) // used to fail to compile
+	y := float64(uint64(1)<<x)	// used to fail to compile
 	if y != 32 {
 		println("wrong y", y)
 		panic("fail")
diff --git a/test/const5.go b/test/const5.go
index 0f878dcd83..51e46cbb2f 100644
--- a/test/const5.go
+++ b/test/const5.go
@@ -9,7 +9,7 @@
 package p
 
 var b struct {
-	a [10]int
+	a[10]int
 }
 
 var m map[string][20]int
@@ -17,7 +17,6 @@ var m map[string][20]int
 var s [][30]int
 
 func f() *[40]int
-
 var c chan *[50]int
 var z complex128
 
@@ -26,12 +25,13 @@ const (
 	n2 = len(m[""])
 	n3 = len(s[10])
 
-	n4 = len(f()) // ERROR "is not a constant|is not constant"
+	n4 = len(f())  // ERROR "is not a constant|is not constant"
 	n5 = len(<-c) // ERROR "is not a constant|is not constant"
 
-	n6 = cap(f())                 // ERROR "is not a constant|is not constant"
-	n7 = cap(<-c)                 // ERROR "is not a constant|is not constant"
-	n8 = real(z)                  // ERROR "is not a constant|is not constant"
+	n6 = cap(f())  // ERROR "is not a constant|is not constant"
+	n7 = cap(<-c) // ERROR "is not a constant|is not constant"
+	n8 = real(z) // ERROR "is not a constant|is not constant"
 	n9 = len([4]float64{real(z)}) // ERROR "is not a constant|is not constant"
 
 )
+
diff --git a/test/const6.go b/test/const6.go
index 1484bc4b04..b340e589d5 100644
--- a/test/const6.go
+++ b/test/const6.go
@@ -12,19 +12,19 @@ type mybool bool
 type mybool1 bool
 
 var (
-	x, y int     = 1, 2
-	c1   bool    = x < y
-	c2   mybool  = x < y
-	c3   mybool  = c2 == (x < y)
-	c4   mybool  = c2 == (1 < 2)
-	c5   mybool  = 1 < 2
-	c6   mybool1 = x < y
-	c7           = c1 == c2 // ERROR "mismatched types|incompatible types"
-	c8           = c2 == c6 // ERROR "mismatched types|incompatible types"
-	c9           = c1 == c6 // ERROR "mismatched types|incompatible types"
-	_            = c2 && (x < y)
-	_            = c2 && (1 < 2)
-	_            = c1 && c2 // ERROR "mismatched types|incompatible types"
-	_            = c2 && c6 // ERROR "mismatched types|incompatible types"
-	_            = c1 && c6 // ERROR "mismatched types|incompatible types"
+	x, y int = 1, 2
+	c1 bool = x < y
+	c2 mybool = x < y
+	c3 mybool = c2 == (x < y)
+	c4 mybool = c2 == (1 < 2)
+	c5 mybool = 1 < 2
+	c6 mybool1 = x < y
+	c7 = c1 == c2 // ERROR "mismatched types|incompatible types"
+	c8 = c2 == c6 // ERROR "mismatched types|incompatible types"
+	c9 = c1 == c6 // ERROR "mismatched types|incompatible types"
+	_ = c2 && (x < y)
+	_ = c2 && (1 < 2)
+	_ = c1 && c2 // ERROR "mismatched types|incompatible types"
+	_ = c2 && c6 // ERROR "mismatched types|incompatible types"
+	_ = c1 && c6 // ERROR "mismatched types|incompatible types"
 )
diff --git a/test/convT2X.go b/test/convT2X.go
index 57fb50fe52..7e27f06b0c 100644
--- a/test/convT2X.go
+++ b/test/convT2X.go
@@ -84,8 +84,8 @@ var (
 	jb    J = b
 	jm    J = m
 	jc    J = c
-	jz    J = z
-	jp    J = p // The method set for *T contains the methods for T.
+	jz J = z
+	jp J = p // The method set for *T contains the methods for T.
 	// pp does not implement error.
 )
 
diff --git a/test/convlit1.go b/test/convlit1.go
index 18222d4eff..c06bd74438 100644
--- a/test/convlit1.go
+++ b/test/convlit1.go
@@ -9,12 +9,12 @@
 
 package main
 
-var a = []int{"a"} // ERROR "conver|incompatible|cannot"
-var b = int{1}     // ERROR "compos"
+var a = []int { "a" };	// ERROR "conver|incompatible|cannot"
+var b = int { 1 };	// ERROR "compos"
+
 
 func f() int
 
 func main() {
-	if f < 1 {
-	} // ERROR "conver|incompatible|invalid"
+	if f < 1 { }	// ERROR "conver|incompatible|invalid"
 }
diff --git a/test/ddd2.dir/ddd2.go b/test/ddd2.dir/ddd2.go
index 79d45337c8..f3f863c83f 100644
--- a/test/ddd2.dir/ddd2.go
+++ b/test/ddd2.dir/ddd2.go
@@ -13,3 +13,4 @@ func Sum(args ...int) int {
 	}
 	return s
 }
+
diff --git a/test/deferfin.go b/test/deferfin.go
index 6c75485cfa..80372916d2 100644
--- a/test/deferfin.go
+++ b/test/deferfin.go
@@ -60,3 +60,4 @@ func main() {
 		panic("not all finalizers are called")
 	}
 }
+
diff --git a/test/deferprint.go b/test/deferprint.go
index 6f0573e6de..b74677ac59 100644
--- a/test/deferprint.go
+++ b/test/deferprint.go
@@ -10,7 +10,7 @@ package main
 
 func main() {
 	defer println(42, true, false, true, 1.5, "world", (chan int)(nil), []int(nil), (map[string]int)(nil), (func())(nil), byte(255))
-	defer println(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
+	defer println(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)
 	// Disabled so the test doesn't crash but left here for reference.
 	// defer panic("dead")
 	defer print("printing: ")
diff --git a/test/divmod.go b/test/divmod.go
index 52a8a73eda..ab85b7f149 100644
--- a/test/divmod.go
+++ b/test/divmod.go
@@ -103,7 +103,8 @@ func checkdiv3(x, y uint64) {
 	if (uint64(uint8(x)) == x || uint64(uint8(^x)) == ^x) && (uint64(uint8(y)) == y || uint64(uint8(^y)) == ^y) {
 		checkuint8(uint8(x), uint8(y))
 	}
-
+	
+	
 	sx := int64(x)
 	sy := int64(y)
 	checkint64(sx, sy)
@@ -127,8 +128,8 @@ func checkuint(x, y uint) {
 		return
 	}
 	q, r := udiv(uint64(x), uint64(y))
-	q1 := x / y
-	r1 := x % y
+	q1 := x/y
+	r1 := x%y
 	if q1 != uint(q) {
 		print("uint(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -144,8 +145,8 @@ func checkuint64(x, y uint64) {
 		return
 	}
 	q, r := udiv(x, y)
-	q1 := x / y
-	r1 := x % y
+	q1 := x/y
+	r1 := x%y
 	if q1 != q {
 		print("uint64(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -161,8 +162,8 @@ func checkuint32(x, y uint32) {
 		return
 	}
 	q, r := udiv(uint64(x), uint64(y))
-	q1 := x / y
-	r1 := x % y
+	q1 := x/y
+	r1 := x%y
 	if q1 != uint32(q) {
 		print("uint32(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -178,8 +179,8 @@ func checkuint16(x, y uint16) {
 		return
 	}
 	q, r := udiv(uint64(x), uint64(y))
-	q1 := x / y
-	r1 := x % y
+	q1 := x/y
+	r1 := x%y
 	if q1 != uint16(q) {
 		print("uint16(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -195,8 +196,8 @@ func checkuint8(x, y uint8) {
 		return
 	}
 	q, r := udiv(uint64(x), uint64(y))
-	q1 := x / y
-	r1 := x % y
+	q1 := x/y
+	r1 := x%y
 	if q1 != uint8(q) {
 		print("uint8(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -212,8 +213,8 @@ func checkint(x, y int) {
 		return
 	}
 	q, r := idiv(int64(x), int64(y))
-	q1 := x / y
-	r1 := x % y
+	q1 := x/y
+	r1 := x%y
 	if q1 != int(q) {
 		print("int(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -229,8 +230,8 @@ func checkint64(x, y int64) {
 		return
 	}
 	q, r := idiv(x, y)
-	q1 := x / y
-	r1 := x % y
+	q1 := x/y
+	r1 := x%y
 	if q1 != q {
 		print("int64(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -246,8 +247,8 @@ func checkint32(x, y int32) {
 		return
 	}
 	q, r := idiv(int64(x), int64(y))
-	q1 := x / y
-	r1 := x % y
+	q1 := x/y
+	r1 := x%y
 	if q1 != int32(q) {
 		print("int32(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -263,8 +264,8 @@ func checkint16(x, y int16) {
 		return
 	}
 	q, r := idiv(int64(x), int64(y))
-	q1 := x / y
-	r1 := x % y
+	q1 := x/y
+	r1 := x%y
 	if q1 != int16(q) {
 		print("int16(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -280,8 +281,8 @@ func checkint8(x, y int8) {
 		return
 	}
 	q, r := idiv(int64(x), int64(y))
-	q1 := x / y
-	r1 := x % y
+	q1 := x/y
+	r1 := x%y
 	if q1 != int8(q) {
 		print("int8(", x, "/", y, ") = ", q1, ", want ", q, "\n")
 	}
@@ -429,7 +430,7 @@ func udiv(x, y uint64) (q, r uint64) {
 		}
 		y >>= 1
 	}
-	return q, x
+	return q, x	
 }
 
 // signed divide and mod: do unsigned and adjust signs.
diff --git a/test/dwarf/dwarf.dir/main.go b/test/dwarf/dwarf.dir/main.go
index 732be1c180..175a09c779 100644
--- a/test/dwarf/dwarf.dir/main.go
+++ b/test/dwarf/dwarf.dir/main.go
@@ -8,26 +8,25 @@
 // license that can be found in the LICENSE file.
 
 package main
-
 func main() {
-	F1()
-	F2()
-	F3()
-	F4()
-	F5()
-	F6()
-	F7()
-	F8()
-	F9()
-	F10()
-	F11()
-	F12()
-	F13()
-	F14()
-	F15()
-	F16()
-	F17()
-	F18()
-	F19()
-	F20()
+F1()
+F2()
+F3()
+F4()
+F5()
+F6()
+F7()
+F8()
+F9()
+F10()
+F11()
+F12()
+F13()
+F14()
+F15()
+F16()
+F17()
+F18()
+F19()
+F20()
 }
diff --git a/test/dwarf/dwarf.dir/z1.go b/test/dwarf/dwarf.dir/z1.go
index 1cda10aa65..7f163e9a1d 100644
--- a/test/dwarf/dwarf.dir/z1.go
+++ b/test/dwarf/dwarf.dir/z1.go
@@ -1,4 +1,5 @@
+
+
 //line x1.go:4
 package main
-
 func F1() {}
diff --git a/test/dwarf/dwarf.dir/z10.go b/test/dwarf/dwarf.dir/z10.go
index 1217cbffd8..19c70020e0 100644
--- a/test/dwarf/dwarf.dir/z10.go
+++ b/test/dwarf/dwarf.dir/z10.go
@@ -1,4 +1,6 @@
+
+
+
 //line x10.go:4
 package main
-
 func F10() {}
diff --git a/test/dwarf/dwarf.dir/z11.go b/test/dwarf/dwarf.dir/z11.go
index c0350e2e9d..c1d2f9180f 100644
--- a/test/dwarf/dwarf.dir/z11.go
+++ b/test/dwarf/dwarf.dir/z11.go
@@ -1,4 +1,4 @@
+
 //line x11.go:4
 package main
-
 func F11() {}
diff --git a/test/dwarf/dwarf.dir/z12.go b/test/dwarf/dwarf.dir/z12.go
index 07d8fde60f..7455f18946 100644
--- a/test/dwarf/dwarf.dir/z12.go
+++ b/test/dwarf/dwarf.dir/z12.go
@@ -1,4 +1,4 @@
+
 //line x12.go:4
 package main
-
 func F12() {}
diff --git a/test/dwarf/dwarf.dir/z13.go b/test/dwarf/dwarf.dir/z13.go
index 2986c6ba1a..ecb3c4c8c7 100644
--- a/test/dwarf/dwarf.dir/z13.go
+++ b/test/dwarf/dwarf.dir/z13.go
@@ -1,4 +1,4 @@
+
 //line x13.go:4
 package main
-
 func F13() {}
diff --git a/test/dwarf/dwarf.dir/z14.go b/test/dwarf/dwarf.dir/z14.go
index 742e1eecf1..134b39b64e 100644
--- a/test/dwarf/dwarf.dir/z14.go
+++ b/test/dwarf/dwarf.dir/z14.go
@@ -1,4 +1,4 @@
+
 //line x14.go:4
 package main
-
 func F14() {}
diff --git a/test/dwarf/dwarf.dir/z15.go b/test/dwarf/dwarf.dir/z15.go
index 971ad7e8bf..d73819b443 100644
--- a/test/dwarf/dwarf.dir/z15.go
+++ b/test/dwarf/dwarf.dir/z15.go
@@ -1,4 +1,4 @@
+
 //line x15.go:4
 package main
-
 func F15() {}
diff --git a/test/dwarf/dwarf.dir/z16.go b/test/dwarf/dwarf.dir/z16.go
index 3a00057740..6c31651baa 100644
--- a/test/dwarf/dwarf.dir/z16.go
+++ b/test/dwarf/dwarf.dir/z16.go
@@ -1,4 +1,4 @@
+
 //line x16.go:4
 package main
-
 func F16() {}
diff --git a/test/dwarf/dwarf.dir/z17.go b/test/dwarf/dwarf.dir/z17.go
index d5fbd62531..b742d16726 100644
--- a/test/dwarf/dwarf.dir/z17.go
+++ b/test/dwarf/dwarf.dir/z17.go
@@ -1,4 +1,4 @@
+
 //line x17.go:4
 package main
-
 func F17() {}
diff --git a/test/dwarf/dwarf.dir/z18.go b/test/dwarf/dwarf.dir/z18.go
index 16750d9f37..84150ff0a3 100644
--- a/test/dwarf/dwarf.dir/z18.go
+++ b/test/dwarf/dwarf.dir/z18.go
@@ -1,4 +1,5 @@
+
+
 //line x18.go:4
 package main
-
 func F18() {}
diff --git a/test/dwarf/dwarf.dir/z19.go b/test/dwarf/dwarf.dir/z19.go
index ae57364790..bb2e296841 100644
--- a/test/dwarf/dwarf.dir/z19.go
+++ b/test/dwarf/dwarf.dir/z19.go
@@ -1,4 +1,4 @@
+
 //line x19.go:4
 package main
-
 func F19() {}
diff --git a/test/dwarf/dwarf.dir/z2.go b/test/dwarf/dwarf.dir/z2.go
index daba026c10..68bd58257d 100644
--- a/test/dwarf/dwarf.dir/z2.go
+++ b/test/dwarf/dwarf.dir/z2.go
@@ -1,4 +1,4 @@
+
 //line x2.go:4
 package main
-
 func F2() {}
diff --git a/test/dwarf/dwarf.dir/z20.go b/test/dwarf/dwarf.dir/z20.go
index 15ad35c3e7..03111e1845 100644
--- a/test/dwarf/dwarf.dir/z20.go
+++ b/test/dwarf/dwarf.dir/z20.go
@@ -1,4 +1,4 @@
+
 //line x20.go:4
 package main
-
 func F20() {}
diff --git a/test/dwarf/dwarf.dir/z3.go b/test/dwarf/dwarf.dir/z3.go
index 46f05b92ff..5e4ad3ae25 100644
--- a/test/dwarf/dwarf.dir/z3.go
+++ b/test/dwarf/dwarf.dir/z3.go
@@ -1,4 +1,4 @@
+
 //line x3.go:4
 package main
-
 func F3() {}
diff --git a/test/dwarf/dwarf.dir/z4.go b/test/dwarf/dwarf.dir/z4.go
index c3fd6e37b8..1f28465c57 100644
--- a/test/dwarf/dwarf.dir/z4.go
+++ b/test/dwarf/dwarf.dir/z4.go
@@ -1,4 +1,4 @@
+
 //line x4.go:4
 package main
-
 func F4() {}
diff --git a/test/dwarf/dwarf.dir/z5.go b/test/dwarf/dwarf.dir/z5.go
index 3b6f8b7a63..7f4eeb419a 100644
--- a/test/dwarf/dwarf.dir/z5.go
+++ b/test/dwarf/dwarf.dir/z5.go
@@ -1,4 +1,4 @@
+
 //line x5.go:4
 package main
-
 func F5() {}
diff --git a/test/dwarf/dwarf.dir/z6.go b/test/dwarf/dwarf.dir/z6.go
index d18a067aae..241791dff2 100644
--- a/test/dwarf/dwarf.dir/z6.go
+++ b/test/dwarf/dwarf.dir/z6.go
@@ -1,4 +1,4 @@
+
 //line x6.go:4
 package main
-
 func F6() {}
diff --git a/test/dwarf/dwarf.dir/z7.go b/test/dwarf/dwarf.dir/z7.go
index 10bc1a9e56..68c1ad0c24 100644
--- a/test/dwarf/dwarf.dir/z7.go
+++ b/test/dwarf/dwarf.dir/z7.go
@@ -1,4 +1,4 @@
+
 //line x7.go:4
 package main
-
 func F7() {}
diff --git a/test/dwarf/dwarf.dir/z8.go b/test/dwarf/dwarf.dir/z8.go
index 3b17a9d88b..16eed32a28 100644
--- a/test/dwarf/dwarf.dir/z8.go
+++ b/test/dwarf/dwarf.dir/z8.go
@@ -1,4 +1,4 @@
+
 //line x8.go:4
 package main
-
 func F8() {}
diff --git a/test/dwarf/dwarf.dir/z9.go b/test/dwarf/dwarf.dir/z9.go
index 3af6b317b5..cbb94b4d2b 100644
--- a/test/dwarf/dwarf.dir/z9.go
+++ b/test/dwarf/dwarf.dir/z9.go
@@ -1,4 +1,4 @@
+
 //line x9.go:4
 package main
-
 func F9() {}
diff --git a/test/dwarf/linedirectives.go b/test/dwarf/linedirectives.go
index 3fae427ac4..cc4ffb000f 100644
--- a/test/dwarf/linedirectives.go
+++ b/test/dwarf/linedirectives.go
@@ -6,9 +6,8 @@
 
 //line foo/bar.y:4
 package main
-
 //line foo/bar.y:60
-func main() {
+func main() { 
 //line foo/bar.y:297
 	f, l := 0, 0
 //line yacctab:1
@@ -72,7 +71,7 @@ func main() {
 //line foo/bar.y:272
 	if l == f {
 //line foo/bar.y:277
-		panic("aie!")
+	panic("aie!")
 //line foo/bar.y:281
 	}
 //line foo/bar.y:285
@@ -80,6 +79,5 @@ func main() {
 //line foo/bar.y:288
 //line foo/bar.y:290
 }
-
 //line foo/bar.y:293
 //line foo/bar.y:295
diff --git a/test/empty.go b/test/empty.go
index 8ac3907106..92a79a4e0d 100644
--- a/test/empty.go
+++ b/test/empty.go
@@ -9,10 +9,7 @@
 
 package P
 
-import ()
-
-const ()
-
-var ()
-
-type ()
+import ( )
+const ( )
+var ( )
+type ( )
diff --git a/test/eof.go b/test/eof.go
index b142dd83c9..d051f33bf7 100644
--- a/test/eof.go
+++ b/test/eof.go
@@ -9,4 +9,4 @@
 
 // No newline at the end of this file.
 
-package main
+package main
\ No newline at end of file
diff --git a/test/eof1.go b/test/eof1.go
index 192f207bfc..90792ca76e 100644
--- a/test/eof1.go
+++ b/test/eof1.go
@@ -9,4 +9,4 @@
 
 package eof1
 
-// No newline at the end of this comment.
+// No newline at the end of this comment.
\ No newline at end of file
diff --git a/test/escape2.go b/test/escape2.go
index 758da81a6d..f682621c25 100644
--- a/test/escape2.go
+++ b/test/escape2.go
@@ -146,13 +146,13 @@ func (b Bar) AlsoLeak() *int { // ERROR "leaking param: b to result ~r0 level=0$
 }
 
 func (b Bar) LeaksToo() *int { // ERROR "leaking param: b to result ~r0 level=0$"
-	v := 0 // ERROR "moved to heap: v$"
+	v := 0    // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
 
 func (b *Bar) LeaksABit() *int { // ERROR "leaking param: b to result ~r0 level=1$"
-	v := 0 // ERROR "moved to heap: v$"
+	v := 0    // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
@@ -522,7 +522,7 @@ func foo72a() {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
 		// escapes its scope
-		x := i // ERROR "moved to heap: x$"
+		x := i    // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return
@@ -531,7 +531,7 @@ func foo72a() {
 func foo72b() [10]*int {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
-		x := i // ERROR "moved to heap: x$"
+		x := i    // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return y
@@ -739,11 +739,11 @@ func tee(p *int) (x, y *int) { return p, p } // ERROR "leaking param: p to resul
 func noop(x, y *int) {} // ERROR "noop x does not escape$" "noop y does not escape$"
 
 func foo82() {
-	var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
+	var x, y, z int  // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
 	go noop(tee(&z))
 	go noop(&x, &y)
 	for {
-		var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
+		var u, v, w int     // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
 		defer noop(tee(&u))
 		defer noop(&v, &w)
 	}
@@ -916,10 +916,10 @@ func foo115(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$"
 
 func foo116(b bool) *int {
 	if b {
-		x := 1 // ERROR "moved to heap: x$"
+		x := 1    // ERROR "moved to heap: x$"
 		return &x
 	} else {
-		y := 1 // ERROR "moved to heap: y$"
+		y := 1    // ERROR "moved to heap: y$"
 		return &y
 	}
 	return nil
@@ -931,7 +931,7 @@ func foo117(unknown func(interface{})) { // ERROR "foo117 unknown does not escap
 }
 
 func foo118(unknown func(*int)) { // ERROR "foo118 unknown does not escape$"
-	x := 1 // ERROR "moved to heap: x$"
+	x := 1      // ERROR "moved to heap: x$"
 	unknown(&x)
 }
 
@@ -1185,7 +1185,7 @@ L1:
 func foo124(x **int) { // ERROR "foo124 x does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo124 func literal does not escape$"
+	func() {  // ERROR "foo124 func literal does not escape$"
 		*x = p
 	}()
 }
@@ -1193,7 +1193,7 @@ func foo124(x **int) { // ERROR "foo124 x does not escape$"
 func foo125(ch chan *int) { // ERROR "foo125 ch does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo125 func literal does not escape$"
+	func() {  // ERROR "foo125 func literal does not escape$"
 		ch <- p
 	}()
 }
@@ -1229,7 +1229,7 @@ func foo128() {
 func foo129() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo129 func literal does not escape$"
+	func() {  // ERROR "foo129 func literal does not escape$"
 		q := p
 		func() { // ERROR "foo129.func1 func literal does not escape$"
 			r := q
@@ -1281,7 +1281,7 @@ func foo134() {
 }
 
 func foo135() {
-	var i int // ERROR "moved to heap: i$"
+	var i int   // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1293,7 +1293,7 @@ func foo135() {
 }
 
 func foo136() {
-	var i int // ERROR "moved to heap: i$"
+	var i int   // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1307,7 +1307,7 @@ func foo136() {
 func foo137() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo137 func literal does not escape$"
+	func() {  // ERROR "foo137 func literal does not escape$"
 		q := p
 		go func() { // ERROR "func literal escapes to heap$"
 			r := q
@@ -1320,7 +1320,7 @@ func foo138() *byte {
 	type T struct {
 		x [1]byte
 	}
-	t := new(T) // ERROR "new\(T\) escapes to heap$"
+	t := new(T)    // ERROR "new\(T\) escapes to heap$"
 	return &t.x[0]
 }
 
@@ -1330,7 +1330,7 @@ func foo139() *byte {
 			y byte
 		}
 	}
-	t := new(T) // ERROR "new\(T\) escapes to heap$"
+	t := new(T)   // ERROR "new\(T\) escapes to heap$"
 	return &t.x.y
 }
 
@@ -1498,7 +1498,7 @@ func bar151() {
 }
 
 func bar151b() {
-	var a [10]int // ERROR "moved to heap: a$"
+	var a [10]int      // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8][0])
 }
@@ -1510,7 +1510,7 @@ func bar151c() {
 }
 
 func bar151d() {
-	var a [10]int // ERROR "moved to heap: a$"
+	var a [10]int        // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8:8][0])
 }
@@ -1534,7 +1534,7 @@ func NewV(u U) *V { // ERROR "leaking param: u$"
 }
 
 func foo152() {
-	a := "a" // ERROR "moved to heap: a$"
+	a := "a"   // ERROR "moved to heap: a$"
 	u := U{&a}
 	v := NewV(u)
 	println(v)
@@ -1642,7 +1642,7 @@ type StructWithString struct {
 // to just x, and thus &i looks escaping.
 func fieldFlowTracking() {
 	var x StructWithString
-	i := 0 // ERROR "moved to heap: i$"
+	i := 0     // ERROR "moved to heap: i$"
 	x.p = &i
 	sink = x.s // ERROR "x.s escapes to heap$"
 }
diff --git a/test/escape2n.go b/test/escape2n.go
index c6cf4b4e15..2fd26f7c5c 100644
--- a/test/escape2n.go
+++ b/test/escape2n.go
@@ -146,13 +146,13 @@ func (b Bar) AlsoLeak() *int { // ERROR "leaking param: b to result ~r0 level=0$
 }
 
 func (b Bar) LeaksToo() *int { // ERROR "leaking param: b to result ~r0 level=0$"
-	v := 0 // ERROR "moved to heap: v$"
+	v := 0    // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
 
 func (b *Bar) LeaksABit() *int { // ERROR "leaking param: b to result ~r0 level=1$"
-	v := 0 // ERROR "moved to heap: v$"
+	v := 0    // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
@@ -522,7 +522,7 @@ func foo72a() {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
 		// escapes its scope
-		x := i // ERROR "moved to heap: x$"
+		x := i    // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return
@@ -531,7 +531,7 @@ func foo72a() {
 func foo72b() [10]*int {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
-		x := i // ERROR "moved to heap: x$"
+		x := i    // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return y
@@ -739,11 +739,11 @@ func tee(p *int) (x, y *int) { return p, p } // ERROR "leaking param: p to resul
 func noop(x, y *int) {} // ERROR "noop x does not escape$" "noop y does not escape$"
 
 func foo82() {
-	var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
+	var x, y, z int  // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
 	go noop(tee(&z))
 	go noop(&x, &y)
 	for {
-		var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
+		var u, v, w int     // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
 		defer noop(tee(&u))
 		defer noop(&v, &w)
 	}
@@ -916,10 +916,10 @@ func foo115(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$"
 
 func foo116(b bool) *int {
 	if b {
-		x := 1 // ERROR "moved to heap: x$"
+		x := 1    // ERROR "moved to heap: x$"
 		return &x
 	} else {
-		y := 1 // ERROR "moved to heap: y$"
+		y := 1    // ERROR "moved to heap: y$"
 		return &y
 	}
 	return nil
@@ -931,7 +931,7 @@ func foo117(unknown func(interface{})) { // ERROR "foo117 unknown does not escap
 }
 
 func foo118(unknown func(*int)) { // ERROR "foo118 unknown does not escape$"
-	x := 1 // ERROR "moved to heap: x$"
+	x := 1      // ERROR "moved to heap: x$"
 	unknown(&x)
 }
 
@@ -1185,7 +1185,7 @@ L1:
 func foo124(x **int) { // ERROR "foo124 x does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo124 func literal does not escape$"
+	func() {  // ERROR "foo124 func literal does not escape$"
 		*x = p
 	}()
 }
@@ -1193,7 +1193,7 @@ func foo124(x **int) { // ERROR "foo124 x does not escape$"
 func foo125(ch chan *int) { // ERROR "foo125 ch does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo125 func literal does not escape$"
+	func() {  // ERROR "foo125 func literal does not escape$"
 		ch <- p
 	}()
 }
@@ -1229,7 +1229,7 @@ func foo128() {
 func foo129() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo129 func literal does not escape$"
+	func() {  // ERROR "foo129 func literal does not escape$"
 		q := p
 		func() { // ERROR "foo129.func1 func literal does not escape$"
 			r := q
@@ -1281,7 +1281,7 @@ func foo134() {
 }
 
 func foo135() {
-	var i int // ERROR "moved to heap: i$"
+	var i int   // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1293,7 +1293,7 @@ func foo135() {
 }
 
 func foo136() {
-	var i int // ERROR "moved to heap: i$"
+	var i int   // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1307,7 +1307,7 @@ func foo136() {
 func foo137() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo137 func literal does not escape$"
+	func() {  // ERROR "foo137 func literal does not escape$"
 		q := p
 		go func() { // ERROR "func literal escapes to heap$"
 			r := q
@@ -1320,7 +1320,7 @@ func foo138() *byte {
 	type T struct {
 		x [1]byte
 	}
-	t := new(T) // ERROR "new\(T\) escapes to heap$"
+	t := new(T)    // ERROR "new\(T\) escapes to heap$"
 	return &t.x[0]
 }
 
@@ -1330,7 +1330,7 @@ func foo139() *byte {
 			y byte
 		}
 	}
-	t := new(T) // ERROR "new\(T\) escapes to heap$"
+	t := new(T)   // ERROR "new\(T\) escapes to heap$"
 	return &t.x.y
 }
 
@@ -1498,7 +1498,7 @@ func bar151() {
 }
 
 func bar151b() {
-	var a [10]int // ERROR "moved to heap: a$"
+	var a [10]int      // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8][0])
 }
@@ -1510,7 +1510,7 @@ func bar151c() {
 }
 
 func bar151d() {
-	var a [10]int // ERROR "moved to heap: a$"
+	var a [10]int        // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8:8][0])
 }
@@ -1534,7 +1534,7 @@ func NewV(u U) *V { // ERROR "leaking param: u$"
 }
 
 func foo152() {
-	a := "a" // ERROR "moved to heap: a$"
+	a := "a"   // ERROR "moved to heap: a$"
 	u := U{&a}
 	v := NewV(u)
 	println(v)
@@ -1642,7 +1642,7 @@ type StructWithString struct {
 // to just x, and thus &i looks escaping.
 func fieldFlowTracking() {
 	var x StructWithString
-	i := 0 // ERROR "moved to heap: i$"
+	i := 0     // ERROR "moved to heap: i$"
 	x.p = &i
 	sink = x.s // ERROR "x.s escapes to heap$"
 }
diff --git a/test/escape4.go b/test/escape4.go
index 0c95426915..a4a9c14a3e 100644
--- a/test/escape4.go
+++ b/test/escape4.go
@@ -42,7 +42,7 @@ func f5() *byte {
 	type T struct {
 		x [1]byte
 	}
-	t := new(T) // ERROR "new.T. escapes to heap"
+	t := new(T)    // ERROR "new.T. escapes to heap"
 	return &t.x[0]
 }
 
@@ -52,6 +52,6 @@ func f6() *byte {
 			y byte
 		}
 	}
-	t := new(T) // ERROR "new.T. escapes to heap"
+	t := new(T)   // ERROR "new.T. escapes to heap"
 	return &t.x.y
 }
diff --git a/test/escape_closure.go b/test/escape_closure.go
index d0406c4268..cf055d3b34 100644
--- a/test/escape_closure.go
+++ b/test/escape_closure.go
@@ -50,7 +50,7 @@ func ClosureCallArgs4() {
 }
 
 func ClosureCallArgs5() {
-	x := 0 // ERROR "moved to heap: x"
+	x := 0                     // ERROR "moved to heap: x"
 	// TODO(mdempsky): We get "leaking param: p" here because the new escape analysis pass
 	// can tell that p flows directly to sink, but it's a little weird. Re-evaluate.
 	sink = func(p *int) *int { // ERROR "leaking param: p" "func literal does not escape" "\(func literal\)\(&x\) escapes to heap"
@@ -132,7 +132,7 @@ func ClosureCallArgs14() {
 }
 
 func ClosureCallArgs15() {
-	x := 0 // ERROR "moved to heap: x"
+	x := 0                      // ERROR "moved to heap: x"
 	p := &x
 	sink = func(p **int) *int { // ERROR "leaking param content: p" "func literal does not escape" "\(func literal\)\(&p\) escapes to heap"
 		return *p
diff --git a/test/escape_field.go b/test/escape_field.go
index 7eefeebe71..5d5a6f36b4 100644
--- a/test/escape_field.go
+++ b/test/escape_field.go
@@ -39,7 +39,7 @@ func field3() {
 	i := 0 // ERROR "moved to heap: i$"
 	var x X
 	x.p1 = &i
-	sink = x // ERROR "x escapes to heap"
+	sink = x  // ERROR "x escapes to heap"
 }
 
 func field4() {
@@ -113,16 +113,16 @@ func field10() {
 }
 
 func field11() {
-	i := 0 // ERROR "moved to heap: i$"
+	i := 0         // ERROR "moved to heap: i$"
 	x := X{p1: &i}
-	sink = x.p1 // ERROR "x\.p1 escapes to heap"
+	sink = x.p1    // ERROR "x\.p1 escapes to heap"
 }
 
 func field12() {
 	i := 0 // ERROR "moved to heap: i$"
 	// BAD: &i should not escape
 	x := X{p1: &i}
-	sink = x.p2 // ERROR "x\.p2 escapes to heap"
+	sink = x.p2    // ERROR "x\.p2 escapes to heap"
 }
 
 func field13() {
diff --git a/test/escape_iface.go b/test/escape_iface.go
index 772e7e23e6..50c69cd5c1 100644
--- a/test/escape_iface.go
+++ b/test/escape_iface.go
@@ -37,7 +37,7 @@ func efaceEscape0() {
 		_ = x
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0      // ERROR "moved to heap: i"
 		v := M0{&i}
 		var x M = v // ERROR "v escapes to heap"
 		sink = x    // ERROR "x escapes to heap"
@@ -50,7 +50,7 @@ func efaceEscape0() {
 		_ = v1
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0      // ERROR "moved to heap: i"
 		v := M0{&i}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
@@ -58,14 +58,14 @@ func efaceEscape0() {
 		sink = v1 // ERROR "v1 escapes to heap"
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0      // ERROR "moved to heap: i"
 		v := M0{&i}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
 		x.M()
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0      // ERROR "moved to heap: i"
 		v := M0{&i}
 		var x M = v // ERROR "v escapes to heap"
 		mescapes(x)
@@ -91,46 +91,46 @@ func efaceEscape1() {
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v // ERROR "v does not escape"
+		var x M = v    // ERROR "v does not escape"
 		_ = x
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0         // ERROR "moved to heap: i"
 		v := M1{&i, 0}
-		var x M = v // ERROR "v escapes to heap"
-		sink = x    // ERROR "x escapes to heap"
+		var x M = v    // ERROR "v escapes to heap"
+		sink = x       // ERROR "x escapes to heap"
 	}
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v // ERROR "v does not escape"
+		var x M = v    // ERROR "v does not escape"
 		v1 := x.(M1)
 		_ = v1
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0         // ERROR "moved to heap: i"
 		v := M1{&i, 0}
 		var x M = v // ERROR "efaceEscape1 v does not escape"
 		v1 := x.(M1)
 		sink = v1 // ERROR "v1 escapes to heap"
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0         // ERROR "moved to heap: i"
 		v := M1{&i, 0}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
 		x.M()
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0         // ERROR "moved to heap: i"
 		v := M1{&i, 0}
-		var x M = v // ERROR "v escapes to heap"
+		var x M = v    // ERROR "v escapes to heap"
 		mescapes(x)
 	}
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v // ERROR "v does not escape"
+		var x M = v    // ERROR "v does not escape"
 		mdoesnotescape(x)
 	}
 }
@@ -244,7 +244,7 @@ func dotTypeEscape2() { // #13805, #15796
 		var x interface{} = i // ERROR "i does not escape"
 		var y interface{} = j // ERROR "j does not escape"
 
-		sink = x.(int) // ERROR "x.\(int\) escapes to heap"
+		sink = x.(int)        // ERROR "x.\(int\) escapes to heap"
 		sink, *(&ok) = y.(int)
 	}
 	{
@@ -254,7 +254,7 @@ func dotTypeEscape2() { // #13805, #15796
 		var x interface{} = &i // ERROR "&i escapes to heap"
 		var y interface{} = &j // ERROR "&j escapes to heap"
 
-		sink = x.(*int) // ERROR "x.\(\*int\) escapes to heap"
+		sink = x.(*int)        // ERROR "x.\(\*int\) escapes to heap"
 		sink, *(&ok) = y.(*int)
 	}
 }
diff --git a/test/escape_indir.go b/test/escape_indir.go
index cb6a2205c7..ce21ea821f 100644
--- a/test/escape_indir.go
+++ b/test/escape_indir.go
@@ -54,14 +54,14 @@ func constptr1() {
 	i := 0           // ERROR "moved to heap: i"
 	x := &ConstPtr{} // ERROR "&ConstPtr literal escapes to heap"
 	x.p = &i
-	sink = x // ERROR "x escapes to heap"
+	sink = x         // ERROR "x escapes to heap"
 }
 
 func constptr2() {
 	i := 0           // ERROR "moved to heap: i"
 	x := &ConstPtr{} // ERROR "&ConstPtr literal does not escape"
 	x.p = &i
-	sink = *x // ERROR "\*x escapes to heap"
+	sink = *x        // ERROR "\*x escapes to heap"
 }
 
 func constptr4() *ConstPtr {
@@ -102,7 +102,7 @@ func constptr8() *ConstPtr {
 func constptr9() ConstPtr {
 	p := new(ConstPtr) // ERROR "new\(ConstPtr\) does not escape"
 	var p1 ConstPtr2
-	i := 0 // ERROR "moved to heap: i"
+	i := 0    // ERROR "moved to heap: i"
 	p1.p = &i
 	p.c = p1
 	return *p
@@ -134,7 +134,7 @@ func foo(p **int) { // ERROR "foo p does not escape"
 }
 
 func foo1(p *int) { // ERROR "p does not escape"
-	i := 0 // ERROR "moved to heap: i"
+	i := 0  // ERROR "moved to heap: i"
 	y := &p
 	*y = &i
 }
@@ -148,13 +148,13 @@ func foo2() {
 	var z Z
 	z.f = &x
 	p := z.f
-	i := 0 // ERROR "moved to heap: i"
+	i := 0  // ERROR "moved to heap: i"
 	*p = &i
 }
 
 var global *byte
 
 func f() {
-	var x byte // ERROR "moved to heap: x"
+	var x byte    // ERROR "moved to heap: x"
 	global = &*&x
 }
diff --git a/test/escape_level.go b/test/escape_level.go
index e5a0f50273..44a23e5a4d 100644
--- a/test/escape_level.go
+++ b/test/escape_level.go
@@ -27,15 +27,15 @@ func level1() {
 }
 
 func level2() {
-	i := 0   // ERROR "moved to heap: i"
-	p0 := &i // ERROR "moved to heap: p0"
+	i := 0     // ERROR "moved to heap: i"
+	p0 := &i   // ERROR "moved to heap: p0"
 	p1 := &p0
 	p2 := &p1
 	sink = *p2 // ERROR "\*p2 escapes to heap"
 }
 
 func level3() {
-	i := 0 // ERROR "moved to heap: i"
+	i := 0      // ERROR "moved to heap: i"
 	p0 := &i
 	p1 := &p0
 	p2 := &p1
@@ -43,23 +43,23 @@ func level3() {
 }
 
 func level4() {
-	i := 0   // ERROR "moved to heap: i"
-	p0 := &i // ERROR "moved to heap: p0"
+	i := 0     // ERROR "moved to heap: i"
+	p0 := &i   // ERROR "moved to heap: p0"
 	p1 := &p0
 	p2 := p1   // ERROR "moved to heap: p2"
 	sink = &p2 // ERROR "&p2 escapes to heap"
 }
 
 func level5() {
-	i := 0   // ERROR "moved to heap: i"
-	p0 := &i // ERROR "moved to heap: p0"
+	i := 0    // ERROR "moved to heap: i"
+	p0 := &i  // ERROR "moved to heap: p0"
 	p1 := &p0
 	p2 := p1
 	sink = p2 // ERROR "p2 escapes to heap"
 }
 
 func level6() {
-	i := 0 // ERROR "moved to heap: i"
+	i := 0    // ERROR "moved to heap: i"
 	p0 := &i
 	p1 := &p0
 	p2 := p1
@@ -67,7 +67,7 @@ func level6() {
 }
 
 func level7() {
-	i := 0 // ERROR "moved to heap: i"
+	i := 0    // ERROR "moved to heap: i"
 	p0 := &i
 	p1 := &p0
 	// note *p1 == &i
@@ -76,7 +76,7 @@ func level7() {
 }
 
 func level8() {
-	i := 0 // ERROR "moved to heap: i"
+	i := 0    // ERROR "moved to heap: i"
 	p0 := &i
 	p1 := &p0
 	p2 := *p1
diff --git a/test/escape_map.go b/test/escape_map.go
index d17c457ec7..9912b55a35 100644
--- a/test/escape_map.go
+++ b/test/escape_map.go
@@ -15,7 +15,7 @@ func map0() {
 	// BAD: i should not escape
 	i := 0 // ERROR "moved to heap: i"
 	// BAD: j should not escape
-	j := 0 // ERROR "moved to heap: j"
+	j := 0     // ERROR "moved to heap: j"
 	m[&i] = &j
 	_ = m
 }
@@ -23,8 +23,8 @@ func map0() {
 func map1() *int {
 	m := make(map[*int]*int) // ERROR "make\(map\[\*int\]\*int\) does not escape"
 	// BAD: i should not escape
-	i := 0 // ERROR "moved to heap: i"
-	j := 0 // ERROR "moved to heap: j"
+	i := 0       // ERROR "moved to heap: i"
+	j := 0       // ERROR "moved to heap: j"
 	m[&i] = &j
 	return m[&i]
 }
@@ -41,7 +41,7 @@ func map3() []*int {
 	m := make(map[*int]*int) // ERROR "make\(map\[\*int\]\*int\) does not escape"
 	i := 0                   // ERROR "moved to heap: i"
 	// BAD: j should not escape
-	j := 0 // ERROR "moved to heap: j"
+	j := 0     // ERROR "moved to heap: j"
 	m[&i] = &j
 	var r []*int
 	for k := range m {
@@ -53,8 +53,8 @@ func map3() []*int {
 func map4() []*int {
 	m := make(map[*int]*int) // ERROR "make\(map\[\*int\]\*int\) does not escape"
 	// BAD: i should not escape
-	i := 0 // ERROR "moved to heap: i"
-	j := 0 // ERROR "moved to heap: j"
+	i := 0     // ERROR "moved to heap: i"
+	j := 0     // ERROR "moved to heap: j"
 	m[&i] = &j
 	var r []*int
 	for k, v := range m {
@@ -68,8 +68,8 @@ func map4() []*int {
 }
 
 func map5(m map[*int]*int) { // ERROR "m does not escape"
-	i := 0 // ERROR "moved to heap: i"
-	j := 0 // ERROR "moved to heap: j"
+	i := 0     // ERROR "moved to heap: i"
+	j := 0     // ERROR "moved to heap: j"
 	m[&i] = &j
 }
 
@@ -77,8 +77,8 @@ func map6(m map[*int]*int) { // ERROR "m does not escape"
 	if m != nil {
 		m = make(map[*int]*int) // ERROR "make\(map\[\*int\]\*int\) does not escape"
 	}
-	i := 0 // ERROR "moved to heap: i"
-	j := 0 // ERROR "moved to heap: j"
+	i := 0     // ERROR "moved to heap: i"
+	j := 0     // ERROR "moved to heap: j"
 	m[&i] = &j
 }
 
@@ -95,7 +95,7 @@ func map8() {
 	i := 0                     // ERROR "moved to heap: i"
 	j := 0                     // ERROR "moved to heap: j"
 	m := map[*int]*int{&i: &j} // ERROR "literal escapes to heap"
-	sink = m                   // ERROR "m escapes to heap"
+	sink = m // ERROR "m escapes to heap"
 }
 
 func map9() *int {
diff --git a/test/escape_param.go b/test/escape_param.go
index b063d9c3d3..2097556744 100644
--- a/test/escape_param.go
+++ b/test/escape_param.go
@@ -57,7 +57,7 @@ func caller2b() {
 	i := 0 // ERROR "moved to heap: i$"
 	var p *int
 	param2(&i, &p)
-	sink = p // ERROR "p escapes to heap$"
+	sink = p       // ERROR "p escapes to heap$"
 }
 
 func paramArraySelfAssign(p *PairOfPairs) { // ERROR "p does not escape"
@@ -150,11 +150,11 @@ func caller3a() {
 }
 
 func caller3b() {
-	i := 0 // ERROR "moved to heap: i$"
-	j := 0 // ERROR "moved to heap: j$"
+	i := 0            // ERROR "moved to heap: i$"
+	j := 0            // ERROR "moved to heap: j$"
 	p := Pair{&i, &j}
 	param3(&p)
-	sink = p // ERROR "p escapes to heap$"
+	sink = p          // ERROR "p escapes to heap$"
 }
 
 // in -> rcvr
@@ -173,7 +173,7 @@ func caller4b() {
 	i := 0 // ERROR "moved to heap: i$"
 	p := Pair{}
 	p.param4(&i)
-	sink = p // ERROR "p escapes to heap$"
+	sink = p     // ERROR "p escapes to heap$"
 }
 
 // in -> heap
@@ -182,7 +182,7 @@ func param5(i *int) { // ERROR "leaking param: i$"
 }
 
 func caller5() {
-	i := 0 // ERROR "moved to heap: i$"
+	i := 0     // ERROR "moved to heap: i$"
 	param5(&i)
 }
 
@@ -192,8 +192,8 @@ func param6(i ***int) { // ERROR "leaking param content: i$"
 }
 
 func caller6a() {
-	i := 0  // ERROR "moved to heap: i$"
-	p := &i // ERROR "moved to heap: p$"
+	i := 0      // ERROR "moved to heap: i$"
+	p := &i     // ERROR "moved to heap: p$"
 	p2 := &p
 	param6(&p2)
 }
@@ -204,8 +204,8 @@ func param7(i ***int) { // ERROR "leaking param content: i$"
 }
 
 func caller7() {
-	i := 0  // ERROR "moved to heap: i$"
-	p := &i // ERROR "moved to heap: p$"
+	i := 0      // ERROR "moved to heap: i$"
+	p := &i     // ERROR "moved to heap: p$"
 	p2 := &p
 	param7(&p2)
 }
@@ -234,8 +234,8 @@ func caller9a() {
 }
 
 func caller9b() {
-	i := 0  // ERROR "moved to heap: i$"
-	p := &i // ERROR "moved to heap: p$"
+	i := 0             // ERROR "moved to heap: i$"
+	p := &i            // ERROR "moved to heap: p$"
 	p2 := &p
 	sink = param9(&p2) // ERROR  "param9\(&p2\) escapes to heap"
 }
@@ -253,7 +253,7 @@ func caller10a() {
 }
 
 func caller10b() {
-	i := 0 // ERROR "moved to heap: i$"
+	i := 0              // ERROR "moved to heap: i$"
 	p := &i
 	p2 := &p
 	sink = param10(&p2) // ERROR "param10\(&p2\) escapes to heap"
@@ -265,8 +265,8 @@ func param11(i **int) ***int { // ERROR "moved to heap: i$"
 }
 
 func caller11a() {
-	i := 0  // ERROR "moved to heap: i"
-	p := &i // ERROR "moved to heap: p"
+	i := 0          // ERROR "moved to heap: i"
+	p := &i         // ERROR "moved to heap: p"
 	_ = param11(&p)
 }
 
@@ -283,8 +283,8 @@ func caller11c() { // GOOD
 }
 
 func caller11d() {
-	i := 0  // ERROR "moved to heap: i$"
-	p := &i // ERROR "moved to heap: p"
+	i := 0             // ERROR "moved to heap: i$"
+	p := &i            // ERROR "moved to heap: p"
 	p2 := &p
 	sink = param11(p2) // ERROR "param11\(p2\) escapes to heap"
 }
@@ -319,7 +319,7 @@ func caller12c() {
 	p := &i // ERROR "moved to heap: p$"
 	r := Indir{}
 	r.param12(&p)
-	sink = r // ERROR "r escapes to heap$"
+	sink = r      // ERROR "r escapes to heap$"
 }
 
 func caller12d() {
@@ -327,7 +327,7 @@ func caller12d() {
 	p := &i // ERROR "moved to heap: p$"
 	r := Indir{}
 	r.param12(&p)
-	sink = **r.p // ERROR "\* \(\*r\.p\) escapes to heap"
+	sink = **r.p  // ERROR "\* \(\*r\.p\) escapes to heap"
 }
 
 // in -> value rcvr
@@ -370,15 +370,15 @@ func caller13d() {
 	var v Val
 	v.p = &p
 	v.param13(&i)
-	sink = v // ERROR "v escapes to heap$"
+	sink = v      // ERROR "v escapes to heap$"
 }
 
 func caller13e() {
-	i := 0     // ERROR "moved to heap: i$"
-	var p *int // ERROR "moved to heap: p$"
+	i := 0        // ERROR "moved to heap: i$"
+	var p *int    // ERROR "moved to heap: p$"
 	v := Val{&p}
 	v.param13(&i)
-	sink = v // ERROR "v escapes to heap$"
+	sink = v      // ERROR "v escapes to heap$"
 }
 
 func caller13f() {
@@ -386,7 +386,7 @@ func caller13f() {
 	var p *int    // ERROR "moved to heap: p$"
 	v := &Val{&p} // ERROR "&Val literal escapes to heap$"
 	v.param13(&i)
-	sink = v // ERROR "v escapes to heap$"
+	sink = v      // ERROR "v escapes to heap$"
 }
 
 func caller13g() {
@@ -394,7 +394,7 @@ func caller13g() {
 	var p *int
 	v := Val{&p}
 	v.param13(&i)
-	sink = *v.p // ERROR "\*v\.p escapes to heap"
+	sink = *v.p   // ERROR "\*v\.p escapes to heap"
 }
 
 func caller13h() {
@@ -402,7 +402,7 @@ func caller13h() {
 	var p *int
 	v := &Val{&p} // ERROR "caller13h &Val literal does not escape$"
 	v.param13(&i)
-	sink = **v.p // ERROR "\* \(\*v\.p\) escapes to heap"
+	sink = **v.p  // ERROR "\* \(\*v\.p\) escapes to heap"
 }
 
 type Node struct {
diff --git a/test/escape_slice.go b/test/escape_slice.go
index 40a5ad372c..03053cf326 100644
--- a/test/escape_slice.go
+++ b/test/escape_slice.go
@@ -18,28 +18,28 @@ var sink interface{}
 func slice0() {
 	var s []*int
 	// BAD: i should not escape
-	i := 0 // ERROR "moved to heap: i"
+	i := 0            // ERROR "moved to heap: i"
 	s = append(s, &i)
 	_ = s
 }
 
 func slice1() *int {
 	var s []*int
-	i := 0 // ERROR "moved to heap: i"
+	i := 0            // ERROR "moved to heap: i"
 	s = append(s, &i)
 	return s[0]
 }
 
 func slice2() []*int {
 	var s []*int
-	i := 0 // ERROR "moved to heap: i"
+	i := 0            // ERROR "moved to heap: i"
 	s = append(s, &i)
 	return s
 }
 
 func slice3() *int {
 	var s []*int
-	i := 0 // ERROR "moved to heap: i"
+	i := 0            // ERROR "moved to heap: i"
 	s = append(s, &i)
 	for _, p := range s {
 		return p
@@ -48,7 +48,7 @@ func slice3() *int {
 }
 
 func slice4(s []*int) { // ERROR "s does not escape"
-	i := 0 // ERROR "moved to heap: i"
+	i := 0    // ERROR "moved to heap: i"
 	s[0] = &i
 }
 
@@ -56,14 +56,14 @@ func slice5(s []*int) { // ERROR "s does not escape"
 	if s != nil {
 		s = make([]*int, 10) // ERROR "make\(\[\]\*int, 10\) does not escape"
 	}
-	i := 0 // ERROR "moved to heap: i"
+	i := 0    // ERROR "moved to heap: i"
 	s[0] = &i
 }
 
 func slice6() {
 	s := make([]*int, 10) // ERROR "make\(\[\]\*int, 10\) does not escape"
 	// BAD: i should not escape
-	i := 0 // ERROR "moved to heap: i"
+	i := 0    // ERROR "moved to heap: i"
 	s[0] = &i
 	_ = s
 }
diff --git a/test/escape_struct_param1.go b/test/escape_struct_param1.go
index 5242a507c7..7004946e2f 100644
--- a/test/escape_struct_param1.go
+++ b/test/escape_struct_param1.go
@@ -35,7 +35,7 @@ func (u *U) SPPi() *string { // ERROR "leaking param: u to result ~r0 level=2$"
 }
 
 func tSPPi() {
-	s := "cat" // ERROR "moved to heap: s$"
+	s := "cat"        // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tSPPi &U literal does not escape$"
@@ -43,7 +43,7 @@ func tSPPi() {
 }
 
 func tiSPP() {
-	s := "cat" // ERROR "moved to heap: s$"
+	s := "cat"        // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tiSPP &U literal does not escape$"
@@ -52,8 +52,8 @@ func tiSPP() {
 
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of ps
 func tSP() {
-	s := "cat" // ERROR "moved to heap: s$"
-	ps := &s   // ERROR "moved to heap: ps$"
+	s := "cat"        // ERROR "moved to heap: s$"
+	ps := &s          // ERROR "moved to heap: ps$"
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tSP &U literal does not escape$"
 	Ssink = pu.SP()
@@ -114,14 +114,14 @@ func (v *V) UPiSPd() *string { // ERROR "leaking param: v to result ~r0 level=2$
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPa() {
 	s1 := "ant"
-	s2 := "bat" // ERROR "moved to heap: s2$"
-	s3 := "cat" // ERROR "moved to heap: s3$"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s2 := "bat"          // ERROR "moved to heap: s2$"
+	s3 := "cat"          // ERROR "moved to heap: s3$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4 // ERROR "moved to heap: ps4$"
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps4 := &s4           // ERROR "moved to heap: ps4$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPa &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -132,14 +132,14 @@ func tUPiSPa() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPb() {
 	s1 := "ant"
-	s2 := "bat" // ERROR "moved to heap: s2$"
-	s3 := "cat" // ERROR "moved to heap: s3$"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s2 := "bat"          // ERROR "moved to heap: s2$"
+	s3 := "cat"          // ERROR "moved to heap: s3$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4 // ERROR "moved to heap: ps4$"
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps4 := &s4           // ERROR "moved to heap: ps4$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPb &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -150,14 +150,14 @@ func tUPiSPb() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPc() {
 	s1 := "ant"
-	s2 := "bat" // ERROR "moved to heap: s2$"
-	s3 := "cat" // ERROR "moved to heap: s3$"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s2 := "bat"          // ERROR "moved to heap: s2$"
+	s3 := "cat"          // ERROR "moved to heap: s3$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4 // ERROR "moved to heap: ps4$"
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps4 := &s4           // ERROR "moved to heap: ps4$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPc &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -168,14 +168,14 @@ func tUPiSPc() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPd() {
 	s1 := "ant"
-	s2 := "bat" // ERROR "moved to heap: s2$"
-	s3 := "cat" // ERROR "moved to heap: s3$"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s2 := "bat"          // ERROR "moved to heap: s2$"
+	s3 := "cat"          // ERROR "moved to heap: s3$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4 // ERROR "moved to heap: ps4$"
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps4 := &s4           // ERROR "moved to heap: ps4$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPd &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -204,12 +204,12 @@ func tUPiSPPia() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPia &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPia &U literal does not escape$"
@@ -222,12 +222,12 @@ func tUPiSPPib() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPib &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPib &U literal does not escape$"
@@ -240,12 +240,12 @@ func tUPiSPPic() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPic &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPic &U literal does not escape$"
@@ -258,12 +258,12 @@ func tUPiSPPid() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPid &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPid &U literal does not escape$"
@@ -286,7 +286,7 @@ func tUPPiSPPia() {
 	s3 := "cat"
 	s4 := "dog"
 	s5 := "emu"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s6 := "fox"           // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
 	ps6 := &s6
diff --git a/test/escape_struct_param2.go b/test/escape_struct_param2.go
index 76dc35ccf0..5a9b271958 100644
--- a/test/escape_struct_param2.go
+++ b/test/escape_struct_param2.go
@@ -35,7 +35,7 @@ func (u U) SPPi() *string { // ERROR "leaking param: u to result ~r0 level=1$"
 }
 
 func tSPPi() {
-	s := "cat" // ERROR "moved to heap: s$"
+	s := "cat"        // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tSPPi &U literal does not escape$"
@@ -43,7 +43,7 @@ func tSPPi() {
 }
 
 func tiSPP() {
-	s := "cat" // ERROR "moved to heap: s$"
+	s := "cat"        // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tiSPP &U literal does not escape$"
@@ -52,8 +52,8 @@ func tiSPP() {
 
 // BAD: need fine-grained analysis to avoid spurious escape of ps
 func tSP() {
-	s := "cat" // ERROR "moved to heap: s$"
-	ps := &s   // ERROR "moved to heap: ps$"
+	s := "cat"        // ERROR "moved to heap: s$"
+	ps := &s          // ERROR "moved to heap: ps$"
 	pps := &ps
 	pu := &U{ps, pps} // ERROR "tSP &U literal does not escape$"
 	Ssink = pu.SP()
@@ -114,14 +114,14 @@ func (v V) UPiSPd() *string { // ERROR "leaking param: v to result ~r0 level=1$"
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPa() {
 	s1 := "ant"
-	s2 := "bat" // ERROR "moved to heap: s2$"
-	s3 := "cat" // ERROR "moved to heap: s3$"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s2 := "bat"          // ERROR "moved to heap: s2$"
+	s3 := "cat"          // ERROR "moved to heap: s3$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4 // ERROR "moved to heap: ps4$"
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps4 := &s4           // ERROR "moved to heap: ps4$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPa &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -132,14 +132,14 @@ func tUPiSPa() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPb() {
 	s1 := "ant"
-	s2 := "bat" // ERROR "moved to heap: s2$"
-	s3 := "cat" // ERROR "moved to heap: s3$"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s2 := "bat"          // ERROR "moved to heap: s2$"
+	s3 := "cat"          // ERROR "moved to heap: s3$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4 // ERROR "moved to heap: ps4$"
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps4 := &s4           // ERROR "moved to heap: ps4$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPb &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -150,14 +150,14 @@ func tUPiSPb() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPc() {
 	s1 := "ant"
-	s2 := "bat" // ERROR "moved to heap: s2$"
-	s3 := "cat" // ERROR "moved to heap: s3$"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s2 := "bat"          // ERROR "moved to heap: s2$"
+	s3 := "cat"          // ERROR "moved to heap: s3$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4 // ERROR "moved to heap: ps4$"
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps4 := &s4           // ERROR "moved to heap: ps4$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPc &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -168,14 +168,14 @@ func tUPiSPc() {
 // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
 func tUPiSPd() {
 	s1 := "ant"
-	s2 := "bat" // ERROR "moved to heap: s2$"
-	s3 := "cat" // ERROR "moved to heap: s3$"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s2 := "bat"          // ERROR "moved to heap: s2$"
+	s3 := "cat"          // ERROR "moved to heap: s3$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
-	ps4 := &s4 // ERROR "moved to heap: ps4$"
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps4 := &s4           // ERROR "moved to heap: ps4$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPd &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
@@ -204,12 +204,12 @@ func tUPiSPPia() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPia &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPia &U literal does not escape$"
@@ -222,12 +222,12 @@ func tUPiSPPib() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPib &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPib &U literal does not escape$"
@@ -240,12 +240,12 @@ func tUPiSPPic() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPic &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPic &U literal does not escape$"
@@ -258,12 +258,12 @@ func tUPiSPPid() {
 	s1 := "ant"
 	s2 := "bat"
 	s3 := "cat"
-	s4 := "dog" // ERROR "moved to heap: s4$"
-	s5 := "emu" // ERROR "moved to heap: s5$"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s4 := "dog"          // ERROR "moved to heap: s4$"
+	s5 := "emu"          // ERROR "moved to heap: s5$"
+	s6 := "fox"          // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
-	ps6 := &s6 // ERROR "moved to heap: ps6$"
+	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
 	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPid &U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPid &U literal does not escape$"
@@ -286,7 +286,7 @@ func tUPPiSPPia() { // This test is sensitive to the level cap in function summa
 	s3 := "cat"
 	s4 := "dog"
 	s5 := "emu"
-	s6 := "fox" // ERROR "moved to heap: s6$"
+	s6 := "fox"           // ERROR "moved to heap: s6$"
 	ps2 := &s2
 	ps4 := &s4
 	ps6 := &s6
diff --git a/test/finprofiled.go b/test/finprofiled.go
index 267e15b9af..0eb801a4bd 100644
--- a/test/finprofiled.go
+++ b/test/finprofiled.go
@@ -23,7 +23,7 @@ func main() {
 	// only for middle bytes. The finalizer resurrects that object.
 	// As the result, all allocated memory must stay alive.
 	const (
-		N             = 1 << 20
+		N = 1 << 20
 		tinyBlockSize = 16 // runtime._TinySize
 	)
 	hold := make([]*int32, 0, N)
diff --git a/test/fixedbugs/bug000.go b/test/fixedbugs/bug000.go
index a0a9a654ad..9104a57aaf 100644
--- a/test/fixedbugs/bug000.go
+++ b/test/fixedbugs/bug000.go
@@ -7,16 +7,14 @@
 package main
 
 func main() {
-	var x int
+	var x int;
 	switch x {
 	case 0:
-		{
-		}
+		{}
 	case 1:
-		x = 0
+		x = 0;
 	}
 }
-
 /*
 bug0.go:8: case statement out of place
 */
diff --git a/test/fixedbugs/bug002.go b/test/fixedbugs/bug002.go
index 89b989cb85..3493426d37 100644
--- a/test/fixedbugs/bug002.go
+++ b/test/fixedbugs/bug002.go
@@ -7,6 +7,5 @@
 package main
 
 func main() {
-	if false {
-	} // compiles; should be an error (should be simplevardecl before ;)
+	if ; false {}  // compiles; should be an error (should be simplevardecl before ;)
 }
diff --git a/test/fixedbugs/bug003.go b/test/fixedbugs/bug003.go
index 1602630c39..7165d9d209 100644
--- a/test/fixedbugs/bug003.go
+++ b/test/fixedbugs/bug003.go
@@ -7,14 +7,8 @@
 package main
 
 func main() {
-	switch {
-	case true:
-		return
-	default:
-		return
-	}
+	switch ; { case true: return; default: return }
 }
-
 /*
 bug003.go:6: fatal error: walkswitch: not case EMPTY
 */
diff --git a/test/fixedbugs/bug004.go b/test/fixedbugs/bug004.go
index 4864afacb6..fb207e9bc8 100644
--- a/test/fixedbugs/bug004.go
+++ b/test/fixedbugs/bug004.go
@@ -7,8 +7,5 @@
 package main
 
 func main() {
-	switch {
-	case false:
-		return
-	} // compiles; should be an error (should be simplevardecl before ;)
+	switch ; { case false: return; }  // compiles; should be an error (should be simplevardecl before ;)
 }
diff --git a/test/fixedbugs/bug005.go b/test/fixedbugs/bug005.go
index d57ef6ac2d..3798f8321a 100644
--- a/test/fixedbugs/bug005.go
+++ b/test/fixedbugs/bug005.go
@@ -7,13 +7,11 @@
 package main
 
 func main() {
-Foo:
-	{
-		return
+	Foo: {
+		return;
 	}
-	goto Foo
+	goto Foo;
 }
-
 /*
 bug5.go:4: Foo undefined
 bug5.go:4: fatal error: walktype: switch 1 unknown op GOTO l(4)
diff --git a/test/fixedbugs/bug008.go b/test/fixedbugs/bug008.go
index 4468d74a20..48f74a52d9 100644
--- a/test/fixedbugs/bug008.go
+++ b/test/fixedbugs/bug008.go
@@ -7,21 +7,14 @@
 package main
 
 func main() {
-	i5 := 5
+	i5 := 5;
 
-	switch { // compiler crash fixable with 'switch true'
-	case i5 < 5:
-		dummy := 0
-		_ = dummy
-	case i5 == 5:
-		dummy := 0
-		_ = dummy
-	case i5 > 5:
-		dummy := 0
-		_ = dummy
+	switch {  // compiler crash fixable with 'switch true'
+	case i5 < 5: dummy := 0; _ = dummy;
+	case i5 == 5: dummy := 0; _ = dummy;
+	case i5 > 5: dummy := 0; _ = dummy;
 	}
 }
-
 /*
 Segmentation fault
 */
diff --git a/test/fixedbugs/bug009.go b/test/fixedbugs/bug009.go
index 3db245e64e..0467b297a2 100644
--- a/test/fixedbugs/bug009.go
+++ b/test/fixedbugs/bug009.go
@@ -6,11 +6,10 @@
 
 package main
 
+
 func main() {
-	fired := false
-	_ = fired
+	fired := false; _ = fired;
 }
-
 /*
 bug9.go:5: defaultlit: unknown literal: LITERAL-B0 a(1)
 bug9.go:5: fatal error: addvar: n=NAME-fired G0 a(1) l(5) t=<N> nil
diff --git a/test/fixedbugs/bug010.go b/test/fixedbugs/bug010.go
index a8d3ed4cbb..f54b1d54a8 100644
--- a/test/fixedbugs/bug010.go
+++ b/test/fixedbugs/bug010.go
@@ -6,6 +6,7 @@
 
 package main
 
+
 func f(i int, f float64) {
 	i = 8
 	f = 8.0
diff --git a/test/fixedbugs/bug011.go b/test/fixedbugs/bug011.go
index 95c91a1ff9..519c3585f0 100644
--- a/test/fixedbugs/bug011.go
+++ b/test/fixedbugs/bug011.go
@@ -6,6 +6,7 @@
 
 package main
 
+
 type T struct {
 	x, y int
 }
@@ -21,7 +22,6 @@ func main() {
 	r10 := t.m(1, 3.0)
 	_ = r10
 }
-
 /*
 bug11.go:16: fatal error: walktype: switch 1 unknown op CALLMETH l(16) <int32>INT32
 */
diff --git a/test/fixedbugs/bug012.go b/test/fixedbugs/bug012.go
index d4ccc973a5..38efb6d979 100644
--- a/test/fixedbugs/bug012.go
+++ b/test/fixedbugs/bug012.go
@@ -6,24 +6,18 @@
 
 package main
 
+
 func main() {
-	var u30 uint64 = 0
-	var u31 uint64 = 1
-	_, _ = u30, u31
-	var u32 uint64 = 18446744073709551615
-	var u33 uint64 = +18446744073709551615
-	if u32 != (1<<64)-1 {
-		panic("u32\n")
-	}
-	if u33 != (1<<64)-1 {
-		panic("u33\n")
-	}
-	var i34 int64 = ^0 // note: 2's complement means ^0 == -1
-	if i34 != -1 {
-		panic("i34")
-	}
+	var u30 uint64 = 0;
+	var u31 uint64 = 1;
+	_, _ = u30, u31;
+	var u32 uint64 = 18446744073709551615;
+	var u33 uint64 = +18446744073709551615;
+	if u32 != (1<<64)-1 { panic("u32\n"); }
+	if u33 != (1<<64)-1 { panic("u33\n"); }
+	var i34 int64 = ^0;  // note: 2's complement means ^0 == -1
+	if i34 != -1 { panic("i34") }
 }
-
 /*
 bug12.go:5: overflow converting constant to <uint64>UINT64
 bug12.go:6: overflow converting constant to <uint64>UINT64
diff --git a/test/fixedbugs/bug013.go b/test/fixedbugs/bug013.go
index c80fe67c5a..045786bf7a 100644
--- a/test/fixedbugs/bug013.go
+++ b/test/fixedbugs/bug013.go
@@ -7,11 +7,10 @@
 package main
 
 func main() {
-	var cu0 uint16 = '\u1234'
-	var cU1 uint32 = '\U00101234'
-	_, _ = cu0, cU1
+	var cu0 uint16 = '\u1234';
+	var cU1 uint32 = '\U00101234';
+	_, _ = cu0, cU1;
 }
-
 /*
 bug13.go:4: missing '
 bug13.go:4: syntax error
diff --git a/test/fixedbugs/bug015.go b/test/fixedbugs/bug015.go
index b00071e590..d3a9f22ed0 100644
--- a/test/fixedbugs/bug015.go
+++ b/test/fixedbugs/bug015.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	var i33 int64
-	if i33 == (1<<64)-1 { // ERROR "overflow"
+	var i33 int64;
+	if i33 == (1<<64) -1 {  // ERROR "overflow"
 	}
 }
diff --git a/test/fixedbugs/bug017.go b/test/fixedbugs/bug017.go
index 6201124932..2f5960d104 100644
--- a/test/fixedbugs/bug017.go
+++ b/test/fixedbugs/bug017.go
@@ -7,10 +7,9 @@
 package main
 
 func main() {
-	var s2 string = "\a\b\f\n\r\t\v" // \r is miscompiled
-	_ = s2
+	var s2 string = "\a\b\f\n\r\t\v";  // \r is miscompiled
+	_ = s2;
 }
-
 /*
 main.go.c: In function ‘main_main’:
 main.go.c:20: error: missing terminating " character
diff --git a/test/fixedbugs/bug020.go b/test/fixedbugs/bug020.go
index 1dd2106b24..cde3f8679b 100644
--- a/test/fixedbugs/bug020.go
+++ b/test/fixedbugs/bug020.go
@@ -6,10 +6,10 @@
 
 package main
 
-var digits string
+var digits string;
 
 func putint(buf []byte, i, base, val int, digits string) {
-	buf[i] = digits[val]
+		buf[i] = digits[val];
 }
 
 func main() {
diff --git a/test/fixedbugs/bug021.go b/test/fixedbugs/bug021.go
index fcbebc7397..bf936e875c 100644
--- a/test/fixedbugs/bug021.go
+++ b/test/fixedbugs/bug021.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	s1 := "hi"
-	s2 := "ho"
-	s1 += s2
+	s1 := "hi";
+	s2 := "ho";
+	s1 += s2;
 }
diff --git a/test/fixedbugs/bug022.go b/test/fixedbugs/bug022.go
index 8395ab36a1..65a8bfe9a1 100644
--- a/test/fixedbugs/bug022.go
+++ b/test/fixedbugs/bug022.go
@@ -7,15 +7,15 @@
 package main
 
 func putint(digits *string) {
-	var i byte
-	i = (*digits)[7] // compiles
-	i = digits[7]    // ERROR "illegal|is not|invalid"
-	_ = i
+	var i byte;
+	i = (*digits)[7];  // compiles
+	i = digits[7];  // ERROR "illegal|is not|invalid"
+	_ = i;
 }
 
 func main() {
-	s := "asdfasdfasdfasdf"
-	putint(&s)
+	s := "asdfasdfasdfasdf";
+	putint(&s);
 }
 
 /*
diff --git a/test/fixedbugs/bug023.go b/test/fixedbugs/bug023.go
index c3c77f7243..9b211cd54f 100644
--- a/test/fixedbugs/bug023.go
+++ b/test/fixedbugs/bug023.go
@@ -7,7 +7,7 @@
 package main
 
 type Type interface {
-	TypeName() string
+	TypeName() string;
 }
 
 type TInt struct {
@@ -15,13 +15,14 @@ type TInt struct {
 
 // TInt
 func (i *TInt) TypeName() string {
-	return "int"
+	return "int";
 }
 
+
 func main() {
-	var t Type
-	t = nil
-	_ = t
+	var t Type;
+	t = nil;
+	_ = t;
 }
 
 /*
diff --git a/test/fixedbugs/bug024.go b/test/fixedbugs/bug024.go
index 6e3af02f2c..2e235b7b46 100644
--- a/test/fixedbugs/bug024.go
+++ b/test/fixedbugs/bug024.go
@@ -7,14 +7,13 @@
 package main
 
 func main() {
-	var i int
-	i = '\''
-	i = '\\'
-	var s string
-	s = "\""
-	_, _ = i, s
+	var i int;
+	i = '\'';
+	i = '\\';
+	var s string;
+	s = "\"";
+	_, _ = i, s;
 }
-
 /*
 bug.go:5: unknown escape sequence: '
 bug.go:6: unknown escape sequence: \
diff --git a/test/fixedbugs/bug026.go b/test/fixedbugs/bug026.go
index edb2b5685e..bfd03cc955 100644
--- a/test/fixedbugs/bug026.go
+++ b/test/fixedbugs/bug026.go
@@ -15,12 +15,12 @@ type Vector struct {
 func (v *Vector) Insert(i int, e Element) {
 }
 
+
 func main() {
-	type I struct{ val int } // BUG: can't be local; works if global
-	v := new(Vector)
-	v.Insert(0, new(I))
+	type I struct { val int; };  // BUG: can't be local; works if global
+	v := new(Vector);
+	v.Insert(0, new(I));
 }
-
 /*
 check: main_sigs_I: not defined
 */
diff --git a/test/fixedbugs/bug028.go b/test/fixedbugs/bug028.go
index cd41b09de3..2edf5a9106 100644
--- a/test/fixedbugs/bug028.go
+++ b/test/fixedbugs/bug028.go
@@ -6,23 +6,22 @@
 
 package main
 
+
 func Alloc(i int) int {
 	switch i {
 	default:
-		return 5
+		return 5;
 	case 1:
-		return 1
+		return 1;
 	case 10:
-		return 10
+		return 10;
 	}
 	return 0
 }
 
 func main() {
-	s := Alloc(7)
-	if s != 5 {
-		panic("bad")
-	}
+	s := Alloc(7);
+	if s != 5 { panic("bad") }
 }
 
 /*
diff --git a/test/fixedbugs/bug030.go b/test/fixedbugs/bug030.go
index 93bb2e9e3b..ffd29e057a 100644
--- a/test/fixedbugs/bug030.go
+++ b/test/fixedbugs/bug030.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	var x int
-	x := 0 // ERROR "declar|:="
-	_ = x
+	var x int;
+	x := 0; // ERROR "declar|:="
+	_ = x;
 }
diff --git a/test/fixedbugs/bug031.go b/test/fixedbugs/bug031.go
index 10028c5d1d..529e5ce84c 100644
--- a/test/fixedbugs/bug031.go
+++ b/test/fixedbugs/bug031.go
@@ -7,23 +7,23 @@
 package main
 
 func main() {
-	prog := "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
-		"xxxxxxxxxx" +
-		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
-		"xxxxxxxxxxxxxxxxxxxxxx" +
-		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
-		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
-		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
-		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
-		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
-		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
-		"xxxxxxxxxxxxxxxxxxx" +
-		"xxxxxx" +
-		"xxxxxxxxxxxxxxxxxxxx" +
-		"xxxxxxxx" +
-		"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-
-	_ = prog
+prog := "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
+"xxxxxxxxxx"+
+"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
+"xxxxxxxxxxxxxxxxxxxxxx"+
+"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
+"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
+"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
+"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
+"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
+"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
+"xxxxxxxxxxxxxxxxxxx"+
+"xxxxxx"+
+"xxxxxxxxxxxxxxxxxxxx"+
+"xxxxxxxx"+
+"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+;
+_ = prog;
 }
 
 /* Segmentation fault */
diff --git a/test/fixedbugs/bug037.go b/test/fixedbugs/bug037.go
index e66349a2b7..f17fb3fd74 100644
--- a/test/fixedbugs/bug037.go
+++ b/test/fixedbugs/bug037.go
@@ -7,5 +7,5 @@
 package main
 
 func main() {
-	s := vlong(0) // ERROR "undef"
+	s := vlong(0);  // ERROR "undef"
 }
diff --git a/test/fixedbugs/bug039.go b/test/fixedbugs/bug039.go
index 847ac241db..d34f5e62e4 100644
--- a/test/fixedbugs/bug039.go
+++ b/test/fixedbugs/bug039.go
@@ -6,6 +6,6 @@
 
 package main
 
-func f(x int) { // GCCGO_ERROR "previous"
-	var x int // ERROR "redecl|redefinition"
+func f (x int) {	// GCCGO_ERROR "previous"
+	var x int;	// ERROR "redecl|redefinition"
 }
diff --git a/test/fixedbugs/bug040.go b/test/fixedbugs/bug040.go
index cb1e35f3e3..d2cf88afcb 100644
--- a/test/fixedbugs/bug040.go
+++ b/test/fixedbugs/bug040.go
@@ -6,6 +6,6 @@
 
 package main
 
-func f(x, // GCCGO_ERROR "previous"
-	x int) { // ERROR "duplicate argument|redefinition"
+func f (x,		// GCCGO_ERROR "previous"
+	x int) {	// ERROR "duplicate argument|redefinition"
 }
diff --git a/test/fixedbugs/bug045.go b/test/fixedbugs/bug045.go
index a15e16343e..c66a2411a8 100644
--- a/test/fixedbugs/bug045.go
+++ b/test/fixedbugs/bug045.go
@@ -11,12 +11,11 @@ type T struct {
 }
 
 func main() {
-	var ta []*T
+	var ta []*T;
 
-	ta = new([1]*T)[0:]
-	ta[0] = nil
+	ta = new([1]*T)[0:];
+	ta[0] = nil;
 }
-
 /*
 bug045.go:13: fatal error: goc: exit 1
 */
diff --git a/test/fixedbugs/bug046.go b/test/fixedbugs/bug046.go
index 2ef98177de..219e91d537 100644
--- a/test/fixedbugs/bug046.go
+++ b/test/fixedbugs/bug046.go
@@ -6,9 +6,9 @@
 
 package main
 
-type T *struct{}
+type T *struct {}
 
-func (x T) M() {} // ERROR "pointer|receiver"
+func (x T) M () {}  // ERROR "pointer|receiver"
 
 /*
 bug046.go:7: illegal <this> pointer
diff --git a/test/fixedbugs/bug048.go b/test/fixedbugs/bug048.go
index 112343c77f..48ad751e2c 100644
--- a/test/fixedbugs/bug048.go
+++ b/test/fixedbugs/bug048.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	type M map[int]int
-	m1 := M{7: 8}
-	_ = m1
+	type M map[int] int;
+	m1 := M{7 : 8};
+	_ = m1;
 }
diff --git a/test/fixedbugs/bug049.go b/test/fixedbugs/bug049.go
index 7de429c80c..51990f2dfb 100644
--- a/test/fixedbugs/bug049.go
+++ b/test/fixedbugs/bug049.go
@@ -7,8 +7,8 @@
 package main
 
 func atom(s string) {
-	if s == nil { // ERROR "nil|incompatible"
-		return
+	if s == nil {	// ERROR "nil|incompatible"
+		return;
 	}
 }
 
diff --git a/test/fixedbugs/bug051.go b/test/fixedbugs/bug051.go
index e337f960d7..c4ba2eff67 100644
--- a/test/fixedbugs/bug051.go
+++ b/test/fixedbugs/bug051.go
@@ -7,9 +7,9 @@
 package main
 
 func f() int {
-	return 0
+	return 0;
 }
 
 func main() {
-	const n = f() // ERROR "const"
+	const n = f();	// ERROR "const"
 }
diff --git a/test/fixedbugs/bug052.go b/test/fixedbugs/bug052.go
index ec372b33cc..440a00ebeb 100644
--- a/test/fixedbugs/bug052.go
+++ b/test/fixedbugs/bug052.go
@@ -7,14 +7,14 @@
 package main
 
 func main() {
-	c := 10
-	d := 7
-	var x [10]int
-	i := 0
+	c := 10;
+	d := 7;
+	var x [10]int;
+	i := 0;
 	/* this works:
 	q := c/d;
 	x[i] = q;
 	*/
 	// this doesn't:
-	x[i] = c / d // BUG segmentation fault
+	x[i] = c/d;	// BUG segmentation fault
 }
diff --git a/test/fixedbugs/bug053.go b/test/fixedbugs/bug053.go
index 8a8b4be5cf..00625fd7c3 100644
--- a/test/fixedbugs/bug053.go
+++ b/test/fixedbugs/bug053.go
@@ -7,6 +7,6 @@
 package main
 
 func main() {
-	var len int // len should not be a keyword - this doesn't compile
-	_ = len
+	var len int;	// len should not be a keyword - this doesn't compile
+	_ = len;
 }
diff --git a/test/fixedbugs/bug054.go b/test/fixedbugs/bug054.go
index 064696bd5c..01590585c5 100644
--- a/test/fixedbugs/bug054.go
+++ b/test/fixedbugs/bug054.go
@@ -10,31 +10,31 @@ type Element interface {
 }
 
 type Vector struct {
-	elem []Element
+	elem []Element;
 }
 
 func (v *Vector) At(i int) Element {
-	return v.elem[i]
+	return v.elem[i];
 }
 
 type TStruct struct {
-	name   string
-	fields *Vector
+	name string;
+	fields *Vector;
 }
 
 func (s *TStruct) field(i int) *TStruct {
-	return s.fields.At(i).(*TStruct)
+	return s.fields.At(i).(*TStruct);
 }
 
 func main() {
-	v := new(Vector)
-	v.elem = make([]Element, 10)
-	t := new(TStruct)
-	t.name = "hi"
-	v.elem[0] = t
-	s := new(TStruct)
-	s.name = "foo"
-	s.fields = v
+	v := new(Vector);
+	v.elem = make([]Element, 10);
+	t := new(TStruct);
+	t.name = "hi";
+	v.elem[0] = t;
+	s := new(TStruct);
+	s.name = "foo";
+	s.fields = v;
 	if s.field(0).name != "hi" {
 		panic("bad name")
 	}
diff --git a/test/fixedbugs/bug056.go b/test/fixedbugs/bug056.go
index dfee21b8bf..13eac29204 100644
--- a/test/fixedbugs/bug056.go
+++ b/test/fixedbugs/bug056.go
@@ -11,8 +11,8 @@ func frexp() (a int, b float64) {
 }
 
 func main() {
-	a, b := frexp()
-	_, _ = a, b
+	a, b := frexp();
+	_, _ = a, b;
 }
 
 /*
diff --git a/test/fixedbugs/bug057.go b/test/fixedbugs/bug057.go
index 9df1acd077..19b8651a54 100644
--- a/test/fixedbugs/bug057.go
+++ b/test/fixedbugs/bug057.go
@@ -7,15 +7,16 @@
 package main
 
 type T struct {
-	s string
+	s string;
 }
 
+
 func main() {
-	s := ""
-	l1 := len(s)
-	var t T
-	l2 := len(t.s) // BUG: cannot take len() of a string field
-	_, _ = l1, l2
+	s := "";
+	l1 := len(s);
+	var t T;
+	l2 := len(t.s);	// BUG: cannot take len() of a string field
+	_, _ = l1, l2;
 }
 
 /*
diff --git a/test/fixedbugs/bug058.go b/test/fixedbugs/bug058.go
index ec58317ff5..2b97dbf7c0 100644
--- a/test/fixedbugs/bug058.go
+++ b/test/fixedbugs/bug058.go
@@ -6,15 +6,14 @@
 
 package main
 
-type Box struct{}
-
-var m map[string]*Box
+type Box struct {};
+var m map[string] *Box;
 
 func main() {
-	m := make(map[string]*Box)
-	s := "foo"
-	var x *Box = nil
-	m[s] = x
+	m := make(map[string] *Box);
+	s := "foo";
+	var x *Box = nil;
+	m[s] = x;
 }
 
 /*
diff --git a/test/fixedbugs/bug059.go b/test/fixedbugs/bug059.go
index 4dbd297bc7..6f64b9e0b1 100644
--- a/test/fixedbugs/bug059.go
+++ b/test/fixedbugs/bug059.go
@@ -9,28 +9,28 @@ package main
 import "os"
 
 func P(a []string) string {
-	s := "{"
+	s := "{";
 	for i := 0; i < 2; i++ {
 		if i > 0 {
 			s += ","
 		}
-		s += `"` + a[i] + `"`
+		s += `"` + a[i] + `"`;
 	}
-	s += "}"
-	return s
+	s +="}";
+	return s;
 }
 
 func main() {
-	m := make(map[string][]string)
-	as := new([2]string)
-	as[0] = "0"
-	as[1] = "1"
-	m["0"] = as[0:]
+	m := make(map[string] []string);
+	as := new([2]string);
+	as[0] = "0";
+	as[1] = "1";
+	m["0"] = as[0:];
 
-	a := m["0"]
-	a[0] = "x"
-	m["0"][0] = "deleted"
+	a := m["0"];
+	a[0] = "x";
+	m["0"][0] = "deleted";
 	if m["0"][0] != "deleted" {
-		os.Exit(1)
+		os.Exit(1);
 	}
 }
diff --git a/test/fixedbugs/bug060.go b/test/fixedbugs/bug060.go
index a97c1cd2fd..8260729056 100644
--- a/test/fixedbugs/bug060.go
+++ b/test/fixedbugs/bug060.go
@@ -9,11 +9,11 @@ package main
 import "os"
 
 func main() {
-	m := make(map[int]int)
-	m[0] = 0
-	m[0]++
+	m := make(map[int]int);
+	m[0] = 0;
+	m[0]++;
 	if m[0] != 1 {
-		print("map does not increment\n")
+		print("map does not increment\n");
 		os.Exit(1)
 	}
 }
diff --git a/test/fixedbugs/bug061.go b/test/fixedbugs/bug061.go
index 295d6f3b45..ae99b186d8 100644
--- a/test/fixedbugs/bug061.go
+++ b/test/fixedbugs/bug061.go
@@ -7,9 +7,9 @@
 package main
 
 func main() {
-	var s string
-	s = "0000000000000000000000000000000000000000000000000000000000"[0:7]
-	_ = s
+	var s string;
+	s = "0000000000000000000000000000000000000000000000000000000000"[0:7];
+	_ = s;
 }
 
 /*
diff --git a/test/fixedbugs/bug062.go b/test/fixedbugs/bug062.go
index 1008f1af9c..1cc5003655 100644
--- a/test/fixedbugs/bug062.go
+++ b/test/fixedbugs/bug062.go
@@ -7,5 +7,5 @@
 package main
 
 func main() {
-	var s string = nil // ERROR "illegal|invalid|incompatible|cannot"
+	var s string = nil;	// ERROR "illegal|invalid|incompatible|cannot"
 }
diff --git a/test/fixedbugs/bug063.go b/test/fixedbugs/bug063.go
index 8e586ac781..a3ae3f0962 100644
--- a/test/fixedbugs/bug063.go
+++ b/test/fixedbugs/bug063.go
@@ -5,5 +5,4 @@
 // license that can be found in the LICENSE file.
 
 package bug063
-
 const c = 0 ^ 0
diff --git a/test/fixedbugs/bug064.go b/test/fixedbugs/bug064.go
index b186bfe6b5..d8b3bea9a6 100644
--- a/test/fixedbugs/bug064.go
+++ b/test/fixedbugs/bug064.go
@@ -6,15 +6,17 @@
 
 package main
 
-func swap(x, y int) (u, v int) {
+func
+swap(x, y int) (u, v int) {
 	return y, x
 }
 
-func main() {
-	a := 1
-	b := 2
-	a, b = swap(swap(a, b))
+func
+main() {
+	a := 1;
+	b := 2;
+	a, b = swap(swap(a, b));
 	if a != 2 || b != 1 {
-		panic("bad swap")
+		panic("bad swap");
 	}
 }
diff --git a/test/fixedbugs/bug065.go b/test/fixedbugs/bug065.go
index 78b98d9621..a1e3b08bba 100644
--- a/test/fixedbugs/bug065.go
+++ b/test/fixedbugs/bug065.go
@@ -7,6 +7,6 @@
 package main
 
 func main() {
-	k, l, m := 0, 0, 0
-	_, _, _ = k, l, m
+	k, l, m := 0,0,0;
+	_, _, _ = k, l, m;
 }
diff --git a/test/fixedbugs/bug066.go b/test/fixedbugs/bug066.go
index 0d43d4c910..db3d7f8602 100644
--- a/test/fixedbugs/bug066.go
+++ b/test/fixedbugs/bug066.go
@@ -7,17 +7,20 @@
 package bug066
 
 type Scope struct {
-	entries map[string]*Object
+	entries map[string] *Object;
 }
 
+
 type Type struct {
-	scope *Scope
+	scope *Scope;
 }
 
+
 type Object struct {
-	typ *Type
+	typ *Type;
 }
 
+
 func Lookup(scope *Scope) *Object {
-	return scope.entries["foo"]
+	return scope.entries["foo"];
 }
diff --git a/test/fixedbugs/bug067.go b/test/fixedbugs/bug067.go
index f1aadb7c64..aaeefb0ba1 100644
--- a/test/fixedbugs/bug067.go
+++ b/test/fixedbugs/bug067.go
@@ -9,7 +9,7 @@ package main
 var c chan int
 
 func main() {
-	c = make(chan int)
-	go func() { c <- 0 }()
+	c = make(chan int);
+	go func() { c <- 0 } ();
 	<-c
 }
diff --git a/test/fixedbugs/bug069.go b/test/fixedbugs/bug069.go
index 4dff02f474..7b07b773d4 100644
--- a/test/fixedbugs/bug069.go
+++ b/test/fixedbugs/bug069.go
@@ -7,14 +7,14 @@
 package main
 
 func main() {
-	c := make(chan int)
-	ok := false
-	var i int
-
-	i, ok = <-c // works
-	_, _ = i, ok
-
-	ca := new([2]chan int)
-	i, ok = <-(ca[0]) // fails: c.go:11: bad shape across assignment - cr=1 cl=2
-	_, _ = i, ok
+	c := make(chan int);
+	ok := false;
+	var i int;
+	
+	i, ok = <-c;  // works
+	_, _ = i, ok;
+	
+	ca := new([2]chan int);
+	i, ok = <-(ca[0]);  // fails: c.go:11: bad shape across assignment - cr=1 cl=2
+	_, _ = i, ok;
 }
diff --git a/test/fixedbugs/bug071.go b/test/fixedbugs/bug071.go
index caae01c6ec..ec38f7a979 100644
--- a/test/fixedbugs/bug071.go
+++ b/test/fixedbugs/bug071.go
@@ -6,18 +6,18 @@
 
 package bug071
 
-type rat struct {
-	den int
+type rat struct  {
+	den  int;
 }
 
 func (u *rat) pr() {
 }
 
 type dch struct {
-	dat chan *rat
+	dat chan  *rat;
 }
 
-func dosplit(in *dch) {
-	dat := <-in.dat
-	_ = dat
+func dosplit(in *dch){
+	dat := <-in.dat;
+	_ = dat;
 }
diff --git a/test/fixedbugs/bug072.go b/test/fixedbugs/bug072.go
index b6f46045b2..05ad93dac2 100644
--- a/test/fixedbugs/bug072.go
+++ b/test/fixedbugs/bug072.go
@@ -7,5 +7,5 @@
 package main
 
 func main() {
-	s := string(bug) // ERROR "undef"
+	s := string(bug);  // ERROR "undef"
 }
diff --git a/test/fixedbugs/bug074.go b/test/fixedbugs/bug074.go
index e632e9bf4e..fb789cb4c1 100644
--- a/test/fixedbugs/bug074.go
+++ b/test/fixedbugs/bug074.go
@@ -7,6 +7,6 @@
 package main
 
 func main() {
-	x := string{'a', 'b', '\n'} // ERROR "composite"
-	print(x)
+	x := string{'a', 'b', '\n'};	// ERROR "composite"
+	print(x);
 }
diff --git a/test/fixedbugs/bug075.go b/test/fixedbugs/bug075.go
index a568b5fa70..d0b7d14e71 100644
--- a/test/fixedbugs/bug075.go
+++ b/test/fixedbugs/bug075.go
@@ -6,13 +6,12 @@
 
 package main
 
-type T struct{ m map[int]int }
-
+type T struct { m map[int]int }
 func main() {
-	t := new(T)
-	t.m = make(map[int]int)
-	var x int
-	var ok bool
-	x, ok = t.m[0] //bug075.go:11: bad shape across assignment - cr=1 cl=2
-	_, _ = x, ok
+	t := new(T);
+	t.m = make(map[int]int);
+	var x int;
+	var ok bool;
+	x, ok = t.m[0];  //bug075.go:11: bad shape across assignment - cr=1 cl=2
+	_, _ = x, ok;
 }
diff --git a/test/fixedbugs/bug076.go b/test/fixedbugs/bug076.go
index 57401318c0..60aaa97608 100644
--- a/test/fixedbugs/bug076.go
+++ b/test/fixedbugs/bug076.go
@@ -12,6 +12,7 @@ exit:
 	goto exit
 }
 
+
 func main() {
 exit:
 	; // this should be legal (labels not properly scoped?)
@@ -19,6 +20,6 @@ exit:
 }
 
 /*
-uetli:~/Source/go/test/bugs gri$ 6g bug076.go
+uetli:~/Source/go/test/bugs gri$ 6g bug076.go 
 bug076.go:11: label redeclared: exit
 */
diff --git a/test/fixedbugs/bug078.go b/test/fixedbugs/bug078.go
index 2a191dc24e..1041b858c8 100644
--- a/test/fixedbugs/bug078.go
+++ b/test/fixedbugs/bug078.go
@@ -6,7 +6,7 @@
 
 package main
 
-func dosplit(wait chan int) {
+func dosplit(wait chan int ){
 	select {
 	case <-wait:
 	}
diff --git a/test/fixedbugs/bug083.dir/bug1.go b/test/fixedbugs/bug083.dir/bug1.go
index 778688e072..ea5bcfe205 100644
--- a/test/fixedbugs/bug083.dir/bug1.go
+++ b/test/fixedbugs/bug083.dir/bug1.go
@@ -10,4 +10,5 @@ import "./bug0"
 // visible here in package bug1.  The test for failure is in
 // ../bug083.go.
 
-var v1 bug0.t0 // ERROR "bug0"
+var v1 bug0.t0;	// ERROR "bug0"
+
diff --git a/test/fixedbugs/bug085.go b/test/fixedbugs/bug085.go
index 6182c6a645..dae83f8a49 100644
--- a/test/fixedbugs/bug085.go
+++ b/test/fixedbugs/bug085.go
@@ -9,7 +9,7 @@ package P
 var x int
 
 func foo() {
-	print(P.x) // ERROR "undefined"
+	print(P.x);  // ERROR "undefined"
 }
 
 /*
diff --git a/test/fixedbugs/bug086.go b/test/fixedbugs/bug086.go
index 97aaa60f91..40d2362066 100644
--- a/test/fixedbugs/bug086.go
+++ b/test/fixedbugs/bug086.go
@@ -8,13 +8,13 @@ package main
 
 func f() int {
 	if false {
-		return 0
+		return 0;
 	}
 	// we should not be able to return successfully w/o a return statement
 } // ERROR "return"
 
 func main() {
-	print(f(), "\n")
+	print(f(), "\n");
 }
 
 /*
diff --git a/test/fixedbugs/bug087.go b/test/fixedbugs/bug087.go
index a973f8b348..67e7210cdb 100644
--- a/test/fixedbugs/bug087.go
+++ b/test/fixedbugs/bug087.go
@@ -6,11 +6,11 @@
 
 package main
 
-const s string = "foo"
+const s string = "foo";
 
 func main() {
-	i := len(s) // should be legal to take len() of a constant
-	_ = i
+	i := len(s);  // should be legal to take len() of a constant
+	_ = i;
 }
 
 /*
diff --git a/test/fixedbugs/bug088.dir/bug0.go b/test/fixedbugs/bug088.dir/bug0.go
index 8bfda6a279..7a6e34747f 100644
--- a/test/fixedbugs/bug088.dir/bug0.go
+++ b/test/fixedbugs/bug088.dir/bug0.go
@@ -4,6 +4,6 @@
 
 package bug0
 
-var V0 func() int
-var V1 func() (a int)
-var V2 func() (a, b int)
+var V0 func() int;
+var V1 func() (a int);
+var V2 func() (a, b int);
diff --git a/test/fixedbugs/bug088.dir/bug1.go b/test/fixedbugs/bug088.dir/bug1.go
index 98a4e7cfe4..2568e37d02 100644
--- a/test/fixedbugs/bug088.dir/bug1.go
+++ b/test/fixedbugs/bug088.dir/bug1.go
@@ -7,10 +7,10 @@ package main
 import P "./bug0"
 
 func main() {
-	a0 := P.V0()     // works
-	a1 := P.V1()     // works
-	a2, b2 := P.V2() // doesn't work
-	_, _, _, _ = a0, a1, a2, b2
+	a0 := P.V0();  // works
+	a1 := P.V1();  // works
+	a2, b2 := P.V2();  // doesn't work
+	_, _, _, _ = a0, a1, a2, b2;
 }
 
 /*
diff --git a/test/fixedbugs/bug089.go b/test/fixedbugs/bug089.go
index e1a87801f0..e88f17babb 100644
--- a/test/fixedbugs/bug089.go
+++ b/test/fixedbugs/bug089.go
@@ -6,15 +6,16 @@
 
 package main
 
-type I1 interface{}
-type I2 interface{ pr() }
+type	I1	interface {}
+type	I2	interface { pr() }
 
-func e() I1
+func	e()	I1;
 
-var i1 I1
-var i2 I2
+var	i1	I1;
+var	i2	I2;
 
-func main() {
+func
+main() {
 
-	i2 = e().(I2) // bug089.go:16: fatal error: agen_inter i2i
+	i2 = e().(I2);	// bug089.go:16: fatal error: agen_inter i2i
 }
diff --git a/test/fixedbugs/bug090.go b/test/fixedbugs/bug090.go
index d074b30880..320bd57f5c 100644
--- a/test/fixedbugs/bug090.go
+++ b/test/fixedbugs/bug090.go
@@ -7,8 +7,8 @@
 package main
 
 const (
-	c3div2 = 3 / 2
-	f3div2 = 3. / 2.
+	c3div2 = 3/2;
+	f3div2 = 3./2.;
 )
 
 func assert(t bool, s string) {
@@ -18,29 +18,29 @@ func assert(t bool, s string) {
 }
 
 func main() {
-	var i int
-	var f float64
+	var i int;
+	var f float64;
 
-	assert(c3div2 == 1, "3/2")
-	assert(f3div2 == 1.5, "3/2")
+	assert(c3div2 == 1, "3/2");
+	assert(f3div2 == 1.5, "3/2");
 
-	i = c3div2
-	assert(i == c3div2, "i == c3div2")
+	i = c3div2;
+	assert(i == c3div2, "i == c3div2");
 
-	f = c3div2
-	assert(f == c3div2, "f == c3div2")
+	f = c3div2;
+	assert(f == c3div2, "f == c3div2");
 
-	f = f3div2
-	assert(f == f3div2, "f == f3div2")
+	f = f3div2;
+	assert(f == f3div2, "f == f3div2");
 
-	i = f3div2 // ERROR "truncate"
-	assert(i == c3div2, "i == c3div2 from f3div2")
-	assert(i != f3div2, "i != f3div2") // ERROR "truncate"
+	i = f3div2;	// ERROR "truncate"
+	assert(i == c3div2, "i == c3div2 from f3div2");
+	assert(i != f3div2, "i != f3div2");	// ERROR "truncate"
 
-	const g float64 = 1.0
-	i = g // ERROR "convert|incompatible|cannot"
+	const g float64 = 1.0;
+	i = g;  // ERROR "convert|incompatible|cannot"
 
-	const h float64 = 3.14
-	i = h      // ERROR "convert|incompatible|cannot"
-	i = int(h) // ERROR "truncate"
+	const h float64 = 3.14;
+	i = h;  // ERROR "convert|incompatible|cannot"
+	i = int(h);	// ERROR "truncate"
 }
diff --git a/test/fixedbugs/bug092.go b/test/fixedbugs/bug092.go
index b34969afd3..8027d941ea 100644
--- a/test/fixedbugs/bug092.go
+++ b/test/fixedbugs/bug092.go
@@ -7,9 +7,9 @@
 package main
 
 func main() {
-	var a [1000]int64  // this alone works
-	var b [10000]int64 // this causes a runtime crash
-	_, _ = a, b
+	var a [1000] int64;  // this alone works
+	var b [10000] int64;  // this causes a runtime crash
+	_, _ = a, b;
 }
 
 /*
diff --git a/test/fixedbugs/bug093.go b/test/fixedbugs/bug093.go
index a3a626a1b0..acd94466f5 100644
--- a/test/fixedbugs/bug093.go
+++ b/test/fixedbugs/bug093.go
@@ -13,15 +13,16 @@ func (p *S) M() {
 }
 
 type I interface {
-	M()
+	M();
 }
 
 func main() {
-	var p *S = nil
-	var i I = p // this should be possible even though p is nil: we still know the type
-	i.M()       // should be possible since we know the type, and don't ever use the receiver
+	var p *S = nil;
+	var i I = p;  // this should be possible even though p is nil: we still know the type
+	i.M();  // should be possible since we know the type, and don't ever use the receiver
 }
 
+
 /*
 throw: ifaces2i: nil pointer
 SIGSEGV: segmentation violation
diff --git a/test/fixedbugs/bug094.go b/test/fixedbugs/bug094.go
index 4456237302..3ef11da3d3 100644
--- a/test/fixedbugs/bug094.go
+++ b/test/fixedbugs/bug094.go
@@ -7,17 +7,19 @@
 package main
 
 func f0() {
-	const x = 0
+	const x = 0;
 }
 
+
 func f1() {
-	x := 0
-	_ = x
+	x := 0;
+	_ = x;
 }
 
+
 func main() {
-	f0()
-	f1()
+	f0();
+	f1();
 }
 
 /*
diff --git a/test/fixedbugs/bug096.go b/test/fixedbugs/bug096.go
index 39ce017bb7..411ba74e0c 100644
--- a/test/fixedbugs/bug096.go
+++ b/test/fixedbugs/bug096.go
@@ -6,12 +6,12 @@
 
 package main
 
-type A []int
+type A []int;
 
 func main() {
-	a := &A{0}
-	b := &A{0, 1}
-	_, _ = a, b
+	a := &A{0};
+	b := &A{0, 1};
+	_, _ = a, b;
 }
 
 /*
diff --git a/test/fixedbugs/bug098.go b/test/fixedbugs/bug098.go
index b872b50fa7..eb4ee4de03 100644
--- a/test/fixedbugs/bug098.go
+++ b/test/fixedbugs/bug098.go
@@ -6,13 +6,13 @@
 
 package main
 
-type A []int
-type M map[int]int
+type A []int;
+type M map[int] int;
 
 func main() {
-	var a *A = &A{0}
-	var m *M = &M{0: 0} // should be legal to use & here for consistency with other composite constructors (prev. line)
-	_, _ = a, m
+	var a *A = &A{0};
+	var m *M = &M{0 : 0};  // should be legal to use & here for consistency with other composite constructors (prev. line)
+	_, _ = a, m;
 }
 
 /*
diff --git a/test/fixedbugs/bug099.go b/test/fixedbugs/bug099.go
index 51b667bca8..03a5c454b0 100644
--- a/test/fixedbugs/bug099.go
+++ b/test/fixedbugs/bug099.go
@@ -7,11 +7,10 @@
 package main
 
 // Interface
-type I interface{ F() int }
+type I interface { F() int }
 
 // Implements interface
-type S struct{}
-
+type S struct { }
 func (s *S) F() int { return 1 }
 
 // Allocates S but returns I
@@ -28,10 +27,11 @@ func Use(x I) {
 }
 
 func main() {
-	i := NewI(0)
-	Use(i)
+	i := NewI(0);
+	Use(i);
 
 	// Again, without temporary
 	// Crashes because x.F is 0.
-	Use(NewI(0))
+	Use(NewI(0));
 }
+
diff --git a/test/fixedbugs/bug101.go b/test/fixedbugs/bug101.go
index 5afc4b6dda..82e496a8a6 100644
--- a/test/fixedbugs/bug101.go
+++ b/test/fixedbugs/bug101.go
@@ -6,14 +6,10 @@
 
 package main
 
-var a = []int{1, 2, 3}
+var a = []int { 1, 2, 3 }
 
 func main() {
-	if len(a) != 3 {
-		panic("array len")
-	}
+	if len(a) != 3 { panic("array len") }
 	// print(a[0], " ", a[1], " ", a[2], "\n")
-	if a[0] != 1 || a[1] != 2 || a[2] != 3 {
-		panic("array contents")
-	}
+	if a[0] != 1 || a[1] != 2 || a[2] != 3 { panic("array contents") }
 }
diff --git a/test/fixedbugs/bug103.go b/test/fixedbugs/bug103.go
index c79ebf25cb..1cb710e368 100644
--- a/test/fixedbugs/bug103.go
+++ b/test/fixedbugs/bug103.go
@@ -6,8 +6,9 @@
 
 package main
 
-func f()/* no return type */ {}
+func f() /* no return type */ {}
 
 func main() {
-	x := f() // ERROR "mismatch|as value|no type"
+	x := f();  // ERROR "mismatch|as value|no type"
 }
+
diff --git a/test/fixedbugs/bug104.go b/test/fixedbugs/bug104.go
index 0e32d94262..f0c19a8aa7 100644
--- a/test/fixedbugs/bug104.go
+++ b/test/fixedbugs/bug104.go
@@ -5,7 +5,6 @@
 // license that can be found in the LICENSE file.
 
 package main
-
 func f() string {
-	return 0 // ERROR "conversion|type"
+	return 0	// ERROR "conversion|type"
 }
diff --git a/test/fixedbugs/bug106.dir/bug1.go b/test/fixedbugs/bug106.dir/bug1.go
index eae2abbbaa..eff0d36ed2 100644
--- a/test/fixedbugs/bug106.dir/bug1.go
+++ b/test/fixedbugs/bug106.dir/bug1.go
@@ -5,3 +5,4 @@
 package bug1
 
 import _ "./bug0"
+
diff --git a/test/fixedbugs/bug107.go b/test/fixedbugs/bug107.go
index 198a1f40f3..dcd8e9d113 100644
--- a/test/fixedbugs/bug107.go
+++ b/test/fixedbugs/bug107.go
@@ -5,14 +5,11 @@
 // license that can be found in the LICENSE file.
 
 package main
-
 import os "os"
-
 type _ os.FileInfo
-
 func f() (os int) {
-	// In the next line "os" should refer to the result variable, not
-	// to the package.
-	v := os.Open("", 0, 0) // ERROR "undefined"
-	return 0
+	 // In the next line "os" should refer to the result variable, not
+	 // to the package.
+	 v := os.Open("", 0, 0);	// ERROR "undefined"
+	 return 0
 }
diff --git a/test/fixedbugs/bug108.go b/test/fixedbugs/bug108.go
index a0f979c3ea..cfec4c9f1f 100644
--- a/test/fixedbugs/bug108.go
+++ b/test/fixedbugs/bug108.go
@@ -5,8 +5,7 @@
 // license that can be found in the LICENSE file.
 
 package main
-
 func f() {
-	v := 1 << 1025 // ERROR "overflow|shift count too large"
+	v := 1 << 1025;		// ERROR "overflow|shift count too large"
 	_ = v
 }
diff --git a/test/fixedbugs/bug111.go b/test/fixedbugs/bug111.go
index c30afbb6d2..d977bd54fb 100644
--- a/test/fixedbugs/bug111.go
+++ b/test/fixedbugs/bug111.go
@@ -6,7 +6,7 @@
 
 package main
 
-var ncall int
+var ncall int;
 
 type Iffy interface {
 	Me() Iffy
@@ -17,15 +17,15 @@ type Stucky struct {
 }
 
 func (s *Stucky) Me() Iffy {
-	ncall++
+	ncall++;
 	return s
 }
 
 func main() {
-	s := new(Stucky)
-	i := s.Me()
-	j := i.Me()
-	j.Me()
+	s := new(Stucky);
+	i := s.Me();
+	j := i.Me();
+	j.Me();
 	if ncall != 3 {
 		panic("bug111")
 	}
diff --git a/test/fixedbugs/bug112.go b/test/fixedbugs/bug112.go
index 2928bc15b5..e2ed5c0d41 100644
--- a/test/fixedbugs/bug112.go
+++ b/test/fixedbugs/bug112.go
@@ -6,8 +6,7 @@
 
 package main
 
-type T struct{ s string }
-
+type T struct { s string }
 var t = T{"hi"}
 
 func main() {}
diff --git a/test/fixedbugs/bug113.go b/test/fixedbugs/bug113.go
index 03e22c0558..a1e61cb36f 100644
--- a/test/fixedbugs/bug113.go
+++ b/test/fixedbugs/bug113.go
@@ -21,7 +21,7 @@ func main() {
 	if foo2(v2) != 1 {
 		panic(2)
 	}
-
+	
 	shouldPanic(p1)
 }
 
diff --git a/test/fixedbugs/bug115.go b/test/fixedbugs/bug115.go
index 726d33c124..7cc3dc40a6 100644
--- a/test/fixedbugs/bug115.go
+++ b/test/fixedbugs/bug115.go
@@ -6,9 +6,9 @@
 
 package main
 
-func isuint(i uint) {}
+func isuint(i uint) { }
 
 func main() {
-	i := ^uint(0)
-	isuint(i)
+	i := ^uint(0);
+	isuint(i);
 }
diff --git a/test/fixedbugs/bug118.go b/test/fixedbugs/bug118.go
index ca7fdbba5d..198b8ff280 100644
--- a/test/fixedbugs/bug118.go
+++ b/test/fixedbugs/bug118.go
@@ -9,7 +9,7 @@ package bug118
 func Send(c chan int) int {
 	select {
 	default:
-		return 1
+		return 1;
 	}
-	return 2
+	return 2;
 }
diff --git a/test/fixedbugs/bug122.go b/test/fixedbugs/bug122.go
index 9ae597462d..fb4eb9f3ad 100644
--- a/test/fixedbugs/bug122.go
+++ b/test/fixedbugs/bug122.go
@@ -8,5 +8,5 @@ package main
 
 func main() {
 	// should allow at most 2 sizes
-	a := make([]int, 10, 20, 30, 40) // ERROR "too many"
+	a := make([]int, 10, 20, 30, 40); // ERROR "too many"
 }
diff --git a/test/fixedbugs/bug123.go b/test/fixedbugs/bug123.go
index 8c4f323761..f38551a914 100644
--- a/test/fixedbugs/bug123.go
+++ b/test/fixedbugs/bug123.go
@@ -5,13 +5,9 @@
 // license that can be found in the LICENSE file.
 
 package main
-
-const (
-	F = 1
-)
-
+const ( F = 1 )
 func fn(i int) int {
-	if i == F() { // ERROR "func"
+	if i == F() {		// ERROR "func"
 		return 0
 	}
 	return 1
diff --git a/test/fixedbugs/bug126.go b/test/fixedbugs/bug126.go
index 8274c1e931..f5d9763412 100644
--- a/test/fixedbugs/bug126.go
+++ b/test/fixedbugs/bug126.go
@@ -7,5 +7,5 @@
 package main
 
 // same const identifier declared twice should not be accepted
-const none = 0 // GCCGO_ERROR "previous"
-const none = 1 // ERROR "redeclared|redef"
+const none = 0  // GCCGO_ERROR "previous"
+const none = 1;  // ERROR "redeclared|redef"
diff --git a/test/fixedbugs/bug127.go b/test/fixedbugs/bug127.go
index 573c40c681..f8ea99470c 100644
--- a/test/fixedbugs/bug127.go
+++ b/test/fixedbugs/bug127.go
@@ -5,9 +5,8 @@
 // license that can be found in the LICENSE file.
 
 package main
-
 func main() {
-	var x int64 = 0
-	println(x != nil) // ERROR "illegal|incompatible|nil"
-	println(0 != nil) // ERROR "illegal|incompatible|nil"
+	var x int64 = 0;
+	println(x != nil);	// ERROR "illegal|incompatible|nil"
+	println(0 != nil);	// ERROR "illegal|incompatible|nil"
 }
diff --git a/test/fixedbugs/bug128.go b/test/fixedbugs/bug128.go
index 7389426c57..e8cbea079f 100644
--- a/test/fixedbugs/bug128.go
+++ b/test/fixedbugs/bug128.go
@@ -5,20 +5,19 @@
 // license that can be found in the LICENSE file.
 
 package main
-
 func main() {
 	switch {
-	// empty switch is allowed according to syntax
-	// unclear why it shouldn't be allowed
+		// empty switch is allowed according to syntax
+		// unclear why it shouldn't be allowed
 	}
 	switch tag := 0; tag {
-	// empty switch is allowed according to syntax
-	// unclear why it shouldn't be allowed
+		// empty switch is allowed according to syntax
+		// unclear why it shouldn't be allowed
 	}
 }
 
 /*
-uetli:~/Source/go1/test/bugs gri$ 6g bug127.go
+uetli:~/Source/go1/test/bugs gri$ 6g bug127.go 
 bug127.go:5: switch statement must have case labels
 bug127.go:9: switch statement must have case labels
 */
diff --git a/test/fixedbugs/bug129.go b/test/fixedbugs/bug129.go
index 64666e9377..157ce78ff7 100644
--- a/test/fixedbugs/bug129.go
+++ b/test/fixedbugs/bug129.go
@@ -5,11 +5,10 @@
 // license that can be found in the LICENSE file.
 
 package foo
-
 import "fmt"
 
 func f() {
-	fmt.Println()
-	fmt := 1
-	_ = fmt
+	fmt.Println();
+	fmt := 1;
+	_ = fmt;
 }
diff --git a/test/fixedbugs/bug130.go b/test/fixedbugs/bug130.go
index ba38bb5551..16b029af34 100644
--- a/test/fixedbugs/bug130.go
+++ b/test/fixedbugs/bug130.go
@@ -8,16 +8,15 @@ package main
 
 import "os"
 
-type I interface{ send(chan<- int) }
+type I interface { send(chan <- int) }
 
-type S struct{ v int }
-
-func (p *S) send(c chan<- int) { c <- p.v }
+type S struct { v int }
+func (p *S) send(c chan <- int) { c <- p.v }
 
 func main() {
-	s := S{0}
-	var i I = &s
-	c := make(chan int)
-	go i.send(c)
-	os.Exit(<-c)
+	s := S{0};
+	var i I = &s;
+	c := make(chan int);
+	go i.send(c);
+	os.Exit(<-c);
 }
diff --git a/test/fixedbugs/bug131.go b/test/fixedbugs/bug131.go
index de606da167..0ebbd26069 100644
--- a/test/fixedbugs/bug131.go
+++ b/test/fixedbugs/bug131.go
@@ -7,6 +7,6 @@
 package main
 
 func main() {
-	const a uint64 = 10
-	var b int64 = a // ERROR "convert|cannot|incompatible"
+	const a uint64 = 10;
+	var b int64 = a;	// ERROR "convert|cannot|incompatible"
 }
diff --git a/test/fixedbugs/bug132.go b/test/fixedbugs/bug132.go
index b9b9e6712b..e334566c79 100644
--- a/test/fixedbugs/bug132.go
+++ b/test/fixedbugs/bug132.go
@@ -7,5 +7,5 @@
 package main
 
 type T struct {
-	x, x int // ERROR "duplicate"
+	x, x int  // ERROR "duplicate"
 }
diff --git a/test/fixedbugs/bug133.dir/bug0.go b/test/fixedbugs/bug133.dir/bug0.go
index 052de3d7ac..19a2bfbd4b 100644
--- a/test/fixedbugs/bug133.dir/bug0.go
+++ b/test/fixedbugs/bug133.dir/bug0.go
@@ -4,4 +4,4 @@
 
 package bug0
 
-type T struct{ i int }
+type T struct { i int }
diff --git a/test/fixedbugs/bug133.dir/bug1.go b/test/fixedbugs/bug133.dir/bug1.go
index d47746e4b5..dd59b2f2ec 100644
--- a/test/fixedbugs/bug133.dir/bug1.go
+++ b/test/fixedbugs/bug133.dir/bug1.go
@@ -6,4 +6,4 @@ package bug1
 
 import "./bug0"
 
-type T struct{ t bug0.T }
+type T struct { t bug0.T }
diff --git a/test/fixedbugs/bug133.dir/bug2.go b/test/fixedbugs/bug133.dir/bug2.go
index 4449ded991..b6184c2e75 100644
--- a/test/fixedbugs/bug133.dir/bug2.go
+++ b/test/fixedbugs/bug133.dir/bug2.go
@@ -7,10 +7,10 @@ package bug2
 import _ "./bug1"
 import "./bug0"
 
-type T2 struct{ t bug0.T }
+type T2 struct { t bug0.T }
 
 func fn(p *T2) int {
 	// This reference should be invalid, because bug0.T.i is local
 	// to package bug0 and should not be visible in package bug1.
-	return p.t.i // ERROR "field|undef"
+	return p.t.i;	// ERROR "field|undef"
 }
diff --git a/test/fixedbugs/bug135.go b/test/fixedbugs/bug135.go
index 5cca2b252d..34d234e224 100644
--- a/test/fixedbugs/bug135.go
+++ b/test/fixedbugs/bug135.go
@@ -6,15 +6,14 @@
 
 package main
 
-type Foo interface{}
-
-type T struct{}
+type Foo interface { }
 
+type T struct {}
 func (t *T) foo() {}
 
 func main() {
-	t := new(T)
-	var i interface{}
-	f, ok := i.(Foo)
-	_, _, _ = t, f, ok
+	t := new(T);
+	var i interface {};
+	f, ok := i.(Foo);
+	_, _, _ = t, f, ok;
 }
diff --git a/test/fixedbugs/bug136.go b/test/fixedbugs/bug136.go
index 2964176afd..bea9bac083 100644
--- a/test/fixedbugs/bug136.go
+++ b/test/fixedbugs/bug136.go
@@ -7,18 +7,16 @@
 package main
 
 func main() {
-L:
-	; // ';' terminates empty statement => L does not apply to for loop
+	L: ;  // ';' terminates empty statement => L does not apply to for loop
 	for i := 0; i < 10; i++ {
-		println(i)
-		break L // ERROR "L"
+		println(i);
+		break L;  // ERROR "L"
 	}
 
-L1:
-	{ // L1 labels block => L1 does not apply to for loop
+	L1: { // L1 labels block => L1 does not apply to for loop
 		for i := 0; i < 10; i++ {
-			println(i)
-			break L1 // ERROR "L1"
+			println(i);
+			break L1;  // ERROR "L1"
 		}
 	}
 }
diff --git a/test/fixedbugs/bug139.go b/test/fixedbugs/bug139.go
index 610a2b87a2..095e5c93cc 100644
--- a/test/fixedbugs/bug139.go
+++ b/test/fixedbugs/bug139.go
@@ -7,17 +7,9 @@
 package main
 
 func main() {
-	x := false
-	func() {
-		if x {
-			println(1)
-		}
-	}() // this does not compile
-	func() {
-		if x == false {
-			println(2)
-		}
-	}() // this works as expected
+	x := false;
+	func () { if x          { println(1); } }();  // this does not compile
+	func () { if x == false { println(2); } }();  // this works as expected
 }
 
 /*
diff --git a/test/fixedbugs/bug141.go b/test/fixedbugs/bug141.go
index f905681b6a..81ba6f1b56 100644
--- a/test/fixedbugs/bug141.go
+++ b/test/fixedbugs/bug141.go
@@ -8,29 +8,25 @@ package main
 
 import "os"
 
-type S struct{ i int }
-
+type S struct { i int }
 func (p *S) Get() int { return p.i }
 
 type Empty interface {
 }
 
 type Getter interface {
-	Get() int
+	Get() int;
 }
 
 func f1(p Empty) {
 	switch x := p.(type) {
-	default:
-		println("failed to match interface", x)
-		os.Exit(1)
-	case Getter:
-		break
+	default: println("failed to match interface", x); os.Exit(1);
+	case Getter: break;
 	}
 
 }
 
 func main() {
-	var s S
-	f1(&s)
+	var s S;
+	f1(&s);
 }
diff --git a/test/fixedbugs/bug142.go b/test/fixedbugs/bug142.go
index 083b6ac8ac..e28d889a93 100644
--- a/test/fixedbugs/bug142.go
+++ b/test/fixedbugs/bug142.go
@@ -7,12 +7,12 @@
 package main
 
 func panic1(s string) bool {
-	panic(s)
+	panic(s);
 }
 
 func main() {
-	x := false && panic1("first") && panic1("second")
-	x = x == true && panic1("first") && panic1("second")
+	x := false && panic1("first") && panic1("second");
+	x = x == true && panic1("first") && panic1("second");
 }
 
 /*
@@ -27,5 +27,5 @@ mainstart+0xf /Users/rsc/goX/src/runtime/amd64/asm.s:53
 	mainstart()
 sys·Goexit /Users/rsc/goX/src/runtime/proc.c:124
 	sys·Goexit()
-;
+; 
 */
diff --git a/test/fixedbugs/bug143.go b/test/fixedbugs/bug143.go
index c4378f27ad..a43e406676 100644
--- a/test/fixedbugs/bug143.go
+++ b/test/fixedbugs/bug143.go
@@ -6,34 +6,34 @@
 
 package main
 
-type myMap map[string]int
+type myMap map[string] int;
 
 func f() myMap {
-	m := make(map[string]int)
+	m := make(map[string] int);
 	return m
 }
 
 func main() {
-	m := make(myMap)
-	mp := &m
+	m := make(myMap);
+	mp := &m;
 
 	{
-		x, ok := m["key"]
-		_, _ = x, ok
+		x, ok := m["key"];
+		_, _ = x, ok;
 	}
 	{
-		x, ok := (*mp)["key"]
-		_, _ = x, ok
+		x, ok := (*mp)["key"];
+		_, _ = x, ok;
 	}
 	{
-		x, ok := f()["key"]
-		_, _ = x, ok
+		x, ok := f()["key"];
+		_, _ = x, ok;
 	}
 	{
-		var x int
-		var ok bool
-		x, ok = f()["key"]
-		_, _ = x, ok
+		var x int;
+		var ok bool;
+		x, ok = f()["key"];
+		_, _ = x, ok;
 	}
 }
 
diff --git a/test/fixedbugs/bug144.go b/test/fixedbugs/bug144.go
index f42e64ee98..9f8ec7667c 100644
--- a/test/fixedbugs/bug144.go
+++ b/test/fixedbugs/bug144.go
@@ -6,11 +6,11 @@
 
 package main
 
-const c = 1
+const c = 1;
 
 func main() {
-	c := 0
-	_ = c
+	c := 0;
+	_ = c;
 }
 
 /*
diff --git a/test/fixedbugs/bug145.go b/test/fixedbugs/bug145.go
index 44bce2a610..602fe7426d 100644
--- a/test/fixedbugs/bug145.go
+++ b/test/fixedbugs/bug145.go
@@ -9,8 +9,8 @@ package main
 type t int
 
 func main() {
-	t := 0
-	_ = t
+	t := 0;
+	_ = t;
 }
 
 /*
diff --git a/test/fixedbugs/bug146.go b/test/fixedbugs/bug146.go
index fcdeb4ce42..e29f910ba5 100644
--- a/test/fixedbugs/bug146.go
+++ b/test/fixedbugs/bug146.go
@@ -7,9 +7,9 @@
 package main
 
 func main() {
-	type Slice []byte
-	a := [...]byte{0}
-	b := Slice(a[0:]) // This should be OK.
-	c := Slice(a)     // ERROR "invalid|illegal|cannot"
-	_, _ = b, c
+	type Slice []byte;
+	a := [...]byte{ 0 };
+	b := Slice(a[0:]);	// This should be OK.
+	c := Slice(a);		// ERROR "invalid|illegal|cannot"
+	_, _ = b, c;
 }
diff --git a/test/fixedbugs/bug148.go b/test/fixedbugs/bug148.go
index e7b544439e..b67870b12a 100644
--- a/test/fixedbugs/bug148.go
+++ b/test/fixedbugs/bug148.go
@@ -6,32 +6,32 @@
 
 package main
 
-type T struct{ a, b int }
+type T struct {a, b int};
 
-func println(x, y int) {}
+func println(x, y int) { }
 
 func f(x interface{}) interface{} {
-	type T struct{ a, b int }
+	type T struct {a, b int};
 
 	if x == nil {
-		return T{2, 3}
+		return T{2, 3};
 	}
 
-	t := x.(T)
-	println(t.a, t.b)
-	return x
+	t := x.(T);
+	println(t.a, t.b);
+	return x;
 }
 
 func main() {
-	inner_T := f(nil)
-	f(inner_T)
+	inner_T := f(nil);
+	f(inner_T);
 
 	shouldPanic(p1)
 }
 
 func p1() {
-	outer_T := T{5, 7}
-	f(outer_T)
+	outer_T := T{5, 7};
+	f(outer_T);
 }
 
 func shouldPanic(f func()) {
diff --git a/test/fixedbugs/bug149.go b/test/fixedbugs/bug149.go
index d18c7479ba..78b687e971 100644
--- a/test/fixedbugs/bug149.go
+++ b/test/fixedbugs/bug149.go
@@ -7,16 +7,16 @@
 package main
 
 func main() {
-	var b1 []byte
-	s1 := string(b1)
-	println(len(s1)) // prints 0
+	var b1 []byte;
+	s1 := string(b1);
+	println(len(s1));  // prints 0
 
-	b2 := ([]byte)(nil)
-	s2 := string(b2)
-	println(len(s2)) // prints 0
+	b2 := ([]byte)(nil);
+	s2 := string(b2);
+	println(len(s2));  // prints 0
 
-	s3 := string(([]byte)(nil)) // does not compile (literal substitution of b2)
-	println(len(s3))
+	s3 := string(([]byte)(nil));  // does not compile (literal substitution of b2)
+	println(len(s3));
 }
 
 /*
diff --git a/test/fixedbugs/bug150.go b/test/fixedbugs/bug150.go
index b2c4f15dc4..b565ef73dd 100644
--- a/test/fixedbugs/bug150.go
+++ b/test/fixedbugs/bug150.go
@@ -7,16 +7,15 @@
 package bug150
 
 type T int
-
 func (t T) M()
 
-type M interface{ M() }
+type M interface { M() } 
 
 func g() (T, T)
 
 func f() (a, b M) {
-	a, b = g()
-	return
+	a, b = g();
+	return;
 }
 
 /*
diff --git a/test/fixedbugs/bug151.go b/test/fixedbugs/bug151.go
index 87a9c0201d..d9f5e021c9 100644
--- a/test/fixedbugs/bug151.go
+++ b/test/fixedbugs/bug151.go
@@ -8,10 +8,10 @@ package bug151
 
 type S string
 
-type Empty interface{}
+type Empty interface {}
 
 func (v S) Less(e Empty) bool {
-	return v < e.(S)
+	return v < e.(S);
 }
 
 /*
diff --git a/test/fixedbugs/bug152.go b/test/fixedbugs/bug152.go
index 2f297656e4..45b9b3d530 100644
--- a/test/fixedbugs/bug152.go
+++ b/test/fixedbugs/bug152.go
@@ -7,11 +7,11 @@
 package main
 
 func main() {
-	s := 0
+	s := 0;
 	for _, v := range []int{1} {
-		s += v
+		s += v;
 	}
 	if s != 1 {
-		println("BUG: s =", s)
+		println("BUG: s =", s);
 	}
 }
diff --git a/test/fixedbugs/bug154.go b/test/fixedbugs/bug154.go
index 3162e80a4f..a2cfd4accd 100644
--- a/test/fixedbugs/bug154.go
+++ b/test/fixedbugs/bug154.go
@@ -9,23 +9,25 @@ package main
 import "fmt"
 
 func f0() string {
-	const f = 3.141592
-	return fmt.Sprintf("%v", float64(f))
+	const f = 3.141592;
+	return fmt.Sprintf("%v", float64(f));
 }
 
+
 func f1() string {
-	const f = 3.141592
-	x := float64(float32(f)) // appears to change the precision of f
-	_ = x
-	return fmt.Sprintf("%v", float64(f))
+	const f = 3.141592;
+	x := float64(float32(f));  // appears to change the precision of f
+	_ = x;
+	return fmt.Sprintf("%v", float64(f));
 }
 
+
 func main() {
-	r0 := f0()
-	r1 := f1()
+	r0 := f0();
+	r1 := f1();
 	if r0 != r1 {
-		println("r0 =", r0)
-		println("r1 =", r1)
-		panic("r0 and r1 should be the same")
+		println("r0 =", r0);
+		println("r1 =", r1);
+		panic("r0 and r1 should be the same");
 	}
 }
diff --git a/test/fixedbugs/bug155.go b/test/fixedbugs/bug155.go
index ba2f1c04ca..8872e978da 100644
--- a/test/fixedbugs/bug155.go
+++ b/test/fixedbugs/bug155.go
@@ -6,7 +6,7 @@
 
 package main
 
-const big uint64 = 1 << 63
+const big uint64 = 1<<63
 
 func f(a uint64) uint64 {
 	return a << big
diff --git a/test/fixedbugs/bug156.go b/test/fixedbugs/bug156.go
index 7b6825fe83..f26658729f 100644
--- a/test/fixedbugs/bug156.go
+++ b/test/fixedbugs/bug156.go
@@ -7,9 +7,9 @@
 package main
 
 func f(a int64) int64 {
-	const b int64 = 0
-	n := a &^ b
-	return n
+	const b int64 = 0;
+	n := a &^ b;
+	return n;
 }
 
 func main() {
diff --git a/test/fixedbugs/bug157.go b/test/fixedbugs/bug157.go
index 160762c1cc..1072d7df49 100644
--- a/test/fixedbugs/bug157.go
+++ b/test/fixedbugs/bug157.go
@@ -9,26 +9,23 @@ package main
 func f() {}
 
 func main() {
-	x := 0
+	x := 0;
 
 	// this compiles
 	switch x {
-	case 0:
-		f()
-	default:
-		f()
+	case 0: f();
+	default: f();
 	}
 
 	// this doesn't but it should
 	// (semicolons are not needed at the end of a statement list)
 	switch x {
-	case 0:
-		f()
-	default:
-		f()
+	case 0: f()
+	default: f()
 	}
 }
 
+
 /*
 bug157.go:20: syntax error near default
 bug157.go:20: first switch statement must be a case
diff --git a/test/fixedbugs/bug158.go b/test/fixedbugs/bug158.go
index 3e5c0eab29..496d7e0db0 100644
--- a/test/fixedbugs/bug158.go
+++ b/test/fixedbugs/bug158.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	x := 0
+	x := 0;
 
 	// this compiles
 	switch x {
@@ -20,6 +20,7 @@ func main() {
 	}
 }
 
+
 /*
 bug158.go:14: fatal error: dowidth: unknown type: E-33
 */
diff --git a/test/fixedbugs/bug159.go b/test/fixedbugs/bug159.go
index 7dd0497135..92d5345635 100644
--- a/test/fixedbugs/bug159.go
+++ b/test/fixedbugs/bug159.go
@@ -9,9 +9,9 @@ package main
 import "os"
 
 func main() {
-	ok := true
-	var a, b, c, x, y, z int
-	f := func() int { b--; return -b }
+	ok := true;
+	var a, b, c, x, y, z int;
+	f := func() int { b--; return -b };
 
 	// this fails on 6g: apparently it rewrites
 	// the list into
@@ -19,21 +19,21 @@ func main() {
 	//	y = f();
 	//	x = f();
 	// so that the values come out backward.
-	x, y, z = f(), f(), f()
+	x, y, z = f(), f(), f();
 	if x != 1 || y != 2 || z != 3 {
-		println("xyz: expected 1 2 3 got", x, y, z)
-		ok = false
+		println("xyz: expected 1 2 3 got", x, y, z);
+		ok = false;
 	}
 
 	// this fails on 6g too.  one of the function calls
 	// happens after assigning to b.
-	a, b, c = f(), f(), f()
+	a, b, c = f(), f(), f();
 	if a != 4 || b != 5 || c != 6 {
-		println("abc: expected 4 5 6 got", a, b, c)
-		ok = false
+		println("abc: expected 4 5 6 got", a, b, c);
+		ok = false;
 	}
 
 	if !ok {
-		os.Exit(1)
+		os.Exit(1);
 	}
 }
diff --git a/test/fixedbugs/bug160.dir/y.go b/test/fixedbugs/bug160.dir/y.go
index 87039c98bc..428808dd19 100644
--- a/test/fixedbugs/bug160.dir/y.go
+++ b/test/fixedbugs/bug160.dir/y.go
@@ -9,11 +9,11 @@ import "./x"
 
 func main() {
 	if x.Zero != 0 {
-		println("x.Zero = ", x.Zero)
-		os.Exit(1)
+		println("x.Zero = ", x.Zero);
+		os.Exit(1);
 	}
 	if x.Ten != 10 {
-		println("x.Ten = ", x.Ten)
-		os.Exit(1)
+		println("x.Ten = ", x.Ten);
+		os.Exit(1);
 	}
 }
diff --git a/test/fixedbugs/bug161.go b/test/fixedbugs/bug161.go
index bf3c91eb82..aab58ee895 100644
--- a/test/fixedbugs/bug161.go
+++ b/test/fixedbugs/bug161.go
@@ -6,10 +6,10 @@
 
 package P
 
-const a = 0
+const a = 0;
 
 func f(a int) {
-	a = 0
+	a = 0;
 }
 
 /*
diff --git a/test/fixedbugs/bug165.go b/test/fixedbugs/bug165.go
index 487ee992b9..f8d50af13f 100644
--- a/test/fixedbugs/bug165.go
+++ b/test/fixedbugs/bug165.go
@@ -7,9 +7,9 @@
 package main
 
 type I interface {
-	m(map[I]bool) // ok
+	m(map[I] bool);	// ok
 }
 
 type S struct {
-	m map[S]bool // ERROR "map key type"
+	m map[S] bool;	// ERROR "map key type"
 }
diff --git a/test/fixedbugs/bug170.go b/test/fixedbugs/bug170.go
index 3255a04b85..11ff5ff3c7 100644
--- a/test/fixedbugs/bug170.go
+++ b/test/fixedbugs/bug170.go
@@ -5,11 +5,10 @@
 // license that can be found in the LICENSE file.
 
 package main
-
-var v1 = ([10]int)(nil) // ERROR "illegal|nil|invalid"
-var v2 [10]int = nil    // ERROR "illegal|nil|incompatible"
-var v3 [10]int
-var v4 = nil // ERROR "nil"
+var v1 = ([10]int)(nil);	// ERROR "illegal|nil|invalid"
+var v2 [10]int = nil;		// ERROR "illegal|nil|incompatible"
+var v3 [10]int;
+var v4 = nil;	// ERROR "nil"
 func main() {
-	v3 = nil // ERROR "illegal|nil|incompatible"
+	v3 = nil;		// ERROR "illegal|nil|incompatible"
 }
diff --git a/test/fixedbugs/bug171.go b/test/fixedbugs/bug171.go
index 9284b686f4..49bbb3b892 100644
--- a/test/fixedbugs/bug171.go
+++ b/test/fixedbugs/bug171.go
@@ -6,5 +6,5 @@
 
 package main
 
-func f() int       {} // ERROR "return|control"
-func g() (foo int) {} // ERROR "return|control"
+func f() int { }	// ERROR "return|control"
+func g() (foo int) { }	// ERROR "return|control"
diff --git a/test/fixedbugs/bug172.go b/test/fixedbugs/bug172.go
index a4ee045ba5..4dbe7930f9 100644
--- a/test/fixedbugs/bug172.go
+++ b/test/fixedbugs/bug172.go
@@ -7,6 +7,6 @@
 package main
 
 func f() {
-	a := true
-	a |= a // ERROR "illegal.*OR|bool|expected"
+	a := true;
+	a |= a;	// ERROR "illegal.*OR|bool|expected"
 }
diff --git a/test/fixedbugs/bug173.go b/test/fixedbugs/bug173.go
index 20813cec99..3515c649bb 100644
--- a/test/fixedbugs/bug173.go
+++ b/test/fixedbugs/bug173.go
@@ -11,10 +11,9 @@
 package main
 
 type T string
-
 func main() {
-	var t T = "hello"
-	println(t[0:4], t[4])
+	var t T = "hello";
+	println(t[0:4], t[4]);
 	for _, _ = range t {
 	}
 	for _ = range t {
diff --git a/test/fixedbugs/bug174.go b/test/fixedbugs/bug174.go
index c06670859d..448f630867 100644
--- a/test/fixedbugs/bug174.go
+++ b/test/fixedbugs/bug174.go
@@ -7,6 +7,6 @@
 package main
 
 func main() {
-	var x uint
-	println(1 << x)
+	var x uint;
+	println(1<<x);
 }
diff --git a/test/fixedbugs/bug175.go b/test/fixedbugs/bug175.go
index 55a161910b..5fca4b22bc 100644
--- a/test/fixedbugs/bug175.go
+++ b/test/fixedbugs/bug175.go
@@ -9,6 +9,6 @@ package main
 func f() (int, bool) { return 0, true }
 
 func main() {
-	x, y := f(), 2 // ERROR "multi"
+	x, y := f(), 2;	// ERROR "multi"
 	_, _ = x, y
 }
diff --git a/test/fixedbugs/bug176.go b/test/fixedbugs/bug176.go
index 82b6033090..ea3a909747 100644
--- a/test/fixedbugs/bug176.go
+++ b/test/fixedbugs/bug176.go
@@ -8,6 +8,7 @@ package main
 
 var x int
 
-var a = []int{x: 1} // ERROR "constant"
+var a = []int{ x: 1}	// ERROR "constant"
 var b = [...]int{x: 1}
-var c = map[int]int{x: 1}
+var c = map[int]int{ x: 1}
+
diff --git a/test/fixedbugs/bug181.go b/test/fixedbugs/bug181.go
index b854cfd7ca..4827e9cf03 100644
--- a/test/fixedbugs/bug181.go
+++ b/test/fixedbugs/bug181.go
@@ -7,5 +7,5 @@
 package main
 
 type T *struct {
-	T // ERROR "embed.*pointer"
+	T;	// ERROR "embed.*pointer"
 }
diff --git a/test/fixedbugs/bug182.go b/test/fixedbugs/bug182.go
index fad2bb612d..e02dc59f86 100644
--- a/test/fixedbugs/bug182.go
+++ b/test/fixedbugs/bug182.go
@@ -7,7 +7,7 @@
 package main
 
 func main() {
-	x := 0
-	if x { // ERROR "x.*int|bool"
+	x := 0;
+	if x {	// ERROR "x.*int|bool"
 	}
 }
diff --git a/test/fixedbugs/bug183.go b/test/fixedbugs/bug183.go
index d746981dd0..dc9f5356e0 100644
--- a/test/fixedbugs/bug183.go
+++ b/test/fixedbugs/bug183.go
@@ -9,18 +9,19 @@ package main
 type T int
 
 func f() {
-	var x struct{ T }
-	var y struct{ T T }
-	x = y // ERROR "cannot|incompatible"
-	_ = x
+	var x struct { T };
+	var y struct { T T };
+	x = y;	// ERROR "cannot|incompatible"
+	_ = x;
 }
 
-type T1 struct{ T }
-type T2 struct{ T T }
+type T1 struct { T }
+type T2 struct { T T }
 
 func g() {
-	var x T1
-	var y T2
-	x = y // ERROR "cannot|incompatible"
-	_ = x
+	var x T1;
+	var y T2;
+	x = y;	// ERROR "cannot|incompatible"
+	_ = x;
 }
+
diff --git a/test/fixedbugs/bug186.go b/test/fixedbugs/bug186.go
index 5f37cc4044..5aefd7e5cf 100644
--- a/test/fixedbugs/bug186.go
+++ b/test/fixedbugs/bug186.go
@@ -8,10 +8,10 @@ package main
 
 const X = iota
 
-func f(x int) {}
+func f(x int) { }
 
 func main() {
-	f(X)
-	f(iota) // ERROR "iota"
-	f(X)
+	f(X);
+	f(iota);	// ERROR "iota"
+	f(X);
 }
diff --git a/test/fixedbugs/bug187.go b/test/fixedbugs/bug187.go
index fe7c450967..5c3c2bb1e1 100644
--- a/test/fixedbugs/bug187.go
+++ b/test/fixedbugs/bug187.go
@@ -10,13 +10,13 @@ import "os"
 
 func main() {
 	// This bug doesn't arise with [...]int, or []interface{} or [3]interface{}.
-	a := [...]interface{}{1, 2, 3}
-	n := 1
+	a := [...]interface{} { 1, 2, 3 };
+	n := 1;
 	for _, v := range a {
 		if v.(int) != n {
-			println("BUG:", n, v.(int))
-			os.Exit(0)
+			println("BUG:", n, v.(int));
+			os.Exit(0);
 		}
-		n++
+		n++;
 	}
 }
diff --git a/test/fixedbugs/bug188.go b/test/fixedbugs/bug188.go
index 8d5a58928b..5506147894 100644
--- a/test/fixedbugs/bug188.go
+++ b/test/fixedbugs/bug188.go
@@ -9,7 +9,7 @@ package main
 import "sort"
 
 func main() {
-	sort.Sort(nil)
-	var x int
-	sort(x) // ERROR "package"
+	sort.Sort(nil);
+	var x int;
+	sort(x);	// ERROR "package"
 }
diff --git a/test/fixedbugs/bug189.go b/test/fixedbugs/bug189.go
index cde34c14ba..9e412c66d8 100644
--- a/test/fixedbugs/bug189.go
+++ b/test/fixedbugs/bug189.go
@@ -11,8 +11,8 @@ type S struct {
 }
 
 func main() {
-	s1 := S{a: 7}  // ok - field is named
-	s3 := S{7, 11} // ok - all fields have values
-	s2 := S{7}     // ERROR "too few"
-	_, _, _ = s1, s3, s2
+	s1 := S{a: 7};	// ok - field is named
+	s3 := S{7, 11};	// ok - all fields have values
+	s2 := S{7};	// ERROR "too few"
+	_, _, _ = s1, s3, s2;
 }
diff --git a/test/fixedbugs/bug190.go b/test/fixedbugs/bug190.go
index 4442609c47..bb2d81cbb9 100644
--- a/test/fixedbugs/bug190.go
+++ b/test/fixedbugs/bug190.go
@@ -7,20 +7,20 @@
 package main
 
 type S struct {
-	p *S
-	s []S
-	m map[int]S
-	c chan S
-	i interface{ f(S) }
-	f func(S) S
+	p *S;
+	s []S;
+	m map[int] S;
+	c chan S;
+	i interface { f(S); };
+	f func(S) S;
 }
 
 func main() {
-	var s S
-	s.p = &s
-	s.s = make([]S, 1)
-	s.s[0] = s
-	s.m[0] = s
-	s.c <- s
-	s.i.f(s)
+	var s S;
+	s.p = &s;
+	s.s = make([]S, 1);
+	s.s[0] = s;
+	s.m[0] = s;
+	s.c <- s;
+	s.i.f(s);
 }
diff --git a/test/fixedbugs/bug191.dir/a.go b/test/fixedbugs/bug191.dir/a.go
index b39256b9b9..139a8a3a23 100644
--- a/test/fixedbugs/bug191.dir/a.go
+++ b/test/fixedbugs/bug191.dir/a.go
@@ -10,4 +10,5 @@ func init() {
 	A = 1
 }
 
-type T int
+type T int;
+
diff --git a/test/fixedbugs/bug191.dir/b.go b/test/fixedbugs/bug191.dir/b.go
index 1af37e1353..36770f6fc9 100644
--- a/test/fixedbugs/bug191.dir/b.go
+++ b/test/fixedbugs/bug191.dir/b.go
@@ -10,4 +10,4 @@ func init() {
 	B = 2
 }
 
-type V int
+type V int;
diff --git a/test/fixedbugs/bug192.go b/test/fixedbugs/bug192.go
index fd22e87dee..679aaed1f2 100644
--- a/test/fixedbugs/bug192.go
+++ b/test/fixedbugs/bug192.go
@@ -6,6 +6,6 @@
 
 package main
 
-import "fmt" // GCCGO_ERROR "previous"
+import "fmt"	// GCCGO_ERROR "previous"
 
-var fmt int // ERROR "redecl|redefinition"
+var fmt int	// ERROR "redecl|redefinition"
diff --git a/test/fixedbugs/bug195.go b/test/fixedbugs/bug195.go
index 660f20a5b2..8d392bda71 100644
--- a/test/fixedbugs/bug195.go
+++ b/test/fixedbugs/bug195.go
@@ -6,22 +6,22 @@
 
 package main
 
-type I1 interface{ I2 } // ERROR "interface"
+type I1 interface { I2 }	// ERROR "interface"
 type I2 int
 
-type I3 interface{ int } // ERROR "interface"
+type I3 interface { int }	// ERROR "interface"
 
 type S struct {
-	x interface{ S } // ERROR "interface"
+	x interface{ S }	// ERROR "interface"
 }
 type I4 interface { // GC_ERROR "invalid recursive type"
-	I4 // GCCGO_ERROR "interface"
+	I4	// GCCGO_ERROR "interface"
 }
 
 type I5 interface {
-	I6 // GCCGO_ERROR "interface"
+	I6	// GCCGO_ERROR "interface"
 }
 
 type I6 interface { // GC_ERROR "invalid recursive type"
-	I5 // GCCGO_ERROR "interface"
+	I5	// GCCGO_ERROR "interface"
 }
diff --git a/test/fixedbugs/bug197.go b/test/fixedbugs/bug197.go
index bbeece81b1..4a9f103ea0 100644
--- a/test/fixedbugs/bug197.go
+++ b/test/fixedbugs/bug197.go
@@ -11,19 +11,18 @@ type U int
 
 var x int
 
-var t T = int(0)  // ERROR "cannot use|incompatible"
-var t1 T = int(x) // ERROR "cannot use|incompatible"
-var u U = int(0)  // ERROR "cannot use|incompatible"
-var u1 U = int(x) // ERROR "cannot use|incompatible"
+var t T = int(0)	// ERROR "cannot use|incompatible"
+var t1 T = int(x)	// ERROR "cannot use|incompatible"
+var u U = int(0)	// ERROR "cannot use|incompatible"
+var u1 U = int(x)	// ERROR "cannot use|incompatible"
 
 type S string
-
 var s S
 
 var s1 = s + "hello"
 var s2 = "hello" + s
-var s3 = s + string("hello") // ERROR "invalid operation|incompatible"
-var s4 = string("hello") + s // ERROR "invalid operation|incompatible"
+var s3 = s + string("hello")	// ERROR "invalid operation|incompatible"
+var s4 = string("hello") + s	// ERROR "invalid operation|incompatible"
 
 var r string
 
@@ -31,3 +30,4 @@ var r1 = r + "hello"
 var r2 = "hello" + r
 var r3 = r + string("hello")
 var r4 = string("hello") + r
+
diff --git a/test/fixedbugs/bug198.go b/test/fixedbugs/bug198.go
index 7f13234400..73bb64688a 100644
--- a/test/fixedbugs/bug198.go
+++ b/test/fixedbugs/bug198.go
@@ -5,9 +5,8 @@
 // license that can be found in the LICENSE file.
 
 package main
-
-func f(a T) T { return a } // ERROR "undefined"
+func f(a T) T { return a }	// ERROR "undefined"
 func main() {
-	x := f(0)
-	_ = x
+	x := f(0);
+	_ = x;
 }
diff --git a/test/fixedbugs/bug200.go b/test/fixedbugs/bug200.go
index c4d71893cc..da628faf5d 100644
--- a/test/fixedbugs/bug200.go
+++ b/test/fixedbugs/bug200.go
@@ -11,9 +11,9 @@ func main() {
 	// hash codes so it missed the duplication
 	// and worse, compiled the wrong code
 	// for one of them.
-	var x interface{}
+	var x interface{};
 	switch x.(type) {
 	case func(int):
-	case func(f int): // ERROR "duplicate"
+	case func(f int):	// ERROR "duplicate"
 	}
 }
diff --git a/test/fixedbugs/bug202.go b/test/fixedbugs/bug202.go
index 892501e5d4..49871e3e06 100644
--- a/test/fixedbugs/bug202.go
+++ b/test/fixedbugs/bug202.go
@@ -5,11 +5,12 @@
 // license that can be found in the LICENSE file.
 
 package main
-
 func f() {
-	v := [...]string{"a", "b"}
-	_ = v
+	v := [...]string{"a", "b"};
+	_ = v;
 }
 func main() {
-	f()
+	f();
 }
+
+
diff --git a/test/fixedbugs/bug203.go b/test/fixedbugs/bug203.go
index b3917c453f..68647ec372 100644
--- a/test/fixedbugs/bug203.go
+++ b/test/fixedbugs/bug203.go
@@ -8,9 +8,11 @@ package main
 
 var s [8]string
 
-func init() {
-	s = [...]string{"now", "is", "the", "time", "to", "fix", "this", "bug"}
+func
+init() {
+       s = [...]string{ "now", "is", "the", "time", "to", "fix", "this", "bug"}
 }
 
-func main() {
+func
+main() {
 }
diff --git a/test/fixedbugs/bug205.go b/test/fixedbugs/bug205.go
index b6e54a9adf..1e0d9d1f34 100644
--- a/test/fixedbugs/bug205.go
+++ b/test/fixedbugs/bug205.go
@@ -7,11 +7,12 @@
 package main
 
 var t []int
-var s string
-var m map[string]int
+var s string;
+var m map[string]int;
 
 func main() {
-	println(t["hi"]) // ERROR "non-integer slice index|must be integer"
-	println(s["hi"]) // ERROR "non-integer string index|must be integer"
-	println(m[0])    // ERROR "cannot use.*as type string"
+	println(t["hi"]); // ERROR "non-integer slice index|must be integer"
+	println(s["hi"]); // ERROR "non-integer string index|must be integer"
+	println(m[0]);    // ERROR "cannot use.*as type string"
 }
+
diff --git a/test/fixedbugs/bug206.go b/test/fixedbugs/bug206.go
index 7f35f15ecb..91efa3ff79 100644
--- a/test/fixedbugs/bug206.go
+++ b/test/fixedbugs/bug206.go
@@ -6,25 +6,28 @@
 
 package main
 
-import "go/ast"
+import "go/ast";
 
 func g(list []ast.Expr) {
-	n := len(list) - 1
-	println(list[n].Pos())
+	n := len(list)-1;
+	println(list[n].Pos());
 }
 
+
 // f is the same as g except that the expression assigned to n is inlined.
 func f(list []ast.Expr) {
 	// n := len(list)-1;
-	println(list[len(list)-1 /* n */].Pos())
+	println(list[len(list)-1 /* n */].Pos());
 }
 
+
 func main() {
-	list := []ast.Expr{&ast.Ident{}}
-	g(list) // this works
-	f(list) // this doesn't
+	list := []ast.Expr{&ast.Ident{}};
+	g(list);  // this works
+	f(list);  // this doesn't
 }
 
+
 /*
 0
 throw: index out of range
diff --git a/test/fixedbugs/bug207.go b/test/fixedbugs/bug207.go
index 4a6d5b19b8..50923df1c2 100644
--- a/test/fixedbugs/bug207.go
+++ b/test/fixedbugs/bug207.go
@@ -12,12 +12,12 @@ package main
 import "fmt"
 
 type T struct {
-	a, b, c, d, e []int
+	a, b, c, d, e []int;
 }
 
 var t T
 
 func main() {
-	if fmt.Sprint("xxx", t) != "yyy" {
+	if fmt.Sprint("xxx", t) != "yyy" { 
 	}
 }
diff --git a/test/fixedbugs/bug208.go b/test/fixedbugs/bug208.go
index d9def8ea3d..09ec0afbed 100644
--- a/test/fixedbugs/bug208.go
+++ b/test/fixedbugs/bug208.go
@@ -6,13 +6,15 @@
 
 package main
 
-type T struct {
-	f int
+type	T struct
+{
+	f int;
 }
 
 // 6g used to get confused by the f:1 above
 // and allow uses of f that would be silently
 // dropped during the compilation.
-var _ = f // ERROR "undefined"
+var _ = f;	// ERROR "undefined"
 
 var _ = T{f: 1}
+
diff --git a/test/fixedbugs/bug209.go b/test/fixedbugs/bug209.go
index 6b5fad99da..52faf1fb92 100644
--- a/test/fixedbugs/bug209.go
+++ b/test/fixedbugs/bug209.go
@@ -7,8 +7,8 @@
 package main
 
 func main() {
-	var buf [10]int
-	for len(buf) { // ERROR "bool"
+	var buf [10]int;
+	for ; len(buf); {  // ERROR "bool"
 	}
 }
 
diff --git a/test/fixedbugs/bug211.go b/test/fixedbugs/bug211.go
index b18887292d..b150479276 100644
--- a/test/fixedbugs/bug211.go
+++ b/test/fixedbugs/bug211.go
@@ -6,12 +6,9 @@
 
 package main
 
-type R interface{ duplicate() }
-type S interface{ duplicate() }
-type T interface {
-	R
-	S
-} // ERROR "duplicate"
+type R interface { duplicate() }
+type S interface { duplicate() }
+type T interface { R; S }	// ERROR "duplicate"
 
 func main() {
 }
diff --git a/test/fixedbugs/bug212.go b/test/fixedbugs/bug212.go
index b3c8b1598e..4e58b91ec0 100644
--- a/test/fixedbugs/bug212.go
+++ b/test/fixedbugs/bug212.go
@@ -5,10 +5,8 @@
 // license that can be found in the LICENSE file.
 
 package main
-
 type I int
-type S struct{ f map[I]int }
-
-var v1 = S{make(map[int]int)}    // ERROR "cannot|illegal|incompatible|wrong"
-var v2 map[I]int = map[int]int{} // ERROR "cannot|illegal|incompatible|wrong"
-var v3 = S{make(map[uint]int)}   // ERROR "cannot|illegal|incompatible|wrong"
+type S struct { f map[I]int }
+var v1 = S{ make(map[int]int) }		// ERROR "cannot|illegal|incompatible|wrong"
+var v2 map[I]int = map[int]int{}	// ERROR "cannot|illegal|incompatible|wrong"
+var v3 = S{ make(map[uint]int) }	// ERROR "cannot|illegal|incompatible|wrong"
diff --git a/test/fixedbugs/bug213.go b/test/fixedbugs/bug213.go
index adb9b756d2..7f4786b52b 100644
--- a/test/fixedbugs/bug213.go
+++ b/test/fixedbugs/bug213.go
@@ -5,13 +5,12 @@
 // license that can be found in the LICENSE file.
 
 package main
-
 func main() {
-	var v interface{} = 0
+	var v interface{} = 0;
 	switch v.(type) {
 	case int:
-		fallthrough // ERROR "fallthrough"
+		fallthrough;		// ERROR "fallthrough"
 	default:
-		panic("fell through")
+		panic("fell through");
 	}
 }
diff --git a/test/fixedbugs/bug214.go b/test/fixedbugs/bug214.go
index ac4df4010d..f3c25e727f 100644
--- a/test/fixedbugs/bug214.go
+++ b/test/fixedbugs/bug214.go
@@ -10,6 +10,6 @@
 package main
 
 func main() {
-	x := make(map[int]int, 10)
-	x[0], x[1] = 2, 6
+	x := make(map[int]int, 10);
+	x[0], x[1] = 2, 6;
 }
diff --git a/test/fixedbugs/bug215.go b/test/fixedbugs/bug215.go
index 16bfb15979..b27cc7db1a 100644
--- a/test/fixedbugs/bug215.go
+++ b/test/fixedbugs/bug215.go
@@ -9,6 +9,6 @@
 
 package main
 
-type A struct{ a A } // ERROR "recursive"
-func foo()           { new(A).bar() }
-func (a A) bar()     {}
+type A struct {	a A }	// ERROR "recursive"
+func foo()		{ new(A).bar() }
+func (a A) bar()	{}
diff --git a/test/fixedbugs/bug216.go b/test/fixedbugs/bug216.go
index 25b777fb5a..470369a6a8 100644
--- a/test/fixedbugs/bug216.go
+++ b/test/fixedbugs/bug216.go
@@ -9,7 +9,7 @@
 
 package main
 
-func complexSqrt(i int) (int, int) { return 0, 1 }
+func complexSqrt(i int) (int, int)	{ return 0, 1 }
 
 var re, im = complexSqrt(-1)
 
diff --git a/test/fixedbugs/bug217.go b/test/fixedbugs/bug217.go
index 5e89310439..ea836b9b6d 100644
--- a/test/fixedbugs/bug217.go
+++ b/test/fixedbugs/bug217.go
@@ -9,8 +9,9 @@
 
 package main
 
-func () x() // ERROR "no receiver"
+func () x()	// ERROR "no receiver"
 
-func (a b, c d) x() // ERROR "multiple receiver"
+func (a b, c d) x()	// ERROR "multiple receiver"
 
 type b int
+
diff --git a/test/fixedbugs/bug218.go b/test/fixedbugs/bug218.go
index 85bc38e49b..f159f05fa8 100644
--- a/test/fixedbugs/bug218.go
+++ b/test/fixedbugs/bug218.go
@@ -10,7 +10,7 @@
 package main
 
 func main() {
-	bar := make(chan bool)
+	bar := make(chan bool);
 	select {
 	case _ = <-bar:
 		return
@@ -18,6 +18,6 @@ func main() {
 }
 
 /*
-6g bug218.go
+6g bug218.go 
 <epoch>: fatal error: dowidth: unknown type: blank
 */
diff --git a/test/fixedbugs/bug219.go b/test/fixedbugs/bug219.go
index 0d5afd70f5..290c691eab 100644
--- a/test/fixedbugs/bug219.go
+++ b/test/fixedbugs/bug219.go
@@ -12,10 +12,9 @@ func f(func()) int { return 0 }
 // bug219.go:16: syntax error near if
 func g1() {
 	if x := f(func() {
-		if true {
-		}
+		if true {}
 	}); true {
-		_ = x
+		_ = x;
 	}
 }
 
@@ -24,17 +23,16 @@ func g2() {
 	if x := f(func() {
 		//if true {}
 	}); true {
-		_ = x
+		_ = x;
 	}
 }
 
 // this works
 func g3() {
 	x := f(func() {
-		if true {
-		}
-	})
+		if true {}
+	});
 	if true {
-		_ = x
+		_ = x;
 	}
 }
diff --git a/test/fixedbugs/bug222.dir/chanbug.go b/test/fixedbugs/bug222.dir/chanbug.go
index 75332d86c4..16920246e0 100644
--- a/test/fixedbugs/bug222.dir/chanbug.go
+++ b/test/fixedbugs/bug222.dir/chanbug.go
@@ -3,8 +3,7 @@
 // license that can be found in the LICENSE file
 
 package chanbug
-
 var C chan<- (chan int)
 var D chan<- func()
 var E func() chan int
-var F func() func()
+var F func() (func())
diff --git a/test/fixedbugs/bug222.dir/chanbug2.go b/test/fixedbugs/bug222.dir/chanbug2.go
index f481082ede..109581dc30 100644
--- a/test/fixedbugs/bug222.dir/chanbug2.go
+++ b/test/fixedbugs/bug222.dir/chanbug2.go
@@ -3,5 +3,4 @@
 // license that can be found in the LICENSE file
 
 package Bar
-
 import _ "chanbug"
diff --git a/test/fixedbugs/bug224.go b/test/fixedbugs/bug224.go
index 107924a6ae..d2fd67cf32 100644
--- a/test/fixedbugs/bug224.go
+++ b/test/fixedbugs/bug224.go
@@ -6,4 +6,5 @@
 
 package main
 
-type T T // ERROR "recursive"
+type T T		// ERROR "recursive"
+
diff --git a/test/fixedbugs/bug225.go b/test/fixedbugs/bug225.go
index 42c432c845..1bda9ab4b6 100644
--- a/test/fixedbugs/bug225.go
+++ b/test/fixedbugs/bug225.go
@@ -6,17 +6,17 @@
 
 package main
 
-func main() {
-	c := make(chan bool, 1)
+func main() {	
+	c := make(chan bool, 1);
 	select {
 	case _ = <-c:
-		panic("BUG: recv should not")
+		panic("BUG: recv should not");
 	default:
 	}
-	c <- true
+	c <- true;
 	select {
 	case _ = <-c:
 	default:
-		panic("BUG: recv should")
+		panic("BUG: recv should");
 	}
 }
diff --git a/test/fixedbugs/bug229.go b/test/fixedbugs/bug229.go
index 2dd10c2dac..4baf65e48b 100644
--- a/test/fixedbugs/bug229.go
+++ b/test/fixedbugs/bug229.go
@@ -10,11 +10,11 @@ import "testing"
 
 func main() {
 	var t testing.T
-
+	
 	// make sure error mentions that
 	// name is unexported, not just "name not found".
 
-	t.common.name = nil // ERROR "unexported"
-
-	println(testing.anyLowercaseName("asdf")) // ERROR "unexported" "undefined: testing.anyLowercaseName"
+	t.common.name = nil	// ERROR "unexported"
+	
+	println(testing.anyLowercaseName("asdf"))	// ERROR "unexported" "undefined: testing.anyLowercaseName"
 }
diff --git a/test/fixedbugs/bug231.go b/test/fixedbugs/bug231.go
index 8b054edebd..f64ddc3e75 100644
--- a/test/fixedbugs/bug231.go
+++ b/test/fixedbugs/bug231.go
@@ -6,18 +6,17 @@
 
 package main
 
-type I interface{ m() }
-type T struct{ m func() }
-type M struct{}
-
+type I interface { m() }
+type T struct { m func() }
+type M struct {}
 func (M) m() {}
 
 func main() {
 	var t T
 	var m M
 	var i I
-
+	
 	i = m
-	i = t // ERROR "not a method|has no methods" "does not implement I"
+	i = t	// ERROR "not a method|has no methods" "does not implement I"
 	_ = i
 }
diff --git a/test/fixedbugs/bug232.go b/test/fixedbugs/bug232.go
index d7a33a24e5..10b0c521a4 100644
--- a/test/fixedbugs/bug232.go
+++ b/test/fixedbugs/bug232.go
@@ -5,5 +5,4 @@
 // license that can be found in the LICENSE file.
 
 package bug232
-
-type I interface{ X(...int) }
+type I interface { X(...int) }
diff --git a/test/fixedbugs/bug233.go b/test/fixedbugs/bug233.go
index 9f2d8d1e3d..d4e1e07816 100644
--- a/test/fixedbugs/bug233.go
+++ b/test/fixedbugs/bug233.go
@@ -5,8 +5,6 @@
 // license that can be found in the LICENSE file.
 
 package bug233
-
 import p "fmt"
-
 var _ = p.Print
 var fmt = 10
diff --git a/test/fixedbugs/bug235.go b/test/fixedbugs/bug235.go
index 8dcebca66e..a33092bdb6 100644
--- a/test/fixedbugs/bug235.go
+++ b/test/fixedbugs/bug235.go
@@ -14,3 +14,4 @@ type T struct {
 
 var p *T
 var v = *p
+
diff --git a/test/fixedbugs/bug237.go b/test/fixedbugs/bug237.go
index f736b9a93d..75d6132df9 100644
--- a/test/fixedbugs/bug237.go
+++ b/test/fixedbugs/bug237.go
@@ -9,7 +9,6 @@ package main
 import "fmt"
 
 var indent uint = 10
-
 func main() {
 	const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " +
 		". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
diff --git a/test/fixedbugs/bug238.go b/test/fixedbugs/bug238.go
index 3b5995dd77..cc47189e16 100644
--- a/test/fixedbugs/bug238.go
+++ b/test/fixedbugs/bug238.go
@@ -18,3 +18,4 @@ const g interface{} = 7 // ERROR "constant|wrong|invalid"
 const h bool = false
 const i int = 2
 const j float64 = 5
+
diff --git a/test/fixedbugs/bug240.go b/test/fixedbugs/bug240.go
index ae9dc35062..478b5b2eaf 100644
--- a/test/fixedbugs/bug240.go
+++ b/test/fixedbugs/bug240.go
@@ -6,7 +6,7 @@
 
 package main
 
-import . "unsafe" // ERROR "not used"
+import . "unsafe"	// ERROR "not used"
 
 func main() {
 	var x int
diff --git a/test/fixedbugs/bug241.go b/test/fixedbugs/bug241.go
index ab7d0ce643..1f4440147b 100644
--- a/test/fixedbugs/bug241.go
+++ b/test/fixedbugs/bug241.go
@@ -7,5 +7,5 @@
 package main
 
 const c = 3
+var x = c.String()	// ERROR "String"
 
-var x = c.String() // ERROR "String"
diff --git a/test/fixedbugs/bug245.go b/test/fixedbugs/bug245.go
index 9763349e25..adf62f98b5 100644
--- a/test/fixedbugs/bug245.go
+++ b/test/fixedbugs/bug245.go
@@ -7,7 +7,6 @@
 package main
 
 type T []int
-
 func (t T) m()
 
 func main() {
diff --git a/test/fixedbugs/bug249.go b/test/fixedbugs/bug249.go
index 1de59536bd..ec9699a894 100644
--- a/test/fixedbugs/bug249.go
+++ b/test/fixedbugs/bug249.go
@@ -6,34 +6,34 @@
 
 package main
 
-var c1 chan<- chan int = (chan<- (chan int))(nil)
-var c2 chan<- chan int = (chan (<-chan int))(nil) // ERROR "chan|incompatible"
-var c3 <-chan chan int = (<-chan (chan int))(nil)
-var c4 chan chan<- int = (chan (chan<- int))(nil)
-
-var c5 <-chan <-chan int = (<-chan (<-chan int))(nil)
-var c6 chan<- <-chan int = (chan<- (<-chan int))(nil)
-var c7 chan<- chan<- int = (chan<- (chan<- int))(nil)
-
-var c8 <-chan <-chan chan int = (<-chan (<-chan (chan int)))(nil)
-var c9 <-chan chan<- chan int = (<-chan (chan<- (chan int)))(nil)
-var c10 chan<- <-chan chan int = (chan<- (<-chan (chan int)))(nil)
-var c11 chan<- chan<- chan int = (chan<- (chan<- (chan int)))(nil)
-var c12 chan chan<- <-chan int = (chan (chan<- (<-chan int)))(nil)
-var c13 chan chan<- chan<- int = (chan (chan<- (chan<- int)))(nil)
-
-var r1 chan<- (chan int) = (chan<- chan int)(nil)
-var r2 chan (<-chan int) = (chan<- chan int)(nil) // ERROR "chan|incompatible"
-var r3 <-chan (chan int) = (<-chan chan int)(nil)
-var r4 chan (chan<- int) = (chan chan<- int)(nil)
-
-var r5 <-chan (<-chan int) = (<-chan <-chan int)(nil)
-var r6 chan<- (<-chan int) = (chan<- <-chan int)(nil)
-var r7 chan<- (chan<- int) = (chan<- chan<- int)(nil)
-
-var r8 <-chan (<-chan (chan int)) = (<-chan <-chan chan int)(nil)
-var r9 <-chan (chan<- (chan int)) = (<-chan chan<- chan int)(nil)
-var r10 chan<- (<-chan (chan int)) = (chan<- <-chan chan int)(nil)
-var r11 chan<- (chan<- (chan int)) = (chan<- chan<- chan int)(nil)
-var r12 chan (chan<- (<-chan int)) = (chan chan<- <-chan int)(nil)
-var r13 chan (chan<- (chan<- int)) = (chan chan<- chan<- int)(nil)
+var c1 chan <- chan int = (chan<- (chan int))(nil)
+var c2 chan <- chan int = (chan (<-chan int))(nil)  // ERROR "chan|incompatible"
+var c3 <- chan chan int = (<-chan (chan int))(nil)
+var c4 chan chan <- int = (chan (chan<- int))(nil)
+
+var c5 <- chan <- chan int = (<-chan (<-chan int))(nil)
+var c6 chan <- <- chan int = (chan<- (<-chan int))(nil)
+var c7 chan <- chan <- int = (chan<- (chan<- int))(nil)
+
+var c8 <- chan <- chan chan int = (<-chan (<-chan (chan int)))(nil)
+var c9 <- chan chan <- chan int = (<-chan (chan<- (chan int)))(nil)
+var c10 chan <- <- chan chan int = (chan<- (<-chan (chan int)))(nil)
+var c11 chan <- chan <- chan int = (chan<- (chan<- (chan int)))(nil)
+var c12 chan chan <- <- chan int = (chan (chan<- (<-chan int)))(nil)
+var c13 chan chan <- chan <- int = (chan (chan<- (chan<- int)))(nil)
+
+var r1 chan<- (chan int) = (chan <- chan int)(nil)
+var r2 chan (<-chan int) = (chan <- chan int)(nil)  // ERROR "chan|incompatible"
+var r3 <-chan (chan int) = (<- chan chan int)(nil)
+var r4 chan (chan<- int) = (chan chan <- int)(nil)
+
+var r5 <-chan (<-chan int) = (<- chan <- chan int)(nil)
+var r6 chan<- (<-chan int) = (chan <- <- chan int)(nil)
+var r7 chan<- (chan<- int) = (chan <- chan <- int)(nil)
+
+var r8 <-chan (<-chan (chan int)) = (<- chan <- chan chan int)(nil)
+var r9 <-chan (chan<- (chan int)) = (<- chan chan <- chan int)(nil)
+var r10 chan<- (<-chan (chan int)) = (chan <- <- chan chan int)(nil)
+var r11 chan<- (chan<- (chan int)) = (chan <- chan <- chan int)(nil)
+var r12 chan (chan<- (<-chan int)) = (chan chan <- <- chan int)(nil)
+var r13 chan (chan<- (chan<- int)) = (chan chan <- chan <- int)(nil)
diff --git a/test/fixedbugs/bug251.go b/test/fixedbugs/bug251.go
index a0c04319b3..05e111a61f 100644
--- a/test/fixedbugs/bug251.go
+++ b/test/fixedbugs/bug251.go
@@ -19,6 +19,7 @@ type I2 interface {
 	I1 // GCCGO_ERROR "loop|interface"
 }
 
+
 var i1 I1 = i2
 var i2 I2
 var i2a I2 = i1
diff --git a/test/fixedbugs/bug252.go b/test/fixedbugs/bug252.go
index 19b37b00d0..f678925fbb 100644
--- a/test/fixedbugs/bug252.go
+++ b/test/fixedbugs/bug252.go
@@ -11,5 +11,5 @@ func f(args ...int) {
 }
 
 func g(args ...interface{}) {
-	f(args) // ERROR "cannot use|incompatible"
+	f(args)	// ERROR "cannot use|incompatible"
 }
diff --git a/test/fixedbugs/bug256.go b/test/fixedbugs/bug256.go
index 3a6df90969..705a0321b4 100644
--- a/test/fixedbugs/bug256.go
+++ b/test/fixedbugs/bug256.go
@@ -6,9 +6,11 @@
 
 package main
 
-type T U // bogus "invalid recursive type T" from 6g
+type T U	// bogus "invalid recursive type T" from 6g
 type U int
 
 const x T = 123
 
-type V V // ERROR "invalid recursive type"
+type V V	// ERROR "invalid recursive type"
+
+
diff --git a/test/fixedbugs/bug258.go b/test/fixedbugs/bug258.go
index d4b993ab00..075da87577 100644
--- a/test/fixedbugs/bug258.go
+++ b/test/fixedbugs/bug258.go
@@ -25,7 +25,7 @@ func main() {
 		} else {
 			println("BUG 2")
 		}
-
+		
 		if math.Pow(2, 3) != 8 {
 			println("BUG 3")
 		}
diff --git a/test/fixedbugs/bug259.go b/test/fixedbugs/bug259.go
index 4946a3d4dc..857b442010 100644
--- a/test/fixedbugs/bug259.go
+++ b/test/fixedbugs/bug259.go
@@ -9,7 +9,7 @@ package main
 import "fmt"
 
 var x = uint32(0x01020304)
-var y = [...]uint32{1, 2, 3, 4, 5}
+var y = [...]uint32{1,2,3,4,5}
 
 func main() {
 	fmt.Sprint(y[byte(x)])
diff --git a/test/fixedbugs/bug261.go b/test/fixedbugs/bug261.go
index 3645d27d05..abe6431b51 100644
--- a/test/fixedbugs/bug261.go
+++ b/test/fixedbugs/bug261.go
@@ -14,7 +14,7 @@ func f() int {
 }
 
 func main() {
-	x := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	x := []int{0,1,2,3,4,5,6,7,8,9,10}
 	n = 5
 	y := x[f():f()]
 	if len(y) != 1 || y[0] != 6 {
diff --git a/test/fixedbugs/bug266.go b/test/fixedbugs/bug266.go
index b51c5acdad..5d2334c05a 100644
--- a/test/fixedbugs/bug266.go
+++ b/test/fixedbugs/bug266.go
@@ -13,12 +13,12 @@ func f() int {
 	panic("oops")
 }
 
-func g() int {
+func g() int {	
 	return 12345
 }
 
 func main() {
-	g() // leave 12345 on stack
+	g()	// leave 12345 on stack
 	x := f()
 	if x != 0 {
 		panic(x)
diff --git a/test/fixedbugs/bug269.go b/test/fixedbugs/bug269.go
index 4241faf9b5..ec0dbc6c34 100644
--- a/test/fixedbugs/bug269.go
+++ b/test/fixedbugs/bug269.go
@@ -13,6 +13,6 @@ func f() (ok bool) { return false }
 func main() {
 	var i interface{}
 	i = f
-	_ = i.(func() bool)
-	_ = i.(func() bool)
+	_ = i.(func()bool)
+	_ = i.(func()(bool))
 }
diff --git a/test/fixedbugs/bug271.go b/test/fixedbugs/bug271.go
index d285f29be0..a6abbfef7e 100644
--- a/test/fixedbugs/bug271.go
+++ b/test/fixedbugs/bug271.go
@@ -14,7 +14,7 @@ func f() (int, int) { return 1, 2 }
 
 func main() {
 	s := fmt.Sprint(f())
-	if s != "1 2" { // with bug, was "{1 2}"
+	if s != "1 2" {	// with bug, was "{1 2}"
 		println("BUG")
 	}
 }
diff --git a/test/fixedbugs/bug272.go b/test/fixedbugs/bug272.go
index ca39cbb4ce..6b8862f697 100644
--- a/test/fixedbugs/bug272.go
+++ b/test/fixedbugs/bug272.go
@@ -8,15 +8,15 @@
 
 package main
 
-func main() {
+func main() {	
 	n := int64(100)
 	x := make([]int, n)
-	x[99] = 234
+	x[99] = 234;	
 	z := x[n-1]
 	if z != 234 {
 		println("BUG")
 	}
-	n |= 1 << 32
+	n |= 1<<32
 	defer func() {
 		recover()
 	}()
diff --git a/test/fixedbugs/bug276.go b/test/fixedbugs/bug276.go
index a9af72cf63..dc2308ea6b 100644
--- a/test/fixedbugs/bug276.go
+++ b/test/fixedbugs/bug276.go
@@ -13,10 +13,10 @@ func main() {
 	x := 0
 
 	a := (x & 1) << uint(1-i)
-
-	s := uint(1 - i)
+	
+	s := uint(1-i)
 	b := (x & 1) << s
-
+	
 	if a != b {
 		panic(0)
 	}
diff --git a/test/fixedbugs/bug277.go b/test/fixedbugs/bug277.go
index fe87a07006..207556493e 100644
--- a/test/fixedbugs/bug277.go
+++ b/test/fixedbugs/bug277.go
@@ -43,7 +43,7 @@ func main() {
 		x int
 	}(s)
 	p = (*S)(p)
-	f = (func(x int) int)(f)
+	f = func(x int) int(f)
 	i = (interface {
 		m(x int) int
 	})(s) // this is accepted by 6g
diff --git a/test/fixedbugs/bug278.go b/test/fixedbugs/bug278.go
index 592aac9190..4817ebfee4 100644
--- a/test/fixedbugs/bug278.go
+++ b/test/fixedbugs/bug278.go
@@ -15,9 +15,9 @@ func f() [10]int {
 var m map[int][10]int
 
 func main() {
-	f()[1] = 2      // ERROR "cannot|invalid"
-	f()[2:3][0] = 4 // ERROR "cannot|addressable"
+	f()[1] = 2	// ERROR "cannot|invalid"
+	f()[2:3][0] = 4	// ERROR "cannot|addressable"
 	var x = "abc"
-	x[2] = 3    // ERROR "cannot|invalid"
-	m[0][5] = 6 // ERROR "cannot|invalid"
+	x[2] = 3	// ERROR "cannot|invalid"
+	m[0][5] = 6  // ERROR "cannot|invalid"
 }
diff --git a/test/fixedbugs/bug279.go b/test/fixedbugs/bug279.go
index c2a9a533d6..3b1df3b8fe 100644
--- a/test/fixedbugs/bug279.go
+++ b/test/fixedbugs/bug279.go
@@ -21,7 +21,7 @@ func main() {
 		println("BUG alignof 0", n)
 		return
 	}
-
+	
 	n = unsafe.Sizeof("")
 	if n != 8 && n != 16 {
 		println("BUG sizeof \"\"", n)
@@ -33,3 +33,4 @@ func main() {
 		return
 	}
 }
+
diff --git a/test/fixedbugs/bug280.go b/test/fixedbugs/bug280.go
index c23642ea20..afec57f037 100644
--- a/test/fixedbugs/bug280.go
+++ b/test/fixedbugs/bug280.go
@@ -8,4 +8,6 @@
 
 package main
 
-type A [...]int // ERROR "outside of array literal"
+type A [...]int	// ERROR "outside of array literal"
+
+
diff --git a/test/fixedbugs/bug281.go b/test/fixedbugs/bug281.go
index d52d932e32..c65530f7dd 100644
--- a/test/fixedbugs/bug281.go
+++ b/test/fixedbugs/bug281.go
@@ -17,7 +17,7 @@ type Rect struct {
 }
 
 func (p Point) Sub(q Point) Point {
-	return Point{p.X - q.X, p.Y - q.Y}
+	return Point{p.X-q.X, p.Y-q.Y}
 }
 
 type Obj struct {
@@ -28,7 +28,7 @@ func (o *Obj) Bbox() Rect {
 	return o.bbox
 }
 
-func (o *Obj) Points() [2]Point {
+func (o *Obj) Points() [2]Point{
 	return [2]Point{o.bbox.Min, o.bbox.Max}
 }
 
@@ -42,12 +42,12 @@ func main() {
 		println("BUG dot: ", q.X, q.Y)
 		return
 	}
-
+	
 	q = p.Sub(o.Points()[0])
 	if q.X != 0 || q.Y != 300 {
 		println("BUG index const: ", q.X, q.Y)
 	}
-
+	
 	q = p.Sub(o.Points()[x])
 	if q.X != 0 || q.Y != 300 {
 		println("BUG index var: ", q.X, q.Y)
diff --git a/test/fixedbugs/bug282.dir/p1.go b/test/fixedbugs/bug282.dir/p1.go
index 1fbfa3aa74..0f7422c0ba 100644
--- a/test/fixedbugs/bug282.dir/p1.go
+++ b/test/fixedbugs/bug282.dir/p1.go
@@ -7,3 +7,4 @@ package p1
 type T struct {
 	f func() "x"
 }
+
diff --git a/test/fixedbugs/bug282.dir/p2.go b/test/fixedbugs/bug282.dir/p2.go
index 6e72020dcf..f614507946 100644
--- a/test/fixedbugs/bug282.dir/p2.go
+++ b/test/fixedbugs/bug282.dir/p2.go
@@ -5,3 +5,4 @@
 package p2
 
 import _ "./p1"
+
diff --git a/test/fixedbugs/bug284.go b/test/fixedbugs/bug284.go
index 589eec15eb..68208085fa 100644
--- a/test/fixedbugs/bug284.go
+++ b/test/fixedbugs/bug284.go
@@ -108,7 +108,7 @@ func main() {
 	var f2 F2
 	f0 = f0
 	f0 = f1
-	f0 = (func(x NewInt) int)(f2) // ERROR "cannot|invalid"
+	f0 = func(x NewInt) int(f2) // ERROR "cannot|invalid"
 	f1 = f0
 	f1 = f1
 	f1 = F1(f2) // ERROR "cannot|invalid"
diff --git a/test/fixedbugs/bug285.go b/test/fixedbugs/bug285.go
index 5b33ab7d42..0632ab4ba7 100644
--- a/test/fixedbugs/bug285.go
+++ b/test/fixedbugs/bug285.go
@@ -66,7 +66,7 @@ func main() {
 	m0[z] = 42 // this should work: z is assignment-compatible with interface{}
 	m0[new(struct {
 		x int
-	})] = 42 // this should work: *struct{x int} is assignment-compatible with interface{}
+	})] = 42       // this should work: *struct{x int} is assignment-compatible with interface{}
 	m0[p] = 42     // this should work: p is assignment-compatible with interface{}
 	m0[false] = 42 // this should work: false is assignment-compatible with interface{}
 	m0[17] = 42    // this should work: 17 is assignment-compatible with interface{}
@@ -76,7 +76,7 @@ func main() {
 	m1[i1] = 42
 	m1[new(struct {
 		x int
-	})] = 42 // this should work: *struct{x int} is assignment-compatible with I1
+	})] = 42       // this should work: *struct{x int} is assignment-compatible with I1
 	m1[false] = 42 // this should work: false is assignment-compatible with I1
 	m1[17] = 42    // this should work: 17 is assignment-compatible with I1
 	m1["foo"] = 42 // this should work: "foo" is assignment-compatible with I1
diff --git a/test/fixedbugs/bug287.go b/test/fixedbugs/bug287.go
index 5ca280f6fa..94582a8695 100644
--- a/test/fixedbugs/bug287.go
+++ b/test/fixedbugs/bug287.go
@@ -8,4 +8,4 @@
 
 package main
 
-var mult [3][...]byte = [3][5]byte{} // ERROR "\.\.\."
+var mult [3][...]byte = [3][5]byte{}	// ERROR "\.\.\."
diff --git a/test/fixedbugs/bug289.go b/test/fixedbugs/bug289.go
index 8334b8f5ed..3fc7fb2eef 100644
--- a/test/fixedbugs/bug289.go
+++ b/test/fixedbugs/bug289.go
@@ -9,18 +9,18 @@
 package main
 
 func f1() {
-	a, b := f() // ERROR "assignment mismatch|does not match"
+	a, b := f()	// ERROR "assignment mismatch|does not match"
 	_ = a
 	_ = b
 }
 
 func f2() {
 	var a, b int
-	a, b = f() // ERROR "assignment mismatch|does not match"
+	a, b = f()	// ERROR "assignment mismatch|does not match"
 	_ = a
 	_ = b
 }
 
 func f() int {
-	return 1
+	return 1;
 }
diff --git a/test/fixedbugs/bug290.go b/test/fixedbugs/bug290.go
index ae648d2531..4eee285a35 100644
--- a/test/fixedbugs/bug290.go
+++ b/test/fixedbugs/bug290.go
@@ -8,8 +8,8 @@
 
 package main
 
-type X struct{ x []X }
+type X struct { x []X }
 
 func main() {
-	type Y struct{ x []Y } // used to get invalid recursive type
+	type Y struct { x []Y }	// used to get invalid recursive type
 }
diff --git a/test/fixedbugs/bug293.go b/test/fixedbugs/bug293.go
index e834a4bc85..ae7cc1fd1c 100644
--- a/test/fixedbugs/bug293.go
+++ b/test/fixedbugs/bug293.go
@@ -9,7 +9,7 @@
 package main
 
 func x() (a int, b bool) {
-	defer func() {
+	defer func(){
 		a++
 	}()
 	a, b = y()
@@ -17,7 +17,7 @@ func x() (a int, b bool) {
 }
 
 func x2() (a int, b bool) {
-	defer func() {
+	defer func(){
 		a++
 	}()
 	return y()
diff --git a/test/fixedbugs/bug294.go b/test/fixedbugs/bug294.go
index 26e922df6b..b35b771916 100644
--- a/test/fixedbugs/bug294.go
+++ b/test/fixedbugs/bug294.go
@@ -76,3 +76,4 @@ func main() {
 		bad()
 	}
 }
+
diff --git a/test/fixedbugs/bug295.go b/test/fixedbugs/bug295.go
index 691aa92c7f..d1c961ce1d 100644
--- a/test/fixedbugs/bug295.go
+++ b/test/fixedbugs/bug295.go
@@ -6,7 +6,7 @@
 
 package main
 
-import . "testing" // defines file-level T
+import . "testing"  // defines file-level T
 
 type _ B // make use of package "testing" (but don't refer to T)
 
@@ -15,5 +15,5 @@ type S struct {
 }
 
 func main() {
-	_ = &S{T: 1} // should work
+	_ = &S{T: 1}	// should work
 }
diff --git a/test/fixedbugs/bug297.go b/test/fixedbugs/bug297.go
index 4d14ad2475..c2bd253d05 100644
--- a/test/fixedbugs/bug297.go
+++ b/test/fixedbugs/bug297.go
@@ -9,8 +9,7 @@
 package main
 
 type ByteSize float64
-
 const (
-	_           = iota          // ignore first value by assigning to blank identifier
-	KB ByteSize = 1 << (10 * X) // ERROR "undefined"
+	_ = iota;   // ignore first value by assigning to blank identifier
+	KB ByteSize = 1<<(10*X) // ERROR "undefined"
 )
diff --git a/test/fixedbugs/bug302.dir/main.go b/test/fixedbugs/bug302.dir/main.go
index 9d3356f387..52c054fb4c 100644
--- a/test/fixedbugs/bug302.dir/main.go
+++ b/test/fixedbugs/bug302.dir/main.go
@@ -9,3 +9,4 @@ import _ "p"
 
 // Check that it's still correct in pp.a (which contains p.6).
 import _ "pp"
+
diff --git a/test/fixedbugs/bug302.dir/p.go b/test/fixedbugs/bug302.dir/p.go
index 1f3cfcbb3c..0be521b4f8 100644
--- a/test/fixedbugs/bug302.dir/p.go
+++ b/test/fixedbugs/bug302.dir/p.go
@@ -5,1005 +5,1005 @@
 package p
 
 type T struct {
-	x1    int
-	x2    int
-	x3    int
-	x4    int
-	x5    int
-	x6    int
-	x7    int
-	x8    int
-	x9    int
-	x10   int
-	x11   int
-	x12   int
-	x13   int
-	x14   int
-	x15   int
-	x16   int
-	x17   int
-	x18   int
-	x19   int
-	x20   int
-	x21   int
-	x22   int
-	x23   int
-	x24   int
-	x25   int
-	x26   int
-	x27   int
-	x28   int
-	x29   int
-	x30   int
-	x31   int
-	x32   int
-	x33   int
-	x34   int
-	x35   int
-	x36   int
-	x37   int
-	x38   int
-	x39   int
-	x40   int
-	x41   int
-	x42   int
-	x43   int
-	x44   int
-	x45   int
-	x46   int
-	x47   int
-	x48   int
-	x49   int
-	x50   int
-	x51   int
-	x52   int
-	x53   int
-	x54   int
-	x55   int
-	x56   int
-	x57   int
-	x58   int
-	x59   int
-	x60   int
-	x61   int
-	x62   int
-	x63   int
-	x64   int
-	x65   int
-	x66   int
-	x67   int
-	x68   int
-	x69   int
-	x70   int
-	x71   int
-	x72   int
-	x73   int
-	x74   int
-	x75   int
-	x76   int
-	x77   int
-	x78   int
-	x79   int
-	x80   int
-	x81   int
-	x82   int
-	x83   int
-	x84   int
-	x85   int
-	x86   int
-	x87   int
-	x88   int
-	x89   int
-	x90   int
-	x91   int
-	x92   int
-	x93   int
-	x94   int
-	x95   int
-	x96   int
-	x97   int
-	x98   int
-	x99   int
-	x100  int
-	x101  int
-	x102  int
-	x103  int
-	x104  int
-	x105  int
-	x106  int
-	x107  int
-	x108  int
-	x109  int
-	x110  int
-	x111  int
-	x112  int
-	x113  int
-	x114  int
-	x115  int
-	x116  int
-	x117  int
-	x118  int
-	x119  int
-	x120  int
-	x121  int
-	x122  int
-	x123  int
-	x124  int
-	x125  int
-	x126  int
-	x127  int
-	x128  int
-	x129  int
-	x130  int
-	x131  int
-	x132  int
-	x133  int
-	x134  int
-	x135  int
-	x136  int
-	x137  int
-	x138  int
-	x139  int
-	x140  int
-	x141  int
-	x142  int
-	x143  int
-	x144  int
-	x145  int
-	x146  int
-	x147  int
-	x148  int
-	x149  int
-	x150  int
-	x151  int
-	x152  int
-	x153  int
-	x154  int
-	x155  int
-	x156  int
-	x157  int
-	x158  int
-	x159  int
-	x160  int
-	x161  int
-	x162  int
-	x163  int
-	x164  int
-	x165  int
-	x166  int
-	x167  int
-	x168  int
-	x169  int
-	x170  int
-	x171  int
-	x172  int
-	x173  int
-	x174  int
-	x175  int
-	x176  int
-	x177  int
-	x178  int
-	x179  int
-	x180  int
-	x181  int
-	x182  int
-	x183  int
-	x184  int
-	x185  int
-	x186  int
-	x187  int
-	x188  int
-	x189  int
-	x190  int
-	x191  int
-	x192  int
-	x193  int
-	x194  int
-	x195  int
-	x196  int
-	x197  int
-	x198  int
-	x199  int
-	x200  int
-	x201  int
-	x202  int
-	x203  int
-	x204  int
-	x205  int
-	x206  int
-	x207  int
-	x208  int
-	x209  int
-	x210  int
-	x211  int
-	x212  int
-	x213  int
-	x214  int
-	x215  int
-	x216  int
-	x217  int
-	x218  int
-	x219  int
-	x220  int
-	x221  int
-	x222  int
-	x223  int
-	x224  int
-	x225  int
-	x226  int
-	x227  int
-	x228  int
-	x229  int
-	x230  int
-	x231  int
-	x232  int
-	x233  int
-	x234  int
-	x235  int
-	x236  int
-	x237  int
-	x238  int
-	x239  int
-	x240  int
-	x241  int
-	x242  int
-	x243  int
-	x244  int
-	x245  int
-	x246  int
-	x247  int
-	x248  int
-	x249  int
-	x250  int
-	x251  int
-	x252  int
-	x253  int
-	x254  int
-	x255  int
-	x256  int
-	x257  int
-	x258  int
-	x259  int
-	x260  int
-	x261  int
-	x262  int
-	x263  int
-	x264  int
-	x265  int
-	x266  int
-	x267  int
-	x268  int
-	x269  int
-	x270  int
-	x271  int
-	x272  int
-	x273  int
-	x274  int
-	x275  int
-	x276  int
-	x277  int
-	x278  int
-	x279  int
-	x280  int
-	x281  int
-	x282  int
-	x283  int
-	x284  int
-	x285  int
-	x286  int
-	x287  int
-	x288  int
-	x289  int
-	x290  int
-	x291  int
-	x292  int
-	x293  int
-	x294  int
-	x295  int
-	x296  int
-	x297  int
-	x298  int
-	x299  int
-	x300  int
-	x301  int
-	x302  int
-	x303  int
-	x304  int
-	x305  int
-	x306  int
-	x307  int
-	x308  int
-	x309  int
-	x310  int
-	x311  int
-	x312  int
-	x313  int
-	x314  int
-	x315  int
-	x316  int
-	x317  int
-	x318  int
-	x319  int
-	x320  int
-	x321  int
-	x322  int
-	x323  int
-	x324  int
-	x325  int
-	x326  int
-	x327  int
-	x328  int
-	x329  int
-	x330  int
-	x331  int
-	x332  int
-	x333  int
-	x334  int
-	x335  int
-	x336  int
-	x337  int
-	x338  int
-	x339  int
-	x340  int
-	x341  int
-	x342  int
-	x343  int
-	x344  int
-	x345  int
-	x346  int
-	x347  int
-	x348  int
-	x349  int
-	x350  int
-	x351  int
-	x352  int
-	x353  int
-	x354  int
-	x355  int
-	x356  int
-	x357  int
-	x358  int
-	x359  int
-	x360  int
-	x361  int
-	x362  int
-	x363  int
-	x364  int
-	x365  int
-	x366  int
-	x367  int
-	x368  int
-	x369  int
-	x370  int
-	x371  int
-	x372  int
-	x373  int
-	x374  int
-	x375  int
-	x376  int
-	x377  int
-	x378  int
-	x379  int
-	x380  int
-	x381  int
-	x382  int
-	x383  int
-	x384  int
-	x385  int
-	x386  int
-	x387  int
-	x388  int
-	x389  int
-	x390  int
-	x391  int
-	x392  int
-	x393  int
-	x394  int
-	x395  int
-	x396  int
-	x397  int
-	x398  int
-	x399  int
-	x400  int
-	x401  int
-	x402  int
-	x403  int
-	x404  int
-	x405  int
-	x406  int
-	x407  int
-	x408  int
-	x409  int
-	x410  int
-	x411  int
-	x412  int
-	x413  int
-	x414  int
-	x415  int
-	x416  int
-	x417  int
-	x418  int
-	x419  int
-	x420  int
-	x421  int
-	x422  int
-	x423  int
-	x424  int
-	x425  int
-	x426  int
-	x427  int
-	x428  int
-	x429  int
-	x430  int
-	x431  int
-	x432  int
-	x433  int
-	x434  int
-	x435  int
-	x436  int
-	x437  int
-	x438  int
-	x439  int
-	x440  int
-	x441  int
-	x442  int
-	x443  int
-	x444  int
-	x445  int
-	x446  int
-	x447  int
-	x448  int
-	x449  int
-	x450  int
-	x451  int
-	x452  int
-	x453  int
-	x454  int
-	x455  int
-	x456  int
-	x457  int
-	x458  int
-	x459  int
-	x460  int
-	x461  int
-	x462  int
-	x463  int
-	x464  int
-	x465  int
-	x466  int
-	x467  int
-	x468  int
-	x469  int
-	x470  int
-	x471  int
-	x472  int
-	x473  int
-	x474  int
-	x475  int
-	x476  int
-	x477  int
-	x478  int
-	x479  int
-	x480  int
-	x481  int
-	x482  int
-	x483  int
-	x484  int
-	x485  int
-	x486  int
-	x487  int
-	x488  int
-	x489  int
-	x490  int
-	x491  int
-	x492  int
-	x493  int
-	x494  int
-	x495  int
-	x496  int
-	x497  int
-	x498  int
-	x499  int
-	x500  int
-	x501  int
-	x502  int
-	x503  int
-	x504  int
-	x505  int
-	x506  int
-	x507  int
-	x508  int
-	x509  int
-	x510  int
-	x511  int
-	x512  int
-	x513  int
-	x514  int
-	x515  int
-	x516  int
-	x517  int
-	x518  int
-	x519  int
-	x520  int
-	x521  int
-	x522  int
-	x523  int
-	x524  int
-	x525  int
-	x526  int
-	x527  int
-	x528  int
-	x529  int
-	x530  int
-	x531  int
-	x532  int
-	x533  int
-	x534  int
-	x535  int
-	x536  int
-	x537  int
-	x538  int
-	x539  int
-	x540  int
-	x541  int
-	x542  int
-	x543  int
-	x544  int
-	x545  int
-	x546  int
-	x547  int
-	x548  int
-	x549  int
-	x550  int
-	x551  int
-	x552  int
-	x553  int
-	x554  int
-	x555  int
-	x556  int
-	x557  int
-	x558  int
-	x559  int
-	x560  int
-	x561  int
-	x562  int
-	x563  int
-	x564  int
-	x565  int
-	x566  int
-	x567  int
-	x568  int
-	x569  int
-	x570  int
-	x571  int
-	x572  int
-	x573  int
-	x574  int
-	x575  int
-	x576  int
-	x577  int
-	x578  int
-	x579  int
-	x580  int
-	x581  int
-	x582  int
-	x583  int
-	x584  int
-	x585  int
-	x586  int
-	x587  int
-	x588  int
-	x589  int
-	x590  int
-	x591  int
-	x592  int
-	x593  int
-	x594  int
-	x595  int
-	x596  int
-	x597  int
-	x598  int
-	x599  int
-	x600  int
-	x601  int
-	x602  int
-	x603  int
-	x604  int
-	x605  int
-	x606  int
-	x607  int
-	x608  int
-	x609  int
-	x610  int
-	x611  int
-	x612  int
-	x613  int
-	x614  int
-	x615  int
-	x616  int
-	x617  int
-	x618  int
-	x619  int
-	x620  int
-	x621  int
-	x622  int
-	x623  int
-	x624  int
-	x625  int
-	x626  int
-	x627  int
-	x628  int
-	x629  int
-	x630  int
-	x631  int
-	x632  int
-	x633  int
-	x634  int
-	x635  int
-	x636  int
-	x637  int
-	x638  int
-	x639  int
-	x640  int
-	x641  int
-	x642  int
-	x643  int
-	x644  int
-	x645  int
-	x646  int
-	x647  int
-	x648  int
-	x649  int
-	x650  int
-	x651  int
-	x652  int
-	x653  int
-	x654  int
-	x655  int
-	x656  int
-	x657  int
-	x658  int
-	x659  int
-	x660  int
-	x661  int
-	x662  int
-	x663  int
-	x664  int
-	x665  int
-	x666  int
-	x667  int
-	x668  int
-	x669  int
-	x670  int
-	x671  int
-	x672  int
-	x673  int
-	x674  int
-	x675  int
-	x676  int
-	x677  int
-	x678  int
-	x679  int
-	x680  int
-	x681  int
-	x682  int
-	x683  int
-	x684  int
-	x685  int
-	x686  int
-	x687  int
-	x688  int
-	x689  int
-	x690  int
-	x691  int
-	x692  int
-	x693  int
-	x694  int
-	x695  int
-	x696  int
-	x697  int
-	x698  int
-	x699  int
-	x700  int
-	x701  int
-	x702  int
-	x703  int
-	x704  int
-	x705  int
-	x706  int
-	x707  int
-	x708  int
-	x709  int
-	x710  int
-	x711  int
-	x712  int
-	x713  int
-	x714  int
-	x715  int
-	x716  int
-	x717  int
-	x718  int
-	x719  int
-	x720  int
-	x721  int
-	x722  int
-	x723  int
-	x724  int
-	x725  int
-	x726  int
-	x727  int
-	x728  int
-	x729  int
-	x730  int
-	x731  int
-	x732  int
-	x733  int
-	x734  int
-	x735  int
-	x736  int
-	x737  int
-	x738  int
-	x739  int
-	x740  int
-	x741  int
-	x742  int
-	x743  int
-	x744  int
-	x745  int
-	x746  int
-	x747  int
-	x748  int
-	x749  int
-	x750  int
-	x751  int
-	x752  int
-	x753  int
-	x754  int
-	x755  int
-	x756  int
-	x757  int
-	x758  int
-	x759  int
-	x760  int
-	x761  int
-	x762  int
-	x763  int
-	x764  int
-	x765  int
-	x766  int
-	x767  int
-	x768  int
-	x769  int
-	x770  int
-	x771  int
-	x772  int
-	x773  int
-	x774  int
-	x775  int
-	x776  int
-	x777  int
-	x778  int
-	x779  int
-	x780  int
-	x781  int
-	x782  int
-	x783  int
-	x784  int
-	x785  int
-	x786  int
-	x787  int
-	x788  int
-	x789  int
-	x790  int
-	x791  int
-	x792  int
-	x793  int
-	x794  int
-	x795  int
-	x796  int
-	x797  int
-	x798  int
-	x799  int
-	x800  int
-	x801  int
-	x802  int
-	x803  int
-	x804  int
-	x805  int
-	x806  int
-	x807  int
-	x808  int
-	x809  int
-	x810  int
-	x811  int
-	x812  int
-	x813  int
-	x814  int
-	x815  int
-	x816  int
-	x817  int
-	x818  int
-	x819  int
-	x820  int
-	x821  int
-	x822  int
-	x823  int
-	x824  int
-	x825  int
-	x826  int
-	x827  int
-	x828  int
-	x829  int
-	x830  int
-	x831  int
-	x832  int
-	x833  int
-	x834  int
-	x835  int
-	x836  int
-	x837  int
-	x838  int
-	x839  int
-	x840  int
-	x841  int
-	x842  int
-	x843  int
-	x844  int
-	x845  int
-	x846  int
-	x847  int
-	x848  int
-	x849  int
-	x850  int
-	x851  int
-	x852  int
-	x853  int
-	x854  int
-	x855  int
-	x856  int
-	x857  int
-	x858  int
-	x859  int
-	x860  int
-	x861  int
-	x862  int
-	x863  int
-	x864  int
-	x865  int
-	x866  int
-	x867  int
-	x868  int
-	x869  int
-	x870  int
-	x871  int
-	x872  int
-	x873  int
-	x874  int
-	x875  int
-	x876  int
-	x877  int
-	x878  int
-	x879  int
-	x880  int
-	x881  int
-	x882  int
-	x883  int
-	x884  int
-	x885  int
-	x886  int
-	x887  int
-	x888  int
-	x889  int
-	x890  int
-	x891  int
-	x892  int
-	x893  int
-	x894  int
-	x895  int
-	x896  int
-	x897  int
-	x898  int
-	x899  int
-	x900  int
-	x901  int
-	x902  int
-	x903  int
-	x904  int
-	x905  int
-	x906  int
-	x907  int
-	x908  int
-	x909  int
-	x910  int
-	x911  int
-	x912  int
-	x913  int
-	x914  int
-	x915  int
-	x916  int
-	x917  int
-	x918  int
-	x919  int
-	x920  int
-	x921  int
-	x922  int
-	x923  int
-	x924  int
-	x925  int
-	x926  int
-	x927  int
-	x928  int
-	x929  int
-	x930  int
-	x931  int
-	x932  int
-	x933  int
-	x934  int
-	x935  int
-	x936  int
-	x937  int
-	x938  int
-	x939  int
-	x940  int
-	x941  int
-	x942  int
-	x943  int
-	x944  int
-	x945  int
-	x946  int
-	x947  int
-	x948  int
-	x949  int
-	x950  int
-	x951  int
-	x952  int
-	x953  int
-	x954  int
-	x955  int
-	x956  int
-	x957  int
-	x958  int
-	x959  int
-	x960  int
-	x961  int
-	x962  int
-	x963  int
-	x964  int
-	x965  int
-	x966  int
-	x967  int
-	x968  int
-	x969  int
-	x970  int
-	x971  int
-	x972  int
-	x973  int
-	x974  int
-	x975  int
-	x976  int
-	x977  int
-	x978  int
-	x979  int
-	x980  int
-	x981  int
-	x982  int
-	x983  int
-	x984  int
-	x985  int
-	x986  int
-	x987  int
-	x988  int
-	x989  int
-	x990  int
-	x991  int
-	x992  int
-	x993  int
-	x994  int
-	x995  int
-	x996  int
-	x997  int
-	x998  int
-	x999  int
+	x1 int
+	x2 int
+	x3 int
+	x4 int
+	x5 int
+	x6 int
+	x7 int
+	x8 int
+	x9 int
+	x10 int
+	x11 int
+	x12 int
+	x13 int
+	x14 int
+	x15 int
+	x16 int
+	x17 int
+	x18 int
+	x19 int
+	x20 int
+	x21 int
+	x22 int
+	x23 int
+	x24 int
+	x25 int
+	x26 int
+	x27 int
+	x28 int
+	x29 int
+	x30 int
+	x31 int
+	x32 int
+	x33 int
+	x34 int
+	x35 int
+	x36 int
+	x37 int
+	x38 int
+	x39 int
+	x40 int
+	x41 int
+	x42 int
+	x43 int
+	x44 int
+	x45 int
+	x46 int
+	x47 int
+	x48 int
+	x49 int
+	x50 int
+	x51 int
+	x52 int
+	x53 int
+	x54 int
+	x55 int
+	x56 int
+	x57 int
+	x58 int
+	x59 int
+	x60 int
+	x61 int
+	x62 int
+	x63 int
+	x64 int
+	x65 int
+	x66 int
+	x67 int
+	x68 int
+	x69 int
+	x70 int
+	x71 int
+	x72 int
+	x73 int
+	x74 int
+	x75 int
+	x76 int
+	x77 int
+	x78 int
+	x79 int
+	x80 int
+	x81 int
+	x82 int
+	x83 int
+	x84 int
+	x85 int
+	x86 int
+	x87 int
+	x88 int
+	x89 int
+	x90 int
+	x91 int
+	x92 int
+	x93 int
+	x94 int
+	x95 int
+	x96 int
+	x97 int
+	x98 int
+	x99 int
+	x100 int
+	x101 int
+	x102 int
+	x103 int
+	x104 int
+	x105 int
+	x106 int
+	x107 int
+	x108 int
+	x109 int
+	x110 int
+	x111 int
+	x112 int
+	x113 int
+	x114 int
+	x115 int
+	x116 int
+	x117 int
+	x118 int
+	x119 int
+	x120 int
+	x121 int
+	x122 int
+	x123 int
+	x124 int
+	x125 int
+	x126 int
+	x127 int
+	x128 int
+	x129 int
+	x130 int
+	x131 int
+	x132 int
+	x133 int
+	x134 int
+	x135 int
+	x136 int
+	x137 int
+	x138 int
+	x139 int
+	x140 int
+	x141 int
+	x142 int
+	x143 int
+	x144 int
+	x145 int
+	x146 int
+	x147 int
+	x148 int
+	x149 int
+	x150 int
+	x151 int
+	x152 int
+	x153 int
+	x154 int
+	x155 int
+	x156 int
+	x157 int
+	x158 int
+	x159 int
+	x160 int
+	x161 int
+	x162 int
+	x163 int
+	x164 int
+	x165 int
+	x166 int
+	x167 int
+	x168 int
+	x169 int
+	x170 int
+	x171 int
+	x172 int
+	x173 int
+	x174 int
+	x175 int
+	x176 int
+	x177 int
+	x178 int
+	x179 int
+	x180 int
+	x181 int
+	x182 int
+	x183 int
+	x184 int
+	x185 int
+	x186 int
+	x187 int
+	x188 int
+	x189 int
+	x190 int
+	x191 int
+	x192 int
+	x193 int
+	x194 int
+	x195 int
+	x196 int
+	x197 int
+	x198 int
+	x199 int
+	x200 int
+	x201 int
+	x202 int
+	x203 int
+	x204 int
+	x205 int
+	x206 int
+	x207 int
+	x208 int
+	x209 int
+	x210 int
+	x211 int
+	x212 int
+	x213 int
+	x214 int
+	x215 int
+	x216 int
+	x217 int
+	x218 int
+	x219 int
+	x220 int
+	x221 int
+	x222 int
+	x223 int
+	x224 int
+	x225 int
+	x226 int
+	x227 int
+	x228 int
+	x229 int
+	x230 int
+	x231 int
+	x232 int
+	x233 int
+	x234 int
+	x235 int
+	x236 int
+	x237 int
+	x238 int
+	x239 int
+	x240 int
+	x241 int
+	x242 int
+	x243 int
+	x244 int
+	x245 int
+	x246 int
+	x247 int
+	x248 int
+	x249 int
+	x250 int
+	x251 int
+	x252 int
+	x253 int
+	x254 int
+	x255 int
+	x256 int
+	x257 int
+	x258 int
+	x259 int
+	x260 int
+	x261 int
+	x262 int
+	x263 int
+	x264 int
+	x265 int
+	x266 int
+	x267 int
+	x268 int
+	x269 int
+	x270 int
+	x271 int
+	x272 int
+	x273 int
+	x274 int
+	x275 int
+	x276 int
+	x277 int
+	x278 int
+	x279 int
+	x280 int
+	x281 int
+	x282 int
+	x283 int
+	x284 int
+	x285 int
+	x286 int
+	x287 int
+	x288 int
+	x289 int
+	x290 int
+	x291 int
+	x292 int
+	x293 int
+	x294 int
+	x295 int
+	x296 int
+	x297 int
+	x298 int
+	x299 int
+	x300 int
+	x301 int
+	x302 int
+	x303 int
+	x304 int
+	x305 int
+	x306 int
+	x307 int
+	x308 int
+	x309 int
+	x310 int
+	x311 int
+	x312 int
+	x313 int
+	x314 int
+	x315 int
+	x316 int
+	x317 int
+	x318 int
+	x319 int
+	x320 int
+	x321 int
+	x322 int
+	x323 int
+	x324 int
+	x325 int
+	x326 int
+	x327 int
+	x328 int
+	x329 int
+	x330 int
+	x331 int
+	x332 int
+	x333 int
+	x334 int
+	x335 int
+	x336 int
+	x337 int
+	x338 int
+	x339 int
+	x340 int
+	x341 int
+	x342 int
+	x343 int
+	x344 int
+	x345 int
+	x346 int
+	x347 int
+	x348 int
+	x349 int
+	x350 int
+	x351 int
+	x352 int
+	x353 int
+	x354 int
+	x355 int
+	x356 int
+	x357 int
+	x358 int
+	x359 int
+	x360 int
+	x361 int
+	x362 int
+	x363 int
+	x364 int
+	x365 int
+	x366 int
+	x367 int
+	x368 int
+	x369 int
+	x370 int
+	x371 int
+	x372 int
+	x373 int
+	x374 int
+	x375 int
+	x376 int
+	x377 int
+	x378 int
+	x379 int
+	x380 int
+	x381 int
+	x382 int
+	x383 int
+	x384 int
+	x385 int
+	x386 int
+	x387 int
+	x388 int
+	x389 int
+	x390 int
+	x391 int
+	x392 int
+	x393 int
+	x394 int
+	x395 int
+	x396 int
+	x397 int
+	x398 int
+	x399 int
+	x400 int
+	x401 int
+	x402 int
+	x403 int
+	x404 int
+	x405 int
+	x406 int
+	x407 int
+	x408 int
+	x409 int
+	x410 int
+	x411 int
+	x412 int
+	x413 int
+	x414 int
+	x415 int
+	x416 int
+	x417 int
+	x418 int
+	x419 int
+	x420 int
+	x421 int
+	x422 int
+	x423 int
+	x424 int
+	x425 int
+	x426 int
+	x427 int
+	x428 int
+	x429 int
+	x430 int
+	x431 int
+	x432 int
+	x433 int
+	x434 int
+	x435 int
+	x436 int
+	x437 int
+	x438 int
+	x439 int
+	x440 int
+	x441 int
+	x442 int
+	x443 int
+	x444 int
+	x445 int
+	x446 int
+	x447 int
+	x448 int
+	x449 int
+	x450 int
+	x451 int
+	x452 int
+	x453 int
+	x454 int
+	x455 int
+	x456 int
+	x457 int
+	x458 int
+	x459 int
+	x460 int
+	x461 int
+	x462 int
+	x463 int
+	x464 int
+	x465 int
+	x466 int
+	x467 int
+	x468 int
+	x469 int
+	x470 int
+	x471 int
+	x472 int
+	x473 int
+	x474 int
+	x475 int
+	x476 int
+	x477 int
+	x478 int
+	x479 int
+	x480 int
+	x481 int
+	x482 int
+	x483 int
+	x484 int
+	x485 int
+	x486 int
+	x487 int
+	x488 int
+	x489 int
+	x490 int
+	x491 int
+	x492 int
+	x493 int
+	x494 int
+	x495 int
+	x496 int
+	x497 int
+	x498 int
+	x499 int
+	x500 int
+	x501 int
+	x502 int
+	x503 int
+	x504 int
+	x505 int
+	x506 int
+	x507 int
+	x508 int
+	x509 int
+	x510 int
+	x511 int
+	x512 int
+	x513 int
+	x514 int
+	x515 int
+	x516 int
+	x517 int
+	x518 int
+	x519 int
+	x520 int
+	x521 int
+	x522 int
+	x523 int
+	x524 int
+	x525 int
+	x526 int
+	x527 int
+	x528 int
+	x529 int
+	x530 int
+	x531 int
+	x532 int
+	x533 int
+	x534 int
+	x535 int
+	x536 int
+	x537 int
+	x538 int
+	x539 int
+	x540 int
+	x541 int
+	x542 int
+	x543 int
+	x544 int
+	x545 int
+	x546 int
+	x547 int
+	x548 int
+	x549 int
+	x550 int
+	x551 int
+	x552 int
+	x553 int
+	x554 int
+	x555 int
+	x556 int
+	x557 int
+	x558 int
+	x559 int
+	x560 int
+	x561 int
+	x562 int
+	x563 int
+	x564 int
+	x565 int
+	x566 int
+	x567 int
+	x568 int
+	x569 int
+	x570 int
+	x571 int
+	x572 int
+	x573 int
+	x574 int
+	x575 int
+	x576 int
+	x577 int
+	x578 int
+	x579 int
+	x580 int
+	x581 int
+	x582 int
+	x583 int
+	x584 int
+	x585 int
+	x586 int
+	x587 int
+	x588 int
+	x589 int
+	x590 int
+	x591 int
+	x592 int
+	x593 int
+	x594 int
+	x595 int
+	x596 int
+	x597 int
+	x598 int
+	x599 int
+	x600 int
+	x601 int
+	x602 int
+	x603 int
+	x604 int
+	x605 int
+	x606 int
+	x607 int
+	x608 int
+	x609 int
+	x610 int
+	x611 int
+	x612 int
+	x613 int
+	x614 int
+	x615 int
+	x616 int
+	x617 int
+	x618 int
+	x619 int
+	x620 int
+	x621 int
+	x622 int
+	x623 int
+	x624 int
+	x625 int
+	x626 int
+	x627 int
+	x628 int
+	x629 int
+	x630 int
+	x631 int
+	x632 int
+	x633 int
+	x634 int
+	x635 int
+	x636 int
+	x637 int
+	x638 int
+	x639 int
+	x640 int
+	x641 int
+	x642 int
+	x643 int
+	x644 int
+	x645 int
+	x646 int
+	x647 int
+	x648 int
+	x649 int
+	x650 int
+	x651 int
+	x652 int
+	x653 int
+	x654 int
+	x655 int
+	x656 int
+	x657 int
+	x658 int
+	x659 int
+	x660 int
+	x661 int
+	x662 int
+	x663 int
+	x664 int
+	x665 int
+	x666 int
+	x667 int
+	x668 int
+	x669 int
+	x670 int
+	x671 int
+	x672 int
+	x673 int
+	x674 int
+	x675 int
+	x676 int
+	x677 int
+	x678 int
+	x679 int
+	x680 int
+	x681 int
+	x682 int
+	x683 int
+	x684 int
+	x685 int
+	x686 int
+	x687 int
+	x688 int
+	x689 int
+	x690 int
+	x691 int
+	x692 int
+	x693 int
+	x694 int
+	x695 int
+	x696 int
+	x697 int
+	x698 int
+	x699 int
+	x700 int
+	x701 int
+	x702 int
+	x703 int
+	x704 int
+	x705 int
+	x706 int
+	x707 int
+	x708 int
+	x709 int
+	x710 int
+	x711 int
+	x712 int
+	x713 int
+	x714 int
+	x715 int
+	x716 int
+	x717 int
+	x718 int
+	x719 int
+	x720 int
+	x721 int
+	x722 int
+	x723 int
+	x724 int
+	x725 int
+	x726 int
+	x727 int
+	x728 int
+	x729 int
+	x730 int
+	x731 int
+	x732 int
+	x733 int
+	x734 int
+	x735 int
+	x736 int
+	x737 int
+	x738 int
+	x739 int
+	x740 int
+	x741 int
+	x742 int
+	x743 int
+	x744 int
+	x745 int
+	x746 int
+	x747 int
+	x748 int
+	x749 int
+	x750 int
+	x751 int
+	x752 int
+	x753 int
+	x754 int
+	x755 int
+	x756 int
+	x757 int
+	x758 int
+	x759 int
+	x760 int
+	x761 int
+	x762 int
+	x763 int
+	x764 int
+	x765 int
+	x766 int
+	x767 int
+	x768 int
+	x769 int
+	x770 int
+	x771 int
+	x772 int
+	x773 int
+	x774 int
+	x775 int
+	x776 int
+	x777 int
+	x778 int
+	x779 int
+	x780 int
+	x781 int
+	x782 int
+	x783 int
+	x784 int
+	x785 int
+	x786 int
+	x787 int
+	x788 int
+	x789 int
+	x790 int
+	x791 int
+	x792 int
+	x793 int
+	x794 int
+	x795 int
+	x796 int
+	x797 int
+	x798 int
+	x799 int
+	x800 int
+	x801 int
+	x802 int
+	x803 int
+	x804 int
+	x805 int
+	x806 int
+	x807 int
+	x808 int
+	x809 int
+	x810 int
+	x811 int
+	x812 int
+	x813 int
+	x814 int
+	x815 int
+	x816 int
+	x817 int
+	x818 int
+	x819 int
+	x820 int
+	x821 int
+	x822 int
+	x823 int
+	x824 int
+	x825 int
+	x826 int
+	x827 int
+	x828 int
+	x829 int
+	x830 int
+	x831 int
+	x832 int
+	x833 int
+	x834 int
+	x835 int
+	x836 int
+	x837 int
+	x838 int
+	x839 int
+	x840 int
+	x841 int
+	x842 int
+	x843 int
+	x844 int
+	x845 int
+	x846 int
+	x847 int
+	x848 int
+	x849 int
+	x850 int
+	x851 int
+	x852 int
+	x853 int
+	x854 int
+	x855 int
+	x856 int
+	x857 int
+	x858 int
+	x859 int
+	x860 int
+	x861 int
+	x862 int
+	x863 int
+	x864 int
+	x865 int
+	x866 int
+	x867 int
+	x868 int
+	x869 int
+	x870 int
+	x871 int
+	x872 int
+	x873 int
+	x874 int
+	x875 int
+	x876 int
+	x877 int
+	x878 int
+	x879 int
+	x880 int
+	x881 int
+	x882 int
+	x883 int
+	x884 int
+	x885 int
+	x886 int
+	x887 int
+	x888 int
+	x889 int
+	x890 int
+	x891 int
+	x892 int
+	x893 int
+	x894 int
+	x895 int
+	x896 int
+	x897 int
+	x898 int
+	x899 int
+	x900 int
+	x901 int
+	x902 int
+	x903 int
+	x904 int
+	x905 int
+	x906 int
+	x907 int
+	x908 int
+	x909 int
+	x910 int
+	x911 int
+	x912 int
+	x913 int
+	x914 int
+	x915 int
+	x916 int
+	x917 int
+	x918 int
+	x919 int
+	x920 int
+	x921 int
+	x922 int
+	x923 int
+	x924 int
+	x925 int
+	x926 int
+	x927 int
+	x928 int
+	x929 int
+	x930 int
+	x931 int
+	x932 int
+	x933 int
+	x934 int
+	x935 int
+	x936 int
+	x937 int
+	x938 int
+	x939 int
+	x940 int
+	x941 int
+	x942 int
+	x943 int
+	x944 int
+	x945 int
+	x946 int
+	x947 int
+	x948 int
+	x949 int
+	x950 int
+	x951 int
+	x952 int
+	x953 int
+	x954 int
+	x955 int
+	x956 int
+	x957 int
+	x958 int
+	x959 int
+	x960 int
+	x961 int
+	x962 int
+	x963 int
+	x964 int
+	x965 int
+	x966 int
+	x967 int
+	x968 int
+	x969 int
+	x970 int
+	x971 int
+	x972 int
+	x973 int
+	x974 int
+	x975 int
+	x976 int
+	x977 int
+	x978 int
+	x979 int
+	x980 int
+	x981 int
+	x982 int
+	x983 int
+	x984 int
+	x985 int
+	x986 int
+	x987 int
+	x988 int
+	x989 int
+	x990 int
+	x991 int
+	x992 int
+	x993 int
+	x994 int
+	x995 int
+	x996 int
+	x997 int
+	x998 int
+	x999 int
 	x1000 int
 }
 
diff --git a/test/fixedbugs/bug304.go b/test/fixedbugs/bug304.go
index 69cb9e4d38..4073073eec 100644
--- a/test/fixedbugs/bug304.go
+++ b/test/fixedbugs/bug304.go
@@ -9,12 +9,10 @@
 // bug304.go:15:2: internal compiler error: in copy_tree_r, at tree-inline.c:4114
 
 package p
-
 type S struct {
 	v interface{}
 }
-
-func g(e interface{}) {}
+func g(e interface{}) { }
 func f(s S) {
 	g(s.v.(*int))
 }
diff --git a/test/fixedbugs/bug306.dir/p1.go b/test/fixedbugs/bug306.dir/p1.go
index b7a3579d04..b28551807d 100644
--- a/test/fixedbugs/bug306.dir/p1.go
+++ b/test/fixedbugs/bug306.dir/p1.go
@@ -5,5 +5,5 @@
 package p1
 
 type T <-chan int
-
 var x = make(chan T)
+
diff --git a/test/fixedbugs/bug306.dir/p2.go b/test/fixedbugs/bug306.dir/p2.go
index 6e72020dcf..f614507946 100644
--- a/test/fixedbugs/bug306.dir/p2.go
+++ b/test/fixedbugs/bug306.dir/p2.go
@@ -5,3 +5,4 @@
 package p2
 
 import _ "./p1"
+
diff --git a/test/fixedbugs/bug311.go b/test/fixedbugs/bug311.go
index 3bf8426af0..f5cab44c7e 100644
--- a/test/fixedbugs/bug311.go
+++ b/test/fixedbugs/bug311.go
@@ -9,9 +9,9 @@ package main
 func main() {
 	m := make(map[string][1000]byte)
 	m["hi"] = [1000]byte{1}
-
+	
 	v := m["hi"]
-
+	
 	for k, vv := range m {
 		if k != "hi" || string(v[:]) != string(vv[:]) {
 			panic("bad iter")
diff --git a/test/fixedbugs/bug314.go b/test/fixedbugs/bug314.go
index ad8b364765..6e26d14e1f 100644
--- a/test/fixedbugs/bug314.go
+++ b/test/fixedbugs/bug314.go
@@ -10,11 +10,10 @@ package main
 
 type S struct {
 }
-
-func (S) a() int {
+func (S) a() int{
 	return 0
 }
-func (S) b() int {
+func (S) b() int{
 	return 1
 }
 
diff --git a/test/fixedbugs/bug317.go b/test/fixedbugs/bug317.go
index 226b7fe9ad..4cd9ec2813 100644
--- a/test/fixedbugs/bug317.go
+++ b/test/fixedbugs/bug317.go
@@ -12,5 +12,5 @@ func main() {
 }
 
 func f() uint {
-	return 1 << 31 // doesn't panic with 1<<31 - 1
+	return 1<<31 // doesn't panic with 1<<31 - 1
 }
diff --git a/test/fixedbugs/bug319.go b/test/fixedbugs/bug319.go
index d837af9a06..b93106d4bd 100644
--- a/test/fixedbugs/bug319.go
+++ b/test/fixedbugs/bug319.go
@@ -10,7 +10,7 @@ import "unsafe"
 
 func main() {
 	var x int
-
+	
 	a := uint64(uintptr(unsafe.Pointer(&x)))
 	b := uint32(uintptr(unsafe.Pointer(&x)))
 	c := uint16(uintptr(unsafe.Pointer(&x)))
diff --git a/test/fixedbugs/bug320.go b/test/fixedbugs/bug320.go
index c6bcc0f5c0..0406b96561 100644
--- a/test/fixedbugs/bug320.go
+++ b/test/fixedbugs/bug320.go
@@ -42,3 +42,4 @@ func escape(*int) {
 
 func f(int) {
 }
+
diff --git a/test/fixedbugs/bug322.dir/lib.go b/test/fixedbugs/bug322.dir/lib.go
index c338781925..0de56d3d64 100644
--- a/test/fixedbugs/bug322.dir/lib.go
+++ b/test/fixedbugs/bug322.dir/lib.go
@@ -5,7 +5,7 @@
 package lib
 
 type T struct {
-	x int // non-exported field
+	x int  // non-exported field
 }
 
 func (t T) M() {
diff --git a/test/fixedbugs/bug322.dir/main.go b/test/fixedbugs/bug322.dir/main.go
index 0b6984c6d2..f403c7d32e 100644
--- a/test/fixedbugs/bug322.dir/main.go
+++ b/test/fixedbugs/bug322.dir/main.go
@@ -22,7 +22,7 @@ func main() {
 	// This is still an error.
 	// var i1 I = t
 	// i1.M()
-
+	
 	// This combination is illegal because
 	// PM requires a pointer receiver.
 	// var pi1 PI = t
diff --git a/test/fixedbugs/bug324.dir/prog.go b/test/fixedbugs/bug324.dir/prog.go
index 4e415758cb..3ab61f3eb5 100644
--- a/test/fixedbugs/bug324.dir/prog.go
+++ b/test/fixedbugs/bug324.dir/prog.go
@@ -16,16 +16,17 @@ type Implementation struct{}
 
 func (p *Implementation) private() {}
 
+
 func main() {
 	// nothing unusual here
 	var x Exported
 	x = new(Implementation)
-	x.private() //  main.Implementation.private()
+	x.private()  //  main.Implementation.private()
 
 	// same here - should be and is legal
 	var px p.Exported
 	px = p.X
-
+	
 	// this assignment is correctly illegal:
 	//	px.private undefined (cannot refer to unexported field or method private)
 	// px.private()
@@ -43,10 +44,10 @@ func main() {
 		recover()
 	}()
 	x = px.(Exported)
-
+	
 	println("should not get this far")
 
 	// this is a legitimate call, but because of the previous assignment,
 	// it invokes the method private in p!
-	x.private() // p.Implementation.private()
+	x.private()  // p.Implementation.private()
 }
diff --git a/test/fixedbugs/bug325.go b/test/fixedbugs/bug325.go
index 50d79d521d..e6528ae46a 100644
--- a/test/fixedbugs/bug325.go
+++ b/test/fixedbugs/bug325.go
@@ -10,6 +10,6 @@ import "unsafe"
 
 func main() {
 	var x unsafe.Pointer
-	println(*x)                       // ERROR "invalid indirect.*unsafe.Pointer"
-	var _ = (unsafe.Pointer)(nil).foo // ERROR "foo"
+	println(*x) // ERROR "invalid indirect.*unsafe.Pointer"
+	var _ = (unsafe.Pointer)(nil).foo  // ERROR "foo"
 }
diff --git a/test/fixedbugs/bug330.go b/test/fixedbugs/bug330.go
index 6c1cb1394b..2f33feb4b6 100644
--- a/test/fixedbugs/bug330.go
+++ b/test/fixedbugs/bug330.go
@@ -8,6 +8,6 @@ package main
 
 func main() {
 	x := ""
-	x = +"hello" // ERROR "invalid operation.*string|expected numeric"
-	x = +x       // ERROR "invalid operation.*string|expected numeric"
+	x = +"hello"  // ERROR "invalid operation.*string|expected numeric"
+	x = +x  // ERROR "invalid operation.*string|expected numeric"
 }
diff --git a/test/fixedbugs/bug332.go b/test/fixedbugs/bug332.go
index faa445fb5a..d43c2ddcff 100644
--- a/test/fixedbugs/bug332.go
+++ b/test/fixedbugs/bug332.go
@@ -14,4 +14,4 @@ func main() {}
 
 // important: no newline on end of next line.
 // 6g used to print <epoch> instead of bug332.go:111
-func (t *T) F() {} // ERROR "undefined: T"
+func (t *T) F() {} // ERROR "undefined: T"
\ No newline at end of file
diff --git a/test/fixedbugs/bug333.go b/test/fixedbugs/bug333.go
index 86927b26ed..149843a3b0 100644
--- a/test/fixedbugs/bug333.go
+++ b/test/fixedbugs/bug333.go
@@ -9,9 +9,9 @@
 package main
 
 func main() {
-	type Ts string
-	var ts Ts
-	_ = []byte(ts)
+       type Ts string
+       var ts Ts
+       _ = []byte(ts)
 }
 
 /*
diff --git a/test/fixedbugs/bug337.go b/test/fixedbugs/bug337.go
index 8021c8b910..1a0616f70a 100644
--- a/test/fixedbugs/bug337.go
+++ b/test/fixedbugs/bug337.go
@@ -6,7 +6,7 @@
 
 // Issue 1722.
 
-// Check that the error messages says
+// Check that the error messages says 
 //	bug337.go:16: len("foo") not used
 // and not
 //	bug337.go:16: 3 not used
@@ -14,5 +14,6 @@
 package main
 
 func main() {
-	len("foo") // ERROR "len|value computed is not used"
+	len("foo")	// ERROR "len|value computed is not used"
 }
+
diff --git a/test/fixedbugs/bug341.go b/test/fixedbugs/bug341.go
index 7e478f3742..baab28216f 100644
--- a/test/fixedbugs/bug341.go
+++ b/test/fixedbugs/bug341.go
@@ -15,7 +15,6 @@ func main() {
 	_ = uint64(x)
 	_ = float32(0)
 }
-
 /*
 panic: runtime error: floating point error
 
diff --git a/test/fixedbugs/bug343.go b/test/fixedbugs/bug343.go
index e63347cd44..fd8bd76bbf 100644
--- a/test/fixedbugs/bug343.go
+++ b/test/fixedbugs/bug343.go
@@ -9,22 +9,22 @@
 package main
 
 func getArgs(data map[string]interface{}, keys ...string) map[string]string {
-	ret := map[string]string{}
-	var ok bool
-	for _, k := range keys {
-		ret[k], ok = data[k].(string)
-		if !ok {
-		}
-	}
-	return ret
+       ret := map[string]string{}
+       var ok bool
+       for _, k := range keys {
+               ret[k], ok = data[k].(string)
+               if !ok {}
+       }
+       return ret
 }
 
 func main() {
-	x := getArgs(map[string]interface{}{"x": "y"}, "x")
+	x := getArgs(map[string]interface{}{"x":"y"}, "x")
 	if x["x"] != "y" {
 		println("BUG bug343", x)
 	}
 }
+	
 
 /*
 typecheck [1008592b0]
diff --git a/test/fixedbugs/bug344.go b/test/fixedbugs/bug344.go
index 42aace6ab6..b53abd26e3 100644
--- a/test/fixedbugs/bug344.go
+++ b/test/fixedbugs/bug344.go
@@ -14,10 +14,10 @@ func main() {
 	i := 42
 	a := []*int{&i, &i, &i, &i}
 	x := a[0]
-	goto start // ERROR "jumps into block"
+	goto start  // ERROR "jumps into block"
 	z := 1
 	_ = z
-	for _, x = range a { // GCCGO_ERROR "block"
+	for _, x = range a {	// GCCGO_ERROR "block"
 	start:
 		fmt.Sprint(*x)
 	}
diff --git a/test/fixedbugs/bug347.go b/test/fixedbugs/bug347.go
index 6ea0419c39..92afb2e704 100644
--- a/test/fixedbugs/bug347.go
+++ b/test/fixedbugs/bug347.go
@@ -19,7 +19,7 @@ var c chan int
 
 func f() {
 	select {
-	case <-t.c: // THIS IS LINE 22
+	case <-t.c:  // THIS IS LINE 22
 		break
 	case <-c:
 		break
@@ -29,7 +29,7 @@ func f() {
 func main() {
 	defer func() {
 		recover()
-		for i := 0; ; i++ {
+		for i := 0;; i++ {
 			pc, file, line, ok := runtime.Caller(i)
 			if !ok {
 				print("BUG: bug347: cannot find caller\n")
diff --git a/test/fixedbugs/bug348.go b/test/fixedbugs/bug348.go
index 8d7dc0a3bd..c7f1346159 100644
--- a/test/fixedbugs/bug348.go
+++ b/test/fixedbugs/bug348.go
@@ -13,8 +13,8 @@ import (
 
 func f() {
 	var x *string
-
-	for _, i := range *x { // THIS IS LINE 17
+	
+	for _, i := range *x {  // THIS IS LINE 17
 		println(i)
 	}
 }
@@ -24,7 +24,7 @@ func g() {
 
 func main() {
 	defer func() {
-		for i := 0; ; i++ {
+		for i := 0;; i++ {
 			pc, file, line, ok := runtime.Caller(i)
 			if !ok {
 				print("BUG: bug348: cannot find caller\n")
diff --git a/test/fixedbugs/bug356.go b/test/fixedbugs/bug356.go
index 2dcd8675d0..6d93860be9 100644
--- a/test/fixedbugs/bug356.go
+++ b/test/fixedbugs/bug356.go
@@ -12,26 +12,27 @@ func main() {
 	var i uint64
 	var x int = 12345
 
-	if y := x << (i & 5); y != 12345<<0 {
+	if y := x << (i&5); y != 12345<<0 {
 		println("BUG bug344", y)
 		return
 	}
-
+	
 	i++
-	if y := x << (i & 5); y != 12345<<1 {
+	if y := x << (i&5); y != 12345<<1 {
 		println("BUG bug344a", y)
 	}
-
+	
 	i = 70
 	if y := x << i; y != 0 {
 		println("BUG bug344b", y)
 	}
-
-	i = 1 << 32
+	
+	i = 1<<32
 	if y := x << i; y != 0 {
 		println("BUG bug344c", y)
 	}
 }
+	
 
 /*
 typecheck [1008592b0]
diff --git a/test/fixedbugs/bug357.go b/test/fixedbugs/bug357.go
index 16f3abb002..e9db50e88e 100644
--- a/test/fixedbugs/bug357.go
+++ b/test/fixedbugs/bug357.go
@@ -15,7 +15,7 @@ func bla1() bool {
 
 func bla5() bool {
 	_ = 1
-	false // ERROR "false evaluated but not used|value computed is not used"
+	false  // ERROR "false evaluated but not used|value computed is not used"
 	_ = 2
 	return false
 }
diff --git a/test/fixedbugs/bug361.go b/test/fixedbugs/bug361.go
index 57e933658d..8e282431eb 100644
--- a/test/fixedbugs/bug361.go
+++ b/test/fixedbugs/bug361.go
@@ -10,6 +10,6 @@
 package test
 
 func main() {
-	buf := [1 << 30]byte{}
+	buf := [1<<30]byte{}
 	_ = buf[:]
 }
diff --git a/test/fixedbugs/bug362.go b/test/fixedbugs/bug362.go
index cc73c947a3..771d13d435 100644
--- a/test/fixedbugs/bug362.go
+++ b/test/fixedbugs/bug362.go
@@ -10,7 +10,7 @@
 package main
 
 var (
-	a = iota // ERROR "undefined: iota|iota is only defined in const"
-	b = iota // ERROR "undefined: iota|iota is only defined in const"
-	c = iota // ERROR "undefined: iota|iota is only defined in const"
+	a = iota  // ERROR "undefined: iota|iota is only defined in const"
+	b = iota  // ERROR "undefined: iota|iota is only defined in const"
+	c = iota  // ERROR "undefined: iota|iota is only defined in const"
 )
diff --git a/test/fixedbugs/bug363.go b/test/fixedbugs/bug363.go
index 4c10a3a334..1bd1400987 100644
--- a/test/fixedbugs/bug363.go
+++ b/test/fixedbugs/bug363.go
@@ -10,12 +10,12 @@ package main
 
 func main() {
 	var i uint = 33
-	var a = (1 << i) + 4.5 // ERROR "shift of type float64|invalid.*shift"
+	var a = (1<<i) + 4.5  // ERROR "shift of type float64|invalid.*shift"
 	println(a)
-
-	var b = (1 << i) + 4.0 // ERROR "shift of type float64|invalid.*shift"
+	
+	var b = (1<<i) + 4.0  // ERROR "shift of type float64|invalid.*shift"
 	println(b)
 
-	var c int64 = (1 << i) + 4.0 // ok - it's all int64
+	var c int64 = (1<<i) + 4.0  // ok - it's all int64
 	println(c)
 }
diff --git a/test/fixedbugs/bug364.go b/test/fixedbugs/bug364.go
index b6d1377372..64120d1643 100644
--- a/test/fixedbugs/bug364.go
+++ b/test/fixedbugs/bug364.go
@@ -14,7 +14,7 @@ func accum(args ...interface{}) {
 	s += fmt.Sprintln(args...)
 }
 
-func f() {
+func f(){
 	v := 0.0
 	for i := 0; i < 3; i++ {
 		v += 0.1
diff --git a/test/fixedbugs/bug366.go b/test/fixedbugs/bug366.go
index 2f937b91b5..3af5beaaf0 100644
--- a/test/fixedbugs/bug366.go
+++ b/test/fixedbugs/bug366.go
@@ -15,23 +15,23 @@ func five(x int64) {
 }
 
 func main() {
-	// 5
-	five(int64(5 / (5 / 3)))
-
-	// 5
-	five(int64(byte(5) / (byte(5) / byte(3))))
-
-	// 5
-	var a, b byte = 5, 3
-	five(int64(a / (a / b)))
-
-	// integer divide by zero in golang.org sandbox
-	// 0 on windows/amd64
-	x := [3]byte{2, 3, 5}
-	five(int64(x[2] / (x[2] / x[1])))
-
-	// integer divide by zero in golang.org sandbox
-	// crash on windows/amd64
-	y := x[1:3]
-	five(int64(y[1] / (y[1] / y[0])))
-}
+       // 5
+       five(int64(5 / (5 / 3)))
+
+       // 5
+       five(int64(byte(5) / (byte(5) / byte(3))))
+
+       // 5
+       var a, b byte = 5, 3
+       five(int64(a / (a / b)))
+       
+       // integer divide by zero in golang.org sandbox
+       // 0 on windows/amd64
+       x := [3]byte{2, 3, 5}
+       five(int64(x[2] / (x[2] / x[1])))
+
+       // integer divide by zero in golang.org sandbox
+       // crash on windows/amd64
+       y := x[1:3]
+       five(int64(y[1] / (y[1] / y[0])))
+}
\ No newline at end of file
diff --git a/test/fixedbugs/bug368.go b/test/fixedbugs/bug368.go
index 60f3628b4b..353ea5a0b1 100644
--- a/test/fixedbugs/bug368.go
+++ b/test/fixedbugs/bug368.go
@@ -12,7 +12,7 @@ package main
 func f(n int) int {
 	s := 0
 	for i := 0; i < n; i++ {
-		s += i >> 1
+		s += i>>1
 	}
 	return s
 }
diff --git a/test/fixedbugs/bug369.dir/pkg.go b/test/fixedbugs/bug369.dir/pkg.go
index c46acff79b..9964347250 100644
--- a/test/fixedbugs/bug369.dir/pkg.go
+++ b/test/fixedbugs/bug369.dir/pkg.go
@@ -12,3 +12,4 @@ func NonASCII(b []byte, i int) int {
 	}
 	return i
 }
+
diff --git a/test/fixedbugs/bug372.go b/test/fixedbugs/bug372.go
index caf5b54447..5fba131d7a 100644
--- a/test/fixedbugs/bug372.go
+++ b/test/fixedbugs/bug372.go
@@ -7,8 +7,7 @@
 // Issue 2355
 package main
 
-type T struct{}
-
+type T struct {}
 func (T) m() string { return "T" }
 
 type TT struct {
@@ -16,6 +15,7 @@ type TT struct {
 	m func() string
 }
 
+
 func ff() string { return "ff" }
 
 func main() {
diff --git a/test/fixedbugs/bug373.go b/test/fixedbugs/bug373.go
index 6efdfad58b..aa0f5d1efa 100644
--- a/test/fixedbugs/bug373.go
+++ b/test/fixedbugs/bug373.go
@@ -9,7 +9,7 @@
 package foo
 
 func f(x interface{}) {
-	switch t := x.(type) { // ERROR "declared and not used"
+	switch t := x.(type) {  // ERROR "declared and not used"
 	case int:
 	}
 }
diff --git a/test/fixedbugs/bug374.go b/test/fixedbugs/bug374.go
index b659b46e39..2d604cbd3c 100644
--- a/test/fixedbugs/bug374.go
+++ b/test/fixedbugs/bug374.go
@@ -13,8 +13,8 @@ type I interface {
 
 type T int
 
-var _ I = T(0) // GCCGO_ERROR "incompatible"
+var _ I = T(0)	// GCCGO_ERROR "incompatible"
 
-func (T) m(buf []byte) (a int, b xxxx) { // ERROR "xxxx"
+func (T) m(buf []byte) (a int, b xxxx) {  // ERROR "xxxx"
 	return 0, nil
 }
diff --git a/test/fixedbugs/bug376.go b/test/fixedbugs/bug376.go
index d4f28c33ce..cd700124fe 100644
--- a/test/fixedbugs/bug376.go
+++ b/test/fixedbugs/bug376.go
@@ -6,7 +6,5 @@
 
 // issue 1951
 package foo
-
 import "unsafe"
-
-var v = unsafe.Sizeof // ERROR "not in function call|must be called"
+var v = unsafe.Sizeof  // ERROR "not in function call|must be called"
diff --git a/test/fixedbugs/bug377.dir/one.go b/test/fixedbugs/bug377.dir/one.go
index d0829473d6..e29b813a48 100644
--- a/test/fixedbugs/bug377.dir/one.go
+++ b/test/fixedbugs/bug377.dir/one.go
@@ -7,3 +7,4 @@ package one
 func Foo() (n int64, _ *int) {
 	return 42, nil
 }
+
diff --git a/test/fixedbugs/bug377.dir/two.go b/test/fixedbugs/bug377.dir/two.go
index 9e016462c2..2a10812d56 100644
--- a/test/fixedbugs/bug377.dir/two.go
+++ b/test/fixedbugs/bug377.dir/two.go
@@ -5,3 +5,4 @@
 package two
 
 import _ "./one"
+
diff --git a/test/fixedbugs/bug378.go b/test/fixedbugs/bug378.go
index d382e198b0..c7b0dac313 100644
--- a/test/fixedbugs/bug378.go
+++ b/test/fixedbugs/bug378.go
@@ -9,12 +9,11 @@
 package main
 
 type Header struct{}
-
 func (h Header) Method() {}
 
 var _ interface{} = Header{}
 
 func main() {
-	type X Header
-	var _ interface{} = X{}
+  	type X Header
+  	var _ interface{} = X{}
 }
diff --git a/test/fixedbugs/bug379.go b/test/fixedbugs/bug379.go
index bef19ddbed..5638123d50 100644
--- a/test/fixedbugs/bug379.go
+++ b/test/fixedbugs/bug379.go
@@ -6,7 +6,7 @@
 
 // Issue 2452.
 
-// Check that the error messages says
+// Check that the error messages says 
 //	bug378.go:17: 1 + 2 not used
 // and not
 //	bug378.go:17: 1 not used
diff --git a/test/fixedbugs/bug380.go b/test/fixedbugs/bug380.go
index cacaec6d09..0cb3487327 100644
--- a/test/fixedbugs/bug380.go
+++ b/test/fixedbugs/bug380.go
@@ -7,7 +7,5 @@
 // Used to cause a typechecking loop error.
 
 package pkg
-
 type T map[int]string
-
 var q = &T{}
diff --git a/test/fixedbugs/bug381.go b/test/fixedbugs/bug381.go
index b04617cd8b..a0a1c8aaa4 100644
--- a/test/fixedbugs/bug381.go
+++ b/test/fixedbugs/bug381.go
@@ -6,7 +6,7 @@
 
 // Issue 2276.
 
-// Check that the error messages says
+// Check that the error messages says 
 //	bug381.go:29: unsafe.Alignof(0) not used
 // and not
 //	bug381.go:29: 4 not used
diff --git a/test/fixedbugs/bug382.dir/pkg.go b/test/fixedbugs/bug382.dir/pkg.go
index d66ba8a3c6..92fe4e335a 100644
--- a/test/fixedbugs/bug382.dir/pkg.go
+++ b/test/fixedbugs/bug382.dir/pkg.go
@@ -3,7 +3,5 @@
 // license that can be found in the LICENSE file.
 
 package pkg
-
-type T struct{}
-
+type T struct {}
 var E T
diff --git a/test/fixedbugs/bug383.go b/test/fixedbugs/bug383.go
index 2520736745..dc2ecd61fb 100644
--- a/test/fixedbugs/bug383.go
+++ b/test/fixedbugs/bug383.go
@@ -7,10 +7,7 @@
 // Issue 2520
 
 package main
-
 func main() {
-	if 2e9 {
-	} // ERROR "2e.09|expected bool"
-	if 3.14 + 1i {
-	} // ERROR "3.14 . 1i|expected bool"
+	if 2e9 { }      // ERROR "2e.09|expected bool"
+	if 3.14+1i { }  // ERROR "3.14 . 1i|expected bool"
 }
diff --git a/test/fixedbugs/bug384.go b/test/fixedbugs/bug384.go
index a84dcf488a..d02352b478 100644
--- a/test/fixedbugs/bug384.go
+++ b/test/fixedbugs/bug384.go
@@ -9,4 +9,4 @@
 package foo
 
 // Check that we only get root cause message, no further complaints about r undefined
-func (r *indexWriter) foo() {} // ERROR "undefined.*indexWriter"
+func (r *indexWriter) foo() {}  // ERROR "undefined.*indexWriter"
diff --git a/test/fixedbugs/bug385_32.go b/test/fixedbugs/bug385_32.go
index 3747141de1..73a1311f32 100644
--- a/test/fixedbugs/bug385_32.go
+++ b/test/fixedbugs/bug385_32.go
@@ -8,9 +8,8 @@
 // Issue 2444
 
 package main
-
 func main() {
-	var arr [1000200030]int // GC_ERROR "type .* too large"
+	var arr [1000200030]int   // GC_ERROR "type .* too large"
 	arr_bkup := arr
 	_ = arr_bkup
 }
diff --git a/test/fixedbugs/bug385_64.go b/test/fixedbugs/bug385_64.go
index 3c3790145b..0f941ca2f4 100644
--- a/test/fixedbugs/bug385_64.go
+++ b/test/fixedbugs/bug385_64.go
@@ -10,420 +10,214 @@
 
 package main
 
-var z [10 << 20]byte
+var z [10<<20]byte
 
 func main() { // GC_ERROR "stack frame too large"
 	// seq 1 206 | sed 's/.*/	var x& [10<<20]byte; z = x&/'
-	var x1 [10 << 20]byte
-	z = x1
-	var x2 [10 << 20]byte
-	z = x2
-	var x3 [10 << 20]byte
-	z = x3
-	var x4 [10 << 20]byte
-	z = x4
-	var x5 [10 << 20]byte
-	z = x5
-	var x6 [10 << 20]byte
-	z = x6
-	var x7 [10 << 20]byte
-	z = x7
-	var x8 [10 << 20]byte
-	z = x8
-	var x9 [10 << 20]byte
-	z = x9
-	var x10 [10 << 20]byte
-	z = x10
-	var x11 [10 << 20]byte
-	z = x11
-	var x12 [10 << 20]byte
-	z = x12
-	var x13 [10 << 20]byte
-	z = x13
-	var x14 [10 << 20]byte
-	z = x14
-	var x15 [10 << 20]byte
-	z = x15
-	var x16 [10 << 20]byte
-	z = x16
-	var x17 [10 << 20]byte
-	z = x17
-	var x18 [10 << 20]byte
-	z = x18
-	var x19 [10 << 20]byte
-	z = x19
-	var x20 [10 << 20]byte
-	z = x20
-	var x21 [10 << 20]byte
-	z = x21
-	var x22 [10 << 20]byte
-	z = x22
-	var x23 [10 << 20]byte
-	z = x23
-	var x24 [10 << 20]byte
-	z = x24
-	var x25 [10 << 20]byte
-	z = x25
-	var x26 [10 << 20]byte
-	z = x26
-	var x27 [10 << 20]byte
-	z = x27
-	var x28 [10 << 20]byte
-	z = x28
-	var x29 [10 << 20]byte
-	z = x29
-	var x30 [10 << 20]byte
-	z = x30
-	var x31 [10 << 20]byte
-	z = x31
-	var x32 [10 << 20]byte
-	z = x32
-	var x33 [10 << 20]byte
-	z = x33
-	var x34 [10 << 20]byte
-	z = x34
-	var x35 [10 << 20]byte
-	z = x35
-	var x36 [10 << 20]byte
-	z = x36
-	var x37 [10 << 20]byte
-	z = x37
-	var x38 [10 << 20]byte
-	z = x38
-	var x39 [10 << 20]byte
-	z = x39
-	var x40 [10 << 20]byte
-	z = x40
-	var x41 [10 << 20]byte
-	z = x41
-	var x42 [10 << 20]byte
-	z = x42
-	var x43 [10 << 20]byte
-	z = x43
-	var x44 [10 << 20]byte
-	z = x44
-	var x45 [10 << 20]byte
-	z = x45
-	var x46 [10 << 20]byte
-	z = x46
-	var x47 [10 << 20]byte
-	z = x47
-	var x48 [10 << 20]byte
-	z = x48
-	var x49 [10 << 20]byte
-	z = x49
-	var x50 [10 << 20]byte
-	z = x50
-	var x51 [10 << 20]byte
-	z = x51
-	var x52 [10 << 20]byte
-	z = x52
-	var x53 [10 << 20]byte
-	z = x53
-	var x54 [10 << 20]byte
-	z = x54
-	var x55 [10 << 20]byte
-	z = x55
-	var x56 [10 << 20]byte
-	z = x56
-	var x57 [10 << 20]byte
-	z = x57
-	var x58 [10 << 20]byte
-	z = x58
-	var x59 [10 << 20]byte
-	z = x59
-	var x60 [10 << 20]byte
-	z = x60
-	var x61 [10 << 20]byte
-	z = x61
-	var x62 [10 << 20]byte
-	z = x62
-	var x63 [10 << 20]byte
-	z = x63
-	var x64 [10 << 20]byte
-	z = x64
-	var x65 [10 << 20]byte
-	z = x65
-	var x66 [10 << 20]byte
-	z = x66
-	var x67 [10 << 20]byte
-	z = x67
-	var x68 [10 << 20]byte
-	z = x68
-	var x69 [10 << 20]byte
-	z = x69
-	var x70 [10 << 20]byte
-	z = x70
-	var x71 [10 << 20]byte
-	z = x71
-	var x72 [10 << 20]byte
-	z = x72
-	var x73 [10 << 20]byte
-	z = x73
-	var x74 [10 << 20]byte
-	z = x74
-	var x75 [10 << 20]byte
-	z = x75
-	var x76 [10 << 20]byte
-	z = x76
-	var x77 [10 << 20]byte
-	z = x77
-	var x78 [10 << 20]byte
-	z = x78
-	var x79 [10 << 20]byte
-	z = x79
-	var x80 [10 << 20]byte
-	z = x80
-	var x81 [10 << 20]byte
-	z = x81
-	var x82 [10 << 20]byte
-	z = x82
-	var x83 [10 << 20]byte
-	z = x83
-	var x84 [10 << 20]byte
-	z = x84
-	var x85 [10 << 20]byte
-	z = x85
-	var x86 [10 << 20]byte
-	z = x86
-	var x87 [10 << 20]byte
-	z = x87
-	var x88 [10 << 20]byte
-	z = x88
-	var x89 [10 << 20]byte
-	z = x89
-	var x90 [10 << 20]byte
-	z = x90
-	var x91 [10 << 20]byte
-	z = x91
-	var x92 [10 << 20]byte
-	z = x92
-	var x93 [10 << 20]byte
-	z = x93
-	var x94 [10 << 20]byte
-	z = x94
-	var x95 [10 << 20]byte
-	z = x95
-	var x96 [10 << 20]byte
-	z = x96
-	var x97 [10 << 20]byte
-	z = x97
-	var x98 [10 << 20]byte
-	z = x98
-	var x99 [10 << 20]byte
-	z = x99
-	var x100 [10 << 20]byte
-	z = x100
-	var x101 [10 << 20]byte
-	z = x101
-	var x102 [10 << 20]byte
-	z = x102
-	var x103 [10 << 20]byte
-	z = x103
-	var x104 [10 << 20]byte
-	z = x104
-	var x105 [10 << 20]byte
-	z = x105
-	var x106 [10 << 20]byte
-	z = x106
-	var x107 [10 << 20]byte
-	z = x107
-	var x108 [10 << 20]byte
-	z = x108
-	var x109 [10 << 20]byte
-	z = x109
-	var x110 [10 << 20]byte
-	z = x110
-	var x111 [10 << 20]byte
-	z = x111
-	var x112 [10 << 20]byte
-	z = x112
-	var x113 [10 << 20]byte
-	z = x113
-	var x114 [10 << 20]byte
-	z = x114
-	var x115 [10 << 20]byte
-	z = x115
-	var x116 [10 << 20]byte
-	z = x116
-	var x117 [10 << 20]byte
-	z = x117
-	var x118 [10 << 20]byte
-	z = x118
-	var x119 [10 << 20]byte
-	z = x119
-	var x120 [10 << 20]byte
-	z = x120
-	var x121 [10 << 20]byte
-	z = x121
-	var x122 [10 << 20]byte
-	z = x122
-	var x123 [10 << 20]byte
-	z = x123
-	var x124 [10 << 20]byte
-	z = x124
-	var x125 [10 << 20]byte
-	z = x125
-	var x126 [10 << 20]byte
-	z = x126
-	var x127 [10 << 20]byte
-	z = x127
-	var x128 [10 << 20]byte
-	z = x128
-	var x129 [10 << 20]byte
-	z = x129
-	var x130 [10 << 20]byte
-	z = x130
-	var x131 [10 << 20]byte
-	z = x131
-	var x132 [10 << 20]byte
-	z = x132
-	var x133 [10 << 20]byte
-	z = x133
-	var x134 [10 << 20]byte
-	z = x134
-	var x135 [10 << 20]byte
-	z = x135
-	var x136 [10 << 20]byte
-	z = x136
-	var x137 [10 << 20]byte
-	z = x137
-	var x138 [10 << 20]byte
-	z = x138
-	var x139 [10 << 20]byte
-	z = x139
-	var x140 [10 << 20]byte
-	z = x140
-	var x141 [10 << 20]byte
-	z = x141
-	var x142 [10 << 20]byte
-	z = x142
-	var x143 [10 << 20]byte
-	z = x143
-	var x144 [10 << 20]byte
-	z = x144
-	var x145 [10 << 20]byte
-	z = x145
-	var x146 [10 << 20]byte
-	z = x146
-	var x147 [10 << 20]byte
-	z = x147
-	var x148 [10 << 20]byte
-	z = x148
-	var x149 [10 << 20]byte
-	z = x149
-	var x150 [10 << 20]byte
-	z = x150
-	var x151 [10 << 20]byte
-	z = x151
-	var x152 [10 << 20]byte
-	z = x152
-	var x153 [10 << 20]byte
-	z = x153
-	var x154 [10 << 20]byte
-	z = x154
-	var x155 [10 << 20]byte
-	z = x155
-	var x156 [10 << 20]byte
-	z = x156
-	var x157 [10 << 20]byte
-	z = x157
-	var x158 [10 << 20]byte
-	z = x158
-	var x159 [10 << 20]byte
-	z = x159
-	var x160 [10 << 20]byte
-	z = x160
-	var x161 [10 << 20]byte
-	z = x161
-	var x162 [10 << 20]byte
-	z = x162
-	var x163 [10 << 20]byte
-	z = x163
-	var x164 [10 << 20]byte
-	z = x164
-	var x165 [10 << 20]byte
-	z = x165
-	var x166 [10 << 20]byte
-	z = x166
-	var x167 [10 << 20]byte
-	z = x167
-	var x168 [10 << 20]byte
-	z = x168
-	var x169 [10 << 20]byte
-	z = x169
-	var x170 [10 << 20]byte
-	z = x170
-	var x171 [10 << 20]byte
-	z = x171
-	var x172 [10 << 20]byte
-	z = x172
-	var x173 [10 << 20]byte
-	z = x173
-	var x174 [10 << 20]byte
-	z = x174
-	var x175 [10 << 20]byte
-	z = x175
-	var x176 [10 << 20]byte
-	z = x176
-	var x177 [10 << 20]byte
-	z = x177
-	var x178 [10 << 20]byte
-	z = x178
-	var x179 [10 << 20]byte
-	z = x179
-	var x180 [10 << 20]byte
-	z = x180
-	var x181 [10 << 20]byte
-	z = x181
-	var x182 [10 << 20]byte
-	z = x182
-	var x183 [10 << 20]byte
-	z = x183
-	var x184 [10 << 20]byte
-	z = x184
-	var x185 [10 << 20]byte
-	z = x185
-	var x186 [10 << 20]byte
-	z = x186
-	var x187 [10 << 20]byte
-	z = x187
-	var x188 [10 << 20]byte
-	z = x188
-	var x189 [10 << 20]byte
-	z = x189
-	var x190 [10 << 20]byte
-	z = x190
-	var x191 [10 << 20]byte
-	z = x191
-	var x192 [10 << 20]byte
-	z = x192
-	var x193 [10 << 20]byte
-	z = x193
-	var x194 [10 << 20]byte
-	z = x194
-	var x195 [10 << 20]byte
-	z = x195
-	var x196 [10 << 20]byte
-	z = x196
-	var x197 [10 << 20]byte
-	z = x197
-	var x198 [10 << 20]byte
-	z = x198
-	var x199 [10 << 20]byte
-	z = x199
-	var x200 [10 << 20]byte
-	z = x200
-	var x201 [10 << 20]byte
-	z = x201
-	var x202 [10 << 20]byte
-	z = x202
-	var x203 [10 << 20]byte
-	z = x203
-	var x204 [10 << 20]byte
-	z = x204
-	var x205 [10 << 20]byte
-	z = x205
-	var x206 [10 << 20]byte
-	z = x206
+	var x1 [10<<20]byte; z = x1
+	var x2 [10<<20]byte; z = x2
+	var x3 [10<<20]byte; z = x3
+	var x4 [10<<20]byte; z = x4
+	var x5 [10<<20]byte; z = x5
+	var x6 [10<<20]byte; z = x6
+	var x7 [10<<20]byte; z = x7
+	var x8 [10<<20]byte; z = x8
+	var x9 [10<<20]byte; z = x9
+	var x10 [10<<20]byte; z = x10
+	var x11 [10<<20]byte; z = x11
+	var x12 [10<<20]byte; z = x12
+	var x13 [10<<20]byte; z = x13
+	var x14 [10<<20]byte; z = x14
+	var x15 [10<<20]byte; z = x15
+	var x16 [10<<20]byte; z = x16
+	var x17 [10<<20]byte; z = x17
+	var x18 [10<<20]byte; z = x18
+	var x19 [10<<20]byte; z = x19
+	var x20 [10<<20]byte; z = x20
+	var x21 [10<<20]byte; z = x21
+	var x22 [10<<20]byte; z = x22
+	var x23 [10<<20]byte; z = x23
+	var x24 [10<<20]byte; z = x24
+	var x25 [10<<20]byte; z = x25
+	var x26 [10<<20]byte; z = x26
+	var x27 [10<<20]byte; z = x27
+	var x28 [10<<20]byte; z = x28
+	var x29 [10<<20]byte; z = x29
+	var x30 [10<<20]byte; z = x30
+	var x31 [10<<20]byte; z = x31
+	var x32 [10<<20]byte; z = x32
+	var x33 [10<<20]byte; z = x33
+	var x34 [10<<20]byte; z = x34
+	var x35 [10<<20]byte; z = x35
+	var x36 [10<<20]byte; z = x36
+	var x37 [10<<20]byte; z = x37
+	var x38 [10<<20]byte; z = x38
+	var x39 [10<<20]byte; z = x39
+	var x40 [10<<20]byte; z = x40
+	var x41 [10<<20]byte; z = x41
+	var x42 [10<<20]byte; z = x42
+	var x43 [10<<20]byte; z = x43
+	var x44 [10<<20]byte; z = x44
+	var x45 [10<<20]byte; z = x45
+	var x46 [10<<20]byte; z = x46
+	var x47 [10<<20]byte; z = x47
+	var x48 [10<<20]byte; z = x48
+	var x49 [10<<20]byte; z = x49
+	var x50 [10<<20]byte; z = x50
+	var x51 [10<<20]byte; z = x51
+	var x52 [10<<20]byte; z = x52
+	var x53 [10<<20]byte; z = x53
+	var x54 [10<<20]byte; z = x54
+	var x55 [10<<20]byte; z = x55
+	var x56 [10<<20]byte; z = x56
+	var x57 [10<<20]byte; z = x57
+	var x58 [10<<20]byte; z = x58
+	var x59 [10<<20]byte; z = x59
+	var x60 [10<<20]byte; z = x60
+	var x61 [10<<20]byte; z = x61
+	var x62 [10<<20]byte; z = x62
+	var x63 [10<<20]byte; z = x63
+	var x64 [10<<20]byte; z = x64
+	var x65 [10<<20]byte; z = x65
+	var x66 [10<<20]byte; z = x66
+	var x67 [10<<20]byte; z = x67
+	var x68 [10<<20]byte; z = x68
+	var x69 [10<<20]byte; z = x69
+	var x70 [10<<20]byte; z = x70
+	var x71 [10<<20]byte; z = x71
+	var x72 [10<<20]byte; z = x72
+	var x73 [10<<20]byte; z = x73
+	var x74 [10<<20]byte; z = x74
+	var x75 [10<<20]byte; z = x75
+	var x76 [10<<20]byte; z = x76
+	var x77 [10<<20]byte; z = x77
+	var x78 [10<<20]byte; z = x78
+	var x79 [10<<20]byte; z = x79
+	var x80 [10<<20]byte; z = x80
+	var x81 [10<<20]byte; z = x81
+	var x82 [10<<20]byte; z = x82
+	var x83 [10<<20]byte; z = x83
+	var x84 [10<<20]byte; z = x84
+	var x85 [10<<20]byte; z = x85
+	var x86 [10<<20]byte; z = x86
+	var x87 [10<<20]byte; z = x87
+	var x88 [10<<20]byte; z = x88
+	var x89 [10<<20]byte; z = x89
+	var x90 [10<<20]byte; z = x90
+	var x91 [10<<20]byte; z = x91
+	var x92 [10<<20]byte; z = x92
+	var x93 [10<<20]byte; z = x93
+	var x94 [10<<20]byte; z = x94
+	var x95 [10<<20]byte; z = x95
+	var x96 [10<<20]byte; z = x96
+	var x97 [10<<20]byte; z = x97
+	var x98 [10<<20]byte; z = x98
+	var x99 [10<<20]byte; z = x99
+	var x100 [10<<20]byte; z = x100
+	var x101 [10<<20]byte; z = x101
+	var x102 [10<<20]byte; z = x102
+	var x103 [10<<20]byte; z = x103
+	var x104 [10<<20]byte; z = x104
+	var x105 [10<<20]byte; z = x105
+	var x106 [10<<20]byte; z = x106
+	var x107 [10<<20]byte; z = x107
+	var x108 [10<<20]byte; z = x108
+	var x109 [10<<20]byte; z = x109
+	var x110 [10<<20]byte; z = x110
+	var x111 [10<<20]byte; z = x111
+	var x112 [10<<20]byte; z = x112
+	var x113 [10<<20]byte; z = x113
+	var x114 [10<<20]byte; z = x114
+	var x115 [10<<20]byte; z = x115
+	var x116 [10<<20]byte; z = x116
+	var x117 [10<<20]byte; z = x117
+	var x118 [10<<20]byte; z = x118
+	var x119 [10<<20]byte; z = x119
+	var x120 [10<<20]byte; z = x120
+	var x121 [10<<20]byte; z = x121
+	var x122 [10<<20]byte; z = x122
+	var x123 [10<<20]byte; z = x123
+	var x124 [10<<20]byte; z = x124
+	var x125 [10<<20]byte; z = x125
+	var x126 [10<<20]byte; z = x126
+	var x127 [10<<20]byte; z = x127
+	var x128 [10<<20]byte; z = x128
+	var x129 [10<<20]byte; z = x129
+	var x130 [10<<20]byte; z = x130
+	var x131 [10<<20]byte; z = x131
+	var x132 [10<<20]byte; z = x132
+	var x133 [10<<20]byte; z = x133
+	var x134 [10<<20]byte; z = x134
+	var x135 [10<<20]byte; z = x135
+	var x136 [10<<20]byte; z = x136
+	var x137 [10<<20]byte; z = x137
+	var x138 [10<<20]byte; z = x138
+	var x139 [10<<20]byte; z = x139
+	var x140 [10<<20]byte; z = x140
+	var x141 [10<<20]byte; z = x141
+	var x142 [10<<20]byte; z = x142
+	var x143 [10<<20]byte; z = x143
+	var x144 [10<<20]byte; z = x144
+	var x145 [10<<20]byte; z = x145
+	var x146 [10<<20]byte; z = x146
+	var x147 [10<<20]byte; z = x147
+	var x148 [10<<20]byte; z = x148
+	var x149 [10<<20]byte; z = x149
+	var x150 [10<<20]byte; z = x150
+	var x151 [10<<20]byte; z = x151
+	var x152 [10<<20]byte; z = x152
+	var x153 [10<<20]byte; z = x153
+	var x154 [10<<20]byte; z = x154
+	var x155 [10<<20]byte; z = x155
+	var x156 [10<<20]byte; z = x156
+	var x157 [10<<20]byte; z = x157
+	var x158 [10<<20]byte; z = x158
+	var x159 [10<<20]byte; z = x159
+	var x160 [10<<20]byte; z = x160
+	var x161 [10<<20]byte; z = x161
+	var x162 [10<<20]byte; z = x162
+	var x163 [10<<20]byte; z = x163
+	var x164 [10<<20]byte; z = x164
+	var x165 [10<<20]byte; z = x165
+	var x166 [10<<20]byte; z = x166
+	var x167 [10<<20]byte; z = x167
+	var x168 [10<<20]byte; z = x168
+	var x169 [10<<20]byte; z = x169
+	var x170 [10<<20]byte; z = x170
+	var x171 [10<<20]byte; z = x171
+	var x172 [10<<20]byte; z = x172
+	var x173 [10<<20]byte; z = x173
+	var x174 [10<<20]byte; z = x174
+	var x175 [10<<20]byte; z = x175
+	var x176 [10<<20]byte; z = x176
+	var x177 [10<<20]byte; z = x177
+	var x178 [10<<20]byte; z = x178
+	var x179 [10<<20]byte; z = x179
+	var x180 [10<<20]byte; z = x180
+	var x181 [10<<20]byte; z = x181
+	var x182 [10<<20]byte; z = x182
+	var x183 [10<<20]byte; z = x183
+	var x184 [10<<20]byte; z = x184
+	var x185 [10<<20]byte; z = x185
+	var x186 [10<<20]byte; z = x186
+	var x187 [10<<20]byte; z = x187
+	var x188 [10<<20]byte; z = x188
+	var x189 [10<<20]byte; z = x189
+	var x190 [10<<20]byte; z = x190
+	var x191 [10<<20]byte; z = x191
+	var x192 [10<<20]byte; z = x192
+	var x193 [10<<20]byte; z = x193
+	var x194 [10<<20]byte; z = x194
+	var x195 [10<<20]byte; z = x195
+	var x196 [10<<20]byte; z = x196
+	var x197 [10<<20]byte; z = x197
+	var x198 [10<<20]byte; z = x198
+	var x199 [10<<20]byte; z = x199
+	var x200 [10<<20]byte; z = x200
+	var x201 [10<<20]byte; z = x201
+	var x202 [10<<20]byte; z = x202
+	var x203 [10<<20]byte; z = x203
+	var x204 [10<<20]byte; z = x204
+	var x205 [10<<20]byte; z = x205
+	var x206 [10<<20]byte; z = x206
 }
diff --git a/test/fixedbugs/bug386.go b/test/fixedbugs/bug386.go
index 92fc33bb36..889c8b0c12 100644
--- a/test/fixedbugs/bug386.go
+++ b/test/fixedbugs/bug386.go
@@ -4,9 +4,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Issue 2451, 2452
+// Issue 2451, 2452 
 package foo
 
 func f() error { return 0 } // ERROR "cannot use 0 .type int.|has no methods"
 
-func g() error { return -1 } // ERROR "cannot use -1 .type int.|has no methods"
+func g() error { return -1 }  // ERROR "cannot use -1 .type int.|has no methods"
diff --git a/test/fixedbugs/bug387.go b/test/fixedbugs/bug387.go
index 2e30bc42a3..d885445744 100644
--- a/test/fixedbugs/bug387.go
+++ b/test/fixedbugs/bug387.go
@@ -12,18 +12,19 @@ missing typecheck: [7f5bf07b4438]
 .   AS l(45)
 .   .   NAME-main.autotmp_0017 u(1) a(1) l(45) x(0+0) class(PAUTO)
 esc(N) tc(1) used(1) ARRAY-[2]string
-internal compiler error: missing typecheck
+internal compiler error: missing typecheck 
 */
 package main
 
 import (
-	"fmt"
-	"path/filepath"
+        "fmt"
+        "path/filepath"
 )
 
 func main() {
-	switch _, err := filepath.Glob(filepath.Join(".", "vnc")); {
-	case err != nil:
-		fmt.Println(err)
-	}
+        switch _, err := filepath.Glob(filepath.Join(".", "vnc")); {
+        case err != nil:
+                fmt.Println(err)
+        }
 }
+
diff --git a/test/fixedbugs/bug389.go b/test/fixedbugs/bug389.go
index 8f40c0e215..14804c8471 100644
--- a/test/fixedbugs/bug389.go
+++ b/test/fixedbugs/bug389.go
@@ -9,4 +9,4 @@ package foo
 
 func fn(a float32) {}
 
-var f func(arg int) = fn // ERROR "cannot use fn .type func.float32.. as type func.int. in assignment|different parameter types"
+var f func(arg int) = fn  // ERROR "cannot use fn .type func.float32.. as type func.int. in assignment|different parameter types"
diff --git a/test/fixedbugs/bug391.go b/test/fixedbugs/bug391.go
index 00b84103bc..9211b1c2cf 100644
--- a/test/fixedbugs/bug391.go
+++ b/test/fixedbugs/bug391.go
@@ -7,9 +7,8 @@
 // Issue 2576
 package bug
 
-type T struct{ a int }
+type T struct { a int }
 
 func f(t T) {
-	switch _, _ = t.a, t.a; {
-	}
-}
+        switch _, _ = t.a, t.a; {}
+}
\ No newline at end of file
diff --git a/test/fixedbugs/bug392.dir/one.go b/test/fixedbugs/bug392.dir/one.go
index 081e25c532..aba8649b5b 100644
--- a/test/fixedbugs/bug392.dir/one.go
+++ b/test/fixedbugs/bug392.dir/one.go
@@ -18,25 +18,26 @@ func F2(c chan int) bool { return c == (<-chan int)(nil) }
 func F3() (ret []int) { return append(ret, 1) }
 
 // Call of inlined method with blank receiver.
-func (_ *T) M() int  { return 1 }
+func (_ *T) M() int { return 1 }
 func (t *T) MM() int { return t.M() }
 
+
 // One more like issue 2678
-type S struct{ x, y int }
+type S struct { x, y int }
 type U []S
 
-func F4(S int) U { return U{{S, S}} }
+func F4(S int) U { return U{{S,S}} }
 
 func F5() []*S {
-	return []*S{{1, 2}, {3, 4}}
+	return []*S{ {1,2}, { 3, 4} }
 }
 
 func F6(S int) *U {
-	return &U{{S, S}}
+	return &U{{S,S}}
 }
 
 // Bug in the fix.
 
-type PB struct{ x int }
+type PB struct { x int }
 
 func (t *PB) Reset() { *t = PB{} }
diff --git a/test/fixedbugs/bug396.dir/one.go b/test/fixedbugs/bug396.dir/one.go
index f599959e10..66eba63f5c 100644
--- a/test/fixedbugs/bug396.dir/one.go
+++ b/test/fixedbugs/bug396.dir/one.go
@@ -5,6 +5,6 @@
 package one
 
 // Issue 2687
-type T struct{ int }
+type T struct { int }
 
 func New(i int) T { return T{i} }
diff --git a/test/fixedbugs/bug396.dir/two.go b/test/fixedbugs/bug396.dir/two.go
index 4e30bfab9c..9152bec254 100644
--- a/test/fixedbugs/bug396.dir/two.go
+++ b/test/fixedbugs/bug396.dir/two.go
@@ -11,4 +11,4 @@ import "./one"
 
 func use() {
 	_ = one.New(1)
-}
+}
\ No newline at end of file
diff --git a/test/fixedbugs/bug397.go b/test/fixedbugs/bug397.go
index 339da2eb4b..6188e3ee0c 100644
--- a/test/fixedbugs/bug397.go
+++ b/test/fixedbugs/bug397.go
@@ -7,7 +7,7 @@
 package main
 
 // Issue 2623
-var m = map[string]int{
-	"abc": 1,
-	1:     2, // ERROR "cannot use 1.*as type string in map key|incompatible type"
+var m = map[string]int {
+	"abc":1,
+	1:2, // ERROR "cannot use 1.*as type string in map key|incompatible type"
 }
diff --git a/test/fixedbugs/bug398.go b/test/fixedbugs/bug398.go
index 3848cd4061..a1583bd774 100644
--- a/test/fixedbugs/bug398.go
+++ b/test/fixedbugs/bug398.go
@@ -12,33 +12,33 @@ package p
 // exported interfaces
 
 type I1 interface {
-	F() interface{ I1 }
+      F() interface{I1}
 }
 
 type I2 interface {
-	F() interface{ I2 }
+      F() interface{I2}
 }
 
 var V1 I1
 var V2 I2
 
 func F() bool {
-	return V1 == V2
+       return V1 == V2
 }
 
 // non-exported interfaces
 
 type i1 interface {
-	F() interface{ i1 }
+      F() interface{i1}
 }
 
 type i2 interface {
-	F() interface{ i2 }
+      F() interface{i2}
 }
 
 var v1 i1
 var v2 i2
 
 func f() bool {
-	return v1 == v2
+       return v1 == v2
 }
diff --git a/test/fixedbugs/bug399.go b/test/fixedbugs/bug399.go
index 343add59da..e460d81227 100644
--- a/test/fixedbugs/bug399.go
+++ b/test/fixedbugs/bug399.go
@@ -7,9 +7,9 @@
 // Issue 2674
 
 package main
-
 const dow = "\000\003"
 
 func main() {
 	println(int(dow[1]))
 }
+
diff --git a/test/fixedbugs/bug405.go b/test/fixedbugs/bug405.go
index f0c3081976..e8ecc4d034 100644
--- a/test/fixedbugs/bug405.go
+++ b/test/fixedbugs/bug405.go
@@ -8,7 +8,7 @@
 
 package main
 
-type S struct{}
+type S struct {}
 
 func (_ S) F(i int) int {
 	return i
diff --git a/test/fixedbugs/bug407.dir/one.go b/test/fixedbugs/bug407.dir/one.go
index fd900ef4ad..c85b077b66 100644
--- a/test/fixedbugs/bug407.dir/one.go
+++ b/test/fixedbugs/bug407.dir/one.go
@@ -11,7 +11,10 @@ type T struct {
 }
 
 func (t *T) foo(arg int) {}
-func (t T) goo(arg int)  {}
+func (t T) goo(arg int) {}
 
 func (t *T) F() { t.f = (*T).foo }
 func (t *T) G() { t.g = T.goo }
+
+
+
diff --git a/test/fixedbugs/bug410.go b/test/fixedbugs/bug410.go
index f0761febfa..a4eef64d8e 100644
--- a/test/fixedbugs/bug410.go
+++ b/test/fixedbugs/bug410.go
@@ -12,13 +12,13 @@ type y struct {
 	num int
 }
 
-func zzz() {
-	k := make([]byte, 10)
-	arr := make([]*y, 0)
-	for s := range arr {
-		x := make([]byte, 10)
-		for i := 0; i < 100; i++ {
-			x[i] ^= k[i-arr[s].num%3]
-		}
-	}
+func zzz () {
+    k := make([]byte, 10)
+	arr := make ([]*y, 0)
+    for s := range arr {
+        x := make([]byte, 10)
+        for i := 0; i < 100 ; i++ {
+            x[i] ^= k[i-arr[s].num%3]
+        }
+    }
 }
diff --git a/test/fixedbugs/bug411.go b/test/fixedbugs/bug411.go
index 7f90ae0e93..a1c36f617c 100644
--- a/test/fixedbugs/bug411.go
+++ b/test/fixedbugs/bug411.go
@@ -14,5 +14,6 @@ func f1(a int64) {
 	f2(float64(a), float64(a))
 }
 
-func f2(a, b float64) {
+func f2(a,b float64) {
 }
+
diff --git a/test/fixedbugs/bug412.go b/test/fixedbugs/bug412.go
index a39abf17e1..183fb7e4af 100644
--- a/test/fixedbugs/bug412.go
+++ b/test/fixedbugs/bug412.go
@@ -7,10 +7,10 @@
 package p
 
 type t struct {
-	x int // GCCGO_ERROR "duplicate field name .x."
-	x int // GC_ERROR "duplicate field x"
+	x int  // GCCGO_ERROR "duplicate field name .x."
+	x int  // GC_ERROR "duplicate field x"
 }
 
 func f(t *t) int {
-	return t.x // GC_ERROR "ambiguous selector t.x"
+	return t.x  // GC_ERROR "ambiguous selector t.x"
 }
diff --git a/test/fixedbugs/bug413.go b/test/fixedbugs/bug413.go
index 12e1e5e58b..819bd1a984 100644
--- a/test/fixedbugs/bug413.go
+++ b/test/fixedbugs/bug413.go
@@ -8,4 +8,4 @@ package p
 
 func f(i int) int { return i }
 
-var i = func() int { a := f(i); return a }() // ERROR "initialization loop|depends upon itself"
+var i = func() int {a := f(i); return a}()  // ERROR "initialization loop|depends upon itself"
diff --git a/test/fixedbugs/bug415.dir/p.go b/test/fixedbugs/bug415.dir/p.go
index fca0124014..e86a697643 100644
--- a/test/fixedbugs/bug415.dir/p.go
+++ b/test/fixedbugs/bug415.dir/p.go
@@ -5,9 +5,10 @@
 package p
 
 type A struct {
-	s struct{ int }
+	s struct{int}
 }
 
 func (a *A) f() {
-	a.s = struct{ int }{0}
+	a.s = struct{int}{0}
 }
+
diff --git a/test/fixedbugs/bug415.dir/prog.go b/test/fixedbugs/bug415.dir/prog.go
index f2a4e6dd0d..1ffde188b7 100644
--- a/test/fixedbugs/bug415.dir/prog.go
+++ b/test/fixedbugs/bug415.dir/prog.go
@@ -3,9 +3,7 @@
 // license that can be found in the LICENSE file.
 
 package main
-
 import "./p"
-
 func main() {}
-
 var _ p.A
+
diff --git a/test/fixedbugs/bug417.go b/test/fixedbugs/bug417.go
index 1b44aa927c..a9acb42386 100644
--- a/test/fixedbugs/bug417.go
+++ b/test/fixedbugs/bug417.go
@@ -14,19 +14,17 @@ type S1 struct {
 	s [][1]S3
 	m map[int][1]S3
 	c chan [1]S3
-	i interface{ f([1]S3) [1]S3 }
+	i interface { f([1]S3) [1]S3 }
 	f func([1]S3) [1]S3
 }
 
 type S2 struct {
-	p *struct{ F S3 }
-	s []struct{ F S3 }
-	m map[int]struct{ F S3 }
-	c chan struct{ F S3 }
-	i interface {
-		f(struct{ F S3 }) struct{ F S3 }
-	}
-	f func(struct{ F S3 }) struct{ F S3 }
+	p *struct { F S3 }
+	s []struct { F S3 }
+	m map[int]struct { F S3 }
+	c chan struct { F S3 }
+	i interface { f(struct { F S3 }) struct { F S3 } }
+	f func(struct { F S3 } ) struct { F S3 }
 }
 
 type S3 struct {
diff --git a/test/fixedbugs/bug420.go b/test/fixedbugs/bug420.go
index 6601597cad..02b4349d80 100644
--- a/test/fixedbugs/bug420.go
+++ b/test/fixedbugs/bug420.go
@@ -10,5 +10,5 @@
 package main
 
 func main() {
-	(_) = 0
+     (_) = 0
 }
diff --git a/test/fixedbugs/bug421.go b/test/fixedbugs/bug421.go
index b1f1c56275..1fe02375ab 100644
--- a/test/fixedbugs/bug421.go
+++ b/test/fixedbugs/bug421.go
@@ -10,8 +10,8 @@
 package main
 
 func main() {
-	println(int(1) == uint(1)) // ERROR "types"
+	println(int(1) == uint(1))	// ERROR "types"
 	var x int = 1
 	var y uint = 1
-	println(x == y) // ERROR "types"
+	println(x == y)			// ERROR "types"
 }
diff --git a/test/fixedbugs/bug424.dir/main.go b/test/fixedbugs/bug424.dir/main.go
index adf01fc112..28b41e68a7 100644
--- a/test/fixedbugs/bug424.dir/main.go
+++ b/test/fixedbugs/bug424.dir/main.go
@@ -59,7 +59,7 @@ func main() {
 	if t3.m() != "main.localT.m" {
 		println("BUG: t3:", t3.m(), "called")
 	}
-
+	
 	i = new(myT3)
 	if i.m() != "main.localT.m" {
 		t := reflect.TypeOf(i)
@@ -70,7 +70,7 @@ func main() {
 		}
 		println("BUG: myT3:", i.m(), "called")
 	}
-
+	
 	var t4 struct {
 		localT
 		lib.T
@@ -82,7 +82,7 @@ func main() {
 	if i.m() != "main.localT.m" {
 		println("BUG: myT4:", i.m(), "called")
 	}
-
+	
 	var t5 struct {
 		lib.T
 		localT
diff --git a/test/fixedbugs/bug424.go b/test/fixedbugs/bug424.go
index 6423961fe0..9c59abe802 100644
--- a/test/fixedbugs/bug424.go
+++ b/test/fixedbugs/bug424.go
@@ -10,3 +10,4 @@
 // embedding is done.
 
 package ignored
+
diff --git a/test/fixedbugs/bug425.go b/test/fixedbugs/bug425.go
index a13a82c0f8..c3035f6a91 100644
--- a/test/fixedbugs/bug425.go
+++ b/test/fixedbugs/bug425.go
@@ -13,5 +13,5 @@ import "fmt"
 func main() {
 	s := "hello"
 	fmt.Println(s == "")
-	fmt.Println(s+"world" == "world")
+	fmt.Println(s + "world" == "world")
 }
diff --git a/test/fixedbugs/bug427.go b/test/fixedbugs/bug427.go
index a1b3f5b7fa..c13bb815ca 100644
--- a/test/fixedbugs/bug427.go
+++ b/test/fixedbugs/bug427.go
@@ -9,10 +9,10 @@
 package main
 
 // struct with four fields of basic type
-type S struct{ a, b, c, d int }
+type S struct {a, b, c, d int}
 
 // struct with five fields of basic type
-type T struct{ a, b, c, d, e int }
+type T struct {a, b, c, d, e int}
 
 // array with four elements
 type A [4]int
diff --git a/test/fixedbugs/bug439.go b/test/fixedbugs/bug439.go
index 1ad7b7f443..87d4ae0373 100644
--- a/test/fixedbugs/bug439.go
+++ b/test/fixedbugs/bug439.go
@@ -14,7 +14,7 @@ func (e E) P() *E { return &e }
 
 const (
 	C1 E = 0
-	C2   = C1
+	C2 = C1
 )
 
 func F() *E {
diff --git a/test/fixedbugs/bug441.go b/test/fixedbugs/bug441.go
index a0b051e62f..b67125b1e8 100644
--- a/test/fixedbugs/bug441.go
+++ b/test/fixedbugs/bug441.go
@@ -23,13 +23,11 @@ func main() {
 	}
 }
 
-func foo(_ int)     {}
+func foo(_ int) {}
 func foo2(_, _ int) {}
 func foo3(int, int) {}
-
 type T int
-
-func (_ T) m1()      {}
+func (_ T) m1() {}
 func (t T) m2(_ int) {}
 
 func side() int {
diff --git a/test/fixedbugs/bug442.go b/test/fixedbugs/bug442.go
index c3e1d5b20f..684d54ffbb 100644
--- a/test/fixedbugs/bug442.go
+++ b/test/fixedbugs/bug442.go
@@ -20,7 +20,7 @@ func main() {
 	m := map[T]int{}
 	m[T{X: 1, Y: 2}] = 1
 	m[T{X: 2, Y: 3}] = 2
-	m[T{X: 1, Y: 2}] = 3 // overwrites first entry
+	m[T{X: 1, Y: 2}] = 3  // overwrites first entry
 	if len(m) != 2 {
 		println("BUG")
 	}
diff --git a/test/fixedbugs/bug443.go b/test/fixedbugs/bug443.go
index eaa3d55823..9abd2548a5 100644
--- a/test/fixedbugs/bug443.go
+++ b/test/fixedbugs/bug443.go
@@ -9,9 +9,9 @@
 
 package p
 
-type T1 struct{ F *T2 }
+type T1 struct { F *T2 }
 type T2 T1
 
 type T3 T2
+func (*T3) M()  // was invalid receiver
 
-func (*T3) M() // was invalid receiver
diff --git a/test/fixedbugs/bug444.go b/test/fixedbugs/bug444.go
index 69c5bd8e59..29a60f590f 100644
--- a/test/fixedbugs/bug444.go
+++ b/test/fixedbugs/bug444.go
@@ -12,14 +12,14 @@ package main
 
 import "reflect"
 
-type T interface{}
+type T interface {}
 
 var x bool
 
 func main() {
-	reflect.TypeOf(nil)
-	reflect.TypeOf(T(nil)) // used to miscompile
-	shouldPanic()
+        reflect.TypeOf(nil)
+        reflect.TypeOf(T(nil)) // used to miscompile
+        shouldPanic()
 }
 
 func f() byte {
diff --git a/test/fixedbugs/bug446.go b/test/fixedbugs/bug446.go
index 580415c181..1e435e1109 100644
--- a/test/fixedbugs/bug446.go
+++ b/test/fixedbugs/bug446.go
@@ -33,3 +33,4 @@ func main() {
 		panic("dummy2 != 2")
 	}
 }
+
diff --git a/test/fixedbugs/bug447.go b/test/fixedbugs/bug447.go
index db3b8404ec..8358f0034f 100644
--- a/test/fixedbugs/bug447.go
+++ b/test/fixedbugs/bug447.go
@@ -16,8 +16,8 @@ import (
 )
 
 var (
-	intWidths   = []int{8, 16, 32, 64} // int%d and uint%d
-	floatWidths = []int{32, 64}        // float%d
+	intWidths = []int{8, 16, 32, 64} // int%d and uint%d
+	floatWidths = []int{32, 64} // float%d
 )
 
 func main() {
@@ -59,7 +59,8 @@ const testSegment = `
 		}
 	}`
 
-const testFunc = `func test$I(f float64, i int64) {
+const testFunc =
+`func test$I(f float64, i int64) {
 	if i != int64($I(i))$TEST {
 		return
 	}
@@ -67,7 +68,8 @@ $TESTSEGMENTS
 }
 `
 
-var program = `package main
+var program =
+`package main
 
 import (
 	"fmt"
diff --git a/test/fixedbugs/bug448.dir/pkg2.go b/test/fixedbugs/bug448.dir/pkg2.go
index 8eee8e88dd..20d850915d 100644
--- a/test/fixedbugs/bug448.dir/pkg2.go
+++ b/test/fixedbugs/bug448.dir/pkg2.go
@@ -11,3 +11,4 @@ import "./pkg1"
 func F() {
 	pkg1.Do()
 }
+
diff --git a/test/fixedbugs/bug460.go b/test/fixedbugs/bug460.go
index 130d190cb3..a1b6f477ff 100644
--- a/test/fixedbugs/bug460.go
+++ b/test/fixedbugs/bug460.go
@@ -7,3 +7,4 @@
 // part one of issue 4124. Make sure that the compiler rejects access attempts.
 
 package ignored
+
diff --git a/test/fixedbugs/bug462.go b/test/fixedbugs/bug462.go
index 4765e18afd..3df63b091d 100644
--- a/test/fixedbugs/bug462.go
+++ b/test/fixedbugs/bug462.go
@@ -13,7 +13,7 @@ type T struct {
 }
 
 func main() {
-	_ = T{
+	_ = T {
 		os.File: 1, // ERROR "unknown T? ?field"
 	}
 }
diff --git a/test/fixedbugs/bug466.dir/a.go b/test/fixedbugs/bug466.dir/a.go
index 21fe0a6062..e27699c2ef 100644
--- a/test/fixedbugs/bug466.dir/a.go
+++ b/test/fixedbugs/bug466.dir/a.go
@@ -4,7 +4,7 @@
 
 package a
 
-const N = 2 + 3i
+const N = 2+3i
 
 func Func() []complex128 {
 	return []complex128{1, complex(2, 3), complex(4, 5)}
diff --git a/test/fixedbugs/bug466.go b/test/fixedbugs/bug466.go
index c2a15ef707..dc909d483c 100644
--- a/test/fixedbugs/bug466.go
+++ b/test/fixedbugs/bug466.go
@@ -8,3 +8,4 @@
 // complex literals "a+bi" to "a+b".
 
 package ignored
+
diff --git a/test/fixedbugs/bug468.dir/p1.go b/test/fixedbugs/bug468.dir/p1.go
index b35e08acb4..cdda735e96 100644
--- a/test/fixedbugs/bug468.dir/p1.go
+++ b/test/fixedbugs/bug468.dir/p1.go
@@ -4,4 +4,4 @@
 
 package p1
 
-type S struct{ X, Y int }
+type S struct { X, Y int }
diff --git a/test/fixedbugs/bug468.dir/p2.go b/test/fixedbugs/bug468.dir/p2.go
index 42deea8bd5..dbb46931b8 100644
--- a/test/fixedbugs/bug468.dir/p2.go
+++ b/test/fixedbugs/bug468.dir/p2.go
@@ -12,7 +12,7 @@ import (
 
 func main() {
 	var v1 = p1.S{1, 2}
-	var v2 = struct{ X, Y int }{1, 2}
+	var v2 = struct { X, Y int }{1, 2}
 	v1 = v2
 	t1 := reflect.TypeOf(v1)
 	t2 := reflect.TypeOf(v2)
diff --git a/test/fixedbugs/bug470.go b/test/fixedbugs/bug470.go
index 72326b6e85..c21663f3f3 100644
--- a/test/fixedbugs/bug470.go
+++ b/test/fixedbugs/bug470.go
@@ -11,8 +11,8 @@ package main
 import "fmt"
 
 const (
-	F32 = 0.00999999977648258209228515625
-	F64 = 0.01000000000000000020816681711721685132943093776702880859375
+    F32 = 0.00999999977648258209228515625
+    F64 = 0.01000000000000000020816681711721685132943093776702880859375
 )
 
 var F = float64(float32(0.01))
diff --git a/test/fixedbugs/bug479.dir/a.go b/test/fixedbugs/bug479.dir/a.go
index 424fc45d30..eddb4cf078 100644
--- a/test/fixedbugs/bug479.dir/a.go
+++ b/test/fixedbugs/bug479.dir/a.go
@@ -6,7 +6,7 @@ package p
 
 import "unsafe"
 
-type S2 struct{}
+type S2 struct {}
 
 const C = unsafe.Sizeof(S2{})
 
diff --git a/test/fixedbugs/bug480.dir/a.go b/test/fixedbugs/bug480.dir/a.go
index cd87d87f2d..26a8d11669 100644
--- a/test/fixedbugs/bug480.dir/a.go
+++ b/test/fixedbugs/bug480.dir/a.go
@@ -4,7 +4,7 @@
 
 package a
 
-type S interface {
+type S interface{
 	F() T
 }
 
diff --git a/test/fixedbugs/bug486.go b/test/fixedbugs/bug486.go
index dce43f4b0e..9ad23b3cfc 100644
--- a/test/fixedbugs/bug486.go
+++ b/test/fixedbugs/bug486.go
@@ -11,4 +11,4 @@
 package main
 
 /*// comment
- */
+*/
diff --git a/test/fixedbugs/bug487.go b/test/fixedbugs/bug487.go
index c61dcb0f31..ab61a19a94 100644
--- a/test/fixedbugs/bug487.go
+++ b/test/fixedbugs/bug487.go
@@ -14,11 +14,11 @@ func G() (int, int, int) {
 }
 
 func F() {
-	a, b := G() // ERROR "assignment mismatch"
-	a, b = G()  // ERROR "assignment mismatch"
+	a, b := G()	// ERROR "assignment mismatch"
+	a, b = G()	// ERROR "assignment mismatch"
 	_, _ = a, b
 }
 
 func H() (int, int) {
-	return G() // ERROR "too many|mismatch"
+	return G()	// ERROR "too many|mismatch"
 }
diff --git a/test/fixedbugs/bug488.dir/a.go b/test/fixedbugs/bug488.dir/a.go
index 798011414e..fc494207a1 100644
--- a/test/fixedbugs/bug488.dir/a.go
+++ b/test/fixedbugs/bug488.dir/a.go
@@ -4,4 +4,4 @@
 
 package a
 
-var p2 = Printf // ERROR "undefined"
+var p2 = Printf		// ERROR "undefined"
diff --git a/test/fixedbugs/bug490.go b/test/fixedbugs/bug490.go
index 1d8b29d037..387a680aee 100644
--- a/test/fixedbugs/bug490.go
+++ b/test/fixedbugs/bug490.go
@@ -8,7 +8,7 @@
 // interface and an empty struct literal.
 
 package p
-
+ 
 type S struct{}
 
 func F(v interface{}) bool {
diff --git a/test/fixedbugs/bug491.go b/test/fixedbugs/bug491.go
index 6bc7b470f0..39a3509c69 100644
--- a/test/fixedbugs/bug491.go
+++ b/test/fixedbugs/bug491.go
@@ -107,4 +107,4 @@ func bug() {
 		println("BUG")
 		bugged = true
 	}
-}
+}
\ No newline at end of file
diff --git a/test/fixedbugs/bug500.go b/test/fixedbugs/bug500.go
index e57de98b60..2dd5df13b0 100644
--- a/test/fixedbugs/bug500.go
+++ b/test/fixedbugs/bug500.go
@@ -35,7 +35,7 @@ func init() {
 
 func main() {
 	runtime.GC()
-	if a[0].str != b+c {
+	if a[0].str != b + c {
 		panic(a[0].str)
 	}
 }
diff --git a/test/fixedbugs/gcc61264.go b/test/fixedbugs/gcc61264.go
index 569f601bc8..a4092f5bec 100644
--- a/test/fixedbugs/gcc61264.go
+++ b/test/fixedbugs/gcc61264.go
@@ -9,5 +9,5 @@
 package main
 
 func main() {
-	map[int]int{}[0]++
+        map[int]int{}[0]++
 }
diff --git a/test/fixedbugs/gcc67968.dir/b.go b/test/fixedbugs/gcc67968.dir/b.go
index dd9eddae31..41b62d2088 100644
--- a/test/fixedbugs/gcc67968.dir/b.go
+++ b/test/fixedbugs/gcc67968.dir/b.go
@@ -6,7 +6,7 @@ package b
 
 import "./a"
 
-func F() interface{} {
-	var v *a.T
-	return v.Foo()
+func F() (interface{}) {
+     var v *a.T
+     return v.Foo()
 }
diff --git a/test/fixedbugs/issue10607a.go b/test/fixedbugs/issue10607a.go
index 92a7474fa1..51399e4ecf 100644
--- a/test/fixedbugs/issue10607a.go
+++ b/test/fixedbugs/issue10607a.go
@@ -54,7 +54,7 @@ func main() {
 
 			// 3 == NT_GNU_BUILD_ID
 			if typ == 3 && namesz == 4 && bytes.Equal(d[12:16], []byte("GNU\000")) {
-				id := string(d[12+an : 12+an+descsz])
+				id := string(d[12+an:12+an+descsz])
 				if id == "\x12\x34\x56\x78" {
 					c++
 				} else {
diff --git a/test/fixedbugs/issue11326.go b/test/fixedbugs/issue11326.go
index 178f1335b6..82754c73fb 100644
--- a/test/fixedbugs/issue11326.go
+++ b/test/fixedbugs/issue11326.go
@@ -18,14 +18,14 @@ func main() {
 
 	// Any implementation must be able to handle these constants at
 	// compile time (even though they cannot be assigned to a float64).
-	var _ = 1e646456992 // ERROR "1e\+646456992 overflows float64"
-	var _ = 1e64645699  // ERROR "1e\+64645699 overflows float64"
-	var _ = 1e6464569   // ERROR "1e\+6464569 overflows float64"
-	var _ = 1e646456    // ERROR "1e\+646456 overflows float64"
-	var _ = 1e64645     // ERROR "1e\+64645 overflows float64"
-	var _ = 1e6464      // ERROR "1e\+6464 overflows float64"
-	var _ = 1e646       // ERROR "1e\+646 overflows float64"
-	var _ = 1e309       // ERROR "1e\+309 overflows float64"
+	var _ = 1e646456992  // ERROR "1e\+646456992 overflows float64"
+	var _ = 1e64645699   // ERROR "1e\+64645699 overflows float64"
+	var _ = 1e6464569    // ERROR "1e\+6464569 overflows float64"
+	var _ = 1e646456     // ERROR "1e\+646456 overflows float64"
+	var _ = 1e64645      // ERROR "1e\+64645 overflows float64"
+	var _ = 1e6464       // ERROR "1e\+6464 overflows float64"
+	var _ = 1e646        // ERROR "1e\+646 overflows float64"
+	var _ = 1e309        // ERROR "1e\+309 overflows float64"
 
 	var _ = 1e308
 }
diff --git a/test/fixedbugs/issue11361.go b/test/fixedbugs/issue11361.go
index f9fa6a4ea3..1260ea89c9 100644
--- a/test/fixedbugs/issue11361.go
+++ b/test/fixedbugs/issue11361.go
@@ -6,6 +6,6 @@
 
 package a
 
-import "fmt" // ERROR "imported and not used"
+import "fmt"  // ERROR "imported and not used"
 
 const n = fmt // ERROR "fmt without selector"
diff --git a/test/fixedbugs/issue11362.go b/test/fixedbugs/issue11362.go
index 2c14e9e318..9e9e599595 100644
--- a/test/fixedbugs/issue11362.go
+++ b/test/fixedbugs/issue11362.go
@@ -12,3 +12,4 @@ import _ "unicode//utf8" // ERROR "non-canonical import path .unicode//utf8. \(s
 
 func main() {
 }
+
diff --git a/test/fixedbugs/issue12677.dir/p.go b/test/fixedbugs/issue12677.dir/p.go
index 40cd872158..e395071f8d 100644
--- a/test/fixedbugs/issue12677.dir/p.go
+++ b/test/fixedbugs/issue12677.dir/p.go
@@ -3,7 +3,6 @@
 // license that can be found in the LICENSE file.
 
 package p
-
 func Baz(f int) float64 {
-	return 1 / float64(int(1)<<(uint(f)))
+    return 1 / float64(int(1)<<(uint(f)))
 }
diff --git a/test/fixedbugs/issue12677.dir/q.go b/test/fixedbugs/issue12677.dir/q.go
index ae4fb8aa84..fd39c8a9ca 100644
--- a/test/fixedbugs/issue12677.dir/q.go
+++ b/test/fixedbugs/issue12677.dir/q.go
@@ -3,7 +3,5 @@
 // license that can be found in the LICENSE file.
 
 package q
-
 import "./p"
-
 func f() { println(p.Baz(2)) }
diff --git a/test/fixedbugs/issue13261.go b/test/fixedbugs/issue13261.go
index 1b39f08ce8..a944f3a9b5 100644
--- a/test/fixedbugs/issue13261.go
+++ b/test/fixedbugs/issue13261.go
@@ -13,23 +13,17 @@ type T struct{}
 func main() {
 	_ = &T{}
 	_ = &(T{})
-	_ = &(T{})
+	_ = &((T{}))
 
 	_ = &struct{}{}
 	_ = &(struct{}{})
-	_ = &(struct{}{})
+	_ = &((struct{}{}))
+
+	switch (&T{}) {}
+	switch &(T{}) {}
+	switch &((T{})) {}
 
-	switch (&T{}) {
-	}
-	switch &(T{}) {
-	}
-	switch &(T{}) {
-	}
-
-	switch &struct{}{} {
-	}
-	switch &(struct{}{}) {
-	}
-	switch &(struct{}{}) {
-	}
+	switch &struct{}{} {}
+	switch &(struct{}{}) {}
+	switch &((struct{}{})) {}
 }
diff --git a/test/fixedbugs/issue13265.go b/test/fixedbugs/issue13265.go
index 9086ccda63..3e16cee6e7 100644
--- a/test/fixedbugs/issue13265.go
+++ b/test/fixedbugs/issue13265.go
@@ -10,7 +10,7 @@
 package p
 
 func f() {
-	var c chan chan chan int
-	for ; ; <-<-<-c {
-	}
+    var c chan chan chan int
+    for ; ; <-<-<-c {
+    }
 }
diff --git a/test/fixedbugs/issue13337.go b/test/fixedbugs/issue13337.go
index 4138eaf583..81f984b732 100644
--- a/test/fixedbugs/issue13337.go
+++ b/test/fixedbugs/issue13337.go
@@ -10,7 +10,6 @@
 package s
 
 type S0 struct{ f int }
-
 func (S0) m() {}
 
 type S1 struct{ S0 }
diff --git a/test/fixedbugs/issue13415.go b/test/fixedbugs/issue13415.go
index 20085a3f49..989a1ed50f 100644
--- a/test/fixedbugs/issue13415.go
+++ b/test/fixedbugs/issue13415.go
@@ -10,10 +10,10 @@
 package p
 
 func f() {
-	select {
-	case x, x := <-func() chan int { // ERROR "x repeated on left side of :="
-		c := make(chan int)
-		return c
-	}():
-	}
+    select {
+    case x, x := <-func() chan int { // ERROR "x repeated on left side of :="
+            c := make(chan int)
+            return c
+    }():
+    }
 }
diff --git a/test/fixedbugs/issue13485.go b/test/fixedbugs/issue13485.go
index 982dba494c..a9beea1f7d 100644
--- a/test/fixedbugs/issue13485.go
+++ b/test/fixedbugs/issue13485.go
@@ -9,7 +9,7 @@ package p
 var (
 	_ [10]int
 	_ [10.0]int
-	_ [float64(10)]int // ERROR "invalid array bound"
+	_ [float64(10)]int                // ERROR "invalid array bound"
 	_ [10 + 0i]int
 	_ [complex(10, 0)]int
 	_ [complex128(complex(10, 0))]int // ERROR "invalid array bound"
diff --git a/test/fixedbugs/issue14136.go b/test/fixedbugs/issue14136.go
index 12d18c37b1..f9efd05f96 100644
--- a/test/fixedbugs/issue14136.go
+++ b/test/fixedbugs/issue14136.go
@@ -15,5 +15,5 @@ type T struct{}
 
 func main() {
 	t := T{X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1, X: 1} // ERROR "unknown field 'X' in struct literal of type T"
-	var s string = 1                                                   // ERROR "cannot use 1"
+	var s string = 1 // ERROR "cannot use 1"
 }
diff --git a/test/fixedbugs/issue14321.go b/test/fixedbugs/issue14321.go
index dbef63179b..058008c386 100644
--- a/test/fixedbugs/issue14321.go
+++ b/test/fixedbugs/issue14321.go
@@ -8,14 +8,14 @@
 
 package p
 
-type A struct {
+type A struct{
 	H int
 }
 
 func (A) F() {}
 func (A) G() {}
 
-type B struct {
+type B struct{
 	G int
 	H int
 }
diff --git a/test/fixedbugs/issue14540.go b/test/fixedbugs/issue14540.go
index cc55c7f522..62b17a04c4 100644
--- a/test/fixedbugs/issue14540.go
+++ b/test/fixedbugs/issue14540.go
@@ -10,11 +10,10 @@ func f(x int) {
 	switch x {
 	case 0:
 		fallthrough
-		// ok
+		; // ok
 	case 1:
 		fallthrough // ERROR "fallthrough statement out of place"
-		{
-		}
+		{}
 	case 2:
 		fallthrough // ERROR "cannot fallthrough"
 	}
diff --git a/test/fixedbugs/issue14651.go b/test/fixedbugs/issue14651.go
index 49eb816554..4c756e502e 100644
--- a/test/fixedbugs/issue14651.go
+++ b/test/fixedbugs/issue14651.go
@@ -18,9 +18,9 @@ import (
 )
 
 const (
-	p149  = 1.0 / (1 << 149)        // 1p-149
-	p500  = 1.0 / (1 << 500)        // 1p-500
-	p1074 = p500 * p500 / (1 << 74) // 1p-1074
+	p149 = 1.0 / (1 << 149) // 1p-149
+	p500 = 1.0 / (1 << 500) // 1p-500
+	p1074 = p500 * p500 / (1<<74) // 1p-1074
 )
 
 const (
diff --git a/test/fixedbugs/issue14729.go b/test/fixedbugs/issue14729.go
index 50b615e2cf..88e01f9e16 100644
--- a/test/fixedbugs/issue14729.go
+++ b/test/fixedbugs/issue14729.go
@@ -10,5 +10,5 @@ package main
 
 import "unsafe"
 
-type s struct{ unsafe.Pointer } // ERROR "embedded type cannot be a pointer"
-type s1 struct{ p unsafe.Pointer }
+type s struct { unsafe.Pointer } // ERROR "embedded type cannot be a pointer"
+type s1 struct { p unsafe.Pointer }
diff --git a/test/fixedbugs/issue15039.go b/test/fixedbugs/issue15039.go
index 243653e3f0..85d9e8340a 100644
--- a/test/fixedbugs/issue15039.go
+++ b/test/fixedbugs/issue15039.go
@@ -18,7 +18,7 @@ func main() {
 	}
 
 	// cmd/compile used to require integer constants to fit into an "int".
-	const huge = string(1 << 100)
+	const huge = string(1<<100)
 	if huge != fffd {
 		panic("huge != bad")
 	}
diff --git a/test/fixedbugs/issue15042.go b/test/fixedbugs/issue15042.go
index 7941bd7157..85d5d6c361 100644
--- a/test/fixedbugs/issue15042.go
+++ b/test/fixedbugs/issue15042.go
@@ -22,6 +22,6 @@ func F(c bool, s1, s2 S) (int, int) {
 func main() {
 	i, j := F(true, S{1}, S{20})
 	if i != 20 || j != 1 {
-		panic(i + j)
+		panic(i+j)
 	}
 }
diff --git a/test/fixedbugs/issue15311.go b/test/fixedbugs/issue15311.go
index 6f4ad85feb..81fa541325 100644
--- a/test/fixedbugs/issue15311.go
+++ b/test/fixedbugs/issue15311.go
@@ -10,11 +10,11 @@
 package p
 
 type T struct {
-	toInt    map[string]int
-	toString map[int]string
+        toInt    map[string]int
+        toString map[int]string
 }
 
 var t = T{
-	foo.toInt:    make(map[string]int), // ERROR "field name"
-	bar.toString: make(map[int]string), // ERROR "field name"
+        foo.toInt:    make(map[string]int), // ERROR "field name"
+        bar.toString: make(map[int]string), // ERROR "field name"
 }
diff --git a/test/fixedbugs/issue15439.go b/test/fixedbugs/issue15439.go
index d53077d11a..840a3c02a8 100644
--- a/test/fixedbugs/issue15439.go
+++ b/test/fixedbugs/issue15439.go
@@ -10,9 +10,7 @@ import "reflect"
 
 func main() {
 	a := &struct{ x int }{}
-	b := &struct {
-		x int ""
-	}{}
+	b := &struct{ x int "" }{}
 
 	ta := reflect.TypeOf(a)
 	tb := reflect.TypeOf(b)
diff --git a/test/fixedbugs/issue15470.dir/a.go b/test/fixedbugs/issue15470.dir/a.go
index 69b63530ba..1fcf3ea6e0 100644
--- a/test/fixedbugs/issue15470.dir/a.go
+++ b/test/fixedbugs/issue15470.dir/a.go
@@ -10,10 +10,10 @@ type T interface {
 
 type S struct{}
 
-func (S) M0(_ int)       {}
-func (S) M1(x, _ int)    {}
+func (S) M0(_ int) {}
+func (S) M1(x, _ int) {}
 func (S) M2() (x, _ int) { return }
-func (_ S) M3()          {}
+func (_ S) M3() {}
 
 // Snippet from x/tools/godoc/analysis/analysis.go.
 // Offending code from #5470.
diff --git a/test/fixedbugs/issue15548.dir/c.go b/test/fixedbugs/issue15548.dir/c.go
index ce6e3204b3..6d3f3be53e 100644
--- a/test/fixedbugs/issue15548.dir/c.go
+++ b/test/fixedbugs/issue15548.dir/c.go
@@ -5,6 +5,6 @@
 package c
 
 import (
-	_ "./a"
 	_ "./b"
+	_ "./a"
 )
diff --git a/test/fixedbugs/issue15646.go b/test/fixedbugs/issue15646.go
index 53ccd4096e..cd4ba9d4e5 100644
--- a/test/fixedbugs/issue15646.go
+++ b/test/fixedbugs/issue15646.go
@@ -6,4 +6,4 @@
 
 // Test that method expressions are correctly encoded
 // in binary export data and can be imported again.
-package ignore
+package ignore
\ No newline at end of file
diff --git a/test/fixedbugs/issue15926.go b/test/fixedbugs/issue15926.go
index 8004545e14..76e25eb640 100644
--- a/test/fixedbugs/issue15926.go
+++ b/test/fixedbugs/issue15926.go
@@ -16,5 +16,5 @@ func (s S) def() {}
 var I = S.def
 
 func main() {
-	I(S{})
+    I(S{})
 }
diff --git a/test/fixedbugs/issue16515.go b/test/fixedbugs/issue16515.go
index cacff54bfa..6b67436383 100644
--- a/test/fixedbugs/issue16515.go
+++ b/test/fixedbugs/issue16515.go
@@ -34,10 +34,7 @@ func g() {
 }
 
 func main() {
-	var s struct {
-		a T
-		b [8192 - 62]int
-	} // allocate 64K, hopefully it's in a new span and a few bytes before it is garbage
+	var s struct { a T; b [8192-62]int } // allocate 64K, hopefully it's in a new span and a few bytes before it is garbage
 	sink = &s // force heap allocation
 	s.a[0] = 2
 	zero(&s.a)
diff --git a/test/fixedbugs/issue16948.go b/test/fixedbugs/issue16948.go
index 65c87c3f05..c986024896 100644
--- a/test/fixedbugs/issue16948.go
+++ b/test/fixedbugs/issue16948.go
@@ -18,7 +18,6 @@ func main() {
 var x int32
 
 type T [10]int
-
 var sink *T
 
 func f() (t T) {
diff --git a/test/fixedbugs/issue17449.go b/test/fixedbugs/issue17449.go
index 8c8bd4844f..51cc8eaa06 100644
--- a/test/fixedbugs/issue17449.go
+++ b/test/fixedbugs/issue17449.go
@@ -11,25 +11,25 @@
 package master
 
 type PriorityList struct {
-	elems []interface{}
+    elems []interface{}
 }
 
 func (x *PriorityList) Len() int { return len(x.elems) }
 
 func (l *PriorityList) remove(i int) interface{} {
-	elem := l.elems[i]
-	l.elems = append(l.elems[:i], l.elems[i+1:]...)
-	return elem
+    elem := l.elems[i]
+    l.elems = append(l.elems[:i], l.elems[i+1:]...)
+    return elem
 }
 
 func (l *PriorityList) Next() interface{} {
-	return l.remove(l.Len() - 1)
+    return l.remove(l.Len() - 1)
 }
 
 var l *PriorityList
 
 func Foo() {
-	// It would fail here if instrumented code (including inline-label) was copied.
-	for elem := l.Next(); elem != nil; elem = l.Next() {
-	}
+    // It would fail here if instrumented code (including inline-label) was copied.
+    for elem := l.Next(); elem != nil; elem = l.Next() {
+    }
 }
diff --git a/test/fixedbugs/issue17588.go b/test/fixedbugs/issue17588.go
index 23af6f613b..1be57c6292 100644
--- a/test/fixedbugs/issue17588.go
+++ b/test/fixedbugs/issue17588.go
@@ -11,10 +11,10 @@
 
 package p
 
-type F func(b T) // ERROR "T is not a type"
+type F func(b T)  // ERROR "T is not a type"
 
 func T(fn F) {
-	func() {
-		fn(nil) // If Decldepth is not initialized properly, typecheckclosure() Fatals here.
-	}()
+    func() {
+        fn(nil)  // If Decldepth is not initialized properly, typecheckclosure() Fatals here.
+    }()
 }
diff --git a/test/fixedbugs/issue17645.go b/test/fixedbugs/issue17645.go
index 0fc495c851..ed92c54cfa 100644
--- a/test/fixedbugs/issue17645.go
+++ b/test/fixedbugs/issue17645.go
@@ -12,5 +12,6 @@ type Foo struct {
 
 func main() {
 	var s []int
-	var _ string = append(s, Foo{""}) // ERROR "cannot use .. \(type string\) as type int in field value" "cannot use Foo literal \(type Foo\) as type int in append" "cannot use append\(s\, Foo literal\) \(type \[\]int\) as type string in assignment"
+	var _ string = append(s, Foo{""})  // ERROR "cannot use .. \(type string\) as type int in field value" "cannot use Foo literal \(type Foo\) as type int in append" "cannot use append\(s\, Foo literal\) \(type \[\]int\) as type string in assignment"
 }
+
diff --git a/test/fixedbugs/issue18231.go b/test/fixedbugs/issue18231.go
index 972c0f28a7..adfd2277ff 100644
--- a/test/fixedbugs/issue18231.go
+++ b/test/fixedbugs/issue18231.go
@@ -14,7 +14,7 @@ type T struct {
 }
 
 var _ = T{
-	f: { // ERROR "missing type in composite literal"
+	f: {                // ERROR "missing type in composite literal"
 		"a": "b",
 	},
 }
diff --git a/test/fixedbugs/issue18808.go b/test/fixedbugs/issue18808.go
index 8e1a55471d..c98386ee78 100644
--- a/test/fixedbugs/issue18808.go
+++ b/test/fixedbugs/issue18808.go
@@ -56,8 +56,8 @@ func lte(x uint32) {
 func main() {
 	eq(lim)
 	neq(lim)
-	gt(lim + 1)
-	gte(lim + 1)
-	lt(lim + 1)
-	lte(lim + 1)
+	gt(lim+1)
+	gte(lim+1)
+	lt(lim+1)
+	lte(lim+1)
 }
diff --git a/test/fixedbugs/issue19028.dir/main.go b/test/fixedbugs/issue19028.dir/main.go
index ca2cf8c694..627e926f93 100644
--- a/test/fixedbugs/issue19028.dir/main.go
+++ b/test/fixedbugs/issue19028.dir/main.go
@@ -5,12 +5,12 @@
 package main
 
 import (
-	fake "./reflect" // 2nd package with name "reflect"
-	"reflect"
+        "reflect"
+        fake "./reflect" // 2nd package with name "reflect"
 )
 
 type T struct {
-	_ fake.Type
+        _ fake.Type
 }
 
 func (T) f()            {}
@@ -18,9 +18,9 @@ func (T) G() (_ int)    { return }
 func (T) H() (_, _ int) { return }
 
 func main() {
-	var x T
-	typ := reflect.TypeOf(x)
-	for i := 0; i < typ.NumMethod(); i++ {
-		_ = typ.Method(i) // must not crash
-	}
+        var x T
+        typ := reflect.TypeOf(x)
+        for i := 0; i < typ.NumMethod(); i++ {
+                _ = typ.Method(i) // must not crash
+        }
 }
diff --git a/test/fixedbugs/issue19515.go b/test/fixedbugs/issue19515.go
index 8a230485f5..a1605bec96 100644
--- a/test/fixedbugs/issue19515.go
+++ b/test/fixedbugs/issue19515.go
@@ -48,3 +48,4 @@ func (v *VScrollPanel) Draw() {
 	BoxGradient(x+x-2, y-1, 0, 0, 0, Color{}, Color{})
 	BoxGradient(x+y-2, y-1, 0, 0, 0, Color{}, Color{})
 }
+
diff --git a/test/fixedbugs/issue19764.dir/a.go b/test/fixedbugs/issue19764.dir/a.go
index 7467d03a40..64538e5bdf 100644
--- a/test/fixedbugs/issue19764.dir/a.go
+++ b/test/fixedbugs/issue19764.dir/a.go
@@ -5,10 +5,9 @@
 package a
 
 type T struct{ _ int }
-
 func (t T) M() {}
 
-type I interface{ M() }
+type I interface { M() }
 
 func F() {
 	var t I = &T{}
diff --git a/test/fixedbugs/issue20602.go b/test/fixedbugs/issue20602.go
index c938ca3006..ca4ce095aa 100644
--- a/test/fixedbugs/issue20602.go
+++ b/test/fixedbugs/issue20602.go
@@ -10,5 +10,5 @@
 package p
 
 var p = &[1]complex128{0}
-var _ = real(p) // ERROR "type \*\[1\]complex128"
-var _ = imag(p) // ERROR "type \*\[1\]complex128"
+var _ = real(p)  // ERROR "type \*\[1\]complex128"
+var _ = imag(p)	 // ERROR "type \*\[1\]complex128"
diff --git a/test/fixedbugs/issue20811.go b/test/fixedbugs/issue20811.go
index 2ccf453a14..96b61ec728 100644
--- a/test/fixedbugs/issue20811.go
+++ b/test/fixedbugs/issue20811.go
@@ -20,3 +20,4 @@ func main() {
 func g() int64 {
 	return 4398046511104
 }
+
diff --git a/test/fixedbugs/issue22429.go b/test/fixedbugs/issue22429.go
index 03c007f2aa..289b434a74 100644
--- a/test/fixedbugs/issue22429.go
+++ b/test/fixedbugs/issue22429.go
@@ -9,10 +9,10 @@
 package p
 
 type T struct {
-	a, b, c, d float32
+	a,b,c,d float32
 }
 
-func f(a *[8]T, i, j, k int) float32 {
+func f(a *[8]T, i,j,k int) float32 {
 	b := *a
 	return b[i].a + b[j].b + b[k].c
 }
diff --git a/test/fixedbugs/issue22458.go b/test/fixedbugs/issue22458.go
index 9317bcfdbd..5c89929577 100644
--- a/test/fixedbugs/issue22458.go
+++ b/test/fixedbugs/issue22458.go
@@ -11,16 +11,16 @@ package main
 import "runtime"
 
 type node struct {
-	next *node
+        next *node
 }
 
 var x bool
 
 func main() {
-	var head *node
-	for x {
-		head = &node{head}
-	}
+        var head *node
+        for x {
+                head = &node{head}
+        }
 
-	runtime.KeepAlive(head)
+        runtime.KeepAlive(head)
 }
diff --git a/test/fixedbugs/issue22662.go b/test/fixedbugs/issue22662.go
index 03830de862..a1f00bfac3 100644
--- a/test/fixedbugs/issue22662.go
+++ b/test/fixedbugs/issue22662.go
@@ -25,7 +25,7 @@ func check(file string, line int) {
 }
 
 func main() {
-	//-style line directives
+//-style line directives
 //line :1
 	check("??", 1) // no file specified
 //line foo.go:1
@@ -35,16 +35,12 @@ func main() {
 //line :11:22
 	check("bar.go", 11) // no file, but column specified => keep old filename
 
-	/*-style line directives */
-	/*line :1*/
-	check("??", 1) // no file specified
-	/*line foo.go:1*/ check("foo.go", 1)
-	/*line bar.go:10:20*/ check("bar.go", 10)
-	/*line :11:22*/ check("bar.go", 11) // no file, but column specified => keep old filename
-
-	/*line :10*/
-	check("??", 10)     /*line foo.go:20*/
-	check("foo.go", 20) /*line :30:1*/
-	check("foo.go", 30)
+/*-style line directives */
+/*line :1*/ check("??", 1) // no file specified
+/*line foo.go:1*/ check("foo.go", 1)
+/*line bar.go:10:20*/ check("bar.go", 10)
+/*line :11:22*/ check("bar.go", 11) // no file, but column specified => keep old filename
+
+	/*line :10*/ check("??", 10); /*line foo.go:20*/ check("foo.go", 20); /*line :30:1*/ check("foo.go", 30)
 	check("foo.go", 31)
 }
diff --git a/test/fixedbugs/issue24339.go b/test/fixedbugs/issue24339.go
index 308fa75825..0670becdfe 100644
--- a/test/fixedbugs/issue24339.go
+++ b/test/fixedbugs/issue24339.go
@@ -9,6 +9,12 @@ package p
 // Use a diffent line number for each token so we can
 // check that the error message appears at the correct
 // position.
-var _ = struct{}{ /*line :20:1*/ foo /*line :21:1*/ : /*line :22:1*/ 0}
+var _ = struct{}{ /*line :20:1*/foo /*line :21:1*/: /*line :22:1*/0 }
 
-// ERROR "unknown field 'foo'"
+
+
+
+
+
+
+// ERROR "unknown field 'foo'"
\ No newline at end of file
diff --git a/test/fixedbugs/issue24799.go b/test/fixedbugs/issue24799.go
index 70f8def24d..c805c86dda 100644
--- a/test/fixedbugs/issue24799.go
+++ b/test/fixedbugs/issue24799.go
@@ -10,7 +10,7 @@
 package main
 
 import (
-	"fmt"
+        "fmt"
 )
 
 type Level string
@@ -20,39 +20,39 @@ type Level string
 // not aligned to 4 bytes due to the type of relocation that
 // is generated for the instruction. A fix was made to avoid
 // generating an instruction with DS relocation for go.strings
-// since their alignment is not known until link time.
+// since their alignment is not known until link time. 
 
 // This problem only affects go.string since other types have
 // correct alignment.
 
 const (
-	LevelBad             Level = "badvals"
-	LevelNone            Level = "No"
-	LevelMetadata        Level = "Metadata"
-	LevelRequest         Level = "Request"
-	LevelRequestResponse Level = "RequestResponse"
+        LevelBad Level = "badvals"
+        LevelNone Level = "No"
+        LevelMetadata Level = "Metadata"
+        LevelRequest Level = "Request"
+        LevelRequestResponse Level = "RequestResponse"
 )
 
 func ordLevel(l Level) int {
-	switch l {
-	case LevelMetadata:
-		return 1
-	case LevelRequest:
-		return 2
-	case LevelRequestResponse:
-		return 3
-	default:
-		return 0
-	}
+        switch l {
+        case LevelMetadata:
+                return 1
+        case LevelRequest:
+                return 2
+        case LevelRequestResponse:
+                return 3
+        default:
+                return 0
+        }
 }
 
 //go:noinline
 func test(l Level) {
-	if ordLevel(l) < ordLevel(LevelMetadata) {
-		fmt.Printf("OK\n")
-	}
+        if ordLevel(l) < ordLevel(LevelMetadata) {
+                fmt.Printf("OK\n")
+        }
 }
 
 func main() {
-	test(LevelMetadata)
+        test(LevelMetadata)
 }
diff --git a/test/fixedbugs/issue25727.go b/test/fixedbugs/issue25727.go
index da7c94cc12..9b7c804a0e 100644
--- a/test/fixedbugs/issue25727.go
+++ b/test/fixedbugs/issue25727.go
@@ -9,13 +9,13 @@ package main
 import "net/http"
 
 var s = http.Server{}
-var _ = s.doneChan                  // ERROR "s.doneChan undefined .cannot refer to unexported field or method doneChan.$"
-var _ = s.DoneChan                  // ERROR "s.DoneChan undefined .type http.Server has no field or method DoneChan.$"
+var _ = s.doneChan // ERROR "s.doneChan undefined .cannot refer to unexported field or method doneChan.$"
+var _ = s.DoneChan // ERROR "s.DoneChan undefined .type http.Server has no field or method DoneChan.$"
 var _ = http.Server{tlsConfig: nil} // ERROR "unknown field 'tlsConfig' in struct literal.+ .but does have TLSConfig.$"
-var _ = http.Server{DoneChan: nil}  // ERROR "unknown field 'DoneChan' in struct literal of type http.Server$"
+var _ = http.Server{DoneChan: nil} // ERROR "unknown field 'DoneChan' in struct literal of type http.Server$"
 
 type foo struct {
-	bar int
+    bar int
 }
 
 var _ = &foo{bAr: 10} // ERROR "unknown field 'bAr' in struct literal.+ .but does have bar.$"
diff --git a/test/fixedbugs/issue26335.go b/test/fixedbugs/issue26335.go
index 97174ea11d..a97b4b6c72 100644
--- a/test/fixedbugs/issue26335.go
+++ b/test/fixedbugs/issue26335.go
@@ -15,7 +15,7 @@ import (
 
 type Empty struct {
 	f1, f2 *byte
-	empty  struct{}
+	empty struct{}
 }
 
 func F(e Empty, s []string) {
diff --git a/test/fixedbugs/issue26340.go b/test/fixedbugs/issue26340.go
index afa32c8881..f973ce2237 100644
--- a/test/fixedbugs/issue26340.go
+++ b/test/fixedbugs/issue26340.go
@@ -10,12 +10,12 @@
 package p
 
 type S []T
-type T struct{ x int }
+type T struct { x int }
 
 var _ = map[string]*S{
 	"a": {
-		{1},
+		{ 1 },
 	},
 }
 
-var _ = [1]*S{{{1}}}
+var _ = [1]*S{ { {1}, } }
diff --git a/test/fixedbugs/issue26407.go b/test/fixedbugs/issue26407.go
index 02c1c19334..aa8e79c1e6 100644
--- a/test/fixedbugs/issue26407.go
+++ b/test/fixedbugs/issue26407.go
@@ -55,4 +55,4 @@ func grow() {
 }
 
 //go:noinline
-func use(_ []uintptr) {}
+func use(_ []uintptr) { }
diff --git a/test/fixedbugs/issue27278.go b/test/fixedbugs/issue27278.go
index 321b85cb63..73f7c755e1 100644
--- a/test/fixedbugs/issue27278.go
+++ b/test/fixedbugs/issue27278.go
@@ -50,7 +50,7 @@ func grow(n int) {
 	if n == 0 {
 		return
 	}
-	grow(n - 1)
+	grow(n-1)
 }
 
 // put some junk on stack, which cannot be valid address
diff --git a/test/fixedbugs/issue27356.go b/test/fixedbugs/issue27356.go
index 18530bf6a9..42784876a5 100644
--- a/test/fixedbugs/issue27356.go
+++ b/test/fixedbugs/issue27356.go
@@ -8,11 +8,12 @@
 
 package p
 
-var a = []int{1, 2, 3}
+var a = []int{1,2,3}
 
 func _(len int) {
-	_ = len(a) // ERROR "cannot call non-function"
+	_ =  len(a) // ERROR "cannot call non-function"
 }
 
 var cap = false
 var _ = cap(a) // ERROR "cannot call non-function"
+
diff --git a/test/fixedbugs/issue29215.go b/test/fixedbugs/issue29215.go
index 69bbdc3be4..4e8f107aee 100644
--- a/test/fixedbugs/issue29215.go
+++ b/test/fixedbugs/issue29215.go
@@ -7,14 +7,14 @@
 package main
 
 func f() {
-	var s string
-	var p, q bool
-	s = "a"
-	for p {
-		p = false == (true != q)
-		s = ""
-	}
-	_ = s == "bbb"
+        var s string
+        var p, q bool
+        s = "a"
+        for p {
+                p = false == (true != q)
+                s = ""
+        }
+        _ = s == "bbb"
 }
 
 // Another case: load from negative offset of a symbol
diff --git a/test/fixedbugs/issue29402.go b/test/fixedbugs/issue29402.go
index fed779bc5f..8a1f959d84 100644
--- a/test/fixedbugs/issue29402.go
+++ b/test/fixedbugs/issue29402.go
@@ -1,5 +1,5 @@
 // run
-
+  
 // Copyright 2018 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.
diff --git a/test/fixedbugs/issue31747.go b/test/fixedbugs/issue31747.go
index 81bd111d44..dfb585c613 100644
--- a/test/fixedbugs/issue31747.go
+++ b/test/fixedbugs/issue31747.go
@@ -14,10 +14,10 @@ const (
 	_ = 0xabc // ok
 	_ = 0x0p1 // ERROR "hexadecimal floating-point literals only supported as of -lang=go1.13"
 
-	_ = 0b111 // ERROR "binary"
-	_ = 0o567 // ERROR "octal"
-	_ = 0xabc // ok
-	_ = 0x0p1 // ERROR "hexadecimal floating-point"
+	_ = 0B111 // ERROR "binary"
+	_ = 0O567 // ERROR "octal"
+	_ = 0Xabc // ok
+	_ = 0X0P1 // ERROR "hexadecimal floating-point"
 
 	_ = 1_000i // ERROR "underscores"
 	_ = 0b111i // ERROR "binary"
diff --git a/test/fixedbugs/issue3552.dir/one.go b/test/fixedbugs/issue3552.dir/one.go
index dacd2565da..e594db7478 100644
--- a/test/fixedbugs/issue3552.dir/one.go
+++ b/test/fixedbugs/issue3552.dir/one.go
@@ -6,20 +6,23 @@ package one
 
 // Issue 3552
 
-type T struct{ int }
+type T struct { int }
 
 func (t T) F() int { return t.int }
 
-type U struct{ int int }
+type U struct { int int }
 
 func (u U) F() int { return u.int }
 
 type lint int
 
-type V struct{ lint }
+type V struct { lint }
 
 func (v V) F() int { return int(v.lint) }
 
-type W struct{ lint lint }
+type W struct { lint lint }
 
 func (w W) F() int { return int(w.lint) }
+
+
+
diff --git a/test/fixedbugs/issue3783.go b/test/fixedbugs/issue3783.go
index b60b4b3ee0..7db06d1881 100644
--- a/test/fixedbugs/issue3783.go
+++ b/test/fixedbugs/issue3783.go
@@ -9,3 +9,4 @@ package foo
 var i int
 
 func (*i) bar() // ERROR "not a type|expected type"
+
diff --git a/test/fixedbugs/issue3925.go b/test/fixedbugs/issue3925.go
index a8c73a3d65..628c222685 100644
--- a/test/fixedbugs/issue3925.go
+++ b/test/fixedbugs/issue3925.go
@@ -11,7 +11,7 @@
 package foo
 
 var _ = map[string]string{
-	"1":      "2",
+	"1": "2",
 	"3", "4", // ERROR "missing key|must have keys"
 }
 
@@ -20,3 +20,4 @@ var _ = []string{
 	"bar",
 	20, // ERROR "cannot use|incompatible type"
 }
+
diff --git a/test/fixedbugs/issue4097.go b/test/fixedbugs/issue4097.go
index a3c9fea8cb..30b65bce83 100644
--- a/test/fixedbugs/issue4097.go
+++ b/test/fixedbugs/issue4097.go
@@ -7,5 +7,5 @@
 package foo
 
 var s [][10]int
+const m = len(s[len(s)-1]) // ERROR "is not a constant|is not constant" 
 
-const m = len(s[len(s)-1]) // ERROR "is not a constant|is not constant"
diff --git a/test/fixedbugs/issue4099.go b/test/fixedbugs/issue4099.go
index c02e337f37..5a4ea7c998 100644
--- a/test/fixedbugs/issue4099.go
+++ b/test/fixedbugs/issue4099.go
@@ -20,7 +20,7 @@ func F2([]byte)
 func G() {
 	var buf1 [10]byte
 	F1(buf1[:])
-
+	
 	var buf2 [10]byte // ERROR "moved to heap: buf2"
 	F2(buf2[:])
 }
diff --git a/test/fixedbugs/issue4162.go b/test/fixedbugs/issue4162.go
index 23b93e5841..f236bd0f6a 100644
--- a/test/fixedbugs/issue4162.go
+++ b/test/fixedbugs/issue4162.go
@@ -10,8 +10,8 @@ package p
 
 // All these are valid now.
 var (
-	_ = int(1.0)      // comma was always permitted (like function call)
-	_ = []byte("foo") // was syntax error: unexpected comma
-	_ = chan int(nil) // was syntax error: unexpected comma
-	_ = (func())(nil) // was syntax error: unexpected comma
+	_ = int(1.0,)      // comma was always permitted (like function call)
+	_ = []byte("foo",) // was syntax error: unexpected comma
+	_ = chan int(nil,) // was syntax error: unexpected comma
+	_ = (func())(nil,) // was syntax error: unexpected comma
 )
diff --git a/test/fixedbugs/issue4251.go b/test/fixedbugs/issue4251.go
index b3434d7ff6..d11ce51b97 100644
--- a/test/fixedbugs/issue4251.go
+++ b/test/fixedbugs/issue4251.go
@@ -9,13 +9,13 @@
 package p
 
 func F1(s []byte) []byte {
-	return s[2:1] // ERROR "invalid slice index|inverted slice range"
+	return s[2:1]		// ERROR "invalid slice index|inverted slice range"
 }
 
 func F2(a [10]byte) []byte {
-	return a[2:1] // ERROR "invalid slice index|inverted slice range"
+	return a[2:1]		// ERROR "invalid slice index|inverted slice range"
 }
 
 func F3(s string) string {
-	return s[2:1] // ERROR "invalid slice index|inverted slice range"
+	return s[2:1]		// ERROR "invalid slice index|inverted slice range"
 }
diff --git a/test/fixedbugs/issue4264.go b/test/fixedbugs/issue4264.go
index f550c95e71..627393211e 100644
--- a/test/fixedbugs/issue4264.go
+++ b/test/fixedbugs/issue4264.go
@@ -13,7 +13,7 @@ func main() {
 	var y float64
 	var z complex128
 
-	println(x / 0) // ERROR "division by zero"
-	println(y / 0)
-	println(z / 0)
-}
+	println(x/0) // ERROR "division by zero"
+	println(y/0)
+	println(z/0)
+}
\ No newline at end of file
diff --git a/test/fixedbugs/issue4283.go b/test/fixedbugs/issue4283.go
index 5d69538843..fa5629b20a 100644
--- a/test/fixedbugs/issue4283.go
+++ b/test/fixedbugs/issue4283.go
@@ -9,9 +9,9 @@
 package p
 
 func F1() bool {
-	return nil == nil // ERROR "invalid"
+	return nil == nil	// ERROR "invalid"
 }
 
 func F2() bool {
-	return nil != nil // ERROR "invalid"
+	return nil != nil	// ERROR "invalid"
 }
diff --git a/test/fixedbugs/issue4313.go b/test/fixedbugs/issue4313.go
index ad45f60a5b..2494b83b03 100644
--- a/test/fixedbugs/issue4313.go
+++ b/test/fixedbugs/issue4313.go
@@ -22,10 +22,7 @@ func main() {
 }
 
 func makec(px *int) chan bool {
-	if false {
-		for {
-		}
-	}
+	if false { for {} }
 	*px = 42
 	return make(chan bool, 0)
 }
diff --git a/test/fixedbugs/issue4326.dir/q1.go b/test/fixedbugs/issue4326.dir/q1.go
index f1a0d18ea8..f118eb0925 100644
--- a/test/fixedbugs/issue4326.dir/q1.go
+++ b/test/fixedbugs/issue4326.dir/q1.go
@@ -1,8 +1,8 @@
 package q1
 
 func Deref(typ interface{}) interface{} {
-	if typ, ok := typ.(*int); ok {
-		return *typ
-	}
-	return typ
+      if typ, ok := typ.(*int); ok {
+            return *typ
+      }
+      return typ
 }
diff --git a/test/fixedbugs/issue4326.dir/q2.go b/test/fixedbugs/issue4326.dir/q2.go
index 2bcc0e224d..075e2b21e7 100644
--- a/test/fixedbugs/issue4326.dir/q2.go
+++ b/test/fixedbugs/issue4326.dir/q2.go
@@ -3,9 +3,9 @@ package main
 import "./q1"
 
 func main() {
-	x := 1
-	y := q1.Deref(&x)
-	if y != 1 {
-		panic("y != 1")
-	}
+      x := 1
+      y := q1.Deref(&x)
+      if y != 1 {
+            panic("y != 1")
+      }
 }
diff --git a/test/fixedbugs/issue4365.go b/test/fixedbugs/issue4365.go
index 9b4a7641b1..09ff1bf8f7 100644
--- a/test/fixedbugs/issue4365.go
+++ b/test/fixedbugs/issue4365.go
@@ -10,7 +10,7 @@
 package main
 
 type T interface {
-	M()
+        M()
 }
 
 type M struct{}
@@ -18,10 +18,10 @@ type M struct{}
 func (M) M() {}
 
 type Foo struct {
-	M
+        M
 }
 
 func main() {
-	var v T = Foo{} // ERROR "has no methods|not a method|cannot use"
-	_ = v
+        var v T = Foo{} // ERROR "has no methods|not a method|cannot use"
+        _ = v
 }
diff --git a/test/fixedbugs/issue4396a.go b/test/fixedbugs/issue4396a.go
index 12f4212d76..38dd4b8cfb 100644
--- a/test/fixedbugs/issue4396a.go
+++ b/test/fixedbugs/issue4396a.go
@@ -8,7 +8,7 @@
 // word aligned. 5g should use MOVB to load the address
 // of s.g[0] for its nil check.
 //
-// This test _may_ fail on arm, but requires the host to
+// This test _may_ fail on arm, but requires the host to 
 // trap unaligned loads. This is generally done with
 //
 // echo "4" > /proc/cpu/alignment
diff --git a/test/fixedbugs/issue4396b.go b/test/fixedbugs/issue4396b.go
index 1281284d17..1284870ece 100644
--- a/test/fixedbugs/issue4396b.go
+++ b/test/fixedbugs/issue4396b.go
@@ -17,7 +17,7 @@ type T struct {
 }
 
 type T2 struct {
-	pad  [4096]byte
+	pad    [4096]byte
 	A, B byte
 }
 
diff --git a/test/fixedbugs/issue4429.go b/test/fixedbugs/issue4429.go
index 7b2c92a7bc..9eb2e0f9c2 100644
--- a/test/fixedbugs/issue4429.go
+++ b/test/fixedbugs/issue4429.go
@@ -7,10 +7,10 @@
 package p
 
 type a struct {
-	a int
+  a int
 }
 
 func main() {
-	av := a{}
-	_ = *a(av) // ERROR "invalid indirect|expected pointer"
+  av := a{};
+  _ = *a(av); // ERROR "invalid indirect|expected pointer"
 }
diff --git a/test/fixedbugs/issue4463.go b/test/fixedbugs/issue4463.go
index 500b4975e6..6ad1952d67 100644
--- a/test/fixedbugs/issue4463.go
+++ b/test/fixedbugs/issue4463.go
@@ -17,17 +17,17 @@ func F() {
 	var m map[int]int
 	var s struct{ f int }
 
-	append(a, 0)         // ERROR "not used"
-	cap(a)               // ERROR "not used"
-	complex(1, 2)        // ERROR "not used"
-	imag(1i)             // ERROR "not used"
-	len(a)               // ERROR "not used"
-	make([]int, 10)      // ERROR "not used"
-	new(int)             // ERROR "not used"
-	real(1i)             // ERROR "not used"
-	unsafe.Alignof(a)    // ERROR "not used"
-	unsafe.Offsetof(s.f) // ERROR "not used"
-	unsafe.Sizeof(a)     // ERROR "not used"
+	append(a, 0)			// ERROR "not used"
+	cap(a)				// ERROR "not used"
+	complex(1, 2)			// ERROR "not used"
+	imag(1i)			// ERROR "not used"
+	len(a)				// ERROR "not used"
+	make([]int, 10)			// ERROR "not used"
+	new(int)			// ERROR "not used"
+	real(1i)			// ERROR "not used"
+	unsafe.Alignof(a)		// ERROR "not used"
+	unsafe.Offsetof(s.f)		// ERROR "not used"
+	unsafe.Sizeof(a)		// ERROR "not used"
 
 	close(c)
 	copy(a, a)
@@ -45,17 +45,17 @@ func F() {
 	(println("bar"))
 	(recover())
 
-	go append(a, 0)         // ERROR "not used|discards result"
-	go cap(a)               // ERROR "not used|discards result"
-	go complex(1, 2)        // ERROR "not used|discards result"
-	go imag(1i)             // ERROR "not used|discards result"
-	go len(a)               // ERROR "not used|discards result"
-	go make([]int, 10)      // ERROR "not used|discards result"
-	go new(int)             // ERROR "not used|discards result"
-	go real(1i)             // ERROR "not used|discards result"
-	go unsafe.Alignof(a)    // ERROR "not used|discards result"
-	go unsafe.Offsetof(s.f) // ERROR "not used|discards result"
-	go unsafe.Sizeof(a)     // ERROR "not used|discards result"
+	go append(a, 0)			// ERROR "not used|discards result"
+	go cap(a)			// ERROR "not used|discards result"
+	go complex(1, 2)		// ERROR "not used|discards result"
+	go imag(1i)			// ERROR "not used|discards result"
+	go len(a)			// ERROR "not used|discards result"
+	go make([]int, 10)		// ERROR "not used|discards result"
+	go new(int)			// ERROR "not used|discards result"
+	go real(1i)			// ERROR "not used|discards result"
+	go unsafe.Alignof(a)		// ERROR "not used|discards result"
+	go unsafe.Offsetof(s.f)		// ERROR "not used|discards result"
+	go unsafe.Sizeof(a)		// ERROR "not used|discards result"
 
 	go close(c)
 	go copy(a, a)
@@ -65,17 +65,17 @@ func F() {
 	go println("bar")
 	go recover()
 
-	defer append(a, 0)         // ERROR "not used|discards result"
-	defer cap(a)               // ERROR "not used|discards result"
-	defer complex(1, 2)        // ERROR "not used|discards result"
-	defer imag(1i)             // ERROR "not used|discards result"
-	defer len(a)               // ERROR "not used|discards result"
-	defer make([]int, 10)      // ERROR "not used|discards result"
-	defer new(int)             // ERROR "not used|discards result"
-	defer real(1i)             // ERROR "not used|discards result"
-	defer unsafe.Alignof(a)    // ERROR "not used|discards result"
-	defer unsafe.Offsetof(s.f) // ERROR "not used|discards result"
-	defer unsafe.Sizeof(a)     // ERROR "not used|discards result"
+	defer append(a, 0)		// ERROR "not used|discards result"
+	defer cap(a)			// ERROR "not used|discards result"
+	defer complex(1, 2)		// ERROR "not used|discards result"
+	defer imag(1i)			// ERROR "not used|discards result"
+	defer len(a)			// ERROR "not used|discards result"
+	defer make([]int, 10)		// ERROR "not used|discards result"
+	defer new(int)			// ERROR "not used|discards result"
+	defer real(1i)			// ERROR "not used|discards result"
+	defer unsafe.Alignof(a)		// ERROR "not used|discards result"
+	defer unsafe.Offsetof(s.f)	// ERROR "not used|discards result"
+	defer unsafe.Sizeof(a)		// ERROR "not used|discards result"
 
 	defer close(c)
 	defer copy(a, a)
diff --git a/test/fixedbugs/issue4470.go b/test/fixedbugs/issue4470.go
index f84a5409b7..d922478455 100644
--- a/test/fixedbugs/issue4470.go
+++ b/test/fixedbugs/issue4470.go
@@ -10,7 +10,7 @@ package main
 
 func main() {
 	var i interface{}
-	switch i.(type) { // ERROR "outside type switch"
+	switch (i.(type)) { // ERROR "outside type switch"
 	default:
 	}
 }
diff --git a/test/fixedbugs/issue4495.go b/test/fixedbugs/issue4495.go
index 8f90809501..308acc2280 100644
--- a/test/fixedbugs/issue4495.go
+++ b/test/fixedbugs/issue4495.go
@@ -26,3 +26,4 @@ func main() {
 		panic("ret != 3")
 	}
 }
+
diff --git a/test/fixedbugs/issue4562.go b/test/fixedbugs/issue4562.go
index 94280359b0..8c958f5725 100644
--- a/test/fixedbugs/issue4562.go
+++ b/test/fixedbugs/issue4562.go
@@ -34,7 +34,7 @@ func expectError(expectLine int) {
 	if recover() == nil {
 		panic("did not crash")
 	}
-	for i := 1; ; i++ {
+	for i := 1;; i++ {
 		_, file, line, ok := runtime.Caller(i)
 		if !ok {
 			panic("cannot find issue4562.go on stack")
diff --git a/test/fixedbugs/issue4610.go b/test/fixedbugs/issue4610.go
index 8993f9882b..d56c6d3e8c 100644
--- a/test/fixedbugs/issue4610.go
+++ b/test/fixedbugs/issue4610.go
@@ -14,3 +14,4 @@ func main() {
 	var foo bar
 	_ = &foo{} // ERROR "is not a type|expected .;."
 } // GCCGO_ERROR "expected declaration"
+
diff --git a/test/fixedbugs/issue4618.go b/test/fixedbugs/issue4618.go
index fe43aa828d..0ba95230cf 100644
--- a/test/fixedbugs/issue4618.go
+++ b/test/fixedbugs/issue4618.go
@@ -13,7 +13,7 @@ import (
 	"testing"
 )
 
-type T struct{ int }
+type T struct { int }
 
 var globl *T
 
diff --git a/test/fixedbugs/issue4620.go b/test/fixedbugs/issue4620.go
index 20d641d3f4..5aa29086f7 100644
--- a/test/fixedbugs/issue4620.go
+++ b/test/fixedbugs/issue4620.go
@@ -11,7 +11,7 @@ package main
 import "fmt"
 
 func main() {
-	m := map[int]int{0: 1}
+	m := map[int]int{0:1}
 	i := 0
 	i, m[i] = 1, 2
 	if m[0] != 2 {
diff --git a/test/fixedbugs/issue4654.go b/test/fixedbugs/issue4654.go
index 595782f953..76aff76a67 100644
--- a/test/fixedbugs/issue4654.go
+++ b/test/fixedbugs/issue4654.go
@@ -12,60 +12,60 @@ package p
 import "unsafe"
 
 func f() {
-	defer int(0)             // ERROR "defer requires function call, not conversion|is not used"
+	defer int(0) // ERROR "defer requires function call, not conversion|is not used"
 	go string([]byte("abc")) // ERROR "go requires function call, not conversion|is not used"
-
+	
 	var c complex128
 	var f float64
-	var t struct{ X int }
+	var t struct {X int}
 
 	var x []int
-	defer append(x, 1)         // ERROR "defer discards result of append|is not used"
-	defer cap(x)               // ERROR "defer discards result of cap|is not used"
-	defer complex(1, 2)        // ERROR "defer discards result of complex|is not used"
-	defer complex(f, 1)        // ERROR "defer discards result of complex|is not used"
-	defer imag(1i)             // ERROR "defer discards result of imag|is not used"
-	defer imag(c)              // ERROR "defer discards result of imag|is not used"
-	defer len(x)               // ERROR "defer discards result of len|is not used"
-	defer make([]int, 1)       // ERROR "defer discards result of make|is not used"
-	defer make(chan bool)      // ERROR "defer discards result of make|is not used"
+	defer append(x, 1) // ERROR "defer discards result of append|is not used"
+	defer cap(x) // ERROR "defer discards result of cap|is not used"
+	defer complex(1, 2) // ERROR "defer discards result of complex|is not used"
+	defer complex(f, 1) // ERROR "defer discards result of complex|is not used"
+	defer imag(1i) // ERROR "defer discards result of imag|is not used"
+	defer imag(c) // ERROR "defer discards result of imag|is not used"
+	defer len(x) // ERROR "defer discards result of len|is not used"
+	defer make([]int, 1) // ERROR "defer discards result of make|is not used"
+	defer make(chan bool) // ERROR "defer discards result of make|is not used"
 	defer make(map[string]int) // ERROR "defer discards result of make|is not used"
-	defer new(int)             // ERROR "defer discards result of new|is not used"
-	defer real(1i)             // ERROR "defer discards result of real|is not used"
-	defer real(c)              // ERROR "defer discards result of real|is not used"
-	defer append(x, 1)         // ERROR "defer discards result of append|is not used"
-	defer append(x, 1)         // ERROR "defer discards result of append|is not used"
-	defer unsafe.Alignof(t.X)  // ERROR "defer discards result of unsafe.Alignof|is not used"
+	defer new(int) // ERROR "defer discards result of new|is not used"
+	defer real(1i) // ERROR "defer discards result of real|is not used"
+	defer real(c) // ERROR "defer discards result of real|is not used"
+	defer append(x, 1) // ERROR "defer discards result of append|is not used"
+	defer append(x, 1) // ERROR "defer discards result of append|is not used"
+	defer unsafe.Alignof(t.X) // ERROR "defer discards result of unsafe.Alignof|is not used"
 	defer unsafe.Offsetof(t.X) // ERROR "defer discards result of unsafe.Offsetof|is not used"
-	defer unsafe.Sizeof(t)     // ERROR "defer discards result of unsafe.Sizeof|is not used"
-
+	defer unsafe.Sizeof(t) // ERROR "defer discards result of unsafe.Sizeof|is not used"
+	
 	defer copy(x, x) // ok
 	m := make(map[int]int)
 	defer delete(m, 1) // ok
-	defer panic(1)     // ok
-	defer print(1)     // ok
-	defer println(1)   // ok
-	defer recover()    // ok
+	defer panic(1) // ok
+	defer print(1) // ok
+	defer println(1) // ok
+	defer recover() // ok
 
-	int(0)                // ERROR "int\(0\) evaluated but not used|is not used"
+	int(0) // ERROR "int\(0\) evaluated but not used|is not used"
 	string([]byte("abc")) // ERROR "string\(.*\) evaluated but not used|is not used"
 
-	append(x, 1)         // ERROR "not used"
-	cap(x)               // ERROR "not used"
-	complex(1, 2)        // ERROR "not used"
-	complex(f, 1)        // ERROR "not used"
-	imag(1i)             // ERROR "not used"
-	imag(c)              // ERROR "not used"
-	len(x)               // ERROR "not used"
-	make([]int, 1)       // ERROR "not used"
-	make(chan bool)      // ERROR "not used"
+	append(x, 1) // ERROR "not used"
+	cap(x) // ERROR "not used"
+	complex(1, 2) // ERROR "not used"
+	complex(f, 1) // ERROR "not used"
+	imag(1i) // ERROR "not used"
+	imag(c) // ERROR "not used"
+	len(x) // ERROR "not used"
+	make([]int, 1) // ERROR "not used"
+	make(chan bool) // ERROR "not used"
 	make(map[string]int) // ERROR "not used"
-	new(int)             // ERROR "not used"
-	real(1i)             // ERROR "not used"
-	real(c)              // ERROR "not used"
-	append(x, 1)         // ERROR "not used"
-	append(x, 1)         // ERROR "not used"
-	unsafe.Alignof(t.X)  // ERROR "not used"
+	new(int) // ERROR "not used"
+	real(1i) // ERROR "not used"
+	real(c) // ERROR "not used"
+	append(x, 1) // ERROR "not used"
+	append(x, 1) // ERROR "not used"
+	unsafe.Alignof(t.X) // ERROR "not used"
 	unsafe.Offsetof(t.X) // ERROR "not used"
-	unsafe.Sizeof(t)     // ERROR "not used"
+	unsafe.Sizeof(t) // ERROR "not used"
 }
diff --git a/test/fixedbugs/issue4663.go b/test/fixedbugs/issue4663.go
index 2533f0f269..971290d8dd 100644
--- a/test/fixedbugs/issue4663.go
+++ b/test/fixedbugs/issue4663.go
@@ -10,6 +10,6 @@
 package main
 
 func a(b int) int64 {
-	b // ERROR "not used"
-	return 0
+  b // ERROR "not used"
+  return 0
 }
diff --git a/test/fixedbugs/issue4748.go b/test/fixedbugs/issue4748.go
index 7a9deca039..f7c77cf882 100644
--- a/test/fixedbugs/issue4748.go
+++ b/test/fixedbugs/issue4748.go
@@ -10,11 +10,11 @@
 package main
 
 func jump() {
-	goto exit
+        goto exit
 exit:
-	return
+        return
 }
 func main() {
-	jump()
-	jump()
+        jump()
+        jump()
 }
diff --git a/test/fixedbugs/issue4879.dir/a.go b/test/fixedbugs/issue4879.dir/a.go
index 9bfb0c7d4f..7ee7c48604 100644
--- a/test/fixedbugs/issue4879.dir/a.go
+++ b/test/fixedbugs/issue4879.dir/a.go
@@ -30,3 +30,4 @@ func MakePrivateCollection3() *Collection {
 		root: unsafe.Pointer(&maptype{}),
 	}
 }
+
diff --git a/test/fixedbugs/issue4879.dir/b.go b/test/fixedbugs/issue4879.dir/b.go
index 62dcb36e21..d8fb5693db 100644
--- a/test/fixedbugs/issue4879.dir/b.go
+++ b/test/fixedbugs/issue4879.dir/b.go
@@ -3,7 +3,7 @@ package b
 import "./a"
 
 func F() {
-	a.MakePrivateCollection()
-	a.MakePrivateCollection2()
-	a.MakePrivateCollection3()
+      a.MakePrivateCollection()
+      a.MakePrivateCollection2()
+      a.MakePrivateCollection3()
 }
diff --git a/test/fixedbugs/issue5056.go b/test/fixedbugs/issue5056.go
index d43bbbee1f..6fb444aa67 100644
--- a/test/fixedbugs/issue5056.go
+++ b/test/fixedbugs/issue5056.go
@@ -10,7 +10,7 @@ package main
 
 type Foo int16
 
-func (f Foo) Esc() *int {
+func (f Foo) Esc() *int{
 	x := int(f)
 	return &x
 }
@@ -24,7 +24,7 @@ var bar, foobar *int
 func main() {
 	var quux iface
 	var x Foo
-
+	
 	quux = x
 	bar = quux.Esc()
 	foobar = quux.Esc()
diff --git a/test/fixedbugs/issue5172.go b/test/fixedbugs/issue5172.go
index 4a29dd1812..a6acbd3db7 100644
--- a/test/fixedbugs/issue5172.go
+++ b/test/fixedbugs/issue5172.go
@@ -14,6 +14,6 @@ type foo struct {
 
 func main() {
 	var f foo
-	go f.bar()    // GCCGO_ERROR "undefined"
-	defer f.bar() // GCCGO_ERROR "undefined"
+	go f.bar()	// GCCGO_ERROR "undefined"
+	defer f.bar()	// GCCGO_ERROR "undefined"
 }
diff --git a/test/fixedbugs/issue5493.go b/test/fixedbugs/issue5493.go
index ee7a0dc071..2ee0398af2 100644
--- a/test/fixedbugs/issue5493.go
+++ b/test/fixedbugs/issue5493.go
@@ -14,7 +14,6 @@ import (
 )
 
 const N = 10
-
 var count int64
 
 func run() error {
@@ -57,3 +56,4 @@ func main() {
 		panic("not all finalizers are called")
 	}
 }
+
diff --git a/test/fixedbugs/issue5515.go b/test/fixedbugs/issue5515.go
index 2dab1eaab3..053abf6f7c 100644
--- a/test/fixedbugs/issue5515.go
+++ b/test/fixedbugs/issue5515.go
@@ -11,24 +11,24 @@ package main
 type T uint32
 
 func main() {
-	b := make([]T, 8)
-	b[0] = 0xdeadbeef
-	rs := Slice(b)
-	sort(rs)
+        b := make([]T, 8)
+        b[0] = 0xdeadbeef
+        rs := Slice(b)
+        sort(rs)
 }
 
 type Slice []T
 
 func (s Slice) Swap(i, j int) {
-	tmp := s[i]
-	s[i] = s[j]
-	s[j] = tmp
+        tmp := s[i]
+        s[i] = s[j]
+        s[j] = tmp
 }
 
 type Interface interface {
-	Swap(i, j int)
+        Swap(i, j int)
 }
 
 func sort(data Interface) {
-	data.Swap(0, 4)
+        data.Swap(0, 4)
 }
diff --git a/test/fixedbugs/issue5614.dir/x.go b/test/fixedbugs/issue5614.dir/x.go
index 6cd0969db8..7e4f3a7e6b 100644
--- a/test/fixedbugs/issue5614.dir/x.go
+++ b/test/fixedbugs/issue5614.dir/x.go
@@ -3,3 +3,5 @@ package x
 import "./rethinkgo"
 
 var S *rethinkgo.Session
+
+
diff --git a/test/fixedbugs/issue5753.go b/test/fixedbugs/issue5753.go
index 597fd2f58c..230a1e8c3b 100644
--- a/test/fixedbugs/issue5753.go
+++ b/test/fixedbugs/issue5753.go
@@ -25,5 +25,5 @@ func main() {
 	if s[0] != "foo" {
 		panic(`s[0] != "foo"`)
 	}
-
+	
 }
diff --git a/test/fixedbugs/issue5809.go b/test/fixedbugs/issue5809.go
index e63515f678..fc8eeef82f 100644
--- a/test/fixedbugs/issue5809.go
+++ b/test/fixedbugs/issue5809.go
@@ -14,13 +14,13 @@ func main() {
 	const d16 = "0123456789ABCDEF"
 	k := 0x1234
 	var x [4]byte
-
+	
 	x[0] = d16[k>>12&0xf]
 	x[1] = d16[k>>8&0xf]
 	x[2] = d16[k>>4&0xf]
 	x[3] = d16[k&0xf]
-
-	if x != [4]byte{'1', '2', '3', '4'} {
+	
+	if x != [4]byte{'1','2','3','4'} {
 		fmt.Println(x)
 		panic("x != [4]byte{'1','2','3','4'}")
 	}
diff --git a/test/fixedbugs/issue5957.dir/b.go b/test/fixedbugs/issue5957.dir/b.go
index 674bcbc006..9bc561b9ce 100644
--- a/test/fixedbugs/issue5957.dir/b.go
+++ b/test/fixedbugs/issue5957.dir/b.go
@@ -1 +1,2 @@
 package surprise2
+
diff --git a/test/fixedbugs/issue5957.dir/c.go b/test/fixedbugs/issue5957.dir/c.go
index 28f6e84a59..d115eacdd5 100644
--- a/test/fixedbugs/issue5957.dir/c.go
+++ b/test/fixedbugs/issue5957.dir/c.go
@@ -1,12 +1,12 @@
 package p
 
 import (
-	"./a"      // ERROR "imported and not used: \x22a\x22 as surprise|imported and not used: surprise"
-	"./b"      // ERROR "imported and not used: \x22b\x22 as surprise2|imported and not used: surprise2"
-	b "./b"    // ERROR "imported and not used: \x22b\x22$|imported and not used: surprise2"
-	"fmt"      // actually used
+	"./a" // ERROR "imported and not used: \x22a\x22 as surprise|imported and not used: surprise"
+	"./b" // ERROR "imported and not used: \x22b\x22 as surprise2|imported and not used: surprise2"
+	b "./b" // ERROR "imported and not used: \x22b\x22$|imported and not used: surprise2"
 	foo "math" // ERROR "imported and not used: \x22math\x22 as foo|imported and not used: math"
-	"strings"  // ERROR "imported and not used: \x22strings\x22|imported and not used: strings"
+	"fmt" // actually used
+	"strings" // ERROR "imported and not used: \x22strings\x22|imported and not used: strings"
 )
 
 var _ = fmt.Printf
diff --git a/test/fixedbugs/issue6004.go b/test/fixedbugs/issue6004.go
index 4a4a43cf94..2b3dcd923d 100644
--- a/test/fixedbugs/issue6004.go
+++ b/test/fixedbugs/issue6004.go
@@ -7,8 +7,9 @@
 package main
 
 func main() {
-	_ = nil                  // ERROR "use of untyped nil"
-	_, _ = nil, 1            // ERROR "use of untyped nil"
-	_, _ = 1, nil            // ERROR "use of untyped nil"
+	_ = nil // ERROR "use of untyped nil"
+	_, _ = nil, 1 // ERROR "use of untyped nil"
+	_, _ = 1, nil // ERROR "use of untyped nil"
 	_ = append(nil, 1, 2, 3) // ERROR "untyped nil"
 }
+
diff --git a/test/fixedbugs/issue6406.go b/test/fixedbugs/issue6406.go
index 429aa7f5f3..5491193ef3 100644
--- a/test/fixedbugs/issue6406.go
+++ b/test/fixedbugs/issue6406.go
@@ -8,5 +8,5 @@ package main
 
 func main() {
 	s = "bob" // ERROR "undefined.*s"
-	_ = s     // ERROR "undefined.*s"
+	_ = s // ERROR "undefined.*s"
 }
diff --git a/test/fixedbugs/issue6703g.go b/test/fixedbugs/issue6703g.go
index 1762d0bc42..05ec7405f3 100644
--- a/test/fixedbugs/issue6703g.go
+++ b/test/fixedbugs/issue6703g.go
@@ -17,4 +17,4 @@ func (T) m() int {
 
 type E struct{ T }
 
-var x = E.m // ERROR "initialization loop|depends upon itself"
+var x = E.m // ERROR "initialization loop|depends upon itself" 
diff --git a/test/fixedbugs/issue6703h.go b/test/fixedbugs/issue6703h.go
index af0cdfbbdd..f6b69e1b70 100644
--- a/test/fixedbugs/issue6703h.go
+++ b/test/fixedbugs/issue6703h.go
@@ -17,4 +17,4 @@ func (T) m() int {
 
 type E struct{ T }
 
-var x = E.m(E{0}) // ERROR "initialization loop|depends upon itself"
+var x = E.m(E{0}) // ERROR "initialization loop|depends upon itself" 
diff --git a/test/fixedbugs/issue6703i.go b/test/fixedbugs/issue6703i.go
index c412268d7e..fb580a2461 100644
--- a/test/fixedbugs/issue6703i.go
+++ b/test/fixedbugs/issue6703i.go
@@ -17,4 +17,4 @@ func (T) m() int {
 
 type E struct{ T }
 
-var x = E{}.m // ERROR "initialization loop|depends upon itself"
+var x = E{}.m // ERROR "initialization loop|depends upon itself" 
diff --git a/test/fixedbugs/issue6703o.go b/test/fixedbugs/issue6703o.go
index e87e5ecec4..a11fdfd858 100644
--- a/test/fixedbugs/issue6703o.go
+++ b/test/fixedbugs/issue6703o.go
@@ -19,5 +19,5 @@ type E struct{ T }
 
 var (
 	e E
-	x = e.m // ERROR "initialization loop|depends upon itself"
+	x = e.m // ERROR "initialization loop|depends upon itself" 
 )
diff --git a/test/fixedbugs/issue6703p.go b/test/fixedbugs/issue6703p.go
index 79c6a5f41c..3ac7a63de8 100644
--- a/test/fixedbugs/issue6703p.go
+++ b/test/fixedbugs/issue6703p.go
@@ -19,5 +19,5 @@ type E struct{ T }
 
 var (
 	e E
-	x = e.m() // ERROR "initialization loop|depends upon itself"
+	x = e.m() // ERROR "initialization loop|depends upon itself" 
 )
diff --git a/test/fixedbugs/issue6703q.go b/test/fixedbugs/issue6703q.go
index 743a6ae3df..b087c15d37 100644
--- a/test/fixedbugs/issue6703q.go
+++ b/test/fixedbugs/issue6703q.go
@@ -24,5 +24,5 @@ type E struct{ T }
 
 var (
 	e E
-	x = g().m // ERROR "initialization loop|depends upon itself"
+	x = g().m // ERROR "initialization loop|depends upon itself" 
 )
diff --git a/test/fixedbugs/issue6703r.go b/test/fixedbugs/issue6703r.go
index a22f9a2122..de514f1802 100644
--- a/test/fixedbugs/issue6703r.go
+++ b/test/fixedbugs/issue6703r.go
@@ -24,5 +24,5 @@ type E struct{ T }
 
 var (
 	e E
-	x = g().m() // ERROR "initialization loop|depends upon itself"
+	x = g().m() // ERROR "initialization loop|depends upon itself" 
 )
diff --git a/test/fixedbugs/issue6703y.go b/test/fixedbugs/issue6703y.go
index f679933f8e..278dfcdb5e 100644
--- a/test/fixedbugs/issue6703y.go
+++ b/test/fixedbugs/issue6703y.go
@@ -20,4 +20,4 @@ func pf() *T {
 	return nil
 }
 
-var x = pf().pm // ERROR "initialization loop|depends upon itself"
+var x = pf().pm // ERROR "initialization loop|depends upon itself" 
diff --git a/test/fixedbugs/issue6703z.go b/test/fixedbugs/issue6703z.go
index 658d05a2af..f81a3a8c34 100644
--- a/test/fixedbugs/issue6703z.go
+++ b/test/fixedbugs/issue6703z.go
@@ -20,4 +20,4 @@ func pf() *T {
 	return nil
 }
 
-var x = pf().pm() // ERROR "initialization loop|depends upon itself"
+var x = pf().pm() // ERROR "initialization loop|depends upon itself" 
diff --git a/test/fixedbugs/issue6789.dir/a.go b/test/fixedbugs/issue6789.dir/a.go
index 9e076fec71..9c90e0740c 100644
--- a/test/fixedbugs/issue6789.dir/a.go
+++ b/test/fixedbugs/issue6789.dir/a.go
@@ -5,10 +5,10 @@
 package a
 
 type unexported struct {
-	a int
-	b bool
+        a int
+        b bool
 }
 
 type Struct struct {
-	unexported
+        unexported
 }
diff --git a/test/fixedbugs/issue6847.go b/test/fixedbugs/issue6847.go
index 58ebb636f4..da300bcd01 100644
--- a/test/fixedbugs/issue6847.go
+++ b/test/fixedbugs/issue6847.go
@@ -56,7 +56,7 @@ func F() {
 	case cs, ok = <-cc:
 	case c = <-cc:
 	}
-	// Interfaces.
+      // Interfaces.
 	var (
 		c1 chan I1
 		c2 chan I2
diff --git a/test/fixedbugs/issue7223.go b/test/fixedbugs/issue7223.go
index e03d6f703d..0ec3476403 100644
--- a/test/fixedbugs/issue7223.go
+++ b/test/fixedbugs/issue7223.go
@@ -7,15 +7,14 @@
 package main
 
 var bits1 uint = 10
-
 const bits2 uint = 10
 
 func main() {
 	_ = make([]byte, 1<<bits1)
 	_ = make([]byte, 1<<bits2)
-	_ = make([]byte, nil)    // ERROR "non-integer.*len"
+	_ = make([]byte, nil) // ERROR "non-integer.*len"
 	_ = make([]byte, nil, 2) // ERROR "non-integer.*len"
 	_ = make([]byte, 1, nil) // ERROR "non-integer.*cap"
-	_ = make([]byte, true)   // ERROR "non-integer.*len"
-	_ = make([]byte, "abc")  // ERROR "non-integer.*len"
+	_ = make([]byte, true) // ERROR "non-integer.*len"
+	_ = make([]byte, "abc") // ERROR "non-integer.*len"
 }
diff --git a/test/fixedbugs/issue7310.go b/test/fixedbugs/issue7310.go
index 4183b0b4eb..1169fcfbf0 100644
--- a/test/fixedbugs/issue7310.go
+++ b/test/fixedbugs/issue7310.go
@@ -11,5 +11,5 @@ package main
 func main() {
 	_ = copy(nil, []int{}) // ERROR "use of untyped nil"
 	_ = copy([]int{}, nil) // ERROR "use of untyped nil"
-	_ = 1 + true           // ERROR "cannot convert true" "mismatched types int and bool"
+	_ = 1+true // ERROR "cannot convert true" "mismatched types int and bool"
 }
diff --git a/test/fixedbugs/issue7550.go b/test/fixedbugs/issue7550.go
index 794b95fcba..0c4cf93079 100644
--- a/test/fixedbugs/issue7550.go
+++ b/test/fixedbugs/issue7550.go
@@ -7,19 +7,19 @@
 package main
 
 func shouldPanic(f func()) {
-	defer func() {
-		if recover() == nil {
-			panic("not panicking")
-		}
-	}()
-	f()
+        defer func() {
+                if recover() == nil {
+                        panic("not panicking")
+                }
+        }()
+        f()
 }
 
 func f() {
-	length := int(^uint(0) >> 1)
-	a := make([]struct{}, length)
-	b := make([]struct{}, length)
-	_ = append(a, b...)
+        length := int(^uint(0) >> 1)
+        a := make([]struct{}, length)
+        b := make([]struct{}, length)
+        _ = append(a, b...)
 }
 
 func main() {
diff --git a/test/fixedbugs/issue7590.go b/test/fixedbugs/issue7590.go
index e67e393dfb..607a3ae606 100644
--- a/test/fixedbugs/issue7590.go
+++ b/test/fixedbugs/issue7590.go
@@ -13,7 +13,7 @@ type S struct {
 }
 
 var M = map[string]S{
-	"a": {F: 1},
+	"a": { F: 1 },
 }
 
 var P = M["a"]
diff --git a/test/fixedbugs/issue7648.dir/a.go b/test/fixedbugs/issue7648.dir/a.go
index 9139dc279f..c76aaa675f 100644
--- a/test/fixedbugs/issue7648.dir/a.go
+++ b/test/fixedbugs/issue7648.dir/a.go
@@ -6,5 +6,6 @@ package a
 
 const (
 	sinPi4 = 0.70710678118654752440084436210484903928483593768847
-	A      = complex(sinPi4, -sinPi4)
+	A = complex(sinPi4, -sinPi4)
 )
+
diff --git a/test/fixedbugs/issue7760.go b/test/fixedbugs/issue7760.go
index cf99ac1cc9..cccae48910 100644
--- a/test/fixedbugs/issue7760.go
+++ b/test/fixedbugs/issue7760.go
@@ -13,13 +13,13 @@ import "unsafe"
 type myPointer unsafe.Pointer
 
 const _ = unsafe.Pointer(uintptr(1)) // ERROR "is not (a )?constant"
-const _ = myPointer(uintptr(1))      // ERROR "is not (a )?constant"
+const _ = myPointer(uintptr(1)) // ERROR "is not (a )?constant"
 
 const _ = (*int)(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant"
-const _ = (*int)(myPointer(uintptr(1)))      // ERROR "is not (a )?constant"
+const _ = (*int)(myPointer(uintptr(1))) // ERROR "is not (a )?constant"
 
 const _ = uintptr(unsafe.Pointer(uintptr(1))) // ERROR "is not (a )?constant"
-const _ = uintptr(myPointer(uintptr(1)))      // ERROR "is not (a )?constant"
+const _ = uintptr(myPointer(uintptr(1))) // ERROR "is not (a )?constant"
 
 const _ = []byte("") // ERROR "is not (a )?constant"
 const _ = []rune("") // ERROR "is not (a )?constant"
diff --git a/test/fixedbugs/issue7921.go b/test/fixedbugs/issue7921.go
index 2eb6d4ecd0..e19b113062 100644
--- a/test/fixedbugs/issue7921.go
+++ b/test/fixedbugs/issue7921.go
@@ -41,7 +41,7 @@ func bufferNoEscape3(xs []string) string { // ERROR "bufferNoEscape3 xs does not
 
 func bufferNoEscape4() []byte {
 	var b bytes.Buffer
-	b.Grow(64) // ERROR "bufferNoEscape4 ignoring self-assignment in bytes.b.buf = bytes.b.buf\[:bytes.m·3\]$" "inlining call to bytes.\(\*Buffer\).Grow$"
+	b.Grow(64)       // ERROR "bufferNoEscape4 ignoring self-assignment in bytes.b.buf = bytes.b.buf\[:bytes.m·3\]$" "inlining call to bytes.\(\*Buffer\).Grow$"
 	useBuffer(&b)
 	return b.Bytes() // ERROR "inlining call to bytes.\(\*Buffer\).Bytes$"
 }
diff --git a/test/fixedbugs/issue8155.go b/test/fixedbugs/issue8155.go
index 5450d04bc8..56a6738920 100644
--- a/test/fixedbugs/issue8155.go
+++ b/test/fixedbugs/issue8155.go
@@ -36,7 +36,7 @@ func poison() uintptr {
 	var x [20]uintptr
 	var s uintptr
 	for i := range x {
-		x[i] = uintptr(i + 1)
+		x[i] = uintptr(i+1)
 		s += x[i]
 	}
 	return s
diff --git a/test/fixedbugs/issue8961.go b/test/fixedbugs/issue8961.go
index 144bbb2cf7..22b0f0410a 100644
--- a/test/fixedbugs/issue8961.go
+++ b/test/fixedbugs/issue8961.go
@@ -7,8 +7,7 @@
 // Issue 8961. Empty composite literals to small globals were not filled in
 package main
 
-type small struct{ a int }
-
+type small struct { a int }
 var foo small
 
 func main() {
diff --git a/test/fixedbugs/issue9076.go b/test/fixedbugs/issue9076.go
index dd2a474148..8daf12fee8 100644
--- a/test/fixedbugs/issue9076.go
+++ b/test/fixedbugs/issue9076.go
@@ -11,6 +11,5 @@ package main
 import "unsafe"
 
 const Hundred = 100
-
-var _ int32 = 100/unsafe.Sizeof(int(0)) + 1     // GC_ERROR "100 \/ unsafe.Sizeof\(int\(0\)\) \+ 1"
+var _ int32 = 100/unsafe.Sizeof(int(0)) + 1 // GC_ERROR "100 \/ unsafe.Sizeof\(int\(0\)\) \+ 1"
 var _ int32 = Hundred/unsafe.Sizeof(int(0)) + 1 // GC_ERROR "Hundred \/ unsafe.Sizeof\(int\(0\)\) \+ 1"
diff --git a/test/fixedbugs/issue9083.go b/test/fixedbugs/issue9083.go
index ea53e7a69a..8fbd78be7a 100644
--- a/test/fixedbugs/issue9083.go
+++ b/test/fixedbugs/issue9083.go
@@ -13,10 +13,10 @@ const zero = 0
 
 func main() {
 	var x int
-	x = make(map[int]int)       // ERROR "cannot use make\(map\[int\]int\)|incompatible"
-	x = make(map[int]int, 0)    // ERROR "cannot use make\(map\[int\]int, 0\)|incompatible"
+	x = make(map[int]int) // ERROR "cannot use make\(map\[int\]int\)|incompatible"
+	x = make(map[int]int, 0) // ERROR "cannot use make\(map\[int\]int, 0\)|incompatible"
 	x = make(map[int]int, zero) // ERROR "cannot use make\(map\[int\]int, zero\)|incompatible"
-	x = make(chan int)          // ERROR "cannot use make\(chan int\)|incompatible"
-	x = make(chan int, 0)       // ERROR "cannot use make\(chan int, 0\)|incompatible"
-	x = make(chan int, zero)    // ERROR "cannot use make\(chan int, zero\)|incompatible"
+	x = make(chan int) // ERROR "cannot use make\(chan int\)|incompatible"
+	x = make(chan int, 0) // ERROR "cannot use make\(chan int, 0\)|incompatible"
+	x = make(chan int, zero) // ERROR "cannot use make\(chan int, zero\)|incompatible"
 }
diff --git a/test/fixedbugs/issue9537.dir/b.go b/test/fixedbugs/issue9537.dir/b.go
index c8dce22c14..52e64c81f1 100644
--- a/test/fixedbugs/issue9537.dir/b.go
+++ b/test/fixedbugs/issue9537.dir/b.go
@@ -15,8 +15,8 @@ type X struct {
 }
 
 type Intf interface {
-	Get() []byte
-	RetPtr(int) *int
+	Get()        []byte
+	RetPtr(int)  *int
 	RetRPtr(int) (int, *int)
 }
 
diff --git a/test/fixedbugs/issue9634.go b/test/fixedbugs/issue9634.go
index cc3e7484eb..2d5aae4a30 100644
--- a/test/fixedbugs/issue9634.go
+++ b/test/fixedbugs/issue9634.go
@@ -10,7 +10,7 @@
 package main
 
 func main() {
-	s := struct {
+	s := struct{
 		t []int
 		u int
 	}{}
diff --git a/test/float_lit.go b/test/float_lit.go
index f78c933f99..4efae2362d 100644
--- a/test/float_lit.go
+++ b/test/float_lit.go
@@ -77,8 +77,8 @@ func main() {
 		print("-210.012 is ", -210.012, "\n")
 	}
 
-	if !close(0e+1, 0, 1, 0) {
-		print("0E+1 is ", 0e+1, "\n")
+	if !close(0E+1, 0, 1, 0) {
+		print("0E+1 is ", 0E+1, "\n")
 	}
 	if !close(+10e2, 10, 1, 2) {
 		print("+10e2 is ", +10e2, "\n")
@@ -87,8 +87,8 @@ func main() {
 		print("-210e3 is ", -210e3, "\n")
 	}
 
-	if !close(0e-1, 0, 1, 0) {
-		print("0E-1 is ", 0e-1, "\n")
+	if !close(0E-1, 0, 1, 0) {
+		print("0E-1 is ", 0E-1, "\n")
 	}
 	if !close(+0e23, 0, 1, 1) {
 		print("+0e23 is ", +0e23, "\n")
@@ -97,8 +97,8 @@ func main() {
 		print("-0e345 is ", -0e345, "\n")
 	}
 
-	if !close(0e1, 0, 1, 1) {
-		print("0E1 is ", 0e1, "\n")
+	if !close(0E1, 0, 1, 1) {
+		print("0E1 is ", 0E1, "\n")
 	}
 	if !close(+10e23, 10, 1, 23) {
 		print("+10e23 is ", +10e23, "\n")
@@ -107,8 +107,8 @@ func main() {
 		print("-210e34 is ", -210e34, "\n")
 	}
 
-	if !close(0.e1, 0, 1, 1) {
-		print("0.E1 is ", 0.e1, "\n")
+	if !close(0.E1, 0, 1, 1) {
+		print("0.E1 is ", 0.E1, "\n")
 	}
 	if !close(+10.e+2, 10, 1, 2) {
 		print("+10.e+2 is ", +10.e+2, "\n")
@@ -117,8 +117,8 @@ func main() {
 		print("-210.e-3 is ", -210.e-3, "\n")
 	}
 
-	if !close(.0e1, 0, 1, 1) {
-		print(".0E1 is ", .0e1, "\n")
+	if !close(.0E1, 0, 1, 1) {
+		print(".0E1 is ", .0E1, "\n")
 	}
 	if !close(+.01e2, 1, 100, 2) {
 		print("+.01e2 is ", +.01e2, "\n")
@@ -127,8 +127,8 @@ func main() {
 		print("-.012e3 is ", -.012e3, "\n")
 	}
 
-	if !close(0.0e1, 0, 1, 0) {
-		print("0.0E1 is ", 0.0e1, "\n")
+	if !close(0.0E1, 0, 1, 0) {
+		print("0.0E1 is ", 0.0E1, "\n")
 	}
 	if !close(+10.01e2, 1001, 100, 2) {
 		print("+10.01e2 is ", +10.01e2, "\n")
@@ -137,8 +137,8 @@ func main() {
 		print("-210.012e3 is ", -210.012e3, "\n")
 	}
 
-	if !close(0.e+12, 0, 1, 0) {
-		print("0.E+12 is ", 0.e+12, "\n")
+	if !close(0.E+12, 0, 1, 0) {
+		print("0.E+12 is ", 0.E+12, "\n")
 	}
 	if !close(+10.e23, 10, 1, 23) {
 		print("+10.e23 is ", +10.e23, "\n")
@@ -147,8 +147,8 @@ func main() {
 		print("-210.e33 is ", -210.e33, "\n")
 	}
 
-	if !close(.0e-12, 0, 1, 0) {
-		print(".0E-12 is ", .0e-12, "\n")
+	if !close(.0E-12, 0, 1, 0) {
+		print(".0E-12 is ", .0E-12, "\n")
 	}
 	if !close(+.01e23, 1, 100, 23) {
 		print("+.01e23 is ", +.01e23, "\n")
@@ -157,8 +157,8 @@ func main() {
 		print("-.012e34 is ", -.012e34, "\n")
 	}
 
-	if !close(0.0e12, 0, 1, 12) {
-		print("0.0E12 is ", 0.0e12, "\n")
+	if !close(0.0E12, 0, 1, 12) {
+		print("0.0E12 is ", 0.0E12, "\n")
 	}
 	if !close(+10.01e23, 1001, 100, 23) {
 		print("+10.01e23 is ", +10.01e23, "\n")
@@ -167,8 +167,8 @@ func main() {
 		print("-210.012e33 is ", -210.012e33, "\n")
 	}
 
-	if !close(0.e123, 0, 1, 123) {
-		print("0.E123 is ", 0.e123, "\n")
+	if !close(0.E123, 0, 1, 123) {
+		print("0.E123 is ", 0.E123, "\n")
 	}
 	if !close(+10.e+23, 10, 1, 23) {
 		print("+10.e+234 is ", +10.e+234, "\n")
@@ -177,8 +177,8 @@ func main() {
 		print("-210.e-35 is ", -210.e-35, "\n")
 	}
 
-	if !close(.0e123, 0, 1, 123) {
-		print(".0E123 is ", .0e123, "\n")
+	if !close(.0E123, 0, 1, 123) {
+		print(".0E123 is ", .0E123, "\n")
 	}
 	if !close(+.01e29, 1, 100, 29) {
 		print("+.01e29 is ", +.01e29, "\n")
@@ -187,8 +187,8 @@ func main() {
 		print("-.012e29 is ", -.012e29, "\n")
 	}
 
-	if !close(0.0e123, 0, 1, 123) {
-		print("0.0E123 is ", 0.0e123, "\n")
+	if !close(0.0E123, 0, 1, 123) {
+		print("0.0E123 is ", 0.0E123, "\n")
 	}
 	if !close(+10.01e31, 1001, 100, 31) {
 		print("+10.01e31 is ", +10.01e31, "\n")
diff --git a/test/for.go b/test/for.go
index 14d516bf71..8a50090657 100644
--- a/test/for.go
+++ b/test/for.go
@@ -44,11 +44,11 @@ func main() {
 	for sum < 100 {
 		sum = sum + 9
 	}
-	assertequal(sum, 99+9, "only one")
+	assertequal(sum, 99 + 9, "only one")
 
 	sum = 0
 	for i := 0; i <= 10; i++ {
-		if i%2 == 0 {
+		if i % 2 == 0 {
 			continue
 		}
 		sum = sum + i
diff --git a/test/func.go b/test/func.go
index 9a31b4f300..246cb56fd9 100644
--- a/test/func.go
+++ b/test/func.go
@@ -41,6 +41,7 @@ func f7(a int) (x int, y float32) {
 	return 7, 7.0
 }
 
+
 func f8(a int) (x int, y float32) {
 	return 8, 8.0
 }
@@ -53,12 +54,14 @@ func (t *T) m10(a int, b float32) int {
 	return (t.x + a) * (t.y + int(b))
 }
 
+
 func f9(a int) (i int, f float32) {
 	i = 9
 	f = 9.0
 	return
 }
 
+
 func main() {
 	f1()
 	f2(1)
diff --git a/test/func1.go b/test/func1.go
index 8ab4b70989..fb6f56184f 100644
--- a/test/func1.go
+++ b/test/func1.go
@@ -13,6 +13,7 @@ func f1(a int) (int, float32) {
 	return 7, 7.0
 }
 
+
 func f2(a int) (a int, b float32) { // ERROR "duplicate argument a|definition"
 	return 8, 8.0
 }
diff --git a/test/func4.go b/test/func4.go
index 53e69cf0a9..85f1e4b81e 100644
--- a/test/func4.go
+++ b/test/func4.go
@@ -12,7 +12,7 @@ package main
 var notmain func()
 
 func main() {
-	var x = &main  // ERROR "address of|invalid"
-	main = notmain // ERROR "assign to|invalid"
+	var x = &main		// ERROR "address of|invalid"
+	main = notmain	// ERROR "assign to|invalid"
 	_ = x
 }
diff --git a/test/func5.go b/test/func5.go
index 367b683e30..2e058be7e6 100644
--- a/test/func5.go
+++ b/test/func5.go
@@ -39,7 +39,7 @@ func fn() func(int, int) int {
 var fc func(int, int, chan int)
 
 func addc(x, y int, c chan int) {
-	c <- x + y
+	c <- x+y
 }
 
 func fnc() func(int, int, chan int) {
@@ -79,7 +79,7 @@ func main() {
 	three(<-c)
 	go fnc()(1, 2, c)
 	three(<-c)
-	go func(a, b int, c chan int) { c <- a + b }(1, 2, c)
+	go func(a, b int, c chan int) { c <- a+b }(1, 2, c)
 	three(<-c)
 
 	emptyresults()
diff --git a/test/func6.go b/test/func6.go
index 9b2a10846a..5b2f9f273e 100644
--- a/test/func6.go
+++ b/test/func6.go
@@ -9,10 +9,8 @@
 package main
 
 func main() {
-	if func() bool { return true }() {
-	} // gc used to say this was a syntax error
-	if (func() bool { return true })() {
-	}
-	if func() bool { return true }() {
-	}
+	if func() bool { return true }() {}  // gc used to say this was a syntax error
+	if (func() bool { return true })() {}
+	if (func() bool { return true }()) {}
 }
+
diff --git a/test/funcdup.go b/test/funcdup.go
index 468f255b86..7b05d12606 100644
--- a/test/funcdup.go
+++ b/test/funcdup.go
@@ -8,20 +8,20 @@ package p
 
 type T interface {
 	F1(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-	F2(i, i int)      // ERROR "duplicate argument i|redefinition|previous"
-	F3() (i, i int)   // ERROR "duplicate argument i|redefinition|previous"
+	F2(i, i int) // ERROR "duplicate argument i|redefinition|previous"
+	F3() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
 }
 
-type T1 func(i, i int)      // ERROR "duplicate argument i|redefinition|previous"
+type T1 func(i, i int) // ERROR "duplicate argument i|redefinition|previous"
 type T2 func(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-type T3 func() (i, i int)   // ERROR "duplicate argument i|redefinition|previous"
+type T3 func() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
 
 type R struct{}
 
-func (i *R) F1(i int)         {}           // ERROR "duplicate argument i|redefinition|previous"
-func (i *R) F2() (i int)      { return 0 } // ERROR "duplicate argument i|redefinition|previous"
-func (i *R) F3(j int) (j int) { return 0 } // ERROR "duplicate argument j|redefinition|previous"
+func (i *R) F1(i int)         {} // ERROR "duplicate argument i|redefinition|previous"
+func (i *R) F2() (i int)      {return 0} // ERROR "duplicate argument i|redefinition|previous"
+func (i *R) F3(j int) (j int) {return 0} // ERROR "duplicate argument j|redefinition|previous"
 
-func F1(i, i int)      {}              // ERROR "duplicate argument i|redefinition|previous"
-func F2(i int) (i int) { return 0 }    // ERROR "duplicate argument i|redefinition|previous"
-func F3() (i, i int)   { return 0, 0 } // ERROR "duplicate argument i|redefinition|previous"
+func F1(i, i int)      {} // ERROR "duplicate argument i|redefinition|previous"
+func F2(i int) (i int) {return 0} // ERROR "duplicate argument i|redefinition|previous"
+func F3() (i, i int)   {return 0, 0} // ERROR "duplicate argument i|redefinition|previous"
diff --git a/test/funcdup2.go b/test/funcdup2.go
index fde2c9604f..9513ef46bd 100644
--- a/test/funcdup2.go
+++ b/test/funcdup2.go
@@ -8,10 +8,10 @@ package p
 
 var T interface {
 	F1(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-	F2(i, i int)      // ERROR "duplicate argument i|redefinition|previous"
-	F3() (i, i int)   // ERROR "duplicate argument i|redefinition|previous"
+	F2(i, i int) // ERROR "duplicate argument i|redefinition|previous"
+	F3() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
 }
 
-var T1 func(i, i int)      // ERROR "duplicate argument i|redefinition|previous"
+var T1 func(i, i int) // ERROR "duplicate argument i|redefinition|previous"
 var T2 func(i int) (i int) // ERROR "duplicate argument i|redefinition|previous"
-var T3 func() (i, i int)   // ERROR "duplicate argument i|redefinition|previous"
+var T3 func() (i, i int) // ERROR "duplicate argument i|redefinition|previous"
diff --git a/test/gcstring.go b/test/gcstring.go
index 4b2499a604..7633d5da55 100644
--- a/test/gcstring.go
+++ b/test/gcstring.go
@@ -25,16 +25,16 @@ func main() {
 	setup()
 	runtime.GC()
 	runtime.GC()
-	time.Sleep(10 * time.Millisecond)
+	time.Sleep(10*time.Millisecond)
 	runtime.GC()
 	runtime.GC()
-	time.Sleep(10 * time.Millisecond)
+	time.Sleep(10*time.Millisecond)
 }
 
 func setup() {
 	var Ts []interface{}
 	buf := make([]byte, 128)
-
+	
 	for i := 0; i < 10000; i++ {
 		s := string(buf)
 		t := &T{ptr: new(*int)}
@@ -42,6 +42,7 @@ func setup() {
 		Ts = append(Ts, t)
 		things = append(things, s[len(s):])
 	}
-
+	
 	things = append(things, Ts...)
 }
+
diff --git a/test/goprint.go b/test/goprint.go
index 84dc28e51c..57eeac53a8 100644
--- a/test/goprint.go
+++ b/test/goprint.go
@@ -16,6 +16,6 @@ import (
 func main() {
 	go println(42, true, false, true, 1.5, "world", (chan int)(nil), []int(nil), (map[string]int)(nil), (func())(nil), byte(255))
 	for runtime.NumGoroutine() > 1 {
-		time.Sleep(10 * time.Millisecond)
+		time.Sleep(10*time.Millisecond)
 	}
 }
diff --git a/test/import1.go b/test/import1.go
index 19e766fd6f..2433b5f2ad 100644
--- a/test/import1.go
+++ b/test/import1.go
@@ -9,11 +9,11 @@
 
 package main
 
-import "bufio"    // GCCGO_ERROR "previous|not used"
-import bufio "os" // ERROR "redeclared|redefinition|incompatible" "imported and not used"
+import "bufio"	// GCCGO_ERROR "previous|not used"
+import bufio "os"	// ERROR "redeclared|redefinition|incompatible" "imported and not used"
 
 import (
-	"fmt"      // GCCGO_ERROR "previous|not used"
-	. "math"   // GC_ERROR "imported and not used: \x22math\x22$"
-	fmt "math" // ERROR "redeclared|redefinition|incompatible" "imported and not used: \x22math\x22 as fmt"
+	"fmt"	// GCCGO_ERROR "previous|not used"
+	fmt "math"	// ERROR "redeclared|redefinition|incompatible" "imported and not used: \x22math\x22 as fmt"
+	. "math"	// GC_ERROR "imported and not used: \x22math\x22$"
 )
diff --git a/test/import2.dir/import2.go b/test/import2.dir/import2.go
index aaaa7336e1..9c54a1b87e 100644
--- a/test/import2.dir/import2.go
+++ b/test/import2.dir/import2.go
@@ -6,38 +6,37 @@
 
 package p
 
-var C1 chan<- chan int = (chan<- (chan int))(nil)
-var C2 chan (<-chan int) = (chan (<-chan int))(nil)
-var C3 <-chan chan int = (<-chan (chan int))(nil)
-var C4 chan chan<- int = (chan (chan<- int))(nil)
-
-var C5 <-chan <-chan int = (<-chan (<-chan int))(nil)
-var C6 chan<- <-chan int = (chan<- (<-chan int))(nil)
-var C7 chan<- chan<- int = (chan<- (chan<- int))(nil)
-
-var C8 <-chan <-chan chan int = (<-chan (<-chan (chan int)))(nil)
-var C9 <-chan chan<- chan int = (<-chan (chan<- (chan int)))(nil)
-var C10 chan<- <-chan chan int = (chan<- (<-chan (chan int)))(nil)
-var C11 chan<- chan<- chan int = (chan<- (chan<- (chan int)))(nil)
-var C12 chan chan<- <-chan int = (chan (chan<- (<-chan int)))(nil)
-var C13 chan chan<- chan<- int = (chan (chan<- (chan<- int)))(nil)
-
-var R1 chan<- (chan int) = (chan<- chan int)(nil)
-var R3 <-chan (chan int) = (<-chan chan int)(nil)
-var R4 chan (chan<- int) = (chan chan<- int)(nil)
-
-var R5 <-chan (<-chan int) = (<-chan <-chan int)(nil)
-var R6 chan<- (<-chan int) = (chan<- <-chan int)(nil)
-var R7 chan<- (chan<- int) = (chan<- chan<- int)(nil)
-
-var R8 <-chan (<-chan (chan int)) = (<-chan <-chan chan int)(nil)
-var R9 <-chan (chan<- (chan int)) = (<-chan chan<- chan int)(nil)
-var R10 chan<- (<-chan (chan int)) = (chan<- <-chan chan int)(nil)
-var R11 chan<- (chan<- (chan int)) = (chan<- chan<- chan int)(nil)
-var R12 chan (chan<- (<-chan int)) = (chan chan<- <-chan int)(nil)
-var R13 chan (chan<- (chan<- int)) = (chan chan<- chan<- int)(nil)
+var C1 chan <- chan int = (chan<- (chan int))(nil)
+var C2 chan (<- chan int) = (chan (<-chan int))(nil)
+var C3 <- chan chan int = (<-chan (chan int))(nil)
+var C4 chan chan <- int = (chan (chan<- int))(nil)
+
+var C5 <- chan <- chan int = (<-chan (<-chan int))(nil)
+var C6 chan <- <- chan int = (chan<- (<-chan int))(nil)
+var C7 chan <- chan <- int = (chan<- (chan<- int))(nil)
+
+var C8 <- chan <- chan chan int = (<-chan (<-chan (chan int)))(nil)
+var C9 <- chan chan <- chan int = (<-chan (chan<- (chan int)))(nil)
+var C10 chan <- <- chan chan int = (chan<- (<-chan (chan int)))(nil)
+var C11 chan <- chan <- chan int = (chan<- (chan<- (chan int)))(nil)
+var C12 chan chan <- <- chan int = (chan (chan<- (<-chan int)))(nil)
+var C13 chan chan <- chan <- int = (chan (chan<- (chan<- int)))(nil)
+
+var R1 chan<- (chan int) = (chan <- chan int)(nil)
+var R3 <-chan (chan int) = (<- chan chan int)(nil)
+var R4 chan (chan<- int) = (chan chan <- int)(nil)
+
+var R5 <-chan (<-chan int) = (<- chan <- chan int)(nil)
+var R6 chan<- (<-chan int) = (chan <- <- chan int)(nil)
+var R7 chan<- (chan<- int) = (chan <- chan <- int)(nil)
+
+var R8 <-chan (<-chan (chan int)) = (<- chan <- chan chan int)(nil)
+var R9 <-chan (chan<- (chan int)) = (<- chan chan <- chan int)(nil)
+var R10 chan<- (<-chan (chan int)) = (chan <- <- chan chan int)(nil)
+var R11 chan<- (chan<- (chan int)) = (chan <- chan <- chan int)(nil)
+var R12 chan (chan<- (<-chan int)) = (chan chan <- <- chan int)(nil)
+var R13 chan (chan<- (chan<- int)) = (chan chan <- chan <- int)(nil)
 
 var F1 func() func() int
-
 func F2() func() func() int
 func F3(func() func() int)
diff --git a/test/import2.dir/import3.go b/test/import2.dir/import3.go
index 461251d489..3bf9cb0c3c 100644
--- a/test/import2.dir/import3.go
+++ b/test/import2.dir/import3.go
@@ -33,19 +33,20 @@ func main() {
 	p.C12 = (chan (chan<- (<-chan int)))(nil)
 	p.C13 = (chan (chan<- (chan<- int)))(nil)
 
-	p.R1 = (chan<- chan int)(nil)
-	p.R3 = (<-chan chan int)(nil)
-	p.R4 = (chan chan<- int)(nil)
+	p.R1 = (chan <- chan int)(nil)
+	p.R3 = (<- chan chan int)(nil)
+	p.R4 = (chan chan <- int)(nil)
 
-	p.R5 = (<-chan <-chan int)(nil)
-	p.R6 = (chan<- <-chan int)(nil)
-	p.R7 = (chan<- chan<- int)(nil)
+	p.R5 = (<- chan <- chan int)(nil)
+	p.R6 = (chan <- <- chan int)(nil)
+	p.R7 = (chan <- chan <- int)(nil)
 
-	p.R8 = (<-chan <-chan chan int)(nil)
-	p.R9 = (<-chan chan<- chan int)(nil)
-	p.R10 = (chan<- <-chan chan int)(nil)
-	p.R11 = (chan<- chan<- chan int)(nil)
-	p.R12 = (chan chan<- <-chan int)(nil)
-	p.R13 = (chan chan<- chan<- int)(nil)
+	p.R8 = (<- chan <- chan chan int)(nil)
+	p.R9 = (<- chan chan <- chan int)(nil)
+	p.R10 = (chan <- <- chan chan int)(nil)
+	p.R11 = (chan <- chan <- chan int)(nil)
+	p.R12 = (chan chan <- <- chan int)(nil)
+	p.R13 = (chan chan <- chan <- int)(nil)
 
 }
+
diff --git a/test/import4.dir/empty.go b/test/import4.dir/empty.go
index 398c260d0f..1dffa170df 100644
--- a/test/import4.dir/empty.go
+++ b/test/import4.dir/empty.go
@@ -4,10 +4,7 @@
 
 package empty
 
-import ()
-
-const ()
-
-var ()
-
-type ()
+import ( )
+const ( )
+var ( )
+type ( )
diff --git a/test/import4.dir/import4.go b/test/import4.dir/import4.go
index f174b70be4..b9f973f172 100644
--- a/test/import4.dir/import4.go
+++ b/test/import4.dir/import4.go
@@ -9,15 +9,16 @@
 package main
 
 // standard
-import "fmt" // ERROR "imported and not used.*fmt"
+import "fmt"	// ERROR "imported and not used.*fmt"
 
 // renamed
-import X "math" // ERROR "imported and not used.*math"
+import X "math"	// ERROR "imported and not used.*math"
 
 // import dot
-import . "bufio" // ERROR "imported and not used.*bufio"
+import . "bufio"	// ERROR "imported and not used.*bufio"
 
 // again, package without anything in it
-import "./empty"   // ERROR "imported and not used.*empty"
-import Z "./empty" // ERROR "imported and not used.*empty"
-import . "./empty" // ERROR "imported and not used.*empty"
+import "./empty"	// ERROR "imported and not used.*empty"
+import Z "./empty"	// ERROR "imported and not used.*empty"
+import . "./empty"	// ERROR "imported and not used.*empty"
+
diff --git a/test/indirect1.go b/test/indirect1.go
index 1395eacaf8..51da4cc7c4 100644
--- a/test/indirect1.go
+++ b/test/indirect1.go
@@ -37,36 +37,36 @@ func f() {
 	// line number for each len call when
 	// it decides there are type errors.
 	x :=
-		len(m0) +
-			len(m1) + // ERROR "illegal|invalid|must be"
-			len(m2) + // ERROR "illegal|invalid|must be"
-			len(m3) +
-			len(m4) + // ERROR "illegal|invalid|must be"
+		len(m0)+
+		len(m1)+	// ERROR "illegal|invalid|must be"
+		len(m2)+	// ERROR "illegal|invalid|must be"
+		len(m3)+
+		len(m4)+	// ERROR "illegal|invalid|must be"
 
-			len(s0) +
-			len(s1) + // ERROR "illegal|invalid|must be"
-			len(s2) + // ERROR "illegal|invalid|must be"
-			len(s3) +
-			len(s4) + // ERROR "illegal|invalid|must be"
+		len(s0)+
+		len(s1)+	// ERROR "illegal|invalid|must be"
+		len(s2)+	// ERROR "illegal|invalid|must be"
+		len(s3)+
+		len(s4)+	// ERROR "illegal|invalid|must be"
 
-			len(a0) +
-			len(a1) +
-			len(a2) +
+		len(a0)+
+		len(a1)+
+		len(a2)+
 
-			cap(a0) +
-			cap(a1) +
-			cap(a2) +
+		cap(a0)+
+		cap(a1)+
+		cap(a2)+
 
-			len(b0) +
-			len(b1) + // ERROR "illegal|invalid|must be"
-			len(b2) + // ERROR "illegal|invalid|must be"
-			len(b3) +
-			len(b4) + // ERROR "illegal|invalid|must be"
+		len(b0)+
+		len(b1)+	// ERROR "illegal|invalid|must be"
+		len(b2)+	// ERROR "illegal|invalid|must be"
+		len(b3)+
+		len(b4)+	// ERROR "illegal|invalid|must be"
 
-			cap(b0) +
-			cap(b1) + // ERROR "illegal|invalid|must be"
-			cap(b2) + // ERROR "illegal|invalid|must be"
-			cap(b3) +
-			cap(b4) // ERROR "illegal|invalid|must be"
+		cap(b0)+
+		cap(b1)+	// ERROR "illegal|invalid|must be"
+		cap(b2)+	// ERROR "illegal|invalid|must be"
+		cap(b3)+
+		cap(b4)	// ERROR "illegal|invalid|must be"
 	_ = x
 }
diff --git a/test/initcomma.go b/test/initcomma.go
index e6cfffda3a..a54fce4280 100644
--- a/test/initcomma.go
+++ b/test/initcomma.go
@@ -8,10 +8,10 @@
 
 package main
 
-var a = []int{1, 2}
-var b = [5]int{1, 2, 3}
-var c = []int{1}
-var d = [...]int{1, 2, 3}
+var a = []int{1, 2, }
+var b = [5]int{1, 2, 3, }
+var c = []int{1, }
+var d = [...]int{1, 2, 3, }
 
 func main() {
 	if len(a) != 2 {
diff --git a/test/initialize.go b/test/initialize.go
index 0cf7fe2f5c..1307e02096 100644
--- a/test/initialize.go
+++ b/test/initialize.go
@@ -19,35 +19,35 @@ type T struct {
 	S
 }
 
-var a1 = S{0, 0, 0, 1, 2, 3}
-var b1 = S{X: 1, Z: 3, Y: 2}
+var a1 = S { 0, 0, 0, 1, 2, 3 }
+var b1 = S { X: 1, Z: 3, Y: 2 }
 
-var a2 = S{0, 0, 0, 0, 0, 0}
-var b2 = S{}
+var a2 = S { 0, 0, 0, 0, 0, 0, }
+var b2 = S { }
 
-var a3 = T{S{1, 2, 3, 0, 0, 0}}
-var b3 = T{S: S{A: 1, B: 2, C: 3}}
+var a3 = T { S { 1, 2, 3, 0, 0, 0, } }
+var b3 = T { S: S{ A: 1, B: 2, C: 3 } }
 
-var a4 = &[16]byte{0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0}
-var b4 = &[16]byte{4: 1, 1, 1, 1, 12: 1, 1}
+var a4 = &[16]byte { 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, }
+var b4 = &[16]byte { 4: 1, 1, 1, 1, 12: 1, 1, }
 
-var a5 = &[16]byte{1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0}
-var b5 = &[16]byte{1, 4: 1, 1, 1, 1, 12: 1, 1}
+var a5 = &[16]byte { 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, }
+var b5 = &[16]byte { 1, 4: 1, 1, 1, 1, 12: 1, 1, }
 
-var a6 = &[16]byte{1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0}
-var b6 = &[...]byte{1, 4: 1, 1, 1, 1, 12: 1, 1, 0, 0}
+var a6 = &[16]byte { 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, }
+var b6 = &[...]byte { 1, 4: 1, 1, 1, 1, 12: 1, 1, 0, 0,}
 
 type Same struct {
 	a, b interface{}
 }
 
-var same = []Same{
-	Same{a1, b1},
-	Same{a2, b2},
-	Same{a3, b3},
-	Same{a4, b4},
-	Same{a5, b5},
-	Same{a6, b6},
+var same = []Same {
+	Same{ a1, b1 },
+	Same{ a2, b2 },
+	Same{ a3, b3 },
+	Same{ a4, b4 },
+	Same{ a5, b5 },
+	Same{ a6, b6 },
 }
 
 func main() {
diff --git a/test/initializerr.go b/test/initializerr.go
index 11f1941629..990ab60f96 100644
--- a/test/initializerr.go
+++ b/test/initializerr.go
@@ -18,24 +18,24 @@ type T struct {
 }
 
 var x = 1
-var a1 = S{0, X: 1}                             // ERROR "mixture|undefined"
-var a2 = S{Y: 3, Z: 2, Y: 3}                    // ERROR "duplicate"
-var a3 = T{S{}, 2, 3, 4, 5, 6}                  // ERROR "convert|too many"
-var a4 = [5]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} // ERROR "index|too many"
-var a5 = []byte{x: 2}                           // ERROR "index"
-var a6 = []byte{1: 1, 2: 2, 1: 3}               // ERROR "duplicate index"
+var a1 = S { 0, X: 1 }	// ERROR "mixture|undefined"
+var a2 = S { Y: 3, Z: 2, Y: 3 } // ERROR "duplicate"
+var a3 = T { S{}, 2, 3, 4, 5, 6 }	// ERROR "convert|too many"
+var a4 = [5]byte{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }	// ERROR "index|too many"
+var a5 = []byte { x: 2 }	// ERROR "index"
+var a6 = []byte{1: 1, 2: 2, 1: 3}	// ERROR "duplicate index"
 
-var ok1 = S{}       // should be ok
-var ok2 = T{S: ok1} // should be ok
+var ok1 = S { }	// should be ok
+var ok2 = T { S: ok1 }	// should be ok
 
 // These keys can be computed at compile time but they are
 // not constants as defined by the spec, so they do not trigger
 // compile-time errors about duplicate key values.
 // See issue 4555.
 
-type Key struct{ X, Y int }
+type Key struct {X, Y int}
 
 var _ = map[Key]string{
-	Key{1, 2}: "hello",
-	Key{1, 2}: "world",
+	Key{1,2}: "hello",
+	Key{1,2}: "world",
 }
diff --git a/test/inline_sync.go b/test/inline_sync.go
index 27913c1ccc..30b436af41 100644
--- a/test/inline_sync.go
+++ b/test/inline_sync.go
@@ -35,18 +35,19 @@ func small6() { // ERROR "can inline small6"
 var once *sync.Once
 
 func small7() { // ERROR "can inline small7"
-	// the Do fast path should be inlined
-	once.Do(small5) // ERROR "inlining call to sync\.\(\*Once\)\.Do"
+        // the Do fast path should be inlined
+        once.Do(small5) // ERROR "inlining call to sync\.\(\*Once\)\.Do"
 }
 
 var rwmutex *sync.RWMutex
 
 func small8() { // ERROR "can inline small8"
-	// the RUnlock fast path should be inlined
-	rwmutex.RUnlock() // ERROR "inlining call to sync\.\(\*RWMutex\)\.RUnlock"
+        // the RUnlock fast path should be inlined
+        rwmutex.RUnlock() // ERROR "inlining call to sync\.\(\*RWMutex\)\.RUnlock"
 }
 
 func small9() { // ERROR "can inline small9"
-	// the RLock fast path should be inlined
-	rwmutex.RLock() // ERROR "inlining call to sync\.\(\*RWMutex\)\.RLock"
+        // the RLock fast path should be inlined
+        rwmutex.RLock() // ERROR "inlining call to sync\.\(\*RWMutex\)\.RLock"
 }
+
diff --git a/test/int_lit.go b/test/int_lit.go
index cb24c6cb16..78deaea130 100644
--- a/test/int_lit.go
+++ b/test/int_lit.go
@@ -11,14 +11,14 @@ package main
 import "os"
 
 func main() {
-	s := 0 +
+	s := 	0 +
 		123 +
 		0123 +
 		0000 +
 		0x0 +
 		0x123 +
-		0x0 +
-		0x123
+		0X0 +
+		0X123
 	if s != 788 {
 		print("s is ", s, "; should be 788\n")
 		os.Exit(1)
diff --git a/test/intcvt.go b/test/intcvt.go
index d9477617ae..3920528a40 100644
--- a/test/intcvt.go
+++ b/test/intcvt.go
@@ -86,7 +86,6 @@ func chku64(i, v uint64) {
 		panic("fail")
 	}
 }
-
 //func chkf32(f, v float32) { if f != v { println(f, "!=", v); panic("fail") } }
 //func chkf64(f, v float64) { if f != v { println(f, "!=", v); panic("fail") } }
 
@@ -135,6 +134,7 @@ func main() {
 	//	chki64(int64(f32), 0)
 	//	chki64(int64(f64), 0)
 
+
 	chku8(uint8(i8), ci8&0xff)
 	chku8(uint8(i16), ci16&0xff)
 	chku8(uint8(i32), ci32&0xff)
diff --git a/test/interface/bigdata.go b/test/interface/bigdata.go
index f194f75b08..0f2e9a990e 100644
--- a/test/interface/bigdata.go
+++ b/test/interface/bigdata.go
@@ -8,18 +8,15 @@
 
 package main
 
-type I interface{ M() int64 }
+type I interface { M() int64 }
 
-type BigPtr struct{ a, b, c, d int64 }
-
-func (z *BigPtr) M() int64 { return z.a + z.b + z.c + z.d }
-
-type SmallPtr struct{ a int32 }
+type BigPtr struct { a, b, c, d int64 }
+func (z *BigPtr) M() int64 { return z.a+z.b+z.c+z.d }
 
+type SmallPtr struct { a int32 }
 func (z *SmallPtr) M() int64 { return int64(z.a) }
 
 type IntPtr int32
-
 func (z *IntPtr) M() int64 { return int64(*z) }
 
 var bad bool
@@ -33,33 +30,30 @@ func test(name string, i I) {
 }
 
 func ptrs() {
-	var bigptr BigPtr = BigPtr{10000, 2000, 300, 45}
-	var smallptr SmallPtr = SmallPtr{12345}
+	var bigptr BigPtr = BigPtr{ 10000, 2000, 300, 45 }
+	var smallptr SmallPtr = SmallPtr{ 12345 }
 	var intptr IntPtr = 12345
 
-	//	test("bigptr", bigptr)
+//	test("bigptr", bigptr)
 	test("&bigptr", &bigptr)
-	//	test("smallptr", smallptr)
+//	test("smallptr", smallptr)
 	test("&smallptr", &smallptr)
-	//	test("intptr", intptr)
+//	test("intptr", intptr)
 	test("&intptr", &intptr)
 }
 
-type Big struct{ a, b, c, d int64 }
-
-func (z Big) M() int64 { return z.a + z.b + z.c + z.d }
-
-type Small struct{ a int32 }
+type Big struct { a, b, c, d int64 }
+func (z Big) M() int64 { return z.a+z.b+z.c+z.d }
 
+type Small struct { a int32 }
 func (z Small) M() int64 { return int64(z.a) }
 
 type Int int32
-
 func (z Int) M() int64 { return int64(z) }
 
 func nonptrs() {
-	var big Big = Big{10000, 2000, 300, 45}
-	var small Small = Small{12345}
+	var big Big = Big{ 10000, 2000, 300, 45 }
+	var small Small = Small{ 12345 }
 	var int Int = 12345
 
 	test("big", big)
diff --git a/test/interface/convert1.go b/test/interface/convert1.go
index 98261edf9b..4a3ec8a375 100644
--- a/test/interface/convert1.go
+++ b/test/interface/convert1.go
@@ -8,13 +8,10 @@
 
 package main
 
-type R interface{ R() }
-type RW interface {
-	R()
-	W()
-}
+type R interface { R() }
+type RW interface { R(); W() }
 
-var e interface{}
+var e interface {}
 var r R
 var rw RW
 
diff --git a/test/interface/convert2.go b/test/interface/convert2.go
index 98261edf9b..4a3ec8a375 100644
--- a/test/interface/convert2.go
+++ b/test/interface/convert2.go
@@ -8,13 +8,10 @@
 
 package main
 
-type R interface{ R() }
-type RW interface {
-	R()
-	W()
-}
+type R interface { R() }
+type RW interface { R(); W() }
 
-var e interface{}
+var e interface {}
 var r R
 var rw RW
 
diff --git a/test/interface/embed.go b/test/interface/embed.go
index 993c532b2a..5c52ac0232 100644
--- a/test/interface/embed.go
+++ b/test/interface/embed.go
@@ -12,19 +12,16 @@ import "os"
 
 const Value = 1e12
 
-type Inter interface{ M() int64 }
+type Inter interface { M() int64 }
 
 type T int64
-
 func (t T) M() int64 { return int64(t) }
-
 var t = T(Value)
 var pt = &t
 var ti Inter = t
 
-type S struct{ Inter }
-
-var s = S{ti}
+type S struct { Inter }
+var s = S{ ti }
 var ps = &s
 
 var i Inter
diff --git a/test/interface/embed1.dir/embed0.go b/test/interface/embed1.dir/embed0.go
index 4aed391b63..728bec74e8 100644
--- a/test/interface/embed1.dir/embed0.go
+++ b/test/interface/embed1.dir/embed0.go
@@ -7,11 +7,10 @@
 package p
 
 type T int
-
 func (t T) m() {}
 
-type I interface{ m() }
-type J interface{ I }
+type I interface { m() }
+type J interface { I }
 
 func main() {
 	var i I
diff --git a/test/interface/embed1.dir/embed1.go b/test/interface/embed1.dir/embed1.go
index 54754f3069..7dfb1dbc0a 100644
--- a/test/interface/embed1.dir/embed1.go
+++ b/test/interface/embed1.dir/embed1.go
@@ -9,14 +9,13 @@ package main
 import "./embed0"
 
 type T int
-
 func (t T) m() {}
 
-type I interface{ m() }
-type J interface{ I }
+type I interface { m() }
+type J interface { I }
 
-type PI interface{ p.I }
-type PJ interface{ p.J }
+type PI interface { p.I }
+type PJ interface { p.J }
 
 func main() {
 	var i I
diff --git a/test/interface/pointer.go b/test/interface/pointer.go
index 23e8ec285c..2927050669 100644
--- a/test/interface/pointer.go
+++ b/test/interface/pointer.go
@@ -24,6 +24,7 @@ type Start struct {
 
 func (start *Start) Next() *Inst { return nil }
 
+
 func AddInst(Inst) *Inst {
 	print("ok in addinst\n")
 	return nil
@@ -33,5 +34,5 @@ func main() {
 	print("call addinst\n")
 	var x Inst = AddInst(new(Start)) // ERROR "pointer to interface"
 	print("return from  addinst\n")
-	var y *Inst = new(Start) // ERROR "pointer to interface|incompatible type"
+	var y *Inst = new(Start)  // ERROR "pointer to interface|incompatible type"
 }
diff --git a/test/interface/private.dir/private1.go b/test/interface/private.dir/private1.go
index 8743ddb352..75eee51f5a 100644
--- a/test/interface/private.dir/private1.go
+++ b/test/interface/private.dir/private1.go
@@ -15,3 +15,4 @@ type Implementation struct{}
 func (p *Implementation) private() {}
 
 var X = new(Implementation)
+
diff --git a/test/interface/private.dir/prog.go b/test/interface/private.dir/prog.go
index e20c188eda..abea7d625c 100644
--- a/test/interface/private.dir/prog.go
+++ b/test/interface/private.dir/prog.go
@@ -25,9 +25,9 @@ func main() {
 	var px p.Exported
 	px = p.X
 
-	px.private() // ERROR "private"
+	px.private()			// ERROR "private"
 
-	px = new(Implementation) // ERROR "private"
+	px = new(Implementation)	// ERROR "private"
 
-	x = px // ERROR "private"
+	x = px				// ERROR "private"
 }
diff --git a/test/interface/recursive.go b/test/interface/recursive.go
index bfb517bdcc..fcc88331e0 100644
--- a/test/interface/recursive.go
+++ b/test/interface/recursive.go
@@ -17,6 +17,5 @@ type I2 interface {
 }
 
 type T int
-
 func (t T) foo() I2 { return t }
 func (t T) bar() I1 { return t }
diff --git a/test/interface/returntype.go b/test/interface/returntype.go
index d94b2ed68b..4d86f39184 100644
--- a/test/interface/returntype.go
+++ b/test/interface/returntype.go
@@ -8,14 +8,14 @@
 
 package main
 
-type S struct{ a int }
-type T struct{ b string }
+type S struct { a int }
+type T struct { b string }
 
-func (s *S) Name() int8  { return 1 }
+func (s *S) Name() int8 { return 1 }
 func (t *T) Name() int64 { return 64 }
 
-type I1 interface{ Name() int8 }
-type I2 interface{ Name() int64 }
+type I1 interface { Name() int8 }
+type I2 interface { Name() int64 }
 
 func main() {
 	shouldPanic(p1)
diff --git a/test/interface/struct.go b/test/interface/struct.go
index 628e5de5e3..f60819ca81 100644
--- a/test/interface/struct.go
+++ b/test/interface/struct.go
@@ -13,20 +13,16 @@ import "os"
 var fail int
 
 func check(b bool, msg string) {
-	if !b {
+	if (!b) {
 		println("failure in", msg)
 		fail++
 	}
 }
 
-type I1 interface {
-	Get() int
-	Put(int)
-}
-
-type S1 struct{ i int }
+type I1 interface { Get() int; Put(int) }
 
-func (p S1) Get() int  { return p.i }
+type S1 struct { i int }
+func (p S1) Get() int { return p.i }
 func (p S1) Put(i int) { p.i = i }
 
 func f1() {
@@ -53,9 +49,8 @@ func f3() {
 	check(s.i == 1, "f3 s")
 }
 
-type S2 struct{ i int }
-
-func (p *S2) Get() int  { return p.i }
+type S2 struct { i int }
+func (p *S2) Get() int { return p.i }
 func (p *S2) Put(i int) { p.i = i }
 
 // Disallowed by restriction of values going to pointer receivers
@@ -83,14 +78,10 @@ func f6() {
 	check(s.i == 2, "f6 s")
 }
 
-type I2 interface {
-	Get() int64
-	Put(int64)
-}
-
-type S3 struct{ i, j, k, l int64 }
+type I2 interface { Get() int64; Put(int64) }
 
-func (p S3) Get() int64  { return p.l }
+type S3 struct { i, j, k, l int64 }
+func (p S3) Get() int64 { return p.l }
 func (p S3) Put(i int64) { p.l = i }
 
 func f7() {
@@ -117,9 +108,8 @@ func f9() {
 	check(s.l == 4, "f9 s")
 }
 
-type S4 struct{ i, j, k, l int64 }
-
-func (p *S4) Get() int64  { return p.l }
+type S4 struct { i, j, k, l int64 }
+func (p *S4) Get() int64 { return p.l }
 func (p *S4) Put(i int64) { p.l = i }
 
 // Disallowed by restriction of values going to pointer receivers
@@ -151,13 +141,13 @@ func main() {
 	f1()
 	f2()
 	f3()
-	//	f4()
+//	f4()
 	f5()
 	f6()
 	f7()
 	f8()
 	f9()
-	//	f10()
+//	f10()
 	f11()
 	f12()
 	if fail > 0 {
diff --git a/test/iota.go b/test/iota.go
index 490b27d238..7187dbe335 100644
--- a/test/iota.go
+++ b/test/iota.go
@@ -16,9 +16,9 @@ func assert(cond bool, msg string) {
 }
 
 const (
-	x int     = iota
-	y         = iota
-	z         = 1 << iota
+	x int = iota
+	y = iota
+	z = 1 << iota
 	f float32 = 2 * iota
 	g float32 = 4.5 * float32(iota)
 )
diff --git a/test/ken/complit.go b/test/ken/complit.go
index 99d9d7713f..bc50bbe224 100644
--- a/test/ken/complit.go
+++ b/test/ken/complit.go
@@ -8,115 +8,118 @@
 
 package main
 
-type M map[int]int
-type S struct{ a, b, c int }
-type SS struct{ aa, bb, cc S }
-type SA struct{ a, b, c [3]int }
-type SC struct{ a, b, c []int }
-type SM struct{ a, b, c M }
-
-func main() {
-	test("s.a", s.a)
-	test("s.b", s.b)
-	test("s.c", s.c)
-
-	test("ss.aa.a", ss.aa.a)
-	test("ss.aa.b", ss.aa.b)
-	test("ss.aa.c", ss.aa.c)
-
-	test("ss.bb.a", ss.bb.a)
-	test("ss.bb.b", ss.bb.b)
-	test("ss.bb.c", ss.bb.c)
-
-	test("ss.cc.a", ss.cc.a)
-	test("ss.cc.b", ss.cc.b)
-	test("ss.cc.c", ss.cc.c)
-
-	for i := 0; i < 3; i++ {
-		test("a[i]", a[i])
-		test("c[i]", c[i])
-		test("m[i]", m[i])
-
-		test("as[i].a", as[i].a)
-		test("as[i].b", as[i].b)
-		test("as[i].c", as[i].c)
-
-		test("cs[i].a", cs[i].a)
-		test("cs[i].b", cs[i].b)
-		test("cs[i].c", cs[i].c)
-
-		test("ms[i].a", ms[i].a)
-		test("ms[i].b", ms[i].b)
-		test("ms[i].c", ms[i].c)
-
-		test("sa.a[i]", sa.a[i])
-		test("sa.b[i]", sa.b[i])
-		test("sa.c[i]", sa.c[i])
-
-		test("sc.a[i]", sc.a[i])
-		test("sc.b[i]", sc.b[i])
-		test("sc.c[i]", sc.c[i])
-
-		test("sm.a[i]", sm.a[i])
-		test("sm.b[i]", sm.b[i])
-		test("sm.c[i]", sm.c[i])
-
-		for j := 0; j < 3; j++ {
-			test("aa[i][j]", aa[i][j])
-			test("ac[i][j]", ac[i][j])
-			test("am[i][j]", am[i][j])
-			test("ca[i][j]", ca[i][j])
-			test("cc[i][j]", cc[i][j])
-			test("cm[i][j]", cm[i][j])
-			test("ma[i][j]", ma[i][j])
-			test("mc[i][j]", mc[i][j])
-			test("mm[i][j]", mm[i][j])
+type	M	map[int]int
+type	S	struct{ a,b,c int };
+type	SS	struct{ aa,bb,cc S };
+type	SA	struct{ a,b,c [3]int };
+type	SC	struct{ a,b,c []int };
+type	SM	struct{ a,b,c M };
+
+func
+main() {
+	test("s.a", s.a);
+	test("s.b", s.b);
+	test("s.c", s.c);
+
+	test("ss.aa.a", ss.aa.a);
+	test("ss.aa.b", ss.aa.b);
+	test("ss.aa.c", ss.aa.c);
+
+	test("ss.bb.a", ss.bb.a);
+	test("ss.bb.b", ss.bb.b);
+	test("ss.bb.c", ss.bb.c);
+
+	test("ss.cc.a", ss.cc.a);
+	test("ss.cc.b", ss.cc.b);
+	test("ss.cc.c", ss.cc.c);
+
+	for i:=0; i<3; i++ {
+		test("a[i]", a[i]);
+		test("c[i]", c[i]);
+		test("m[i]", m[i]);
+
+		test("as[i].a", as[i].a);
+		test("as[i].b", as[i].b);
+		test("as[i].c", as[i].c);
+
+		test("cs[i].a", cs[i].a);
+		test("cs[i].b", cs[i].b);
+		test("cs[i].c", cs[i].c);
+
+		test("ms[i].a", ms[i].a);
+		test("ms[i].b", ms[i].b);
+		test("ms[i].c", ms[i].c);
+
+		test("sa.a[i]", sa.a[i]);
+		test("sa.b[i]", sa.b[i]);
+		test("sa.c[i]", sa.c[i]);
+
+		test("sc.a[i]", sc.a[i]);
+		test("sc.b[i]", sc.b[i]);
+		test("sc.c[i]", sc.c[i]);
+
+		test("sm.a[i]", sm.a[i]);
+		test("sm.b[i]", sm.b[i]);
+		test("sm.c[i]", sm.c[i]);
+
+		for j:=0; j<3; j++ {
+			test("aa[i][j]", aa[i][j]);
+			test("ac[i][j]", ac[i][j]);
+			test("am[i][j]", am[i][j]);
+			test("ca[i][j]", ca[i][j]);
+			test("cc[i][j]", cc[i][j]);
+			test("cm[i][j]", cm[i][j]);
+			test("ma[i][j]", ma[i][j]);
+			test("mc[i][j]", mc[i][j]);
+			test("mm[i][j]", mm[i][j]);
 		}
 	}
 
 }
 
-var ref = 0
+var	ref	= 0;
 
-func test(xs string, x int) {
+func
+test(xs string, x int) {
 
 	if ref >= len(answers) {
-		println(xs, x)
-		return
+		println(xs, x);
+		return;
 	}
 
 	if x != answers[ref] {
 		println(xs, "is", x, "should be", answers[ref])
 	}
-	ref++
+	ref++;
 }
 
-var a = [3]int{1001, 1002, 1003}
-var s = S{1101, 1102, 1103}
-var c = []int{1201, 1202, 1203}
-var m = M{0: 1301, 1: 1302, 2: 1303}
 
-var aa = [3][3]int{[3]int{2001, 2002, 2003}, [3]int{2004, 2005, 2006}, [3]int{2007, 2008, 2009}}
-var as = [3]S{S{2101, 2102, 2103}, S{2104, 2105, 2106}, S{2107, 2108, 2109}}
-var ac = [3][]int{[]int{2201, 2202, 2203}, []int{2204, 2205, 2206}, []int{2207, 2208, 2209}}
-var am = [3]M{M{0: 2301, 1: 2302, 2: 2303}, M{0: 2304, 1: 2305, 2: 2306}, M{0: 2307, 1: 2308, 2: 2309}}
+var	a	= [3]int{1001, 1002, 1003}
+var	s	= S{1101, 1102, 1103}
+var	c	= []int{1201, 1202, 1203}
+var	m	= M{0:1301, 1:1302, 2:1303}
 
-var sa = SA{[3]int{3001, 3002, 3003}, [3]int{3004, 3005, 3006}, [3]int{3007, 3008, 3009}}
-var ss = SS{S{3101, 3102, 3103}, S{3104, 3105, 3106}, S{3107, 3108, 3109}}
-var sc = SC{[]int{3201, 3202, 3203}, []int{3204, 3205, 3206}, []int{3207, 3208, 3209}}
-var sm = SM{M{0: 3301, 1: 3302, 2: 3303}, M{0: 3304, 1: 3305, 2: 3306}, M{0: 3307, 1: 3308, 2: 3309}}
+var	aa	= [3][3]int{[3]int{2001,2002,2003}, [3]int{2004,2005,2006}, [3]int{2007,2008,2009}}
+var	as	= [3]S{S{2101,2102,2103},S{2104,2105,2106},S{2107,2108,2109}}
+var	ac	= [3][]int{[]int{2201,2202,2203}, []int{2204,2205,2206}, []int{2207,2208,2209}}
+var	am	= [3]M{M{0:2301,1:2302,2:2303}, M{0:2304,1:2305,2:2306}, M{0:2307,1:2308,2:2309}}
 
-var ca = [][3]int{[3]int{4001, 4002, 4003}, [3]int{4004, 4005, 4006}, [3]int{4007, 4008, 4009}}
-var cs = []S{S{4101, 4102, 4103}, S{4104, 4105, 4106}, S{4107, 4108, 4109}}
-var cc = [][]int{[]int{4201, 4202, 4203}, []int{4204, 4205, 4206}, []int{4207, 4208, 4209}}
-var cm = []M{M{0: 4301, 1: 4302, 2: 4303}, M{0: 4304, 1: 4305, 2: 4306}, M{0: 4307, 1: 4308, 2: 4309}}
+var	sa	= SA{[3]int{3001,3002,3003},[3]int{3004,3005,3006},[3]int{3007,3008,3009}}
+var	ss	= SS{S{3101,3102,3103},S{3104,3105,3106},S{3107,3108,3109}}
+var	sc	= SC{[]int{3201,3202,3203},[]int{3204,3205,3206},[]int{3207,3208,3209}}
+var	sm	= SM{M{0:3301,1:3302,2:3303}, M{0:3304,1:3305,2:3306}, M{0:3307,1:3308,2:3309}}
 
-var ma = map[int][3]int{0: [3]int{5001, 5002, 5003}, 1: [3]int{5004, 5005, 5006}, 2: [3]int{5007, 5008, 5009}}
-var ms = map[int]S{0: S{5101, 5102, 5103}, 1: S{5104, 5105, 5106}, 2: S{5107, 5108, 5109}}
-var mc = map[int][]int{0: []int{5201, 5202, 5203}, 1: []int{5204, 5205, 5206}, 2: []int{5207, 5208, 5209}}
-var mm = map[int]M{0: M{0: 5301, 1: 5302, 2: 5303}, 1: M{0: 5304, 1: 5305, 2: 5306}, 2: M{0: 5307, 1: 5308, 2: 5309}}
+var	ca	= [][3]int{[3]int{4001,4002,4003}, [3]int{4004,4005,4006}, [3]int{4007,4008,4009}}
+var	cs	= []S{S{4101,4102,4103},S{4104,4105,4106},S{4107,4108,4109}}
+var	cc	= [][]int{[]int{4201,4202,4203}, []int{4204,4205,4206}, []int{4207,4208,4209}}
+var	cm	= []M{M{0:4301,1:4302,2:4303}, M{0:4304,1:4305,2:4306}, M{0:4307,1:4308,2:4309}}
 
-var answers = [...]int{
+var	ma	= map[int][3]int{0:[3]int{5001,5002,5003}, 1:[3]int{5004,5005,5006}, 2:[3]int{5007,5008,5009}}
+var	ms	= map[int]S{0:S{5101,5102,5103},1:S{5104,5105,5106},2:S{5107,5108,5109}}
+var	mc	= map[int][]int{0:[]int{5201,5202,5203}, 1:[]int{5204,5205,5206}, 2:[]int{5207,5208,5209}}
+var	mm	= map[int]M{0:M{0:5301,1:5302,2:5303}, 1:M{0:5304,1:5305,2:5306}, 2:M{0:5307,1:5308,2:5309}}
+
+var	answers	= [...]int {
 	// s
 	1101, 1102, 1103,
 
diff --git a/test/ken/convert.go b/test/ken/convert.go
index f3b08edbc2..33acbd8cd2 100644
--- a/test/ken/convert.go
+++ b/test/ken/convert.go
@@ -9,26 +9,26 @@
 
 package main
 
-var i8 int8
-var u8 uint8
-var i16 int16
-var u16 uint16
-var i32 int32
-var u32 uint32
-var i64 int64
-var u64 uint64
-var f32 float32
-var f64 float64
-
-type big float64
-
-type t struct {
-	from, to int
-	val      big
+var i8 int8;
+var u8 uint8;
+var i16 int16;
+var u16 uint16;
+var i32 int32;
+var u32 uint32;
+var i64 int64;
+var u64 uint64;
+var f32 float32;
+var f64 float64;
+
+type	big	float64
+
+type	t	struct {
+	from, to	int
+	val		big
 }
 
 const (
-	ti8 = iota + 1
+	ti8	= iota+1
 	tu8
 	ti16
 	tu16
@@ -40,184 +40,177 @@ const (
 	tf64
 )
 
-var x = []t{
+var	x = []t{
 
 	/* value good in all types (10) */
-	{ti8, ti8, 10}, {ti8, tu8, 10}, {ti8, ti16, 10}, {ti8, tu16, 10},
-	{ti8, ti32, 10}, {ti8, tu32, 10}, {ti8, ti64, 10}, {ti8, tu64, 10},
-	{ti8, tf32, 10}, {ti8, tf64, 10},
+	{ ti8,  ti8,  10 }, { ti8,  tu8,  10 }, { ti8,  ti16, 10 }, { ti8,  tu16, 10 },
+	{ ti8,  ti32, 10 }, { ti8,  tu32, 10 }, { ti8,  ti64, 10 }, { ti8,  tu64, 10 },
+	{ ti8,  tf32, 10 }, { ti8,  tf64, 10 },
 
-	{tu8, ti8, 10}, {tu8, tu8, 10}, {tu8, ti16, 10}, {tu8, tu16, 10},
-	{tu8, ti32, 10}, {tu8, tu32, 10}, {tu8, ti64, 10}, {tu8, tu64, 10},
-	{tu8, tf32, 10}, {tu8, tf64, 10},
+	{ tu8,  ti8,  10 }, { tu8,  tu8,  10 }, { tu8,  ti16, 10 }, { tu8,  tu16, 10 },
+	{ tu8,  ti32, 10 }, { tu8,  tu32, 10 }, { tu8,  ti64, 10 }, { tu8,  tu64, 10 },
+	{ tu8,  tf32, 10 }, { tu8,  tf64, 10 },
 
-	{ti16, ti8, 10}, {ti16, tu8, 10}, {ti16, ti16, 10}, {ti16, tu16, 10},
-	{ti16, ti32, 10}, {ti16, tu32, 10}, {ti16, ti64, 10}, {ti16, tu64, 10},
-	{ti16, tf32, 10}, {ti16, tf64, 10},
+	{ ti16, ti8,  10 }, { ti16, tu8,  10 }, { ti16, ti16, 10 }, { ti16, tu16, 10 },
+	{ ti16, ti32, 10 }, { ti16, tu32, 10 }, { ti16, ti64, 10 }, { ti16, tu64, 10 },
+	{ ti16, tf32, 10 }, { ti16, tf64, 10 },
 
-	{tu16, ti8, 10}, {tu16, tu8, 10}, {tu16, ti16, 10}, {tu16, tu16, 10},
-	{tu16, ti32, 10}, {tu16, tu32, 10}, {tu16, ti64, 10}, {tu16, tu64, 10},
-	{tu16, tf32, 10}, {tu16, tf64, 10},
+	{ tu16, ti8,  10 }, { tu16, tu8,  10 }, { tu16, ti16, 10 }, { tu16, tu16, 10 },
+	{ tu16, ti32, 10 }, { tu16, tu32, 10 }, { tu16, ti64, 10 }, { tu16, tu64, 10 },
+	{ tu16, tf32, 10 }, { tu16, tf64, 10 },
 
-	{ti32, ti8, 10}, {ti32, tu8, 10}, {ti32, ti16, 10}, {ti32, tu16, 10},
-	{ti32, ti32, 10}, {ti32, tu32, 10}, {ti32, ti64, 10}, {ti32, tu64, 10},
-	{ti32, tf32, 10}, {ti32, tf64, 10},
+	{ ti32, ti8,  10 }, { ti32, tu8,  10 }, { ti32, ti16, 10 }, { ti32, tu16, 10 },
+	{ ti32, ti32, 10 }, { ti32, tu32, 10 }, { ti32, ti64, 10 }, { ti32, tu64, 10 },
+	{ ti32, tf32, 10 }, { ti32, tf64, 10 },
 
-	{tu32, ti8, 10}, {tu32, tu8, 10}, {tu32, ti16, 10}, {tu32, tu16, 10},
-	{tu32, ti32, 10}, {tu32, tu32, 10}, {tu32, ti64, 10}, {tu32, tu64, 10},
-	{tu32, tf32, 10}, {tu32, tf64, 10},
+	{ tu32, ti8,  10 }, { tu32, tu8,  10 }, { tu32, ti16, 10 }, { tu32, tu16, 10 },
+	{ tu32, ti32, 10 }, { tu32, tu32, 10 }, { tu32, ti64, 10 }, { tu32, tu64, 10 },
+	{ tu32, tf32, 10 }, { tu32, tf64, 10 },
 
-	{ti64, ti8, 10}, {ti64, tu8, 10}, {ti64, ti16, 10}, {ti64, tu16, 10},
-	{ti64, ti32, 10}, {ti64, tu32, 10}, {ti64, ti64, 10}, {ti64, tu64, 10},
-	{ti64, tf32, 10}, {ti64, tf64, 10},
+	{ ti64, ti8,  10 }, { ti64, tu8,  10 }, { ti64, ti16, 10 }, { ti64, tu16, 10 },
+	{ ti64, ti32, 10 }, { ti64, tu32, 10 }, { ti64, ti64, 10 }, { ti64, tu64, 10 },
+	{ ti64, tf32, 10 }, { ti64, tf64, 10 },
 
-	{tu64, ti8, 10}, {tu64, tu8, 10}, {tu64, ti16, 10}, {tu64, tu16, 10},
-	{tu64, ti32, 10}, {tu64, tu32, 10}, {tu64, ti64, 10}, {tu64, tu64, 10},
-	{tu64, tf32, 10}, {tu64, tf64, 10},
+	{ tu64, ti8,  10 }, { tu64, tu8,  10 }, { tu64, ti16, 10 }, { tu64, tu16, 10 },
+	{ tu64, ti32, 10 }, { tu64, tu32, 10 }, { tu64, ti64, 10 }, { tu64, tu64, 10 },
+	{ tu64, tf32, 10 }, { tu64, tf64, 10 },
 
-	{tf32, ti8, 10}, {tf32, tu8, 10}, {tf32, ti16, 10}, {tf32, tu16, 10},
-	{tf32, ti32, 10}, {tf32, tu32, 10}, {tf32, ti64, 10}, {tf32, tu64, 10},
-	{tf32, tf32, 10}, {tf32, tf64, 10},
+	{ tf32, ti8,  10 }, { tf32, tu8,  10 }, { tf32, ti16, 10 }, { tf32, tu16, 10 },
+	{ tf32, ti32, 10 }, { tf32, tu32, 10 }, { tf32, ti64, 10 }, { tf32, tu64, 10 },
+	{ tf32, tf32, 10 }, { tf32, tf64, 10 },
 
-	{tf64, ti8, 10}, {tf64, tu8, 10}, {tf64, ti16, 10}, {tf64, tu16, 10},
-	{tf64, ti32, 10}, {tf64, tu32, 10}, {tf64, ti64, 10}, {tf64, tu64, 10},
-	{tf64, tf32, 10}, {tf64, tf64, 10},
+	{ tf64, ti8,  10 }, { tf64, tu8,  10 }, { tf64, ti16, 10 }, { tf64, tu16, 10 },
+	{ tf64, ti32, 10 }, { tf64, tu32, 10 }, { tf64, ti64, 10 }, { tf64, tu64, 10 },
+	{ tf64, tf32, 10 }, { tf64, tf64, 10 },
 
 	/* value good in all signed types (-4) */
-	{ti8, ti8, -4}, {ti8, ti16, -4},
-	{ti8, ti32, -4}, {ti8, ti64, -4},
-	{ti8, tf32, -4}, {ti8, tf64, -4},
+	{ ti8,  ti8,  -4 }, { ti8,  ti16, -4 },
+	{ ti8,  ti32, -4 }, { ti8,  ti64, -4 },
+	{ ti8,  tf32, -4 }, { ti8,  tf64, -4 },
 
-	{ti16, ti8, -4}, {ti16, ti16, -4},
-	{ti16, ti32, -4}, {ti16, ti64, -4},
-	{ti16, tf32, -4},
+	{ ti16, ti8,  -4 }, { ti16, ti16, -4 },
+	{ ti16, ti32, -4 }, { ti16, ti64, -4 },
+	{ ti16, tf32, -4 },
 
-	{ti32, ti8, -4}, {ti32, ti16, -4},
-	{ti32, ti32, -4}, {ti32, ti64, -4},
-	{ti32, tf32, -4}, {ti32, tf64, -4},
+	{ ti32, ti8,  -4 }, { ti32, ti16, -4 },
+	{ ti32, ti32, -4 }, { ti32, ti64, -4 },
+	{ ti32, tf32, -4 }, { ti32, tf64, -4 },
 
-	{ti64, ti8, -4}, {ti64, ti16, -4},
-	{ti64, ti32, -4}, {ti64, ti64, -4},
-	{ti64, tf32, -4},
+	{ ti64, ti8,  -4 }, { ti64, ti16, -4 },
+	{ ti64, ti32, -4 }, { ti64, ti64, -4 },
+	{ ti64, tf32, -4 },
 
-	{tf32, ti8, -4}, {tf32, ti16, -4},
-	{tf32, ti32, -4}, {tf32, ti64, -4},
-	{tf32, tf32, -4},
+	{ tf32, ti8,  -4 }, { tf32, ti16, -4 },
+	{ tf32, ti32, -4 }, { tf32, ti64, -4 },
+	{ tf32, tf32, -4 },
 
-	{tf64, ti8, -4}, {tf64, ti16, -4},
-	{tf64, ti32, -4}, {tf64, ti64, -4},
-	{tf64, tf32, -4}, {tf64, tf64, -4},
+	{ tf64, ti8,  -4 }, { tf64, ti16, -4 },
+	{ tf64, ti32, -4 }, { tf64, ti64, -4 },
+	{ tf64, tf32, -4 }, { tf64, tf64, -4 },
 
 	/* value good in u8 and up (175) */
-	{tu8, tu8, 175}, {tu8, ti16, 175}, {tu8, tu16, 175},
-	{tu8, ti32, 175}, {tu8, tu32, 175}, {tu8, ti64, 175}, {tu8, tu64, 175},
-	{tu8, tf32, 175}, {tu8, tf64, 175},
+	{ tu8,  tu8,  175 }, { tu8,  ti16, 175 }, { tu8,  tu16, 175 },
+	{ tu8,  ti32, 175 }, { tu8,  tu32, 175 }, { tu8,  ti64, 175 }, { tu8,  tu64, 175 },
+	{ tu8,  tf32, 175 }, { tu8,  tf64, 175 },
 
-	{ti16, tu8, 175}, {ti16, ti16, 175}, {ti16, tu16, 175},
-	{ti16, ti32, 175}, {ti16, tu32, 175}, {ti16, ti64, 175}, {ti16, tu64, 175},
-	{ti16, tf32, 175}, {ti16, tf64, 175},
+	{ ti16, tu8,  175 }, { ti16, ti16, 175 }, { ti16, tu16, 175 },
+	{ ti16, ti32, 175 }, { ti16, tu32, 175 }, { ti16, ti64, 175 }, { ti16, tu64, 175 },
+	{ ti16, tf32, 175 }, { ti16, tf64, 175 },
 
-	{tu16, tu8, 175}, {tu16, ti16, 175}, {tu16, tu16, 175},
-	{tu16, ti32, 175}, {tu16, tu32, 175}, {tu16, ti64, 175}, {tu16, tu64, 175},
-	{tu16, tf32, 175}, {tu16, tf64, 175},
+	{ tu16, tu8,  175 }, { tu16, ti16, 175 }, { tu16, tu16, 175 },
+	{ tu16, ti32, 175 }, { tu16, tu32, 175 }, { tu16, ti64, 175 }, { tu16, tu64, 175 },
+	{ tu16, tf32, 175 }, { tu16, tf64, 175 },
 
-	{ti32, tu8, 175}, {ti32, ti16, 175}, {ti32, tu16, 175},
-	{ti32, ti32, 175}, {ti32, tu32, 175}, {ti32, ti64, 175}, {ti32, tu64, 175},
-	{ti32, tf32, 175}, {ti32, tf64, 175},
+	{ ti32, tu8,  175 }, { ti32, ti16, 175 }, { ti32, tu16, 175 },
+	{ ti32, ti32, 175 }, { ti32, tu32, 175 }, { ti32, ti64, 175 }, { ti32, tu64, 175 },
+	{ ti32, tf32, 175 }, { ti32, tf64, 175 },
 
-	{tu32, tu8, 175}, {tu32, ti16, 175}, {tu32, tu16, 175},
-	{tu32, ti32, 175}, {tu32, tu32, 175}, {tu32, ti64, 175}, {tu32, tu64, 175},
-	{tu32, tf32, 175}, {tu32, tf64, 175},
+	{ tu32, tu8,  175 }, { tu32, ti16, 175 }, { tu32, tu16, 175 },
+	{ tu32, ti32, 175 }, { tu32, tu32, 175 }, { tu32, ti64, 175 }, { tu32, tu64, 175 },
+	{ tu32, tf32, 175 }, { tu32, tf64, 175 },
 
-	{ti64, tu8, 175}, {ti64, ti16, 175}, {ti64, tu16, 175},
-	{ti64, ti32, 175}, {ti64, tu32, 175}, {ti64, ti64, 175}, {ti64, tu64, 175},
-	{ti64, tf32, 175}, {ti64, tf64, 175},
+	{ ti64, tu8,  175 }, { ti64, ti16, 175 }, { ti64, tu16, 175 },
+	{ ti64, ti32, 175 }, { ti64, tu32, 175 }, { ti64, ti64, 175 }, { ti64, tu64, 175 },
+	{ ti64, tf32, 175 }, { ti64, tf64, 175 },
 
-	{tu64, tu8, 175}, {tu64, ti16, 175}, {tu64, tu16, 175},
-	{tu64, ti32, 175}, {tu64, tu32, 175}, {tu64, ti64, 175}, {tu64, tu64, 175},
-	{tu64, tf32, 175}, {tu64, tf64, 175},
+	{ tu64, tu8,  175 }, { tu64, ti16, 175 }, { tu64, tu16, 175 },
+	{ tu64, ti32, 175 }, { tu64, tu32, 175 }, { tu64, ti64, 175 }, { tu64, tu64, 175 },
+	{ tu64, tf32, 175 }, { tu64, tf64, 175 },
 
-	{tf32, tu8, 175}, {tf32, ti16, 175}, {tf32, tu16, 175},
-	{tf32, ti32, 175}, {tf32, tu32, 175}, {tf32, ti64, 175}, {tf32, tu64, 175},
-	{tf32, tf32, 175}, {tf32, tf64, 175},
+	{ tf32, tu8,  175 }, { tf32, ti16, 175 }, { tf32, tu16, 175 },
+	{ tf32, ti32, 175 }, { tf32, tu32, 175 }, { tf32, ti64, 175 }, { tf32, tu64, 175 },
+	{ tf32, tf32, 175 }, { tf32, tf64, 175 },
 
-	{tf64, tu8, 175}, {tf64, ti16, 175}, {tf64, tu16, 175},
-	{tf64, ti32, 175}, {tf64, tu32, 175}, {tf64, ti64, 175}, {tf64, tu64, 175},
-	{tf64, tf32, 175}, {tf64, tf64, 175},
+	{ tf64, tu8,  175 }, { tf64, ti16, 175 }, { tf64, tu16, 175 },
+	{ tf64, ti32, 175 }, { tf64, tu32, 175 }, { tf64, ti64, 175 }, { tf64, tu64, 175 },
+	{ tf64, tf32, 175 }, { tf64, tf64, 175 },
 
 	/* value good in u16 and up (41259) */
-	{tu16, tu16, 41259},
-	{tu16, ti32, 41259}, {tu16, ti64, 41259}, {tu16, tu64, 41259},
-	{tu16, tf32, 41259}, {tu16, tf64, 41259},
+	{ tu16, tu16, 41259 },
+	{ tu16, ti32, 41259 }, { tu16, ti64, 41259 }, { tu16, tu64, 41259 },
+	{ tu16, tf32, 41259 }, { tu16, tf64, 41259 },
 
-	{ti32, tu16, 41259},
-	{ti32, ti32, 41259}, {ti32, tu32, 41259}, {ti32, ti64, 41259}, {ti32, tu64, 41259},
-	{ti32, tf32, 41259}, {ti32, tf64, 41259},
+	{ ti32, tu16, 41259 },
+	{ ti32, ti32, 41259 }, { ti32, tu32, 41259 }, { ti32, ti64, 41259 }, { ti32, tu64, 41259 },
+	{ ti32, tf32, 41259 }, { ti32, tf64, 41259 },
 
-	{tu32, tu16, 41259},
-	{tu32, ti32, 41259}, {tu32, tu32, 41259}, {tu32, ti64, 41259}, {tu32, tu64, 41259},
-	{tu32, tf32, 41259}, {tu32, tf64, 41259},
+	{ tu32, tu16, 41259 },
+	{ tu32, ti32, 41259 }, { tu32, tu32, 41259 }, { tu32, ti64, 41259 }, { tu32, tu64, 41259 },
+	{ tu32, tf32, 41259 }, { tu32, tf64, 41259 },
 
-	{ti64, tu16, 41259},
-	{ti64, ti32, 41259}, {ti64, tu32, 41259}, {ti64, ti64, 41259}, {ti64, tu64, 41259},
-	{ti64, tf32, 41259}, {ti64, tf64, 41259},
+	{ ti64, tu16, 41259 },
+	{ ti64, ti32, 41259 }, { ti64, tu32, 41259 }, { ti64, ti64, 41259 }, { ti64, tu64, 41259 },
+	{ ti64, tf32, 41259 }, { ti64, tf64, 41259 },
 
-	{tu64, tu16, 41259},
-	{tu64, ti32, 41259}, {tu64, tu32, 41259}, {tu64, ti64, 41259}, {tu64, tu64, 41259},
-	{tu64, tf32, 41259}, {tu64, tf64, 41259},
+	{ tu64, tu16, 41259 },
+	{ tu64, ti32, 41259 }, { tu64, tu32, 41259 }, { tu64, ti64, 41259 }, { tu64, tu64, 41259 },
+	{ tu64, tf32, 41259 }, { tu64, tf64, 41259 },
 
-	{tf32, tu16, 41259},
-	{tf32, ti32, 41259}, {tf32, tu32, 41259}, {tf32, ti64, 41259}, {tf32, tu64, 41259},
-	{tf32, tf32, 41259}, {tf32, tf64, 41259},
+	{ tf32, tu16, 41259 },
+	{ tf32, ti32, 41259 }, { tf32, tu32, 41259 }, { tf32, ti64, 41259 }, { tf32, tu64, 41259 },
+	{ tf32, tf32, 41259 }, { tf32, tf64, 41259 },
 
-	{tf64, tu16, 41259},
-	{tf64, ti32, 41259}, {tf64, tu32, 41259}, {tf64, ti64, 41259}, {tf64, tu64, 41259},
-	{tf64, tf32, 41259}, {tf64, tf64, 41259},
+	{ tf64, tu16, 41259 },
+	{ tf64, ti32, 41259 }, { tf64, tu32, 41259 }, { tf64, ti64, 41259 }, { tf64, tu64, 41259 },
+	{ tf64, tf32, 41259 }, { tf64, tf64, 41259 },
 
 	/* value good in u32 and up (3758096384) */
-	{tu32, tu32, 3758096384}, {tu32, ti64, 3758096384}, {tu32, tu64, 3758096384},
-	{tu32, tf32, 3758096384}, {tu32, tf64, 3758096384},
+	{ tu32, tu32, 3758096384 }, { tu32, ti64, 3758096384 }, { tu32, tu64, 3758096384 },
+	{ tu32, tf32, 3758096384 }, { tu32, tf64, 3758096384 },
 
-	{ti64, tu32, 3758096384}, {ti64, ti64, 3758096384}, {ti64, tu64, 3758096384},
-	{ti64, tf32, 3758096384}, {ti64, tf64, 3758096384},
+	{ ti64, tu32, 3758096384 }, { ti64, ti64, 3758096384 }, { ti64, tu64, 3758096384 },
+	{ ti64, tf32, 3758096384 }, { ti64, tf64, 3758096384 },
 
-	{tu64, tu32, 3758096384}, {tu64, ti64, 3758096384}, {tu64, tu64, 3758096384},
-	{tu64, tf32, 3758096384}, {tu64, tf64, 3758096384},
+	{ tu64, tu32, 3758096384 }, { tu64, ti64, 3758096384 }, { tu64, tu64, 3758096384 },
+	{ tu64, tf32, 3758096384 }, { tu64, tf64, 3758096384 },
 
-	{tf32, tu32, 3758096384}, {tf32, ti64, 3758096384}, {tf32, tu64, 3758096384},
-	{tf32, tf32, 3758096384}, {tf32, tf64, 3758096384},
+	{ tf32, tu32, 3758096384 }, { tf32, ti64, 3758096384 }, { tf32, tu64, 3758096384 },
+	{ tf32, tf32, 3758096384 }, { tf32, tf64, 3758096384 },
 
-	{tf64, tu32, 3758096384}, {tf64, ti64, 3758096384}, {tf64, tu64, 3758096384},
-	{tf64, tf32, 3758096384}, {tf64, tf64, 3758096384},
+	{ tf64, tu32, 3758096384 }, { tf64, ti64, 3758096384 }, { tf64, tu64, 3758096384 },
+	{ tf64, tf32, 3758096384 }, { tf64, tf64, 3758096384 },
 
 	/* value good in u64 and up (16717361816799281152) */
-	{tu64, tu64, 16717361816799281152},
-	{tu64, tf32, 16717361816799281152}, {tu64, tf64, 16717361816799281152},
+	{ tu64, tu64, 16717361816799281152 },
+	{ tu64, tf32, 16717361816799281152 }, { tu64, tf64, 16717361816799281152 },
 
-	{tf32, tu64, 16717361816799281152},
-	{tf32, tf32, 16717361816799281152}, {tf32, tf64, 16717361816799281152},
+	{ tf32, tu64, 16717361816799281152 },
+	{ tf32, tf32, 16717361816799281152 }, { tf32, tf64, 16717361816799281152 },
 
-	{tf64, tu64, 16717361816799281152},
-	{tf64, tf32, 16717361816799281152}, {tf64, tf64, 16717361816799281152},
+	{ tf64, tu64, 16717361816799281152 },
+	{ tf64, tf32, 16717361816799281152 }, { tf64, tf64, 16717361816799281152 },
 }
 
 func main() {
-	for i := 0; i < len(x); i++ {
-		v := x[i].val  // input value
-		w := big(0)    // output value
-		f := x[i].from // input type
-		t := x[i].to   // output type
-
-		i8 = 0
-		u8 = 0
-		i16 = 0
-		u16 = 0
-		i32 = 0
-		u32 = 0
-		i64 = 0
-		u64 = 0
-		f32 = 0
-		f64 = 0
+	for i:=0; i<len(x); i++ {
+		v := x[i].val		// input value
+		w := big(0)		// output value
+		f := x[i].from		// input type
+		t := x[i].to		// output type
+
+		i8  = 0; u8  = 0; i16 = 0; u16 = 0
+		i32 = 0; u32 = 0; i64 = 0; u64 = 0
+		f32 = 0; f64 = 0
 
 		switch f*100 + t {
 		default:
@@ -225,417 +218,215 @@ func main() {
 			w = v
 
 		case ti8*100 + ti8:
-			i8 = int8(v)
-			i8 = int8(i8)
-			w = big(i8)
+			i8 = int8(v); i8 = int8(i8); w = big(i8)
 		case ti8*100 + tu8:
-			i8 = int8(v)
-			u8 = uint8(i8)
-			w = big(u8)
+			i8 = int8(v); u8 = uint8(i8); w = big(u8)
 		case ti8*100 + ti16:
-			i8 = int8(v)
-			i16 = int16(i8)
-			w = big(i16)
+			i8 = int8(v); i16 = int16(i8); w = big(i16)
 		case ti8*100 + tu16:
-			i8 = int8(v)
-			u16 = uint16(i8)
-			w = big(u16)
+			i8 = int8(v); u16 = uint16(i8); w = big(u16)
 		case ti8*100 + ti32:
-			i8 = int8(v)
-			i32 = int32(i8)
-			w = big(i32)
+			i8 = int8(v); i32 = int32(i8); w = big(i32)
 		case ti8*100 + tu32:
-			i8 = int8(v)
-			u32 = uint32(i8)
-			w = big(u32)
+			i8 = int8(v); u32 = uint32(i8); w = big(u32)
 		case ti8*100 + ti64:
-			i8 = int8(v)
-			i64 = int64(i8)
-			w = big(i64)
+			i8 = int8(v); i64 = int64(i8); w = big(i64)
 		case ti8*100 + tu64:
-			i8 = int8(v)
-			u64 = uint64(i8)
-			w = big(u64)
+			i8 = int8(v); u64 = uint64(i8); w = big(u64)
 		case ti8*100 + tf32:
-			i8 = int8(v)
-			f32 = float32(i8)
-			w = big(f32)
+			i8 = int8(v); f32 = float32(i8); w = big(f32)
 		case ti8*100 + tf64:
-			i8 = int8(v)
-			f64 = float64(i8)
-			w = big(f64)
+			i8 = int8(v); f64 = float64(i8); w = big(f64)
 
 		case tu8*100 + ti8:
-			u8 = uint8(v)
-			i8 = int8(u8)
-			w = big(i8)
+			u8 = uint8(v); i8 = int8(u8); w = big(i8)
 		case tu8*100 + tu8:
-			u8 = uint8(v)
-			u8 = uint8(u8)
-			w = big(u8)
+			u8 = uint8(v); u8 = uint8(u8); w = big(u8)
 		case tu8*100 + ti16:
-			u8 = uint8(v)
-			i16 = int16(u8)
-			w = big(i16)
+			u8 = uint8(v); i16 = int16(u8); w = big(i16)
 		case tu8*100 + tu16:
-			u8 = uint8(v)
-			u16 = uint16(u8)
-			w = big(u16)
+			u8 = uint8(v); u16 = uint16(u8); w = big(u16)
 		case tu8*100 + ti32:
-			u8 = uint8(v)
-			i32 = int32(u8)
-			w = big(i32)
+			u8 = uint8(v); i32 = int32(u8); w = big(i32)
 		case tu8*100 + tu32:
-			u8 = uint8(v)
-			u32 = uint32(u8)
-			w = big(u32)
+			u8 = uint8(v); u32 = uint32(u8); w = big(u32)
 		case tu8*100 + ti64:
-			u8 = uint8(v)
-			i64 = int64(u8)
-			w = big(i64)
+			u8 = uint8(v); i64 = int64(u8); w = big(i64)
 		case tu8*100 + tu64:
-			u8 = uint8(v)
-			u64 = uint64(u8)
-			w = big(u64)
+			u8 = uint8(v); u64 = uint64(u8); w = big(u64)
 		case tu8*100 + tf32:
-			u8 = uint8(v)
-			f32 = float32(u8)
-			w = big(f32)
+			u8 = uint8(v); f32 = float32(u8); w = big(f32)
 		case tu8*100 + tf64:
-			u8 = uint8(v)
-			f64 = float64(u8)
-			w = big(f64)
+			u8 = uint8(v); f64 = float64(u8); w = big(f64)
 
 		case ti16*100 + ti8:
-			i16 = int16(v)
-			i8 = int8(i16)
-			w = big(i8)
+			i16 = int16(v); i8 = int8(i16); w = big(i8)
 		case ti16*100 + tu8:
-			i16 = int16(v)
-			u8 = uint8(i16)
-			w = big(u8)
+			i16 = int16(v); u8 = uint8(i16); w = big(u8)
 		case ti16*100 + ti16:
-			i16 = int16(v)
-			i16 = int16(i16)
-			w = big(i16)
+			i16 = int16(v); i16 = int16(i16); w = big(i16)
 		case ti16*100 + tu16:
-			i16 = int16(v)
-			u16 = uint16(i16)
-			w = big(u16)
+			i16 = int16(v); u16 = uint16(i16); w = big(u16)
 		case ti16*100 + ti32:
-			i16 = int16(v)
-			i32 = int32(i16)
-			w = big(i32)
+			i16 = int16(v); i32 = int32(i16); w = big(i32)
 		case ti16*100 + tu32:
-			i16 = int16(v)
-			u32 = uint32(i16)
-			w = big(u32)
+			i16 = int16(v); u32 = uint32(i16); w = big(u32)
 		case ti16*100 + ti64:
-			i16 = int16(v)
-			i64 = int64(i16)
-			w = big(i64)
+			i16 = int16(v); i64 = int64(i16); w = big(i64)
 		case ti16*100 + tu64:
-			i16 = int16(v)
-			u64 = uint64(i16)
-			w = big(u64)
+			i16 = int16(v); u64 = uint64(i16); w = big(u64)
 		case ti16*100 + tf32:
-			i16 = int16(v)
-			f32 = float32(i16)
-			w = big(f32)
+			i16 = int16(v); f32 = float32(i16); w = big(f32)
 		case ti16*100 + tf64:
-			i16 = int16(v)
-			f64 = float64(i16)
-			w = big(f64)
+			i16 = int16(v); f64 = float64(i16); w = big(f64)
 
 		case tu16*100 + ti8:
-			u16 = uint16(v)
-			i8 = int8(u16)
-			w = big(i8)
+			u16 = uint16(v); i8 = int8(u16); w = big(i8)
 		case tu16*100 + tu8:
-			u16 = uint16(v)
-			u8 = uint8(u16)
-			w = big(u8)
+			u16 = uint16(v); u8 = uint8(u16); w = big(u8)
 		case tu16*100 + ti16:
-			u16 = uint16(v)
-			i16 = int16(u16)
-			w = big(i16)
+			u16 = uint16(v); i16 = int16(u16); w = big(i16)
 		case tu16*100 + tu16:
-			u16 = uint16(v)
-			u16 = uint16(u16)
-			w = big(u16)
+			u16 = uint16(v); u16 = uint16(u16); w = big(u16)
 		case tu16*100 + ti32:
-			u16 = uint16(v)
-			i32 = int32(u16)
-			w = big(i32)
+			u16 = uint16(v); i32 = int32(u16); w = big(i32)
 		case tu16*100 + tu32:
-			u16 = uint16(v)
-			u32 = uint32(u16)
-			w = big(u32)
+			u16 = uint16(v); u32 = uint32(u16); w = big(u32)
 		case tu16*100 + ti64:
-			u16 = uint16(v)
-			i64 = int64(u16)
-			w = big(i64)
+			u16 = uint16(v); i64 = int64(u16); w = big(i64)
 		case tu16*100 + tu64:
-			u16 = uint16(v)
-			u64 = uint64(u16)
-			w = big(u64)
+			u16 = uint16(v); u64 = uint64(u16); w = big(u64)
 		case tu16*100 + tf32:
-			u16 = uint16(v)
-			f32 = float32(u16)
-			w = big(f32)
+			u16 = uint16(v); f32 = float32(u16); w = big(f32)
 		case tu16*100 + tf64:
-			u16 = uint16(v)
-			f64 = float64(u16)
-			w = big(f64)
+			u16 = uint16(v); f64 = float64(u16); w = big(f64)
 
 		case ti32*100 + ti8:
-			i32 = int32(v)
-			i8 = int8(i32)
-			w = big(i8)
+			i32 = int32(v); i8 = int8(i32); w = big(i8)
 		case ti32*100 + tu8:
-			i32 = int32(v)
-			u8 = uint8(i32)
-			w = big(u8)
+			i32 = int32(v); u8 = uint8(i32); w = big(u8)
 		case ti32*100 + ti16:
-			i32 = int32(v)
-			i16 = int16(i32)
-			w = big(i16)
+			i32 = int32(v); i16 = int16(i32); w = big(i16)
 		case ti32*100 + tu16:
-			i32 = int32(v)
-			u16 = uint16(i32)
-			w = big(u16)
+			i32 = int32(v); u16 = uint16(i32); w = big(u16)
 		case ti32*100 + ti32:
-			i32 = int32(v)
-			i32 = int32(i32)
-			w = big(i32)
+			i32 = int32(v); i32 = int32(i32); w = big(i32)
 		case ti32*100 + tu32:
-			i32 = int32(v)
-			u32 = uint32(i32)
-			w = big(u32)
+			i32 = int32(v); u32 = uint32(i32); w = big(u32)
 		case ti32*100 + ti64:
-			i32 = int32(v)
-			i64 = int64(i32)
-			w = big(i64)
+			i32 = int32(v); i64 = int64(i32); w = big(i64)
 		case ti32*100 + tu64:
-			i32 = int32(v)
-			u64 = uint64(i32)
-			w = big(u64)
+			i32 = int32(v); u64 = uint64(i32); w = big(u64)
 		case ti32*100 + tf32:
-			i32 = int32(v)
-			f32 = float32(i32)
-			w = big(f32)
+			i32 = int32(v); f32 = float32(i32); w = big(f32)
 		case ti32*100 + tf64:
-			i32 = int32(v)
-			f64 = float64(i32)
-			w = big(f64)
+			i32 = int32(v); f64 = float64(i32); w = big(f64)
 
 		case tu32*100 + ti8:
-			u32 = uint32(v)
-			i8 = int8(u32)
-			w = big(i8)
+			u32 = uint32(v); i8 = int8(u32); w = big(i8)
 		case tu32*100 + tu8:
-			u32 = uint32(v)
-			u8 = uint8(u32)
-			w = big(u8)
+			u32 = uint32(v); u8 = uint8(u32); w = big(u8)
 		case tu32*100 + ti16:
-			u32 = uint32(v)
-			i16 = int16(u32)
-			w = big(i16)
+			u32 = uint32(v); i16 = int16(u32); w = big(i16)
 		case tu32*100 + tu16:
-			u32 = uint32(v)
-			u16 = uint16(u32)
-			w = big(u16)
+			u32 = uint32(v); u16 = uint16(u32); w = big(u16)
 		case tu32*100 + ti32:
-			u32 = uint32(v)
-			i32 = int32(u32)
-			w = big(i32)
+			u32 = uint32(v); i32 = int32(u32); w = big(i32)
 		case tu32*100 + tu32:
-			u32 = uint32(v)
-			u32 = uint32(u32)
-			w = big(u32)
+			u32 = uint32(v); u32 = uint32(u32); w = big(u32)
 		case tu32*100 + ti64:
-			u32 = uint32(v)
-			i64 = int64(u32)
-			w = big(i64)
+			u32 = uint32(v); i64 = int64(u32); w = big(i64)
 		case tu32*100 + tu64:
-			u32 = uint32(v)
-			u64 = uint64(u32)
-			w = big(u64)
+			u32 = uint32(v); u64 = uint64(u32); w = big(u64)
 		case tu32*100 + tf32:
-			u32 = uint32(v)
-			f32 = float32(u32)
-			w = big(f32)
+			u32 = uint32(v); f32 = float32(u32); w = big(f32)
 		case tu32*100 + tf64:
-			u32 = uint32(v)
-			f64 = float64(u32)
-			w = big(f64)
+			u32 = uint32(v); f64 = float64(u32); w = big(f64)
 
 		case ti64*100 + ti8:
-			i64 = int64(v)
-			i8 = int8(i64)
-			w = big(i8)
+			i64 = int64(v); i8 = int8(i64); w = big(i8)
 		case ti64*100 + tu8:
-			i64 = int64(v)
-			u8 = uint8(i64)
-			w = big(u8)
+			i64 = int64(v); u8 = uint8(i64); w = big(u8)
 		case ti64*100 + ti16:
-			i64 = int64(v)
-			i16 = int16(i64)
-			w = big(i16)
+			i64 = int64(v); i16 = int16(i64); w = big(i16)
 		case ti64*100 + tu16:
-			i64 = int64(v)
-			u16 = uint16(i64)
-			w = big(u16)
+			i64 = int64(v); u16 = uint16(i64); w = big(u16)
 		case ti64*100 + ti32:
-			i64 = int64(v)
-			i32 = int32(i64)
-			w = big(i32)
+			i64 = int64(v); i32 = int32(i64); w = big(i32)
 		case ti64*100 + tu32:
-			i64 = int64(v)
-			u32 = uint32(i64)
-			w = big(u32)
+			i64 = int64(v); u32 = uint32(i64); w = big(u32)
 		case ti64*100 + ti64:
-			i64 = int64(v)
-			i64 = int64(i64)
-			w = big(i64)
+			i64 = int64(v); i64 = int64(i64); w = big(i64)
 		case ti64*100 + tu64:
-			i64 = int64(v)
-			u64 = uint64(i64)
-			w = big(u64)
+			i64 = int64(v); u64 = uint64(i64); w = big(u64)
 		case ti64*100 + tf32:
-			i64 = int64(v)
-			f32 = float32(i64)
-			w = big(f32)
+			i64 = int64(v); f32 = float32(i64); w = big(f32)
 		case ti64*100 + tf64:
-			i64 = int64(v)
-			f64 = float64(i64)
-			w = big(f64)
+			i64 = int64(v); f64 = float64(i64); w = big(f64)
 
 		case tu64*100 + ti8:
-			u64 = uint64(v)
-			i8 = int8(u64)
-			w = big(i8)
+			u64 = uint64(v); i8 = int8(u64); w = big(i8)
 		case tu64*100 + tu8:
-			u64 = uint64(v)
-			u8 = uint8(u64)
-			w = big(u8)
+			u64 = uint64(v); u8 = uint8(u64); w = big(u8)
 		case tu64*100 + ti16:
-			u64 = uint64(v)
-			i16 = int16(u64)
-			w = big(i16)
+			u64 = uint64(v); i16 = int16(u64); w = big(i16)
 		case tu64*100 + tu16:
-			u64 = uint64(v)
-			u16 = uint16(u64)
-			w = big(u16)
+			u64 = uint64(v); u16 = uint16(u64); w = big(u16)
 		case tu64*100 + ti32:
-			u64 = uint64(v)
-			i32 = int32(u64)
-			w = big(i32)
+			u64 = uint64(v); i32 = int32(u64); w = big(i32)
 		case tu64*100 + tu32:
-			u64 = uint64(v)
-			u32 = uint32(u64)
-			w = big(u32)
+			u64 = uint64(v); u32 = uint32(u64); w = big(u32)
 		case tu64*100 + ti64:
-			u64 = uint64(v)
-			i64 = int64(u64)
-			w = big(i64)
+			u64 = uint64(v); i64 = int64(u64); w = big(i64)
 		case tu64*100 + tu64:
-			u64 = uint64(v)
-			u64 = uint64(u64)
-			w = big(u64)
+			u64 = uint64(v); u64 = uint64(u64); w = big(u64)
 		case tu64*100 + tf32:
-			u64 = uint64(v)
-			f32 = float32(u64)
-			w = big(f32)
+			u64 = uint64(v); f32 = float32(u64); w = big(f32)
 		case tu64*100 + tf64:
-			u64 = uint64(v)
-			f64 = float64(u64)
-			w = big(f64)
+			u64 = uint64(v); f64 = float64(u64); w = big(f64)
 
 		case tf32*100 + ti8:
-			f32 = float32(v)
-			i8 = int8(f32)
-			w = big(i8)
+			f32 = float32(v); i8 = int8(f32); w = big(i8)
 		case tf32*100 + tu8:
-			f32 = float32(v)
-			u8 = uint8(f32)
-			w = big(u8)
+			f32 = float32(v); u8 = uint8(f32); w = big(u8)
 		case tf32*100 + ti16:
-			f32 = float32(v)
-			i16 = int16(f32)
-			w = big(i16)
+			f32 = float32(v); i16 = int16(f32); w = big(i16)
 		case tf32*100 + tu16:
-			f32 = float32(v)
-			u16 = uint16(f32)
-			w = big(u16)
+			f32 = float32(v); u16 = uint16(f32); w = big(u16)
 		case tf32*100 + ti32:
-			f32 = float32(v)
-			i32 = int32(f32)
-			w = big(i32)
+			f32 = float32(v); i32 = int32(f32); w = big(i32)
 		case tf32*100 + tu32:
-			f32 = float32(v)
-			u32 = uint32(f32)
-			w = big(u32)
+			f32 = float32(v); u32 = uint32(f32); w = big(u32)
 		case tf32*100 + ti64:
-			f32 = float32(v)
-			i64 = int64(f32)
-			w = big(i64)
+			f32 = float32(v); i64 = int64(f32); w = big(i64)
 		case tf32*100 + tu64:
-			f32 = float32(v)
-			u64 = uint64(f32)
-			w = big(u64)
+			f32 = float32(v); u64 = uint64(f32); w = big(u64)
 		case tf32*100 + tf32:
-			f32 = float32(v)
-			f32 = float32(f32)
-			w = big(f32)
+			f32 = float32(v); f32 = float32(f32); w = big(f32)
 		case tf32*100 + tf64:
-			f32 = float32(v)
-			f64 = float64(f32)
-			w = big(f64)
+			f32 = float32(v); f64 = float64(f32); w = big(f64)
 
 		case tf64*100 + ti8:
-			f64 = float64(v)
-			i8 = int8(f64)
-			w = big(i8)
+			f64 = float64(v); i8 = int8(f64); w = big(i8)
 		case tf64*100 + tu8:
-			f64 = float64(v)
-			u8 = uint8(f64)
-			w = big(u8)
+			f64 = float64(v); u8 = uint8(f64); w = big(u8)
 		case tf64*100 + ti16:
-			f64 = float64(v)
-			i16 = int16(f64)
-			w = big(i16)
+			f64 = float64(v); i16 = int16(f64); w = big(i16)
 		case tf64*100 + tu16:
-			f64 = float64(v)
-			u16 = uint16(f64)
-			w = big(u16)
+			f64 = float64(v); u16 = uint16(f64); w = big(u16)
 		case tf64*100 + ti32:
-			f64 = float64(v)
-			i32 = int32(f64)
-			w = big(i32)
+			f64 = float64(v); i32 = int32(f64); w = big(i32)
 		case tf64*100 + tu32:
-			f64 = float64(v)
-			u32 = uint32(f64)
-			w = big(u32)
+			f64 = float64(v); u32 = uint32(f64); w = big(u32)
 		case tf64*100 + ti64:
-			f64 = float64(v)
-			i64 = int64(f64)
-			w = big(i64)
+			f64 = float64(v); i64 = int64(f64); w = big(i64)
 		case tf64*100 + tu64:
-			f64 = float64(v)
-			u64 = uint64(f64)
-			w = big(u64)
+			f64 = float64(v); u64 = uint64(f64); w = big(u64)
 		case tf64*100 + tf32:
-			f64 = float64(v)
-			f32 = float32(f64)
-			w = big(f32)
+			f64 = float64(v); f32 = float32(f64); w = big(f32)
 		case tf64*100 + tf64:
-			f64 = float64(v)
-			f64 = float64(f64)
-			w = big(f64)
-		}
-		if v != w {
-			println(i, v, w, f, t)
+			f64 = float64(v); f64 = float64(f64); w = big(f64)
 		}
+		if v != w { println(i, v, w, f, t) }
 	}
 }
diff --git a/test/ken/cplx2.go b/test/ken/cplx2.go
index 45d9bc613e..eb1da7b8c0 100644
--- a/test/ken/cplx2.go
+++ b/test/ken/cplx2.go
@@ -107,13 +107,13 @@ func main() {
 		println("opcode x", ce, Ce)
 		panic("fail")
 	}
-
+	
 	r32 := real(complex64(ce))
 	if r32 != float32(real(Ce)) {
 		println("real(complex64(ce))", r32, real(Ce))
 		panic("fail")
 	}
-
+	
 	r64 := real(complex128(ce))
 	if r64 != real(Ce) {
 		println("real(complex128(ce))", r64, real(Ce))
diff --git a/test/ken/cplx3.go b/test/ken/cplx3.go
index 8ae567e219..be0b8646ab 100644
--- a/test/ken/cplx3.go
+++ b/test/ken/cplx3.go
@@ -24,7 +24,7 @@ func main() {
 	r, i := real(c0), imag(c0)
 	d := r - 1.292308
 	if d < 0 {
-		d = -d
+		d = - d
 	}
 	if d > 1e-6 {
 		println(r, "!= 1.292308")
@@ -32,7 +32,7 @@ func main() {
 	}
 	d = i + 0.1384615
 	if d < 0 {
-		d = -d
+		d = - d
 	}
 	if d > 1e-6 {
 		println(i, "!= -0.1384615")
diff --git a/test/ken/embed.go b/test/ken/embed.go
index 2e46c34590..f7ca0665e2 100644
--- a/test/ken/embed.go
+++ b/test/ken/embed.go
@@ -8,6 +8,7 @@
 
 package main
 
+
 type I interface {
 	test1() int
 	test2() int
diff --git a/test/ken/for.go b/test/ken/for.go
index 4c257ffcc9..db35548db8 100644
--- a/test/ken/for.go
+++ b/test/ken/for.go
@@ -8,13 +8,12 @@
 
 package main
 
-func main() {
-	var t, i int
+func
+main() {
+	var t,i int;
 
-	for i = 0; i < 100; i = i + 1 {
-		t = t + i
-	}
-	if t != 50*99 {
-		panic(t)
+	for i=0; i<100; i=i+1 {
+		t = t+i;
 	}
+	if t != 50*99  { panic(t); }
 }
diff --git a/test/ken/interfun.go b/test/ken/interfun.go
index 47955c610f..9432181df2 100644
--- a/test/ken/interfun.go
+++ b/test/ken/interfun.go
@@ -9,64 +9,51 @@
 package main
 
 type S struct {
-	a, b int
+	a,b	int;
 }
 
 type I1 interface {
-	f() int
+	f	()int;
 }
 
 type I2 interface {
-	g() int
-	f() int
+	g() int;
+	f() int;
 }
 
-func (this *S) f() int {
-	return this.a
+func (this *S) f()int {
+	return this.a;
 }
 
-func (this *S) g() int {
-	return this.b
+func (this *S) g()int {
+	return this.b;
 }
 
-func main() {
-	var i1 I1
-	var i2 I2
-	var g *S
+func
+main() {
+	var i1 I1;
+	var i2 I2;
+	var g *S;
 
-	s := new(S)
-	s.a = 5
-	s.b = 6
+	s := new(S);
+	s.a = 5;
+	s.b = 6;
 
 	// call structure
-	if s.f() != 5 {
-		panic(11)
-	}
-	if s.g() != 6 {
-		panic(12)
-	}
+	if s.f() != 5 { panic(11); }
+	if s.g() != 6 { panic(12); }
 
-	i1 = s       // convert S to I1
-	i2 = i1.(I2) // convert I1 to I2
+	i1 = s;		// convert S to I1
+	i2 = i1.(I2);	// convert I1 to I2
 
 	// call interface
-	if i1.f() != 5 {
-		panic(21)
-	}
-	if i2.f() != 5 {
-		panic(22)
-	}
-	if i2.g() != 6 {
-		panic(23)
-	}
+	if i1.f() != 5 { panic(21); }
+	if i2.f() != 5 { panic(22); }
+	if i2.g() != 6 { panic(23); }
 
-	g = i1.(*S) // convert I1 to S
-	if g != s {
-		panic(31)
-	}
+	g = i1.(*S);		// convert I1 to S
+	if g != s { panic(31); }
 
-	g = i2.(*S) // convert I2 to S
-	if g != s {
-		panic(32)
-	}
+	g = i2.(*S);		// convert I2 to S
+	if g != s { panic(32); }
 }
diff --git a/test/ken/intervar.go b/test/ken/intervar.go
index 9ae98d92d8..8a2fca0d4b 100644
--- a/test/ken/intervar.go
+++ b/test/ken/intervar.go
@@ -8,59 +8,60 @@
 
 package main
 
-type Iputs interface {
-	puts(s string) string
+type	Iputs	interface {
+	puts	(s string) string;
 }
 
 // ---------
 
-type Print struct {
-	whoami int
-	put    Iputs
+type	Print	struct {
+	whoami	int;
+	put	Iputs;
 }
 
 func (p *Print) dop() string {
-	r := " print " + string(p.whoami+'0')
-	return r + p.put.puts("abc")
+	r := " print " + string(p.whoami + '0')
+	return r + p.put.puts("abc");
 }
 
 // ---------
 
-type Bio struct {
-	whoami int
-	put    Iputs
+type	Bio	struct {
+	whoami	int;
+	put	Iputs;
 }
 
 func (b *Bio) puts(s string) string {
-	r := " bio " + string(b.whoami+'0')
-	return r + b.put.puts(s)
+	r := " bio " + string(b.whoami + '0')
+	return r + b.put.puts(s);
 }
 
 // ---------
 
-type File struct {
-	whoami int
-	put    Iputs
+type	File	struct {
+	whoami	int;
+	put	Iputs;
 }
 
 func (f *File) puts(s string) string {
-	return " file " + string(f.whoami+'0') + " -- " + s
+	return " file " + string(f.whoami + '0') + " -- " + s
 }
 
-func main() {
-	p := new(Print)
-	b := new(Bio)
-	f := new(File)
+func
+main() {
+	p := new(Print);
+	b := new(Bio);
+	f := new(File);
 
-	p.whoami = 1
-	p.put = b
+	p.whoami = 1;
+	p.put = b;
 
-	b.whoami = 2
-	b.put = f
+	b.whoami = 2;
+	b.put = f;
 
-	f.whoami = 3
+	f.whoami = 3;
 
-	r := p.dop()
+	r := p.dop();
 	expected := " print 1 bio 2 file 3 -- abc"
 	if r != expected {
 		panic(r + " != " + expected)
diff --git a/test/ken/litfun.go b/test/ken/litfun.go
index ba19ccf305..e241d4edb7 100644
--- a/test/ken/litfun.go
+++ b/test/ken/litfun.go
@@ -8,17 +8,16 @@
 
 package main
 
-func main() {
-	x := func(a int) int {
-		x := func(a int) int {
-			x := func(a int) int {
-				return a + 5
-			}
-			return x(a) + 7
-		}
-		return x(a) + 11
-	}
-	if x(3) != 3+5+7+11 {
-		panic(x(3))
-	}
+func
+main() {
+	x := func(a int)int {
+		x := func(a int)int {
+			x := func(a int)int {
+				return a+5;
+			};
+			return x(a)+7;
+		};
+		return x(a)+11;
+	};
+	if x(3) != 3+5+7+11 { panic(x(3)); }
 }
diff --git a/test/ken/mfunc.go b/test/ken/mfunc.go
index 3754bbf6a2..ef2499194f 100644
--- a/test/ken/mfunc.go
+++ b/test/ken/mfunc.go
@@ -8,15 +8,15 @@
 
 package main
 
-func main() {
-	var x, y int
+func
+main() {
+	var x,y int;
 
-	x, y = simple(10, 20, 30)
-	if x+y != 65 {
-		panic(x + y)
-	}
+	x,y = simple(10,20,30);
+	if x+y != 65 { panic(x+y); }
 }
 
-func simple(ia, ib, ic int) (oa, ob int) {
-	return ia + 5, ib + ic
+func
+simple(ia,ib,ic int) (oa,ob int) {
+	return ia+5, ib+ic;
 }
diff --git a/test/ken/ptrfun.go b/test/ken/ptrfun.go
index 2fc13a7ebb..af806cfd92 100644
--- a/test/ken/ptrfun.go
+++ b/test/ken/ptrfun.go
@@ -9,44 +9,37 @@
 package main
 
 type C struct {
-	a int
-	x func(p *C) int
+	a	int;
+	x	func(p *C)int;
 }
 
-func (this *C) f() int {
-	return this.a
+func (this *C) f()int {
+	return this.a;
 }
 
-func main() {
-	var v int
-	var c *C
+func
+main() {
+	var v int;
+	var c *C;
 
-	c = new(C)
-	c.a = 6
-	c.x = g
+	c = new(C);
+	c.a = 6;
+	c.x = g;
 
-	v = g(c)
-	if v != 6 {
-		panic(v)
-	}
+	v = g(c);
+	if v != 6 { panic(v); }
 
-	v = c.x(c)
-	if v != 6 {
-		panic(v)
-	}
+	v = c.x(c);
+	if v != 6 { panic(v); }
 
-	v = c.f()
-	if v != 6 {
-		panic(v)
-	}
+	v = c.f();
+	if v != 6 { panic(v); }
 }
 
-func g(p *C) int {
-	var v int
+func g(p *C)int {
+	var v int;
 
-	v = p.a
-	if v != 6 {
-		panic(v)
-	}
-	return p.a
+	v = p.a;
+	if v != 6 { panic(v); }
+	return p.a;
 }
diff --git a/test/ken/ptrvar.go b/test/ken/ptrvar.go
index 4d1b9eb794..d78170c9d2 100644
--- a/test/ken/ptrvar.go
+++ b/test/ken/ptrvar.go
@@ -8,49 +8,36 @@
 
 package main
 
-type x2 struct {
-	a, b, c int
-	d       int
-}
-
-var g1 x2
-var g2 struct {
-	a, b, c int
-	d       x2
-}
-
-func main() {
-	var x int
-	var s1 *x2
-	var s2 *struct {
-		a, b, c int
-		d       x2
-	}
-
-	s1 = &g1
-	s2 = &g2
-
-	s1.a = 1
-	s1.b = 2
-	s1.c = 3
-	s1.d = 5
-
-	s2.a = 7
-	s2.b = 11
-	s2.c = 13
-	s2.d.a = 17
-	s2.d.b = 19
-	s2.d.c = 23
-	s2.d.d = 20
-
-	if s2.d.c != 23 {
-		panic(1)
-	}
-	if g2.d.c != 23 {
-		panic(2)
-	}
-
-	x = s1.a +
+type	x2	struct { a,b,c int; d int; };
+var	g1	x2;
+var	g2	struct { a,b,c int; d x2; };
+
+func
+main() {
+	var x int;
+	var s1 *x2;
+	var s2 *struct { a,b,c int; d x2; };
+
+	s1 = &g1;
+	s2 = &g2;
+
+	s1.a = 1;
+	s1.b = 2;
+	s1.c = 3;
+	s1.d = 5;
+
+	s2.a = 7;
+	s2.b = 11;
+	s2.c = 13;
+	s2.d.a = 17;
+	s2.d.b = 19;
+	s2.d.c = 23;
+	s2.d.d = 20;
+
+	if(s2.d.c != 23) { panic(1); }
+	if(g2.d.c != 23) { panic(2); }
+
+	x =	s1.a +
 		s1.b +
 		s1.c +
 		s1.d +
@@ -61,9 +48,7 @@ func main() {
 		s2.d.a +
 		s2.d.b +
 		s2.d.c +
-		s2.d.d
+		s2.d.d;
 
-	if x != 121 {
-		panic(x)
-	}
+	if(x != 121) { panic(x); }
 }
diff --git a/test/ken/robfor.go b/test/ken/robfor.go
index 3269c0714b..c6a420b39d 100644
--- a/test/ken/robfor.go
+++ b/test/ken/robfor.go
@@ -10,49 +10,49 @@ package main
 
 func assertequal(is, shouldbe int, msg string) {
 	if is != shouldbe {
-		print("assertion fail" + msg + "\n")
-		panic(1)
+		print("assertion fail" + msg + "\n");
+		panic(1);
 	}
 }
 
 func main() {
-	var i, sum int
+	var i, sum int;
 
-	i = 0
+	i = 0;
 	for {
-		i = i + 1
+		i = i + 1;
 		if i > 5 {
-			break
+			break;
 		}
 	}
-	assertequal(i, 6, "break")
+	assertequal(i, 6, "break");
 
-	sum = 0
+	sum = 0;
 	for i := 0; i <= 10; i++ {
-		sum = sum + i
+		sum = sum + i;
 	}
-	assertequal(sum, 55, "all three")
+	assertequal(sum, 55, "all three");
 
-	sum = 0
+	sum = 0;
 	for i := 0; i <= 10; {
-		sum = sum + i
-		i++
+		sum = sum + i;
+		i++;
 	}
-	assertequal(sum, 55, "only two")
+	assertequal(sum, 55, "only two");
 
-	sum = 0
+	sum = 0;
 	for sum < 100 {
-		sum = sum + 9
+		sum = sum + 9;
 	}
-	assertequal(sum, 99+9, "only one")
+	assertequal(sum, 99 + 9, "only one");
 
-	sum = 0
+	sum = 0;
 	for i := 0; i <= 10; i++ {
-		if i%2 == 0 {
-			continue
+		if i % 2 == 0 {
+			continue;
 		}
-		sum = sum + i
+		sum = sum + i;
 	}
-	assertequal(sum, 1+3+5+7+9, "continue")
+	assertequal(sum, 1+3+5+7+9, "continue");
 
 }
diff --git a/test/ken/robfunc.go b/test/ken/robfunc.go
index 6a417c073f..885267e30c 100644
--- a/test/ken/robfunc.go
+++ b/test/ken/robfunc.go
@@ -41,6 +41,7 @@ func f7(a int) (x int, y float64) {
 	return 7, 7.0
 }
 
+
 func f8(a int) (x int, y float64) {
 	return 8, 8.0
 }
@@ -53,12 +54,14 @@ func (t *T) m10(a int, b float64) int {
 	return (t.x + a) * (t.y + int(b))
 }
 
+
 func f9(a int) (in int, fl float64) {
 	i := 9
 	f := float64(9)
 	return i, f
 }
 
+
 func main() {
 	f1()
 	f2(1)
diff --git a/test/ken/shift.go b/test/ken/shift.go
index 895e7e90aa..af8789615e 100644
--- a/test/ken/shift.go
+++ b/test/ken/shift.go
@@ -8,122 +8,114 @@
 
 package main
 
-var ians [18]int
-var uans [18]uint
-var pass string
+var	ians	[18]int;
+var	uans	[18]uint;
+var	pass	string;
 
-func testi(i int, t1, t2, t3 int) {
-	n := ((t1*3)+t2)*2 + t3
+func
+testi(i int, t1,t2,t3 int) {
+	n := ((t1*3) + t2)*2 + t3;
 	if i != ians[n] {
-		print("itest ", t1, t2, t3, pass,
-			" is ", i, " sb ", ians[n], "\n")
+		print("itest ", t1,t2,t3,pass,
+			" is ", i, " sb ", ians[n], "\n");
 	}
 }
 
-func index(t1, t2, t3 int) int {
-	return ((t1*3)+t2)*2 + t3
+func
+index(t1,t2,t3 int) int {
+	return ((t1*3) + t2)*2 + t3;
 }
 
-func testu(u uint, t1, t2, t3 int) {
-	n := index(t1, t2, t3)
+func
+testu(u uint, t1,t2,t3 int) {
+	n := index(t1,t2,t3);
 	if u != uans[n] {
-		print("utest ", t1, t2, t3, pass,
-			" is ", u, " sb ", uans[n], "\n")
+		print("utest ", t1,t2,t3,pass,
+			" is ", u, " sb ", uans[n], "\n");
 	}
 }
 
-func main() {
-	var i int
-	var u, c uint
+func
+main() {
+	var i int;
+	var u,c uint;
 
 	/*
 	 * test constant evaluations
 	 */
-	pass = "con" // constant part
+	pass = "con";	// constant part
 
-	testi(int(1234)<<0, 0, 0, 0)
-	testi(int(1234)>>0, 0, 0, 1)
-	testi(int(1234)<<5, 0, 1, 0)
-	testi(int(1234)>>5, 0, 1, 1)
+	testi( int(1234) <<    0, 0,0,0);
+	testi( int(1234) >>    0, 0,0,1);
+	testi( int(1234) <<    5, 0,1,0);
+	testi( int(1234) >>    5, 0,1,1);
 
-	testi(int(-1234)<<0, 1, 0, 0)
-	testi(int(-1234)>>0, 1, 0, 1)
-	testi(int(-1234)<<5, 1, 1, 0)
-	testi(int(-1234)>>5, 1, 1, 1)
+	testi(int(-1234) <<    0, 1,0,0);
+	testi(int(-1234) >>    0, 1,0,1);
+	testi(int(-1234) <<    5, 1,1,0);
+	testi(int(-1234) >>    5, 1,1,1);
 
-	testu(uint(5678)<<0, 2, 0, 0)
-	testu(uint(5678)>>0, 2, 0, 1)
-	testu(uint(5678)<<5, 2, 1, 0)
-	testu(uint(5678)>>5, 2, 1, 1)
+	testu(uint(5678) <<    0, 2,0,0);
+	testu(uint(5678) >>    0, 2,0,1);
+	testu(uint(5678) <<    5, 2,1,0);
+	testu(uint(5678) >>    5, 2,1,1);
 
 	/*
 	 * test variable evaluations
 	 */
-	pass = "var" // variable part
-
-	for t1 := 0; t1 < 3; t1++ { // +int, -int, uint
-		for t2 := 0; t2 < 3; t2++ { // 0, +small, +large
-			for t3 := 0; t3 < 2; t3++ { // <<, >>
-				switch t1 {
-				case 0:
-					i = 1234
-				case 1:
-					i = -1234
-				case 2:
-					u = 5678
-				}
-				switch t2 {
-				case 0:
-					c = 0
-				case 1:
-					c = 5
-				case 2:
-					c = 1025
-				}
-				switch t3 {
-				case 0:
-					i <<= c
-					u <<= c
-				case 1:
-					i >>= c
-					u >>= c
-				}
-				switch t1 {
-				case 0:
-					testi(i, t1, t2, t3)
-				case 1:
-					testi(i, t1, t2, t3)
-				case 2:
-					testu(u, t1, t2, t3)
-				}
-			}
+	pass = "var";	// variable part
+
+	for t1:=0; t1<3; t1++ {	// +int, -int, uint
+	for t2:=0; t2<3; t2++ {	// 0, +small, +large
+	for t3:=0; t3<2; t3++ {	// <<, >>
+		switch t1 {
+		case 0:	i =  1234;
+		case 1:	i = -1234;
+		case 2:	u =  5678;
 		}
+		switch t2 {
+		case 0:	c =    0;
+		case 1:	c =    5;
+		case 2:	c = 1025;
+		}
+		switch t3 {
+		case 0:	i <<= c; u <<= c;
+		case 1:	i >>= c; u >>= c;
+		}
+		switch t1 {
+		case 0:	testi(i,t1,t2,t3);
+		case 1:	testi(i,t1,t2,t3);
+		case 2:	testu(u,t1,t2,t3);
+		}
+	}
+	}
 	}
 }
 
-func init() {
+func
+init() {
 	/*
 	 * set the 'correct' answer
 	 */
 
-	ians[index(0, 0, 0)] = 1234
-	ians[index(0, 0, 1)] = 1234
-	ians[index(0, 1, 0)] = 39488
-	ians[index(0, 1, 1)] = 38
-	ians[index(0, 2, 0)] = 0
-	ians[index(0, 2, 1)] = 0
-
-	ians[index(1, 0, 0)] = -1234
-	ians[index(1, 0, 1)] = -1234
-	ians[index(1, 1, 0)] = -39488
-	ians[index(1, 1, 1)] = -39
-	ians[index(1, 2, 0)] = 0
-	ians[index(1, 2, 1)] = -1
-
-	uans[index(2, 0, 0)] = 5678
-	uans[index(2, 0, 1)] = 5678
-	uans[index(2, 1, 0)] = 181696
-	uans[index(2, 1, 1)] = 177
-	uans[index(2, 2, 0)] = 0
-	uans[index(2, 2, 1)] = 0
+	ians[index(0,0,0)] =   1234;
+	ians[index(0,0,1)] =   1234;
+	ians[index(0,1,0)] =  39488;
+	ians[index(0,1,1)] =     38;
+	ians[index(0,2,0)] =      0;
+	ians[index(0,2,1)] =      0;
+
+	ians[index(1,0,0)] =  -1234;
+	ians[index(1,0,1)] =  -1234;
+	ians[index(1,1,0)] = -39488;
+	ians[index(1,1,1)] =    -39;
+	ians[index(1,2,0)] =      0;
+	ians[index(1,2,1)] =     -1;
+
+	uans[index(2,0,0)] =   5678;
+	uans[index(2,0,1)] =   5678;
+	uans[index(2,1,0)] = 181696;
+	uans[index(2,1,1)] =    177;
+	uans[index(2,2,0)] =      0;
+	uans[index(2,2,1)] =      0;
 }
diff --git a/test/ken/simparray.go b/test/ken/simparray.go
index 51bbeaae83..0e81a341b8 100644
--- a/test/ken/simparray.go
+++ b/test/ken/simparray.go
@@ -8,48 +8,43 @@
 
 package main
 
-var b [10]float32
+var b[10] float32;
 
-func main() {
-	var a [10]float32
+func
+main() {
+	var a[10] float32;
 
-	for i := int16(5); i < 10; i = i + 1 {
-		a[i] = float32(i)
+	for i:=int16(5); i<10; i=i+1 {
+		a[i] = float32(i);
 	}
 
-	s1 := float32(0)
-	for i := 5; i < 10; i = i + 1 {
-		s1 = s1 + a[i]
+	s1 := float32(0);
+	for i:=5; i<10; i=i+1 {
+		s1 = s1 + a[i];
 	}
 
-	if s1 != 35 {
-		panic(s1)
-	}
+	if s1 != 35 { panic(s1); }
 
-	for i := int16(5); i < 10; i = i + 1 {
-		b[i] = float32(i)
+	for i:=int16(5); i<10; i=i+1 {
+		b[i] = float32(i);
 	}
 
-	s2 := float32(0)
-	for i := 5; i < 10; i = i + 1 {
-		s2 = s2 + b[i]
+	s2 := float32(0);
+	for i:=5; i<10; i=i+1 {
+		s2 = s2 + b[i];
 	}
 
-	if s2 != 35 {
-		panic(s2)
-	}
+	if s2 != 35 { panic(s2); }
 
-	b := new([100]int)
-	for i := 0; i < 100; i = i + 1 {
-		b[i] = i
+	b := new([100]int);
+	for i:=0; i<100; i=i+1 {
+		b[i] = i;
 	}
 
-	s3 := 0
-	for i := 0; i < 100; i = i + 1 {
-		s3 = s3 + b[i]
+	s3 := 0;
+	for i:=0; i<100; i=i+1 {
+		s3 = s3+b[i];
 	}
 
-	if s3 != 4950 {
-		panic(s3)
-	}
+	if s3 != 4950 { panic(s3); }
 }
diff --git a/test/ken/simpbool.go b/test/ken/simpbool.go
index 25c10cfcfe..ab2ecc21aa 100644
--- a/test/ken/simpbool.go
+++ b/test/ken/simpbool.go
@@ -9,186 +9,99 @@
 package main
 
 type s struct {
-	a bool
-	b bool
+	a	bool;
+	b	bool;
 }
 
-func main() {
-	var a, b bool
-
-	a = true
-	b = false
-
-	if !a {
-		panic(1)
-	}
-	if b {
-		panic(2)
-	}
-	if !!!a {
-		panic(3)
-	}
-	if !!b {
-		panic(4)
-	}
-
-	a = !b
-	if !a {
-		panic(5)
-	}
-	if !!!a {
-		panic(6)
-	}
-
-	var x *s
-	x = new(s)
-	x.a = true
-	x.b = false
-
-	if !x.a {
-		panic(7)
-	}
-	if x.b {
-		panic(8)
-	}
-	if !!!x.a {
-		panic(9)
-	}
-	if !!x.b {
-		panic(10)
-	}
-
-	x.a = !x.b
-	if !x.a {
-		panic(11)
-	}
-	if !!!x.a {
-		panic(12)
-	}
+func
+main() {
+	var a,b bool;
+
+	a = true;
+	b = false;
+
+	if !a { panic(1); }
+	if b { panic(2); }
+	if !!!a { panic(3); }
+	if !!b { panic(4); }
+
+	a = !b;
+	if !a { panic(5); }
+	if !!!a { panic(6); }
+
+	var x *s;
+	x = new(s);
+	x.a = true;
+	x.b = false;
+
+	if !x.a { panic(7); }
+	if x.b { panic(8); }
+	if !!!x.a { panic(9); }
+	if !!x.b { panic(10); }
+
+	x.a = !x.b;
+	if !x.a { panic(11); }
+	if !!!x.a { panic(12); }
 
 	/*
 	 * test &&
 	 */
-	a = true
-	b = true
-	if !(a && b) {
-		panic(21)
-	}
-	if a && !b {
-		panic(22)
-	}
-	if !a && b {
-		panic(23)
-	}
-	if !a && !b {
-		panic(24)
-	}
-
-	a = false
-	b = true
-	if !(!a && b) {
-		panic(31)
-	}
-	if !a && !b {
-		panic(32)
-	}
-	if a && b {
-		panic(33)
-	}
-	if a && !b {
-		panic(34)
-	}
-
-	a = true
-	b = false
-	if !(a && !b) {
-		panic(41)
-	}
-	if a && b {
-		panic(41)
-	}
-	if !a && !b {
-		panic(41)
-	}
-	if !a && b {
-		panic(44)
-	}
-
-	a = false
-	b = false
-	if !(!a && !b) {
-		panic(51)
-	}
-	if !a && b {
-		panic(52)
-	}
-	if a && !b {
-		panic(53)
-	}
-	if a && b {
-		panic(54)
-	}
+	a = true;
+	b = true;
+	if !(a && b) { panic(21); }
+	if a && !b { panic(22); }
+	if !a && b { panic(23); }
+	if !a && !b { panic(24); }
+
+	a = false;
+	b = true;
+	if !(!a && b) { panic(31); }
+	if !a && !b { panic(32); }
+	if a && b { panic(33); }
+	if a && !b { panic(34); }
+
+	a = true;
+	b = false;
+	if !(a && !b) { panic(41); }
+	if a && b { panic(41); }
+	if !a && !b { panic(41); }
+	if !a && b { panic(44); }
+
+	a = false;
+	b = false;
+	if !(!a && !b) { panic(51); }
+	if !a && b { panic(52); }
+	if a && !b { panic(53); }
+	if a && b { panic(54); }
 
 	/*
 	 * test ||
 	 */
-	a = true
-	b = true
-	if !(a || b) {
-		panic(61)
-	}
-	if !(a || !b) {
-		panic(62)
-	}
-	if !(!a || b) {
-		panic(63)
-	}
-	if !a || !b {
-		panic(64)
-	}
-
-	a = false
-	b = true
-	if !(!a || b) {
-		panic(71)
-	}
-	if !(!a || !b) {
-		panic(72)
-	}
-	if !(a || b) {
-		panic(73)
-	}
-	if a || !b {
-		panic(74)
-	}
-
-	a = true
-	b = false
-	if !(a || !b) {
-		panic(81)
-	}
-	if !(a || b) {
-		panic(82)
-	}
-	if !(!a || !b) {
-		panic(83)
-	}
-	if !a || b {
-		panic(84)
-	}
-
-	a = false
-	b = false
-	if !(!a || !b) {
-		panic(91)
-	}
-	if !(!a || b) {
-		panic(92)
-	}
-	if !(a || !b) {
-		panic(93)
-	}
-	if a || b {
-		panic(94)
-	}
+	a = true;
+	b = true;
+	if !(a || b) { panic(61); }
+	if !(a || !b) { panic(62); }
+	if !(!a || b) { panic(63); }
+	if !a || !b { panic(64); }
+
+	a = false;
+	b = true;
+	if !(!a || b) { panic(71); }
+	if !(!a || !b) { panic(72); }
+	if !(a || b) { panic(73); }
+	if a || !b { panic(74); }
+
+	a = true;
+	b = false;
+	if !(a || !b) { panic(81); }
+	if !(a || b) { panic(82); }
+	if !(!a || !b) { panic(83); }
+	if !a || b { panic(84); }
+
+	a = false;
+	b = false;
+	if !(!a || !b) { panic(91); }
+	if !(!a || b) { panic(92); }
+	if !(a || !b) { panic(93); }
+	if a || b { panic(94); }
 }
diff --git a/test/ken/simpfun.go b/test/ken/simpfun.go
index 1d5534b9fa..e5dc2b2495 100644
--- a/test/ken/simpfun.go
+++ b/test/ken/simpfun.go
@@ -8,21 +8,19 @@
 
 package main
 
-func main() {
-	var x int
+func
+main() {
+	var x int;
 
-	x = fun(10, 20, 30)
-	if x != 60 {
-		panic(x)
-	}
+	x = fun(10,20,30);
+	if x != 60 { panic(x); }
 }
 
-func fun(ia, ib, ic int) int {
-	var o int
+func
+fun(ia,ib,ic int)int {
+	var o int;
 
-	o = ia + ib + ic
-	if o != 60 {
-		panic(o)
-	}
-	return o
+	o = ia+ib+ic;
+	if o != 60 { panic(o); }
+	return o;
 }
diff --git a/test/ken/simpvar.go b/test/ken/simpvar.go
index 039d32c94e..c6eefbb5ad 100644
--- a/test/ken/simpvar.go
+++ b/test/ken/simpvar.go
@@ -6,22 +6,22 @@
 
 // Test scoping of variables.
 
+
 package main
 
-var x, y int
+var	x,y	int;
 
-func main() {
+func
+main() {
 
-	x = 15
-	y = 20
+	x = 15;
+	y = 20;
 	{
-		var x int
-		x = 25
-		y = 25
-		_ = x
-	}
-	x = x + y
-	if x != 40 {
-		panic(x)
+		var x int;
+		x = 25;
+		y = 25;
+		_ = x;
 	}
+	x = x+y;
+	if(x != 40) { panic(x); }
 }
diff --git a/test/ken/strvar.go b/test/ken/strvar.go
index 826d796e01..4d511fe673 100644
--- a/test/ken/strvar.go
+++ b/test/ken/strvar.go
@@ -8,60 +8,40 @@
 
 package main
 
-type x2 struct {
-	a, b, c int
-	d       int
-}
-
-var g1 x2
-var g2 struct {
-	a, b, c int
-	d       x2
-}
-
-func main() {
-	var x int
-	var s1 *x2
-	var s2 *struct {
-		a, b, c int
-		d       x2
-	}
-	var s3 struct {
-		a, b, c int
-		d       x2
-	}
-
-	s1 = &g1
-	s2 = &g2
-
-	s1.a = 1
-	s1.b = 2
-	s1.c = 3
-	s1.d = 5
-
-	if s1.c != 3 {
-		panic(s1.c)
-	}
-	if g1.c != 3 {
-		panic(g1.c)
-	}
-
-	s2.a = 7
-	s2.b = 11
-	s2.c = 13
-	s2.d.a = 17
-	s2.d.b = 19
-	s2.d.c = 23
-	s2.d.d = 29
-
-	if s2.d.c != 23 {
-		panic(s2.d.c)
-	}
-	if g2.d.c != 23 {
-		panic(g2.d.c)
-	}
-
-	x = s1.a +
+type	x2	struct { a,b,c int; d int; };
+var	g1	x2;
+var	g2	struct { a,b,c int; d x2; };
+
+func
+main() {
+	var x int;
+	var s1 *x2;
+	var s2 *struct { a,b,c int; d x2; };
+	var s3 struct { a,b,c int; d x2; };
+
+	s1 = &g1;
+	s2 = &g2;
+
+	s1.a = 1;
+	s1.b = 2;
+	s1.c = 3;
+	s1.d = 5;
+
+	if(s1.c != 3) { panic(s1.c); }
+	if(g1.c != 3) { panic(g1.c); }
+
+	s2.a = 7;
+	s2.b = 11;
+	s2.c = 13;
+	s2.d.a = 17;
+	s2.d.b = 19;
+	s2.d.c = 23;
+	s2.d.d = 29;
+
+	if(s2.d.c != 23) { panic(s2.d.c); }
+	if(g2.d.c != 23) { panic(g2.d.c); }
+
+	x =	s1.a +
 		s1.b +
 		s1.c +
 		s1.d +
@@ -72,34 +52,28 @@ func main() {
 		s2.d.a +
 		s2.d.b +
 		s2.d.c +
-		s2.d.d
+		s2.d.d;
 
-	if x != 130 {
-		panic(x)
-	}
+	if(x != 130) { panic(x); }
 
 	// test an automatic struct
-	s3.a = 7
-	s3.b = 11
-	s3.c = 13
-	s3.d.a = 17
-	s3.d.b = 19
-	s3.d.c = 23
-	s3.d.d = 29
-
-	if s3.d.c != 23 {
-		panic(s3.d.c)
-	}
-
-	x = s3.a +
+	s3.a = 7;
+	s3.b = 11;
+	s3.c = 13;
+	s3.d.a = 17;
+	s3.d.b = 19;
+	s3.d.c = 23;
+	s3.d.d = 29;
+
+	if(s3.d.c != 23) { panic(s3.d.c); }
+
+	x =	s3.a +
 		s3.b +
 		s3.c +
 		s3.d.a +
 		s3.d.b +
 		s3.d.c +
-		s3.d.d
+		s3.d.d;
 
-	if x != 119 {
-		panic(x)
-	}
+	if(x != 119) { panic(x); }
 }
diff --git a/test/literal2.go b/test/literal2.go
index 064d47f726..f552e33ada 100644
--- a/test/literal2.go
+++ b/test/literal2.go
@@ -31,8 +31,8 @@ func main() {
 	assert(0_1 == 01)
 	assert(012 == 012)
 	assert(0_1_2 == 012)
-	assert(1_2i == complex(0, 12)) // decimal digits despite leading 0 for backward-compatibility
-	assert(89i == complex(0, 89))  // decimal digits despite leading 0 for backward-compatibility
+	assert(0_1_2i == complex(0, 12)) // decimal digits despite leading 0 for backward-compatibility
+	assert(00089i == complex(0, 89)) // decimal digits despite leading 0 for backward-compatibility
 
 	// decimals
 	assert(1_000_000 == 1000000)
diff --git a/test/live1.go b/test/live1.go
index 3d37b9ec53..87c8c97c41 100644
--- a/test/live1.go
+++ b/test/live1.go
@@ -43,3 +43,4 @@ func f1(pkg, typ, meth string) {
 func f2() interface{} {
 	return new(int)
 }
+
diff --git a/test/live_syscall.go b/test/live_syscall.go
index 1f9a2c2668..2d1ef14de7 100644
--- a/test/live_syscall.go
+++ b/test/live_syscall.go
@@ -30,7 +30,7 @@ func h() { // ERROR "can inline h"
 func i() { // ERROR "can inline i"
 	var t int
 	p := unsafe.Pointer(&t)
-	f(uintptr(p)) // ERROR "live at call to f: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
+	f(uintptr(p))           // ERROR "live at call to f: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
 }
 
 func j() { // ERROR "can inline j"
diff --git a/test/map1.go b/test/map1.go
index 91589a7c48..498c2ec45b 100644
--- a/test/map1.go
+++ b/test/map1.go
@@ -39,10 +39,10 @@ var (
 	_ map[[]int]v       // ERROR "invalid map key"
 	_ map[func()]v      // ERROR "invalid map key"
 	_ map[map[int]int]v // ERROR "invalid map key"
-	_ map[T1]v          // ERROR "invalid map key"
-	_ map[T2]v          // ERROR "invalid map key"
-	_ map[T3]v          // ERROR "invalid map key"
-	_ map[T4]v          // ERROR "invalid map key"
+	_ map[T1]v    // ERROR "invalid map key"
+	_ map[T2]v    // ERROR "invalid map key"
+	_ map[T3]v    // ERROR "invalid map key"
+	_ map[T4]v    // ERROR "invalid map key"
 	_ map[T5]v
 	_ map[T6]v
 	_ map[T7]v
@@ -50,14 +50,14 @@ var (
 )
 
 type T1 []int
-type T2 struct{ F T1 }
+type T2 struct { F T1 }
 type T3 []T4
-type T4 struct{ F T3 }
+type T4 struct { F T3 }
 
 type T5 *int
-type T6 struct{ F T5 }
+type T6 struct { F T5 }
 type T7 *T4
-type T8 struct{ F *T7 }
+type T8 struct { F *T7 }
 
 func main() {
 	m := make(map[int]int)
@@ -65,4 +65,4 @@ func main() {
 	delete(m)       // ERROR "missing second \(key\) argument"
 	delete(m, 2, 3) // ERROR "too many arguments"
 	delete(1, m)    // ERROR "first argument to delete must be map"
-}
+}
\ No newline at end of file
diff --git a/test/method5.go b/test/method5.go
index e48baf4ccc..d87bb6f5b2 100644
--- a/test/method5.go
+++ b/test/method5.go
@@ -16,53 +16,53 @@ type Tinter interface {
 
 type Tsmallv byte
 
-func (v Tsmallv) M(x int, b byte) (byte, int) { return b, x + int(v) }
+func (v Tsmallv) M(x int, b byte) (byte, int) { return b, x+int(v) }
 
 type Tsmallp byte
 
-func (p *Tsmallp) M(x int, b byte) (byte, int) { return b, x + int(*p) }
+func (p *Tsmallp) M(x int, b byte) (byte, int) { return b, x+int(*p) }
 
 type Twordv uintptr
 
-func (v Twordv) M(x int, b byte) (byte, int) { return b, x + int(v) }
+func (v Twordv) M(x int, b byte) (byte, int) { return b, x+int(v) }
 
 type Twordp uintptr
 
-func (p *Twordp) M(x int, b byte) (byte, int) { return b, x + int(*p) }
+func (p *Twordp) M(x int, b byte) (byte, int) { return b, x+int(*p) }
 
 type Tbigv [2]uintptr
 
-func (v Tbigv) M(x int, b byte) (byte, int) { return b, x + int(v[0]) + int(v[1]) }
+func (v Tbigv) M(x int, b byte) (byte, int) { return b, x+int(v[0])+int(v[1]) }
 
 type Tbigp [2]uintptr
 
-func (p *Tbigp) M(x int, b byte) (byte, int) { return b, x + int(p[0]) + int(p[1]) }
+func (p *Tbigp) M(x int, b byte) (byte, int) { return b, x+int(p[0])+int(p[1]) }
 
 // Again, with an unexported method.
 
 type tsmallv byte
 
-func (v tsmallv) m(x int, b byte) (byte, int) { return b, x + int(v) }
+func (v tsmallv) m(x int, b byte) (byte, int) { return b, x+int(v) }
 
 type tsmallp byte
 
-func (p *tsmallp) m(x int, b byte) (byte, int) { return b, x + int(*p) }
+func (p *tsmallp) m(x int, b byte) (byte, int) { return b, x+int(*p) }
 
 type twordv uintptr
 
-func (v twordv) m(x int, b byte) (byte, int) { return b, x + int(v) }
+func (v twordv) m(x int, b byte) (byte, int) { return b, x+int(v) }
 
 type twordp uintptr
 
-func (p *twordp) m(x int, b byte) (byte, int) { return b, x + int(*p) }
+func (p *twordp) m(x int, b byte) (byte, int) { return b, x+int(*p) }
 
 type tbigv [2]uintptr
 
-func (v tbigv) m(x int, b byte) (byte, int) { return b, x + int(v[0]) + int(v[1]) }
+func (v tbigv) m(x int, b byte) (byte, int) { return b, x+int(v[0])+int(v[1]) }
 
 type tbigp [2]uintptr
 
-func (p *tbigp) m(x int, b byte) (byte, int) { return b, x + int(p[0]) + int(p[1]) }
+func (p *tbigp) m(x int, b byte) (byte, int) { return b, x+int(p[0])+int(p[1]) }
 
 type tinter interface {
 	m(int, byte) (byte, int)
@@ -85,7 +85,7 @@ type T3 struct {
 type T4 struct {
 }
 
-func (t4 T4) M(x int, b byte) (byte, int) { return b, x + 40 }
+func (t4 T4) M(x int, b byte) (byte, int) { return b, x+40 }
 
 var failed = false
 
@@ -95,7 +95,7 @@ func CheckI(name string, i Tinter, inc int) {
 		failed = true
 		print(name, ".M(1000, 99) = ", b, ", ", x, " want 99, ", 1000+inc, "\n")
 	}
-
+	
 	CheckF("(i="+name+")", i.M, inc)
 }
 
@@ -113,7 +113,7 @@ func checkI(name string, i tinter, inc int) {
 		failed = true
 		print(name, ".m(1000, 99) = ", b, ", ", x, " want 99, ", 1000+inc, "\n")
 	}
-
+	
 	checkF("(i="+name+")", i.m, inc)
 }
 
@@ -183,8 +183,8 @@ func main() {
 	CheckI("pbv", pbv, 11)
 	CheckF("pbv.M", pbv.M, 11)
 	CheckF("(*pbv).M", (*pbv).M, 11)
-
-	bp := Tbigp([2]uintptr{7, 8})
+	
+	bp := Tbigp([2]uintptr{7,8})
 	CheckI("&bp", &bp, 15)
 	CheckF("bp.M", bp.M, 15)
 	CheckF("(&bp).M", (&bp).M, 15)
@@ -237,8 +237,8 @@ func main() {
 	checkI("_pbv", _pbv, 11)
 	checkF("_pbv.m", _pbv.m, 11)
 	checkF("(*_pbv).m", (*_pbv).m, 11)
-
-	_bp := tbigp([2]uintptr{7, 8})
+	
+	_bp := tbigp([2]uintptr{7,8})
 	checkI("&_bp", &_bp, 15)
 	checkF("_bp.m", _bp.m, 15)
 	checkF("(&_bp).m", (&_bp).m, 15)
@@ -246,7 +246,7 @@ func main() {
 	checkI("_pbp", _pbp, 15)
 	checkF("_pbp.m", _pbp.m, 15)
 	checkF("(*_pbp).m", (*_pbp).m, 15)
-
+	
 	t4 := T4{}
 	t3 := T3{&t4}
 	t2 := T2{&t3}
@@ -259,7 +259,7 @@ func main() {
 	CheckI("&t2", &t2, 40)
 	CheckI("t1", t1, 40)
 	CheckI("&t1", &t1, 40)
-
+	
 	// x.M panics if x is an interface type and is nil,
 	// or if x.M expands to (*x).M where x is nil,
 	// or if x.M expands to x.y.z.w.M where something
@@ -281,7 +281,7 @@ func main() {
 	if f != nil {
 		panic("something set f")
 	}
-
+	
 	// x.M does not panic if x is a nil pointer and
 	// M is a method with a pointer receiver.
 	shouldNotPanic(func() { psp = nil; f = psp.M })
diff --git a/test/named.go b/test/named.go
index 60a88c542b..9763c76bfd 100644
--- a/test/named.go
+++ b/test/named.go
@@ -31,6 +31,7 @@ func asString(String) {}
 
 func (Map) M() {}
 
+
 // These functions check at run time that the default type
 // (in the absence of any implicit conversion hints)
 // is the given type.
diff --git a/test/nilptr2.go b/test/nilptr2.go
index 8e3be659bb..8a85b6dbcb 100644
--- a/test/nilptr2.go
+++ b/test/nilptr2.go
@@ -27,7 +27,7 @@ func main() {
 var intp *int
 var slicep *[]byte
 var a10p *[10]int
-var a10Mp *[1 << 20]int
+var a10Mp *[1<<20]int
 var structp *Struct
 var bigstructp *BigStruct
 var i int
@@ -41,9 +41,9 @@ func use(x interface{}) {
 	V = x
 }
 
-var tests = []struct {
+var tests = []struct{
 	name string
-	fn   func()
+	fn func()
 }{
 	// Edit .+1,/^}/s/^[^	].+/	{"&", func() { println(&) }},\n	{"\&&", func() { println(\&&) }},/g
 	{"*intp", func() { println(*intp) }},
@@ -112,14 +112,14 @@ type BigStruct struct {
 	i int
 	j float64
 	k string
-	x [128 << 20]byte
+	x [128<<20]byte
 	l []byte
 }
 
 type M struct {
 }
 
-func (m *M) F() int { return 0 }
+func (m *M) F() int {return 0}
 
 type M1 struct {
 	M
diff --git a/test/oldescape2.go b/test/oldescape2.go
index fc686cb921..864a956164 100644
--- a/test/oldescape2.go
+++ b/test/oldescape2.go
@@ -146,13 +146,13 @@ func (b Bar) AlsoLeak() *int { // ERROR "leaking param: b to result ~r0 level=0$
 }
 
 func (b Bar) LeaksToo() *int { // ERROR "leaking param: b to result ~r0 level=0$"
-	v := 0 // ERROR "moved to heap: v$"
+	v := 0    // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
 
 func (b *Bar) LeaksABit() *int { // ERROR "leaking param: b to result ~r0 level=1$"
-	v := 0 // ERROR "moved to heap: v$"
+	v := 0    // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
@@ -522,7 +522,7 @@ func foo72a() {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
 		// escapes its scope
-		x := i // ERROR "moved to heap: x$"
+		x := i    // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return
@@ -531,7 +531,7 @@ func foo72a() {
 func foo72b() [10]*int {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
-		x := i // ERROR "moved to heap: x$"
+		x := i    // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return y
@@ -739,11 +739,11 @@ func tee(p *int) (x, y *int) { return p, p } // ERROR "leaking param: p to resul
 func noop(x, y *int) {} // ERROR "noop x does not escape$" "noop y does not escape$"
 
 func foo82() {
-	var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
+	var x, y, z int  // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
 	go noop(tee(&z))
 	go noop(&x, &y)
 	for {
-		var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
+		var u, v, w int     // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
 		defer noop(tee(&u))
 		defer noop(&v, &w)
 	}
@@ -916,10 +916,10 @@ func foo115(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$"
 
 func foo116(b bool) *int {
 	if b {
-		x := 1 // ERROR "moved to heap: x$"
+		x := 1    // ERROR "moved to heap: x$"
 		return &x
 	} else {
-		y := 1 // ERROR "moved to heap: y$"
+		y := 1    // ERROR "moved to heap: y$"
 		return &y
 	}
 	return nil
@@ -931,7 +931,7 @@ func foo117(unknown func(interface{})) { // ERROR "foo117 unknown does not escap
 }
 
 func foo118(unknown func(*int)) { // ERROR "foo118 unknown does not escape$"
-	x := 1 // ERROR "moved to heap: x$"
+	x := 1      // ERROR "moved to heap: x$"
 	unknown(&x)
 }
 
@@ -1185,7 +1185,7 @@ L1:
 func foo124(x **int) { // ERROR "foo124 x does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo124 func literal does not escape$"
+	func() {  // ERROR "foo124 func literal does not escape$"
 		*x = p
 	}()
 }
@@ -1193,7 +1193,7 @@ func foo124(x **int) { // ERROR "foo124 x does not escape$"
 func foo125(ch chan *int) { // ERROR "foo125 ch does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo125 func literal does not escape$"
+	func() {  // ERROR "foo125 func literal does not escape$"
 		ch <- p
 	}()
 }
@@ -1229,7 +1229,7 @@ func foo128() {
 func foo129() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo129 func literal does not escape$"
+	func() {  // ERROR "foo129 func literal does not escape$"
 		q := p
 		func() { // ERROR "foo129.func1 func literal does not escape$"
 			r := q
@@ -1281,7 +1281,7 @@ func foo134() {
 }
 
 func foo135() {
-	var i int // ERROR "moved to heap: i$"
+	var i int   // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1293,7 +1293,7 @@ func foo135() {
 }
 
 func foo136() {
-	var i int // ERROR "moved to heap: i$"
+	var i int   // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1307,7 +1307,7 @@ func foo136() {
 func foo137() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo137 func literal does not escape$"
+	func() {  // ERROR "foo137 func literal does not escape$"
 		q := p
 		go func() { // ERROR "func literal escapes to heap$"
 			r := q
@@ -1320,7 +1320,7 @@ func foo138() *byte {
 	type T struct {
 		x [1]byte
 	}
-	t := new(T) // ERROR "new\(T\) escapes to heap$"
+	t := new(T)    // ERROR "new\(T\) escapes to heap$"
 	return &t.x[0]
 }
 
@@ -1330,7 +1330,7 @@ func foo139() *byte {
 			y byte
 		}
 	}
-	t := new(T) // ERROR "new\(T\) escapes to heap$"
+	t := new(T)   // ERROR "new\(T\) escapes to heap$"
 	return &t.x.y
 }
 
@@ -1498,7 +1498,7 @@ func bar151() {
 }
 
 func bar151b() {
-	var a [10]int // ERROR "moved to heap: a$"
+	var a [10]int      // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8][0])
 }
@@ -1510,7 +1510,7 @@ func bar151c() {
 }
 
 func bar151d() {
-	var a [10]int // ERROR "moved to heap: a$"
+	var a [10]int        // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8:8][0])
 }
@@ -1535,7 +1535,7 @@ func NewV(u U) *V { // ERROR "leaking param: u to result ~r1 level=-1"
 }
 
 func foo152() {
-	a := "a" // ERROR "moved to heap: a$"
+	a := "a"   // ERROR "moved to heap: a$"
 	u := U{&a}
 	v := NewV(u)
 	println(v)
@@ -1643,7 +1643,7 @@ type StructWithString struct {
 // to just x, and thus &i looks escaping.
 func fieldFlowTracking() {
 	var x StructWithString
-	i := 0 // ERROR "moved to heap: i$"
+	i := 0     // ERROR "moved to heap: i$"
 	x.p = &i
 	sink = x.s // ERROR "x.s escapes to heap$"
 }
diff --git a/test/oldescape2n.go b/test/oldescape2n.go
index a9edec5f92..fb2a956618 100644
--- a/test/oldescape2n.go
+++ b/test/oldescape2n.go
@@ -146,13 +146,13 @@ func (b Bar) AlsoLeak() *int { // ERROR "leaking param: b to result ~r0 level=0$
 }
 
 func (b Bar) LeaksToo() *int { // ERROR "leaking param: b to result ~r0 level=0$"
-	v := 0 // ERROR "moved to heap: v$"
+	v := 0    // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
 
 func (b *Bar) LeaksABit() *int { // ERROR "leaking param: b to result ~r0 level=1$"
-	v := 0 // ERROR "moved to heap: v$"
+	v := 0    // ERROR "moved to heap: v$"
 	b.ii = &v
 	return b.ii
 }
@@ -522,7 +522,7 @@ func foo72a() {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
 		// escapes its scope
-		x := i // ERROR "moved to heap: x$"
+		x := i    // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return
@@ -531,7 +531,7 @@ func foo72a() {
 func foo72b() [10]*int {
 	var y [10]*int
 	for i := 0; i < 10; i++ {
-		x := i // ERROR "moved to heap: x$"
+		x := i    // ERROR "moved to heap: x$"
 		y[i] = &x
 	}
 	return y
@@ -739,11 +739,11 @@ func tee(p *int) (x, y *int) { return p, p } // ERROR "leaking param: p to resul
 func noop(x, y *int) {} // ERROR "noop x does not escape$" "noop y does not escape$"
 
 func foo82() {
-	var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
+	var x, y, z int  // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$"
 	go noop(tee(&z))
 	go noop(&x, &y)
 	for {
-		var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
+		var u, v, w int     // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$"
 		defer noop(tee(&u))
 		defer noop(&v, &w)
 	}
@@ -916,10 +916,10 @@ func foo115(x *int) *int { // ERROR "leaking param: x to result ~r1 level=0$"
 
 func foo116(b bool) *int {
 	if b {
-		x := 1 // ERROR "moved to heap: x$"
+		x := 1    // ERROR "moved to heap: x$"
 		return &x
 	} else {
-		y := 1 // ERROR "moved to heap: y$"
+		y := 1    // ERROR "moved to heap: y$"
 		return &y
 	}
 	return nil
@@ -931,7 +931,7 @@ func foo117(unknown func(interface{})) { // ERROR "foo117 unknown does not escap
 }
 
 func foo118(unknown func(*int)) { // ERROR "foo118 unknown does not escape$"
-	x := 1 // ERROR "moved to heap: x$"
+	x := 1      // ERROR "moved to heap: x$"
 	unknown(&x)
 }
 
@@ -1185,7 +1185,7 @@ L1:
 func foo124(x **int) { // ERROR "foo124 x does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo124 func literal does not escape$"
+	func() {  // ERROR "foo124 func literal does not escape$"
 		*x = p
 	}()
 }
@@ -1193,7 +1193,7 @@ func foo124(x **int) { // ERROR "foo124 x does not escape$"
 func foo125(ch chan *int) { // ERROR "foo125 ch does not escape$"
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo125 func literal does not escape$"
+	func() {  // ERROR "foo125 func literal does not escape$"
 		ch <- p
 	}()
 }
@@ -1229,7 +1229,7 @@ func foo128() {
 func foo129() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo129 func literal does not escape$"
+	func() {  // ERROR "foo129 func literal does not escape$"
 		q := p
 		func() { // ERROR "foo129.func1 func literal does not escape$"
 			r := q
@@ -1281,7 +1281,7 @@ func foo134() {
 }
 
 func foo135() {
-	var i int // ERROR "moved to heap: i$"
+	var i int   // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1293,7 +1293,7 @@ func foo135() {
 }
 
 func foo136() {
-	var i int // ERROR "moved to heap: i$"
+	var i int   // ERROR "moved to heap: i$"
 	p := &i
 	go func() { // ERROR "func literal escapes to heap$"
 		q := p
@@ -1307,7 +1307,7 @@ func foo136() {
 func foo137() {
 	var i int // ERROR "moved to heap: i$"
 	p := &i
-	func() { // ERROR "foo137 func literal does not escape$"
+	func() {  // ERROR "foo137 func literal does not escape$"
 		q := p
 		go func() { // ERROR "func literal escapes to heap$"
 			r := q
@@ -1320,7 +1320,7 @@ func foo138() *byte {
 	type T struct {
 		x [1]byte
 	}
-	t := new(T) // ERROR "new\(T\) escapes to heap$"
+	t := new(T)    // ERROR "new\(T\) escapes to heap$"
 	return &t.x[0]
 }
 
@@ -1330,7 +1330,7 @@ func foo139() *byte {
 			y byte
 		}
 	}
-	t := new(T) // ERROR "new\(T\) escapes to heap$"
+	t := new(T)   // ERROR "new\(T\) escapes to heap$"
 	return &t.x.y
 }
 
@@ -1498,7 +1498,7 @@ func bar151() {
 }
 
 func bar151b() {
-	var a [10]int // ERROR "moved to heap: a$"
+	var a [10]int      // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8][0])
 }
@@ -1510,7 +1510,7 @@ func bar151c() {
 }
 
 func bar151d() {
-	var a [10]int // ERROR "moved to heap: a$"
+	var a [10]int        // ERROR "moved to heap: a$"
 	b := a[:]
 	foo151(&b[4:8:8][0])
 }
@@ -1535,7 +1535,7 @@ func NewV(u U) *V { // ERROR "leaking param: u to result ~r1 level=-1"
 }
 
 func foo152() {
-	a := "a" // ERROR "moved to heap: a$"
+	a := "a"   // ERROR "moved to heap: a$"
 	u := U{&a}
 	v := NewV(u)
 	println(v)
@@ -1643,7 +1643,7 @@ type StructWithString struct {
 // to just x, and thus &i looks escaping.
 func fieldFlowTracking() {
 	var x StructWithString
-	i := 0 // ERROR "moved to heap: i$"
+	i := 0     // ERROR "moved to heap: i$"
 	x.p = &i
 	sink = x.s // ERROR "x.s escapes to heap$"
 }
diff --git a/test/oldescape5.go b/test/oldescape5.go
index 972b9ed8a8..53d0ff801d 100644
--- a/test/oldescape5.go
+++ b/test/oldescape5.go
@@ -71,13 +71,13 @@ func f2() {
 }
 
 func f3() {
-	var x int // ERROR "moved to heap: x"
+	var x int          // ERROR "moved to heap: x"
 	p := leaktoret(&x)
 	gp = p
 }
 
 func f4() {
-	var x int // ERROR "moved to heap: x"
+	var x int              // ERROR "moved to heap: x"
 	p, q := leaktoret2(&x)
 	gp = p
 	gp = q
@@ -89,7 +89,7 @@ func f5() {
 }
 
 func f6() {
-	var x int // ERROR "moved to heap: x"
+	var x int                               // ERROR "moved to heap: x"
 	px1, px2 := leaktoret22(leaktoret2(&x))
 	gp = px1
 	_ = px2
diff --git a/test/oldescape_field.go b/test/oldescape_field.go
index 09f1ea7758..e4213aaf59 100644
--- a/test/oldescape_field.go
+++ b/test/oldescape_field.go
@@ -39,7 +39,7 @@ func field3() {
 	i := 0 // ERROR "moved to heap: i$"
 	var x X
 	x.p1 = &i
-	sink = x // ERROR "x escapes to heap"
+	sink = x  // ERROR "x escapes to heap"
 }
 
 func field4() {
@@ -113,16 +113,16 @@ func field10() {
 }
 
 func field11() {
-	i := 0 // ERROR "moved to heap: i$"
+	i := 0         // ERROR "moved to heap: i$"
 	x := X{p1: &i}
-	sink = x.p1 // ERROR "x\.p1 escapes to heap"
+	sink = x.p1    // ERROR "x\.p1 escapes to heap"
 }
 
 func field12() {
 	i := 0 // ERROR "moved to heap: i$"
 	// BAD: &i should not escape
 	x := X{p1: &i}
-	sink = x.p2 // ERROR "x\.p2 escapes to heap"
+	sink = x.p2    // ERROR "x\.p2 escapes to heap"
 }
 
 func field13() {
diff --git a/test/oldescape_iface.go b/test/oldescape_iface.go
index ca5aa1187f..88502df99b 100644
--- a/test/oldescape_iface.go
+++ b/test/oldescape_iface.go
@@ -37,7 +37,7 @@ func efaceEscape0() {
 		_ = x
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0      // ERROR "moved to heap: i"
 		v := M0{&i}
 		var x M = v // ERROR "v escapes to heap"
 		sink = x    // ERROR "x escapes to heap"
@@ -50,7 +50,7 @@ func efaceEscape0() {
 		_ = v1
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0      // ERROR "moved to heap: i"
 		v := M0{&i}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
@@ -58,14 +58,14 @@ func efaceEscape0() {
 		sink = v1 // ERROR "v1 escapes to heap"
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0      // ERROR "moved to heap: i"
 		v := M0{&i}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
 		x.M()
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0      // ERROR "moved to heap: i"
 		v := M0{&i}
 		var x M = v // ERROR "v escapes to heap"
 		mescapes(x)
@@ -91,24 +91,24 @@ func efaceEscape1() {
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v // ERROR "v does not escape"
+		var x M = v    // ERROR "v does not escape"
 		_ = x
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0         // ERROR "moved to heap: i"
 		v := M1{&i, 0}
-		var x M = v // ERROR "v escapes to heap"
-		sink = x    // ERROR "x escapes to heap"
+		var x M = v    // ERROR "v escapes to heap"
+		sink = x       // ERROR "x escapes to heap"
 	}
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v // ERROR "v does not escape"
+		var x M = v    // ERROR "v does not escape"
 		v1 := x.(M1)
 		_ = v1
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0         // ERROR "moved to heap: i"
 		v := M1{&i, 0}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
@@ -116,22 +116,22 @@ func efaceEscape1() {
 		sink = v1 // ERROR "v1 escapes to heap"
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0         // ERROR "moved to heap: i"
 		v := M1{&i, 0}
 		// BAD: v does not escape to heap here
 		var x M = v // ERROR "v escapes to heap"
 		x.M()
 	}
 	{
-		i := 0 // ERROR "moved to heap: i"
+		i := 0         // ERROR "moved to heap: i"
 		v := M1{&i, 0}
-		var x M = v // ERROR "v escapes to heap"
+		var x M = v    // ERROR "v escapes to heap"
 		mescapes(x)
 	}
 	{
 		i := 0
 		v := M1{&i, 0}
-		var x M = v // ERROR "v does not escape"
+		var x M = v    // ERROR "v does not escape"
 		mdoesnotescape(x)
 	}
 }
@@ -245,7 +245,7 @@ func dotTypeEscape2() { // #13805, #15796
 		var x interface{} = i // ERROR "i does not escape"
 		var y interface{} = j // ERROR "j does not escape"
 
-		sink = x.(int) // ERROR "x.\(int\) escapes to heap"
+		sink = x.(int)        // ERROR "x.\(int\) escapes to heap"
 		sink, *(&ok) = y.(int)
 	}
 	{
@@ -255,7 +255,7 @@ func dotTypeEscape2() { // #13805, #15796
 		var x interface{} = &i // ERROR "&i escapes to heap"
 		var y interface{} = &j // ERROR "&j escapes to heap"
 
-		sink = x.(*int) // ERROR "x.\(\*int\) escapes to heap"
+		sink = x.(*int)        // ERROR "x.\(\*int\) escapes to heap"
 		sink, *(&ok) = y.(*int)
 	}
 }
diff --git a/test/oldescape_param.go b/test/oldescape_param.go
index cf85d745cb..3a3eee2a5b 100644
--- a/test/oldescape_param.go
+++ b/test/oldescape_param.go
@@ -57,7 +57,7 @@ func caller2b() {
 	i := 0 // ERROR "moved to heap: i$"
 	var p *int
 	param2(&i, &p)
-	sink = p // ERROR "p escapes to heap$"
+	sink = p       // ERROR "p escapes to heap$"
 }
 
 func paramArraySelfAssign(p *PairOfPairs) { // ERROR "p does not escape"
@@ -150,11 +150,11 @@ func caller3a() {
 }
 
 func caller3b() {
-	i := 0 // ERROR "moved to heap: i$"
-	j := 0 // ERROR "moved to heap: j$"
+	i := 0            // ERROR "moved to heap: i$"
+	j := 0            // ERROR "moved to heap: j$"
 	p := Pair{&i, &j}
 	param3(&p)
-	sink = p // ERROR "p escapes to heap$"
+	sink = p          // ERROR "p escapes to heap$"
 }
 
 // in -> rcvr
@@ -173,7 +173,7 @@ func caller4b() {
 	i := 0 // ERROR "moved to heap: i$"
 	p := Pair{}
 	p.param4(&i)
-	sink = p // ERROR "p escapes to heap$"
+	sink = p     // ERROR "p escapes to heap$"
 }
 
 // in -> heap
@@ -182,7 +182,7 @@ func param5(i *int) { // ERROR "leaking param: i$"
 }
 
 func caller5() {
-	i := 0 // ERROR "moved to heap: i$"
+	i := 0     // ERROR "moved to heap: i$"
 	param5(&i)
 }
 
@@ -192,8 +192,8 @@ func param6(i ***int) { // ERROR "leaking param content: i$"
 }
 
 func caller6a() {
-	i := 0  // ERROR "moved to heap: i$"
-	p := &i // ERROR "moved to heap: p$"
+	i := 0      // ERROR "moved to heap: i$"
+	p := &i     // ERROR "moved to heap: p$"
 	p2 := &p
 	param6(&p2)
 }
@@ -204,8 +204,8 @@ func param7(i ***int) { // ERROR "leaking param content: i$"
 }
 
 func caller7() {
-	i := 0  // ERROR "moved to heap: i$"
-	p := &i // ERROR "moved to heap: p$"
+	i := 0      // ERROR "moved to heap: i$"
+	p := &i     // ERROR "moved to heap: p$"
 	p2 := &p
 	param7(&p2)
 }
@@ -234,8 +234,8 @@ func caller9a() {
 }
 
 func caller9b() {
-	i := 0  // ERROR "moved to heap: i$"
-	p := &i // ERROR "moved to heap: p$"
+	i := 0             // ERROR "moved to heap: i$"
+	p := &i            // ERROR "moved to heap: p$"
 	p2 := &p
 	sink = param9(&p2) // ERROR  "param9\(&p2\) escapes to heap"
 }
@@ -253,7 +253,7 @@ func caller10a() {
 }
 
 func caller10b() {
-	i := 0 // ERROR "moved to heap: i$"
+	i := 0              // ERROR "moved to heap: i$"
 	p := &i
 	p2 := &p
 	sink = param10(&p2) // ERROR "param10\(&p2\) escapes to heap"
@@ -265,8 +265,8 @@ func param11(i **int) ***int { // ERROR "moved to heap: i$"
 }
 
 func caller11a() {
-	i := 0  // ERROR "moved to heap: i"
-	p := &i // ERROR "moved to heap: p"
+	i := 0          // ERROR "moved to heap: i"
+	p := &i         // ERROR "moved to heap: p"
 	_ = param11(&p)
 }
 
@@ -283,8 +283,8 @@ func caller11c() { // GOOD
 }
 
 func caller11d() {
-	i := 0  // ERROR "moved to heap: i$"
-	p := &i // ERROR "moved to heap: p"
+	i := 0             // ERROR "moved to heap: i$"
+	p := &i            // ERROR "moved to heap: p"
 	p2 := &p
 	sink = param11(p2) // ERROR "param11\(p2\) escapes to heap"
 }
@@ -319,7 +319,7 @@ func caller12c() {
 	p := &i // ERROR "moved to heap: p$"
 	r := Indir{}
 	r.param12(&p)
-	sink = r // ERROR "r escapes to heap$"
+	sink = r      // ERROR "r escapes to heap$"
 }
 
 func caller12d() {
@@ -327,7 +327,7 @@ func caller12d() {
 	p := &i // ERROR "moved to heap: p$"
 	r := Indir{}
 	r.param12(&p)
-	sink = **r.p // ERROR "\* \(\*r\.p\) escapes to heap"
+	sink = **r.p  // ERROR "\* \(\*r\.p\) escapes to heap"
 }
 
 // in -> value rcvr
@@ -370,15 +370,15 @@ func caller13d() {
 	var v Val
 	v.p = &p
 	v.param13(&i)
-	sink = v // ERROR "v escapes to heap$"
+	sink = v      // ERROR "v escapes to heap$"
 }
 
 func caller13e() {
-	i := 0     // ERROR "moved to heap: i$"
-	var p *int // ERROR "moved to heap: p$"
+	i := 0        // ERROR "moved to heap: i$"
+	var p *int    // ERROR "moved to heap: p$"
 	v := Val{&p}
 	v.param13(&i)
-	sink = v // ERROR "v escapes to heap$"
+	sink = v      // ERROR "v escapes to heap$"
 }
 
 func caller13f() {
@@ -386,7 +386,7 @@ func caller13f() {
 	var p *int    // ERROR "moved to heap: p$"
 	v := &Val{&p} // ERROR "&Val literal escapes to heap$"
 	v.param13(&i)
-	sink = v // ERROR "v escapes to heap$"
+	sink = v      // ERROR "v escapes to heap$"
 }
 
 func caller13g() {
@@ -394,7 +394,7 @@ func caller13g() {
 	var p *int
 	v := Val{&p}
 	v.param13(&i)
-	sink = *v.p // ERROR "\*v\.p escapes to heap"
+	sink = *v.p   // ERROR "\*v\.p escapes to heap"
 }
 
 func caller13h() {
@@ -402,7 +402,7 @@ func caller13h() {
 	var p *int
 	v := &Val{&p} // ERROR "caller13h &Val literal does not escape$"
 	v.param13(&i)
-	sink = **v.p // ERROR "\* \(\*v\.p\) escapes to heap"
+	sink = **v.p  // ERROR "\* \(\*v\.p\) escapes to heap"
 }
 
 type Node struct {
diff --git a/test/parentype.go b/test/parentype.go
index d7881129c5..eafa076481 100644
--- a/test/parentype.go
+++ b/test/parentype.go
@@ -11,9 +11,9 @@ package main
 func f(interface{})
 func g() {}
 func main() {
-	f(map[string]string{"a": "b", "c": "d"})
-	f([...]int{1, 2, 3})
-	f(map[string]func(){"a": g, "c": g})
-	f(make(chan (<-chan int)))
-	f(make(chan<- (chan int)))
+	f(map[string]string{"a":"b","c":"d"})
+	f([...]int{1,2,3})
+	f(map[string]func(){"a":g,"c":g})
+	f(make(chan(<-chan int)))
+	f(make(chan<-(chan int)))
 }
diff --git a/test/printbig.go b/test/printbig.go
index a4af1fc9e1..9e08c39adc 100644
--- a/test/printbig.go
+++ b/test/printbig.go
@@ -9,6 +9,6 @@
 package main
 
 func main() {
-	print(-(1 << 63), "\n")
+	print(-(1<<63), "\n")
 	print((1<<63)-1, "\n")
 }
diff --git a/test/recover1.go b/test/recover1.go
index 7e7c2c5968..c14a607c6b 100644
--- a/test/recover1.go
+++ b/test/recover1.go
@@ -22,21 +22,21 @@ func main() {
 }
 
 func die() {
-	runtime.Breakpoint() // can't depend on panic
+	runtime.Breakpoint()	// can't depend on panic
 }
 
 func mustRecover(x interface{}) {
-	mustNotRecover() // because it's not a defer call
+	mustNotRecover()	// because it's not a defer call
 	v := recover()
 	if v == nil {
 		println("missing recover")
-		die() // panic is useless here
+		die()	// panic is useless here
 	}
 	if v != x {
 		println("wrong value", v, x)
 		die()
 	}
-
+	
 	// the value should be gone now regardless
 	v = recover()
 	if v != nil {
@@ -54,7 +54,7 @@ func mustNotRecover() {
 }
 
 func withoutRecover() {
-	mustNotRecover() // because it's a sub-call
+	mustNotRecover()	// because it's a sub-call
 }
 
 func test1() {
@@ -116,7 +116,7 @@ func test6() {
 	// Like test3, but changed recover to defer (same change as test4 → test5).
 	defer mustNotRecover()
 	defer func() {
-		defer recover() // like a normal call from this func; runs because mustRecover stops the panic
+		defer recover()	// like a normal call from this func; runs because mustRecover stops the panic
 		defer mustRecover(3)
 		panic(3)
 	}()
@@ -134,7 +134,7 @@ func test7() {
 	defer mustRecover(2)
 	defer func() {
 		defer mustRecover(3)
-		defer recover() // now a no-op, unlike in test6.
+		defer recover()	// now a no-op, unlike in test6.
 		panic(3)
 	}()
 	panic(2)
diff --git a/test/return.go b/test/return.go
index 20f648cf46..95f94b9276 100644
--- a/test/return.go
+++ b/test/return.go
@@ -151,31 +151,27 @@ func _() int {
 func _() int {
 	print(1)
 	return 2
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 func _() int {
 L:
 	print(1)
 	goto L
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 func _() int {
 	print(1)
 	panic(2)
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 func _() int {
 	{
 		print(1)
 		return 2
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
@@ -184,8 +180,7 @@ L:
 	{
 		print(1)
 		goto L
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
@@ -193,8 +188,7 @@ func _() int {
 	print(1)
 	{
 		panic(2)
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
@@ -203,8 +197,7 @@ func _() int {
 		print(1)
 		return 2
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 func _() int {
@@ -213,8 +206,7 @@ L:
 		print(1)
 		goto L
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 func _() int {
@@ -222,8 +214,7 @@ func _() int {
 	{
 		panic(2)
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 // if-else chain with final else and all terminating is okay
@@ -291,12 +282,12 @@ func _() int {
 	}
 } // ERROR "missing return"
 
+
 // for { loops that never break are okay.
 
 func _() int {
 	print(1)
-	for {
-	}
+	for {}
 }
 
 func _() int {
@@ -309,7 +300,7 @@ func _() int {
 
 func _() int {
 	for {
-	L:
+		L:
 		for {
 			break L
 		}
@@ -320,9 +311,7 @@ func _() int {
 
 func _() int {
 	print(1)
-	for {
-		break
-	}
+	for { break }
 } // ERROR "missing return"
 
 func _() int {
@@ -346,8 +335,7 @@ L:
 
 func _() int {
 	print(1)
-	for x == nil {
-	}
+	for x == nil {}
 } // ERROR "missing return"
 
 func _() int {
@@ -360,17 +348,16 @@ func _() int {
 
 func _() int {
 	for x == nil {
-	L:
+		L:
 		for {
 			break L
 		}
-	}
+	}	
 } // ERROR "missing return"
 
 func _() int {
 	print(1)
-	for true {
-	}
+	for true {}
 } // ERROR "missing return"
 
 func _() int {
@@ -383,7 +370,7 @@ func _() int {
 
 func _() int {
 	for true {
-	L:
+		L:
 		for {
 			break L
 		}
@@ -394,7 +381,7 @@ func _() int {
 
 func _() int {
 	print(1)
-	select {}
+	select{}
 }
 
 func _() int {
@@ -411,8 +398,7 @@ func _() int {
 	select {
 	case <-c:
 		print(2)
-		for {
-		}
+		for{}
 	}
 }
 
@@ -436,7 +422,7 @@ func _() int {
 		print(2)
 		panic("abc")
 	default:
-		select {}
+		select{}
 	}
 }
 
@@ -463,6 +449,7 @@ L:
 	}
 } // ERROR "missing return"
 
+
 func _() int {
 	print(1)
 	select {
@@ -474,14 +461,12 @@ func _() int {
 	}
 } // ERROR "missing return"
 
+
 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
 
 func _() int {
 	print(1)
-	select {
-	default:
-		break
-	}
+	select{ default: break }
 } // ERROR "missing return"
 
 func _() int {
@@ -500,9 +485,7 @@ L:
 	select {
 	case <-c:
 		print(2)
-		for {
-			break L
-		}
+		for{ break L }
 	}
 } // ERROR "missing return"
 
@@ -526,7 +509,7 @@ func _() int {
 		print(1)
 		panic("abc")
 	default:
-		select {}
+		select{}
 		break
 	}
 } // ERROR "missing return"
@@ -574,6 +557,7 @@ func _() int {
 	}
 } // ERROR "missing return"
 
+
 func _() int {
 	print(1)
 	switch x {
@@ -689,6 +673,7 @@ func _() int {
 	}
 } // ERROR "missing return"
 
+
 func _() int {
 	print(1)
 	switch x.(type) {
@@ -878,28 +863,24 @@ func _() int {
 
 func _() int {
 	return 2
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 func _() int {
 L:
 	goto L
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 func _() int {
 	panic(2)
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 func _() int {
 	{
 		return 2
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
@@ -907,16 +888,14 @@ func _() int {
 L:
 	{
 		goto L
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
 func _() int {
 	{
 		panic(2)
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
@@ -924,8 +903,7 @@ func _() int {
 	{
 		return 2
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 func _() int {
@@ -933,16 +911,14 @@ L:
 	{
 		goto L
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 func _() int {
 	{
 		panic(2)
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 // if-else chain with final else and all terminating is okay
@@ -1004,11 +980,11 @@ func _() int {
 	}
 } // ERROR "missing return"
 
+
 // for { loops that never break are okay.
 
 func _() int {
-	for {
-	}
+	for {}
 }
 
 func _() int {
@@ -1021,7 +997,7 @@ func _() int {
 
 func _() int {
 	for {
-	L:
+		L:
 		for {
 			break L
 		}
@@ -1031,9 +1007,7 @@ func _() int {
 // for { loops that break are not okay.
 
 func _() int {
-	for {
-		break
-	}
+	for { break }
 } // ERROR "missing return"
 
 func _() int {
@@ -1056,8 +1030,7 @@ L:
 // if there's a condition - even "true" - the loops are no longer syntactically terminating
 
 func _() int {
-	for x == nil {
-	}
+	for x == nil {}
 } // ERROR "missing return"
 
 func _() int {
@@ -1070,16 +1043,15 @@ func _() int {
 
 func _() int {
 	for x == nil {
-	L:
+		L:
 		for {
 			break L
 		}
-	}
+	}	
 } // ERROR "missing return"
 
 func _() int {
-	for true {
-	}
+	for true {}
 } // ERROR "missing return"
 
 func _() int {
@@ -1092,7 +1064,7 @@ func _() int {
 
 func _() int {
 	for true {
-	L:
+		L:
 		for {
 			break L
 		}
@@ -1102,7 +1074,7 @@ func _() int {
 // select in which all cases terminate and none break are okay.
 
 func _() int {
-	select {}
+	select{}
 }
 
 func _() int {
@@ -1117,8 +1089,7 @@ func _() int {
 	select {
 	case <-c:
 		print(2)
-		for {
-		}
+		for{}
 	}
 }
 
@@ -1140,7 +1111,7 @@ func _() int {
 		print(2)
 		panic("abc")
 	default:
-		select {}
+		select{}
 	}
 }
 
@@ -1165,6 +1136,7 @@ L:
 	}
 } // ERROR "missing return"
 
+
 func _() int {
 	select {
 	case <-c:
@@ -1175,13 +1147,11 @@ func _() int {
 	}
 } // ERROR "missing return"
 
+
 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
 
 func _() int {
-	select {
-	default:
-		break
-	}
+	select{ default: break }
 } // ERROR "missing return"
 
 func _() int {
@@ -1198,9 +1168,7 @@ L:
 	select {
 	case <-c:
 		print(2)
-		for {
-			break L
-		}
+		for{ break L }
 	}
 } // ERROR "missing return"
 
@@ -1221,7 +1189,7 @@ func _() int {
 	case <-c:
 		panic("abc")
 	default:
-		select {}
+		select{}
 		break
 	}
 } // ERROR "missing return"
@@ -1265,6 +1233,7 @@ func _() int {
 	}
 } // ERROR "missing return"
 
+
 func _() int {
 	switch x {
 	case 1:
@@ -1370,6 +1339,7 @@ func _() int {
 	}
 } // ERROR "missing return"
 
+
 func _() int {
 	switch x.(type) {
 	case int:
@@ -1583,31 +1553,27 @@ var _ = func() int {
 var _ = func() int {
 	print(1)
 	return 2
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 var _ = func() int {
 L:
 	print(1)
 	goto L
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 var _ = func() int {
 	print(1)
 	panic(2)
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 var _ = func() int {
 	{
 		print(1)
 		return 2
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
@@ -1616,8 +1582,7 @@ L:
 	{
 		print(1)
 		goto L
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
@@ -1625,8 +1590,7 @@ var _ = func() int {
 	print(1)
 	{
 		panic(2)
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
@@ -1635,8 +1599,7 @@ var _ = func() int {
 		print(1)
 		return 2
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1645,8 +1608,7 @@ L:
 		print(1)
 		goto L
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1654,8 +1616,7 @@ var _ = func() int {
 	{
 		panic(2)
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 // if-else chain with final else and all terminating is okay
@@ -1723,12 +1684,12 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
+
 // for { loops that never break are okay.
 
 var _ = func() int {
 	print(1)
-	for {
-	}
+	for {}
 }
 
 var _ = func() int {
@@ -1741,7 +1702,7 @@ var _ = func() int {
 
 var _ = func() int {
 	for {
-	L:
+		L:
 		for {
 			break L
 		}
@@ -1752,9 +1713,7 @@ var _ = func() int {
 
 var _ = func() int {
 	print(1)
-	for {
-		break
-	}
+	for { break }
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1778,8 +1737,7 @@ L:
 
 var _ = func() int {
 	print(1)
-	for x == nil {
-	}
+	for x == nil {}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1792,17 +1750,16 @@ var _ = func() int {
 
 var _ = func() int {
 	for x == nil {
-	L:
+		L:
 		for {
 			break L
 		}
-	}
+	}	
 } // ERROR "missing return"
 
 var _ = func() int {
 	print(1)
-	for true {
-	}
+	for true {}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1815,7 +1772,7 @@ var _ = func() int {
 
 var _ = func() int {
 	for true {
-	L:
+		L:
 		for {
 			break L
 		}
@@ -1826,7 +1783,7 @@ var _ = func() int {
 
 var _ = func() int {
 	print(1)
-	select {}
+	select{}
 }
 
 var _ = func() int {
@@ -1843,8 +1800,7 @@ var _ = func() int {
 	select {
 	case <-c:
 		print(2)
-		for {
-		}
+		for{}
 	}
 }
 
@@ -1868,7 +1824,7 @@ var _ = func() int {
 		print(2)
 		panic("abc")
 	default:
-		select {}
+		select{}
 	}
 }
 
@@ -1895,6 +1851,7 @@ L:
 	}
 } // ERROR "missing return"
 
+
 var _ = func() int {
 	print(1)
 	select {
@@ -1906,14 +1863,12 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
+
 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
 
 var _ = func() int {
 	print(1)
-	select {
-	default:
-		break
-	}
+	select{ default: break }
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -1932,9 +1887,7 @@ L:
 	select {
 	case <-c:
 		print(2)
-		for {
-			break L
-		}
+		for{ break L }
 	}
 } // ERROR "missing return"
 
@@ -1958,7 +1911,7 @@ var _ = func() int {
 		print(1)
 		panic("abc")
 	default:
-		select {}
+		select{}
 		break
 	}
 } // ERROR "missing return"
@@ -2006,6 +1959,7 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
+
 var _ = func() int {
 	print(1)
 	switch x {
@@ -2121,6 +2075,7 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
+
 var _ = func() int {
 	print(1)
 	switch x.(type) {
@@ -2310,28 +2265,24 @@ var _ = func() int {
 
 var _ = func() int {
 	return 2
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 var _ = func() int {
 L:
 	goto L
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 var _ = func() int {
 	panic(2)
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 var _ = func() int {
 	{
 		return 2
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
@@ -2339,16 +2290,14 @@ var _ = func() int {
 L:
 	{
 		goto L
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
 var _ = func() int {
 	{
 		panic(2)
-		{
-		}
+		{}
 	}
 } // ERROR "missing return"
 
@@ -2356,8 +2305,7 @@ var _ = func() int {
 	{
 		return 2
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -2365,16 +2313,14 @@ L:
 	{
 		goto L
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 var _ = func() int {
 	{
 		panic(2)
 	}
-	{
-	}
+	{}
 } // ERROR "missing return"
 
 // if-else chain with final else and all terminating is okay
@@ -2436,11 +2382,11 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
+
 // for { loops that never break are okay.
 
 var _ = func() int {
-	for {
-	}
+	for {}
 }
 
 var _ = func() int {
@@ -2453,7 +2399,7 @@ var _ = func() int {
 
 var _ = func() int {
 	for {
-	L:
+		L:
 		for {
 			break L
 		}
@@ -2463,9 +2409,7 @@ var _ = func() int {
 // for { loops that break are not okay.
 
 var _ = func() int {
-	for {
-		break
-	}
+	for { break }
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -2488,8 +2432,7 @@ L:
 // if there's a condition - even "true" - the loops are no longer syntactically terminating
 
 var _ = func() int {
-	for x == nil {
-	}
+	for x == nil {}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -2502,16 +2445,15 @@ var _ = func() int {
 
 var _ = func() int {
 	for x == nil {
-	L:
+		L:
 		for {
 			break L
 		}
-	}
+	}	
 } // ERROR "missing return"
 
 var _ = func() int {
-	for true {
-	}
+	for true {}
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -2524,7 +2466,7 @@ var _ = func() int {
 
 var _ = func() int {
 	for true {
-	L:
+		L:
 		for {
 			break L
 		}
@@ -2534,7 +2476,7 @@ var _ = func() int {
 // select in which all cases terminate and none break are okay.
 
 var _ = func() int {
-	select {}
+	select{}
 }
 
 var _ = func() int {
@@ -2549,8 +2491,7 @@ var _ = func() int {
 	select {
 	case <-c:
 		print(2)
-		for {
-		}
+		for{}
 	}
 }
 
@@ -2572,7 +2513,7 @@ var _ = func() int {
 		print(2)
 		panic("abc")
 	default:
-		select {}
+		select{}
 	}
 }
 
@@ -2597,6 +2538,7 @@ L:
 	}
 } // ERROR "missing return"
 
+
 var _ = func() int {
 	select {
 	case <-c:
@@ -2607,13 +2549,11 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
+
 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
 
 var _ = func() int {
-	select {
-	default:
-		break
-	}
+	select{ default: break }
 } // ERROR "missing return"
 
 var _ = func() int {
@@ -2630,9 +2570,7 @@ L:
 	select {
 	case <-c:
 		print(2)
-		for {
-			break L
-		}
+		for{ break L }
 	}
 } // ERROR "missing return"
 
@@ -2653,7 +2591,7 @@ var _ = func() int {
 	case <-c:
 		panic("abc")
 	default:
-		select {}
+		select{}
 		break
 	}
 } // ERROR "missing return"
@@ -2697,6 +2635,7 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
+
 var _ = func() int {
 	switch x {
 	case 1:
@@ -2802,6 +2741,7 @@ var _ = func() int {
 	}
 } // ERROR "missing return"
 
+
 var _ = func() int {
 	switch x.(type) {
 	case int:
diff --git a/test/rune.go b/test/rune.go
index 3509876910..73a5aa23f8 100644
--- a/test/rune.go
+++ b/test/rune.go
@@ -11,12 +11,12 @@ package rune
 
 var (
 	r0 = 'a'
-	r1 = 'a' + 1
-	r2 = 1 + 'a'
-	r3 = 'a' * 2
-	r4 = 'a' / 2
-	r5 = 'a' << 1
-	r6 = 'b' << 2
+	r1 = 'a'+1
+	r2 = 1+'a'
+	r3 = 'a'*2
+	r4 = 'a'/2
+	r5 = 'a'<<1
+	r6 = 'b'<<2
 	r7 int32
 
 	r = []rune{r0, r1, r2, r3, r4, r5, r6, r7}
@@ -24,15 +24,15 @@ var (
 
 var (
 	f0 = 1.2
-	f1 = 1.2 / 'a'
+	f1 = 1.2/'a'
 
 	f = []float64{f0, f1}
 )
 
 var (
 	i0 = 1
-	i1 = 1 << '\x01'
-
+	i1 = 1<<'\x01'
+	
 	i = []int{i0, i1}
 )
 
@@ -42,6 +42,6 @@ const (
 
 var (
 	b0 = maxRune < r0
-
+	
 	b = []bool{b0}
 )
diff --git a/test/runtime.go b/test/runtime.go
index 09862acf50..0cf781b814 100644
--- a/test/runtime.go
+++ b/test/runtime.go
@@ -17,5 +17,5 @@ package main
 import "runtime"
 
 func main() {
-	runtime.printbool(true) // ERROR "unexported" "undefined"
+	runtime.printbool(true)	// ERROR "unexported" "undefined"
 }
diff --git a/test/shift1.go b/test/shift1.go
index dd990fa929..01ecbed53a 100644
--- a/test/shift1.go
+++ b/test/shift1.go
@@ -61,12 +61,12 @@ func _() {
 		o       = 1<<s == 2<<s   // 1 and 2 have type int; o == true if ints are 32bits in size
 		// next test only fails on 32bit systems
 		// p = 1<<s == 1<<33  // illegal if ints are 32bits in size: 1 has type int, but 1<<33 overflows int
-		u                                    = 1.0 << s    // ERROR "non-integer|float64"
-		u1                                   = 1.0<<s != 0 // ERROR "non-integer|float64"
-		u2                                   = 1<<s != 1.0 // ERROR "non-integer|float64"
-		v                            float32 = 1 << s      // ERROR "non-integer|float32"
-		w                            int64   = 1.0 << 33   // 1.0<<33 is a constant shift expression
-		_, _, _, _, _, _, _, _, _, _         = j, k, m, n, o, u, u1, u2, v, w
+		u          = 1.0 << s    // ERROR "non-integer|float64"
+		u1         = 1.0<<s != 0 // ERROR "non-integer|float64"
+		u2         = 1<<s != 1.0 // ERROR "non-integer|float64"
+		v  float32 = 1 << s      // ERROR "non-integer|float32"
+		w  int64   = 1.0 << 33   // 1.0<<33 is a constant shift expression
+		_, _, _, _, _, _, _, _, _, _ = j, k, m, n, o, u, u1, u2, v, w
 	)
 
 	// non constants arguments trigger a different path
diff --git a/test/stack.go b/test/stack.go
index 4c56276e1f..b62febd48d 100644
--- a/test/stack.go
+++ b/test/stack.go
@@ -46,7 +46,7 @@ func f1() [3000]byte {
 	// does not pass the frame size, the new
 	// stack (default size 5k) will not be big
 	// enough for the frame, and the morestack
-	// check in f2 will die, if we get that far
+	// check in f2 will die, if we get that far 
 	// without faulting.
 	f2()
 	return [3000]byte{}
diff --git a/test/switch5.go b/test/switch5.go
index 705fd9a958..ce95bf8d7b 100644
--- a/test/switch5.go
+++ b/test/switch5.go
@@ -86,7 +86,7 @@ func f8(r rune) {
 	case 34, '"': // ERROR "duplicate case '"' .value 34. in switch"
 	case 35, rune('#'): // ERROR "duplicate case rune.'#'. .value 35. in switch"
 	case 36, rune(36): // ERROR "duplicate case rune.36. .value 36. in switch"
-	case 37, '$' + 1: // ERROR "duplicate case '\$' \+ 1 .value 37. in switch"
+	case 37, '$'+1: // ERROR "duplicate case '\$' \+ 1 .value 37. in switch"
 	case 'b':
 	case 'a', 'b', 'c', 'd': // ERROR "duplicate case 'b' .value 98."
 	case x, x: // ERROR "duplicate case x .value 10."
diff --git a/test/switch7.go b/test/switch7.go
index d9cc7a81da..75060669b3 100644
--- a/test/switch7.go
+++ b/test/switch7.go
@@ -32,3 +32,4 @@ func f4(e interface{}) {
 	}:
 	}
 }
+
diff --git a/test/tinyfin.go b/test/tinyfin.go
index 215b3d1b73..5171dfc72e 100644
--- a/test/tinyfin.go
+++ b/test/tinyfin.go
@@ -32,7 +32,7 @@ func main() {
 	runtime.GC()
 	count := 0
 	done := make([]bool, N)
-	timeout := time.After(5 * time.Second)
+	timeout := time.After(5*time.Second)
 	for {
 		select {
 		case <-timeout:
diff --git a/test/typecheck.go b/test/typecheck.go
index 3c225ad346..6f1204289a 100644
--- a/test/typecheck.go
+++ b/test/typecheck.go
@@ -8,11 +8,11 @@
 
 package main
 
-func mine(int b) int { // ERROR "undefined.*b"
-	return b + 2 // ERROR "undefined.*b"
+func mine(int b) int {	// ERROR "undefined.*b"
+	return b + 2	// ERROR "undefined.*b"
 }
 
 func main() {
-	mine()     // GCCGO_ERROR "not enough arguments"
-	c = mine() // ERROR "undefined.*c|not enough arguments"
+	mine()		// GCCGO_ERROR "not enough arguments"
+	c = mine()	// ERROR "undefined.*c|not enough arguments"
 }
diff --git a/test/typeswitch2.go b/test/typeswitch2.go
index b6c78e8251..5958b7db8e 100644
--- a/test/typeswitch2.go
+++ b/test/typeswitch2.go
@@ -26,7 +26,7 @@ func whatis(x interface{}) string {
 		w()
 	}:
 		return "rw"
-	case interface { // ERROR "duplicate"
+	case interface {	// ERROR "duplicate"
 		w()
 		r()
 	}:
diff --git a/test/undef.go b/test/undef.go
index 14cefa93d7..61524f3d4c 100644
--- a/test/undef.go
+++ b/test/undef.go
@@ -10,26 +10,24 @@
 package main
 
 var (
-	_ = x // ERROR "undefined.*x"
-	_ = x // ERROR "undefined.*x"
-	_ = x // ERROR "undefined.*x"
+	_ = x	// ERROR "undefined.*x"
+	_ = x	// ERROR "undefined.*x"
+	_ = x	// ERROR "undefined.*x"
 )
 
 type T struct {
 	y int
 }
 
-func foo() *T  { return &T{y: 99} }
-func bar() int { return y } // ERROR "undefined.*y"
+func foo() *T { return &T{y: 99} }
+func bar() int { return y }	// ERROR "undefined.*y"
 
 type T1 struct {
 	y1 int
 }
 
 func foo1() *T1 { return &T1{y1: 99} }
-
 var y1 = 2
-
 func bar1() int { return y1 }
 
 func f1(val interface{}) {
@@ -42,6 +40,6 @@ func f1(val interface{}) {
 func f2(val interface{}) {
 	switch val.(type) {
 	default:
-		println(v) // ERROR "undefined.*v"
+		println(v)	// ERROR "undefined.*v"
 	}
 }
diff --git a/test/varerr.go b/test/varerr.go
index 95a03fd8c5..82ab814197 100644
--- a/test/varerr.go
+++ b/test/varerr.go
@@ -10,7 +10,8 @@
 package main
 
 func main() {
-	_ = asdf // ERROR "undefined.*asdf"
+	_ = asdf	// ERROR "undefined.*asdf"
 
-	new = 1 // ERROR "use of builtin new not in function call|invalid left hand side"
+	new = 1	// ERROR "use of builtin new not in function call|invalid left hand side"
 }
+

From 2cbc9ab851f6088016e37da7add8eb5b06a8ba6b Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 24 Sep 2019 21:18:02 -0400
Subject: [PATCH 120/126] Fix cross-platform compilation errors

---
 src/runtime/defs_linux_386.go     |  8 +++---
 src/runtime/defs_linux_arm.go     |  8 +++---
 src/runtime/defs_linux_arm64.go   |  8 +++---
 src/runtime/defs_linux_mips64x.go |  8 +++---
 src/runtime/defs_linux_mipsx.go   |  8 +++---
 src/runtime/defs_linux_ppc64.go   |  8 +++---
 src/runtime/defs_linux_ppc64le.go |  8 +++---
 src/runtime/defs_linux_s390x.go   |  8 +++---
 src/runtime/defs_perf_linux.go    |  6 ++---
 src/runtime/os_linux.go           | 21 ++++++++-------
 src/runtime/perf_linux.go         | 18 ++++++-------
 src/runtime/proc.go               |  2 +-
 src/runtime/runtime2.go           | 43 ++++++++++++++++---------------
 13 files changed, 86 insertions(+), 68 deletions(-)

diff --git a/src/runtime/defs_linux_386.go b/src/runtime/defs_linux_386.go
index 21758918fe..0ade3f80de 100644
--- a/src/runtime/defs_linux_386.go
+++ b/src/runtime/defs_linux_386.go
@@ -13,9 +13,11 @@ const (
 	_PROT_WRITE = 0x2
 	_PROT_EXEC  = 0x4
 
-	_MAP_ANON    = 0x20
-	_MAP_PRIVATE = 0x2
-	_MAP_FIXED   = 0x10
+	_MAP_SHARED          = 0x1
+	_MAP_PRIVATE         = 0x2
+	_MAP_SHARED_VALIDATE = 0x3
+	_MAP_FIXED           = 0x10
+	_MAP_ANON            = 0x20
 
 	_MADV_DONTNEED   = 0x4
 	_MADV_FREE       = 0x8
diff --git a/src/runtime/defs_linux_arm.go b/src/runtime/defs_linux_arm.go
index 944aeac4f4..01fa2fffe0 100644
--- a/src/runtime/defs_linux_arm.go
+++ b/src/runtime/defs_linux_arm.go
@@ -11,9 +11,11 @@ const (
 	_PROT_WRITE = 0x2
 	_PROT_EXEC  = 0x4
 
-	_MAP_ANON    = 0x20
-	_MAP_PRIVATE = 0x2
-	_MAP_FIXED   = 0x10
+	_MAP_SHARED          = 0x1
+	_MAP_PRIVATE         = 0x2
+	_MAP_SHARED_VALIDATE = 0x3
+	_MAP_FIXED           = 0x10
+	_MAP_ANON            = 0x20
 
 	_MADV_DONTNEED   = 0x4
 	_MADV_FREE       = 0x8
diff --git a/src/runtime/defs_linux_arm64.go b/src/runtime/defs_linux_arm64.go
index b1f788aa83..d19bc77da8 100644
--- a/src/runtime/defs_linux_arm64.go
+++ b/src/runtime/defs_linux_arm64.go
@@ -13,9 +13,11 @@ const (
 	_PROT_WRITE = 0x2
 	_PROT_EXEC  = 0x4
 
-	_MAP_ANON    = 0x20
-	_MAP_PRIVATE = 0x2
-	_MAP_FIXED   = 0x10
+	_MAP_SHARED          = 0x1
+	_MAP_PRIVATE         = 0x2
+	_MAP_SHARED_VALIDATE = 0x3
+	_MAP_FIXED           = 0x10
+	_MAP_ANON            = 0x20
 
 	_MADV_DONTNEED   = 0x4
 	_MADV_FREE       = 0x8
diff --git a/src/runtime/defs_linux_mips64x.go b/src/runtime/defs_linux_mips64x.go
index 96499ad219..e751798d57 100644
--- a/src/runtime/defs_linux_mips64x.go
+++ b/src/runtime/defs_linux_mips64x.go
@@ -13,9 +13,11 @@ const (
 	_PROT_WRITE = 0x2
 	_PROT_EXEC  = 0x4
 
-	_MAP_ANON    = 0x800
-	_MAP_PRIVATE = 0x2
-	_MAP_FIXED   = 0x10
+	_MAP_SHARED          = 0x1
+	_MAP_PRIVATE         = 0x2
+	_MAP_SHARED_VALIDATE = 0x3
+	_MAP_FIXED           = 0x10
+	_MAP_ANON            = 0x800
 
 	_MADV_DONTNEED   = 0x4
 	_MADV_FREE       = 0x8
diff --git a/src/runtime/defs_linux_mipsx.go b/src/runtime/defs_linux_mipsx.go
index bb63a95ce8..e79b110856 100644
--- a/src/runtime/defs_linux_mipsx.go
+++ b/src/runtime/defs_linux_mipsx.go
@@ -17,9 +17,11 @@ const (
 	_PROT_WRITE = 0x2
 	_PROT_EXEC  = 0x4
 
-	_MAP_ANON    = 0x800
-	_MAP_PRIVATE = 0x2
-	_MAP_FIXED   = 0x10
+	_MAP_SHARED          = 0x1
+	_MAP_PRIVATE         = 0x2
+	_MAP_SHARED_VALIDATE = 0x3
+	_MAP_FIXED           = 0x10
+	_MAP_ANON            = 0x800
 
 	_MADV_DONTNEED   = 0x4
 	_MADV_FREE       = 0x8
diff --git a/src/runtime/defs_linux_ppc64.go b/src/runtime/defs_linux_ppc64.go
index 4388b24f73..e298833c95 100644
--- a/src/runtime/defs_linux_ppc64.go
+++ b/src/runtime/defs_linux_ppc64.go
@@ -13,9 +13,11 @@ const (
 	_PROT_WRITE = 0x2
 	_PROT_EXEC  = 0x4
 
-	_MAP_ANON    = 0x20
-	_MAP_PRIVATE = 0x2
-	_MAP_FIXED   = 0x10
+	_MAP_SHARED          = 0x1
+	_MAP_PRIVATE         = 0x2
+	_MAP_SHARED_VALIDATE = 0x3
+	_MAP_FIXED           = 0x10
+	_MAP_ANON            = 0x20
 
 	_MADV_DONTNEED   = 0x4
 	_MADV_FREE       = 0x8
diff --git a/src/runtime/defs_linux_ppc64le.go b/src/runtime/defs_linux_ppc64le.go
index 90aaacecf2..0f5b5771d6 100644
--- a/src/runtime/defs_linux_ppc64le.go
+++ b/src/runtime/defs_linux_ppc64le.go
@@ -13,9 +13,11 @@ const (
 	_PROT_WRITE = 0x2
 	_PROT_EXEC  = 0x4
 
-	_MAP_ANON    = 0x20
-	_MAP_PRIVATE = 0x2
-	_MAP_FIXED   = 0x10
+	_MAP_SHARED          = 0x1
+	_MAP_PRIVATE         = 0x2
+	_MAP_SHARED_VALIDATE = 0x3
+	_MAP_FIXED           = 0x10
+	_MAP_ANON            = 0x20
 
 	_MADV_DONTNEED   = 0x4
 	_MADV_FREE       = 0x8
diff --git a/src/runtime/defs_linux_s390x.go b/src/runtime/defs_linux_s390x.go
index bd411f3726..165bb5a788 100644
--- a/src/runtime/defs_linux_s390x.go
+++ b/src/runtime/defs_linux_s390x.go
@@ -14,9 +14,11 @@ const (
 	_PROT_WRITE = 0x2
 	_PROT_EXEC  = 0x4
 
-	_MAP_ANON    = 0x20
-	_MAP_PRIVATE = 0x2
-	_MAP_FIXED   = 0x10
+	_MAP_SHARED          = 0x1
+	_MAP_PRIVATE         = 0x2
+	_MAP_SHARED_VALIDATE = 0x3
+	_MAP_FIXED           = 0x10
+	_MAP_ANON            = 0x20
 
 	_MADV_DONTNEED   = 0x4
 	_MADV_FREE       = 0x8
diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index f4735d4fc4..ddea650499 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -2,7 +2,7 @@ package runtime
 
 // Convert platform-agnostic pmu events to Linux perf events
 var perfEventOpt = map[int32]struct {
-	// The lower-case type is reserved for Go
+	// The lower-case "type" is the key word in Go
 	Type   uint32 // type of event
 	config uint64 // event
 }{
@@ -17,7 +17,7 @@ var perfEventOpt = map[int32]struct {
 }
 
 type perfEventAttr struct {
-	// The lower-case type is reserved for Go
+	// The lower-case "type" is the key word in Go
 	Type               uint32
 	size               uint32
 	config             uint64
@@ -66,7 +66,7 @@ type perfEventMmapPage struct {
 }
 
 type perfEventHeader struct {
-	// The lower-case type is reserved for Go
+	// The lower-case "type" is the key word in Go
 	Type uint32
 	misc uint16
 	size uint16
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index e9a00bdfbb..0ee12242dc 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -517,8 +517,8 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		}
 
 		// create mmap buffer for this file
-		perfMmap := perfSetMmap(fd)
-		if perfMmap == nil {
+		mmapBuf := perfSetMmap(fd)
+		if mmapBuf == nil {
 			println("Fail to set perf mmap")
 			closefd(fd)
 			return
@@ -528,7 +528,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		_, err = fcntl(fd, 0x4 /* F_SETFL */, flag|0x2000 /* O_ASYNC */)
 		if err != 0 {
 			println("Failed to set notification for the PMU event")
-			perfUnsetMmap(perfMmap)
+			perfUnsetMmap(mmapBuf)
 			closefd(fd)
 			return
 		}
@@ -536,7 +536,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		_, err = fcntl(fd, 0xa /* F_SETSIG */, _SIGPROF)
 		if err != 0 {
 			println("Failed to set signal for the PMU event")
-			perfUnsetMmap(perfMmap)
+			perfUnsetMmap(mmapBuf)
 			closefd(fd)
 			return
 		}
@@ -545,25 +545,25 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		_, err = fcntl2(fd, 0xf /* F_SETOWN_EX */, &fOwnEx)
 		if err != 0 {
 			println("Failed to set the owner of the perf event file")
-			perfUnsetMmap(perfMmap)
+			perfUnsetMmap(mmapBuf)
 			closefd(fd)
 			return
 		}
 
 		_g_.m.eventAttrs[eventId] = eventAttr
-		_g_.m.eventMmapBufs[eventId] = perfMmap
+		_g_.m.eventMmapBufs[eventId] = mmapBuf
 		_g_.m.eventFds[eventId] = fd
 
 		if !perfResetCounter(fd) {
 			_g_.m.eventAttrs[eventId] = nil
-			perfUnsetMmap(perfMmap)
+			perfUnsetMmap(mmapBuf)
 			_g_.m.eventMmapBufs[eventId] = nil
 			closefd(fd)
 			return
 		}
 		if !perfStartCounter(fd) {
 			_g_.m.eventAttrs[eventId] = nil
-			perfUnsetMmap(perfMmap)
+			perfUnsetMmap(mmapBuf)
 			_g_.m.eventMmapBufs[eventId] = nil
 			closefd(fd)
 			return
@@ -586,8 +586,9 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 			break
 		}
 	}
+
 	if eventId != -1 {
-		mmapBuf := _g_.m.eventMmapBufs[eventId]
+		mmapBuf := (*perfEventMmapPage)(_g_.m.eventMmapBufs[eventId])
 
 		head := mmapBuf.data_head
 		rmb() // on SMP-capable platforms, after reading the data_head value, user space should issue a memory barrier
@@ -623,7 +624,7 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 
 				perfRecordSample(head, mmapBuf, _g_.m.eventAttrs[eventId], &sampleData)
 
-				sigprofPMU(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId, &sampleData)
+				sigprofPMU(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId /* &sampleData */)
 			} else if hdr.size == 0 {
 				perfSkipAll(head, mmapBuf)
 			} else {
diff --git a/src/runtime/perf_linux.go b/src/runtime/perf_linux.go
index 3b3a9293ee..d2245eb369 100644
--- a/src/runtime/perf_linux.go
+++ b/src/runtime/perf_linux.go
@@ -74,29 +74,28 @@ func perfMmapSize() uintptr {
 	return uintptr(perfPageSize * (perfDataPages + 1 /* metadata page */))
 }
 
-func perfSetMmap(fd int32) *perfEventMmapPage {
+func perfSetMmap(fd int32) unsafe.Pointer {
 	if perfPageSize == 0 {
 		perfMmapInit()
 	}
 
 	size := perfMmapSize()
-	r, err := mmap(nil, size, _PROT_WRITE|_PROT_READ, _MAP_SHARED, fd, 0 /* page offset */)
+	mmapBuf, err := mmap(nil, size, _PROT_WRITE|_PROT_READ, _MAP_SHARED, fd, 0 /* page offset */)
 	if err != 0 {
 		return nil
 	}
 
-	perfMmap := (*perfEventMmapPage)(r)
 	// There is no memset available in Go runime
-	// We instead employ the following approach to initialize all bytes in perfMmap to zeros
+	// We instead employ the following approach to initialize all bytes in mmapBuf to zeros
 	var temp perfEventMmapPage
-	memmove(unsafe.Pointer(perfMmap), unsafe.Pointer(&temp), unsafe.Sizeof(temp))
+	memmove(mmapBuf, unsafe.Pointer(&temp), unsafe.Sizeof(temp))
 
-	return perfMmap
+	return mmapBuf
 }
 
-func perfUnsetMmap(mmapBuf *perfEventMmapPage) {
+func perfUnsetMmap(mmapBuf unsafe.Pointer) {
 	size := perfMmapSize()
-	munmap(unsafe.Pointer(mmapBuf), size)
+	munmap(mmapBuf, size)
 }
 
 func perfSkipNBytes(head uint64, mmapBuf *perfEventMmapPage, n uint64) {
@@ -113,6 +112,7 @@ func perfSkipRecord(head uint64, mmapBuf *perfEventMmapPage, hdr *perfEventHeade
 	if mmapBuf == nil {
 		return
 	}
+
 	remains := uint64(hdr.size) - uint64(unsafe.Sizeof(*hdr))
 	if remains > 0 {
 		perfSkipNBytes(head, mmapBuf, remains)
@@ -128,7 +128,7 @@ func perfSkipAll(head uint64, mmapBuf *perfEventMmapPage) {
 
 	remains := head - tail
 	if remains > 0 {
-		perfSkipNBytes(head, mmapBuf, remains)
+		mmapBuf.data_tail += remains
 	}
 }
 
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 65afb6d5b0..50d081c85f 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3820,7 +3820,7 @@ var lostPMUAtomic64Count [GO_COUNT_PMU_EVENTS_MAX]uint64
 // Called if we receive a SIGPROF signal and PMU is enabled.
 // Called by the signal handler, may run during STW.
 //go:nowritebarrierrec
-func sigprofPMU(pc, sp, lr uintptr, gp *g, mp *m, eventId int, sampleData *perfSampleData) {
+func sigprofPMU(pc, sp, lr uintptr, gp *g, mp *m, eventId int) {
 	if pmuEvent[eventId].eventAttr == nil {
 		return
 	}
diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index e5b5dc4932..d86ff7c498 100644
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -455,27 +455,28 @@ type m struct {
 	divmod  uint32 // div/mod denominator for arm - known to liblink
 
 	// Fields not known to debuggers.
-	procid        uint64       // for debuggers, but offset not hard-coded
-	gsignal       *g           // signal-handling g
-	goSigStack    gsignalStack // Go-allocated signal handling stack
-	sigmask       sigset       // storage for saved signal mask
-	tls           [6]uintptr   // thread-local storage (for x86 extern register)
-	mstartfn      func()
-	curg          *g       // current running goroutine
-	caughtsig     guintptr // goroutine running during fatal signal
-	p             puintptr // attached p for executing go code (nil if not executing go code)
-	nextp         puintptr
-	oldp          puintptr // the p that was attached before executing a syscall
-	id            int64
-	mallocing     int32
-	throwing      int32
-	preemptoff    string // if != "", keep curg running on this m
-	locks         int32
-	dying         int32
-	profilehz     int32
-	eventFds      [GO_COUNT_PMU_EVENTS_MAX]int32
-	eventAttrs    [GO_COUNT_PMU_EVENTS_MAX]*PMUEventAttr
-	eventMmapBufs [GO_COUNT_PMU_EVENTS_MAX]*perfEventMmapPage
+	procid     uint64       // for debuggers, but offset not hard-coded
+	gsignal    *g           // signal-handling g
+	goSigStack gsignalStack // Go-allocated signal handling stack
+	sigmask    sigset       // storage for saved signal mask
+	tls        [6]uintptr   // thread-local storage (for x86 extern register)
+	mstartfn   func()
+	curg       *g       // current running goroutine
+	caughtsig  guintptr // goroutine running during fatal signal
+	p          puintptr // attached p for executing go code (nil if not executing go code)
+	nextp      puintptr
+	oldp       puintptr // the p that was attached before executing a syscall
+	id         int64
+	mallocing  int32
+	throwing   int32
+	preemptoff string // if != "", keep curg running on this m
+	locks      int32
+	dying      int32
+	profilehz  int32
+	eventFds   [GO_COUNT_PMU_EVENTS_MAX]int32
+	eventAttrs [GO_COUNT_PMU_EVENTS_MAX]*PMUEventAttr
+	// eventMmapBufs [GO_COUNT_PMU_EVENTS_MAX]*perfEventMmapPage
+	eventMmapBufs [GO_COUNT_PMU_EVENTS_MAX]unsafe.Pointer
 	spinning      bool // m is out of work and is actively looking for work
 	blocked       bool // m is blocked on a note
 	newSigstack   bool // minit on C thread called sigaltstack

From 99c2b0ef7ae9006888908266fe691d10ae03351e Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 24 Sep 2019 21:34:20 -0400
Subject: [PATCH 121/126] Change the comments

---
 src/runtime/defs_perf_linux.go | 6 +++---
 src/runtime/os_linux.go        | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/runtime/defs_perf_linux.go b/src/runtime/defs_perf_linux.go
index ddea650499..fce76ccf16 100644
--- a/src/runtime/defs_perf_linux.go
+++ b/src/runtime/defs_perf_linux.go
@@ -2,7 +2,7 @@ package runtime
 
 // Convert platform-agnostic pmu events to Linux perf events
 var perfEventOpt = map[int32]struct {
-	// The lower-case "type" is the key word in Go
+	// The lower-case "type" is the keyword in Go
 	Type   uint32 // type of event
 	config uint64 // event
 }{
@@ -17,7 +17,7 @@ var perfEventOpt = map[int32]struct {
 }
 
 type perfEventAttr struct {
-	// The lower-case "type" is the key word in Go
+	// The lower-case "type" is the keyword in Go
 	Type               uint32
 	size               uint32
 	config             uint64
@@ -66,7 +66,7 @@ type perfEventMmapPage struct {
 }
 
 type perfEventHeader struct {
-	// The lower-case "type" is the key word in Go
+	// The lower-case "type" is the keyword in Go
 	Type uint32
 	misc uint16
 	size uint16
diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 0ee12242dc..95673d5ffc 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -624,7 +624,7 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 
 				perfRecordSample(head, mmapBuf, _g_.m.eventAttrs[eventId], &sampleData)
 
-				sigprofPMU(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId /* &sampleData */)
+				sigprofPMU(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m, eventId /* , &sampleData */)
 			} else if hdr.size == 0 {
 				perfSkipAll(head, mmapBuf)
 			} else {

From 9e43ce5074e8b30cdece7e5770a132dc5b6890df Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 15 Oct 2019 00:08:17 -0400
Subject: [PATCH 122/126] delete excess space

---
 src/cmd/go/alldocs.go            |  2 +-
 src/cmd/go/internal/test/test.go |  2 +-
 src/math/cmplx/cmath_test.go     |  2 +-
 src/runtime/sys_linux_amd64.s    |  2 +-
 src/runtime/sys_linux_mips64x.s  | 18 ++++++-------
 src/runtime/sys_linux_ppc64x.s   | 44 ++++++++++++++++----------------
 src/runtime/sys_linux_s390x.s    |  8 +++---
 7 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index 079cecc1ff..8b3afdbb29 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -2962,7 +2962,7 @@
 // 	    Write a PMU profile to the specified file before exiting.
 // 	    Writes test binary as -c would.
 //
-//     	-pmuevent event
+// 	-pmuevent event
 // 	    Specify which pmu event to sample.
 // 	    To sample PMU cycles, use -test.pmuevent=cycles.
 // 	    To sample PMU instructions, use -test.pmuevent=instructions.
diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 055f5b4d58..0be5a351a6 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -317,7 +317,7 @@ profile the tests during execution:
 	    Write a PMU profile to the specified file before exiting.
 	    Writes test binary as -c would.
 
-    	-pmuevent event
+	-pmuevent event
 	    Specify which pmu event to sample.
 	    To sample PMU cycles, use -test.pmuevent=cycles.
 	    To sample PMU instructions, use -test.pmuevent=instructions.
diff --git a/src/math/cmplx/cmath_test.go b/src/math/cmplx/cmath_test.go
index 57ba76a767..fbb49fdd5b 100644
--- a/src/math/cmplx/cmath_test.go
+++ b/src/math/cmplx/cmath_test.go
@@ -222,7 +222,7 @@ var pow = []complex128{
 	(-2.499956739197529585028819e+00 + 1.759751724335650228957144e+00i),
 	(7.357094338218116311191939e+04 - 5.089973412479151648145882e+04i),
 	(1.320777296067768517259592e+01 - 3.165621914333901498921986e+01i),
-	(-3.123287828297300934072149e-07 - 1.9849567521490553032502223e-7i),
+	(-3.123287828297300934072149e-07 - 1.9849567521490553032502223E-7i),
 	(8.0622651468477229614813e+04 - 7.80028727944573092944363e+04i),
 	(-1.0268824572103165858577141e+00 - 4.716844738244989776610672e-01i),
 	(-4.35953819012244175753187e+01 + 2.2036445974645306917648585e+02i),
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index 40a2bd1f7f..ba3da27077 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -39,7 +39,7 @@
 #define SYS_gettid		186
 #define SYS_futex		202
 #define SYS_sched_getaffinity	204
-#define SYS_epoll_create	213
+#define SYS_epoll_create        213
 #define SYS_exit_group		231
 #define SYS_epoll_ctl		233
 #define SYS_tgkill		234
diff --git a/src/runtime/sys_linux_mips64x.s b/src/runtime/sys_linux_mips64x.s
index 5bcf7b5407..9580812277 100644
--- a/src/runtime/sys_linux_mips64x.s
+++ b/src/runtime/sys_linux_mips64x.s
@@ -516,7 +516,7 @@ TEXT runtime·ioctl,NOSPLIT,$0-40
 	BEQ	R7, ok
 	MOVV	$-1, R1
 	MOVV	R1, r+24(FP)
-	MOVV	R2, err+32(FP)	
+	MOVV	R2, err+32(FP)
 	RET
 ok:
 	MOVV	R2, r+24(FP)
@@ -535,12 +535,12 @@ TEXT runtime·fcntl,NOSPLIT,$0-40
 	SYSCALL
 	BEQ	R7, ok
 	MOVV	$-1, R1
-	MOVV	R1, r+24(FP)	
-	MOVV	R2, err+32(FP)	
+	MOVV	R1, r+24(FP)
+	MOVV	R2, err+32(FP)
 	RET
 ok:
-	MOVV	R2, r+24(FP)	
-	MOVV	R0, err+32(FP)	
+	MOVV	R2, r+24(FP)
+	MOVV	R0, err+32(FP)
 	RET
 
 // psu: not tested
@@ -555,10 +555,10 @@ TEXT runtime·fcntl2,NOSPLIT,$0-40
 	SYSCALL
 	BEQ	R7, ok
 	MOVV	$-1, R1
-	MOVV	R1, r+24(FP)	
-	MOVV	R2, err+32(FP)	
+	MOVV	R1, r+24(FP)
+	MOVV	R2, err+32(FP)
 	RET
 ok:
-	MOVV	R2, r+24(FP)	
-	MOVV	R0, err+32(FP)	
+	MOVV	R2, r+24(FP)
+	MOVV	R0, err+32(FP)
 	RET
diff --git a/src/runtime/sys_linux_ppc64x.s b/src/runtime/sys_linux_ppc64x.s
index e030320aab..8cb7fa91ce 100644
--- a/src/runtime/sys_linux_ppc64x.s
+++ b/src/runtime/sys_linux_ppc64x.s
@@ -645,18 +645,18 @@ TEXT runtime·perfEventOpen(SB),NOSPLIT,$0-72
 	MOVD	groupFd+24(FP), R6
 	MOVD	flags+32(FP), R7
 	MOVD	dummy+40(FP), R8
-	MOVD	$SYS_perf_event_open, R9	
+	MOVD	$SYS_perf_event_open, R9
 	SYSCALL R9
 	BVC	ok
 	MOVD	$-1, R4
-	MOVW	R4, r+48(FP)	
-	MOVD	R0, r2+56(FP)	
-	MOVD	R3, err+64(FP)	
+	MOVW	R4, r+48(FP)
+	MOVD	R0, r2+56(FP)
+	MOVD	R3, err+64(FP)
 	RET
 ok:
-	MOVW	R3, r+48(FP)	
-	MOVD	R4, r2+56(FP)	
-	MOVD	R0, err+64(FP)	
+	MOVW	R3, r+48(FP)
+	MOVD	R4, r2+56(FP)
+	MOVD	R0, err+64(FP)
 	RET
 
 // psu: not tested
@@ -667,16 +667,16 @@ TEXT runtime·ioctl(SB),NOSPLIT,$0-40
 	MOVD	R0, R6
 	MOVD	R0, R7
 	MOVD	R0, R8
-	MOVD	$SYS_ioctl, R9	
+	MOVD	$SYS_ioctl, R9
 	SYSCALL R9
 	BVC	ok
 	MOVD	$-1, R4
-	MOVD	R4, r+24(FP)	
-	MOVD	R3, err+32(FP)	
+	MOVD	R4, r+24(FP)
+	MOVD	R3, err+32(FP)
 	RET
 ok:
-	MOVD	R3, r+24(FP)	
-	MOVD	R0, err+32(FP)	
+	MOVD	R3, r+24(FP)
+	MOVD	R0, err+32(FP)
 	RET
 
 // psu: not tested
@@ -687,16 +687,16 @@ TEXT runtime·fcntl(SB),NOSPLIT,$0-40
 	MOVD	R0, R6
 	MOVD	R0, R7
 	MOVD	R0, R8
-	MOVD	$SYS_fcntl, R9	
+	MOVD	$SYS_fcntl, R9
 	SYSCALL R9
 	BVC	ok
 	MOVD	$-1, R4
-	MOVD	R4, r+24(FP)	
-	MOVD	R3, err+32(FP)	
+	MOVD	R4, r+24(FP)
+	MOVD	R3, err+32(FP)
 	RET
 ok:
-	MOVD	R3, r+24(FP)	
-	MOVD	R0, err+32(FP)	
+	MOVD	R3, r+24(FP)
+	MOVD	R0, err+32(FP)
 	RET
 
 // psu: not tested
@@ -707,14 +707,14 @@ TEXT runtime·fcntl2(SB),NOSPLIT,$0-40
 	MOVD	R0, R6
 	MOVD	R0, R7
 	MOVD	R0, R8
-	MOVD	$SYS_fcntl, R9	
+	MOVD	$SYS_fcntl, R9
 	SYSCALL R9
 	BVC	ok
 	MOVD	$-1, R4
-	MOVD	R4, r+24(FP)	
-	MOVD	R3, err+32(FP)	
+	MOVD	R4, r+24(FP)
+	MOVD	R3, err+32(FP)
 	RET
 ok:
-	MOVD	R3, r+24(FP)	
-	MOVD	R0, err+32(FP)	
+	MOVD	R3, r+24(FP)
+	MOVD	R0, err+32(FP)
 	RET
diff --git a/src/runtime/sys_linux_s390x.s b/src/runtime/sys_linux_s390x.s
index 4f75286ba5..9d785d856c 100644
--- a/src/runtime/sys_linux_s390x.s
+++ b/src/runtime/sys_linux_s390x.s
@@ -16,8 +16,8 @@
 #define SYS_close                 6
 #define SYS_getpid               20
 #define SYS_kill                 37
-#define SYS_brk			 45
-#define SYS_ioctl		 54
+#define SYS_brk                  45
+#define SYS_ioctl                54
 #define SYS_fcntl                55
 #define SYS_mmap                 90
 #define SYS_munmap               91
@@ -41,7 +41,7 @@
 #define SYS_epoll_wait          251
 #define SYS_clock_gettime       260
 #define SYS_epoll_create1       327
-#define SYS_perf_event_open	331
+#define SYS_perf_event_open     331
 
 TEXT runtime·exit(SB),NOSPLIT|NOFRAME,$0-4
 	MOVW	code+0(FP), R2
@@ -475,7 +475,7 @@ TEXT runtime·perfEventOpen(SB),NOSPLIT,$0-72
 	MOVD	groupFd+24(FP), R5
 	MOVD	flags+32(FP), R6
 	MOVD	dummy+40(FP), R7
-	MOVD	SYS_perf_event_open, R1	
+	MOVD	SYS_perf_event_open, R1
 	SYSCALL
 	MOVD	$0xfffffffffffff001, R8
 	CMPUBLT	R2, R8, ok

From ed87648809f11d12321b330c169366a81791f61d Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 15 Oct 2019 11:41:48 -0400
Subject: [PATCH 123/126] delete excess space

---
 src/runtime/sys_linux_amd64.s | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index ba3da27077..40a2bd1f7f 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -39,7 +39,7 @@
 #define SYS_gettid		186
 #define SYS_futex		202
 #define SYS_sched_getaffinity	204
-#define SYS_epoll_create        213
+#define SYS_epoll_create	213
 #define SYS_exit_group		231
 #define SYS_epoll_ctl		233
 #define SYS_tgkill		234

From ab79a0a6a2cc8e2cf14fe2c36168c64c5fb4bb8f Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 15 Oct 2019 11:41:48 -0400
Subject: [PATCH 124/126] delete excess space

---
 src/runtime/perf_linux.go     | 5 -----
 src/runtime/sys_linux_amd64.s | 2 +-
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/src/runtime/perf_linux.go b/src/runtime/perf_linux.go
index d2245eb369..1e9779c674 100644
--- a/src/runtime/perf_linux.go
+++ b/src/runtime/perf_linux.go
@@ -85,11 +85,6 @@ func perfSetMmap(fd int32) unsafe.Pointer {
 		return nil
 	}
 
-	// There is no memset available in Go runime
-	// We instead employ the following approach to initialize all bytes in mmapBuf to zeros
-	var temp perfEventMmapPage
-	memmove(mmapBuf, unsafe.Pointer(&temp), unsafe.Sizeof(temp))
-
 	return mmapBuf
 }
 
diff --git a/src/runtime/sys_linux_amd64.s b/src/runtime/sys_linux_amd64.s
index ba3da27077..40a2bd1f7f 100644
--- a/src/runtime/sys_linux_amd64.s
+++ b/src/runtime/sys_linux_amd64.s
@@ -39,7 +39,7 @@
 #define SYS_gettid		186
 #define SYS_futex		202
 #define SYS_sched_getaffinity	204
-#define SYS_epoll_create        213
+#define SYS_epoll_create	213
 #define SYS_exit_group		231
 #define SYS_epoll_ctl		233
 #define SYS_tgkill		234

From b67770af5f804792df66d0e7cc32ceb4754a1cc4 Mon Sep 17 00:00:00 2001
From: Milind Chabbi <chabbi.milind@gmail.com>
Date: Mon, 21 Oct 2019 22:18:35 -0700
Subject: [PATCH 125/126] Pprof+PMU: Set the file descriptor to 0 after closing

---
 src/runtime/os_linux.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index 95673d5ffc..ede6b45e5e 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -491,6 +491,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 	if eventAttr == nil {
 		if _g_.m.eventAttrs[eventId] != nil {
 			closefd(_g_.m.eventFds[eventId])
+			_g_.m.eventFds[eventId] = 0
 			_g_.m.eventAttrs[eventId] = nil
 		}
 		if _g_.m.eventMmapBufs[eventId] != nil {
@@ -500,6 +501,7 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 	} else {
 		if _g_.m.eventAttrs[eventId] != nil {
 			closefd(_g_.m.eventFds[eventId])
+			_g_.m.eventFds[eventId] = 0
 			_g_.m.eventAttrs[eventId] = nil
 		}
 		if _g_.m.eventMmapBufs[eventId] != nil {

From 9465bad596948142f5f1489d81700d1123c2160a Mon Sep 17 00:00:00 2001
From: Pengfei Su <psu@email.wm.edu>
Date: Tue, 22 Oct 2019 15:07:41 -0400
Subject: [PATCH 126/126] Two patches: 1) disable the PMU counter before
 closing the associated file descriptor and 2) in the signal handler, find out
 the PMU counter that triggers the overflow interrupt

---
 src/runtime/os_linux.go | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go
index ede6b45e5e..a55ad2a6c5 100644
--- a/src/runtime/os_linux.go
+++ b/src/runtime/os_linux.go
@@ -490,8 +490,9 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 
 	if eventAttr == nil {
 		if _g_.m.eventAttrs[eventId] != nil {
+			// We need to disable the counter prior to closing the file descriptor
+			perfStopCounter(_g_.m.eventFds[eventId])
 			closefd(_g_.m.eventFds[eventId])
-			_g_.m.eventFds[eventId] = 0
 			_g_.m.eventAttrs[eventId] = nil
 		}
 		if _g_.m.eventMmapBufs[eventId] != nil {
@@ -500,8 +501,9 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		}
 	} else {
 		if _g_.m.eventAttrs[eventId] != nil {
+			// We need to disable the counter prior to closing the file descriptor
+			perfStopCounter(_g_.m.eventFds[eventId])
 			closefd(_g_.m.eventFds[eventId])
-			_g_.m.eventFds[eventId] = 0
 			_g_.m.eventAttrs[eventId] = nil
 		}
 		if _g_.m.eventMmapBufs[eventId] != nil {
@@ -521,34 +523,34 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		// create mmap buffer for this file
 		mmapBuf := perfSetMmap(fd)
 		if mmapBuf == nil {
-			println("Fail to set perf mmap")
 			closefd(fd)
+			println("Fail to set perf mmap")
 			return
 		}
 
 		flag, _ := fcntl(fd, 0x3 /* F_GETFL */, 0)
 		_, err = fcntl(fd, 0x4 /* F_SETFL */, flag|0x2000 /* O_ASYNC */)
 		if err != 0 {
-			println("Failed to set notification for the PMU event")
-			perfUnsetMmap(mmapBuf)
 			closefd(fd)
+			perfUnsetMmap(mmapBuf)
+			println("Failed to set notification for the PMU event")
 			return
 		}
 
 		_, err = fcntl(fd, 0xa /* F_SETSIG */, _SIGPROF)
 		if err != 0 {
-			println("Failed to set signal for the PMU event")
-			perfUnsetMmap(mmapBuf)
 			closefd(fd)
+			perfUnsetMmap(mmapBuf)
+			println("Failed to set signal for the PMU event")
 			return
 		}
 
 		fOwnEx := fOwnerEx{0 /* F_OWNER_TID */, int32(gettid())}
 		_, err = fcntl2(fd, 0xf /* F_SETOWN_EX */, &fOwnEx)
 		if err != 0 {
-			println("Failed to set the owner of the perf event file")
-			perfUnsetMmap(mmapBuf)
 			closefd(fd)
+			perfUnsetMmap(mmapBuf)
+			println("Failed to set the owner of the perf event file")
 			return
 		}
 
@@ -557,17 +559,17 @@ func setThreadPMUProfiler(eventId int32, eventAttr *PMUEventAttr) {
 		_g_.m.eventFds[eventId] = fd
 
 		if !perfResetCounter(fd) {
-			_g_.m.eventAttrs[eventId] = nil
+			closefd(fd)
 			perfUnsetMmap(mmapBuf)
+			_g_.m.eventAttrs[eventId] = nil
 			_g_.m.eventMmapBufs[eventId] = nil
-			closefd(fd)
 			return
 		}
 		if !perfStartCounter(fd) {
-			_g_.m.eventAttrs[eventId] = nil
+			closefd(fd)
 			perfUnsetMmap(mmapBuf)
+			_g_.m.eventAttrs[eventId] = nil
 			_g_.m.eventMmapBufs[eventId] = nil
-			closefd(fd)
 			return
 		}
 	}
@@ -583,7 +585,7 @@ func sigprofPMUHandler(info *siginfo, c *sigctxt, gp *g, _g_ *g) {
 
 	var eventId int = -1
 	for i := 0; i < GO_COUNT_PMU_EVENTS_MAX; i++ {
-		if _g_.m.eventFds[i] == fd {
+		if _g_.m.eventFds[i] == fd && _g_.m.eventAttrs[i] != nil {
 			eventId = i
 			break
 		}