From dc24ddbd63bf6d4b7310ef5913c4566cee2bff9b Mon Sep 17 00:00:00 2001 From: sayle Date: Sun, 14 Mar 2004 22:26:14 +0000 Subject: [PATCH] * alias.c (get_alias_set): Replace calls via (*lang_hooks.foo) () with lang_hooks.foo (). * builtins.c (expand_builtin_va_arg): Likewise. * c-common.c (fname_as_string, c_common_truthvalue_conversion, c_common_type_for_mode, c_common_nodes_and_builtins, handle_mode_attribute, handle_vector_size_attribute): Likewise. * c-convert.c (convert): Likewise. * c-format.c (check_format_types): Likewise. * c-objc-common.c (c_tree_printer): Likewise. * c-typeck.c (build_unary_op, build_conditional_expr, build_binary_op): Likewise. * calls.c (try_to_integrate, expand_call, emit_library_call_value_1): Likewise. * cgraph.c (cgraph_node_name, cgraph_function_possibly_inlined_p): Likewise. * cgraphunit.c (record_call_1, cgraph_analyze_function, cgraph_expand_function): Likewise. * convert.c (convert_to_pointer, convert_to_integer): Likewise. * coverage.c (build_fn_info_type, build_ctr_info_type, build_gcov_info, create_coverage): Likewise. * dbxout.c (dbxout_init): Likewise. * diagnostic.c (diagnostic_report_current_function): Likewise. * dojump.c (do_jump): Likewise. * dwarf2out.c (dwarf2_name): Likewise. * except.c (init_eh): Likewise. * explow.c (expr_size, int_expr_size): Likewise. * expmed.c (make_tree, const_mult_add_overflow_p, expand_mult_add): Likewise. * expr.c (store_expr, store_constructor, safe_from_p, expand_expr_real, do_store_flag, try_casesi): Likewise. * function.c (push_function_context_to, pop_function_context_from, free_after_parsing, assign_stack_local_1, assign_stack_temp_for_type, put_var_into_stack, allocate_struct_function, current_function_name): Likewise. * integrate.c (copy_decl_for_inlining, expand_inline_function): Likewise. * langhooks.c (lhd_clear_binding_stack, write_global_declarations, lhd_print_error_function): Likewise. * opts.c (handle_option, decode_options): Likewise. * passes.c (open_dump_file): Likewise. * print-tree.c (print_node): Likewise. * stmt.c (expand_fixup, fixup_gotos, expand_asm_operands, expand_decl_cleanup, emit_case_nodes): Likewise. * stor-layout.c (variable_size): Likewise. * toplev.c (announce_function, wrapup_global_declarations, check_global_declarations, compile_file, default_tree_printer, process_options, lang_dependent_init, finalize): Likewise. * tree-dump.c (dequeue_and_dump): Likewise. * tree-inline.c (remap_decl, remap_block, copy_body_r, initialize_inlined_parameters, declare_return_variable, inlinable_function_p, expand_call_inline, optimize_inline_calls, walk_tree, copy_tree_r): Likewise. * tree-optimize.c (tree_rest_of_compilation): Likewise. * tree.c (decl_assembler_name, tree_size, size_in_bytes, staticp, unsafe_for_reeval, get_unwidened, get_narrower, get_callee_fndecl, variably_modified_type_p, dump_tree_statistics): Likewise. * varasm.c (assemble_variable, compare_constant, copy_constant, force_const_mem, compute_reloc_for_constant, output_constant, output_addressed_constants, initializer_constant_valid_p): Likewise. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@79481 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 62 +++++++++++++++++++++++++ gcc/alias.c | 4 +- gcc/builtins.c | 2 +- gcc/c-common.c | 130 ++++++++++++++++++++++++++-------------------------- gcc/c-convert.c | 2 +- gcc/c-format.c | 4 +- gcc/c-objc-common.c | 4 +- gcc/c-typeck.c | 8 ++-- gcc/calls.c | 14 +++--- gcc/cgraph.c | 4 +- gcc/cgraphunit.c | 8 ++-- gcc/convert.c | 21 +++++---- gcc/coverage.c | 8 ++-- gcc/dbxout.c | 2 +- gcc/diagnostic.c | 2 +- gcc/dojump.c | 8 ++-- gcc/dwarf2out.c | 2 +- gcc/except.c | 4 +- gcc/explow.c | 4 +- gcc/expmed.c | 22 ++++----- gcc/expr.c | 28 +++++------ gcc/function.c | 16 +++---- gcc/integrate.c | 4 +- gcc/langhooks.c | 8 ++-- gcc/opts.c | 6 +-- gcc/passes.c | 2 +- gcc/print-tree.c | 8 ++-- gcc/stmt.c | 24 +++++----- gcc/stor-layout.c | 4 +- gcc/toplev.c | 20 ++++---- gcc/tree-dump.c | 6 +-- gcc/tree-inline.c | 40 ++++++++-------- gcc/tree-optimize.c | 6 +-- gcc/tree.c | 22 ++++----- gcc/varasm.c | 20 ++++---- 35 files changed, 297 insertions(+), 232 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index d15a3c2..eacd78a 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,65 @@ +2004-03-14 Roger Sayle + + * alias.c (get_alias_set): Replace calls via (*lang_hooks.foo) () + with lang_hooks.foo (). + * builtins.c (expand_builtin_va_arg): Likewise. + * c-common.c (fname_as_string, c_common_truthvalue_conversion, + c_common_type_for_mode, c_common_nodes_and_builtins, + handle_mode_attribute, handle_vector_size_attribute): Likewise. + * c-convert.c (convert): Likewise. + * c-format.c (check_format_types): Likewise. + * c-objc-common.c (c_tree_printer): Likewise. + * c-typeck.c (build_unary_op, build_conditional_expr, + build_binary_op): Likewise. + * calls.c (try_to_integrate, expand_call, + emit_library_call_value_1): Likewise. + * cgraph.c (cgraph_node_name, cgraph_function_possibly_inlined_p): + Likewise. + * cgraphunit.c (record_call_1, cgraph_analyze_function, + cgraph_expand_function): Likewise. + * convert.c (convert_to_pointer, convert_to_integer): Likewise. + * coverage.c (build_fn_info_type, build_ctr_info_type, + build_gcov_info, create_coverage): Likewise. + * dbxout.c (dbxout_init): Likewise. + * diagnostic.c (diagnostic_report_current_function): Likewise. + * dojump.c (do_jump): Likewise. + * dwarf2out.c (dwarf2_name): Likewise. + * except.c (init_eh): Likewise. + * explow.c (expr_size, int_expr_size): Likewise. + * expmed.c (make_tree, const_mult_add_overflow_p, expand_mult_add): + Likewise. + * expr.c (store_expr, store_constructor, safe_from_p, + expand_expr_real, do_store_flag, try_casesi): Likewise. + * function.c (push_function_context_to, pop_function_context_from, + free_after_parsing, assign_stack_local_1, assign_stack_temp_for_type, + put_var_into_stack, allocate_struct_function, current_function_name): + Likewise. + * integrate.c (copy_decl_for_inlining, expand_inline_function): + Likewise. + * langhooks.c (lhd_clear_binding_stack, write_global_declarations, + lhd_print_error_function): Likewise. + * opts.c (handle_option, decode_options): Likewise. + * passes.c (open_dump_file): Likewise. + * print-tree.c (print_node): Likewise. + * stmt.c (expand_fixup, fixup_gotos, expand_asm_operands, + expand_decl_cleanup, emit_case_nodes): Likewise. + * stor-layout.c (variable_size): Likewise. + * toplev.c (announce_function, wrapup_global_declarations, + check_global_declarations, compile_file, default_tree_printer, + process_options, lang_dependent_init, finalize): Likewise. + * tree-dump.c (dequeue_and_dump): Likewise. + * tree-inline.c (remap_decl, remap_block, copy_body_r, + initialize_inlined_parameters, declare_return_variable, + inlinable_function_p, expand_call_inline, optimize_inline_calls, + walk_tree, copy_tree_r): Likewise. + * tree-optimize.c (tree_rest_of_compilation): Likewise. + * tree.c (decl_assembler_name, tree_size, size_in_bytes, staticp, + unsafe_for_reeval, get_unwidened, get_narrower, get_callee_fndecl, + variably_modified_type_p, dump_tree_statistics): Likewise. + * varasm.c (assemble_variable, compare_constant, copy_constant, + force_const_mem, compute_reloc_for_constant, output_constant, + output_addressed_constants, initializer_constant_valid_p): Likewise. + 2004-03-14 Kelley Cook * doc/install.texi: Make autoconf 2.13 the exception, not the rule. diff --git a/gcc/alias.c b/gcc/alias.c index 30013ec..f317a57 100644 --- a/gcc/alias.c +++ b/gcc/alias.c @@ -486,7 +486,7 @@ get_alias_set (tree t) /* Remove any nops, then give the language a chance to do something with this tree before we look at it. */ STRIP_NOPS (t); - set = (*lang_hooks.get_alias_set) (t); + set = lang_hooks.get_alias_set (t); if (set != -1) return set; @@ -577,7 +577,7 @@ get_alias_set (tree t) return TYPE_ALIAS_SET (t); /* See if the language has special handling for this type. */ - set = (*lang_hooks.get_alias_set) (t); + set = lang_hooks.get_alias_set (t); if (set != -1) return set; diff --git a/gcc/builtins.c b/gcc/builtins.c index b6fa872..a206b7c 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -4090,7 +4090,7 @@ expand_builtin_va_arg (tree valist, tree type) /* Generate a diagnostic for requesting data of a type that cannot be passed through `...' due to type promotion at the call site. */ - else if ((promoted_type = (*lang_hooks.types.type_promotes_to) (type)) + else if ((promoted_type = lang_hooks.types.type_promotes_to (type)) != type) { const char *name = "", *pname = 0; diff --git a/gcc/c-common.c b/gcc/c-common.c index 4c0ce27..3e0b539 100644 --- a/gcc/c-common.c +++ b/gcc/c-common.c @@ -1086,7 +1086,7 @@ fname_as_string (int pretty_p) } if (current_function_decl) - name = (*lang_hooks.decl_printable_name) (current_function_decl, vrb); + name = lang_hooks.decl_printable_name (current_function_decl, vrb); return name; } @@ -2646,15 +2646,15 @@ c_common_truthvalue_conversion (tree expr) case COMPLEX_EXPR: return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)) ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), - (*lang_hooks.truthvalue_conversion) (TREE_OPERAND (expr, 0)), - (*lang_hooks.truthvalue_conversion) (TREE_OPERAND (expr, 1)), + lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)), + lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)), 0); case NEGATE_EXPR: case ABS_EXPR: case FLOAT_EXPR: /* These don't change whether an object is nonzero or zero. */ - return (*lang_hooks.truthvalue_conversion) (TREE_OPERAND (expr, 0)); + return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)); case LROTATE_EXPR: case RROTATE_EXPR: @@ -2662,15 +2662,15 @@ c_common_truthvalue_conversion (tree expr) we can't ignore them if their second arg has side-effects. */ if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))) return build (COMPOUND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 1), - (*lang_hooks.truthvalue_conversion) (TREE_OPERAND (expr, 0))); + lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0))); else - return (*lang_hooks.truthvalue_conversion) (TREE_OPERAND (expr, 0)); + return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)); case COND_EXPR: /* Distribute the conversion into the arms of a COND_EXPR. */ return fold (build (COND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 0), - (*lang_hooks.truthvalue_conversion) (TREE_OPERAND (expr, 1)), - (*lang_hooks.truthvalue_conversion) (TREE_OPERAND (expr, 2)))); + lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 1)), + lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 2)))); case CONVERT_EXPR: /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE, @@ -2683,7 +2683,7 @@ c_common_truthvalue_conversion (tree expr) /* If this is widening the argument, we can ignore it. */ if (TYPE_PRECISION (TREE_TYPE (expr)) >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0)))) - return (*lang_hooks.truthvalue_conversion) (TREE_OPERAND (expr, 0)); + return lang_hooks.truthvalue_conversion (TREE_OPERAND (expr, 0)); break; case MINUS_EXPR: @@ -2732,8 +2732,8 @@ c_common_truthvalue_conversion (tree expr) return (build_binary_op ((TREE_SIDE_EFFECTS (expr) ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), - (*lang_hooks.truthvalue_conversion) (build_unary_op (REALPART_EXPR, t, 0)), - (*lang_hooks.truthvalue_conversion) (build_unary_op (IMAGPART_EXPR, t, 0)), + lang_hooks.truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)), + lang_hooks.truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)), 0)); } @@ -3099,43 +3099,43 @@ c_common_nodes_and_builtins (void) /* 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, - intHI_type_node)); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE, - intSI_type_node)); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE, - intDI_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, + intQI_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, + intHI_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, + intSI_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, + intDI_type_node)); #if HOST_BITS_PER_WIDE_INT >= 64 - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, - get_identifier ("__int128_t"), - intTI_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, + get_identifier ("__int128_t"), + intTI_type_node)); #endif - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE, - unsigned_intQI_type_node)); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE, - unsigned_intHI_type_node)); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE, - unsigned_intSI_type_node)); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE, - unsigned_intDI_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, + unsigned_intQI_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, + unsigned_intHI_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, + unsigned_intSI_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, + unsigned_intDI_type_node)); #if HOST_BITS_PER_WIDE_INT >= 64 - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, - get_identifier ("__uint128_t"), - unsigned_intTI_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, + get_identifier ("__uint128_t"), + unsigned_intTI_type_node)); #endif /* Create the widest literal types. */ widest_integer_literal_type_node = make_signed_type (HOST_BITS_PER_WIDE_INT * 2); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE, - widest_integer_literal_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, + widest_integer_literal_type_node)); widest_unsigned_literal_type_node = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE, - widest_unsigned_literal_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE, + widest_unsigned_literal_type_node)); /* `unsigned long' is the standard type for sizeof. Note that stddef.h uses `unsigned long', @@ -3151,16 +3151,16 @@ c_common_nodes_and_builtins (void) record_builtin_type (RID_DOUBLE, NULL, double_type_node); record_builtin_type (RID_MAX, "long double", long_double_type_node); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, - get_identifier ("complex int"), - complex_integer_type_node)); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, - get_identifier ("complex float"), - complex_float_type_node)); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, - get_identifier ("complex double"), - complex_double_type_node)); - (*lang_hooks.decls.pushdecl) + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, + get_identifier ("complex int"), + complex_integer_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, + get_identifier ("complex float"), + complex_float_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, + get_identifier ("complex double"), + complex_double_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"), complex_long_double_type_node)); @@ -3184,12 +3184,12 @@ c_common_nodes_and_builtins (void) if (g77_integer_type_node != NULL_TREE) { - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, - get_identifier ("__g77_integer"), - g77_integer_type_node)); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, - get_identifier ("__g77_uinteger"), - g77_uinteger_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, + get_identifier ("__g77_integer"), + g77_integer_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, + get_identifier ("__g77_uinteger"), + g77_uinteger_type_node)); } if (TYPE_PRECISION (float_type_node) * 2 @@ -3209,12 +3209,12 @@ c_common_nodes_and_builtins (void) if (g77_longint_type_node != NULL_TREE) { - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, - get_identifier ("__g77_longint"), - g77_longint_type_node)); - (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, - get_identifier ("__g77_ulongint"), - g77_ulongint_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, + get_identifier ("__g77_longint"), + g77_longint_type_node)); + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, + get_identifier ("__g77_ulongint"), + g77_ulongint_type_node)); } record_builtin_type (RID_VOID, NULL, void_type_node); @@ -3281,15 +3281,15 @@ c_common_nodes_and_builtins (void) = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE))); unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node); - (*lang_hooks.decls.pushdecl) + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"), va_list_type_node)); - (*lang_hooks.decls.pushdecl) + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"), ptrdiff_type_node)); - (*lang_hooks.decls.pushdecl) + lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"), sizetype)); @@ -4629,7 +4629,7 @@ handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED, if (mode == VOIDmode) error ("unknown machine mode `%s'", p); - else if (0 == (typefm = (*lang_hooks.types.type_for_mode) + else if (0 == (typefm = lang_hooks.types.type_for_mode (mode, TREE_UNSIGNED (type)))) error ("no data type for mode `%s'", p); else if ((TREE_CODE (type) == POINTER_TYPE @@ -5194,8 +5194,8 @@ handle_vector_size_attribute (tree *node, tree name, tree args, { tree index, array, rt, list_node; - new_type = (*lang_hooks.types.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/c-convert.c b/gcc/c-convert.c index 20d2e46..582ec8b 100644 --- a/gcc/c-convert.c +++ b/gcc/c-convert.c @@ -95,7 +95,7 @@ convert (tree type, tree expr) return fold (convert_to_integer (type, e)); if (code == BOOLEAN_TYPE) { - tree t = (*lang_hooks.truthvalue_conversion) (expr); + tree t = lang_hooks.truthvalue_conversion (expr); if (TREE_CODE (t) == ERROR_MARK) return t; diff --git a/gcc/c-format.c b/gcc/c-format.c index a532259..9da4200 100644 --- a/gcc/c-format.c +++ b/gcc/c-format.c @@ -1,6 +1,6 @@ /* Check calls to formatted I/O functions (-Wformat). Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, - 2001, 2002, 2003 Free Software Foundation, Inc. + 2001, 2002, 2003, 2004 Free Software Foundation, Inc. This file is part of GCC. @@ -2286,7 +2286,7 @@ check_format_types (int *status, format_wanted_type *types) abort (); if (types->pointer_count == 0) - wanted_type = (*lang_hooks.types.type_promotes_to) (wanted_type); + wanted_type = lang_hooks.types.type_promotes_to (wanted_type); STRIP_NOPS (cur_param); diff --git a/gcc/c-objc-common.c b/gcc/c-objc-common.c index d011ef4..3bc89ee 100644 --- a/gcc/c-objc-common.c +++ b/gcc/c-objc-common.c @@ -290,14 +290,14 @@ c_tree_printer (pretty_printer *pp, text_info *text) case 'D': case 'F': if (DECL_NAME (t)) - n = (*lang_hooks.decl_printable_name) (t, 2); + n = lang_hooks.decl_printable_name (t, 2); break; case 'T': if (TREE_CODE (t) == TYPE_DECL) { if (DECL_NAME (t)) - n = (*lang_hooks.decl_printable_name) (t, 2); + n = lang_hooks.decl_printable_name (t, 2); } else { diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c index 20768cc..bb9cdd3 100644 --- a/gcc/c-typeck.c +++ b/gcc/c-typeck.c @@ -2285,7 +2285,7 @@ build_unary_op (enum tree_code code, tree xarg, int flag) error ("wrong type argument to unary exclamation mark"); return error_mark_node; } - arg = (*lang_hooks.truthvalue_conversion) (arg); + arg = lang_hooks.truthvalue_conversion (arg); return invert_truthvalue (arg); case NOP_EXPR: @@ -2658,7 +2658,7 @@ build_conditional_expr (tree ifexp, tree op1, tree op2) tree result_type = NULL; tree orig_op1 = op1, orig_op2 = op2; - ifexp = (*lang_hooks.truthvalue_conversion) (default_conversion (ifexp)); + ifexp = lang_hooks.truthvalue_conversion (default_conversion (ifexp)); /* Promote both alternatives. */ @@ -6566,8 +6566,8 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, but that does not mean the operands should be converted to ints! */ result_type = integer_type_node; - op0 = (*lang_hooks.truthvalue_conversion) (op0); - op1 = (*lang_hooks.truthvalue_conversion) (op1); + op0 = lang_hooks.truthvalue_conversion (op0); + op1 = lang_hooks.truthvalue_conversion (op1); converted = 1; } break; diff --git a/gcc/calls.c b/gcc/calls.c index e58bd05..04e1671 100644 --- a/gcc/calls.c +++ b/gcc/calls.c @@ -1829,7 +1829,7 @@ try_to_integrate (tree fndecl, tree actparms, rtx target, int ignore, warning ("%Jinlining failed in call to '%F'", fndecl, fndecl); warning ("called from here"); } - (*lang_hooks.mark_addressable) (fndecl); + lang_hooks.mark_addressable (fndecl); return (rtx) (size_t) - 1; } @@ -2201,7 +2201,7 @@ expand_call (tree exp, rtx target, int ignore) warning ("%Jcan't inline call to '%F'", fndecl, fndecl); warning ("called from here"); } - (*lang_hooks.mark_addressable) (fndecl); + lang_hooks.mark_addressable (fndecl); } if (ignore @@ -2284,7 +2284,7 @@ expand_call (tree exp, rtx target, int ignore) /* In case this is a static function, note that it has been used. */ if (! TREE_ADDRESSABLE (fndecl)) - (*lang_hooks.mark_addressable) (fndecl); + lang_hooks.mark_addressable (fndecl); is_integrable = 0; } } @@ -2532,7 +2532,7 @@ expand_call (tree exp, rtx target, int ignore) != RETURN_POPS_ARGS (current_function_decl, TREE_TYPE (current_function_decl), current_function_args_size)) - || !(*lang_hooks.decls.ok_for_sibcall) (fndecl)) + || !lang_hooks.decls.ok_for_sibcall (fndecl)) try_tail_call = 0; if (try_tail_call || try_tail_recursion) @@ -3751,7 +3751,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value, decide where in memory it should come back. */ if (outmode != VOIDmode) { - tfom = (*lang_hooks.types.type_for_mode) (outmode, 0); + tfom = lang_hooks.types.type_for_mode (outmode, 0); if (aggregate_value_p (tfom, 0)) { #ifdef PCC_STATIC_STRUCT_RETURN @@ -3896,13 +3896,13 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value, slot = val; else if (must_copy) { - slot = assign_temp ((*lang_hooks.types.type_for_mode) (mode, 0), + slot = assign_temp (lang_hooks.types.type_for_mode (mode, 0), 0, 1, 1); emit_move_insn (slot, val); } else { - tree type = (*lang_hooks.types.type_for_mode) (mode, 0); + tree type = lang_hooks.types.type_for_mode (mode, 0); slot = gen_rtx_MEM (mode, diff --git a/gcc/cgraph.c b/gcc/cgraph.c index 8cee3df..c45b339 100644 --- a/gcc/cgraph.c +++ b/gcc/cgraph.c @@ -353,7 +353,7 @@ cgraph_rtl_info (tree decl) const char * cgraph_node_name (struct cgraph_node *node) { - return (*lang_hooks.decl_printable_name) (node->decl, 2); + return lang_hooks.decl_printable_name (node->decl, 2); } /* Dump the callgraph. */ @@ -628,7 +628,7 @@ cgraph_function_possibly_inlined_p (tree decl) if (!cgraph_global_info_ready) return (DECL_INLINE (decl) && (!flag_really_no_inline - || (*lang_hooks.tree_inlining.disregard_inline_limits) (decl))); + || lang_hooks.tree_inlining.disregard_inline_limits (decl))); return cgraph_node (decl)->global.inlined; } diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c index 79bbe6d..2ebc4d7 100644 --- a/gcc/cgraphunit.c +++ b/gcc/cgraphunit.c @@ -293,7 +293,7 @@ record_call_1 (tree *tp, int *walk_subtrees, void *data) } if ((unsigned int) TREE_CODE (t) >= LAST_AND_UNUSED_TREE_CODE) - return (*lang_hooks.callgraph.analyze_expr) (tp, walk_subtrees, data); + return lang_hooks.callgraph.analyze_expr (tp, walk_subtrees, data); break; } @@ -329,10 +329,10 @@ cgraph_analyze_function (struct cgraph_node *node) node->local.inlinable = tree_inlinable_function_p (decl); if (!node->local.self_insns) node->local.self_insns - = (*lang_hooks.tree_inlining.estimate_num_insns) (decl); + = lang_hooks.tree_inlining.estimate_num_insns (decl); if (node->local.inlinable) node->local.disregard_inline_limits - = (*lang_hooks.tree_inlining.disregard_inline_limits) (decl); + = lang_hooks.tree_inlining.disregard_inline_limits (decl); for (e = node->callers; e; e = e->next_caller) if (e->inline_failed) { @@ -530,7 +530,7 @@ cgraph_expand_function (struct cgraph_node *node) /* Generate RTL for the body of DECL. Nested functions are expanded via lang_expand_decl_stmt. */ - (*lang_hooks.callgraph.expand_function) (decl); + lang_hooks.callgraph.expand_function (decl); if (DECL_DEFER_OUTPUT (decl)) abort (); diff --git a/gcc/convert.c b/gcc/convert.c index 9bb28aa..3a83445 100644 --- a/gcc/convert.c +++ b/gcc/convert.c @@ -63,7 +63,7 @@ convert_to_pointer (tree type, tree expr) return convert_to_pointer (type, - convert ((*lang_hooks.types.type_for_size) + convert (lang_hooks.types.type_for_size (POINTER_SIZE, 0), expr)); default: @@ -304,8 +304,9 @@ convert_to_integer (tree type, tree expr) if (integer_zerop (expr)) expr = integer_zero_node; else - expr = fold (build1 (CONVERT_EXPR, (*lang_hooks.types.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); @@ -378,7 +379,7 @@ convert_to_integer (tree type, tree expr) else if (TREE_CODE (type) == ENUMERAL_TYPE || outprec != GET_MODE_BITSIZE (TYPE_MODE (type))) return build1 (NOP_EXPR, type, - convert ((*lang_hooks.types.type_for_mode) + convert (lang_hooks.types.type_for_mode (TYPE_MODE (type), TREE_UNSIGNED (type)), expr)); @@ -490,7 +491,7 @@ convert_to_integer (tree type, tree 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 = (*lang_hooks.types.type_for_size) + typex = lang_hooks.types.type_for_size (TYPE_PRECISION (typex), TREE_UNSIGNED (typex)); /* But now perhaps TYPEX is as wide as INPREC. @@ -517,9 +518,9 @@ convert_to_integer (tree type, tree expr) || ex_form == LROTATE_EXPR || ex_form == RROTATE_EXPR)) || ex_form == LSHIFT_EXPR) - typex = (*lang_hooks.types.unsigned_type) (typex); + typex = lang_hooks.types.unsigned_type (typex); else - typex = (*lang_hooks.types.signed_type) (typex); + typex = lang_hooks.types.signed_type (typex); return convert (type, fold (build (ex_form, typex, convert (typex, arg0), @@ -539,7 +540,7 @@ convert_to_integer (tree type, tree 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 = (*lang_hooks.types.type_for_size) + typex = lang_hooks.types.type_for_size (TYPE_PRECISION (typex), TREE_UNSIGNED (typex)); /* But now perhaps TYPEX is as wide as INPREC. @@ -550,9 +551,9 @@ convert_to_integer (tree type, tree expr) /* Don't do unsigned arithmetic where signed was wanted, or vice versa. */ if (TREE_UNSIGNED (TREE_TYPE (expr))) - typex = (*lang_hooks.types.unsigned_type) (typex); + typex = lang_hooks.types.unsigned_type (typex); else - typex = (*lang_hooks.types.signed_type) (typex); + typex = lang_hooks.types.signed_type (typex); return convert (type, fold (build1 (ex_form, typex, convert (typex, diff --git a/gcc/coverage.c b/gcc/coverage.c index d045d79..27643fa 100644 --- a/gcc/coverage.c +++ b/gcc/coverage.c @@ -560,7 +560,7 @@ coverage_end_function (void) static tree build_fn_info_type (unsigned int counters) { - tree type = (*lang_hooks.types.make_type) (RECORD_TYPE); + tree type = lang_hooks.types.make_type (RECORD_TYPE); tree field, fields; tree array_type; @@ -634,7 +634,7 @@ build_fn_info_value (const struct function_list *function, tree type) static tree build_ctr_info_type (void) { - tree type = (*lang_hooks.types.make_type) (RECORD_TYPE); + tree type = lang_hooks.types.make_type (RECORD_TYPE); tree field, fields = NULL_TREE; tree gcov_ptr_type = build_pointer_type (GCOV_TYPE_NODE); tree gcov_merge_fn_type; @@ -744,7 +744,7 @@ build_gcov_info (void) if (prg_ctr_mask & (1 << ix)) n_ctr_types++; - type = (*lang_hooks.types.make_type) (RECORD_TYPE); + type = lang_hooks.types.make_type (RECORD_TYPE); const_type = build_qualified_type (type, TYPE_QUAL_CONST); /* Version ident */ @@ -902,7 +902,7 @@ create_coverage (void) DECL_RESULT (ctor) = build_decl (RESULT_DECL, NULL_TREE, void_type_node); DECL_UNINLINABLE (ctor) = 1; - ctor = (*lang_hooks.decls.pushdecl) (ctor); + ctor = lang_hooks.decls.pushdecl (ctor); rest_of_decl_compilation (ctor, 0, 1, 0); announce_function (ctor); current_function_decl = ctor; diff --git a/gcc/dbxout.c b/gcc/dbxout.c index 2e7c1eb..1729b4e 100644 --- a/gcc/dbxout.c +++ b/gcc/dbxout.c @@ -476,7 +476,7 @@ static void dbxout_init (const char *input_file_name) { char ltext_label_name[100]; - tree syms = (*lang_hooks.decls.getdecls) (); + tree syms = lang_hooks.decls.getdecls (); asmfile = asm_out_file; diff --git a/gcc/diagnostic.c b/gcc/diagnostic.c index 5350d0c..b495d64 100644 --- a/gcc/diagnostic.c +++ b/gcc/diagnostic.c @@ -293,7 +293,7 @@ void diagnostic_report_current_function (diagnostic_context *context) { diagnostic_report_current_module (context); - (*lang_hooks.print_error_function) (context, input_filename); + lang_hooks.print_error_function (context, input_filename); } void diff --git a/gcc/dojump.c b/gcc/dojump.c index 48e4953..d0cc13c 100644 --- a/gcc/dojump.c +++ b/gcc/dojump.c @@ -1,6 +1,6 @@ /* Convert tree expression to rtl instructions, for GNU compiler. Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. This file is part of GCC. @@ -151,7 +151,7 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label) case UNSAVE_EXPR: do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label); TREE_OPERAND (exp, 0) - = (*lang_hooks.unsave_expr_now) (TREE_OPERAND (exp, 0)); + = lang_hooks.unsave_expr_now (TREE_OPERAND (exp, 0)); break; case NOP_EXPR: @@ -218,7 +218,7 @@ do_jump (tree exp, rtx if_false_label, rtx 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 = (*lang_hooks.types.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)) @@ -278,7 +278,7 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label) get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode, &unsignedp, &volatilep); - type = (*lang_hooks.types.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)) diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index 90a9caa..a9639c3 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -6983,7 +6983,7 @@ output_comp_unit (dw_die_ref die, int output_if_empty) static const char * dwarf2_name (tree decl, int scope) { - return (*lang_hooks.decl_printable_name) (decl, scope ? 1 : 0); + return lang_hooks.decl_printable_name (decl, scope ? 1 : 0); } /* Add a new entry to .debug_pubnames if appropriate. */ diff --git a/gcc/except.c b/gcc/except.c index 809f653..4e38df2 100644 --- a/gcc/except.c +++ b/gcc/except.c @@ -377,7 +377,7 @@ init_eh (void) { tree f_jbuf, f_per, f_lsda, f_prev, f_cs, f_data, tmp; - sjlj_fc_type_node = (*lang_hooks.types.make_type) (RECORD_TYPE); + sjlj_fc_type_node = lang_hooks.types.make_type (RECORD_TYPE); f_prev = build_decl (FIELD_DECL, get_identifier ("__prev"), build_pointer_type (sjlj_fc_type_node)); @@ -388,7 +388,7 @@ init_eh (void) DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node; tmp = build_index_type (build_int_2 (4 - 1, 0)); - tmp = build_array_type ((*lang_hooks.types.type_for_mode) (word_mode, 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); DECL_FIELD_CONTEXT (f_data) = sjlj_fc_type_node; diff --git a/gcc/explow.c b/gcc/explow.c index f1adacd..0655f24 100644 --- a/gcc/explow.c +++ b/gcc/explow.c @@ -240,7 +240,7 @@ eliminate_constant_term (rtx x, rtx *constptr) rtx expr_size (tree exp) { - tree size = (*lang_hooks.expr_size) (exp); + tree size = lang_hooks.expr_size (exp); if (CONTAINS_PLACEHOLDER_P (size)) size = build (WITH_RECORD_EXPR, sizetype, size, exp); @@ -254,7 +254,7 @@ expr_size (tree exp) HOST_WIDE_INT int_expr_size (tree exp) { - tree t = (*lang_hooks.expr_size) (exp); + tree t = lang_hooks.expr_size (exp); if (t == 0 || TREE_CODE (t) != INTEGER_CST diff --git a/gcc/expmed.c b/gcc/expmed.c index fe81877..8586f40 100644 --- a/gcc/expmed.c +++ b/gcc/expmed.c @@ -4180,14 +4180,14 @@ make_tree (tree type, rtx x) make_tree (type, XEXP (x, 1)))); case LSHIFTRT: - t = (*lang_hooks.types.unsigned_type) (type); + t = lang_hooks.types.unsigned_type (type); return fold (convert (type, build (RSHIFT_EXPR, t, make_tree (t, XEXP (x, 0)), make_tree (type, XEXP (x, 1))))); case ASHIFTRT: - t = (*lang_hooks.types.signed_type) (type); + t = lang_hooks.types.signed_type (type); return fold (convert (type, build (RSHIFT_EXPR, t, make_tree (t, XEXP (x, 0)), @@ -4195,7 +4195,7 @@ make_tree (tree type, rtx x) case DIV: if (TREE_CODE (type) != REAL_TYPE) - t = (*lang_hooks.types.signed_type) (type); + t = lang_hooks.types.signed_type (type); else t = type; @@ -4204,7 +4204,7 @@ make_tree (tree type, rtx x) make_tree (t, XEXP (x, 0)), make_tree (t, XEXP (x, 1))))); case UDIV: - t = (*lang_hooks.types.unsigned_type) (type); + t = lang_hooks.types.unsigned_type (type); return fold (convert (type, build (TRUNC_DIV_EXPR, t, make_tree (t, XEXP (x, 0)), @@ -4212,8 +4212,8 @@ make_tree (tree type, rtx x) case SIGN_EXTEND: case ZERO_EXTEND: - t = (*lang_hooks.types.type_for_mode) (GET_MODE (XEXP (x, 0)), - GET_CODE (x) == ZERO_EXTEND); + t = lang_hooks.types.type_for_mode (GET_MODE (XEXP (x, 0)), + GET_CODE (x) == ZERO_EXTEND); return fold (convert (type, make_tree (t, XEXP (x, 0)))); default: @@ -4245,7 +4245,7 @@ const_mult_add_overflow_p (rtx x, rtx mult, rtx add, enum machine_mode mode, int { tree type, mult_type, add_type, result; - type = (*lang_hooks.types.type_for_mode) (mode, unsignedp); + type = lang_hooks.types.type_for_mode (mode, unsignedp); /* In order to get a proper overflow indication from an unsigned type, we have to pretend that it's a sizetype. */ @@ -4257,7 +4257,7 @@ const_mult_add_overflow_p (rtx x, rtx mult, rtx add, enum machine_mode mode, int } add_type = (GET_MODE (add) == VOIDmode ? mult_type - : (*lang_hooks.types.type_for_mode) (GET_MODE (add), unsignedp)); + : lang_hooks.types.type_for_mode (GET_MODE (add), unsignedp)); result = fold (build (PLUS_EXPR, mult_type, fold (build (MULT_EXPR, mult_type, @@ -4280,10 +4280,10 @@ rtx expand_mult_add (rtx x, rtx target, rtx mult, rtx add, enum machine_mode mode, int unsignedp) { - tree type = (*lang_hooks.types.type_for_mode) (mode, unsignedp); + tree type = lang_hooks.types.type_for_mode (mode, unsignedp); tree add_type = (GET_MODE (add) == VOIDmode - ? type: (*lang_hooks.types.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 46140bb..b909c7c 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -4128,10 +4128,10 @@ store_expr (tree exp, rtx target, int want_value) if (TREE_UNSIGNED (TREE_TYPE (exp)) != SUBREG_PROMOTED_UNSIGNED_P (target)) exp = convert - ((*lang_hooks.types.signed_or_unsigned_type) + (lang_hooks.types.signed_or_unsigned_type (SUBREG_PROMOTED_UNSIGNED_P (target), TREE_TYPE (exp)), exp); - exp = convert ((*lang_hooks.types.type_for_mode) + exp = convert (lang_hooks.types.type_for_mode (GET_MODE (SUBREG_REG (target)), SUBREG_PROMOTED_UNSIGNED_P (target)), exp); @@ -4655,7 +4655,7 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size) if (TYPE_PRECISION (type) < BITS_PER_WORD) { - type = (*lang_hooks.types.type_for_size) + type = lang_hooks.types.type_for_size (BITS_PER_WORD, TREE_UNSIGNED (type)); value = convert (type, value); } @@ -5122,7 +5122,7 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size) { targetx = assign_temp - ((build_qualified_type ((*lang_hooks.types.type_for_mode) + ((build_qualified_type (lang_hooks.types.type_for_mode (GET_MODE (target), 0), TYPE_QUAL_CONST)), 0, 1, 1); @@ -5937,7 +5937,7 @@ safe_from_p (rtx x, tree exp, int top_p) special handling. */ if ((unsigned int) TREE_CODE (exp) >= (unsigned int) LAST_AND_UNUSED_TREE_CODE - && !(*lang_hooks.safe_from_p) (x, exp)) + && !lang_hooks.safe_from_p (x, exp)) return 0; } @@ -6386,7 +6386,7 @@ expand_expr_real (tree exp, rtx target, enum machine_mode tmode, DECL_NONLOCAL (exp) = 1; if (DECL_NO_STATIC_CHAIN (current_function_decl)) abort (); - (*lang_hooks.mark_addressable) (exp); + lang_hooks.mark_addressable (exp); if (GET_CODE (DECL_RTL (exp)) != MEM) abort (); addr = XEXP (DECL_RTL (exp), 0); @@ -6649,7 +6649,7 @@ expand_expr_real (tree exp, rtx target, enum machine_mode tmode, rtx temp; temp = expand_expr (TREE_OPERAND (exp, 0), target, tmode, modifier); TREE_OPERAND (exp, 0) - = (*lang_hooks.unsave_expr_now) (TREE_OPERAND (exp, 0)); + = lang_hooks.unsave_expr_now (TREE_OPERAND (exp, 0)); return temp; } @@ -6724,7 +6724,7 @@ expand_expr_real (tree exp, rtx target, enum machine_mode tmode, /* Mark the corresponding BLOCK for output in its proper place. */ if (TREE_OPERAND (exp, 2) != 0 && ! TREE_USED (TREE_OPERAND (exp, 2))) - (*lang_hooks.decls.insert_block) (TREE_OPERAND (exp, 2)); + lang_hooks.decls.insert_block (TREE_OPERAND (exp, 2)); /* If VARS have not yet been expanded, expand them now. */ while (vars) @@ -7484,6 +7484,7 @@ expand_expr_real (tree exp, rtx target, enum machine_mode tmode, { if (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) == BUILT_IN_FRONTEND) + /* ??? Use (*fun) form because expand_expr is a macro. */ return (*lang_hooks.expand_expr) (exp, original_target, tmode, modifier, alt_rtl); @@ -8613,7 +8614,7 @@ expand_expr_real (tree exp, rtx target, enum machine_mode tmode, if (TREE_OPERAND (exp, 2) == 0) TREE_OPERAND (exp, 2) - = (*lang_hooks.maybe_build_cleanup) (slot); + = lang_hooks.maybe_build_cleanup (slot); cleanups = TREE_OPERAND (exp, 2); } } @@ -9067,8 +9068,9 @@ expand_expr_real (tree exp, rtx target, enum machine_mode tmode, abort (); default: - return (*lang_hooks.expand_expr) (exp, original_target, tmode, modifier, - alt_rtl); + /* ??? Use (*fun) form because expand_expr is a macro. */ + return (*lang_hooks.expand_expr) (exp, original_target, tmode, + modifier, alt_rtl); } /* Here to do an ordinary binary operator, generating an instruction @@ -9539,7 +9541,7 @@ do_store_flag (tree exp, rtx target, enum machine_mode mode, int only_cheap) && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1) && integer_pow2p (TREE_OPERAND (arg0, 1))) { - tree type = (*lang_hooks.types.type_for_mode) (mode, unsignedp); + tree type = lang_hooks.types.type_for_mode (mode, unsignedp); return expand_expr (fold_single_bit_test (code == NE ? NE_EXPR : EQ_EXPR, arg0, arg1, type), target, VOIDmode, EXPAND_NORMAL); @@ -9683,7 +9685,7 @@ try_casesi (tree index_type, tree index_expr, tree minval, tree range, { if (TYPE_MODE (index_type) != index_mode) { - index_expr = convert ((*lang_hooks.types.type_for_size) + index_expr = convert (lang_hooks.types.type_for_size (index_bits, 0), index_expr); index_type = TREE_TYPE (index_expr); } diff --git a/gcc/function.c b/gcc/function.c index 3d48b40..4236d15 100644 --- a/gcc/function.c +++ b/gcc/function.c @@ -345,7 +345,7 @@ push_function_context_to (tree context) outer_function_chain = p; p->fixup_var_refs_queue = 0; - (*lang_hooks.function.enter_nested) (p); + lang_hooks.function.enter_nested (p); cfun = 0; } @@ -373,7 +373,7 @@ pop_function_context_from (tree context ATTRIBUTE_UNUSED) restore_emit_status (p); - (*lang_hooks.function.leave_nested) (p); + lang_hooks.function.leave_nested (p); /* Finish doing put_var_into_stack for any of our variables which became addressable during the nested function. If only one entry has to be @@ -425,7 +425,7 @@ free_after_parsing (struct function *f) /* f->varasm is used by code generation. */ /* f->eh->eh_return_stub_label is used by code generation. */ - (*lang_hooks.function.final) (f); + lang_hooks.function.final (f); f->stmt = NULL; } @@ -532,7 +532,7 @@ assign_stack_local_1 (enum machine_mode mode, HOST_WIDE_INT size, int align, /* Allow the target to (possibly) increase the alignment of this stack slot. */ - type = (*lang_hooks.types.type_for_mode) (mode, 0); + type = lang_hooks.types.type_for_mode (mode, 0); if (type) alignment = LOCAL_ALIGNMENT (type, alignment); @@ -660,7 +660,7 @@ assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, int keep align = GET_MODE_ALIGNMENT (mode); if (! type) - type = (*lang_hooks.types.type_for_mode) (mode, 0); + type = lang_hooks.types.type_for_mode (mode, 0); if (type) align = LOCAL_ALIGNMENT (type, align); @@ -1375,7 +1375,7 @@ put_var_into_stack (tree decl, int rescan) 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 = (*lang_hooks.types.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 @@ -6422,7 +6422,7 @@ allocate_struct_function (tree fndecl) init_stmt_for_function (); init_eh_for_function (); - (*lang_hooks.function.init) (cfun); + lang_hooks.function.init (cfun); if (init_machine_status) cfun->machine = (*init_machine_status) (); @@ -8131,7 +8131,7 @@ init_function_once (void) const char * current_function_name (void) { - return (*lang_hooks.decl_printable_name) (cfun->decl, 2); + return lang_hooks.decl_printable_name (cfun->decl, 2); } #include "gt-function.h" diff --git a/gcc/integrate.c b/gcc/integrate.c index d90dfaa..d7136c3 100644 --- a/gcc/integrate.c +++ b/gcc/integrate.c @@ -373,7 +373,7 @@ copy_decl_for_inlining (tree decl, tree from_fn, tree to_fn) copy = copy_node (decl); /* The COPY is not abstract; it will be generated in TO_FN. */ DECL_ABSTRACT (copy) = 0; - (*lang_hooks.dup_lang_specific_decl) (copy); + lang_hooks.dup_lang_specific_decl (copy); /* TREE_ADDRESSABLE isn't used to indicate that a label's address has been taken; it's for internal bookkeeping in @@ -1256,7 +1256,7 @@ expand_inline_function (tree fndecl, tree parms, rtx target, int ignore, this block to the list of blocks at this binding level. We can't do it the way it's done for function-at-a-time mode the superblocks have not been created yet. */ - (*lang_hooks.decls.insert_block) (block); + lang_hooks.decls.insert_block (block); else { BLOCK_CHAIN (block) diff --git a/gcc/langhooks.c b/gcc/langhooks.c index d37ba21..4e9c3e9 100644 --- a/gcc/langhooks.c +++ b/gcc/langhooks.c @@ -215,7 +215,7 @@ lhd_can_use_bit_fields_p (void) void lhd_clear_binding_stack (void) { - while (! (*lang_hooks.decls.global_bindings_p) ()) + while (! lang_hooks.decls.global_bindings_p ()) poplevel (0, 0, 0); } @@ -495,7 +495,7 @@ write_global_declarations (void) Really output inline functions that must actually be callable and have not been output so far. */ - tree globals = (*lang_hooks.decls.getdecls) (); + tree globals = lang_hooks.decls.getdecls (); int len = list_length (globals); tree *vec = xmalloc (sizeof (tree) * len); int i; @@ -540,11 +540,11 @@ lhd_print_error_function (diagnostic_context *context, const char *file) if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE) pp_printf (context->printer, "In member function `%s':", - (*lang_hooks.decl_printable_name) (current_function_decl, 2)); + lang_hooks.decl_printable_name (current_function_decl, 2)); else pp_printf (context->printer, "In function `%s':", - (*lang_hooks.decl_printable_name) (current_function_decl, 2)); + lang_hooks.decl_printable_name (current_function_decl, 2)); } diagnostic_set_last_function (context); diff --git a/gcc/opts.c b/gcc/opts.c index 99d576a..f21cf25 100644 --- a/gcc/opts.c +++ b/gcc/opts.c @@ -403,7 +403,7 @@ handle_option (const char **argv, unsigned int lang_mask) if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE))) { - if (!(*lang_hooks.missing_argument) (opt, opt_index)) + if (!lang_hooks.missing_argument (opt, opt_index)) error ("missing argument to \"%s\"", opt); goto done; } @@ -421,7 +421,7 @@ handle_option (const char **argv, unsigned int lang_mask) } if (option->flags & lang_mask) - if ((*lang_hooks.handle_option) (opt_index, arg, value) == 0) + if (lang_hooks.handle_option (opt_index, arg, value) == 0) result = 0; if (result && (option->flags & CL_COMMON)) @@ -483,7 +483,7 @@ decode_options (unsigned int argc, const char **argv) unsigned int i, lang_mask; /* Perform language-specific options initialization. */ - lang_mask = (*lang_hooks.init_options) (argc, argv); + lang_mask = lang_hooks.init_options (argc, argv); lang_hooks.initialize_diagnostics (global_dc); diff --git a/gcc/passes.c b/gcc/passes.c index 1bd554c..c730949 100644 --- a/gcc/passes.c +++ b/gcc/passes.c @@ -270,7 +270,7 @@ open_dump_file (enum dump_file_index index, tree decl) if (decl) fprintf (dump_file, "\n;; Function %s%s\n\n", - (*lang_hooks.decl_printable_name) (decl, 2), + lang_hooks.decl_printable_name (decl, 2), cfun->function_frequency == FUNCTION_FREQUENCY_HOT ? " (hot)" : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED diff --git a/gcc/print-tree.c b/gcc/print-tree.c index df566fb..14a7021 100644 --- a/gcc/print-tree.c +++ b/gcc/print-tree.c @@ -418,7 +418,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent) print_node (file, "result", DECL_RESULT_FLD (node), indent + 4); print_node_brief (file, "initial", DECL_INITIAL (node), indent + 4); - (*lang_hooks.print_decl) (file, node, indent); + lang_hooks.print_decl (file, node, indent); if (DECL_RTL_SET_P (node)) { @@ -549,7 +549,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent) if (TYPE_CONTEXT (node)) print_node_brief (file, "context", TYPE_CONTEXT (node), indent + 4); - (*lang_hooks.print_type) (file, node, indent); + lang_hooks.print_type (file, node, indent); if (TYPE_POINTER_TO (node) || TREE_CHAIN (node)) indent_to (file, indent + 3); @@ -708,7 +708,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent) break; case IDENTIFIER_NODE: - (*lang_hooks.print_identifier) (file, node, indent); + lang_hooks.print_identifier (file, node, indent); break; case TREE_LIST: @@ -731,7 +731,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent) default: if (TREE_CODE_CLASS (TREE_CODE (node)) == 'x') - (*lang_hooks.print_xnode) (file, node, indent); + lang_hooks.print_xnode (file, node, indent); break; } diff --git a/gcc/stmt.c b/gcc/stmt.c index b0cd4fa..3d5da37 100644 --- a/gcc/stmt.c +++ b/gcc/stmt.c @@ -868,7 +868,7 @@ expand_fixup (tree tree_label, rtx rtl_label, rtx last_insn) TREE_USED (block) = 1; if (!cfun->x_whole_function_mode_p) - (*lang_hooks.decls.insert_block) (block); + lang_hooks.decls.insert_block (block); else { BLOCK_CHAIN (block) @@ -985,8 +985,8 @@ fixup_gotos (struct nesting *thisblock, rtx stack_level, logically be inserting the fixup code. We do this for the sake of getting the debugging information right. */ - (*lang_hooks.decls.pushlevel) (0); - (*lang_hooks.decls.set_block) (f->context); + lang_hooks.decls.pushlevel (0); + lang_hooks.decls.set_block (f->context); /* Expand the cleanups for blocks this jump exits. */ if (f->cleanup_list_list) @@ -1025,7 +1025,7 @@ fixup_gotos (struct nesting *thisblock, rtx stack_level, destructed are still "in scope". */ cleanup_insns = get_insns (); - (*lang_hooks.decls.poplevel) (1, 0, 0); + lang_hooks.decls.poplevel (1, 0, 0); end_sequence (); emit_insn_after (cleanup_insns, f->before_jump); @@ -1059,12 +1059,12 @@ fixup_gotos (struct nesting *thisblock, rtx stack_level, if (TREE_CHAIN (lists) == thisblock->data.block.outer_cleanups) { start_sequence (); - (*lang_hooks.decls.pushlevel) (0); - (*lang_hooks.decls.set_block) (f->context); + lang_hooks.decls.pushlevel (0); + lang_hooks.decls.set_block (f->context); expand_cleanups (TREE_VALUE (lists), 1, 1); do_pending_stack_adjust (); cleanup_insns = get_insns (); - (*lang_hooks.decls.poplevel) (1, 0, 0); + lang_hooks.decls.poplevel (1, 0, 0); end_sequence (); if (cleanup_insns != 0) f->before_jump @@ -1552,7 +1552,7 @@ expand_asm_operands (tree string, tree outputs, tree inputs, || (DECL_P (val) && GET_CODE (DECL_RTL (val)) == REG && GET_MODE (DECL_RTL (val)) != TYPE_MODE (type)))) - (*lang_hooks.mark_addressable) (val); + lang_hooks.mark_addressable (val); if (is_inout) ninout++; @@ -1581,7 +1581,7 @@ expand_asm_operands (tree string, tree outputs, tree inputs, return; if (! allows_reg && allows_mem) - (*lang_hooks.mark_addressable) (TREE_VALUE (tail)); + lang_hooks.mark_addressable (TREE_VALUE (tail)); } /* Second pass evaluates arguments. */ @@ -4138,12 +4138,12 @@ expand_decl_cleanup (tree decl, tree cleanup) emit_move_insn (flag, const1_rtx); cond = build_decl (VAR_DECL, NULL_TREE, - (*lang_hooks.types.type_for_mode) (word_mode, 1)); + lang_hooks.types.type_for_mode (word_mode, 1)); SET_DECL_RTL (cond, flag); /* Conditionalize the cleanup. */ cleanup = build (COND_EXPR, void_type_node, - (*lang_hooks.truthvalue_conversion) (cond), + lang_hooks.truthvalue_conversion (cond), cleanup, integer_zero_node); cleanup = fold (cleanup); @@ -6464,7 +6464,7 @@ emit_case_nodes (rtx index, case_node_ptr node, rtx default_label, else if (!low_bound && !high_bound) { /* Widen LOW and HIGH to the same width as INDEX. */ - tree type = (*lang_hooks.types.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/stor-layout.c b/gcc/stor-layout.c index 979aaba..7923492 100644 --- a/gcc/stor-layout.c +++ b/gcc/stor-layout.c @@ -142,7 +142,7 @@ variable_size (tree size) just return SIZE unchanged. Likewise for self-referential sizes and constant sizes. */ if (TREE_CONSTANT (size) - || (*lang_hooks.decls.global_bindings_p) () < 0 + || lang_hooks.decls.global_bindings_p () < 0 || CONTAINS_PLACEHOLDER_P (size)) return size; @@ -164,7 +164,7 @@ variable_size (tree size) if (TREE_CODE (save) == SAVE_EXPR) SAVE_EXPR_PERSISTENT_P (save) = 1; - if ((*lang_hooks.decls.global_bindings_p) ()) + if (lang_hooks.decls.global_bindings_p ()) { if (TREE_CONSTANT (size)) error ("type size can't be explicitly evaluated"); diff --git a/gcc/toplev.c b/gcc/toplev.c index 8192a1a..13bd98e 100644 --- a/gcc/toplev.c +++ b/gcc/toplev.c @@ -1085,7 +1085,7 @@ announce_function (tree decl) if (rtl_dump_and_exit) verbatim ("%s ", IDENTIFIER_POINTER (DECL_NAME (decl))); else - verbatim (" %s", (*lang_hooks.decl_printable_name) (decl, 2)); + verbatim (" %s", lang_hooks.decl_printable_name (decl, 2)); fflush (stderr); pp_needs_newline (global_dc->printer) = true; diagnostic_set_last_function (global_dc); @@ -1322,7 +1322,7 @@ wrapup_global_declarations (tree *vec, int len) DECL_DEFER_OUTPUT (decl) = 0; if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0) - (*lang_hooks.finish_incomplete_decl) (decl); + lang_hooks.finish_incomplete_decl (decl); } /* Now emit any global variables or functions that we have been @@ -1471,7 +1471,7 @@ check_global_declarations (tree *vec, int len) /* Global register variables must be declared to reserve them. */ && ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)) /* Otherwise, ask the language. */ - && (*lang_hooks.decls.warn_unused_global) (decl)) + && lang_hooks.decls.warn_unused_global (decl)) warning ("%J'%D' defined but not used", decl, decl); /* Avoid confusing the debug information machinery when there are @@ -1572,11 +1572,11 @@ compile_file (void) /* Call the parser, which parses the entire file (calling rest_of_compilation for each function). */ - (*lang_hooks.parse_file) (set_yydebug); + lang_hooks.parse_file (set_yydebug); /* In case there were missing block closers, get us back to the global binding level. */ - (*lang_hooks.clear_binding_stack) (); + lang_hooks.clear_binding_stack (); /* Compilation is now finished except for writing what's left of the symbol table output. */ @@ -1585,7 +1585,7 @@ compile_file (void) if (flag_syntax_only) return; - (*lang_hooks.decls.final_write_globals)(); + lang_hooks.decls.final_write_globals (); cgraph_varpool_assemble_pending_decls (); @@ -2115,7 +2115,7 @@ default_tree_printer (pretty_printer * pp, text_info *text) { tree t = va_arg (*text->args_ptr, tree); const char *n = DECL_NAME (t) - ? (*lang_hooks.decl_printable_name) (t, 2) + ? lang_hooks.decl_printable_name (t, 2) : ""; pp_string (pp, n); } @@ -2200,7 +2200,7 @@ process_options (void) initialization based on the command line options. This hook also sets the original filename if appropriate (e.g. foo.i -> foo.c) so we can correctly initialize debug output. */ - no_backend = (*lang_hooks.post_options) (&main_input_filename); + no_backend = lang_hooks.post_options (&main_input_filename); input_filename = main_input_filename; #ifdef OVERRIDE_OPTIONS @@ -2462,7 +2462,7 @@ lang_dependent_init (const char *name) dump_base_name = name ? name : "gccdump"; /* Other front-end initialization. */ - if ((*lang_hooks.init) () == 0) + if (lang_hooks.init () == 0) return 0; init_asm_output (name); @@ -2538,7 +2538,7 @@ finalize (void) free_reg_info (); /* Language-specific end of compilation actions. */ - (*lang_hooks.finish) (); + lang_hooks.finish (); } /* Initialize the compiler, and compile the input file. */ diff --git a/gcc/tree-dump.c b/gcc/tree-dump.c index 6f958cf..c00cc5f 100644 --- a/gcc/tree-dump.c +++ b/gcc/tree-dump.c @@ -1,5 +1,5 @@ /* Tree-dumping functionality for intermediate representation. - Copyright (C) 1999, 2000, 2002, 2003 Free Software Foundation, Inc. + Copyright (C) 1999, 2000, 2002, 2003, 2004 Free Software Foundation, Inc. Written by Mark Mitchell This file is part of GCC. @@ -346,7 +346,7 @@ dequeue_and_dump (dump_info_p di) else if (code_class == 't') { /* All types have qualifiers. */ - int quals = (*lang_hooks.tree_dump.type_quals) (t); + int quals = lang_hooks.tree_dump.type_quals (t); if (quals != TYPE_UNQUALIFIED) { @@ -377,7 +377,7 @@ dequeue_and_dump (dump_info_p di) /* Give the language-specific code a chance to print something. If it's completely taken care of things, don't bother printing anything more ourselves. */ - if ((*lang_hooks.tree_dump.dump_tree) (di, t)) + if (lang_hooks.tree_dump.dump_tree (di, t)) goto done; /* Now handle the various kinds of nodes. */ diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index ba5eb7a..1d410af 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -154,7 +154,7 @@ remap_decl (tree decl, inline_data *id) /* We only remap local variables in the current function. */ fn = VARRAY_TOP_TREE (id->fns); - if (! (*lang_hooks.tree_inlining.auto_var_in_fn_p) (decl, fn)) + if (! lang_hooks.tree_inlining.auto_var_in_fn_p (decl, fn)) return NULL_TREE; /* See if we have remapped this declaration. */ @@ -183,7 +183,7 @@ remap_decl (tree decl, inline_data *id) #ifndef INLINER_FOR_JAVA if (! DECL_NAME (t) && TREE_TYPE (t) - && (*lang_hooks.tree_inlining.anon_aggr_type_p) (TREE_TYPE (t))) + && lang_hooks.tree_inlining.anon_aggr_type_p (TREE_TYPE (t))) { /* For a VAR_DECL of anonymous type, we must also copy the member VAR_DECLS here and rechain the DECL_ANON_UNION_ELEMS. */ @@ -390,7 +390,7 @@ remap_block (tree *block, tree decls, inline_data *id) /* We're building a clone; DECL_INITIAL is still error_mark_node, and current_binding_level is the parm binding level. */ - (*lang_hooks.decls.insert_block) (new_block); + lang_hooks.decls.insert_block (new_block); else { /* Attach this new block after the DECL_INITIAL block for the @@ -588,7 +588,7 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) variables. We don't want to copy static variables; there's only one of those, no matter how many times we inline the containing function. */ - else if ((*lang_hooks.tree_inlining.auto_var_in_fn_p) (*tp, fn)) + else if (lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn)) { tree new_decl; @@ -648,7 +648,7 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) { if (TREE_CODE (*tp) == MODIFY_EXPR && TREE_OPERAND (*tp, 0) == TREE_OPERAND (*tp, 1) - && ((*lang_hooks.tree_inlining.auto_var_in_fn_p) + && (lang_hooks.tree_inlining.auto_var_in_fn_p (TREE_OPERAND (*tp, 0), fn))) { /* Some assignments VAR = VAR; don't generate any rtl code @@ -670,7 +670,7 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) } } else if (TREE_CODE (*tp) == ADDR_EXPR - && ((*lang_hooks.tree_inlining.auto_var_in_fn_p) + && (lang_hooks.tree_inlining.auto_var_in_fn_p (TREE_OPERAND (*tp, 0), fn))) { /* Get rid of &* from inline substitutions. It can occur when @@ -764,7 +764,7 @@ DECL_ARGUMENTS (fn); ++argnum; /* Find the initializer. */ - value = (*lang_hooks.tree_inlining.convert_parm_for_inlining) + value = lang_hooks.tree_inlining.convert_parm_for_inlining (p, a ? TREE_VALUE (a) : NULL_TREE, fn, argnum); /* If the parameter is never assigned to, we may not need to @@ -860,7 +860,7 @@ DECL_ARGUMENTS (fn); } /* See if we need to clean up the declaration. */ - cleanup = (*lang_hooks.maybe_build_cleanup) (var); + cleanup = lang_hooks.maybe_build_cleanup (var); if (cleanup) { tree cleanup_stmt; @@ -946,7 +946,7 @@ declare_return_variable (struct inline_data *id, tree return_slot_addr, } #ifndef INLINER_FOR_JAVA - var = ((*lang_hooks.tree_inlining.copy_res_decl_for_inlining) + var = (lang_hooks.tree_inlining.copy_res_decl_for_inlining (result, fn, VARRAY_TREE (id->fns, 0), id->decl_map, &need_return_decl, return_slot_addr)); @@ -970,7 +970,7 @@ declare_return_variable (struct inline_data *id, tree return_slot_addr, if (need_return_decl) return build_stmt (DECL_STMT, var); #else /* INLINER_FOR_JAVA */ - *var = ((*lang_hooks.tree_inlining.copy_res_decl_for_inlining) + *var = (lang_hooks.tree_inlining.copy_res_decl_for_inlining (result, fn, VARRAY_TREE (id->fns, 0), id->decl_map, &need_return_decl, return_slot_addr)); @@ -1170,7 +1170,7 @@ inlinable_function_p (tree fn) in C++ it may result in template instantiation.) If the function is not inlinable for language-specific reasons, it is left up to the langhook to explain why. */ - inlinable = !(*lang_hooks.tree_inlining.cannot_inline_tree_fn) (&fn); + inlinable = !lang_hooks.tree_inlining.cannot_inline_tree_fn (&fn); /* If we don't have the function body available, we can't inline it. However, this should not be recorded since we also get here for @@ -1352,7 +1352,7 @@ expand_call_inline (tree *tp, int *walk_subtrees, void *data) return NULL_TREE; } - if (! (*lang_hooks.tree_inlining.start_inlining) (fn)) + if (! lang_hooks.tree_inlining.start_inlining (fn)) return NULL_TREE; /* Set the current filename and line number to the function we are @@ -1592,7 +1592,7 @@ expand_call_inline (tree *tp, int *walk_subtrees, void *data) /* Don't walk into subtrees. We've already handled them above. */ *walk_subtrees = 0; - (*lang_hooks.tree_inlining.end_inlining) (fn); + lang_hooks.tree_inlining.end_inlining (fn); /* Keep iterating. */ return NULL_TREE; @@ -1642,7 +1642,7 @@ optimize_inline_calls (tree fn) prev_fn = current_function_decl; } - prev_fn = ((*lang_hooks.tree_inlining.add_pending_fn_decls) + prev_fn = (lang_hooks.tree_inlining.add_pending_fn_decls (&id.fns, prev_fn)); /* Create the list of functions this call will inline. */ @@ -1763,7 +1763,7 @@ walk_tree (tree *tp, walk_tree_fn func, void *data, void *htab_) if (!walk_subtrees) { if (STATEMENT_CODE_P (code) || code == TREE_LIST - || (*lang_hooks.tree_inlining.tree_chain_matters_p) (*tp)) + || lang_hooks.tree_inlining.tree_chain_matters_p (*tp)) /* But we still need to check our siblings. */ WALK_SUBTREE_TAIL (TREE_CHAIN (*tp)); else @@ -1838,8 +1838,8 @@ walk_tree (tree *tp, walk_tree_fn func, void *data, void *htab_) /* Also examine various special fields, below. */ } - result = (*lang_hooks.tree_inlining.walk_subtrees) (tp, &walk_subtrees, func, - data, htab); + result = lang_hooks.tree_inlining.walk_subtrees (tp, &walk_subtrees, func, + data, htab); if (result || ! walk_subtrees) return result; @@ -1973,7 +1973,7 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) || TREE_CODE_CLASS (code) == 'c' || code == TREE_LIST || code == TREE_VEC - || (*lang_hooks.tree_inlining.tree_chain_matters_p) (*tp)) + || lang_hooks.tree_inlining.tree_chain_matters_p (*tp)) { /* Because the chain gets clobbered when we make a copy, we save it here. */ @@ -1986,7 +1986,7 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) walk_tree to walk into the chain as well. */ if (code == PARM_DECL || code == TREE_LIST #ifndef INLINER_FOR_JAVA - || (*lang_hooks.tree_inlining.tree_chain_matters_p) (*tp) + || lang_hooks.tree_inlining.tree_chain_matters_p (*tp) || STATEMENT_CODE_P (code)) TREE_CHAIN (*tp) = chain; @@ -1995,7 +1995,7 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) if (TREE_CODE (*tp) == SCOPE_STMT) SCOPE_STMT_BLOCK (*tp) = NULL_TREE; #else /* INLINER_FOR_JAVA */ - || (*lang_hooks.tree_inlining.tree_chain_matters_p) (*tp)) + || lang_hooks.tree_inlining.tree_chain_matters_p (*tp)) TREE_CHAIN (*tp) = chain; #endif /* INLINER_FOR_JAVA */ } diff --git a/gcc/tree-optimize.c b/gcc/tree-optimize.c index 3522016..b1be8b0 100644 --- a/gcc/tree-optimize.c +++ b/gcc/tree-optimize.c @@ -131,7 +131,7 @@ tree_rest_of_compilation (tree fndecl, bool nested_p) expand_function_start (fndecl, 0); /* Allow language dialects to perform special processing. */ - (*lang_hooks.rtl_expand.start) (); + lang_hooks.rtl_expand.start (); /* If this function is `main', emit a call to `__main' to run global initializers, etc. */ @@ -141,7 +141,7 @@ tree_rest_of_compilation (tree fndecl, bool nested_p) expand_main_function (); /* Generate the RTL for this function. */ - (*lang_hooks.rtl_expand.stmt) (DECL_SAVED_TREE (fndecl)); + lang_hooks.rtl_expand.stmt (DECL_SAVED_TREE (fndecl)); /* We hard-wired immediate_size_expand to zero above. expand_function_end will decrement this variable. So, we set the @@ -150,7 +150,7 @@ tree_rest_of_compilation (tree fndecl, bool nested_p) immediate_size_expand = 1; /* Allow language dialects to perform special processing. */ - (*lang_hooks.rtl_expand.end) (); + lang_hooks.rtl_expand.end (); /* Generate rtl for function exit. */ expand_function_end (); diff --git a/gcc/tree.c b/gcc/tree.c index bc07652..8238ea4 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -131,7 +131,7 @@ tree decl_assembler_name (tree decl) { if (!DECL_ASSEMBLER_NAME_SET_P (decl)) - (*lang_hooks.set_decl_assembler_name) (decl); + lang_hooks.set_decl_assembler_name (decl); return DECL_CHECK (decl)->decl.assembler_name; } @@ -171,7 +171,7 @@ tree_size (tree node) case VECTOR_CST: return sizeof (struct tree_vector); case STRING_CST: return sizeof (struct tree_string); default: - return (*lang_hooks.tree_size) (code); + return lang_hooks.tree_size (code); } case 'x': /* something random, like an identifier. */ @@ -187,7 +187,7 @@ tree_size (tree node) case PLACEHOLDER_EXPR: return sizeof (struct tree_common); default: - return (*lang_hooks.tree_size) (code); + return lang_hooks.tree_size (code); } default: @@ -1119,7 +1119,7 @@ size_in_bytes (tree type) if (t == 0) { - (*lang_hooks.types.incomplete_type_error) (NULL_TREE, type); + lang_hooks.types.incomplete_type_error (NULL_TREE, type); return size_zero_node; } @@ -1313,7 +1313,7 @@ staticp (tree arg) default: if ((unsigned int) TREE_CODE (arg) >= (unsigned int) LAST_AND_UNUSED_TREE_CODE) - return (*lang_hooks.staticp) (arg); + return lang_hooks.staticp (arg); else return 0; } @@ -1653,7 +1653,7 @@ unsafe_for_reeval (tree expr) return exp ? unsafe_for_reeval (exp) : 0; default: - tmp = (*lang_hooks.unsafe_for_reeval) (expr); + tmp = lang_hooks.unsafe_for_reeval (expr); if (tmp >= 0) return tmp; break; @@ -4290,7 +4290,7 @@ get_unwidened (tree op, tree for_type) = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1); int unsignedp = (TREE_UNSIGNED (TREE_OPERAND (op, 1)) || TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1)))); - type = (*lang_hooks.types.type_for_size) (innerprec, unsignedp); + 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 @@ -4375,7 +4375,7 @@ get_narrower (tree op, int *unsignedp_ptr) = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1); int unsignedp = (TREE_UNSIGNED (TREE_OPERAND (op, 1)) || TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1)))); - tree type = (*lang_hooks.types.type_for_size) (innerprec, unsignedp); + tree type = lang_hooks.types.type_for_size (innerprec, unsignedp); /* We can get this structure field in a narrower type that fits it, but the resulting extension to its nominal type (a fullword type) @@ -4539,7 +4539,7 @@ variably_modified_type_p (tree type) /* The current language may have other cases to check, but in general, all other types are not variably modified. */ - return (*lang_hooks.tree_inlining.var_mod_type_p) (type); + return lang_hooks.tree_inlining.var_mod_type_p (type); } /* Given a DECL or TYPE, return the scope in which it was declared, or @@ -4660,7 +4660,7 @@ get_callee_fndecl (tree call) /* We couldn't figure out what was being called. Maybe the front end has some idea. */ - return (*lang_hooks.lang_get_callee_fndecl) (call); + return lang_hooks.lang_get_callee_fndecl (call); } /* Print debugging information about tree nodes generated during the compile, @@ -4693,7 +4693,7 @@ dump_tree_statistics (void) fprintf (stderr, "(No per-node statistics)\n"); #endif print_type_hash_statistics (); - (*lang_hooks.print_statistics) (); + lang_hooks.print_statistics (); } #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s" diff --git a/gcc/varasm.c b/gcc/varasm.c index 6a32ccc..9cf8b94 100644 --- a/gcc/varasm.c +++ b/gcc/varasm.c @@ -1297,7 +1297,7 @@ assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED, rtx decl_rtl; if (lang_hooks.decls.prepare_assemble_variable) - (*lang_hooks.decls.prepare_assemble_variable) (decl); + lang_hooks.decls.prepare_assemble_variable (decl); last_assemble_variable_decl = 0; @@ -2250,8 +2250,8 @@ compare_constant (const tree t1, const tree t2) default: { tree nt1, nt2; - nt1 = (*lang_hooks.expand_constant) (t1); - nt2 = (*lang_hooks.expand_constant) (t2); + nt1 = lang_hooks.expand_constant (t1); + nt2 = lang_hooks.expand_constant (t2); if (nt1 != t1 || nt2 != t2) return compare_constant (nt1, nt2); else @@ -2322,7 +2322,7 @@ copy_constant (tree exp) default: { tree t; - t = (*lang_hooks.expand_constant) (exp); + t = lang_hooks.expand_constant (exp); if (t != exp) return copy_constant (t); else @@ -2745,7 +2745,7 @@ force_const_mem (enum machine_mode mode, rtx x) align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode); #ifdef CONSTANT_ALIGNMENT { - tree type = (*lang_hooks.types.type_for_mode) (mode, 0); + tree type = lang_hooks.types.type_for_mode (mode, 0); if (type != NULL_TREE) align = CONSTANT_ALIGNMENT (make_tree (type, x), align); } @@ -2789,7 +2789,7 @@ force_const_mem (enum machine_mode mode, rtx x) /* Construct the MEM. */ desc->mem = def = gen_rtx_MEM (mode, symbol); - set_mem_attributes (def, (*lang_hooks.types.type_for_mode) (mode, 0), 1); + set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1); RTX_UNCHANGING_P (def) = 1; /* If we're dropping a label to the constant pool, make sure we @@ -3113,7 +3113,7 @@ compute_reloc_for_constant (tree exp) /* Give the front-end a chance to convert VALUE to something that looks more like a constant to the back-end. */ - exp = (*lang_hooks.expand_constant) (exp); + exp = lang_hooks.expand_constant (exp); switch (TREE_CODE (exp)) { @@ -3177,7 +3177,7 @@ output_addressed_constants (tree exp) /* Give the front-end a chance to convert VALUE to something that looks more like a constant to the back-end. */ - exp = (*lang_hooks.expand_constant) (exp); + exp = lang_hooks.expand_constant (exp); switch (TREE_CODE (exp)) { @@ -3233,7 +3233,7 @@ initializer_constant_valid_p (tree value, tree endtype) { /* Give the front-end a chance to convert VALUE to something that looks more like a constant to the back-end. */ - value = (*lang_hooks.expand_constant) (value); + value = lang_hooks.expand_constant (value); switch (TREE_CODE (value)) { @@ -3461,7 +3461,7 @@ output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align) /* Some front-ends use constants other than the standard language-independent varieties, but which may still be output directly. Give the front-end a chance to convert EXP to a language-independent representation. */ - exp = (*lang_hooks.expand_constant) (exp); + exp = lang_hooks.expand_constant (exp); if (size == 0 || flag_syntax_only) return; -- 2.7.4