770ae6cc71
modify sizes to be unsigned and use HOST_WIDE_INT.
* alias.c (reg_known_value_size): Now unsigned.
* c-typeck.c (build_unary_op, case ADDR_EXPR): Use byte_position.
(really_start_incremental_init): Use bitsize_zero_node.
(push_init_level, pop_init_level, output_init_element): Likewise.
Use bitsize_unit_node and bitsize_one_node.
(output_pending_init_elements, process_init_element): Likewise.
* combine.c (combine_max_regno, reg_sign_bit_copies): Now unsigned.
(make_extraction): Position and length HOST_WIDE_INT and unsigned
HOST_WIDE_INT, respectively.
(get_pos_from_mask): Passed in value is unsigned HOST_WIDE_INT.
(num_sign_bit_copies): Returns unsigned.
BITWIDTH now unsigned; rework arithmetic.
Remove recursive call from arg to MAX.
(combine_instructions, init_reg_last_arrays): NREGS now unsigned.
(setup_incoming_promotions, can_combine_p, try_combine, simplify_set):
REGNO now unsigned.
(set_nonzero_bit_and_sign_copies): NUM now unsigned.
(find_split_point, expand_compound_operation, make_extraction): LEN
now unsigned HOST_WIDE_INT, POS now HOST_WIDE_INT.
(make_field_assignment): Likewise.
(combine_simplify_rtx): Add cast.
(expand_compound_operation): MODEWIDTH now unsigned; rework arithmetic.
(force_to_mode): WIDTH now unsigned; add cast.
(if_then_else_cond): SIZE now unsigned.
(nonzero_bits): MODE_WIDTH, RESULT_WIDTH, and WIDTH now unsigned.
(extended_count): Now returns unsigned.
(simplify_shift_const): COUNT unsigned; arg is now INPUT_COUNT.
Add SIGNED_COUNT variable; MODE_WORDS and FIRST_COUNT now unsigned.
(simplify_comparison): MODE_WIDTH now unsigned.
(update_table_tick): REGNO and ENDREGNO now unsigned; new var R.
(mark_used_regs_combine): Likewise; rework arithmetic.
(record_value_for_reg): REGNO, ENDREGNO, and I now unsigned.
(record_dead_and_set_regs, reg_dead_at_p, distribute_notes): Likewise.
(record_promoted_value): REGNO now unsigned.
(get_last_value_validate): REGNO, ENDREGNO, and J now unsigned.
(get_last_value): REGNO now unsigned.
(use_crosses_set_p): REGNO and ENDREGNO now unsigned.
(reg_dead_regno, reg_dead_endregno): Now unsigned.
(remove_death): Arg REGNO now unsigned.
(move_deaths): REGNO, DEADREGNO, DEADEND, OUREND, and I now unsigned.
(reg_bitfield_target_p): REGNO, REGNO, ENDREGNO, and ENDTREGNO
now unsigned.
* convert.c (convert_to_integer): INPREC and OUTPREC now unsigned.
* cse.c (struct qty_table_elem): FIRST_REG and LAST_REG now unsigned.
(struct cse_reg_info): REGNO now unsigned.
(cached_regno): Now unsigned.
(REGNO_QTY_VALID_P): Add cast.
(make_new_qty, make_regs_eqv, delete_reg_eqiv): Regno args unsigned.
(remove_invalid_regs): Likewise.
(remove_invalid_subreg_refs): Likewise; arg WORD also unsigned
as are variables END and I.
(get_cse_reg_info, insert): Likewise.
(mention_regs, invalidate_for_call): REGNO, ENDREGNO, and I unsigned.
(canon_hash): Likewise.
(insert_regs, lookup_for_remove): REGNO now unsigned.
(invalidate): REGNO, ENDREGNO, TREGNO, and TENDREGNO now unsigned.
New variable RN.
* dbxout.c (dbxout_parms, dbxout_reg_parms): Don't check for REGNO < 0.
* dwarf2out.c (dwarf2ou_frame_debug_expr): Remove cast.
* emit-rtl.c (subreg_realpart_p): Add cast.
(operand_subword): Arg I is now unsigned as is var PARTWORDS.
(operand_subword_force): Arg I is now unsigned.
* except.c (eh_regs): Variable I is now unsigned.
* explow.c (hard_function_value): BYTES is unsigned HOST_WIDE_INT.
* expmed.c (store_fixed_bit_field): Position is HOST_WIDE_INT;
length is unsigned HOST_WIDE_INT; likewise for internal variables.
(store_split_bit_field, extract_fixed_bit_field): Likewise.
(extract_split_bit_field, store_bit_field, extract_bit_field):
Likewise.
* expr.c (store_constructor_fields, store_constructor, store_field):
Positions are HOST_WIDE_INT and lengths are unsigned HOST_WIDE_INT.
(expand_assignment, expand_expr, expand_expr_unaligned): Likewise.
(do_jump): Likewise.
(move_by_pieces, move_by_pieces_ninsns, clear_by_pieces):
MAX_SIZE is now unsigned.
(emit_group_load): BYTEPOS is HOST_WIDE_INT; BYTELEN is unsigned.
(emit_group_store): Likewise.
(emit_move_insn): I now unsigned.
(store_constructor): Use host_integerp, tree_low_cst, and
bitsize_unit_node.
(get_inner_reference): Return bitpos and bitsize as HOST_WIDE_INT.
Rework all calculations to use trees and new fields.
* expr.h (promoted_input_arg): Regno now unsigned.
(store_bit_field, extract_bit_field): Adjust types of pos and size.
(mark_seen_cases): Arg is HOST_WIDE_INT.
* flow.c (verify_wide_reg_1): REGNO now unsigned.
* fold-const.c (decode_field_reference): Size and pos HOST_WIDE_INT;
precisions and alignments are unsigned.
(optimize_bit_field_compare, fold_truthop): Likewise.
(int_const_binop): Adjust threshold for size_int_type_wide call.
(fold_convert): Likewise.
(size_int_type_wide): Make table larger and fix thinko that only
had half of table used.
(all_ones_mask_p, fold): Precisions are unsigned.
* function.c (put_reg_info_stack): REGNO is unsigned.
(instantiate_decl): Size is HOST_WIDE_INT.
(instantiate_virtual_regs): I is unsigned.
(assign_parms): REGNO, REGNOI, and REGNOR are unsigned.
(promoted_input_arg): REGNO is unsigned.
* function.h (struct function): x_max_parm_reg is now unsigned.
* gcse.c (max_gcse_regno): Now unsigned.
(struct null_pointer_info): min_reg and max_reg now unsigned.
(lookup_set, next_set): REGNO arg now unsigned.
(compute_hash_table): REGNO and I now unsigned.
(handle_avail_expr): regnum_for_replacing now unsigned.
(cprop_insn): REGNO now unsigned.
(delete_null_pointer_checks_1): BLOCK_REG now pointer to unsigned.
* ggc-common.c (ggc_mark_tree_children, case FIELD_DECL): New case.
* global.c (set_preference): SRC_REGNO, DEST_REGNO, and I now unsigned.
* hard-reg-set.h (reg_class_size): Now unsigned.
* integrate.c (mark_stores): LAST_REG and I now unsigned; new UREGNO.
* jump.c (mark_modified_reg): I now unsigned; add cast.
(rtx_equal_for_thread_p): Add cast.
* loop.c (max_reg_before_loop): Now unsigned.
(struct_movable): REGNO now unsigned.
(try_copy_prop): REGNO arg unsigned.
(regs_match_p): XN and YN now unsigned.
(consec_sets_invariant_p, maybe_eliminate_biv): REGNO now unsigned.
(strength_reduce): Likewise; NREGS also unsigned.
(first_increment_giv, last_increment_giv unsigned): Now unsigned.
* loop.h (struct iv_class): REGNO now unsigned.
(max_reg_before_loop, first_increment_giv, last_increment_giv):
Now unsigned.
* machmode.h (mode_size, mode_unit_size): Now unsigned.
(mode_for_size, smallest_mode_for_size): Pass size as unsigned.
* optabs.c (expand_binop): I and NWORDS now unsigned.
(expand_unop): I now unsigned.
* print-tree.c (print_node): Don't print DECL_FIELD_BITPOS, but do
print DECL_FIELD_OFFSET and DECL_FIELD_BIT_OFFSET.
* real.c (significand_size): Now returns unsigned.
* real.h (significand_size): Likewise.
* regclass.c (reg_class_size): Now unsigned.
(choose_hard_reg_mode): Both operands now unsigned.
(record_reg_classes): REGNO and NR now unsigned.
(reg_scan): NREGS now unsigned.
(reg_scan_update): old_max_regno now unsigned.
(reg_scan_mark_refs): Arg MIN_REGNO and var REGNO now unsigned.
* reload.c (find_valid_class): BEST_SIZE now unsigned.
(find_dummy_reload): REGNO, NWORDS, and I now unsigned.
(hard_reg_set_here_p): Args BEG_REGNO and END_REGNO now unsigned.
Likewise for variable R.
(refers_to_regno_for_reload_p): Args REGNO and END_REGNO now unsigned,
as are variables INNER_REGNO and INNER_ENDREGNO; add new variable R.
(find_equiv_reg): Add casts.
(regno_clobbered_p): Arg REGNO now unsigned.
* reload.h (struct reload): NREGS now unsigned.
(refers_to_regno_for_reload_p): Regno args are unsigned.
(regno_clobbered_p): Likewise.
* reload1.c (reg_max_ref_width, spill_stack_slot_width): Now unsigned.
(compute_use_by_pseudos): REGNO now unsigned.
(find_reg): I and J now unsigned, new variable K, and change loop
variables accordingly; THIS_NREGS now unsigned.
(alter_reg): INHERENT_SIZE and TOTAL_SIZE now unsigned.
(spill_hard_reg): REGNO arg now unsigned; add casts.
(forget_old_reloads_1): REGNO, NR, and I now unsigned.
(mark_reload_reg_in_use): Arg REGNO and vars NREGS and I now unsigned.
(clear_reload_reg_in_use): Arg REGNO and vars NREGS, START_REGNO,
END_REGNO, CONFLICT_START, and CONFLICT_END now unsigned.
(reload_reg_free_p, reload_reg_reaches_end_p): Arg REGNO now unsigned.
(choose_reload_regs): MAX_GROUP_SIZE now unsigned.
(emit_reload_insns): REGNO now unsigned.
(reload_cse_move2add): Add cast.
(move2add_note_store): REGNO and I now unsigned; new variable ENDREGNO
and rework loop.
* resource.c (mark_referenced_resources, mark_set_resources): New
variable R; REGNO and LAST_REGNO now unsigned.
(mark_target_live_regs): J and REGNO now unsigned.
* rtl.c (mode_size, mode_unit_size): Now unsigned.
* rtl.h (union rtunion_def): New field rtuint.
(XCUINT): New macro.
(ADDRESSOF_REGNO, REGNO, SUBREG_WORD): New XCUINT.
(operand_subword, operand_subword_force): Word number is unsigned.
(choose_hard_reg_mode): Operands are unsigned.
(refers_to-regno_p, dead_or_set_regno_p): Regno arg is unsigned.
(find_regno_note, find_regno_fusage, replace_regs): Likewise.
(regno_use_in, combine_instructions, remove_death): Likewise.
(reg_scan, reg_scan_update): Likewise.
(extended_count): Return is unsigned.
* rtlanal.c (refers_to_regno_p): Args REGNO and ENDREGNO and vars I,
INNER_REGNO, and INNER_ENDREGNO now unsigned; new variable X_REGNO.
(reg_overlap_mentioned_p): REGNO and ENDREGNO now unsigned.
(reg_set_last_first_regno, reg_set_last_last_regno): Now unsigned.
(reg_reg_last_1): FIRS and LAST now unsigned.
(dead_or_set_p): REGNO, LAST_REGNO, and I now unsigned.
(dead_or_set_regno_p): Arg TEST_REGNO and vars REGNO and ENDREGNO
now unsigned.
(find_regno_note, regno_use_in): Arg REGNO now unsigned.
(find_regno_fusage): Likewise; also var REGNOTE now unsigned.
(find_reg_fusage): Variables REGNO, END_REGNO, and I now unsigned.
(replace_regs): Arg NREGS now unsigned.
* sdbout.c (sdbout_parms, sdbout_reg_parms): Don't check REGNO < 0.
* simplify-rtx.c (simplify_unary_operation): WIDTH now unsigned.
(simplify_binary_operation): Likewise.
(cselib_invalidate_regno): Arg REGNO and variables ENDREGNO, I, and
THIS_LAST now unsigned.
(cselib_record_set): Add cast.
* ssa.c (ssa_max_reg_num): Now unsigned.
(rename_block): REGNO now unsigned.
* stmt.c (expand_return): Bit positions unsigned HOST_WIDE_INT;
sizes now unsigned.
(all_cases_count): Just return -1 not -2.
COUNT, MINVAL, and LASTVAL now HOST_WIDE_INT.
Rework tests to use trees whenever possible.
Use host_integerp and tree_low_cst.
(mark_seen_cases): COUNT arg now HOST_WIDE_INT;
Likewise variable NEXT_NODE_OFFSET; XLO now unsigned.
(check_for_full_enumeration_handing): BYTES_NEEDED, I to HOST_WIDE_INT.
* stor-layout.c (mode_for_size): SIZE arg now unsigned.
(smallest_mode_for_size): Likewise.
(layout_decl): Simplify handing of a specified DECL_SIZE_UNIT.
KNOWN_ALIGN is now an alignment, so simplify code.
Don't turn off DECL_BIT_FIELD if field is BLKmode, but not type.
(start_record_layout): Renamed from new_record_layout_info.
Update to new fields.
(debug_rli, normalize_rli, rli_size_unit_so_far, rli_size_so_far):
New functions.
(place_union_field): Renamed from layout_union_field.
Update to use new fields in rli.
(place_field): Renamed from layout_field.
Major rewrite to use new fields in rli; pass alignment to layout_decl.
(finalize_record_size): Rework to use new fields in rli and handle
union.
(compute_record_mode): Rework to simplify and to use new DECL fields.
(finalize_type_size): Make rounding more consistent.
(finish_union_layout): Deleted.
(layout_type, case VOID_TYPE): Don't set TYPE_SIZE_UNIT either.
(layout_type, case RECORD_TYPE): Call new function names.
(initialize_sizetypes): Set TYPE_IS_SIZETYPE.
(set_sizetype): Set TYPE_IS_SIZETYPE earlier.
(get_best_mode): UNIT is now unsigned; remove casts.
* tree.c (bit_position): Compute from new fields.
(byte_position, int_byte_position): New functions.
(print_type_hash_statistics): Cast to remove warning.
(build_range_type): Use host_integerp and tree_low_cst to try to hash.
(build_index_type): Likewise; make subtype of sizetype.
(build_index_2_type): Pass sizetype to build_range_type.
(build_common_tree_nodes): Use size_int and bitsize_int to
initialize nodes; add bitsize_{zero,one,unit}_node.
* tree.h (DECL_FIELD_CONTEXT): Use FIELD_DECL_CHECK.
(DECL_BIT_FIELD_TYPE, DECL_QUALIFIER, DECL_FCONTEXT): Likewise.
(DECL_PACKED, DECL_BIT_FIELD): Likewise.
(DECL_FIELD_BITPOS): Deleted.
(DECL_FIELD_OFFSET, DECL_FIELD_BIT_OFFSET): New fields.
(DECL_RESULT, DECL_SAVED_INSNS): Use FUNCTION_DECL_CHECK.
(DECL_FRAME_SIZE, DECL_FUNCTION_CODE, DECL_NO_STATIC_CHAIN): Likewise.
(DECL_INLINE, DECL_BUILT_IN_NONANSI, DECL_IS_MALLOC): Likewise.
(DECL_BUILT_IN_CLASS, DECL_STATIC_CONSTRUCTOR): Likewise.
(DECL_STATIC_DESTRUCTOR, DECL_NO_CHECK_MEMORY_USAGE): Likewise.
(DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT, DECL_NO_LIMIT_STACK) Likewise.
(DECL_ORIGINAL_TYPE, TYPE_DECL_SUPPRESS_DEBUG): Use TYPE_DECL_CHECK.
(DECL_ARG_TYPE_AS_WRITEN, DECL_ARG_TYPE): Use PARM_DECL_CHECK.
(DECL_INCOMING_RTL, DECL_TRANSPARENT_UNION): Likewise.
(DECL_ALIGN): Adjust to new field in union.
(DECL_OFFSET_ALIGN): New field.
(DECL_ERROR_ISSUED, DECL_TOO_LATE): Use LABEL_DECL_CHECK.
(DECL_IN_TEXT_SECTION): Use VAR_DECL_CHECK.
(union tree_decl): Add struct for both aligns.
(enum tree_index): Add TI_BITSIZE_{ZERO,ONE,UNIT}.
(bitsize_zero_node, bitsize_one_node, bitsize_unit_node): Added.
(struct record_layout_info): Rework fields to have offset
alignment and byte and bit position.
(start_record_layout, place_field): Renamed from old names.
(rli_size_so_far, rli_size_unit_so_far, normalize_rli): New decls.
(byte_position, int_byte_position): Likewise.
(get_inner_reference): Change types of position and length.
* unroll.c (unroll_loop): New variable R; use for some loops.
MAX_LOCAL_REGNUM and MAXREGNUM now unsigned.
(calculate_giv_inc): Arg REGNO now unsigned.
(copy_loop_body): REGNO and SRC_REGNO now unsigned.
* varasm.c (assemble_variable): Clean up handling of size using
host_integerp and tree_low_cst.
(decode_addr_const): Use byte, not bit, position.
(output_constructor): bitpos and offsets are HOST_WIDE_INT;
use tree_low_cst and int_bit_position.
* objc/objc-act.c (build_ivar_list_initializer): Use byte_position.
* ch/actions.c (check_missing_cases): BYTES_NEEDED is HOST_WIDE_INT.
* ch/typeck.c (expand_constant_to_buffer): Use int_byte_position.
(extract_constant_from_buffer): Likewise.
* cp/class.c (build_vbase_pointer_fields): layout_field now
place_field.
(get_vfield_offset): Use byte_position.
(set_rtti_entry): Set OFFSET to ssizetype zero.
(get_binfo_offset_as_int): Deleted.
(dfs_record_base_offsets): Use tree_low_cst.
(dfs_search_base_offsets): Likewise.
(layout_nonempty_base_or_field): Reflect changes in RLI format
and call byte_position.
(layout_empty_base): Convert offset to ssizetype.
(build_base_field): use rli_size_unit_so_far.
(dfs_propagate_binfo_offsets): Do computation in proper type.
(layout_virtual_bases): Pass ssizetype to propagate_binfo_offsets.
(layout_class_type): Reflect changes in RLI names and fields.
(finish_struct_1): Set DECL_FIELD_OFFSET.
* cp/dump.c (dequeue_and_dump): Call bit_position.
* cp/expr.c (cplus_expand_constant): Use byte_position.
* cp/rtti.c (expand_class_desc): Use bitsize_one_node.
* cp/typeck.c (build_component_addr): Use byte_position and don't
special case for zero offset.
* f/com.c (ffecom_tree_canonize_ptr_): Use bitsize_zero_node.
(ffecom_tree_canonize_ref_): Likewise.
* java/class.c (make_field_value): Use byte_position.
* java/expr.c (JAVA_ARRAY_LENGTH_OFFSET): Use byte_position.
(java_array_data_offset): Likewise.
* java/java-tree.h (MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC): Add case to
bzero call.
From-SVN: r32742
1148 lines
46 KiB
C++
1148 lines
46 KiB
C++
/* Definitions for parsing and type checking for the GNU compiler for
|
|
the Java(TM) language.
|
|
Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU CC.
|
|
|
|
GNU CC is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU CC is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU CC; see the file COPYING. If not, write to
|
|
the Free Software Foundation, 59 Temple Place - Suite 330,
|
|
Boston, MA 02111-1307, USA.
|
|
|
|
Java and all Java-based marks are trademarks or registered trademarks
|
|
of Sun Microsystems, Inc. in the United States and other countries.
|
|
The Free Software Foundation is independent of Sun Microsystems, Inc. */
|
|
|
|
/* Hacked by Per Bothner <bothner@cygnus.com> February 1996. */
|
|
|
|
#include "hash.h"
|
|
|
|
/* Java language-specific tree codes. */
|
|
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) SYM,
|
|
enum java_tree_code {
|
|
__DUMMY = LAST_AND_UNUSED_TREE_CODE,
|
|
#include "java-tree.def"
|
|
LAST_JAVA_TREE_CODE
|
|
};
|
|
#undef DEFTREECODE
|
|
|
|
struct JCF;
|
|
|
|
/* Usage of TREE_LANG_FLAG_?:
|
|
0: IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P (in IDENTIFIER_NODE)
|
|
RESOLVE_EXPRESSION_NAME_P (in EXPR_WITH_FILE_LOCATION)
|
|
FOR_LOOP_P (in LOOP_EXPR)
|
|
ANONYMOUS_CLASS_P (in RECORD_TYPE)
|
|
ARG_FINAL_P (in TREE_LIST)
|
|
1: CLASS_HAS_SUPER_FLAG (in TREE_VEC).
|
|
IS_A_CLASSFILE_NAME (in IDENTIFIER_NODE)
|
|
COMPOUND_ASSIGN_P (in EXPR (binop_*))
|
|
LOCAL_CLASS_P (in RECORD_TYPE)
|
|
2: RETURN_MAP_ADJUSTED (in TREE_VEC).
|
|
QUALIFIED_P (in IDENTIFIER_NODE)
|
|
PRIMARY_P (in EXPR_WITH_FILE_LOCATION)
|
|
MODIFY_EXPR_FROM_INITIALIZATION_P (in MODIFY_EXPR)
|
|
3: IS_AN_IMPORT_ON_DEMAND_P (in IDENTIFIER_NODE)
|
|
RESOLVE_PACKAGE_NAME_P (in EXPR_WITH_FILE_LOCATION)
|
|
SWITCH_HAS_DEFAULT (in SWITCH_EXPR)
|
|
4: IS_A_COMMAND_LINE_FILENAME_P (in IDENTIFIER_NODE)
|
|
RESOLVE_TYPE_NAME_P (in EXPR_WITH_FILE_LOCATION)
|
|
CALL_USING_SUPER (in CALL_EXPR)
|
|
5: HAS_BEEN_ALREADY_PARSED_P (in IDENTIFIER_NODE)
|
|
IS_BREAK_STMT_P (in EXPR_WITH_FILE_LOCATION)
|
|
IS_CRAFTED_STRING_BUFFER_P (in CALL_EXPR)
|
|
IS_INIT_CHECKED (in SAVE_EXPR)
|
|
6: CAN_COMPLETE_NORMALLY (in statement nodes)
|
|
OUTER_FIELD_ACCESS_IDENTIFIER_P (in IDENTIFIER_NODE)
|
|
|
|
Usage of TYPE_LANG_FLAG_?:
|
|
0: CLASS_ACCESS0_GENERATED_P (in RECORD_TYPE)
|
|
1: TYPE_ARRAY_P (in RECORD_TYPE).
|
|
2: CLASS_LOADED_P (in RECORD_TYPE).
|
|
3: CLASS_FROM_SOURCE_P (in RECORD_TYPE).
|
|
4: CLASS_P (in RECORD_TYPE).
|
|
5: CLASS_FROM_CURRENTLY_COMPILED_SOURCE_P (in RECORD_TYPE)
|
|
6: CLASS_BEING_LAIDOUT (in RECORD_TYPE)
|
|
|
|
Usage of DECL_LANG_FLAG_?:
|
|
0: METHOD_DEPRECATED (in FUNCTION_DECL).
|
|
FIELD_DEPRECATED (in FIELD_DECL).
|
|
CLASS_DEPRECATED (in TYPE_DECL).
|
|
1: METHOD_PUBLIC (in FUNCTION_DECL).
|
|
FIELD_PUBLIC (in FIELD_DECL).
|
|
CLASS_PUBLIC (in TYPE_DECL).
|
|
2: METHOD_STATIC (in FUNCTION_DECL).
|
|
(But note that FIELD_STATIC uses TREE_STATIC!)
|
|
CLASS_COMPLETE_P (in TYPE_DECL)
|
|
3: METHOD_FINAL (in FUNCTION_DECL)
|
|
FIELD_FINAL (in FIELD_DECL)
|
|
CLASS_FINAL (in TYPE_DECL)
|
|
LOCAL_FINAL (in VAR_DECL)
|
|
4: METHOD_SYNCHRONIZED (in FUNCTION_DECL).
|
|
LABEL_IN_SUBR (in LABEL_DECL)
|
|
CLASS_INTERFACE (in TYPE_DECL)
|
|
FIELD_VOLATILE (int FIELD_DECL)
|
|
5: METHOD_ABSTRACT (in FUNCTION_DECL).
|
|
LABEL_IS_SUBR_START (in LABEL_DECL)
|
|
CLASS_ABSTRACT (in TYPE_DECL)
|
|
FIELD_TRANSIENT (in FIELD_DECL)
|
|
6: METHOD_TRANSIENT (in FUNCTION_DECL)
|
|
LABEL_CHANGED (in LABEL_DECL)
|
|
CLASS_SUPER (in TYPE_DECL, ACC_SUPER flag)
|
|
FIELD_LOCAL_ALIAS (in FIELD_DECL)
|
|
7: DECL_CONSTRUCTOR_P (in FUNCTION_DECL).
|
|
CLASS_STATIC (in TYPE_DECL)
|
|
FIELD_LOCAL_ALIAS_USED (in FIELD_DECL)
|
|
FIELD_THISN (in FIELD_DECL)
|
|
*/
|
|
|
|
/* True if the class whose TYPE_BINFO this is has a superclass.
|
|
(True of all classes except Object.) */
|
|
#define CLASS_HAS_SUPER_FLAG(BINFO) TREE_LANG_FLAG_1(BINFO)
|
|
#define CLASS_HAS_SUPER(TYPE) CLASS_HAS_SUPER_FLAG (TYPE_BINFO (TYPE))
|
|
|
|
/* Return the supertype of class TYPE, or NULL_TREE is it has none. */
|
|
#define CLASSTYPE_SUPER(TYPE) (CLASS_HAS_SUPER (TYPE) ? \
|
|
BINFO_TYPE (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (TYPE), 0)) : NULL_TREE)
|
|
|
|
/* True if the class we are compiling is a .java source file;
|
|
false if it is a .class bytecode file. */
|
|
extern int compiling_from_source;
|
|
|
|
/* The class defined by the actual (main) file we are compiling. */
|
|
extern tree main_class;
|
|
|
|
/* The class we are currently processing. */
|
|
extern tree current_class;
|
|
|
|
/* List of all class DECLs seen so far. */
|
|
extern tree all_class_list;
|
|
|
|
/* Nonzero if we should make is_compiled_class always return 1 for
|
|
appropriate classes that we're referencing. */
|
|
|
|
extern int flag_assume_compiled;
|
|
|
|
extern int flag_emit_class_files;
|
|
|
|
/* When non zero, we emit xref strings. Values of the flag for xref
|
|
backends are defined in xref.h. */
|
|
|
|
extern int flag_emit_xref;
|
|
|
|
/* When doing xrefs, tell when not to fold. */
|
|
extern int do_not_fold;
|
|
|
|
/* Turned to 1 if -Wall was encountered. See lang.c for their meanings. */
|
|
extern int flag_wall;
|
|
extern int flag_redundant;
|
|
extern int flag_not_overriding;
|
|
extern int flag_static_local_jdk1_1;
|
|
|
|
/* When non zero, call a library routine to do integer divisions. */
|
|
extern int flag_use_divide_subroutine;
|
|
|
|
/* When non zero, generate code for the Boehm GC. */
|
|
extern int flag_use_boehm_gc;
|
|
|
|
/* When non zero, assume the runtime uses a hash table to map an
|
|
object to its synchronization structure. */
|
|
extern int flag_hash_synchronization;
|
|
|
|
/* The Java .class file that provides main_class; the main input file. */
|
|
extern struct JCF *current_jcf;
|
|
|
|
typedef struct CPool constant_pool;
|
|
|
|
#define CONSTANT_ResolvedFlag 16
|
|
|
|
/* The cpool->data[i] for a ResolvedString points to a STRING_CST. */
|
|
#define CONSTANT_ResolvedString (CONSTANT_String+CONSTANT_ResolvedFlag)
|
|
|
|
/* The cpool->data[i] for a ResolvedClass points to a RECORD_TYPE. */
|
|
#define CONSTANT_ResolvedClass (CONSTANT_Class+CONSTANT_ResolvedFlag)
|
|
|
|
#define CPOOL_UTF(CPOOL, INDEX) ((tree) (CPOOL)->data[INDEX])
|
|
|
|
/* A NameAndType constant is represented as a TREE_LIST.
|
|
The type is the signature string (as an IDENTIFIER_NODE). */
|
|
|
|
#define NAME_AND_TYPE_NAME(CPOOL, IDX) \
|
|
CPOOL_UTF(CPOOL, CPOOL_USHORT1(CPOOL, IDX))
|
|
#define NAME_AND_TYPE_SIGNATURE(CPOOL, IDX) \
|
|
CPOOL_UTF(CPOOL, CPOOL_USHORT2(CPOOL, IDX))
|
|
|
|
/* A FieldRef, MethodRef or InterfaceMethodRef constant
|
|
is represented as a TREE_LIST. */
|
|
|
|
#define COMPONENT_REF_CLASS_INDEX(CPOOL, IDX) CPOOL_USHORT1(CPOOL, IDX)
|
|
#define COMPONENT_REF_NAME_AND_TYPE(CPOOL, IDX) CPOOL_USHORT2(CPOOL, IDX)
|
|
#define COMPONENT_REF_NAME(CPOOL, IDX) \
|
|
NAME_AND_TYPE_NAME (CPOOL, COMPONENT_REF_NAME_AND_TYPE(CPOOL, IDX))
|
|
#define COMPONENT_REF_SIGNATURE(CPOOL, IDX) \
|
|
NAME_AND_TYPE_SIGNATURE (CPOOL, COMPONENT_REF_NAME_AND_TYPE(CPOOL, IDX))
|
|
|
|
/* "Promoted types" that are used for primitive types smaller
|
|
than int. We could use int_type_node, but then we would lose
|
|
type information (such as needed for debugging). */
|
|
extern tree promoted_byte_type_node;
|
|
extern tree promoted_short_type_node;
|
|
extern tree promoted_char_type_node;
|
|
extern tree promoted_boolean_type_node;
|
|
|
|
extern tree byte_type_node;
|
|
extern tree short_type_node;
|
|
extern tree int_type_node;
|
|
extern tree long_type_node;
|
|
|
|
extern tree unsigned_byte_type_node;
|
|
extern tree unsigned_short_type_node;
|
|
extern tree unsigned_int_type_node;
|
|
extern tree unsigned_long_type_node;
|
|
|
|
extern tree boolean_type_node;
|
|
|
|
extern tree object_type_node;
|
|
extern tree unqualified_object_id_node;
|
|
extern tree object_ptr_type_node;
|
|
extern tree string_type_node;
|
|
extern tree string_ptr_type_node;
|
|
extern tree throwable_type_node;
|
|
extern tree runtime_exception_type_node;
|
|
extern tree error_exception_type_node;
|
|
|
|
extern tree *predef_filenames;
|
|
extern int predef_filenames_size;
|
|
|
|
extern tree byte_array_type_node;
|
|
extern tree short_array_type_node;
|
|
extern tree int_array_type_node;
|
|
extern tree long_array_type_node;
|
|
extern tree boolean_array_type_node;
|
|
extern tree char_array_type_node;
|
|
extern tree double_array_type_node;
|
|
extern tree float_array_type_node;
|
|
extern tree array_array_type_node;
|
|
extern tree object_array_type_node;
|
|
extern tree string_array_type_node;
|
|
extern tree TYPE_identifier_node; /* "TYPE" */
|
|
extern tree init_identifier_node; /* "<init>" */
|
|
extern tree clinit_identifier_node; /* "<clinit>" */
|
|
extern tree finit_identifier_node; /* "$finit$" */
|
|
extern tree void_signature_node; /* "()V" */
|
|
extern tree length_identifier_node; /* "length" */
|
|
extern tree this_identifier_node; /* "this" */
|
|
extern tree super_identifier_node; /* "super" */
|
|
extern tree continue_identifier_node; /* "continue" */
|
|
extern tree access0_identifier_node; /* "access$0" */
|
|
extern tree one_elt_array_domain_type;
|
|
/* The type of the return address of a subroutine. */
|
|
extern tree return_address_type_node;
|
|
|
|
/* Nodes for boolean constants TRUE and FALSE. */
|
|
extern tree boolean_true_node, boolean_false_node;
|
|
|
|
/* Integer constants not declared in tree.h. */
|
|
extern tree long_zero_node;
|
|
extern tree float_zero_node;
|
|
extern tree double_zero_node;
|
|
extern tree integer_negative_one_node;
|
|
extern tree integer_two_node;
|
|
extern tree integer_four_node;
|
|
extern tree empty_stmt_node;
|
|
|
|
/* The type for struct methodtable. */
|
|
extern tree methodtable_type;
|
|
extern tree methodtable_ptr_type;
|
|
|
|
extern tree utf8const_type;
|
|
extern tree utf8const_ptr_type;
|
|
|
|
extern tree class_type_node;
|
|
extern tree class_ptr_type;
|
|
extern tree field_type_node;
|
|
extern tree constants_type_node;
|
|
extern tree dtable_type, dtable_ptr_type;
|
|
extern tree field_ptr_type_node;
|
|
extern tree field_info_union_node;
|
|
extern tree method_type_node;
|
|
extern tree method_ptr_type_node;
|
|
#define nativecode_ptr_type_node ptr_type_node
|
|
|
|
extern tree end_params_node;
|
|
|
|
/* References to internal libjava functions we use. */
|
|
extern tree alloc_object_node;
|
|
extern tree soft_instanceof_node;
|
|
extern tree soft_checkcast_node;
|
|
extern tree soft_initclass_node;
|
|
extern tree soft_newarray_node;
|
|
extern tree soft_anewarray_node;
|
|
extern tree soft_multianewarray_node;
|
|
extern tree soft_badarrayindex_node;
|
|
extern tree throw_node[];
|
|
extern tree soft_checkarraystore_node;
|
|
extern tree soft_monitorenter_node;
|
|
extern tree soft_monitorexit_node;
|
|
extern tree soft_lookupinterfacemethod_node;
|
|
extern tree soft_fmod_node;
|
|
extern tree soft_exceptioninfo_call_node;
|
|
extern tree soft_idiv_node;
|
|
extern tree soft_irem_node;
|
|
extern tree soft_ldiv_node;
|
|
extern tree soft_lrem_node;
|
|
|
|
extern tree access_flags_type_node;
|
|
|
|
extern tree class_dtable_decl;
|
|
|
|
/* They need to be reset before processing each class */
|
|
extern struct CPool *outgoing_cpool;
|
|
extern tree current_constant_pool_data_ref;
|
|
|
|
extern tree wfl_operator;
|
|
|
|
extern char *cyclic_inheritance_report;
|
|
|
|
extern char *cyclic_inheritance_report;
|
|
|
|
struct lang_identifier
|
|
{
|
|
struct tree_identifier ignore;
|
|
tree global_value, local_value;
|
|
|
|
/* If non-NULL: An ADDR_REF to a VAR_DECL that contains
|
|
* the Utf8Const representation of the identifier. */
|
|
tree utf8_ref;
|
|
};
|
|
|
|
/* Macros for access to language-specific slots in an identifier. */
|
|
/* UNless specifide, each of these slots contains a DECL node or null. */
|
|
|
|
/* This represents the value which the identifier has in the
|
|
file-scope namespace. */
|
|
#define IDENTIFIER_GLOBAL_VALUE(NODE) \
|
|
(((struct lang_identifier *)(NODE))->global_value)
|
|
/* This represents the value which the identifier has in the current
|
|
scope. */
|
|
#define IDENTIFIER_LOCAL_VALUE(NODE) \
|
|
(((struct lang_identifier *)(NODE))->local_value)
|
|
|
|
/* Given an identifier NODE, get the corresponding (non-handle) class.
|
|
For get_identifier ("java.lang.Number"), the result is
|
|
the struct whose DECL_ASSEMBLER_NAME is "Classjava_lang_Number". */
|
|
#define IDENTIFIER_CLASS_VALUE(NODE) IDENTIFIER_GLOBAL_VALUE(NODE)
|
|
|
|
/* Given an identifier NODE, get the corresponding handle class.
|
|
For get_identifier ("java.lang.Number"), the result is
|
|
the struct whose DECL_ASSEMBLER_NAME is "Hjava_lang_Number". */
|
|
#define IDENTIFIER_HANDLECLASS_VALUE(NODE) ???
|
|
|
|
/* Given a signature of a reference (or array) type, or a method, return the
|
|
corresponding type (if one has been allocated).
|
|
Do not use for primitive types, since they may be ambiguous.
|
|
(E.g. is "I" a signature or a class name?) */
|
|
#define IDENTIFIER_SIGNATURE_TYPE(NODE) IDENTIFIER_GLOBAL_VALUE(NODE)
|
|
|
|
/* If non-NULL: An ADDR_REF to a VAR_DECL that contains
|
|
the Utf8Const representation of the identifier. */
|
|
#define IDENTIFIER_UTF8_REF(NODE) \
|
|
(((struct lang_identifier *)(NODE))->utf8_ref)
|
|
|
|
#define IDENTIFIER_UTF8_DECL(NODE) \
|
|
TREE_OPERAND((((struct lang_identifier *)(NODE))->utf8_ref), 0)
|
|
|
|
/* For a FUNCTION_DECL, if we are compiling a .class file, then this is
|
|
the position in the .class file of the method code.
|
|
Specifically, this is the code itself, not the code attribute. */
|
|
#define DECL_CODE_OFFSET(DECL) (DECL_LANG_SPECIFIC(DECL)->code_offset)
|
|
/* Similarly, the length of the bytecode. */
|
|
#define DECL_CODE_LENGTH(DECL) (DECL_LANG_SPECIFIC(DECL)->code_length)
|
|
/* Similarly, the position of the LineNumberTable attribute. */
|
|
#define DECL_LINENUMBERS_OFFSET(DECL) \
|
|
(DECL_LANG_SPECIFIC(DECL)->linenumbers_offset)
|
|
/* Similarly, the position of the LocalVariableTable attribute
|
|
(following the standard attribute header). */
|
|
#define DECL_LOCALVARIABLES_OFFSET(DECL) \
|
|
(DECL_LANG_SPECIFIC(DECL)->localvariables_offset)
|
|
|
|
#define DECL_MAX_LOCALS(DECL) (DECL_LANG_SPECIFIC(DECL)->max_locals)
|
|
#define DECL_MAX_STACK(DECL) (DECL_LANG_SPECIFIC(DECL)->max_stack)
|
|
/* Number of local variable slots needed for the arguments of this function. */
|
|
#define DECL_ARG_SLOT_COUNT(DECL) (DECL_LANG_SPECIFIC(DECL)->arg_slot_count)
|
|
/* List of checked thrown exceptions, as specified with the `throws'
|
|
keyword */
|
|
#define DECL_FUNCTION_THROWS(DECL) (DECL_LANG_SPECIFIC(DECL)->throws_list)
|
|
/* List of other constructors of the same class that this constructor
|
|
calls */
|
|
#define DECL_CONSTRUCTOR_CALLS(DECL) \
|
|
(DECL_LANG_SPECIFIC(DECL)->called_constructor)
|
|
/* When the function is an access function, the DECL it was trying to
|
|
access */
|
|
#define DECL_FUNCTION_ACCESS_DECL(DECL) \
|
|
(DECL_LANG_SPECIFIC(DECL)->called_constructor)
|
|
/* The identifier of the access method used to invoke this method from
|
|
an inner class. */
|
|
#define DECL_FUNCTION_INNER_ACCESS(DECL) \
|
|
(DECL_LANG_SPECIFIC(DECL)->inner_access)
|
|
/* Pointer to the function's current's COMPOUND_EXPR tree (while
|
|
completing its body) or the function's block */
|
|
#define DECL_FUNCTION_BODY(DECL) (DECL_LANG_SPECIFIC(DECL)->function_decl_body)
|
|
/* How specific the function is (for method selection - Java source
|
|
code front-end */
|
|
#define DECL_SPECIFIC_COUNT(DECL) DECL_ARG_SLOT_COUNT(DECL)
|
|
/* For each function decl, init_test_table contains a hash table whose
|
|
entries are keyed on class names, and whose values are local
|
|
boolean decls. The variables are intended to be TRUE when the
|
|
class has been initialized in this function, and FALSE otherwise. */
|
|
#define DECL_FUNCTION_INIT_TEST_TABLE(DECL) \
|
|
(DECL_LANG_SPECIFIC(DECL)->init_test_table)
|
|
/* The Number of Artificial Parameters (NAP) DECL contains. this$<n>
|
|
is excluded, because sometimes created as a parameter before the
|
|
function decl exists. */
|
|
#define DECL_FUNCTION_NAP(DECL) (DECL_LANG_SPECIFIC(DECL)->nap)
|
|
|
|
/* For a FIELD_DECL, holds the name of the access method used to
|
|
read/write the content of the field from an inner class.
|
|
The cast is ugly. FIXME */
|
|
#define FIELD_INNER_ACCESS(DECL) ((tree)DECL_LANG_SPECIFIC (DECL))
|
|
|
|
/* True when DECL aliases an outer context local variable. */
|
|
#define FIELD_LOCAL_ALIAS(DECL) DECL_LANG_FLAG_6 (DECL)
|
|
|
|
/* True when DECL, which aliases an outer context local variable is
|
|
used by the inner classe */
|
|
#define FIELD_LOCAL_ALIAS_USED(DECL) DECL_LANG_FLAG_7 (DECL)
|
|
|
|
/* True when DECL is a this$<n> field. Note that
|
|
FIELD_LOCAL_ALIAS_USED can be differenciated when tested against
|
|
FIELD_LOCAL_ALIAS. */
|
|
#define FIELD_THISN(DECL) DECL_LANG_FLAG_7 (DECL)
|
|
|
|
/* In a LABEL_DECL, a TREE_VEC that saves the type_map at that point. */
|
|
#define LABEL_TYPE_STATE(NODE) (DECL_INITIAL (NODE))
|
|
|
|
/* In the label of a subroutine, a dummy label that records the
|
|
state following a merge of all the ret instructions in this subroutine. */
|
|
#define LABEL_RETURN_LABEL(DECL) DECL_ARGUMENTS(DECL)
|
|
|
|
/* In the label of a sub-routine, records the type state at return.
|
|
* A local may be TYPE_UNUSED, which means that the local is not
|
|
* used (stored to or loaded from) in this subroutine - at least for
|
|
* code that we have verified so far. */
|
|
#define LABEL_RETURN_TYPE_STATE(NODE) LABEL_TYPE_STATE (LABEL_RETURN_LABEL (NODE))
|
|
|
|
/* In a TREE_VEC for a LABEL_RETURN_TYPE_STATE, notes that
|
|
TREE_VEC_LENGTH has been adjust to the correct stack size. */
|
|
#define RETURN_MAP_ADJUSTED(NODE) TREE_LANG_FLAG_2(NODE)
|
|
|
|
/* In the label of a sub-routine, a chain of the return location labels. */
|
|
#define LABEL_RETURN_LABELS(node) DECL_RESULT (LABEL_RETURN_LABEL(node))
|
|
|
|
/* In a LABEL_DECL, the next pending label.
|
|
See pending_blocks in expr.c. */
|
|
#define LABEL_PENDING_CHAIN(NODE) DECL_RESULT(NODE)
|
|
|
|
/* In a LABEL_DECL, the corresponding bytecode program counter. */
|
|
#define LABEL_PC(NODE) ((NODE)->decl.u2.i)
|
|
|
|
/* Used during verification to mark the label has "changed". (See JVM Spec). */
|
|
#define LABEL_CHANGED(NODE) DECL_LANG_FLAG_6(NODE)
|
|
|
|
/* In a LABEL_DECL, true if we have verified instructions starting here. */
|
|
#define LABEL_VERIFIED(NODE) (instruction_bits[LABEL_PC(NODE)]&BCODE_VERIFIED)
|
|
|
|
/* True if this code is within a subroutine (target of a jsr). */
|
|
#define LABEL_IN_SUBR(NODE) DECL_LANG_FLAG_4(NODE)
|
|
/* True if this code is the start of a subroutine (target of a jsr). */
|
|
#define LABEL_IS_SUBR_START(NODE) DECL_LANG_FLAG_5(NODE)
|
|
|
|
/* In a LABEL_DECL, if LABEL_IN_SUBR(NODE), points to start of subroutine. */
|
|
#define LABEL_SUBR_START(NODE) DECL_ABSTRACT_ORIGIN(NODE)
|
|
|
|
/* In a LABEL_DECL that has LABEL_IS_SUBR_START, this points to the start
|
|
of surrounding subroutine in the case of a nested subroutine,
|
|
and NULL_TREE otherwise. */
|
|
#define LABEL_SUBR_CONTEXT(NODE) DECL_CONTEXT (LABEL_RETURN_LABEL (NODE))
|
|
|
|
/* The slot number for this local variable. */
|
|
#define DECL_LOCAL_SLOT_NUMBER(NODE) \
|
|
(((struct lang_decl_var*)DECL_LANG_SPECIFIC(NODE))->slot_number)
|
|
/* The start (bytecode) pc for the valid range of this local variable. */
|
|
#define DECL_LOCAL_START_PC(NODE) \
|
|
(((struct lang_decl_var*)DECL_LANG_SPECIFIC(NODE))->start_pc)
|
|
/* The end (bytecode) pc for the valid range of this local variable. */
|
|
#define DECL_LOCAL_END_PC(NODE) \
|
|
(((struct lang_decl_var*)DECL_LANG_SPECIFIC(NODE))->end_pc)
|
|
/* For a VAR_DECLor PARM_DECL, used to chain decls with the same
|
|
slot_number in decl_map. */
|
|
#define DECL_LOCAL_SLOT_CHAIN(NODE) \
|
|
(((struct lang_decl_var*)DECL_LANG_SPECIFIC(NODE))->slot_chain)
|
|
|
|
/* For a local VAR_DECL, holds the index into a words bitstring that
|
|
specifies if this decl is definitively assigned.
|
|
A DECL_BIT_INDEX of -1 means we no longer care. */
|
|
#define DECL_BIT_INDEX(DECL) (DECL_CHECK (DECL)->decl.u2.i)
|
|
|
|
/* DECL_LANG_SPECIFIC for FUNCTION_DECLs. */
|
|
struct lang_decl
|
|
{
|
|
/* tree chain; not yet used. */
|
|
long code_offset;
|
|
int code_length;
|
|
long linenumbers_offset;
|
|
long localvariables_offset;
|
|
int arg_slots;
|
|
int max_locals, max_stack, arg_slot_count;
|
|
tree throws_list; /* Exception specified by `throws' */
|
|
tree function_decl_body; /* Hold all function's statements */
|
|
tree called_constructor; /* When decl is a constructor, the
|
|
list of other constructor it calls. */
|
|
struct hash_table init_test_table;
|
|
/* Class initialization test variables. */
|
|
tree inner_access; /* The identifier of the access method
|
|
used for invocation from inner classes */
|
|
int nap; /* Number of artificial parameters */
|
|
};
|
|
|
|
/* init_test_table hash table entry structure. */
|
|
struct init_test_hash_entry
|
|
{
|
|
struct hash_entry root;
|
|
tree init_test_decl;
|
|
};
|
|
|
|
/* DECL_LANG_SPECIFIC for VAR_DECL and PARM_DECL. */
|
|
struct lang_decl_var
|
|
{
|
|
int slot_number;
|
|
int start_pc;
|
|
int end_pc;
|
|
tree slot_chain;
|
|
};
|
|
|
|
/* Macro to access fields in `struct lang_type'. */
|
|
|
|
#define TYPE_SIGNATURE(T) (TYPE_LANG_SPECIFIC(T)->signature)
|
|
#define TYPE_JCF(T) (TYPE_LANG_SPECIFIC(T)->jcf)
|
|
#define TYPE_CPOOL(T) (TYPE_LANG_SPECIFIC(T)->cpool)
|
|
#define TYPE_CPOOL_DATA_REF(T) (TYPE_LANG_SPECIFIC(T)->cpool_data_ref)
|
|
#define MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC(T) \
|
|
if (TYPE_LANG_SPECIFIC ((T)) == NULL) \
|
|
{ \
|
|
TYPE_LANG_SPECIFIC ((T)) = \
|
|
(struct lang_type *) xmalloc (sizeof (struct lang_type)); \
|
|
\
|
|
bzero ((char *) TYPE_LANG_SPECIFIC ((T)), \
|
|
sizeof (struct lang_type)); \
|
|
}
|
|
|
|
#define TYPE_FINIT_STMT_LIST(T) (TYPE_LANG_SPECIFIC(T)->finit_stmt_list)
|
|
#define TYPE_CLINIT_STMT_LIST(T) (TYPE_LANG_SPECIFIC(T)->clinit_stmt_list)
|
|
#define TYPE_II_STMT_LIST(T) (TYPE_LANG_SPECIFIC(T)->ii_block)
|
|
/* The decl of the synthetic method `class$' used to handle `.class'
|
|
for non primitive types when compiling to bytecode. */
|
|
#define TYPE_DOT_CLASS(T) (TYPE_LANG_SPECIFIC(T)->dot_class)
|
|
|
|
struct lang_type
|
|
{
|
|
tree signature;
|
|
struct JCF *jcf;
|
|
struct CPool *cpool;
|
|
tree cpool_data_ref; /* Cached */
|
|
tree finit_stmt_list; /* List of statements $finit$ will use */
|
|
tree clinit_stmt_list; /* List of statements <clinit> will use */
|
|
tree ii_block; /* Instance initializer block */
|
|
tree dot_class; /* The decl of the `class$' function that
|
|
needs to be invoked and generated when
|
|
compiling to bytecode to implement
|
|
<non_primitive_type>.class */
|
|
};
|
|
|
|
#ifdef JAVA_USE_HANDLES
|
|
/* TYPE_BINFO_HANDLE points from a handle-class to its corresponding
|
|
non-handle-class, and vice verse. */
|
|
|
|
#define BINFO_HANDLE(NODE) TREE_VEC_ELT ((NODE), 6)
|
|
|
|
/* Given a RECORD_TYPE for a handle type, return the corresponding class. */
|
|
#define HANDLE_TO_CLASS_TYPE(HTYPE) BINFO_HANDLE (TYPE_BINFO (HTYPE))
|
|
|
|
/* Given a RECORD_TYPE for a class, return the corresponding handle type. */
|
|
#define CLASS_TO_HANDLE_TYPE(TYPE) BINFO_HANDLE (TYPE_BINFO (TYPE))
|
|
#else
|
|
#define HANDLE_TO_CLASS_TYPE(HTYPE) (HTYPE)
|
|
#define CLASS_TO_HANDLE_TYPE(TYPE) (TYPE)
|
|
#endif
|
|
|
|
#define JCF_u4 unsigned long
|
|
#define JCF_u2 unsigned short
|
|
|
|
extern void add_assume_compiled PARAMS ((const char *, int));
|
|
extern tree lookup_class PARAMS ((tree));
|
|
extern tree lookup_java_constructor PARAMS ((tree, tree));
|
|
extern tree lookup_java_method PARAMS ((tree, tree, tree));
|
|
extern tree lookup_argument_method PARAMS ((tree, tree, tree));
|
|
extern tree lookup_argument_method2 PARAMS ((tree, tree, tree));
|
|
extern tree promote_type PARAMS ((tree));
|
|
extern tree get_constant PARAMS ((struct JCF*, int));
|
|
extern tree get_name_constant PARAMS ((struct JCF*, int));
|
|
extern tree get_class_constant PARAMS ((struct JCF*, int));
|
|
extern tree parse_signature PARAMS ((struct JCF *jcf, int sig_index));
|
|
extern void jcf_parse PARAMS ((struct JCF*));
|
|
extern tree add_field PARAMS ((tree, tree, tree, int));
|
|
extern tree add_method PARAMS ((tree, int, tree, tree));
|
|
extern tree add_method_1 PARAMS ((tree, int, tree, tree));
|
|
extern tree make_class PARAMS ((void));
|
|
extern tree push_class PARAMS ((tree, tree));
|
|
extern tree unmangle_classname PARAMS ((const char *name, int name_length));
|
|
extern tree parse_signature_string PARAMS ((const unsigned char *, int));
|
|
extern tree get_type_from_signature PARAMS ((tree));
|
|
extern void layout_class PARAMS ((tree));
|
|
extern tree layout_class_method PARAMS ((tree, tree, tree, tree));
|
|
extern void layout_class_methods PARAMS ((tree));
|
|
extern tree build_class_ref PARAMS ((tree));
|
|
extern tree build_dtable_decl PARAMS ((tree));
|
|
extern tree build_internal_class_name PARAMS ((tree));
|
|
extern tree build_constants_constructor PARAMS ((void));
|
|
extern tree build_ref_from_constant_pool PARAMS ((int));
|
|
extern tree build_utf8_ref PARAMS ((tree));
|
|
extern tree ident_subst PARAMS ((const char*, int,
|
|
const char*, int, int, const char*));
|
|
extern tree identifier_subst PARAMS ((const tree,
|
|
const char *, int, int, const char *));
|
|
extern tree build_java_signature PARAMS ((tree));
|
|
extern tree build_java_argument_signature PARAMS ((tree));
|
|
extern void set_java_signature PARAMS ((tree, tree));
|
|
extern tree build_static_field_ref PARAMS ((tree));
|
|
extern tree build_address_of PARAMS ((tree));
|
|
extern tree find_local_variable PARAMS ((int index, tree type, int pc));
|
|
extern tree find_stack_slot PARAMS ((int index, tree type));
|
|
extern tree build_prim_array_type PARAMS ((tree, HOST_WIDE_INT));
|
|
extern tree build_java_array_type PARAMS ((tree, HOST_WIDE_INT));
|
|
extern int is_compiled_class PARAMS ((tree));
|
|
extern tree mangled_classname PARAMS ((const char*, tree));
|
|
extern tree lookup_label PARAMS ((int));
|
|
extern tree pop_type_0 PARAMS ((tree));
|
|
extern tree pop_type PARAMS ((tree));
|
|
extern void pop_argument_types PARAMS ((tree));
|
|
extern tree decode_newarray_type PARAMS ((int));
|
|
extern tree lookup_field PARAMS ((tree*, tree));
|
|
extern int is_array_type_p PARAMS ((tree));
|
|
extern HOST_WIDE_INT java_array_type_length PARAMS ((tree));
|
|
extern int read_class PARAMS ((tree));
|
|
extern void load_class PARAMS ((tree, int));
|
|
|
|
extern tree lookup_name PARAMS ((tree));
|
|
extern tree build_known_method_ref PARAMS ((tree, tree, tree, tree, tree));
|
|
extern tree build_class_init PARAMS ((tree, tree));
|
|
extern tree build_invokevirtual PARAMS ((tree, tree));
|
|
extern tree build_invokeinterface PARAMS ((tree, tree));
|
|
extern tree invoke_build_dtable PARAMS ((int, tree));
|
|
extern tree build_field_ref PARAMS ((tree, tree, tree));
|
|
extern void pushdecl_force_head PARAMS ((tree));
|
|
extern tree build_java_binop PARAMS ((enum tree_code, tree, tree, tree));
|
|
extern tree build_java_soft_divmod PARAMS ((enum tree_code, tree, tree, tree));
|
|
extern tree binary_numeric_promotion PARAMS ((tree, tree, tree *, tree *));
|
|
extern tree build_java_arrayaccess PARAMS ((tree, tree, tree));
|
|
extern tree build_newarray PARAMS ((int, tree));
|
|
extern tree build_anewarray PARAMS ((tree, tree));
|
|
extern tree build_new_array PARAMS ((tree, tree));
|
|
extern tree build_java_array_length_access PARAMS ((tree));
|
|
extern tree build_java_arraynull_check PARAMS ((tree, tree, tree));
|
|
extern tree create_label_decl PARAMS ((tree));
|
|
extern void push_labeled_block PARAMS ((tree));
|
|
extern tree prepare_eh_table_type PARAMS ((tree));
|
|
extern void java_set_exception_lang_code PARAMS ((void));
|
|
extern tree generate_name PARAMS ((void));
|
|
extern void pop_labeled_block PARAMS ((void));
|
|
extern const char *lang_printable_name PARAMS ((tree, int));
|
|
extern tree maybe_add_interface PARAMS ((tree, tree));
|
|
extern void set_super_info PARAMS ((int, tree, tree, int));
|
|
extern int get_access_flags_from_decl PARAMS ((tree));
|
|
extern int interface_of_p PARAMS ((tree, tree));
|
|
extern int inherits_from_p PARAMS ((tree, tree));
|
|
extern int enclosing_context_p PARAMS ((tree, tree));
|
|
extern void complete_start_java_method PARAMS ((tree));
|
|
extern tree build_result_decl PARAMS ((tree));
|
|
extern void emit_handlers PARAMS ((void));
|
|
extern void init_outgoing_cpool PARAMS ((void));
|
|
extern void make_class_data PARAMS ((tree));
|
|
extern void register_class PARAMS ((void));
|
|
extern int alloc_name_constant PARAMS ((int, tree));
|
|
extern void emit_register_classes PARAMS ((void));
|
|
extern void lang_init_source PARAMS ((int));
|
|
extern void write_classfile PARAMS ((tree));
|
|
extern char *print_int_node PARAMS ((tree));
|
|
extern void parse_error_context PARAMS ((tree cl, const char *, ...))
|
|
ATTRIBUTE_PRINTF_2;
|
|
extern tree build_primtype_type_ref PARAMS ((const char *));
|
|
extern tree java_get_real_method_name PARAMS ((tree));
|
|
extern void finish_class PARAMS ((void));
|
|
extern void java_layout_seen_class_methods PARAMS ((void));
|
|
extern void check_for_initialization PARAMS ((tree));
|
|
|
|
extern tree pushdecl_top_level PARAMS ((tree));
|
|
extern int alloc_class_constant PARAMS ((tree));
|
|
extern int unicode_mangling_length PARAMS ((const char *, int));
|
|
extern void init_expr_processing PARAMS ((void));
|
|
extern void push_super_field PARAMS ((tree, tree));
|
|
extern void init_class_processing PARAMS ((void));
|
|
extern int can_widen_reference_to PARAMS ((tree, tree));
|
|
extern int class_depth PARAMS ((tree));
|
|
extern int verify_jvm_instructions PARAMS ((struct JCF *, const unsigned char *, long));
|
|
extern void maybe_pushlevels PARAMS ((int));
|
|
extern void maybe_poplevels PARAMS ((int));
|
|
extern void force_poplevels PARAMS ((int));
|
|
extern int process_jvm_instruction PARAMS ((int, const unsigned char *, long));
|
|
extern void set_local_type PARAMS ((int, tree));
|
|
extern int merge_type_state PARAMS ((tree));
|
|
extern void push_type PARAMS ((tree));
|
|
extern void load_type_state PARAMS ((tree));
|
|
extern void add_interface PARAMS ((tree, tree));
|
|
extern void append_gpp_mangled_name PARAMS ((struct obstack *, const char *, int));
|
|
extern void append_gpp_mangled_classtype PARAMS ((struct obstack *, const char *));
|
|
extern void emit_unicode_mangled_name PARAMS ((struct obstack *, const char *, int));
|
|
extern tree force_evaluation_order PARAMS ((tree));
|
|
extern int verify_constant_pool PARAMS ((struct JCF *));
|
|
extern void start_java_method PARAMS ((tree));
|
|
extern void end_java_method PARAMS ((void));
|
|
extern void give_name_to_locals PARAMS ((struct JCF *));
|
|
extern void expand_byte_code PARAMS ((struct JCF *, tree));
|
|
extern int open_in_zip PARAMS ((struct JCF *, const char *, const char *, int));
|
|
extern void set_constant_value PARAMS ((tree, tree));
|
|
#ifdef jword
|
|
extern int find_constant1 PARAMS ((struct CPool *, int, jword));
|
|
extern int find_constant2 PARAMS ((struct CPool *, int, jword, jword));
|
|
#endif
|
|
extern int find_utf8_constant PARAMS ((struct CPool *, tree));
|
|
extern int find_string_constant PARAMS ((struct CPool *, tree));
|
|
extern int find_class_constant PARAMS ((struct CPool *, tree));
|
|
extern int find_fieldref_index PARAMS ((struct CPool *, tree));
|
|
extern int find_methodref_index PARAMS ((struct CPool *, tree));
|
|
extern void write_constant_pool PARAMS ((struct CPool *, unsigned char *, int));
|
|
extern int count_constant_pool_bytes PARAMS ((struct CPool *));
|
|
extern int encode_newarray_type PARAMS ((tree));
|
|
#ifdef uint64
|
|
extern void format_int PARAMS ((char *, jlong, int));
|
|
extern void format_uint PARAMS ((char *, uint64, int));
|
|
#endif
|
|
extern void jcf_trim_old_input PARAMS ((struct JCF *));
|
|
#ifdef BUFSIZ
|
|
extern void jcf_print_utf8 PARAMS ((FILE *, const unsigned char *, int));
|
|
extern void jcf_print_char PARAMS ((FILE *, int));
|
|
extern void jcf_print_utf8_replace PARAMS ((FILE *, const unsigned char *,
|
|
int, int, int));
|
|
# if JCF_USE_STDIO
|
|
extern char* open_class PARAMS ((char *, struct JCF *, FILE *, const char *));
|
|
# else
|
|
extern char* open_class PARAMS ((char *, struct JCF *, int, const char *));
|
|
# endif /* JCF_USE_STDIO */
|
|
#endif
|
|
void java_debug_context PARAMS ((void));
|
|
void safe_layout_class PARAMS ((tree));
|
|
|
|
extern tree get_boehm_type_descriptor PARAMS ((tree));
|
|
|
|
/* We use ARGS_SIZE_RTX to indicate that gcc/expr.h has been included
|
|
to declare `enum expand_modifier'. */
|
|
#if defined (TREE_CODE) && defined(RTX_CODE) && defined (HAVE_MACHINE_MODES) && defined (ARGS_SIZE_RTX)
|
|
struct rtx_def * java_lang_expand_expr PARAMS ((tree, rtx, enum machine_mode,
|
|
enum expand_modifier));
|
|
#endif /* TREE_CODE && RTX_CODE && HAVE_MACHINE_MODES && ARGS_SIZE_RTX */
|
|
|
|
/* Access flags etc for a method (a FUNCTION_DECL): */
|
|
|
|
#define METHOD_PUBLIC(DECL) DECL_LANG_FLAG_1 (DECL)
|
|
#define METHOD_PRIVATE(DECL) TREE_PRIVATE (DECL)
|
|
#define METHOD_PROTECTED(DECL) TREE_PROTECTED (DECL)
|
|
#define METHOD_STATIC(DECL) DECL_LANG_FLAG_2 (DECL)
|
|
#define METHOD_FINAL(DECL) DECL_LANG_FLAG_3 (DECL)
|
|
#define METHOD_SYNCHRONIZED(DECL) DECL_LANG_FLAG_4 (DECL)
|
|
#define METHOD_NATIVE(DECL) DECL_EXTERNAL(DECL)
|
|
#define METHOD_ABSTRACT(DECL) DECL_LANG_FLAG_5 (DECL)
|
|
#define METHOD_TRANSIENT(DECL) DECL_LANG_FLAG_6 (DECL)
|
|
|
|
/* Other predicates on method decls */
|
|
|
|
#define DECL_CONSTRUCTOR_P(DECL) DECL_LANG_FLAG_7(DECL)
|
|
|
|
#define DECL_INIT_P(DECL) (ID_INIT_P (DECL_NAME (DECL)))
|
|
#define DECL_FINIT_P(DECL) (ID_FINIT_P (DECL_NAME (DECL)))
|
|
#define DECL_CLINIT_P(DECL) (ID_CLINIT_P (DECL_NAME (DECL)))
|
|
|
|
/* Predicates on method identifiers. Kept close to other macros using
|
|
them */
|
|
#define ID_INIT_P(ID) ((ID) == init_identifier_node)
|
|
#define ID_FINIT_P(ID) ((ID) == finit_identifier_node)
|
|
#define ID_CLINIT_P(ID) ((ID) == clinit_identifier_node)
|
|
|
|
/* Access flags etc for a variable/field (a FIELD_DECL): */
|
|
|
|
#define FIELD_PRIVATE(DECL) TREE_PRIVATE (DECL)
|
|
#define FIELD_PROTECTED(DECL) TREE_PROTECTED (DECL)
|
|
#define FIELD_PUBLIC(DECL) DECL_LANG_FLAG_1 (DECL)
|
|
#define FIELD_STATIC(DECL) TREE_STATIC (DECL)
|
|
#define FIELD_FINAL(DECL) DECL_LANG_FLAG_3 (DECL)
|
|
#define FIELD_VOLATILE(DECL) DECL_LANG_FLAG_4 (DECL)
|
|
#define FIELD_TRANSIENT(DECL) DECL_LANG_FLAG_5 (DECL)
|
|
#define LOCAL_FINAL(DECL) FIELD_FINAL(DECL)
|
|
|
|
/* Access flags etc for a class (a TYPE_DECL): */
|
|
|
|
#define CLASS_PUBLIC(DECL) DECL_LANG_FLAG_1 (DECL)
|
|
#define CLASS_FINAL(DECL) DECL_LANG_FLAG_3 (DECL)
|
|
#define CLASS_INTERFACE(DECL) DECL_LANG_FLAG_4 (DECL)
|
|
#define CLASS_ABSTRACT(DECL) DECL_LANG_FLAG_5 (DECL)
|
|
#define CLASS_SUPER(DECL) DECL_LANG_FLAG_6 (DECL)
|
|
#define CLASS_STATIC(DECL) DECL_LANG_FLAG_7 (DECL)
|
|
|
|
/* @deprecated marker flag on methods, fields and classes */
|
|
|
|
#define METHOD_DEPRECATED(DECL) DECL_LANG_FLAG_0 (DECL)
|
|
#define FIELD_DEPRECATED(DECL) DECL_LANG_FLAG_0 (DECL)
|
|
#define CLASS_DEPRECATED(DECL) DECL_LANG_FLAG_0 (DECL)
|
|
#define DECL_DEPRECATED(DECL) DECL_LANG_FLAG_0 (DECL)
|
|
|
|
/* The number of virtual methods in this class's dispatch table.
|
|
Does not include initial two dummy entries (one points to the
|
|
Class object, and the other is for G++ -fvtable-thunks compatibility). */
|
|
#define TYPE_NVIRTUALS(TYPE) TYPE_BINFO_VIRTUALS (TYPE)
|
|
|
|
/* A TREE_VEC (indexed by DECL_VINDEX) containing this class's
|
|
virtual methods. */
|
|
#define TYPE_VTABLE(TYPE) TYPE_BINFO_VTABLE(TYPE)
|
|
|
|
/* Use CLASS_LOADED_P? FIXME */
|
|
#define CLASS_COMPLETE_P(DECL) DECL_LANG_FLAG_2 (DECL)
|
|
|
|
/* This maps a bytecode offset (PC) to various flags,
|
|
listed below (starting with BCODE_). */
|
|
extern char *instruction_bits;
|
|
|
|
/* True iff the byte is the start of an instruction. */
|
|
#define BCODE_INSTRUCTION_START 1
|
|
|
|
/* True iff there is a jump to this location. */
|
|
#define BCODE_JUMP_TARGET 2
|
|
|
|
/* True iff there is a return to this location.
|
|
(I.e. the preceedng instruction was a call.) */
|
|
#define BCODE_RETURN_TARGET 4
|
|
|
|
/* True iff this is the start of an exception handler. */
|
|
#define BCODE_EXCEPTION_TARGET 16
|
|
|
|
/* True iff there is a jump to this location (and it needs a label). */
|
|
#define BCODE_TARGET \
|
|
(BCODE_JUMP_TARGET|BCODE_RETURN_TARGET \
|
|
| BCODE_EXCEPTION_TARGET)
|
|
|
|
/* True iff there is an entry in the linenumber table for this location. */
|
|
#define BCODE_HAS_LINENUMBER 32
|
|
|
|
/* True iff there is more than one entry in the linenumber table for
|
|
this location. (This probably does not make much sense.) */
|
|
#define BCODE_HAS_MULTI_LINENUMBERS 64
|
|
|
|
/* True if this instruction has been verified. */
|
|
#define BCODE_VERIFIED 8
|
|
|
|
/* A pointer to the line number table of the current method. */
|
|
extern const unsigned char *linenumber_table;
|
|
/* The length (in items) of the line number table. */
|
|
extern int linenumber_count;
|
|
|
|
/* In type_map, means that slot is uninitialized or otherwise unusable. */
|
|
#define TYPE_UNKNOWN NULL_TREE
|
|
|
|
/* In type_map, means the second half of a 64-bit double or long. */
|
|
#define TYPE_SECOND void_type_node
|
|
|
|
/* In type_map, means the null type (i.e. type of a null reference). */
|
|
#define TYPE_NULL ptr_type_node
|
|
|
|
/* In a type map means the type the address subroutine return address. */
|
|
#define TYPE_RETURN_ADDR return_address_type_node
|
|
|
|
/* In a subroutine's return type map, indicates that the slot was neither
|
|
used nor set in the subroutine. */
|
|
#define TYPE_UNUSED error_mark_node
|
|
|
|
/* A array mapping variable/stack slot index to the type current
|
|
in that variable/stack slot.
|
|
TYPE_UNKNOWN, TYPE_SECOND, and TYPE_NULL are special cases. */
|
|
extern tree *type_map;
|
|
|
|
/* Map a stack index to the type currently in that slot. */
|
|
#define stack_type_map (type_map+DECL_MAX_LOCALS(current_function_decl))
|
|
|
|
/* True iff TYPE takes two variable/stack slots. */
|
|
#define TYPE_IS_WIDE(TYPE) \
|
|
((TYPE) == double_type_node || (TYPE) == long_type_node)
|
|
|
|
/* True iif CLASS has it's access$0 method generated. */
|
|
#define CLASS_ACCESS0_GENERATED_P(CLASS) TYPE_LANG_FLAG_0 (CLASS)
|
|
|
|
/* True iff TYPE is a Java array type. */
|
|
#define TYPE_ARRAY_P(TYPE) TYPE_LANG_FLAG_1 (TYPE)
|
|
|
|
/* If FUNCTION_TYPE or METHOD_TYPE: cache for build_java_argument_signature. */
|
|
#define TYPE_ARGUMENT_SIGNATURE(TYPE) TYPE_VFIELD(TYPE)
|
|
|
|
/* Given an array type, give the type of the elements. */
|
|
/* FIXME this use of TREE_TYPE conflicts with something or other. */
|
|
#define TYPE_ARRAY_ELEMENT(ATYPE) TREE_TYPE(ATYPE)
|
|
|
|
/* True if class TYPE has been loaded. */
|
|
#define CLASS_LOADED_P(TYPE) TYPE_LANG_FLAG_2 (TYPE)
|
|
|
|
/* True if class TYPE was defined in Java source code. */
|
|
#define CLASS_FROM_SOURCE_P(TYPE) TYPE_LANG_FLAG_3 (TYPE)
|
|
|
|
/* True of a RECORD_TYPE of a class/interface type (not array type) */
|
|
#define CLASS_P(TYPE) TYPE_LANG_FLAG_4 (TYPE)
|
|
|
|
/* True if class TYPE was defined in a Java source file compiled. */
|
|
#define CLASS_FROM_CURRENTLY_COMPILED_SOURCE_P(TYPE) \
|
|
TYPE_LANG_FLAG_5 (TYPE)
|
|
|
|
/* True if class TYPE is currently being laid out. Helps in detection
|
|
of inheritance cycle occuring as a side effect of performing the
|
|
layout of a class. */
|
|
#define CLASS_BEING_LAIDOUT(TYPE) TYPE_LANG_FLAG_6 (TYPE)
|
|
|
|
/* True if class TYPE is currently being laid out. Helps in detection
|
|
of inheritance cycle occuring as a side effect of performing the
|
|
layout of a class. */
|
|
#define CLASS_BEING_LAIDOUT(TYPE) TYPE_LANG_FLAG_6 (TYPE)
|
|
|
|
/* True if class TYPE has a field initializer $finit$ function */
|
|
#define CLASS_HAS_FINIT_P(TYPE) TYPE_FINIT_STMT_LIST (TYPE)
|
|
|
|
/* True if identifier ID was seen while processing a single type import stmt */
|
|
#define IS_A_SINGLE_IMPORT_CLASSFILE_NAME_P(ID) TREE_LANG_FLAG_0 (ID)
|
|
|
|
/* True if identifier ID was seen while processing an import statement */
|
|
#define IS_A_CLASSFILE_NAME(ID) TREE_LANG_FLAG_1 (ID)
|
|
|
|
/* True if ID is a qualified named (contains . or /) */
|
|
#define QUALIFIED_P(ID) TREE_LANG_FLAG_2 (ID)
|
|
|
|
/* True if ID is an already processed import on demand */
|
|
#define IS_AN_IMPORT_ON_DEMAND_P(ID) TREE_LANG_FLAG_3 (ID)
|
|
|
|
/* True if ID is a command-line specified filename */
|
|
#define IS_A_COMMAND_LINE_FILENAME_P(ID) TREE_LANG_FLAG_4 (ID)
|
|
|
|
/* True if filename ID has already been parsed */
|
|
#define HAS_BEEN_ALREADY_PARSED_P(ID) TREE_LANG_FLAG_5 (ID)
|
|
|
|
/* True if EXPR is RHS sub-tree of a compound assign expression */
|
|
#define COMPOUND_ASSIGN_P(EXPR) TREE_LANG_FLAG_1 (EXPR)
|
|
|
|
/* True if a SWITCH_EXPR has a DEFAULT_EXPR. */
|
|
#define SWITCH_HAS_DEFAULT(NODE) TREE_LANG_FLAG_3 (NODE)
|
|
|
|
/* True if EXPR (a WFL in that case) was created after the
|
|
reduction of PRIMARY . XXX */
|
|
#define PRIMARY_P(EXPR) TREE_LANG_FLAG_2 (EXPR)
|
|
|
|
/* True if EXPR (a MODIFY_EXPR in that case) is the result of variable
|
|
initialization during its declaration */
|
|
#define MODIFY_EXPR_FROM_INITIALIZATION_P(EXPR) TREE_LANG_FLAG_2 (EXPR)
|
|
|
|
/* True if EXPR (a WFL in that case) resolves into an expression name */
|
|
#define RESOLVE_EXPRESSION_NAME_P(WFL) TREE_LANG_FLAG_0 (WFL)
|
|
|
|
/* True if EXPR (a LOOP_EXPR in that case) is part of a for statement */
|
|
#define FOR_LOOP_P(EXPR) TREE_LANG_FLAG_0 (EXPR)
|
|
|
|
/* True if NODE (a RECORD_TYPE in that case) is an anonymous class. */
|
|
#define ANONYMOUS_CLASS_P(NODE) TREE_LANG_FLAG_0 (NODE)
|
|
|
|
/* True if NODE (a RECORD_TYPE in that case) is a block local class. */
|
|
#define LOCAL_CLASS_P(NODE) TREE_LANG_FLAG_1 (NODE)
|
|
|
|
/* True if NODE (a TREE_LIST) hold a pair of argument name/type
|
|
declared with the final modifier */
|
|
#define ARG_FINAL_P(NODE) TREE_LANG_FLAG_0 (NODE)
|
|
|
|
/* True if EXPR (a WFL in that case) resolves into a package name */
|
|
#define RESOLVE_PACKAGE_NAME_P(WFL) TREE_LANG_FLAG_3 (WFL)
|
|
|
|
/* True if EXPR (a WFL in that case) resolves into a type name */
|
|
#define RESOLVE_TYPE_NAME_P(WFL) TREE_LANG_FLAG_4 (WFL)
|
|
|
|
/* True if STMT (a WFL in that case) holds a BREAK statement */
|
|
#define IS_BREAK_STMT_P(WFL) TREE_LANG_FLAG_5 (WFL)
|
|
|
|
/* True if EXPR (a CALL_EXPR in that case) is a crafted StringBuffer */
|
|
#define IS_CRAFTED_STRING_BUFFER_P(EXPR) TREE_LANG_FLAG_5 (EXPR)
|
|
|
|
/* True if EXPR (a SAVE_EXPR in that case) had its content already
|
|
checked for (un)initialized local variables. */
|
|
#define IS_INIT_CHECKED(EXPR) TREE_LANG_FLAG_5 (EXPR)
|
|
|
|
/* If set in CALL_EXPR, the receiver is 'super'. */
|
|
#define CALL_USING_SUPER(EXPR) TREE_LANG_FLAG_4 (EXPR)
|
|
|
|
/* True if NODE (a statement) can complete normally. */
|
|
#define CAN_COMPLETE_NORMALLY(NODE) TREE_LANG_FLAG_6(NODE)
|
|
|
|
/* True if NODE (an IDENTIFIER) bears the name of a outer field from
|
|
inner class access function. */
|
|
#define OUTER_FIELD_ACCESS_IDENTIFIER_P(NODE) TREE_LANG_FLAG_6(NODE)
|
|
|
|
/* Non null if NODE belongs to an inner class TYPE_DECL node.
|
|
Verifies that NODE as the attributes of a decl. */
|
|
#define INNER_CLASS_DECL_P(NODE) (TYPE_NAME (TREE_TYPE (NODE)) == NODE \
|
|
&& DECL_CONTEXT (NODE))
|
|
|
|
/* Non null if NODE is an top level class TYPE_DECL node: NODE isn't
|
|
an inner class or NODE is a static class. */
|
|
#define TOPLEVEL_CLASS_DECL_P(NODE) (!INNER_CLASS_DECL_P (NODE) \
|
|
|| CLASS_STATIC (NODE))
|
|
|
|
/* True if the class decl NODE was declared in a inner scope and is
|
|
not a toplevel class */
|
|
#define PURE_INNER_CLASS_DECL_P(NODE) \
|
|
(INNER_CLASS_DECL_P (NODE) && !CLASS_STATIC (NODE))
|
|
|
|
/* Non null if NODE belongs to an inner class RECORD_TYPE node. Checks
|
|
that TYPE_NAME bears a decl. An array type wouldn't. */
|
|
#define INNER_CLASS_TYPE_P(NODE) (TREE_CODE (TYPE_NAME (NODE)) == TYPE_DECL \
|
|
&& DECL_CONTEXT (TYPE_NAME (NODE)))
|
|
|
|
#define TOPLEVEL_CLASS_TYPE_P(NODE) (!INNER_CLASS_TYPE_P (NODE) \
|
|
|| CLASS_STATIC (TYPE_NAME (NODE)))
|
|
|
|
/* True if the class type NODE was declared in a inner scope and is
|
|
not a toplevel class */
|
|
#define PURE_INNER_CLASS_TYPE_P(NODE) \
|
|
(INNER_CLASS_TYPE_P (NODE) && !CLASS_STATIC (TYPE_NAME (NODE)))
|
|
|
|
/* Non null if NODE (a TYPE_DECL or a RECORD_TYPE) is an inner class. */
|
|
#define INNER_CLASS_P(NODE) (TREE_CODE (NODE) == TYPE_DECL ? \
|
|
INNER_CLASS_DECL_P (NODE) : \
|
|
(TREE_CODE (NODE) == RECORD_TYPE ? \
|
|
INNER_CLASS_TYPE_P (NODE) : \
|
|
(fatal ("INNER_CLASS_P: Wrong node type"), 0)))
|
|
|
|
/* On a TYPE_DECL, hold the list of inner classes defined within the
|
|
scope of TYPE_DECL. */
|
|
#define DECL_INNER_CLASS_LIST(NODE) DECL_INITIAL (NODE)
|
|
|
|
/* Add a FIELD_DECL to RECORD_TYPE RTYPE.
|
|
The field has name NAME (a char*), and type FTYPE.
|
|
Unless this is the first field, FIELD most hold the previous field.
|
|
FIELD is set to the newly created FIELD_DECL.
|
|
|
|
We set DECL_ARTIFICIAL so these fields get skipped by make_class_data
|
|
if compiling java.lang.Object or java.lang.Class. */
|
|
|
|
#define PUSH_FIELD(RTYPE, FIELD, NAME, FTYPE) \
|
|
{ tree tmp_field = build_decl (FIELD_DECL, get_identifier(NAME), FTYPE); \
|
|
if (TYPE_FIELDS (RTYPE) == NULL_TREE) TYPE_FIELDS (RTYPE) = tmp_field; \
|
|
else TREE_CHAIN(FIELD) = tmp_field; \
|
|
DECL_CONTEXT (tmp_field) = RTYPE; \
|
|
DECL_ARTIFICIAL (tmp_field) = 1; \
|
|
FIELD = tmp_field; }
|
|
|
|
#define FINISH_RECORD(RTYPE) layout_type (RTYPE)
|
|
|
|
/* Start building a RECORD_TYPE constructor with a given TYPE in CONS. */
|
|
#define START_RECORD_CONSTRUCTOR(CONS, CTYPE) { \
|
|
CONS = build (CONSTRUCTOR, CTYPE, NULL_TREE, NULL_TREE);\
|
|
TREE_CHAIN(CONS) = TYPE_FIELDS (CTYPE); }
|
|
|
|
/* Append a field initializer to CONS for the dummy field for the inherited
|
|
fields. The dummy field has the given VALUE, and the same type as the
|
|
super-class. Must be specified before calls to PUSH_FIELD_VALUE. */
|
|
|
|
#define PUSH_SUPER_VALUE(CONS, VALUE) {\
|
|
tree field = TREE_CHAIN(CONS);\
|
|
if (DECL_NAME (field) != NULL_TREE) abort();\
|
|
CONSTRUCTOR_ELTS(CONS) = tree_cons (field, VALUE, CONSTRUCTOR_ELTS(CONS));\
|
|
TREE_CHAIN(CONS) = TREE_CHAIN (field); }
|
|
|
|
/* Append a field initializer to CONS for a field with the given VALUE.
|
|
NAME is a char* string used for error checking;
|
|
the initializer must be specified in order. */
|
|
#define PUSH_FIELD_VALUE(CONS, NAME, VALUE) {\
|
|
tree field = TREE_CHAIN(CONS);\
|
|
if (strcmp (IDENTIFIER_POINTER (DECL_NAME (field)), NAME) != 0) abort();\
|
|
CONSTRUCTOR_ELTS(CONS) = tree_cons (field, VALUE, CONSTRUCTOR_ELTS(CONS));\
|
|
TREE_CHAIN(CONS) = TREE_CHAIN (field); }
|
|
|
|
/* Finish creating a record CONSTRUCTOR CONS. */
|
|
#define FINISH_RECORD_CONSTRUCTOR(CONS) \
|
|
CONSTRUCTOR_ELTS(CONS) = nreverse (CONSTRUCTOR_ELTS(CONS))
|
|
|
|
/* Macros on constructors invocations. */
|
|
#define CALL_CONSTRUCTOR_P(NODE) \
|
|
(TREE_CODE (NODE) == NEW_CLASS_EXPR || CALL_EXPLICIT_CONSTRUCTOR_P (NODE))
|
|
|
|
#define CALL_EXPLICIT_CONSTRUCTOR_P(NODE) \
|
|
(CALL_THIS_CONSTRUCTOR_P (NODE) || CALL_SUPER_CONSTRUCTOR_P (NODE))
|
|
|
|
#define CALL_THIS_CONSTRUCTOR_P(NODE) \
|
|
(TREE_CODE (NODE) == CALL_EXPR \
|
|
&& EXPR_WFL_NODE (TREE_OPERAND (NODE, 0)) == this_identifier_node)
|
|
|
|
#define CALL_SUPER_CONSTRUCTOR_P(NODE) \
|
|
(TREE_CODE (NODE) == CALL_EXPR \
|
|
&& EXPR_WFL_NODE (TREE_OPERAND (NODE, 0)) == super_identifier_node)
|
|
|
|
/* Using a FINALLY_EXPR node */
|
|
#define FINALLY_EXPR_LABEL(NODE) TREE_OPERAND ((NODE), 0)
|
|
#define FINALLY_EXPR_BLOCK(NODE) TREE_OPERAND ((NODE), 1)
|
|
|
|
#define BLOCK_EXPR_DECLS(NODE) BLOCK_VARS(NODE)
|
|
#define BLOCK_EXPR_BODY(NODE) BLOCK_SUBBLOCKS(NODE)
|
|
|
|
#define BUILD_MONITOR_ENTER(WHERE, ARG) \
|
|
{ \
|
|
(WHERE) = build (CALL_EXPR, int_type_node, \
|
|
build_address_of (soft_monitorenter_node), \
|
|
build_tree_list (NULL_TREE, (ARG)), \
|
|
NULL_TREE); \
|
|
TREE_SIDE_EFFECTS (WHERE) = 1; \
|
|
}
|
|
|
|
#define BUILD_MONITOR_EXIT(WHERE, ARG) \
|
|
{ \
|
|
(WHERE) = build (CALL_EXPR, int_type_node, \
|
|
build_address_of (soft_monitorexit_node), \
|
|
build_tree_list (NULL_TREE, (ARG)), \
|
|
NULL_TREE); \
|
|
TREE_SIDE_EFFECTS (WHERE) = 1; \
|
|
}
|
|
|
|
/* Non zero if TYPE is an unchecked exception */
|
|
#define IS_UNCHECKED_EXCEPTION_P(TYPE) \
|
|
(inherits_from_p ((TYPE), runtime_exception_type_node) \
|
|
|| inherits_from_p ((TYPE), error_exception_type_node))
|
|
|
|
extern int java_error_count; \
|
|
|
|
/* Make the current function where this macro is invoked report error
|
|
messages and and return, if any */
|
|
#define java_parse_abort_on_error() \
|
|
{ \
|
|
if (java_error_count > save_error_count) \
|
|
return; \
|
|
}
|
|
|
|
#undef DEBUG_JAVA_BINDING_LEVELS
|