FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

re PR libgcj/16923 (-D* Options passed to JNI_CreateJavaVM are ignored)

Browse source 
2005-02-23  Thomas Fitzsimmons  <fitzsim@redhat.com>

	PR libgcj/16923
	* gcj.texi (Invocation): Add descriptions of JvVMInitArgs and
	JvVMOption.

2005-02-23  Thomas Fitzsimmons  <fitzsim@redhat.com>

	PR libgcj/16923
	* jni.cc (JNI_CreateJavaVM): Check JNI version.  Cast args to
	JvVMInitArgs.  Pass args to _Jv_CreateJavaVM and check return
	value.  Move argument parsing code to prims.cc.
	* prims.cc (no_properties): Remove.
	(_Jv_Compiler_Properties): Initialize to NULL.
	(_Jv_Properties_Count): Initialize to 0.
	(parse_verbose_args): New function.
	(parse_init_args): New function.
	(_Jv_CreateJavaVM): Call parse_init_args.
	(_Jv_RunMain): Check return value of _Jv_CreateJavaVM.
	* gcj/cni.h (JvVMOption): New struct.
	(JvVMInitArgs): Likewise.
	(JvCreateJavaVM): Declare vm_args as JvVMInitArgs* rather than
	void*.
	* libjava/gcj/javaprims.h (_Jv_VMOption): New struct.
	(_Jv_VMInitArgs): Likewise.
	* include/java-props.h (_Jv_Properties_Count): Declare.
	* java/lang/natRuntime.cc (insertSystemProperties): Use
	_Jv_Properties_Count in for loop exit condition.
	* testsuite/libjava.jni/jni.exp
	(gcj_invocation_compile_c_to_binary): New procedure.
	(gcj_invocation_test_one): Likewise.
	(gcj_jni_run): Run JNI invocation API tests.
	* testsuite/libjava.jni/invocation/PR16923.c,
	testsuite/libjava.jni/invocation/PR16923.java,
	testsuite/libjava.jni/invocation/PR16923.out: New test.

From-SVN: r95459
This commit is contained in:
Thomas Fitzsimmons 2005-02-23 17:36:26 +00:00 • committed by Thomas Fitzsimmons
parent c150a271b1
commit bc71e4a22b
13 changed files with 424 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

30
libjava/ChangeLog
View file

@ -1,3 +1,33 @@
2005-02-23 Thomas Fitzsimmons <fitzsim@redhat.com>
PR libgcj/16923
* jni.cc (JNI_CreateJavaVM): Check JNI version. Cast args to
JvVMInitArgs. Pass args to _Jv_CreateJavaVM and check return
value. Move argument parsing code to prims.cc.
* prims.cc (no_properties): Remove.
(_Jv_Compiler_Properties): Initialize to NULL.
(_Jv_Properties_Count): Initialize to 0.
(parse_verbose_args): New function.
(parse_init_args): New function.
(_Jv_CreateJavaVM): Call parse_init_args.
(_Jv_RunMain): Check return value of _Jv_CreateJavaVM.
* gcj/cni.h (JvVMOption): New struct.
(JvVMInitArgs): Likewise.
(JvCreateJavaVM): Declare vm_args as JvVMInitArgs* rather than
void*.
* libjava/gcj/javaprims.h (_Jv_VMOption): New struct.
(_Jv_VMInitArgs): Likewise.
* include/java-props.h (_Jv_Properties_Count): Declare.
* java/lang/natRuntime.cc (insertSystemProperties): Use
_Jv_Properties_Count in for loop exit condition.
* testsuite/libjava.jni/jni.exp
(gcj_invocation_compile_c_to_binary): New procedure.
(gcj_invocation_test_one): Likewise.
(gcj_jni_run): Run JNI invocation API tests.
* testsuite/libjava.jni/invocation/PR16923.c,
testsuite/libjava.jni/invocation/PR16923.java,
testsuite/libjava.jni/invocation/PR16923.out: New test.
2005-02-23 Michael Koch <konqueror@gmx.de>
* Makefile.am: Added new file gnu/java/nio/ChannelReader.java.

6
libjava/gcj/cni.h
View file

@ -17,6 +17,7 @@ details. */
#include <java/lang/Class.h>
#include <gcj/array.h>
#include <gcj/javaprims.h>
#include <string.h>
@ -113,8 +114,11 @@ JvFree (void *ptr)
return _Jv_Free (ptr);
}
typedef struct _Jv_VMOption JvVMOption;
typedef struct _Jv_VMInitArgs JvVMInitArgs;
extern inline jint
JvCreateJavaVM (void* vm_args)
JvCreateJavaVM (JvVMInitArgs* vm_args)
{
return _Jv_CreateJavaVM (vm_args);
}

25
libjava/gcj/javaprims.h
View file

@ -487,7 +487,30 @@ extern "C" jsize _Jv_GetStringUTFLength (jstring);
extern "C" jsize _Jv_GetStringUTFRegion (jstring, jsize, jsize, char *);
extern "C" jint _Jv_hashUtf8String (char*, int);
extern jint _Jv_CreateJavaVM (void* /*vm_args*/);
struct _Jv_VMOption
{
// a VM initialization option
char* optionString;
// extra information associated with this option
void* extraInfo;
};
struct _Jv_VMInitArgs
{
// for compatibility with JavaVMInitArgs
jint version;
// number of VM initialization options
jint nOptions;
// an array of VM initialization options
struct _Jv_VMOption* options;
// true if the option parser should ignore unrecognized options
jboolean ignoreUnrecognized;
};
extern jint _Jv_CreateJavaVM (struct _Jv_VMInitArgs*);
void
_Jv_ThreadRun (java::lang::Thread* thread);

1
libjava/include/java-props.h
View file

@ -21,6 +21,7 @@ typedef struct
// Set to NULL-terminated list of properties set at compile time.
extern const char **_Jv_Compiler_Properties;
extern int _Jv_Properties_Count;
// The JAR file to add to the beginning of java.class.path.
extern const char *_Jv_Jar_Class_Path;

2
libjava/java/lang/natRuntime.cc
View file

@ -557,7 +557,7 @@ java::lang::Runtime::insertSystemProperties (java::util::Properties *newprops)
// `-D'. Important: after this point, the only properties that
// should be set are those which either the user cannot meaningfully
// override, or which augment whatever value the user has provided.
for (int i = 0; _Jv_Compiler_Properties[i]; ++i)
for (int i = 0; i < _Jv_Properties_Count; ++i)
{
const char *s, *p;
// Find the `='.

53
libjava/jni.cc
View file

@ -2498,7 +2498,16 @@ JNI_CreateJavaVM (JavaVM **vm, void **penv, void *args)
{
JvAssert (! the_vm);
_Jv_CreateJavaVM (NULL);
jint version = * (jint *) args;
// We only support 1.2 and 1.4.
if (version != JNI_VERSION_1_2 && version != JNI_VERSION_1_4)
return JNI_EVERSION;
JvVMInitArgs* vm_args = reinterpret_cast<JvVMInitArgs *> (args);
jint result = _Jv_CreateJavaVM (vm_args);
if (result)
return result;
// FIXME: synchronize
JavaVM *nvm = (JavaVM *) _Jv_MallocUnchecked (sizeof (JavaVM));
@ -2506,48 +2515,6 @@ JNI_CreateJavaVM (JavaVM **vm, void **penv, void *args)
return JNI_ERR;
nvm->functions = &_Jv_JNI_InvokeFunctions;
// Parse the arguments.
if (args != NULL)
{
jint version = * (jint *) args;
// We only support 1.2 and 1.4.
if (version != JNI_VERSION_1_2 && version != JNI_VERSION_1_4)
return JNI_EVERSION;
JavaVMInitArgs *ia = reinterpret_cast<JavaVMInitArgs *> (args);
for (int i = 0; i < ia->nOptions; ++i)
{
if (! strcmp (ia->options[i].optionString, "vfprintf")
|| ! strcmp (ia->options[i].optionString, "exit")
|| ! strcmp (ia->options[i].optionString, "abort"))
{
// We are required to recognize these, but for now we
// don't handle them in any way. FIXME.
continue;
}
else if (! strncmp (ia->options[i].optionString,
"-verbose", sizeof ("-verbose") - 1))
{
// We don't do anything with this option either. We
// might want to make sure the argument is valid, but we
// don't really care all that much for now.
continue;
}
else if (! strncmp (ia->options[i].optionString, "-D", 2))
{
// FIXME.
continue;
}
else if (ia->ignoreUnrecognized)
{
if (ia->options[i].optionString[0] == '_'
|| ! strncmp (ia->options[i].optionString, "-X", 2))
continue;
}
return JNI_ERR;
}
}
jint r =_Jv_JNI_AttachCurrentThread (nvm, penv, NULL);
if (r < 0)
return r;

181
libjava/prims.cc
View file

@ -80,10 +80,9 @@ static java::lang::OutOfMemoryError *no_memory;
// functions are changed to take a size_t argument instead of jint.
#define MAX_OBJECT_SIZE ((1<<31) - 1)
static const char *no_properties[] = { NULL };
// Properties set at compile time.
const char **_Jv_Compiler_Properties = no_properties;
const char **_Jv_Compiler_Properties = NULL;
int _Jv_Properties_Count = 0;
// The JAR file to add to the beginning of java.class.path.
const char *_Jv_Jar_Class_Path;
@ -909,16 +908,181 @@ namespace gcj
bool runtimeInitialized = false;
}
static jint
parse_verbose_args (char* option_string,
bool ignore_unrecognized)
{
size_t len = sizeof ("-verbose");
if (strlen (option_string) < len)
return -1;
if (option_string[len] == ':'
&& option_string[len + 1] != '\0')
{
char* verbose_args = option_string + len + 1;
size_t last = 0;
do
{
if (! strncmp (verbose_args,
"gc", (last = sizeof ("gc")) - 1)
&& (verbose_args[last] == '\0'
|| verbose_args[last] == ','))
{
// FIXME: we should add functions to boehm-gc that
// toggle GC_print_stats, GC_PRINT_ADDRESS_MAP and
// GC_print_back_height.
}
else if (! strncmp (verbose_args,
"class",
(last = sizeof ("class")) - 1)
&& (verbose_args[last] == '\0'
|| verbose_args[last] == ','))
{
gcj::verbose_class_flag = true;
}
else if (! strncmp (verbose_args, "jni",
(last = sizeof ("jni")) - 1)
&& (verbose_args[last] == '\0'
|| verbose_args[last] == ','))
{
// FIXME: enable JNI messages.
}
else if (ignore_unrecognized
&& verbose_args[0] == 'X')
{
// ignore unrecognized non-standard verbose option
last = 0;
while (verbose_args[last] != '\0'
&& verbose_args[last++] != ',');
}
if (strlen (verbose_args) >= last)
{
if (verbose_args[last] == ',')
{
if (verbose_args[last + 1] == '\0')
// trailing comma
return -1;
else
{
verbose_args = verbose_args + last + 1;
last = 0;
}
}
// here verbose_args[last] is either '\0' or
// the first character in the next verbose
// argument.
}
else
// partial option
return -1;
// verbose_args[last] will be '\0' here if we're
// done.
}
while (verbose_args[last] != '\0');
}
else if (option_string[len] == 'g'
&& option_string[len + 1] == 'c'
&& option_string[len + 2] == '\0')
{
// FIXME: we should add functions to boehm-gc that
// toggle GC_print_stats, GC_PRINT_ADDRESS_MAP and
// GC_print_back_height.
return 0;
}
else if (option_string[len] == '\0')
{
gcj::verbose_class_flag = true;
return 0;
}
else
{
// unrecognized option beginning with -verbose
return -1;
}
return 0;
}
static jint
parse_init_args (JvVMInitArgs* vm_args)
{
// if _Jv_Compiler_Properties is non-NULL then it needs to be
// re-allocated dynamically.
if (_Jv_Compiler_Properties)
{
const char** props = _Jv_Compiler_Properties;
_Jv_Compiler_Properties = NULL;
for (int i = 0; props[i]; i++)
{
_Jv_Compiler_Properties = (const char**) _Jv_Realloc
(_Jv_Compiler_Properties,
(_Jv_Properties_Count + 1) * sizeof (const char*));
_Jv_Compiler_Properties[_Jv_Properties_Count++] = props[i];
}
}
if (vm_args == NULL)
return 0;
for (int i = 0; i < vm_args->nOptions; ++i)
{
char* option_string = vm_args->options[i].optionString;
if (! strcmp (option_string, "vfprintf")
|| ! strcmp (option_string, "exit")
|| ! strcmp (option_string, "abort"))
{
// FIXME: we are required to recognize these, but for
// now we don't handle them in any way.
continue;
}
else if (! strncmp (option_string,
"-verbose", sizeof ("-verbose") - 1))
{
jint result = parse_verbose_args (option_string,
vm_args->ignoreUnrecognized);
if (result < 0)
return result;
}
else if (! strncmp (option_string, "-D", 2))
{
_Jv_Compiler_Properties = (const char**) _Jv_Realloc
(_Jv_Compiler_Properties,
(_Jv_Properties_Count + 1) * sizeof (char*));
_Jv_Compiler_Properties[_Jv_Properties_Count++] =
strdup (option_string + 2);
continue;
}
else if (vm_args->ignoreUnrecognized)
{
if (option_string[0] == '_'
|| ! strncmp (option_string, "-X", 2))
continue;
}
}
return 0;
}
jint
_Jv_CreateJavaVM (void* /*vm_args*/)
_Jv_CreateJavaVM (JvVMInitArgs* vm_args)
{
using namespace gcj;
if (runtimeInitialized)
return -1;
runtimeInitialized = true;
jint result = parse_init_args (vm_args);
if (result < 0)
return -1;
PROCESS_GCJ_PROPERTIES;
/* Threads must be initialized before the GC, so that it inherits the
@ -1016,7 +1180,12 @@ _Jv_RunMain (jclass klass, const char *name, int argc, const char **argv,
// is initialized.
if (is_jar)
_Jv_Jar_Class_Path = strdup (name);
_Jv_CreateJavaVM (NULL);
if (_Jv_CreateJavaVM (NULL) < 0)
{
fprintf (stderr, "libgcj: couldn't create virtual machine\n");
exit (1);
}
// Get the Runtime here. We want to initialize it before searching
// for `main'; that way it will be set up if `main' is a JNI method.

43
libjava/testsuite/libjava.jni/invocation/PR16923.c Normal file
View file

@ -0,0 +1,43 @@
#include <assert.h>
#include <jni.h>
union env_union
{
void *void_env;
JNIEnv *jni_env;
};
int
main (int argc, const char** argv)
{
union env_union tmp;
JNIEnv* env;
JavaVM* jvm;
JavaVMInitArgs vm_args;
JavaVMOption options[1];
jclass class_id;
jmethodID method_id;
jint result;
options[0].optionString = "-DPR16923=optionReceived";
vm_args.version = JNI_VERSION_1_2;
vm_args.ignoreUnrecognized = JNI_TRUE;
vm_args.options = options;
vm_args.nOptions = 1;
result = JNI_CreateJavaVM (&jvm, &tmp.void_env, &vm_args);
assert (result >= 0);
env = tmp.jni_env;
class_id = (*env)->FindClass (env, "PR16923");
assert (class_id);
method_id = (*env)->GetStaticMethodID (env, class_id, "printIt", "()V");
assert (method_id);
(*env)->CallStaticVoidMethod (env, class_id, method_id, NULL);
return 0;
}

7
libjava/testsuite/libjava.jni/invocation/PR16923.java Normal file
View file

@ -0,0 +1,7 @@
public class PR16923
{
public static void printIt ()
{
System.out.println (System.getProperty ("PR16923"));
}
}

1
libjava/testsuite/libjava.jni/invocation/PR16923.out Normal file
View file

@ -0,0 +1 @@
optionReceived

86
libjava/testsuite/libjava.jni/jni.exp
View file

@ -181,6 +181,85 @@ proc gcj_jni_test_one {file} {
return 1
}
# Compile a single C file and produce a binary. OPTIONS is a list of
# options to pass to the compiler. Returns 0 on failure, 1 on
# success.
proc gcj_jni_invocation_compile_c_to_binary {file {options {}}} {
global srcdir
global host_triplet
verbose "options: $options"
set options_cxx $options
set options ""
set filename [file tail $file]
set name [file rootname $filename]
# Find jni.h.
lappend options "additional_flags=-I$srcdir/../include"
# Append C++ options
lappend options "additional_flags=$options_cxx"
set x [libjava_prune_warnings \
[target_compile $file $name executable $options]]
if {$x != ""} {
verbose "target_compile failed: $x" 2
fail "$filename compilation"
return 0
}
pass "$filename compilation"
return 1
}
# Do all the work for a single invocation API test. Return 0 on
# failure.
proc gcj_jni_invocation_test_one {file} {
global runtests
global host_triplet
global INTERPRETER
# The base name. We use it for several purposes.
set main [file rootname [file tail $file]]
if {! [runtest_file_p $runtests $main]} {
# Simply skip it.
return 1
}
if {! [bytecompile_file $file [pwd]]} {
fail "bytecompile $file"
# FIXME - should use `untested' on all remaining tests.
# But that is hard.
return 0
}
pass "bytecompile $file"
set cfile [file rootname $file].c
set cxxflags "-lgcj"
if {! [gcj_jni_invocation_compile_c_to_binary $cfile $cxxflags]} {
# FIXME
return 0
}
set resultfile [file rootname $file].out
if {! [gcj_invoke $main $resultfile ""]} {
# FIXME
return 0
}
# We purposely ignore errors here; we still want to run the other
# appropriate tests.
set errname [file rootname [file tail $file]]
# When we succeed we remove all our clutter.
eval gcj_cleanup [glob -nocomplain -- ${main}.*] \
[list $main]
return 1
}
# Run the JNI tests.
proc gcj_jni_run {} {
global srcdir subdir
@ -193,6 +272,13 @@ proc gcj_jni_run {} {
foreach x $srcfiles {
gcj_jni_test_one $x
}
# Run JNI invocation API tests
catch { lsort [glob -nocomplain ${srcdir}/${subdir}/invocation/*.java] } srcfiles
foreach x $srcfiles {
gcj_jni_invocation_test_one $x
}
} else {
verbose "JNI tests not run in cross-compilation environment"
}