Lock abstraction, introduced with a view toward making the JIT thread-safe.

Eventually.

llvm-svn: 10284

llvm/include/Support/ThreadSupport-PThreads.h

@@ -0,0 +1,69 @@
+//===-- Support/Lock.h - Platform-agnostic mutual exclusion -----*- C++ -*-===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
+//
+// This file contains classes that implement locks (mutual exclusion
+// variables) in a platform-agnostic way. Basically the user should
+// just call Lock::create() to get a Lock object of the correct sort
+// for the current platform, and use its acquire() and release()
+// methods, or a LockHolder, to protect critical sections of code for
+// thread-safety.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUPPORT_LOCK_H
+#define SUPPORT_LOCK_H
+
+#include <pthread.h>
+#include <cstdlib>
+
+namespace llvm {
+
+/// Lock - Abstract class that provides mutual exclusion (also known
+/// as a mutex.)
+///
+class Lock {
+protected:
+  virtual ~Lock() {}                        // Derive from me
+public:
+  virtual void acquire () { abort (); }
+  virtual void release () { abort (); }
+
+  /// create - Static method that returns a Lock of the correct class
+  /// for the current host OS.
+  ///
+  static Lock create ();
+};
+
+/// POSIXLock - Specialization of Lock class implemented using
+/// pthread_mutex_t objects.
+///
+class POSIXLock : public Lock {
+  pthread_mutex_t mutex;
+public:
+  POSIXLock () { pthread_mutex_init (&mutex, 0); }
+  virtual ~POSIXLock () { pthread_mutex_destroy (&mutex); }
+  virtual void acquire () { pthread_mutex_lock (&mutex); }
+  virtual void release () { pthread_mutex_unlock (&mutex); }
+};
+
+/// LockHolder - Instances of this class acquire a given Lock when
+/// constructed and hold that lock until destruction.  Uncle Bjarne
+/// says, "Resource acquisition is allocation." Or is it the other way
+/// around? I never can remember.
+///
+class LockHolder {
+  Lock &L;
+public:
+  LockHolder (Lock &_L) : L (_L) { L.acquire (); }
+  ~LockHolder () { L.release (); }
+};
+
+} // end namespace llvm
+
+#endif // SUPPORT_LOCK_H

llvm/lib/Support/Mutex.cpp

@@ -0,0 +1,24 @@
+//===-- Support/Lock.cpp - Platform-agnostic mutual exclusion -------------===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
+//
+// Implementation of various methods supporting platform-agnostic lock
+// abstraction. See Support/Lock.h for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Support/Lock.h"
+
+using namespace llvm;
+
+Lock Lock::create () {
+  // Currently we only support creating POSIX pthread_mutex_t locks.
+  // In the future we might want to construct different kinds of locks
+  // based on what OS is running.
+  return POSIXLock ();
+}