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