/* Default language-specific hooks.
- Copyright 2001, 2002 Free Software Foundation, Inc.
+ Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ Free Software Foundation, Inc.
Contributed by Alexandre Oliva <aoliva@redhat.com>
-This file is part of GNU CC.
+This file is part of GCC.
-GNU CC is free software; you can redistribute it and/or modify
+GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
-GNU CC is distributed in the hope that it will be useful,
+GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "intl.h"
+#include "tm.h"
#include "toplev.h"
#include "tree.h"
-#include "c-tree.h"
#include "tree-inline.h"
+#include "tree-gimple.h"
#include "rtl.h"
#include "insn-config.h"
#include "integrate.h"
#include "flags.h"
#include "langhooks.h"
+#include "target.h"
#include "langhooks-def.h"
+#include "ggc.h"
+#include "diagnostic.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 ARG_UNUSED (t))
{
}
/* Do nothing (int). */
void
-lhd_do_nothing_i (i)
- int i ATTRIBUTE_UNUSED;
+lhd_do_nothing_i (int ARG_UNUSED (i))
{
}
-/* Do nothing (function). */
+/* Do nothing (int, int, int). Return NULL_TREE. */
-void
-lhd_do_nothing_f (f)
- struct function *f ATTRIBUTE_UNUSED;
+tree
+lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i),
+ int ARG_UNUSED (j),
+ int ARG_UNUSED (k))
{
+ return NULL_TREE;
}
-/* Do nothing (return the tree node passed). */
+/* Do nothing (function). */
-tree
-lhd_return_tree (t)
- tree t;
+void
+lhd_do_nothing_f (struct function * ARG_UNUSED (f))
{
- return t;
}
/* Do nothing (return NULL_TREE). */
tree
-lhd_return_null_tree (t)
- tree t ATTRIBUTE_UNUSED;
+lhd_return_null_tree_v (void)
{
return NULL_TREE;
}
-/* Do nothing; the default hook to decode an option. */
+/* Do nothing (return NULL_TREE). */
-int
-lhd_decode_option (argc, argv)
- int argc ATTRIBUTE_UNUSED;
- char **argv ATTRIBUTE_UNUSED;
+tree
+lhd_return_null_tree (tree ARG_UNUSED (t))
{
- return 0;
+ return NULL_TREE;
}
-/* Called from by print-tree.c. */
+/* Do nothing (return NULL_TREE). */
-void
-lhd_print_tree_nothing (file, node, indent)
- FILE *file ATTRIBUTE_UNUSED;
- tree node ATTRIBUTE_UNUSED;
- int indent ATTRIBUTE_UNUSED;
+tree
+lhd_return_null_const_tree (const_tree ARG_UNUSED (t))
{
+ return NULL_TREE;
}
-/* Called from safe_from_p. */
+/* The default post options hook. */
-int
-lhd_safe_from_p (x, exp)
- rtx x ATTRIBUTE_UNUSED;
- tree exp ATTRIBUTE_UNUSED;
+bool
+lhd_post_options (const char ** ARG_UNUSED (pfilename))
{
- return 1;
+ return false;
}
-/* Called from unsafe_for_reeval. */
+/* Called from by print-tree.c. */
-int
-lhd_unsafe_for_reeval (t)
- tree t ATTRIBUTE_UNUSED;
+void
+lhd_print_tree_nothing (FILE * ARG_UNUSED (file),
+ tree ARG_UNUSED (node),
+ int ARG_UNUSED (indent))
{
- return -1;
}
/* Called from staticp. */
-int
-lhd_staticp (exp)
- tree exp ATTRIBUTE_UNUSED;
+tree
+lhd_staticp (tree ARG_UNUSED (exp))
{
- return 0;
+ return NULL;
}
/* Called from check_global_declarations. */
bool
-lhd_warn_unused_global_decl (decl)
- tree decl;
+lhd_warn_unused_global_decl (const_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)
{
+ 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))))
- /* 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));
+ 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
- /* 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 ();
-}
+ {
+ const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
+ char *label;
+
+ ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
+ id = get_identifier (label);
+ }
+ SET_DECL_ASSEMBLER_NAME (decl, id);
-/* 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 ()
-{
- 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 ARG_UNUSED (type))
{
- abort ();
+ gcc_unreachable ();
}
-/* Invalid use of an incomplete type. */
+/* Registration of machine- or os-specific builtin types. */
void
-lhd_incomplete_type_error (value, type)
- tree value ATTRIBUTE_UNUSED, type;
+lhd_register_builtin_type (tree ARG_UNUSED (type),
+ const char * ARG_UNUSED (name))
{
- if (TREE_CODE (type) == ERROR_MARK)
- return;
+}
- abort ();
+/* Invalid use of an incomplete type. */
+void
+lhd_incomplete_type_error (const_tree ARG_UNUSED (value), const_tree type)
+{
+ gcc_assert (TREE_CODE (type) == ERROR_MARK);
+ return;
}
/* Provide a default routine for alias sets that always returns -1. This
is used by languages that don't need to do anything special. */
-HOST_WIDE_INT
-lhd_get_alias_set (t)
- tree t ATTRIBUTE_UNUSED;
+alias_set_type
+lhd_get_alias_set (tree ARG_UNUSED (t))
{
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. */
+/* This is the default expand_expr function. */
-HOST_WIDE_INT
-hook_get_alias_set_0 (t)
- tree t ATTRIBUTE_UNUSED;
+rtx
+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))
{
- return 0;
+ gcc_unreachable ();
}
-/* This is the default expand_expr function. */
+/* 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. */
-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;
+int
+lhd_expand_decl (tree ARG_UNUSED (t))
{
- abort ();
+ return 0;
}
/* 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 ARG_UNUSED (verbosity))
{
+ gcc_assert (decl && DECL_NAME (decl));
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
- 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 non-zero
- when the function is called. */
+/* This is the default dwarf_name function. */
-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;
+const char *
+lhd_dwarf_name (tree t, int verbosity)
{
- return NULL_TREE;
+ gcc_assert (DECL_P (t));
+
+ return lang_hooks.decl_printable_name (t, verbosity);
}
-/* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
- determine whether there are language-specific reasons for not
- inlining a given function. */
+/* 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_tree_inlining_cannot_inline_tree_fn (fnp)
- tree *fnp;
+lhd_types_compatible_p (tree x, tree y)
{
- if (flag_really_no_inline
- && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
- return 1;
+ return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
+}
- return 0;
+/* 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. */
+
+bool
+lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
+{
+ return false;
}
-/* lang_hooks.tree_inlining.disregard_inline_limits is called to
- determine whether a function should be considered for inlining even
- if it would exceed inlining limits. */
+/* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a
+ language-specific way. */
int
-lhd_tree_inlining_disregard_inline_limits (fn)
- tree fn;
+lhd_tree_dump_type_quals (const_tree t)
{
- if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
- return 1;
-
- return 0;
+ return TYPE_QUALS (t);
}
-/* 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. */
+/* 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_tree_inlining_add_pending_fn_decls (vafnp, pfn)
- void *vafnp ATTRIBUTE_UNUSED;
- tree pfn;
+lhd_expr_size (const_tree exp)
{
- return pfn;
+ if (DECL_P (exp)
+ && DECL_SIZE_UNIT (exp) != 0)
+ return DECL_SIZE_UNIT (exp);
+ else
+ return size_in_bytes (TREE_TYPE (exp));
}
-/* 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. */
+/* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */
int
-lhd_tree_inlining_tree_chain_matters_p (t)
- tree t ATTRIBUTE_UNUSED;
+lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
+ tree *post_p ATTRIBUTE_UNUSED)
{
- return 0;
+ return GS_UNHANDLED;
}
-/* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
- whether VT is an automatic variable defined in function FT. */
-
-int
-lhd_tree_inlining_auto_var_in_fn_p (var, fn)
- tree var, fn;
+/* lang_hooks.tree_size: Determine the size of a tree with code C,
+ which is a language-specific tree code in category tcc_constant or
+ tcc_exceptional. The default expects never to be called. */
+size_t
+lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
{
- return (DECL_P (var) && DECL_CONTEXT (var) == fn
- && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
- && ! TREE_STATIC (var))
- || TREE_CODE (var) == LABEL_DECL
- || TREE_CODE (var) == RESULT_DECL));
+ gcc_unreachable ();
}
-/* 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. */
+/* Return true if decl, which is a function decl, may be called by a
+ sibcall. */
-tree
-lhd_tree_inlining_copy_res_decl_for_inlining (res, fn, caller,
- dm, ndp, texps)
- tree res, fn, caller;
- void *dm ATTRIBUTE_UNUSED;
- int *ndp ATTRIBUTE_UNUSED;
- void *texps ATTRIBUTE_UNUSED;
+bool
+lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED)
{
- return copy_decl_for_inlining (res, fn, caller);
+ return true;
}
-/* 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. */
+/* Return the COMDAT group into which DECL should be placed. */
-int
-lhd_tree_inlining_anon_aggr_type_p (t)
- tree t ATTRIBUTE_UNUSED;
+const char *
+lhd_comdat_group (tree decl)
{
- return 0;
+ return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
}
-/* 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
- not.
+/* lang_hooks.decls.final_write_globals: perform final processing on
+ global variables. */
+void
+write_global_declarations (void)
+{
+ /* Really define vars that have had only a tentative definition.
+ Really output inline functions that must actually be callable
+ and have not been output so far. */
- For instance, the C++ version keeps track of template instantiations to
- avoid infinite recursion. */
+ tree globals = lang_hooks.decls.getdecls ();
+ int len = list_length (globals);
+ tree *vec = XNEWVEC (tree, len);
+ int i;
+ tree decl;
-int
-lhd_tree_inlining_start_inlining (fn)
- tree fn ATTRIBUTE_UNUSED;
+ /* Process the decls in reverse order--earliest first.
+ Put them into VEC from back to front, then take out from front. */
+
+ for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
+ vec[len - i - 1] = decl;
+
+ wrapup_global_declarations (vec, len);
+ check_global_declarations (vec, len);
+ emit_debug_global_declarations (vec, len);
+
+ /* Clean up. */
+ free (vec);
+}
+
+/* Called to perform language-specific initialization of CTX. */
+void
+lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
{
- return 1;
}
+/* The default function to print out name of current function that caused
+ an error. */
void
-lhd_tree_inlining_end_inlining (fn)
- tree fn ATTRIBUTE_UNUSED;
+lhd_print_error_function (diagnostic_context *context, const char *file,
+ diagnostic_info *diagnostic)
+{
+ if (diagnostic_last_function_changed (context, diagnostic))
+ {
+ const char *old_prefix = context->printer->prefix;
+ tree abstract_origin = diagnostic->abstract_origin;
+ char *new_prefix = (file && abstract_origin == NULL)
+ ? file_name_as_prefix (file) : NULL;
+
+ pp_set_prefix (context->printer, new_prefix);
+
+ if (current_function_decl == NULL)
+ pp_printf (context->printer, _("At top level:"));
+ else
+ {
+ tree fndecl, ao;
+
+ if (abstract_origin)
+ {
+ ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
+ while (TREE_CODE (ao) == BLOCK && BLOCK_ABSTRACT_ORIGIN (ao))
+ ao = BLOCK_ABSTRACT_ORIGIN (ao);
+ gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
+ fndecl = ao;
+ }
+ else
+ fndecl = current_function_decl;
+
+ if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
+ pp_printf
+ (context->printer, _("In member function %qs"),
+ lang_hooks.decl_printable_name (fndecl, 2));
+ else
+ pp_printf
+ (context->printer, _("In function %qs"),
+ lang_hooks.decl_printable_name (fndecl, 2));
+
+ while (abstract_origin)
+ {
+ location_t *locus;
+ tree block = abstract_origin;
+
+ locus = &BLOCK_SOURCE_LOCATION (block);
+ fndecl = NULL;
+ block = BLOCK_SUPERCONTEXT (block);
+ while (block && TREE_CODE (block) == BLOCK
+ && BLOCK_ABSTRACT_ORIGIN (block))
+ {
+ ao = BLOCK_ABSTRACT_ORIGIN (block);
+
+ while (TREE_CODE (ao) == BLOCK && BLOCK_ABSTRACT_ORIGIN (ao))
+ ao = BLOCK_ABSTRACT_ORIGIN (ao);
+
+ if (TREE_CODE (ao) == FUNCTION_DECL)
+ {
+ fndecl = ao;
+ break;
+ }
+ else if (TREE_CODE (ao) != BLOCK)
+ break;
+
+ block = BLOCK_SUPERCONTEXT (block);
+ }
+ if (fndecl)
+ abstract_origin = block;
+ else
+ {
+ while (block && TREE_CODE (block) == BLOCK)
+ block = BLOCK_SUPERCONTEXT (block);
+
+ if (TREE_CODE (block) == FUNCTION_DECL)
+ fndecl = block;
+ abstract_origin = NULL;
+ }
+ if (fndecl)
+ {
+ expanded_location s = expand_location (*locus);
+ pp_character (context->printer, ',');
+ pp_newline (context->printer);
+ if (s.file != NULL)
+ {
+ if (flag_show_column && s.column != 0)
+ pp_printf (context->printer,
+ _(" inlined from %qs at %s:%d:%d"),
+ lang_hooks.decl_printable_name (fndecl, 2),
+ s.file, s.line, s.column);
+ else
+ pp_printf (context->printer,
+ _(" inlined from %qs at %s:%d"),
+ lang_hooks.decl_printable_name (fndecl, 2),
+ s.file, s.line);
+
+ }
+ else
+ pp_printf (context->printer, _(" inlined from %qs"),
+ lang_hooks.decl_printable_name (fndecl, 2));
+ }
+ }
+ pp_character (context->printer, ':');
+ }
+
+ diagnostic_set_last_function (context, diagnostic);
+ pp_flush (context->printer);
+ context->printer->prefix = old_prefix;
+ free ((char*) new_prefix);
+ }
+}
+
+tree
+lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
+ int *walk_subtrees ATTRIBUTE_UNUSED)
+{
+ return NULL;
+}
+
+tree
+lhd_make_node (enum tree_code code)
{
+ return make_node (code);
}
-/* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
- language-specific conversion before assigning VALUE to PARM. */
+HOST_WIDE_INT
+lhd_to_target_charset (HOST_WIDE_INT c)
+{
+ return c;
+}
tree
-lhd_tree_inlining_convert_parm_for_inlining (parm, value, fndecl)
- tree parm ATTRIBUTE_UNUSED;
- tree value;
- tree fndecl ATTRIBUTE_UNUSED;
+lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
{
- return value;
+ return expr;
}
-/* 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
- second argument. */
+/* Return sharing kind if OpenMP sharing attribute of DECL is
+ predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */
-int
-lhd_tree_dump_dump_tree (di, t)
- void *di ATTRIBUTE_UNUSED;
- tree t ATTRIBUTE_UNUSED;
+enum omp_clause_default_kind
+lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
{
- return 0;
+ if (DECL_ARTIFICIAL (decl))
+ return OMP_CLAUSE_DEFAULT_SHARED;
+ return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
}
-/* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a
- language-specific way. */
+/* Generate code to copy SRC to DST. */
-int
-lhd_tree_dump_type_quals (t)
- tree t;
+tree
+lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
{
- return TYPE_QUALS (t);
+ 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) = -1;
+ gcc_assert (DECL_FUNCTION_CODE (decl) >= function_code);
+ 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;
+}