6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-08-09 11:25:55 +00:00
Code Issues Projects Releases Wiki Activity

Remove dead code.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@148206 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
David Blaikie
2012-01-15 01:09:13 +00:00
parent 799ea5ccc0
commit 49c0a9ac98
2 changed files with 70 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
lib/Support/Mutex.cpp
View File

@@ -40,109 +40,80 @@ bool MutexImpl::tryacquire() { return true; }
namespace llvm { namespace llvm {
using namespace sys; using namespace sys;
// This variable is useful for situations where the pthread library has been
// compiled with weak linkage for its interface symbols. This allows the
// threading support to be turned off by simply not linking against -lpthread.
// In that situation, the value of pthread_mutex_init will be 0 and
// consequently pthread_enabled will be false. In such situations, all the
// pthread operations become no-ops and the functions all return false. If
// pthread_mutex_init does have an address, then mutex support is enabled.
// Note: all LLVM tools will link against -lpthread if its available since it
// is configured into the LIBS variable.
// Note: this line of code generates a warning if pthread_mutex_init is not
// declared with weak linkage. It's safe to ignore the warning.
static const bool pthread_enabled = true;
// Construct a Mutex using pthread calls // Construct a Mutex using pthread calls
MutexImpl::MutexImpl( bool recursive) MutexImpl::MutexImpl( bool recursive)
: data_(0) : data_(0)
{ {
if (pthread_enabled) // Declare the pthread_mutex data structures
{ pthread_mutex_t* mutex =
// Declare the pthread_mutex data structures static_cast<pthread_mutex_t*>(malloc(sizeof(pthread_mutex_t)));
pthread_mutex_t* mutex = pthread_mutexattr_t attr;
static_cast<pthread_mutex_t*>(malloc(sizeof(pthread_mutex_t)));
pthread_mutexattr_t attr;
// Initialize the mutex attributes // Initialize the mutex attributes
int errorcode = pthread_mutexattr_init(&attr); int errorcode = pthread_mutexattr_init(&attr);
assert(errorcode == 0); assert(errorcode == 0);
// Initialize the mutex as a recursive mutex, if requested, or normal // Initialize the mutex as a recursive mutex, if requested, or normal
// otherwise. // otherwise.
int kind = ( recursive ? PTHREAD_MUTEX_RECURSIVE : PTHREAD_MUTEX_NORMAL ); int kind = ( recursive ? PTHREAD_MUTEX_RECURSIVE : PTHREAD_MUTEX_NORMAL );
errorcode = pthread_mutexattr_settype(&attr, kind); errorcode = pthread_mutexattr_settype(&attr, kind);
assert(errorcode == 0); assert(errorcode == 0);
#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__) && !defined(__DragonFly__) #if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__) && !defined(__DragonFly__)
// Make it a process local mutex // Make it a process local mutex
errorcode = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_PRIVATE); errorcode = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_PRIVATE);
assert(errorcode == 0); assert(errorcode == 0);
#endif #endif
// Initialize the mutex // Initialize the mutex
errorcode = pthread_mutex_init(mutex, &attr); errorcode = pthread_mutex_init(mutex, &attr);
assert(errorcode == 0); assert(errorcode == 0);
// Destroy the attributes // Destroy the attributes
errorcode = pthread_mutexattr_destroy(&attr); errorcode = pthread_mutexattr_destroy(&attr);
assert(errorcode == 0); assert(errorcode == 0);
// Assign the data member // Assign the data member
data_ = mutex; data_ = mutex;
}
} }
// Destruct a Mutex // Destruct a Mutex
MutexImpl::~MutexImpl() MutexImpl::~MutexImpl()
{ {
if (pthread_enabled) pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
{ assert(mutex != 0);
pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_); pthread_mutex_destroy(mutex);
assert(mutex != 0); free(mutex);
pthread_mutex_destroy(mutex);
free(mutex);
}
} }
bool bool
MutexImpl::acquire() MutexImpl::acquire()
{ {
if (pthread_enabled) pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
{ assert(mutex != 0);
pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
assert(mutex != 0);
int errorcode = pthread_mutex_lock(mutex); int errorcode = pthread_mutex_lock(mutex);
return errorcode == 0; return errorcode == 0;
} else return false;
} }
bool bool
MutexImpl::release() MutexImpl::release()
{ {
if (pthread_enabled) pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
{ assert(mutex != 0);
pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
assert(mutex != 0);
int errorcode = pthread_mutex_unlock(mutex); int errorcode = pthread_mutex_unlock(mutex);
return errorcode == 0; return errorcode == 0;
} else return false;
} }
bool bool
MutexImpl::tryacquire() MutexImpl::tryacquire()
{ {
if (pthread_enabled) pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
{ assert(mutex != 0);
pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
assert(mutex != 0);
int errorcode = pthread_mutex_trylock(mutex); int errorcode = pthread_mutex_trylock(mutex);
return errorcode == 0; return errorcode == 0;
} else return false;
} }
} }

94
lib/Support/RWMutex.cpp
View File

@@ -42,107 +42,75 @@ bool RWMutexImpl::writer_release() { return true; }
namespace llvm { namespace llvm {
using namespace sys; using namespace sys;
// This variable is useful for situations where the pthread library has been
// compiled with weak linkage for its interface symbols. This allows the
// threading support to be turned off by simply not linking against -lpthread.
// In that situation, the value of pthread_mutex_init will be 0 and
// consequently pthread_enabled will be false. In such situations, all the
// pthread operations become no-ops and the functions all return false. If
// pthread_rwlock_init does have an address, then rwlock support is enabled.
// Note: all LLVM tools will link against -lpthread if its available since it
// is configured into the LIBS variable.
// Note: this line of code generates a warning if pthread_rwlock_init is not
// declared with weak linkage. It's safe to ignore the warning.
static const bool pthread_enabled = true;
// Construct a RWMutex using pthread calls // Construct a RWMutex using pthread calls
RWMutexImpl::RWMutexImpl() RWMutexImpl::RWMutexImpl()
: data_(0) : data_(0)
{ {
if (pthread_enabled) // Declare the pthread_rwlock data structures
{ pthread_rwlock_t* rwlock =
// Declare the pthread_rwlock data structures static_cast<pthread_rwlock_t*>(malloc(sizeof(pthread_rwlock_t)));
pthread_rwlock_t* rwlock =
static_cast<pthread_rwlock_t*>(malloc(sizeof(pthread_rwlock_t)));
#ifdef __APPLE__ #ifdef __APPLE__
// Workaround a bug/mis-feature in Darwin's pthread_rwlock_init. // Workaround a bug/mis-feature in Darwin's pthread_rwlock_init.
bzero(rwlock, sizeof(pthread_rwlock_t)); bzero(rwlock, sizeof(pthread_rwlock_t));
#endif #endif
// Initialize the rwlock // Initialize the rwlock
int errorcode = pthread_rwlock_init(rwlock, NULL); int errorcode = pthread_rwlock_init(rwlock, NULL);
(void)errorcode; (void)errorcode;
assert(errorcode == 0); assert(errorcode == 0);
// Assign the data member // Assign the data member
data_ = rwlock; data_ = rwlock;
}
} }
// Destruct a RWMutex // Destruct a RWMutex
RWMutexImpl::~RWMutexImpl() RWMutexImpl::~RWMutexImpl()
{ {
if (pthread_enabled) pthread_rwlock_t* rwlock = static_cast<pthread_rwlock_t*>(data_);
{ assert(rwlock != 0);
pthread_rwlock_t* rwlock = static_cast<pthread_rwlock_t*>(data_); pthread_rwlock_destroy(rwlock);
assert(rwlock != 0); free(rwlock);
pthread_rwlock_destroy(rwlock);
free(rwlock);
}
} }
bool bool
RWMutexImpl::reader_acquire() RWMutexImpl::reader_acquire()
{ {
if (pthread_enabled) pthread_rwlock_t* rwlock = static_cast<pthread_rwlock_t*>(data_);
{ assert(rwlock != 0);
pthread_rwlock_t* rwlock = static_cast<pthread_rwlock_t*>(data_);
assert(rwlock != 0);
int errorcode = pthread_rwlock_rdlock(rwlock); int errorcode = pthread_rwlock_rdlock(rwlock);
return errorcode == 0; return errorcode == 0;
} else return false;
} }
bool bool
RWMutexImpl::reader_release() RWMutexImpl::reader_release()
{ {
if (pthread_enabled) pthread_rwlock_t* rwlock = static_cast<pthread_rwlock_t*>(data_);
{ assert(rwlock != 0);
pthread_rwlock_t* rwlock = static_cast<pthread_rwlock_t*>(data_);
assert(rwlock != 0);
int errorcode = pthread_rwlock_unlock(rwlock); int errorcode = pthread_rwlock_unlock(rwlock);
return errorcode == 0; return errorcode == 0;
} else return false;
} }
bool bool
RWMutexImpl::writer_acquire() RWMutexImpl::writer_acquire()
{ {
if (pthread_enabled) pthread_rwlock_t* rwlock = static_cast<pthread_rwlock_t*>(data_);
{ assert(rwlock != 0);
pthread_rwlock_t* rwlock = static_cast<pthread_rwlock_t*>(data_);
assert(rwlock != 0);
int errorcode = pthread_rwlock_wrlock(rwlock); int errorcode = pthread_rwlock_wrlock(rwlock);
return errorcode == 0; return errorcode == 0;
} else return false;
} }
bool bool
RWMutexImpl::writer_release() RWMutexImpl::writer_release()
{ {
if (pthread_enabled) pthread_rwlock_t* rwlock = static_cast<pthread_rwlock_t*>(data_);
{ assert(rwlock != 0);
pthread_rwlock_t* rwlock = static_cast<pthread_rwlock_t*>(data_);
assert(rwlock != 0);
int errorcode = pthread_rwlock_unlock(rwlock); int errorcode = pthread_rwlock_unlock(rwlock);
return errorcode == 0; return errorcode == 0;
} else return false;
} }
} }