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);
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
-const char tree_code_type[] = {
+const enum tree_code_class tree_code_type[] = {
#include "tree.def"
- 'x',
+ tcc_exceptional,
#include "java-tree.def"
};
#undef DEFTREECODE
const char *resource_name;
-int flag_emit_class_files = 0;
-
-/* Nonzero if input file is a file with a list of filenames to compile. */
-
-int flag_filelist_file = 0;
-
/* When nonzero, we emit xref strings. Values of the flag for xref
backends are defined in xref_flag_table, xref.c. */
/* When nonzero, -Wall was turned on. */
int flag_wall = 0;
-/* When nonzero, check for redundant modifier uses. */
-int flag_redundant = 0;
-
-/* When nonzero, call a library routine to do integer divisions. */
-int flag_use_divide_subroutine = 1;
-
-/* When nonzero, generate code for the Boehm GC. */
-int flag_use_boehm_gc = 0;
-
-/* When nonzero, assume the runtime uses a hash table to map an
- object to its synchronization structure. */
-int flag_hash_synchronization;
-
-/* When nonzero, permit the use of the assert keyword. */
-int flag_assert = 1;
-
-/* When nonzero, assume all native functions are implemented with
- JNI, not CNI. */
-int flag_jni = 0;
-
-/* When nonzero, warn when source file is newer than matching class
- file. */
-int flag_newer = 1;
-
-/* When nonzero, generate checks for references to NULL. */
-int flag_check_references = 0;
-
/* The encoding of the source file. */
const char *current_encoding = NULL;
-/* When nonzero, report the now deprecated empty statements. */
-int flag_extraneous_semicolon;
-
/* When nonzero, report use of deprecated classes, methods, or fields. */
int flag_deprecated = 1;
-/* When nonzero, always check for a non gcj generated classes archive. */
-int flag_force_classes_archive_check;
-
/* 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;
+/* int flag_optimize_sci = 0; */
-/* When nonzero, use offset tables for virtual method calls
- in order to improve binary compatibility. */
-int flag_indirect_dispatch = 0;
+/* Don't attempt to verify invocations. */
+int flag_verify_invocations = 0;
-/* When zero, don't generate runtime array store checks. */
-int flag_store_check = 1;
+/* 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
switch (code)
{
- default:
- abort();
-
case OPT_I:
jcf_path_include_arg (arg);
break;
set_Wunused (value);
break;
- case OPT_Wdeprecated:
- flag_deprecated = value;
- break;
-
- case OPT_Wextraneous_semicolon:
- flag_extraneous_semicolon = value;
- break;
-
- case OPT_Wout_of_date:
- flag_newer = value;
- break;
-
- case OPT_Wredundant_modifiers:
- flag_redundant = value;
- break;
-
- case OPT_fassert:
- flag_assert = value;
- break;
-
case OPT_fenable_assertions_:
add_enable_assert (arg, value);
break;
jcf_path_bootclasspath_arg (arg);
break;
- case OPT_fcheck_references:
- flag_check_references = value;
- break;
-
case OPT_fclasspath_:
case OPT_fCLASSPATH_:
jcf_path_classpath_arg (arg);
return 0;
break;
- case OPT_femit_class_file:
- case OPT_femit_class_files:
- flag_emit_class_files = value;
- break;
-
case OPT_fencoding_:
current_encoding = arg;
break;
jcf_path_extdirs_arg (arg);
break;
- case OPT_ffilelist_file:
- flag_filelist_file = value;
- break;
-
- case OPT_fforce_classes_archive_check:
- flag_force_classes_archive_check = value;
- break;
-
- case OPT_fhash_synchronization:
- flag_hash_synchronization = value;
- break;
-
- case OPT_findirect_dispatch:
- flag_indirect_dispatch = value;
- break;
-
- case OPT_finline_functions:
- flag_inline_functions = value;
- flag_really_inline = value;
- break;
-
- case OPT_fjni:
- flag_jni = value;
- break;
-
- case OPT_foptimize_static_class_initialization:
- flag_optimize_sci = value;
- break;
-
case OPT_foutput_class_dir_:
jcf_write_base_directory = arg;
break;
- case OPT_fstore_check:
- flag_store_check = value;
- break;
-
- case OPT_fuse_boehm_gc:
- flag_use_boehm_gc = value;
- break;
-
- case OPT_fuse_divide_subroutine:
- flag_use_divide_subroutine = value;
- break;
-
case OPT_version:
v_flag = 1;
break;
+
+ default:
+ if (cl_options[code].flags & CL_Java)
+ break;
+ abort();
}
return 1;
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)
node = TREE_TYPE (node);
was_pointer = 1;
}
- if (TREE_CODE_CLASS (TREE_CODE (node)) == 'd'
- && DECL_NAME (node) != NULL_TREE)
+ if (DECL_P (node) && DECL_NAME (node) != NULL_TREE)
{
if (TREE_CODE (node) == FUNCTION_DECL)
{
else
put_decl_node (DECL_NAME (node));
}
- else if (TREE_CODE_CLASS (TREE_CODE (node)) == 't'
- && TYPE_NAME (node) != NULL_TREE)
+ else if (TYPE_P (node) && TYPE_NAME (node) != NULL_TREE)
{
if (TREE_CODE (node) == RECORD_TYPE && TYPE_ARRAY_P (node))
{
which is also called directly by java_print_error_function. */
const char *
-lang_printable_name (tree decl, int v __attribute__ ((__unused__)))
+lang_printable_name (tree decl, int v)
{
decl_bufpos = 0;
- put_decl_node (decl);
- put_decl_string ("", 1);
- return decl_buf;
-}
-
-/* Does the same thing that lang_printable_name, but add a leading
- space to the DECL name string -- With Leading Space. */
-
-const char *
-lang_printable_name_wls (tree decl, int v __attribute__ ((__unused__)))
-{
- decl_bufpos = 1;
- put_decl_node (decl);
+ if (v == 0 && TREE_CODE (decl) == FUNCTION_DECL)
+ put_decl_node (DECL_NAME (decl));
+ else
+ put_decl_node (decl);
put_decl_string ("", 1);
- decl_buf [0] = ' ';
return decl_buf;
}
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)
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);
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. */
}
}
}
+#ifdef USE_MAPPED_LOCATION
+ linemap_add (&line_table, LC_ENTER, false, filename, 0);
+ linemap_add (&line_table, LC_RENAME, false, "<built-in>", 0);
+#endif
/* Initialize the compiler back end. */
return false;
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;
#define WALK_SUBTREE(NODE) \
do \
{ \
- result = walk_tree (&(NODE), func, data, htab); \
+ result = walk_tree (&(NODE), func, data, pset); \
if (result) \
return result; \
} \
WALK_SUBTREE (BLOCK_EXPR_BODY (t));
return NULL_TREE;
+ case EXIT_BLOCK_EXPR:
+ *subtrees = 0;
+ return NULL_TREE;
+
default:
return NULL_TREE;
}
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:
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);