blob: 3a26224d7fb69fb20ad94048faeeadf0cb6189d2 [file] [log] [blame]
/* Mudflap: narrow-pointer bounds-checking by tree rewriting.
Copyright (C) 2002, 2003, 2004, 2005, 2009, 2011
Free Software Foundation, Inc.
Contributed by Frank Ch. Eigler <>
and Graydon Hoare <>
This file is part of GCC.
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 3, or (at your option) any later
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
for more details.
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
<>. */
#include "config.h"
#define socklen_t int
/* These attempt to coax various unix flavours to declare all our
needed tidbits in the system headers. */
#if !defined(__FreeBSD__) && !defined(__APPLE__)
#endif /* Some BSDs break <sys/socket.h> if this is defined. */
#define _GNU_SOURCE
#define _BSD_TYPES
#define __EXTENSIONS__
#define _ALL_SOURCE
#define _REENTRANT
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <errno.h>
#include <stdbool.h>
#include "mf-runtime.h"
#include "mf-impl.h"
#ifdef _MUDFLAP
#error "Do not compile this file with -fmudflap!"
#error "pthreadstuff is to be included only in libmudflapth"
/* ??? Why isn't this done once in the header files. */
DECLARE(void *, malloc, size_t sz);
DECLARE(void, free, void *ptr);
DECLARE(int, pthread_create, pthread_t *thr, const pthread_attr_t *attr,
void * (*start) (void *), void *arg);
/* Multithreading support hooks. */
#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
__mf_get_state during thread startup. This can be solved with clever uses
of a mutex. The second problem is that thread shutdown is indistinguishable
from thread startup, since libpthread is deallocating our state variable.
I've no good solution for this.
Which leaves us to handle this mess by totally by hand. */
/* Yes, we want this prime. If pthread_t is a pointer, it's almost always
page aligned, and if we use a smaller power of 2, this results in "%N"
being the worst possible hash -- all threads hash to zero. */
struct mf_thread_data
pthread_t self;
unsigned char used_p;
unsigned char state;
static struct mf_thread_data mf_thread_data[LIBMUDFLAPTH_THREADS_MAX];
static pthread_mutex_t mf_thread_data_lock = PTHREAD_MUTEX_INITIALIZER;
#define PTHREAD_HASH(p) ((unsigned long) (p) % LIBMUDFLAPTH_THREADS_MAX)
static struct mf_thread_data *
__mf_find_threadinfo (int alloc)
pthread_t self = pthread_self ();
unsigned long hash = PTHREAD_HASH (self);
unsigned long rehash;
#ifdef __alpha__
/* Alpha has the loosest memory ordering rules of all. We need a memory
barrier to flush the reorder buffer before considering a *read* of a
shared variable. Since we're not always taking a lock, we have to do
this by hand. */
__sync_synchronize ();
rehash = hash;
while (1)
if (mf_thread_data[rehash].used_p && mf_thread_data[rehash].self == self)
return &mf_thread_data[rehash];
rehash += 7;
if (rehash == hash)
if (alloc)
pthread_mutex_lock (&mf_thread_data_lock);
rehash = hash;
while (1)
if (!mf_thread_data[rehash].used_p)
mf_thread_data[rehash].self = self;
__sync_synchronize ();
mf_thread_data[rehash].used_p = 1;
pthread_mutex_unlock (&mf_thread_data_lock);
return &mf_thread_data[rehash];
rehash += 7;
if (rehash == hash)
pthread_mutex_unlock (&mf_thread_data_lock);
return NULL;
enum __mf_state_enum
__mf_get_state (void)
struct mf_thread_data *data = __mf_find_threadinfo (0);
if (data)
return data->state;
/* 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
hooks actually do anything. Why? Because that thread isn't a real
thread from the point of view of the thread library, and so lots of
stuff isn't initialized, leading to SEGV very quickly. Even calling
pthread_self is a bit suspect, but it happens to work. */
return reentrant;
__mf_set_state (enum __mf_state_enum new_state)
struct mf_thread_data *data = __mf_find_threadinfo (1);
data->state = new_state;
/* The following two functions are used only with __mf_opts.heur_std_data.
We're interested in recording the location of the thread-local errno
Note that this doesn't handle TLS references in general; we have no
visibility into __tls_get_data for when that memory is allocated at
runtime. Hopefully we get to see the malloc or mmap operation that
eventually allocates the backing store. */
/* Describe the startup information for a new user thread. */
struct mf_thread_start_info
/* The user's thread entry point and argument. */
void * (*user_fn)(void *);
void *user_arg;
static void
__mf_pthread_cleanup (void *arg)
if (__mf_opts.heur_std_data)
__mf_unregister (&errno, sizeof (errno), __MF_TYPE_GUESS);
#if !defined(HAVE_TLS) || defined(USE_EMUTLS)
struct mf_thread_data *data = __mf_find_threadinfo (0);
if (data)
data->used_p = 0;
static void *
__mf_pthread_spawner (void *arg)
void *result = NULL;
__mf_set_state (active);
/* 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
know of as __MF_TYPE_HEAP. */
if (__mf_opts.heur_std_data)
__mf_register (&errno, sizeof (errno), __MF_TYPE_GUESS,
"errno area (thread)");
/* We considered using pthread_key_t objects instead of these
cleanup stacks, but they were less cooperative with the
interposed malloc hooks in libmudflap. */
/* ??? The pthread_key_t problem is solved above... */
pthread_cleanup_push (__mf_pthread_cleanup, NULL);
/* Extract given entry point and argument. */
struct mf_thread_start_info *psi = arg;
void * (*user_fn)(void *) = psi->user_fn;
void *user_arg = psi->user_arg;
CALL_REAL (free, arg);
result = (*user_fn)(user_arg);
pthread_cleanup_pop (1 /* execute */);
return result;
#if PIC
/* A special bootstrap variant. */
__mf_0fn_pthread_create (pthread_t *thr, const pthread_attr_t *attr,
void * (*start) (void *), void *arg)
return -1;
#undef pthread_create
WRAPPER(int, pthread_create, pthread_t *thr, const pthread_attr_t *attr,
void * (*start) (void *), void *arg)
struct mf_thread_start_info *si;
TRACE ("pthread_create\n");
/* Fill in startup-control fields. */
si = CALL_REAL (malloc, sizeof (*si));
si->user_fn = start;
si->user_arg = arg;
/* Actually create the thread. */
return CALL_REAL (pthread_create, thr, attr, __mf_pthread_spawner, si);