2008-06-30 12:50:36 -06:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
#include "runtime.h"
|
2010-03-30 11:53:16 -06:00
|
|
|
#include "type.h"
|
2008-06-30 12:50:36 -06:00
|
|
|
|
2009-10-12 11:26:38 -06:00
|
|
|
//static Lock debuglock;
|
2008-06-30 12:50:36 -06:00
|
|
|
|
2010-01-27 16:37:08 -07:00
|
|
|
static void vprintf(int8*, byte*);
|
|
|
|
|
2008-06-30 12:50:36 -06:00
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·dump(byte *p, int32 n)
|
2008-06-30 12:50:36 -06:00
|
|
|
{
|
|
|
|
int32 i;
|
|
|
|
|
|
|
|
for(i=0; i<n; i++) {
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printpointer((byte*)(p[i]>>4));
|
|
|
|
runtime·printpointer((byte*)(p[i]&0xf));
|
2008-06-30 12:50:36 -06:00
|
|
|
if((i&15) == 15)
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·prints("\n");
|
2008-06-30 12:50:36 -06:00
|
|
|
else
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·prints(" ");
|
2008-06-30 12:50:36 -06:00
|
|
|
}
|
|
|
|
if(n & 15)
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·prints("\n");
|
2008-06-30 12:50:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·prints(int8 *s)
|
2008-06-30 12:50:36 -06:00
|
|
|
{
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, s, runtime·findnull((byte*)s));
|
2008-06-30 12:50:36 -06:00
|
|
|
}
|
|
|
|
|
2010-01-27 16:37:08 -07:00
|
|
|
#pragma textflag 7
|
2008-11-25 17:48:10 -07:00
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printf(int8 *s, ...)
|
2010-01-27 16:37:08 -07:00
|
|
|
{
|
|
|
|
byte *arg;
|
|
|
|
|
|
|
|
arg = (byte*)(&s+1);
|
|
|
|
vprintf(s, arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Very simple printf. Only for debugging prints.
|
|
|
|
// Do not add to this without checking with Rob.
|
|
|
|
static void
|
2011-03-04 13:42:39 -07:00
|
|
|
vprintf(int8 *s, byte *base)
|
2008-11-25 17:48:10 -07:00
|
|
|
{
|
|
|
|
int8 *p, *lp;
|
2011-03-04 13:42:39 -07:00
|
|
|
uintptr arg, narg;
|
|
|
|
byte *v;
|
2008-11-25 17:48:10 -07:00
|
|
|
|
runtime: parallelize garbage collector mark + sweep
Running test/garbage/parser.out.
On a 4-core Lenovo X201s (Linux):
31.12u 0.60s 31.74r 1 cpu, no atomics
32.27u 0.58s 32.86r 1 cpu, atomic instructions
33.04u 0.83s 27.47r 2 cpu
On a 16-core Xeon (Linux):
33.08u 0.65s 33.80r 1 cpu, no atomics
34.87u 1.12s 29.60r 2 cpu
36.00u 1.87s 28.43r 3 cpu
36.46u 2.34s 27.10r 4 cpu
38.28u 3.85s 26.92r 5 cpu
37.72u 5.25s 26.73r 6 cpu
39.63u 7.11s 26.95r 7 cpu
39.67u 8.10s 26.68r 8 cpu
On a 2-core MacBook Pro Core 2 Duo 2.26 (circa 2009, MacBookPro5,5):
39.43u 1.45s 41.27r 1 cpu, no atomics
43.98u 2.95s 38.69r 2 cpu
On a 2-core Mac Mini Core 2 Duo 1.83 (circa 2008; Macmini2,1):
48.81u 2.12s 51.76r 1 cpu, no atomics
57.15u 4.72s 51.54r 2 cpu
The handoff algorithm is really only good for two cores.
Beyond that we will need to so something more sophisticated,
like have each core hand off to the next one, around a circle.
Even so, the code is a good checkpoint; for now we'll limit the
number of gc procs to at most 2.
R=dvyukov
CC=golang-dev
https://golang.org/cl/4641082
2011-09-30 07:40:01 -06:00
|
|
|
//runtime·lock(&debuglock);
|
2009-10-09 17:45:20 -06:00
|
|
|
|
2008-11-25 17:48:10 -07:00
|
|
|
lp = p = s;
|
2011-03-04 13:42:39 -07:00
|
|
|
arg = 0;
|
2008-11-25 17:48:10 -07:00
|
|
|
for(; *p; p++) {
|
|
|
|
if(*p != '%')
|
|
|
|
continue;
|
|
|
|
if(p > lp)
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, lp, p-lp);
|
2008-11-25 17:48:10 -07:00
|
|
|
p++;
|
2011-03-04 13:42:39 -07:00
|
|
|
narg = 0;
|
2009-03-30 01:01:07 -06:00
|
|
|
switch(*p) {
|
2010-01-27 16:37:08 -07:00
|
|
|
case 't':
|
|
|
|
narg = arg + 1;
|
|
|
|
break;
|
2009-03-30 01:01:07 -06:00
|
|
|
case 'd': // 32-bit
|
|
|
|
case 'x':
|
2011-03-04 13:42:39 -07:00
|
|
|
arg = runtime·rnd(arg, 4);
|
2009-03-30 01:01:07 -06:00
|
|
|
narg = arg + 4;
|
|
|
|
break;
|
|
|
|
case 'D': // 64-bit
|
2010-01-27 16:37:08 -07:00
|
|
|
case 'U':
|
2009-03-30 01:01:07 -06:00
|
|
|
case 'X':
|
2010-01-27 16:37:08 -07:00
|
|
|
case 'f':
|
2011-03-04 13:42:39 -07:00
|
|
|
arg = runtime·rnd(arg, sizeof(uintptr));
|
2009-03-30 01:01:07 -06:00
|
|
|
narg = arg + 8;
|
|
|
|
break;
|
2010-03-05 21:16:04 -07:00
|
|
|
case 'C':
|
2011-03-04 13:42:39 -07:00
|
|
|
arg = runtime·rnd(arg, sizeof(uintptr));
|
2010-03-05 21:16:04 -07:00
|
|
|
narg = arg + 16;
|
|
|
|
break;
|
2009-03-30 01:01:07 -06:00
|
|
|
case 'p': // pointer-sized
|
|
|
|
case 's':
|
2011-03-04 13:42:39 -07:00
|
|
|
arg = runtime·rnd(arg, sizeof(uintptr));
|
2009-03-30 01:01:07 -06:00
|
|
|
narg = arg + sizeof(uintptr);
|
|
|
|
break;
|
2009-04-15 19:52:28 -06:00
|
|
|
case 'S': // pointer-aligned but bigger
|
2011-03-04 13:42:39 -07:00
|
|
|
arg = runtime·rnd(arg, sizeof(uintptr));
|
2009-04-15 19:52:28 -06:00
|
|
|
narg = arg + sizeof(String);
|
|
|
|
break;
|
2010-01-27 16:37:08 -07:00
|
|
|
case 'a': // pointer-aligned but bigger
|
2011-03-04 13:42:39 -07:00
|
|
|
arg = runtime·rnd(arg, sizeof(uintptr));
|
2010-01-27 16:37:08 -07:00
|
|
|
narg = arg + sizeof(Slice);
|
|
|
|
break;
|
|
|
|
case 'i': // pointer-aligned but bigger
|
|
|
|
case 'e':
|
2011-03-04 13:42:39 -07:00
|
|
|
arg = runtime·rnd(arg, sizeof(uintptr));
|
2010-01-27 16:37:08 -07:00
|
|
|
narg = arg + sizeof(Eface);
|
|
|
|
break;
|
2009-03-30 01:01:07 -06:00
|
|
|
}
|
2011-03-04 13:42:39 -07:00
|
|
|
v = base+arg;
|
2008-11-25 17:48:10 -07:00
|
|
|
switch(*p) {
|
2010-01-27 16:37:08 -07:00
|
|
|
case 'a':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printslice(*(Slice*)v);
|
2010-01-27 16:37:08 -07:00
|
|
|
break;
|
2008-11-25 17:48:10 -07:00
|
|
|
case 'd':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printint(*(int32*)v);
|
2008-11-25 17:48:10 -07:00
|
|
|
break;
|
|
|
|
case 'D':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printint(*(int64*)v);
|
2008-11-25 17:48:10 -07:00
|
|
|
break;
|
2010-01-27 16:37:08 -07:00
|
|
|
case 'e':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printeface(*(Eface*)v);
|
2008-11-25 17:48:10 -07:00
|
|
|
break;
|
2010-01-27 16:37:08 -07:00
|
|
|
case 'f':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printfloat(*(float64*)v);
|
2010-01-27 16:37:08 -07:00
|
|
|
break;
|
2010-02-19 21:42:50 -07:00
|
|
|
case 'C':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printcomplex(*(Complex128*)v);
|
2010-02-19 21:42:50 -07:00
|
|
|
break;
|
2010-01-27 16:37:08 -07:00
|
|
|
case 'i':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printiface(*(Iface*)v);
|
2008-11-25 17:48:10 -07:00
|
|
|
break;
|
|
|
|
case 'p':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printpointer(*(void**)v);
|
2008-11-25 17:48:10 -07:00
|
|
|
break;
|
|
|
|
case 's':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·prints(*(int8**)v);
|
2008-11-25 17:48:10 -07:00
|
|
|
break;
|
|
|
|
case 'S':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printstring(*(String*)v);
|
2008-11-25 17:48:10 -07:00
|
|
|
break;
|
2010-01-27 16:37:08 -07:00
|
|
|
case 't':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printbool(*(bool*)v);
|
2010-01-27 16:37:08 -07:00
|
|
|
break;
|
|
|
|
case 'U':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printuint(*(uint64*)v);
|
2010-01-27 16:37:08 -07:00
|
|
|
break;
|
|
|
|
case 'x':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printhex(*(uint32*)v);
|
2010-01-27 16:37:08 -07:00
|
|
|
break;
|
|
|
|
case 'X':
|
2011-03-04 13:42:39 -07:00
|
|
|
runtime·printhex(*(uint64*)v);
|
2010-01-27 16:37:08 -07:00
|
|
|
break;
|
2008-11-25 17:48:10 -07:00
|
|
|
}
|
2009-03-30 01:01:07 -06:00
|
|
|
arg = narg;
|
2008-11-25 17:48:10 -07:00
|
|
|
lp = p+1;
|
|
|
|
}
|
|
|
|
if(p > lp)
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, lp, p-lp);
|
2009-10-09 17:45:20 -06:00
|
|
|
|
runtime: parallelize garbage collector mark + sweep
Running test/garbage/parser.out.
On a 4-core Lenovo X201s (Linux):
31.12u 0.60s 31.74r 1 cpu, no atomics
32.27u 0.58s 32.86r 1 cpu, atomic instructions
33.04u 0.83s 27.47r 2 cpu
On a 16-core Xeon (Linux):
33.08u 0.65s 33.80r 1 cpu, no atomics
34.87u 1.12s 29.60r 2 cpu
36.00u 1.87s 28.43r 3 cpu
36.46u 2.34s 27.10r 4 cpu
38.28u 3.85s 26.92r 5 cpu
37.72u 5.25s 26.73r 6 cpu
39.63u 7.11s 26.95r 7 cpu
39.67u 8.10s 26.68r 8 cpu
On a 2-core MacBook Pro Core 2 Duo 2.26 (circa 2009, MacBookPro5,5):
39.43u 1.45s 41.27r 1 cpu, no atomics
43.98u 2.95s 38.69r 2 cpu
On a 2-core Mac Mini Core 2 Duo 1.83 (circa 2008; Macmini2,1):
48.81u 2.12s 51.76r 1 cpu, no atomics
57.15u 4.72s 51.54r 2 cpu
The handoff algorithm is really only good for two cores.
Beyond that we will need to so something more sophisticated,
like have each core hand off to the next one, around a circle.
Even so, the code is a good checkpoint; for now we'll limit the
number of gc procs to at most 2.
R=dvyukov
CC=golang-dev
https://golang.org/cl/4641082
2011-09-30 07:40:01 -06:00
|
|
|
//runtime·unlock(&debuglock);
|
2008-11-25 17:48:10 -07:00
|
|
|
}
|
|
|
|
|
2010-03-04 16:34:25 -07:00
|
|
|
#pragma textflag 7
|
2010-01-27 16:37:08 -07:00
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·goprintf(String s, ...)
|
2010-01-27 16:37:08 -07:00
|
|
|
{
|
|
|
|
// Can assume s has terminating NUL because only
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
// the Go compiler generates calls to runtime·goprintf, using
|
2010-01-27 16:37:08 -07:00
|
|
|
// string constants, and all the string constants have NULs.
|
|
|
|
vprintf((int8*)s.str, (byte*)(&s+1));
|
|
|
|
}
|
2008-11-25 17:48:10 -07:00
|
|
|
|
2008-06-30 12:50:36 -06:00
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printpc(void *p)
|
2008-06-30 12:50:36 -06:00
|
|
|
{
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·prints("PC=");
|
|
|
|
runtime·printhex((uint64)runtime·getcallerpc(p));
|
2008-06-30 12:50:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printbool(bool v)
|
2008-06-30 12:50:36 -06:00
|
|
|
{
|
|
|
|
if(v) {
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, (byte*)"true", 4);
|
2008-06-30 12:50:36 -06:00
|
|
|
return;
|
|
|
|
}
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, (byte*)"false", 5);
|
2008-06-30 12:50:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printfloat(float64 v)
|
2008-06-30 12:50:36 -06:00
|
|
|
{
|
2008-07-04 19:01:35 -06:00
|
|
|
byte buf[20];
|
|
|
|
int32 e, s, i, n;
|
|
|
|
float64 h;
|
|
|
|
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
if(runtime·isNaN(v)) {
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, "NaN", 3);
|
2008-11-10 15:54:10 -07:00
|
|
|
return;
|
|
|
|
}
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
if(runtime·isInf(v, 1)) {
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, "+Inf", 4);
|
2008-11-10 15:54:10 -07:00
|
|
|
return;
|
|
|
|
}
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
if(runtime·isInf(v, -1)) {
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, "-Inf", 4);
|
2008-11-10 15:54:10 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-09-27 14:33:50 -06:00
|
|
|
n = 7; // digits printed
|
2008-07-04 19:01:35 -06:00
|
|
|
e = 0; // exp
|
|
|
|
s = 0; // sign
|
|
|
|
if(v != 0) {
|
|
|
|
// sign
|
|
|
|
if(v < 0) {
|
|
|
|
v = -v;
|
|
|
|
s = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// normalize
|
|
|
|
while(v >= 10) {
|
|
|
|
e++;
|
|
|
|
v /= 10;
|
|
|
|
}
|
|
|
|
while(v < 1) {
|
|
|
|
e--;
|
|
|
|
v *= 10;
|
|
|
|
}
|
|
|
|
|
|
|
|
// round
|
|
|
|
h = 5;
|
|
|
|
for(i=0; i<n; i++)
|
|
|
|
h /= 10;
|
2010-11-03 18:31:07 -06:00
|
|
|
|
2008-07-04 19:01:35 -06:00
|
|
|
v += h;
|
|
|
|
if(v >= 10) {
|
|
|
|
e++;
|
|
|
|
v /= 10;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// format +d.dddd+edd
|
|
|
|
buf[0] = '+';
|
|
|
|
if(s)
|
|
|
|
buf[0] = '-';
|
|
|
|
for(i=0; i<n; i++) {
|
|
|
|
s = v;
|
|
|
|
buf[i+2] = s+'0';
|
|
|
|
v -= s;
|
|
|
|
v *= 10.;
|
|
|
|
}
|
|
|
|
buf[1] = buf[2];
|
|
|
|
buf[2] = '.';
|
|
|
|
|
2008-09-14 17:57:55 -06:00
|
|
|
buf[n+2] = 'e';
|
|
|
|
buf[n+3] = '+';
|
2008-07-04 19:01:35 -06:00
|
|
|
if(e < 0) {
|
|
|
|
e = -e;
|
2008-09-14 17:57:55 -06:00
|
|
|
buf[n+3] = '-';
|
2008-07-04 19:01:35 -06:00
|
|
|
}
|
2008-09-14 17:57:55 -06:00
|
|
|
|
2008-11-10 15:54:10 -07:00
|
|
|
buf[n+4] = (e/100) + '0';
|
|
|
|
buf[n+5] = (e/10)%10 + '0';
|
|
|
|
buf[n+6] = (e%10) + '0';
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, buf, n+7);
|
2008-06-30 12:50:36 -06:00
|
|
|
}
|
|
|
|
|
2010-02-19 21:42:50 -07:00
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printcomplex(Complex128 v)
|
2010-02-19 21:42:50 -07:00
|
|
|
{
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, "(", 1);
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printfloat(v.real);
|
|
|
|
runtime·printfloat(v.imag);
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, "i)", 2);
|
2010-02-19 21:42:50 -07:00
|
|
|
}
|
|
|
|
|
2008-06-30 12:50:36 -06:00
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printuint(uint64 v)
|
2008-06-30 12:50:36 -06:00
|
|
|
{
|
|
|
|
byte buf[100];
|
2008-11-10 15:54:10 -07:00
|
|
|
int32 i;
|
2008-06-30 12:50:36 -06:00
|
|
|
|
|
|
|
for(i=nelem(buf)-1; i>0; i--) {
|
|
|
|
buf[i] = v%10 + '0';
|
|
|
|
if(v < 10)
|
|
|
|
break;
|
|
|
|
v = v/10;
|
|
|
|
}
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, buf+i, nelem(buf)-i);
|
2008-06-30 12:50:36 -06:00
|
|
|
}
|
|
|
|
|
2008-11-10 15:54:10 -07:00
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printint(int64 v)
|
2008-11-10 15:54:10 -07:00
|
|
|
{
|
|
|
|
if(v < 0) {
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, "-", 1);
|
2008-11-10 15:54:10 -07:00
|
|
|
v = -v;
|
|
|
|
}
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printuint(v);
|
2008-11-10 15:54:10 -07:00
|
|
|
}
|
|
|
|
|
2008-06-30 12:50:36 -06:00
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printhex(uint64 v)
|
2008-06-30 12:50:36 -06:00
|
|
|
{
|
2008-11-25 17:48:10 -07:00
|
|
|
static int8 *dig = "0123456789abcdef";
|
2008-06-30 12:50:36 -06:00
|
|
|
byte buf[100];
|
|
|
|
int32 i;
|
|
|
|
|
2008-11-25 17:48:10 -07:00
|
|
|
i=nelem(buf);
|
|
|
|
for(; v>0; v/=16)
|
|
|
|
buf[--i] = dig[v%16];
|
|
|
|
if(i == nelem(buf))
|
|
|
|
buf[--i] = '0';
|
|
|
|
buf[--i] = 'x';
|
|
|
|
buf[--i] = '0';
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, buf+i, nelem(buf)-i);
|
2008-06-30 12:50:36 -06:00
|
|
|
}
|
|
|
|
|
2008-11-25 17:48:10 -07:00
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printpointer(void *p)
|
2008-11-25 17:48:10 -07:00
|
|
|
{
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printhex((uint64)p);
|
2008-11-25 17:48:10 -07:00
|
|
|
}
|
|
|
|
|
2008-06-30 12:50:36 -06:00
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printstring(String v)
|
2008-06-30 12:50:36 -06:00
|
|
|
{
|
2011-07-11 23:21:06 -06:00
|
|
|
extern uint32 runtime·maxstring;
|
2009-01-29 18:38:58 -07:00
|
|
|
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
if(v.len > runtime·maxstring) {
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, "[invalid string]", 16);
|
2009-04-09 19:16:21 -06:00
|
|
|
return;
|
2009-01-29 18:38:58 -07:00
|
|
|
}
|
2009-04-09 19:16:21 -06:00
|
|
|
if(v.len > 0)
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, v.str, v.len);
|
2008-06-30 12:50:36 -06:00
|
|
|
}
|
2008-10-02 15:38:07 -06:00
|
|
|
|
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printsp(void)
|
2008-10-02 15:38:07 -06:00
|
|
|
{
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, " ", 1);
|
2008-10-02 15:38:07 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·printnl(void)
|
2008-10-02 15:38:07 -06:00
|
|
|
{
|
2010-12-14 09:52:42 -07:00
|
|
|
runtime·write(2, "\n", 1);
|
2008-10-02 15:38:07 -06:00
|
|
|
}
|
2010-10-22 15:04:32 -06:00
|
|
|
|
|
|
|
void
|
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost
Prefix all external symbols in runtime by runtime·,
to avoid conflicts with possible symbols of the same
name in linked-in C libraries. The obvious conflicts
are printf, malloc, and free, but hide everything to
avoid future pain.
The symbols left alone are:
** known to cgo **
_cgo_free
_cgo_malloc
libcgo_thread_start
initcgo
ncgocall
** known to linker **
_rt0_$GOARCH
_rt0_$GOARCH_$GOOS
text
etext
data
end
pclntab
epclntab
symtab
esymtab
** known to C compiler **
_divv
_modv
_div64by32
etc (arch specific)
Tested on darwin/386, darwin/amd64, linux/386, linux/amd64.
Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386.
R=r, PeterGo
CC=golang-dev
https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
|
|
|
runtime·typestring(Eface e, String s)
|
2010-10-22 15:04:32 -06:00
|
|
|
{
|
|
|
|
s = *e.type->string;
|
|
|
|
FLUSH(&s);
|
|
|
|
}
|
runtime: parallelize garbage collector mark + sweep
Running test/garbage/parser.out.
On a 4-core Lenovo X201s (Linux):
31.12u 0.60s 31.74r 1 cpu, no atomics
32.27u 0.58s 32.86r 1 cpu, atomic instructions
33.04u 0.83s 27.47r 2 cpu
On a 16-core Xeon (Linux):
33.08u 0.65s 33.80r 1 cpu, no atomics
34.87u 1.12s 29.60r 2 cpu
36.00u 1.87s 28.43r 3 cpu
36.46u 2.34s 27.10r 4 cpu
38.28u 3.85s 26.92r 5 cpu
37.72u 5.25s 26.73r 6 cpu
39.63u 7.11s 26.95r 7 cpu
39.67u 8.10s 26.68r 8 cpu
On a 2-core MacBook Pro Core 2 Duo 2.26 (circa 2009, MacBookPro5,5):
39.43u 1.45s 41.27r 1 cpu, no atomics
43.98u 2.95s 38.69r 2 cpu
On a 2-core Mac Mini Core 2 Duo 1.83 (circa 2008; Macmini2,1):
48.81u 2.12s 51.76r 1 cpu, no atomics
57.15u 4.72s 51.54r 2 cpu
The handoff algorithm is really only good for two cores.
Beyond that we will need to so something more sophisticated,
like have each core hand off to the next one, around a circle.
Even so, the code is a good checkpoint; for now we'll limit the
number of gc procs to at most 2.
R=dvyukov
CC=golang-dev
https://golang.org/cl/4641082
2011-09-30 07:40:01 -06:00
|
|
|
|