[clang][Sema] adds `[[clang::no_address]]` attribute

[cjdb]

Summary

[namespace.std]/p6 indicates that taking the address of standard
library is unspecified (possibly ill-formed). This commit adds an
opt-in mechanism for standard library functions to ensure that a
program can't take the address of said function.

[zoecarver]

clang/include/clang/Basic/AttrDocs.td

5972

Could you make this an error?

clang/lib/Sema/SemaOverload.cpp

12286

Nit: you can just assert(OverloadSet && "...").

However, it looks like from the implementation of GetOverloadSet this might very well be null. Asserts crash compilers. If you're very confident this isn't going to be null, leave the assert but change the dyn_casts in GetOverloadSet to casts. Otherwise, provide some way to bail here.

[• Quuxplusone]

clang/test/SemaCXX/attr-no-address.cpp

47–48

FWIW, I don't think this diagnostic provides any benefit to the user-programmer; it merely inconveniences them.
But it does add a lot of burden on the libc++ developers, who must now remember to add a new clang-specific attribute on every function they write.
So for me this is all cost and no benefit.

Am I correct that this attribute doesn't interfere with the user-programmer's writing std::addressof(std::one_overload)?

[cjdb]

A different path forward was discussed with @ldionne and @zoecarver. Will experiment this other way.

[ldionne]

Just for posterity, what we discussed is that since there is a list of addressable functions in the standard, we should explore adding a warning to Clang that fires whenever somebody takes the address of a function in namespace std, except if it's an addressable function. That list would either be maintained explicitly in Clang, or, preferably, we'd have an attribute that we can mark addressable functions with so that the compiler doesn't flag those specific functions.

I'm not sure whether that is actually a good approach, but I told @cjdb that from the library perspective, I was more comfortable with marking a few functions with that attribute than marking basically everything in the library with [[noaddress]].

[xbolva00]

In D101598#2729865, @ldionne wrote:

Just for posterity, what we discussed is that since there is a list of addressable functions in the standard, we should explore adding a warning to Clang that fires whenever somebody takes the address of a function in namespace std, except if it's an addressable function. That list would either be maintained explicitly in Clang, or, preferably, we'd have an attribute that we can mark addressable functions with so that the compiler doesn't flag those specific functions.

I'm not sure whether that is actually a good approach, but I told @cjdb that from the library perspective, I was more comfortable with marking a few functions with that attribute than marking basically everything in the library with [[noaddress]].

Maybe opportunity to rework https://reviews.llvm.org/D58882 :)

[rsmith]

In D101598#2729865, @ldionne wrote:

Just for posterity, what we discussed is that since there is a list of addressable functions in the standard, we should explore adding a warning to Clang that fires whenever somebody takes the address of a function in namespace std, except if it's an addressable function. That list would either be maintained explicitly in Clang, or, preferably, we'd have an attribute that we can mark addressable functions with so that the compiler doesn't flag those specific functions.

Just in case this didn't come up in the discussion already: we can't rely on the standard library implementation having the "this function is addressable" attributes, because we support other standard libraries that won't have those attributes. I think a combination of an opt-in attribute on the std namespace plus an opt-out attribute on addressable functions would work, as would maintaining a list of addressable functions in Clang.

clang/include/clang/AST/DeclBase.h

public:
 
   bool isRecord() const {
     return getDeclKind() >= Decl::firstRecord &&
            getDeclKind() <= Decl::lastRecord;
   }
 
   bool isNamespace() const { return getDeclKind() == Decl::Namespace; }
 
+  // Determines if the namespace is exactly `std`.
   bool isStdNamespace() const;
 
+  // Determines if the namespace is `std`, or a namespace nested in `std`.
+  bool isStdNestedNamespace() const;
+
   bool isInlineNamespace() const;
 
   /// Determines whether this context is dependent on a
   /// template parameter.
   bool isDependentContext() const;
 
   /// isTransparentContext - Determines whether this context is a
   /// "transparent" context, meaning that the members declared in this

clang/include/clang/Basic/Attr.td

 
 def AllocAlign : InheritableAttr {
   let Spellings = [GCC<"alloc_align">];
   let Subjects = SubjectList<[HasFunctionProto]>;
   let Args = [ParamIdxArgument<"ParamIndex">];
   let Documentation = [AllocAlignDocs];
 }
 
+def NoAddress : InheritableAttr {
+  let Spellings = [Clang<"no_address">];
+  let Subjects = SubjectList<[Function], ErrorDiag>;
+  let Documentation = [NoAddressDocs];
+  let SimpleHandler = 0;
+}
+
 def NoReturn : InheritableAttr {
   let Spellings = [GCC<"noreturn">, Declspec<"noreturn">];
   // FIXME: Does GCC allow this on the function instead?
   let Documentation = [Undocumented];
 }
 
 def NoInstrumentFunction : InheritableAttr {
   let Spellings = [GCC<"no_instrument_function">];

clang/include/clang/Basic/AttrDocs.td

 that appears to be capable of returning to its caller.
   }];
 }
 
 def NoMergeDocs : Documentation {
   let Category = DocCatStmt;
   let Content = [{
 If a statement is marked ``nomerge`` and contains call expressions, those call
-expressions inside the statement will not be merged during optimization. This 
+expressions inside the statement will not be merged during optimization. This
 attribute can be used to prevent the optimizer from obscuring the source
 location of certain calls. For example, it will prevent tail merging otherwise
 identical code sequences that raise an exception or terminate the program. Tail
 merging normally reduces the precision of source location information, making
 stack traces less useful for debugging. This attribute gives the user control
-over the tradeoff between code size and debug information precision. 
+over the tradeoff between code size and debug information precision.
 
-``nomerge`` attribute can also be used as function attribute to prevent all 
-calls to the specified function from merging. It has no effect on indirect 
+``nomerge`` attribute can also be used as function attribute to prevent all
+calls to the specified function from merging. It has no effect on indirect
 calls.
   }];
 }
 
 def MustTailDocs : Documentation {
   let Category = DocCatStmt;
   let Content = [{
 If a ``return`` statement is marked ``musttail``, this indicates that the

 
 
 def NullabilityDocs : DocumentationCategory<"Nullability Attributes"> {
   let Content = [{
 Whether a particular pointer may be "null" is an important concern when working
 with pointers in the C family of languages. The various nullability attributes
 indicate whether a particular pointer can be null or not, which makes APIs more
 expressive and can help static analysis tools identify bugs involving null
-pointers. Clang supports several kinds of nullability attributes: the 
+pointers. Clang supports several kinds of nullability attributes: the
 ``nonnull`` and ``returns_nonnull`` attributes indicate which function or
 method parameters and result types can never be null, while nullability type
 qualifiers indicate which pointer types can be null (``_Nullable``) or cannot
 be null (``_Nonnull``).
 
 The nullability (type) qualifiers express whether a value of a given pointer
 type can be null (the ``_Nullable`` qualifier), doesn't have a defined meaning
 for null (the ``_Nonnull`` qualifier), or for which the purpose of null is
memory is not available rather than returning a null pointer:
 
   .. code-block:: c
 
     extern void * malloc (size_t size) __attribute__((returns_nonnull));
 
 The ``returns_nonnull`` attribute implies that returning a null pointer is
 undefined behavior, which the optimizer may take advantage of. The ``_Nonnull``
 type qualifier indicates that a pointer cannot be null in a more general manner
-(because it is part of the type system) and does not imply undefined behavior, 
+(because it is part of the type system) and does not imply undefined behavior,
 making it more widely applicable
 }];
 }
 
 def NoAliasDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 The ``noalias`` attribute indicates that the only memory accesses inside

 }];
 }
 
 def CFGuardDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Code can indicate CFG checks are not wanted with the ``__declspec(guard(nocf))``
 attribute. This directs the compiler to not insert any CFG checks for the entire
-function. This approach is typically used only sparingly in specific situations 
-where the programmer has manually inserted "CFG-equivalent" protection. The 
-programmer knows that they are calling through some read-only function table 
-whose address is obtained through read-only memory references and for which the 
-index is masked to the function table limit. This approach may also be applied 
-to small wrapper functions that are not inlined and that do nothing more than 
-make a call through a function pointer. Since incorrect usage of this directive 
-can compromise the security of CFG, the programmer must be very careful using 
-the directive. Typically, this usage is limited to very small functions that 
+function. This approach is typically used only sparingly in specific situations
+where the programmer has manually inserted "CFG-equivalent" protection. The
+programmer knows that they are calling through some read-only function table
+whose address is obtained through read-only memory references and for which the
+index is masked to the function table limit. This approach may also be applied
+to small wrapper functions that are not inlined and that do nothing more than
+make a call through a function pointer. Since incorrect usage of this directive
+can compromise the security of CFG, the programmer must be very careful using
+the directive. Typically, this usage is limited to very small functions that
 only call one function.
 
 `Control Flow Guard documentation <https://docs.microsoft.com/en-us/windows/win32/secbp/pe-metadata>`
 }];
 }
 
 def CUDADeviceBuiltinSurfaceTypeDocs : Documentation {
   let Category = DocCatType;
def EnforceTCBLeafDocs : Documentation {
   let Content = [{
   The ``enforce_tcb_leaf`` attribute satisfies the requirement enforced by
   ``enforce_tcb`` for the marked function to be in the named TCB but does not
   continue to check the functions called from within the leaf function.
 
   - ``enforce_tcb_leaf(Name)`` indicates that this function is a part of the TCB named ``Name``
   }];
 }
+
+def NoAddressDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+  The ``no_address`` attribute is an opt-in mechanism for the C++ standard library to prevent users
+  from taking the address of standard library functions, function templates, and member functions.
+
+  Although opt-in, the attribute poisons the entire overload set, meaning that only one overload
+  needs the attribute per set (although such usage is discouraged). Until there is confidence that
+  this attribute doesn't have many sharp edges, usage is restricted to only entities in namespace
+  ``std`` (and nested namespaces).
+  }];
+}

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_diagnose_if_succeeded : Warning<"%0">, InGroup<UserDefinedWarnings>,
     ShowInSystemHeader;
 def note_ovl_candidate_disabled_by_function_cond_attr : Note<
     "candidate disabled: %0">;
 def note_ovl_candidate_disabled_by_extension : Note<
     "candidate unavailable as it requires OpenCL extension '%0' to be enabled">;
 def err_addrof_function_disabled_by_enable_if_attr : Error<
     "cannot take address of function %0 because it has one or more "
     "non-tautological enable_if conditions">;
+def err_no_address_std_only : Error<
+    "[[clang::no_address]] can only be used by the C++ standard library">;
+def err_function_has_no_address : Error<
+    "cannot take address of '%0' because %select{functions|member functions}1 "
+    "in %2 are not addressable">;
 def err_addrof_function_constraints_not_satisfied : Error<
     "cannot take address of function %0 because its constraints are not "
     "satisfied">;
 def note_addrof_ovl_candidate_disabled_by_enable_if_attr : Note<
     "candidate function made ineligible by enable_if">;
 def note_ovl_candidate_deduced_mismatch : Note<
     "candidate template ignored: deduced type "
     "%diff{$ of %select{|element of }4%ordinal0 parameter does not match "

clang/lib/AST/Decl.cpp

if (hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
     return true;
 
   if (auto *FnTy = getType()->getAs<FunctionType>())
     return FnTy->getNoReturnAttr();
 
   return false;
 }
 
-
 MultiVersionKind FunctionDecl::getMultiVersionKind() const {
   if (hasAttr<TargetAttr>())
     return MultiVersionKind::Target;
   if (hasAttr<CPUDispatchAttr>())
     return MultiVersionKind::CPUDispatch;
   if (hasAttr<CPUSpecificAttr>())
     return MultiVersionKind::CPUSpecific;
   return MultiVersionKind::None;

clang/lib/AST/DeclBase.cpp

bool DeclContext::isStdNamespace() const {
 
   if (!getParent()->getRedeclContext()->isTranslationUnit())
     return false;
 
   const IdentifierInfo *II = ND->getIdentifier();
   return II && II->isStr("std");
 }
 
+bool DeclContext::isStdNestedNamespace() const {
+  if (isStdNamespace())
+    return true;
+
+  if (!getParent()->getRedeclContext()->isTranslationUnit())
+    return getParent()->getRedeclContext()->isStdNestedNamespace();
+
+  return false;
+}
+
 bool DeclContext::isDependentContext() const {
   if (isFileContext())
     return false;
 
   if (isa<ClassTemplatePartialSpecializationDecl>(this))
     return true;
 
   if (const auto *Record = dyn_cast<CXXRecordDecl>(this)) {

clang/lib/Sema/SemaDeclAttr.cpp

if (const ConflictingAttrTy *ConflictingAttr =
     // needs to be kept because it can only suppresses warnings, not cause them.
     D->dropAttr<EnforceTCBAttr>();
     return;
   }
 
   D->addAttr(AttrTy::Create(S.Context, Argument, AL));
 }
 
+static void handleNoAddressAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  DeclContext *C = D->getDeclContext();
+  if (!C->isStdNestedNamespace()) {
+    S.Diag(AL.getLoc(), diag::err_no_address_std_only);
+    return;
+  }
+  D->addAttr(::new (S.Context) NoAddressAttr(S.Context, AL));
+}
+
 template <typename AttrTy, typename ConflictingAttrTy>
 static AttrTy *mergeEnforceTCBAttrImpl(Sema &S, Decl *D, const AttrTy &AL) {
   // Check if the new redeclaration has different leaf-ness in the same TCB.
   StringRef TCBName = AL.getTCBName();
   if (const ConflictingAttrTy *ConflictingAttr =
       findEnforceTCBAttrByName<ConflictingAttrTy>(D, TCBName)) {
     S.Diag(ConflictingAttr->getLoc(), diag::err_tcb_conflicting_attributes)
       << ConflictingAttr->getAttrName()->getName()
case ParsedAttr::AT_SwiftErrorResult:
     S.AddParameterABIAttr(D, AL, ParameterABI::SwiftErrorResult);
     break;
   case ParsedAttr::AT_SwiftIndirectResult:
     S.AddParameterABIAttr(D, AL, ParameterABI::SwiftIndirectResult);
     break;
   case ParsedAttr::AT_InternalLinkage:
     handleInternalLinkageAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_NoAddress:
+    handleNoAddressAttr(S, D, AL);
+    break;
 
   // Microsoft attributes:
   case ParsedAttr::AT_LayoutVersion:
     handleLayoutVersion(S, D, AL);
     break;
   case ParsedAttr::AT_Uuid:
     handleUuidAttr(S, D, AL);
     break;

clang/lib/Sema/SemaOverload.cpp

 //===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides Sema routines for C++ overloading.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/CXXInheritance.h"
+#include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DependenceFlags.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/TypeOrdering.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Overload.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Support/Casting.h"
 #include <algorithm>
 #include <cstdlib>
 
 using namespace clang;
 using namespace sema;
 
 using AllowedExplicit = Sema::AllowedExplicit;
 
if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
       SCS.QualificationIncludesObjCLifetime = false;
       SCS.setAllToTypes(FromType);
       return true;
     }
   } else if (FromType->isFunctionType() && argIsLValue) {
     // Function-to-pointer conversion (C++ 4.3).
     SCS.First = ICK_Function_To_Pointer;
 
-    if (auto *DRE = dyn_cast<DeclRefExpr>(From->IgnoreParenCasts()))
-      if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
-        if (!S.checkAddressOfFunctionIsAvailable(FD))
+    if (auto *DRE = dyn_cast<DeclRefExpr>(From->IgnoreParenCasts())) {
+      if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
+        if (!S.checkAddressOfFunctionIsAvailable(FD) ||
+            FD->hasAttr<NoAddressAttr>()) {
           return false;
+        }
+      }
+    }
 
     // An lvalue of function type T can be converted to an rvalue of
     // type "pointer to T." The result is a pointer to the
     // function. (C++ 4.3p1).
     FromType = S.Context.getPointerType(FromType);
   } else {
     // We don't require any conversions for the first step.
     SCS.First = ICK_Identity;
if (!Satisfaction.IsSatisfied) {
           S.Diag(Loc, diag::err_addrof_function_constraints_not_satisfied)
               << FD;
         S.DiagnoseUnsatisfiedConstraint(Satisfaction);
       }
       return false;
     }
   }
 
+  if (FD->hasAttr<NoAddressAttr>()) {
+    if (Complain) {
+      if (!InOverloadResolution) {
+        S.Diag(Loc, diag::err_function_has_no_address)
+            << FD->getQualifiedNameAsString() << isa<CXXMethodDecl>(FD)
+            << FD->getEnclosingNamespaceContext();
+      }
+    }
+    return false;
+  }
+
   auto I = llvm::find_if(FD->parameters(), [](const ParmVarDecl *P) {
     return P->hasAttr<PassObjectSizeAttr>();
   });
   if (I == FD->param_end())
     return true;
 
   if (Complain) {
     // Add one to ParamNo because it's user-facing
     unsigned ParamNo = std::distance(FD->param_begin(), I) + 1;
     if (InOverloadResolution)
       S.Diag(FD->getLocation(),
              diag::note_ovl_candidate_has_pass_object_size_params)
           << ParamNo;
     else
       S.Diag(Loc, diag::err_address_of_function_with_pass_object_size_params)
           << FD << ParamNo;
   }
+
   return false;
 }
 
 static bool checkAddressOfCandidateIsAvailable(Sema &S,
                                                const FunctionDecl *FD) {
   return checkAddressOfFunctionIsAvailable(S, FD, /*Complain=*/true,
                                            /*InOverloadResolution=*/true,
                                            /*Loc=*/SourceLocation());
for (unsigned I = 0, N = Matches.size(); I != N; ) {
       }
     }
   }
 
   void EliminateSuboptimalCudaMatches() {
     S.EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(S.CurContext), Matches);
   }
 
+  static bool HasNoAddressAttr(const NamedDecl *D) {
+    if (auto *FD = dyn_cast<FunctionDecl>(D))
+      return FD->hasAttr<NoAddressAttr>();
+    if (auto *FTD = dyn_cast<FunctionTemplateDecl>(D))
+      if (auto *FD = FTD->getTemplatedDecl())
+        return FD->hasAttr<NoAddressAttr>();
+    return false;
+  }
+
+  static bool IsMethod(const NamedDecl *D) {
+    if (auto *TFD = dyn_cast<FunctionTemplateDecl>(D))
+      return isa<CXXMethodDecl>(TFD->getTemplatedDecl());
+    return isa<CXXMethodDecl>(D);
+  }
+
+  UnresolvedLookupExpr *GetOverloadSet() const {
+    if (auto *E = dyn_cast<UnaryOperator>(SourceExpr->IgnoreParenCasts()))
+      return dyn_cast<UnresolvedLookupExpr>(E->getSubExpr());
+    return dyn_cast<UnresolvedLookupExpr>(SourceExpr->IgnoreParenCasts());
+  }
+
 public:
   void ComplainNoMatchesFound() const {
     assert(Matches.empty());
     S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_no_viable)
         << OvlExpr->getName() << TargetFunctionType
         << OvlExpr->getSourceRange();
     if (FailedCandidates.empty())
       S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
public:
   void ComplainMultipleMatchesFound() const {
     assert(Matches.size() > 1);
     S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_ambiguous)
         << OvlExpr->getName() << OvlExpr->getSourceRange();
     S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
                                 /*TakingAddress=*/true);
   }
 
+  bool AnyMatchHasNoAddress() const {
+    UnresolvedLookupExpr *OverloadSet = GetOverloadSet();
+    assert(OverloadSet != nullptr);
+    return llvm::any_of(OverloadSet->decls(), HasNoAddressAttr);
+  }
+
+  void ComplainMatchHasNoAddress() const {
+    auto *OverloadSet = GetOverloadSet();
+    assert(OverloadSet != nullptr);
+    auto D = llvm::find_if(OverloadSet->decls(), HasNoAddressAttr);
+    assert(D != OverloadSet->decls_end());
+    auto *C = (*D)->getDeclContext();
+
+    S.Diag(OvlExpr->getBeginLoc(), diag::err_function_has_no_address)
+        << D->getQualifiedNameAsString() << IsMethod(*D)
+        << C->getEnclosingNamespaceContext();
+  }
+
   bool hadMultipleCandidates() const { return (OvlExpr->getNumDecls() > 1); }
 
   int getNumMatches() const { return Matches.size(); }
 
   FunctionDecl* getMatchingFunctionDecl() const {
     if (Matches.size() != 1) return nullptr;
     return Matches[0].second;
   }
Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
                                          bool *pHadMultipleCandidates) {
   assert(AddressOfExpr->getType() == Context.OverloadTy);
 
   AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType,
                                      Complain);
   int NumMatches = Resolver.getNumMatches();
   FunctionDecl *Fn = nullptr;
   bool ShouldComplain = Complain && !Resolver.hasComplained();
-  if (NumMatches == 0 && ShouldComplain) {
+  if (Resolver.AnyMatchHasNoAddress() && ShouldComplain)
+    Resolver.ComplainMatchHasNoAddress();
+  else if (NumMatches == 0 && ShouldComplain) {
     if (Resolver.IsInvalidFormOfPointerToMemberFunction())
       Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
     else
       Resolver.ComplainNoMatchesFound();
-  }
-  else if (NumMatches > 1 && ShouldComplain)
+  } else if (NumMatches > 1 && ShouldComplain)
     Resolver.ComplainMultipleMatchesFound();
   else if (NumMatches == 1) {
     Fn = Resolver.getMatchingFunctionDecl();
     assert(Fn);
     if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
       ResolveExceptionSpec(AddressOfExpr->getExprLoc(), FPT);
     FoundResult = *Resolver.getMatchingFunctionAccessPair();
     if (Complain) {

clang/test/SemaCXX/attr-no-address.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+namespace std {
+  [[clang::no_address]] void one_overload();
+  [[clang::no_address]] void two_overloads();
+  [[clang::no_address]] void two_overloads(int);
+
+  template<class T>
+  [[clang::no_address]] void many_overloads(T);
+
+  struct type {
+    [[clang::no_address]] void one_overload();
+    [[clang::no_address]] void two_overloads();
+    [[clang::no_address]] void two_overloads() const;
+
+    template<class T>
+    [[clang::no_address]] void many_overloads(T) &;
+
+    template<class T>
+    [[clang::no_address]] void many_overloads(T) const&;
+
+    template<class T>
+    [[clang::no_address]] void many_overloads(T) &&;
+
+    template<class T>
+    [[clang::no_address]] void many_overloads(T) const&&;
+
+    [[clang::no_address]] static void single_overload();
+    [[clang::no_address]] static void double_overload(double);
+    [[clang::no_address]] static void double_overload(int);
+
+    template<class T>
+    [[clang::no_address]] static void multi_overload(T);
+  };
+
+  namespace ranges {
+    [[clang::no_address]] void one_overload();
+    [[clang::no_address]] void two_overloads();
+    [[clang::no_address]] void two_overloads(int);
+
+    template<class T>
+    [[clang::no_address]] void many_overloads(T);
+  }
+} // namespace std
+
+void address_test() {
+  void (*fp1)() = &std::one_overload;
+  // expected-error@-1{{cannot take address of 'std::one_overload' because functions in namespace 'std' are not addressable}}
+  void (*fp2)() = std::one_overload;
+  // expected-error@-1{{cannot take address of 'std::one_overload' because functions in namespace 'std' are not addressable}}
+  void (*fp3)() = &std::two_overloads;
+  // expected-error@-1{{cannot take address of 'std::two_overloads' because functions in namespace 'std' are not addressable}}
+  void (*fp4)() = std::two_overloads;
+  // expected-error@-1{{cannot take address of 'std::two_overloads' because functions in namespace 'std' are not addressable}}
+  void (*fp5)(int) = &std::many_overloads<int>;
+  // expected-error@-1{{cannot take address of 'std::many_overloads' because functions in namespace 'std' are not addressable}}
+  void (*fp6)(double) = std::many_overloads<double>;
+  // expected-error@-1{{cannot take address of 'std::many_overloads' because functions in namespace 'std' are not addressable}}
+  void (*fp8)() = &std::ranges::one_overload;
+  // expected-error@-1{{cannot take address of 'std::ranges::one_overload' because functions in namespace 'std::ranges' are not addressable}}
+  void (*fp9)() = std::ranges::one_overload;
+  // expected-error@-1{{cannot take address of 'std::ranges::one_overload' because functions in namespace 'std::ranges' are not addressable}}
+  void (*fp10)() = &std::ranges::two_overloads;
+  // expected-error@-1{{cannot take address of 'std::ranges::two_overloads' because functions in namespace 'std::ranges' are not addressable}}
+  void (*fp11)() = std::ranges::two_overloads;
+  // expected-error@-1{{cannot take address of 'std::ranges::two_overloads' because functions in namespace 'std::ranges' are not addressable}}
+  void (*fp12)(int) = &std::ranges::many_overloads<int>;
+  // expected-error@-1{{cannot take address of 'std::ranges::many_overloads' because functions in namespace 'std::ranges' are not addressable}}
+  void (*fp13)(double) = std::ranges::many_overloads<double>;
+  // expected-error@-1{{cannot take address of 'std::ranges::many_overloads' because functions in namespace 'std::ranges' are not addressable}}
+
+  void (&fr1)() = &std::one_overload;
+  // expected-error@-1{{cannot take address of 'std::one_overload' because functions in namespace 'std' are not addressable}}
+  void (*fr2)() = std::one_overload;
+  // expected-error@-1{{cannot take address of 'std::one_overload' because functions in namespace 'std' are not addressable}}
+  void (&fr3)() = &std::two_overloads;
+  // expected-error@-1{{cannot take address of 'std::two_overloads' because functions in namespace 'std' are not addressable}}
+  void (&fr4)() = std::two_overloads;
+  // expected-error@-1{{cannot take address of 'std::two_overloads' because functions in namespace 'std' are not addressable}}
+  void (&fr5)(int) = &std::many_overloads<int>;
+  // expected-error@-1{{cannot take address of 'std::many_overloads' because functions in namespace 'std' are not addressable}}
+  void (&fr6)(double) = std::many_overloads<double>;
+  // expected-error@-1{{cannot take address of 'std::many_overloads' because functions in namespace 'std' are not addressable}}
+  void (&fr8)() = &std::ranges::one_overload;
+  // expected-error@-1{{cannot take address of 'std::ranges::one_overload' because functions in namespace 'std::ranges' are not addressable}}
+  void (&fr9)() = std::ranges::one_overload;
+  // expected-error@-1{{cannot take address of 'std::ranges::one_overload' because functions in namespace 'std::ranges' are not addressable}}
+  void (&fr10)() = &std::ranges::two_overloads;
+  // expected-error@-1{{cannot take address of 'std::ranges::two_overloads' because functions in namespace 'std::ranges' are not addressable}}
+  void (&fr11)() = std::ranges::two_overloads;
+  // expected-error@-1{{cannot take address of 'std::ranges::two_overloads' because functions in namespace 'std::ranges' are not addressable}}
+  void (&fr12)(int) = &std::ranges::many_overloads<int>;
+  // expected-error@-1{{cannot take address of 'std::ranges::many_overloads' because functions in namespace 'std::ranges' are not addressable}}
+  void (&fr13)(double) = std::ranges::many_overloads<double>;
+  // expected-error@-1{{cannot take address of 'std::ranges::many_overloads' because functions in namespace 'std::ranges' are not addressable}}
+
+  void (std::type::*mfp1)() = &std::type::one_overload;
+  // expected-error@-1{{cannot take address of 'std::type::one_overload' because member functions in namespace 'std' are not addressable}}
+  void (std::type::*mfp2)() = &std::type::two_overloads;
+  // expected-error@-1{{cannot take address of 'std::type::two_overloads' because member functions in namespace 'std' are not addressable}}
+  void (std::type::*mfp3)() const = &std::type::two_overloads;
+  // expected-error@-1{{cannot take address of 'std::type::two_overloads' because member functions in namespace 'std' are not addressable}}
+  void (std::type::*mfp4)(int) & = &std::type::many_overloads<int>;
+  // expected-error@-1{{cannot take address of 'std::type::many_overloads' because member functions in namespace 'std' are not addressable}}
+  void (std::type::*mfp5)(int) const& = &std::type::many_overloads<int>;
+  // expected-error@-1{{cannot take address of 'std::type::many_overloads' because member functions in namespace 'std' are not addressable}}
+  void (std::type::*mfp6)(int) && = &std::type::many_overloads<int>;
+  // expected-error@-1{{cannot take address of 'std::type::many_overloads' because member functions in namespace 'std' are not addressable}}
+  void (std::type::*mfp7)(int) const&& = &std::type::many_overloads<int>;
+  // expected-error@-1{{cannot take address of 'std::type::many_overloads' because member functions in namespace 'std' are not addressable}}
+
+  void (*sfp1)() = &std::type::single_overload;
+  // expected-error@-1{{cannot take address of 'std::type::single_overload' because member functions in namespace 'std' are not addressable}}
+  void (*sfp2)() = std::type::single_overload;
+  // expected-error@-1{{cannot take address of 'std::type::single_overload' because member functions in namespace 'std' are not addressable}}
+  void (*sfp3)(double) = &std::type::double_overload;
+  // expected-error@-1{{cannot take address of 'std::type::double_overload' because member functions in namespace 'std' are not addressable}}
+  void (*sfp4)(int) = std::type::double_overload;
+  // expected-error@-1{{cannot take address of 'std::type::double_overload' because member functions in namespace 'std' are not addressable}}
+  void (*sfp5)(double) = &std::type::multi_overload<double>;
+  // expected-error@-1{{cannot take address of 'std::type::multi_overload' because member functions in namespace 'std' are not addressable}}
+  void (*sfp6)(int) = std::type::multi_overload<int>;
+  // expected-error@-1{{cannot take address of 'std::type::multi_overload' because member functions in namespace 'std' are not addressable}}
+
+  void (&sfr1)() = &std::type::single_overload;
+  // expected-error@-1{{cannot take address of 'std::type::single_overload' because member functions in namespace 'std' are not addressable}}
+  void (&sfr2)() = std::type::single_overload;
+  // expected-error@-1{{cannot take address of 'std::type::single_overload' because member functions in namespace 'std' are not addressable}}
+  void (&sfr3)(double) = &std::type::double_overload;
+  // expected-error@-1{{cannot take address of 'std::type::double_overload' because member functions in namespace 'std' are not addressable}}
+  void (&sfr4)(int) = std::type::double_overload;
+  // expected-error@-1{{cannot take address of 'std::type::double_overload' because member functions in namespace 'std' are not addressable}}
+  void (&sfr5)(double) = &std::type::multi_overload<double>;
+  // expected-error@-1{{cannot take address of 'std::type::multi_overload' because member functions in namespace 'std' are not addressable}}
+  void (&sfr6)(int) = std::type::multi_overload<int>;
+  // expected-error@-1{{cannot take address of 'std::type::multi_overload' because member functions in namespace 'std' are not addressable}}
+}
+
+void call_regression_test() {
+  std::one_overload();
+  std::two_overloads();
+  std::two_overloads(0);
+  std::many_overloads(0);
+  std::many_overloads(0.0);
+
+  std::type s;
+  s.one_overload();
+  s.two_overloads();
+  static_cast<const std::type&>(s).two_overloads();
+  s.many_overloads(0);
+  s.many_overloads(1);
+}
+
+namespace notstd {
+  [[clang::no_address]] void one_overload();
+  // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+  [[clang::no_address]] void two_overloads();
+  // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+  [[clang::no_address]] void two_overloads(int);
+  // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+
+  template<class T>
+  [[clang::no_address]] void many_overloads(T);
+  // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+
+  struct type {
+    [[clang::no_address]] void one_overload();
+    // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+    [[clang::no_address]] void two_overloads();
+    // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+    [[clang::no_address]] void two_overloads() const;
+    // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+    template<class T>
+    [[clang::no_address]] void many_overloads(T) &;
+    // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+    template<class T>
+    [[clang::no_address]] void many_overloads(T) const&;
+    // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+    template<class T>
+    [[clang::no_address]] void many_overloads(T) &&;
+    // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+    template<class T>
+    [[clang::no_address]] void many_overloads(T) const&&;
+    // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+  };
+
+  namespace std {
+    [[clang::no_address]] void one_overload();
+    // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+    [[clang::no_address]] void two_overloads();
+    // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+    [[clang::no_address]] void two_overloads(int);
+    // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+
+    template<class T>
+    [[clang::no_address]] void many_overloads(T);
+    // expected-error@-1 {{[[clang::no_address]] can only be used by the C++ standard library}}
+  }
+} // namespace notstd