From b0c48229854447bec65f7f5a6ef1dbbe451cc3fb Mon Sep 17 00:00:00 2001 From: Neil Booth Date: Fri, 29 Mar 2002 21:46:27 +0000 Subject: [PATCH] Makefile.in (convert.o, [...]): Update. * Makefile.in (convert.o, calls.o, expmed.o): Update. * attribs.c (handle_mode_attribute, handle_vector_size_attribute): Use new hooks. * builtin-types.def (BT_PTRMODE): Update. * c-common.c (type_for_size): Rename c_common_type_for_size. (type_for_mode): Similarly. (shorten_compare, pointer_int_sum, c_common_nodes_and_builtins): Use new hook. * c-bommon.h (c_common_type_for_size, c_common_type_for_mode): New. * c-decl.c (finish_enum, build_enumerator): Use new hooks. * c-lang.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIZE): Redefine. * c-typeck.c (common_type, comptypes, default_conversion): Use new hooks. * calls.c: Include langhooks.h. (emit_library_call_value_1): Use new hooks. Avoid redundant calls. * convert.c: Include langhooks.h (convert_to_pointer, convert_to_integer): Use new hooks. * except.c (init_eh): Similarly. * expmed.c: Include langhooks.h. (expand_mult_add): Use new hooks. * expr.c (store_expr, store_constructor, expand_expr, do_jump, try_casesi): Similarly. * fold-const.c (optimize_bit_field_compare, make_range, decode_field_reference, fold_truthop, fold): Similarly. * function.c (assign_stack_local_1, assign_stack_temp_for_type, put_var_into_stack): Similarly. * langhooks-def.h (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIZE): New. (LANG_HOOKS_TYPES_INITIALIZER): Update. * langhooks.h (lang_hooks_for_types): New hooks. * stmt.c (expand_decl_cleanup, emit_case_nodes): Use new hooks. * tree.c (get_unwidened, get_narrower): Similarly. * tree.h (type_for_mode, type_for_size): Remove. * varasm.c (force_const_mem): Use new hooks. ada: * gigi.h (type_for_size, type_for_mode): Rename. * misc.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIZE): Redefine. * trans.c (tree_transform): Update. * utils.c (gnat_init_decl_processing, init_gigi_decls, builtin_function, float_type_for_size, signed_or_unsigned_type, build_vms_descriptor, unchecked_convert): Update. (type_for_mode, type_for_size): Rename. * utils2.c (nonbinary_modular_operation): Update. cp: * cp-lang.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIZE): Redefine. * cvt.c (cp_convert_to_pointer, type_promotes_to): Use new hooks. * decl.c (finish_enum): Similarly. * error.c (dump_type): Similarly. * lex.c (cxx_init): Similarly. * mangle.c (write_builtin_type): Similarly. * typeck.c (comptypes): Similarly. f: * com.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIZE): Redefine. (type_for_mode, type_for_size): Rename. (signed_or_unsigned_type, signed_type, truthvalue_conversion, unsigned_type): Use new hooks. java: * Make-lang.in (builtins.o): Update. * boehm.c (get_boehm_type_descriptor): Update. * builtins.c: Include langhooks.h. * decl.c (java_init_decl_processing): Update. * java-tree.h (java_type_for_mode, java_type_for_size): New. * lang.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIaZE): Redefine. * typeck.c (type_for_mode, type_for_size): Update. objc: * objc-act.c (handle_impent): Update. * objc-lang.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIaZE): Redefine. From-SVN: r51571 --- gcc/ChangeLog | 44 +++++++++++++++++++++++++++++++++ gcc/Makefile.in | 8 +++--- gcc/ada/gigi.h | 4 +-- gcc/ada/misc.c | 4 +++ gcc/ada/trans.c | 2 +- gcc/ada/utils.c | 57 +++++++++++++++++++++++-------------------- gcc/ada/utils2.c | 4 +-- gcc/attribs.c | 7 +++--- gcc/builtin-types.def | 2 +- gcc/c-common.c | 13 +++++----- gcc/c-common.h | 3 +++ gcc/c-decl.c | 13 +++++----- gcc/c-lang.c | 5 ++++ gcc/c-typeck.c | 18 +++++++------- gcc/calls.c | 46 +++++++++++++++++++--------------- gcc/convert.c | 20 ++++++++------- gcc/cp/ChangeLog | 11 +++++++++ gcc/cp/cp-lang.c | 4 +++ gcc/cp/cvt.c | 6 ++--- gcc/cp/decl.c | 2 +- gcc/cp/error.c | 2 +- gcc/cp/lex.c | 2 +- gcc/cp/mangle.c | 3 ++- gcc/cp/typeck.c | 4 +-- gcc/except.c | 3 ++- gcc/expmed.c | 6 +++-- gcc/expr.c | 22 ++++++++++------- gcc/f/ChangeLog | 8 ++++++ gcc/f/com.c | 20 +++++++++------ gcc/fold-const.c | 17 +++++++------ gcc/function.c | 6 ++--- gcc/java/ChangeLog | 11 +++++++++ gcc/java/Make-lang.in | 2 +- gcc/java/boehm.c | 2 +- gcc/java/builtins.c | 2 +- gcc/java/decl.c | 2 +- gcc/java/java-tree.h | 2 ++ gcc/java/lang.c | 4 +++ gcc/java/typeck.c | 4 +-- gcc/langhooks-def.h | 7 ++++-- gcc/langhooks.h | 10 ++++++++ gcc/objc/objc-act.c | 2 +- gcc/objc/objc-lang.c | 5 ++++ gcc/stmt.c | 5 ++-- gcc/tree.c | 10 ++++---- gcc/tree.h | 14 ----------- gcc/varasm.c | 5 ++-- 47 files changed, 293 insertions(+), 160 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 17695ffa5db..1b85c02f6c8 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,47 @@ +2002-03-29 Neil Booth + + * Makefile.in (convert.o, calls.o, expmed.o): Update. + * attribs.c (handle_mode_attribute, handle_vector_size_attribute): + Use new hooks. + * builtin-types.def (BT_PTRMODE): Update. + * c-common.c (type_for_size): Rename c_common_type_for_size. + (type_for_mode): Similarly. + (shorten_compare, pointer_int_sum, c_common_nodes_and_builtins): + Use new hook. + * c-bommon.h (c_common_type_for_size, c_common_type_for_mode): New. + * c-decl.c (finish_enum, build_enumerator): Use new hooks. + * c-lang.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIZE): + Redefine. + * c-typeck.c (common_type, comptypes, default_conversion): + Use new hooks. + * calls.c: Include langhooks.h. + (emit_library_call_value_1): Use new hooks. Avoid redundant + calls. + * convert.c: Include langhooks.h + (convert_to_pointer, convert_to_integer): Use new hooks. + * except.c (init_eh): Similarly. + * expmed.c: Include langhooks.h. + (expand_mult_add): Use new hooks. + * expr.c (store_expr, store_constructor, expand_expr, do_jump, + try_casesi): Similarly. + * fold-const.c (optimize_bit_field_compare, make_range, + decode_field_reference, fold_truthop, fold): Similarly. + * function.c (assign_stack_local_1, assign_stack_temp_for_type, + put_var_into_stack): Similarly. + * langhooks-def.h (LANG_HOOKS_TYPE_FOR_MODE, + LANG_HOOKS_TYPE_FOR_SIZE): New. + (LANG_HOOKS_TYPES_INITIALIZER): Update. + * langhooks.h (lang_hooks_for_types): New hooks. + * stmt.c (expand_decl_cleanup, emit_case_nodes): Use new hooks. + * tree.c (get_unwidened, get_narrower): Similarly. + * tree.h (type_for_mode, type_for_size): Remove. + * varasm.c (force_const_mem): Use new hooks. + * utils2.c (nonbinary_modular_operation): Update. +objc: + * objc-act.c (handle_impent): Update. + * objc-lang.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIaZE): + Redefine. + 2002-03-29 Steve Ellcey * config/ia64/ia64.md (*ptr_extend_plus_1, *ptr_extend_plus_2): New. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 7162b3264c2..23fba7f2071 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1319,7 +1319,8 @@ prefix.o: prefix.c $(CONFIG_H) $(SYSTEM_H) Makefile prefix.h -DPREFIX=\"$(prefix)\" \ -c $(srcdir)/prefix.c $(OUTPUT_OPTION) -convert.o: convert.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) flags.h convert.h toplev.h +convert.o: convert.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) flags.h convert.h \ + toplev.h langhooks.h langhooks.o : langhooks.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) toplev.h \ tree-inline.h $(RTL_H) insn-config.h integrate.h langhooks.h \ @@ -1395,11 +1396,12 @@ builtins.o : builtins.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) $(TREE_H) flags.h \ $(TARGET_H) function.h $(REGS_H) $(EXPR_H) $(OPTABS_H) insn-config.h \ $(RECOG_H) output.h typeclass.h hard-reg-set.h toplev.h hard-reg-set.h \ except.h $(TM_P_H) $(PREDICT_H) libfuncs.h -calls.o : calls.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) $(TREE_H) flags.h $(EXPR_H) \ +calls.o : calls.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) $(TREE_H) flags.h \ + $(EXPR_H) langhooks.h \ libfuncs.h $(REGS_H) toplev.h output.h function.h $(TIMEVAR_H) $(TM_P_H) expmed.o : expmed.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) $(TREE_H) flags.h \ insn-config.h $(EXPR_H) $(OPTABS_H) $(RECOG_H) real.h \ - toplev.h $(TM_P_H) + toplev.h $(TM_P_H) langhooks.h explow.o : explow.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) $(TREE_H) flags.h \ hard-reg-set.h insn-config.h $(EXPR_H) $(OPTABS_H) $(RECOG_H) \ toplev.h function.h ggc.h $(TM_P_H) diff --git a/gcc/ada/gigi.h b/gcc/ada/gigi.h index b8da148cc62..0223eac3c59 100644 --- a/gcc/ada/gigi.h +++ b/gcc/ada/gigi.h @@ -423,11 +423,11 @@ extern void gnat_init_gcc_eh PARAMS ((void)); /* Return an integer type with the number of bits of precision given by PRECISION. UNSIGNEDP is nonzero if the type is unsigned; otherwise it is a signed type. */ -extern tree type_for_size PARAMS ((unsigned, int)); +extern tree gnat_type_for_size PARAMS ((unsigned, int)); /* Return a data type that has machine mode MODE. UNSIGNEDP selects an unsigned type; otherwise a signed type is returned. */ -extern tree type_for_mode PARAMS ((enum machine_mode, int)); +extern tree gnat_type_for_mode PARAMS ((enum machine_mode, int)); /* Return the unsigned version of a TYPE_NODE, a scalar type. */ extern tree unsigned_type PARAMS ((tree)); diff --git a/gcc/ada/misc.c b/gcc/ada/misc.c index 982e7c00580..78222c2f8d7 100644 --- a/gcc/ada/misc.c +++ b/gcc/ada/misc.c @@ -118,6 +118,10 @@ static rtx gnat_expand_expr PARAMS ((tree, rtx, enum machine_mode, #define LANG_HOOKS_PRINT_TYPE gnat_print_type #undef LANG_HOOKS_DECL_PRINTABLE_NAME #define LANG_HOOKS_DECL_PRINTABLE_NAME gnat_printable_name +#undef LANG_HOOKS_TYPE_FOR_MODE +#define LANG_HOOKS_TYPE_FOR_MODE gnat_type_for_mode +#undef LANG_HOOKS_TYPE_FOR_SIZE +#define LANG_HOOKS_TYPE_FOR_SIZE gnat_type_for_size const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER; diff --git a/gcc/ada/trans.c b/gcc/ada/trans.c index 9875bb1d0a9..c943a009225 100644 --- a/gcc/ada/trans.c +++ b/gcc/ada/trans.c @@ -2994,7 +2994,7 @@ tree_transform (gnat_node) gnu_actual = unchecked_convert (DECL_ARG_TYPE (get_gnu_tree (gnat_formal)), - convert (type_for_size + convert (gnat_type_for_size (tree_low_cst (gnu_actual_size, 1), 1), integer_zero_node)); else diff --git a/gcc/ada/utils.c b/gcc/ada/utils.c index 776fbbeb2f0..d01e7d84a4d 100644 --- a/gcc/ada/utils.c +++ b/gcc/ada/utils.c @@ -499,7 +499,7 @@ gnat_init_decl_processing () /* In Ada, we use a signed type for SIZETYPE. Use the signed type corresponding to the size of ptr_mode. Make this here since we need this before we can expand the GNAT types. */ - set_sizetype (type_for_size (GET_MODE_BITSIZE (ptr_mode), 0)); + set_sizetype (gnat_type_for_size (GET_MODE_BITSIZE (ptr_mode), 0)); build_common_tree_nodes_2 (0); pushdecl (build_decl (TYPE_DECL, get_identifier (SIZE_TYPE), sizetype)); @@ -543,7 +543,7 @@ init_gigi_decls (long_long_float_type, exception_type) except_type_node = TREE_TYPE (exception_type); - unsigned_type_node = type_for_size (INT_TYPE_SIZE, 1); + unsigned_type_node = gnat_type_for_size (INT_TYPE_SIZE, 1); pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"), unsigned_type_node)); @@ -579,7 +579,7 @@ init_gigi_decls (long_long_float_type, exception_type) /* Make the types and functions used for exception processing. */ jmpbuf_type - = build_array_type (type_for_mode (Pmode, 0), + = build_array_type (gnat_type_for_mode (Pmode, 0), build_index_type (build_int_2 (5, 0))); pushdecl (build_decl (TYPE_DECL, get_identifier ("JMPBUF_T"), jmpbuf_type)); jmpbuf_ptr_type = build_pointer_type (jmpbuf_type); @@ -1954,7 +1954,7 @@ builtin_function (name, type, function_code, class, library_name) it is a signed type. */ tree -type_for_size (precision, unsignedp) +gnat_type_for_size (precision, unsignedp) unsigned precision; int unsignedp; { @@ -2015,14 +2015,14 @@ float_type_for_size (precision, mode) an unsigned type; otherwise a signed type is returned. */ tree -type_for_mode (mode, unsignedp) +gnat_type_for_mode (mode, unsignedp) enum machine_mode mode; int unsignedp; { if (GET_MODE_CLASS (mode) == MODE_FLOAT) return float_type_for_size (GET_MODE_BITSIZE (mode), mode); else - return type_for_size (GET_MODE_BITSIZE (mode), unsignedp); + return gnat_type_for_size (GET_MODE_BITSIZE (mode), unsignedp); } /* Return the unsigned version of a TYPE_NODE, a scalar type. */ @@ -2031,7 +2031,7 @@ tree unsigned_type (type_node) tree type_node; { - tree type = type_for_size (TYPE_PRECISION (type_node), 1); + tree type = gnat_type_for_size (TYPE_PRECISION (type_node), 1); if (TREE_CODE (type_node) == INTEGER_TYPE && TYPE_MODULAR_P (type_node)) { @@ -2055,7 +2055,7 @@ tree signed_type (type_node) tree type_node; { - tree type = type_for_size (TYPE_PRECISION (type_node), 0); + tree type = gnat_type_for_size (TYPE_PRECISION (type_node), 0); if (TREE_CODE (type_node) == INTEGER_TYPE && TYPE_MODULAR_P (type_node)) { @@ -2084,7 +2084,7 @@ signed_or_unsigned_type (unsignedp, type) if (! INTEGRAL_TYPE_P (type) || TREE_UNSIGNED (type) == unsignedp) return type; else - return type_for_size (TYPE_PRECISION (type), unsignedp); + return gnat_type_for_size (TYPE_PRECISION (type), unsignedp); } /* EXP is an expression for the size of an object. If this size contains @@ -2401,14 +2401,16 @@ build_vms_descriptor (type, mech, gnat_entity) field_list = chainon (field_list, make_descriptor_field - ("LENGTH", type_for_size (16, 1), record_type, + ("LENGTH", gnat_type_for_size (16, 1), record_type, size_in_bytes (mech == By_Descriptor_A ? inner_type : type))); field_list = chainon (field_list, - make_descriptor_field ("DTYPE", type_for_size (8, 1), + make_descriptor_field ("DTYPE", + gnat_type_for_size (8, 1), record_type, size_int (dtype))); field_list = chainon (field_list, - make_descriptor_field ("CLASS", type_for_size (8, 1), + make_descriptor_field ("CLASS", + gnat_type_for_size (8, 1), record_type, size_int (class))); field_list @@ -2431,13 +2433,13 @@ build_vms_descriptor (type, mech, gnat_entity) field_list = chainon (field_list, make_descriptor_field - ("SB_L1", type_for_size (32, 1), record_type, + ("SB_L1", gnat_type_for_size (32, 1), record_type, TREE_CODE (type) == ARRAY_TYPE ? TYPE_MIN_VALUE (TYPE_DOMAIN (type)) : size_zero_node)); field_list = chainon (field_list, make_descriptor_field - ("SB_L2", type_for_size (32, 1), record_type, + ("SB_L2", gnat_type_for_size (32, 1), record_type, TREE_CODE (type) == ARRAY_TYPE ? TYPE_MAX_VALUE (TYPE_DOMAIN (type)) : size_zero_node)); break; @@ -2446,20 +2448,20 @@ build_vms_descriptor (type, mech, gnat_entity) case By_Descriptor_NCA: field_list = chainon (field_list, make_descriptor_field ("SCALE", - type_for_size (8, 1), + gnat_type_for_size (8, 1), record_type, size_zero_node)); field_list = chainon (field_list, make_descriptor_field ("DIGITS", - type_for_size (8, 1), + gnat_type_for_size (8, 1), record_type, size_zero_node)); field_list = chainon (field_list, make_descriptor_field - ("AFLAGS", type_for_size (8, 1), record_type, + ("AFLAGS", gnat_type_for_size (8, 1), record_type, size_int (mech == By_Descriptor_NCA ? 0 /* Set FL_COLUMN, FL_COEFF, and FL_BOUNDS. */ @@ -2469,13 +2471,13 @@ build_vms_descriptor (type, mech, gnat_entity) field_list = chainon (field_list, make_descriptor_field ("DIMCT", - type_for_size (8, 1), + gnat_type_for_size (8, 1), record_type, size_int (ndim))); field_list = chainon (field_list, make_descriptor_field ("ARSIZE", - type_for_size (32, 1), + gnat_type_for_size (32, 1), record_type, size_in_bytes (type))); @@ -2507,11 +2509,11 @@ build_vms_descriptor (type, mech, gnat_entity) fname[0] = (mech == By_Descriptor_NCA ? 'S' : 'M'); fname[1] = '0' + i, fname[2] = 0; - field_list = chainon (field_list, - make_descriptor_field (fname, - type_for_size (32, 1), - record_type, - idx_length)); + field_list + = chainon (field_list, + make_descriptor_field (fname, + gnat_type_for_size (32, 1), + record_type, idx_length)); if (mech == By_Descriptor_NCA) tem = idx_length; @@ -2526,14 +2528,14 @@ build_vms_descriptor (type, mech, gnat_entity) field_list = chainon (field_list, make_descriptor_field - (fname, type_for_size (32, 1), record_type, + (fname, gnat_type_for_size (32, 1), record_type, TYPE_MIN_VALUE (idx_arr[i]))); fname[0] = 'U'; field_list = chainon (field_list, make_descriptor_field - (fname, type_for_size (32, 1), record_type, + (fname, gnat_type_for_size (32, 1), record_type, TYPE_MAX_VALUE (idx_arr[i]))); } break; @@ -3348,7 +3350,8 @@ unchecked_convert (type, expr) 0)) && ! (TREE_UNSIGNED (type) && TREE_UNSIGNED (etype))) { - tree base_type = type_for_mode (TYPE_MODE (type), TREE_UNSIGNED (type)); + tree base_type = gnat_type_for_mode (TYPE_MODE (type), + TREE_UNSIGNED (type)); tree shift_expr = convert (base_type, size_binop (MINUS_EXPR, diff --git a/gcc/ada/utils2.c b/gcc/ada/utils2.c index c10ddeaecce..2872474bac8 100644 --- a/gcc/ada/utils2.c +++ b/gcc/ada/utils2.c @@ -511,7 +511,7 @@ nonbinary_modular_operation (op_code, type, lhs, rhs) || TREE_UNSIGNED (op_type) != unsignedp) { /* Copy the node so we ensure it can be modified to make it modular. */ - op_type = copy_node (type_for_size (precision, unsignedp)); + op_type = copy_node (gnat_type_for_size (precision, unsignedp)); modulus = convert (op_type, modulus); TYPE_MODULUS (op_type) = modulus; TYPE_MODULAR_P (op_type) = 1; @@ -527,7 +527,7 @@ nonbinary_modular_operation (op_code, type, lhs, rhs) possible size. */ if (op_code == MULT_EXPR) { - tree div_type = copy_node (type_for_size (needed_precision, 1)); + tree div_type = copy_node (gnat_type_for_size (needed_precision, 1)); modulus = convert (div_type, modulus); TYPE_MODULUS (div_type) = modulus; TYPE_MODULAR_P (div_type) = 1; diff --git a/gcc/attribs.c b/gcc/attribs.c index 69d2ef26a64..74786a54376 100644 --- a/gcc/attribs.c +++ b/gcc/attribs.c @@ -835,8 +835,8 @@ handle_mode_attribute (node, name, args, flags, no_add_attrs) if (mode == VOIDmode) error ("unknown machine mode `%s'", p); - else if (0 == (typefm = type_for_mode (mode, - TREE_UNSIGNED (type)))) + else if (0 == (typefm = (*lang_hooks.types.type_for_mode) + (mode, TREE_UNSIGNED (type)))) error ("no data type for mode `%s'", p); else *node = typefm; @@ -1343,7 +1343,8 @@ handle_vector_size_attribute (node, name, args, flags, no_add_attrs) { tree index, array, rt; - new_type = type_for_mode (new_mode, TREE_UNSIGNED (type)); + new_type = (*lang_hooks.types.type_for_mode) (new_mode, + TREE_UNSIGNED (type)); if (!new_type) { diff --git a/gcc/builtin-types.def b/gcc/builtin-types.def index 24b87d30cfa..7a33ffd7894 100644 --- a/gcc/builtin-types.def +++ b/gcc/builtin-types.def @@ -73,7 +73,7 @@ DEF_PRIMITIVE_TYPE (BT_COMPLEX_LONG_DOUBLE, complex_long_double_type_node) DEF_PRIMITIVE_TYPE (BT_PTR, ptr_type_node) DEF_PRIMITIVE_TYPE (BT_CONST_PTR, const_ptr_type_node) -DEF_PRIMITIVE_TYPE (BT_PTRMODE, type_for_mode (ptr_mode, 0)) +DEF_PRIMITIVE_TYPE (BT_PTRMODE, (*lang_hooks.types.type_for_mode)(ptr_mode, 0)) DEF_PRIMITIVE_TYPE (BT_SIZE, c_size_type_node) DEF_PRIMITIVE_TYPE (BT_STRING, string_type_node) DEF_PRIMITIVE_TYPE (BT_CONST_STRING, const_string_type_node) diff --git a/gcc/c-common.c b/gcc/c-common.c index f699c86ca39..cccd2bc8ceb 100644 --- a/gcc/c-common.c +++ b/gcc/c-common.c @@ -1302,7 +1302,7 @@ check_case_value (value) that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ tree -type_for_size (bits, unsignedp) +c_common_type_for_size (bits, unsignedp) unsigned bits; int unsignedp; { @@ -1346,7 +1346,7 @@ type_for_size (bits, unsignedp) then UNSIGNEDP selects between signed and unsigned types. */ tree -type_for_mode (mode, unsignedp) +c_common_type_for_mode (mode, unsignedp) enum machine_mode mode; int unsignedp; { @@ -1761,7 +1761,7 @@ shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr) values from it's underlying integral type, not the enumerated type itself. */ if (TREE_CODE (type) == ENUMERAL_TYPE) - type = type_for_size (TYPE_PRECISION (type), unsignedp0); + type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0); maxval = TYPE_MAX_VALUE (type); minval = TYPE_MIN_VALUE (type); @@ -2065,8 +2065,8 @@ pointer_int_sum (resultcode, ptrop, intop) if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype) || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype)) - intop = convert (type_for_size (TYPE_PRECISION (sizetype), - TREE_UNSIGNED (sizetype)), intop); + intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype), + TREE_UNSIGNED (sizetype)), intop); /* Replace the integer argument with a suitable product by the object size. Do this multiplication as signed, then convert to the appropriate @@ -2577,7 +2577,8 @@ c_common_nodes_and_builtins () record_builtin_type (RID_MAX, "signed char", signed_char_type_node); record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node); - /* These are types that type_for_size and type_for_mode use. */ + /* These are types that c_common_type_for_size and + c_common_type_for_mode use. */ (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node)); (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE, diff --git a/gcc/c-common.h b/gcc/c-common.h index 7b11f70779a..823b08137d2 100644 --- a/gcc/c-common.h +++ b/gcc/c-common.h @@ -507,6 +507,9 @@ extern tree handle_format_attribute PARAMS ((tree *, tree, tree, extern tree handle_format_arg_attribute PARAMS ((tree *, tree, tree, int, bool *)); extern void c_common_insert_default_attributes PARAMS ((tree)); +extern tree c_common_type_for_mode PARAMS ((enum machine_mode, + int)); +extern tree c_common_type_for_size PARAMS ((unsigned int, int)); extern void c_apply_type_quals_to_decl PARAMS ((int, tree)); extern tree c_sizeof PARAMS ((tree)); extern tree c_alignof PARAMS ((tree)); diff --git a/gcc/c-decl.c b/gcc/c-decl.c index 931f17487ac..c7986218aa8 100644 --- a/gcc/c-decl.c +++ b/gcc/c-decl.c @@ -5844,7 +5844,7 @@ finish_enum (enumtype, values, attributes) min_precision (maxnode, unsign)); if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node)) { - tree narrowest = type_for_size (precision, unsign); + tree narrowest = c_common_type_for_size (precision, unsign); if (narrowest == 0) { warning ("enumeration values exceed range of largest integer"); @@ -5857,7 +5857,7 @@ finish_enum (enumtype, values, attributes) precision = TYPE_PRECISION (integer_type_node); if (precision == TYPE_PRECISION (integer_type_node)) - enum_value_type = type_for_size (precision, 0); + enum_value_type = c_common_type_for_size (precision, 0); else enum_value_type = enumtype; @@ -5985,10 +5985,11 @@ build_enumerator (name, value) /* Now create a declaration for the enum value name. */ type = TREE_TYPE (value); - type = type_for_size (MAX (TYPE_PRECISION (type), - TYPE_PRECISION (integer_type_node)), - (TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node) - && TREE_UNSIGNED (type))); + type = c_common_type_for_size (MAX (TYPE_PRECISION (type), + TYPE_PRECISION (integer_type_node)), + (TYPE_PRECISION (type) + >= TYPE_PRECISION (integer_type_node) + && TREE_UNSIGNED (type))); decl = build_decl (CONST_DECL, name, type); DECL_INITIAL (decl) = convert (type, value); diff --git a/gcc/c-lang.c b/gcc/c-lang.c index c49c948fc46..8e9516553a5 100644 --- a/gcc/c-lang.c +++ b/gcc/c-lang.c @@ -80,6 +80,11 @@ static void c_post_options PARAMS ((void)); #define LANG_HOOKS_TREE_INLINING_CONVERT_PARM_FOR_INLINING \ c_convert_parm_for_inlining +#undef LANG_HOOKS_TYPE_FOR_MODE +#define LANG_HOOKS_TYPE_FOR_MODE c_common_type_for_mode +#undef LANG_HOOKS_TYPE_FOR_SIZE +#define LANG_HOOKS_TYPE_FOR_SIZE c_common_type_for_size + /* ### When changing hooks, consider if ObjC needs changing too!! ### */ /* Each front end provides its own. */ diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c index 297b0f9e188..a4ba6576432 100644 --- a/gcc/c-typeck.c +++ b/gcc/c-typeck.c @@ -216,9 +216,9 @@ common_type (t1, t2) /* Treat an enum type as the unsigned integer type of the same width. */ if (TREE_CODE (t1) == ENUMERAL_TYPE) - t1 = type_for_size (TYPE_PRECISION (t1), 1); + t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1); if (TREE_CODE (t2) == ENUMERAL_TYPE) - t2 = type_for_size (TYPE_PRECISION (t2), 1); + t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1); code1 = TREE_CODE (t1); code2 = TREE_CODE (t2); @@ -465,9 +465,9 @@ comptypes (type1, type2) signedness. */ if (TREE_CODE (t1) == ENUMERAL_TYPE) - t1 = type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1)); + t1 = c_common_type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1)); if (TREE_CODE (t2) == ENUMERAL_TYPE) - t2 = type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2)); + t2 = c_common_type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2)); if (t1 == t2) return 1; @@ -994,11 +994,11 @@ default_conversion (exp) but convert wide enums to something wider. */ if (code == ENUMERAL_TYPE) { - type = type_for_size (MAX (TYPE_PRECISION (type), - TYPE_PRECISION (integer_type_node)), - ((TYPE_PRECISION (type) - >= TYPE_PRECISION (integer_type_node)) - && TREE_UNSIGNED (type))); + type = c_common_type_for_size (MAX (TYPE_PRECISION (type), + TYPE_PRECISION (integer_type_node)), + ((TYPE_PRECISION (type) + >= TYPE_PRECISION (integer_type_node)) + && TREE_UNSIGNED (type))); return convert (type, exp); } diff --git a/gcc/calls.c b/gcc/calls.c index 67715229b8d..cbeb92c20aa 100644 --- a/gcc/calls.c +++ b/gcc/calls.c @@ -33,6 +33,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "tm_p.h" #include "timevar.h" #include "sbitmap.h" +#include "langhooks.h" #if !defined FUNCTION_OK_FOR_SIBCALL #define FUNCTION_OK_FOR_SIBCALL(DECL) 1 @@ -3476,6 +3477,7 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p) int reg_parm_stack_space = 0; int needed; rtx before_call; + tree tfom; /* type_for_mode (outmode, 0) */ #ifdef REG_PARM_STACK_SPACE /* Define the boundary of the register parm stack space that needs to be @@ -3537,27 +3539,31 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p) /* If this kind of value comes back in memory, decide where in memory it should come back. */ - if (outmode != VOIDmode && aggregate_value_p (type_for_mode (outmode, 0))) + if (outmode != VOIDmode) { + tfom = (*lang_hooks.types.type_for_mode) (outmode, 0); + if (aggregate_value_p (tfom)) + { #ifdef PCC_STATIC_STRUCT_RETURN - rtx pointer_reg - = hard_function_value (build_pointer_type (type_for_mode (outmode, 0)), - 0, 0); - mem_value = gen_rtx_MEM (outmode, pointer_reg); - pcc_struct_value = 1; - if (value == 0) - value = gen_reg_rtx (outmode); + rtx pointer_reg + = hard_function_value (build_pointer_type (tfom), 0, 0); + mem_value = gen_rtx_MEM (outmode, pointer_reg); + pcc_struct_value = 1; + if (value == 0) + value = gen_reg_rtx (outmode); #else /* not PCC_STATIC_STRUCT_RETURN */ - struct_value_size = GET_MODE_SIZE (outmode); - if (value != 0 && GET_CODE (value) == MEM) - mem_value = value; - else - mem_value = assign_temp (type_for_mode (outmode, 0), 0, 1, 1); + struct_value_size = GET_MODE_SIZE (outmode); + if (value != 0 && GET_CODE (value) == MEM) + mem_value = value; + else + mem_value = assign_temp (tfom, 0, 1, 1); #endif - - /* This call returns a big structure. */ - flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK); + /* This call returns a big structure. */ + flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK); + } } + else + tfom = void_type_node; /* ??? Unfinished: must pass the memory address as an argument. */ @@ -3670,12 +3676,13 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p) slot = val; else if (must_copy) { - slot = assign_temp (type_for_mode (mode, 0), 0, 1, 1); + slot = assign_temp ((*lang_hooks.types.type_for_mode) (mode, 0), + 0, 1, 1); emit_move_insn (slot, val); } else { - tree type = type_for_mode (mode, 0); + tree type = (*lang_hooks.types.type_for_mode) (mode, 0); slot = gen_rtx_MEM (mode, expand_expr (build1 (ADDR_EXPR, @@ -4042,8 +4049,7 @@ emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p) emit_call_1 (fun, get_identifier (XSTR (orgfun, 0)), - build_function_type (outmode == VOIDmode ? void_type_node - : type_for_mode (outmode, 0), NULL_TREE), + build_function_type (tfom, NULL_TREE), original_args_size.constant, args_size.constant, struct_value_size, FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1), diff --git a/gcc/convert.c b/gcc/convert.c index 127b22b7eef..25aae573cac 100644 --- a/gcc/convert.c +++ b/gcc/convert.c @@ -29,6 +29,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "flags.h" #include "convert.h" #include "toplev.h" +#include "langhooks.h" /* Convert EXPR to some pointer or reference type TYPE. @@ -61,7 +62,8 @@ convert_to_pointer (type, expr) return convert_to_pointer (type, - convert (type_for_size (POINTER_SIZE, 0), expr)); + convert ((*lang_hooks.types.type_for_size) + (POINTER_SIZE, 0), expr)); default: error ("cannot convert to a pointer type"); @@ -138,8 +140,8 @@ convert_to_integer (type, expr) if (integer_zerop (expr)) expr = integer_zero_node; else - expr = fold (build1 (CONVERT_EXPR, - type_for_size (POINTER_SIZE, 0), expr)); + expr = fold (build1 (CONVERT_EXPR, (*lang_hooks.types.type_for_size) + (POINTER_SIZE, 0), expr)); return convert_to_integer (type, expr); @@ -189,8 +191,8 @@ convert_to_integer (type, expr) else if (TREE_CODE (type) == ENUMERAL_TYPE || outprec != GET_MODE_BITSIZE (TYPE_MODE (type))) return build1 (NOP_EXPR, type, - convert (type_for_mode (TYPE_MODE (type), - TREE_UNSIGNED (type)), + convert ((*lang_hooks.types.type_for_mode) + (TYPE_MODE (type), TREE_UNSIGNED (type)), expr)); /* Here detect when we can distribute the truncation down past some @@ -300,8 +302,8 @@ convert_to_integer (type, expr) /* Can't do arithmetic in enumeral types so use an integer type that will hold the values. */ if (TREE_CODE (typex) == ENUMERAL_TYPE) - typex = type_for_size (TYPE_PRECISION (typex), - TREE_UNSIGNED (typex)); + typex = (*lang_hooks.types.type_for_size) + (TYPE_PRECISION (typex), TREE_UNSIGNED (typex)); /* But now perhaps TYPEX is as wide as INPREC. In that case, do nothing special here. @@ -338,8 +340,8 @@ convert_to_integer (type, expr) /* Can't do arithmetic in enumeral types so use an integer type that will hold the values. */ if (TREE_CODE (typex) == ENUMERAL_TYPE) - typex = type_for_size (TYPE_PRECISION (typex), - TREE_UNSIGNED (typex)); + typex = (*lang_hooks.types.type_for_size) + (TYPE_PRECISION (typex), TREE_UNSIGNED (typex)); /* But now perhaps TYPEX is as wide as INPREC. In that case, do nothing special here. diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index b7f8cb2cc78..8dd802c9b1d 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,14 @@ +2002-03-29 Neil Booth + + * cp-lang.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIZE): + Redefine. + * cvt.c (cp_convert_to_pointer, type_promotes_to): Use new hooks. + * decl.c (finish_enum): Similarly. + * error.c (dump_type): Similarly. + * lex.c (cxx_init): Similarly. + * mangle.c (write_builtin_type): Similarly. + * typeck.c (comptypes): Similarly. + 2002-03-28 Roger Sayle PR c++/5998: diff --git a/gcc/cp/cp-lang.c b/gcc/cp/cp-lang.c index a3ede8da133..5cd481de423 100644 --- a/gcc/cp/cp-lang.c +++ b/gcc/cp/cp-lang.c @@ -111,6 +111,10 @@ static bool ok_to_generate_alias_set_for_type PARAMS ((tree)); #undef LANG_HOOKS_MAKE_TYPE #define LANG_HOOKS_MAKE_TYPE cxx_make_type +#undef LANG_HOOKS_TYPE_FOR_MODE +#define LANG_HOOKS_TYPE_FOR_MODE c_common_type_for_mode +#undef LANG_HOOKS_TYPE_FOR_SIZE +#define LANG_HOOKS_TYPE_FOR_SIZE c_common_type_for_size /* Each front end provides its own hooks, for toplev.c. */ const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER; diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c index cea204e29dc..d934df03de5 100644 --- a/gcc/cp/cvt.c +++ b/gcc/cp/cvt.c @@ -256,7 +256,7 @@ cp_convert_to_pointer (type, expr, force) { if (TYPE_PRECISION (intype) == POINTER_SIZE) return build1 (CONVERT_EXPR, type, expr); - expr = cp_convert (type_for_size (POINTER_SIZE, 0), expr); + expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr); /* Modes may be different but sizes should be the same. */ if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (expr))) != GET_MODE_SIZE (TYPE_MODE (type))) @@ -1183,10 +1183,10 @@ type_promotes_to (type) { int precision = MAX (TYPE_PRECISION (type), TYPE_PRECISION (integer_type_node)); - tree totype = type_for_size (precision, 0); + tree totype = c_common_type_for_size (precision, 0); if (TREE_UNSIGNED (type) && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype)) - type = type_for_size (precision, 1); + type = c_common_type_for_size (precision, 1); else type = totype; } diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 1739771debf..8ba011e601a 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -13247,7 +13247,7 @@ finish_enum (enumtype) if (flag_short_enums || (precision > TYPE_PRECISION (integer_type_node))) /* Use the width of the narrowest normal C type which is wide enough. */ - TYPE_PRECISION (enumtype) = TYPE_PRECISION (type_for_size + TYPE_PRECISION (enumtype) = TYPE_PRECISION (c_common_type_for_size (precision, 1)); else TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node); diff --git a/gcc/cp/error.c b/gcc/cp/error.c index 812def9f382..b411d27da7f 100644 --- a/gcc/cp/error.c +++ b/gcc/cp/error.c @@ -387,7 +387,7 @@ dump_type (t, flags) which has no name and is not very useful for diagnostics. So look up the equivalent C type and print its name. */ tree elt = TREE_TYPE (t); - elt = type_for_mode (TYPE_MODE (elt), TREE_UNSIGNED (elt)); + elt = c_common_type_for_mode (TYPE_MODE (elt), TREE_UNSIGNED (elt)); dump_type (elt, flags); } break; diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c index e9e660dc972..7e442fbc70e 100644 --- a/gcc/cp/lex.c +++ b/gcc/cp/lex.c @@ -677,7 +677,7 @@ cxx_init (filename) /* Create the built-in __null node. */ null_node = build_int_2 (0, 0); - TREE_TYPE (null_node) = type_for_size (POINTER_SIZE, 0); + TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0); ridpointers[RID_NULL] = null_node; token_count = init_cpp_parse (); diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c index ac24b6eb8c6..1a1c995bb6d 100644 --- a/gcc/cp/mangle.c +++ b/gcc/cp/mangle.c @@ -1560,7 +1560,8 @@ write_builtin_type (type) if (itk == itk_none) { - tree t = type_for_mode (TYPE_MODE (type), TREE_UNSIGNED (type)); + tree t = c_common_type_for_mode (TYPE_MODE (type), + TREE_UNSIGNED (type)); if (type == t) { if (TYPE_PRECISION (type) == 128) diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 767f90d72cb..1a575f22fcc 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -910,9 +910,9 @@ comptypes (t1, t2, strict) /* Treat an enum type as the unsigned integer type of the same width. */ if (TREE_CODE (t1) == ENUMERAL_TYPE) - t1 = type_for_size (TYPE_PRECISION (t1), 1); + t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1); if (TREE_CODE (t2) == ENUMERAL_TYPE) - t2 = type_for_size (TYPE_PRECISION (t2), 1); + t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1); if (t1 == t2) return 1; diff --git a/gcc/except.c b/gcc/except.c index 9aa5a0a34fd..3eb31bd0237 100644 --- a/gcc/except.c +++ b/gcc/except.c @@ -396,7 +396,8 @@ init_eh () DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node; tmp = build_index_type (build_int_2 (4 - 1, 0)); - tmp = build_array_type (type_for_mode (word_mode, 1), tmp); + tmp = build_array_type ((*lang_hooks.types.type_for_mode) (word_mode, 1), + tmp); f_data = build_decl (FIELD_DECL, get_identifier ("__data"), tmp); DECL_FIELD_CONTEXT (f_data) = sjlj_fc_type_node; diff --git a/gcc/expmed.c b/gcc/expmed.c index d2edd813c96..cdc403fcc91 100644 --- a/gcc/expmed.c +++ b/gcc/expmed.c @@ -33,6 +33,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "optabs.h" #include "real.h" #include "recog.h" +#include "langhooks.h" static void store_fixed_bit_field PARAMS ((rtx, unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, @@ -4168,9 +4169,10 @@ expand_mult_add (x, target, mult, add, mode, unsignedp) enum machine_mode mode; int unsignedp; { - tree type = type_for_mode (mode, unsignedp); + tree type = (*lang_hooks.types.type_for_mode) (mode, unsignedp); tree add_type = (GET_MODE (add) == VOIDmode - ? type : type_for_mode (GET_MODE (add), unsignedp)); + ? type: (*lang_hooks.types.type_for_mode) (GET_MODE (add), + unsignedp)); tree result = fold (build (PLUS_EXPR, type, fold (build (MULT_EXPR, type, make_tree (type, x), diff --git a/gcc/expr.c b/gcc/expr.c index e83e1078bc4..6587212296e 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -4027,8 +4027,9 @@ store_expr (exp, target, want_value) TREE_TYPE (exp)), exp); - exp = convert (type_for_mode (GET_MODE (SUBREG_REG (target)), - SUBREG_PROMOTED_UNSIGNED_P (target)), + exp = convert ((*lang_hooks.types.type_for_mode) + (GET_MODE (SUBREG_REG (target)), + SUBREG_PROMOTED_UNSIGNED_P (target)), exp); inner_target = SUBREG_REG (target); @@ -4526,7 +4527,8 @@ store_constructor (exp, target, cleared, size) if (TYPE_PRECISION (type) < BITS_PER_WORD) { - type = type_for_size (BITS_PER_WORD, TREE_UNSIGNED (type)); + type = (*lang_hooks.types.type_for_size) + (BITS_PER_WORD, TREE_UNSIGNED (type)); value = convert (type, value); } @@ -4955,7 +4957,8 @@ store_constructor (exp, target, cleared, size) { targetx = assign_temp - ((build_qualified_type (type_for_mode (GET_MODE (target), 0), + ((build_qualified_type ((*lang_hooks.types.type_for_mode) + (GET_MODE (target), 0), TYPE_QUAL_CONST)), 0, 1, 1); emit_move_insn (targetx, target); @@ -7015,7 +7018,8 @@ expand_expr (exp, target, tmode, modifier) if (mode == BLKmode) { rtx new = assign_temp (build_qualified_type - (type_for_mode (ext_mode, 0), + ((*lang_hooks.types.type_for_mode) + (ext_mode, 0), TYPE_QUAL_CONST), 0, 1, 1); emit_move_insn (new, op0); @@ -9252,7 +9256,7 @@ do_jump (exp, if_false_label, if_true_label) && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT && (i = tree_floor_log2 (TREE_OPERAND (exp, 1))) >= 0 && (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode - && (type = type_for_mode (mode, 1)) != 0 + && (type = (*lang_hooks.types.type_for_mode) (mode, 1)) != 0 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp)) && (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code != CODE_FOR_nothing)) @@ -9312,7 +9316,7 @@ do_jump (exp, if_false_label, if_true_label) get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode, &unsignedp, &volatilep); - type = type_for_size (bitsize, unsignedp); + type = (*lang_hooks.types.type_for_size) (bitsize, unsignedp); if (! SLOW_BYTE_ACCESS && type != 0 && bitsize >= 0 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp)) @@ -10393,8 +10397,8 @@ try_casesi (index_type, index_expr, minval, range, { if (TYPE_MODE (index_type) != index_mode) { - index_expr = convert (type_for_size (index_bits, 0), - index_expr); + index_expr = convert ((*lang_hooks.types.type_for_size) + (index_bits, 0), index_expr); index_type = TREE_TYPE (index_expr); } diff --git a/gcc/f/ChangeLog b/gcc/f/ChangeLog index 68c8ade99ee..74202a6f819 100644 --- a/gcc/f/ChangeLog +++ b/gcc/f/ChangeLog @@ -1,3 +1,11 @@ +Fri Mar 29 21:59:15 2002 Neil Booth + + * com.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIZE): + Redefine. + (type_for_mode, type_for_size): Rename. + (signed_or_unsigned_type, signed_type, truthvalue_conversion, + unsigned_type): Use new hooks. + Tue Mar 26 10:30:05 2002 Andrew Cagney * invoke.texi (Warning Options): Mention -Wswitch-enum. diff --git a/gcc/f/com.c b/gcc/f/com.c index a2b2e09d1e3..fcff40150e0 100644 --- a/gcc/f/com.c +++ b/gcc/f/com.c @@ -261,6 +261,8 @@ struct _ffecom_concat_list_ /* Static functions (internal). */ +static tree ffe_type_for_mode PARAMS ((enum machine_mode, int)); +static tree ffe_type_for_size PARAMS ((unsigned int, int)); static void ffecom_init_decl_processing PARAMS ((void)); static tree ffecom_arglist_expr_ (const char *argstring, ffebld args); static tree ffecom_widest_expr_type_ (ffebld list); @@ -14225,6 +14227,10 @@ static void ffe_mark_tree (tree); #define LANG_HOOKS_PRINT_IDENTIFIER ffe_print_identifier #undef LANG_HOOKS_DECL_PRINTABLE_NAME #define LANG_HOOKS_DECL_PRINTABLE_NAME ffe_printable_name +#undef LANG_HOOKS_TYPE_FOR_MODE +#define LANG_HOOKS_TYPE_FOR_MODE ffe_type_for_mode +#undef LANG_HOOKS_TYPE_FOR_SIZE +#define LANG_HOOKS_TYPE_FOR_SIZE ffe_type_for_size /* We do not wish to use alias-set based aliasing at all. Used in the extreme (every object with its own set, with equivalences recorded) it @@ -14758,7 +14764,7 @@ signed_or_unsigned_type (unsignedp, type) return (unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node); - type2 = type_for_size (TYPE_PRECISION (type), unsignedp); + type2 = ffe_type_for_size (TYPE_PRECISION (type), unsignedp); if (type2 == NULL_TREE) return type; @@ -14794,7 +14800,7 @@ signed_type (type) return intQI_type_node; #endif - type2 = type_for_size (TYPE_PRECISION (type1), 0); + type2 = ffe_type_for_size (TYPE_PRECISION (type1), 0); if (type2 != NULL_TREE) return type2; @@ -14992,8 +14998,8 @@ truthvalue_conversion (expr) convert (TREE_TYPE (expr), integer_zero_node)); } -tree -type_for_mode (mode, unsignedp) +static tree +ffe_type_for_mode (mode, unsignedp) enum machine_mode mode; int unsignedp; { @@ -15049,8 +15055,8 @@ type_for_mode (mode, unsignedp) return 0; } -tree -type_for_size (bits, unsignedp) +static tree +ffe_type_for_size (bits, unsignedp) unsigned bits; int unsignedp; { @@ -15114,7 +15120,7 @@ unsigned_type (type) return unsigned_intQI_type_node; #endif - type2 = type_for_size (TYPE_PRECISION (type1), 1); + type2 = ffe_type_for_size (TYPE_PRECISION (type1), 1); if (type2 != NULL_TREE) return type2; diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 4c5b91ed11e..875ade3bf75 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -2426,8 +2426,8 @@ optimize_bit_field_compare (code, compare_type, lhs, rhs) /* Set signed and unsigned types of the precision of this mode for the shifts below. */ - signed_type = type_for_mode (nmode, 0); - unsigned_type = type_for_mode (nmode, 1); + signed_type = (*lang_hooks.types.type_for_mode) (nmode, 0); + unsigned_type = (*lang_hooks.types.type_for_mode) (nmode, 1); /* Compute the bit position and size for the new reference and our offset within it. If the new reference is the same size as the original, we @@ -2590,7 +2590,7 @@ decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp, return 0; /* Compute the mask to access the bitfield. */ - unsigned_type = type_for_size (*pbitsize, 1); + unsigned_type = (*lang_hooks.types.type_for_size) (*pbitsize, 1); precision = TYPE_PRECISION (unsigned_type); mask = build_int_2 (~0, ~0); @@ -2960,7 +2960,8 @@ make_range (exp, pin_p, plow, phigh) be interpreted as positive. */ if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp))) { - tree equiv_type = type_for_mode (TYPE_MODE (type), 1); + tree equiv_type = (*lang_hooks.types.type_for_mode) + (TYPE_MODE (type), 1); tree high_positive; /* A range without an upper bound is, naturally, unbounded. @@ -3509,7 +3510,7 @@ fold_truthop (code, truth_type, lhs, rhs) lnbitsize = GET_MODE_BITSIZE (lnmode); lnbitpos = first_bit & ~ (lnbitsize - 1); - lntype = type_for_size (lnbitsize, 1); + lntype = (*lang_hooks.types.type_for_size) (lnbitsize, 1); xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos; if (BYTES_BIG_ENDIAN) @@ -3580,7 +3581,7 @@ fold_truthop (code, truth_type, lhs, rhs) rnbitsize = GET_MODE_BITSIZE (rnmode); rnbitpos = first_bit & ~ (rnbitsize - 1); - rntype = type_for_size (rnbitsize, 1); + rntype = (*lang_hooks.types.type_for_size) (rnbitsize, 1); xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos; if (BYTES_BIG_ENDIAN) @@ -5720,7 +5721,7 @@ fold (expr) || integer_onep (folded_compare)) return omit_one_operand (type, folded_compare, varop); - unsigned_type = type_for_size (size, 1); + unsigned_type = (*lang_hooks.types.type_for_size)(size, 1); precision = TYPE_PRECISION (unsigned_type); mask = build_int_2 (~0, ~0); TREE_TYPE (mask) = unsigned_type; @@ -5781,7 +5782,7 @@ fold (expr) || integer_onep (folded_compare)) return omit_one_operand (type, folded_compare, varop); - unsigned_type = type_for_size (size, 1); + unsigned_type = (*lang_hooks.types.type_for_size)(size, 1); precision = TYPE_PRECISION (unsigned_type); mask = build_int_2 (~0, ~0); TREE_TYPE (mask) = TREE_TYPE (varop); diff --git a/gcc/function.c b/gcc/function.c index e7facd453b7..a17b249661f 100644 --- a/gcc/function.c +++ b/gcc/function.c @@ -556,7 +556,7 @@ assign_stack_local_1 (mode, size, align, function) /* Allow the target to (possibly) increase the alignment of this stack slot. */ - type = type_for_mode (mode, 0); + type = (*lang_hooks.types.type_for_mode) (mode, 0); if (type) alignment = LOCAL_ALIGNMENT (type, alignment); @@ -675,7 +675,7 @@ assign_stack_temp_for_type (mode, size, keep, type) align = GET_MODE_ALIGNMENT (mode); if (! type) - type = type_for_mode (mode, 0); + type = (*lang_hooks.types.type_for_mode) (mode, 0); if (type) align = LOCAL_ALIGNMENT (type, align); @@ -1415,7 +1415,7 @@ put_var_into_stack (decl) to the whole CONCAT, lest we do double fixups for the latter references. */ enum machine_mode part_mode = GET_MODE (XEXP (reg, 0)); - tree part_type = type_for_mode (part_mode, 0); + tree part_type = (*lang_hooks.types.type_for_mode) (part_mode, 0); rtx lopart = XEXP (reg, 0); rtx hipart = XEXP (reg, 1); #ifdef FRAME_GROWS_DOWNWARD diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog index 3006c856672..b4ffd1988e3 100644 --- a/gcc/java/ChangeLog +++ b/gcc/java/ChangeLog @@ -1,3 +1,14 @@ +2002-03-29 Neil Booth + + * Make-lang.in (builtins.o): Update. + * boehm.c (get_boehm_type_descriptor): Update. + * builtins.c: Include langhooks.h. + * decl.c (java_init_decl_processing): Update. + * java-tree.h (java_type_for_mode, java_type_for_size): New. + * lang.c (LANG_HOOKS_TYPE_FOR_MODE, LANG_HOOKS_TYPE_FOR_SIaZE): + Redefine. + * typeck.c (type_for_mode, type_for_size): Update. + 2002-03-29 Martin Kahlert * lex.c (java_new_lexer): Alias "646" to DEFAULT_ENCODING. diff --git a/gcc/java/Make-lang.in b/gcc/java/Make-lang.in index 9165a09fa90..00185e5824b 100644 --- a/gcc/java/Make-lang.in +++ b/gcc/java/Make-lang.in @@ -261,7 +261,7 @@ java/boehm.o: java/boehm.c $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(JAVA_TREE_H) \ java/parse.h toplev.h java/buffer.o: java/buffer.c $(CONFIG_H) java/buffer.h $(SYSTEM_H) toplev.h java/builtins.o: java/builtins.c $(CONFIG_H) $(SYSTEM_H) $(JAVA_TREE_H) \ - $(GGC_H) flags.h + $(GGC_H) flags.h builtin-types.def langhooks.h java/check-init.o: java/check-init.c $(CONFIG_H) \ $(JAVA_TREE_H) $(SYSTEM_H) toplev.h java/class.o: java/class.c $(CONFIG_H) $(JAVA_TREE_H) $(RTL_H) java/jcf.h \ diff --git a/gcc/java/boehm.c b/gcc/java/boehm.c index 3eb20434d26..566655a6c96 100644 --- a/gcc/java/boehm.c +++ b/gcc/java/boehm.c @@ -230,6 +230,6 @@ get_boehm_type_descriptor (tree type) value = build_int_2 (2, 0); } - TREE_TYPE (value) = type_for_mode (ptr_mode, 1); + TREE_TYPE (value) = java_type_for_mode (ptr_mode, 1); return value; } diff --git a/gcc/java/builtins.c b/gcc/java/builtins.c index 7af0435dda6..81be7e3d457 100644 --- a/gcc/java/builtins.c +++ b/gcc/java/builtins.c @@ -30,7 +30,7 @@ The Free Software Foundation is independent of Sun Microsystems, Inc. */ #include "tree.h" #include "ggc.h" #include "flags.h" - +#include "langhooks.h" #include "java-tree.h" enum builtin_type diff --git a/gcc/java/decl.c b/gcc/java/decl.c index a0a77b26d9b..c0560c6dbb7 100644 --- a/gcc/java/decl.c +++ b/gcc/java/decl.c @@ -441,7 +441,7 @@ java_init_decl_processing () set_sizetype (make_unsigned_type (POINTER_SIZE)); /* Define these next since types below may used them. */ - integer_type_node = type_for_size (INT_TYPE_SIZE, 0); + integer_type_node = java_type_for_size (INT_TYPE_SIZE, 0); integer_zero_node = build_int_2 (0, 0); integer_one_node = build_int_2 (1, 0); integer_two_node = build_int_2 (2, 0); diff --git a/gcc/java/java-tree.h b/gcc/java/java-tree.h index cf272fd6320..3f47430aa40 100644 --- a/gcc/java/java-tree.h +++ b/gcc/java/java-tree.h @@ -1039,6 +1039,8 @@ struct lang_type extern void java_set_yydebug PARAMS ((int)); extern void java_parse_file PARAMS ((void)); extern void java_mark_tree PARAMS ((tree)); +extern tree java_type_for_mode PARAMS ((enum machine_mode, int)); +extern tree java_type_for_size PARAMS ((unsigned int, int)); extern void add_assume_compiled PARAMS ((const char *, int)); extern tree lookup_class PARAMS ((tree)); extern tree lookup_java_constructor PARAMS ((tree, tree)); diff --git a/gcc/java/lang.c b/gcc/java/lang.c index fd197235cd4..583af75eaf1 100644 --- a/gcc/java/lang.c +++ b/gcc/java/lang.c @@ -231,6 +231,10 @@ static int dependency_tracking = 0; #define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL java_dup_lang_specific_decl #undef LANG_HOOKS_DECL_PRINTABLE_NAME #define LANG_HOOKS_DECL_PRINTABLE_NAME lang_printable_name +#undef LANG_HOOKS_TYPE_FOR_MODE +#define LANG_HOOKS_TYPE_FOR_MODE java_type_for_mode +#undef LANG_HOOKS_TYPE_FOR_SIZE +#define LANG_HOOKS_TYPE_FOR_SIZE java_type_for_size /* Each front end provides its own. */ const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER; diff --git a/gcc/java/typeck.c b/gcc/java/typeck.c index 34dbc2e2ba7..88f3fb9f3ca 100644 --- a/gcc/java/typeck.c +++ b/gcc/java/typeck.c @@ -183,7 +183,7 @@ incomplete_type_error (value, type) then UNSIGNEDP selects between signed and unsigned types. */ tree -type_for_mode (mode, unsignedp) +java_type_for_mode (mode, unsignedp) enum machine_mode mode; int unsignedp; { @@ -207,7 +207,7 @@ type_for_mode (mode, unsignedp) that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ tree -type_for_size (bits, unsignedp) +java_type_for_size (bits, unsignedp) unsigned bits; int unsignedp; { diff --git a/gcc/langhooks-def.h b/gcc/langhooks-def.h index 821def79402..8679f235c9a 100644 --- a/gcc/langhooks-def.h +++ b/gcc/langhooks-def.h @@ -145,11 +145,14 @@ int lhd_tree_dump_type_quals PARAMS ((tree)); LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN \ } -/* Types hooks. */ +/* Types hooks. No default for LANG_HOOKS_TYPE_FOR_MODE or + LANG_HOOKS_TYPE_FOR_SIZE. */ #define LANG_HOOKS_MAKE_TYPE make_node #define LANG_HOOKS_FOR_TYPES_INITIALIZER { \ - LANG_HOOKS_MAKE_TYPE \ + LANG_HOOKS_MAKE_TYPE, \ + LANG_HOOKS_TYPE_FOR_MODE, \ + LANG_HOOKS_TYPE_FOR_SIZE \ } /* Declaration hooks. */ diff --git a/gcc/langhooks.h b/gcc/langhooks.h index 88a45f969ae..df404c53254 100644 --- a/gcc/langhooks.h +++ b/gcc/langhooks.h @@ -71,7 +71,17 @@ struct lang_hooks_for_tree_dump struct lang_hooks_for_types { + /* Return a new type (with the indicated CODE), doing whatever + language-specific processing is required. */ tree (*make_type) PARAMS ((enum tree_code)); + + /* Given MODE and UNSIGNEDP, return a suitable type-tree with that + mode. */ + tree (*type_for_mode) PARAMS ((enum machine_mode, int)); + + /* Given PRECISION and UNSIGNEDP, return a suitable type-tree for an + integer type with at least that precision. */ + tree (*type_for_size) PARAMS ((unsigned, int)); }; /* Language hooks related to decls and the symbol table. */ diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c index cfc47024bf5..827a5a7166f 100644 --- a/gcc/objc/objc-act.c +++ b/gcc/objc/objc-act.c @@ -8306,7 +8306,7 @@ handle_impent (impent) tree decl, init; init = build_int_2 (0, 0); - TREE_TYPE (init) = type_for_size (BITS_PER_WORD, 1); + TREE_TYPE (init) = c_common_type_for_size (BITS_PER_WORD, 1); decl = build_decl (VAR_DECL, get_identifier (string), TREE_TYPE (init)); TREE_PUBLIC (decl) = 1; TREE_READONLY (decl) = 1; diff --git a/gcc/objc/objc-lang.c b/gcc/objc/objc-lang.c index b189d6bfe93..aa7e308ecbd 100644 --- a/gcc/objc/objc-lang.c +++ b/gcc/objc/objc-lang.c @@ -76,6 +76,11 @@ static void objc_post_options PARAMS ((void)); #define LANG_HOOKS_TREE_INLINING_CONVERT_PARM_FOR_INLINING \ c_convert_parm_for_inlining +#undef LANG_HOOKS_TYPE_FOR_MODE +#define LANG_HOOKS_TYPE_FOR_MODE c_common_type_for_mode +#undef LANG_HOOKS_TYPE_FOR_SIZE +#define LANG_HOOKS_TYPE_FOR_SIZE c_common_type_for_size + /* Each front end provides its own hooks, for toplev.c. */ const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER; diff --git a/gcc/stmt.c b/gcc/stmt.c index fcda52d5324..d732047aaf8 100644 --- a/gcc/stmt.c +++ b/gcc/stmt.c @@ -4115,7 +4115,8 @@ expand_decl_cleanup (decl, cleanup) emit_move_insn (flag, const1_rtx); - cond = build_decl (VAR_DECL, NULL_TREE, type_for_mode (word_mode, 1)); + cond = build_decl (VAR_DECL, NULL_TREE, + (*lang_hooks.types.type_for_mode) (word_mode, 1)); SET_DECL_RTL (cond, flag); /* Conditionalize the cleanup. */ @@ -6310,7 +6311,7 @@ emit_case_nodes (index, node, default_label, index_type) else if (!low_bound && !high_bound) { /* Widen LOW and HIGH to the same width as INDEX. */ - tree type = type_for_mode (mode, unsignedp); + tree type = (*lang_hooks.types.type_for_mode) (mode, unsignedp); tree low = build1 (CONVERT_EXPR, type, node->low); tree high = build1 (CONVERT_EXPR, type, node->high); rtx low_rtx, new_index, new_bound; diff --git a/gcc/tree.c b/gcc/tree.c index 1b5bddda152..98ac6bc663b 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -4024,8 +4024,8 @@ get_unwidened (op, for_type) { unsigned int innerprec = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1); - - type = type_for_size (innerprec, TREE_UNSIGNED (TREE_OPERAND (op, 1))); + int unsignedp = TREE_UNSIGNED (TREE_OPERAND (op, 1)); + type = (*lang_hooks.types.type_for_size) (innerprec, unsignedp); /* We can get this structure field in the narrowest type it fits in. If FOR_TYPE is 0, do this only for a field that matches the @@ -4035,8 +4035,7 @@ get_unwidened (op, for_type) if (innerprec < TYPE_PRECISION (TREE_TYPE (op)) && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))) - && (! uns || final_prec <= innerprec - || TREE_UNSIGNED (TREE_OPERAND (op, 1))) + && (! uns || final_prec <= innerprec || unsignedp) && type != 0) { win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0), @@ -4110,7 +4109,8 @@ get_narrower (op, unsignedp_ptr) { unsigned HOST_WIDE_INT innerprec = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1); - tree type = type_for_size (innerprec, TREE_UNSIGNED (op)); + tree type = (*lang_hooks.types.type_for_size) (innerprec, + TREE_UNSIGNED (op)); /* We can get this structure field in a narrower type that fits it, but the resulting extension to its nominal type (a fullword type) diff --git a/gcc/tree.h b/gcc/tree.h index c40b611d018..58b2ebae410 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -2611,20 +2611,6 @@ extern tree get_unwidened PARAMS ((tree, tree)); extern tree get_narrower PARAMS ((tree, int *)); -/* Given MODE and UNSIGNEDP, return a suitable type-tree - with that mode. - The definition of this resides in language-specific code - as the repertoire of available types may vary. */ - -extern tree type_for_mode PARAMS ((enum machine_mode, int)); - -/* Given PRECISION and UNSIGNEDP, return a suitable type-tree - for an integer type with at least that precision. - The definition of this resides in language-specific code - as the repertoire of available types may vary. */ - -extern tree type_for_size PARAMS ((unsigned, int)); - /* Given an integer type T, return a type like T but unsigned. If T is unsigned, the value is T. The definition of this resides in language-specific code diff --git a/gcc/varasm.c b/gcc/varasm.c index ad0ef708abf..fc45cd8b0d0 100644 --- a/gcc/varasm.c +++ b/gcc/varasm.c @@ -3799,7 +3799,8 @@ force_const_mem (mode, x) /* Align the location counter as required by EXP's data type. */ align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode); #ifdef CONSTANT_ALIGNMENT - align = CONSTANT_ALIGNMENT (make_tree (type_for_mode (mode, 0), x), align); + align = CONSTANT_ALIGNMENT (make_tree ((*lang_hooks.types.type_for_mode) + (mode, 0), x), align); #endif pool_offset += (align / BITS_PER_UNIT) - 1; @@ -3837,7 +3838,7 @@ force_const_mem (mode, x) pool->desc->rtl = def = gen_rtx_MEM (mode, gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label))); set_mem_alias_set (def, const_alias_set); - set_mem_attributes (def, type_for_mode (mode, 0), 1); + set_mem_attributes (def, (*lang_hooks.types.type_for_mode) (mode, 0), 1); RTX_UNCHANGING_P (def) = 1; /* Add label to symbol hash table. */