1//===- Mutex.cpp - Mutual Exclusion Lock ------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the llvm::sys::Mutex class. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/Config/config.h" 15#include "llvm/Support/Mutex.h" 16 17//===----------------------------------------------------------------------===// 18//=== WARNING: Implementation here must contain only TRULY operating system 19//=== independent code. 20//===----------------------------------------------------------------------===// 21 22#if !defined(ENABLE_THREADS) || ENABLE_THREADS == 0 23// Define all methods as no-ops if threading is explicitly disabled 24namespace llvm { 25using namespace sys; 26MutexImpl::MutexImpl( bool recursive) { } 27MutexImpl::~MutexImpl() { } 28bool MutexImpl::acquire() { return true; } 29bool MutexImpl::release() { return true; } 30bool MutexImpl::tryacquire() { return true; } 31} 32#else 33 34#if defined(HAVE_PTHREAD_H) && defined(HAVE_PTHREAD_MUTEX_LOCK) 35 36#include <cassert> 37#include <pthread.h> 38#include <stdlib.h> 39 40namespace llvm { 41using namespace sys; 42 43 44// This variable is useful for situations where the pthread library has been 45// compiled with weak linkage for its interface symbols. This allows the 46// threading support to be turned off by simply not linking against -lpthread. 47// In that situation, the value of pthread_mutex_init will be 0 and 48// consequently pthread_enabled will be false. In such situations, all the 49// pthread operations become no-ops and the functions all return false. If 50// pthread_mutex_init does have an address, then mutex support is enabled. 51// Note: all LLVM tools will link against -lpthread if its available since it 52// is configured into the LIBS variable. 53// Note: this line of code generates a warning if pthread_mutex_init is not 54// declared with weak linkage. It's safe to ignore the warning. 55static const bool pthread_enabled = true; 56 57// Construct a Mutex using pthread calls 58MutexImpl::MutexImpl( bool recursive) 59 : data_(0) 60{ 61 if (pthread_enabled) 62 { 63 // Declare the pthread_mutex data structures 64 pthread_mutex_t* mutex = 65 static_cast<pthread_mutex_t*>(malloc(sizeof(pthread_mutex_t))); 66 pthread_mutexattr_t attr; 67 68 // Initialize the mutex attributes 69 int errorcode = pthread_mutexattr_init(&attr); 70 assert(errorcode == 0); 71 72 // Initialize the mutex as a recursive mutex, if requested, or normal 73 // otherwise. 74 int kind = ( recursive ? PTHREAD_MUTEX_RECURSIVE : PTHREAD_MUTEX_NORMAL ); 75 errorcode = pthread_mutexattr_settype(&attr, kind); 76 assert(errorcode == 0); 77 78#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__) && !defined(__DragonFly__) && !defined(__Fuchsia__) 79 // Make it a process local mutex 80 errorcode = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_PRIVATE); 81 assert(errorcode == 0); 82#endif 83 84 // Initialize the mutex 85 errorcode = pthread_mutex_init(mutex, &attr); 86 assert(errorcode == 0); 87 88 // Destroy the attributes 89 errorcode = pthread_mutexattr_destroy(&attr); 90 assert(errorcode == 0); 91 92 // Assign the data member 93 data_ = mutex; 94 } 95} 96 97// Destruct a Mutex 98MutexImpl::~MutexImpl() 99{ 100 if (pthread_enabled) 101 { 102 pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_); 103 assert(mutex != 0); 104 pthread_mutex_destroy(mutex); 105 free(mutex); 106 } 107} 108 109bool 110MutexImpl::acquire() 111{ 112 if (pthread_enabled) 113 { 114 pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_); 115 assert(mutex != 0); 116 117 int errorcode = pthread_mutex_lock(mutex); 118 return errorcode == 0; 119 } else return false; 120} 121 122bool 123MutexImpl::release() 124{ 125 if (pthread_enabled) 126 { 127 pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_); 128 assert(mutex != 0); 129 130 int errorcode = pthread_mutex_unlock(mutex); 131 return errorcode == 0; 132 } else return false; 133} 134 135bool 136MutexImpl::tryacquire() 137{ 138 if (pthread_enabled) 139 { 140 pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_); 141 assert(mutex != 0); 142 143 int errorcode = pthread_mutex_trylock(mutex); 144 return errorcode == 0; 145 } else return false; 146} 147 148} 149 150#elif defined(LLVM_ON_UNIX) 151#include "Unix/Mutex.inc" 152#elif defined( LLVM_ON_WIN32) 153#include "Windows/Mutex.inc" 154#else 155#warning Neither LLVM_ON_UNIX nor LLVM_ON_WIN32 was set in Support/Mutex.cpp 156#endif 157#endif 158