/* Default language-specific hooks.
- Copyright 2001 Free Software Foundation, Inc.
+ Copyright 2001, 2002 Free Software Foundation, Inc.
Contributed by Alexandre Oliva <aoliva@redhat.com>
This file is part of GNU CC.
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "toplev.h"
#include "tree.h"
#include "c-tree.h"
#include "rtl.h"
#include "insn-config.h"
#include "integrate.h"
+#include "flags.h"
#include "langhooks.h"
#include "langhooks-def.h"
{
}
+/* Do nothing (tree). */
+
+void
+lhd_do_nothing_t (t)
+ tree t ATTRIBUTE_UNUSED;
+{
+}
+
+/* Do nothing (int). */
+
+void
+lhd_do_nothing_i (i)
+ int i ATTRIBUTE_UNUSED;
+{
+}
+
+/* Do nothing (function). */
+
+void
+lhd_do_nothing_f (f)
+ struct function *f ATTRIBUTE_UNUSED;
+{
+}
+
/* Do nothing (return the tree node passed). */
tree
return t;
}
+/* Do nothing (return NULL_TREE). */
+
+tree
+lhd_return_null_tree (t)
+ tree t ATTRIBUTE_UNUSED;
+{
+ return NULL_TREE;
+}
+
/* Do nothing; the default hook to decode an option. */
int
return 1;
}
+/* Called from unsafe_for_reeval. */
+
+int
+lhd_unsafe_for_reeval (t)
+ tree t ATTRIBUTE_UNUSED;
+{
+ return -1;
+}
+
/* Called from staticp. */
int
lhd_staticp (exp)
- tree exp;
+ tree exp ATTRIBUTE_UNUSED;
{
return 0;
}
-/* Called when -dy is given on the command line. */
+/* Called from check_global_declarations. */
+bool
+lhd_warn_unused_global_decl (decl)
+ tree decl;
+{
+ /* This is what used to exist in check_global_declarations. Probably
+ not many of these actually apply to non-C languages. */
+
+ if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl))
+ return false;
+ if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
+ return false;
+ if (DECL_IN_SYSTEM_HEADER (decl))
+ return false;
+
+ return true;
+}
+
+/* Set the DECL_ASSEMBLER_NAME for DECL. */
void
-lhd_set_yydebug (value)
- int value;
+lhd_set_decl_assembler_name (decl)
+ tree decl;
{
- if (value)
- fprintf (stderr, "warning: no yacc/bison-generated output to debug!\n");
+ /* The language-independent code should never use the
+ DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and
+ VAR_DECLs for variables with static storage duration need a real
+ DECL_ASSEMBLER_NAME. */
+ if (TREE_CODE (decl) == FUNCTION_DECL
+ || (TREE_CODE (decl) == VAR_DECL
+ && (TREE_STATIC (decl)
+ || DECL_EXTERNAL (decl)
+ || TREE_PUBLIC (decl))))
+ /* By default, assume the name to use in assembly code is the
+ 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. */
+ SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
+ else
+ /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
+ these DECLs -- unless they're in language-dependent code, in
+ which case set_decl_assembler_name hook should handle things. */
+ abort ();
+}
+
+/* By default we always allow bit-field based optimizations. */
+bool
+lhd_can_use_bit_fields_p ()
+{
+ return true;
}
/* Provide a default routine to clear the binding stack. This is used
void
lhd_clear_binding_stack ()
{
- while (! global_bindings_p ())
+ 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;
+{
+ abort ();
+}
+
+/* Invalid use of an incomplete type. */
+void
+lhd_incomplete_type_error (value, type)
+ tree value ATTRIBUTE_UNUSED, type;
+{
+ if (TREE_CODE (type) == ERROR_MARK)
+ return;
+
+ abort ();
+}
+
/* Provide a default routine for alias sets that always returns -1. This
is used by languages that don't need to do anything special. */
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;
+{
+ abort ();
+}
+
+/* This is the default decl_printable_name function. */
+
+const char *
+lhd_decl_printable_name (decl, verbosity)
+ tree decl;
+ int verbosity ATTRIBUTE_UNUSED;
+{
+ return IDENTIFIER_POINTER (DECL_NAME (decl));
+}
+
/* 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
completely handled within this function, it should set *SUBTREES to
0, so that generic handling isn't attempted. For language-specific
tree codes, generic handling would abort(), so make sure it is set
- properly. Both SUBTREES and *SUBTREES is guaranteed to be non-zero
+ properly. Both SUBTREES and *SUBTREES is guaranteed to be nonzero
when the function is called. */
tree
int
lhd_tree_inlining_cannot_inline_tree_fn (fnp)
- tree *fnp ATTRIBUTE_UNUSED;
+ tree *fnp;
{
+ if (flag_really_no_inline
+ && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
+ return 1;
+
return 0;
}
int
lhd_tree_inlining_disregard_inline_limits (fn)
- tree fn ATTRIBUTE_UNUSED;
+ tree fn;
{
+ if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
+ return 1;
+
return 0;
}
tree
lhd_tree_inlining_copy_res_decl_for_inlining (res, fn, caller,
- dm, ndp, texps)
+ dm, ndp, return_slot_addr)
tree res, fn, caller;
void *dm ATTRIBUTE_UNUSED;
int *ndp ATTRIBUTE_UNUSED;
- void *texps ATTRIBUTE_UNUSED;
+ tree return_slot_addr ATTRIBUTE_UNUSED;
{
- return copy_decl_for_inlining (res, fn, caller);
+ 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
/* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
language-specific bookkeeping necessary for processing
- FN. start_inlining returns non-zero if inlining should proceed, zero if
+ FN. start_inlining returns nonzero if inlining should proceed, zero if
not.
For instance, the C++ version keeps track of template instantiations to
{
}
-/* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree
- nodes. Returns non-zero if it does not want the usual dumping of the
+/* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
+ 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;
+{
+ return value;
+}
+
+/* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree
+ nodes. Returns nonzero if it does not want the usual dumping of the
second argument. */
int
return 0;
}
-/* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a
+/* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a
language-specific way. */
int
return TYPE_QUALS (t);
}
+/* lang_hooks.expr_size: Determine the size of the value of an expression T
+ in a language-specific way. Returns a tree for the size in bytes. */
+
+tree
+lhd_expr_size (exp)
+ tree exp;
+{
+ if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
+ && DECL_SIZE_UNIT (exp) != 0)
+ return DECL_SIZE_UNIT (exp);
+ else
+ return size_in_bytes (TREE_TYPE (exp));
+}