gcc/java:

[pf3gnuchains/gcc-fork.git] / gcc / java / lang.c

diff --git a/gcc/java/lang.c b/gcc/java/lang.c
index 3e4ba49..b89bdf9 100644 (file)
--- a/gcc/java/lang.c
+++ b/gcc/java/lang.c
@@ -58,7 +58,7 @@ static void put_decl_string (const char *, int);
 static void put_decl_node (tree);
 static void java_print_error_function (diagnostic_context *, const char *);
 static tree java_tree_inlining_walk_subtrees (tree *, int *, walk_tree_fn,
-                                             void *, void *);
+                                             void *, struct pointer_set_t *);
 static int merge_init_test_initialization (void * *, void *);
 static int inline_init_test_initialization (void * *, void *);
 static bool java_can_use_bit_fields_p (void);
@@ -128,13 +128,23 @@ int flag_wall = 0;
 /* The encoding of the source file.  */
 const char *current_encoding = NULL;
 
+/* When nonzero, report use of deprecated classes, methods, or fields.  */
+int flag_deprecated = 1;
+
+/* When zero, don't optimize static class initialization. This flag shouldn't
+   be tested alone, use STATIC_CLASS_INITIALIZATION_OPTIMIZATION_P instead.  */
+/* FIXME: Make this work with gimplify.  */
+/* int flag_optimize_sci = 0;  */
+
+/* Don't attempt to verify invocations.  */
+int flag_verify_invocations = 0; 
+
+/* True if the new bytecode verifier should be used.  */
+int flag_new_verifier = 0;
+
 /* When nonzero, print extra version information.  */
 static int v_flag = 0;
 
-/* Set nonzero if the user specified -finline-functions on the command
-   line.  */
-int flag_really_inline = 0;
-
 JCF *current_jcf;
 
 /* Variable controlling how dependency tracking is enabled in
@@ -322,11 +332,6 @@ java_handle_option (size_t scode, const char *arg, int value)
       jcf_path_extdirs_arg (arg);
       break;
 
-    case OPT_finline_functions:
-      flag_inline_functions = value;
-      flag_really_inline = value;
-      break;
-
     case OPT_foutput_class_dir_:
       jcf_write_base_directory = arg;
       break;
@@ -355,9 +360,6 @@ java_init (void)
   flag_minimal_debug = 0;
 #endif
 
-  if (flag_inline_functions)
-    flag_inline_trees = 1;
-
   /* FIXME: Indirect dispatch isn't yet compatible with static class
      init optimization.  */
   if (flag_indirect_dispatch)
@@ -526,7 +528,7 @@ java_print_error_function (diagnostic_context *context ATTRIBUTE_UNUSED,
        fprintf (stderr, "%s: ", file);
 
       last_error_function_context = DECL_CONTEXT (current_function_decl);
-      fprintf (stderr, "In class `%s':\n",
+      fprintf (stderr, "In class '%s':\n",
               lang_printable_name (last_error_function_context, 0));
     }
   if (last_error_function != current_function_decl)
@@ -539,7 +541,7 @@ java_print_error_function (diagnostic_context *context ATTRIBUTE_UNUSED,
       else
        {
          const char *name = lang_printable_name (current_function_decl, 2);
-         fprintf (stderr, "In %s `%s':\n",
+         fprintf (stderr, "In %s '%s':\n",
                   (DECL_CONSTRUCTOR_P (current_function_decl) ? "constructor"
                    : "method"),
                   name);
@@ -603,9 +605,17 @@ java_post_options (const char **pfilename)
   if (!flag_no_inline)
     flag_no_inline = 1;
   if (flag_inline_functions)
+    flag_inline_trees = 2;
+
+  /* An absolute requirement: if we're not using indirect dispatch, we
+     must always verify everything.  */
+  if (! flag_indirect_dispatch)
+    flag_verify_invocations = true;
+  else
     {
-      flag_inline_trees = 2;
-      flag_inline_functions = 0;
+      /* If we are using indirect dispatch, then we want the new
+        verifier as well.  */
+      flag_new_verifier = 1;
     }
 
   /* Open input file.  */
@@ -706,7 +716,7 @@ java_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
                                  int *subtrees ATTRIBUTE_UNUSED,
                                  walk_tree_fn func ATTRIBUTE_UNUSED,
                                  void *data ATTRIBUTE_UNUSED,
-                                 void *htab ATTRIBUTE_UNUSED)
+                                 struct pointer_set_t *pset ATTRIBUTE_UNUSED)
 {
   enum tree_code code;
   tree result;
@@ -714,7 +724,7 @@ java_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
 #define WALK_SUBTREE(NODE)                             \
   do                                                   \
     {                                                  \
-      result = walk_tree (&(NODE), func, data, htab);  \
+      result = walk_tree (&(NODE), func, data, pset);  \
       if (result)                                      \
        return result;                                  \
     }                                                  \
@@ -731,6 +741,10 @@ java_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
       WALK_SUBTREE (BLOCK_EXPR_BODY (t));
       return NULL_TREE;
 
+    case EXIT_BLOCK_EXPR:
+      *subtrees = 0;
+      return NULL_TREE;
+
     default:
       return NULL_TREE;
     }
@@ -921,13 +935,12 @@ java_dump_tree (void *dump_info, tree t)
       return true;
 
     case LABELED_BLOCK_EXPR:
-      dump_child ("label", TREE_OPERAND (t, 0));
-      dump_child ("block", TREE_OPERAND (t, 1));
+      dump_child ("label", LABELED_BLOCK_LABEL (t));
+      dump_child ("block", LABELED_BLOCK_BODY (t));
       return true;
 
     case EXIT_BLOCK_EXPR:
-      dump_child ("block", TREE_OPERAND (t, 0));
-      dump_child ("val", TREE_OPERAND (t, 1));
+      dump_child ("block", EXIT_BLOCK_LABELED_BLOCK (t));
       return true;
 
     case BLOCK:
@@ -984,6 +997,10 @@ java_get_callee_fndecl (tree call_expr)
 
   HOST_WIDE_INT index;
 
+  /* FIXME: This is disabled because we end up passing calls through
+     the PLT, and we do NOT want to do that.  */
+  return NULL;
+
   if (TREE_CODE (call_expr) != CALL_EXPR)
     return NULL;
   method = TREE_OPERAND (call_expr, 0);