/* Default language-specific hooks.
- Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
+ Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
Contributed by Alexandre Oliva <aoliva@redhat.com>
This file is part of GCC.
#include "toplev.h"
#include "tree.h"
#include "tree-inline.h"
+#include "tree-gimple.h"
#include "rtl.h"
#include "insn-config.h"
#include "integrate.h"
/* Do nothing (tree). */
void
-lhd_do_nothing_t (tree t ATTRIBUTE_UNUSED)
+lhd_do_nothing_t (tree ARG_UNUSED (t))
{
}
/* Do nothing (int). */
void
-lhd_do_nothing_i (int i ATTRIBUTE_UNUSED)
+lhd_do_nothing_i (int ARG_UNUSED (i))
{
}
/* Do nothing (int, int, int). Return NULL_TREE. */
tree
-lhd_do_nothing_iii_return_null_tree (int i ATTRIBUTE_UNUSED,
- int j ATTRIBUTE_UNUSED,
- int k ATTRIBUTE_UNUSED)
+lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i),
+ int ARG_UNUSED (j),
+ int ARG_UNUSED (k))
{
return NULL_TREE;
}
/* Do nothing (function). */
void
-lhd_do_nothing_f (struct function *f ATTRIBUTE_UNUSED)
+lhd_do_nothing_f (struct function * ARG_UNUSED (f))
{
}
/* Do nothing (return NULL_TREE). */
tree
-lhd_return_null_tree (tree t ATTRIBUTE_UNUSED)
+lhd_return_null_tree (tree ARG_UNUSED (t))
{
return NULL_TREE;
}
/* The default post options hook. */
bool
-lhd_post_options (const char **pfilename ATTRIBUTE_UNUSED)
+lhd_post_options (const char ** ARG_UNUSED (pfilename))
{
return false;
}
/* Called from by print-tree.c. */
void
-lhd_print_tree_nothing (FILE *file ATTRIBUTE_UNUSED,
- tree node ATTRIBUTE_UNUSED,
- int indent ATTRIBUTE_UNUSED)
+lhd_print_tree_nothing (FILE * ARG_UNUSED (file),
+ tree ARG_UNUSED (node),
+ int ARG_UNUSED (indent))
{
}
/* Called from safe_from_p. */
int
-lhd_safe_from_p (rtx x ATTRIBUTE_UNUSED, tree exp ATTRIBUTE_UNUSED)
+lhd_safe_from_p (rtx ARG_UNUSED (x), tree ARG_UNUSED (exp))
{
return 1;
}
-/* Called from unsafe_for_reeval. */
-
-int
-lhd_unsafe_for_reeval (tree t ATTRIBUTE_UNUSED)
-{
- return -1;
-}
-
/* Called from staticp. */
-int
-lhd_staticp (tree exp ATTRIBUTE_UNUSED)
+tree
+lhd_staticp (tree ARG_UNUSED (exp))
{
- return 0;
+ return NULL;
}
/* Called from check_global_declarations. */
return true;
}
-/* Number for making the label on the next
- static variable internal to a function. */
-
-static GTY(()) int var_labelno;
-
/* Set the DECL_ASSEMBLER_NAME for DECL. */
void
lhd_set_decl_assembler_name (tree decl)
same as that used in the source language. (That's correct
for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
value as DECL_NAME in build_decl, so this choice provides
- backwards compatibility with existing front-ends.
+ backwards compatibility with existing front-ends.
Can't use just the variable's own name for a variable whose
scope is less than the whole compilation. Concatenate a
- distinguishing number. */
- if (!TREE_PUBLIC (decl) && DECL_CONTEXT (decl))
+ distinguishing number - we use the DECL_UID. */
+ if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE)
+ SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
+ else
{
const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
char *label;
-
- ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
- var_labelno++;
+
+ ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
}
- else
- SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
}
else
/* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
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 (void)
-{
- while (! (*lang_hooks.decls.global_bindings_p) ())
- poplevel (0, 0, 0);
-}
-
/* Type promotion for variable arguments. */
tree
-lhd_type_promotes_to (tree type ATTRIBUTE_UNUSED)
+lhd_type_promotes_to (tree ARG_UNUSED (type))
{
abort ();
}
/* Registration of machine- or os-specific builtin types. */
void
-lhd_register_builtin_type (tree type ATTRIBUTE_UNUSED,
- const char* name ATTRIBUTE_UNUSED)
+lhd_register_builtin_type (tree ARG_UNUSED (type),
+ const char * ARG_UNUSED (name))
{
}
/* Invalid use of an incomplete type. */
void
-lhd_incomplete_type_error (tree value ATTRIBUTE_UNUSED, tree type)
+lhd_incomplete_type_error (tree ARG_UNUSED (value), 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 (tree t ATTRIBUTE_UNUSED)
+lhd_get_alias_set (tree ARG_UNUSED (t))
{
return -1;
}
used by languages that haven't deal with alias sets yet. */
HOST_WIDE_INT
-hook_get_alias_set_0 (tree t ATTRIBUTE_UNUSED)
+hook_get_alias_set_0 (tree ARG_UNUSED (t))
{
return 0;
}
/* This is the default expand_expr function. */
rtx
-lhd_expand_expr (tree t ATTRIBUTE_UNUSED, rtx r ATTRIBUTE_UNUSED,
- enum machine_mode mm ATTRIBUTE_UNUSED,
- int em ATTRIBUTE_UNUSED)
+lhd_expand_expr (tree ARG_UNUSED (t), rtx ARG_UNUSED (r),
+ enum machine_mode ARG_UNUSED (mm),
+ int ARG_UNUSED (em),
+ rtx * ARG_UNUSED (a))
{
abort ();
}
+/* The default language-specific function for expanding a decl. After
+ the language-independent cases are handled, this function will be
+ called. If this function is not defined, it is assumed that
+ declarations other than those for variables and labels do not require
+ any RTL generation. */
+
+int
+lhd_expand_decl (tree ARG_UNUSED (t))
+{
+ return 0;
+}
+
/* This is the default decl_printable_name function. */
const char *
-lhd_decl_printable_name (tree decl, int verbosity ATTRIBUTE_UNUSED)
+lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
{
return IDENTIFIER_POINTER (DECL_NAME (decl));
}
+/* This compares two types for equivalence ("compatible" in C-based languages).
+ This routine should only return 1 if it is sure. It should not be used
+ in contexts where erroneously returning 0 causes problems. */
+
+int
+lhd_types_compatible_p (tree x, tree y)
+{
+ return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
+}
+
/* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
after handling common cases, but before walking code-specific
sub-trees. If this hook is overridden for a language, it should
return pfn;
}
-/* lang_hooks.tree_inlining.tree_chain_matters_p indicates whether the
- TREE_CHAIN of a language-specific tree node is relevant, i.e.,
- whether it should be walked, copied and preserved across copies. */
-
-int
-lhd_tree_inlining_tree_chain_matters_p (tree t ATTRIBUTE_UNUSED)
-{
- return 0;
-}
-
/* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
whether VT is an automatic variable defined in function FT. */
|| TREE_CODE (var) == RESULT_DECL));
}
-/* lang_hooks.tree_inlining.copy_res_decl_for_inlining should return a
- declaration for the result RES of function FN to be inlined into
- CALLER. NDP points to an integer that should be set in case a new
- declaration wasn't created (presumably because RES was of aggregate
- type, such that a TARGET_EXPR is used for the result). TEXPS is a
- pointer to a varray with the stack of TARGET_EXPRs seen while
- inlining functions into caller; the top of TEXPS is supposed to
- match RES. */
-
-tree
-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)),
- return_slot_addr);
- else
- return copy_decl_for_inlining (res, fn, caller);
-}
-
/* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
type node representing an anonymous aggregate (union, struct, etc),
i.e., one whose members are in the same scope as the union itself. */
else
return size_in_bytes (TREE_TYPE (exp));
}
-/* lang_hooks.decl_uninit: Find out if a variable is uninitialized based
- on DECL_INITIAL. */
-bool
-lhd_decl_uninit (tree t ATTRIBUTE_UNUSED)
+/* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */
+
+int
+lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
+ tree *post_p ATTRIBUTE_UNUSED)
{
- return false;
+ return GS_UNHANDLED;
}
/* lang_hooks.tree_size: Determine the size of a tree with code C,
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;
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));
}
- pp_newline (context->printer);
diagnostic_set_last_function (context);
pp_flush (context->printer);
return NULL;
}
-#include "gt-langhooks.h"
+tree
+lhd_make_node (enum tree_code code)
+{
+ return make_node (code);
+}
OSDN Git Service
