libgo/runtime/stack.c

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // Stack scanning code for the garbage collector.
   6
   7 #include "runtime.h"
   8
   9 #ifdef USING_SPLIT_STACK
  10
  11 extern void * __splitstack_find (void *, void *, size_t *, void **, void **,
  12                                  void **);
  13
  14 extern void * __splitstack_find_context (void *context[10], size_t *, void **,
  15                                          void **, void **);
  16
  17 #endif
  18
  19 // Calling unwind_init in doscanstack only works if it does not do a
  20 // tail call to doscanstack1.
  21 #pragma GCC optimize ("-fno-optimize-sibling-calls")
  22
  23 extern void scanstackblock(uintptr addr, uintptr size, void *gcw)
  24   __asm__("runtime.scanstackblock");
  25
  26 static bool doscanstack1(G*, void*)
  27   __attribute__ ((noinline));
  28
  29 // Scan gp's stack, passing stack chunks to scanstackblock.
  30 bool doscanstack(G *gp, void* gcw) {
  31         // Save registers on the stack, so that if we are scanning our
  32         // own stack we will see them.
  33         if (!runtime_usestackmaps) {
  34                 __builtin_unwind_init();
  35                 flush_registers_to_secondary_stack();
  36         }
  37
  38         return doscanstack1(gp, gcw);
  39 }
  40
  41 // Scan gp's stack after saving registers.
  42 static bool doscanstack1(G *gp, void *gcw) {
  43 #ifdef USING_SPLIT_STACK
  44         void* sp;
  45         size_t spsize;
  46         void* next_segment;
  47         void* next_sp;
  48         void* initial_sp;
  49         G* _g_;
  50
  51         _g_ = runtime_g();
  52         if (runtime_usestackmaps) {
  53                 // If stack map is enabled, we get here only when we can unwind
  54                 // the stack being scanned. That is, either we are scanning our
  55                 // own stack, or we are scanning through a signal handler.
  56                 __go_assert((_g_ == gp) || ((_g_ == gp->m->gsignal) && (gp == gp->m->curg)));
  57                 return scanstackwithmap(gcw);
  58         }
  59         if (_g_ == gp) {
  60                 // Scanning our own stack.
  61                 // If we are on a signal stack, it can unwind through the signal
  62                 // handler and see the g stack, so just scan our own stack.
  63                 sp = __splitstack_find(nil, nil, &spsize, &next_segment,
  64                                        &next_sp, &initial_sp);
  65         } else {
  66                 // Scanning another goroutine's stack.
  67                 // The goroutine is usually asleep (the world is stopped).
  68
  69                 // The exception is that if the goroutine is about to enter or might
  70                 // have just exited a system call, it may be executing code such
  71                 // as schedlock and may have needed to start a new stack segment.
  72                 // Use the stack segment and stack pointer at the time of
  73                 // the system call instead, since that won't change underfoot.
  74                 if(gp->gcstack != 0) {
  75                         sp = (void*)(gp->gcstack);
  76                         spsize = gp->gcstacksize;
  77                         next_segment = (void*)(gp->gcnextsegment);
  78                         next_sp = (void*)(gp->gcnextsp);
  79                         initial_sp = (void*)(gp->gcinitialsp);
  80                 } else {
  81                         sp = __splitstack_find_context((void**)(&gp->stackcontext[0]),
  82                                                        &spsize, &next_segment,
  83                                                        &next_sp, &initial_sp);
  84                 }
  85         }
  86         if(sp != nil) {
  87                 scanstackblock((uintptr)(sp), (uintptr)(spsize), gcw);
  88                 while((sp = __splitstack_find(next_segment, next_sp,
  89                                               &spsize, &next_segment,
  90                                               &next_sp, &initial_sp)) != nil)
  91                         scanstackblock((uintptr)(sp), (uintptr)(spsize), gcw);
  92         }
  93 #else
  94         byte* bottom;
  95         byte* top;
  96         byte* nextsp2;
  97         byte* initialsp2;
  98
  99         if(gp == runtime_g()) {
 100                 // Scanning our own stack.
 101                 bottom = (byte*)&gp;
 102                 nextsp2 = secondary_stack_pointer();
 103         } else {
 104                 // Scanning another goroutine's stack.
 105                 // The goroutine is usually asleep (the world is stopped).
 106                 bottom = (void*)gp->gcnextsp;
 107                 if(bottom == nil)
 108                         return true;
 109                 nextsp2 = (void*)gp->gcnextsp2;
 110         }
 111         top = (byte*)(void*)(gp->gcinitialsp) + gp->gcstacksize;
 112         if(top > bottom)
 113                 scanstackblock((uintptr)(bottom), (uintptr)(top - bottom), gcw);
 114         else
 115                 scanstackblock((uintptr)(top), (uintptr)(bottom - top), gcw);
 116         if (nextsp2 != nil) {
 117                 initialsp2 = (byte*)(void*)(gp->gcinitialsp2);
 118                 if(initialsp2 > nextsp2)
 119                         scanstackblock((uintptr)(nextsp2), (uintptr)(initialsp2 - nextsp2), gcw);
 120                 else
 121                         scanstackblock((uintptr)(initialsp2), (uintptr)(nextsp2 - initialsp2), gcw);
 122         }
 123 #endif
 124         return true;
 125 }