diff options
author | Richard Kenner <kenner@vlsi1.ultra.nyu.edu> | 2000-02-27 21:39:40 +0000 |
---|---|---|
committer | Richard Kenner <kenner@gcc.gnu.org> | 2000-02-27 16:39:40 -0500 |
commit | fed3cef0dbbd17e3d7b8860f42cd8490f0325340 (patch) | |
tree | da73c398c9c03435ecc0d3821031b7c0fe89911d /gcc/ch | |
parent | 43931371e2321b6c50c3e0b9095d46606ec48ce1 (diff) | |
download | gcc-fed3cef0dbbd17e3d7b8860f42cd8490f0325340.zip gcc-fed3cef0dbbd17e3d7b8860f42cd8490f0325340.tar.gz gcc-fed3cef0dbbd17e3d7b8860f42cd8490f0325340.tar.bz2 |
builtins.c (c_strlen): Use size_diffop and return ssizetype value.
* builtins.c (c_strlen): Use size_diffop and return ssizetype value.
(expand_builtin_strcpy): Pass correct type to size_binop.
(expand_builtin_strcmp): Likewise.
Clean up conditional structure.
* c-decl.c (init_decl_processing): Don't call set_sizetype twice.
(complete_array_type): Don't use size_binop for MAXINDEX.
* c-typeck.c (c_sizeof): Use size_one_node and TYPE_SIZE_UNIT.
(c_sizeof_nowarn, c_size_in_bytes): Likewise.
(c_alignof): Use size_one_node.
(build_unary_op): Pass arg of proper type to size_binop.
(really_start_incremental_init, push_init_level): Use sizetype for
constructor{,_bit,_unfilled}_index.
(pop_init_label, output_init_element): Likewise.
(output_pending_init_elements, process_init_element): Likewise.
* calls.c (compute_argument_block_size): Field VAR is ssizetype.
* expr.c (store_expr): Use size_int.
(store_constructor): Use proper types for size_binop args.
(get_inner_reference, expand_expr, case ARRAY_REF): Likewise.
(expand_expr_unaligned): Likewise.
(string_contant): Return object of sizetype.
* expr.h (SUB_PARM_SIZE): Call size_diffop and pass proper types.
(ARGS_SIZE_RTX): Call ARGS_SIZE_TREE.
(ARGS_SIZE_TREE): Pass proper types to size_binop.
* fold-const.c (int_const_binop): Refine when size_int is called.
(fold_convert): Likewise.
(size_int_wide): Rework to take KIND as arg, only take low order
bits, handle new sizetype_tab datatype, and chain entries in
size_table.
(size_int_type_wide): New function.
(size_binop): Validate types of arguments.
(ssize_binop): Deleted.
(size_diffop): New function.
(extract_muldiv): Only fold division into multiplication for sizetypes.
* function.c (assign_parms): Use size_diffop and make sure
VAR field is of ssizetype; also pass proper type to size_binop.
(locate_and_pad_parm, pad_to_arg_alignment): Likewise.
(round_down): Deleted from here.
* store-layout.c (sizetype_tab): Now an array.
(sizetype_set, early_root_list): New variables.
(variable_size): Use size_one_node.
(round_up): Pass proper type to size_binop.
(round_down): Moved to here and corrected as above.
(layout_record): Pass proper arg types to size_binop.
(layout_type): Likewise.
If sizetype_set is zero, record the type just laid out.
(make_unsigned_type): Don't call set_sizetype;
(make_signed_type): Likewise; also, call fixup_signed_type.
(initialize_sizetypes): New function.
(set_sizetype): Make copy of types, set TYPE_IS_SIZETYPE, and
set name of bitsizetype to "bit_size_type".
Fix up type of sizes of all types made before call.
* tm.texi (ROUND_TYPE_SIZE_UNIT): New macro.
* tree.c (fix_sizetype): Deleted.
(build_common_tree_nodes): Call initialize_sizetypes.
(build_common_tree_nodes_2): Don't call fix_sizetype.
* tree.h (TYPE_IS_SIZETYPE): New macro.
(initialize_sizetype): New declaration.
(enum size_type_kind): New type.
(struct sizetype_tab): Deleted.
(sizetype_tab): Now array; adjust sizetype macros.
(size_diffop, size_int_type_wide): New functions.
(size_int_wide): Change number of args and type; access macros changed.
(ssize_int, sbitsize_int): New macros.
* config/i960/i960.h (ROUND_TYPE_SIZE): Use size_int.
(ROUND_TYPE_SIZE_UNIT): New macro.
* ch/actions.c (chill_convert_for_assignment): Don't use size_binop
for things that aren't sizes.
(expand_varying_length_assignment): Likewise.
* ch/convert.c (digest_array_tuple, convert): Likewise.
* ch/typeck.c (build_chill_slice, smash_dummy_type): Likewise.
(build_chill_slice_with_range): Likewise.
(build_chill_slice_with_length): Likewise.
(build_array_from_set): Adjust types for size_binop.
* ch/expr.c (build_concat_expr, build_chill_repetition_op): Likewise.
(build_chill_sizeof): Use TYPE_SIZE_UNIT.
* ch/tree.c (build_string_type): Pass proper type to size_binop.
* cp/class.c (dfs_build_vtable_offset_vtbl_entries): Don't use
size_binop on things that are not sizes; ssize_binop deleted.
Call size_diffop when appropriate.
(dfs_build_vcall_offset_vtbl_entries): Likewise.
(build_primary_vtable, build_secondary_vtable): Likewise.
(dfs_set_offset_for_unshared_vbases, dfs_modify_vtables): Likewise.
Variable I is HOST_WIDE_INT.
(get_vfield_offset): Pass proper types to size_binop.
(size_extra_vtbl_entries, layout_virtual_bases): Likewise.
(finish_struct_1): Likewise.
(skip_rtti_stuff): Arg N is now pointer to signed.
(layout_class_type): Use size_zero_node.
* cp/cp-tree.h (skip_rtti_stuff): Arg N is pointer to signed.
* cp/cvt.c (cp_convert_to_pointer): Pass proper types to size_binop.
* cp/decl.c (complete_arry_type): Pass proper types to size_binop.
(xref_basetypes): BINFO_OFFSET is sizetype.
* cp/error.c (dump_expr): Don't use size_binop non-sizes.
* cp/expr.c (cplus_expand_constant): Pass proper types to size_binop.
* cp/init.c (construct_virtual_bases): Fix type error.
(build_vec_delete_1): Pass proper type to size_binop and don't
fold result.
* cp/lex.c (cp_make_lang_type): BINFO_OFFSET is sizetype.
* cp/rtti.c (get_base_offset): Pass proper type to size_binop.
* cp/search.c (dfs_find_vbases): Fix type error.
(expand_upcast_fixups): Arg to skip_rtti_stuff is pointer to signed.
(dfs_get_vbase_types): BINFO_OFFSET is sizetype.
* cp/tree.c (debug_binfo): Variable N is signed.
Use HOST_WIDE_INT_PRINT_DEC.
* cp/typeck.c (comptypes): sizetype is same as equivalent integer type.
(c_sizeof, c_sizeof_nowarn, expr_sizeof): Use TYPE_SIZE_UNIT,
size_one_node and size_zero_node.
(c_alignof): Use size_one_node.
(build_component_addr): Pass proper types to size_binop.
(expand_ptrmemfunc_cst): Don't use size_binop on non-sizes.
* f/com.c (ffecom_arrayref_): Convert args to size_binop to proper
type.
(ffecom_tree_canonize_ptr_): Don't use size_binop for non-sizes.
(ffecom_tree_canonize_ref_): Likewise.
(type_for_mode): Handle TImode.
* f/ste.c (ffeste_io_dofio_, ffeste_io_douio_): Use TYPE_SIZE_UNIT.
(ffeste_io_ciclist_): Likewise.
* java/expr.c (build_java_ret): Pass proper type to size_binop.
From-SVN: r32225
Diffstat (limited to 'gcc/ch')
-rw-r--r-- | gcc/ch/ChangeLog | 14 | ||||
-rw-r--r-- | gcc/ch/actions.c | 72 | ||||
-rw-r--r-- | gcc/ch/convert.c | 22 | ||||
-rw-r--r-- | gcc/ch/expr.c | 23 | ||||
-rw-r--r-- | gcc/ch/tree.c | 9 | ||||
-rw-r--r-- | gcc/ch/typeck.c | 54 |
6 files changed, 113 insertions, 81 deletions
diff --git a/gcc/ch/ChangeLog b/gcc/ch/ChangeLog index e8501c9..35df1ba 100644 --- a/gcc/ch/ChangeLog +++ b/gcc/ch/ChangeLog @@ -1,3 +1,17 @@ +Sun Feb 27 16:40:33 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu> + + * actions.c (chill_convert_for_assignment): Don't use size_binop + for things that aren't sizes. + (expand_varying_length_assignment): Likewise. + * convert.c (digest_array_tuple, convert): Likewise. + * typeck.c (build_chill_slice, smash_dummy_type): Likewise. + (build_chill_slice_with_range): Likewise. + (build_chill_slice_with_length): Likewise. + (build_array_from_set): Adjust types for size_binop. + * expr.c (build_concat_expr, build_chill_repetition_op): Likewise. + (build_chill_sizeof): Use TYPE_SIZE_UNIT. + * tree.c (build_string_type): Pass proper type to size_binop. + Sat Feb 19 18:43:13 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu> * decl.c (layout_enum): Set DECL_SIZE_UNIT. diff --git a/gcc/ch/actions.c b/gcc/ch/actions.c index b07a532..c97c1b6 100644 --- a/gcc/ch/actions.c +++ b/gcc/ch/actions.c @@ -1,5 +1,6 @@ /* Implement actions for CHILL. - Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc. + Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000 + Free Software Foundation, Inc. Authors: Per Bothner, Bill Cox, Michael Tiemann, Michael North This file is part of GNU CC. @@ -466,13 +467,12 @@ check_non_null (expr) return expr; } -/* - * There are four conditions to generate a runtime check: - * 1) assigning a longer INT to a shorter (signs irrelevant) - * 2) assigning a signed to an unsigned - * 3) assigning an unsigned to a signed of the same size. - * 4) TYPE is a discrete subrange - */ +/* There are four conditions to generate a runtime check: + 1) assigning a longer INT to a shorter (signs irrelevant) + 2) assigning a signed to an unsigned + 3) assigning an unsigned to a signed of the same size. + 4) TYPE is a discrete subrange */ + tree chill_convert_for_assignment (type, expr, place) tree type, expr; @@ -558,10 +558,10 @@ chill_convert_for_assignment (type, expr, place) } result = convert (type, expr); - /* If the type is a array of PACK bits and the expression is an array constructor, - then build a CONSTRUCTOR for a bitstring. Bitstrings are zero based, so - decrement the value of each CONSTRUCTOR element by the amount of the lower - bound of the array. */ + /* If the type is a array of PACK bits and the expression is an array + constructor, then build a CONSTRUCTOR for a bitstring. Bitstrings are + zero based, so decrement the value of each CONSTRUCTOR element by the + amount of the lower bound of the array. */ if (TREE_CODE (type) == ARRAY_TYPE && TYPE_PACKED (type) && TREE_CODE (result) == CONSTRUCTOR) { @@ -569,6 +569,7 @@ chill_convert_for_assignment (type, expr, place) tree new_list = NULL_TREE; long index; tree element; + for (element = TREE_OPERAND (result, 1); element != NULL_TREE; element = TREE_CHAIN (element)) @@ -579,18 +580,21 @@ chill_convert_for_assignment (type, expr, place) switch (TREE_CODE (purpose)) { case INTEGER_CST: - new_list = tree_cons (NULL_TREE, - size_binop (MINUS_EXPR, purpose, domain_min), - new_list); + new_list + = tree_cons (NULL_TREE, + fold (build (MINUS_EXPR, TREE_TYPE (purpose), + purpose, domain_min)), + new_list); break; case RANGE_EXPR: for (index = TREE_INT_CST_LOW (TREE_OPERAND (purpose, 0)); index <= TREE_INT_CST_LOW (TREE_OPERAND (purpose, 1)); index++) new_list = tree_cons (NULL_TREE, - size_binop (MINUS_EXPR, - build_int_2 (index, 0), - domain_min), + fold (build (MINUS_EXPR, + integer_type_node, + build_int_2 (index, 0), + domain_min)), new_list); break; default: @@ -1697,11 +1701,12 @@ chill_expand_assignment (lhs, modifycode, rhs) tree from_pos = save_expr (TREE_OPERAND (lhs, 0)); tree set = TREE_OPERAND (lhs, 1); tree domain = TYPE_DOMAIN (TREE_TYPE (set)); - tree set_length = size_binop (PLUS_EXPR, - size_binop (MINUS_EXPR, - TYPE_MAX_VALUE (domain), - TYPE_MIN_VALUE (domain)), - integer_one_node); + tree set_length + = fold (build (PLUS_EXPR, integer_type_node, + fold (build (MINUS_EXPR, integer_type_node, + TYPE_MAX_VALUE (domain), + TYPE_MIN_VALUE (domain))), + integer_one_node)); tree filename = force_addr_of (get_chill_filename()); if (TREE_CODE (TREE_TYPE (lhs)) != BOOLEAN_TYPE) @@ -1750,19 +1755,22 @@ chill_expand_assignment (lhs, modifycode, rhs) tree numbits = TREE_OPERAND (lhs, 1); tree from_pos = save_expr (TREE_OPERAND (lhs, 2)); tree domain = TYPE_DOMAIN (TREE_TYPE (set)); - tree set_length = size_binop (PLUS_EXPR, - size_binop (MINUS_EXPR, - TYPE_MAX_VALUE (domain), - TYPE_MIN_VALUE (domain)), - integer_one_node); + tree set_length + = fold (build (PLUS_EXPR, integer_type_node, + fold (build (MINUS_EXPR, integer_type_node, + TYPE_MAX_VALUE (domain), + TYPE_MIN_VALUE (domain))), + integer_one_node)); tree filename = force_addr_of (get_chill_filename()); tree to_pos; + switch (TREE_CODE (TREE_TYPE (rhs))) { case SET_TYPE: - to_pos = size_binop (MINUS_EXPR, - size_binop (PLUS_EXPR, from_pos, numbits), - integer_one_node); + to_pos = fold (build (MINUS_EXPR, integer_type_node, + fold (build (PLUS_EXPR, integer_type_node, + from_pos, numbits)), + integer_one_node)); break; case BOOLEAN_TYPE: to_pos = from_pos; @@ -1812,7 +1820,7 @@ expand_varying_length_assignment (lhs, rhs) min_domain_val = TYPE_MIN_VALUE (TYPE_DOMAIN (base_array)); lhs = build_component_ref (lhs, var_length_id); - rhs = size_binop (MINUS_EXPR, rhs, min_domain_val); + rhs = fold (build (MINUS_EXPR, TREE_TYPE (rhs), rhs, min_domain_val)); expand_expr_stmt (build_chill_modify_expr (lhs, rhs)); } diff --git a/gcc/ch/convert.c b/gcc/ch/convert.c index 80405da..dcea057 100644 --- a/gcc/ch/convert.c +++ b/gcc/ch/convert.c @@ -1,5 +1,6 @@ /* Language-level data type conversion for GNU CHILL. - Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc. + Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000 + Free Software Foundation, Inc. This file is part of GNU CC. @@ -858,14 +859,12 @@ digest_array_tuple (type, init, allow_missing_elements) } /* Calculate the last element of the gap. */ if (*ptr) - { - /* Actually end up with correct type. */ - last = size_binop (MINUS_EXPR, - CONSTRUCTOR_ELT_LO (*ptr), - integer_one_node); - } + last = fold (build (MINUS_EXPR, integer_type_node, + CONSTRUCTOR_ELT_LO (*ptr), + integer_one_node)); else last = domain_max; + if (TREE_CODE (last) == INTEGER_CST && tree_int_cst_lt (last, first)) ; /* Empty "gap" - no missing elements. */ else if (default_value) @@ -1058,16 +1057,17 @@ convert (type, expr) { /* Note that array_type_nelts returns 1 less than the size. */ nentries = array_type_nelts (TREE_TYPE (e)); - needed_padding = size_binop (MINUS_EXPR, - array_type_nelts (target_array_type), - nentries); + needed_padding = fold (build (MINUS_EXPR, integer_type_node, + array_type_nelts (target_array_type), + nentries)); if (TREE_CODE (needed_padding) != INTEGER_CST) { padding_max_size = size_in_bytes (TREE_TYPE (e)); if (TREE_CODE (padding_max_size) != INTEGER_CST) padding_max_size = TYPE_ARRAY_MAX_SIZE (TREE_TYPE (e)); } - nentries = size_binop (PLUS_EXPR, nentries, integer_one_node); + nentries = fold (build (PLUS_EXPR, integer_type_node, + nentries, integer_one_node)); } else if (TREE_CODE (e) == CONSTRUCTOR) { diff --git a/gcc/ch/expr.c b/gcc/ch/expr.c index 13e5bd8..b4bdf35 100644 --- a/gcc/ch/expr.c +++ b/gcc/ch/expr.c @@ -1,6 +1,7 @@ /* Convert language-specific tree expression to rtl instructions, for GNU CHILL compiler. - Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc. + Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000 + Free Software Foundation, Inc. This file is part of GNU CC. @@ -2264,8 +2265,9 @@ build_chill_sizeof (type) return error_mark_node; } - temp = size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type), - size_int (TYPE_PRECISION (char_type_node))); + temp = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type), + size_int (TYPE_PRECISION (char_type_node) + / BITS_PER_UNIT)); if (signame != NULL_TREE) { /* we have a signal definition. This signal may have no @@ -3344,9 +3346,9 @@ build_concat_expr (op0, op1) if (TREE_CODE (type0) == SET_TYPE) { - result_size = size_binop (PLUS_EXPR, - discrete_count (TYPE_DOMAIN (type0)), - discrete_count (TYPE_DOMAIN (type1))); + result_size = fold (build (PLUS_EXPR, integer_type_node, + discrete_count (TYPE_DOMAIN (type0)), + discrete_count (TYPE_DOMAIN (type1)))); result_class.mode = build_bitstring_type (result_size); } else @@ -4250,15 +4252,16 @@ build_chill_repetition_op (count_op, string) for (temp = vallist; temp; temp = TREE_CHAIN (temp)) { tree new_value - = fold (size_binop (PLUS_EXPR, origin, TREE_VALUE (temp))); + = fold (build (PLUS_EXPR, TREE_TYPE (origin), + TREE_VALUE (temp))); tree new_purpose = NULL_TREE; + if (! TREE_CONSTANT (TREE_VALUE (temp))) tree_const = 0; if (TREE_PURPOSE (temp)) { - new_purpose = fold (size_binop (PLUS_EXPR, - origin, - TREE_PURPOSE (temp))); + new_purpose = fold (build (PLUS_EXPR, TREE_TYPE (origin), + origin, TREE_PURPOSE (temp))); if (! TREE_CONSTANT (TREE_PURPOSE (temp))) tree_const = 0; } diff --git a/gcc/ch/tree.c b/gcc/ch/tree.c index 88fd5ff..53485db 100644 --- a/gcc/ch/tree.c +++ b/gcc/ch/tree.c @@ -1,5 +1,6 @@ /* Language-dependent node constructors for parse phase of GNU compiler. - Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc. + Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000 + Free Software Foundation, Inc. This file is part of GNU CC. @@ -65,9 +66,9 @@ build_string_type (elt_type, length) /* Subtract 1 from length to get max index value. Note we cannot use size_binop for pass 1 expressions. */ if (TREE_CODE (length) == INTEGER_CST || pass != 1) - length = size_binop (MINUS_EXPR, length, integer_one_node); + length = size_binop (MINUS_EXPR, length, size_one_node); else - length = build (MINUS_EXPR, sizetype, length, integer_one_node); + length = build (MINUS_EXPR, sizetype, length, size_one_node); t = make_node (elt_type == boolean_type_node ? SET_TYPE : ARRAY_TYPE); TREE_TYPE (t) = elt_type; @@ -289,7 +290,9 @@ discrete_count (t) tree t; { tree hi = convert (sizetype, TYPE_MAX_VALUE (t)); + if (TYPE_MIN_VALUE (t)) hi = size_binop (MINUS_EXPR, hi, convert (sizetype, TYPE_MIN_VALUE (t))); + return size_binop (PLUS_EXPR, hi, integer_one_node); } diff --git a/gcc/ch/typeck.c b/gcc/ch/typeck.c index 5082b78..8c74896 100644 --- a/gcc/ch/typeck.c +++ b/gcc/ch/typeck.c @@ -1,5 +1,6 @@ /* Build expressions with type checking for CHILL compiler. - Copyright (C) 1992, 93, 94, 98, 99, 2000 Free Software Foundation, Inc. + Copyright (C) 1992, 1993, 1994, 1998, 1999, 2000 + Free Software Foundation, Inc. This file is part of GNU CC. @@ -215,17 +216,17 @@ build_chill_slice (array, min_value, length) The static allocation info is passed by using the parent array's limits to compute a temp_size, which is passed in the lang_specific - field of the slice_type. - */ + field of the slice_type. */ if (TREE_CODE (array_type) == ARRAY_TYPE) { tree domain_type = TYPE_DOMAIN (array_type); tree domain_min = TYPE_MIN_VALUE (domain_type); - tree domain_max = fold (build (PLUS_EXPR, domain_type, - domain_min, - size_binop (MINUS_EXPR, - length, integer_one_node))); + tree domain_max + = fold (build (PLUS_EXPR, domain_type, + domain_min, + fold (build (MINUS_EXPR, integer_type_node, + length, integer_one_node)))); tree index_type = build_chill_range_type (TYPE_DOMAIN (array_type), domain_min, domain_max); @@ -408,13 +409,15 @@ build_chill_slice_with_range (array, min_value, max_value) && tree_int_cst_lt (max_value, min_value)) return build_empty_string (TREE_TYPE (TREE_TYPE (array))); - return build_chill_slice (array, min_value, - save_expr (size_binop (PLUS_EXPR, - size_binop (MINUS_EXPR, max_value, min_value), - integer_one_node))); + return + build_chill_slice + (array, min_value, + save_expr (fold (build (PLUS_EXPR, integer_type_node, + fold (build (MINUS_EXPR, integer_type_node, + max_value, min_value)), + integer_one_node)))); } - tree build_chill_slice_with_length (array, min_value, length) tree array, min_value, length; @@ -450,9 +453,10 @@ build_chill_slice_with_length (array, min_value, length) length = integer_one_node; } - max_index = size_binop (MINUS_EXPR, - size_binop (PLUS_EXPR, length, min_value), - integer_one_node); + max_index = fold (build (MINUS_EXPR, integer_type_node, + fold (build (PLUS_EXPR, integer_type_node, + length, min_value)), + integer_one_node)); max_index = convert_to_class (chill_expr_class (min_value), max_index); min_value = valid_array_index_p (array, min_value, @@ -1208,22 +1212,22 @@ build_chill_cast (type, expr) return expr; } -/* - * given a set_type, build an integer array from it that C will grok. - */ +/* Given a set_type, build an integer array from it that C will grok. */ + tree build_array_from_set (type) tree type; { tree bytespint, bit_array_size, int_array_count; - if (type == NULL_TREE || type == error_mark_node || TREE_CODE (type) != SET_TYPE) + if (type == NULL_TREE || type == error_mark_node + || TREE_CODE (type) != SET_TYPE) return error_mark_node; - bytespint = build_int_2 (HOST_BITS_PER_INT / HOST_BITS_PER_CHAR, 0); + /* ??? Should this really be *HOST*?? */ + bytespint = size_int (HOST_BITS_PER_INT / HOST_BITS_PER_CHAR); bit_array_size = size_in_bytes (type); - int_array_count = fold (size_binop (TRUNC_DIV_EXPR, bit_array_size, - bytespint)); + int_array_count = size_binop (TRUNC_DIV_EXPR, bit_array_size, bytespint); if (integer_zerop (int_array_count)) int_array_count = size_one_node; type = build_array_type (integer_type_node, @@ -3371,9 +3375,9 @@ smash_dummy_type (type) { tree oldindex = TYPE_DOMAIN (origin); new_max = check_range (new_max, new_max, NULL_TREE, - size_binop (PLUS_EXPR, - TYPE_MAX_VALUE (oldindex), - integer_one_node)); + fold (build (PLUS_EXPR, integer_type_node, + TYPE_MAX_VALUE (oldindex), + integer_one_node))); origin = build_string_type (TREE_TYPE (origin), new_max); } else if (TREE_CODE (origin) == ARRAY_TYPE) |