obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

23 files changed, 939 insertions, 0 deletions

diff --git a/libjava/java/util/concurrent/locks/AbstractOwnableSynchronizer.h b/libjava/java/util/concurrent/locks/AbstractOwnableSynchronizer.h
new file mode 100644
index 000000000..8a14257c9
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/AbstractOwnableSynchronizer.h
@@ -0,0 +1,25 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_AbstractOwnableSynchronizer__
+#define __java_util_concurrent_locks_AbstractOwnableSynchronizer__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::AbstractOwnableSynchronizer : public ::java::lang::Object
+{
+
+public: // actually protected
+  AbstractOwnableSynchronizer();
+  virtual void setExclusiveOwnerThread(::java::lang::Thread *);
+  virtual ::java::lang::Thread * getExclusiveOwnerThread();
+private:
+  static const jlong serialVersionUID = 3737899427754241961LL;
+  ::java::lang::Thread * __attribute__((aligned(__alignof__( ::java::lang::Object)))) exclusiveOwnerThread;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_AbstractOwnableSynchronizer__
diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$ConditionObject.h b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$ConditionObject.h
new file mode 100644
index 000000000..123ab81b5
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$ConditionObject.h
@@ -0,0 +1,52 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$ConditionObject__
+#define __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$ConditionObject__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::AbstractQueuedLongSynchronizer$ConditionObject : public ::java::lang::Object
+{
+
+public:
+  AbstractQueuedLongSynchronizer$ConditionObject(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer *);
+private:
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * addConditionWaiter();
+  void doSignal(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  void doSignalAll(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  jboolean isOnConditionQueue(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  void unlinkCancelledWaiter(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+public:
+  virtual void signal();
+  virtual void signalAll();
+  virtual void awaitUninterruptibly();
+private:
+  jint checkInterruptWhileWaiting(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  void reportInterruptAfterWait(jint);
+public:
+  virtual void await();
+  virtual jlong awaitNanos(jlong);
+  virtual jboolean awaitUntil(::java::util::Date *);
+  virtual jboolean await(jlong, ::java::util::concurrent::TimeUnit *);
+public: // actually package-private
+  virtual jboolean isOwnedBy(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer *);
+public: // actually protected
+  virtual jboolean hasWaiters();
+  virtual jint getWaitQueueLength();
+  virtual ::java::util::Collection * getWaitingThreads();
+private:
+  static const jlong serialVersionUID = 1173984872572414699LL;
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * __attribute__((aligned(__alignof__( ::java::lang::Object)))) firstWaiter;
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * lastWaiter;
+  static const jint REINTERRUPT = 1;
+  static const jint THROW_IE = -1;
+public: // actually package-private
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer * this$0;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$ConditionObject__
diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$Node.h b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$Node.h
new file mode 100644
index 000000000..097692062
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer$Node.h
@@ -0,0 +1,34 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$Node__
+#define __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$Node__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node : public ::java::lang::Object
+{
+
+public: // actually package-private
+  jboolean isShared();
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * predecessor();
+  AbstractQueuedLongSynchronizer$Node();
+  AbstractQueuedLongSynchronizer$Node(::java::lang::Thread *, ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  AbstractQueuedLongSynchronizer$Node(::java::lang::Thread *, jint);
+  static const jint CANCELLED = 1;
+  static const jint SIGNAL = -1;
+  static const jint CONDITION = -2;
+  static ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * SHARED;
+  static ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * EXCLUSIVE;
+  jint volatile __attribute__((aligned(__alignof__( ::java::lang::Object)))) waitStatus;
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * volatile prev;
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * volatile next;
+  ::java::lang::Thread * volatile thread;
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * nextWaiter;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_AbstractQueuedLongSynchronizer$Node__
diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.h b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.h
new file mode 100644
index 000000000..41f1f7cba
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.h
@@ -0,0 +1,115 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_AbstractQueuedLongSynchronizer__
+#define __java_util_concurrent_locks_AbstractQueuedLongSynchronizer__
+
+#pragma interface
+
+#include <java/util/concurrent/locks/AbstractOwnableSynchronizer.h>
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::locks::AbstractQueuedLongSynchronizer : public ::java::util::concurrent::locks::AbstractOwnableSynchronizer
+{
+
+public: // actually protected
+  AbstractQueuedLongSynchronizer();
+  virtual jlong getState();
+  virtual void setState(jlong);
+  virtual jboolean compareAndSetState(jlong, jlong);
+private:
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * enq(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * addWaiter(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  void setHead(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  void unparkSuccessor(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  void setHeadAndPropagate(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *, jlong);
+  void cancelAcquire(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  static jboolean shouldParkAfterFailedAcquire(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *, ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  static void selfInterrupt();
+  jboolean parkAndCheckInterrupt();
+public: // actually package-private
+  virtual jboolean acquireQueued(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *, jlong);
+private:
+  void doAcquireInterruptibly(jlong);
+  jboolean doAcquireNanos(jlong, jlong);
+  void doAcquireShared(jlong);
+  void doAcquireSharedInterruptibly(jlong);
+  jboolean doAcquireSharedNanos(jlong, jlong);
+public: // actually protected
+  virtual jboolean tryAcquire(jlong);
+  virtual jboolean tryRelease(jlong);
+  virtual jlong tryAcquireShared(jlong);
+  virtual jboolean tryReleaseShared(jlong);
+  virtual jboolean isHeldExclusively();
+public:
+  virtual void acquire(jlong);
+  virtual void acquireInterruptibly(jlong);
+  virtual jboolean tryAcquireNanos(jlong, jlong);
+  virtual jboolean release(jlong);
+  virtual void acquireShared(jlong);
+  virtual void acquireSharedInterruptibly(jlong);
+  virtual jboolean tryAcquireSharedNanos(jlong, jlong);
+  virtual jboolean releaseShared(jlong);
+  virtual jboolean hasQueuedThreads();
+  virtual jboolean hasContended();
+  virtual ::java::lang::Thread * getFirstQueuedThread();
+private:
+  ::java::lang::Thread * fullGetFirstQueuedThread();
+public:
+  virtual jboolean isQueued(::java::lang::Thread *);
+public: // actually package-private
+  virtual jboolean apparentlyFirstQueuedIsExclusive();
+  virtual jboolean isFirst(::java::lang::Thread *);
+  virtual jboolean fullIsFirst(::java::lang::Thread *);
+public:
+  virtual jint getQueueLength();
+  virtual ::java::util::Collection * getQueuedThreads();
+  virtual ::java::util::Collection * getExclusiveQueuedThreads();
+  virtual ::java::util::Collection * getSharedQueuedThreads();
+  virtual ::java::lang::String * toString();
+public: // actually package-private
+  virtual jboolean isOnSyncQueue(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+private:
+  jboolean findNodeFromTail(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+public: // actually package-private
+  virtual jboolean transferForSignal(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  virtual jboolean transferAfterCancelledWait(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  virtual jlong fullyRelease(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+public:
+  virtual jboolean owns(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$ConditionObject *);
+  virtual jboolean hasWaiters(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$ConditionObject *);
+  virtual jint getWaitQueueLength(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$ConditionObject *);
+  virtual ::java::util::Collection * getWaitingThreads(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$ConditionObject *);
+private:
+  jboolean compareAndSetHead(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  jboolean compareAndSetTail(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *, ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *);
+  static jboolean compareAndSetWaitStatus(::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node *, jint, jint);
+public: // actually package-private
+  static void access$0();
+private:
+  static const jlong serialVersionUID = 7373984972572414692LL;
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * volatile __attribute__((aligned(__alignof__( ::java::util::concurrent::locks::AbstractOwnableSynchronizer)))) head;
+  ::java::util::concurrent::locks::AbstractQueuedLongSynchronizer$Node * volatile tail;
+  jlong volatile state;
+public: // actually package-private
+  static const jlong spinForTimeoutThreshold = 1000LL;
+private:
+  static ::sun::misc::Unsafe * unsafe;
+  static jlong stateOffset;
+  static jlong headOffset;
+  static jlong tailOffset;
+  static jlong waitStatusOffset;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_AbstractQueuedLongSynchronizer__
diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$ConditionObject.h b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$ConditionObject.h
new file mode 100644
index 000000000..67ca64f6e
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$ConditionObject.h
@@ -0,0 +1,52 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_AbstractQueuedSynchronizer$ConditionObject__
+#define __java_util_concurrent_locks_AbstractQueuedSynchronizer$ConditionObject__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject : public ::java::lang::Object
+{
+
+public:
+  AbstractQueuedSynchronizer$ConditionObject(::java::util::concurrent::locks::AbstractQueuedSynchronizer *);
+private:
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * addConditionWaiter();
+  void doSignal(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  void doSignalAll(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  jboolean isOnConditionQueue(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  void unlinkCancelledWaiter(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+public:
+  virtual void signal();
+  virtual void signalAll();
+  virtual void awaitUninterruptibly();
+private:
+  jint checkInterruptWhileWaiting(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  void reportInterruptAfterWait(jint);
+public:
+  virtual void await();
+  virtual jlong awaitNanos(jlong);
+  virtual jboolean awaitUntil(::java::util::Date *);
+  virtual jboolean await(jlong, ::java::util::concurrent::TimeUnit *);
+public: // actually package-private
+  virtual jboolean isOwnedBy(::java::util::concurrent::locks::AbstractQueuedSynchronizer *);
+public: // actually protected
+  virtual jboolean hasWaiters();
+  virtual jint getWaitQueueLength();
+  virtual ::java::util::Collection * getWaitingThreads();
+private:
+  static const jlong serialVersionUID = 1173984872572414699LL;
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * __attribute__((aligned(__alignof__( ::java::lang::Object)))) firstWaiter;
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * lastWaiter;
+  static const jint REINTERRUPT = 1;
+  static const jint THROW_IE = -1;
+public: // actually package-private
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer * this$0;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_AbstractQueuedSynchronizer$ConditionObject__
diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$Node.h b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$Node.h
new file mode 100644
index 000000000..cc4955057
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer$Node.h
@@ -0,0 +1,34 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_AbstractQueuedSynchronizer$Node__
+#define __java_util_concurrent_locks_AbstractQueuedSynchronizer$Node__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::AbstractQueuedSynchronizer$Node : public ::java::lang::Object
+{
+
+public: // actually package-private
+  jboolean isShared();
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * predecessor();
+  AbstractQueuedSynchronizer$Node();
+  AbstractQueuedSynchronizer$Node(::java::lang::Thread *, ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  AbstractQueuedSynchronizer$Node(::java::lang::Thread *, jint);
+  static const jint CANCELLED = 1;
+  static const jint SIGNAL = -1;
+  static const jint CONDITION = -2;
+  static ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * SHARED;
+  static ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * EXCLUSIVE;
+  jint volatile __attribute__((aligned(__alignof__( ::java::lang::Object)))) waitStatus;
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * volatile prev;
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * volatile next;
+  ::java::lang::Thread * volatile thread;
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * nextWaiter;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_AbstractQueuedSynchronizer$Node__
diff --git a/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer.h b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer.h
new file mode 100644
index 000000000..e50fcef61
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/AbstractQueuedSynchronizer.h
@@ -0,0 +1,115 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_AbstractQueuedSynchronizer__
+#define __java_util_concurrent_locks_AbstractQueuedSynchronizer__
+
+#pragma interface
+
+#include <java/util/concurrent/locks/AbstractOwnableSynchronizer.h>
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::locks::AbstractQueuedSynchronizer : public ::java::util::concurrent::locks::AbstractOwnableSynchronizer
+{
+
+public: // actually protected
+  AbstractQueuedSynchronizer();
+  virtual jint getState();
+  virtual void setState(jint);
+  virtual jboolean compareAndSetState(jint, jint);
+private:
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * enq(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * addWaiter(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  void setHead(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  void unparkSuccessor(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  void setHeadAndPropagate(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *, jint);
+  void cancelAcquire(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  static jboolean shouldParkAfterFailedAcquire(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *, ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  static void selfInterrupt();
+  jboolean parkAndCheckInterrupt();
+public: // actually package-private
+  virtual jboolean acquireQueued(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *, jint);
+private:
+  void doAcquireInterruptibly(jint);
+  jboolean doAcquireNanos(jint, jlong);
+  void doAcquireShared(jint);
+  void doAcquireSharedInterruptibly(jint);
+  jboolean doAcquireSharedNanos(jint, jlong);
+public: // actually protected
+  virtual jboolean tryAcquire(jint);
+  virtual jboolean tryRelease(jint);
+  virtual jint tryAcquireShared(jint);
+  virtual jboolean tryReleaseShared(jint);
+  virtual jboolean isHeldExclusively();
+public:
+  virtual void acquire(jint);
+  virtual void acquireInterruptibly(jint);
+  virtual jboolean tryAcquireNanos(jint, jlong);
+  virtual jboolean release(jint);
+  virtual void acquireShared(jint);
+  virtual void acquireSharedInterruptibly(jint);
+  virtual jboolean tryAcquireSharedNanos(jint, jlong);
+  virtual jboolean releaseShared(jint);
+  virtual jboolean hasQueuedThreads();
+  virtual jboolean hasContended();
+  virtual ::java::lang::Thread * getFirstQueuedThread();
+private:
+  ::java::lang::Thread * fullGetFirstQueuedThread();
+public:
+  virtual jboolean isQueued(::java::lang::Thread *);
+public: // actually package-private
+  virtual jboolean apparentlyFirstQueuedIsExclusive();
+  virtual jboolean isFirst(::java::lang::Thread *);
+  virtual jboolean fullIsFirst(::java::lang::Thread *);
+public:
+  virtual jint getQueueLength();
+  virtual ::java::util::Collection * getQueuedThreads();
+  virtual ::java::util::Collection * getExclusiveQueuedThreads();
+  virtual ::java::util::Collection * getSharedQueuedThreads();
+  virtual ::java::lang::String * toString();
+public: // actually package-private
+  virtual jboolean isOnSyncQueue(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+private:
+  jboolean findNodeFromTail(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+public: // actually package-private
+  virtual jboolean transferForSignal(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  virtual jboolean transferAfterCancelledWait(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  virtual jint fullyRelease(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+public:
+  virtual jboolean owns(::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject *);
+  virtual jboolean hasWaiters(::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject *);
+  virtual jint getWaitQueueLength(::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject *);
+  virtual ::java::util::Collection * getWaitingThreads(::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject *);
+private:
+  jboolean compareAndSetHead(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  jboolean compareAndSetTail(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *, ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *);
+  static jboolean compareAndSetWaitStatus(::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node *, jint, jint);
+public: // actually package-private
+  static void access$0();
+private:
+  static const jlong serialVersionUID = 7373984972572414691LL;
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * volatile __attribute__((aligned(__alignof__( ::java::util::concurrent::locks::AbstractOwnableSynchronizer)))) head;
+  ::java::util::concurrent::locks::AbstractQueuedSynchronizer$Node * volatile tail;
+  jint volatile state;
+public: // actually package-private
+  static const jlong spinForTimeoutThreshold = 1000LL;
+private:
+  static ::sun::misc::Unsafe * unsafe;
+  static jlong stateOffset;
+  static jlong headOffset;
+  static jlong tailOffset;
+  static jlong waitStatusOffset;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_AbstractQueuedSynchronizer__
diff --git a/libjava/java/util/concurrent/locks/Condition.h b/libjava/java/util/concurrent/locks/Condition.h
new file mode 100644
index 000000000..141a4e919
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/Condition.h
@@ -0,0 +1,25 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_Condition__
+#define __java_util_concurrent_locks_Condition__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::Condition : public ::java::lang::Object
+{
+
+public:
+  virtual void await() = 0;
+  virtual void awaitUninterruptibly() = 0;
+  virtual jlong awaitNanos(jlong) = 0;
+  virtual jboolean await(jlong, ::java::util::concurrent::TimeUnit *) = 0;
+  virtual jboolean awaitUntil(::java::util::Date *) = 0;
+  virtual void signal() = 0;
+  virtual void signalAll() = 0;
+  static ::java::lang::Class class$;
+} __attribute__ ((java_interface));
+
+#endif // __java_util_concurrent_locks_Condition__
diff --git a/libjava/java/util/concurrent/locks/Lock.h b/libjava/java/util/concurrent/locks/Lock.h
new file mode 100644
index 000000000..b00f601e7
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/Lock.h
@@ -0,0 +1,24 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_Lock__
+#define __java_util_concurrent_locks_Lock__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::Lock : public ::java::lang::Object
+{
+
+public:
+  virtual void lock() = 0;
+  virtual void lockInterruptibly() = 0;
+  virtual jboolean tryLock() = 0;
+  virtual jboolean tryLock(jlong, ::java::util::concurrent::TimeUnit *) = 0;
+  virtual void unlock() = 0;
+  virtual ::java::util::concurrent::locks::Condition * newCondition() = 0;
+  static ::java::lang::Class class$;
+} __attribute__ ((java_interface));
+
+#endif // __java_util_concurrent_locks_Lock__
diff --git a/libjava/java/util/concurrent/locks/LockSupport.h b/libjava/java/util/concurrent/locks/LockSupport.h
new file mode 100644
index 000000000..15ef7306f
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/LockSupport.h
@@ -0,0 +1,42 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_LockSupport__
+#define __java_util_concurrent_locks_LockSupport__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::locks::LockSupport : public ::java::lang::Object
+{
+
+  LockSupport();
+  static void setBlocker(::java::lang::Thread *, ::java::lang::Object *);
+public:
+  static void unpark(::java::lang::Thread *);
+  static void park(::java::lang::Object *);
+  static void parkNanos(::java::lang::Object *, jlong);
+  static void parkUntil(::java::lang::Object *, jlong);
+  static ::java::lang::Object * getBlocker(::java::lang::Thread *);
+  static void park();
+  static void parkNanos(jlong);
+  static void parkUntil(jlong);
+private:
+  static ::sun::misc::Unsafe * unsafe;
+  static jlong parkBlockerOffset;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_LockSupport__
diff --git a/libjava/java/util/concurrent/locks/ReadWriteLock.h b/libjava/java/util/concurrent/locks/ReadWriteLock.h
new file mode 100644
index 000000000..1f4ae2e72
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReadWriteLock.h
@@ -0,0 +1,20 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReadWriteLock__
+#define __java_util_concurrent_locks_ReadWriteLock__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::ReadWriteLock : public ::java::lang::Object
+{
+
+public:
+  virtual ::java::util::concurrent::locks::Lock * readLock() = 0;
+  virtual ::java::util::concurrent::locks::Lock * writeLock() = 0;
+  static ::java::lang::Class class$;
+} __attribute__ ((java_interface));
+
+#endif // __java_util_concurrent_locks_ReadWriteLock__
diff --git a/libjava/java/util/concurrent/locks/ReentrantLock$FairSync.h b/libjava/java/util/concurrent/locks/ReentrantLock$FairSync.h
new file mode 100644
index 000000000..d4268afcd
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantLock$FairSync.h
@@ -0,0 +1,25 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantLock$FairSync__
+#define __java_util_concurrent_locks_ReentrantLock$FairSync__
+
+#pragma interface
+
+#include <java/util/concurrent/locks/ReentrantLock$Sync.h>
+
+class java::util::concurrent::locks::ReentrantLock$FairSync : public ::java::util::concurrent::locks::ReentrantLock$Sync
+{
+
+public: // actually package-private
+  ReentrantLock$FairSync();
+  void lock();
+public: // actually protected
+  jboolean tryAcquire(jint);
+private:
+  static const jlong serialVersionUID = -3000897897090466540LL;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantLock$FairSync__
diff --git a/libjava/java/util/concurrent/locks/ReentrantLock$NonfairSync.h b/libjava/java/util/concurrent/locks/ReentrantLock$NonfairSync.h
new file mode 100644
index 000000000..743a0bd75
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantLock$NonfairSync.h
@@ -0,0 +1,25 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantLock$NonfairSync__
+#define __java_util_concurrent_locks_ReentrantLock$NonfairSync__
+
+#pragma interface
+
+#include <java/util/concurrent/locks/ReentrantLock$Sync.h>
+
+class java::util::concurrent::locks::ReentrantLock$NonfairSync : public ::java::util::concurrent::locks::ReentrantLock$Sync
+{
+
+public: // actually package-private
+  ReentrantLock$NonfairSync();
+  void lock();
+public: // actually protected
+  jboolean tryAcquire(jint);
+private:
+  static const jlong serialVersionUID = 7316153563782823691LL;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantLock$NonfairSync__
diff --git a/libjava/java/util/concurrent/locks/ReentrantLock$Sync.h b/libjava/java/util/concurrent/locks/ReentrantLock$Sync.h
new file mode 100644
index 000000000..b3656d0df
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantLock$Sync.h
@@ -0,0 +1,33 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantLock$Sync__
+#define __java_util_concurrent_locks_ReentrantLock$Sync__
+
+#pragma interface
+
+#include <java/util/concurrent/locks/AbstractQueuedSynchronizer.h>
+
+class java::util::concurrent::locks::ReentrantLock$Sync : public ::java::util::concurrent::locks::AbstractQueuedSynchronizer
+{
+
+public: // actually package-private
+  ReentrantLock$Sync();
+  virtual void lock() = 0;
+  virtual jboolean nonfairTryAcquire(jint);
+public: // actually protected
+  virtual jboolean tryRelease(jint);
+  virtual jboolean isHeldExclusively();
+public: // actually package-private
+  virtual ::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject * newCondition();
+  virtual ::java::lang::Thread * getOwner();
+  virtual jint getHoldCount();
+  virtual jboolean isLocked();
+private:
+  void readObject(::java::io::ObjectInputStream *);
+  static const jlong serialVersionUID = -5179523762034025860LL;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantLock$Sync__
diff --git a/libjava/java/util/concurrent/locks/ReentrantLock.h b/libjava/java/util/concurrent/locks/ReentrantLock.h
new file mode 100644
index 000000000..5cac4b27f
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantLock.h
@@ -0,0 +1,49 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantLock__
+#define __java_util_concurrent_locks_ReentrantLock__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::ReentrantLock : public ::java::lang::Object
+{
+
+public:
+  ReentrantLock();
+  ReentrantLock(jboolean);
+  virtual void lock();
+  virtual void lockInterruptibly();
+  virtual jboolean tryLock();
+  virtual jboolean tryLock(jlong, ::java::util::concurrent::TimeUnit *);
+  virtual void unlock();
+  virtual ::java::util::concurrent::locks::Condition * newCondition();
+  virtual jint getHoldCount();
+  virtual jboolean isHeldByCurrentThread();
+  virtual jboolean isLocked();
+  virtual jboolean isFair();
+public: // actually protected
+  virtual ::java::lang::Thread * getOwner();
+public:
+  virtual jboolean hasQueuedThreads();
+  virtual jboolean hasQueuedThread(::java::lang::Thread *);
+  virtual jint getQueueLength();
+public: // actually protected
+  virtual ::java::util::Collection * getQueuedThreads();
+public:
+  virtual jboolean hasWaiters(::java::util::concurrent::locks::Condition *);
+  virtual jint getWaitQueueLength(::java::util::concurrent::locks::Condition *);
+public: // actually protected
+  virtual ::java::util::Collection * getWaitingThreads(::java::util::concurrent::locks::Condition *);
+public:
+  virtual ::java::lang::String * toString();
+private:
+  static const jlong serialVersionUID = 7373984872572414699LL;
+  ::java::util::concurrent::locks::ReentrantLock$Sync * __attribute__((aligned(__alignof__( ::java::lang::Object)))) sync;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantLock__
diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$FairSync.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$FairSync.h
new file mode 100644
index 000000000..05090b5b1
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$FairSync.h
@@ -0,0 +1,24 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$FairSync__
+#define __java_util_concurrent_locks_ReentrantReadWriteLock$FairSync__
+
+#pragma interface
+
+#include <java/util/concurrent/locks/ReentrantReadWriteLock$Sync.h>
+
+class java::util::concurrent::locks::ReentrantReadWriteLock$FairSync : public ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync
+{
+
+public: // actually package-private
+  ReentrantReadWriteLock$FairSync();
+  jboolean writerShouldBlock(::java::lang::Thread *);
+  jboolean readerShouldBlock(::java::lang::Thread *);
+private:
+  static const jlong serialVersionUID = -2274990926593161451LL;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$FairSync__
diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$NonfairSync.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$NonfairSync.h
new file mode 100644
index 000000000..29a565ae4
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$NonfairSync.h
@@ -0,0 +1,24 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$NonfairSync__
+#define __java_util_concurrent_locks_ReentrantReadWriteLock$NonfairSync__
+
+#pragma interface
+
+#include <java/util/concurrent/locks/ReentrantReadWriteLock$Sync.h>
+
+class java::util::concurrent::locks::ReentrantReadWriteLock$NonfairSync : public ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync
+{
+
+public: // actually package-private
+  ReentrantReadWriteLock$NonfairSync();
+  jboolean writerShouldBlock(::java::lang::Thread *);
+  jboolean readerShouldBlock(::java::lang::Thread *);
+private:
+  static const jlong serialVersionUID = -8159625535654395037LL;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$NonfairSync__
diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$ReadLock.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$ReadLock.h
new file mode 100644
index 000000000..0f48a6cb8
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$ReadLock.h
@@ -0,0 +1,31 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$ReadLock__
+#define __java_util_concurrent_locks_ReentrantReadWriteLock$ReadLock__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::ReentrantReadWriteLock$ReadLock : public ::java::lang::Object
+{
+
+public: // actually protected
+  ReentrantReadWriteLock$ReadLock(::java::util::concurrent::locks::ReentrantReadWriteLock *);
+public:
+  virtual void lock();
+  virtual void lockInterruptibly();
+  virtual jboolean tryLock();
+  virtual jboolean tryLock(jlong, ::java::util::concurrent::TimeUnit *);
+  virtual void unlock();
+  virtual ::java::util::concurrent::locks::Condition * newCondition();
+  virtual ::java::lang::String * toString();
+private:
+  static const jlong serialVersionUID = -5992448646407690164LL;
+  ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync * __attribute__((aligned(__alignof__( ::java::lang::Object)))) sync;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$ReadLock__
diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$HoldCounter.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$HoldCounter.h
new file mode 100644
index 000000000..4813f0d8f
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$HoldCounter.h
@@ -0,0 +1,23 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$HoldCounter__
+#define __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$HoldCounter__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::ReentrantReadWriteLock$Sync$HoldCounter : public ::java::lang::Object
+{
+
+public: // actually package-private
+  ReentrantReadWriteLock$Sync$HoldCounter();
+  jint tryDecrement();
+  jint __attribute__((aligned(__alignof__( ::java::lang::Object)))) count;
+  jlong tid;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$HoldCounter__
diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter.h
new file mode 100644
index 000000000..10f87c922
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter.h
@@ -0,0 +1,22 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter__
+#define __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter__
+
+#pragma interface
+
+#include <java/lang/ThreadLocal.h>
+
+class java::util::concurrent::locks::ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter : public ::java::lang::ThreadLocal
+{
+
+public: // actually package-private
+  ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter();
+public:
+  ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync$HoldCounter * ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter$initialValue();
+  ::java::lang::Object * initialValue();
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter__
diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync.h
new file mode 100644
index 000000000..d1d43078f
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$Sync.h
@@ -0,0 +1,55 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$Sync__
+#define __java_util_concurrent_locks_ReentrantReadWriteLock$Sync__
+
+#pragma interface
+
+#include <java/util/concurrent/locks/AbstractQueuedSynchronizer.h>
+
+class java::util::concurrent::locks::ReentrantReadWriteLock$Sync : public ::java::util::concurrent::locks::AbstractQueuedSynchronizer
+{
+
+public: // actually package-private
+  static jint sharedCount(jint);
+  static jint exclusiveCount(jint);
+  ReentrantReadWriteLock$Sync();
+  virtual jboolean readerShouldBlock(::java::lang::Thread *) = 0;
+  virtual jboolean writerShouldBlock(::java::lang::Thread *) = 0;
+public: // actually protected
+  virtual jboolean tryRelease(jint);
+  virtual jboolean tryAcquire(jint);
+  virtual jboolean tryReleaseShared(jint);
+  virtual jint tryAcquireShared(jint);
+public: // actually package-private
+  virtual jint fullTryAcquireShared(::java::lang::Thread *);
+  virtual jboolean tryWriteLock();
+  virtual jboolean tryReadLock();
+public: // actually protected
+  virtual jboolean isHeldExclusively();
+public: // actually package-private
+  virtual ::java::util::concurrent::locks::AbstractQueuedSynchronizer$ConditionObject * newCondition();
+  virtual ::java::lang::Thread * getOwner();
+  virtual jint getReadLockCount();
+  virtual jboolean isWriteLocked();
+  virtual jint getWriteHoldCount();
+  virtual jint getReadHoldCount();
+private:
+  void readObject(::java::io::ObjectInputStream *);
+public: // actually package-private
+  virtual jint getCount();
+private:
+  static const jlong serialVersionUID = 6317671515068378041LL;
+public: // actually package-private
+  static const jint SHARED_SHIFT = 16;
+  static const jint SHARED_UNIT = 65536;
+  static const jint MAX_COUNT = 65535;
+  static const jint EXCLUSIVE_MASK = 65535;
+  ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync$ThreadLocalHoldCounter * __attribute__((aligned(__alignof__( ::java::util::concurrent::locks::AbstractQueuedSynchronizer)))) readHolds;
+  ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync$HoldCounter * cachedHoldCounter;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$Sync__
diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$WriteLock.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$WriteLock.h
new file mode 100644
index 000000000..4e57d53c6
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock$WriteLock.h
@@ -0,0 +1,33 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock$WriteLock__
+#define __java_util_concurrent_locks_ReentrantReadWriteLock$WriteLock__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::ReentrantReadWriteLock$WriteLock : public ::java::lang::Object
+{
+
+public: // actually protected
+  ReentrantReadWriteLock$WriteLock(::java::util::concurrent::locks::ReentrantReadWriteLock *);
+public:
+  virtual void lock();
+  virtual void lockInterruptibly();
+  virtual jboolean tryLock();
+  virtual jboolean tryLock(jlong, ::java::util::concurrent::TimeUnit *);
+  virtual void unlock();
+  virtual ::java::util::concurrent::locks::Condition * newCondition();
+  virtual ::java::lang::String * toString();
+  virtual jboolean isHeldByCurrentThread();
+  virtual jint getHoldCount();
+private:
+  static const jlong serialVersionUID = -4992448646407690164LL;
+  ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync * __attribute__((aligned(__alignof__( ::java::lang::Object)))) sync;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantReadWriteLock$WriteLock__
diff --git a/libjava/java/util/concurrent/locks/ReentrantReadWriteLock.h b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock.h
new file mode 100644
index 000000000..e7da50a75
--- /dev/null
+++ b/libjava/java/util/concurrent/locks/ReentrantReadWriteLock.h
@@ -0,0 +1,57 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_locks_ReentrantReadWriteLock__
+#define __java_util_concurrent_locks_ReentrantReadWriteLock__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::locks::ReentrantReadWriteLock : public ::java::lang::Object
+{
+
+public:
+  ReentrantReadWriteLock();
+  ReentrantReadWriteLock(jboolean);
+  virtual ::java::util::concurrent::locks::ReentrantReadWriteLock$WriteLock * ReentrantReadWriteLock$writeLock();
+  virtual ::java::util::concurrent::locks::ReentrantReadWriteLock$ReadLock * ReentrantReadWriteLock$readLock();
+  virtual jboolean isFair();
+public: // actually protected
+  virtual ::java::lang::Thread * getOwner();
+public:
+  virtual jint getReadLockCount();
+  virtual jboolean isWriteLocked();
+  virtual jboolean isWriteLockedByCurrentThread();
+  virtual jint getWriteHoldCount();
+  virtual jint getReadHoldCount();
+public: // actually protected
+  virtual ::java::util::Collection * getQueuedWriterThreads();
+  virtual ::java::util::Collection * getQueuedReaderThreads();
+public:
+  virtual jboolean hasQueuedThreads();
+  virtual jboolean hasQueuedThread(::java::lang::Thread *);
+  virtual jint getQueueLength();
+public: // actually protected
+  virtual ::java::util::Collection * getQueuedThreads();
+public:
+  virtual jboolean hasWaiters(::java::util::concurrent::locks::Condition *);
+  virtual jint getWaitQueueLength(::java::util::concurrent::locks::Condition *);
+public: // actually protected
+  virtual ::java::util::Collection * getWaitingThreads(::java::util::concurrent::locks::Condition *);
+public:
+  virtual ::java::lang::String * toString();
+  virtual ::java::util::concurrent::locks::Lock * readLock();
+  virtual ::java::util::concurrent::locks::Lock * writeLock();
+public: // actually package-private
+  static ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync * access$2(::java::util::concurrent::locks::ReentrantReadWriteLock *);
+private:
+  static const jlong serialVersionUID = -6992448646407690164LL;
+  ::java::util::concurrent::locks::ReentrantReadWriteLock$ReadLock * __attribute__((aligned(__alignof__( ::java::lang::Object)))) readerLock;
+  ::java::util::concurrent::locks::ReentrantReadWriteLock$WriteLock * writerLock;
+  ::java::util::concurrent::locks::ReentrantReadWriteLock$Sync * sync;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_locks_ReentrantReadWriteLock__