Merged gcj-eclipse branch to trunk.

From-SVN: r120621

libjava/java/util/concurrent/atomic/AtomicBoolean.h

@@ -0,0 +1,43 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicBoolean__
+#define __java_util_concurrent_atomic_AtomicBoolean__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::atomic::AtomicBoolean : public ::java::lang::Object
+{
+
+public:
+  AtomicBoolean(jboolean);
+  AtomicBoolean();
+  virtual jboolean get();
+  virtual jboolean compareAndSet(jboolean, jboolean);
+  virtual jboolean weakCompareAndSet(jboolean, jboolean);
+  virtual void set(jboolean);
+  virtual void lazySet(jboolean);
+  virtual jboolean getAndSet(jboolean);
+  virtual ::java::lang::String * toString();
+private:
+  static const jlong serialVersionUID = 4654671469794556979LL;
+  static ::sun::misc::Unsafe * unsafe;
+  static jlong valueOffset;
+  volatile jint __attribute__((aligned(__alignof__( ::java::lang::Object)))) value;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicBoolean__

libjava/java/util/concurrent/atomic/AtomicInteger.h

@@ -0,0 +1,53 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicInteger__
+#define __java_util_concurrent_atomic_AtomicInteger__
+
+#pragma interface
+
+#include <java/lang/Number.h>
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::atomic::AtomicInteger : public ::java::lang::Number
+{
+
+public:
+  AtomicInteger(jint);
+  AtomicInteger();
+  virtual jint get();
+  virtual void set(jint);
+  virtual void lazySet(jint);
+  virtual jint getAndSet(jint);
+  virtual jboolean compareAndSet(jint, jint);
+  virtual jboolean weakCompareAndSet(jint, jint);
+  virtual jint getAndIncrement();
+  virtual jint getAndDecrement();
+  virtual jint getAndAdd(jint);
+  virtual jint incrementAndGet();
+  virtual jint decrementAndGet();
+  virtual jint addAndGet(jint);
+  virtual ::java::lang::String * toString();
+  virtual jint intValue();
+  virtual jlong longValue();
+  virtual jfloat floatValue();
+  virtual jdouble doubleValue();
+private:
+  static const jlong serialVersionUID = 6214790243416807050LL;
+  static ::sun::misc::Unsafe * unsafe;
+  static jlong valueOffset;
+  volatile jint __attribute__((aligned(__alignof__( ::java::lang::Number)))) value;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicInteger__

libjava/java/util/concurrent/atomic/AtomicIntegerArray.h

@@ -0,0 +1,54 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicIntegerArray__
+#define __java_util_concurrent_atomic_AtomicIntegerArray__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+#include <gcj/array.h>
+
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::atomic::AtomicIntegerArray : public ::java::lang::Object
+{
+
+  jlong rawIndex(jint);
+public:
+  AtomicIntegerArray(jint);
+  AtomicIntegerArray(JArray< jint > *);
+  virtual jint length();
+  virtual jint get(jint);
+  virtual void set(jint, jint);
+  virtual void lazySet(jint, jint);
+  virtual jint getAndSet(jint, jint);
+  virtual jboolean compareAndSet(jint, jint, jint);
+  virtual jboolean weakCompareAndSet(jint, jint, jint);
+  virtual jint getAndIncrement(jint);
+  virtual jint getAndDecrement(jint);
+  virtual jint getAndAdd(jint, jint);
+  virtual jint incrementAndGet(jint);
+  virtual jint decrementAndGet(jint);
+  virtual jint addAndGet(jint, jint);
+  virtual ::java::lang::String * toString();
+private:
+  static const jlong serialVersionUID = 2862133569453604235LL;
+  static ::sun::misc::Unsafe * unsafe;
+  static jint base;
+  static jint scale;
+  JArray< jint > * __attribute__((aligned(__alignof__( ::java::lang::Object)))) array;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicIntegerArray__

libjava/java/util/concurrent/atomic/AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl.h

@@ -0,0 +1,44 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl__
+#define __java_util_concurrent_atomic_AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl__
+
+#pragma interface
+
+#include <java/util/concurrent/atomic/AtomicIntegerFieldUpdater.h>
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::atomic::AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl : public ::java::util::concurrent::atomic::AtomicIntegerFieldUpdater
+{
+
+public: // actually package-private
+  AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl(::java::lang::Class *, ::java::lang::String *);
+private:
+  void fullCheck(::java::lang::Object *);
+public:
+  virtual jboolean compareAndSet(::java::lang::Object *, jint, jint);
+  virtual jboolean weakCompareAndSet(::java::lang::Object *, jint, jint);
+  virtual void set(::java::lang::Object *, jint);
+  virtual void lazySet(::java::lang::Object *, jint);
+  virtual jint get(::java::lang::Object *);
+private:
+  void ensureProtectedAccess(::java::lang::Object *);
+  static ::sun::misc::Unsafe * unsafe;
+  jlong __attribute__((aligned(__alignof__( ::java::util::concurrent::atomic::AtomicIntegerFieldUpdater)))) offset;
+  ::java::lang::Class * tclass;
+  ::java::lang::Class * cclass;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl__

libjava/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.h

@@ -0,0 +1,34 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicIntegerFieldUpdater__
+#define __java_util_concurrent_atomic_AtomicIntegerFieldUpdater__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::atomic::AtomicIntegerFieldUpdater : public ::java::lang::Object
+{
+
+public:
+  static ::java::util::concurrent::atomic::AtomicIntegerFieldUpdater * newUpdater(::java::lang::Class *, ::java::lang::String *);
+public: // actually protected
+  AtomicIntegerFieldUpdater();
+public:
+  virtual jboolean compareAndSet(::java::lang::Object *, jint, jint) = 0;
+  virtual jboolean weakCompareAndSet(::java::lang::Object *, jint, jint) = 0;
+  virtual void set(::java::lang::Object *, jint) = 0;
+  virtual void lazySet(::java::lang::Object *, jint) = 0;
+  virtual jint get(::java::lang::Object *) = 0;
+  virtual jint getAndSet(::java::lang::Object *, jint);
+  virtual jint getAndIncrement(::java::lang::Object *);
+  virtual jint getAndDecrement(::java::lang::Object *);
+  virtual jint getAndAdd(::java::lang::Object *, jint);
+  virtual jint incrementAndGet(::java::lang::Object *);
+  virtual jint decrementAndGet(::java::lang::Object *);
+  virtual jint addAndGet(::java::lang::Object *, jint);
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicIntegerFieldUpdater__

libjava/java/util/concurrent/atomic/AtomicLong.h

@@ -0,0 +1,57 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicLong__
+#define __java_util_concurrent_atomic_AtomicLong__
+
+#pragma interface
+
+#include <java/lang/Number.h>
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::atomic::AtomicLong : public ::java::lang::Number
+{
+
+  static jboolean VMSupportsCS8();
+public:
+  AtomicLong(jlong);
+  AtomicLong();
+  virtual jlong get();
+  virtual void set(jlong);
+  virtual void lazySet(jlong);
+  virtual jlong getAndSet(jlong);
+  virtual jboolean compareAndSet(jlong, jlong);
+  virtual jboolean weakCompareAndSet(jlong, jlong);
+  virtual jlong getAndIncrement();
+  virtual jlong getAndDecrement();
+  virtual jlong getAndAdd(jlong);
+  virtual jlong incrementAndGet();
+  virtual jlong decrementAndGet();
+  virtual jlong addAndGet(jlong);
+  virtual ::java::lang::String * toString();
+  virtual jint intValue();
+  virtual jlong longValue();
+  virtual jfloat floatValue();
+  virtual jdouble doubleValue();
+private:
+  static const jlong serialVersionUID = 1927816293512124184LL;
+  static ::sun::misc::Unsafe * unsafe;
+  static jlong valueOffset;
+public: // actually package-private
+  static jboolean VM_SUPPORTS_LONG_CAS;
+private:
+  volatile jlong __attribute__((aligned(__alignof__( ::java::lang::Number)))) value;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicLong__

libjava/java/util/concurrent/atomic/AtomicLongArray.h

@@ -0,0 +1,54 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicLongArray__
+#define __java_util_concurrent_atomic_AtomicLongArray__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+#include <gcj/array.h>
+
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::atomic::AtomicLongArray : public ::java::lang::Object
+{
+
+  jlong rawIndex(jint);
+public:
+  AtomicLongArray(jint);
+  AtomicLongArray(JArray< jlong > *);
+  virtual jint length();
+  virtual jlong get(jint);
+  virtual void set(jint, jlong);
+  virtual void lazySet(jint, jlong);
+  virtual jlong getAndSet(jint, jlong);
+  virtual jboolean compareAndSet(jint, jlong, jlong);
+  virtual jboolean weakCompareAndSet(jint, jlong, jlong);
+  virtual jlong getAndIncrement(jint);
+  virtual jlong getAndDecrement(jint);
+  virtual jlong getAndAdd(jint, jlong);
+  virtual jlong incrementAndGet(jint);
+  virtual jlong decrementAndGet(jint);
+  virtual jlong addAndGet(jint, jlong);
+  virtual ::java::lang::String * toString();
+private:
+  static const jlong serialVersionUID = -2308431214976778248LL;
+  static ::sun::misc::Unsafe * unsafe;
+  static jint base;
+  static jint scale;
+  JArray< jlong > * __attribute__((aligned(__alignof__( ::java::lang::Object)))) array;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicLongArray__

libjava/java/util/concurrent/atomic/AtomicLongFieldUpdater$CASUpdater.h

@@ -0,0 +1,44 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicLongFieldUpdater$CASUpdater__
+#define __java_util_concurrent_atomic_AtomicLongFieldUpdater$CASUpdater__
+
+#pragma interface
+
+#include <java/util/concurrent/atomic/AtomicLongFieldUpdater.h>
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::atomic::AtomicLongFieldUpdater$CASUpdater : public ::java::util::concurrent::atomic::AtomicLongFieldUpdater
+{
+
+public: // actually package-private
+  AtomicLongFieldUpdater$CASUpdater(::java::lang::Class *, ::java::lang::String *);
+private:
+  void fullCheck(::java::lang::Object *);
+public:
+  virtual jboolean compareAndSet(::java::lang::Object *, jlong, jlong);
+  virtual jboolean weakCompareAndSet(::java::lang::Object *, jlong, jlong);
+  virtual void set(::java::lang::Object *, jlong);
+  virtual void lazySet(::java::lang::Object *, jlong);
+  virtual jlong get(::java::lang::Object *);
+private:
+  void ensureProtectedAccess(::java::lang::Object *);
+  static ::sun::misc::Unsafe * unsafe;
+  jlong __attribute__((aligned(__alignof__( ::java::util::concurrent::atomic::AtomicLongFieldUpdater)))) offset;
+  ::java::lang::Class * tclass;
+  ::java::lang::Class * cclass;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicLongFieldUpdater$CASUpdater__

libjava/java/util/concurrent/atomic/AtomicLongFieldUpdater$LockedUpdater.h

@@ -0,0 +1,44 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicLongFieldUpdater$LockedUpdater__
+#define __java_util_concurrent_atomic_AtomicLongFieldUpdater$LockedUpdater__
+
+#pragma interface
+
+#include <java/util/concurrent/atomic/AtomicLongFieldUpdater.h>
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::atomic::AtomicLongFieldUpdater$LockedUpdater : public ::java::util::concurrent::atomic::AtomicLongFieldUpdater
+{
+
+public: // actually package-private
+  AtomicLongFieldUpdater$LockedUpdater(::java::lang::Class *, ::java::lang::String *);
+private:
+  void fullCheck(::java::lang::Object *);
+public:
+  virtual jboolean compareAndSet(::java::lang::Object *, jlong, jlong);
+  virtual jboolean weakCompareAndSet(::java::lang::Object *, jlong, jlong);
+  virtual void set(::java::lang::Object *, jlong);
+  virtual void lazySet(::java::lang::Object *, jlong);
+  virtual jlong get(::java::lang::Object *);
+private:
+  void ensureProtectedAccess(::java::lang::Object *);
+  static ::sun::misc::Unsafe * unsafe;
+  jlong __attribute__((aligned(__alignof__( ::java::util::concurrent::atomic::AtomicLongFieldUpdater)))) offset;
+  ::java::lang::Class * tclass;
+  ::java::lang::Class * cclass;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicLongFieldUpdater$LockedUpdater__

libjava/java/util/concurrent/atomic/AtomicLongFieldUpdater.h

@@ -0,0 +1,34 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicLongFieldUpdater__
+#define __java_util_concurrent_atomic_AtomicLongFieldUpdater__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::atomic::AtomicLongFieldUpdater : public ::java::lang::Object
+{
+
+public:
+  static ::java::util::concurrent::atomic::AtomicLongFieldUpdater * newUpdater(::java::lang::Class *, ::java::lang::String *);
+public: // actually protected
+  AtomicLongFieldUpdater();
+public:
+  virtual jboolean compareAndSet(::java::lang::Object *, jlong, jlong) = 0;
+  virtual jboolean weakCompareAndSet(::java::lang::Object *, jlong, jlong) = 0;
+  virtual void set(::java::lang::Object *, jlong) = 0;
+  virtual void lazySet(::java::lang::Object *, jlong) = 0;
+  virtual jlong get(::java::lang::Object *) = 0;
+  virtual jlong getAndSet(::java::lang::Object *, jlong);
+  virtual jlong getAndIncrement(::java::lang::Object *);
+  virtual jlong getAndDecrement(::java::lang::Object *);
+  virtual jlong getAndAdd(::java::lang::Object *, jlong);
+  virtual jlong incrementAndGet(::java::lang::Object *);
+  virtual jlong decrementAndGet(::java::lang::Object *);
+  virtual jlong addAndGet(::java::lang::Object *, jlong);
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicLongFieldUpdater__

libjava/java/util/concurrent/atomic/AtomicMarkableReference$ReferenceBooleanPair.h

@@ -0,0 +1,25 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicMarkableReference$ReferenceBooleanPair__
+#define __java_util_concurrent_atomic_AtomicMarkableReference$ReferenceBooleanPair__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::atomic::AtomicMarkableReference$ReferenceBooleanPair : public ::java::lang::Object
+{
+
+public: // actually package-private
+  AtomicMarkableReference$ReferenceBooleanPair(::java::lang::Object *, jboolean);
+  static ::java::lang::Object * access$0(::java::util::concurrent::atomic::AtomicMarkableReference$ReferenceBooleanPair *);
+  static jboolean access$1(::java::util::concurrent::atomic::AtomicMarkableReference$ReferenceBooleanPair *);
+private:
+  ::java::lang::Object * __attribute__((aligned(__alignof__( ::java::lang::Object)))) reference;
+  jboolean bit;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicMarkableReference$ReferenceBooleanPair__

libjava/java/util/concurrent/atomic/AtomicMarkableReference.h

@@ -0,0 +1,31 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicMarkableReference__
+#define __java_util_concurrent_atomic_AtomicMarkableReference__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+#include <gcj/array.h>
+
+
+class java::util::concurrent::atomic::AtomicMarkableReference : public ::java::lang::Object
+{
+
+public:
+  AtomicMarkableReference(::java::lang::Object *, jboolean);
+  virtual ::java::lang::Object * getReference();
+  virtual jboolean isMarked();
+  virtual ::java::lang::Object * get(JArray< jboolean > *);
+  virtual jboolean weakCompareAndSet(::java::lang::Object *, ::java::lang::Object *, jboolean, jboolean);
+  virtual jboolean compareAndSet(::java::lang::Object *, ::java::lang::Object *, jboolean, jboolean);
+  virtual void set(::java::lang::Object *, jboolean);
+  virtual jboolean attemptMark(::java::lang::Object *, jboolean);
+private:
+  ::java::util::concurrent::atomic::AtomicReference * __attribute__((aligned(__alignof__( ::java::lang::Object)))) atomicRef;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicMarkableReference__

libjava/java/util/concurrent/atomic/AtomicReference.h

@@ -0,0 +1,43 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicReference__
+#define __java_util_concurrent_atomic_AtomicReference__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::atomic::AtomicReference : public ::java::lang::Object
+{
+
+public:
+  AtomicReference(::java::lang::Object *);
+  AtomicReference();
+  virtual ::java::lang::Object * get();
+  virtual void set(::java::lang::Object *);
+  virtual void lazySet(::java::lang::Object *);
+  virtual jboolean compareAndSet(::java::lang::Object *, ::java::lang::Object *);
+  virtual jboolean weakCompareAndSet(::java::lang::Object *, ::java::lang::Object *);
+  virtual ::java::lang::Object * getAndSet(::java::lang::Object *);
+  virtual ::java::lang::String * toString();
+private:
+  static const jlong serialVersionUID = -1848883965231344442LL;
+  static ::sun::misc::Unsafe * unsafe;
+  static jlong valueOffset;
+  volatile ::java::lang::Object * __attribute__((aligned(__alignof__( ::java::lang::Object)))) value;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicReference__

libjava/java/util/concurrent/atomic/AtomicReferenceArray.h

@@ -0,0 +1,48 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicReferenceArray__
+#define __java_util_concurrent_atomic_AtomicReferenceArray__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+#include <gcj/array.h>
+
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::atomic::AtomicReferenceArray : public ::java::lang::Object
+{
+
+  jlong rawIndex(jint);
+public:
+  AtomicReferenceArray(jint);
+  AtomicReferenceArray(JArray< ::java::lang::Object * > *);
+  virtual jint length();
+  virtual ::java::lang::Object * get(jint);
+  virtual void set(jint, ::java::lang::Object *);
+  virtual void lazySet(jint, ::java::lang::Object *);
+  virtual ::java::lang::Object * getAndSet(jint, ::java::lang::Object *);
+  virtual jboolean compareAndSet(jint, ::java::lang::Object *, ::java::lang::Object *);
+  virtual jboolean weakCompareAndSet(jint, ::java::lang::Object *, ::java::lang::Object *);
+  virtual ::java::lang::String * toString();
+private:
+  static const jlong serialVersionUID = -6209656149925076980LL;
+  static ::sun::misc::Unsafe * unsafe;
+  static jint base;
+  static jint scale;
+  JArray< ::java::lang::Object * > * __attribute__((aligned(__alignof__( ::java::lang::Object)))) array;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicReferenceArray__

libjava/java/util/concurrent/atomic/AtomicReferenceFieldUpdater$AtomicReferenceFieldUpdaterImpl.h

@@ -0,0 +1,45 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicReferenceFieldUpdater$AtomicReferenceFieldUpdaterImpl__
+#define __java_util_concurrent_atomic_AtomicReferenceFieldUpdater$AtomicReferenceFieldUpdaterImpl__
+
+#pragma interface
+
+#include <java/util/concurrent/atomic/AtomicReferenceFieldUpdater.h>
+extern "Java"
+{
+  namespace sun
+  {
+    namespace misc
+    {
+        class Unsafe;
+    }
+  }
+}
+
+class java::util::concurrent::atomic::AtomicReferenceFieldUpdater$AtomicReferenceFieldUpdaterImpl : public ::java::util::concurrent::atomic::AtomicReferenceFieldUpdater
+{
+
+public: // actually package-private
+  AtomicReferenceFieldUpdater$AtomicReferenceFieldUpdaterImpl(::java::lang::Class *, ::java::lang::Class *, ::java::lang::String *);
+  void targetCheck(::java::lang::Object *);
+  void updateCheck(::java::lang::Object *, ::java::lang::Object *);
+public:
+  jboolean compareAndSet(::java::lang::Object *, ::java::lang::Object *, ::java::lang::Object *);
+  jboolean weakCompareAndSet(::java::lang::Object *, ::java::lang::Object *, ::java::lang::Object *);
+  void set(::java::lang::Object *, ::java::lang::Object *);
+  void lazySet(::java::lang::Object *, ::java::lang::Object *);
+  ::java::lang::Object * get(::java::lang::Object *);
+private:
+  void ensureProtectedAccess(::java::lang::Object *);
+  static ::sun::misc::Unsafe * unsafe;
+  jlong __attribute__((aligned(__alignof__( ::java::util::concurrent::atomic::AtomicReferenceFieldUpdater)))) offset;
+  ::java::lang::Class * tclass;
+  ::java::lang::Class * vclass;
+  ::java::lang::Class * cclass;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicReferenceFieldUpdater$AtomicReferenceFieldUpdaterImpl__

libjava/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.h

@@ -0,0 +1,28 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicReferenceFieldUpdater__
+#define __java_util_concurrent_atomic_AtomicReferenceFieldUpdater__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::atomic::AtomicReferenceFieldUpdater : public ::java::lang::Object
+{
+
+public:
+  static ::java::util::concurrent::atomic::AtomicReferenceFieldUpdater * newUpdater(::java::lang::Class *, ::java::lang::Class *, ::java::lang::String *);
+public: // actually protected
+  AtomicReferenceFieldUpdater();
+public:
+  virtual jboolean compareAndSet(::java::lang::Object *, ::java::lang::Object *, ::java::lang::Object *) = 0;
+  virtual jboolean weakCompareAndSet(::java::lang::Object *, ::java::lang::Object *, ::java::lang::Object *) = 0;
+  virtual void set(::java::lang::Object *, ::java::lang::Object *) = 0;
+  virtual void lazySet(::java::lang::Object *, ::java::lang::Object *) = 0;
+  virtual ::java::lang::Object * get(::java::lang::Object *) = 0;
+  virtual ::java::lang::Object * getAndSet(::java::lang::Object *, ::java::lang::Object *);
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicReferenceFieldUpdater__

libjava/java/util/concurrent/atomic/AtomicStampedReference$ReferenceIntegerPair.h

@@ -0,0 +1,25 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicStampedReference$ReferenceIntegerPair__
+#define __java_util_concurrent_atomic_AtomicStampedReference$ReferenceIntegerPair__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+
+class java::util::concurrent::atomic::AtomicStampedReference$ReferenceIntegerPair : public ::java::lang::Object
+{
+
+public: // actually package-private
+  AtomicStampedReference$ReferenceIntegerPair(::java::lang::Object *, jint);
+  static ::java::lang::Object * access$0(::java::util::concurrent::atomic::AtomicStampedReference$ReferenceIntegerPair *);
+  static jint access$1(::java::util::concurrent::atomic::AtomicStampedReference$ReferenceIntegerPair *);
+private:
+  ::java::lang::Object * __attribute__((aligned(__alignof__( ::java::lang::Object)))) reference;
+  jint integer;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicStampedReference$ReferenceIntegerPair__

libjava/java/util/concurrent/atomic/AtomicStampedReference.h

@@ -0,0 +1,31 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __java_util_concurrent_atomic_AtomicStampedReference__
+#define __java_util_concurrent_atomic_AtomicStampedReference__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+#include <gcj/array.h>
+
+
+class java::util::concurrent::atomic::AtomicStampedReference : public ::java::lang::Object
+{
+
+public:
+  AtomicStampedReference(::java::lang::Object *, jint);
+  virtual ::java::lang::Object * getReference();
+  virtual jint getStamp();
+  virtual ::java::lang::Object * get(JArray< jint > *);
+  virtual jboolean weakCompareAndSet(::java::lang::Object *, ::java::lang::Object *, jint, jint);
+  virtual jboolean compareAndSet(::java::lang::Object *, ::java::lang::Object *, jint, jint);
+  virtual void set(::java::lang::Object *, jint);
+  virtual jboolean attemptStamp(::java::lang::Object *, jint);
+private:
+  ::java::util::concurrent::atomic::AtomicReference * __attribute__((aligned(__alignof__( ::java::lang::Object)))) atomicRef;
+public:
+  static ::java::lang::Class class$;
+};
+
+#endif // __java_util_concurrent_atomic_AtomicStampedReference__

libjava/java/util/concurrent/atomic/natAtomicLong.cc

@@ -0,0 +1,12 @@
+#include <config.h>
+
+#include <java/util/concurrent/atomic/AtomicLong.h>
+#include <gcj/cni.h>
+#include <java/lang/UnsupportedOperationException.h>
+
+jboolean
+java::util::concurrent::atomic::AtomicLong::VMSupportsCS8 ()
+{
+  // FIXME
+  return false;
+}