/* Default language-specific hooks.
- Copyright 2001, 2002 Free Software Foundation, Inc.
+ Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
Contributed by Alexandre Oliva <aoliva@redhat.com>
This file is part of GCC.
#include "tm.h"
#include "toplev.h"
#include "tree.h"
-#include "c-tree.h"
#include "tree-inline.h"
#include "rtl.h"
#include "insn-config.h"
/* Do nothing; in many cases the default hook. */
void
-lhd_do_nothing ()
+lhd_do_nothing (void)
{
}
/* Do nothing (tree). */
void
-lhd_do_nothing_t (t)
- tree t ATTRIBUTE_UNUSED;
+lhd_do_nothing_t (tree t ATTRIBUTE_UNUSED)
{
}
/* Do nothing (int). */
void
-lhd_do_nothing_i (i)
- int i ATTRIBUTE_UNUSED;
+lhd_do_nothing_i (int i ATTRIBUTE_UNUSED)
{
}
/* Do nothing (function). */
void
-lhd_do_nothing_f (f)
- struct function *f ATTRIBUTE_UNUSED;
+lhd_do_nothing_f (struct function *f ATTRIBUTE_UNUSED)
{
}
/* Do nothing (return the tree node passed). */
tree
-lhd_return_tree (t)
- tree t;
+lhd_return_tree (tree t)
{
return t;
}
/* Do nothing (return NULL_TREE). */
tree
-lhd_return_null_tree (t)
- tree t ATTRIBUTE_UNUSED;
+lhd_return_null_tree (tree t ATTRIBUTE_UNUSED)
{
return NULL_TREE;
}
-/* Do nothing; the default hook to decode an option. */
-
-int
-lhd_decode_option (argc, argv)
- int argc ATTRIBUTE_UNUSED;
- char **argv ATTRIBUTE_UNUSED;
-{
- return 0;
-}
-
/* The default post options hook. */
bool
-lhd_post_options (pfilename)
- const char **pfilename ATTRIBUTE_UNUSED;
+lhd_post_options (const char **pfilename ATTRIBUTE_UNUSED)
{
return false;
}
/* Called from by print-tree.c. */
void
-lhd_print_tree_nothing (file, node, indent)
- FILE *file ATTRIBUTE_UNUSED;
- tree node ATTRIBUTE_UNUSED;
- int indent ATTRIBUTE_UNUSED;
+lhd_print_tree_nothing (FILE *file ATTRIBUTE_UNUSED,
+ tree node ATTRIBUTE_UNUSED,
+ int indent ATTRIBUTE_UNUSED)
{
}
/* Called from safe_from_p. */
int
-lhd_safe_from_p (x, exp)
- rtx x ATTRIBUTE_UNUSED;
- tree exp ATTRIBUTE_UNUSED;
+lhd_safe_from_p (rtx x ATTRIBUTE_UNUSED, tree exp ATTRIBUTE_UNUSED)
{
return 1;
}
/* Called from unsafe_for_reeval. */
int
-lhd_unsafe_for_reeval (t)
- tree t ATTRIBUTE_UNUSED;
+lhd_unsafe_for_reeval (tree t ATTRIBUTE_UNUSED)
{
return -1;
}
/* Called from staticp. */
int
-lhd_staticp (exp)
- tree exp ATTRIBUTE_UNUSED;
+lhd_staticp (tree exp ATTRIBUTE_UNUSED)
{
return 0;
}
/* Called from check_global_declarations. */
bool
-lhd_warn_unused_global_decl (decl)
- tree decl;
+lhd_warn_unused_global_decl (tree decl)
{
/* This is what used to exist in check_global_declarations. Probably
not many of these actually apply to non-C languages. */
/* Set the DECL_ASSEMBLER_NAME for DECL. */
void
-lhd_set_decl_assembler_name (decl)
- tree decl;
+lhd_set_decl_assembler_name (tree decl)
{
/* The language-independent code should never use the
DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and
/* By default we always allow bit-field based optimizations. */
bool
-lhd_can_use_bit_fields_p ()
+lhd_can_use_bit_fields_p (void)
{
return true;
}
/* Provide a default routine to clear the binding stack. This is used
by languages that don't need to do anything special. */
void
-lhd_clear_binding_stack ()
+lhd_clear_binding_stack (void)
{
while (! (*lang_hooks.decls.global_bindings_p) ())
poplevel (0, 0, 0);
/* Type promotion for variable arguments. */
tree
-lhd_type_promotes_to (type)
- tree type ATTRIBUTE_UNUSED;
+lhd_type_promotes_to (tree type ATTRIBUTE_UNUSED)
{
abort ();
}
/* Invalid use of an incomplete type. */
void
-lhd_incomplete_type_error (value, type)
- tree value ATTRIBUTE_UNUSED, type;
+lhd_incomplete_type_error (tree value ATTRIBUTE_UNUSED, tree type)
{
if (TREE_CODE (type) == ERROR_MARK)
return;
is used by languages that don't need to do anything special. */
HOST_WIDE_INT
-lhd_get_alias_set (t)
- tree t ATTRIBUTE_UNUSED;
+lhd_get_alias_set (tree t ATTRIBUTE_UNUSED)
{
return -1;
}
used by languages that haven't deal with alias sets yet. */
HOST_WIDE_INT
-hook_get_alias_set_0 (t)
- tree t ATTRIBUTE_UNUSED;
+hook_get_alias_set_0 (tree t ATTRIBUTE_UNUSED)
{
return 0;
}
/* This is the default expand_expr function. */
rtx
-lhd_expand_expr (t, r, mm, em)
- tree t ATTRIBUTE_UNUSED;
- rtx r ATTRIBUTE_UNUSED;
- enum machine_mode mm ATTRIBUTE_UNUSED;
- int em ATTRIBUTE_UNUSED;
+lhd_expand_expr (tree t ATTRIBUTE_UNUSED, rtx r ATTRIBUTE_UNUSED,
+ enum machine_mode mm ATTRIBUTE_UNUSED,
+ int em ATTRIBUTE_UNUSED)
{
abort ();
}
/* This is the default decl_printable_name function. */
const char *
-lhd_decl_printable_name (decl, verbosity)
- tree decl;
- int verbosity ATTRIBUTE_UNUSED;
+lhd_decl_printable_name (tree decl, int verbosity ATTRIBUTE_UNUSED)
{
return IDENTIFIER_POINTER (DECL_NAME (decl));
}
when the function is called. */
tree
-lhd_tree_inlining_walk_subtrees (tp,subtrees,func,data,htab)
- tree *tp ATTRIBUTE_UNUSED;
- int *subtrees ATTRIBUTE_UNUSED;
- walk_tree_fn func ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
- void *htab ATTRIBUTE_UNUSED;
+lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
+ int *subtrees ATTRIBUTE_UNUSED,
+ walk_tree_fn func ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED,
+ void *htab ATTRIBUTE_UNUSED)
{
return NULL_TREE;
}
inlining a given function. */
int
-lhd_tree_inlining_cannot_inline_tree_fn (fnp)
- tree *fnp;
+lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp)
{
if (flag_really_no_inline
&& lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
if it would exceed inlining limits. */
int
-lhd_tree_inlining_disregard_inline_limits (fn)
- tree fn;
+lhd_tree_inlining_disregard_inline_limits (tree fn)
{
if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
return 1;
returned. */
tree
-lhd_tree_inlining_add_pending_fn_decls (vafnp, pfn)
- void *vafnp ATTRIBUTE_UNUSED;
- tree pfn;
+lhd_tree_inlining_add_pending_fn_decls (void *vafnp ATTRIBUTE_UNUSED, tree pfn)
{
return pfn;
}
whether it should be walked, copied and preserved across copies. */
int
-lhd_tree_inlining_tree_chain_matters_p (t)
- tree t ATTRIBUTE_UNUSED;
+lhd_tree_inlining_tree_chain_matters_p (tree t ATTRIBUTE_UNUSED)
{
return 0;
}
whether VT is an automatic variable defined in function FT. */
int
-lhd_tree_inlining_auto_var_in_fn_p (var, fn)
- tree var, fn;
+lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
{
return (DECL_P (var) && DECL_CONTEXT (var) == fn
&& (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
match RES. */
tree
-lhd_tree_inlining_copy_res_decl_for_inlining (res, fn, caller,
- dm, ndp, return_slot_addr)
- tree res, fn, caller;
- void *dm ATTRIBUTE_UNUSED;
- int *ndp ATTRIBUTE_UNUSED;
- tree return_slot_addr ATTRIBUTE_UNUSED;
+lhd_tree_inlining_copy_res_decl_for_inlining (tree res, tree fn, tree caller,
+ void *dm ATTRIBUTE_UNUSED,
+ int *ndp ATTRIBUTE_UNUSED,
+ tree return_slot_addr ATTRIBUTE_UNUSED)
{
if (return_slot_addr)
return build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (return_slot_addr)),
i.e., one whose members are in the same scope as the union itself. */
int
-lhd_tree_inlining_anon_aggr_type_p (t)
- tree t ATTRIBUTE_UNUSED;
+lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED)
{
return 0;
}
avoid infinite recursion. */
int
-lhd_tree_inlining_start_inlining (fn)
- tree fn ATTRIBUTE_UNUSED;
+lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED)
{
return 1;
}
void
-lhd_tree_inlining_end_inlining (fn)
- tree fn ATTRIBUTE_UNUSED;
+lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED)
{
}
language-specific conversion before assigning VALUE to PARM. */
tree
-lhd_tree_inlining_convert_parm_for_inlining (parm, value, fndecl)
- tree parm ATTRIBUTE_UNUSED;
- tree value;
- tree fndecl ATTRIBUTE_UNUSED;
+lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
+ tree value,
+ tree fndecl ATTRIBUTE_UNUSED)
{
return value;
}
second argument. */
bool
-lhd_tree_dump_dump_tree (di, t)
- void *di ATTRIBUTE_UNUSED;
- tree t ATTRIBUTE_UNUSED;
+lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
{
return false;
}
language-specific way. */
int
-lhd_tree_dump_type_quals (t)
- tree t;
+lhd_tree_dump_type_quals (tree t)
{
return TYPE_QUALS (t);
}
in a language-specific way. Returns a tree for the size in bytes. */
tree
-lhd_expr_size (exp)
- tree exp;
+lhd_expr_size (tree exp)
{
if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
&& DECL_SIZE_UNIT (exp) != 0)
return size_in_bytes (TREE_TYPE (exp));
}
+/* lang_hooks.tree_size: Determine the size of a tree with code C,
+ which is a language-specific tree code in category 'x'. The
+ default expects never to be called. */
+size_t
+lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
+{
+ abort ();
+ return 0;
+}
+
+/* Return true if decl, which is a function decl, may be called by a
+ sibcall. */
+
+bool
+lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
+{
+ return true;
+}
+
/* lang_hooks.decls.final_write_globals: perform final processing on
global variables. */
void
-write_global_declarations ()
+write_global_declarations (void)
{
/* Really define vars that have had only a tentative definition.
Really output inline functions that must actually be callable