tree.h (build_int_cst): New.

.:	* tree.h (build_int_cst): New.
	(build_int_2): Remove.
	* tree.c (build_int_2): Remove.
	(build_int_cst): New.
	(make_vector_type, build_common_tree_nodes,
	build_common_tree_nodes_2): Use build_int_cst.
	* builtins.c (expand_builtin_prefetch, expand_builtin_strstr,
	expand_builtin_strpbrk, expand_builtin_fputs,
	build_string_literal, expand_builtin_printf,
	expand_builtin_sprintf, fold_builtin_lround, fold_builtin_bitop,
	fold_builtin_bitop, fold_builtin_isascii, fold_builtin_toascii,
	fold_builtin_isdigit, simplify_builtin_strstr,
	simplify_builtin_strpbrk, fold_builtin_fputs,
	simplify_builtin_sprintf): Use build_int_cst.
	* c-common.c (start_fname_decls, fix_string_type,
	c_common_nodes_and_builtins, c_init_attributes,
	shorten_compare): Likewise.
	* c-decl.c (complete_array_type,
	check_bitfield_type_and_width): Likewise.
	* c-lex.c (interpret_integer, lex_charconst): Likewise.
	* c-parse.in (primary): <TYPES_COMPATIBLE_P> Likewise.
	* c-pretty-print.c (pp_c_integer_constant): Likewise.
	* c-typeck.c (really_start_incremental_init, push_init_level,
	set_nonincremental_init_from_string): Likewise.
	* calls.c (load_register_parameters): Likewise.
	* convert.c (convert_to_pointer): Likewise.
	* coverage.c (coverage_counter_alloc, tree_coverage_counter_ref,
	build_fn_info_type, build_ctr_info_value, build_gcov_info):
	Likewise.
	* except.c (init_eh, assign_filter_values, assign_filter_values):
	Likewise.
	* expmed.c (store_fixed_bit_field, extract_bit_field,
	extract_fixed_bit_field, extract_split_bit_field, expand_shift,
	expand_mult_const, expand_mult_highpart_adjust, extract_high_half,
	expand_sdiv_pow2, expand_divmod, make_tree): Likewise.
	* expr.c (convert_move, emit_group_load, emit_group_store,
	expand_assignment, store_constructor, store_field,
	expand_expr_real_1, reduce_to_bit_field_precision): Likewise.
	* fold-const.c (force_fit_type, int_const_binop, fold_convert_const,
	invert_truthvalue, optimize_bit_field_compare,
	decode_field_reference, all_ones_mask_p, constant_boolean_node,
	fold_div_compare, fold, fold_read_from_constant_string,
	fold_negate_const, fold_abs_const, fold_not_const): Likewise.
	* function.c (assign_parm_setup_block): Likewise.
	* stmt.c (shift_return_value, expand_end_case_type,
	estimate_case_costs): Likewise.
	* stor-layout.c (layout_type, initialize_sizetypes,
	set_min_and_max_values_for_integral_type): Likewise.
	* tree-chrec.c (chrec_fold_multiply_poly_poly,
	reset_evolution_in_loop): Likewise.
	* tree-chrec.h (build_polynomial_chrec): Likewise.
	* tree-complex.c (build_replicated_const): Likewise.
	* tree-eh.c (honor_protect_cleanup_actions,
	lower_try_finally_onedest, lower_try_finally_copy,
	lower_try_finally_switch): Likewise.
	* tree-mudflap.c (mf_build_string, mx_register_decls,
	mudflap_register_call, mudflap_enqueue_constant): Likewise.
	* tree-nested.c (get_trampoline_type, get_nl_goto_field): Likewise.
	* tree-pretty-print.c (dump_generic_node): Likewise.
	* tree-ssa-ccp.c (widen_bitfield, maybe_fold_offset_to_array_ref):
	Likewise.
	* tree-ssa-dom.c (simplify_rhs_and_lookup_avail_expr): Likewise.
	* tree-ssa-loop-niter.c (number_of_iterations_cond,
	loop_niter_by_eval, upper_bound_in_type, lower_bound_in_type):
	Likewise.

	* config/alpha/alpha.c (alpha_initialize_trampoline,
	alpha_va_start, alpha_gimplify_va_arg_1): Use build_int_cst.
	* config/arm/arm.c (arm_get_cookie_size): Likewise.
	* config/c4x/c4x.c (c4x_gimplify_va_arg_expr): Likewise.
	* config/i386/i386.c (ix86_va_start, ix86_gimplify_va_arg): Likewise.
	* config/i860/i860.c (i860_va_start): Likewise.
	* config/ia64/ia64.c (ia64_gimplify_va_arg): Likewise.
	* config/mips/mips.c (mips_build_builtin_va_list, mips_va_start,
	mips_gimplify_va_arg_expr): Likewise.
	* config/pa/pa.c (hppa_gimplify_va_arg_expr): Likewise.
	* config/rs6000/rs6000.c (rs6000_va_start, rs6000_gimplify_va_arg,
	add_compiler_branch_island): Likewise.
	* config/s390/s390.c (s390_va_start): Likewise.
	* config/sh/sh.c (sh_va_start): Likewise.
	* config/stormy16/stormy16.c (xstormy16_expand_builtin_va_start):
	Likewise.
	* config/xtensa/xtensa.c (xtensa_va_start,
	xtensa_gimplify_va_arg_expr): Likewise.

	* objc/objc-act.c (build_objc_string_object,
	build_objc_symtab_template, init_def_list, init_objc_symtab,
	init_module_descriptor, generate_static_references,
	build_selector_translation_table, get_proto_encoding,
	build_typed_selector_reference, build_selector_reference,
	build_next_objc_exception_stuff,
	build_method_prototype_list_template, generate_descriptor_table,
	generate_protocols, build_protocol_initializer,
	build_ivar_list_template, build_method_list_template,
	build_ivar_list_initializer, generate_ivars_list,
	generate_dispatch_table, generate_protocol_list,
	build_category_initializer, build_shared_structure_initializer,
	generate_shared_structures, handle_impent,
	generate_objc_image_info): Use build_int_cst.
ada:
	* cuintp.c (UI_To_gnu): Use build_int_cst..
	* trans.c (Exception_Handler_to_gnu_sjlj, gnat_to_gnu): Likewise.
	* utils.c (init_gigi_decls): Likewise.
	* utils2.c (build_call_raise): Likewise.
cp:
	* call.c (convert_class_to_reference,
	build_user_type_conversion_1, convert_like_real,
	build_java_interface_fn_ref, build_special_member_call): Use
	build_int_cst.
	* class.c (build_vtbl_initializer): Likewise.
	* cp-gimplify.c (cp_gimplify_expr): Likewise.
	* cvt.c (cp_convert_to_pointer): Likewise.
	* decl.c (cxx_init_decl_processing, complete_array_type): Likewise.
	* decl2.c (start_static_initialization_or_destruction,
	generate_ctor_or_dtor_function): Likewise.
	* except.c (build_throw): Likewise.
	* lex.c (cxx_init): Likewise.
	* mangle.c (write_integer_cst): Likewise.
	* rtti.c (build_headof, get_tinfo_decl_dynamic,
	build_dynamic_cast_1, ptr_initializer, ptm_initializer,
	get_pseudo_ti_init): Likewise.
	* search.c (get_dynamic_cast_base_type): Likewise.
	* tree.c (build_shared_int_cst): Likewise.
fortran:
	* trans-array.c (gfc_trans_array_constructor_value): Use
	build_int_cst.
	* trans-const.c (gfc_build_string_const,
	gfc_init_constants, gfc_conv_mpz_to_tree,
	gfc_conv_constant_to_tree): Likewise.
	* trans-decl.c (gfc_get_symbol_decl): Likewise.
	* trans-intrinsic.c (gfc_conv_intrinsic_ibits,
	gfc_conv_intrinsic_len, prepare_arg_info): Likewise.
	* trans-io.c (add_case, set_error_locus, build_dt,
	transfer_expr): Likewise.
	* trans-stmt.c (gfc_trans_label_assign, gfc_trans_pause,
	gfc_trans_stop, gfc_trans_character_select): Likewise.
	* trans-types.c (gfc_init_types, gfc_get_dtype): Likewise.
	* trans.c (gfc_trans_runtime_check): Likewise.
java:
	* boehm.c (get_boehm_type_descriptor): Use build_int_cst.
	* class.c (build_utf8_ref, build_static_field_ref,
	make_field_value, make_method_value, get_dispatch_table,
	make_class_data, emit_symbol_table, emit_catch_table): Likewise.
	* constants.c (get_tag_node,  build_ref_from_constant_pool,
	build_constants_constructor): Likewise.
	* decl.c (java_init_decl_processing): Likewise.
	* expr.c (build_java_array_length_access, build_newarray,
	expand_java_multianewarray, expand_java_pushc, expand_iinc,
	build_java_binop, build_field_ref, expand_java_add_case,
	expand_java_call, build_known_method_ref, build_invokevirtual,
	build_invokeinterface, build_jni_stub): Likewise.
	* java-gimplify.c (java_gimplify_new_array_init): Likewise.
	* jcf-parse.c (get_constant): Likewise.
	* lex.c (do_java_lex): Likewise.
	* parse.y (patch_binop, patch_unaryop, patch_cast,
	build_null_of_type, patch_newarray): Likewise.
	* resource.c (compile_resource_data): Likewise.
	* typeck.c (build_prim_array_type): Likewise.

From-SVN: r86022

12 files changed, 121 insertions, 105 deletions

diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog
index a1e5a05..493a5f3 100644
--- a/gcc/java/ChangeLog
+++ b/gcc/java/ChangeLog
@@ -1,3 +1,25 @@
+2004-08-15  Nathan Sidwell  <nathan@codesourcery.com>
+
+	* boehm.c (get_boehm_type_descriptor): Use build_int_cst.
+	* class.c (build_utf8_ref, build_static_field_ref,
+	make_field_value, make_method_value, get_dispatch_table,
+	make_class_data, emit_symbol_table, emit_catch_table): Likewise.
+	* constants.c (get_tag_node,  build_ref_from_constant_pool, 
+	build_constants_constructor): Likewise.
+	* decl.c (java_init_decl_processing): Likewise.
+	* expr.c (build_java_array_length_access, build_newarray,
+	expand_java_multianewarray, expand_java_pushc, expand_iinc,
+	build_java_binop, build_field_ref, expand_java_add_case,
+	expand_java_call, build_known_method_ref, build_invokevirtual,
+	build_invokeinterface, build_jni_stub): Likewise.
+	* java-gimplify.c (java_gimplify_new_array_init): Likewise.
+	* jcf-parse.c (get_constant): Likewise.
+	* lex.c (do_java_lex): Likewise.
+	* parse.y (patch_binop, patch_unaryop, patch_cast,
+	build_null_of_type, patch_newarray): Likewise.
+	* resource.c (compile_resource_data): Likewise.
+	* typeck.c (build_prim_array_type): Likewise.
+
 2004-08-10  Bryce McKinlay  <mckinlay@redhat.com>
 
 	* java-gimplify.c (java_gimplify_new_array_init): Use create_tmp_var.
diff --git a/gcc/java/boehm.c b/gcc/java/boehm.c
index 00dc490..ae2fbfa 100644
--- a/gcc/java/boehm.c
+++ b/gcc/java/boehm.c
@@ -146,12 +146,13 @@ get_boehm_type_descriptor (tree type)
   HOST_WIDE_INT last_view_index = -1;
   int pointer_after_end = 0;
   unsigned HOST_WIDE_INT low = 0, high = 0;
-  tree field, value;
+  tree field, value, value_type;
 
   /* If the GC wasn't requested, just use a null pointer.  */
   if (! flag_use_boehm_gc)
     return null_pointer_node;
 
+  value_type = java_type_for_mode (ptr_mode, 1);
   /* If we have a type of unknown size, use a proc.  */
   if (int_size_in_bytes (type) == -1)
     goto procedure_object_descriptor;
@@ -205,13 +206,13 @@ get_boehm_type_descriptor (tree type)
 	  last_set_index >>= 1;
 	  ++count;
 	}
-      value = build_int_2 (low, high);
+      value = build_int_cst (value_type, low, high);
     }
   else if (! pointer_after_end)
     {
       /* Bottom two bits for bitmap mark type are 01.  */
       set_bit (&low, &high, 0);
-      value = build_int_2 (low, high);
+      value = build_int_cst (value_type, low, high);
     }
   else
     {
@@ -222,9 +223,8 @@ get_boehm_type_descriptor (tree type)
 	    | DS_PROC)
 	 Here DS_PROC == 2.  */
     procedure_object_descriptor:
-      value = build_int_2 (2, 0);
+      value = build_int_cst (value_type, 2, 0);
     }
 
-  TREE_TYPE (value) = java_type_for_mode (ptr_mode, 1);
   return value;
 }
diff --git a/gcc/java/class.c b/gcc/java/class.c
index 7f4c01c..b8b4c90 100644
--- a/gcc/java/class.c
+++ b/gcc/java/class.c
@@ -880,8 +880,8 @@ build_utf8_ref (tree name)
   FINISH_RECORD (ctype);
   START_RECORD_CONSTRUCTOR (cinit, ctype);
   name_hash = hashUtf8String (name_ptr, name_len) & 0xFFFF;
-  PUSH_FIELD_VALUE (cinit, "hash", build_int_2 (name_hash, 0));
-  PUSH_FIELD_VALUE (cinit, "length", build_int_2 (name_len, 0));
+  PUSH_FIELD_VALUE (cinit, "hash", build_int_cst (NULL_TREE, name_hash, 0));
+  PUSH_FIELD_VALUE (cinit, "length", build_int_cst (NULL_TREE, name_len, 0));
   string = build_string (name_len, name_ptr);
   TREE_TYPE (string) = str_type;
   PUSH_FIELD_VALUE (cinit, "data", string);
@@ -1081,8 +1081,8 @@ build_static_field_ref (tree fdecl)
   if (flag_indirect_dispatch)
     {
       tree table_index 
-	= build_int_2 (get_symbol_table_index 
-		       (fdecl, &TYPE_ATABLE_METHODS (output_class)), 0);
+	= build_int_cst (NULL_TREE, get_symbol_table_index 
+			 (fdecl, &TYPE_ATABLE_METHODS (output_class)), 0);
       tree field_address
 	= build4 (ARRAY_REF, build_pointer_type (TREE_TYPE (fdecl)), 
 		  TYPE_ATABLE_DECL (output_class), table_index,
@@ -1114,7 +1114,7 @@ build_static_field_ref (tree fdecl)
 	}
       field_index *= int_size_in_bytes (field_type_node);
       ref = fold (build2 (PLUS_EXPR, field_ptr_type_node,
-			  ref, build_int_2 (field_index, 0)));
+			  ref, build_int_cst (NULL_TREE, field_index, 0)));
       ref = build1 (INDIRECT_REF, field_type_node, ref);
       ref = build3 (COMPONENT_REF, field_info_union_node,
 		    ref, lookup_field (&field_type_node, info_ident),
@@ -1224,7 +1224,7 @@ make_field_value (tree fdecl)
   if (! resolved)
     flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
 
-  PUSH_FIELD_VALUE (finit, "accflags", build_int_2 (flags, 0));
+  PUSH_FIELD_VALUE (finit, "accflags", build_int_cst (NULL_TREE, flags, 0));
   PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
 
   PUSH_FIELD_VALUE
@@ -1256,7 +1256,8 @@ make_method_value (tree mdecl)
   class_decl = DECL_CONTEXT (mdecl);
   /* For interfaces, the index field contains the dispatch index. */
   if (CLASS_INTERFACE (TYPE_NAME (class_decl)))
-    index = build_int_2 (get_interface_method_index (mdecl, class_decl), 0);
+    index = build_int_cst (NULL_TREE,
+			   get_interface_method_index (mdecl, class_decl), 0);
   else if (!flag_indirect_dispatch && get_method_index (mdecl) != NULL_TREE)
     index = get_method_index (mdecl);
   else
@@ -1278,7 +1279,7 @@ make_method_value (tree mdecl)
 			(IDENTIFIER_POINTER(signature),
 			 IDENTIFIER_LENGTH(signature)))));
   }
-  PUSH_FIELD_VALUE (minit, "accflags", build_int_2 (accflags, 0));
+  PUSH_FIELD_VALUE (minit, "accflags", build_int_cst (NULL_TREE, accflags, 0));
   PUSH_FIELD_VALUE (minit, "index", index);
   PUSH_FIELD_VALUE (minit, "ncode", code);
 
@@ -1391,7 +1392,7 @@ get_dispatch_table (tree type, tree this_class_addr)
 	    for (j = 0; j < TARGET_VTABLE_USES_DESCRIPTORS; ++j)
 	      {
 		tree fdesc = build2 (FDESC_EXPR, nativecode_ptr_type_node, 
-				     method, build_int_2 (j, 0));
+				     method, build_int_cst (NULL_TREE, j, 0));
 		TREE_CONSTANT (fdesc) = 1;
 		TREE_INVARIANT (fdesc) = 1;
 	        list = tree_cons (NULL_TREE, fdesc, list);
@@ -1504,7 +1505,9 @@ make_class_data (tree type)
   tree type_decl = TYPE_NAME (type);
   /** Offset from start of virtual function table declaration
       to where objects actually point at, following new g++ ABI. */
-  tree dtable_start_offset = build_int_2 (2 * POINTER_SIZE / BITS_PER_UNIT, 0);
+  tree dtable_start_offset = build_int_cst (NULL_TREE,
+					    2 * POINTER_SIZE / BITS_PER_UNIT,
+					    0);
 
   this_class_addr = build_class_ref (type);
   decl = TREE_OPERAND (this_class_addr, 0);
@@ -1618,8 +1621,7 @@ make_class_data (tree type)
   else
     {
       int super_index = alloc_class_constant (super);
-      super = build_int_2 (super_index, 0);
-      TREE_TYPE (super) = ptr_type_node;
+      super = build_int_cst (ptr_type_node, super_index, 0);
     }
 
   /* Build and emit the array of implemented interfaces. */
@@ -1648,8 +1650,7 @@ make_class_data (tree type)
 	  else
 	    {
 	      int int_index = alloc_class_constant (iclass);
-	      index = build_int_2 (int_index, 0);
-	      TREE_TYPE (index) = ptr_type_node;
+	      index = build_int_cst (ptr_type_node, int_index, 0);
 	    }
 	  init = tree_cons (NULL_TREE, index, init); 
 	}
@@ -1694,14 +1695,16 @@ make_class_data (tree type)
   PUSH_FIELD_VALUE (cons, "next", null_pointer_node);
   PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl)));
   PUSH_FIELD_VALUE (cons, "accflags",
-		    build_int_2 (get_access_flags_from_decl (type_decl), 0));
+		    build_int_cst (NULL_TREE,
+				   get_access_flags_from_decl (type_decl), 0));
 
   PUSH_FIELD_VALUE (cons, "superclass", 
 		    CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
   PUSH_FIELD_VALUE (cons, "constants", constant_pool_constructor);
   PUSH_FIELD_VALUE (cons, "methods",
 		    build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
-  PUSH_FIELD_VALUE (cons, "method_count",  build_int_2 (method_count, 0));
+  PUSH_FIELD_VALUE (cons, "method_count",
+		    build_int_cst (NULL_TREE, method_count, 0));
 
   if (flag_indirect_dispatch)
     PUSH_FIELD_VALUE (cons, "vtable_method_count", integer_minus_one_node);
@@ -1712,9 +1715,10 @@ make_class_data (tree type)
 		    fields_decl == NULL_TREE ? null_pointer_node
 		    : build1 (ADDR_EXPR, field_ptr_type_node, fields_decl));
   PUSH_FIELD_VALUE (cons, "size_in_bytes", size_in_bytes (type));
-  PUSH_FIELD_VALUE (cons, "field_count", build_int_2 (field_count, 0));
+  PUSH_FIELD_VALUE (cons, "field_count",
+		    build_int_cst (NULL_TREE, field_count, 0));
   PUSH_FIELD_VALUE (cons, "static_field_count",
-		    build_int_2 (static_field_count, 0));
+		    build_int_cst (NULL_TREE, static_field_count, 0));
 
   if (flag_indirect_dispatch)
     PUSH_FIELD_VALUE (cons, "vtable", null_pointer_node);
@@ -1760,7 +1764,8 @@ make_class_data (tree type)
 		    build1 (ADDR_EXPR, ptr_type_node, TYPE_CTABLE_DECL (type))); 
   PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
   PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
-  PUSH_FIELD_VALUE (cons, "interface_count", build_int_2 (interface_len, 0));
+  PUSH_FIELD_VALUE (cons, "interface_count",
+		    build_int_cst (NULL_TREE, interface_len, 0));
   PUSH_FIELD_VALUE (cons, "state", integer_zero_node);
 
   PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
@@ -2394,7 +2399,7 @@ emit_symbol_table (tree name, tree the_table, tree decl_list,
      uninitialized static array of INDEX + 1 elements. The extra entry
      is used by the runtime to track whether the table has been
      initialized. */
-  table_size = build_index_type (build_int_2 (index, 0));
+  table_size = build_index_type (build_int_cst (NULL_TREE, index, 0));
   the_array_type = build_array_type (the_array_element_type, table_size);
   the_table = build_decl (VAR_DECL, name, the_array_type);
   TREE_STATIC (the_table) = 1;
@@ -2433,9 +2438,9 @@ emit_catch_table (tree this_class)
     tree_cons (NULL,
 	       make_catch_class_record (null_pointer_node, null_pointer_node),
 	       TYPE_CATCH_CLASSES (this_class));
-  table_size = 
-    build_index_type (build_int_2 
-		      (list_length (TYPE_CATCH_CLASSES (this_class)), 0));
+  table_size = build_index_type
+    (build_int_cst (NULL_TREE,
+		    list_length (TYPE_CATCH_CLASSES (this_class)), 0));
   array_type 
     = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
 			table_size);
diff --git a/gcc/java/constants.c b/gcc/java/constants.c
index cffd5d9..d6a3513 100644
--- a/gcc/java/constants.c
+++ b/gcc/java/constants.c
@@ -321,10 +321,10 @@ static GTY(()) tree tag_nodes[13];
 static tree
 get_tag_node (int tag)
 {
-  /* A Cache for build_int_2 (CONSTANT_XXX, 0). */
+  /* A Cache for build_int_cst (CONSTANT_XXX, 0). */
 
   if (tag_nodes[tag] == NULL_TREE)
-    tag_nodes[tag] = build_int_2 (tag, 0);
+    tag_nodes[tag] = build_int_cst (NULL_TREE, tag, 0);
   return tag_nodes[tag];
 }
 
@@ -424,7 +424,7 @@ tree
 build_ref_from_constant_pool (int index)
 {
   tree d = build_constant_data_ref ();
-  tree i = build_int_2 (index, 0);
+  tree i = build_int_cst (NULL_TREE, index, 0);
   return build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (d)), d, i,
 		 NULL_TREE, NULL_TREE);
 }
@@ -452,11 +452,9 @@ build_constants_constructor (void)
     }
   if (outgoing_cpool->count > 0)
     {
-      tree index_type;
       tree data_decl, tags_decl, tags_type;
-      tree max_index = build_int_2 (outgoing_cpool->count - 1, 0);
-      TREE_TYPE (max_index) = sizetype;
-      index_type = build_index_type (max_index);
+      tree max_index = build_int_cst (sizetype, outgoing_cpool->count - 1, 0);
+      tree index_type = build_index_type (max_index);
 
       /* Add dummy 0'th element of constant pool. */
       tags_list = tree_cons (NULL_TREE, get_tag_node (0), tags_list);
@@ -486,7 +484,8 @@ build_constants_constructor (void)
       tags_value = null_pointer_node;
     }
   START_RECORD_CONSTRUCTOR (cons, constants_type_node);
-  PUSH_FIELD_VALUE (cons, "size", build_int_2 (outgoing_cpool->count, 0));
+  PUSH_FIELD_VALUE (cons, "size",
+		    build_int_cst (NULL_TREE, outgoing_cpool->count, 0));
   PUSH_FIELD_VALUE (cons, "tags", tags_value);
   PUSH_FIELD_VALUE (cons, "data", data_value);
   FINISH_RECORD_CONSTRUCTOR (cons);
diff --git a/gcc/java/decl.c b/gcc/java/decl.c
index 73653b2..d6bce48 100644
--- a/gcc/java/decl.c
+++ b/gcc/java/decl.c
@@ -585,25 +585,24 @@ java_init_decl_processing (void)
 
   /* Define these next since types below may used them.  */
   integer_type_node = java_type_for_size (INT_TYPE_SIZE, 0);
-  integer_zero_node = build_int_2 (0, 0);
-  integer_one_node = build_int_2 (1, 0);
-  integer_two_node = build_int_2 (2, 0);
-  integer_four_node = build_int_2 (4, 0);
-  integer_minus_one_node = build_int_2 (-1, -1);
+  integer_zero_node = build_int_cst (NULL_TREE, 0, 0);
+  integer_one_node = build_int_cst (NULL_TREE, 1, 0);
+  integer_two_node = build_int_cst (NULL_TREE, 2, 0);
+  integer_four_node = build_int_cst (NULL_TREE, 4, 0);
+  integer_minus_one_node = build_int_cst (NULL_TREE, -1, -1);
 
   /* A few values used for range checking in the lexer.  */
-  decimal_int_max = build_int_2 (0x80000000, 0);
-  TREE_TYPE (decimal_int_max) = unsigned_int_type_node;
+  decimal_int_max = build_int_cst (unsigned_int_type_node, 0x80000000, 0);
 #if HOST_BITS_PER_WIDE_INT == 64
-  decimal_long_max = build_int_2 (0x8000000000000000LL, 0);
+  decimal_long_max = build_int_cst (unsigned_long_type_node,
+				    0x8000000000000000LL, 0);
 #else
 #if HOST_BITS_PER_WIDE_INT == 32
-  decimal_long_max = build_int_2 (0, 0x80000000);
+  decimal_long_max = build_int_cst (unsigned_long_type_node, 0, 0x80000000);
 #else
  #error "unsupported size"
 #endif
 #endif
-  TREE_TYPE (decimal_long_max) = unsigned_long_type_node;
 
   size_zero_node = size_int (0);
   size_one_node = size_int (1);
@@ -611,8 +610,7 @@ java_init_decl_processing (void)
   bitsize_one_node = bitsize_int (1);
   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
 
-  long_zero_node = build_int_2 (0, 0);
-  TREE_TYPE (long_zero_node) = long_type_node;
+  long_zero_node = build_int_cst (long_type_node, 0, 0);
 
   void_type_node = make_node (VOID_TYPE);
   pushdecl (build_decl (TYPE_DECL, get_identifier ("void"), void_type_node));
@@ -622,8 +620,7 @@ java_init_decl_processing (void)
   layout_type (t); /* Uses size_zero_node */
   return_address_type_node = build_pointer_type (t);
 
-  null_pointer_node = build_int_2 (0, 0);
-  TREE_TYPE (null_pointer_node) = ptr_type_node;
+  null_pointer_node = build_int_cst (ptr_type_node, 0, 0);
 
 #if 0
   /* Make a type to be the domain of a few array types
diff --git a/gcc/java/expr.c b/gcc/java/expr.c
index 1479b6e..9472794 100644
--- a/gcc/java/expr.c
+++ b/gcc/java/expr.c
@@ -698,7 +698,7 @@ build_java_array_length_access (tree node)
 
   length = java_array_type_length (type);
   if (length >= 0)
-    return build_int_2 (length, 0);
+    return build_int_cst (NULL_TREE, length, 0);
 
   node = build3 (COMPONENT_REF, int_type_node,
 		 build_java_indirect_ref (array_type, node,
@@ -910,7 +910,7 @@ build_newarray (int atype_value, tree length)
      and save the runtime some work. However, the bytecode generator
      expects to find the type_code int here. */
   if (flag_emit_class_files)
-    type_arg = build_int_2 (atype_value, 0);
+    type_arg = build_int_cst (NULL_TREE, atype_value, 0);
   else
     type_arg = build_class_ref (prim_type);
 
@@ -971,7 +971,8 @@ expand_java_multianewarray (tree class_type, int ndim)
 		      build_address_of (soft_multianewarray_node),
 		      tree_cons (NULL_TREE, build_class_ref (class_type),
 				 tree_cons (NULL_TREE, 
-					    build_int_2 (ndim, 0), args)),
+					    build_int_cst (NULL_TREE, ndim, 0),
+					    args)),
 		      NULL_TREE));
 }
 
@@ -1081,10 +1082,7 @@ expand_java_pushc (int ival, tree type)
   if (type == ptr_type_node && ival == 0)
     value = null_pointer_node;
   else if (type == int_type_node || type == long_type_node)
-    {
-      value = build_int_2 (ival, ival < 0 ? -1 : 0);
-      TREE_TYPE (value) = type;
-    }
+    value = build_int_cst (type, ival, ival < 0 ? -1 : 0);
   else if (type == float_type_node || type == double_type_node)
     {
       REAL_VALUE_TYPE x;
@@ -1289,7 +1287,7 @@ expand_iinc (unsigned int local_var_index, int ival, int pc)
 
   flush_quick_stack ();
   local_var = find_local_variable (local_var_index, int_type_node, pc);
-  constant_value = build_int_2 (ival, ival < 0 ? -1 : 0);
+  constant_value = build_int_cst (NULL_TREE, ival, ival < 0 ? -1 : 0);
   res = fold (build2 (PLUS_EXPR, int_type_node, local_var, constant_value));
   java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (local_var), local_var, res));
   update_aliases (local_var, local_var_index, pc);
@@ -1359,7 +1357,8 @@ build_java_binop (enum tree_code op, tree type, tree arg1, tree arg2)
       }
     case LSHIFT_EXPR:
     case RSHIFT_EXPR:
-      mask = build_int_2 (TYPE_PRECISION (TREE_TYPE (arg1)) - 1, 0);
+      mask = build_int_cst (NULL_TREE,
+			    TYPE_PRECISION (TREE_TYPE (arg1)) - 1, 0);
       arg2 = fold (build2 (BIT_AND_EXPR, int_type_node, arg2, mask));
       break;
 
@@ -1539,9 +1538,9 @@ build_field_ref (tree self_value, tree self_class, tree name)
 	   we can make a direct reference.  */
 	{
 	  tree otable_index
-	    = build_int_2 (get_symbol_table_index 
-			   (field_decl, &TYPE_OTABLE_METHODS (output_class)),
-			   0);
+	    = build_int_cst (NULL_TREE, get_symbol_table_index 
+			     (field_decl, &TYPE_OTABLE_METHODS (output_class)),
+			     0);
 	  tree field_offset
 	    = build4 (ARRAY_REF, integer_type_node,
 		      TYPE_OTABLE_DECL (output_class), otable_index,
@@ -1689,8 +1688,7 @@ expand_java_add_case (tree switch_expr, int match, int target_pc)
 {
   tree value, x;
 
-  value = build_int_2 (match, match < 0 ? -1 : 0);
-  TREE_TYPE (value) = TREE_TYPE (switch_expr);
+  value = build_int_cst (TREE_TYPE (switch_expr), match, match < 0 ? -1 : 0);
   
   x = build3 (CASE_LABEL_EXPR, void_type_node, value, NULL_TREE,
 	      create_artificial_label ());
@@ -1705,7 +1703,8 @@ static void
 expand_java_call (int target_pc, int return_address)
 {
   tree target_label = lookup_label (target_pc);
-  tree value = build_int_2 (return_address, return_address < 0 ? -1 : 0);
+  tree value = build_int_cst (NULL_TREE,
+			      return_address, return_address < 0 ? -1 : 0);
   push_value (value);
   flush_quick_stack ();
   expand_goto (target_label);
@@ -1836,8 +1835,8 @@ build_known_method_ref (tree method, tree method_type ATTRIBUTE_UNUSED,
       else
 	{
 	  tree table_index
-	    = build_int_2 (get_symbol_table_index 
-			   (method, &TYPE_ATABLE_METHODS (output_class)), 0);
+	    = build_int_cst (NULL_TREE, get_symbol_table_index 
+			     (method, &TYPE_ATABLE_METHODS (output_class)), 0);
 	  func = build4 (ARRAY_REF,  method_ptr_type_node, 
 			 TYPE_ATABLE_DECL (output_class), table_index,
 			 NULL_TREE, NULL_TREE);
@@ -1881,7 +1880,7 @@ build_known_method_ref (tree method, tree method_type ATTRIBUTE_UNUSED,
 	}
       method_index *= int_size_in_bytes (method_type_node);
       ref = fold (build2 (PLUS_EXPR, method_ptr_type_node,
-			  ref, build_int_2 (method_index, 0)));
+			  ref, build_int_cst (NULL_TREE, method_index, 0)));
       ref = build1 (INDIRECT_REF, method_type_node, ref);
       func = build3 (COMPONENT_REF, nativecode_ptr_type_node,
 		     ref, lookup_field (&method_type_node, ncode_ident),
@@ -1961,8 +1960,8 @@ build_invokevirtual (tree dtable, tree method)
   if (flag_indirect_dispatch)
     {
       otable_index 
-	= build_int_2 (get_symbol_table_index 
-		       (method, &TYPE_OTABLE_METHODS (output_class)), 0);
+	= build_int_cst (NULL_TREE, get_symbol_table_index 
+			 (method, &TYPE_OTABLE_METHODS (output_class)), 0);
       method_index = build4 (ARRAY_REF, integer_type_node, 
 			     TYPE_OTABLE_DECL (output_class), 
 			     otable_index, NULL_TREE, NULL_TREE);
@@ -2021,14 +2020,15 @@ build_invokeinterface (tree dtable, tree method)
   if (flag_indirect_dispatch)
     {
       otable_index
-	= build_int_2 (get_symbol_table_index 
-		       (method, &TYPE_OTABLE_METHODS (output_class)), 0);
+	= build_int_cst (NULL_TREE, get_symbol_table_index 
+			 (method, &TYPE_OTABLE_METHODS (output_class)), 0);
       idx = build4 (ARRAY_REF, integer_type_node,
 		    TYPE_OTABLE_DECL (output_class), otable_index,
 		    NULL_TREE, NULL_TREE);
     }
   else
-    idx = build_int_2 (get_interface_method_index (method, interface), 0);
+    idx = build_int_cst (NULL_TREE,
+			 get_interface_method_index (method, interface), 0);
 
   lookup_arg = tree_cons (NULL_TREE, dtable,
                           tree_cons (NULL_TREE, build_class_ref (interface),
@@ -2282,7 +2282,7 @@ build_jni_stub (tree method)
   /* We call _Jv_LookupJNIMethod to find the actual underlying
      function pointer.  _Jv_LookupJNIMethod will throw the appropriate
      exception if this function is not found at runtime.  */
-  tem = build_tree_list (NULL_TREE, build_int_2 (args_size, 0));
+  tem = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, args_size, 0));
   method_sig = build_java_signature (TREE_TYPE (method));
   lookup_arg = tree_cons (NULL_TREE,
                           build_utf8_ref (unmangle_classname
diff --git a/gcc/java/java-gimplify.c b/gcc/java/java-gimplify.c
index 2d3be99..0945559 100644
--- a/gcc/java/java-gimplify.c
+++ b/gcc/java/java-gimplify.c
@@ -242,7 +242,7 @@ java_gimplify_new_array_init (tree exp)
   tree data_field = lookup_field (&array_type, get_identifier ("data"));
   tree element_type = TYPE_ARRAY_ELEMENT (array_type);
   HOST_WIDE_INT ilength = java_array_type_length (array_type);
-  tree length = build_int_2 (ilength, 0);
+  tree length = build_int_cst (NULL_TREE, ilength, 0);
   tree init = TREE_OPERAND (exp, 0);
   tree values = CONSTRUCTOR_ELTS (init);
 
@@ -263,7 +263,7 @@ java_gimplify_new_array_init (tree exp)
 			 data_field, NULL_TREE);
       tree assignment = build2 (MODIFY_EXPR, element_type,
 				build4 (ARRAY_REF, element_type, lhs,
-					build_int_2 (index++, 0),
+					build_int_cst (NULL_TREE, index++, 0),
 					NULL_TREE, NULL_TREE),
 				TREE_VALUE (values));
       body = build2 (COMPOUND_EXPR, element_type, body, assignment);
diff --git a/gcc/java/jcf-parse.c b/gcc/java/jcf-parse.c
index 272ce96..d62b1b8 100644
--- a/gcc/java/jcf-parse.c
+++ b/gcc/java/jcf-parse.c
@@ -266,8 +266,7 @@ get_constant (JCF *jcf, int index)
     case CONSTANT_Integer:
       {
 	jint num = JPOOL_INT(jcf, index);
-	value = build_int_2 (num, num < 0 ? -1 : 0);
-	TREE_TYPE (value) = int_type_node;
+	value = build_int_cst (int_type_node, num, num < 0 ? -1 : 0);
 	break;
       }
     case CONSTANT_Long:
@@ -279,8 +278,7 @@ get_constant (JCF *jcf, int index)
 	lshift_double (num, 0, 32, 64, &lo, &hi, 0);
 	num = JPOOL_UINT (jcf, index+1);
 	add_double (lo, hi, num, 0, &lo, &hi);
-	value = build_int_2 (lo, hi);
-	TREE_TYPE (value) = long_type_node;
+	value = build_int_cst (long_type_node, lo, hi);
 	value = force_fit_type (value, 0, false, false);
 	break;
       }
diff --git a/gcc/java/lex.c b/gcc/java/lex.c
index 95fbd57..5467d60 100644
--- a/gcc/java/lex.c
+++ b/gcc/java/lex.c
@@ -1276,11 +1276,10 @@ do_java_lex (YYSTYPE *java_lval)
 
 #ifndef JC1_LITE
       /* Range checking.  */
-      value = build_int_2 (low, high);
       /* Temporarily set type to unsigned.  */
-      TREE_TYPE (value) =  (long_suffix
-			    ? unsigned_long_type_node
-			    : unsigned_int_type_node);
+      value = build_int_cst (long_suffix
+			     ? unsigned_long_type_node
+			     : unsigned_int_type_node, low, high);
       SET_LVAL_NODE (value);
 
       /* For base 10 numbers, only values up to the highest value
@@ -1301,7 +1300,8 @@ do_java_lex (YYSTYPE *java_lval)
 	}
 
       /* Sign extend the value.  */
-      TREE_TYPE (value) = long_suffix ? long_type_node : int_type_node;
+      value = build_int_cst (long_suffix ? long_type_node : int_type_node,
+			     low, high);
       value = force_fit_type (value, 0, false, false);
       SET_LVAL_NODE (value);
       
@@ -1335,13 +1335,7 @@ do_java_lex (YYSTYPE *java_lval)
         char_lit = 0;		/* We silently convert it to zero.  */
 
       JAVA_LEX_CHAR_LIT (char_lit);
-#ifndef JC1_LITE
-      {
-	tree value = build_int_2 (char_lit, 0);
-	TREE_TYPE (value) = char_type_node;
-	SET_LVAL_NODE (value);
-      }
-#endif
+      SET_LVAL_NODE (build_int_cst (char_type_node, char_lit, 0));
       return CHAR_LIT_TK;
     }
 
diff --git a/gcc/java/parse.y b/gcc/java/parse.y
index 3b08ad2..8e0d319 100644
--- a/gcc/java/parse.y
+++ b/gcc/java/parse.y
@@ -13322,10 +13322,10 @@ patch_binop (tree node, tree wfl_op1, tree wfl_op2)
       /* Shift int only up to 0x1f and long up to 0x3f */
       if (prom_type == int_type_node)
 	op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
-			    build_int_2 (0x1f, 0)));
+			    build_int_cst (NULL_TREE, 0x1f, 0)));
       else
 	op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
-			    build_int_2 (0x3f, 0)));
+			    build_int_cst (NULL_TREE, 0x3f, 0)));
 
       /* The >>> operator is a >> operating on unsigned quantities */
       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
@@ -14020,12 +14020,12 @@ patch_unaryop (tree node, tree wfl_op)
 	     both operands, if really necessary */
 	  if (JINTEGRAL_TYPE_P (op_type))
 	    {
-	      value = build_int_2 (1, 0);
-	      TREE_TYPE (value) = TREE_TYPE (node) = op_type;
+	      value = build_int_cst (op_type, 1, 0);
+	      TREE_TYPE (node) = op_type;
 	    }
 	  else
 	    {
-	      value = build_int_2 (1, 0);
+	      value = build_int_cst (NULL_TREE, 1, 0);
 	      TREE_TYPE (node) =
 		binary_numeric_promotion (op_type,
 					  TREE_TYPE (value), &op, &value);
@@ -14251,8 +14251,7 @@ patch_cast (tree node, tree wfl_op)
 static tree
 build_null_of_type (tree type)
 {
-  tree node = build_int_2 (0, 0);
-  TREE_TYPE (node) = promote_type (type);
+  tree node = build_int_cst (promote_type (type), 0, 0);
   return node;
 }
 
@@ -14333,7 +14332,8 @@ static tree
 build_newarray_node (tree type, tree dims, int extra_dims)
 {
   tree node = build3 (NEW_ARRAY_EXPR, NULL_TREE, type,
-		      nreverse (dims), build_int_2 (extra_dims, 0));
+		      nreverse (dims),
+		      build_int_cst (NULL_TREE, extra_dims, 0));
   return node;
 }
 
@@ -14432,7 +14432,8 @@ patch_newarray (tree node)
 		 tree_cons (NULL_TREE,
 			    build_class_ref (TREE_TYPE (array_type)),
 			    tree_cons (NULL_TREE,
-				       build_int_2 (ndims, 0), dims )),
+				       build_int_cst (NULL_TREE,
+						      ndims, 0), dims )),
 		 NULL_TREE);
 }
 
diff --git a/gcc/java/resource.c b/gcc/java/resource.c
index 6257d37..362aab4 100644
--- a/gcc/java/resource.c
+++ b/gcc/java/resource.c
@@ -69,9 +69,9 @@ compile_resource_data (const char *name, const char *buffer, int length)
   FINISH_RECORD (rtype);
   START_RECORD_CONSTRUCTOR (rinit, rtype);
   PUSH_FIELD_VALUE (rinit, "name_length", 
-		    build_int_2 (strlen (name), 0));
+		    build_int_cst (NULL_TREE, strlen (name), 0));
   PUSH_FIELD_VALUE (rinit, "resource_length", 
-		    build_int_2 (length, 0));
+		    build_int_cst (NULL_TREE, length, 0));
   data = build_string (strlen(name) + length, buffer);
   TREE_TYPE (data) = data_type;
   PUSH_FIELD_VALUE (rinit, "data", data);
diff --git a/gcc/java/typeck.c b/gcc/java/typeck.c
index 289048e..830b95c5 100644
--- a/gcc/java/typeck.c
+++ b/gcc/java/typeck.c
@@ -357,8 +357,8 @@ build_prim_array_type (tree element_type, HOST_WIDE_INT length)
 
   if (length != -1)
     {
-      tree max_index = build_int_2 (length - 1, (0 == length ? -1 : 0));
-      TREE_TYPE (max_index) = sizetype;
+      tree max_index = build_int_cst (sizetype,
+				      length - 1, (0 == length ? -1 : 0));
       index = build_index_type (max_index);
     }
   return build_array_type (element_type, index);