blob: 0c0c30e46acdf31ee12ab406a1eb572e221a7c0f [file] [log] [blame]
// 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.
// Stack scanning code for the garbage collector.
#include "runtime.h"
#ifdef USING_SPLIT_STACK
extern void * __splitstack_find (void *, void *, size_t *, void **, void **,
void **);
extern void * __splitstack_find_context (void *context[10], size_t *, void **,
void **, void **);
#endif
bool runtime_usestackmaps;
// Calling unwind_init in doscanstack only works if it does not do a
// tail call to doscanstack1.
#pragma GCC optimize ("-fno-optimize-sibling-calls")
extern void scanstackblock(uintptr addr, uintptr size, void *gcw)
__asm__(GOSYM_PREFIX "runtime.scanstackblock");
static bool doscanstack1(G*, void*)
__attribute__ ((noinline));
// Scan gp's stack, passing stack chunks to scanstackblock.
bool doscanstack(G *gp, void* gcw) {
// Save registers on the stack, so that if we are scanning our
// own stack we will see them.
if (!runtime_usestackmaps) {
__builtin_unwind_init();
flush_registers_to_secondary_stack();
}
return doscanstack1(gp, gcw);
}
// Scan gp's stack after saving registers.
static bool doscanstack1(G *gp, void *gcw) {
#ifdef USING_SPLIT_STACK
void* sp;
size_t spsize;
void* next_segment;
void* next_sp;
void* initial_sp;
G* _g_;
_g_ = runtime_g();
if (runtime_usestackmaps) {
// If stack map is enabled, we get here only when we can unwind
// the stack being scanned. That is, either we are scanning our
// own stack, or we are scanning through a signal handler.
__go_assert((_g_ == gp) || ((_g_ == gp->m->gsignal) && (gp == gp->m->curg)));
return scanstackwithmap(gcw);
}
if (_g_ == gp) {
// Scanning our own stack.
// If we are on a signal stack, it can unwind through the signal
// handler and see the g stack, so just scan our own stack.
sp = __splitstack_find(nil, nil, &spsize, &next_segment,
&next_sp, &initial_sp);
} else {
// Scanning another goroutine's stack.
// The goroutine is usually asleep (the world is stopped).
// The exception is that if the goroutine is about to enter or might
// have just exited a system call, it may be executing code such
// as schedlock and may have needed to start a new stack segment.
// Use the stack segment and stack pointer at the time of
// the system call instead, since that won't change underfoot.
if(gp->gcstack != 0) {
sp = (void*)(gp->gcstack);
spsize = gp->gcstacksize;
next_segment = (void*)(gp->gcnextsegment);
next_sp = (void*)(gp->gcnextsp);
initial_sp = (void*)(gp->gcinitialsp);
} else {
sp = __splitstack_find_context((void**)(&gp->stackcontext[0]),
&spsize, &next_segment,
&next_sp, &initial_sp);
}
}
if(sp != nil) {
scanstackblock((uintptr)(sp), (uintptr)(spsize), gcw);
while((sp = __splitstack_find(next_segment, next_sp,
&spsize, &next_segment,
&next_sp, &initial_sp)) != nil)
scanstackblock((uintptr)(sp), (uintptr)(spsize), gcw);
}
#else
byte* bottom;
byte* top;
byte* nextsp2;
byte* initialsp2;
if(gp == runtime_g()) {
// Scanning our own stack.
bottom = (byte*)&gp;
nextsp2 = secondary_stack_pointer();
} else {
// Scanning another goroutine's stack.
// The goroutine is usually asleep (the world is stopped).
bottom = (void*)gp->gcnextsp;
if(bottom == nil)
return true;
nextsp2 = (void*)gp->gcnextsp2;
}
top = (byte*)(void*)(gp->gcinitialsp) + gp->gcstacksize;
if(top > bottom)
scanstackblock((uintptr)(bottom), (uintptr)(top - bottom), gcw);
else
scanstackblock((uintptr)(top), (uintptr)(bottom - top), gcw);
if (nextsp2 != nil) {
initialsp2 = (byte*)(void*)(gp->gcinitialsp2);
if(initialsp2 > nextsp2)
scanstackblock((uintptr)(nextsp2), (uintptr)(initialsp2 - nextsp2), gcw);
else
scanstackblock((uintptr)(initialsp2), (uintptr)(nextsp2 - initialsp2), gcw);
}
#endif
return true;
}
extern bool onCurrentStack(uintptr p)
__asm__(GOSYM_PREFIX "runtime.onCurrentStack");
bool onCurrentStack(uintptr p)
{
#ifdef USING_SPLIT_STACK
void* sp;
size_t spsize;
void* next_segment;
void* next_sp;
void* initial_sp;
sp = __splitstack_find(nil, nil, &spsize, &next_segment, &next_sp,
&initial_sp);
while (sp != nil) {
if (p >= (uintptr)(sp) && p < (uintptr)(sp) + spsize) {
return true;
}
sp = __splitstack_find(next_segment, next_sp, &spsize,
&next_segment, &next_sp, &initial_sp);
}
return false;
#else
G* gp;
byte* bottom;
byte* top;
byte* temp;
byte* nextsp2;
byte* initialsp2;
gp = runtime_g();
bottom = (byte*)(&p);
top = (byte*)(void*)(gp->gcinitialsp) + gp->gcstacksize;
if ((uintptr)(top) < (uintptr)(bottom)) {
temp = top;
top = bottom;
bottom = temp;
}
if (p >= (uintptr)(bottom) && p < (uintptr)(top)) {
return true;
}
nextsp2 = secondary_stack_pointer();
if (nextsp2 != nil) {
initialsp2 = (byte*)(void*)(gp->gcinitialsp2);
if (uintptr(initialsp2) < uintptr(nextsp2)) {
temp = initialsp2;
initialsp2 = nextsp2;
nextsp2 = temp;
}
if (p >= (uintptr)(nextsp2) && p < (uintptr)(initialsp2)) {
return true;
}
}
return false;
#endif
}