# if defined(GC_DARWIN_THREADS)
+#include <AvailabilityMacros.h>
+#include "mono/utils/mono-compiler.h"
+
+#ifdef MONO_DEBUGGER_SUPPORTED
+#include "include/libgc-mono-debugger.h"
+#endif
+
/* From "Inside Mac OS X - Mach-O Runtime Architecture" published by Apple
Page 49:
"The space beneath the stack pointer, where a new stack frame would normally
ptr_t lo, hi;
#if defined(POWERPC)
ppc_thread_state_t state;
+ mach_msg_type_number_t thread_state_count = PPC_THREAD_STATE_COUNT;
#elif defined(I386)
i386_thread_state_t state;
+ mach_msg_type_number_t thread_state_count = i386_THREAD_STATE_COUNT;
+#elif defined(ARM)
+ arm_thread_state_t state;
+ mach_msg_type_number_t thread_state_count = ARM_THREAD_STATE_COUNT;
+#elif defined(X86_64)
+ x86_thread_state64_t state;
+ mach_msg_type_number_t thread_state_count = x86_THREAD_STATE64_COUNT;
#else
# error FIXME for non-x86 || ppc architectures
-#endif
mach_msg_type_number_t thread_state_count = MACHINE_THREAD_STATE_COUNT;
+#endif
me = pthread_self();
if (!GC_thr_initialized) GC_thr_init();
/* Get the thread state (registers, etc) */
r = thread_get_state(
p->stop_info.mach_thread,
- MACHINE_THREAD_STATE,
+ GC_MACH_THREAD_STATE_FLAVOR,
(natural_t*)&state,
&thread_state_count);
- if(r != KERN_SUCCESS) ABORT("thread_get_state failed");
+ if(r != KERN_SUCCESS) continue;
#if defined(I386)
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
+
+ lo = state.__esp;
+
+ GC_push_one(state.__eax);
+ GC_push_one(state.__ebx);
+ GC_push_one(state.__ecx);
+ GC_push_one(state.__edx);
+ GC_push_one(state.__edi);
+ GC_push_one(state.__esi);
+ GC_push_one(state.__ebp);
+#else
lo = state.esp;
GC_push_one(state.eax);
GC_push_one(state.edi);
GC_push_one(state.esi);
GC_push_one(state.ebp);
+#endif
+#elif defined(X86_64)
+ lo = state.__rsp;
+ GC_push_one(state.__rax);
+ GC_push_one(state.__rbx);
+ GC_push_one(state.__rcx);
+ GC_push_one(state.__rdx);
+ GC_push_one(state.__rdi);
+ GC_push_one(state.__rsi);
+ GC_push_one(state.__rbp);
+ GC_push_one(state.__r8);
+ GC_push_one(state.__r9);
+ GC_push_one(state.__r10);
+ GC_push_one(state.__r11);
+ GC_push_one(state.__r12);
+ GC_push_one(state.__r13);
+ GC_push_one(state.__r14);
+ GC_push_one(state.__r15);
#elif defined(POWERPC)
+#if defined(_STRUCT_PPC_EXCEPTION_STATE) && defined(__DARWIN_UNIX03)
+ lo = (void*)(state.__r1 - PPC_RED_ZONE_SIZE);
+
+ GC_push_one(state.__r0);
+ GC_push_one(state.__r2);
+ GC_push_one(state.__r3);
+ GC_push_one(state.__r4);
+ GC_push_one(state.__r5);
+ GC_push_one(state.__r6);
+ GC_push_one(state.__r7);
+ GC_push_one(state.__r8);
+ GC_push_one(state.__r9);
+ GC_push_one(state.__r10);
+ GC_push_one(state.__r11);
+ GC_push_one(state.__r12);
+ GC_push_one(state.__r13);
+ GC_push_one(state.__r14);
+ GC_push_one(state.__r15);
+ GC_push_one(state.__r16);
+ GC_push_one(state.__r17);
+ GC_push_one(state.__r18);
+ GC_push_one(state.__r19);
+ GC_push_one(state.__r20);
+ GC_push_one(state.__r21);
+ GC_push_one(state.__r22);
+ GC_push_one(state.__r23);
+ GC_push_one(state.__r24);
+ GC_push_one(state.__r25);
+ GC_push_one(state.__r26);
+ GC_push_one(state.__r27);
+ GC_push_one(state.__r28);
+ GC_push_one(state.__r29);
+ GC_push_one(state.__r30);
+ GC_push_one(state.__r31);
+#else
lo = (void*)(state.r1 - PPC_RED_ZONE_SIZE);
GC_push_one(state.r0);
GC_push_one(state.r29);
GC_push_one(state.r30);
GC_push_one(state.r31);
+#endif
+#elif defined(ARM)
+ lo = (void*)state.__sp;
+
+ GC_push_one(state.__r[0]);
+ GC_push_one(state.__r[1]);
+ GC_push_one(state.__r[2]);
+ GC_push_one(state.__r[3]);
+ GC_push_one(state.__r[4]);
+ GC_push_one(state.__r[5]);
+ GC_push_one(state.__r[6]);
+ GC_push_one(state.__r[7]);
+ GC_push_one(state.__r[8]);
+ GC_push_one(state.__r[9]);
+ GC_push_one(state.__r[10]);
+ GC_push_one(state.__r[11]);
+ GC_push_one(state.__r[12]);
+ /* GC_push_one(state.__sp); */
+ GC_push_one(state.__lr);
+ GC_push_one(state.__pc);
+ GC_push_one(state.__cpsr);
#else
# error FIXME for non-x86 || ppc architectures
#endif
void GC_push_all_stacks() {
int i;
+ task_t my_task;
kern_return_t r;
mach_port_t me;
ptr_t lo, hi;
me = mach_thread_self();
if (!GC_thr_initialized) GC_thr_init();
- r = task_threads(current_task(), &act_list, &listcount);
+ my_task = current_task();
+ r = task_threads(my_task, &act_list, &listcount);
if(r != KERN_SUCCESS) ABORT("task_threads failed");
for(i = 0; i < listcount; i++) {
thread_act_t thread = act_list[i];
ppc_thread_state64_t info;
# endif
mach_msg_type_number_t outCount = THREAD_STATE_MAX;
- r = thread_get_state(thread, MACHINE_THREAD_STATE,
+ r = thread_get_state(thread, GC_MACH_THREAD_STATE_FLAVOR,
(natural_t *)&info, &outCount);
if(r != KERN_SUCCESS) continue;
+#if defined(_STRUCT_PPC_EXCEPTION_STATE)
+ lo = (void*)(info.__r1 - PPC_RED_ZONE_SIZE);
+ hi = (ptr_t)FindTopOfStack(info.__r1);
+
+ GC_push_one(info.__r0);
+ GC_push_one(info.__r2);
+ GC_push_one(info.__r3);
+ GC_push_one(info.__r4);
+ GC_push_one(info.__r5);
+ GC_push_one(info.__r6);
+ GC_push_one(info.__r7);
+ GC_push_one(info.__r8);
+ GC_push_one(info.__r9);
+ GC_push_one(info.__r10);
+ GC_push_one(info.__r11);
+ GC_push_one(info.__r12);
+ GC_push_one(info.__r13);
+ GC_push_one(info.__r14);
+ GC_push_one(info.__r15);
+ GC_push_one(info.__r16);
+ GC_push_one(info.__r17);
+ GC_push_one(info.__r18);
+ GC_push_one(info.__r19);
+ GC_push_one(info.__r20);
+ GC_push_one(info.__r21);
+ GC_push_one(info.__r22);
+ GC_push_one(info.__r23);
+ GC_push_one(info.__r24);
+ GC_push_one(info.__r25);
+ GC_push_one(info.__r26);
+ GC_push_one(info.__r27);
+ GC_push_one(info.__r28);
+ GC_push_one(info.__r29);
+ GC_push_one(info.__r30);
+ GC_push_one(info.__r31);
+#else
lo = (void*)(info.r1 - PPC_RED_ZONE_SIZE);
hi = (ptr_t)FindTopOfStack(info.r1);
GC_push_one(info.r29);
GC_push_one(info.r30);
GC_push_one(info.r31);
-# else
+#endif
+# elif defined(I386) /* !POWERPC */
/* FIXME: Remove after testing: */
WARN("This is completely untested and likely will not work\n", 0);
i386_thread_state_t info;
mach_msg_type_number_t outCount = THREAD_STATE_MAX;
- r = thread_get_state(thread, MACHINE_THREAD_STATE,
+ r = thread_get_state(thread, GC_MACH_THREAD_STATE_FLAVOR,
(natural_t *)&info, &outCount);
if(r != KERN_SUCCESS) continue;
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
+ lo = (void*)info.__esp;
+ hi = (ptr_t)FindTopOfStack(info.__esp);
+
+ GC_push_one(info.__eax);
+ GC_push_one(info.__ebx);
+ GC_push_one(info.__ecx);
+ GC_push_one(info.__edx);
+ GC_push_one(info.__edi);
+ GC_push_one(info.__esi);
+ GC_push_one(info.__ebp);
+ /* GC_push_one(info.__esp); */
+ GC_push_one(info.__ss);
+ GC_push_one(info.__eip);
+ GC_push_one(info.__cs);
+ GC_push_one(info.__ds);
+ GC_push_one(info.__es);
+ GC_push_one(info.__fs);
+ GC_push_one(info.__gs);
+#else
lo = (void*)info.esp;
hi = (ptr_t)FindTopOfStack(info.esp);
GC_push_one(info.edx);
GC_push_one(info.edi);
GC_push_one(info.esi);
- /* GC_push_one(info.ebp); */
+ GC_push_one(info.ebp);
/* GC_push_one(info.esp); */
GC_push_one(info.ss);
GC_push_one(info.eip);
GC_push_one(info.es);
GC_push_one(info.fs);
GC_push_one(info.gs);
-# endif /* !POWERPC */
+#endif
+# elif defined(ARM) /* !I386 */
+ arm_thread_state_t info;
+ mach_msg_type_number_t outCount = THREAD_STATE_MAX;
+ r = thread_get_state(thread, GC_MACH_THREAD_STATE_FLAVOR,
+ (natural_t *)&info, &outCount);
+ if(r != KERN_SUCCESS) continue;
+
+ lo = (void*)info.__sp;
+ hi = (ptr_t)FindTopOfStack(info.__sp);
+
+ GC_push_one(info.__r[0]);
+ GC_push_one(info.__r[1]);
+ GC_push_one(info.__r[2]);
+ GC_push_one(info.__r[3]);
+ GC_push_one(info.__r[4]);
+ GC_push_one(info.__r[5]);
+ GC_push_one(info.__r[6]);
+ GC_push_one(info.__r[7]);
+ GC_push_one(info.__r[8]);
+ GC_push_one(info.__r[9]);
+ GC_push_one(info.__r[10]);
+ GC_push_one(info.__r[11]);
+ GC_push_one(info.__r[12]);
+ /* GC_push_one(info.__sp); */
+ GC_push_one(info.__lr);
+ GC_push_one(info.__pc);
+ GC_push_one(info.__cpsr);
+# endif /* !ARM */
}
# if DEBUG_THREADS
GC_printf3("Darwin: Stack for thread 0x%lx = [%lx,%lx)\n",
(unsigned long) hi
);
# endif
- GC_push_all_stack(lo, hi);
+ GC_push_all_stack(lo, hi);
+ mach_port_deallocate(my_task, thread);
} /* for(p=GC_threads[i]...) */
- vm_deallocate(current_task(), (vm_address_t)act_list, sizeof(thread_t) * listcount);
+ vm_deallocate(my_task, (vm_address_t)act_list, sizeof(thread_t) * listcount);
+ mach_port_deallocate(my_task, me);
}
#endif /* !DARWIN_DONT_PARSE_STACK */
static mach_port_t GC_mach_handler_thread;
static int GC_use_mach_handler_thread = 0;
-static struct GC_mach_thread GC_mach_threads[THREAD_TABLE_SZ];
+#define SUSPEND_THREADS_SIZE 2048
+static struct GC_mach_thread GC_mach_threads[SUSPEND_THREADS_SIZE];
static int GC_mach_threads_count;
void GC_stop_init() {
int i;
- for (i = 0; i < THREAD_TABLE_SZ; i++) {
+ for (i = 0; i < SUSPEND_THREADS_SIZE; i++) {
GC_mach_threads[i].thread = 0;
GC_mach_threads[i].already_suspended = 0;
}
}
if (!found) GC_mach_threads_count++;
}
+
+ mach_port_deallocate(current_task(), my_thread);
return changed;
}
{
int i, changes;
GC_thread p;
+ task_t my_task = current_task();
mach_port_t my_thread = mach_thread_self();
kern_return_t kern_result;
thread_act_array_t act_list, prev_list;
prev_list = NULL;
prevcount = 0;
do {
- int result;
- kern_result = task_threads(current_task(), &act_list, &listcount);
- result = GC_suspend_thread_list(act_list, listcount,
- prev_list, prevcount);
- changes = result;
- prev_list = act_list;
- prevcount = listcount;
- vm_deallocate(current_task(), (vm_address_t)act_list, sizeof(thread_t) * listcount);
+ int result;
+ kern_result = task_threads(my_task, &act_list, &listcount);
+
+ if(kern_result == KERN_SUCCESS) {
+ result = GC_suspend_thread_list(act_list, listcount,
+ prev_list, prevcount);
+ changes = result;
+
+ if(prev_list != NULL) {
+ for(i = 0; i < prevcount; i++)
+ mach_port_deallocate(my_task, prev_list[i]);
+
+ vm_deallocate(my_task, (vm_address_t)prev_list, sizeof(thread_t) * prevcount);
+ }
+
+ prev_list = act_list;
+ prevcount = listcount;
+ }
} while (changes);
-
+
+ for(i = 0; i < listcount; i++)
+ mach_port_deallocate(my_task, act_list[i]);
+
+ vm_deallocate(my_task, (vm_address_t)act_list, sizeof(thread_t) * listcount);
+
# ifdef MPROTECT_VDB
if(GC_incremental) {
#if DEBUG_THREADS
GC_printf1("World stopped from 0x%lx\n", my_thread);
#endif
+
+ mach_port_deallocate(my_task, my_thread);
}
/* Caller holds allocation lock, and has held it continuously since */
/* the world stopped. */
void GC_start_world()
{
+ task_t my_task = current_task();
mach_port_t my_thread = mach_thread_self();
int i, j;
GC_thread p;
}
# endif
- kern_result = task_threads(current_task(), &act_list, &listcount);
+ kern_result = task_threads(my_task, &act_list, &listcount);
for(i = 0; i < listcount; i++) {
thread_act_t thread = act_list[i];
if (thread != my_thread &&
}
}
}
+
+ mach_port_deallocate(my_task, thread);
}
- vm_deallocate(current_task(), (vm_address_t)act_list, sizeof(thread_t) * listcount);
+ vm_deallocate(my_task, (vm_address_t)act_list, sizeof(thread_t) * listcount);
+
+ mach_port_deallocate(my_task, my_thread);
# if DEBUG_THREADS
GC_printf0("World started\n");
# endif
GC_use_mach_handler_thread = 1;
}
+#ifdef MONO_DEBUGGER_SUPPORTED
+GCThreadFunctions *gc_thread_vtable = NULL;
+
+void *
+GC_mono_debugger_get_stack_ptr (void)
+{
+ GC_thread me;
+
+ me = GC_lookup_thread (pthread_self ());
+ return &me->stop_info.stack_ptr;
+}
+#endif
+
#endif
projects / mono.git / blobdiff