OSDN Git Service

* alias.c (get_alias_set): Replace calls via (*lang_hooks.foo) ()
authorsayle <sayle@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 14 Mar 2004 22:26:14 +0000 (22:26 +0000)
committersayle <sayle@138bc75d-0d04-0410-961f-82ee72b054a4>
Sun, 14 Mar 2004 22:26:14 +0000 (22:26 +0000)
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

35 files changed:
gcc/ChangeLog
gcc/alias.c
gcc/builtins.c
gcc/c-common.c
gcc/c-convert.c
gcc/c-format.c
gcc/c-objc-common.c
gcc/c-typeck.c
gcc/calls.c
gcc/cgraph.c
gcc/cgraphunit.c
gcc/convert.c
gcc/coverage.c
gcc/dbxout.c
gcc/diagnostic.c
gcc/dojump.c
gcc/dwarf2out.c
gcc/except.c
gcc/explow.c
gcc/expmed.c
gcc/expr.c
gcc/function.c
gcc/integrate.c
gcc/langhooks.c
gcc/opts.c
gcc/passes.c
gcc/print-tree.c
gcc/stmt.c
gcc/stor-layout.c
gcc/toplev.c
gcc/tree-dump.c
gcc/tree-inline.c
gcc/tree-optimize.c
gcc/tree.c
gcc/varasm.c

index d15a3c2..eacd78a 100644 (file)
@@ -1,3 +1,65 @@
+2004-03-14  Roger Sayle  <roger@eyesopen.com>
+
+       * 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  <kcook@gcc.gnu.org>
 
        * doc/install.texi: Make autoconf 2.13 the exception, not the rule.
index 30013ec..f317a57 100644 (file)
@@ -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;
 
index b6fa872..a206b7c 100644 (file)
@@ -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 = "<anonymous type>", *pname = 0;
index 4c0ce27..3e0b539 100644 (file)
@@ -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)
        {
index 20d2e46..582ec8b 100644 (file)
@@ -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;
 
index a532259..9da4200 100644 (file)
@@ -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);
 
index d011ef4..3bc89ee 100644 (file)
@@ -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
        {
index 20768cc..bb9cdd3 100644 (file)
@@ -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;
index e58bd05..04e1671 100644 (file)
@@ -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,
index 8cee3df..c45b339 100644 (file)
@@ -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;
 }
 
index 79bbe6d..2ebc4d7 100644 (file)
@@ -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 ();
 
index 9bb28aa..3a83445 100644 (file)
@@ -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,
index d045d79..27643fa 100644 (file)
@@ -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;
index 2e7c1eb..1729b4e 100644 (file)
@@ -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;
 
index 5350d0c..b495d64 100644 (file)
@@ -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
index 48e4953..d0cc13c 100644 (file)
@@ -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))
index 90a9caa..a9639c3 100644 (file)
@@ -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.  */
index 809f653..4e38df2 100644 (file)
@@ -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;
index f1adacd..0655f24 100644 (file)
@@ -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
index fe81877..8586f40 100644 (file)
@@ -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),
index 46140bb..b909c7c 100644 (file)
@@ -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);
        }
index 3d48b40..4236d15 100644 (file)
@@ -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"
index d90dfaa..d7136c3 100644 (file)
@@ -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)
index d37ba21..4e9c3e9 100644 (file)
@@ -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);
index 99d576a..f21cf25 100644 (file)
@@ -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);
 
index 1bd554c..c730949 100644 (file)
@@ -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
index df566fb..14a7021 100644 (file)
@@ -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;
        }
 
index b0cd4fa..3d5da37 100644 (file)
@@ -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;
index 979aaba..7923492 100644 (file)
@@ -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");
index 8192a1a..13bd98e 100644 (file)
@@ -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)
           : "<anonymous>";
         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.  */
index 6f958cf..c00cc5f 100644 (file)
@@ -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 <mark@codesourcery.com>
 
 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.  */
index ba5eb7a..1d410af 100644 (file)
@@ -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 */
     }
index 3522016..b1be8b0 100644 (file)
@@ -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 ();
index bc07652..8238ea4 100644 (file)
@@ -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 ();
 }
 \f
 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
index 6a32ccc..9cf8b94 100644 (file)
@@ -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;