2010-01-06 18:58:55 -07: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"
|
2011-02-01 09:49:24 -07:00
|
|
|
#include "type.h"
|
2011-01-19 13:10:15 -07:00
|
|
|
#include "defs.h"
|
2010-01-06 18:58:55 -07:00
|
|
|
#include "os.h"
|
|
|
|
|
2010-12-07 13:28:33 -07:00
|
|
|
#pragma dynimport runtime·CloseHandle CloseHandle "kernel32.dll"
|
2011-02-01 09:49:24 -07:00
|
|
|
#pragma dynimport runtime·CreateEvent CreateEventA "kernel32.dll"
|
|
|
|
#pragma dynimport runtime·CreateThread CreateThread "kernel32.dll"
|
2010-12-07 13:28:33 -07:00
|
|
|
#pragma dynimport runtime·ExitProcess ExitProcess "kernel32.dll"
|
2011-02-01 09:49:24 -07:00
|
|
|
#pragma dynimport runtime·FreeEnvironmentStringsW FreeEnvironmentStringsW "kernel32.dll"
|
|
|
|
#pragma dynimport runtime·GetEnvironmentStringsW GetEnvironmentStringsW "kernel32.dll"
|
|
|
|
#pragma dynimport runtime·GetProcAddress GetProcAddress "kernel32.dll"
|
2010-12-07 13:28:33 -07:00
|
|
|
#pragma dynimport runtime·GetStdHandle GetStdHandle "kernel32.dll"
|
2011-02-01 09:49:24 -07:00
|
|
|
#pragma dynimport runtime·LoadLibraryEx LoadLibraryExA "kernel32.dll"
|
|
|
|
#pragma dynimport runtime·QueryPerformanceCounter QueryPerformanceCounter "kernel32.dll"
|
|
|
|
#pragma dynimport runtime·QueryPerformanceFrequency QueryPerformanceFrequency "kernel32.dll"
|
2011-02-14 10:15:13 -07:00
|
|
|
#pragma dynimport runtime·SetConsoleCtrlHandler SetConsoleCtrlHandler "kernel32.dll"
|
2010-12-07 13:28:33 -07:00
|
|
|
#pragma dynimport runtime·SetEvent SetEvent "kernel32.dll"
|
2011-02-01 09:49:24 -07:00
|
|
|
#pragma dynimport runtime·WaitForSingleObject WaitForSingleObject "kernel32.dll"
|
2010-12-07 13:28:33 -07:00
|
|
|
#pragma dynimport runtime·WriteFile WriteFile "kernel32.dll"
|
2010-01-06 18:58:55 -07:00
|
|
|
|
2010-12-12 22:41:02 -07:00
|
|
|
extern void *runtime·CloseHandle;
|
2011-02-01 09:49:24 -07:00
|
|
|
extern void *runtime·CreateEvent;
|
|
|
|
extern void *runtime·CreateThread;
|
2010-12-12 22:41:02 -07:00
|
|
|
extern void *runtime·ExitProcess;
|
2011-02-01 09:49:24 -07:00
|
|
|
extern void *runtime·FreeEnvironmentStringsW;
|
|
|
|
extern void *runtime·GetEnvironmentStringsW;
|
|
|
|
extern void *runtime·GetProcAddress;
|
2010-12-12 22:41:02 -07:00
|
|
|
extern void *runtime·GetStdHandle;
|
2011-02-01 09:49:24 -07:00
|
|
|
extern void *runtime·LoadLibraryEx;
|
|
|
|
extern void *runtime·QueryPerformanceCounter;
|
|
|
|
extern void *runtime·QueryPerformanceFrequency;
|
2011-02-14 10:15:13 -07:00
|
|
|
extern void *runtime·SetConsoleCtrlHandler;
|
2010-12-12 22:41:02 -07:00
|
|
|
extern void *runtime·SetEvent;
|
2011-02-01 09:49:24 -07:00
|
|
|
extern void *runtime·WaitForSingleObject;
|
2010-12-12 22:41:02 -07:00
|
|
|
extern void *runtime·WriteFile;
|
2010-01-06 18:58:55 -07:00
|
|
|
|
2011-02-01 09:49:24 -07:00
|
|
|
static int64 timerfreq;
|
2010-01-06 18:58:55 -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·osinit(void)
|
2010-01-06 18:58:55 -07:00
|
|
|
{
|
2011-02-01 09:49:24 -07:00
|
|
|
runtime·stdcall(runtime·QueryPerformanceFrequency, 1, &timerfreq);
|
2011-06-27 20:46:16 -06:00
|
|
|
runtime·stdcall(runtime·SetConsoleCtrlHandler, 2, runtime·ctrlhandler, (uintptr)1);
|
2010-01-06 18:58:55 -07:00
|
|
|
}
|
|
|
|
|
2011-01-11 17:48:15 -07:00
|
|
|
void
|
|
|
|
runtime·goenvs(void)
|
|
|
|
{
|
|
|
|
extern Slice os·Envs;
|
|
|
|
|
|
|
|
uint16 *env;
|
|
|
|
String *s;
|
|
|
|
int32 i, n;
|
|
|
|
uint16 *p;
|
|
|
|
|
|
|
|
env = runtime·stdcall(runtime·GetEnvironmentStringsW, 0);
|
|
|
|
|
|
|
|
n = 0;
|
|
|
|
for(p=env; *p; n++)
|
|
|
|
p += runtime·findnullw(p)+1;
|
|
|
|
|
|
|
|
s = runtime·malloc(n*sizeof s[0]);
|
|
|
|
|
|
|
|
p = env;
|
|
|
|
for(i=0; i<n; i++) {
|
|
|
|
s[i] = runtime·gostringw(p);
|
|
|
|
p += runtime·findnullw(p)+1;
|
|
|
|
}
|
|
|
|
os·Envs.array = (byte*)s;
|
|
|
|
os·Envs.len = n;
|
|
|
|
os·Envs.cap = n;
|
|
|
|
|
|
|
|
runtime·stdcall(runtime·FreeEnvironmentStringsW, 1, env);
|
|
|
|
}
|
|
|
|
|
2010-01-06 18:58:55 -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·exit(int32 code)
|
2010-01-06 18:58:55 -07:00
|
|
|
{
|
2011-06-27 20:46:16 -06:00
|
|
|
runtime·stdcall(runtime·ExitProcess, 1, (uintptr)code);
|
2010-01-06 18:58:55 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int32
|
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·write(int32 fd, void *buf, int32 n)
|
2010-01-06 18:58:55 -07:00
|
|
|
{
|
|
|
|
void *handle;
|
|
|
|
uint32 written;
|
|
|
|
|
|
|
|
written = 0;
|
|
|
|
switch(fd) {
|
|
|
|
case 1:
|
2011-06-27 20:46:16 -06:00
|
|
|
handle = runtime·stdcall(runtime·GetStdHandle, 1, (uintptr)-11);
|
2010-01-06 18:58:55 -07:00
|
|
|
break;
|
|
|
|
case 2:
|
2011-06-27 20:46:16 -06:00
|
|
|
handle = runtime·stdcall(runtime·GetStdHandle, 1, (uintptr)-12);
|
2010-01-06 18:58:55 -07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
2011-06-27 20:46:16 -06:00
|
|
|
runtime·stdcall(runtime·WriteFile, 5, handle, buf, (uintptr)n, &written, (uintptr)0);
|
2010-01-06 18:58:55 -07:00
|
|
|
return written;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Thread-safe allocation of an event.
|
|
|
|
static void
|
|
|
|
initevent(void **pevent)
|
|
|
|
{
|
|
|
|
void *event;
|
|
|
|
|
2011-06-27 20:46:16 -06:00
|
|
|
event = runtime·stdcall(runtime·CreateEvent, 4, (uintptr)0, (uintptr)0, (uintptr)0, (uintptr)0);
|
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·casp(pevent, 0, event)) {
|
2010-01-06 18:58:55 -07:00
|
|
|
// Someone else filled it in. Use theirs.
|
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·stdcall(runtime·CloseHandle, 1, event);
|
2010-01-06 18:58:55 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
eventlock(Lock *l)
|
|
|
|
{
|
|
|
|
// Allocate event if needed.
|
|
|
|
if(l->event == 0)
|
|
|
|
initevent(&l->event);
|
|
|
|
|
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·xadd(&l->key, 1) > 1) // someone else has it; wait
|
2011-06-27 20:46:16 -06:00
|
|
|
runtime·stdcall(runtime·WaitForSingleObject, 2, l->event, (uintptr)-1);
|
2010-01-06 18:58:55 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
eventunlock(Lock *l)
|
|
|
|
{
|
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·xadd(&l->key, -1) > 0) // someone else is waiting
|
|
|
|
runtime·stdcall(runtime·SetEvent, 1, l->event);
|
2010-01-06 18:58:55 -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·lock(Lock *l)
|
2010-01-06 18:58:55 -07:00
|
|
|
{
|
|
|
|
if(m->locks < 0)
|
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·throw("lock count");
|
2010-01-06 18:58:55 -07:00
|
|
|
m->locks++;
|
|
|
|
eventlock(l);
|
|
|
|
}
|
|
|
|
|
|
|
|
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·unlock(Lock *l)
|
2010-01-06 18:58:55 -07:00
|
|
|
{
|
|
|
|
m->locks--;
|
|
|
|
if(m->locks < 0)
|
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·throw("lock count");
|
2010-01-06 18:58:55 -07:00
|
|
|
eventunlock(l);
|
|
|
|
}
|
|
|
|
|
2010-03-24 19:03:10 -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·destroylock(Lock *l)
|
2010-03-24 19:03:10 -06:00
|
|
|
{
|
2010-06-11 01:53:54 -06:00
|
|
|
if(l->event != 0)
|
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·stdcall(runtime·CloseHandle, 1, l->event);
|
2010-03-24 19:03:10 -06:00
|
|
|
}
|
|
|
|
|
2010-01-06 18:58:55 -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·noteclear(Note *n)
|
2010-01-06 18:58:55 -07:00
|
|
|
{
|
2011-02-14 10:15:13 -07:00
|
|
|
n->lock.key = 0; // memset(n, 0, sizeof *n)
|
2010-01-06 18:58:55 -07:00
|
|
|
eventlock(&n->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
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·notewakeup(Note *n)
|
2010-01-06 18:58:55 -07:00
|
|
|
{
|
|
|
|
eventunlock(&n->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
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·notesleep(Note *n)
|
2010-01-06 18:58:55 -07:00
|
|
|
{
|
|
|
|
eventlock(&n->lock);
|
|
|
|
eventunlock(&n->lock); // Let other sleepers find out too.
|
|
|
|
}
|
|
|
|
|
|
|
|
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·newosproc(M *m, G *g, void *stk, void (*fn)(void))
|
2010-01-06 18:58:55 -07:00
|
|
|
{
|
2011-02-14 15:42:25 -07:00
|
|
|
void *thandle;
|
|
|
|
|
2010-09-11 19:45:16 -06:00
|
|
|
USED(stk);
|
|
|
|
USED(g); // assuming g = m->g0
|
|
|
|
USED(fn); // assuming fn = mstart
|
|
|
|
|
2011-06-27 20:46:16 -06:00
|
|
|
thandle = runtime·stdcall(runtime·CreateThread, 6, (uintptr)0, (uintptr)0, runtime·tstart_stdcall, m, (uintptr)0, (uintptr)0);
|
2011-02-14 15:42:25 -07:00
|
|
|
if(thandle == 0) {
|
|
|
|
runtime·printf("runtime: failed to create new OS thread (have %d already; errno=%d)\n", runtime·mcount(), runtime·getlasterror());
|
|
|
|
runtime·throw("runtime.newosproc");
|
|
|
|
}
|
2010-01-06 18:58:55 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// Called to initialize a new m (including the bootstrap m).
|
|
|
|
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·minit(void)
|
2010-01-06 18:58:55 -07:00
|
|
|
{
|
|
|
|
}
|
2010-06-11 02:38:12 -06:00
|
|
|
|
2011-02-01 09:49:24 -07:00
|
|
|
void
|
|
|
|
runtime·gettime(int64 *sec, int32 *usec)
|
|
|
|
{
|
|
|
|
int64 count;
|
|
|
|
|
|
|
|
runtime·stdcall(runtime·QueryPerformanceCounter, 1, &count);
|
|
|
|
*sec = count / timerfreq;
|
|
|
|
count %= timerfreq;
|
|
|
|
*usec = count*1000000 / timerfreq;
|
|
|
|
}
|
|
|
|
|
2010-06-11 02:38:12 -06:00
|
|
|
// Calling stdcall on os stack.
|
|
|
|
#pragma textflag 7
|
|
|
|
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·stdcall(void *fn, int32 count, ...)
|
2010-06-11 02:38:12 -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
|
|
|
return runtime·stdcall_raw(fn, count, (uintptr*)(&count + 1));
|
2010-06-11 02:38:12 -06:00
|
|
|
}
|
|
|
|
|
2011-02-01 09:49:24 -07:00
|
|
|
uintptr
|
|
|
|
runtime·syscall(void *fn, uintptr nargs, void *args, uintptr *err)
|
2010-06-11 02:38:12 -06:00
|
|
|
{
|
2011-01-21 19:55:53 -07:00
|
|
|
G *oldlock;
|
2011-02-01 09:49:24 -07:00
|
|
|
uintptr ret;
|
2010-09-11 19:45:16 -06:00
|
|
|
|
2011-01-21 19:55:53 -07:00
|
|
|
/*
|
|
|
|
* Lock g to m to ensure we stay on the same stack if we do a callback.
|
|
|
|
*/
|
|
|
|
oldlock = m->lockedg;
|
|
|
|
m->lockedg = g;
|
|
|
|
g->lockedm = m;
|
|
|
|
|
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·entersyscall();
|
2011-02-01 09:49:24 -07:00
|
|
|
runtime·setlasterror(0);
|
|
|
|
ret = (uintptr)runtime·stdcall_raw(fn, nargs, args);
|
|
|
|
if(err)
|
|
|
|
*err = runtime·getlasterror();
|
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·exitsyscall();
|
2011-01-21 19:55:53 -07:00
|
|
|
|
|
|
|
m->lockedg = oldlock;
|
|
|
|
if(oldlock == nil)
|
|
|
|
g->lockedm = nil;
|
2011-02-01 09:49:24 -07:00
|
|
|
|
|
|
|
return ret;
|
2010-06-11 02:38:12 -06:00
|
|
|
}
|
2011-01-19 13:10:15 -07:00
|
|
|
|
|
|
|
uint32
|
|
|
|
runtime·issigpanic(uint32 code)
|
|
|
|
{
|
|
|
|
switch(code) {
|
|
|
|
case EXCEPTION_ACCESS_VIOLATION:
|
|
|
|
case EXCEPTION_INT_DIVIDE_BY_ZERO:
|
|
|
|
case EXCEPTION_INT_OVERFLOW:
|
|
|
|
case EXCEPTION_FLT_DENORMAL_OPERAND:
|
|
|
|
case EXCEPTION_FLT_DIVIDE_BY_ZERO:
|
|
|
|
case EXCEPTION_FLT_INEXACT_RESULT:
|
|
|
|
case EXCEPTION_FLT_OVERFLOW:
|
|
|
|
case EXCEPTION_FLT_UNDERFLOW:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
runtime·sigpanic(void)
|
|
|
|
{
|
|
|
|
switch(g->sig) {
|
|
|
|
case EXCEPTION_ACCESS_VIOLATION:
|
|
|
|
if(g->sigcode1 < 0x1000)
|
|
|
|
runtime·panicstring("invalid memory address or nil pointer dereference");
|
|
|
|
runtime·printf("unexpected fault address %p\n", g->sigcode1);
|
|
|
|
runtime·throw("fault");
|
|
|
|
case EXCEPTION_INT_DIVIDE_BY_ZERO:
|
|
|
|
runtime·panicstring("integer divide by zero");
|
|
|
|
case EXCEPTION_INT_OVERFLOW:
|
|
|
|
runtime·panicstring("integer overflow");
|
|
|
|
case EXCEPTION_FLT_DENORMAL_OPERAND:
|
|
|
|
case EXCEPTION_FLT_DIVIDE_BY_ZERO:
|
|
|
|
case EXCEPTION_FLT_INEXACT_RESULT:
|
|
|
|
case EXCEPTION_FLT_OVERFLOW:
|
|
|
|
case EXCEPTION_FLT_UNDERFLOW:
|
|
|
|
runtime·panicstring("floating point error");
|
|
|
|
}
|
|
|
|
runtime·throw("fault");
|
|
|
|
}
|
2011-01-21 19:55:53 -07:00
|
|
|
|
2011-02-14 10:15:13 -07:00
|
|
|
String
|
|
|
|
runtime·signame(int32 sig)
|
|
|
|
{
|
|
|
|
int8 *s;
|
|
|
|
|
|
|
|
switch(sig) {
|
|
|
|
case SIGINT:
|
|
|
|
s = "SIGINT: interrupt";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return runtime·emptystring;
|
|
|
|
}
|
|
|
|
return runtime·gostringnocopy((byte*)s);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32
|
|
|
|
runtime·ctrlhandler1(uint32 type)
|
|
|
|
{
|
|
|
|
int32 s;
|
|
|
|
|
|
|
|
switch(type) {
|
|
|
|
case CTRL_C_EVENT:
|
|
|
|
case CTRL_BREAK_EVENT:
|
|
|
|
s = SIGINT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(runtime·sigsend(s))
|
|
|
|
return 1;
|
|
|
|
runtime·exit(2); // SIGINT, SIGTERM, etc
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-02 01:08:56 -06:00
|
|
|
// Will keep all callbacks in a linked list, so they don't get garbage collected.
|
|
|
|
typedef struct Callback Callback;
|
|
|
|
struct Callback {
|
|
|
|
Callback* link;
|
|
|
|
void* gobody;
|
|
|
|
byte asmbody;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct Callbacks Callbacks;
|
|
|
|
struct Callbacks {
|
|
|
|
Lock;
|
|
|
|
Callback* link;
|
|
|
|
int32 n;
|
|
|
|
};
|
|
|
|
|
|
|
|
static Callbacks cbs;
|
|
|
|
|
2011-01-21 19:55:53 -07:00
|
|
|
// Call back from windows dll into go.
|
2011-02-01 09:49:24 -07:00
|
|
|
byte *
|
|
|
|
runtime·compilecallback(Eface fn, bool cleanstack)
|
2011-01-21 19:55:53 -07:00
|
|
|
{
|
2011-02-01 09:49:24 -07:00
|
|
|
Func *f;
|
|
|
|
int32 argsize, n;
|
2011-06-02 01:08:56 -06:00
|
|
|
byte *p;
|
|
|
|
Callback *c;
|
2011-02-01 09:49:24 -07:00
|
|
|
|
|
|
|
if(fn.type->kind != KindFunc)
|
|
|
|
runtime·panicstring("not a function");
|
|
|
|
if((f = runtime·findfunc((uintptr)fn.data)) == nil)
|
|
|
|
runtime·throw("cannot find function");
|
|
|
|
argsize = (f->args-2) * 4;
|
|
|
|
|
|
|
|
// compute size of new fn.
|
|
|
|
// must match code laid out below.
|
|
|
|
n = 1+4; // MOVL fn, AX
|
|
|
|
n += 1+4; // MOVL argsize, DX
|
|
|
|
n += 1+4; // MOVL callbackasm, CX
|
|
|
|
n += 2; // CALL CX
|
|
|
|
n += 1; // RET
|
|
|
|
if(cleanstack)
|
|
|
|
n += 2; // ... argsize
|
|
|
|
|
2011-06-02 01:08:56 -06:00
|
|
|
runtime·lock(&cbs);
|
|
|
|
for(c = cbs.link; c != nil; c = c->link) {
|
|
|
|
if(c->gobody == fn.data) {
|
|
|
|
runtime·unlock(&cbs);
|
|
|
|
return &c->asmbody;
|
|
|
|
}
|
|
|
|
}
|
2011-06-08 18:29:25 -06:00
|
|
|
if(cbs.n >= 2000)
|
2011-06-02 01:08:56 -06:00
|
|
|
runtime·throw("too many callback functions");
|
|
|
|
c = runtime·mal(sizeof *c + n);
|
|
|
|
c->gobody = fn.data;
|
|
|
|
c->link = cbs.link;
|
|
|
|
cbs.link = c;
|
|
|
|
cbs.n++;
|
|
|
|
runtime·unlock(&cbs);
|
|
|
|
|
|
|
|
p = &c->asmbody;
|
2011-02-01 09:49:24 -07:00
|
|
|
|
|
|
|
// MOVL fn, AX
|
2011-01-21 19:55:53 -07:00
|
|
|
*p++ = 0xb8;
|
2011-02-01 09:49:24 -07:00
|
|
|
*(uint32*)p = (uint32)fn.data;
|
2011-01-21 19:55:53 -07:00
|
|
|
p += 4;
|
|
|
|
|
2011-02-01 09:49:24 -07:00
|
|
|
// MOVL argsize, DX
|
|
|
|
*p++ = 0xba;
|
|
|
|
*(uint32*)p = argsize;
|
|
|
|
p += 4;
|
2011-01-21 19:55:53 -07:00
|
|
|
|
2011-02-01 09:49:24 -07:00
|
|
|
// MOVL callbackasm, CX
|
|
|
|
*p++ = 0xb9;
|
|
|
|
*(uint32*)p = (uint32)runtime·callbackasm;
|
|
|
|
p += 4;
|
2011-01-21 19:55:53 -07:00
|
|
|
|
2011-02-01 09:49:24 -07:00
|
|
|
// CALL CX
|
|
|
|
*p++ = 0xff;
|
|
|
|
*p++ = 0xd1;
|
2011-01-21 19:55:53 -07:00
|
|
|
|
2011-02-01 09:49:24 -07:00
|
|
|
// RET argsize?
|
|
|
|
if(cleanstack) {
|
|
|
|
*p++ = 0xc2;
|
|
|
|
*(uint16*)p = argsize;
|
|
|
|
} else
|
|
|
|
*p = 0xc3;
|
2011-01-21 19:55:53 -07:00
|
|
|
|
2011-06-02 01:08:56 -06:00
|
|
|
return &c->asmbody;
|
2011-01-21 19:55:53 -07:00
|
|
|
}
|
2011-04-25 14:58:00 -06:00
|
|
|
|
|
|
|
void
|
|
|
|
os·sigpipe(void)
|
|
|
|
{
|
|
|
|
runtime·throw("too many writes on closed pipe");
|
|
|
|
}
|