procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

alias.c (get_alias_set): Replace calls via (*lang_hooks.foo) () with lang_hooks.foo ().

Browse source 
* 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.

From-SVN: r79481
This commit is contained in:
Roger Sayle 2004-03-14 22:26:14 +00:00 • committed by Roger Sayle
parent 89acbae0bc
commit ae2bcd98fa
35 changed files with 297 additions and 232 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
gcc/ChangeLog
View 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.

4
gcc/alias.c
View 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;

2
gcc/builtins.c
View 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;

130
gcc/c-common.c
View 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)
{

2
gcc/c-convert.c
View 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;

4
gcc/c-format.c
View 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);

4
gcc/c-objc-common.c
View 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
{

8
gcc/c-typeck.c
View 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;

14
gcc/calls.c
View 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,

4
gcc/cgraph.c
View 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;
}

8
gcc/cgraphunit.c
View 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 ();

21
gcc/convert.c
View 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,

8
gcc/coverage.c
View 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;

2
gcc/dbxout.c
View 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;

2
gcc/diagnostic.c
View 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

8
gcc/dojump.c
View 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))

2
gcc/dwarf2out.c
View 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. */

4
gcc/except.c
View 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;

4
gcc/explow.c
View 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

22
gcc/expmed.c
View 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),

28
gcc/expr.c
View 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);
}

16
gcc/function.c
View 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"

4
gcc/integrate.c
View 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)

8
gcc/langhooks.c
View 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);

6
gcc/opts.c
View 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);

2
gcc/passes.c
View 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

8
gcc/print-tree.c
View 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;
}

24
gcc/stmt.c
View 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;

4
gcc/stor-layout.c
View 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");

20
gcc/toplev.c
View 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. */

6
gcc/tree-dump.c
View 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. */

40
gcc/tree-inline.c
View 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 */
}

6
gcc/tree-optimize.c
View 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 ();

22
gcc/tree.c
View 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 ();
}
#define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"

20
gcc/varasm.c
View 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;