/* Default language-specific hooks.
- Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
Contributed by Alexandre Oliva <aoliva@redhat.com>
This file is part of GCC.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#include "config.h"
#include "system.h"
#include "integrate.h"
#include "flags.h"
#include "langhooks.h"
+#include "target.h"
#include "langhooks-def.h"
#include "ggc.h"
#include "diagnostic.h"
{
}
-/* Called from safe_from_p. */
-
-int
-lhd_safe_from_p (rtx ARG_UNUSED (x), tree ARG_UNUSED (exp))
-{
- return 1;
-}
-
/* Called from staticp. */
tree
void
lhd_set_decl_assembler_name (tree decl)
{
+ tree id;
+
/* 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))))
+ gcc_assert (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. This assumption is wrapped
+ in a target hook, to allow for target-specific modification of the
+ identifier.
+
+ Can't use just the variable's own name for a variable whose scope
+ is less than the whole compilation. Concatenate a distinguishing
+ number - we use the DECL_UID. */
+
+ if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE)
+ id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
+ else
{
- /* 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.
-
- Can't use just the variable's own name for a variable whose
- scope is less than the whole compilation. Concatenate a
- 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, DECL_UID (decl));
- SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
- }
+ const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
+ char *label;
+
+ ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
+ id = get_identifier (label);
}
- 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 ();
-}
+ SET_DECL_ASSEMBLER_NAME (decl, id);
-/* By default we always allow bit-field based optimizations. */
-bool
-lhd_can_use_bit_fields_p (void)
-{
- return true;
}
/* Type promotion for variable arguments. */
tree
lhd_type_promotes_to (tree ARG_UNUSED (type))
{
- abort ();
+ gcc_unreachable ();
}
/* Registration of machine- or os-specific builtin types. */
void
lhd_incomplete_type_error (tree ARG_UNUSED (value), tree type)
{
- if (TREE_CODE (type) == ERROR_MARK)
- return;
-
- abort ();
+ gcc_assert (TREE_CODE (type) == ERROR_MARK);
+ return;
}
/* Provide a default routine for alias sets that always returns -1. This
return -1;
}
-/* Provide a hook routine for alias sets that always returns 0. This is
- used by languages that haven't deal with alias sets yet. */
-
-HOST_WIDE_INT
-hook_get_alias_set_0 (tree ARG_UNUSED (t))
-{
- return 0;
-}
-
/* This is the default expand_expr function. */
rtx
int ARG_UNUSED (em),
rtx * ARG_UNUSED (a))
{
- abort ();
+ gcc_unreachable ();
}
/* The default language-specific function for expanding a decl. After
return IDENTIFIER_POINTER (DECL_NAME (decl));
}
+/* This is the default dwarf_name function. */
+
+const char *
+lhd_dwarf_name (tree t, int verbosity)
+{
+ gcc_assert (DECL_P (t));
+
+ return lang_hooks.decl_printable_name (t, verbosity);
+}
+
/* 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. */
handle language-specific tree codes, as well as language-specific
information associated to common tree codes. If a tree node is
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 nonzero
- when the function is called. */
+ 0, so that generic handling isn't attempted. The generic handling
+ cannot deal with language-specific tree codes, so make sure it is
+ set properly. Both SUBTREES and *SUBTREES is guaranteed to be
+ nonzero when the function is called. */
tree
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)
+ struct pointer_set_t *pset ATTRIBUTE_UNUSED)
{
return NULL_TREE;
}
return 0;
}
-/* lang_hooks.tree_inlining.add_pending_fn_decls is called before
- starting to inline a function, to push any language-specific
- functions that should not be inlined into the current function,
- into VAFNP. PFN is the top of varray, and should be returned if no
- functions are pushed into VAFNP. The top of the varray should be
- returned. */
-
-tree
-lhd_tree_inlining_add_pending_fn_decls (void *vafnp ATTRIBUTE_UNUSED, tree pfn)
-{
- return pfn;
-}
-
/* 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.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. */
-
-int
-lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED)
-{
- return 0;
-}
-
-/* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
- language-specific bookkeeping necessary for processing
- FN. start_inlining returns nonzero if inlining should proceed, zero if
- not.
-
- For instance, the C++ version keeps track of template instantiations to
- avoid infinite recursion. */
-
-int
-lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED)
-{
- return 1;
-}
-
-void
-lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED)
-{
-}
-
/* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
language-specific conversion before assigning VALUE to PARM. */
size_t
lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
{
- abort ();
- return 0;
+ gcc_unreachable ();
}
/* Return true if decl, which is a function decl, may be called by a
tree globals = lang_hooks.decls.getdecls ();
int len = list_length (globals);
- tree *vec = xmalloc (sizeof (tree) * len);
+ tree *vec = XNEWVEC (tree, len);
int i;
tree decl;
vec[len - i - 1] = decl;
wrapup_global_declarations (vec, len);
-
check_global_declarations (vec, len);
+ emit_debug_global_declarations (vec, len);
- /* Clean up. */
+ /* Clean up. */
free (vec);
}
{
return make_node (code);
}
+
+HOST_WIDE_INT
+lhd_to_target_charset (HOST_WIDE_INT c)
+{
+ return c;
+}
+
+tree
+lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED,
+ bool *ti ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
+{
+ return expr;
+}
+
+/* Return sharing kind if OpenMP sharing attribute of DECL is
+ predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */
+
+enum omp_clause_default_kind
+lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
+{
+ if (DECL_ARTIFICIAL (decl))
+ return OMP_CLAUSE_DEFAULT_SHARED;
+ return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
+}
+
+/* Generate code to copy SRC to DST. */
+
+tree
+lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
+{
+ return build_gimple_modify_stmt (dst, src);
+}
+
+/* Register language specific type size variables as potentially OpenMP
+ firstprivate variables. */
+
+void
+lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED,
+ tree t ATTRIBUTE_UNUSED)
+{
+}
+
+tree
+add_builtin_function (const char *name,
+ tree type,
+ int function_code,
+ enum built_in_class cl,
+ const char *library_name,
+ tree attrs)
+{
+ tree id = get_identifier (name);
+ tree decl = build_decl (FUNCTION_DECL, id, type);
+
+ TREE_PUBLIC (decl) = 1;
+ DECL_EXTERNAL (decl) = 1;
+ DECL_BUILT_IN_CLASS (decl) = cl;
+ DECL_FUNCTION_CODE (decl) = function_code;
+
+ if (library_name)
+ {
+ tree libname = get_identifier (library_name);
+ SET_DECL_ASSEMBLER_NAME (decl, libname);
+ }
+
+ /* Possibly apply some default attributes to this built-in function. */
+ if (attrs)
+ decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
+ else
+ decl_attributes (&decl, NULL_TREE, 0);
+
+ return lang_hooks.builtin_function (decl);
+
+}
+
+tree
+lhd_builtin_function (tree decl)
+{
+ lang_hooks.decls.pushdecl (decl);
+ return decl;
+}
+
+/* If TYPE is an integral type, return an equivalent type which is
+ unsigned iff UNSIGNEDP is true. If TYPE is not an integral type,
+ return TYPE itself. */
+
+tree
+get_signed_or_unsigned_type (int unsignedp, tree type)
+{
+ return lang_hooks.types.signed_or_unsigned_type(unsignedp, type);
+}
+
+/* Default implementation of the signed_or_unsigned_type language hook */
+
+tree
+lhd_signed_or_unsigned_type (int unsignedp, tree type)
+{
+ if (!INTEGRAL_TYPE_P (type) || TYPE_UNSIGNED (type) == unsignedp)
+ return type;
+
+ return lang_hooks.types.type_for_size (TYPE_PRECISION (type), unsignedp);
+}