OSDN Git Service

* tree.h (build_int_cst): New, sign extended constant.
authornathan <nathan@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 25 Aug 2004 09:52:54 +0000 (09:52 +0000)
committernathan <nathan@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 25 Aug 2004 09:52:54 +0000 (09:52 +0000)
(build_int_cstu): New, zero extended constant.
(build_int_cst_wide): Renamed from build_int_cst.
* tree.c (build_int_cst, build_int_cstu): New.
(build_int_cst_wide): Renamed from build_int_cst.
(make_vector_type, build_common_tree_nodes,
build_common_tree_nodes_2): Adjust build_int_cst calls.
* 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_classify_type,
fold_builtin_lround, fold_builtin_bitop, fold_builtin_isascii,
fold_builtin_toascii, fold_builtin_isdigit,
simplify_builtin_strstr, simplify_builtin_strpbrk,
fold_builtin_fputs, simplify_builtin_sprintf): Likewise.
* c-common.c (start_fname_decls, fix_string_type, shorten_compare,
DEF_ATTR_INT): 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_fn_info_value, build_ctr_info_value,
build_gcov_info): Likewise.
* except.c (init_eh, 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, round_up,
round_down): Likewise.
* function.c (assign_parm_setup_block): Likewise.
* stmt.c (shift_return_value, expand_case, 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.
* tree-ssa-loop-ivcanon.c (create_canonical_iv,
canonicalize_loop_induction_variables): Likewise.
* tree-vectorizer.c (vect_create_index_for_array_ref,
vect_transform_loop_bound, vect_compute_data_ref_alignment):
Likewise.

* config/alpha/alpha.c (alpha_initialize_trampoline, alpha_va_start,
alpha_gimplify_va_arg_1): Likewise.
* 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/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): Likewise.

2004-04-25  Paolo Bonzini  <bonzini@gnu.org>

* cfglayout.c (duplicate_insn_chain): Remove references to
NOTE_INSN_LOOP_VTOP and NOTE_INSN_LOOP_CONT.
* cfgloop.h (struct loop): Remove fields vtop, cont and cont_dominator.
* cfgrtl.c (rtl_delete_block): Remove handling of NOTE_INSN_LOOP_CONT.
* final.c (final_scan_insn): Remove references to NOTE_INSN_LOOP_VTOP
and NOTE_INSN_LOOP_CONT.
* insn-notes.def (NOTE_INSN_LOOP_VTOP, NOTE_INSN_LOOP_CONT): Remove.
* jump.c (squeeze_notes): Remove references to NOTE_INSN_LOOP_VTOP
and NOTE_INSN_LOOP_CONT.
* loop.c (scan_loops, find_and_verify_loops, for_each_insn_in_loop,
check_dbra_loop, loop_dump_aux): Remove references to removed notes
and fields.
* reorg.c (mostly_true_jump): Do not rely on NOTE_INSN_LOOP_VTOPs.
* unroll.c (unroll_loop, copy_loop_body, loop_iterations): Remove
references to removed notes and fields.
(subtract_reg_term, ujump_to_loop_cont): Remove.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@86544 138bc75d-0d04-0410-961f-82ee72b054a4

83 files changed:
gcc/ChangeLog
gcc/ada/ChangeLog
gcc/ada/cuintp.c
gcc/ada/trans.c
gcc/ada/utils.c
gcc/ada/utils2.c
gcc/builtins.c
gcc/c-common.c
gcc/c-decl.c
gcc/c-lex.c
gcc/c-parse.in
gcc/c-pretty-print.c
gcc/c-typeck.c
gcc/calls.c
gcc/config/alpha/alpha.c
gcc/config/arm/arm.c
gcc/config/c4x/c4x.c
gcc/config/i386/i386.c
gcc/config/ia64/ia64.c
gcc/config/mips/mips.c
gcc/config/pa/pa.c
gcc/config/rs6000/rs6000.c
gcc/config/s390/s390.c
gcc/config/sh/sh.c
gcc/config/stormy16/stormy16.c
gcc/config/xtensa/xtensa.c
gcc/convert.c
gcc/coverage.c
gcc/cp/ChangeLog
gcc/cp/call.c
gcc/cp/class.c
gcc/cp/cp-gimplify.c
gcc/cp/cvt.c
gcc/cp/decl.c
gcc/cp/decl2.c
gcc/cp/except.c
gcc/cp/mangle.c
gcc/cp/method.c
gcc/cp/rtti.c
gcc/cp/search.c
gcc/except.c
gcc/expmed.c
gcc/expr.c
gcc/fold-const.c
gcc/fortran/ChangeLog
gcc/fortran/trans-array.c
gcc/fortran/trans-const.c
gcc/fortran/trans-decl.c
gcc/fortran/trans-intrinsic.c
gcc/fortran/trans-io.c
gcc/fortran/trans-stmt.c
gcc/fortran/trans-types.c
gcc/fortran/trans.c
gcc/function.c
gcc/java/ChangeLog
gcc/java/boehm.c
gcc/java/class.c
gcc/java/constants.c
gcc/java/decl.c
gcc/java/expr.c
gcc/java/java-gimplify.c
gcc/java/jcf-parse.c
gcc/java/lex.c
gcc/java/parse.y
gcc/java/resource.c
gcc/java/typeck.c
gcc/objc/objc-act.c
gcc/stmt.c
gcc/stor-layout.c
gcc/tree-chrec.c
gcc/tree-chrec.h
gcc/tree-complex.c
gcc/tree-eh.c
gcc/tree-mudflap.c
gcc/tree-nested.c
gcc/tree-pretty-print.c
gcc/tree-ssa-ccp.c
gcc/tree-ssa-dom.c
gcc/tree-ssa-loop-ivcanon.c
gcc/tree-ssa-loop-niter.c
gcc/tree-vectorizer.c
gcc/tree.c
gcc/tree.h

index 1c2abb0..11a05c4 100644 (file)
@@ -1,3 +1,109 @@
+2004-08-25  Nathan Sidwell  <nathan@codesourcery.com>
+
+       * tree.h  (build_int_cst): New, sign extended constant.
+       (build_int_cstu): New, zero extended constant.
+       (build_int_cst_wide): Renamed from build_int_cst.
+       * tree.c (build_int_cst, build_int_cstu): New.
+       (build_int_cst_wide): Renamed from build_int_cst.
+       (make_vector_type, build_common_tree_nodes,
+       build_common_tree_nodes_2): Adjust build_int_cst calls.
+       * 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_classify_type,
+       fold_builtin_lround, fold_builtin_bitop, fold_builtin_isascii,
+       fold_builtin_toascii, fold_builtin_isdigit,
+       simplify_builtin_strstr, simplify_builtin_strpbrk,
+       fold_builtin_fputs, simplify_builtin_sprintf): Likewise.
+       * c-common.c (start_fname_decls, fix_string_type, shorten_compare,
+       DEF_ATTR_INT): 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_fn_info_value, build_ctr_info_value,
+       build_gcov_info): Likewise.
+       * except.c (init_eh, 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, round_up,
+       round_down): Likewise.
+       * function.c (assign_parm_setup_block): Likewise.
+       * stmt.c (shift_return_value, expand_case, 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.
+       * tree-ssa-loop-ivcanon.c (create_canonical_iv,
+       canonicalize_loop_induction_variables): Likewise.
+       * tree-vectorizer.c (vect_create_index_for_array_ref,
+       vect_transform_loop_bound, vect_compute_data_ref_alignment):
+       Likewise.
+
+       * config/alpha/alpha.c (alpha_initialize_trampoline, alpha_va_start,
+       alpha_gimplify_va_arg_1): Likewise.
+       * 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/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): Likewise.
+
 2004-04-25  Paolo Bonzini  <bonzini@gnu.org>
 
        * cfglayout.c (duplicate_insn_chain): Remove references to
index dc3dd9a..e49c9ab 100644 (file)
@@ -1,6 +1,13 @@
+2004-08-25  Nathan Sidwell  <nathan@codesourcery.com>
+
+       * cuintp.c (UI_To_gnu): Adjust build_int_cst calls.
+       * trans.c (Exception_Handler_to_gnu_sjlj, gnat_to_gnu): Likewise.
+       * utils.c (init_gigi_decls): Likewise.
+       * utils2.c (build_call_raise, build_allocator): Likewise.
+       
 2004-08-24  Nathan Sidwell  <nathan@codesourcery.com>
 
-       * ada/utils.c (gnat_init_decl_processing): Adjust
+       * utils.c (gnat_init_decl_processing): Adjust
        build_common_tree_nodes call.
 
 2004-08-20  Nathan Sidwell  <nathan@codesourcery.com>
index b919bb5..12eff09 100644 (file)
@@ -63,9 +63,7 @@ UI_To_gnu (Uint Input, tree type)
 
   if (Input <= Uint_Direct_Last)
     gnu_ret = convert (type, build_int_cst (NULL_TREE,
-                                           Input - Uint_Direct_Bias,
-                                           Input < Uint_Direct_Bias
-                                           ? -1 : 0));
+                                           Input - Uint_Direct_Bias));
   else
     {
       Int Idx =    Uints_Ptr[Input].Loc;
@@ -76,13 +74,12 @@ UI_To_gnu (Uint Input, tree type)
       tree comp_type
        = (TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node)
           ? type : integer_type_node);
-      tree gnu_base = convert (comp_type, build_int_cst (NULL_TREE, Base, 0));
+      tree gnu_base = convert (comp_type, build_int_cst (NULL_TREE, Base));
 
       if (Length <= 0)
        abort ();
 
-      gnu_ret = convert (comp_type, build_int_cst (NULL_TREE,
-                                                  First, First < 0 ? -1 : 0));
+      gnu_ret = convert (comp_type, build_int_cst (NULL_TREE, First));
       if (First < 0)
        for (Idx++, Length--; Length; Idx++, Length--)
          gnu_ret = fold (build (MINUS_EXPR, comp_type,
@@ -90,7 +87,7 @@ UI_To_gnu (Uint Input, tree type)
                                              gnu_ret, gnu_base)),
                                 convert (comp_type,
                                          build_int_cst (NULL_TREE,
-                                                        Udigits_Ptr[Idx], 0))));
+                                                        Udigits_Ptr[Idx]))));
       else
        for (Idx++, Length--; Length; Idx++, Length--)
          gnu_ret = fold (build (PLUS_EXPR, comp_type,
@@ -98,7 +95,7 @@ UI_To_gnu (Uint Input, tree type)
                                              gnu_ret, gnu_base)),
                                 convert (comp_type,
                                          build_int_cst (NULL_TREE,
-                                                        Udigits_Ptr[Idx], 0))));
+                                                        Udigits_Ptr[Idx]))));
     }
 
   gnu_ret = convert (type, gnu_ret);
index 452c3e5..d7b3b23 100644 (file)
@@ -2218,8 +2218,7 @@ Exception_Handler_to_gnu_sjlj (Node_Id gnat_node)
                  (TRUTH_ORIF_EXPR, integer_type_node,
                   build_binary_op (EQ_EXPR, integer_type_node, gnu_comp,
                                    convert (TREE_TYPE (gnu_comp),
-                                            build_int_cst (NULL_TREE,
-                                                           'V', 0))),
+                                            build_int_cst (NULL_TREE, 'V'))),
                   this_choice);
            }
        }
@@ -2507,7 +2506,7 @@ gnat_to_gnu (Node_Id gnat_node)
       else
        gnu_result = convert (gnu_result_type,
                              build_int_cst (NULL_TREE,
-                                            Char_Literal_Value (gnat_node), 0));
+                                            Char_Literal_Value (gnat_node)));
       break;
 
     case N_Real_Literal:
@@ -2623,8 +2622,7 @@ gnat_to_gnu (Node_Id gnat_node)
                             convert (TREE_TYPE (gnu_result_type),
                                      build_int_cst
                                      (NULL_TREE,
-                                      Get_String_Char (gnat_string, i + 1),
-                                      0)),
+                                      Get_String_Char (gnat_string, i + 1))),
                           gnu_list);
 
              gnu_idx = int_const_binop (PLUS_EXPR, gnu_idx, integer_one_node,
index f0440f7..0cc6c98 100644 (file)
@@ -580,7 +580,7 @@ init_gigi_decls (tree long_long_float_type, tree exception_type)
   /* Make the types and functions used for exception processing.    */
   jmpbuf_type
     = build_array_type (gnat_type_for_mode (Pmode, 0),
-                       build_index_type (build_int_cst (NULL_TREE, 5, 0)));
+                       build_index_type (build_int_cst (NULL_TREE, 5)));
   create_type_decl (get_identifier ("JMPBUF_T"), jmpbuf_type, NULL,
                    false, true, Empty);
   jmpbuf_ptr_type = build_pointer_type (jmpbuf_type);
index 60de87d..10da013 100644 (file)
@@ -1444,13 +1444,13 @@ build_call_raise (int msg)
 
   TREE_TYPE (filename)
     = build_array_type (char_type_node,
-                       build_index_type (build_int_cst (NULL_TREE, len, 0)));
+                       build_index_type (build_int_cst (NULL_TREE, len)));
 
   return
     build_call_2_expr (fndecl,
                       build1 (ADDR_EXPR, build_pointer_type (char_type_node),
                               filename),
-                      build_int_cst (NULL_TREE, input_line, 0));
+                      build_int_cst (NULL_TREE, input_line));
 }
 \f
 /* Return a CONSTRUCTOR of TYPE whose list is LIST.  */
@@ -1799,7 +1799,7 @@ build_allocator (tree type, tree init, tree result_type, Entity_Id gnat_proc,
       /* If the size overflows, pass -1 so the allocator will raise
         storage error.  */
       if (TREE_CODE (size) == INTEGER_CST && TREE_OVERFLOW (size))
-       size = build_int_cst (ssizetype, -1, -1);
+       size = build_int_cst (ssizetype, -1);
 
       storage = build_call_alloc_dealloc (NULL_TREE, size,
                                          TYPE_ALIGN (storage_type),
@@ -1872,7 +1872,7 @@ build_allocator (tree type, tree init, tree result_type, Entity_Id gnat_proc,
   /* If the size overflows, pass -1 so the allocator will raise
      storage error.  */
   if (TREE_CODE (size) == INTEGER_CST && TREE_OVERFLOW (size))
-    size = build_int_cst (ssizetype, -1, -1);
+    size = build_int_cst (ssizetype, -1);
 
   /* If this is a type whose alignment is larger than the
      biggest we support in normal alignment and this is in
index 65028cf..9b4a88d 100644 (file)
@@ -903,12 +903,12 @@ expand_builtin_prefetch (tree arglist)
       if (TREE_CHAIN (TREE_CHAIN (arglist)))
        arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
       else
-       arg2 = build_int_cst (NULL_TREE, 3, 0);
+       arg2 = build_int_cst (NULL_TREE, 3);
     }
   else
     {
       arg1 = integer_zero_node;
-      arg2 = build_int_cst (NULL_TREE, 3, 0);
+      arg2 = build_int_cst (NULL_TREE, 3);
     }
 
   /* Argument 0 is an address.  */
@@ -2491,7 +2491,7 @@ expand_builtin_strstr (tree arglist, rtx target, enum machine_mode mode)
       /* New argument list transforming strstr(s1, s2) to
         strchr(s1, s2[0]).  */
       arglist = build_tree_list (NULL_TREE,
-                                build_int_cst (NULL_TREE, p2[0], 0));
+                                build_int_cst (NULL_TREE, p2[0]));
       arglist = tree_cons (NULL_TREE, s1, arglist);
       return expand_expr (build_function_call_expr (fn, arglist),
                          target, mode, EXPAND_NORMAL);
@@ -2648,7 +2648,7 @@ expand_builtin_strpbrk (tree arglist, rtx target, enum machine_mode mode)
       /* New argument list transforming strpbrk(s1, s2) to
         strchr(s1, s2[0]).  */
       arglist = build_tree_list (NULL_TREE,
-                                build_int_cst (NULL_TREE, p2[0], 0));
+                                build_int_cst (NULL_TREE, p2[0]));
       arglist = tree_cons (NULL_TREE, s1, arglist);
       return expand_expr (build_function_call_expr (fn, arglist),
                          target, mode, EXPAND_NORMAL);
@@ -4679,7 +4679,7 @@ expand_builtin_fputs (tree arglist, rtx target, bool unlocked)
            arglist = build_tree_list (NULL_TREE,
                                       TREE_VALUE (TREE_CHAIN (arglist)));
            arglist = tree_cons (NULL_TREE,
-                                build_int_cst (NULL_TREE, p[0], 0),
+                                build_int_cst (NULL_TREE, p[0]),
                                 arglist);
            fn = fn_fputc;
            break;
@@ -4937,7 +4937,7 @@ build_string_literal (int len, const char *str)
 
   t = build_string (len, str);
   elem = build_type_variant (char_type_node, 1, 0);
-  index = build_index_type (build_int_cst (NULL_TREE, len - 1, 0));
+  index = build_index_type (build_int_cst (NULL_TREE, len - 1));
   type = build_array_type (elem, index);
   TREE_TYPE (t) = type;
   TREE_CONSTANT (t) = 1;
@@ -5023,7 +5023,7 @@ expand_builtin_printf (tree arglist, rtx target, enum machine_mode mode,
          /* Given printf("c"), (where c is any one character,)
             convert "c"[0] to an int and pass that to the replacement
             function.  */
-         arg = build_int_cst (NULL_TREE, fmt_str[0], 0);
+         arg = build_int_cst (NULL_TREE, fmt_str[0]);
          arglist = build_tree_list (NULL_TREE, arg);
          fn = fn_putchar;
        }
@@ -5194,7 +5194,7 @@ expand_builtin_sprintf (tree arglist, rtx target, enum machine_mode mode)
                   const0_rtx, VOIDmode, EXPAND_NORMAL);
       if (target == const0_rtx)
        return const0_rtx;
-      exp = build_int_cst (NULL_TREE, strlen (fmt_str), 0);
+      exp = build_int_cst (NULL_TREE, strlen (fmt_str));
       return expand_expr (exp, target, mode, EXPAND_NORMAL);
     }
   /* If the format is "%s", use strcpy if the result isn't used.  */
@@ -6271,10 +6271,10 @@ static tree
 fold_builtin_classify_type (tree arglist)
 {
   if (arglist == 0)
-    return build_int_cst (NULL_TREE, no_type_class, 0);
+    return build_int_cst (NULL_TREE, no_type_class);
 
   return build_int_cst (NULL_TREE,
-                       type_to_class (TREE_TYPE (TREE_VALUE (arglist))), 0);
+                       type_to_class (TREE_TYPE (TREE_VALUE (arglist))));
 }
 
 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
@@ -6707,7 +6707,7 @@ fold_builtin_lround (tree exp)
 
          real_round (&r, TYPE_MODE (ftype), &x);
          REAL_VALUE_TO_INT (&lo, &hi, r);
-         result = build_int_cst (NULL_TREE, lo, hi);
+         result = build_int_cst_wide (NULL_TREE, lo, hi);
          if (int_fits_type_p (result, itype))
            return fold_convert (itype, result);
        }
@@ -6816,7 +6816,7 @@ fold_builtin_bitop (tree exp)
          abort();
        }
 
-      return build_int_cst (TREE_TYPE (exp), result, 0);
+      return build_int_cst (TREE_TYPE (exp), result);
     }
 
   return NULL_TREE;
@@ -7573,8 +7573,7 @@ fold_builtin_isascii (tree arglist)
 
       arg = build2 (BIT_AND_EXPR, integer_type_node, arg,
                    build_int_cst (NULL_TREE,
-                                  ~ (unsigned HOST_WIDE_INT) 0x7f,
-                                  ~ (HOST_WIDE_INT) 0));
+                                  ~ (unsigned HOST_WIDE_INT) 0x7f));
       arg = fold (build2 (EQ_EXPR, integer_type_node,
                          arg, integer_zero_node));
 
@@ -7598,7 +7597,7 @@ fold_builtin_toascii (tree arglist)
       tree arg = TREE_VALUE (arglist);
 
       return fold (build2 (BIT_AND_EXPR, integer_type_node, arg,
-                          build_int_cst (NULL_TREE, 0x7f, 0)));
+                          build_int_cst (NULL_TREE, 0x7f)));
     }
 }
 
@@ -7616,9 +7615,9 @@ fold_builtin_isdigit (tree arglist)
       tree arg = TREE_VALUE (arglist);
       arg = fold_convert (unsigned_type_node, arg);
       arg = build2 (MINUS_EXPR, unsigned_type_node, arg,
-                   build_int_cst (unsigned_type_node, TARGET_DIGIT0, 0));
+                   build_int_cst (unsigned_type_node, TARGET_DIGIT0));
       arg = build2 (LE_EXPR, integer_type_node, arg,
-                   build_int_cst (unsigned_type_node, 9, 0));
+                   build_int_cst (unsigned_type_node, 9));
       arg = fold (arg);
       if (in_gimple_form && !TREE_CONSTANT (arg))
         return NULL_TREE;
@@ -8696,7 +8695,7 @@ simplify_builtin_strstr (tree arglist)
       /* New argument list transforming strstr(s1, s2) to
         strchr(s1, s2[0]).  */
       arglist = build_tree_list (NULL_TREE,
-                                build_int_cst (NULL_TREE, p2[0], 0));
+                                build_int_cst (NULL_TREE, p2[0]));
       arglist = tree_cons (NULL_TREE, s1, arglist);
       return build_function_call_expr (fn, arglist);
     }
@@ -8882,7 +8881,7 @@ simplify_builtin_strpbrk (tree arglist)
       /* New argument list transforming strpbrk(s1, s2) to
         strchr(s1, s2[0]).  */
       arglist = build_tree_list (NULL_TREE,
-                                build_int_cst (NULL_TREE, p2[0], 0));
+                                build_int_cst (NULL_TREE, p2[0]));
       arglist = tree_cons (NULL_TREE, s1, arglist);
       return build_function_call_expr (fn, arglist);
     }
@@ -9133,7 +9132,7 @@ fold_builtin_fputs (tree arglist, bool ignore, bool unlocked, tree len)
            arglist = build_tree_list (NULL_TREE,
                                       TREE_VALUE (TREE_CHAIN (arglist)));
            arglist = tree_cons (NULL_TREE,
-                                build_int_cst (NULL_TREE, p[0], 0),
+                                build_int_cst (NULL_TREE, p[0]),
                                 arglist);
            fn = fn_fputc;
            break;
@@ -9258,7 +9257,7 @@ simplify_builtin_sprintf (tree arglist, int ignored)
       arglist = tree_cons (NULL_TREE, dest, arglist);
       call = build_function_call_expr (fn, arglist);
       if (!ignored)
-       retval = build_int_cst (NULL_TREE, strlen (fmt_str), 0);
+       retval = build_int_cst (NULL_TREE, strlen (fmt_str));
     }
 
   /* If the format is "%s", use strcpy if the result isn't used.  */
index 7306cdf..62d2231 100644 (file)
@@ -660,7 +660,7 @@ start_fname_decls (void)
 
       if (decl)
        {
-         saved = tree_cons (decl, build_int_cst (NULL_TREE, ix, 0), saved);
+         saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
          *fname_vars[ix].decl = NULL_TREE;
        }
     }
@@ -851,7 +851,7 @@ fix_string_type (tree value)
      For C++, this is the standard behavior.  */
   if (flag_const_strings)
     e_type = build_type_variant (e_type, 1, 0);
-  i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1, 0));
+  i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
   TREE_TYPE (value) = build_array_type (e_type, i_type);
 
   TREE_CONSTANT (value) = 1;
@@ -1992,9 +1992,9 @@ shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
        {
          /* Convert primop1 to target type, but do not introduce
             additional overflow.  We know primop1 is an int_cst.  */
-         tree tmp = build_int_cst (*restype_ptr,
-                                   TREE_INT_CST_LOW (primop1),
-                                   TREE_INT_CST_HIGH (primop1));
+         tree tmp = build_int_cst_wide (*restype_ptr,
+                                        TREE_INT_CST_LOW (primop1),
+                                        TREE_INT_CST_HIGH (primop1));
 
          primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
                                    TREE_CONSTANT_OVERFLOW (primop1));
@@ -3897,8 +3897,7 @@ c_init_attributes (void)
 #define DEF_ATTR_NULL_TREE(ENUM)                               \
   built_in_attributes[(int) ENUM] = NULL_TREE;
 #define DEF_ATTR_INT(ENUM, VALUE)                              \
-  built_in_attributes[(int) ENUM] = build_int_cst              \
-       (NULL_TREE, VALUE, VALUE < 0 ? -1 : 0);
+  built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
 #define DEF_ATTR_IDENT(ENUM, STRING)                           \
   built_in_attributes[(int) ENUM] = get_identifier (STRING);
 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)        \
index ffa4747..e9a9036 100644 (file)
@@ -3272,12 +3272,12 @@ complete_array_type (tree type, tree initial_value, int do_default)
            = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
          maxindex = build_int_cst (NULL_TREE,
                                    (TREE_STRING_LENGTH (initial_value)
-                                    / eltsize) - 1, 0);
+                                    / eltsize) - 1);
        }
       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
        {
          tree elts = CONSTRUCTOR_ELTS (initial_value);
-         maxindex = build_int_cst (NULL_TREE, -1, -1);
+         maxindex = build_int_cst (NULL_TREE, -1);
          for (; elts; elts = TREE_CHAIN (elts))
            {
              if (TREE_PURPOSE (elts))
@@ -3294,14 +3294,14 @@ complete_array_type (tree type, tree initial_value, int do_default)
            value = 1;
 
          /* Prevent further error messages.  */
-         maxindex = build_int_cst (NULL_TREE, 0, 0);
+         maxindex = build_int_cst (NULL_TREE, 0);
        }
     }
 
   if (!maxindex)
     {
       if (do_default)
-       maxindex = build_int_cst (NULL_TREE, 0, 0);
+       maxindex = build_int_cst (NULL_TREE, 0);
       value = 2;
     }
 
@@ -3412,7 +3412,7 @@ check_bitfield_type_and_width (tree *type, tree *width, const char *orig_name)
     {
       error ("width of `%s' exceeds its type", name);
       w = max_width;
-      *width = build_int_cst (NULL_TREE, w, 0);
+      *width = build_int_cst (NULL_TREE, w);
     }
   else
     w = tree_low_cst (*width, 1);
index 74f8be6..720519f 100644 (file)
@@ -588,11 +588,11 @@ interpret_integer (const cpp_token *token, unsigned int flags)
     pedwarn ("integer constant is too large for \"%s\" type",
             (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
 
-  value = build_int_cst (type, integer.low, integer.high);
+  value = build_int_cst_wide (type, integer.low, integer.high);
 
   /* Convert imaginary to a complex type.  */
   if (flags & CPP_N_IMAGINARY)
-    value = build_complex (NULL_TREE, build_int_cst (type, 0, 0), value);
+    value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 
   return value;
 }
@@ -805,9 +805,9 @@ lex_charconst (const cpp_token *token)
   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
   if (unsignedp || (cppchar_signed_t) result >= 0)
-    value = build_int_cst (type, result, 0);
+    value = build_int_cst_wide (type, result, 0);
   else
-    value = build_int_cst (type, (cppchar_signed_t) result, -1);
+    value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
 
   return value;
 }
index 2269bef..16cbd22 100644 (file)
@@ -704,8 +704,8 @@ primary:
                  e2 = TYPE_MAIN_VARIANT (groktypename ($5));
 
                  $$.value = comptypes (e1, e2)
-                   ? build_int_cst (NULL_TREE, 1, 0)
-                   : build_int_cst (NULL_TREE, 0, 0);
+                   ? build_int_cst (NULL_TREE, 1)
+                   : build_int_cst (NULL_TREE, 0);
                  $$.original_code = ERROR_MARK;
                }
        | TYPES_COMPATIBLE_P '(' error ')'
index dbb56ed..43bc1de 100644 (file)
@@ -786,9 +786,10 @@ pp_c_integer_constant (c_pretty_printer *pp, tree i)
       if (tree_int_cst_sgn (i) < 0)
         {
           pp_c_char (pp, '-');
-          i = build_int_cst (NULL_TREE,
-                            -TREE_INT_CST_LOW (i),
-                            ~TREE_INT_CST_HIGH (i) + !TREE_INT_CST_LOW (i));
+          i = build_int_cst_wide (NULL_TREE,
+                                 -TREE_INT_CST_LOW (i),
+                                 ~TREE_INT_CST_HIGH (i)
+                                 + !TREE_INT_CST_LOW (i));
         }
       sprintf (pp_buffer (pp)->digit_buffer,
                HOST_WIDE_INT_PRINT_DOUBLE_HEX,
index 3530c20..d71b990 100644 (file)
@@ -4484,14 +4484,14 @@ really_start_incremental_init (tree type)
          /* Detect non-empty initializations of zero-length arrays.  */
          if (constructor_max_index == NULL_TREE
              && TYPE_SIZE (constructor_type))
-           constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
+           constructor_max_index = build_int_cst (NULL_TREE, -1);
 
          /* constructor_max_index needs to be an INTEGER_CST.  Attempts
             to initialize VLAs will cause a proper error; avoid tree
             checking errors as well by setting a safe value.  */
          if (constructor_max_index
              && TREE_CODE (constructor_max_index) != INTEGER_CST)
-           constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
+           constructor_max_index = build_int_cst (NULL_TREE, -1);
 
          constructor_index
            = convert (bitsizetype,
@@ -4506,8 +4506,7 @@ really_start_incremental_init (tree type)
     {
       /* Vectors are like simple fixed-size arrays.  */
       constructor_max_index =
-       build_int_cst (NULL_TREE,
-                      TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
+       build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
       constructor_index = convert (bitsizetype, bitsize_zero_node);
       constructor_unfilled_index = constructor_index;
     }
@@ -4662,8 +4661,7 @@ push_init_level (int implicit)
     {
       /* Vectors are like simple fixed-size arrays.  */
       constructor_max_index =
-       build_int_cst (NULL_TREE,
-                      TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
+       build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
       constructor_index = convert (bitsizetype, integer_zero_node);
       constructor_unfilled_index = constructor_index;
     }
@@ -4677,14 +4675,14 @@ push_init_level (int implicit)
          /* Detect non-empty initializations of zero-length arrays.  */
          if (constructor_max_index == NULL_TREE
              && TYPE_SIZE (constructor_type))
-           constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
+           constructor_max_index = build_int_cst (NULL_TREE, -1);
 
          /* constructor_max_index needs to be an INTEGER_CST.  Attempts
             to initialize VLAs will cause a proper error; avoid tree
             checking errors as well by setting a safe value.  */
          if (constructor_max_index
              && TREE_CODE (constructor_max_index) != INTEGER_CST)
-           constructor_max_index = build_int_cst (NULL_TREE, -1, -1);
+           constructor_max_index = build_int_cst (NULL_TREE, -1);
 
          constructor_index
            = convert (bitsizetype,
@@ -5408,7 +5406,7 @@ set_nonincremental_init_from_string (tree str)
                      << (bitpos - HOST_BITS_PER_WIDE_INT);
        }
 
-      value = build_int_cst (type, val[1], val[0]);
+      value = build_int_cst_wide (type, val[1], val[0]);
       add_pending_init (purpose, value);
     }
 
index 592f8bc..2e500bd 100644 (file)
@@ -1505,8 +1505,7 @@ load_register_parameters (struct arg_data *args, int num_actuals,
                     seem worth generating rtl to say that.  */
                  reg = gen_rtx_REG (word_mode, REGNO (reg));
                  x = expand_shift (LSHIFT_EXPR, word_mode, reg,
-                                   build_int_cst (NULL_TREE,
-                                                  shift, 0),
+                                   build_int_cst (NULL_TREE, shift),
                                    reg, 1);
                  if (x != reg)
                    emit_move_insn (reg, x);
@@ -1544,7 +1543,7 @@ load_register_parameters (struct arg_data *args, int num_actuals,
 
                  emit_move_insn (x, tem);
                  x = expand_shift (dir, word_mode, x,
-                                   build_int_cst (NULL_TREE, shift, 0),
+                                   build_int_cst (NULL_TREE, shift),
                                    ri, 1);
                  if (x != ri)
                    emit_move_insn (ri, x);
index a92adeb..c623e00 100644 (file)
@@ -4925,7 +4925,7 @@ alpha_initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt,
       temp = expand_binop (DImode, sub_optab, fnaddr, temp, temp, 1,
                           OPTAB_WIDEN);
       temp = expand_shift (RSHIFT_EXPR, Pmode, temp,
-                          build_int_cst (NULL_TREE, 2, 0), NULL_RTX, 1);
+                          build_int_cst (NULL_TREE, 2), NULL_RTX, 1);
       temp = expand_and (SImode, gen_lowpart (SImode, temp),
                         GEN_INT (0x3fff), 0);
 
@@ -5379,12 +5379,12 @@ alpha_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
 
       t = make_tree (ptr_type_node, virtual_incoming_args_rtx);
       t = build (PLUS_EXPR, ptr_type_node, t,
-                build_int_cst (NULL_TREE, offset, 0));
+                build_int_cst (NULL_TREE, offset));
       t = build (MODIFY_EXPR, TREE_TYPE (base_field), base_field, t);
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
-      t = build_int_cst (NULL_TREE, NUM_ARGS * UNITS_PER_WORD, 0);
+      t = build_int_cst (NULL_TREE, NUM_ARGS * UNITS_PER_WORD);
       t = build (MODIFY_EXPR, TREE_TYPE (offset_field), offset_field, t);
       TREE_SIDE_EFFECTS (t) = 1;
       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -5400,7 +5400,7 @@ alpha_gimplify_va_arg_1 (tree type, tree base, tree offset, tree *pre_p)
      reserved for the registers.  */
   if (targetm.calls.must_pass_in_stack (TYPE_MODE (type), type))
     {
-      t = build_int_cst (TREE_TYPE (offset), 6*8, 0);
+      t = build_int_cst (TREE_TYPE (offset), 6*8);
       t = build (MODIFY_EXPR, TREE_TYPE (offset), offset,
                 build (MAX_EXPR, TREE_TYPE (offset), offset, t));
       gimplify_and_add (t, pre_p);
@@ -5429,7 +5429,7 @@ alpha_gimplify_va_arg_1 (tree type, tree base, tree offset, tree *pre_p)
     {
       tree fpaddend, cond, fourtyeight;
 
-      fourtyeight = build_int_cst (TREE_TYPE (addend), 6*8, 0);
+      fourtyeight = build_int_cst (TREE_TYPE (addend), 6*8);
       fpaddend = fold (build (MINUS_EXPR, TREE_TYPE (addend),
                              addend, fourtyeight));
       cond = fold (build (LT_EXPR, boolean_type_node, addend, fourtyeight));
index ce9a27c..9d9acb2 100644 (file)
@@ -14181,7 +14181,7 @@ arm_get_cookie_size (tree type)
   if (!TARGET_AAPCS_BASED)
     return default_cxx_get_cookie_size (type);
 
-  size = build_int_cst (sizetype, 8, 0);
+  size = build_int_cst (sizetype, 8);
   return size;
 }
 
index e3ab61b..5437568 100644 (file)
@@ -738,7 +738,7 @@ c4x_gimplify_va_arg_expr (tree valist, tree type,
     type = build_pointer_type (type);
 
   t = build (PREDECREMENT_EXPR, TREE_TYPE (valist), valist,
-            build_int_cst (NULL_TREE, int_size_in_bytes (type), 0));
+            build_int_cst (NULL_TREE, int_size_in_bytes (type)));
   t = fold_convert (build_pointer_type (type), t);
   t = build_fold_indirect_ref (t);
 
index 53ed7f1..3e2eef7 100644 (file)
@@ -3236,12 +3236,12 @@ ix86_va_start (tree valist, rtx nextarg)
             (int) words, (int) n_gpr, (int) n_fpr);
 
   t = build (MODIFY_EXPR, TREE_TYPE (gpr), gpr,
-            build_int_cst (NULL_TREE, n_gpr * 8, 0));
+            build_int_cst (NULL_TREE, n_gpr * 8));
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
   t = build (MODIFY_EXPR, TREE_TYPE (fpr), fpr,
-            build_int_cst (NULL_TREE, n_fpr * 16 + 8*REGPARM_MAX, 0));
+            build_int_cst (NULL_TREE, n_fpr * 16 + 8*REGPARM_MAX));
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -3249,7 +3249,7 @@ ix86_va_start (tree valist, rtx nextarg)
   t = make_tree (TREE_TYPE (ovf), virtual_incoming_args_rtx);
   if (words != 0)
     t = build (PLUS_EXPR, TREE_TYPE (ovf), t,
-              build_int_cst (NULL_TREE, words * UNITS_PER_WORD, 0));
+              build_int_cst (NULL_TREE, words * UNITS_PER_WORD));
   t = build (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -3369,7 +3369,7 @@ ix86_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
       if (needed_intregs)
        {
          t = build_int_cst (TREE_TYPE (gpr),
-                            (REGPARM_MAX - needed_intregs + 1) * 8, 0);
+                            (REGPARM_MAX - needed_intregs + 1) * 8);
          t = build2 (GE_EXPR, boolean_type_node, gpr, t);
          t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
          t = build (COND_EXPR, void_type_node, t, t2, NULL_TREE);
@@ -3379,7 +3379,7 @@ ix86_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
        {
          t = build_int_cst (TREE_TYPE (fpr),
                             (SSE_REGPARM_MAX - needed_sseregs + 1) * 16
-                            + REGPARM_MAX * 8, 0);
+                            + REGPARM_MAX * 8);
          t = build2 (GE_EXPR, boolean_type_node, fpr, t);
          t2 = build1 (GOTO_EXPR, void_type_node, lab_false);
          t = build (COND_EXPR, void_type_node, t, t2, NULL_TREE);
@@ -3450,14 +3450,14 @@ ix86_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
       if (needed_intregs)
        {
          t = build2 (PLUS_EXPR, TREE_TYPE (gpr), gpr,
-                     build_int_cst (NULL_TREE, needed_intregs * 8, 0));
+                     build_int_cst (NULL_TREE, needed_intregs * 8));
          t = build2 (MODIFY_EXPR, TREE_TYPE (gpr), gpr, t);
          gimplify_and_add (t, pre_p);
        }
       if (needed_sseregs)
        {
          t = build2 (PLUS_EXPR, TREE_TYPE (fpr), fpr,
-                     build_int_cst (NULL_TREE, needed_sseregs * 16, 0));
+                     build_int_cst (NULL_TREE, needed_sseregs * 16));
          t = build2 (MODIFY_EXPR, TREE_TYPE (fpr), fpr, t);
          gimplify_and_add (t, pre_p);
        }
@@ -3478,9 +3478,9 @@ ix86_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
     {
       HOST_WIDE_INT align = FUNCTION_ARG_BOUNDARY (VOIDmode, type) / 8;
       t = build (PLUS_EXPR, TREE_TYPE (ovf), ovf,
-                build_int_cst (NULL_TREE, align - 1, 0));
+                build_int_cst (NULL_TREE, align - 1));
       t = build (BIT_AND_EXPR, TREE_TYPE (t), t,
-                build_int_cst (NULL_TREE, -align, -1));
+                build_int_cst (NULL_TREE, -align));
     }
   gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
 
@@ -3488,7 +3488,7 @@ ix86_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
   gimplify_and_add (t2, pre_p);
 
   t = build2 (PLUS_EXPR, TREE_TYPE (t), t,
-             build_int_cst (NULL_TREE, rsize * UNITS_PER_WORD, 0));
+             build_int_cst (NULL_TREE, rsize * UNITS_PER_WORD));
   t = build2 (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
   gimplify_and_add (t, pre_p);
 
index 770f832..1b9ac8e 100644 (file)
@@ -3400,9 +3400,9 @@ ia64_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
       ? int_size_in_bytes (type) > 8 : TYPE_ALIGN (type) > 8 * BITS_PER_UNIT)
     {
       tree t = build (PLUS_EXPR, TREE_TYPE (valist), valist,
-                     build_int_cst (NULL_TREE, 2 * UNITS_PER_WORD - 1, 0));
+                     build_int_cst (NULL_TREE, 2 * UNITS_PER_WORD - 1));
       t = build (BIT_AND_EXPR, TREE_TYPE (t), t,
-                build_int_cst (NULL_TREE, -2 * UNITS_PER_WORD, -1));
+                build_int_cst (NULL_TREE, -2 * UNITS_PER_WORD));
       t = build (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
       gimplify_and_add (t, pre_p);
     }
index 795d113..07aa4e8 100644 (file)
@@ -3385,7 +3385,7 @@ mips_build_builtin_va_list (void)
                          unsigned_char_type_node);
       /* Explicitly pad to the size of a pointer, so that -Wpadded won't
         warn on every user file.  */
-      index = build_int_cst (NULL_TREE, GET_MODE_SIZE (ptr_mode) - 2 - 1, 0);
+      index = build_int_cst (NULL_TREE, GET_MODE_SIZE (ptr_mode) - 2 - 1);
       array = build_array_type (unsigned_char_type_node,
                                build_index_type (index));
       f_res = build_decl (FIELD_DECL, get_identifier ("__reserved"), array);
@@ -3470,7 +3470,7 @@ mips_va_start (tree valist, rtx nextarg)
          if (cum->stack_words > 0)
            t = build (PLUS_EXPR, TREE_TYPE (ovfl), t,
                       build_int_cst (NULL_TREE,
-                                     cum->stack_words * UNITS_PER_WORD, 0));
+                                     cum->stack_words * UNITS_PER_WORD));
          t = build (MODIFY_EXPR, TREE_TYPE (ovfl), ovfl, t);
          expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -3487,14 +3487,14 @@ mips_va_start (tree valist, rtx nextarg)
          fpr_offset &= ~(UNITS_PER_FPVALUE - 1);
          if (fpr_offset)
            t = build (PLUS_EXPR, TREE_TYPE (ftop), t,
-                      build_int_cst (NULL_TREE, -fpr_offset, -1));
+                      build_int_cst (NULL_TREE, -fpr_offset));
          t = build (MODIFY_EXPR, TREE_TYPE (ftop), ftop, t);
          expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
          /* Emit code to initialize GOFF, the offset from GTOP of the
             next GPR argument.  */
          t = build (MODIFY_EXPR, TREE_TYPE (goff), goff,
-                    build_int_cst (NULL_TREE, gpr_save_area_size, 0));
+                    build_int_cst (NULL_TREE, gpr_save_area_size));
          expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
          /* Likewise emit code to initialize FOFF, the offset from FTOP
@@ -3502,7 +3502,7 @@ mips_va_start (tree valist, rtx nextarg)
          fpr_save_area_size
            = (MAX_ARGS_IN_REGISTERS - cum->num_fprs) * UNITS_PER_FPREG;
          t = build (MODIFY_EXPR, TREE_TYPE (foff), foff,
-                    build_int_cst (NULL_TREE, fpr_save_area_size, 0));
+                    build_int_cst (NULL_TREE, fpr_save_area_size));
          expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
        }
       else
@@ -3626,7 +3626,7 @@ mips_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
            {
              /* [1] Emit code for: off &= -rsize.      */
              t = build (BIT_AND_EXPR, TREE_TYPE (off), off,
-                        build_int_cst (NULL_TREE, -rsize, -1));
+                        build_int_cst (NULL_TREE, -rsize));
              t = build (MODIFY_EXPR, TREE_TYPE (off), off, t);
              gimplify_and_add (t, pre_p);
            }
@@ -3640,7 +3640,7 @@ mips_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
       /* [5] Emit code for: off -= rsize.  We do this as a form of
         post-increment not available to C.  Also widen for the
         coming pointer arithmetic.  */
-      t = fold_convert (TREE_TYPE (off), build_int_cst (NULL_TREE, rsize, 0));
+      t = fold_convert (TREE_TYPE (off), build_int_cst (NULL_TREE, rsize));
       t = build (POSTDECREMENT_EXPR, TREE_TYPE (off), off, t);
       t = fold_convert (sizetype, t);
       t = fold_convert (TREE_TYPE (top), t);
@@ -3651,7 +3651,7 @@ mips_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
       if (BYTES_BIG_ENDIAN && rsize > size)
        {
          u = fold_convert (TREE_TYPE (t), build_int_cst (NULL_TREE,
-                                                         rsize - size, 0));
+                                                         rsize - size));
          t = build (PLUS_EXPR, TREE_TYPE (t), t, u);
        }
       COND_EXPR_THEN (addr) = t;
@@ -3660,10 +3660,10 @@ mips_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
        {
          /* [9] Emit: ovfl += ((intptr_t) ovfl + osize - 1) & -osize.  */
          u = fold_convert (TREE_TYPE (ovfl),
-                           build_int_cst (NULL_TREE, osize - 1, 0));
+                           build_int_cst (NULL_TREE, osize - 1));
          t = build (PLUS_EXPR, TREE_TYPE (ovfl), ovfl, u);
          u = fold_convert (TREE_TYPE (ovfl),
-                           build_int_cst (NULL_TREE, -osize, -1));
+                           build_int_cst (NULL_TREE, -osize));
          t = build (BIT_AND_EXPR, TREE_TYPE (ovfl), t, u);
          align = build (MODIFY_EXPR, TREE_TYPE (ovfl), ovfl, t);
        }
@@ -3674,12 +3674,12 @@ mips_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
         post-increment ovfl by osize.  On big-endian machines,
         the argument has OSIZE - SIZE bytes of leading padding.  */
       u = fold_convert (TREE_TYPE (ovfl),
-                       build_int_cst (NULL_TREE, osize, 0));
+                       build_int_cst (NULL_TREE, osize));
       t = build (POSTINCREMENT_EXPR, TREE_TYPE (ovfl), ovfl, u);
       if (BYTES_BIG_ENDIAN && osize > size)
        {
          u = fold_convert (TREE_TYPE (t),
-                           build_int_cst (NULL_TREE, osize - size, 0));
+                           build_int_cst (NULL_TREE, osize - size));
          t = build (PLUS_EXPR, TREE_TYPE (t), t, u);
        }
 
index a35820b..0bc755a 100644 (file)
@@ -6117,7 +6117,7 @@ hppa_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
 
       /* Copied from va-pa.h, but we probably don't need to align to
         word size, since we generate and preserve that invariant.  */
-      u = build_int_cst (valist_type, (size > 4 ? -8 : -4), -1);
+      u = build_int_cst (valist_type, (size > 4 ? -8 : -4));
       t = build (BIT_AND_EXPR, valist_type, t, u);
 
       t = build (MODIFY_EXPR, valist_type, valist, t);
index b6175f3..fd95f0b 100644 (file)
@@ -5451,12 +5451,12 @@ rs6000_va_start (tree valist, rtx nextarg)
             words, n_gpr, n_fpr);
 
   t = build (MODIFY_EXPR, TREE_TYPE (gpr), gpr,
-            build_int_cst (NULL_TREE, n_gpr, 0));
+            build_int_cst (NULL_TREE, n_gpr));
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
   t = build (MODIFY_EXPR, TREE_TYPE (fpr), fpr,
-            build_int_cst (NULL_TREE, n_fpr, 0));
+            build_int_cst (NULL_TREE, n_fpr));
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -5464,7 +5464,7 @@ rs6000_va_start (tree valist, rtx nextarg)
   t = make_tree (TREE_TYPE (ovf), virtual_incoming_args_rtx);
   if (words != 0)
     t = build (PLUS_EXPR, TREE_TYPE (ovf), t,
-              build_int_cst (NULL_TREE, words * UNITS_PER_WORD, 0));
+              build_int_cst (NULL_TREE, words * UNITS_PER_WORD));
   t = build (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -5472,7 +5472,7 @@ rs6000_va_start (tree valist, rtx nextarg)
   /* Find the register save area.  */
   t = make_tree (TREE_TYPE (sav), virtual_stack_vars_rtx);
   t = build (PLUS_EXPR, TREE_TYPE (sav), t,
-            build_int_cst (NULL_TREE, -RS6000_VARARGS_SIZE, -1));
+            build_int_cst (NULL_TREE, -RS6000_VARARGS_SIZE));
   t = build (MODIFY_EXPR, TREE_TYPE (sav), sav, t);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -5630,7 +5630,7 @@ rs6000_gimplify_va_arg (tree valist, tree type, tree *pre_p, tree *post_p)
     {
       t = build2 (PLUS_EXPR, TREE_TYPE (t), t, size_int (align - 1));
       t = build2 (BIT_AND_EXPR, TREE_TYPE (t), t,
-                 build_int_cst (NULL_TREE, -align, -1));
+                 build_int_cst (NULL_TREE, -align));
     }
   gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
 
@@ -16430,7 +16430,7 @@ static void
 add_compiler_branch_island (tree label_name, tree function_name, int line_number)
 {
   tree branch_island = build_tree_list (function_name, label_name);
-  TREE_TYPE (branch_island) = build_int_cst (NULL_TREE, line_number, 0);
+  TREE_TYPE (branch_island) = build_int_cst (NULL_TREE, line_number);
   TREE_CHAIN (branch_island) = branch_island_list;
   branch_island_list = branch_island;
 }
index 06953ae..f014282 100644 (file)
@@ -7050,12 +7050,12 @@ s390_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
   n_fpr = current_function_args_info.fprs;
 
   t = build (MODIFY_EXPR, TREE_TYPE (gpr), gpr,
-            build_int_cst (NULL_TREE, n_gpr, 0));
+            build_int_cst (NULL_TREE, n_gpr));
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
   t = build (MODIFY_EXPR, TREE_TYPE (fpr), fpr,
-            build_int_cst (NULL_TREE, n_fpr, 0));
+            build_int_cst (NULL_TREE, n_fpr));
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
@@ -7068,7 +7068,7 @@ s390_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
     fprintf (stderr, "va_start: n_gpr = %d, n_fpr = %d off %d\n",
             (int)n_gpr, (int)n_fpr, off);
 
-  t = build (PLUS_EXPR, TREE_TYPE (ovf), t, build_int_cst (NULL_TREE, off, 0));
+  t = build (PLUS_EXPR, TREE_TYPE (ovf), t, build_int_cst (NULL_TREE, off));
 
   t = build (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
   TREE_SIDE_EFFECTS (t) = 1;
@@ -7080,10 +7080,10 @@ s390_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
     t = build (PLUS_EXPR, TREE_TYPE (sav), t,
               build_int_cst (NULL_TREE,
                              -(RETURN_REGNUM - 2) * UNITS_PER_WORD
-                             - (TARGET_64BIT ? 4 : 2) * 8, -1));
+                             - (TARGET_64BIT ? 4 : 2) * 8));
   else
     t = build (PLUS_EXPR, TREE_TYPE (sav), t,
-              build_int_cst (NULL_TREE, -RETURN_REGNUM * UNITS_PER_WORD, -1));
+              build_int_cst (NULL_TREE, -RETURN_REGNUM * UNITS_PER_WORD));
 
   t = build (MODIFY_EXPR, TREE_TYPE (sav), sav, t);
   TREE_SIDE_EFFECTS (t) = 1;
index 1c539e8..31104e5 100644 (file)
@@ -6342,7 +6342,7 @@ sh_va_start (tree valist, rtx nextarg)
   else
     nfp = 0;
   u = fold (build (PLUS_EXPR, ptr_type_node, u,
-                  build_int_cst (NULL_TREE, UNITS_PER_WORD * nfp, 0)));
+                  build_int_cst (NULL_TREE, UNITS_PER_WORD * nfp)));
   t = build (MODIFY_EXPR, ptr_type_node, next_fp_limit, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -6357,7 +6357,7 @@ sh_va_start (tree valist, rtx nextarg)
   else
     nint = 0;
   u = fold (build (PLUS_EXPR, ptr_type_node, u,
-                  build_int_cst (NULL_TREE, UNITS_PER_WORD * nint, 0)));
+                  build_int_cst (NULL_TREE, UNITS_PER_WORD * nint)));
   t = build (MODIFY_EXPR, ptr_type_node, next_o_limit, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
index cc044be..b75703b 100644 (file)
@@ -1487,14 +1487,14 @@ xstormy16_expand_builtin_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
 
   t = make_tree (TREE_TYPE (base), virtual_incoming_args_rtx);
   t = build (PLUS_EXPR, TREE_TYPE (base), t, 
-            build_int_cst (NULL_TREE, INCOMING_FRAME_SP_OFFSET, 0));
+            build_int_cst (NULL_TREE, INCOMING_FRAME_SP_OFFSET));
   t = build (MODIFY_EXPR, TREE_TYPE (base), base, t);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 
   t = build (MODIFY_EXPR, TREE_TYPE (count), count, 
             build_int_cst (NULL_TREE,
-                           current_function_args_info * UNITS_PER_WORD, 0));
+                           current_function_args_info * UNITS_PER_WORD));
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
 }
index 8d9a1b7..4d210e0 100644 (file)
@@ -2379,7 +2379,7 @@ xtensa_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
   /* Set the __va_stk member to ($arg_ptr - 32).  */
   u = make_tree (ptr_type_node, virtual_incoming_args_rtx);
   u = fold (build (PLUS_EXPR, ptr_type_node, u,
-                  build_int_cst (NULL_TREE, -32, -1)));
+                  build_int_cst (NULL_TREE, -32)));
   t = build (MODIFY_EXPR, ptr_type_node, stk, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -2389,7 +2389,7 @@ xtensa_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
      alignment offset for __va_stk.  */
   if (arg_words >= MAX_ARGS_IN_REGISTERS)
     arg_words += 2;
-  u = build_int_cst (NULL_TREE, arg_words * UNITS_PER_WORD, 0);
+  u = build_int_cst (NULL_TREE, arg_words * UNITS_PER_WORD);
   t = build (MODIFY_EXPR, integer_type_node, ndx, u);
   TREE_SIDE_EFFECTS (t) = 1;
   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
@@ -2456,9 +2456,9 @@ xtensa_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
       int align = TYPE_ALIGN (type) / BITS_PER_UNIT;
 
       t = build (PLUS_EXPR, integer_type_node, orig_ndx,
-                build_int_cst (NULL_TREE, align - 1, 0));
+                build_int_cst (NULL_TREE, align - 1));
       t = build (BIT_AND_EXPR, integer_type_node, t,
-                build_int_cst (NULL_TREE, -align, -1));
+                build_int_cst (NULL_TREE, -align));
       t = build (MODIFY_EXPR, integer_type_node, orig_ndx, t);
       gimplify_and_add (t, pre_p);
     }
@@ -2488,7 +2488,7 @@ xtensa_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
       lab_false = create_artificial_label ();
       lab_over = create_artificial_label ();
 
-      t = build_int_cst (NULL_TREE, MAX_ARGS_IN_REGISTERS * UNITS_PER_WORD, 0);
+      t = build_int_cst (NULL_TREE, MAX_ARGS_IN_REGISTERS * UNITS_PER_WORD);
       t = build (GT_EXPR, boolean_type_node, ndx, t);
       t = build (COND_EXPR, void_type_node, t,
                 build (GOTO_EXPR, void_type_node, lab_false),
@@ -2518,7 +2518,7 @@ xtensa_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
 
   lab_false2 = create_artificial_label ();
 
-  t = build_int_cst (NULL_TREE, MAX_ARGS_IN_REGISTERS * UNITS_PER_WORD, 0);
+  t = build_int_cst (NULL_TREE, MAX_ARGS_IN_REGISTERS * UNITS_PER_WORD);
   t = build (GT_EXPR, boolean_type_node, orig_ndx, t);
   t = build (COND_EXPR, void_type_node, t,
             build (GOTO_EXPR, void_type_node, lab_false2),
index 9517c50..ceefbf2 100644 (file)
@@ -43,7 +43,7 @@ convert_to_pointer (tree type, tree expr)
 {
   if (integer_zerop (expr))
     {
-      expr = build_int_cst (type, 0, 0);
+      expr = build_int_cst (type, 0);
       return expr;
     }
 
index 9f6e13b..c8a962f 100644 (file)
@@ -378,7 +378,7 @@ coverage_counter_alloc (unsigned counter, unsigned num)
         will make any clever transformation on it.  */
       char buf[20];
       tree domain_tree
-        = build_index_type (build_int_cst (NULL_TREE, 1000, 0)); /* replaced later */
+        = build_index_type (build_int_cst (NULL_TREE, 1000)); /* replaced later */
       tree gcov_type_array_type
         = build_array_type (GCOV_TYPE_NODE, domain_tree);
       tree_ctr_tables[counter]
@@ -435,7 +435,7 @@ tree_coverage_counter_ref (unsigned counter, unsigned no)
   /* "no" here is an array index, scaled to bytes later.  */
   return build4 (ARRAY_REF, GCOV_TYPE_NODE, tree_ctr_tables[counter],
                 fold_convert (domain_type,
-                              build_int_cst (NULL_TREE, no, 0)),
+                              build_int_cst (NULL_TREE, no)),
                 TYPE_MIN_VALUE (domain_type),
                 size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (GCOV_TYPE_NODE),
                             size_int (TYPE_ALIGN_UNIT (GCOV_TYPE_NODE))));
@@ -610,7 +610,7 @@ build_fn_info_type (unsigned int counters)
   TREE_CHAIN (field) = fields;
   fields = field;
 
-  array_type = build_int_cst (NULL_TREE, counters - 1, 0);
+  array_type = build_int_cst (NULL_TREE, counters - 1);
   array_type = build_index_type (array_type);
   array_type = build_array_type (unsigned_type_node, array_type);
 
@@ -637,21 +637,21 @@ build_fn_info_value (const struct function_list *function, tree type)
   tree array_value = NULL_TREE;
 
   /* ident */
-  value = tree_cons (fields, build_int_cst (unsigned_intSI_type_node,
-                                           function->ident, 0), value);
+  value = tree_cons (fields, build_int_cstu (unsigned_intSI_type_node,
+                                            function->ident), value);
   fields = TREE_CHAIN (fields);
 
   /* checksum */
-  value = tree_cons (fields, build_int_cst (unsigned_intSI_type_node,
-                                           function->checksum, 0), value);
+  value = tree_cons (fields, build_int_cstu (unsigned_intSI_type_node,
+                                            function->checksum), value);
   fields = TREE_CHAIN (fields);
 
   /* counters */
   for (ix = 0; ix != GCOV_COUNTERS; ix++)
     if (prg_ctr_mask & (1 << ix))
       {
-       tree counters = build_int_cst (unsigned_type_node,
-                                      function->n_ctrs[ix], 0);
+       tree counters = build_int_cstu (unsigned_type_node,
+                                       function->n_ctrs[ix]);
 
        array_value = tree_cons (NULL_TREE, counters, array_value);
       }
@@ -712,8 +712,8 @@ build_ctr_info_value (unsigned int counter, tree type)
 
   /* counters */
   value = tree_cons (fields,
-                    build_int_cst (unsigned_intSI_type_node,
-                                   prg_n_ctrs[counter], 0),
+                    build_int_cstu (unsigned_intSI_type_node,
+                                    prg_n_ctrs[counter]),
                     value);
   fields = TREE_CHAIN (fields);
 
@@ -721,8 +721,8 @@ build_ctr_info_value (unsigned int counter, tree type)
     {
       tree array_type;
 
-      array_type = build_int_cst (unsigned_type_node,
-                                 prg_n_ctrs[counter] - 1, 0);
+      array_type = build_int_cstu (unsigned_type_node,
+                                  prg_n_ctrs[counter] - 1);
       array_type = build_index_type (array_type);
       array_type = build_array_type (TREE_TYPE (TREE_TYPE (fields)),
                                     array_type);
@@ -789,8 +789,8 @@ build_gcov_info (void)
   field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
   TREE_CHAIN (field) = fields;
   fields = field;
-  value = tree_cons (field, build_int_cst (unsigned_intSI_type_node,
-                                          GCOV_VERSION, 0), value);
+  value = tree_cons (field, build_int_cstu (unsigned_intSI_type_node,
+                                           GCOV_VERSION), value);
 
   /* next -- NULL */
   field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
@@ -802,8 +802,8 @@ build_gcov_info (void)
   field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
   TREE_CHAIN (field) = fields;
   fields = field;
-  value = tree_cons (field, build_int_cst (unsigned_intSI_type_node,
-                                          local_tick, 0), value);
+  value = tree_cons (field, build_int_cstu (unsigned_intSI_type_node,
+                                           local_tick), value);
 
   /* Filename */
   string_type = build_pointer_type (build_qualified_type (char_type_node,
@@ -821,7 +821,7 @@ build_gcov_info (void)
     free (filename);
   TREE_TYPE (filename_string) = build_array_type
     (char_type_node, build_index_type
-     (build_int_cst (NULL_TREE, filename_len, 0)));
+     (build_int_cst (NULL_TREE, filename_len)));
   value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string),
                     value);
 
@@ -837,8 +837,7 @@ build_gcov_info (void)
     {
       tree array_type;
 
-      array_type = build_index_type (build_int_cst (NULL_TREE,
-                                                   n_fns - 1, 0));
+      array_type = build_index_type (build_int_cst (NULL_TREE, n_fns - 1));
       array_type = build_array_type (fn_info_type, array_type);
 
       fn_info_value = build_constructor (array_type, nreverse (fn_info_value));
@@ -852,7 +851,7 @@ build_gcov_info (void)
   TREE_CHAIN (field) = fields;
   fields = field;
   value = tree_cons (field,
-                    build_int_cst (unsigned_type_node, n_fns, 0),
+                    build_int_cstu (unsigned_type_node, n_fns),
                     value);
 
   /* fn_info table */
@@ -866,13 +865,13 @@ build_gcov_info (void)
   TREE_CHAIN (field) = fields;
   fields = field;
   value = tree_cons (field,
-                    build_int_cst (unsigned_type_node, prg_ctr_mask, 0),
+                    build_int_cstu (unsigned_type_node, prg_ctr_mask),
                     value);
 
   /* counters */
   ctr_info_type = build_ctr_info_type ();
   ctr_info_ary_type = build_index_type (build_int_cst (NULL_TREE,
-                                                      n_ctr_types, 0));
+                                                      n_ctr_types));
   ctr_info_ary_type = build_array_type (ctr_info_type, ctr_info_ary_type);
   for (ix = 0; ix != GCOV_COUNTERS; ix++)
     if (prg_ctr_mask & (1 << ix))
index d654d65..fcb0404 100644 (file)
@@ -1,3 +1,23 @@
+2004-08-25  Nathan Sidwell  <nathan@codesourcery.com>
+
+
+       * call.c (convert_class_to_reference): Adjust build_int_cst calls.
+       (build_user_type_conversion_1, convert_like_real,
+       build_java_interface_fn_ref, build_special_member_call): Likewise.
+       * class.c (finish_struct_1, 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.
+       * mangle.c (write_integer_cst): Likewise.
+       * method.c (finish_thunk): 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.
+       
 2004-08-25  Zack Weinberg  <zack@codesourcery.com>
 
        * class.c, search.c: Remove references to DWARF_DEBUG.
@@ -6,10 +26,9 @@
 
        * repo.c (extract_string): Reset backquote after one character.
        (get_base_filename): Fix indentation.
-
 2004-08-24  Nathan Sidwell  <nathan@codesourcery.com>
 
-       * cp/decl.c (cxx_init_decl_processing): Adjust
+       * decl.c (cxx_init_decl_processing): Adjust
        build_common_tree_nodes call.
 
 2004-08-24  Nathan Sidwell  <nathan@codesourcery.com>
index 86f5e6d..6ebe9e2 100644 (file)
@@ -919,7 +919,7 @@ convert_class_to_reference (tree t, tree s, tree expr)
      error messages, which we should not issue now because we are just
      trying to find a conversion operator.  Therefore, we use NULL,
      cast to the appropriate type.  */
-  arglist = build_int_cst (build_pointer_type (s), 0, 0);
+  arglist = build_int_cst (build_pointer_type (s), 0);
   arglist = build_tree_list (NULL_TREE, arglist);
 
   reference_type = build_reference_type (t);
@@ -2519,7 +2519,7 @@ build_user_type_conversion_1 (tree totype, tree expr, int flags)
 
       ctors = BASELINK_FUNCTIONS (ctors);
 
-      t = build_int_cst (build_pointer_type (totype), 0, 0);
+      t = build_int_cst (build_pointer_type (totype), 0);
       args = build_tree_list (NULL_TREE, expr);
       /* We should never try to call the abstract or base constructor
         from here.  */
@@ -4181,7 +4181,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
        if (DECL_CONSTRUCTOR_P (convfn))
          {
            tree t = build_int_cst (build_pointer_type (DECL_CONTEXT (convfn)),
-                                   0, 0);
+                                   0);
 
            args = build_tree_list (NULL_TREE, expr);
            if (DECL_HAS_IN_CHARGE_PARM_P (convfn)
@@ -4959,7 +4959,7 @@ build_java_interface_fn_ref (tree fn, tree instance)
         break;
       i++;
     }
-  idx = build_int_cst (NULL_TREE, i, 0);
+  idx = build_int_cst (NULL_TREE, i);
 
   lookup_args = tree_cons (NULL_TREE, klass_ref, 
                           tree_cons (NULL_TREE, iface_ref,
@@ -5035,7 +5035,7 @@ build_special_member_call (tree instance, tree name, tree args,
   /* Handle the special case where INSTANCE is NULL_TREE.  */
   if (name == complete_ctor_identifier && !instance)
     {
-      instance = build_int_cst (build_pointer_type (class_type), 0, 0);
+      instance = build_int_cst (build_pointer_type (class_type), 0);
       instance = build1 (INDIRECT_REF, class_type, instance);
     }
   else
index e17a438..bd0d3f5 100644 (file)
@@ -5085,7 +5085,7 @@ finish_struct_1 (tree t)
               thunk base function.  */
            DECL_VINDEX (fndecl) = NULL_TREE;
          else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
-           DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex, 0);
+           DECL_VINDEX (fndecl) = build_int_cst (NULL_TREE, vindex);
        }
     }
 
@@ -7279,7 +7279,7 @@ build_vtbl_initializer (tree binfo,
   vid.generate_vcall_entries = true;
   /* The first vbase or vcall offset is at index -3 in the vtable.  */
   vid.index = build_int_cst (ssizetype,
-                            -3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE, -1);
+                            -3 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
 
   /* Add entries to the vtable for RTTI.  */
   build_rtti_vtbl_entries (binfo, &vid);
@@ -7405,7 +7405,7 @@ build_vtbl_initializer (tree binfo,
              {
                tree fdesc = build2 (FDESC_EXPR, vfunc_ptr_type_node,
                                     TREE_OPERAND (init, 0),
-                                    build_int_cst (NULL_TREE, i, 0));
+                                    build_int_cst (NULL_TREE, i));
                TREE_CONSTANT (fdesc) = 1;
                TREE_INVARIANT (fdesc) = 1;
 
index e066f7b..d9fc928 100644 (file)
@@ -211,7 +211,7 @@ cp_gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p)
 
     case EMPTY_CLASS_EXPR:
       /* We create an INTEGER_CST with RECORD_TYPE and value zero.  */
-      *expr_p = build_int_cst (TREE_TYPE (*expr_p), 0, 0);
+      *expr_p = build_int_cst (TREE_TYPE (*expr_p), 0);
       ret = GS_OK;
       break;
 
index 5a6584d..ede4770 100644 (file)
@@ -264,12 +264,12 @@ cp_convert_to_pointer (tree type, tree expr, bool force)
        {
          /* A NULL pointer-to-member is represented by -1, not by
             zero.  */
-         expr = build_int_cst (type, -1, -1);
+         expr = build_int_cst (type, -1);
          /* Fix up the representation of -1 if appropriate.  */
          expr = force_fit_type (expr, 0, false, false);
        }
       else
-       expr = build_int_cst (type, 0, 0);
+       expr = build_int_cst (type, 0);
       
       return expr;
     }
index 0ae7d71..05db490 100644 (file)
@@ -2963,8 +2963,8 @@ cxx_init_decl_processing (void)
   java_char_type_node = record_builtin_java_type ("__java_char", -16);
   java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
 
-  integer_two_node = build_int_cst (NULL_TREE, 2, 0);
-  integer_three_node = build_int_cst (NULL_TREE, 3, 0);
+  integer_two_node = build_int_cst (NULL_TREE, 2);
+  integer_three_node = build_int_cst (NULL_TREE, 3);
 
   record_builtin_type (RID_BOOL, "bool", boolean_type_node);
   truthvalue_type_node = boolean_type_node;
@@ -5254,13 +5254,13 @@ complete_array_type (tree type, tree initial_value, int do_default)
            = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
          maxindex = build_int_cst (NULL_TREE,
                                    (TREE_STRING_LENGTH (initial_value)
-                                    / eltsize) - 1, 0);
+                                    / eltsize) - 1);
        }
       else if (TREE_CODE (initial_value) == CONSTRUCTOR)
        {
          tree elts = CONSTRUCTOR_ELTS (initial_value);
 
-         maxindex = build_int_cst (ssizetype, -1, -1);
+         maxindex = build_int_cst (ssizetype, -1);
          for (; elts; elts = TREE_CHAIN (elts))
            {
              if (TREE_PURPOSE (elts))
@@ -5278,14 +5278,14 @@ complete_array_type (tree type, tree initial_value, int do_default)
            initial_value = NULL_TREE;
 
          /* Prevent further error messages.  */
-         maxindex = build_int_cst (NULL_TREE, 0, 0);
+         maxindex = build_int_cst (NULL_TREE, 0);
        }
     }
 
   if (!maxindex)
     {
       if (do_default)
-       maxindex = build_int_cst (NULL_TREE, 0, 0);
+       maxindex = build_int_cst (NULL_TREE, 0);
       value = 2;
     }
 
index efb86b5..cb9628c 100644 (file)
@@ -2351,7 +2351,7 @@ start_static_initialization_or_destruction (tree decl, int initp)
   guard_if_stmt = begin_if_stmt ();
   cond = cp_build_binary_op (EQ_EXPR,
                             priority_decl,
-                            build_int_cst (NULL_TREE, priority, 0));
+                            build_int_cst (NULL_TREE, priority));
   init_cond = initp ? integer_one_node : integer_zero_node;
   init_cond = cp_build_binary_op (EQ_EXPR,
                                  initialize_p_decl,
@@ -2602,10 +2602,10 @@ generate_ctor_or_dtor_function (bool constructor_p, int priority,
              body = start_objects (function_key, priority);
 
            arguments = tree_cons (NULL_TREE,
-                                  build_int_cst (NULL_TREE, priority, 0), 
+                                  build_int_cst (NULL_TREE, priority), 
                                   NULL_TREE);
            arguments = tree_cons (NULL_TREE,
-                                  build_int_cst (NULL_TREE, constructor_p, 0),
+                                  build_int_cst (NULL_TREE, constructor_p),
                                   arguments);
            finish_expr_stmt (build_function_call (fndecl, arguments));
          }
index e572aa7..72ce286 100644 (file)
@@ -721,7 +721,7 @@ build_throw (tree exp)
          cleanup = build1 (ADDR_EXPR, cleanup_type, cleanup);
        }
       else
-       cleanup = build_int_cst (cleanup_type, 0, 0);
+       cleanup = build_int_cst (cleanup_type, 0);
        
       tmp = tree_cons (NULL_TREE, cleanup, NULL_TREE);
       tmp = tree_cons (NULL_TREE, throw_type, tmp);
index b8feaff..bdff977 100644 (file)
@@ -1183,9 +1183,9 @@ write_integer_cst (const tree cst)
        }
       
       type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst));
-      base = build_int_cst (type, chunk, 0);
-      n = build_int_cst (type,
-                        TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst));
+      base = build_int_cstu (type, chunk);
+      n = build_int_cst_wide (type,
+                             TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst));
 
       if (sign < 0)
        {
index d0bad5d..11107b1 100644 (file)
@@ -179,9 +179,7 @@ void
 finish_thunk (tree thunk)
 {
   tree function, name;
-  tree fixed_offset = build_int_cst (ssizetype,
-                                    THUNK_FIXED_OFFSET (thunk),
-                                    THUNK_FIXED_OFFSET (thunk) < 0 ? -1 : 0);
+  tree fixed_offset = build_int_cst (ssizetype, THUNK_FIXED_OFFSET (thunk));
   tree virtual_offset = THUNK_VIRTUAL_OFFSET (thunk);
 
   my_friendly_assert (!DECL_NAME (thunk) && DECL_THUNK_P (thunk), 20021127);
index 6e9a6ea..1bc3952 100644 (file)
@@ -151,7 +151,7 @@ build_headof (tree exp)
 
   /* The offset-to-top field is at index -2 from the vptr.  */
   index = build_int_cst (NULL_TREE,
-                        -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE, -1);
+                        -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
 
   offset = build_vtbl_ref (build_indirect_ref (exp, NULL), index);
 
@@ -227,7 +227,7 @@ get_tinfo_decl_dynamic (tree exp)
 
       /* The RTTI information is at index -1.  */
       index = build_int_cst (NULL_TREE,
-                            -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE, -1);
+                            -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
       t = build_vtbl_ref (exp, index);
       t = convert (type_info_ptr_type, t);
     }
@@ -590,7 +590,7 @@ build_dynamic_cast_1 (tree type, tree expr)
                {
                  warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
                              op, type);
-                 retval = build_int_cst (type, 0, 0); 
+                 retval = build_int_cst (type, 0); 
                  return retval;
                }
            }
@@ -879,7 +879,7 @@ ptr_initializer (tree desc, tree target)
   
   if (incomplete)
     flags |= 8;
-  init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags, 0), init);
+  init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
   init = tree_cons (NULL_TREE,
                     get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
                     init);
@@ -909,7 +909,7 @@ ptm_initializer (tree desc, tree target)
     flags |= 0x8;
   if (!COMPLETE_TYPE_P (klass))
     flags |= 0x10;
-  init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags, 0), init);
+  init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
   init = tree_cons (NULL_TREE,
                    get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
                     init);
@@ -1090,10 +1090,9 @@ get_pseudo_ti_init (tree type, tree var_desc)
               
               /* Combine offset and flags into one field.  */
               offset = cp_build_binary_op (LSHIFT_EXPR, offset,
-                                          build_int_cst (NULL_TREE, 8, 0));
+                                          build_int_cst (NULL_TREE, 8));
               offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
-                                          build_int_cst (NULL_TREE,
-                                                         flags, 0));
+                                          build_int_cst (NULL_TREE, flags));
               base_init = tree_cons (NULL_TREE, offset, base_init);
               base_init = tree_cons (NULL_TREE, tinfo, base_init);
               base_init = build_constructor (NULL_TREE, base_init);
@@ -1103,11 +1102,11 @@ get_pseudo_ti_init (tree type, tree var_desc)
          base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
          /* Prepend the number of bases.  */
          base_inits = tree_cons (NULL_TREE,
-                                 build_int_cst (NULL_TREE, nbases, 0),
+                                 build_int_cst (NULL_TREE, nbases),
                                  base_inits);
          /* Prepend the hint flags.  */
          base_inits = tree_cons (NULL_TREE,
-                                 build_int_cst (NULL_TREE, hint, 0),
+                                 build_int_cst (NULL_TREE, hint),
                                  base_inits);
 
           return class_initializer (var_desc, type, base_inits);
index 1c52a94..4acd2d5 100644 (file)
@@ -347,7 +347,7 @@ get_dynamic_cast_base_type (tree subtype, tree target)
   
   if (!boff)
     return offset;
-  offset = build_int_cst (ssizetype, boff, -1);
+  offset = build_int_cst (ssizetype, boff);
   return offset;
 }
 
index c9e086e..458b88c 100644 (file)
@@ -376,7 +376,7 @@ init_eh (void)
                         integer_type_node);
       DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node;
 
-      tmp = build_index_type (build_int_cst (NULL_TREE, 4 - 1, 0));
+      tmp = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
       tmp = build_array_type (lang_hooks.types.type_for_mode (word_mode, 1),
                              tmp);
       f_data = build_decl (FIELD_DECL, get_identifier ("__data"), tmp);
@@ -392,19 +392,17 @@ init_eh (void)
 
 #ifdef DONT_USE_BUILTIN_SETJMP
 #ifdef JMP_BUF_SIZE
-      tmp = build_int_cst (NULL_TREE, JMP_BUF_SIZE - 1, 0);
+      tmp = build_int_cst (NULL_TREE, JMP_BUF_SIZE - 1);
 #else
       /* Should be large enough for most systems, if it is not,
         JMP_BUF_SIZE should be defined with the proper value.  It will
         also tend to be larger than necessary for most systems, a more
         optimal port will define JMP_BUF_SIZE.  */
-      tmp = build_int_cst (NULL_TREE,
-                          FIRST_PSEUDO_REGISTER + 2 - 1, 0);
+      tmp = build_int_cst (NULL_TREE, FIRST_PSEUDO_REGISTER + 2 - 1);
 #endif
 #else
       /* builtin_setjmp takes a pointer to 5 words.  */
-      tmp = build_int_cst (NULL_TREE,
-                          5 * BITS_PER_WORD / POINTER_SIZE - 1, 0);
+      tmp = build_int_cst (NULL_TREE, 5 * BITS_PER_WORD / POINTER_SIZE - 1);
 #endif
       tmp = build_index_type (tmp);
       tmp = build_array_type (ptr_type_node, tmp);
@@ -1416,7 +1414,7 @@ assign_filter_values (void)
              for (;tp_node; tp_node = TREE_CHAIN (tp_node))
                {
                  int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node));
-                 tree flt_node = build_int_cst (NULL_TREE, flt, 0);
+                 tree flt_node = build_int_cst (NULL_TREE, flt);
 
                  r->u.catch.filter_list
                    = tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
@@ -1427,7 +1425,7 @@ assign_filter_values (void)
              /* Get a filter value for the NULL list also since it will need
                 an action record anyway.  */
              int flt = add_ttypes_entry (ttypes, NULL);
-             tree flt_node = build_int_cst (NULL_TREE, flt, 0);
+             tree flt_node = build_int_cst (NULL_TREE, flt);
 
              r->u.catch.filter_list
                = tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
index dd79390..034e49a 100644 (file)
@@ -899,8 +899,7 @@ store_fixed_bit_field (rtx op0, unsigned HOST_WIDE_INT offset,
                              NULL_RTX, 1, OPTAB_LIB_WIDEN);
       if (bitpos > 0)
        value = expand_shift (LSHIFT_EXPR, mode, value,
-                             build_int_cst (NULL_TREE,
-                                            bitpos, 0), NULL_RTX, 1);
+                             build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
     }
 
   /* Now clear the chosen bits in OP0,
@@ -1329,13 +1328,11 @@ extract_bit_field (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
       /* Signed bit field: sign-extend with two arithmetic shifts.  */
       target = expand_shift (LSHIFT_EXPR, mode, target,
                             build_int_cst (NULL_TREE,
-                                           GET_MODE_BITSIZE (mode) - bitsize,
-                                           0),
+                                           GET_MODE_BITSIZE (mode) - bitsize),
                             NULL_RTX, 0);
       return expand_shift (RSHIFT_EXPR, mode, target,
                           build_int_cst (NULL_TREE,
-                                         GET_MODE_BITSIZE (mode) - bitsize,
-                                         0),
+                                         GET_MODE_BITSIZE (mode) - bitsize),
                           NULL_RTX, 0);
     }
 
@@ -1740,7 +1737,7 @@ extract_fixed_bit_field (enum machine_mode tmode, rtx op0,
        {
          /* If the field does not already start at the lsb,
             shift it so it does.  */
-         tree amount = build_int_cst (NULL_TREE, bitpos, 0);
+         tree amount = build_int_cst (NULL_TREE, bitpos);
          /* Maybe propagate the target for the shift.  */
          /* But not if we will return it--could confuse integrate.c.  */
          rtx subtarget = (target != 0 && REG_P (target) ? target : 0);
@@ -1781,7 +1778,7 @@ extract_fixed_bit_field (enum machine_mode tmode, rtx op0,
     {
       tree amount
        = build_int_cst (NULL_TREE,
-                        GET_MODE_BITSIZE (mode) - (bitsize + bitpos), 0);
+                        GET_MODE_BITSIZE (mode) - (bitsize + bitpos));
       /* Maybe propagate the target for the shift.  */
       rtx subtarget = (target != 0 && REG_P (target) ? target : 0);
       op0 = expand_shift (LSHIFT_EXPR, mode, op0, amount, subtarget, 1);
@@ -1789,7 +1786,7 @@ extract_fixed_bit_field (enum machine_mode tmode, rtx op0,
 
   return expand_shift (RSHIFT_EXPR, mode, op0,
                       build_int_cst (NULL_TREE,
-                                     GET_MODE_BITSIZE (mode) - bitsize, 0),
+                                     GET_MODE_BITSIZE (mode) - bitsize),
                       target, 0);
 }
 \f
@@ -1937,15 +1934,15 @@ extract_split_bit_field (rtx op0, unsigned HOST_WIDE_INT bitsize,
        {
          if (bitsize != bitsdone)
            part = expand_shift (LSHIFT_EXPR, word_mode, part,
-                                build_int_cst (NULL_TREE,
-                                               bitsize - bitsdone, 0), 0, 1);
+                                build_int_cst (NULL_TREE, bitsize - bitsdone),
+                                0, 1);
        }
       else
        {
          if (bitsdone != thissize)
            part = expand_shift (LSHIFT_EXPR, word_mode, part,
                                 build_int_cst (NULL_TREE,
-                                               bitsdone - thissize, 0), 0, 1);
+                                               bitsdone - thissize), 0, 1);
        }
 
       if (first)
@@ -1964,12 +1961,11 @@ extract_split_bit_field (rtx op0, unsigned HOST_WIDE_INT bitsize,
     return result;
   /* Signed bit field: sign-extend with two arithmetic shifts.  */
   result = expand_shift (LSHIFT_EXPR, word_mode, result,
-                        build_int_cst (NULL_TREE,
-                                       BITS_PER_WORD - bitsize, 0),
+                        build_int_cst (NULL_TREE, BITS_PER_WORD - bitsize),
                         NULL_RTX, 0);
   return expand_shift (RSHIFT_EXPR, word_mode, result,
-                      build_int_cst (NULL_TREE,
-                                     BITS_PER_WORD - bitsize, 0), NULL_RTX, 0);
+                      build_int_cst (NULL_TREE, BITS_PER_WORD - bitsize),
+                      NULL_RTX, 0);
 }
 \f
 /* Add INC into TARGET.  */
@@ -2088,7 +2084,7 @@ expand_shift (enum tree_code code, enum machine_mode mode, rtx shifted,
              tree other_amount
                = fold (build2 (MINUS_EXPR, type, convert
                                (type, build_int_cst
-                                (NULL_TREE, GET_MODE_BITSIZE (mode), 0)),
+                                (NULL_TREE, GET_MODE_BITSIZE (mode))),
                                amount));
 
              shifted = force_reg (mode, shifted);
@@ -2558,14 +2554,14 @@ expand_mult_const (enum machine_mode mode, rtx op0, HOST_WIDE_INT val,
        {
        case alg_shift:
          accum = expand_shift (LSHIFT_EXPR, mode, accum,
-                               build_int_cst (NULL_TREE, log, 0),
+                               build_int_cst (NULL_TREE, log),
                                NULL_RTX, 0);
          val_so_far <<= log;
          break;
 
        case alg_add_t_m2:
          tem = expand_shift (LSHIFT_EXPR, mode, op0,
-                             build_int_cst (NULL_TREE, log, 0),
+                             build_int_cst (NULL_TREE, log),
                              NULL_RTX, 0);
          accum = force_operand (gen_rtx_PLUS (mode, accum, tem),
                                 add_target ? add_target : accum_target);
@@ -2574,7 +2570,7 @@ expand_mult_const (enum machine_mode mode, rtx op0, HOST_WIDE_INT val,
 
        case alg_sub_t_m2:
          tem = expand_shift (LSHIFT_EXPR, mode, op0,
-                             build_int_cst (NULL_TREE, log, 0),
+                             build_int_cst (NULL_TREE, log),
                              NULL_RTX, 0);
          accum = force_operand (gen_rtx_MINUS (mode, accum, tem),
                                 add_target ? add_target : accum_target);
@@ -2583,7 +2579,7 @@ expand_mult_const (enum machine_mode mode, rtx op0, HOST_WIDE_INT val,
 
        case alg_add_t2_m:
          accum = expand_shift (LSHIFT_EXPR, mode, accum,
-                               build_int_cst (NULL_TREE, log, 0),
+                               build_int_cst (NULL_TREE, log),
                                shift_subtarget,
                                0);
          accum = force_operand (gen_rtx_PLUS (mode, accum, op0),
@@ -2593,7 +2589,7 @@ expand_mult_const (enum machine_mode mode, rtx op0, HOST_WIDE_INT val,
 
        case alg_sub_t2_m:
          accum = expand_shift (LSHIFT_EXPR, mode, accum,
-                               build_int_cst (NULL_TREE, log, 0),
+                               build_int_cst (NULL_TREE, log),
                                shift_subtarget, 0);
          accum = force_operand (gen_rtx_MINUS (mode, accum, op0),
                                 add_target ? add_target : accum_target);
@@ -2602,7 +2598,7 @@ expand_mult_const (enum machine_mode mode, rtx op0, HOST_WIDE_INT val,
 
        case alg_add_factor:
          tem = expand_shift (LSHIFT_EXPR, mode, accum,
-                             build_int_cst (NULL_TREE, log, 0),
+                             build_int_cst (NULL_TREE, log),
                              NULL_RTX, 0);
          accum = force_operand (gen_rtx_PLUS (mode, accum, tem),
                                 add_target ? add_target : accum_target);
@@ -2611,7 +2607,7 @@ expand_mult_const (enum machine_mode mode, rtx op0, HOST_WIDE_INT val,
 
        case alg_sub_factor:
          tem = expand_shift (LSHIFT_EXPR, mode, accum,
-                             build_int_cst (NULL_TREE, log, 0),
+                             build_int_cst (NULL_TREE, log),
                              NULL_RTX, 0);
          accum = force_operand (gen_rtx_MINUS (mode, tem, accum),
                                 (add_target
@@ -2907,8 +2903,7 @@ expand_mult_highpart_adjust (enum machine_mode mode, rtx adj_operand, rtx op0,
   enum rtx_code adj_code = unsignedp ? PLUS : MINUS;
 
   tem = expand_shift (RSHIFT_EXPR, mode, op0,
-                     build_int_cst (NULL_TREE,
-                                    GET_MODE_BITSIZE (mode) - 1, 0),
+                     build_int_cst (NULL_TREE, GET_MODE_BITSIZE (mode) - 1),
                      NULL_RTX, 0);
   tem = expand_and (mode, tem, op1, NULL_RTX);
   adj_operand
@@ -2916,8 +2911,7 @@ expand_mult_highpart_adjust (enum machine_mode mode, rtx adj_operand, rtx op0,
                     adj_operand);
 
   tem = expand_shift (RSHIFT_EXPR, mode, op1,
-                     build_int_cst (NULL_TREE,
-                                    GET_MODE_BITSIZE (mode) - 1, 0),
+                     build_int_cst (NULL_TREE, GET_MODE_BITSIZE (mode) - 1),
                      NULL_RTX, 0);
   tem = expand_and (mode, tem, op0, NULL_RTX);
   target = force_operand (gen_rtx_fmt_ee (adj_code, mode, adj_operand, tem),
@@ -2938,8 +2932,7 @@ extract_high_half (enum machine_mode mode, rtx op)
 
   wider_mode = GET_MODE_WIDER_MODE (mode);
   op = expand_shift (RSHIFT_EXPR, wider_mode, op,
-                    build_int_cst (NULL_TREE,
-                                   GET_MODE_BITSIZE (mode), 0), 0, 1);
+                    build_int_cst (NULL_TREE, GET_MODE_BITSIZE (mode)), 0, 1);
   return convert_modes (mode, wider_mode, op, 0);
 }
 
@@ -3202,7 +3195,7 @@ expand_sdiv_pow2 (enum machine_mode mode, rtx op0, HOST_WIDE_INT d)
   int logd;
 
   logd = floor_log2 (d);
-  shift = build_int_cst (NULL_TREE, logd, 0);
+  shift = build_int_cst (NULL_TREE, logd);
 
   if (d == 2 && BRANCH_COST >= 1)
     {
@@ -3249,7 +3242,7 @@ expand_sdiv_pow2 (enum machine_mode mode, rtx op0, HOST_WIDE_INT d)
                             NULL_RTX, 0, OPTAB_LIB_WIDEN);
       else
        temp = expand_shift (RSHIFT_EXPR, mode, temp,
-                            build_int_cst (NULL_TREE, ushift, 0),
+                            build_int_cst (NULL_TREE, ushift),
                             NULL_RTX, 1);
       temp = expand_binop (mode, add_optab, temp, op0, NULL_RTX,
                           0, OPTAB_LIB_WIDEN);
@@ -3527,7 +3520,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
                      }
                    quotient = expand_shift (RSHIFT_EXPR, compute_mode, op0,
                                             build_int_cst (NULL_TREE,
-                                                           pre_shift, 0),
+                                                           pre_shift),
                                             tquotient, 1);
                  }
                else if (size <= HOST_BITS_PER_WIDE_INT)
@@ -3585,15 +3578,14 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
                                                NULL_RTX);
                            t3 = expand_shift
                              (RSHIFT_EXPR, compute_mode, t2,
-                              build_int_cst (NULL_TREE, 1, 0),
+                              build_int_cst (NULL_TREE, 1),
                               NULL_RTX,1);
                            t4 = force_operand (gen_rtx_PLUS (compute_mode,
                                                              t1, t3),
                                                NULL_RTX);
                            quotient = expand_shift
                              (RSHIFT_EXPR, compute_mode, t4,
-                              build_int_cst (NULL_TREE,
-                                             post_shift - 1, 0),
+                              build_int_cst (NULL_TREE, post_shift - 1),
                               tquotient, 1);
                          }
                        else
@@ -3606,7 +3598,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
 
                            t1 = expand_shift
                              (RSHIFT_EXPR, compute_mode, op0,
-                              build_int_cst (NULL_TREE, pre_shift, 0),
+                              build_int_cst (NULL_TREE, pre_shift),
                               NULL_RTX, 1);
                            extra_cost
                              = (shift_cost[compute_mode][pre_shift]
@@ -3618,8 +3610,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
                              goto fail1;
                            quotient = expand_shift
                              (RSHIFT_EXPR, compute_mode, t2,
-                              build_int_cst (NULL_TREE,
-                                             post_shift, 0),
+                              build_int_cst (NULL_TREE, post_shift),
                               tquotient, 1);
                          }
                      }
@@ -3728,11 +3719,11 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
                          goto fail1;
                        t2 = expand_shift
                          (RSHIFT_EXPR, compute_mode, t1,
-                          build_int_cst (NULL_TREE, post_shift, 0),
+                          build_int_cst (NULL_TREE, post_shift),
                           NULL_RTX, 0);
                        t3 = expand_shift
                          (RSHIFT_EXPR, compute_mode, op0,
-                          build_int_cst (NULL_TREE, size - 1, 0),
+                          build_int_cst (NULL_TREE, size - 1),
                           NULL_RTX, 0);
                        if (d < 0)
                          quotient
@@ -3767,11 +3758,11 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
                                            NULL_RTX);
                        t3 = expand_shift
                          (RSHIFT_EXPR, compute_mode, t2,
-                          build_int_cst (NULL_TREE, post_shift, 0),
+                          build_int_cst (NULL_TREE, post_shift),
                           NULL_RTX, 0);
                        t4 = expand_shift
                          (RSHIFT_EXPR, compute_mode, op0,
-                          build_int_cst (NULL_TREE, size - 1, 0),
+                          build_int_cst (NULL_TREE, size - 1),
                           NULL_RTX, 0);
                        if (d < 0)
                          quotient
@@ -3828,7 +3819,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
                      }
                    quotient = expand_shift
                      (RSHIFT_EXPR, compute_mode, op0,
-                      build_int_cst (NULL_TREE, pre_shift, 0),
+                      build_int_cst (NULL_TREE, pre_shift),
                       tquotient, 0);
                  }
                else
@@ -3845,7 +3836,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
                      {
                        t1 = expand_shift
                          (RSHIFT_EXPR, compute_mode, op0,
-                          build_int_cst (NULL_TREE, size - 1, 0),
+                          build_int_cst (NULL_TREE, size - 1),
                           NULL_RTX, 0);
                        t2 = expand_binop (compute_mode, xor_optab, op0, t1,
                                           NULL_RTX, 0, OPTAB_WIDEN);
@@ -3859,7 +3850,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
                          {
                            t4 = expand_shift
                              (RSHIFT_EXPR, compute_mode, t3,
-                              build_int_cst (NULL_TREE, post_shift, 0),
+                              build_int_cst (NULL_TREE, post_shift),
                               NULL_RTX, 1);
                            quotient = expand_binop (compute_mode, xor_optab,
                                                     t4, t1, tquotient, 0,
@@ -3877,7 +3868,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
                                   0, OPTAB_WIDEN);
                nsign = expand_shift
                  (RSHIFT_EXPR, compute_mode, t2,
-                  build_int_cst (NULL_TREE, size - 1, 0),
+                  build_int_cst (NULL_TREE, size - 1),
                   NULL_RTX, 0);
                t3 = force_operand (gen_rtx_MINUS (compute_mode, t1, nsign),
                                    NULL_RTX);
@@ -3992,8 +3983,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
                rtx t1, t2, t3;
                unsigned HOST_WIDE_INT d = INTVAL (op1);
                t1 = expand_shift (RSHIFT_EXPR, compute_mode, op0,
-                                  build_int_cst (NULL_TREE,
-                                                 floor_log2 (d), 0),
+                                  build_int_cst (NULL_TREE, floor_log2 (d)),
                                   tquotient, 1);
                t2 = expand_binop (compute_mode, and_optab, op0,
                                   GEN_INT (d - 1),
@@ -4091,8 +4081,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
                rtx t1, t2, t3;
                unsigned HOST_WIDE_INT d = INTVAL (op1);
                t1 = expand_shift (RSHIFT_EXPR, compute_mode, op0,
-                                  build_int_cst (NULL_TREE,
-                                                 floor_log2 (d), 0),
+                                  build_int_cst (NULL_TREE, floor_log2 (d)),
                                   tquotient, 0);
                t2 = expand_binop (compute_mode, and_optab, op0,
                                   GEN_INT (d - 1),
@@ -4214,7 +4203,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
            pre_shift = floor_log2 (d & -d);
            ml = invert_mod2n (d >> pre_shift, size);
            t1 = expand_shift (RSHIFT_EXPR, compute_mode, op0,
-                              build_int_cst (NULL_TREE, pre_shift, 0),
+                              build_int_cst (NULL_TREE, pre_shift),
                               NULL_RTX, unsignedp);
            quotient = expand_mult (compute_mode, t1,
                                    gen_int_mode (ml, compute_mode),
@@ -4249,7 +4238,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
              }
            tem = plus_constant (op1, -1);
            tem = expand_shift (RSHIFT_EXPR, compute_mode, tem,
-                               build_int_cst (NULL_TREE, 1, 0),
+                               build_int_cst (NULL_TREE, 1),
                                NULL_RTX, 1);
            do_cmp_and_jump (remainder, tem, LEU, compute_mode, label);
            expand_inc (quotient, const1_rtx);
@@ -4275,13 +4264,13 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
            abs_rem = expand_abs (compute_mode, remainder, NULL_RTX, 1, 0);
            abs_op1 = expand_abs (compute_mode, op1, NULL_RTX, 1, 0);
            tem = expand_shift (LSHIFT_EXPR, compute_mode, abs_rem,
-                               build_int_cst (NULL_TREE, 1, 0),
+                               build_int_cst (NULL_TREE, 1),
                                NULL_RTX, 1);
            do_cmp_and_jump (tem, abs_op1, LTU, compute_mode, label);
            tem = expand_binop (compute_mode, xor_optab, op0, op1,
                                NULL_RTX, 0, OPTAB_WIDEN);
            mask = expand_shift (RSHIFT_EXPR, compute_mode, tem,
-                                build_int_cst (NULL_TREE, size - 1, 0),
+                                build_int_cst (NULL_TREE, size - 1),
                                 NULL_RTX, 0);
            tem = expand_binop (compute_mode, xor_optab, mask, const1_rtx,
                                NULL_RTX, 0, OPTAB_WIDEN);
@@ -4434,14 +4423,15 @@ make_tree (tree type, rtx x)
                     < HOST_BITS_PER_WIDE_INT)))
          hi = -1;
       
-       t = build_int_cst (type, INTVAL (x), hi);
+       t = build_int_cst_wide (type, INTVAL (x), hi);
        
        return t;
       }
       
     case CONST_DOUBLE:
       if (GET_MODE (x) == VOIDmode)
-       t = build_int_cst (type, CONST_DOUBLE_LOW (x), CONST_DOUBLE_HIGH (x));
+       t = build_int_cst_wide (type,
+                               CONST_DOUBLE_LOW (x), CONST_DOUBLE_HIGH (x));
       else
        {
          REAL_VALUE_TYPE d;
index 72ba4cd..b989864 100644 (file)
@@ -648,7 +648,7 @@ convert_move (rtx to, rtx from, int unsignedp)
             Generate what we need with shifts.  */
          shift_amount = build_int_cst (NULL_TREE,
                                        GET_MODE_BITSIZE (to_mode)
-                                       - GET_MODE_BITSIZE (from_mode), 0);
+                                       - GET_MODE_BITSIZE (from_mode));
          from = gen_lowpart (to_mode, force_reg (from_mode, from));
          tmp = expand_shift (LSHIFT_EXPR, to_mode, from, shift_amount,
                              to, unsignedp);
@@ -1703,8 +1703,7 @@ emit_group_load (rtx dst, rtx orig_src, tree type ATTRIBUTE_UNUSED, int ssize)
 
       if (shift)
        tmps[i] = expand_shift (LSHIFT_EXPR, mode, tmps[i],
-                               build_int_cst (NULL_TREE,
-                                              shift, 0), tmps[i], 0);
+                               build_int_cst (NULL_TREE, shift), tmps[i], 0);
     }
 
   /* Copy the extracted pieces into the proper (probable) hard regs.  */
@@ -1815,8 +1814,8 @@ emit_group_store (rtx orig_dst, rtx src, tree type ATTRIBUTE_UNUSED, int ssize)
            {
              int shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
              tmps[i] = expand_shift (RSHIFT_EXPR, mode, tmps[i],
-                                     build_int_cst (NULL_TREE,
-                                                    shift, 0), tmps[i], 0);
+                                     build_int_cst (NULL_TREE, shift),
+                                     tmps[i], 0);
            }
          bytelen = ssize - bytepos;
        }
@@ -3642,7 +3641,7 @@ expand_assignment (tree to, tree from, int want_value)
                  binop = xor_optab;
                }
              value = expand_shift (LSHIFT_EXPR, GET_MODE (str_rtx), value,
-                                   build_int_cst (NULL_TREE,bitpos1, 0),
+                                   build_int_cst (NULL_TREE, bitpos1),
                                    NULL_RTX, 1);
              result = expand_binop (GET_MODE (str_rtx), binop, str_rtx,
                                     value, str_rtx, 1, OPTAB_WIDEN);
@@ -4538,7 +4537,7 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size)
                value
                  = fold (build2 (LSHIFT_EXPR, type, value,
                                  build_int_cst (NULL_TREE,
-                                                BITS_PER_WORD - bitsize, 0)));
+                                                BITS_PER_WORD - bitsize)));
              bitsize = BITS_PER_WORD;
              mode = word_mode;
            }
@@ -5274,7 +5273,7 @@ store_field (rtx target, HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos,
                                   NULL_RTX);
 
              count = build_int_cst (NULL_TREE,
-                                    GET_MODE_BITSIZE (tmode) - bitsize, 0);
+                                    GET_MODE_BITSIZE (tmode) - bitsize);
              temp = expand_shift (LSHIFT_EXPR, tmode, temp, count, 0, 0);
              return expand_shift (RSHIFT_EXPR, tmode, temp, count, 0, 0);
            }
@@ -6767,8 +6766,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
                      {
                        tree count
                          = build_int_cst (NULL_TREE,
-                                          GET_MODE_BITSIZE (imode) - bitsize,
-                                          0);
+                                          GET_MODE_BITSIZE (imode) - bitsize);
 
                        op0 = expand_shift (LSHIFT_EXPR, imode, op0, count,
                                            target, 0);
@@ -8234,7 +8232,7 @@ reduce_to_bit_field_precision (rtx exp, rtx target, tree type)
   else
     {
       tree count = build_int_cst (NULL_TREE,
-                                 GET_MODE_BITSIZE (GET_MODE (exp)) - prec, 0);
+                                 GET_MODE_BITSIZE (GET_MODE (exp)) - prec);
       exp = expand_shift (LSHIFT_EXPR, GET_MODE (exp), exp, count, target, 0);
       return expand_shift (RSHIFT_EXPR, GET_MODE (exp), exp, count, target, 0);
     }
index ed6ae0f..1c8c401 100644 (file)
@@ -268,7 +268,7 @@ force_fit_type (tree t, int overflowable,
   if (overflowed || overflowed_const
       || low != TREE_INT_CST_LOW (t) || high != TREE_INT_CST_HIGH (t))
     {
-      t = build_int_cst (TREE_TYPE (t), low, high);
+      t = build_int_cst_wide (TREE_TYPE (t), low, high);
       
       if (overflowed
          || overflowable < 0
@@ -1430,7 +1430,7 @@ int_const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
       abort ();
     }
 
-  t = build_int_cst (TREE_TYPE (arg1), low, hi);
+  t = build_int_cst_wide (TREE_TYPE (arg1), low, hi);
 
   if (notrunc)
     {
@@ -1793,8 +1793,8 @@ fold_convert_const (enum tree_code code, tree type, tree arg1)
 
          /* Given an integer constant, make new constant with new type,
             appropriately sign-extended or truncated.  */
-         t = build_int_cst (type, TREE_INT_CST_LOW (arg1),
-                            TREE_INT_CST_HIGH (arg1));
+         t = build_int_cst_wide (type, TREE_INT_CST_LOW (arg1),
+                                 TREE_INT_CST_HIGH (arg1));
 
          t = force_fit_type (t,
                              /* Don't set the overflow when
@@ -1885,7 +1885,7 @@ fold_convert_const (enum tree_code code, tree type, tree arg1)
          if (! overflow)
            REAL_VALUE_TO_INT (&low, &high, r);
 
-         t = build_int_cst (type, low, high);
+         t = build_int_cst_wide (type, low, high);
 
          t = force_fit_type (t, -1, overflow | TREE_OVERFLOW (arg1),
                              TREE_CONSTANT_OVERFLOW (arg1));
@@ -2960,7 +2960,7 @@ invert_truthvalue (tree arg)
     {
     case INTEGER_CST:
       return fold_convert (type,
-                          build_int_cst (NULL_TREE, integer_zerop (arg), 0));
+                          build_int_cst (NULL_TREE, integer_zerop (arg)));
 
     case TRUTH_AND_EXPR:
       return build2 (TRUTH_OR_EXPR, type,
@@ -3195,7 +3195,7 @@ optimize_bit_field_compare (enum tree_code code, tree compare_type,
     lbitpos = nbitsize - lbitsize - lbitpos;
 
   /* Make the mask to be used against the extracted field.  */
-  mask = build_int_cst (unsigned_type, ~0, ~0);
+  mask = build_int_cst (unsigned_type, -1);
   mask = force_fit_type (mask, 0, false, false);
   mask = fold_convert (unsigned_type, mask);
   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
@@ -3351,7 +3351,7 @@ decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
   unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
   precision = TYPE_PRECISION (unsigned_type);
 
-  mask = build_int_cst (unsigned_type, ~0, ~0);
+  mask = build_int_cst (unsigned_type, -1);
   mask = force_fit_type (mask, 0, false, false);
   
   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
@@ -3377,7 +3377,7 @@ all_ones_mask_p (tree mask, int size)
   unsigned int precision = TYPE_PRECISION (type);
   tree tmask;
 
-  tmask = build_int_cst (lang_hooks.types.signed_type (type), ~0, ~0);
+  tmask = build_int_cst (lang_hooks.types.signed_type (type), -1);
   tmask = force_fit_type (tmask, 0, false, false);
   
   return
@@ -5365,7 +5365,7 @@ constant_boolean_node (int value, tree type)
     return lang_hooks.truthvalue_conversion (value ? integer_one_node
                                                   : integer_zero_node);
   else
-    return build_int_cst (type, value, 0);
+    return build_int_cst (type, value);
 }
 
 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
@@ -5698,7 +5698,7 @@ fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
                         TREE_INT_CST_HIGH (arg01),
                         TREE_INT_CST_LOW (arg1),
                         TREE_INT_CST_HIGH (arg1), &lpart, &hpart);
-  prod = build_int_cst (TREE_TYPE (arg00), lpart, hpart);
+  prod = build_int_cst_wide (TREE_TYPE (arg00), lpart, hpart);
   prod = force_fit_type (prod, -1, overflow, false);
 
   if (TYPE_UNSIGNED (TREE_TYPE (arg0)))
@@ -5712,7 +5712,7 @@ fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
                             TREE_INT_CST_LOW (tmp),
                             TREE_INT_CST_HIGH (tmp),
                             &lpart, &hpart);
-      hi = build_int_cst (TREE_TYPE (arg00), lpart, hpart);
+      hi = build_int_cst_wide (TREE_TYPE (arg00), lpart, hpart);
       hi = force_fit_type (hi, -1, overflow | TREE_OVERFLOW (prod),
                           TREE_CONSTANT_OVERFLOW (prod));
     }
@@ -6620,7 +6620,7 @@ fold (tree expr)
                    {
                      alt0 = fold (build2 (MULT_EXPR, type, arg00,
                                           build_int_cst (NULL_TREE,
-                                                         int01 / int11, 0)));
+                                                         int01 / int11)));
                      alt1 = arg10;
                      same = arg11;
                    }
@@ -7254,7 +7254,7 @@ fold (tree expr)
       if (TREE_CODE (arg0) == BIT_NOT_EXPR
          && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
        {
-         t1 = build_int_cst (type, -1, -1);
+         t1 = build_int_cst (type, -1);
          t1 = force_fit_type (t1, 0, false, false);
          return omit_one_operand (type, t1, arg1);
        }
@@ -7263,7 +7263,7 @@ fold (tree expr)
       if (TREE_CODE (arg1) == BIT_NOT_EXPR
          && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
        {
-         t1 = build_int_cst (type, -1, -1);
+         t1 = build_int_cst (type, -1);
          t1 = force_fit_type (t1, 0, false, false);
          return omit_one_operand (type, t1, arg0);
        }
@@ -7303,7 +7303,7 @@ fold (tree expr)
       if (TREE_CODE (arg0) == BIT_NOT_EXPR
          && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
        {
-         t1 = build_int_cst (type, -1, -1);
+         t1 = build_int_cst (type, -1);
          t1 = force_fit_type (t1, 0, false, false);
          return omit_one_operand (type, t1, arg1);
        }
@@ -7312,7 +7312,7 @@ fold (tree expr)
       if (TREE_CODE (arg1) == BIT_NOT_EXPR
          && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
        {
-         t1 = build_int_cst (type, -1, -1);
+         t1 = build_int_cst (type, -1);
          t1 = force_fit_type (t1, 0, false, false);
          return omit_one_operand (type, t1, arg0);
        }
@@ -7632,7 +7632,7 @@ fold (tree expr)
              low = ((unsigned HOST_WIDE_INT) 1 << l) - 1;
            }
 
-         mask = build_int_cst (type, low, high);
+         mask = build_int_cst_wide (type, low, high);
          return fold (build2 (BIT_AND_EXPR, type,
                               fold_convert (type, arg0), mask));
        }
@@ -7691,7 +7691,7 @@ fold (tree expr)
       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
        {
          tree tem = build_int_cst (NULL_TREE,
-                                   GET_MODE_BITSIZE (TYPE_MODE (type)), 0);
+                                   GET_MODE_BITSIZE (TYPE_MODE (type)));
          tem = fold_convert (TREE_TYPE (arg1), tem);
          tem = const_binop (MINUS_EXPR, tem, arg1, 0);
          return fold (build2 (RROTATE_EXPR, type, arg0, tem));
@@ -8109,8 +8109,7 @@ fold (tree expr)
                return omit_one_operand (type, folded_compare, varop);
 
              shift = build_int_cst (NULL_TREE,
-                                    TYPE_PRECISION (TREE_TYPE (varop)) - size,
-                                    0);
+                                    TYPE_PRECISION (TREE_TYPE (varop)) - size);
              shift = fold_convert (TREE_TYPE (varop), shift);
              newconst = fold (build2 (LSHIFT_EXPR, TREE_TYPE (varop),
                                       newconst, shift));
@@ -10292,7 +10291,7 @@ fold_read_from_constant_string (tree exp)
        return fold_convert (TREE_TYPE (exp),
                             build_int_cst (NULL_TREE,
                                            (TREE_STRING_POINTER (string)
-                                            [TREE_INT_CST_LOW (index)]), 0));
+                                            [TREE_INT_CST_LOW (index)])));
     }
   return NULL;
 }
@@ -10314,7 +10313,7 @@ fold_negate_const (tree arg0, tree type)
       int overflow = neg_double (TREE_INT_CST_LOW (arg0),
                                 TREE_INT_CST_HIGH (arg0),
                                 &low, &high);
-      t = build_int_cst (type, low, high);
+      t = build_int_cst_wide (type, low, high);
       t = force_fit_type (t, 1,
                          (overflow | TREE_OVERFLOW (arg0))
                          && !TYPE_UNSIGNED (type),
@@ -10358,7 +10357,7 @@ fold_abs_const (tree arg0, tree type)
          int overflow = neg_double (TREE_INT_CST_LOW (arg0),
                                     TREE_INT_CST_HIGH (arg0),
                                     &low, &high);
-         t = build_int_cst (type, low, high);
+         t = build_int_cst_wide (type, low, high);
          t = force_fit_type (t, -1, overflow | TREE_OVERFLOW (arg0),
                              TREE_CONSTANT_OVERFLOW (arg0));
          return t;
@@ -10389,9 +10388,9 @@ fold_not_const (tree arg0, tree type)
 
   if (TREE_CODE (arg0) == INTEGER_CST)
     {
-      t = build_int_cst (type,
-                        ~ TREE_INT_CST_LOW (arg0),
-                        ~ TREE_INT_CST_HIGH (arg0));
+      t = build_int_cst_wide (type,
+                             ~ TREE_INT_CST_LOW (arg0),
+                             ~ TREE_INT_CST_HIGH (arg0));
       t = force_fit_type (t, 0, TREE_OVERFLOW (arg0),
                          TREE_CONSTANT_OVERFLOW (arg0));
     }
@@ -10661,9 +10660,9 @@ round_up (tree value, int divisor)
     {
       tree t;
       
-      t = build_int_cst (TREE_TYPE (value), divisor - 1, 0);
+      t = build_int_cst (TREE_TYPE (value), divisor - 1);
       value = size_binop (PLUS_EXPR, value, t);
-      t = build_int_cst (TREE_TYPE (value), -divisor, -1);
+      t = build_int_cst (TREE_TYPE (value), -divisor);
       value = size_binop (BIT_AND_EXPR, value, t);
     }
   else
@@ -10708,7 +10707,7 @@ round_down (tree value, int divisor)
     {
       tree t;
       
-      t = build_int_cst (TREE_TYPE (value), -divisor, -1);
+      t = build_int_cst (TREE_TYPE (value), -divisor);
       value = size_binop (BIT_AND_EXPR, value, t);
     }
   else
index d4d9d00..0d2f8b6 100644 (file)
@@ -1,3 +1,20 @@
+2004-08-25  Nathan Sidwell  <nathan@codesourcery.com>
+
+       * trans-array.c (gfc_trans_array_constructor_value): Adjust
+       build_int_cst calls.
+       * 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, build_entry_thunks,
+       gfc_trans_entry_master_switch): Likewise.
+       * trans-intrinsic.c (gfc_conv_intrinsic_ibits,
+       gfc_conv_intrinsic_len, prepare_arg_info): Likewise.
+       * trans-io.c (add_case, set_error_locus,
+       transfer_namelist_element, 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.
+
 2004-08-24  Tobias Schlueter  <tobias.schlueter@physik.uni-muenchen.de>
 
        * trans-decl.c, trans-types.c: Add and remove blank lines as 
@@ -22,7 +39,7 @@
 
 2004-08-24  Nathan Sidwell  <nathan@codesourcery.com>
 
-       * fortran/f95-lang.c (gfc_init_decl_processing): Adjust
+       * f95-lang.c (gfc_init_decl_processing): Adjust
        build_common_tree_nodes call.
 
 2004-08-24  Tobias Schlueter  <tobias.schlueter@physik.uni-muenchen.de>
index e6c4600..f79ab1e 100644 (file)
@@ -796,7 +796,7 @@ gfc_trans_array_constructor_value (stmtblock_t * pblock, tree type,
                  p = p->next;
                }
 
-             bound = build_int_cst (NULL_TREE, n - 1, 0);
+             bound = build_int_cst (NULL_TREE, n - 1);
               /* Create an array type to hold them.  */
              tmptype = build_range_type (gfc_array_index_type,
                                          gfc_index_zero_node, bound);
@@ -821,7 +821,7 @@ gfc_trans_array_constructor_value (stmtblock_t * pblock, tree type,
              init = gfc_build_addr_expr (NULL, init);
 
              size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (type));
-             bound = build_int_cst (NULL_TREE, n * size, 0);
+             bound = build_int_cst (NULL_TREE, n * size);
              tmp = gfc_chainon_list (NULL_TREE, tmp);
              tmp = gfc_chainon_list (tmp, init);
              tmp = gfc_chainon_list (tmp, bound);
index 110c0db..2f485a7 100644 (file)
@@ -82,7 +82,7 @@ gfc_build_string_const (int length, const char *s)
   tree len;
 
   str = build_string (length, s);
-  len = build_int_cst (NULL_TREE, length, 0);
+  len = build_int_cst (NULL_TREE, length);
   TREE_TYPE (str) =
     build_array_type (gfc_character1_type_node,
                      build_range_type (gfc_strlen_type_node,
@@ -146,7 +146,7 @@ gfc_init_constants (void)
   int n;
 
   for (n = 0; n <= GFC_MAX_DIMENSIONS; n++)
-    gfc_rank_cst[n] = build_int_cst (gfc_array_index_type, n, 0);
+    gfc_rank_cst[n] = build_int_cst (gfc_array_index_type, n);
 
   gfc_strconst_bounds = gfc_build_string_const (21, "Array bound mismatch");
 
@@ -315,7 +315,7 @@ gfc_conv_constant_to_tree (gfc_expr * expr)
       return gfc_conv_mpfr_to_tree (expr->value.real, expr->ts.kind);
 
     case BT_LOGICAL:
-      return build_int_cst (NULL_TREE, expr->value.logical, 0);
+      return build_int_cst (NULL_TREE, expr->value.logical);
 
     case BT_COMPLEX:
       {
index 76618b2..7188905 100644 (file)
@@ -790,7 +790,7 @@ gfc_get_symbol_decl (gfc_symbol * sym)
           ASSIGN_ADDR can not be used. Equal -1 means that ASSIGN_ADDR is the
           target label's address. Other value is the length of format string
           and ASSIGN_ADDR is the address of format string.  */
-      DECL_INITIAL (length) = build_int_cst (NULL_TREE, -2, -1);
+      DECL_INITIAL (length) = build_int_cst (NULL_TREE, -2);
     }
 
   if (sym->ts.type == BT_CHARACTER)
@@ -1346,7 +1346,7 @@ build_entry_thunks (gfc_namespace * ns)
       gfc_start_block (&body);
 
       /* Pass extra parameter identifying this entry point.  */
-      tmp = build_int_cst (gfc_array_index_type, el->id, 0);
+      tmp = build_int_cst (gfc_array_index_type, el->id);
       args = tree_cons (NULL_TREE, tmp, NULL_TREE);
       string_args = NULL_TREE;
 
@@ -2113,7 +2113,7 @@ gfc_trans_entry_master_switch (gfc_entry_list * el)
       /* Add the case label.  */
       label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
       DECL_CONTEXT (label) = current_function_decl;
-      val = build_int_cst (gfc_array_index_type, el->id, 0);
+      val = build_int_cst (gfc_array_index_type, el->id);
       tmp = build_v (CASE_LABEL_EXPR, val, NULL_TREE, label);
       gfc_add_expr_to_block (&block, tmp);
       
index 1a8a8b6..cfe3051 100644 (file)
@@ -1760,7 +1760,7 @@ gfc_conv_intrinsic_ibits (gfc_se * se, gfc_expr * expr)
   arg2 = TREE_VALUE (arg2);
   type = TREE_TYPE (arg);
 
-  mask = build_int_cst (NULL_TREE, -1, ~(unsigned HOST_WIDE_INT) 0);
+  mask = build_int_cst (NULL_TREE, -1);
   mask = build (LSHIFT_EXPR, type, mask, arg3);
   mask = build1 (BIT_NOT_EXPR, type, mask);
 
@@ -1884,7 +1884,7 @@ gfc_conv_intrinsic_len (gfc_se * se, gfc_expr * expr)
   switch (arg->expr_type)
     {
     case EXPR_CONSTANT:
-      len = build_int_cst (NULL_TREE, arg->value.character.length, 0);
+      len = build_int_cst (NULL_TREE, arg->value.character.length);
       break;
 
     default:
@@ -2329,9 +2329,9 @@ void prepare_arg_info (gfc_se * se, gfc_expr * expr,
 
    /* Caculate the numbers of bits of exponent, fraction and word  */
    n = gfc_validate_kind (a1->ts.type, a1->ts.kind);
-   tmp = build_int_cst (NULL_TREE, gfc_real_kinds[n].digits - 1, 0);
+   tmp = build_int_cst (NULL_TREE, gfc_real_kinds[n].digits - 1);
    rcs->fdigits = convert (masktype, tmp);
-   wbits = build_int_cst (NULL_TREE, TYPE_PRECISION (rcs->type) - 1, 0);
+   wbits = build_int_cst (NULL_TREE, TYPE_PRECISION (rcs->type) - 1);
    wbits = convert (masktype, wbits);
    rcs->edigits = fold (build (MINUS_EXPR, masktype, wbits, tmp));
 
index 63d5618..3d04332 100644 (file)
@@ -451,7 +451,7 @@ add_case (int label_value, gfc_st_label * label, stmtblock_t * body)
   if (label == NULL)
     return;                    /* No label, no case */
 
-  value = build_int_cst (NULL_TREE, label_value, 0);
+  value = build_int_cst (NULL_TREE, label_value);
 
   /* Make a backend label for this case.  */
   tmp = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
@@ -524,7 +524,7 @@ set_error_locus (stmtblock_t * block, locus * where)
   gfc_add_modify_expr (block, locus_file, tmp);
 
   line = where->lb->linenum;
-  gfc_add_modify_expr (block, locus_line, build_int_cst (NULL_TREE, line, 0));
+  gfc_add_modify_expr (block, locus_line, build_int_cst (NULL_TREE, line));
 }
 
 
@@ -896,7 +896,7 @@ transfer_namelist_element (stmtblock_t * block, gfc_typespec * ts, tree addr_exp
   args = gfc_chainon_list (NULL_TREE, addr_expr);
   args = gfc_chainon_list (args, string);
   args = gfc_chainon_list (args, string_length);
-  arg2 = build_int_cst (gfc_array_index_type, ts->kind, 0);
+  arg2 = build_int_cst (gfc_array_index_type, ts->kind);
   args = gfc_chainon_list (args,arg2);
 
   switch (ts->type)
@@ -1152,22 +1152,22 @@ transfer_expr (gfc_se * se, gfc_typespec * ts, tree addr_expr)
   switch (ts->type)
     {
     case BT_INTEGER:
-      arg2 = build_int_cst (NULL_TREE, kind, 0);
+      arg2 = build_int_cst (NULL_TREE, kind);
       function = iocall_x_integer;
       break;
 
     case BT_REAL:
-      arg2 = build_int_cst (NULL_TREE, kind, 0);
+      arg2 = build_int_cst (NULL_TREE, kind);
       function = iocall_x_real;
       break;
 
     case BT_COMPLEX:
-      arg2 = build_int_cst (NULL_TREE, kind, 0);
+      arg2 = build_int_cst (NULL_TREE, kind);
       function = iocall_x_complex;
       break;
 
     case BT_LOGICAL:
-      arg2 = build_int_cst (NULL_TREE, kind, 0);
+      arg2 = build_int_cst (NULL_TREE, kind);
       function = iocall_x_logical;
       break;
 
index dbe4422..3b89107 100644 (file)
@@ -113,7 +113,7 @@ gfc_trans_label_assign (gfc_code * code)
     {
       label_str = code->label->format->value.character.string;
       label_len = code->label->format->value.character.length;
-      len_tree = build_int_cst (NULL_TREE, label_len, 0);
+      len_tree = build_int_cst (NULL_TREE, label_len);
       label_tree = gfc_build_string_const (label_len + 1, label_str);
       label_tree = gfc_build_addr_expr (pchar_type_node, label_tree);
     }
@@ -287,7 +287,7 @@ gfc_trans_pause (gfc_code * code)
 
   if (code->expr == NULL)
     {
-      tmp = build_int_cst (gfc_int4_type_node, code->ext.stop_code, 0);
+      tmp = build_int_cst (gfc_int4_type_node, code->ext.stop_code);
       args = gfc_chainon_list (NULL_TREE, tmp);
       fndecl = gfor_fndecl_pause_numeric;
     }
@@ -326,7 +326,7 @@ gfc_trans_stop (gfc_code * code)
 
   if (code->expr == NULL)
     {
-      tmp = build_int_cst (gfc_int4_type_node, code->ext.stop_code, 0);
+      tmp = build_int_cst (gfc_int4_type_node, code->ext.stop_code);
       args = gfc_chainon_list (NULL_TREE, tmp);
       fndecl = gfor_fndecl_stop_numeric;
     }
@@ -1100,7 +1100,7 @@ gfc_trans_character_select (gfc_code *code)
     }
 
   type = build_array_type (select_struct, build_index_type
-                          (build_int_cst (NULL_TREE, n - 1, 0)));
+                          (build_int_cst (NULL_TREE, n - 1)));
 
   init = build1 (CONSTRUCTOR, type, nreverse(init));
   TREE_CONSTANT (init) = 1;
@@ -1118,7 +1118,7 @@ gfc_trans_character_select (gfc_code *code)
   init = gfc_build_addr_expr (pvoid_type_node, init);
   args = gfc_chainon_list (NULL_TREE, init);
 
-  tmp = build_int_cst (NULL_TREE, n, 0);
+  tmp = build_int_cst (NULL_TREE, n);
   args = gfc_chainon_list (args, tmp);
 
   tmp = gfc_build_addr_expr (pvoid_type_node, end_label);
index f96dc28..6f96315 100644 (file)
@@ -168,13 +168,14 @@ gfc_init_types (void)
       hi = 0;
       lo = (~(unsigned HOST_WIDE_INT) 0) >> (sizeof (HOST_WIDE_INT) * 8 - n);
     }
-  gfc_max_array_element_size = build_int_cst (long_unsigned_type_node, lo, hi);
+  gfc_max_array_element_size
+    = build_int_cst_wide (long_unsigned_type_node, lo, hi);
 
   size_type_node = gfc_array_index_type;
   boolean_type_node = gfc_get_logical_type (gfc_default_logical_kind ());
 
-  boolean_true_node = build_int_cst (boolean_type_node, 1, 0);
-  boolean_false_node = build_int_cst (boolean_type_node, 0, 0);
+  boolean_true_node = build_int_cst (boolean_type_node, 1);
+  boolean_false_node = build_int_cst (boolean_type_node, 0);
 }
 
 /* Get a type node for an integer kind.  */
@@ -597,11 +598,11 @@ gfc_get_dtype (tree type, int rank)
 
       i += TREE_INT_CST_LOW (size) << GFC_DTYPE_SIZE_SHIFT;
     }
-  dtype = build_int_cst (gfc_array_index_type, i, 0);
+  dtype = build_int_cst (gfc_array_index_type, i);
 
   if (size && !INTEGER_CST_P (size))
     {
-      tmp = build_int_cst (gfc_array_index_type, GFC_DTYPE_SIZE_SHIFT, 0);
+      tmp = build_int_cst (gfc_array_index_type, GFC_DTYPE_SIZE_SHIFT);
       tmp  = fold (build (LSHIFT_EXPR, gfc_array_index_type, size, tmp));
       dtype = fold (build (PLUS_EXPR, gfc_array_index_type, tmp, dtype));
     }
index 1ac8931..16ef85c 100644 (file)
@@ -365,7 +365,7 @@ gfc_trans_runtime_check (tree cond, tree msg, stmtblock_t * pblock)
   tmp = gfc_build_addr_expr (pchar_type_node, gfc_strconst_current_filename);
   args = gfc_chainon_list (args, tmp);
 
-  tmp = build_int_cst (NULL_TREE, input_line, 0);
+  tmp = build_int_cst (NULL_TREE, input_line);
   args = gfc_chainon_list (args, tmp);
 
   tmp = gfc_build_function_call (gfor_fndecl_runtime_error, args);
index 2fbc722..e4147c0 100644 (file)
@@ -2616,7 +2616,7 @@ assign_parm_setup_block (tree parm, struct assign_parm_data_one *data)
              rtx reg = gen_rtx_REG (word_mode, REGNO (data->entry_parm));
 
              x = expand_shift (LSHIFT_EXPR, word_mode, reg,
-                               build_int_cst (NULL_TREE, by, 0),
+                               build_int_cst (NULL_TREE, by),
                                NULL_RTX, 1);
              tem = change_address (mem, word_mode, 0);
              emit_move_insn (tem, x);
index dd6274c..9dd0fa5 100644 (file)
@@ -1,6 +1,28 @@
+2004-08-25  Nathan Sidwell  <nathan@codesourcery.com>
+
+       * boehm.c (get_boehm_type_descriptor):  Adjust build_int_cst calls.
+       * 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_newarray_node, patch_newarray): Likewise.
+       * resource.c (compile_resource_data): Likewise.
+       * typeck.c (build_prim_array_type): Likewise.
+
 2004-08-24  Nathan Sidwell  <nathan@codesourcery.com>
 
-       * java/decl.c (java_init_decl_processing): Adjust
+       * decl.c (java_init_decl_processing): Adjust
        initialize_sizetypes call.
 
 2004-08-23  Nathan Sidwell  <nathan@codesourcery.com>
index ae2fbfa..8b54590 100644 (file)
@@ -206,13 +206,13 @@ get_boehm_type_descriptor (tree type)
          last_set_index >>= 1;
          ++count;
        }
-      value = build_int_cst (value_type, low, high);
+      value = build_int_cst_wide (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_cst (value_type, low, high);
+      value = build_int_cst_wide (value_type, low, high);
     }
   else
     {
@@ -223,7 +223,7 @@ get_boehm_type_descriptor (tree type)
            | DS_PROC)
         Here DS_PROC == 2.  */
     procedure_object_descriptor:
-      value = build_int_cst (value_type, 2, 0);
+      value = build_int_cst (value_type, 2);
     }
 
   return value;
index 4781a61..d88fbb1 100644 (file)
@@ -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_cst (NULL_TREE, name_hash, 0));
-  PUSH_FIELD_VALUE (cinit, "length", build_int_cst (NULL_TREE, name_len, 0));
+  PUSH_FIELD_VALUE (cinit, "hash", build_int_cst (NULL_TREE, name_hash));
+  PUSH_FIELD_VALUE (cinit, "length", build_int_cst (NULL_TREE, name_len));
   string = build_string (name_len, name_ptr);
   TREE_TYPE (string) = str_type;
   PUSH_FIELD_VALUE (cinit, "data", string);
@@ -1082,7 +1082,7 @@ build_static_field_ref (tree fdecl)
     {
       tree table_index 
        = build_int_cst (NULL_TREE, get_symbol_table_index 
-                        (fdecl, &TYPE_ATABLE_METHODS (output_class)), 0);
+                        (fdecl, &TYPE_ATABLE_METHODS (output_class)));
       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_cst (NULL_TREE, field_index, 0)));
+                         ref, build_int_cst (NULL_TREE, field_index)));
       ref = build1 (INDIRECT_REF, field_type_node, ref);
       ref = build3 (COMPONENT_REF, field_info_union_node,
                    ref, lookup_field (&field_type_node, info_ident),
@@ -1268,7 +1268,7 @@ make_field_value (tree fdecl)
   if (! resolved)
     flags |= 0x8000 /* FIELD_UNRESOLVED_FLAG */;
 
-  PUSH_FIELD_VALUE (finit, "accflags", build_int_cst (NULL_TREE, flags, 0));
+  PUSH_FIELD_VALUE (finit, "accflags", build_int_cst (NULL_TREE, flags));
   PUSH_FIELD_VALUE (finit, "bsize", TYPE_SIZE_UNIT (TREE_TYPE (fdecl)));
 
   PUSH_FIELD_VALUE
@@ -1303,7 +1303,7 @@ make_method_value (tree mdecl)
   /* For interfaces, the index field contains the dispatch index. */
   if (CLASS_INTERFACE (TYPE_NAME (class_decl)))
     index = build_int_cst (NULL_TREE,
-                          get_interface_method_index (mdecl, class_decl), 0);
+                          get_interface_method_index (mdecl, class_decl));
   else if (!flag_indirect_dispatch && get_method_index (mdecl) != NULL_TREE)
     index = get_method_index (mdecl);
   else
@@ -1326,7 +1326,7 @@ make_method_value (tree mdecl)
                        (IDENTIFIER_POINTER(signature),
                         IDENTIFIER_LENGTH(signature)))));
   }
-  PUSH_FIELD_VALUE (minit, "accflags", build_int_cst (NULL_TREE, accflags, 0));
+  PUSH_FIELD_VALUE (minit, "accflags", build_int_cst (NULL_TREE, accflags));
   PUSH_FIELD_VALUE (minit, "index", index);
   PUSH_FIELD_VALUE (minit, "ncode", code);
 
@@ -1439,7 +1439,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_cst (NULL_TREE, j, 0));
+                                    method, build_int_cst (NULL_TREE, j));
                TREE_CONSTANT (fdesc) = 1;
                TREE_INVARIANT (fdesc) = 1;
                list = tree_cons (NULL_TREE, fdesc, list);
@@ -1553,8 +1553,7 @@ make_class_data (tree 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_cst (NULL_TREE,
-                                           2 * POINTER_SIZE / BITS_PER_UNIT,
-                                           0);
+                                           2 * POINTER_SIZE / BITS_PER_UNIT);
 
   this_class_addr = build_class_ref (type);
   decl = TREE_OPERAND (this_class_addr, 0);
@@ -1668,7 +1667,7 @@ make_class_data (tree type)
   else
     {
       int super_index = alloc_class_constant (super);
-      super = build_int_cst (ptr_type_node, super_index, 0);
+      super = build_int_cst (ptr_type_node, super_index);
     }
 
   /* Build and emit the array of implemented interfaces. */
@@ -1697,7 +1696,7 @@ make_class_data (tree type)
          else
            {
              int int_index = alloc_class_constant (iclass);
-             index = build_int_cst (ptr_type_node, int_index, 0);
+             index = build_int_cst (ptr_type_node, int_index);
            }
          init = tree_cons (NULL_TREE, index, init); 
        }
@@ -1743,7 +1742,7 @@ make_class_data (tree type)
   PUSH_FIELD_VALUE (cons, "name", build_utf8_ref (DECL_NAME (type_decl)));
   PUSH_FIELD_VALUE (cons, "accflags",
                    build_int_cst (NULL_TREE,
-                                  get_access_flags_from_decl (type_decl), 0));
+                                  get_access_flags_from_decl (type_decl)));
 
   PUSH_FIELD_VALUE (cons, "superclass", 
                    CLASS_INTERFACE (type_decl) ? null_pointer_node : super);
@@ -1751,7 +1750,7 @@ make_class_data (tree type)
   PUSH_FIELD_VALUE (cons, "methods",
                    build1 (ADDR_EXPR, method_ptr_type_node, methods_decl));
   PUSH_FIELD_VALUE (cons, "method_count",
-                   build_int_cst (NULL_TREE, method_count, 0));
+                   build_int_cst (NULL_TREE, method_count));
 
   if (flag_indirect_dispatch)
     PUSH_FIELD_VALUE (cons, "vtable_method_count", integer_minus_one_node);
@@ -1763,9 +1762,9 @@ make_class_data (tree type)
                    : 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_cst (NULL_TREE, field_count, 0));
+                   build_int_cst (NULL_TREE, field_count));
   PUSH_FIELD_VALUE (cons, "static_field_count",
-                   build_int_cst (NULL_TREE, static_field_count, 0));
+                   build_int_cst (NULL_TREE, static_field_count));
 
   if (flag_indirect_dispatch)
     PUSH_FIELD_VALUE (cons, "vtable", null_pointer_node);
@@ -1812,7 +1811,7 @@ make_class_data (tree type)
   PUSH_FIELD_VALUE (cons, "interfaces", interfaces);
   PUSH_FIELD_VALUE (cons, "loader", null_pointer_node);
   PUSH_FIELD_VALUE (cons, "interface_count",
-                   build_int_cst (NULL_TREE, interface_len, 0));
+                   build_int_cst (NULL_TREE, interface_len));
   PUSH_FIELD_VALUE (cons, "state", integer_zero_node);
 
   PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
@@ -2446,7 +2445,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_cst (NULL_TREE, index, 0));
+  table_size = build_index_type (build_int_cst (NULL_TREE, index));
   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;
@@ -2487,7 +2486,7 @@ emit_catch_table (tree this_class)
               TYPE_CATCH_CLASSES (this_class));
   table_size = build_index_type
     (build_int_cst (NULL_TREE,
-                   list_length (TYPE_CATCH_CLASSES (this_class)), 0));
+                   list_length (TYPE_CATCH_CLASSES (this_class))));
   array_type 
     = build_array_type (TREE_TYPE (TREE_TYPE (TYPE_CTABLE_DECL (this_class))),
                        table_size);
index d6a3513..a5d9622 100644 (file)
@@ -324,7 +324,7 @@ get_tag_node (int tag)
   /* A Cache for build_int_cst (CONSTANT_XXX, 0). */
 
   if (tag_nodes[tag] == NULL_TREE)
-    tag_nodes[tag] = build_int_cst (NULL_TREE, tag, 0);
+    tag_nodes[tag] = build_int_cst (NULL_TREE, tag);
   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_cst (NULL_TREE, index, 0);
+  tree i = build_int_cst (NULL_TREE, index);
   return build4 (ARRAY_REF, TREE_TYPE (TREE_TYPE (d)), d, i,
                 NULL_TREE, NULL_TREE);
 }
@@ -453,7 +453,7 @@ build_constants_constructor (void)
   if (outgoing_cpool->count > 0)
     {
       tree data_decl, tags_decl, tags_type;
-      tree max_index = build_int_cst (sizetype, outgoing_cpool->count - 1, 0);
+      tree max_index = build_int_cst (sizetype, outgoing_cpool->count - 1);
       tree index_type = build_index_type (max_index);
 
       /* Add dummy 0'th element of constant pool. */
@@ -485,7 +485,7 @@ build_constants_constructor (void)
     }
   START_RECORD_CONSTRUCTOR (cons, constants_type_node);
   PUSH_FIELD_VALUE (cons, "size",
-                   build_int_cst (NULL_TREE, outgoing_cpool->count, 0));
+                   build_int_cst (NULL_TREE, outgoing_cpool->count));
   PUSH_FIELD_VALUE (cons, "tags", tags_value);
   PUSH_FIELD_VALUE (cons, "data", data_value);
   FINISH_RECORD_CONSTRUCTOR (cons);
index 93dfcd7..f6c03a5 100644 (file)
@@ -585,24 +585,23 @@ 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_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);
+  integer_zero_node = build_int_cst (NULL_TREE, 0);
+  integer_one_node = build_int_cst (NULL_TREE, 1);
+  integer_two_node = build_int_cst (NULL_TREE, 2);
+  integer_four_node = build_int_cst (NULL_TREE, 4);
+  integer_minus_one_node = build_int_cst (NULL_TREE, -1);
 
   /* A few values used for range checking in the lexer.  */
-  decimal_int_max = build_int_cst (unsigned_int_type_node, 0x80000000, 0);
+  decimal_int_max = build_int_cstu (unsigned_int_type_node, 0x80000000);
 #if HOST_BITS_PER_WIDE_INT == 64
-  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_cst (unsigned_long_type_node, 0, 0x80000000);
+  decimal_long_max = build_int_cstu (unsigned_long_type_node,
+                                    0x8000000000000000LL);
+#elif HOST_BITS_PER_WIDE_INT == 32
+  decimal_long_max = build_int_cst_wide (unsigned_long_type_node,
+                                        0, 0x80000000);
 #else
  #error "unsupported size"
 #endif
-#endif
 
   size_zero_node = size_int (0);
   size_one_node = size_int (1);
@@ -610,7 +609,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_cst (long_type_node, 0, 0);
+  long_zero_node = build_int_cst (long_type_node, 0);
 
   void_type_node = make_node (VOID_TYPE);
   pushdecl (build_decl (TYPE_DECL, get_identifier ("void"), void_type_node));
@@ -620,7 +619,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_cst (ptr_type_node, 0, 0);
+  null_pointer_node = build_int_cst (ptr_type_node, 0);
 
 #if 0
   /* Make a type to be the domain of a few array types
index 97f540a..33d3afd 100644 (file)
@@ -698,7 +698,7 @@ build_java_array_length_access (tree node)
 
   length = java_array_type_length (type);
   if (length >= 0)
-    return build_int_cst (NULL_TREE, length, 0);
+    return build_int_cst (NULL_TREE, length);
 
   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_cst (NULL_TREE, atype_value, 0);
+    type_arg = build_int_cst (NULL_TREE, atype_value);
   else
     type_arg = build_class_ref (prim_type);
 
@@ -971,7 +971,7 @@ 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_cst (NULL_TREE, ndim, 0),
+                                           build_int_cst (NULL_TREE, ndim),
                                            args)),
                      NULL_TREE));
 }
@@ -1082,7 +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_cst (type, ival, ival < 0 ? -1 : 0);
+    value = build_int_cst (type, ival);
   else if (type == float_type_node || type == double_type_node)
     {
       REAL_VALUE_TYPE x;
@@ -1287,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_cst (NULL_TREE, ival, ival < 0 ? -1 : 0);
+  constant_value = build_int_cst (NULL_TREE, ival);
   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);
@@ -1358,7 +1358,7 @@ build_java_binop (enum tree_code op, tree type, tree arg1, tree arg2)
     case LSHIFT_EXPR:
     case RSHIFT_EXPR:
       mask = build_int_cst (NULL_TREE,
-                           TYPE_PRECISION (TREE_TYPE (arg1)) - 1, 0);
+                           TYPE_PRECISION (TREE_TYPE (arg1)) - 1);
       arg2 = fold (build2 (BIT_AND_EXPR, int_type_node, arg2, mask));
       break;
 
@@ -1539,8 +1539,7 @@ build_field_ref (tree self_value, tree self_class, tree name)
        {
          tree otable_index
            = build_int_cst (NULL_TREE, get_symbol_table_index 
-                            (field_decl, &TYPE_OTABLE_METHODS (output_class)),
-                            0);
+                            (field_decl, &TYPE_OTABLE_METHODS (output_class)));
          tree field_offset
            = build4 (ARRAY_REF, integer_type_node,
                      TYPE_OTABLE_DECL (output_class), otable_index,
@@ -1688,7 +1687,7 @@ expand_java_add_case (tree switch_expr, int match, int target_pc)
 {
   tree value, x;
 
-  value = build_int_cst (TREE_TYPE (switch_expr), match, match < 0 ? -1 : 0);
+  value = build_int_cst (TREE_TYPE (switch_expr), match);
   
   x = build3 (CASE_LABEL_EXPR, void_type_node, value, NULL_TREE,
              create_artificial_label ());
@@ -1703,8 +1702,7 @@ static void
 expand_java_call (int target_pc, int return_address)
 {
   tree target_label = lookup_label (target_pc);
-  tree value = build_int_cst (NULL_TREE,
-                             return_address, return_address < 0 ? -1 : 0);
+  tree value = build_int_cst (NULL_TREE, return_address);
   push_value (value);
   flush_quick_stack ();
   expand_goto (target_label);
@@ -1836,7 +1834,7 @@ build_known_method_ref (tree method, tree method_type ATTRIBUTE_UNUSED,
        {
          tree table_index
            = build_int_cst (NULL_TREE, get_symbol_table_index 
-                            (method, &TYPE_ATABLE_METHODS (output_class)), 0);
+                            (method, &TYPE_ATABLE_METHODS (output_class)));
          func = build4 (ARRAY_REF,  method_ptr_type_node, 
                         TYPE_ATABLE_DECL (output_class), table_index,
                         NULL_TREE, NULL_TREE);
@@ -1880,7 +1878,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_cst (NULL_TREE, method_index, 0)));
+                         ref, build_int_cst (NULL_TREE, method_index)));
       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,7 +1959,7 @@ build_invokevirtual (tree dtable, tree method)
     {
       otable_index 
        = build_int_cst (NULL_TREE, get_symbol_table_index 
-                        (method, &TYPE_OTABLE_METHODS (output_class)), 0);
+                        (method, &TYPE_OTABLE_METHODS (output_class)));
       method_index = build4 (ARRAY_REF, integer_type_node, 
                             TYPE_OTABLE_DECL (output_class), 
                             otable_index, NULL_TREE, NULL_TREE);
@@ -2021,14 +2019,14 @@ build_invokeinterface (tree dtable, tree method)
     {
       otable_index
        = build_int_cst (NULL_TREE, get_symbol_table_index 
-                        (method, &TYPE_OTABLE_METHODS (output_class)), 0);
+                        (method, &TYPE_OTABLE_METHODS (output_class)));
       idx = build4 (ARRAY_REF, integer_type_node,
                    TYPE_OTABLE_DECL (output_class), otable_index,
                    NULL_TREE, NULL_TREE);
     }
   else
     idx = build_int_cst (NULL_TREE,
-                        get_interface_method_index (method, interface), 0);
+                        get_interface_method_index (method, interface));
 
   lookup_arg = tree_cons (NULL_TREE, dtable,
                           tree_cons (NULL_TREE, build_class_ref (interface),
@@ -2282,7 +2280,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_cst (NULL_TREE, args_size, 0));
+  tem = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, args_size));
   method_sig = build_java_signature (TREE_TYPE (method));
   lookup_arg = tree_cons (NULL_TREE,
                           build_utf8_ref (unmangle_classname
index ea1b3f0..6632e93 100644 (file)
@@ -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_cst (NULL_TREE, ilength, 0);
+  tree length = build_int_cst (NULL_TREE, ilength);
   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_cst (NULL_TREE, index++, 0),
+                                       build_int_cst (NULL_TREE, index++),
                                        NULL_TREE, NULL_TREE),
                                TREE_VALUE (values));
       body = build2 (COMPOUND_EXPR, element_type, body, assignment);
index cb4853f..bc733e8 100644 (file)
@@ -266,7 +266,7 @@ get_constant (JCF *jcf, int index)
     case CONSTANT_Integer:
       {
        jint num = JPOOL_INT(jcf, index);
-       value = build_int_cst (int_type_node, num, num < 0 ? -1 : 0);
+       value = build_int_cst (int_type_node, num);
        break;
       }
     case CONSTANT_Long:
@@ -278,7 +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_cst (long_type_node, lo, hi);
+       value = build_int_cst_wide (long_type_node, lo, hi);
        value = force_fit_type (value, 0, false, false);
        break;
       }
index 7c497bd..aa3efcc 100644 (file)
@@ -1277,9 +1277,9 @@ do_java_lex (YYSTYPE *java_lval)
 #ifndef JC1_LITE
       /* Range checking.  */
       /* Temporarily set type to unsigned.  */
-      value = build_int_cst (long_suffix
-                            ? unsigned_long_type_node
-                            : unsigned_int_type_node, low, high);
+      value = build_int_cst_wide (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
@@ -1300,8 +1300,8 @@ do_java_lex (YYSTYPE *java_lval)
        }
 
       /* Sign extend the value.  */
-      value = build_int_cst (long_suffix ? long_type_node : int_type_node,
-                            low, high);
+      value = build_int_cst_wide (long_suffix ? long_type_node : int_type_node,
+                                 low, high);
       value = force_fit_type (value, 0, false, false);
 
       if (radix != 10)
@@ -1340,7 +1340,7 @@ do_java_lex (YYSTYPE *java_lval)
         char_lit = 0;          /* We silently convert it to zero.  */
 
       JAVA_LEX_CHAR_LIT (char_lit);
-      SET_LVAL_NODE (build_int_cst (char_type_node, char_lit, 0));
+      SET_LVAL_NODE (build_int_cst (char_type_node, char_lit));
       return CHAR_LIT_TK;
     }
 
index 85be4b7..4996271 100644 (file)
@@ -13334,10 +13334,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_cst (NULL_TREE, 0x1f, 0)));
+                           build_int_cst (NULL_TREE, 0x1f)));
       else
        op2 = fold (build2 (BIT_AND_EXPR, int_type_node, op2,
-                           build_int_cst (NULL_TREE, 0x3f, 0)));
+                           build_int_cst (NULL_TREE, 0x3f)));
 
       /* The >>> operator is a >> operating on unsigned quantities */
       if (code == URSHIFT_EXPR && ! flag_emit_class_files)
@@ -14032,12 +14032,12 @@ patch_unaryop (tree node, tree wfl_op)
             both operands, if really necessary */
          if (JINTEGRAL_TYPE_P (op_type))
            {
-             value = build_int_cst (op_type, 1, 0);
+             value = build_int_cst (op_type, 1);
              TREE_TYPE (node) = op_type;
            }
          else
            {
-             value = build_int_cst (NULL_TREE, 1, 0);
+             value = build_int_cst (NULL_TREE, 1);
              TREE_TYPE (node) =
                binary_numeric_promotion (op_type,
                                          TREE_TYPE (value), &op, &value);
@@ -14263,7 +14263,7 @@ patch_cast (tree node, tree wfl_op)
 static tree
 build_null_of_type (tree type)
 {
-  tree node = build_int_cst (promote_type (type), 0, 0);
+  tree node = build_int_cst (promote_type (type), 0);
   return node;
 }
 
@@ -14345,7 +14345,7 @@ build_newarray_node (tree type, tree dims, int extra_dims)
 {
   tree node = build3 (NEW_ARRAY_EXPR, NULL_TREE, type,
                      nreverse (dims),
-                     build_int_cst (NULL_TREE, extra_dims, 0));
+                     build_int_cst (NULL_TREE, extra_dims));
   return node;
 }
 
@@ -14444,8 +14444,8 @@ patch_newarray (tree node)
                 tree_cons (NULL_TREE,
                            build_class_ref (TREE_TYPE (array_type)),
                            tree_cons (NULL_TREE,
-                                      build_int_cst (NULL_TREE,
-                                                     ndims, 0), dims )),
+                                      build_int_cst (NULL_TREE, ndims),
+                                      dims)),
                 NULL_TREE);
 }
 
index 362aab4..0778659 100644 (file)
@@ -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_cst (NULL_TREE, strlen (name), 0));
+                   build_int_cst (NULL_TREE, strlen (name)));
   PUSH_FIELD_VALUE (rinit, "resource_length", 
-                   build_int_cst (NULL_TREE, length, 0));
+                   build_int_cst (NULL_TREE, length));
   data = build_string (strlen(name) + length, buffer);
   TREE_TYPE (data) = data_type;
   PUSH_FIELD_VALUE (rinit, "data", data);
index 830b95c..0c61174 100644 (file)
@@ -357,8 +357,7 @@ build_prim_array_type (tree element_type, HOST_WIDE_INT length)
 
   if (length != -1)
     {
-      tree max_index = build_int_cst (sizetype,
-                                     length - 1, (0 == length ? -1 : 0));
+      tree max_index = build_int_cst (sizetype, length - 1);
       index = build_index_type (max_index);
     }
   return build_array_type (element_type, index);
index 92e5228..bc5da03 100644 (file)
@@ -1404,7 +1404,7 @@ build_objc_string_object (tree string)
     }
   else
     {
-      initlist = build_tree_list (fields, build_int_cst (NULL_TREE, 0, 0));
+      initlist = build_tree_list (fields, build_int_cst (NULL_TREE, 0));
     }
 
   fields = TREE_CHAIN (fields);
@@ -1415,7 +1415,7 @@ build_objc_string_object (tree string)
                  
   fields = TREE_CHAIN (fields);
   
-  initlist = tree_cons (fields, build_int_cst (NULL_TREE, length, 0), initlist);
+  initlist = tree_cons (fields, build_int_cst (NULL_TREE, length), initlist);
   constructor = objc_build_constructor (constant_string_type,
                                        nreverse (initlist));
 
@@ -1568,7 +1568,7 @@ build_objc_symtab_template (void)
                   (FIELD_DECL,
                    build_array_type
                    (ptr_type_node,
-                    build_index_type (build_int_cst (NULL_TREE, index, 0))),
+                    build_index_type (build_int_cst (NULL_TREE, index))),
                    "defs");
       chainon (field_decl_chain, field_decl);
     }
@@ -1613,7 +1613,7 @@ init_def_list (tree type)
       if (static_instances_decl)
        expr = build_unary_op (ADDR_EXPR, static_instances_decl, 0);
       else
-       expr = build_int_cst (NULL_TREE, 0, 0);
+       expr = build_int_cst (NULL_TREE, 0);
 
       initlist = tree_cons (NULL_TREE, expr, initlist);
     }
@@ -1630,12 +1630,12 @@ init_objc_symtab (tree type)
 
   /* sel_ref_cnt = { ..., 5, ... } */
 
-  initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 0, 0));
+  initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 0));
 
   /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */
 
   if (flag_next_runtime || ! sel_ref_chain)
-    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
   else
     initlist = tree_cons (NULL_TREE,
                          build_unary_op (ADDR_EXPR,
@@ -1644,11 +1644,11 @@ init_objc_symtab (tree type)
 
   /* cls_def_cnt = { ..., 5, ... } */
 
-  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, imp_count, 0), initlist);
+  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, imp_count), initlist);
 
   /* cat_def_cnt = { ..., 5, ... } */
 
-  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, cat_count, 0), initlist);
+  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, cat_count), initlist);
 
   /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */
 
@@ -1749,7 +1749,7 @@ init_module_descriptor (tree type)
 
   /* version = { 1, ... } */
 
-  expr = build_int_cst (NULL_TREE, OBJC_VERSION, 0);
+  expr = build_int_cst (NULL_TREE, OBJC_VERSION);
   initlist = build_tree_list (NULL_TREE, expr);
 
   /* size = { ..., sizeof (struct objc_module), ... } */
@@ -1767,7 +1767,7 @@ init_module_descriptor (tree type)
   if (UOBJC_SYMBOLS_decl)
     expr = build_unary_op (ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
   else
-    expr = build_int_cst (NULL_TREE, 0, 0);
+    expr = build_int_cst (NULL_TREE, 0);
   initlist = tree_cons (NULL_TREE, expr, initlist);
 
   return objc_build_constructor (type, nreverse (initlist));
@@ -1974,7 +1974,7 @@ generate_static_references (void)
        }
 
       /* Output {..., NULL}.  */
-      initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+      initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
 
       expr = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
       finish_decl (decl, expr, NULL_TREE);
@@ -1982,7 +1982,7 @@ generate_static_references (void)
        = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, decl, 1), decls);
     }
 
-  decls = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), decls);
+  decls = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), decls);
   ident = get_identifier ("_OBJC_STATIC_INSTANCES");
   expr_decl = build_nt (ARRAY_REF, ident, NULL_TREE, NULL_TREE, NULL_TREE);
   decl_spec = tree_cons (NULL_TREE, build_pointer_type (void_type_node),
@@ -2177,7 +2177,7 @@ build_selector_translation_table (void)
       DECL_EXTERNAL (UOBJC_SELECTOR_TABLE_decl) = 0;
       TREE_STATIC (UOBJC_SELECTOR_TABLE_decl) = 1;
       /* NULL terminate the list and fix the decl for output.  */
-      initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+      initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
       DECL_INITIAL (UOBJC_SELECTOR_TABLE_decl) = objc_ellipsis_node;
       initlist = objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl),
                                         nreverse (initlist));
@@ -2203,7 +2203,7 @@ get_proto_encoding (tree proto)
       return add_objc_string (encoding, meth_var_types);
     }
   else
-    return build_int_cst (NULL_TREE, 0, 0);
+    return build_int_cst (NULL_TREE, 0);
 }
 
 /* sel_ref_chain is a list whose "value" fields will be instances of
@@ -2230,7 +2230,7 @@ build_typed_selector_reference (tree ident, tree prototype)
  return_at_index:
   expr = build_unary_op (ADDR_EXPR,
                         build_array_ref (UOBJC_SELECTOR_TABLE_decl,
-                                         build_int_cst (NULL_TREE, index, 0)),
+                                         build_int_cst (NULL_TREE, index)),
                         1);
   return build_c_cast (objc_selector_type, expr);
 }
@@ -2248,7 +2248,7 @@ build_selector_reference (tree ident)
        return (flag_next_runtime
                ? TREE_PURPOSE (*chain)
                : build_array_ref (UOBJC_SELECTOR_TABLE_decl,
-                                  build_int_cst (NULL_TREE, index, 0)));
+                                  build_int_cst (NULL_TREE, index)));
 
       index++;
       chain = &TREE_CHAIN (*chain);
@@ -2261,7 +2261,7 @@ build_selector_reference (tree ident)
   return (flag_next_runtime
          ? expr
          : build_array_ref (UOBJC_SELECTOR_TABLE_decl,
-                            build_int_cst (NULL_TREE, index, 0)));
+                            build_int_cst (NULL_TREE, index)));
 }
 
 static GTY(()) int class_reference_idx;
@@ -3249,7 +3249,7 @@ build_next_objc_exception_stuff (void)
 
   /* int buf[_JBLEN]; */
 
-  index = build_index_type (build_int_cst (NULL_TREE, _JBLEN - 1, 0));
+  index = build_index_type (build_int_cst (NULL_TREE, _JBLEN - 1));
   field_decl = create_builtin_decl (FIELD_DECL,
                                    build_array_type (integer_type_node, index),
                                    "buf");
@@ -3257,7 +3257,7 @@ build_next_objc_exception_stuff (void)
 
   /* void *pointers[4]; */
 
-  index = build_index_type (build_int_cst (NULL_TREE, 4 - 1, 0));
+  index = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
   field_decl = create_builtin_decl (FIELD_DECL,
                                    build_array_type (ptr_type_node, index),
                                    "pointers");
@@ -3495,7 +3495,7 @@ build_method_prototype_list_template (tree list_type, int size)
 
   decl_specs = build_tree_list (NULL_TREE, list_type);
   field_decl = build_nt (ARRAY_REF, get_identifier ("method_list"),
-                        build_int_cst (NULL_TREE, size, 0), NULL_TREE, NULL_TREE);
+                        build_int_cst (NULL_TREE, size), NULL_TREE, NULL_TREE);
   field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
   chainon (field_decl_chain, field_decl);
 
@@ -3641,7 +3641,7 @@ generate_descriptor_table (tree type, const char *name, int size, tree list,
                     decl_specs, 1, NULL_TREE);
   DECL_CONTEXT (decl) = NULL_TREE;
 
-  initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, size, 0));
+  initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, size));
   initlist = tree_cons (NULL_TREE, list, initlist);
 
   finish_decl (decl, objc_build_constructor (type, nreverse (initlist)),
@@ -3851,7 +3851,7 @@ generate_protocols (void)
          TREE_TYPE (refs_expr) = cast_type2;
        }
       else
-       refs_expr = build_int_cst (NULL_TREE, 0, 0);
+       refs_expr = build_int_cst (NULL_TREE, 0);
 
       /* UOBJC_INSTANCE_METHODS_decl/UOBJC_CLASS_METHODS_decl are set
         by generate_method_descriptors, which is called above.  */
@@ -3884,13 +3884,13 @@ build_protocol_initializer (tree type, tree protocol_name,
   /* Filling the "isa" in with one allows the runtime system to
      detect that the version change...should remove before final release.  */
 
-  expr = build_int_cst (cast_type, PROTOCOL_VERSION, 0);
+  expr = build_int_cst (cast_type, PROTOCOL_VERSION);
   initlist = tree_cons (NULL_TREE, expr, initlist);
   initlist = tree_cons (NULL_TREE, protocol_name, initlist);
   initlist = tree_cons (NULL_TREE, protocol_list, initlist);
 
   if (!instance_methods)
-    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
   else
     {
       expr = build_unary_op (ADDR_EXPR, instance_methods, 0);
@@ -3898,7 +3898,7 @@ build_protocol_initializer (tree type, tree protocol_name,
     }
 
   if (!class_methods)
-    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
   else
     {
       expr = build_unary_op (ADDR_EXPR, class_methods, 0);
@@ -4391,7 +4391,7 @@ build_ivar_list_template (tree list_type, int size)
 
   decl_specs = build_tree_list (NULL_TREE, list_type);
   field_decl = build_nt (ARRAY_REF, get_identifier ("ivar_list"),
-                        build_int_cst (NULL_TREE, size, 0), NULL_TREE, NULL_TREE);
+                        build_int_cst (NULL_TREE, size), NULL_TREE, NULL_TREE);
 
   field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
   chainon (field_decl_chain, field_decl);
@@ -4439,7 +4439,7 @@ build_method_list_template (tree list_type, int size)
 
   decl_specs = build_tree_list (NULL_TREE, list_type);
   field_decl = build_nt (ARRAY_REF, get_identifier ("method_list"),
-                        build_int_cst (NULL_TREE, size, 0), NULL_TREE, NULL_TREE);
+                        build_int_cst (NULL_TREE, size), NULL_TREE, NULL_TREE);
 
   field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
   chainon (field_decl_chain, field_decl);
@@ -4466,7 +4466,7 @@ build_ivar_list_initializer (tree type, tree field_decl)
                          ivar);
       else
        /* Unnamed bit-field ivar (yuck).  */
-       ivar = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), ivar);
+       ivar = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), ivar);
 
       /* Set type.  */
       encode_field_decl (field_decl,
@@ -4509,7 +4509,7 @@ generate_ivars_list (tree type, const char *name, int size, tree list)
   decl = start_decl (synth_id_with_class_suffix (name, objc_implementation_context),
                     decl_specs, 1, NULL_TREE);
 
-  initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, size, 0));
+  initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, size));
   initlist = tree_cons (NULL_TREE, list, initlist);
 
   finish_decl (decl,
@@ -4684,8 +4684,8 @@ generate_dispatch_table (tree type, const char *name, int size, tree list)
   decl = start_decl (synth_id_with_class_suffix (name, objc_implementation_context),
                     decl_specs, 1, NULL_TREE);
 
-  initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 0, 0));
-  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, size, 0), initlist);
+  initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 0));
+  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, size), initlist);
   initlist = tree_cons (NULL_TREE, list, initlist);
 
   finish_decl (decl,
@@ -4817,9 +4817,9 @@ generate_protocol_list (tree i_or_p)
       size++;
 
   /* Build initializer.  */
-  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), NULL_TREE);
+  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), NULL_TREE);
 
-  e = build_int_cst (cast_type, size, 0);
+  e = build_int_cst (cast_type, size);
   initlist = tree_cons (NULL_TREE, e, initlist);
 
   for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
@@ -4845,18 +4845,18 @@ generate_protocol_list (tree i_or_p)
     expr_decl = build_nt (ARRAY_REF,
                          synth_id_with_class_suffix ("_OBJC_PROTOCOL_REFS",
                                                      i_or_p),
-                         build_int_cst (NULL_TREE, size + 2, 0), NULL_TREE, NULL_TREE);
+                         build_int_cst (NULL_TREE, size + 2), NULL_TREE, NULL_TREE);
   else if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE)
     expr_decl = build_nt (ARRAY_REF,
                          synth_id_with_class_suffix ("_OBJC_CLASS_PROTOCOLS",
                                                      i_or_p),
-                         build_int_cst (NULL_TREE, size + 2, 0), NULL_TREE, NULL_TREE);
+                         build_int_cst (NULL_TREE, size + 2), NULL_TREE, NULL_TREE);
   else if (TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
     expr_decl
       = build_nt (ARRAY_REF,
                  synth_id_with_class_suffix ("_OBJC_CATEGORY_PROTOCOLS",
                                              i_or_p),
-                 build_int_cst (NULL_TREE, size + 2, 0), NULL_TREE, NULL_TREE);
+                 build_int_cst (NULL_TREE, size + 2), NULL_TREE, NULL_TREE);
   else
     abort ();
 
@@ -4883,14 +4883,14 @@ build_category_initializer (tree type, tree cat_name, tree class_name,
   initlist = tree_cons (NULL_TREE, class_name, initlist);
 
   if (!instance_methods)
-    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
   else
     {
       expr = build_unary_op (ADDR_EXPR, instance_methods, 0);
       initlist = tree_cons (NULL_TREE, expr, initlist);
     }
   if (!class_methods)
-    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
   else
     {
       expr = build_unary_op (ADDR_EXPR, class_methods, 0);
@@ -4899,7 +4899,7 @@ build_category_initializer (tree type, tree cat_name, tree class_name,
 
   /* protocol_list = */
   if (!protocol_list)
-     initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+     initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
   else
      {
        tree cast_type2 = groktypename
@@ -4958,17 +4958,17 @@ build_shared_structure_initializer (tree type, tree isa, tree super,
   initlist = tree_cons (NULL_TREE, default_conversion (name), initlist);
 
   /* version = */
-  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
 
   /* info = */
-  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, status, 0), initlist);
+  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, status), initlist);
 
   /* instance_size = */
   initlist = tree_cons (NULL_TREE, size, initlist);
 
   /* objc_ivar_list = */
   if (!ivar_list)
-    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
   else
     {
       expr = build_unary_op (ADDR_EXPR, ivar_list, 0);
@@ -4977,7 +4977,7 @@ build_shared_structure_initializer (tree type, tree isa, tree super,
 
   /* objc_method_list = */
   if (!dispatch_table)
-    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
   else
     {
       expr = build_unary_op (ADDR_EXPR, dispatch_table, 0);
@@ -4986,22 +4986,22 @@ build_shared_structure_initializer (tree type, tree isa, tree super,
 
   if (flag_next_runtime)
     /* method_cache = */
-    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
   else
     {
       /* dtable = */
-      initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+      initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
 
       /* subclass_list = */
-      initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+      initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
 
       /* sibling_class = */
-      initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+      initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
     }
 
   /* protocol_list = */
   if (! protocol_list)
-    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
   else
      {
        tree cast_type2
@@ -5020,10 +5020,10 @@ build_shared_structure_initializer (tree type, tree isa, tree super,
 
   if (flag_next_runtime)
     /* sel_id = NULL */
-    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+    initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
 
   /* gc_object_type = NULL */
-  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0, 0), initlist);
+  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
 
   return objc_build_constructor (type, nreverse (initlist));
 }
@@ -5132,7 +5132,7 @@ generate_shared_structures (void)
       super_expr = build_c_cast (cast_type, super_expr); /* cast! */
     }
   else
-    super_expr = build_int_cst (NULL_TREE, 0, 0);
+    super_expr = build_int_cst (NULL_TREE, 0);
 
   root_expr = add_objc_string (my_root_id, class_names);
   root_expr = build_c_cast (cast_type, root_expr); /* cast! */
@@ -8989,7 +8989,7 @@ handle_impent (struct imp_entry *impent)
     {
       tree decl, init;
 
-      init = build_int_cst (c_common_type_for_size (BITS_PER_WORD, 1), 0, 0);
+      init = build_int_cst (c_common_type_for_size (BITS_PER_WORD, 1), 0);
       decl = build_decl (VAR_DECL, get_identifier (string), TREE_TYPE (init));
       TREE_PUBLIC (decl) = 1;
       TREE_READONLY (decl) = 1;
@@ -9019,13 +9019,13 @@ generate_objc_image_info (void)
                 tree_cons (NULL_TREE,
                            build_array_type
                            (integer_type_node,
-                            build_index_type (build_int_cst (NULL_TREE, 1, 0))),
+                            build_index_type (build_int_cst (NULL_TREE, 1))),
                            sc_spec),
                 1,
                 NULL_TREE);
 
-  initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 0, 0));
-  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 1, 0), initlist);
+  initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 0));
+  initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 1), initlist);
   initlist = build_constructor (TREE_TYPE (decl), nreverse (initlist));
 
   TREE_USED (decl) = DECL_IGNORED_P (decl) = DECL_ARTIFICIAL (decl) = 1;
index 8127437..02e6664 100644 (file)
@@ -1546,7 +1546,7 @@ shift_return_value (rtx val)
       if (shift > 0)
        val = expand_shift (LSHIFT_EXPR, GET_MODE (target),
                            gen_lowpart (GET_MODE (target), val),
-                           build_int_cst (NULL_TREE, shift, 0), target, 1);
+                           build_int_cst (NULL_TREE, shift), target, 1);
     }
   return val;
 }
@@ -2554,8 +2554,9 @@ expand_case (tree exp)
              if (TREE_CODE (index_expr) != INTEGER_CST)
                {
                  index_expr
-                   = build_int_cst (NULL_TREE, INTVAL (index),
-                                  unsignedp || INTVAL (index) >= 0 ? 0 : -1);
+                   = build_int_cst_wide (NULL_TREE, INTVAL (index),
+                                         unsignedp || INTVAL (index) >= 0
+                                         ? 0 : -1);
                  index_expr = convert (index_type, index_expr);
                }
 
@@ -2727,7 +2728,7 @@ estimate_case_costs (case_node_ptr node)
 {
   tree min_ascii = integer_minus_one_node;
   tree max_ascii = convert (TREE_TYPE (node->high),
-                           build_int_cst (NULL_TREE, 127, 0));
+                           build_int_cst (NULL_TREE, 127));
   case_node_ptr n;
   int i;
 
index 3b04dc7..3141e7d 100644 (file)
@@ -1534,7 +1534,7 @@ layout_type (tree type)
     case VECTOR_TYPE:
       {
        int nunits = TYPE_VECTOR_SUBPARTS (type);
-       tree nunits_tree = build_int_cst (NULL_TREE, nunits, 0);
+       tree nunits_tree = build_int_cst (NULL_TREE, nunits);
        tree innertype = TREE_TYPE (type);
 
        if (nunits & (nunits - 1))
@@ -1856,14 +1856,14 @@ initialize_sizetypes (bool signed_p)
   TYPE_USER_ALIGN (t) = 0;
   TYPE_IS_SIZETYPE (t) = 1;
   TYPE_UNSIGNED (t) = !signed_p;
-  TYPE_SIZE (t) = build_int_cst (t, GET_MODE_BITSIZE (SImode), 0);
-  TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode), 0);
+  TYPE_SIZE (t) = build_int_cst (t, GET_MODE_BITSIZE (SImode));
+  TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode));
   TYPE_PRECISION (t) = GET_MODE_BITSIZE (SImode);
-  TYPE_MIN_VALUE (t) = build_int_cst (t, 0, 0);
+  TYPE_MIN_VALUE (t) = build_int_cst (t, 0);
 
   /* 1000 avoids problems with possible overflow and is certainly
      larger than any size value we'd want to be storing.  */
-  TYPE_MAX_VALUE (t) = build_int_cst (t, 1000, 0);
+  TYPE_MAX_VALUE (t) = build_int_cst (t, 1000);
 
   sizetype = t;
   bitsizetype = build_distinct_type_copy (t);
@@ -1951,34 +1951,37 @@ set_min_and_max_values_for_integral_type (tree type,
 
   if (is_unsigned)
     {
-      min_value = build_int_cst (type, 0, 0);
+      min_value = build_int_cst (type, 0);
       max_value
-       = build_int_cst (type, precision - HOST_BITS_PER_WIDE_INT >= 0
-                        ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1,
-                        precision - HOST_BITS_PER_WIDE_INT > 0
-                        ? ((unsigned HOST_WIDE_INT) ~0
-                           >> (HOST_BITS_PER_WIDE_INT
-                               - (precision - HOST_BITS_PER_WIDE_INT)))
-                        : 0);
+       = build_int_cst_wide (type, precision - HOST_BITS_PER_WIDE_INT >= 0
+                             ? -1
+                             : ((HOST_WIDE_INT) 1 << precision) - 1,
+                             precision - HOST_BITS_PER_WIDE_INT > 0
+                             ? ((unsigned HOST_WIDE_INT) ~0
+                                >> (HOST_BITS_PER_WIDE_INT
+                                    - (precision - HOST_BITS_PER_WIDE_INT)))
+                             : 0);
     }
   else
     {
       min_value
-       = build_int_cst (type,
-                        (precision - HOST_BITS_PER_WIDE_INT > 0
-                         ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
-                        (((HOST_WIDE_INT) (-1)
-                          << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
-                              ? precision - HOST_BITS_PER_WIDE_INT - 1
-                              : 0))));
+       = build_int_cst_wide (type,
+                             (precision - HOST_BITS_PER_WIDE_INT > 0
+                              ? 0
+                              : (HOST_WIDE_INT) (-1) << (precision - 1)),
+                             (((HOST_WIDE_INT) (-1)
+                               << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
+                                   ? precision - HOST_BITS_PER_WIDE_INT - 1
+                                   : 0))));
       max_value
-       = build_int_cst (type,
-                        (precision - HOST_BITS_PER_WIDE_INT > 0
-                         ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
-                        (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
-                         ? (((HOST_WIDE_INT) 1
-                             << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
-                         : 0));
+       = build_int_cst_wide (type,
+                             (precision - HOST_BITS_PER_WIDE_INT > 0
+                              ? -1
+                              : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
+                             (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
+                              ? (((HOST_WIDE_INT) 1
+                                  << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
+                              : 0));
     }
 
   TYPE_MIN_VALUE (type) = min_value;
index 957f55d..d4b8168 100644 (file)
@@ -218,7 +218,7 @@ chrec_fold_multiply_poly_poly (tree type,
      
      /* "2*b*d".  */
      chrec_fold_multiply
-     (type, build_int_cst (NULL_TREE, 2, 0),
+     (type, build_int_cst (NULL_TREE, 2),
       chrec_fold_multiply (type, CHREC_RIGHT (poly0), CHREC_RIGHT (poly1))));
 }
 
@@ -645,7 +645,7 @@ reset_evolution_in_loop (unsigned loop_num,
       && CHREC_VARIABLE (chrec) > loop_num)
     return build 
       (TREE_CODE (chrec), 
-       build_int_cst (NULL_TREE, CHREC_VARIABLE (chrec), 0), 
+       build_int_cst (NULL_TREE, CHREC_VARIABLE (chrec)), 
        reset_evolution_in_loop (loop_num, CHREC_LEFT (chrec), new_evol), 
        reset_evolution_in_loop (loop_num, CHREC_RIGHT (chrec), new_evol));
   
index d2027b2..84eb135 100644 (file)
@@ -105,7 +105,7 @@ build_polynomial_chrec (unsigned loop_num,
     return chrec_dont_know;
 
   return build (POLYNOMIAL_CHREC, TREE_TYPE (left), 
-               build_int_cst (NULL_TREE, loop_num, 0), left, right);
+               build_int_cst (NULL_TREE, loop_num), left, right);
 }
 
 \f
index 5c14e41..68302e8 100644 (file)
@@ -506,7 +506,7 @@ build_replicated_const (tree type, tree inner_type, HOST_WIDE_INT value)
   else
     abort ();
 
-  ret = build_int_cst (type, low, high);
+  ret = build_int_cst_wide (type, low, high);
   return ret;
 }
 
index 0ddf849..6103aa6 100644 (file)
@@ -833,7 +833,7 @@ honor_protect_cleanup_actions (struct leh_state *outer_state,
 
       x = build1 (RESX_EXPR, void_type_node,
                  build_int_cst (NULL_TREE,
-                                get_eh_region_number (tf->region), 0));
+                                get_eh_region_number (tf->region)));
       tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
     }
 
@@ -940,7 +940,7 @@ lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf)
 
       x = build1 (RESX_EXPR, void_type_node,
                  build_int_cst (NULL_TREE,
-                                get_eh_region_number (tf->region), 0));
+                                get_eh_region_number (tf->region)));
       append_to_statement_list (x, tf->top_p);
 
       return;
@@ -1029,7 +1029,7 @@ lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf)
 
       x = build1 (RESX_EXPR, void_type_node,
                  build_int_cst (NULL_TREE,
-                                get_eh_region_number (tf->region), 0));
+                                get_eh_region_number (tf->region)));
       append_to_statement_list (x, &new_stmt);
     }
 
@@ -1137,7 +1137,7 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
   if (tf->may_fallthru)
     {
       x = build (MODIFY_EXPR, void_type_node, finally_tmp,
-                build_int_cst (NULL_TREE, fallthru_index, 0));
+                build_int_cst (NULL_TREE, fallthru_index));
       append_to_statement_list (x, tf->top_p);
 
       if (tf->may_throw)
@@ -1148,7 +1148,7 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
 
 
       last_case = build (CASE_LABEL_EXPR, void_type_node,
-                        build_int_cst (NULL_TREE, fallthru_index, 0), NULL,
+                        build_int_cst (NULL_TREE, fallthru_index), NULL,
                         create_artificial_label ());
       TREE_VEC_ELT (case_label_vec, last_case_index) = last_case;
       last_case_index++;
@@ -1167,11 +1167,11 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
       append_to_statement_list (x, tf->top_p);
 
       x = build (MODIFY_EXPR, void_type_node, finally_tmp,
-                build_int_cst (NULL_TREE, eh_index, 0));
+                build_int_cst (NULL_TREE, eh_index));
       append_to_statement_list (x, tf->top_p);
 
       last_case = build (CASE_LABEL_EXPR, void_type_node,
-                        build_int_cst (NULL_TREE, eh_index, 0), NULL,
+                        build_int_cst (NULL_TREE, eh_index), NULL,
                         create_artificial_label ());
       TREE_VEC_ELT (case_label_vec, last_case_index) = last_case;
       last_case_index++;
@@ -1180,7 +1180,7 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
       append_to_statement_list (x, &switch_body);
       x = build1 (RESX_EXPR, void_type_node,
                  build_int_cst (NULL_TREE,
-                                get_eh_region_number (tf->region), 0));
+                                get_eh_region_number (tf->region)));
       append_to_statement_list (x, &switch_body);
     }
 
@@ -1202,14 +1202,14 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
       if (q->index < 0)
        {
          mod = build (MODIFY_EXPR, void_type_node, finally_tmp,
-                      build_int_cst (NULL_TREE, return_index, 0));
+                      build_int_cst (NULL_TREE, return_index));
          do_return_redirection (q, finally_label, mod, &return_val);
          switch_id = return_index;
        }
       else
        {
          mod = build (MODIFY_EXPR, void_type_node, finally_tmp,
-                      build_int_cst (NULL_TREE, q->index, 0));
+                      build_int_cst (NULL_TREE, q->index));
          do_goto_redirection (q, finally_label, mod);
          switch_id = q->index;
        }
@@ -1218,7 +1218,7 @@ lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
       if (!TREE_VEC_ELT (case_label_vec, case_index))
        {
          last_case = build (CASE_LABEL_EXPR, void_type_node,
-                            build_int_cst (NULL_TREE, switch_id, 0), NULL,
+                            build_int_cst (NULL_TREE, switch_id), NULL,
                             create_artificial_label ());
          TREE_VEC_ELT (case_label_vec, case_index) = last_case;
 
index a10b5d7..580d9ad 100644 (file)
@@ -77,7 +77,7 @@ mf_build_string (const char *string)
   tree result = mf_mark (build_string (len + 1, string));
 
   TREE_TYPE (result) = build_array_type
-    (char_type_node, build_index_type (build_int_cst (NULL_TREE, len, 0)));
+    (char_type_node, build_index_type (build_int_cst (NULL_TREE, len)));
   TREE_CONSTANT (result) = 1;
   TREE_INVARIANT (result) = 1;
   TREE_READONLY (result) = 1;
@@ -918,7 +918,7 @@ mx_register_decls (tree decl, tree *stmt_list)
                                   size,
                                   tree_cons (NULL_TREE,
                                             /* __MF_TYPE_STACK */
-                                             build_int_cst (NULL_TREE, 3, 0),
+                                             build_int_cst (NULL_TREE, 3),
                                              NULL_TREE)));
           /* __mf_unregister (...) */
           unregister_fncall = build_function_call_expr (mf_unregister_fndecl,
@@ -936,7 +936,7 @@ mx_register_decls (tree decl, tree *stmt_list)
                                   size,
                                   tree_cons (NULL_TREE,
                                             /* __MF_TYPE_STACK */
-                                             build_int_cst (NULL_TREE, 3, 0),
+                                             build_int_cst (NULL_TREE, 3),
                                              tree_cons (NULL_TREE,
                                                         variable_name,
                                                         NULL_TREE))));
@@ -1079,7 +1079,7 @@ mudflap_register_call (tree obj, tree object_size, tree varname)
 
   args = tree_cons (NULL_TREE, varname, NULL_TREE);
 
-  arg = build_int_cst (NULL_TREE, 4, 0); /* __MF_TYPE_STATIC */
+  arg = build_int_cst (NULL_TREE, 4); /* __MF_TYPE_STATIC */
   args = tree_cons (NULL_TREE, arg, args);
 
   arg = convert (size_type_node, object_size);
@@ -1161,7 +1161,7 @@ mudflap_enqueue_constant (tree obj)
     return;
 
   if (TREE_CODE (obj) == STRING_CST)
-    object_size = build_int_cst (NULL_TREE, TREE_STRING_LENGTH (obj), 0);
+    object_size = build_int_cst (NULL_TREE, TREE_STRING_LENGTH (obj));
   else
     object_size = size_in_bytes (TREE_TYPE (obj));
 
index 1d7806d..183d3ae 100644 (file)
@@ -405,7 +405,7 @@ get_trampoline_type (void)
       align = STACK_BOUNDARY;
     }
 
-  t = build_index_type (build_int_cst (NULL_TREE, size - 1, 0));
+  t = build_index_type (build_int_cst (NULL_TREE, size - 1));
   t = build_array_type (char_type_node, t);
   t = build_decl (FIELD_DECL, get_identifier ("__data"), t);
   DECL_ALIGN (t) = align;
@@ -489,7 +489,7 @@ get_nl_goto_field (struct nesting_info *info)
       size = size + 1;
 
       type = build_array_type
-       (type, build_index_type (build_int_cst (NULL_TREE, size, 0)));
+       (type, build_index_type (build_int_cst (NULL_TREE, size)));
 
       field = make_node (FIELD_DECL);
       DECL_NAME (field) = get_identifier ("__nl_goto_buf");
index 064c2b0..a00d717 100644 (file)
@@ -473,10 +473,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
          if (tree_int_cst_sgn (val) < 0)
            {
              pp_character (buffer, '-');
-             val = build_int_cst (NULL_TREE,
-                                  -TREE_INT_CST_LOW (val),
-                                  ~TREE_INT_CST_HIGH (val)
-                                  + !TREE_INT_CST_LOW (val));
+             val = build_int_cst_wide (NULL_TREE,
+                                       -TREE_INT_CST_LOW (val),
+                                       ~TREE_INT_CST_HIGH (val)
+                                       + !TREE_INT_CST_LOW (val));
            }
          /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
             systems?  */
index 9149aa6..f8f2ba5 100644 (file)
@@ -1150,7 +1150,7 @@ widen_bitfield (tree val, tree field, tree var)
 
       wide_val = build (BIT_AND_EXPR, TREE_TYPE (var), val, 
                        fold_convert (TREE_TYPE (var),
-                                     build_int_cst (NULL_TREE, mask, 0)));
+                                     build_int_cst (NULL_TREE, mask)));
     }
   else
     {
@@ -1162,7 +1162,7 @@ widen_bitfield (tree val, tree field, tree var)
 
       wide_val = build (BIT_IOR_EXPR, TREE_TYPE (var), val,
                        fold_convert (TREE_TYPE (var),
-                                     build_int_cst (NULL_TREE, mask, 0)));
+                                     build_int_cst (NULL_TREE, mask)));
     }
 
   return fold (wide_val);
@@ -1693,7 +1693,7 @@ maybe_fold_offset_to_array_ref (tree base, tree offset, tree orig_type)
          || lrem || hrem)
        return NULL_TREE;
 
-      idx = build_int_cst (NULL_TREE, lquo, hquo);
+      idx = build_int_cst_wide (NULL_TREE, lquo, hquo);
     }
 
   /* Assume the low bound is zero.  If there is a domain type, get the
index 5fd5363..fb66922 100644 (file)
@@ -1795,7 +1795,7 @@ simplify_rhs_and_lookup_avail_expr (struct dom_walk_data *walk_data,
 
          if (rhs_code == TRUNC_DIV_EXPR)
            t = build (RSHIFT_EXPR, TREE_TYPE (op0), op0,
-                      build_int_cst (NULL_TREE, tree_log2 (op1), 0));
+                      build_int_cst (NULL_TREE, tree_log2 (op1)));
          else
            t = build (BIT_AND_EXPR, TREE_TYPE (op0), op0,
                       local_fold (build (MINUS_EXPR, TREE_TYPE (op1),
index 67c5998..7271878 100644 (file)
@@ -86,7 +86,7 @@ create_canonical_iv (struct loop *loop, edge exit, tree niter)
   type = TREE_TYPE (niter);
   niter = fold (build2 (PLUS_EXPR, type,
                        niter,
-                       build_int_cst (type, 1, 0)));
+                       build_int_cst (type, 1)));
   incr_at = bsi_last (in->src);
   create_iv (niter,
             fold_convert (type, integer_minus_one_node),
@@ -96,7 +96,7 @@ create_canonical_iv (struct loop *loop, edge exit, tree niter)
   cmp = (exit->flags & EDGE_TRUE_VALUE) ? EQ_EXPR : NE_EXPR;
   COND_EXPR_COND (cond) = build2 (cmp, boolean_type_node,
                                  var,
-                                 build_int_cst (type, 0, 0));
+                                 build_int_cst (type, 0));
   modify_stmt (cond);
 }
 
@@ -221,7 +221,7 @@ canonicalize_loop_induction_variables (struct loops *loops, struct loop *loop,
         we expect (i.e. it returns number of executions of the exit
         condition, not of the loop latch edge).  */
       niter = fold (build2 (MINUS_EXPR, TREE_TYPE (niter), niter,
-                           build_int_cst (TREE_TYPE (niter), 1, 0)));
+                           build_int_cst (TREE_TYPE (niter), 1)));
     }
   else if (try_eval)
     niter = find_loop_niter_by_eval (loop, &exit);
index caba8b5..2a66a6b 100644 (file)
@@ -351,7 +351,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
         (inverse(s/d) * (c/d)) mod (size of mode/d).  */
       s = step0;
       d = integer_one_node;
-      bound = convert (niter_type, build_int_cst (NULL_TREE, ~0, ~0));
+      bound = convert (niter_type, build_int_cst (NULL_TREE, -1));
       while (1)
        {
          tmp = EXEC_BINARY (BIT_AND_EXPR, niter_type, s,
@@ -370,7 +370,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
       assumption = fold (build2 (FLOOR_MOD_EXPR, niter_type, base1, d));
       assumption = fold (build2 (EQ_EXPR, boolean_type_node,
                                 assumption,
-                                build_int_cst (niter_type, 0, 0)));
+                                build_int_cst (niter_type, 0)));
       assumptions = fold (build2 (TRUTH_AND_EXPR, boolean_type_node,
                                  assumptions, assumption));
 
@@ -884,7 +884,7 @@ loop_niter_by_eval (struct loop *loop, edge exit)
            fprintf (dump_file,
                     "Proved that loop %d iterates %d times using brute force.\n",
                     loop->num, i);
-         return build_int_cst (unsigned_type_node, i, 0);
+         return build_int_cst (unsigned_type_node, i);
        }
 
       for (j = 0; j < 2; j++)
@@ -1098,7 +1098,7 @@ upper_bound_in_type (tree outer, tree inner)
 
   return convert (outer,
                  convert (inner,
-                          build_int_cst (NULL_TREE, lo, hi)));
+                          build_int_cst_wide (NULL_TREE, lo, hi)));
 }
 
 /* Returns the smallest value obtainable by casting something in INNER type to
@@ -1125,7 +1125,7 @@ lower_bound_in_type (tree outer, tree inner)
 
   return convert (outer,
                  convert (inner,
-                          build_int_cst (NULL_TREE, lo, hi)));
+                          build_int_cst_wide (NULL_TREE, lo, hi)));
 }
 
 /* Returns true if statement S1 dominates statement S2.  */
index 0e6e7ca..34fbb9f 100644 (file)
@@ -560,7 +560,7 @@ vect_create_index_for_array_ref (tree stmt, block_stmt_iterator *bsi)
     abort ();  
 #endif
 
-  vf = build_int_cst (unsigned_type_node, vectorization_factor, 0);
+  vf = build_int_cst (unsigned_type_node, vectorization_factor);
 
   if (vect_debug_details (NULL))
     {
@@ -1457,7 +1457,7 @@ vect_transform_loop_bound (loop_vec_info loop_vinfo)
 
   /* new loop exit test:  */
   lb_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (orig_cond_expr, 0), 1));
-  new_loop_bound = build_int_cst (lb_type, old_N/vf, 0);
+  new_loop_bound = build_int_cst (lb_type, old_N/vf);
 
   if (exit_edge->flags & EDGE_TRUE_VALUE) /* 'then' edge exits the loop.  */
     cond = build2 (GE_EXPR, boolean_type_node, indx_after_incr, new_loop_bound);
@@ -2190,7 +2190,7 @@ vect_compute_data_ref_alignment (struct data_reference *dr,
   tree base_decl = NULL_TREE;
   tree bit_offset = size_zero_node;
   tree offset = size_zero_node;
-  tree unit_bits = build_int_cst (unsigned_type_node, BITS_PER_UNIT, 0);
+  tree unit_bits = build_int_cst (unsigned_type_node, BITS_PER_UNIT);
   tree nunits;
   tree alignment;
 
@@ -2294,10 +2294,10 @@ vect_compute_data_ref_alignment (struct data_reference *dr,
 
   /* alignment required, in bytes: */
   alignment = build_int_cst (unsigned_type_node, 
-                               TYPE_ALIGN (vectype)/BITS_PER_UNIT, 0);
+                            TYPE_ALIGN (vectype)/BITS_PER_UNIT);
   /* bytes per scalar element: */
   nunits = build_int_cst (unsigned_type_node, 
-                               GET_MODE_SIZE (TYPE_MODE (scalar_type)), 0);
+                         GET_MODE_SIZE (TYPE_MODE (scalar_type)));
 
   /* misalign = (offset + (init-array_first_index)*nunits) % alignment  */
   if (vect_debug_details (NULL))
index 12aa391..d56be7c 100644 (file)
@@ -428,11 +428,26 @@ copy_list (tree list)
 }
 
 \f
+/* Create an INT_CST node with a LOW value sign extended.  */
+
+tree build_int_cst (tree type, HOST_WIDE_INT low)
+{
+  return build_int_cst_wide (type, low,
+                            low < 0 ? -1 : 0);
+}
+
+/* Create an INT_CST node with a LOW value zero extended.  */
+
+tree build_int_cstu (tree type, unsigned HOST_WIDE_INT low)
+{
+  return build_int_cst_wide (type, low, 0);
+}
+
 /* Create an INT_CST node of TYPE and value HI:LOW.  If TYPE is NULL,
    integer_type_node is used.  */
 
 tree
-build_int_cst (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
+build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
 {
   tree t;
   int ix = -1;
@@ -5328,7 +5343,7 @@ make_vector_type (tree innertype, int nunits, enum machine_mode mode)
   layout_type (t);
 
   {
-    tree index = build_int_cst (NULL_TREE, nunits - 1, 0);
+    tree index = build_int_cst (NULL_TREE, nunits - 1);
     tree array = build_array_type (innertype, build_index_type (index));
     tree rt = make_node (RECORD_TYPE);
 
@@ -5405,7 +5420,7 @@ build_common_tree_nodes (bool signed_char, bool signed_sizetype)
      boolean_type_node before calling build_common_tree_nodes_2.  */
   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
-  TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1, 0);
+  TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
   TYPE_PRECISION (boolean_type_node) = 1;
 
   /* Fill in the rest of the sized types.  Reuse existing type nodes
@@ -5434,9 +5449,9 @@ void
 build_common_tree_nodes_2 (int short_double)
 {
   /* Define these next since types below may used them.  */
-  integer_zero_node = build_int_cst (NULL_TREE, 0, 0);
-  integer_one_node = build_int_cst (NULL_TREE, 1, 0);
-  integer_minus_one_node = build_int_cst (NULL_TREE, -1, -1);
+  integer_zero_node = build_int_cst (NULL_TREE, 0);
+  integer_one_node = build_int_cst (NULL_TREE, 1);
+  integer_minus_one_node = build_int_cst (NULL_TREE, -1);
 
   size_zero_node = size_int (0);
   size_one_node = size_int (1);
@@ -5455,8 +5470,7 @@ build_common_tree_nodes_2 (int short_double)
   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
   TYPE_USER_ALIGN (void_type_node) = 0;
 
-  null_pointer_node = build_int_cst (build_pointer_type (void_type_node),
-                                    0, 0);
+  null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
   layout_type (TREE_TYPE (null_pointer_node));
 
   ptr_type_node = build_pointer_type (void_type_node);
index a91cd4f..0c26e88 100644 (file)
@@ -2749,7 +2749,9 @@ extern tree build4_stat (enum tree_code, tree, tree, tree, tree,
                         tree MEM_STAT_DECL);
 #define build4(c,t1,t2,t3,t4,t5) build4_stat (c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
 
-extern tree build_int_cst (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
+extern tree build_int_cst (tree, HOST_WIDE_INT);
+extern tree build_int_cstu (tree, unsigned HOST_WIDE_INT);
+extern tree build_int_cst_wide (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
 extern tree build_vector (tree, tree);
 extern tree build_constructor (tree, tree);
 extern tree build_real_from_int_cst (tree, tree);