X-Git-Url: http://git.megacz.com/?p=org.ibex.core.git;a=blobdiff_plain;f=upstream%2Fgcc-3.3%2Fpatches%2Fzzz-inhibit.reflection.patch;fp=upstream%2Fgcc-3.3%2Fpatches%2Fzzz-inhibit.reflection.patch;h=c2a72c79a444c8543a73ebb292e8eab608a3901f;hp=0000000000000000000000000000000000000000;hb=a41252ba1e0f5dd90100aa2064c011268809c038;hpb=a6c4f7b784acf2269c33188982b0d479cc11a0f4 diff --git a/upstream/gcc-3.3/patches/zzz-inhibit.reflection.patch b/upstream/gcc-3.3/patches/zzz-inhibit.reflection.patch new file mode 100644 index 0000000..c2a72c7 --- /dev/null +++ b/upstream/gcc-3.3/patches/zzz-inhibit.reflection.patch @@ -0,0 +1,737 @@ +diff -rBubboehm-gc/configureboehm-gc/configure +---boehm-gc/configure Tue May 13 17:18:14 2003 ++++boehm-gc/configure Mon Mar 1 01:03:55 2004 +@@ -1181,9 +1181,9 @@ + if test "$ac_test_CFLAGS" = set; then + CFLAGS="$ac_save_CFLAGS" + elif test $ac_cv_prog_cc_g = yes; then +- CFLAGS="-g -O2" ++ CFLAGS="-g -Os -ffunction-sections -fdata-sections" + else +- CFLAGS="-O2" ++ CFLAGS="-Os -ffunction-sections -fdata-sections" + fi + else + GCC= +@@ -1275,9 +1275,9 @@ + if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS="$ac_save_CXXFLAGS" + elif test $ac_cv_prog_cxx_g = yes; then +- CXXFLAGS="-g -O2" ++ CXXFLAGS="-g -Os -ffunction-sections -fdata-sections" + else +- CXXFLAGS="-O2" ++ CXXFLAGS="-Os -ffunction-sections -fdata-sections" + fi + else + GXX= +diff -rBubgcc/dwarf2out.cgcc/dwarf2out.c +---gcc/dwarf2out.c Mon May 5 09:59:20 2003 ++++gcc/dwarf2out.c Sat Feb 28 02:37:20 2004 +@@ -1040,6 +1040,8 @@ + else if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM) + return; + ++ if (frame_pointer_needed) return; ++ + if (GET_CODE (insn) == BARRIER) + { + /* When we see a BARRIER, we know to reset args_size to 0. Usually +diff -rBubgcc/java/class.cgcc/java/class.c +---gcc/java/class.c Fri Feb 28 12:53:07 2003 ++++gcc/java/class.c Mon Mar 1 00:20:15 2004 +@@ -971,7 +971,7 @@ + tree type; + { + int is_compiled = is_compiled_class (type); +- if (is_compiled) ++ if (is_compiled || flag_inhibit_reflection) + { + tree ref, decl_name, decl; + if (TREE_CODE (type) == POINTER_TYPE) +@@ -1199,13 +1199,17 @@ + int resolved = is_compiled_class (type); + + START_RECORD_CONSTRUCTOR (finit, field_type_node); ++ if (!flag_inhibit_reflection) { + PUSH_FIELD_VALUE (finit, "name", build_utf8_ref (DECL_NAME (fdecl))); ++ } else { ++ PUSH_FIELD_VALUE (finit, "name", null_pointer_node); ++ } + if (resolved) + type = build_class_ref (type); + else + { ++ if (!flag_inhibit_reflection) { + tree signature = build_java_signature (type); +- + type = build_utf8_ref (unmangle_classname + (IDENTIFIER_POINTER (signature), + IDENTIFIER_LENGTH (signature))); +@@ -1209,6 +1213,9 @@ + type = build_utf8_ref (unmangle_classname + (IDENTIFIER_POINTER (signature), + IDENTIFIER_LENGTH (signature))); ++ } else { ++ type = null_pointer_node; ++ } + } + PUSH_FIELD_VALUE (finit, "type", type); + +@@ -1244,6 +1251,7 @@ + tree code; + #define ACC_TRANSLATED 0x4000 + int accflags = get_access_flags_from_decl (mdecl) | ACC_TRANSLATED; ++ int emitNames = 0; + + if (!flag_indirect_dispatch && DECL_VINDEX (mdecl) != NULL_TREE) + index = DECL_VINDEX (mdecl); +@@ -1254,6 +1262,12 @@ + if (DECL_RTL_SET_P (mdecl)) + code = build1 (ADDR_EXPR, nativecode_ptr_type_node, mdecl); + START_RECORD_CONSTRUCTOR (minit, method_type_node); ++ ++ emitNames = !flag_inhibit_reflection; ++ if (!METHOD_STATIC(mdecl)) emitNames = 1; ++ if (DECL_CLINIT_P(mdecl)) emitNames = 1; ++ if ((METHOD_STATIC(mdecl) && (strcmp(IDENTIFIER_POINTER(DECL_NAME(mdecl)),"main") == 0))) emitNames = 1; ++ if (emitNames) { + PUSH_FIELD_VALUE (minit, "name", + build_utf8_ref (DECL_CONSTRUCTOR_P (mdecl) ? + init_identifier_node +@@ -1266,6 +1280,10 @@ + (IDENTIFIER_POINTER(signature), + IDENTIFIER_LENGTH(signature))))); + } ++ } else { ++ PUSH_FIELD_VALUE (minit, "name", null_pointer_node); ++ PUSH_FIELD_VALUE (minit, "signature", null_pointer_node); ++ } + PUSH_FIELD_VALUE (minit, "accflags", build_int_2 (accflags, 0)); + PUSH_FIELD_VALUE (minit, "index", index); + PUSH_FIELD_VALUE (minit, "ncode", code); +@@ -1273,6 +1291,7 @@ + { + /* Compute the `throws' information for the method. */ + tree table = null_pointer_node; ++ if (!flag_inhibit_reflection) + if (DECL_FUNCTION_THROWS (mdecl) != NULL_TREE) + { + int length = 1 + list_length (DECL_FUNCTION_THROWS (mdecl)); +@@ -1473,6 +1493,7 @@ + DECL_INITIAL (field) = initial; + } + else ++ if (!flag_inhibit_reflection) + { + instance_field_count++; + instance_fields = tree_cons (NULL_TREE, init, instance_fields); +@@ -1480,6 +1501,9 @@ + } + } + field_count = static_field_count + instance_field_count; ++ ++ // we have to leave this here; part of the class initialization is the process ++ // of replacing utf8const's with String objects + if (field_count > 0) + { + static_fields = nreverse (static_fields); +@@ -1550,7 +1574,7 @@ + super = CLASSTYPE_SUPER (type); + if (super == NULL_TREE) + super = null_pointer_node; +- else if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl)))) ++ else if (flag_inhibit_reflection || (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (type_decl))))) + super = build_class_ref (super); + else + { +@@ -1576,7 +1600,7 @@ + tree child = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i); + tree iclass = BINFO_TYPE (child); + tree index; +- if (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass))))) ++ if (flag_inhibit_reflection || (assume_compiled (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (iclass)))))) + index = build_class_ref (iclass); + else + { +@@ -2225,6 +2249,7 @@ + index = 0; + method_list = otable_methods; + list = NULL_TREE; ++ if (!flag_inhibit_reflection) + while (method_list != NULL_TREE) + { + method = TREE_VALUE (method_list); +diff -rBubgcc/java/constants.cgcc/java/constants.c +---gcc/java/constants.c Mon Nov 18 07:46:32 2002 ++++gcc/java/constants.c Mon Mar 1 00:20:32 2004 +@@ -430,9 +430,13 @@ + int i; + for (i = outgoing_cpool->count; --i > 0; ) + { ++ if (!flag_inhibit_reflection) { + tags_list + = tree_cons (NULL_TREE, get_tag_node (outgoing_cpool->tags[i]), + tags_list); ++ } else { ++ tags_list = null_pointer_node; ++ } + data_list + = tree_cons (NULL_TREE, build_utf8_ref ((tree)outgoing_cpool->data[i]), + data_list); +@@ -446,7 +450,9 @@ + index_type = build_index_type (max_index); + + /* Add dummy 0'th element of constant pool. */ ++ if (!flag_inhibit_reflection) { + tags_list = tree_cons (NULL_TREE, get_tag_node (0), tags_list); ++ } + data_list = tree_cons (NULL_TREE, null_pointer_node, data_list); + + data_decl = TREE_OPERAND (build_constant_data_ref (), 0); +@@ -458,6 +464,7 @@ + rest_of_decl_compilation (data_decl, (char *) 0, 1, 0); + data_value = build_address_of (data_decl); + ++ if (!flag_inhibit_reflection) { + tags_type = build_array_type (unsigned_byte_type_node, index_type); + tags_decl = build_decl (VAR_DECL, mangled_classname ("_CT_", + current_class), +@@ -467,6 +474,9 @@ + NULL_TREE, tags_list); + rest_of_decl_compilation (tags_decl, (char*) 0, 1, 0); + tags_value = build_address_of (tags_decl); ++ } else { ++ tags_value = null_pointer_node; ++ } + } + else + { +diff -rBubgcc/java/java-tree.hgcc/java/java-tree.h +---gcc/java/java-tree.h Mon Nov 18 10:13:35 2002 ++++gcc/java/java-tree.h Thu Feb 26 15:01:38 2004 +@@ -225,6 +225,9 @@ + /* Encoding used for source files. */ + extern const char *current_encoding; + ++/** don't emit reflection information */ ++extern int flag_inhibit_reflection; ++ + /* The Java .class file that provides main_class; the main input file. */ + extern struct JCF *current_jcf; + +diff -rBubgcc/java/lang.cgcc/java/lang.c +---gcc/java/lang.c Sun Jan 5 07:03:25 2003 ++++gcc/java/lang.c Thu Feb 26 15:01:38 2004 +@@ -171,6 +171,9 @@ + /* The encoding of the source file. */ + const char *current_encoding = NULL; + ++/** don't emit reflection information */ ++int flag_inhibit_reflection = 0; ++ + /* When nonzero, report the now deprecated empty statements. */ + int flag_extraneous_semicolon; + +@@ -431,6 +434,13 @@ + { + flag_inline_functions = 1; + flag_really_inline = 1; ++ return 1; ++ } ++#undef ARG ++#define ARG "-finhibit-reflection" ++ if (strncmp (p, ARG, sizeof (ARG) - 1) == 0) ++ { ++ flag_inhibit_reflection = 1; + return 1; + } + #undef ARG +diff -rBublibjava/Makefile.inlibjava/Makefile.in +---libjava/Makefile.in Mon Mar 1 01:45:58 2004 ++++libjava/Makefile.in Sun Feb 29 22:09:27 2004 +@@ -174,10 +174,10 @@ + + WARNINGS = -W -Wall + AM_CXXFLAGS = -fno-rtti -fnon-call-exceptions \ +- -fdollars-in-identifiers \ ++ -fdollars-in-identifiers -ffunction-sections -fdata-sections \ + -Wswitch-enum \ + @LIBGCJ_CXXFLAGS@ @X_CFLAGS@ $(WARNINGS) -D_GNU_SOURCE \ +- -DPREFIX="\"$(prefix)\"" ++ -DPREFIX="\"$(prefix)\"" -Os + + @USING_GCC_TRUE@AM_CFLAGS = @USING_GCC_TRUE@@LIBGCJ_CFLAGS@ $(WARNINGS) + @USING_GCC_FALSE@AM_CFLAGS = @USING_GCC_FALSE@@LIBGCJ_CFLAGS@ +diff -rBublibjava/boehm.cclibjava/boehm.cc +---libjava/boehm.cc Thu Jan 2 21:19:53 2003 ++++libjava/boehm.cc Mon Mar 1 00:21:04 2004 +@@ -17,6 +17,7 @@ + + #include + #include ++#include + #include + + // More nastiness: the GC wants to define TRUE and FALSE. We don't +@@ -147,6 +149,7 @@ + for (int i = 0; i < c->method_count; ++i) + { + p = (ptr_t) c->methods[i].name; ++ if (p == NULL) continue; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, + cm1label); + p = (ptr_t) c->methods[i].signature; +@@ -164,9 +167,11 @@ + + #ifndef COMPACT_FIELDS + p = (ptr_t) field->name; ++ if (p == NULL) continue; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c8alabel); + #endif + p = (ptr_t) field->type; ++ if (p == NULL) continue; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c8blabel); + + // For the interpreter, we also need to mark the memory +@@ -258,6 +263,7 @@ + // Note: occasionally `klass' can be null. For instance, this + // can happen if a GC occurs between the point where an object + // is allocated and where the vtbl slot is set. ++ throw new java::lang::VirtualMachineError(); + while (klass && klass != &java::lang::Object::class$) + { + jfieldID field = JvGetFirstInstanceField (klass); +diff -rBublibjava/configurelibjava/configure +---libjava/configure Mon Mar 1 01:45:59 2004 ++++libjava/configure Sun Feb 29 22:13:11 2004 +@@ -1180,13 +1180,13 @@ + CFLAGS="$ac_save_CFLAGS" + elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then +- CFLAGS="-g -O2" ++ CFLAGS="-g -Os" + else + CFLAGS="-g" + fi + else + if test "$GCC" = yes; then +- CFLAGS="-O2" ++ CFLAGS="-Os" + else + CFLAGS= + fi +@@ -1287,9 +1287,9 @@ + if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS="$ac_save_CXXFLAGS" + elif test $ac_cv_prog_cxx_g = yes; then +- CXXFLAGS="-g -O2" ++ CXXFLAGS="-g -Os" + else +- CXXFLAGS="-O2" ++ CXXFLAGS="-Os" + fi + else + GXX= +@@ -1683,6 +1683,9 @@ + + + ++cat >> confdefs.h <<\EOF ++#undef USE_LTDL ++EOF + + + # Only use libltdl for native builds. +@@ -1697,9 +1700,9 @@ + + + DIRLTDL=libltdl +- cat >> confdefs.h <<\EOF +-#define USE_LTDL 1 +-EOF ++# cat >> confdefs.h <<\EOF ++##define USE_LTDL 1 ++#EOF + + # Sigh. Libtool's macro doesn't do the right thing. + INCLTDL="-I\$(top_srcdir)/libltdl $INCLTDL" +@@ -5644,7 +5647,7 @@ + fi + fi + +- test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2" ++ test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -Os" + + + +@@ -5798,7 +5801,7 @@ + echo $ac_n "checking for g++ -ffloat-store bug""... $ac_c" 1>&6 + echo "configure:5796: checking for g++ -ffloat-store bug" >&5 + save_CFLAGS="$CFLAGS" +-CFLAGS="-x c++ -O2 -ffloat-store" ++CFLAGS="-x c++ -Os -ffloat-store" + cat > conftest.$ac_ext <], , + [AC_MSG_RESULT(no)], + [AC_DEFINE(__NO_MATH_INLINES) +diff -rBublibjava/gnu/gcj/convert/BytesToUnicode.javalibjava/gnu/gcj/convert/BytesToUnicode.java +---libjava/gnu/gcj/convert/BytesToUnicode.java Mon Jul 30 13:24:17 2001 ++++libjava/gnu/gcj/convert/BytesToUnicode.java Fri Feb 27 04:17:13 2004 +@@ -65,7 +65,7 @@ + } + catch (Throwable ex) + { +- return new Input_8859_1(); ++ throw new UnsatisfiedLinkError(); + } + } + +@@ -100,6 +100,7 @@ + } + catch (Throwable ex) + { ++ /* + try + { + // We pass the original name to iconv and let it handle +@@ -108,9 +109,10 @@ + } + catch (Throwable _) + { ++ */ + throw new java.io.UnsupportedEncodingException(encoding + + " (" + ex + ')'); +- } ++ //} + } + } + +diff -rBublibjava/gnu/gcj/convert/IOConverter.javalibjava/gnu/gcj/convert/IOConverter.java +---libjava/gnu/gcj/convert/IOConverter.java Sun Sep 16 19:28:53 2001 ++++libjava/gnu/gcj/convert/IOConverter.java Sun Feb 29 01:53:14 2004 +@@ -20,7 +20,7 @@ + + // True if we have to do byte-order conversions on iconv() + // arguments. +- static protected boolean iconv_byte_swap; ++ static protected boolean iconv_byte_swap = false; + + static + { +@@ -64,7 +64,7 @@ + hash.put ("cseucpkdfmtjapanese", "EUCJIS"); + hash.put ("euc-jp", "EUCJIS"); + +- iconv_byte_swap = iconv_init (); ++ //iconv_byte_swap = iconv_init (); + } + + private static native boolean iconv_init (); +diff -rBublibjava/gnu/gcj/convert/UnicodeToBytes.javalibjava/gnu/gcj/convert/UnicodeToBytes.java +---libjava/gnu/gcj/convert/UnicodeToBytes.java Fri Aug 17 20:56:01 2001 ++++libjava/gnu/gcj/convert/UnicodeToBytes.java Fri Feb 27 04:17:02 2004 +@@ -63,7 +63,8 @@ + } + catch (Throwable ex) + { +- return new Output_8859_1(); ++ throw new UnsatisfiedLinkError(); ++ //return new Output_8859_1(); + } + } + +@@ -97,6 +98,7 @@ + } + catch (Throwable ex) + { ++ /* + try + { + // We pass the original name to iconv and let it handle +@@ -105,10 +107,11 @@ + } + catch (Throwable _) + { ++ */ + // Put the original exception in the throwable. + throw new java.io.UnsupportedEncodingException(encoding + " (" + + ex + ')'); +- } ++ //} + } + } + +diff -rBublibjava/gnu/gcj/runtime/FirstThread.javalibjava/gnu/gcj/runtime/FirstThread.java +---libjava/gnu/gcj/runtime/FirstThread.java Wed Oct 10 15:25:43 2001 ++++libjava/gnu/gcj/runtime/FirstThread.java Fri Feb 27 05:05:29 2004 +@@ -90,8 +90,10 @@ + // classes are linked in. Otherwise bootstrapping fails. These + // classes are only referred to via Class.forName(), so we add an + // explicit mention of them here. ++ /* + static final Class Kcert = java.security.cert.Certificate.class; + static final Class Kfile = gnu.gcj.protocol.file.Handler.class; + static final Class Khttp = gnu.gcj.protocol.http.Handler.class; + static final Class Kjar = gnu.gcj.protocol.jar.Handler.class; ++ */ + } +diff -rBublibjava/gnu/gcj/runtime/VMClassLoader.javalibjava/gnu/gcj/runtime/VMClassLoader.java +---libjava/gnu/gcj/runtime/VMClassLoader.java Sun Dec 8 16:03:59 2002 ++++libjava/gnu/gcj/runtime/VMClassLoader.java Fri Feb 27 04:20:56 2004 +@@ -14,13 +14,15 @@ + import java.util.StringTokenizer; + import java.net.URL; + +-public final class VMClassLoader extends java.net.URLClassLoader ++public final class VMClassLoader extends java.lang.ClassLoader //java.net.URLClassLoader + { + private VMClassLoader () + { ++ /* + super (init()); ++ */ + } +- ++ /* + private static URL[] init() + { + StringTokenizer st +@@ -40,7 +42,7 @@ + } + catch (java.net.MalformedURLException x) + { +- /* Ignore this path element */ ++ // Ignore this path element + } + } + // Add core:/ to the end of the java.class.path so any resources +@@ -58,7 +60,7 @@ + p.copyInto (urls); + return urls; + } +- ++*/ + /** This is overridden to search the internal hash table, which + * will only search existing linked-in classes. This will make + * the default implementation of loadClass (in ClassLoader) work right. +diff -rBublibjava/gnu/gcj/runtime/natVMClassLoader.cclibjava/gnu/gcj/runtime/natVMClassLoader.cc +---libjava/gnu/gcj/runtime/natVMClassLoader.cc Tue Dec 10 19:15:14 2002 ++++libjava/gnu/gcj/runtime/natVMClassLoader.cc Fri Feb 27 04:22:00 2004 +@@ -60,8 +60,9 @@ + } + + // Now try loading using the interpreter. ++ /* + if (! klass) + klass = java::net::URLClassLoader::findClass (name); +- ++ */ + return klass; + } +diff -rBublibjava/java/lang/Class.javalibjava/java/lang/Class.java +---libjava/java/lang/Class.java Tue Sep 3 14:33:46 2002 ++++libjava/java/lang/Class.java Sat Feb 28 22:48:09 2004 +@@ -241,6 +241,7 @@ + */ + public ProtectionDomain getProtectionDomain() + { ++ /* + SecurityManager sm = System.getSecurityManager(); + if (sm != null) + sm.checkPermission(ClassLoader.protectionDomainPermission); +@@ -248,9 +249,12 @@ + ProtectionDomain protectionDomain = getProtectionDomain0(); + + if (protectionDomain == null) ++ */ + return ClassLoader.unknownProtectionDomain; ++ /* + else + return protectionDomain; ++ */ + } + + public String toString () +diff -rBublibjava/java/lang/ClassLoader.javalibjava/java/lang/ClassLoader.java +---libjava/java/lang/ClassLoader.java Fri Jan 24 11:38:24 2003 ++++libjava/java/lang/ClassLoader.java Sat Feb 28 21:07:31 2004 +@@ -345,8 +345,8 @@ + // FIXME: should there be a special protection domain used for native code? + + // The permission required to check what a classes protection domain is. +- static final Permission protectionDomainPermission +- = new RuntimePermission("getProtectionDomain"); ++ //static final Permission protectionDomainPermission; ++ //= new RuntimePermission("getProtectionDomain"); + // The protection domain returned if we cannot determine it. + static ProtectionDomain unknownProtectionDomain; + // Protection domain to use when a class is defined without one specified. +@@ -355,12 +355,14 @@ + static + { + Permissions permissions = new Permissions(); +- permissions.add(new AllPermission()); +- unknownProtectionDomain = new ProtectionDomain(null, permissions); ++ //permissions.add(new AllPermission()); ++ //unknownProtectionDomain = new ProtectionDomain(null, permissions); + ++ /* + CodeSource cs = new CodeSource(null, null); + defaultProtectionDomain = + new ProtectionDomain(cs, Policy.getPolicy().getPermissions(cs)); ++ */ + } + + /** +diff -rBublibjava/java/lang/SecurityManager.javalibjava/java/lang/SecurityManager.java +---libjava/java/lang/SecurityManager.java Sun Dec 1 08:16:19 2002 ++++libjava/java/lang/SecurityManager.java Fri Feb 27 02:08:27 2004 +@@ -297,7 +297,8 @@ + public Object getSecurityContext() + { + // XXX Should be: return AccessController.getContext(); +- return new SecurityContext(getClassContext()); ++ //return new SecurityContext(getClassContext()); ++ return null; + } + + /** +diff -rBublibjava/java/lang/natClass.cclibjava/java/lang/natClass.cc +---libjava/java/lang/natClass.cc Thu May 1 14:52:35 2003 ++++libjava/java/lang/natClass.cc Mon Mar 1 01:00:12 2004 +@@ -72,8 +72,10 @@ + + _Jv_Utf8Const *name = _Jv_makeUtf8Const (buffer, length); + ++ /* + if (! _Jv_VerifyClassName (name)) + throw new java::lang::ClassNotFoundException (className); ++ */ + + jclass klass = (buffer[0] == '[' + ? _Jv_FindClassFromSignature (name->data, loader) +@@ -1518,7 +1520,7 @@ + return; + + klass->otable->state = 1; +- ++ return; + int index = 0; + _Jv_MethodSymbol sym = klass->otable_syms[0]; + +diff -rBublibjava/java/lang/natClassLoader.cclibjava/java/lang/natClassLoader.cc +---libjava/java/lang/natClassLoader.cc Thu Dec 19 11:32:17 2002 ++++libjava/java/lang/natClassLoader.cc Sun Feb 29 23:55:48 2004 +@@ -195,6 +195,7 @@ + _Jv_Constants *pool = &klass->constants; + for (int index = 1; index < pool->size; ++index) + { ++ /* + if (pool->tags[index] == JV_CONSTANT_Class) + { + _Jv_Utf8Const *name = pool->data[index].utf8; +@@ -217,12 +218,13 @@ + } + else if (pool->tags[index] == JV_CONSTANT_String) + { ++ */ + jstring str; + + str = _Jv_NewStringUtf8Const (pool->data[index].utf8); + pool->data[index].o = str; +- pool->tags[index] |= JV_CONSTANT_ResolvedFlag; +- } ++ //pool->tags[index] |= JV_CONSTANT_ResolvedFlag; ++ //} + } + + #ifdef INTERPRETER +@@ -253,10 +255,10 @@ + + if (klass->vtable == NULL) + _Jv_MakeVTable(klass); +- ++ /* + if (klass->otable != NULL && klass->otable->state == 0) + _Jv_LinkOffsetTable(klass); +- ++ */ + klass->notifyAll (); + + _Jv_PushClass (klass); +diff -rBublibjava/java/security/Security.javalibjava/java/security/Security.java +---libjava/java/security/Security.java Tue Dec 31 14:49:37 2002 ++++libjava/java/security/Security.java Sat Feb 28 21:33:32 2004 +@@ -60,9 +60,11 @@ + + static + { ++ /* + String base = System.getProperty("gnu.classpath.home.url"); + loadProviders(base, System.getProperty("gnu.classpath.vm.shortname")); + loadProviders(base, "classpath"); ++ */ + } + + // This class can't be instantiated. +diff -rBublibjava/libgcj.spec.inlibjava/libgcj.spec.in +---libjava/libgcj.spec.in Wed Feb 12 18:09:27 2003 ++++libjava/libgcj.spec.in Sun Feb 29 17:15:19 2004 +@@ -4,6 +4,7 @@ + # to link with libgcj. + # + %rename lib liborig +-*lib: -lgcj -lm @LIBICONV@ @GCSPEC@ @THREADSPEC@ @ZLIBSPEC@ @SYSTEMSPEC@ %(libgcc) %(liborig) ++*lib: -lm @LIBICONV@ @GCSPEC@ @THREADSPEC@ @ZLIBSPEC@ @SYSTEMSPEC@ %(libgcc) %(liborig) ++ ++*jc1: @HASH_SYNC_SPEC@ @DIVIDESPEC@ @CHECKREFSPEC@ @JC1GCSPEC@ @EXCEPTIONSPEC@ @BACKTRACESPEC@ @IEEESPEC@ -fkeep-inline-functions -fno-omit-frame-pointer -Os -ffunction-sections -fdata-sections + +-*jc1: @HASH_SYNC_SPEC@ @DIVIDESPEC@ @CHECKREFSPEC@ @JC1GCSPEC@ @EXCEPTIONSPEC@ @BACKTRACESPEC@ @IEEESPEC@ -fkeep-inline-functions +diff -rBublibjava/prims.cclibjava/prims.cc +---libjava/prims.cc Fri Apr 25 09:02:21 2003 ++++libjava/prims.cc Sat Feb 28 20:32:25 2004 +@@ -165,6 +165,7 @@ + { + int len; + _Jv_ushort *aptr, *bptr; ++ if (a == NULL || b == NULL) return false; + if (a == b) + return true; + if (a->hash != b->hash) +@@ -188,6 +189,7 @@ + jboolean + _Jv_equal (Utf8Const* a, jstring str, jint hash) + { ++ if (a == NULL) return false; + if (a->hash != (_Jv_ushort) hash) + return false; + jint len = str->length(); +@@ -210,6 +212,7 @@ + jboolean + _Jv_equaln (Utf8Const *a, jstring str, jint n) + { ++ if (a == NULL) return false; + jint len = str->length(); + jint i = 0; + jchar *sptr = _Jv_GetStringChars (str); +@@ -936,7 +939,7 @@ + + _Jv_platform_initialize (); + +- _Jv_JNI_Init (); ++ // _Jv_JNI_Init (); + + _Jv_GCInitializeFinalizers (&::gnu::gcj::runtime::FinalizerThread::finalizerReady); +