/* Mudflap: narrow-pointer bounds-checking by tree rewriting.
- Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003, 2004, 2005, 2009
+ Free Software Foundation, Inc.
Contributed by Frank Ch. Eigler <fche@redhat.com>
and Graydon Hoare <graydon@redhat.com>
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later
version.
-In addition to the permissions in the GNU General Public License, the
-Free Software Foundation gives you unlimited permission to link the
-compiled version of this file into combinations with other programs,
-and to distribute those combinations without any restriction coming
-from the use of this file. (The General Public License restrictions
-do apply in other respects; for example, they cover modification of
-the file, and distribution when not linked into a combine
-executable.)
-
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
/* Multithreading support hooks. */
-#ifndef HAVE_TLS
+#if !defined(HAVE_TLS) || defined(USE_EMUTLS)
/* We don't have TLS. Ordinarily we could use pthread keys, but since we're
commandeering malloc/free that presents a few problems. The first is that
we'll recurse from __mf_get_state to pthread_setspecific to malloc back to
static struct mf_thread_data mf_thread_data[LIBMUDFLAPTH_THREADS_MAX];
static pthread_mutex_t mf_thread_data_lock = PTHREAD_MUTEX_INITIALIZER;
-/* Try to identify the main thread when filling in mf_thread_data. We
- should always be called at least once from the main thread before
- any new threads are spawned. */
-static int main_seen_p;
-
#define PTHREAD_HASH(p) ((unsigned long) (p) % LIBMUDFLAPTH_THREADS_MAX)
static struct mf_thread_data *
if (data)
return data->state;
- /* The main thread needs to default to active state, so that the global
- constructors are processed in the active state. Child threads should
- be considered to be in the reentrant state, so that we don't wind up
- doing Screwy Things inside the thread library; it'll get reset to
- active state in __mf_pthread_spawner before user code is invoked.
+ /* If we've never seen this thread before, consider it to be in the
+ reentrant state. The state gets reset to active for the main thread
+ in __mf_init, and for child threads in __mf_pthread_spawner.
The trickiest bit here is that the LinuxThreads pthread_manager thread
should *always* be considered to be reentrant, so that none of our
stuff isn't initialized, leading to SEGV very quickly. Even calling
pthread_self is a bit suspect, but it happens to work. */
- if (main_seen_p)
- return reentrant;
- else
- {
- main_seen_p = 1;
- data = __mf_find_threadinfo (1);
- data->state = active;
- return active;
- }
+ return reentrant;
}
void
if (__mf_opts.heur_std_data)
__mf_unregister (&errno, sizeof (errno), __MF_TYPE_GUESS);
-#ifndef HAVE_TLS
+#if !defined(HAVE_TLS) || defined(USE_EMUTLS)
struct mf_thread_data *data = __mf_find_threadinfo (0);
if (data)
data->used_p = 0;
{
void *result = NULL;
-#ifndef HAVE_TLS
__mf_set_state (active);
-#endif
/* NB: We could use __MF_TYPE_STATIC here, but we guess that the thread
errno is coming out of some dynamically allocated pool that we already
WRAPPER(int, pthread_create, pthread_t *thr, const pthread_attr_t *attr,
void * (*start) (void *), void *arg)
{
- int result, need_wrapper = 0;
+ struct mf_thread_start_info *si;
TRACE ("pthread_create\n");
-#ifndef HAVE_TLS
- need_wrapper = 1;
-#endif
- need_wrapper |= __mf_opts.heur_std_data != 0;
+ /* Fill in startup-control fields. */
+ si = CALL_REAL (malloc, sizeof (*si));
+ si->user_fn = start;
+ si->user_arg = arg;
- if (need_wrapper)
- {
- struct mf_thread_start_info *si = CALL_REAL (malloc, sizeof (*si));
-
- /* Fill in startup-control fields. */
- si->user_fn = start;
- si->user_arg = arg;
-
- /* Actually create the thread. */
- result = CALL_REAL (pthread_create, thr, attr, __mf_pthread_spawner, si);
- }
- else
- {
- /* If we're not handling heur_std_data, nothing special to do. */
- result = CALL_REAL (pthread_create, thr, attr, start, arg);
- }
-
- return result;
+ /* Actually create the thread. */
+ return CALL_REAL (pthread_create, thr, attr, __mf_pthread_spawner, si);
}
OSDN Git Service
