Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

runtime: make more functions safe for Go

Browse source 
Convert no-op race functions.
Everything else is tiny and gets NOSPLITs.

After this, all that is left on darwin is sysAlloc, panic, and gothrow (all pending).
There may be system-specific calls in other builds.

LGTM=iant
R=golang-codereviews, iant
CC=dvyukov, golang-codereviews, khr, r
https://golang.org/cl/140240044
This commit is contained in:
Russ Cox 2014-09-04 15:53:45 -04:00
parent c08d8834dd
commit f545b05aae
19 changed files with 274 additions and 220 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/pkg/runtime/cgocall.go
View file

@ -101,7 +101,7 @@ func cgocall_errno(fn, arg unsafe.Pointer) int32 {
// Create an extra M for callbacks on threads not created by Go on first cgo call.
if needextram == 1 && cas(&needextram, 1, 0) {
newextram()
onM(newextram)
}
/*
@ -188,7 +188,7 @@ func cgocallbackg1() {
gp := getg()
if gp.m.needextram {
gp.m.needextram = false
newextram()
onM(newextram)
}
// Add entry to defer stack in case of panic.

1
src/pkg/runtime/os_darwin.c
View file

@ -71,6 +71,7 @@ runtime·osinit(void)
runtime·ncpu = out;
}
#pragma textflag NOSPLIT
void
runtime·get_random_data(byte **rnd, int32 *rnd_len)
{

24
src/pkg/runtime/os_dragonfly.c
View file

@ -72,19 +72,40 @@ runtime·futexsleep(uint32 *addr, uint32 val, int64 ns)
*(int32*)0x1005 = 0x1005;
}
static void badfutexwakeup(void);
#pragma textflag NOSPLIT
void
runtime·futexwakeup(uint32 *addr, uint32 cnt)
{
int32 ret;
void (*fn)(void);
ret = runtime·sys_umtx_wakeup(addr, cnt);
if(ret >= 0)
return;
runtime·printf("umtx_wake addr=%p ret=%d\n", addr, ret);
g->m->ptrarg[0] = addr;
g->m->scalararg[0] = ret;
fn = badfutexwakeup;
if(g == g->m->gsignal)
fn();
else
runtime·onM(&fn);
*(int32*)0x1006 = 0x1006;
}
static void
badfutexwakeup(void)
{
void *addr;
int32 ret;
addr = g->m->ptrarg[0];
ret = g->m->scalararg[0];
runtime·printf("umtx_wake addr=%p ret=%d\n", addr, ret);
}
void runtime·lwp_start(void*);
void
@ -119,6 +140,7 @@ runtime·osinit(void)
runtime·ncpu = getncpu();
}
#pragma textflag NOSPLIT
void
runtime·get_random_data(byte **rnd, int32 *rnd_len)
{

24
src/pkg/runtime/os_freebsd.c
View file

@ -73,19 +73,40 @@ fail:
*(int32*)0x1005 = 0x1005;
}
static void badfutexwakeup(void);
#pragma textflag NOSPLIT
void
runtime·futexwakeup(uint32 *addr, uint32 cnt)
{
int32 ret;
void (*fn)(void);
ret = runtime·sys_umtx_op(addr, UMTX_OP_WAKE_PRIVATE, cnt, nil, nil);
if(ret >= 0)
return;
runtime·printf("umtx_wake addr=%p ret=%d\n", addr, ret);
g->m->ptrarg[0] = addr;
g->m->scalararg[0] = ret;
fn = badfutexwakeup;
if(g == g->m->gsignal)
fn();
else
runtime·onM(&fn);
*(int32*)0x1006 = 0x1006;
}
static void
badfutexwakeup(void)
{
void *addr;
int32 ret;
addr = g->m->ptrarg[0];
ret = g->m->scalararg[0];
runtime·printf("umtx_wake addr=%p ret=%d\n", addr, ret);
}
void runtime·thr_start(void*);
void
@ -127,6 +148,7 @@ runtime·osinit(void)
runtime·ncpu = getncpu();
}
#pragma textflag NOSPLIT
void
runtime·get_random_data(byte **rnd, int32 *rnd_len)
{

25
src/pkg/runtime/os_linux.c
View file

@ -55,24 +55,44 @@ runtime·futexsleep(uint32 *addr, uint32 val, int64 ns)
runtime·futex(addr, FUTEX_WAIT, val, &ts, nil, 0);
}
static void badfutexwakeup(void);
// If any procs are sleeping on addr, wake up at most cnt.
#pragma textflag NOSPLIT
void
runtime·futexwakeup(uint32 *addr, uint32 cnt)
{
int64 ret;
void (*fn)(void);
ret = runtime·futex(addr, FUTEX_WAKE, cnt, nil, nil, 0);
if(ret >= 0)
return;
// I don't know that futex wakeup can return
// EAGAIN or EINTR, but if it does, it would be
// safe to loop and call futex again.
runtime·printf("futexwakeup addr=%p returned %D\n", addr, ret);
g->m->ptrarg[0] = addr;
g->m->scalararg[0] = (int32)ret; // truncated but fine
fn = badfutexwakeup;
if(g == g->m->gsignal)
fn();
else
runtime·onM(&fn);
*(int32*)0x1006 = 0x1006;
}
static void
badfutexwakeup(void)
{
void *addr;
int64 ret;
addr = g->m->ptrarg[0];
ret = (int32)g->m->scalararg[0];
runtime·printf("futexwakeup addr=%p returned %D\n", addr, ret);
}
extern runtime·sched_getaffinity(uintptr pid, uintptr len, uintptr *buf);
static int32
getproccount(void)
@ -162,6 +182,7 @@ runtime·osinit(void)
byte* runtime·startup_random_data;
uint32 runtime·startup_random_data_len;
#pragma textflag NOSPLIT
void
runtime·get_random_data(byte **rnd, int32 *rnd_len)
{

72
src/pkg/runtime/os_nacl.c
View file

@ -65,6 +65,7 @@ runtime·crash(void)
*(int32*)0 = 0;
}
#pragma textflag NOSPLIT
void
runtime·get_random_data(byte **rnd, int32 *rnd_len)
{
@ -112,8 +113,8 @@ runtime·newosproc(M *mp, void *stk)
}
}
uintptr
runtime·semacreate(void)
static void
semacreate(void)
{
int32 mu, cond;
@ -128,14 +129,32 @@ runtime·semacreate(void)
runtime·throw("semacreate");
}
g->m->waitsemalock = mu;
return cond; // assigned to m->waitsema
g->m->scalararg[0] = cond; // assigned to m->waitsema
}
#pragma textflag NOSPLIT
int32
runtime·semasleep(int64 ns)
uint32
runtime·semacreate(void)
{
void (*fn)(void);
uint32 x;
fn = semacreate;
runtime·onM(&fn);
x = g->m->scalararg[0];
g->m->scalararg[0] = 0;
return x;
}
static void
semasleep(void)
{
int32 ret;
int64 ns;
ns = (int64)(uint32)g->m->scalararg[0] | (int64)(uint32)g->m->scalararg[1]<<32;
g->m->scalararg[0] = 0;
g->m->scalararg[1] = 0;
ret = runtime·nacl_mutex_lock(g->m->waitsemalock);
if(ret < 0) {
@ -145,7 +164,8 @@ runtime·semasleep(int64 ns)
if(g->m->waitsemacount > 0) {
g->m->waitsemacount = 0;
runtime·nacl_mutex_unlock(g->m->waitsemalock);
return 0;
g->m->scalararg[0] = 0;
return;
}
while(g->m->waitsemacount == 0) {
@ -163,7 +183,8 @@ runtime·semasleep(int64 ns)
ret = runtime·nacl_cond_timed_wait_abs(g->m->waitsema, g->m->waitsemalock, &ts);
if(ret == -ETIMEDOUT) {
runtime·nacl_mutex_unlock(g->m->waitsemalock);
return -1;
g->m->scalararg[0] = -1;
return;
}
if(ret < 0) {
//runtime·printf("nacl_cond_timed_wait_abs: error %d\n", -ret);
@ -174,14 +195,34 @@ runtime·semasleep(int64 ns)
g->m->waitsemacount = 0;
runtime·nacl_mutex_unlock(g->m->waitsemalock);
return 0;
g->m->scalararg[0] = 0;
}
void
runtime·semawakeup(M *mp)
#pragma textflag NOSPLIT
int32
runtime·semasleep(int64 ns)
{
int32 r;
void (*fn)(void);
g->m->scalararg[0] = (uint32)ns;
g->m->scalararg[1] = (uint32)(ns>>32);
fn = semasleep;
runtime·onM(&fn);
r = g->m->scalararg[0];
g->m->scalararg[0] = 0;
return r;
}
static void
semawakeup(void)
{
int32 ret;
M *mp;
mp = g->m->ptrarg[0];
g->m->ptrarg[0] = nil;
ret = runtime·nacl_mutex_lock(mp->waitsemalock);
if(ret < 0) {
//runtime·printf("nacl_mutex_lock: error %d\n", -ret);
@ -196,6 +237,17 @@ runtime·semawakeup(M *mp)
runtime·nacl_mutex_unlock(mp->waitsemalock);
}
#pragma textflag NOSPLIT
void
runtime·semawakeup(M *mp)
{
void (*fn)(void);
g->m->ptrarg[0] = mp;
fn = semawakeup;
runtime·onM(&fn);
}
uintptr
runtime·memlimit(void)
{

1
src/pkg/runtime/os_netbsd.c
View file

@ -185,6 +185,7 @@ runtime·osinit(void)
runtime·ncpu = getncpu();
}
#pragma textflag NOSPLIT
void
runtime·get_random_data(byte **rnd, int32 *rnd_len)
{

1
src/pkg/runtime/os_openbsd.c
View file

@ -164,6 +164,7 @@ runtime·osinit(void)
runtime·ncpu = getncpu();
}
#pragma textflag NOSPLIT
void
runtime·get_random_data(byte **rnd, int32 *rnd_len)
{

1
src/pkg/runtime/os_plan9.c
View file

@ -100,6 +100,7 @@ runtime·crash(void)
*(int32*)0 = 0;
}
#pragma textflag NOSPLIT
void
runtime·get_random_data(byte **rnd, int32 *rnd_len)
{

1
src/pkg/runtime/os_solaris.c
View file

@ -143,6 +143,7 @@ runtime·newosproc(M *mp, void *stk)
}
}
#pragma textflag NOSPLIT
void
runtime·get_random_data(byte **rnd, int32 *rnd_len)
{

1
src/pkg/runtime/os_windows.c
View file

@ -109,6 +109,7 @@ runtime·osinit(void)
}
}
#pragma textflag NOSPLIT
void
runtime·get_random_data(byte **rnd, int32 *rnd_len)
{

20
src/pkg/runtime/proc.c
View file

@ -2534,6 +2534,7 @@ lockOSThread(void)
g->lockedm = g->m;
}
#pragma textflag NOSPLIT
void
runtime·LockOSThread(void)
{
@ -2541,6 +2542,7 @@ runtime·LockOSThread(void)
lockOSThread();
}
#pragma textflag NOSPLIT
void
runtime·lockOSThread(void)
{
@ -2562,6 +2564,7 @@ unlockOSThread(void)
g->lockedm = nil;
}
#pragma textflag NOSPLIT
void
runtime·UnlockOSThread(void)
{
@ -2569,15 +2572,28 @@ runtime·UnlockOSThread(void)
unlockOSThread();
}
static void badunlockOSThread(void);
#pragma textflag NOSPLIT
void
runtime·unlockOSThread(void)
{
if(g->m->locked < LockInternal)
runtime·throw("runtime: internal error: misuse of lockOSThread/unlockOSThread");
void (*fn)(void);
if(g->m->locked < LockInternal) {
fn = badunlockOSThread;
runtime·onM(&fn);
}
g->m->locked -= LockInternal;
unlockOSThread();
}
static void
badunlockOSThread(void)
{
runtime·throw("runtime: internal error: misuse of lockOSThread/unlockOSThread");
}
bool
runtime·lockedOSThread(void)
{

56
src/pkg/runtime/race.c
View file

@ -80,6 +80,7 @@ void runtime·racesymbolizethunk(void*);
void runtime·racecall(void(*f)(void), ...);
// checks if the address has shadow (i.e. heap or data/bss)
#pragma textflag NOSPLIT
static bool
isvalidaddr(uintptr addr)
{
@ -90,6 +91,7 @@ isvalidaddr(uintptr addr)
return false;
}
#pragma textflag NOSPLIT
uintptr
runtime·raceinit(void)
{
@ -106,12 +108,14 @@ runtime·raceinit(void)
return racectx;
}
#pragma textflag NOSPLIT
void
runtime·racefini(void)
{
runtime·racecall(__tsan_fini);
}
#pragma textflag NOSPLIT
void
runtime·racemapshadow(void *addr, uintptr size)
{
@ -129,6 +133,7 @@ runtime·racemalloc(void *p, uintptr sz)
runtime·racecall(__tsan_malloc, p, sz);
}
#pragma textflag NOSPLIT
uintptr
runtime·racegostart(void *pc)
{
@ -144,12 +149,14 @@ runtime·racegostart(void *pc)
return racectx;
}
#pragma textflag NOSPLIT
void
runtime·racegoend(void)
{
runtime·racecall(__tsan_go_end, g->racectx);
}
#pragma textflag NOSPLIT
void
runtime·racewriterangepc(void *addr, uintptr sz, void *callpc, void *pc)
{
@ -165,6 +172,7 @@ runtime·racewriterangepc(void *addr, uintptr sz, void *callpc, void *pc)
runtime·racefuncexit();
}
#pragma textflag NOSPLIT
void
runtime·racereadrangepc(void *addr, uintptr sz, void *callpc, void *pc)
{
@ -180,6 +188,7 @@ runtime·racereadrangepc(void *addr, uintptr sz, void *callpc, void *pc)
runtime·racefuncexit();
}
#pragma textflag NOSPLIT
void
runtime·racewriteobjectpc(void *addr, Type *t, void *callpc, void *pc)
{
@ -192,6 +201,7 @@ runtime·racewriteobjectpc(void *addr, Type *t, void *callpc, void *pc)
runtime·racewritepc(addr, callpc, pc);
}
#pragma textflag NOSPLIT
void
runtime·racereadobjectpc(void *addr, Type *t, void *callpc, void *pc)
{
@ -204,12 +214,14 @@ runtime·racereadobjectpc(void *addr, Type *t, void *callpc, void *pc)
runtime·racereadpc(addr, callpc, pc);
}
#pragma textflag NOSPLIT
void
runtime·raceacquire(void *addr)
{
runtime·raceacquireg(g, addr);
}
#pragma textflag NOSPLIT
void
runtime·raceacquireg(G *gp, void *addr)
{
@ -218,6 +230,7 @@ runtime·raceacquireg(G *gp, void *addr)
runtime·racecall(__tsan_acquire, gp->racectx, addr);
}
#pragma textflag NOSPLIT
void
runtime·racerelease(void *addr)
{
@ -226,6 +239,7 @@ runtime·racerelease(void *addr)
runtime·racereleaseg(g, addr);
}
#pragma textflag NOSPLIT
void
runtime·racereleaseg(G *gp, void *addr)
{
@ -234,12 +248,14 @@ runtime·racereleaseg(G *gp, void *addr)
runtime·racecall(__tsan_release, gp->racectx, addr);
}
#pragma textflag NOSPLIT
void
runtime·racereleasemerge(void *addr)
{
runtime·racereleasemergeg(g, addr);
}
#pragma textflag NOSPLIT
void
runtime·racereleasemergeg(G *gp, void *addr)
{
@ -248,6 +264,7 @@ runtime·racereleasemergeg(G *gp, void *addr)
runtime·racecall(__tsan_release_merge, gp->racectx, addr);
}
#pragma textflag NOSPLIT
void
runtime·racefingo(void)
{
@ -255,6 +272,7 @@ runtime·racefingo(void)
}
// func RaceAcquire(addr unsafe.Pointer)
#pragma textflag NOSPLIT
void
runtime·RaceAcquire(void *addr)
{
@ -262,6 +280,7 @@ runtime·RaceAcquire(void *addr)
}
// func RaceRelease(addr unsafe.Pointer)
#pragma textflag NOSPLIT
void
runtime·RaceRelease(void *addr)
{
@ -269,6 +288,7 @@ runtime·RaceRelease(void *addr)
}
// func RaceReleaseMerge(addr unsafe.Pointer)
#pragma textflag NOSPLIT
void
runtime·RaceReleaseMerge(void *addr)
{
@ -276,6 +296,7 @@ runtime·RaceReleaseMerge(void *addr)
}
// func RaceDisable()
#pragma textflag NOSPLIT
void
runtime·RaceDisable(void)
{
@ -284,43 +305,10 @@ runtime·RaceDisable(void)
}
// func RaceEnable()
#pragma textflag NOSPLIT
void
runtime·RaceEnable(void)
{
if(--g->raceignore == 0)
runtime·racecall(__tsan_go_ignore_sync_end, g->racectx);
}
typedef struct SymbolizeContext SymbolizeContext;
struct SymbolizeContext
{
uintptr pc;
int8* func;
int8* file;
uintptr line;
uintptr off;
uintptr res;
};
// Callback from C into Go, runs on g0.
void
runtime·racesymbolize(SymbolizeContext *ctx)
{
Func *f;
String file;
f = runtime·findfunc(ctx->pc);
if(f == nil) {
ctx->func = "??";
ctx->file = "-";
ctx->line = 0;
ctx->off = ctx->pc;
ctx->res = 1;
return;
}
ctx->func = runtime·funcname(f);
ctx->line = runtime·funcline(f, ctx->pc, &file);
ctx->file = (int8*)file.str; // assume zero-terminated
ctx->off = ctx->pc - f->entry;
ctx->res = 1;
}

69
src/pkg/runtime/race.go
View file

@ -38,7 +38,7 @@ func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
if kind == kindArray || kind == kindStruct {
// for composite objects we have to read every address
// because a write might happen to any subobject.
racereadrangepc(addr, int(t.size), callerpc, pc)
racereadrangepc(addr, t.size, callerpc, pc)
} else {
// for non-composite objects we can read just the start
// address, as any write must write the first byte.
@ -51,10 +51,75 @@ func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
if kind == kindArray || kind == kindStruct {
// for composite objects we have to write every address
// because a write might happen to any subobject.
racewriterangepc(addr, int(t.size), callerpc, pc)
racewriterangepc(addr, t.size, callerpc, pc)
} else {
// for non-composite objects we can write just the start
// address, as any write must write the first byte.
racewritepc(addr, callerpc, pc)
}
}
//go:noescape
func racereadpc(addr unsafe.Pointer, callpc, pc uintptr)
//go:noescape
func racewritepc(addr unsafe.Pointer, callpc, pc uintptr)
//go:noescape
func racereadrangepc(addr unsafe.Pointer, len uintptr, callpc, pc uintptr)
//go:noescape
func racewriterangepc(addr unsafe.Pointer, len uintptr, callpc, pc uintptr)
//go:noescape
func raceacquire(addr unsafe.Pointer)
//go:noescape
func racerelease(addr unsafe.Pointer)
//go:noescape
func raceacquireg(gp *g, addr unsafe.Pointer)
//go:noescape
func racereleaseg(gp *g, addr unsafe.Pointer)
func racefingo()
//go:noescape
func racemalloc(p unsafe.Pointer, size uintptr)
//go:noescape
func racereleasemerge(addr unsafe.Pointer)
type symbolizeContext struct {
pc uintptr
fn *byte
file *byte
line uintptr
off uintptr
res uintptr
}
var qq = [...]byte{'?', '?', 0}
var dash = [...]byte{'-', 0}
// Callback from C into Go, runs on g0.
func racesymbolize(ctx *symbolizeContext) {
f := findfunc(ctx.pc)
if f == nil {
ctx.fn = &qq[0]
ctx.file = &dash[0]
ctx.line = 0
ctx.off = ctx.pc
ctx.res = 1
return
}
ctx.fn = funcname(f)
var file string
ctx.line = uintptr(funcline(f, ctx.pc, &file))
ctx.file = &bytes(file)[0] // assume NUL-terminated
ctx.off = ctx.pc - f.entry
ctx.res = 1
return
}

124
src/pkg/runtime/race0.c
View file

@ -1,124 +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.
// Stub implementation of the race detector API.
// +build !race
#include "runtime.h"
uintptr
runtime·raceinit(void)
{
return 0;
}
void
runtime·racefini(void)
{
}
void
runtime·racemapshadow(void *addr, uintptr size)
{
USED(addr);
USED(size);
}
void
runtime·racewritepc(void *addr, void *callpc, void *pc)
{
USED(addr);
USED(callpc);
USED(pc);
}
void
runtime·racereadpc(void *addr, void *callpc, void *pc)
{
USED(addr);
USED(callpc);
USED(pc);
}
void
runtime·racewriterangepc(void *addr, uintptr sz, void *callpc, void *pc)
{
USED(addr);
USED(sz);
USED(callpc);
USED(pc);
}
void
runtime·racereadrangepc(void *addr, uintptr sz, void *callpc, void *pc)
{
USED(addr);
USED(sz);
USED(callpc);
USED(pc);
}
void
runtime·raceacquire(void *addr)
{
USED(addr);
}
void
runtime·raceacquireg(G *gp, void *addr)
{
USED(gp);
USED(addr);
}
void
runtime·racerelease(void *addr)
{
USED(addr);
}
void
runtime·racereleaseg(G *gp, void *addr)
{
USED(gp);
USED(addr);
}
void
runtime·racereleasemerge(void *addr)
{
USED(addr);
}
void
runtime·racereleasemergeg(G *gp, void *addr)
{
USED(gp);
USED(addr);
}
void
runtime·racefingo(void)
{
}
void
runtime·racemalloc(void *p, uintptr sz)
{
USED(p);
USED(sz);
}
uintptr
runtime·racegostart(void *pc)
{
USED(pc);
return 0;
}
void
runtime·racegoend(void)
{
}

25
src/pkg/runtime/race0.go
View file

@ -14,7 +14,24 @@ import (
const raceenabled = false
func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
}
func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) {
}
// Because raceenabled is false, none of these functions should be called.
func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) { gothrow("race") }
func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) { gothrow("race") }
func raceinit() { gothrow("race") }
func racefini() { gothrow("race") }
func racemapshadow(addr unsafe.Pointer, size uintptr) { gothrow("race") }
func racewritepc(addr unsafe.Pointer, callerpc, pc uintptr) { gothrow("race") }
func racereadpc(addr unsafe.Pointer, callerpc, pc uintptr) { gothrow("race") }
func racereadrangepc(addr unsafe.Pointer, sz, callerpc, pc uintptr) { gothrow("race") }
func racewriterangepc(addr unsafe.Pointer, sz, callerpc, pc uintptr) { gothrow("race") }
func raceacquire(addr unsafe.Pointer) { gothrow("race") }
func raceacquireg(gp *g, addr unsafe.Pointer) { gothrow("race") }
func racerelease(addr unsafe.Pointer) { gothrow("race") }
func racereleaseg(gp *g, addr unsafe.Pointer) { gothrow("race") }
func racereleasemerge(addr unsafe.Pointer) { gothrow("race") }
func racereleasemergeg(gp *g, addr unsafe.Pointer) { gothrow("race") }
func racefingo() { gothrow("race") }
func racemalloc(p unsafe.Pointer, sz uintptr) { gothrow("race") }
func racegostart(pc uintptr) uintptr { gothrow("race"); return 0 }
func racegoend() { gothrow("race") }

8
src/pkg/runtime/slice.go
View file

@ -48,7 +48,7 @@ func growslice(t *slicetype, old sliceStruct, n int64) sliceStruct {
if raceenabled {
callerpc := getcallerpc(unsafe.Pointer(&t))
racereadrangepc(old.array, old.len*int(t.elem.size), callerpc, funcPC(growslice))
racereadrangepc(old.array, uintptr(old.len*int(t.elem.size)), callerpc, funcPC(growslice))
}
et := t.elem
@ -104,8 +104,8 @@ func slicecopy(to sliceStruct, fm sliceStruct, width uintptr) int {
if raceenabled {
callerpc := getcallerpc(unsafe.Pointer(&to))
pc := funcPC(slicecopy)
racewriterangepc(to.array, n*int(width), callerpc, pc)
racereadrangepc(fm.array, n*int(width), callerpc, pc)
racewriterangepc(to.array, uintptr(n*int(width)), callerpc, pc)
racereadrangepc(fm.array, uintptr(n*int(width)), callerpc, pc)
}
size := uintptr(n) * width
@ -131,7 +131,7 @@ func slicestringcopy(to []byte, fm string) int {
if raceenabled {
callerpc := getcallerpc(unsafe.Pointer(&to))
pc := funcPC(slicestringcopy)
racewriterangepc(unsafe.Pointer(&to[0]), n, callerpc, pc)
racewriterangepc(unsafe.Pointer(&to[0]), uintptr(n), callerpc, pc)
}
memmove(unsafe.Pointer(&to[0]), unsafe.Pointer((*stringStruct)(unsafe.Pointer(&fm)).str), uintptr(n))

6
src/pkg/runtime/string.go
View file

@ -62,7 +62,7 @@ func concatstring5(a [5]string) string {
func slicebytetostring(b []byte) string {
if raceenabled && len(b) > 0 {
racereadrangepc(unsafe.Pointer(&b[0]),
len(b),
uintptr(len(b)),
getcallerpc(unsafe.Pointer(&b)),
funcPC(slicebytetostring))
}
@ -82,7 +82,7 @@ func slicebytetostringtmp(b []byte) string {
if raceenabled && len(b) > 0 {
racereadrangepc(unsafe.Pointer(&b[0]),
len(b),
uintptr(len(b)),
getcallerpc(unsafe.Pointer(&b)),
funcPC(slicebytetostringtmp))
}
@ -119,7 +119,7 @@ func stringtoslicerune(s string) []rune {
func slicerunetostring(a []rune) string {
if raceenabled && len(a) > 0 {
racereadrangepc(unsafe.Pointer(&a[0]),
len(a)*int(unsafe.Sizeof(a[0])),
uintptr(len(a))*unsafe.Sizeof(a[0]),
getcallerpc(unsafe.Pointer(&a)),
funcPC(slicerunetostring))
}

31
src/pkg/runtime/stubs.go
View file

@ -14,35 +14,6 @@ import "unsafe"
const ptrSize = 4 << (^uintptr(0) >> 63) // unsafe.Sizeof(uintptr(0)) but an ideal const
const regSize = 4 << (^uintreg(0) >> 63) // unsafe.Sizeof(uintreg(0)) but an ideal const
//go:noescape
func racereadpc(addr unsafe.Pointer, callpc, pc uintptr)
//go:noescape
func racewritepc(addr unsafe.Pointer, callpc, pc uintptr)
//go:noescape
func racereadrangepc(addr unsafe.Pointer, len int, callpc, pc uintptr)
//go:noescape
func racewriterangepc(addr unsafe.Pointer, len int, callpc, pc uintptr)
//go:noescape
func raceacquire(addr unsafe.Pointer)
//go:noescape
func racerelease(addr unsafe.Pointer)
//go:noescape
func racereleasemerge(addr unsafe.Pointer)
//go:noescape
func raceacquireg(gp *g, addr unsafe.Pointer)
//go:noescape
func racereleaseg(gp *g, addr unsafe.Pointer)
func racefingo()
// Should be a built-in for unsafe.Pointer?
//go:nosplit
func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
@ -135,8 +106,6 @@ func goexit_m()
//go:noescape
func memclr(ptr unsafe.Pointer, n uintptr)
func racemalloc(p unsafe.Pointer, size uintptr)
// memmove copies n bytes from "from" to "to".
// in memmove_*.s
//go:noescape