gcc/libgo/runtime/stack.c

// 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
}