* 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

35 files changed, 297 insertions, 232 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d15a3c25006..eacd78a37e6 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -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.
diff --git a/gcc/alias.c b/gcc/alias.c
index 30013ec7d6a..f317a5720aa 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 b6fa8726b2c..a206b7c18f5 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 = "<anonymous type>", *pname = 0;
diff --git a/gcc/c-common.c b/gcc/c-common.c
index 4c0ce271077..3e0b5393a70 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 20d2e466fe3..582ec8bfe34 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 a532259750c..9da4200d3b4 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 d011ef4f5af..3bc89ee12d4 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 20768cc48bc..bb9cdd37d5a 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 e58bd05f8ce..04e167130f3 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 8cee3dfbffb..c45b3396f2a 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 79bbe6d3e0f..2ebc4d77783 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 9bb28aa40a8..3a834450eb1 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 d045d79358c..27643fa6c50 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 2e7c1eb1777..1729b4ecbc6 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 5350d0c5531..b495d6451c3 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 48e495394d5..d0cc13c45f3 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 90a9caa7ebf..a9639c3f4a9 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 809f6536c78..4e38df26db0 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 f1adacd1bc4..0655f24ded3 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 fe81877fce8..8586f403e92 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 46140bbf3e4..b909c7c7b8f 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 3d48b404a4e..4236d156bb9 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 d90dfaa1049..d7136c36e0d 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 d37ba213586..4e9c3e983be 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 99d576a3af8..f21cf250d21 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 1bd554c61e1..c730949bcf9 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 df566fbe645..14a70218fc6 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 b0cd4fa3d25..3d5da37e8cc 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 979aabab8c1..79234929171 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 8192a1a8ea8..13bd98e7f8b 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)
           : "<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.  */
diff --git a/gcc/tree-dump.c b/gcc/tree-dump.c
index 6f958cf90fd..c00cc5fe2eb 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 <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.  */
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index ba5eb7ab055..1d410af400f 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 35220167a95..b1be8b0270b 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 bc07652c0fa..8238ea407ab 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 6a32ccc76d9..9cf8b94f15a 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;