Re: [PATCH] Add 'no_builtin' function attribute

[Martin Sebor via Gcc]

On 11/2/21 3:14 PM, Keith Packard via Gcc-patches wrote:

This attribute controls optimizations which make assumptions about the
semantics of builtin functions. Typical cases here are code which
match memcpy, calloc, sincos, or which call builtins like free.

This extends on things like the -ftree-loop-distribute-patterns
flag. That flag only covers converting loops into builtin calls, not
numerous other places where knowledge of builtin function semantics
changes the generated code.

The goal is to allow built-in functions to be declared by the compiler
and used directly by the application, but to disable optimizations
which take advantage of compiler knowledge about their semantics, and
to allow this optimization behavior to be changed for individual
functions.

One place where this behavior is especially useful is when compiling
the builtin functions that gcc knows about, as in the C
library. Currently, C library source code and build systems have
various kludges to work around the compilers operations in these
areas, using a combination of -fno-tree-loop-distribute-patterns,
-fno-builtins and even symbol aliases to keep GCC from generating
infinite recursions.

This can be applied globally to a file using the -fno-optimize-builtin
flag.

Can this option be used in attribute optimize?  If yes, what's
the advantage of also providing an atttribute?

A few more comments below.

This disables optimizations which translate a sequence of builtin calls
into an equivalent sequence:

        void
        attribute((no_builtin))
        sincos(double x, double *s, double *c)
        {
                *s = sin(x);
                *c = cos(x);
        }

This also avoids converting loops into builtin calls like this:

        void *
        attribute((no_builtin))
        memcpy(void *__restrict__ dst, const void *__restrict__ src, size_t n)
        {
                char *d = dst;
                const char *s = src;

                while (n--)
                        *d++ = *s++;
                return dst;
        }

As well as disabling analysis of memory lifetimes around free as in
this example:

        void *
        attribute((no_builtin))
        erase_and_free(void *ptr)
        {
                memset(ptr, '\0', malloc_usable_size(ptr));
                free(ptr);
        }

It also prevents converting builtin calls into inline code:

        void
        attribute((no_builtin))
        copy_fixed(char *dest)
        {
                strcpy(dest, "hello world");
        }

Clang has a more sophisticated version of this mechanism which
can disable specific builtins:

        double
        attribute((no_builtin("exp2")))
        exp2(double x)
        {
                return pow (2.0, x);
        }

The general approach in this change is to introduce checks in some
places where builtin functions are used to see if the specific
function is 'allowed' to be used for optimization, skipping the
optimization when the desired function has been disabled.

Three new functions, builtin_decl_implicit_opt_p,
builtin_decl_explicit_opt and builtin_decl_implicit_opt are introduced
which add checks for whether the compiler can assume standard
semantics for the specified function for purposes of
optimization. These are used throughout the compiler wherever
appropriate. Code which must use builtins for correct operation
(e.g. struct assignment) are not affected.

The machinery proposed here could be extended to support the
additional clang feature by extending the attribute parsing function
and creating a list of disabled builtins checked by the builtin_decl
functions described above.

It seems to me that as a matter of QOI, GCC should be able to
disable the expansion of built-ins to calls to themselves in
their bodies (I would view it as a bug if GCC expanded a byte
copying loop into a call to __builtin_memcpy in the body of
a function named memcpy, without issuing a warnings; but even
with a warning I'd hope it to do the sensible thing and avoid
introducing infinite recursion).  A compiler may not be able
to do that in calls made from those functions, and for that
the built-in expansion needs to be disabled explicitly.
-fno-builtin isn't good enough because it doesn't prevent GCC
from introiducing calls to __builtin_ functions, and that's
what this feature is for.  Do I understand correctly?

If we end up adding a new attribute (as opposed to relying
on attribute optimize) and the attribute is expected to have
an effect only on the definitions of functions and not also
on their callers, I would suggest to consider having
the handler check that it is, in fact, on a definiton and
not a declaration and issuing a warning that it has no effect
on a declaration, to avoid misunderstandings.

If either a new attribute or a new option is introduced they
need to be documented in the manual.  From your description
it's not clear to me if it's just about disabling the expansion
of the built-ins or if it's meant to prevent GCC from making
any assumptions about their semantics in calls to the annotated
functions.  That will likely be of interest to users and it
matters for diagnostics.

We will also need to add tests for the feature.  There are many
built-ins in GCC but the patch only affects a small subset of
them (e.g., I see it affects a few stdio and string functions
but I'm not sure the printf family are among them -- all those
handled in gimple-ssa-sprintf.c).

Besides its effect on codegen, I would also hope for a few test
cases for warnings, those issued by the strlen pass in particular,
to make sure their effects either are preserved or are disabled
(whichever is appropriate).

Martin

Signed-off-by: Keith Packard <kei...@keithp.com>
---
  gcc/builtins.c               | 12 +++---
  gcc/c-family/c-attribs.c     | 68 ++++++++++++++++++++++++++++++++++
  gcc/common.opt               |  4 ++
  gcc/gimple-fold.c            | 72 ++++++++++++++++++------------------
  gcc/gimple-match-head.c      |  2 +-
  gcc/tree-loop-distribution.c |  7 ++++
  gcc/tree-ssa-alias.c         |  3 +-
  gcc/tree-ssa-strlen.c        | 48 ++++++++++++++----------
  gcc/tree-ssa-structalias.c   |  3 +-
  gcc/tree.h                   | 39 +++++++++++++++++++
  10 files changed, 194 insertions(+), 64 deletions(-)

diff --git a/gcc/builtins.c b/gcc/builtins.c
index 7d0f61fc98b..d665ee716e8 100644
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -2061,7 +2061,7 @@ mathfn_built_in_1 (tree type, combined_fn fn, bool 
implicit_p)
    if (fcode2 == END_BUILTINS)
      return NULL_TREE;

- if (implicit_p && !builtin_decl_implicit_p (fcode2))

+  if (implicit_p && !builtin_decl_implicit_opt_p (fcode2))
      return NULL_TREE;

return builtin_decl_explicit (fcode2);

@@ -3481,9 +3481,9 @@ expand_builtin_stpcpy_1 (tree exp, rtx target, 
machine_mode mode)
    src = CALL_EXPR_ARG (exp, 1);

/* If return value is ignored, transform stpcpy into strcpy. */

-  if (target == const0_rtx && builtin_decl_implicit (BUILT_IN_STRCPY))
+  if (target == const0_rtx && builtin_decl_implicit_opt (BUILT_IN_STRCPY))
      {
-      tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
+      tree fn = builtin_decl_implicit_opt (BUILT_IN_STRCPY);
        tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
        return expand_expr (result, target, mode, EXPAND_NORMAL);
      }
@@ -8258,7 +8258,7 @@ fold_builtin_sincos (location_t loc,
    if (!call)
      {
        if (!targetm.libc_has_function (function_c99_math_complex, type)
-         || !builtin_decl_implicit_p (fn))
+         || !builtin_decl_implicit_opt_p (fn))
        return NULL_TREE;
        fndecl = builtin_decl_explicit (fn);
        call = build_call_expr_loc (loc, fndecl, 1, arg0);
@@ -9717,7 +9717,7 @@ fold_builtin_strpbrk (location_t loc, tree, tree s1, tree 
s2, tree type)
    if (p2[1] != '\0')
      return NULL_TREE;  /* Really call strpbrk.  */

- fn = builtin_decl_implicit (BUILT_IN_STRCHR);

+  fn = builtin_decl_implicit_opt (BUILT_IN_STRCHR);
    if (!fn)
      return NULL_TREE;

@@ -9810,7 +9810,7 @@ fold_builtin_strcspn (location_t loc, tree expr, tree s1, tree s2)

    const char *p2 = c_getstr (s2);
    if (p2 && *p2 == '\0')
      {
-      tree fn = builtin_decl_implicit (BUILT_IN_STRLEN);
+      tree fn = builtin_decl_implicit_opt (BUILT_IN_STRLEN);

/* If the replacement _DECL isn't initialized, don't do the

         transformation.  */
diff --git a/gcc/c-family/c-attribs.c b/gcc/c-family/c-attribs.c
index 007b928c54b..d5cfa9bc70d 100644
--- a/gcc/c-family/c-attribs.c
+++ b/gcc/c-family/c-attribs.c
@@ -130,6 +130,7 @@ static tree handle_vector_size_attribute (tree *, tree, 
tree, int,
                                          bool *) ATTRIBUTE_NONNULL(3);
  static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
  static tree handle_nonstring_attribute (tree *, tree, tree, int, bool *);
+static tree handle_no_builtin_attribute (tree *, tree, tree, int, bool *);
  static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
  static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
  static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
@@ -536,6 +537,8 @@ const struct attribute_spec c_common_attribute_table[] =
                              handle_special_var_sec_attribute, 
attr_section_exclusions },
    { "access",                     1, 3, false, true, true, false,
                              handle_access_attribute, NULL },
+  { "no_builtin",          0, 0, true, false, false, false,
+                             handle_no_builtin_attribute, NULL },
    /* Attributes used by Objective-C.  */
    { "NSObject",                   0, 0, true, false, false, false,
                              handle_nsobject_attribute, NULL },
@@ -5512,6 +5515,71 @@ handle_optimize_attribute (tree *node, tree name, tree 
args,
    return NULL_TREE;
  }

+/* Handle a "no_builtin" attribute */

+
+static tree
+handle_no_builtin_attribute (tree *node, tree name, tree ARG_UNUSED (args),
+                         int ARG_UNUSED (flags), bool *no_add_attrs)
+{
+  /* Ensure we have a function type.  */
+  if (TREE_CODE (*node) != FUNCTION_DECL)
+    {
+      warning (OPT_Wattributes, "%qE attribute ignored", name);
+      *no_add_attrs = true;
+    }
+  else
+    {
+      struct cl_optimization cur_opts;
+      tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node);
+
+      /* Save current options.  */
+      cl_optimization_save (&cur_opts, &global_options, &global_options_set);
+      tree prev_target_node = build_target_option_node (&global_options,
+                                                       &global_options_set);
+
+      /* If we previously had some optimization options, use them as the
+        default.  */
+      gcc_options *saved_global_options = NULL;
+
+      /* When #pragma GCC optimize pragma is used, it modifies global_options
+        without calling targetm.override_options_after_change.  That can leave
+        target flags inconsistent for comparison.  */
+      if (flag_checking && optimization_current_node == 
optimization_default_node)
+       {
+         saved_global_options = XNEW (gcc_options);
+         *saved_global_options = global_options;
+       }
+
+      if (old_opts)
+       cl_optimization_restore (&global_options, &global_options_set,
+                                TREE_OPTIMIZATION (old_opts));
+
+      /* Set no_builtin option */
+      flag_no_opt_builtin = TRUE;
+
+      DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node)
+       = build_optimization_node (&global_options, &global_options_set);
+      tree target_node = build_target_option_node (&global_options,
+                                                  &global_options_set);
+      if (prev_target_node != target_node)
+       DECL_FUNCTION_SPECIFIC_TARGET (*node) = target_node;
+
+      /* Restore current options.  */
+      cl_optimization_restore (&global_options, &global_options_set,
+                              &cur_opts);
+      cl_target_option_restore (&global_options, &global_options_set,
+                               TREE_TARGET_OPTION (prev_target_node));
+
+      if (saved_global_options != NULL)
+       {
+         cl_optimization_compare (saved_global_options, &global_options);
+         free (saved_global_options);
+       }
+    }
+
+  return NULL_TREE;
+}
+
  /* Handle a "no_split_stack" attribute.  */

static tree

diff --git a/gcc/common.opt b/gcc/common.opt
index eeba1a727f2..a5ec18e82f5 100644
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -2154,6 +2154,10 @@ fsave-optimization-record
  Common Var(flag_save_optimization_record) Optimization
  Write a SRCFILE.opt-record.json file detailing what optimizations were 
performed.

+foptimize-builtin

+Common Var(flag_no_opt_builtin, 0) Optimization
+Enable optimizations based on known semantics for builtin functions.
+
  foptimize-register-move
  Common Ignore
  Does nothing. Preserved for backward compatibility.
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 6e25a7c05db..b054f4248ce 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -1071,7 +1071,7 @@ gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi,
                  && (MIN (src_align, dest_align) / BITS_PER_UNIT
                      >= tree_to_uhwi (len))))
            {
-             tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
+             tree fn = builtin_decl_implicit_opt (BUILT_IN_MEMCPY);
              if (!fn)
                return false;
              gimple_call_set_fndecl (stmt, fn);
@@ -1125,7 +1125,7 @@ gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi,
              else
                return false;

- fn = builtin_decl_implicit (BUILT_IN_MEMCPY);

+             fn = builtin_decl_implicit_opt (BUILT_IN_MEMCPY);
              if (!fn)
                return false;
              gimple_call_set_fndecl (stmt, fn);
@@ -1148,7 +1148,7 @@ gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi,
              if (!refs_may_alias_p_1 (&destr, &srcr, false))
                {
                  tree fn;
-                 fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
+                 fn = builtin_decl_implicit_opt (BUILT_IN_MEMCPY);
                  if (!fn)
                    return false;
                  gimple_call_set_fndecl (stmt, fn);
@@ -1360,7 +1360,7 @@ done:
  static bool
  gimple_fold_builtin_bcmp (gimple_stmt_iterator *gsi)
  {
-  tree fn = builtin_decl_implicit (BUILT_IN_MEMCMP);
+  tree fn = builtin_decl_implicit_opt (BUILT_IN_MEMCMP);

if (!fn)

      return false;
@@ -1384,7 +1384,7 @@ gimple_fold_builtin_bcmp (gimple_stmt_iterator *gsi)
  static bool
  gimple_fold_builtin_bcopy (gimple_stmt_iterator *gsi)
  {
-  tree fn = builtin_decl_implicit (BUILT_IN_MEMMOVE);
+  tree fn = builtin_decl_implicit_opt (BUILT_IN_MEMMOVE);

if (!fn)

      return false;
@@ -1411,7 +1411,7 @@ gimple_fold_builtin_bcopy (gimple_stmt_iterator *gsi)
  static bool
  gimple_fold_builtin_bzero (gimple_stmt_iterator *gsi)
  {
-  tree fn = builtin_decl_implicit (BUILT_IN_MEMSET);
+  tree fn = builtin_decl_implicit_opt (BUILT_IN_MEMSET);

if (!fn)

      return false;
@@ -2067,7 +2067,7 @@ gimple_fold_builtin_strcpy (gimple_stmt_iterator *gsi,
    if (optimize_function_for_size_p (cfun))
      return false;

- fn = builtin_decl_implicit (BUILT_IN_MEMCPY);

+  fn = builtin_decl_implicit_opt (BUILT_IN_MEMCPY);
    if (!fn)
      return false;

@@ -2158,7 +2158,7 @@ gimple_fold_builtin_strncpy (gimple_stmt_iterator *gsi,

    maybe_diag_stxncpy_trunc (*gsi, src, len);

/* OK transform into builtin memcpy. */

-  tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
+  tree fn = builtin_decl_implicit_opt (BUILT_IN_MEMCPY);
    if (!fn)
      return false;

@@ -2219,7 +2219,7 @@ gimple_fold_builtin_strchr (gimple_stmt_iterator *gsi, bool is_strrchr)

    /* Transform strrchr (s, 0) to strchr (s, 0) when optimizing for size.  */
    if (is_strrchr && optimize_function_for_size_p (cfun))
      {
-      tree strchr_fn = builtin_decl_implicit (BUILT_IN_STRCHR);
+      tree strchr_fn = builtin_decl_implicit_opt (BUILT_IN_STRCHR);

if (strchr_fn)

        {
@@ -2232,7 +2232,7 @@ gimple_fold_builtin_strchr (gimple_stmt_iterator *gsi, 
bool is_strrchr)
      }

tree len;

-  tree strlen_fn = builtin_decl_implicit (BUILT_IN_STRLEN);
+  tree strlen_fn = builtin_decl_implicit_opt (BUILT_IN_STRLEN);

if (!strlen_fn)

      return false;
@@ -2314,7 +2314,7 @@ gimple_fold_builtin_strstr (gimple_stmt_iterator *gsi)
    /* Transform strstr (x, "c") into strchr (x, 'c').  */
    if (q[1] == '\0')
      {
-      tree strchr_fn = builtin_decl_implicit (BUILT_IN_STRCHR);
+      tree strchr_fn = builtin_decl_implicit_opt (BUILT_IN_STRCHR);
        if (strchr_fn)
        {
          tree c = build_int_cst (integer_type_node, q[0]);
@@ -2365,8 +2365,8 @@ gimple_fold_builtin_strcat (gimple_stmt_iterator *gsi, 
tree dst, tree src)

/* See if we can store by pieces into (dst + strlen(dst)). */

    tree newdst;
-  tree strlen_fn = builtin_decl_implicit (BUILT_IN_STRLEN);
-  tree memcpy_fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
+  tree strlen_fn = builtin_decl_implicit_opt (BUILT_IN_STRLEN);
+  tree memcpy_fn = builtin_decl_implicit_opt (BUILT_IN_MEMCPY);

if (!strlen_fn || !memcpy_fn)

      return false;
@@ -2445,7 +2445,7 @@ gimple_fold_builtin_strcat_chk (gimple_stmt_iterator *gsi)
      return false;

/* If __builtin_strcat_chk is used, assume strcat is available. */

-  fn = builtin_decl_explicit (BUILT_IN_STRCAT);
+  fn = builtin_decl_explicit_opt (BUILT_IN_STRCAT);
    if (!fn)
      return false;

@@ -2530,7 +2530,7 @@ gimple_fold_builtin_strncat (gimple_stmt_iterator *gsi)

        suppress_warning (stmt, OPT_Wstringop_overflow_);
      }

- tree fn = builtin_decl_implicit (BUILT_IN_STRCAT);

+  tree fn = builtin_decl_implicit_opt (BUILT_IN_STRCAT);

/* If the replacement _DECL isn't initialized, don't do the

       transformation.  */
@@ -2578,7 +2578,7 @@ gimple_fold_builtin_strncat_chk (gimple_stmt_iterator 
*gsi)
          && ! tree_int_cst_lt (len, src_len))
        {
          /* If LEN >= strlen (SRC), optimize into __strcat_chk.  */
-         fn = builtin_decl_explicit (BUILT_IN_STRCAT_CHK);
+         fn = builtin_decl_explicit_opt (BUILT_IN_STRCAT_CHK);
          if (!fn)
            return false;

@@ -2590,7 +2590,7 @@ gimple_fold_builtin_strncat_chk (gimple_stmt_iterator *gsi)

      }

/* If __builtin_strncat_chk is used, assume strncat is available. */

-  fn = builtin_decl_explicit (BUILT_IN_STRNCAT);
+  fn = builtin_decl_explicit_opt (BUILT_IN_STRNCAT);
    if (!fn)
      return false;

@@ -2829,7 +2829,7 @@ gimple_fold_builtin_string_compare (gimple_stmt_iterator *gsi)

        && ((p2 && len2 < bound && len2 == nulpos2)
          || (p1 && len1 < bound && len1 == nulpos1)))
      {
-      tree fn = builtin_decl_implicit (BUILT_IN_STRCMP);
+      tree fn = builtin_decl_implicit_opt (BUILT_IN_STRCMP);
        if (!fn)
          return false;
        gimple *repl = gimple_build_call (fn, 2, str1, str2);
@@ -2927,11 +2927,11 @@ gimple_fold_builtin_fputs (gimple_stmt_iterator *gsi,
    /* If we're using an unlocked function, assume the other unlocked
       functions exist explicitly.  */
    tree const fn_fputc = (unlocked
-                        ? builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED)
-                        : builtin_decl_implicit (BUILT_IN_FPUTC));
+                        ? builtin_decl_explicit_opt (BUILT_IN_FPUTC_UNLOCKED)
+                        : builtin_decl_implicit_opt (BUILT_IN_FPUTC));
    tree const fn_fwrite = (unlocked
-                         ? builtin_decl_explicit (BUILT_IN_FWRITE_UNLOCKED)
-                         : builtin_decl_implicit (BUILT_IN_FWRITE));
+                         ? builtin_decl_explicit_opt (BUILT_IN_FWRITE_UNLOCKED)
+                         : builtin_decl_implicit_opt (BUILT_IN_FWRITE));

/* If the return value is used, don't do the transformation. */

    if (gimple_call_lhs (stmt))
@@ -3041,7 +3041,7 @@ gimple_fold_builtin_memory_chk (gimple_stmt_iterator *gsi,
                {
                  /* (void) __mempcpy_chk () can be optimized into
                     (void) __memcpy_chk ().  */
-                 fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
+                 fn = builtin_decl_explicit_opt (BUILT_IN_MEMCPY_CHK);
                  if (!fn)
                    return false;

@@ -3269,7 +3269,7 @@ gimple_fold_builtin_stpcpy (gimple_stmt_iterator *gsi)

    /* If the result is unused, replace stpcpy with strcpy.  */
    if (gimple_call_lhs (stmt) == NULL_TREE)
      {
-      tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
+      tree fn = builtin_decl_implicit_opt (BUILT_IN_STRCPY);
        if (!fn)
        return false;
        gimple_call_set_fndecl (stmt, fn);
@@ -3309,7 +3309,7 @@ gimple_fold_builtin_stpcpy (gimple_stmt_iterator *gsi)
      return false;

/* If the source has a known length replace stpcpy with memcpy. */

-  fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
+  fn = builtin_decl_implicit_opt (BUILT_IN_MEMCPY);
    if (!fn)
      return false;

@@ -3544,7 +3544,7 @@ gimple_fold_builtin_sprintf (gimple_stmt_iterator *gsi)

    if (!init_target_chars ())
      return false;

- tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);

+  tree fn = builtin_decl_implicit_opt (BUILT_IN_STRCPY);
    if (!fn)
      return false;

@@ -3679,7 +3679,7 @@ gimple_fold_builtin_snprintf (gimple_stmt_iterator *gsi)

    /* If the format doesn't contain % args or %%, use strcpy.  */
    if (strchr (fmt_str, target_percent) == NULL)
      {
-      tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
+      tree fn = builtin_decl_implicit_opt (BUILT_IN_STRCPY);
        if (!fn)
        return false;

@@ -3726,7 +3726,7 @@ gimple_fold_builtin_snprintf (gimple_stmt_iterator *gsi)

    /* If the format is "%s", use strcpy if the result isn't used.  */
    else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
      {
-      tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
+      tree fn = builtin_decl_implicit_opt (BUILT_IN_STRCPY);
        if (!fn)
        return false;

@@ -3809,13 +3809,13 @@ gimple_fold_builtin_fprintf (gimple_stmt_iterator *gsi,

      {
        /* If we're using an unlocked function, assume the other
         unlocked functions exist explicitly.  */
-      fn_fputc = builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED);
-      fn_fputs = builtin_decl_explicit (BUILT_IN_FPUTS_UNLOCKED);
+      fn_fputc = builtin_decl_explicit_opt (BUILT_IN_FPUTC_UNLOCKED);
+      fn_fputs = builtin_decl_explicit_opt (BUILT_IN_FPUTS_UNLOCKED);
      }
    else
      {
-      fn_fputc = builtin_decl_implicit (BUILT_IN_FPUTC);
-      fn_fputs = builtin_decl_implicit (BUILT_IN_FPUTS);
+      fn_fputc = builtin_decl_implicit_opt (BUILT_IN_FPUTC);
+      fn_fputs = builtin_decl_implicit_opt (BUILT_IN_FPUTS);
      }

if (!init_target_chars ())

@@ -3909,13 +3909,13 @@ gimple_fold_builtin_printf (gimple_stmt_iterator *gsi, 
tree fmt,
      {
        /* If we're using an unlocked function, assume the other
         unlocked functions exist explicitly.  */
-      fn_putchar = builtin_decl_explicit (BUILT_IN_PUTCHAR_UNLOCKED);
-      fn_puts = builtin_decl_explicit (BUILT_IN_PUTS_UNLOCKED);
+      fn_putchar = builtin_decl_explicit_opt (BUILT_IN_PUTCHAR_UNLOCKED);
+      fn_puts = builtin_decl_explicit_opt (BUILT_IN_PUTS_UNLOCKED);
      }
    else
      {
-      fn_putchar = builtin_decl_implicit (BUILT_IN_PUTCHAR);
-      fn_puts = builtin_decl_implicit (BUILT_IN_PUTS);
+      fn_putchar = builtin_decl_implicit_opt (BUILT_IN_PUTCHAR);
+      fn_puts = builtin_decl_implicit_opt (BUILT_IN_PUTS);
      }

if (!init_target_chars ())

diff --git a/gcc/gimple-match-head.c b/gcc/gimple-match-head.c
index 9d88b2f8551..82bdad1380e 100644
--- a/gcc/gimple-match-head.c
+++ b/gcc/gimple-match-head.c
@@ -630,7 +630,7 @@ maybe_push_res_to_seq (gimple_match_op *res_op, gimple_seq 
*seq, tree res)
        else
        {
          /* Find the function we want to call.  */
-         tree decl = builtin_decl_implicit (as_builtin_fn (fn));
+         tree decl = builtin_decl_implicit_opt (as_builtin_fn (fn));
          if (!decl)
            return NULL;

diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c

index 583c01a42d8..469c22d63cb 100644
--- a/gcc/tree-loop-distribution.c
+++ b/gcc/tree-loop-distribution.c
@@ -1716,6 +1716,9 @@ classify_builtin_st (loop_p loop, partition *partition, 
data_reference_p dr)
    gimple *stmt = DR_STMT (dr);
    tree base, size, rhs = gimple_assign_rhs1 (stmt);

+ if (!builtin_decl_implicit_opt_p(BUILT_IN_MEMSET))

+    return;
+
    if (const_with_all_bytes_same (rhs) == -1
        && (!INTEGRAL_TYPE_P (TREE_TYPE (rhs))
          || (TYPE_MODE (TREE_TYPE (rhs))
@@ -1762,6 +1765,10 @@ loop_distribution::classify_builtin_ldst (loop_p loop, 
struct graph *rdg,
    tree base, size, src_base, src_size;
    auto_vec<tree> dst_steps, src_steps;

+ if (!builtin_decl_implicit_opt_p(BUILT_IN_MEMMOVE) ||

+      !builtin_decl_implicit_opt_p(BUILT_IN_MEMCPY))
+    return;
+
    /* Compute access range of both load and store.  */
    int res = compute_access_range (loop, dst_dr, &base, &size, &dst_steps);
    if (res != 2)
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index ce667ff32b9..77cf209b235 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -3370,7 +3370,8 @@ stmt_kills_ref_p (gimple *stmt, ao_ref *ref)
      {
        tree callee = gimple_call_fndecl (stmt);
        if (callee != NULL_TREE
-         && gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
+         && gimple_call_builtin_p (stmt, BUILT_IN_NORMAL)
+         && builtin_decl_implicit_opt_p(DECL_FUNCTION_CODE (callee)))
        switch (DECL_FUNCTION_CODE (callee))
          {
          case BUILT_IN_FREE:
diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c
index 2de7cb1a6a0..050d0573936 100644
--- a/gcc/tree-ssa-strlen.c
+++ b/gcc/tree-ssa-strlen.c
@@ -860,12 +860,17 @@ get_string_length (strinfo *si)
         with the same stmt.  If they were unshared before and transformation
         has been already done, the handling of BUILT_IN_STPCPY{,_CHK} should
         just compute the right length.  */
+      if (!builtin_decl_implicit_opt_p (DECL_FUNCTION_CODE (callee)))
+       return NULL;
+
        switch (DECL_FUNCTION_CODE (callee))
        {
        case BUILT_IN_STRCAT:
        case BUILT_IN_STRCAT_CHK:
          gsi = gsi_for_stmt (stmt);
-         fn = builtin_decl_implicit (BUILT_IN_STRLEN);
+         fn = builtin_decl_implicit_opt (BUILT_IN_STRLEN);
+         if (!fn)
+           return NULL;
          gcc_assert (lhs == NULL_TREE);
          tem = unshare_expr (gimple_call_arg (stmt, 0));
          lenstmt = gimple_build_call (fn, 1, tem);
@@ -889,11 +894,12 @@ get_string_length (strinfo *si)
          /* FALLTHRU */
        case BUILT_IN_STRCPY:
        case BUILT_IN_STRCPY_CHK:
-         gcc_assert (builtin_decl_implicit_p (BUILT_IN_STPCPY));
          if (gimple_call_num_args (stmt) == 2)
-           fn = builtin_decl_implicit (BUILT_IN_STPCPY);
+           fn = builtin_decl_implicit_opt (BUILT_IN_STPCPY);
          else
-           fn = builtin_decl_explicit (BUILT_IN_STPCPY_CHK);
+           fn = builtin_decl_explicit_opt (BUILT_IN_STPCPY_CHK);
+         if (!fn)
+           return NULL;
          gcc_assert (lhs == NULL_TREE);
          if (dump_file && (dump_flags & TDF_DETAILS) != 0)
            {
@@ -1689,6 +1695,9 @@ valid_builtin_call (gimple *stmt)
        && !gimple_builtin_call_types_compatible_p (stmt, decl))
      return false;

+ if (!builtin_decl_implicit_opt_p(DECL_FUNCTION_CODE (callee)))

+    return false;
+
    switch (DECL_FUNCTION_CODE (callee))
      {
      case BUILT_IN_MEMCMP:
@@ -2519,7 +2528,7 @@ strlen_pass::handle_builtin_strcpy (built_in_function 
bcode)
        {
        case BUILT_IN_STRCPY:
        case BUILT_IN_STRCPY_CHK:
-       if (lhs != NULL_TREE || !builtin_decl_implicit_p (BUILT_IN_STPCPY))
+       if (lhs != NULL_TREE || !builtin_decl_implicit_opt_p (BUILT_IN_STPCPY))
          return;
        break;
        case BUILT_IN_STPCPY:
@@ -2640,12 +2649,12 @@ strlen_pass::handle_builtin_strcpy (built_in_function 
bcode)
    switch (bcode)
      {
      case BUILT_IN_STRCPY:
-      fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
+      fn = builtin_decl_implicit_opt (BUILT_IN_MEMCPY);
        if (lhs)
        ssa_ver_to_stridx[SSA_NAME_VERSION (lhs)] = didx;
        break;
      case BUILT_IN_STRCPY_CHK:
-      fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
+      fn = builtin_decl_explicit_opt (BUILT_IN_MEMCPY_CHK);
        if (lhs)
        ssa_ver_to_stridx[SSA_NAME_VERSION (lhs)] = didx;
        break;
@@ -2653,7 +2662,7 @@ strlen_pass::handle_builtin_strcpy (built_in_function 
bcode)
        /* This would need adjustment of the lhs (subtract one),
         or detection that the trailing '\0' doesn't need to be
         written, if it will be immediately overwritten.
-      fn = builtin_decl_explicit (BUILT_IN_MEMPCPY);  */
+      fn = builtin_decl_explicit_opt (BUILT_IN_MEMPCPY);  */
        if (lhs)
        {
          dsi->endptr = lhs;
@@ -2664,7 +2673,7 @@ strlen_pass::handle_builtin_strcpy (built_in_function 
bcode)
        /* This would need adjustment of the lhs (subtract one),
         or detection that the trailing '\0' doesn't need to be
         written, if it will be immediately overwritten.
-      fn = builtin_decl_explicit (BUILT_IN_MEMPCPY_CHK);  */
+      fn = builtin_decl_explicit_opt (BUILT_IN_MEMPCPY_CHK);  */
        if (lhs)
        {
          dsi->endptr = lhs;
@@ -3540,7 +3549,7 @@ strlen_pass::handle_builtin_strcat (built_in_function 
bcode)
         with length endptr - p if we need to compute the length
         later on.  Don't do this transformation if we don't need
         it.  */
-      if (builtin_decl_implicit_p (BUILT_IN_STPCPY) && lhs == NULL_TREE)
+      if (builtin_decl_implicit_opt_p (BUILT_IN_STPCPY) && lhs == NULL_TREE)
        {
          if (didx == 0)
            {
@@ -3590,7 +3599,7 @@ strlen_pass::handle_builtin_strcat (built_in_function 
bcode)
      {
        dsi->nonzero_chars = NULL;
        dsi->full_string_p = false;
-      if (lhs == NULL_TREE && builtin_decl_implicit_p (BUILT_IN_STPCPY))
+      if (lhs == NULL_TREE && builtin_decl_implicit_opt_p (BUILT_IN_STPCPY))
        dsi->dont_invalidate = true;
      }

@@ -3610,15 +3619,15 @@ strlen_pass::handle_builtin_strcat (built_in_function bcode)

      {
      case BUILT_IN_STRCAT:
        if (srclen != NULL_TREE)
-       fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
+       fn = builtin_decl_implicit_opt (BUILT_IN_MEMCPY);
        else
-       fn = builtin_decl_implicit (BUILT_IN_STRCPY);
+       fn = builtin_decl_implicit_opt (BUILT_IN_STRCPY);
        break;
      case BUILT_IN_STRCAT_CHK:
        if (srclen != NULL_TREE)
-       fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
+       fn = builtin_decl_explicit_opt (BUILT_IN_MEMCPY_CHK);
        else
-       fn = builtin_decl_explicit (BUILT_IN_STRCPY_CHK);
+       fn = builtin_decl_explicit_opt (BUILT_IN_STRCPY_CHK);
        objsz = gimple_call_arg (stmt, 2);
        break;
      default:
@@ -3798,11 +3807,12 @@ strlen_pass::handle_builtin_memset (bool *zero_write)
    if (code1 == BUILT_IN_CALLOC)
      /* Not touching alloc_stmt */ ;
    else if (code1 == BUILT_IN_MALLOC
-          && operand_equal_p (memset_size, alloc_size, 0))
+          && operand_equal_p (memset_size, alloc_size, 0)
+          && builtin_decl_implicit_opt_p (BUILT_IN_CALLOC))
      {
        /* Replace the malloc + memset calls with calloc.  */
        gimple_stmt_iterator gsi1 = gsi_for_stmt (si1->stmt);
-      update_gimple_call (&gsi1, builtin_decl_implicit (BUILT_IN_CALLOC), 2,
+      update_gimple_call (&gsi1, builtin_decl_implicit_opt (BUILT_IN_CALLOC), 
2,
                          alloc_size, build_one_cst (size_type_node));
        si1->nonzero_chars = build_int_cst (size_type_node, 0);
        si1->full_string_p = true;
@@ -4367,8 +4377,8 @@ strlen_pass::handle_builtin_string_cmp ()
        /* If the known length is less than the size of the other array
         and the strcmp result is only used to test equality to zero,
         transform the call to the equivalent _eq call.  */
-      if (tree fn = builtin_decl_implicit (bound < 0 ? BUILT_IN_STRCMP_EQ
-                                          : BUILT_IN_STRNCMP_EQ))
+      if (tree fn = builtin_decl_implicit_opt (bound < 0 ? BUILT_IN_STRCMP_EQ
+                                              : BUILT_IN_STRNCMP_EQ))
        {
          tree n = build_int_cst (size_type_node, cmpsiz);
          update_gimple_call (&m_gsi, fn, 3, arg1, arg2, n);
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index 99072df0768..c88ac432331 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -4415,7 +4415,8 @@ find_func_aliases_for_builtin_call (struct function *fn, 
gcall *t)
    auto_vec<ce_s, 4> rhsc;
    varinfo_t fi;

- if (gimple_call_builtin_p (t, BUILT_IN_NORMAL))

+  if (gimple_call_builtin_p (t, BUILT_IN_NORMAL) &&
+      builtin_decl_implicit_opt_p (DECL_FUNCTION_CODE (fndecl)))
      /* ???  All builtins that are handled here need to be handled
         in the alias-oracle query functions explicitly!  */
      switch (DECL_FUNCTION_CODE (fndecl))
diff --git a/gcc/tree.h b/gcc/tree.h
index 7542d97ce12..72b969e1684 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -5728,6 +5728,20 @@ builtin_decl_explicit (enum built_in_function fncode)
    return builtin_info[(size_t)fncode].decl;
  }

+/* Return the tree node for an explicit builtin function if the

+   optimizer is allowed to use it or NULL.  Use this instead of
+   builtin_decl_implicit in code that could introduce a new builtin
+   call to perform optimization, but where such a call is not
+   required */
+
+static inline tree
+builtin_decl_explicit_opt (enum built_in_function fncode)
+{
+  if (flag_no_opt_builtin)
+    return NULL_TREE;
+  return builtin_decl_explicit (fncode);
+}
+
  /* Return the tree node for an implicit builtin function or NULL.  */
  static inline tree
  builtin_decl_implicit (enum built_in_function fncode)
@@ -5741,6 +5755,20 @@ builtin_decl_implicit (enum built_in_function fncode)
    return builtin_info[uns_fncode].decl;
  }

+/* Return the tree node for an implicit builtin function if the

+   optimizer is allowed to use it or NULL. Use this instead of
+   builtin_decl_implicit in code that could introduce a new builtin
+   call to perform optimization, but where such a call is not
+   required */
+
+static inline tree
+builtin_decl_implicit_opt (enum built_in_function fncode)
+{
+  if (flag_no_opt_builtin)
+    return NULL_TREE;
+  return builtin_decl_implicit (fncode);
+}
+
  /* Set explicit builtin function nodes and whether it is an implicit
     function.  */

@@ -5805,6 +5833,17 @@ builtin_decl_implicit_p (enum built_in_function fncode)

          && builtin_info[uns_fncode].implicit_p);
  }

+/* Return whether the standard builtin function can be used

+   implicitly. Use this instead of builtin_decl_implicit_p in code
+   that could introduce a new builtin call to perform optimization,
+   but where such a call is not required */
+
+static inline bool
+builtin_decl_implicit_opt_p (enum built_in_function fncode)
+{
+  return !flag_no_opt_builtin && builtin_decl_implicit_p(fncode);
+}
+
  /* Return whether the standard builtin function was declared.  */

static inline bool