OSDN Git Service

2007-01-11 Andreas Tobler <a.tobler@schweiz.org>
[pf3gnuchains/gcc-fork.git] / boehm-gc / darwin_stop_world.c
1 #include "private/pthread_support.h"
2
3 /* This probably needs more porting work to ppc64. */
4
5 # if defined(GC_DARWIN_THREADS)
6
7 /* From "Inside Mac OS X - Mach-O Runtime Architecture" published by Apple
8    Page 49:
9    "The space beneath the stack pointer, where a new stack frame would normally
10    be allocated, is called the red zone. This area as shown in Figure 3-2 may
11    be used for any purpose as long as a new stack frame does not need to be
12    added to the stack."
13
14    Page 50: "If a leaf procedure's red zone usage would exceed 224 bytes, then
15    it must set up a stack frame just like routines that call other routines."
16 */
17 #if defined(__ppc__)
18 # define PPC_RED_ZONE_SIZE 224
19 #elif defined(__ppc64__)
20 # define PPC_RED_ZONE_SIZE 320
21 #endif
22
23 /* Try to work out the right way to access thread state structure members.
24    The structure has changed its definition in different Darwin versions.  */
25 /* This now defaults to the (older) names without __, thus hopefully    */
26 /* not breaking any existing Makefile.direct builds.                    */
27 #if defined (HAS_PPC_THREAD_STATE___R0) ||      \
28     defined (HAS_PPC_THREAD_STATE64___R0) ||    \
29     defined (HAS_X86_THREAD_STATE32___EAX) ||   \
30     defined (HAS_X86_THREAD_STATE64___RAX)
31 #  define THREAD_FLD(x) __ ## x
32 #else
33 #  define THREAD_FLD(x) x
34 #endif
35
36 typedef struct StackFrame {
37   unsigned long savedSP;
38   unsigned long savedCR;
39   unsigned long savedLR;
40   unsigned long reserved[2];
41   unsigned long savedRTOC;
42 } StackFrame;
43
44 unsigned long FindTopOfStack(unsigned long stack_start) {
45   StackFrame    *frame;
46   
47   if (stack_start == 0) {
48 # ifdef POWERPC
49 #   if CPP_WORDSZ == 32
50       __asm__ volatile("lwz     %0,0(r1)" : "=r" (frame));
51 #   else
52       __asm__ volatile("ld      %0,0(r1)" : "=r" (frame));
53 #   endif
54 # endif
55   } else {
56     frame = (StackFrame *)stack_start;
57   }
58
59 # ifdef DEBUG_THREADS
60     /* GC_printf1("FindTopOfStack start at sp = %p\n", frame); */
61 # endif
62   do {
63     if (frame->savedSP == 0) break;
64                 /* if there are no more stack frames, stop */
65
66     frame = (StackFrame*)frame->savedSP;
67
68     /* we do these next two checks after going to the next frame
69        because the LR for the first stack frame in the loop
70        is not set up on purpose, so we shouldn't check it. */
71     if ((frame->savedLR & ~3) == 0) break; /* if the next LR is bogus, stop */
72     if ((~(frame->savedLR) & ~3) == 0) break; /* ditto */
73   } while (1); 
74
75 # ifdef DEBUG_THREADS
76     /* GC_printf1("FindTopOfStack finish at sp = %p\n", frame); */
77 # endif
78
79   return (unsigned long)frame;
80 }       
81
82 #ifdef DARWIN_DONT_PARSE_STACK
83 void GC_push_all_stacks() {
84   int i;
85   kern_return_t r;
86   GC_thread p;
87   pthread_t me;
88   ptr_t lo, hi;
89   GC_THREAD_STATE_T state;
90   mach_msg_type_number_t thread_state_count = GC_MACH_THREAD_STATE_COUNT;
91   
92   me = pthread_self();
93   if (!GC_thr_initialized) GC_thr_init();
94   
95   for(i=0;i<THREAD_TABLE_SZ;i++) {
96     for(p=GC_threads[i];p!=0;p=p->next) {
97       if(p -> flags & FINISHED) continue;
98       if(pthread_equal(p->id,me)) {
99         lo = GC_approx_sp();
100       } else {
101         /* Get the thread state (registers, etc) */
102         r = thread_get_state(p->stop_info.mach_thread, GC_MACH_THREAD_STATE,
103                              (natural_t*)&state, &thread_state_count);
104         if(r != KERN_SUCCESS) ABORT("thread_get_state failed");
105
106 #if defined(I386)
107         lo = (void*)state . THREAD_FLD (esp);
108
109         GC_push_one(state . THREAD_FLD (eax)); 
110         GC_push_one(state . THREAD_FLD (ebx)); 
111         GC_push_one(state . THREAD_FLD (ecx)); 
112         GC_push_one(state . THREAD_FLD (edx)); 
113         GC_push_one(state . THREAD_FLD (edi)); 
114         GC_push_one(state . THREAD_FLD (esi)); 
115         GC_push_one(state . THREAD_FLD (ebp));
116
117 #elif defined(X86_64)
118         lo = (void*)state . THREAD_FLD (rsp);
119
120         GC_push_one(state . THREAD_FLD (rax));
121         GC_push_one(state . THREAD_FLD (rbx));
122         GC_push_one(state . THREAD_FLD (rcx));
123         GC_push_one(state . THREAD_FLD (rdx));
124         GC_push_one(state . THREAD_FLD (rdi));
125         GC_push_one(state . THREAD_FLD (rsi));
126         GC_push_one(state . THREAD_FLD (rbp));
127         GC_push_one(state . THREAD_FLD (rsp));
128         GC_push_one(state . THREAD_FLD (r8));
129         GC_push_one(state . THREAD_FLD (r9));
130         GC_push_one(state . THREAD_FLD (r10));
131         GC_push_one(state . THREAD_FLD (r11));
132         GC_push_one(state . THREAD_FLD (r12));
133         GC_push_one(state . THREAD_FLD (r13));
134         GC_push_one(state . THREAD_FLD (r14));
135         GC_push_one(state . THREAD_FLD (r15));
136         GC_push_one(state . THREAD_FLD (rip));
137         GC_push_one(state . THREAD_FLD (rflags));
138         GC_push_one(state . THREAD_FLD (cs));
139         GC_push_one(state . THREAD_FLD (fs));
140         GC_push_one(state . THREAD_FLD (gs));
141
142 #elif defined(POWERPC)
143         lo = (void*)(state . THREAD_FLD (r1) - PPC_RED_ZONE_SIZE);
144         
145         GC_push_one(state . THREAD_FLD (r0)); 
146         GC_push_one(state . THREAD_FLD (r2)); 
147         GC_push_one(state . THREAD_FLD (r3)); 
148         GC_push_one(state . THREAD_FLD (r4)); 
149         GC_push_one(state . THREAD_FLD (r5)); 
150         GC_push_one(state . THREAD_FLD (r6)); 
151         GC_push_one(state . THREAD_FLD (r7)); 
152         GC_push_one(state . THREAD_FLD (r8)); 
153         GC_push_one(state . THREAD_FLD (r9)); 
154         GC_push_one(state . THREAD_FLD (r10)); 
155         GC_push_one(state . THREAD_FLD (r11)); 
156         GC_push_one(state . THREAD_FLD (r12)); 
157         GC_push_one(state . THREAD_FLD (r13)); 
158         GC_push_one(state . THREAD_FLD (r14)); 
159         GC_push_one(state . THREAD_FLD (r15)); 
160         GC_push_one(state . THREAD_FLD (r16)); 
161         GC_push_one(state . THREAD_FLD (r17)); 
162         GC_push_one(state . THREAD_FLD (r18)); 
163         GC_push_one(state . THREAD_FLD (r19)); 
164         GC_push_one(state . THREAD_FLD (r20)); 
165         GC_push_one(state . THREAD_FLD (r21)); 
166         GC_push_one(state . THREAD_FLD (r22)); 
167         GC_push_one(state . THREAD_FLD (r23)); 
168         GC_push_one(state . THREAD_FLD (r24)); 
169         GC_push_one(state . THREAD_FLD (r25)); 
170         GC_push_one(state . THREAD_FLD (r26)); 
171         GC_push_one(state . THREAD_FLD (r27)); 
172         GC_push_one(state . THREAD_FLD (r28)); 
173         GC_push_one(state . THREAD_FLD (r29)); 
174         GC_push_one(state . THREAD_FLD (r30)); 
175         GC_push_one(state . THREAD_FLD (r31));
176 #else
177 # error FIXME for non-x86 || ppc architectures
178 #endif
179       } /* p != me */
180       if(p->flags & MAIN_THREAD)
181         hi = GC_stackbottom;
182       else
183         hi = p->stack_end;
184 #if DEBUG_THREADS
185       GC_printf3("Darwin: Stack for thread 0x%lx = [%lx,%lx)\n",
186                  (unsigned long) p -> id,
187                  (unsigned long) lo,
188                  (unsigned long) hi
189                  );
190 #endif
191       GC_push_all_stack(lo,hi);
192     } /* for(p=GC_threads[i]...) */
193   } /* for(i=0;i<THREAD_TABLE_SZ...) */
194 }
195
196 #else /* !DARWIN_DONT_PARSE_STACK; Use FindTopOfStack() */
197
198 void GC_push_all_stacks() {
199     int i;
200     kern_return_t r;
201     mach_port_t me;
202     ptr_t lo, hi;
203     thread_act_array_t act_list = 0;
204     mach_msg_type_number_t listcount = 0;
205
206     me = mach_thread_self();
207     if (!GC_thr_initialized) GC_thr_init();
208     
209     r = task_threads(current_task(), &act_list, &listcount);
210     if(r != KERN_SUCCESS) ABORT("task_threads failed");
211     for(i = 0; i < listcount; i++) {
212       thread_act_t thread = act_list[i];
213       if (thread == me) {
214         lo = GC_approx_sp();
215         hi = (ptr_t)FindTopOfStack(0);
216       } else {
217 #     if defined(__ppc__) || defined(__ppc64__)
218         GC_THREAD_STATE_T info;
219         mach_msg_type_number_t outCount = THREAD_STATE_MAX;
220         r = thread_get_state(thread, GC_MACH_THREAD_STATE,
221                              (natural_t *)&info, &outCount);
222         if(r != KERN_SUCCESS) ABORT("task_get_state failed");
223
224         lo = (void*)(info . THREAD_FLD (r1) - PPC_RED_ZONE_SIZE);
225         hi = (ptr_t)FindTopOfStack(info . THREAD_FLD (r1));
226
227         GC_push_one(info . THREAD_FLD (r0)); 
228         GC_push_one(info . THREAD_FLD (r2)); 
229         GC_push_one(info . THREAD_FLD (r3)); 
230         GC_push_one(info . THREAD_FLD (r4)); 
231         GC_push_one(info . THREAD_FLD (r5)); 
232         GC_push_one(info . THREAD_FLD (r6)); 
233         GC_push_one(info . THREAD_FLD (r7)); 
234         GC_push_one(info . THREAD_FLD (r8)); 
235         GC_push_one(info . THREAD_FLD (r9)); 
236         GC_push_one(info . THREAD_FLD (r10)); 
237         GC_push_one(info . THREAD_FLD (r11)); 
238         GC_push_one(info . THREAD_FLD (r12)); 
239         GC_push_one(info . THREAD_FLD (r13)); 
240         GC_push_one(info . THREAD_FLD (r14)); 
241         GC_push_one(info . THREAD_FLD (r15)); 
242         GC_push_one(info . THREAD_FLD (r16)); 
243         GC_push_one(info . THREAD_FLD (r17)); 
244         GC_push_one(info . THREAD_FLD (r18)); 
245         GC_push_one(info . THREAD_FLD (r19)); 
246         GC_push_one(info . THREAD_FLD (r20)); 
247         GC_push_one(info . THREAD_FLD (r21)); 
248         GC_push_one(info . THREAD_FLD (r22)); 
249         GC_push_one(info . THREAD_FLD (r23)); 
250         GC_push_one(info . THREAD_FLD (r24)); 
251         GC_push_one(info . THREAD_FLD (r25)); 
252         GC_push_one(info . THREAD_FLD (r26)); 
253         GC_push_one(info . THREAD_FLD (r27)); 
254         GC_push_one(info . THREAD_FLD (r28)); 
255         GC_push_one(info . THREAD_FLD (r29)); 
256         GC_push_one(info . THREAD_FLD (r30)); 
257         GC_push_one(info . THREAD_FLD (r31));
258 #      else
259         /* FIXME: Remove after testing: */
260         WARN("This is completely untested and likely will not work\n", 0);
261         GC_THREAD_STATE_T info;
262         mach_msg_type_number_t outCount = THREAD_STATE_MAX;
263         r = thread_get_state(thread, GC_MACH_THREAD_STATE, (natural_t *)&info,
264                              &outCount);
265         if(r != KERN_SUCCESS) ABORT("task_get_state failed");
266
267         lo = (void*)info . THREAD_FLD (esp);
268         hi = (ptr_t)FindTopOfStack(info . THREAD_FLD (esp));
269
270         GC_push_one(info . THREAD_FLD (eax)); 
271         GC_push_one(info . THREAD_FLD (ebx)); 
272         GC_push_one(info . THREAD_FLD (ecx)); 
273         GC_push_one(info . THREAD_FLD (edx)); 
274         GC_push_one(info . THREAD_FLD (edi)); 
275         GC_push_one(info . THREAD_FLD (esi)); 
276         /* GC_push_one(info . THREAD_FLD (ebp));  */
277         /* GC_push_one(info . THREAD_FLD (esp));  */
278         GC_push_one(info . THREAD_FLD (ss)); 
279         GC_push_one(info . THREAD_FLD (eip)); 
280         GC_push_one(info . THREAD_FLD (cs)); 
281         GC_push_one(info . THREAD_FLD (ds)); 
282         GC_push_one(info . THREAD_FLD (es)); 
283         GC_push_one(info . THREAD_FLD (fs)); 
284         GC_push_one(info . THREAD_FLD (gs)); 
285 #      endif /* !POWERPC */
286       }
287 #     if DEBUG_THREADS
288        GC_printf3("Darwin: Stack for thread 0x%lx = [%lx,%lx)\n",
289                   (unsigned long) thread,
290                   (unsigned long) lo,
291                   (unsigned long) hi
292                  );
293 #     endif
294       GC_push_all_stack(lo, hi); 
295     } /* for(p=GC_threads[i]...) */
296     vm_deallocate(current_task(), (vm_address_t)act_list, sizeof(thread_t) * listcount);
297 }
298 #endif /* !DARWIN_DONT_PARSE_STACK */
299
300 static mach_port_t GC_mach_handler_thread;
301 static int GC_use_mach_handler_thread = 0;
302
303 static struct GC_mach_thread GC_mach_threads[THREAD_TABLE_SZ];
304 static int GC_mach_threads_count;
305
306 void GC_stop_init() {
307   int i;
308
309   for (i = 0; i < THREAD_TABLE_SZ; i++) {
310     GC_mach_threads[i].thread = 0;
311     GC_mach_threads[i].already_suspended = 0;
312   }
313   GC_mach_threads_count = 0;
314 }
315
316 /* returns true if there's a thread in act_list that wasn't in old_list */
317 int GC_suspend_thread_list(thread_act_array_t act_list, int count, 
318                            thread_act_array_t old_list, int old_count) {
319   mach_port_t my_thread = mach_thread_self();
320   int i, j;
321
322   int changed = 0;
323
324   for(i = 0; i < count; i++) {
325     thread_act_t thread = act_list[i];
326 #   if DEBUG_THREADS 
327       GC_printf1("Attempting to suspend thread %p\n", thread);
328 #   endif
329     /* find the current thread in the old list */
330     int found = 0;
331     for(j = 0; j < old_count; j++) {
332       thread_act_t old_thread = old_list[j];
333       if (old_thread == thread) {
334         found = 1;
335         break;
336       }
337     }
338     if (!found) {
339       /* add it to the GC_mach_threads list */
340       GC_mach_threads[GC_mach_threads_count].thread = thread;
341       /* default is not suspended */
342       GC_mach_threads[GC_mach_threads_count].already_suspended = 0;
343       changed = 1;
344     }      
345
346     if (thread != my_thread &&
347         (!GC_use_mach_handler_thread
348          || (GC_use_mach_handler_thread
349              && GC_mach_handler_thread != thread))) {
350       struct thread_basic_info info;
351       mach_msg_type_number_t outCount = THREAD_INFO_MAX;
352       kern_return_t kern_result = thread_info(thread, THREAD_BASIC_INFO,
353                                 (thread_info_t)&info, &outCount);
354       if(kern_result != KERN_SUCCESS) {
355         /* the thread may have quit since the thread_threads () call 
356          * we mark already_suspended so it's not dealt with anymore later
357          */
358         if (!found) {
359           GC_mach_threads[GC_mach_threads_count].already_suspended = TRUE;
360           GC_mach_threads_count++;
361         }
362         continue;
363       }
364 #     if DEBUG_THREADS
365         GC_printf2("Thread state for 0x%lx = %d\n", thread, info.run_state);
366 #     endif
367       if (!found) {
368         GC_mach_threads[GC_mach_threads_count].already_suspended = info.suspend_count;
369       }
370       if (info.suspend_count) continue;
371       
372 #     if DEBUG_THREADS
373         GC_printf1("Suspending 0x%lx\n", thread);
374 #     endif
375       /* Suspend the thread */
376       kern_result = thread_suspend(thread);
377       if(kern_result != KERN_SUCCESS) {
378         /* the thread may have quit since the thread_threads () call 
379          * we mark already_suspended so it's not dealt with anymore later
380          */
381         if (!found) {
382           GC_mach_threads[GC_mach_threads_count].already_suspended = TRUE;
383           GC_mach_threads_count++;
384         }
385         continue;
386       }
387     } 
388     if (!found) GC_mach_threads_count++;
389   }
390   return changed;
391 }
392
393
394 /* Caller holds allocation lock.        */
395 void GC_stop_world()
396 {
397   int i, changes;
398     GC_thread p;
399     mach_port_t my_thread = mach_thread_self();
400     kern_return_t kern_result;
401     thread_act_array_t act_list, prev_list;
402     mach_msg_type_number_t listcount, prevcount;
403     
404 #   if DEBUG_THREADS
405       GC_printf1("Stopping the world from 0x%lx\n", mach_thread_self());
406 #   endif
407
408     /* clear out the mach threads list table */
409     GC_stop_init(); 
410        
411     /* Make sure all free list construction has stopped before we start. */
412     /* No new construction can start, since free list construction is   */
413     /* required to acquire and release the GC lock before it starts,    */
414     /* and we have the lock.                                            */
415 #   ifdef PARALLEL_MARK
416       GC_acquire_mark_lock();
417       GC_ASSERT(GC_fl_builder_count == 0);
418       /* We should have previously waited for it to become zero. */
419 #   endif /* PARALLEL_MARK */
420
421       /* Loop stopping threads until you have gone over the whole list
422          twice without a new one appearing. thread_create() won't
423          return (and thus the thread stop) until the new thread
424          exists, so there is no window whereby you could stop a
425          thread, recognise it is stopped, but then have a new thread
426          it created before stopping show up later.
427       */
428       
429       changes = 1;
430       prev_list = NULL;
431       prevcount = 0;
432       do {
433         int result;
434         kern_result = task_threads(current_task(), &act_list, &listcount);
435         result = GC_suspend_thread_list(act_list, listcount,
436                                         prev_list, prevcount);
437         changes = result;
438         prev_list = act_list;
439         prevcount = listcount;
440         vm_deallocate(current_task(), (vm_address_t)act_list, sizeof(thread_t) * listcount);
441       } while (changes);
442       
443  
444 #   ifdef MPROTECT_VDB
445       if(GC_incremental) {
446         extern void GC_mprotect_stop();
447         GC_mprotect_stop();
448       }
449 #   endif
450     
451 #   ifdef PARALLEL_MARK
452       GC_release_mark_lock();
453 #   endif
454     #if DEBUG_THREADS
455       GC_printf1("World stopped from 0x%lx\n", my_thread);
456     #endif
457 }
458
459 /* Caller holds allocation lock, and has held it continuously since     */
460 /* the world stopped.                                                   */
461 void GC_start_world()
462 {
463   mach_port_t my_thread = mach_thread_self();
464   int i, j;
465   GC_thread p;
466   kern_return_t kern_result;
467   thread_act_array_t act_list;
468   mach_msg_type_number_t listcount;
469   struct thread_basic_info info;
470   mach_msg_type_number_t outCount = THREAD_INFO_MAX;
471   
472 #   if DEBUG_THREADS
473       GC_printf0("World starting\n");
474 #   endif
475
476 #   ifdef MPROTECT_VDB
477       if(GC_incremental) {
478         extern void GC_mprotect_resume();
479         GC_mprotect_resume();
480       }
481 #   endif
482
483     kern_result = task_threads(current_task(), &act_list, &listcount);
484     for(i = 0; i < listcount; i++) {
485       thread_act_t thread = act_list[i];
486       if (thread != my_thread &&
487           (!GC_use_mach_handler_thread ||
488            (GC_use_mach_handler_thread && GC_mach_handler_thread != thread))) {
489         for(j = 0; j < GC_mach_threads_count; j++) {
490           if (thread == GC_mach_threads[j].thread) {
491             if (GC_mach_threads[j].already_suspended) {
492 #             if DEBUG_THREADS
493                 GC_printf1("Not resuming already suspended thread %p\n", thread);
494 #             endif
495               continue;
496             }
497             kern_result = thread_info(thread, THREAD_BASIC_INFO,
498                                       (thread_info_t)&info, &outCount);
499             if(kern_result != KERN_SUCCESS) ABORT("thread_info failed");
500 #           if DEBUG_THREADS
501               GC_printf2("Thread state for 0x%lx = %d\n", thread,
502                          info.run_state);
503               GC_printf1("Resuming 0x%lx\n", thread);
504 #           endif
505             /* Resume the thread */
506             kern_result = thread_resume(thread);
507             if(kern_result != KERN_SUCCESS) ABORT("thread_resume failed");
508           } 
509         }
510       }
511     }
512     vm_deallocate(current_task(), (vm_address_t)act_list, sizeof(thread_t) * listcount);
513 #   if DEBUG_THREADS
514      GC_printf0("World started\n");
515 #   endif
516 }
517
518 void GC_darwin_register_mach_handler_thread(mach_port_t thread) {
519   GC_mach_handler_thread = thread;
520   GC_use_mach_handler_thread = 1;
521 }
522
523 #endif