* gcj.texi (Object allocation): Remove _Jv_AllocBytes.
(Mixing with C++): Document JvAllocBytes and RawDataManaged.
* gcj/cni.h (JvAllocBytes): New public CNI function. Calls
_Jv_AllocBytes.
* gnu/gcj/RawDataManaged.java: New file.
* java/lang/Thread.java (data): Declare as RawDataManaged.
* java/lang/natThread.cc (init_native): Cast natThread data to
RawDataManaged, not jobject.
* Makefile.am (ordinary_java_source_files): Add RawDataManaged.
* Makefile.in: Rebuilt.
From-SVN: r82372
+2004-05-28 Bryce McKinlay <mckinlay@redhat.com>
+
+ * gcj.texi (Object allocation): Remove _Jv_AllocBytes.
+ (Mixing with C++): Document JvAllocBytes and RawDataManaged.
+
2004-05-26 Bryce McKinlay <mckinlay@redhat.com>
* decl.c (struct binding_level): Add GTY marker. Compile
@code{JvNewObjectArray}. This convention is used to avoid conflicts
with other libraries. Internal functions in CNI start with the prefix
@code{_Jv_}. You should not call these; if you find a need to, let us
-know and we will try to come up with an alternate solution. (This
-manual lists @code{_Jv_AllocBytes} as an example; CNI should instead
-provide a @code{JvAllocBytes} function.)
+know and we will try to come up with an alternate solution.
@subsection Limitations
java::util::Hashtable *ht = new java::util::Hashtable(120);
@end example
-@deftypefun void* _Jv_AllocBytes (jsize @var{size})
-Allocates @var{size} bytes from the heap. The memory is not scanned
-by the garbage collector but it freed if no references to it are discovered.
-@end deftypefun
-
@node Arrays
@section Arrays
@}
@end example
-But this restriction can cause a problem so @acronym{CNI} includes the
+@subsection RawData
+
+The above restriction can be problematic, so @acronym{CNI} includes the
@code{gnu.gcj.RawData} class. The @code{RawData} class is a
@dfn{non-scanned reference} type. In other words variables declared
of type @code{RawData} can contain any data and are not checked by the
-compiler in any way.
+compiler or memory manager in any way.
This means that you can put C/C++ data structures (including classes)
in your @acronym{CNI} classes, as long as you use the appropriate cast.
@end example
+@subsection RawDataManaged
+
+@code{gnu.gcj.RawDataManaged} is another type used to indicate special data used
+by native code. Unlike the @code{RawData} type, fields declared as
+@code{RawDataManaged} will be "marked" by the memory manager and
+considered for garbage collection.
+
+Native data which is allocated using CNI's @code{JvAllocBytes()}
+function and stored in a @code{RawDataManaged} will be automatically
+freed when the Java object it is associated with becomes unreachable.
+
+@subsection Native memory allocation
+
+@deftypefun void* JvAllocBytes (jsize @var{size})
+Allocates @var{size} bytes from the heap. The memory returned is zeroed.
+This memory is not scanned for pointers by the garbage collector, but will
+be freed if no references to it are discovered.
+
+This function can be useful if you need to associate some native data with a
+Java object. Using a CNI's special @code{RawDataManaged} type, native data
+allocated with @code{JvAllocBytes} will be automatically freed when the Java
+object itself becomes unreachable.
+@end deftypefun
+
@node Exception Handling
@section Exception Handling
+2004-05-28 Bryce McKinlay <mckinlay@redhat.com>
+
+ * gcj/cni.h (JvAllocBytes): New public CNI function. Calls
+ _Jv_AllocBytes.
+ * gnu/gcj/RawDataManaged.java: New file.
+ * java/lang/Thread.java (data): Declare as RawDataManaged.
+ * java/lang/natThread.cc (init_native): Cast natThread data to
+ RawDataManaged, not jobject.
+ * Makefile.am (ordinary_java_source_files): Add RawDataManaged.
+ * Makefile.in: Rebuilt.
+
2004-05-27 Jerry Quinn <jlquinn@optonline.net>
* java/util/SimpleTimeZone.java: Reverting my last change until I
gnu/classpath/ServiceProviderLoadingAction.java \
gnu/gcj/Core.java \
gnu/gcj/RawData.java \
+gnu/gcj/RawDataManaged.java \
gnu/gcj/io/DefaultMimeTypes.java \
gnu/gcj/io/MimeTypes.java \
gnu/gcj/io/SimpleSHSStream.java \
gnu/classpath/ServiceProviderLoadingAction.java \
gnu/gcj/Core.java \
gnu/gcj/RawData.java \
+gnu/gcj/RawDataManaged.java \
gnu/gcj/io/DefaultMimeTypes.java \
gnu/gcj/io/MimeTypes.java \
gnu/gcj/io/SimpleSHSStream.java \
.deps/gnu/awt/xlib/XToolkit.P .deps/gnu/classpath/Configuration.P \
.deps/gnu/classpath/ServiceFactory.P \
.deps/gnu/classpath/ServiceProviderLoadingAction.P .deps/gnu/gcj/Core.P \
-.deps/gnu/gcj/RawData.P .deps/gnu/gcj/convert/BytesToUnicode.P \
+.deps/gnu/gcj/RawData.P .deps/gnu/gcj/RawDataManaged.P \
+.deps/gnu/gcj/convert/BytesToUnicode.P \
.deps/gnu/gcj/convert/Convert.P .deps/gnu/gcj/convert/IOConverter.P \
.deps/gnu/gcj/convert/Input_8859_1.P \
.deps/gnu/gcj/convert/Input_ASCII.P \
extern "C" jstring _Jv_NewStringUTF (const char *bytes);
extern "C" void _Jv_InitClass (jclass);
+extern "C" void *_Jv_AllocBytes (jsize size) __attribute__((__malloc__));
extern inline void
JvInitClass (jclass cls)
return _Jv_InitClass (cls);
}
+extern inline void *
+JvAllocBytes (jsize sz)
+{
+ return _Jv_AllocBytes (sz);
+}
+
extern inline jstring
JvAllocString (jsize sz)
{
--- /dev/null
+/* Copyright (C) 2004 Free Software Foundation
+
+ This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
+details. */
+
+package gnu.gcj;
+
+/** A type used to indicate special data used by native code. Unlike the
+ <code>RawData</code> type, fields declared as <code>RawDataManaged</code>
+ will be "marked" by the memory manager and considered for garbage
+ collection.
+
+ Native data which is allocated using CNI's <code>JvAllocBytes()</code>
+ function and stored in a <code>RawDataManaged</code> will be automatically
+ freed when the Java object it is associated with becomes unreachable. */
+
+public final class RawDataManaged
+{
+ private RawDataManaged() { }
+}
package java.lang;
import gnu.gcj.RawData;
+import gnu.gcj.RawDataManaged;
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1
RawData interp_frame;
// Our native data - points to an instance of struct natThread.
- private Object data;
+ private RawDataManaged data;
/**
* Allocates a new <code>Thread</code> object. This constructor has
#include <jvm.h>
#include <java-threads.h>
+#include <gnu/gcj/RawDataManaged.h>
#include <java/lang/Thread.h>
#include <java/lang/ThreadGroup.h>
#include <java/lang/IllegalArgumentException.h>
{
natThread *nt = (natThread *) _Jv_AllocBytes (sizeof (natThread));
- // The native thread data is kept in a Object field, not a RawData, so that
- // the GC allocator can be used and a finalizer run after the thread becomes
- // unreachable. Note that this relies on the GC's ability to finalize
- // non-Java objects. FIXME?
- data = reinterpret_cast<jobject> (nt);
+ data = (gnu::gcj::RawDataManaged *) nt;
// Register a finalizer to clean up the native thread resources.
_Jv_RegisterFinalizer (data, finalize_native);
projects / gcc.git / commitdiff