Mac x86_64: Mach exception support

src/trusted/service_runtime/osx/mach_thread_map.c

+/*
+ * Copyright (c) 2013 The Native Client Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "native_client/src/trusted/service_runtime/osx/mach_thread_map.h"
+
+#include <pthread.h>
+
+#include "native_client/src/shared/platform/nacl_sync.h"
+#include "native_client/src/shared/platform/nacl_sync_checked.h"
+#include "native_client/src/trusted/service_runtime/arch/sel_ldr_arch.h"
+#include "native_client/src/trusted/service_runtime/nacl_globals.h"
+
+#if NACL_ARCH(NACL_BUILD_ARCH) != NACL_x86 || NACL_BUILD_SUBARCH != 32
+
+static struct NaClMutex mach_threads_mu;
+static mach_port_t mach_threads[NACL_THREAD_MAX];
+
+void NaClInitMachThreadMap(void) {
+  NaClXMutexCtor(&mach_threads_mu);
+}
+
+size_t GetNaClThreadIndexForMachThread(mach_port_t mach_thread) {
+  size_t nacl_thread_index;
+
+  NaClXMutexLock(&mach_threads_mu);

[Mark Seaborn, 2013/02/14 00:37:54]

I'd be inclined not to use a lock for this (as on Windows), since the updates
should all be atomic.

Taking a fault is meant to be synchronising so we wouldn't need the memory
barriers implied by lock/unlock either.

[Mark Mentovai, 2013/02/14 19:35:40]

Mark Seaborn wrote:
I’m dropping the lock since this is safe as used here on x86_64.

I don’t see how a fault on one thread results in any synchronization, though.

I guess you’re not concerned about looping through all slots? Presumably faults
happen infrequently enough and code that does handle them doesn’t expect them to
be all that performant.

+  for (nacl_thread_index = 0;
+       nacl_thread_index < NACL_THREAD_MAX;
+       ++nacl_thread_index) {
+    if (mach_threads[nacl_thread_index] == mach_thread) {
+      break;
+    }
+  }
+  NaClXMutexUnlock(&mach_threads_mu);
+
+  return nacl_thread_index == NACL_THREAD_MAX ? 0 : nacl_thread_index;

[Mark Seaborn, 2013/02/14 00:37:54]

Use NACL_TLS_INDEX_INVALID rather than 0

+}
+
+static void SetMachThreadForNaClThreadIndex(mach_port_t mach_thread,
+                                            size_t nacl_thread_index) {
+  NaClXMutexLock(&mach_threads_mu);
+  mach_threads[nacl_thread_index] = mach_thread;
+  NaClXMutexUnlock(&mach_threads_mu);
+}
+
+void SetCurrentMachThreadForNaClThreadIndex(size_t nacl_thread_index) {
+  mach_port_t mach_thread = pthread_mach_thread_np(pthread_self());
+  CHECK(mach_thread != MACH_PORT_NULL);
+  SetMachThreadForNaClThreadIndex(mach_thread, nacl_thread_index);
+}
+
+void ClearMachThreadForNaClThreadIndex(size_t nacl_thread_index) {
+  SetMachThreadForNaClThreadIndex(MACH_PORT_NULL, nacl_thread_index);
+}
+
+#endif