Revert "Treat std::move, forward, etc. as builtins."

This reverts commit b27430f as the
    parent https://reviews.llvm.org/D123345 breaks the AIX CI:

    https://lab.llvm.org/buildbot/#/builders/214/builds/819

Author: daltenty

clang/docs/CommandGuide/clang.rst

@@ -252,24 +252,8 @@ Language Selection and Mode Options
 
 .. option:: -fno-builtin
 
- Disable special handling and optimizations of well-known library functions,
- like :c:func:`strlen` and :c:func:`malloc`.
-
-.. option:: -fno-builtin-<function>
-
- Disable special handling and optimizations for the specific library function.
- For example, ``-fno-builtin-strlen`` removes any special handling for the
- :c:func:`strlen` library function.
-
-.. option:: -fno-builtin-std-<function>
-
- Disable special handling and optimizations for the specific C++ standard
- library function in namespace ``std``. For example,
- ``-fno-builtin-std-move_if_noexcept`` removes any special handling for the
- :cpp:func:`std::move_if_noexcept` library function.
-
- For C standard library functions that the C++ standard library also provides
- in namespace ``std``, use :option:`-fno-builtin-\<function\>` instead.
+ Disable special handling and optimizations of builtin functions like
+ :c:func:`strlen` and :c:func:`malloc`.
 
 .. option:: -fmath-errno
 

clang/docs/ReleaseNotes.rst

@@ -250,10 +250,7 @@ C2x Feature Support
 C++ Language Changes in Clang
 -----------------------------
 
-- Improved ``-O0`` code generation for calls to ``std::move``, ``std::forward``,
-  ``std::move_if_noexcept``, ``std::addressof``, and ``std::as_const``. These
-  are now treated as compiler builtins and implemented directly, rather than
-  instantiating the definition from the standard library.
+- ...
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^

clang/include/clang/Basic/Builtins.def

@@ -81,9 +81,7 @@
 //       builtin even if type doesn't match signature, and don't warn if we
 //       can't be sure the type is right
 //  F -> this is a libc/libm function with a '__builtin_' prefix added.
-//  f -> this is a libc/libm function without a '__builtin_' prefix, or with
-//       'z', a C++ standard library function in namespace std::. This builtin
-//       is disableable by '-fno-builtin-foo' / '-fno-builtin-std-foo'.
+//  f -> this is a libc/libm function without the '__builtin_' prefix.
 //  h -> this function requires a specific header or an explicit declaration.
 //  i -> this is a runtime library implemented function without the
 //       '__builtin_' prefix. It will be implemented in compiler-rt or libgcc.
@@ -103,7 +101,6 @@
 //  V:N: -> requires vectors of at least N bits to be legal
 //  C<N,M_0,...,M_k> -> callback behavior: argument N is called with argument
 //                      M_0, ..., M_k as payload
-//  z -> this is a function in (possibly-versioned) namespace std
 //  FIXME: gcc has nonnull
 
 #if defined(BUILTIN) && !defined(LIBBUILTIN)
@@ -922,7 +919,7 @@ LANGBUILTIN(__exception_info, "v*",  "n", ALL_MS_LANGUAGES)
 LANGBUILTIN(_exception_info,  "v*",  "n", ALL_MS_LANGUAGES)
 LANGBUILTIN(__abnormal_termination, "i", "n", ALL_MS_LANGUAGES)
 LANGBUILTIN(_abnormal_termination,  "i", "n", ALL_MS_LANGUAGES)
-LANGBUILTIN(__GetExceptionInfo, "v*.", "zntu", ALL_MS_LANGUAGES)
+LANGBUILTIN(__GetExceptionInfo, "v*.", "ntu", ALL_MS_LANGUAGES)
 LANGBUILTIN(_InterlockedAnd8,   "ccD*c",        "n", ALL_MS_LANGUAGES)
 LANGBUILTIN(_InterlockedAnd16,  "ssD*s",        "n", ALL_MS_LANGUAGES)
 LANGBUILTIN(_InterlockedAnd,    "NiNiD*Ni",     "n", ALL_MS_LANGUAGES)
@@ -1546,15 +1543,6 @@ LIBBUILTIN(_Block_object_assign, "vv*vC*iC", "f", "Blocks.h", ALL_LANGUAGES)
 LIBBUILTIN(_Block_object_dispose, "vvC*iC", "f", "Blocks.h", ALL_LANGUAGES)
 // FIXME: Also declare NSConcreteGlobalBlock and NSConcreteStackBlock.
 
-// C++ standard library builtins in namespace 'std'.
-LIBBUILTIN(addressof, "v*v&", "zfncTh", "memory", CXX_LANG)
-// Synonym for addressof used internally by libstdc++.
-LANGBUILTIN(__addressof, "v*v&", "zfncT", CXX_LANG)
-LIBBUILTIN(as_const, "v&v&", "zfncTh", "utility", CXX_LANG)
-LIBBUILTIN(forward, "v&v&", "zfncTh", "utility", CXX_LANG)
-LIBBUILTIN(move, "v&v&", "zfncTh", "utility", CXX_LANG)
-LIBBUILTIN(move_if_noexcept, "v&v&", "zfncTh", "utility", CXX_LANG)
-
 // Annotation function
 BUILTIN(__builtin_annotation, "v.", "tn")
 

clang/include/clang/Basic/Builtins.h

@@ -138,10 +138,6 @@ class Context {
   /// Determines whether this builtin is a predefined libc/libm
   /// function, such as "malloc", where we know the signature a
   /// priori.
-  /// In C, such functions behave as if they are predeclared,
-  /// possibly with a warning on first use. In Objective-C and C++,
-  /// they do not, but they are recognized as builtins once we see
-  /// a declaration.
   bool isPredefinedLibFunction(unsigned ID) const {
     return strchr(getRecord(ID).Attributes, 'f') != nullptr;
   }
@@ -160,23 +156,6 @@ class Context {
     return strchr(getRecord(ID).Attributes, 'i') != nullptr;
   }
 
-  /// Determines whether this builtin is a C++ standard library function
-  /// that lives in (possibly-versioned) namespace std, possibly a template
-  /// specialization, where the signature is determined by the standard library
-  /// declaration.
-  bool isInStdNamespace(unsigned ID) const {
-    return strchr(getRecord(ID).Attributes, 'z') != nullptr;
-  }
-
-  /// Determines whether this builtin can have its address taken with no
-  /// special action required.
-  bool isDirectlyAddressable(unsigned ID) const {
-    // Most standard library functions can have their addresses taken. C++
-    // standard library functions formally cannot in C++20 onwards, and when
-    // we allow it, we need to ensure we instantiate a definition.
-    return isPredefinedLibFunction(ID) && !isInStdNamespace(ID);
-  }
-
   /// Determines whether this builtin has custom typechecking.
   bool hasCustomTypechecking(unsigned ID) const {
     return strchr(getRecord(ID).Attributes, 't') != nullptr;
@@ -258,6 +237,10 @@ class Context {
 private:
   const Info &getRecord(unsigned ID) const;
 
+  /// Is this builtin supported according to the given language options?
+  bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
+                          const LangOptions &LangOpts);
+
   /// Helper function for isPrintfLike and isScanfLike.
   bool isLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg,
               const char *Fmt) const;

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -6590,15 +6590,6 @@ def warn_self_move : Warning<
   "explicitly moving variable of type %0 to itself">,
   InGroup<SelfMove>, DefaultIgnore;
 
-def err_builtin_move_forward_unsupported : Error<
-  "unsupported signature for %q0">;
-def err_use_of_unaddressable_function : Error<
-  "taking address of non-addressable standard library function">;
-// FIXME: This should also be in -Wc++23-compat once we have it.
-def warn_cxx20_compat_use_of_unaddressable_function : Warning<
-  "taking address of non-addressable standard library function "
-  "is incompatible with C++20">, InGroup<CXX20Compat>;
-
 def warn_redundant_move_on_return : Warning<
   "redundant move in return statement">,
   InGroup<RedundantMove>, DefaultIgnore;

clang/lib/AST/ExprConstant.cpp

@@ -8127,7 +8127,6 @@ class LValueExprEvaluator
   bool VisitVarDecl(const Expr *E, const VarDecl *VD);
   bool VisitUnaryPreIncDec(const UnaryOperator *UO);
 
-  bool VisitCallExpr(const CallExpr *E);
   bool VisitDeclRefExpr(const DeclRefExpr *E);
   bool VisitPredefinedExpr(const PredefinedExpr *E) { return Success(E); }
   bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
@@ -8293,20 +8292,6 @@ bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {
   return Success(*V, E);
 }
 
-bool LValueExprEvaluator::VisitCallExpr(const CallExpr *E) {
-  switch (E->getBuiltinCallee()) {
-  case Builtin::BIas_const:
-  case Builtin::BIforward:
-  case Builtin::BImove:
-  case Builtin::BImove_if_noexcept:
-    if (cast<FunctionDecl>(E->getCalleeDecl())->isConstexpr())
-      return Visit(E->getArg(0));
-    break;
-  }
-
-  return ExprEvaluatorBaseTy::VisitCallExpr(E);
-}
-
 bool LValueExprEvaluator::VisitMaterializeTemporaryExpr(
     const MaterializeTemporaryExpr *E) {
   // Walk through the expression to find the materialized temporary itself.
@@ -9085,8 +9070,6 @@ static bool isOneByteCharacterType(QualType T) {
 bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
                                                 unsigned BuiltinOp) {
   switch (BuiltinOp) {
-  case Builtin::BIaddressof:
-  case Builtin::BI__addressof:
   case Builtin::BI__builtin_addressof:
     return evaluateLValue(E->getArg(0), Result);
   case Builtin::BI__builtin_assume_aligned: {

clang/lib/Analysis/BodyFarm.cpp

@@ -20,7 +20,6 @@
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/Analysis/CodeInjector.h"
-#include "clang/Basic/Builtins.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Debug.h"
@@ -87,9 +86,6 @@ class ASTMaker {
   ImplicitCastExpr *makeImplicitCast(const Expr *Arg, QualType Ty,
                                      CastKind CK = CK_LValueToRValue);
 
-  /// Create a cast to reference type.
-  CastExpr *makeReferenceCast(const Expr *Arg, QualType Ty);
-
   /// Create an Objective-C bool literal.
   ObjCBoolLiteralExpr *makeObjCBool(bool Val);
 
@@ -177,16 +173,6 @@ ImplicitCastExpr *ASTMaker::makeImplicitCast(const Expr *Arg, QualType Ty,
                                   /* FPFeatures */ FPOptionsOverride());
 }
 
-CastExpr *ASTMaker::makeReferenceCast(const Expr *Arg, QualType Ty) {
-  assert(Ty->isReferenceType());
-  return CXXStaticCastExpr::Create(
-      C, Ty.getNonReferenceType(),
-      Ty->isLValueReferenceType() ? VK_LValue : VK_XValue, CK_NoOp,
-      const_cast<Expr *>(Arg), /*CXXCastPath=*/nullptr,
-      /*Written=*/C.getTrivialTypeSourceInfo(Ty), FPOptionsOverride(),
-      SourceLocation(), SourceLocation(), SourceRange());
-}
-
 Expr *ASTMaker::makeIntegralCast(const Expr *Arg, QualType Ty) {
   if (Arg->getType() == Ty)
     return const_cast<Expr*>(Arg);
@@ -310,22 +296,6 @@ static CallExpr *create_call_once_lambda_call(ASTContext &C, ASTMaker M,
       /*FPFeatures=*/FPOptionsOverride());
 }
 
-/// Create a fake body for 'std::move' or 'std::forward'. This is just:
-///
-/// \code
-/// return static_cast<return_type>(param);
-/// \endcode
-static Stmt *create_std_move_forward(ASTContext &C, const FunctionDecl *D) {
-  LLVM_DEBUG(llvm::dbgs() << "Generating body for std::move / std::forward\n");
-
-  ASTMaker M(C);
-
-  QualType ReturnType = D->getType()->castAs<FunctionType>()->getReturnType();
-  Expr *Param = M.makeDeclRefExpr(D->getParamDecl(0));
-  Expr *Cast = M.makeReferenceCast(Param, ReturnType);
-  return M.makeReturn(Cast);
-}
-
 /// Create a fake body for std::call_once.
 /// Emulates the following function body:
 ///
@@ -711,20 +681,8 @@ Stmt *BodyFarm::getBody(const FunctionDecl *D) {
 
   FunctionFarmer FF;
 
-  if (unsigned BuiltinID = D->getBuiltinID()) {
-    switch (BuiltinID) {
-    case Builtin::BIas_const:
-    case Builtin::BIforward:
-    case Builtin::BImove:
-    case Builtin::BImove_if_noexcept:
-      FF = create_std_move_forward;
-      break;
-    default:
-      FF = nullptr;
-      break;
-    }
-  } else if (Name.startswith("OSAtomicCompareAndSwap") ||
-             Name.startswith("objc_atomicCompareAndSwap")) {
+  if (Name.startswith("OSAtomicCompareAndSwap") ||
+      Name.startswith("objc_atomicCompareAndSwap")) {
     FF = create_OSAtomicCompareAndSwap;
   } else if (Name == "call_once" && D->getDeclContext()->isStdNamespace()) {
     FF = create_call_once;

clang/lib/Basic/Builtins.cpp

@@ -48,22 +48,18 @@ void Builtin::Context::InitializeTarget(const TargetInfo &Target,
 }
 
 bool Builtin::Context::isBuiltinFunc(llvm::StringRef FuncName) {
-  bool InStdNamespace = FuncName.consume_front("std-");
-  for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin;
-       ++i) {
-    if (FuncName.equals(BuiltinInfo[i].Name) &&
-        (bool)strchr(BuiltinInfo[i].Attributes, 'z') == InStdNamespace)
+  for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin; ++i)
+    if (FuncName.equals(BuiltinInfo[i].Name))
       return strchr(BuiltinInfo[i].Attributes, 'f') != nullptr;
-  }
 
   return false;
 }
 
-/// Is this builtin supported according to the given language options?
-static bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
-                               const LangOptions &LangOpts) {
+bool Builtin::Context::builtinIsSupported(const Builtin::Info &BuiltinInfo,
+                                          const LangOptions &LangOpts) {
   bool BuiltinsUnsupported =
-      LangOpts.NoBuiltin && strchr(BuiltinInfo.Attributes, 'f') != nullptr;
+      (LangOpts.NoBuiltin || LangOpts.isNoBuiltinFunc(BuiltinInfo.Name)) &&
+      strchr(BuiltinInfo.Attributes, 'f');
   bool CorBuiltinsUnsupported =
       !LangOpts.Coroutines && (BuiltinInfo.Langs & COR_LANG);
   bool MathBuiltinsUnsupported =
@@ -115,19 +111,6 @@ void Builtin::Context::initializeBuiltins(IdentifierTable &Table,
   for (unsigned i = 0, e = AuxTSRecords.size(); i != e; ++i)
     Table.get(AuxTSRecords[i].Name)
         .setBuiltinID(i + Builtin::FirstTSBuiltin + TSRecords.size());
-
-  // Step #4: Unregister any builtins specified by -fno-builtin-foo.
-  for (llvm::StringRef Name : LangOpts.NoBuiltinFuncs) {
-    bool InStdNamespace = Name.consume_front("std-");
-    auto NameIt = Table.find(Name);
-    if (NameIt != Table.end()) {
-      unsigned ID = NameIt->second->getBuiltinID();
-      if (ID != Builtin::NotBuiltin && isPredefinedLibFunction(ID) &&
-          isInStdNamespace(ID) == InStdNamespace) {
-        Table.get(Name).setBuiltinID(Builtin::NotBuiltin);
-      }
-    }
-  }
 }
 
 unsigned Builtin::Context::getRequiredVectorWidth(unsigned ID) const {
@@ -207,7 +190,8 @@ bool Builtin::Context::performsCallback(unsigned ID,
 }
 
 bool Builtin::Context::canBeRedeclared(unsigned ID) const {
-  return ID == Builtin::NotBuiltin || ID == Builtin::BI__va_start ||
-         (!hasReferenceArgsOrResult(ID) && !hasCustomTypechecking(ID)) ||
-         isInStdNamespace(ID);
+  return ID == Builtin::NotBuiltin ||
+         ID == Builtin::BI__va_start ||
+         (!hasReferenceArgsOrResult(ID) &&
+          !hasCustomTypechecking(ID));
 }

clang/lib/CodeGen/CGBuiltin.cpp

@@ -2271,9 +2271,8 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
                                         ReturnValueSlot ReturnValue) {
   const FunctionDecl *FD = GD.getDecl()->getAsFunction();
   // See if we can constant fold this builtin.  If so, don't emit it at all.
-  // TODO: Extend this handling to all builtin calls that we can constant-fold.
   Expr::EvalResult Result;
-  if (E->isPRValue() && E->EvaluateAsRValue(Result, CGM.getContext()) &&
+  if (E->EvaluateAsRValue(Result, CGM.getContext()) &&
       !Result.hasSideEffects()) {
     if (Result.Val.isInt())
       return RValue::get(llvm::ConstantInt::get(getLLVMContext(),
@@ -4567,8 +4566,6 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
 
     return RValue::get(Carry);
   }
-  case Builtin::BIaddressof:
-  case Builtin::BI__addressof:
   case Builtin::BI__builtin_addressof:
     return RValue::get(EmitLValue(E->getArg(0)).getPointer(*this));
   case Builtin::BI__builtin_function_start:
@@ -4728,12 +4725,6 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     }
     break;
 
-  // C++ std:: builtins.
-  case Builtin::BImove:
-  case Builtin::BImove_if_noexcept:
-  case Builtin::BIforward:
-  case Builtin::BIas_const:
-    return RValue::get(EmitLValue(E->getArg(0)).getPointer(*this));
   case Builtin::BI__GetExceptionInfo: {
     if (llvm::GlobalVariable *GV =
             CGM.getCXXABI().getThrowInfo(FD->getParamDecl(0)->getType()))

clang/lib/CodeGen/CGCall.cpp

@@ -1805,8 +1805,6 @@ void CodeGenModule::getDefaultFunctionAttributes(StringRef Name,
 
   if (AttrOnCallSite) {
     // Attributes that should go on the call site only.
-    // FIXME: Look for 'BuiltinAttr' on the function rather than re-checking
-    // the -fno-builtin-foo list.
     if (!CodeGenOpts.SimplifyLibCalls || LangOpts.isNoBuiltinFunc(Name))
       FuncAttrs.addAttribute(llvm::Attribute::NoBuiltin);
     if (!CodeGenOpts.TrapFuncName.empty())