From d2574e2adb658b46ea2d8e22b3195cc14da1affe Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 16 Sep 2014 10:22:15 -0400 Subject: [PATCH] runtime: remove duplicated Go constants The C header files are the single point of truth: every C enum constant Foo is available to Go as _Foo. Remove or redirect duplicate Go declarations so they cannot be out of sync. Eventually we will need to put constants in Go, but for now having them be out of sync with C is too risky. These predate the build support for auto-generating Go constants from the C definitions. LGTM=iant R=iant CC=golang-codereviews https://golang.org/cl/141510043 --- src/cmd/api/goapi.go | 46 +++++++++++++++++++++++++++ src/cmd/dist/buildruntime.c | 6 ++-- src/runtime/arch_386.go | 4 --- src/runtime/arch_amd64.go | 4 --- src/runtime/arch_amd64p32.go | 4 --- src/runtime/arch_arm.go | 4 --- src/runtime/chan.go | 2 +- src/runtime/malloc.c | 6 ++-- src/runtime/malloc.go | 48 ++++++++++++----------------- src/runtime/mgc0.c | 2 +- src/runtime/mgc0.go | 12 -------- src/runtime/mgc0.h | 12 ++++---- src/runtime/os_darwin.go | 2 -- src/runtime/os_freebsd.go | 2 -- src/runtime/os_linux.go | 2 -- src/runtime/os_nacl.go | 2 -- src/runtime/os_netbsd.go | 2 -- src/runtime/os_openbsd.go | 2 -- src/runtime/os_plan9.go | 4 --- src/runtime/os_solaris.go | 2 -- src/runtime/os_windows.go | 2 -- src/runtime/runtime.h | 1 - src/runtime/sema.go | 2 +- src/runtime/slice.go | 8 ++--- src/runtime/string.go | 2 +- src/runtime/typekind.go | 60 ++++++++++++++++++------------------ src/runtime/typekind.h | 3 -- 27 files changed, 117 insertions(+), 129 deletions(-) diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go index 8494a3f61b..78b7d6edf1 100644 --- a/src/cmd/api/goapi.go +++ b/src/cmd/api/goapi.go @@ -423,6 +423,52 @@ func (w *Walker) parseFile(dir, file string) (*ast.File, error) { " _Genqueue = 7;" + " _Gcopystack = 8;" + " _NSIG = 32;" + + " _FlagNoScan = iota;" + + " _FlagNoZero;" + + " _TinySize;" + + " _TinySizeClass;" + + " _MaxSmallSize;" + + " _PageShift;" + + " _PageSize;" + + " _PageMask;" + + " _BitsPerPointer;" + + " _BitsMask;" + + " _PointersPerByte;" + + " _MaxGCMask;" + + " _BitsDead;" + + " _BitsPointer;" + + " _MSpanInUse;" + + " _ConcurrentSweep;" + + " _KindBool;" + + " _KindInt;" + + " _KindInt8;" + + " _KindInt16;" + + " _KindInt32;" + + " _KindInt64;" + + " _KindUint;" + + " _KindUint8;" + + " _KindUint16;" + + " _KindUint32;" + + " _KindUint64;" + + " _KindUintptr;" + + " _KindFloat32;" + + " _KindFloat64;" + + " _KindComplex64;" + + " _KindComplex128;" + + " _KindArray;" + + " _KindChan;" + + " _KindFunc;" + + " _KindInterface;" + + " _KindMap;" + + " _KindPtr;" + + " _KindSlice;" + + " _KindString;" + + " _KindStruct;" + + " _KindUnsafePointer;" + + " _KindDirectIface;" + + " _KindGCProg;" + + " _KindNoPointers;" + + " _KindMask;" + ")" f, err = parser.ParseFile(fset, filename, src, 0) if err != nil { diff --git a/src/cmd/dist/buildruntime.c b/src/cmd/dist/buildruntime.c index 36efb5711c..1257d5b811 100644 --- a/src/cmd/dist/buildruntime.c +++ b/src/cmd/dist/buildruntime.c @@ -329,6 +329,8 @@ mkzsys(char *dir, char *file) static char *runtimedefs[] = { "defs.c", + "malloc.c", + "mgc0.c", "proc.c", "parfor.c", }; @@ -337,8 +339,8 @@ static char *runtimedefs[] = { // which contains Go struct definitions equivalent to the C ones. // Mostly we just write the output of 6c -q to the file. // However, we run it on multiple files, so we have to delete -// the duplicated definitions, and we don't care about the funcs -// and consts, so we delete those too. +// the duplicated definitions, and we don't care about the funcs, +// so we delete those too. // void mkzruntimedefs(char *dir, char *file) diff --git a/src/runtime/arch_386.go b/src/runtime/arch_386.go index 287b67e270..79d38c7ab1 100644 --- a/src/runtime/arch_386.go +++ b/src/runtime/arch_386.go @@ -4,9 +4,5 @@ package runtime -const ( - cacheLineSize = 64 -) - type uintreg uint32 type intptr int32 // TODO(rsc): remove diff --git a/src/runtime/arch_amd64.go b/src/runtime/arch_amd64.go index fe60c70660..270cd7b957 100644 --- a/src/runtime/arch_amd64.go +++ b/src/runtime/arch_amd64.go @@ -4,9 +4,5 @@ package runtime -const ( - cacheLineSize = 64 -) - type uintreg uint64 type intptr int64 // TODO(rsc): remove diff --git a/src/runtime/arch_amd64p32.go b/src/runtime/arch_amd64p32.go index 90766b404f..5c636aeab2 100644 --- a/src/runtime/arch_amd64p32.go +++ b/src/runtime/arch_amd64p32.go @@ -4,9 +4,5 @@ package runtime -const ( - cacheLineSize = 64 -) - type uintreg uint64 type intptr int32 // TODO(rsc): remove diff --git a/src/runtime/arch_arm.go b/src/runtime/arch_arm.go index 23f2711f6d..79d38c7ab1 100644 --- a/src/runtime/arch_arm.go +++ b/src/runtime/arch_arm.go @@ -4,9 +4,5 @@ package runtime -const ( - cacheLineSize = 32 -) - type uintreg uint32 type intptr int32 // TODO(rsc): remove diff --git a/src/runtime/chan.go b/src/runtime/chan.go index 226b824065..48925b2e3e 100644 --- a/src/runtime/chan.go +++ b/src/runtime/chan.go @@ -26,7 +26,7 @@ func makechan(t *chantype, size int64) *hchan { if hchanSize%maxAlign != 0 || elem.align > maxAlign { gothrow("makechan: bad alignment") } - if size < 0 || int64(uintptr(size)) != size || (elem.size > 0 && uintptr(size) > (maxMem-hchanSize)/uintptr(elem.size)) { + if size < 0 || int64(uintptr(size)) != size || (elem.size > 0 && uintptr(size) > (maxmem-hchanSize)/uintptr(elem.size)) { panic("makechan: size out of range") } diff --git a/src/runtime/malloc.c b/src/runtime/malloc.c index b56f42531e..e5c7e09592 100644 --- a/src/runtime/malloc.c +++ b/src/runtime/malloc.c @@ -102,9 +102,9 @@ uintptr runtime·sizeof_C_MStats = sizeof(MStats) - (NumSizeClasses - 61) * size #define MaxArena32 (2U<<30) -// For use by Go. It can't be a constant in Go, unfortunately, -// because it depends on the OS. -uintptr runtime·maxMem = MaxMem; +// For use by Go. If it were a C enum it would be made available automatically, +// but the value of MaxMem is too large for enum. +uintptr runtime·maxmem = MaxMem; void runtime·mallocinit(void) diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go index d6f1a1a4a2..7bb85057f4 100644 --- a/src/runtime/malloc.go +++ b/src/runtime/malloc.go @@ -11,49 +11,41 @@ import ( const ( debugMalloc = false - flagNoScan = 1 << 0 // GC doesn't have to scan object - flagNoZero = 1 << 1 // don't zero memory + flagNoScan = _FlagNoScan + flagNoZero = _FlagNoZero - maxTinySize = 16 - tinySizeClass = 2 - maxSmallSize = 32 << 10 + maxTinySize = _TinySize + tinySizeClass = _TinySizeClass + maxSmallSize = _MaxSmallSize - pageShift = 13 - pageSize = 1 << pageShift - pageMask = pageSize - 1 + pageShift = _PageShift + pageSize = _PageSize + pageMask = _PageMask - bitsPerPointer = 2 - bitsMask = 1<>pageShift) type pageID uintptr -// All zero-sized allocations return a pointer to this byte. -var zeroObject byte - -// Maximum possible heap size. -var maxMem uintptr +// base address for all 0-byte allocations +var zerobase uintptr // Allocate an object of size bytes. // Small objects are allocated from the per-P cache's free lists. // Large objects (> 32 kB) are allocated straight from the heap. func mallocgc(size uintptr, typ *_type, flags int) unsafe.Pointer { if size == 0 { - return unsafe.Pointer(&zeroObject) + return unsafe.Pointer(&zerobase) } size0 := size @@ -357,7 +349,7 @@ func newarray(typ *_type, n uintptr) unsafe.Pointer { if typ.kind&kindNoPointers != 0 { flags |= flagNoScan } - if int(n) < 0 || (typ.size > 0 && n > maxMem/uintptr(typ.size)) { + if int(n) < 0 || (typ.size > 0 && n > maxmem/uintptr(typ.size)) { panic("runtime: allocation size out of range") } return mallocgc(uintptr(typ.size)*n, typ, flags) diff --git a/src/runtime/mgc0.c b/src/runtime/mgc0.c index 30a8ea2c9c..eac6e704be 100644 --- a/src/runtime/mgc0.c +++ b/src/runtime/mgc0.c @@ -123,7 +123,7 @@ static FinBlock *allfin; // list of all blocks BitVector runtime·gcdatamask; BitVector runtime·gcbssmask; -extern Mutex runtime·gclock; +Mutex runtime·gclock; static Workbuf* getempty(Workbuf*); static Workbuf* getfull(Workbuf*); diff --git a/src/runtime/mgc0.go b/src/runtime/mgc0.go index 130e8262ad..bd5ebab46e 100644 --- a/src/runtime/mgc0.go +++ b/src/runtime/mgc0.go @@ -69,18 +69,6 @@ func clearpools() { } } -// State of background sweep. -// Protected by gclock. -// Must match mgc0.c. -var sweep struct { - g *g - parked bool - spanidx uint32 // background sweeper position - nbgsweep uint32 - npausesweep uint32 -} - -var gclock mutex // also in mgc0.c func gosweepone() uintptr func gosweepdone() bool diff --git a/src/runtime/mgc0.h b/src/runtime/mgc0.h index 0daf7511b6..10f24d009f 100644 --- a/src/runtime/mgc0.h +++ b/src/runtime/mgc0.h @@ -68,9 +68,9 @@ enum { // there. On a 64-bit system the off'th word in the arena is tracked by // the off/16+1'th word before mheap.arena_start. (On a 32-bit system, // the only difference is that the divisor is 8.) - -#define bitBoundary ((uintptr)1) // boundary of an object -#define bitMarked ((uintptr)2) // marked object - -#define bitMask ((uintptr)bitBoundary|bitMarked) -#define bitPtrMask ((uintptr)BitsMask<<2) +enum { + bitBoundary = 1, // boundary of an object + bitMarked = 2, // marked object + bitMask = bitBoundary | bitMarked, + bitPtrMask = BitsMask<<2, +}; diff --git a/src/runtime/os_darwin.go b/src/runtime/os_darwin.go index e0f63ddb90..4327ced914 100644 --- a/src/runtime/os_darwin.go +++ b/src/runtime/os_darwin.go @@ -22,5 +22,3 @@ func mach_semaphore_wait(sema uint32) int32 func mach_semaphore_timedwait(sema, sec, nsec uint32) int32 func mach_semaphore_signal(sema uint32) int32 func mach_semaphore_signal_all(sema uint32) int32 - -const stackSystem = 0 diff --git a/src/runtime/os_freebsd.go b/src/runtime/os_freebsd.go index 96964f1e1e..59708049c8 100644 --- a/src/runtime/os_freebsd.go +++ b/src/runtime/os_freebsd.go @@ -15,5 +15,3 @@ func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, nds func getrlimit(kind int32, limit unsafe.Pointer) int32 func raise(sig int32) func sys_umtx_op(addr unsafe.Pointer, mode int32, val uint32, ptr2, ts unsafe.Pointer) int32 - -const stackSystem = 0 diff --git a/src/runtime/os_linux.go b/src/runtime/os_linux.go index a6799cd414..41123ad570 100644 --- a/src/runtime/os_linux.go +++ b/src/runtime/os_linux.go @@ -15,5 +15,3 @@ func rtsigprocmask(sig int32, new, old unsafe.Pointer, size int32) func getrlimit(kind int32, limit unsafe.Pointer) int32 func raise(sig int32) func sched_getaffinity(pid, len uintptr, buf *uintptr) int32 - -const stackSystem = 0 diff --git a/src/runtime/os_nacl.go b/src/runtime/os_nacl.go index a6c409c091..8dd43ff06f 100644 --- a/src/runtime/os_nacl.go +++ b/src/runtime/os_nacl.go @@ -23,8 +23,6 @@ func nacl_cond_timed_wait_abs(cond, lock int32, ts unsafe.Pointer) int32 func nacl_thread_create(fn, stk, tls, xx unsafe.Pointer) int32 func nacl_nanosleep(ts, extra unsafe.Pointer) int32 -const stackSystem = 0 - func os_sigpipe() { gothrow("too many writes on closed pipe") } diff --git a/src/runtime/os_netbsd.go b/src/runtime/os_netbsd.go index 8792f497e4..f000c5e9f6 100644 --- a/src/runtime/os_netbsd.go +++ b/src/runtime/os_netbsd.go @@ -18,5 +18,3 @@ func lwp_create(ctxt unsafe.Pointer, flags uintptr, lwpid unsafe.Pointer) int32 func lwp_park(abstime unsafe.Pointer, unpark int32, hint, unparkhint unsafe.Pointer) int32 func lwp_unpark(lwp int32, hint unsafe.Pointer) int32 func lwp_self() int32 - -const stackSystem = 0 diff --git a/src/runtime/os_openbsd.go b/src/runtime/os_openbsd.go index 19e2b45a15..a000f963e3 100644 --- a/src/runtime/os_openbsd.go +++ b/src/runtime/os_openbsd.go @@ -15,5 +15,3 @@ func raise(sig int32) func tfork(param unsafe.Pointer, psize uintptr, mm, gg, fn unsafe.Pointer) int32 func thrsleep(ident unsafe.Pointer, clock_id int32, tsp, lock, abort unsafe.Pointer) int32 func thrwakeup(ident unsafe.Pointer, n int32) int32 - -const stackSystem = 0 diff --git a/src/runtime/os_plan9.go b/src/runtime/os_plan9.go index c7b5bf7050..20e47bf42e 100644 --- a/src/runtime/os_plan9.go +++ b/src/runtime/os_plan9.go @@ -24,10 +24,6 @@ func setfpmasks() func tstart_plan9(newm *m) func errstr() string -// The size of the note handler frame varies among architectures, -// but 512 bytes should be enough for every implementation. -const stackSystem = 512 - type _Plink uintptr func os_sigpipe() { diff --git a/src/runtime/os_solaris.go b/src/runtime/os_solaris.go index 3cffff3e29..ca13151204 100644 --- a/src/runtime/os_solaris.go +++ b/src/runtime/os_solaris.go @@ -98,5 +98,3 @@ func sysvicall6(fn *libcFunc, a1, a2, a3, a4, a5, a6 uintptr) uintptr { asmcgocall(unsafe.Pointer(&asmsysvicall6), unsafe.Pointer(libcall)) return libcall.r1 } - -const stackSystem = 0 diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go index da4c736add..1528d2fd13 100644 --- a/src/runtime/os_windows.go +++ b/src/runtime/os_windows.go @@ -26,8 +26,6 @@ func netpollopen(fd uintptr, pd *pollDesc) int32 func netpollclose(fd uintptr) int32 func netpollarm(pd *pollDesc, mode int) -const stackSystem = 512 * ptrSize - func os_sigpipe() { gothrow("too many writes on closed pipe") } diff --git a/src/runtime/runtime.h b/src/runtime/runtime.h index abd53c4ba1..4aa9a963f5 100644 --- a/src/runtime/runtime.h +++ b/src/runtime/runtime.h @@ -697,7 +697,6 @@ enum * external data */ extern String runtime·emptystring; -extern uintptr runtime·zerobase; extern G** runtime·allg; extern Slice runtime·allgs; // []*G extern uintptr runtime·allglen; diff --git a/src/runtime/sema.go b/src/runtime/sema.go index 87ba5463b6..beacd67162 100644 --- a/src/runtime/sema.go +++ b/src/runtime/sema.go @@ -35,7 +35,7 @@ const semTabSize = 251 var semtable [semTabSize]struct { root semaRoot - pad [cacheLineSize - unsafe.Sizeof(semaRoot{})]byte + pad [_CacheLineSize - unsafe.Sizeof(semaRoot{})]byte } // Called from sync/net packages. diff --git a/src/runtime/slice.go b/src/runtime/slice.go index 3b88927c64..171087d7f6 100644 --- a/src/runtime/slice.go +++ b/src/runtime/slice.go @@ -22,11 +22,11 @@ func makeslice(t *slicetype, len64 int64, cap64 int64) sliceStruct { // but since the cap is only being supplied implicitly, saying len is clearer. // See issue 4085. len := int(len64) - if len64 < 0 || int64(len) != len64 || t.elem.size > 0 && uintptr(len) > maxMem/uintptr(t.elem.size) { + if len64 < 0 || int64(len) != len64 || t.elem.size > 0 && uintptr(len) > maxmem/uintptr(t.elem.size) { panic(errorString("makeslice: len out of range")) } cap := int(cap64) - if cap < len || int64(cap) != cap64 || t.elem.size > 0 && uintptr(cap) > maxMem/uintptr(t.elem.size) { + if cap < len || int64(cap) != cap64 || t.elem.size > 0 && uintptr(cap) > maxmem/uintptr(t.elem.size) { panic(errorString("makeslice: cap out of range")) } p := newarray(t.elem, uintptr(cap)) @@ -42,7 +42,7 @@ func growslice(t *slicetype, old sliceStruct, n int64) sliceStruct { cap64 := int64(old.cap) + n cap := int(cap64) - if int64(cap) != cap64 || cap < old.cap || t.elem.size > 0 && uintptr(cap) > maxMem/uintptr(t.elem.size) { + if int64(cap) != cap64 || cap < old.cap || t.elem.size > 0 && uintptr(cap) > maxmem/uintptr(t.elem.size) { panic(errorString("growslice: cap out of range")) } @@ -72,7 +72,7 @@ func growslice(t *slicetype, old sliceStruct, n int64) sliceStruct { } } - if uintptr(newcap) >= maxMem/uintptr(et.size) { + if uintptr(newcap) >= maxmem/uintptr(et.size) { panic(errorString("growslice: cap out of range")) } lenmem := uintptr(old.len) * uintptr(et.size) diff --git a/src/runtime/string.go b/src/runtime/string.go index c84f673427..0809f89bc1 100644 --- a/src/runtime/string.go +++ b/src/runtime/string.go @@ -225,7 +225,7 @@ func rawbyteslice(size int) (b []byte) { // rawruneslice allocates a new rune slice. The rune slice is not zeroed. func rawruneslice(size int) (b []rune) { - if uintptr(size) > maxMem/4 { + if uintptr(size) > maxmem/4 { gothrow("out of memory") } mem := goroundupsize(uintptr(size) * 4) diff --git a/src/runtime/typekind.go b/src/runtime/typekind.go index 5985536289..b64ec44f9e 100644 --- a/src/runtime/typekind.go +++ b/src/runtime/typekind.go @@ -5,37 +5,37 @@ package runtime const ( - kindBool = 1 + iota - kindInt - kindInt8 - kindInt16 - kindInt32 - kindInt64 - kindUint - kindUint8 - kindUint16 - kindUint32 - kindUint64 - kindUintptr - kindFloat32 - kindFloat64 - kindComplex64 - kindComplex128 - kindArray - kindChan - kindFunc - kindInterface - kindMap - kindPtr - kindSlice - kindString - kindStruct - kindUnsafePointer + kindBool = _KindBool + kindInt = _KindInt + kindInt8 = _KindInt8 + kindInt16 = _KindInt16 + kindInt32 = _KindInt32 + kindInt64 = _KindInt64 + kindUint = _KindUint + kindUint8 = _KindUint8 + kindUint16 = _KindUint16 + kindUint32 = _KindUint32 + kindUint64 = _KindUint64 + kindUintptr = _KindUintptr + kindFloat32 = _KindFloat32 + kindFloat64 = _KindFloat64 + kindComplex64 = _KindComplex64 + kindComplex128 = _KindComplex128 + kindArray = _KindArray + kindChan = _KindChan + kindFunc = _KindFunc + kindInterface = _KindInterface + kindMap = _KindMap + kindPtr = _KindPtr + kindSlice = _KindSlice + kindString = _KindString + kindStruct = _KindStruct + kindUnsafePointer = _KindUnsafePointer - kindDirectIface = 1 << 5 - kindGCProg = 1 << 6 // Type.gc points to GC program - kindNoPointers = 1 << 7 - kindMask = (1 << 5) - 1 + kindDirectIface = _KindDirectIface + kindGCProg = _KindGCProg + kindNoPointers = _KindNoPointers + kindMask = _KindMask ) // isDirectIface reports whether t is stored directly in an interface value. diff --git a/src/runtime/typekind.h b/src/runtime/typekind.h index 7c611e8ba6..e0fe177bb7 100644 --- a/src/runtime/typekind.h +++ b/src/runtime/typekind.h @@ -2,9 +2,6 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// PtrSize vs sizeof(void*): This file is also included from src/cmd/ld/... -// which defines PtrSize to be different from sizeof(void*) when crosscompiling. - enum { KindBool = 1, KindInt, -- 2.48.1