Index: clang/lib/AST/ItaniumMangle.cpp
===================================================================
--- clang/lib/AST/ItaniumMangle.cpp
+++ clang/lib/AST/ItaniumMangle.cpp
@@ -610,6 +610,26 @@
   return StdNamespace;
 }
 
+// Determine if this is a constrained friend that meets the requirements to be a
+// different scope, according to [temp.friend]p9.
+static bool IsDifferentlyMangledConstrainedFriend(const Decl *D) {
+  if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(D))
+    return IsDifferentlyMangledConstrainedFriend(FTD->getTemplatedDecl());
+
+  if (D->getFriendObjectKind() == Decl::FOK_None)
+    return false;
+
+  const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
+
+  if (!FD)
+    return false;
+
+  if (FD->getPrimaryTemplate())
+    return FD->FriendConstraintRefersToEnclosingTemplate();
+
+  return FD->getTrailingRequiresClause();
+}
+
 /// Retrieve the declaration context that should be used when mangling the given
 /// declaration.
 const DeclContext *
@@ -659,6 +679,11 @@
     if (FD->isExternC())
       return getASTContext().getTranslationUnitDecl();
 
+  // If these are mangled differently because they are constrained friends,
+  // mangle it in its lexical context.
+  if (IsDifferentlyMangledConstrainedFriend(D))
+    return D->getLexicalDeclContext();
+
   return DC->getRedeclContext();
 }
 
@@ -1694,13 +1719,22 @@
   Out << II->getLength() << II->getName();
 }
 
+// See if the 'F' between the prefix of a nested name or nested template is
+// necessary.  That is, is this a friend with a constraint that refers to an
+// enclosing template.
+static void mangleConstrainedFriendness(llvm::raw_ostream &Out, GlobalDecl GD) {
+  if (IsDifferentlyMangledConstrainedFriend(GD.getDecl()))
+      Out << 'F';
+}
+
 void CXXNameMangler::mangleNestedName(GlobalDecl GD,
                                       const DeclContext *DC,
                                       const AbiTagList *AdditionalAbiTags,
                                       bool NoFunction) {
   const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
   // <nested-name>
-  //   ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
+  //   ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> [F] 
+  //       <unqualified-name> E
   //   ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix>
   //       <template-args> E
 
@@ -1721,6 +1755,7 @@
     mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
   } else {
     manglePrefix(DC, NoFunction);
+    mangleConstrainedFriendness(Out, GD);
     mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
   }
 
@@ -2139,7 +2174,7 @@
 void CXXNameMangler::mangleTemplatePrefix(GlobalDecl GD,
                                           bool NoFunction) {
   const TemplateDecl *ND = cast<TemplateDecl>(GD.getDecl());
-  // <template-prefix> ::= <prefix> <template unqualified-name>
+  // <template-prefix> ::= <prefix> [F] <template unqualified-name>
   //                   ::= <template-param>
   //                   ::= <substitution>
   // <template-template-param> ::= <template-param>
@@ -2154,6 +2189,7 @@
   } else {
     const DeclContext *DC = Context.getEffectiveDeclContext(ND);
     manglePrefix(DC, NoFunction);
+    mangleConstrainedFriendness(Out, GD);
     if (isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND))
       mangleUnqualifiedName(GD, DC, nullptr);
     else
Index: clang/test/CodeGenCXX/friend-concepts-mangling.cpp
===================================================================
--- /dev/null
+++ clang/test/CodeGenCXX/friend-concepts-mangling.cpp
@@ -0,0 +1,71 @@
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -std=c++20 -emit-llvm -o - %s | FileCheck %s
+
+// See US115 from P2103R0 and 
+// https://github.com/itanium-cxx-abi/cxx-abi/issues/24.
+// Friends that have concept constraints that refer to a containing template 
+// (which makes them required to be a definition) must mangle their containing
+// type.
+struct Base {};
+
+template <int N>
+struct S : public Base {
+  friend int func(Base &)
+    requires(N == 1)
+    { return 1; }
+  friend int func(Base &)
+    requires(N == 2)
+    { return 3; }
+  // Without the 'F' mangling addition, this is in conflict with the above.
+  int func(Base &) { return 5; }
+
+  template<typename T>
+    friend int templ_func(Base &)
+    requires(N == 1 || N == 2)
+    { return 10; }
+
+  template<typename T>
+    int templ_func(Base &)
+    { return 15; }
+};
+
+void useS() {
+  S<1> s1{};
+  S<2> s2{};
+  auto const func1 = func(s1);
+  // CHECK: call noundef i32 @_ZN1SILi1EEF4funcER4Base
+  auto const func2 = func(s2);
+  // CHECK: call noundef i32 @_ZN1SILi2EEF4funcER4Base
+
+  // These have the same signature, so we need to make sure they have a
+  // different mangling (or more correctly, that the friend functions do not
+  // conflict). Note that these are the same as above, with the exception of the
+  // missing 'F' before the unqualified name.
+  auto const func3 = s1.func(s1);
+  // CHECK: call noundef i32 @_ZN1SILi1EE4funcER4Base
+  auto const func4 = s2.func(s2);
+  // CHECK: call noundef i32 @_ZN1SILi2EE4funcER4Base
+
+  auto const templ1 = templ_func<int>(s1);
+  // CHECK: call noundef i32 @_ZN1SILi1EEF10templ_funcIiEEiR4Base
+  auto const templ2 = templ_func<int>(s2);
+  // CHECK: call noundef i32 @_ZN1SILi2EEF10templ_funcIiEEiR4Base
+  auto const templ3 = s1.templ_func<int>(s1);
+  // CHECK: call noundef i32 @_ZN1SILi1EE10templ_funcIiEEiR4Base
+  auto const templ4 = s2.templ_func<int>(s2);
+  // CHECK: call noundef i32 @_ZN1SILi2EE10templ_funcIiEEiR4Base
+}
+
+
+template<int N>
+struct U {
+  friend void foo(int) requires (N == 1) {}
+  friend void foo(int) requires (N == 2) {}
+  operator int() const;
+};
+
+void UseU() {
+  foo(U<1>{});
+  // CHECK: call void @_ZN1UILi1EEF3fooEi
+  foo(U<2>{});
+  // CHECK: call void @_ZN1UILi2EEF3fooEi
+}