X-Git-Url: https://oss.titaniummirror.com/gitweb?a=blobdiff_plain;f=gcc%2Flanghooks.c;h=cdf1b6a7623ee1394e32f90f73149f3802a92772;hb=6fed43773c9b0ce596dca5686f37ac3fc0fa11c0;hp=e50ebc9812b51cd88118f8c291547c22f4364330;hpb=27b11d56b743098deb193d510b337ba22dc52e5c;p=msp430-gcc.git

diff --git a/gcc/langhooks.c b/gcc/langhooks.c
index e50ebc98..cdf1b6a7 100644
--- a/gcc/langhooks.c
+++ b/gcc/langhooks.c
@@ -1,318 +1,609 @@
 /* Default language-specific hooks.
-   Copyright 2001 Free Software Foundation, Inc.
+   Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+   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 "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 (return the tree node passed).  */
+/* Do nothing (tree).  */
+
+void
+lhd_do_nothing_t (tree ARG_UNUSED (t))
+{
+}
+
+/* Do nothing (int).  */
+
+void
+lhd_do_nothing_i (int ARG_UNUSED (i))
+{
+}
+
+/* Do nothing (int, int, int).  Return NULL_TREE.  */
 
 tree
-lhd_return_tree (t)
-     tree t;
+lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i),
+				     int ARG_UNUSED (j),
+				     int ARG_UNUSED (k))
 {
-  return t;
+  return NULL_TREE;
 }
 
-/* Do nothing; the default hook to decode an option.  */
+/* Do nothing (function).  */
 
-int
-lhd_decode_option (argc, argv)
-     int argc ATTRIBUTE_UNUSED;
-     char **argv ATTRIBUTE_UNUSED;
+void
+lhd_do_nothing_f (struct function * ARG_UNUSED (f))
+{
+}
+
+/* Do nothing (return NULL_TREE).  */
+
+tree
+lhd_return_null_tree_v (void)
+{
+  return NULL_TREE;
+}
+
+/* Do nothing (return NULL_TREE).  */
+
+tree
+lhd_return_null_tree (tree ARG_UNUSED (t))
+{
+  return NULL_TREE;
+}
+
+/* Do nothing (return NULL_TREE).  */
+
+tree
+lhd_return_null_const_tree (const_tree ARG_UNUSED (t))
+{
+  return NULL_TREE;
+}
+
+/* The default post options hook.  */
+
+bool
+lhd_post_options (const char ** ARG_UNUSED (pfilename))
 {
-  return 0;
+  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 * ARG_UNUSED (file),
+			tree ARG_UNUSED (node),
+			int ARG_UNUSED (indent))
 {
 }
 
-/* Called from safe_from_p.  */
+/* Called from staticp.  */
 
-int
-lhd_safe_from_p (x, exp)
-     rtx x ATTRIBUTE_UNUSED;
-     tree exp ATTRIBUTE_UNUSED;
+tree
+lhd_staticp (tree ARG_UNUSED (exp))
 {
-  return 1;
+  return NULL;
 }
 
-/* Called from staticp.  */
+/* Called from check_global_declarations.  */
 
-int
-lhd_staticp (exp)
-     tree exp ATTRIBUTE_UNUSED;
+bool
+lhd_warn_unused_global_decl (const_tree decl)
 {
-  return 0;
+  /* 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_DECLARED_INLINE_P (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_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.  */
+  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
+    {
+      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);
+
 }
 
-/* Called when -dy is given on the command line.  */
+/* Type promotion for variable arguments.  */
+tree
+lhd_type_promotes_to (tree ARG_UNUSED (type))
+{
+  gcc_unreachable ();
+}
 
+/* Registration of machine- or os-specific builtin types.  */
 void
-lhd_set_yydebug (value)
-     int value;
+lhd_register_builtin_type (tree ARG_UNUSED (type),
+			   const char * ARG_UNUSED (name))
 {
-  if (value)
-    fprintf (stderr, "warning: no yacc/bison-generated output to debug!\n");
 }
 
-/* Provide a default routine to clear the binding stack.  This is used
-   by languages that don't need to do anything special.  */
+/* Invalid use of an incomplete type.  */
 void
-lhd_clear_binding_stack ()
+lhd_incomplete_type_error (const_tree ARG_UNUSED (value), const_tree type)
 {
-  while (! global_bindings_p ())
-    poplevel (0, 0, 0);
+  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 ();
 }
 
-/* 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 decl_printable_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_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
 {
-  return NULL_TREE;
+  gcc_assert (decl && DECL_NAME (decl));
+  return IDENTIFIER_POINTER (DECL_NAME (decl));
 }
 
-/* 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 is the default dwarf_name function.  */
 
-int
-lhd_tree_inlining_cannot_inline_tree_fn (fnp)
-     tree *fnp;
+const char *
+lhd_dwarf_name (tree t, int verbosity)
 {
-  if (flag_really_no_inline
-      && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
-    return 1;
+  gcc_assert (DECL_P (t));
 
-  return 0;
+  return lang_hooks.decl_printable_name (t, verbosity);
 }
 
-/* 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.  */
+/* 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_disregard_inline_limits (fn)
-     tree fn;
+lhd_types_compatible_p (tree x, tree y)
 {
-  if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
-    return 1;
-
-  return 0;
+  return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
 }
 
-/* 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.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.  */
 
-tree
-lhd_tree_inlining_add_pending_fn_decls (vafnp, pfn)
-     void *vafnp ATTRIBUTE_UNUSED;
-     tree pfn;
+bool
+lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
 {
-  return pfn;
+  return false;
 }
 
-/* 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.tree_dump.type_qual:  Determine type qualifiers in a
+   language-specific way.  */
 
 int
-lhd_tree_inlining_tree_chain_matters_p (t)
-     tree t ATTRIBUTE_UNUSED;
+lhd_tree_dump_type_quals (const_tree t)
 {
-  return 0;
+  return TYPE_QUALS (t);
 }
 
-/* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
-   whether VT is an automatic variable defined in function FT.  */
+/* 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 (const_tree exp)
+{
+  if (DECL_P (exp)
+      && DECL_SIZE_UNIT (exp) != 0)
+    return DECL_SIZE_UNIT (exp);
+  else
+    return size_in_bytes (TREE_TYPE (exp));
+}
+
+/* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
 
 int
-lhd_tree_inlining_auto_var_in_fn_p (var, fn)
-     tree var, fn;
+lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED,
+		   gimple_seq *pre_p ATTRIBUTE_UNUSED,
+		   gimple_seq *post_p 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));
+  return GS_UNHANDLED;
 }
 
-/* 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.  */
+/* 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)
+{
+  gcc_unreachable ();
+}
 
-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;
+/* Return true if decl, which is a function decl, may be called by a
+   sibcall.  */
+
+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)
+		     && BLOCK_ABSTRACT_ORIGIN (ao) != 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)
+			 && BLOCK_ABSTRACT_ORIGIN (ao) != 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 (block && 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);
+    }
 }
 
-/* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
-   language-specific conversion before assigning VALUE to PARM.  */
+tree
+lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
+			    int *walk_subtrees ATTRIBUTE_UNUSED)
+{
+  return NULL;
+}
 
 tree
-lhd_tree_inlining_convert_parm_for_inlining (parm, value, fndecl)
-     tree parm ATTRIBUTE_UNUSED;
-     tree value;
-     tree fndecl ATTRIBUTE_UNUSED;
+lhd_make_node (enum tree_code code)
 {
-  return value;
+  return make_node (code);
 }
 
-/* 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.  */
+HOST_WIDE_INT
+lhd_to_target_charset (HOST_WIDE_INT c)
+{
+  return c;
+}
 
-int
-lhd_tree_dump_dump_tree (di, t)
-     void *di ATTRIBUTE_UNUSED;
-     tree t ATTRIBUTE_UNUSED;
+tree
+lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
 {
-  return 0;
+  return expr;
 }
 
-/* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a 
-   language-specific way.  */
+/* Return sharing kind if OpenMP sharing attribute of DECL is
+   predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise.  */
 
-int
-lhd_tree_dump_type_quals (t)
-     tree t;
+enum omp_clause_default_kind
+lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
 {
-  return TYPE_QUALS (t);
+  if (DECL_ARTIFICIAL (decl))
+    return OMP_CLAUSE_DEFAULT_SHARED;
+  return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
 }
 
-/* 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.  */
+/* Generate code to copy SRC to DST.  */
 
 tree
-lhd_expr_size (exp)
-     tree exp;
+lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
 {
-  if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
-      && DECL_SIZE_UNIT (exp) != 0)
-    return DECL_SIZE_UNIT (exp);
+  return build2 (MODIFY_EXPR, TREE_TYPE (dst), 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)
+{
+}
+
+/* Common function for add_builtin_function and
+   add_builtin_function_ext_scope.  */
+static tree
+add_builtin_function_common (const char *name,
+			     tree type,
+			     int function_code,
+			     enum built_in_class cl,
+			     const char *library_name,
+			     tree attrs,
+			     tree (*hook) (tree))
+{
+  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
-    return size_in_bytes (TREE_TYPE (exp));
+    decl_attributes (&decl, NULL_TREE, 0);
+
+  return hook (decl);
+
+}
+
+/* Create a builtin function.  */
+
+tree
+add_builtin_function (const char *name,
+		      tree type,
+		      int function_code,
+		      enum built_in_class cl,
+		      const char *library_name,
+		      tree attrs)
+{
+  return add_builtin_function_common (name, type, function_code, cl,
+				      library_name, attrs,
+				      lang_hooks.builtin_function);
+}
+
+/* Like add_builtin_function, but make sure the scope is the external scope.
+   This is used to delay putting in back end builtin functions until the ISA
+   that defines the builtin is declared via function specific target options,
+   which can save memory for machines like the x86_64 that have multiple ISAs.
+   If this points to the same function as builtin_function, the backend must
+   add all of the builtins at program initialization time.  */
+
+tree
+add_builtin_function_ext_scope (const char *name,
+				tree type,
+				int function_code,
+				enum built_in_class cl,
+				const char *library_name,
+				tree attrs)
+{
+  return add_builtin_function_common (name, type, function_code, cl,
+				      library_name, attrs,
+				      lang_hooks.builtin_function_ext_scope);
+}
+
+tree
+lhd_builtin_function (tree decl)
+{
+  lang_hooks.decls.pushdecl (decl);
+  return decl;
 }