diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index 1dac1470d3b..e4bf9c963bd 100644
--- a/gcc/cp/call.cc
+++ b/gcc/cp/call.cc
@@ -14033,11 +14033,7 @@ std_pair_ref_ref_p (tree t)
   return true;
 }
 
-/* Return true if a class CTYPE is either std::reference_wrapper or
-   std::ref_view, or a reference wrapper class.  We consider a class
-   a reference wrapper class if it has a reference member.  We no
-   longer check that it has a constructor taking the same reference type
-   since that approach still generated too many false positives.  */
+/* Return true if a class T has a reference member.  */
 
 static bool
 class_has_reference_member_p (tree t)
@@ -14061,12 +14057,41 @@ class_has_reference_member_p_r (tree binfo, void *)
 	  ? integer_one_node : NULL_TREE);
 }
 
+
+/* Return true if T (either a class or a function) has been marked as
+   non-owning.  */
+
+static bool
+non_owning_p (tree t)
+{
+  t = lookup_attribute ("non_owning", TYPE_ATTRIBUTES (t));
+  if (!t)
+    return false;
+
+  t = TREE_VALUE (t);
+  if (!t)
+    return true;
+
+  t = build_converted_constant_bool_expr (TREE_VALUE (t), tf_warning_or_error);
+  t = cxx_constant_value (t);
+  return t == boolean_true_node;
+}
+
+/* Return true if a class CTYPE is either std::reference_wrapper or
+   std::ref_view, or a reference wrapper class.  We consider a class
+   a reference wrapper class if it has a reference member.  We no
+   longer check that it has a constructor taking the same reference type
+   since that approach still generated too many false positives.  */
+
 static bool
 reference_like_class_p (tree ctype)
 {
   if (!CLASS_TYPE_P (ctype))
     return false;
 
+  if (non_owning_p (ctype))
+    return true;
+
   /* Also accept a std::pair<const T&, const T&>.  */
   if (std_pair_ref_ref_p (ctype))
     return true;
@@ -14173,7 +14198,8 @@ do_warn_dangling_reference (tree expr, bool arg_p)
 	       but probably not to one of its arguments.  */
 	    || (DECL_OBJECT_MEMBER_FUNCTION_P (fndecl)
 		&& DECL_OVERLOADED_OPERATOR_P (fndecl)
-		&& DECL_OVERLOADED_OPERATOR_IS (fndecl, INDIRECT_REF)))
+		&& DECL_OVERLOADED_OPERATOR_IS (fndecl, INDIRECT_REF))
+	    || non_owning_p (TREE_TYPE (fndecl)))
 	  return NULL_TREE;
 
 	tree rettype = TREE_TYPE (TREE_TYPE (fndecl));
diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
index ad312710f68..017da7e294a 100644
--- a/gcc/cp/tree.cc
+++ b/gcc/cp/tree.cc
@@ -47,6 +47,7 @@ static tree verify_stmt_tree_r (tree *, int *, void *);
 static tree handle_init_priority_attribute (tree *, tree, tree, int, bool *);
 static tree handle_abi_tag_attribute (tree *, tree, tree, int, bool *);
 static tree handle_contract_attribute (tree *, tree, tree, int, bool *);
+static tree handle_non_owning_attribute (tree *, tree, tree, int, bool *);
 
 /* If REF is an lvalue, returns the kind of lvalue that REF is.
    Otherwise, returns clk_none.  */
@@ -5102,6 +5103,8 @@ static const attribute_spec cxx_gnu_attributes[] =
     handle_init_priority_attribute, NULL },
   { "abi_tag", 1, -1, false, false, false, true,
     handle_abi_tag_attribute, NULL },
+  { "non_owning", 0, 1, false, true, false, false,
+    handle_non_owning_attribute, NULL },
 };
 
 const scoped_attribute_specs cxx_gnu_attribute_table =
@@ -5391,6 +5394,29 @@ handle_contract_attribute (tree *ARG_UNUSED (node), tree ARG_UNUSED (name),
   return NULL_TREE;
 }
 
+/* Handle a "non_owning" attribute; arguments as in
+   struct attribute_spec.handler.  */
+
+tree
+handle_non_owning_attribute (tree *node, tree name, tree args, int,
+			     bool *no_add_attrs)
+{
+  if (args && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
+    {
+      error ("%qE attribute argument must be an expression that evaluates "
+	     "to true or false", name);
+      *no_add_attrs = true;
+    }
+  else if (!FUNC_OR_METHOD_TYPE_P (*node)
+	   && !RECORD_OR_UNION_TYPE_P (*node))
+    {
+      warning (OPT_Wattributes, "%qE attribute ignored", name);
+      *no_add_attrs = true;
+    }
+
+  return NULL_TREE;
+}
+
 /* Return a new PTRMEM_CST of the indicated TYPE.  The MEMBER is the
    thing pointed to by the constant.  */
 
diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi
index 2135dfde9c8..9132add8267 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -29320,6 +29320,31 @@ Some_Class  B  __attribute__ ((init_priority (543)));
 Note that the particular values of @var{priority} do not matter; only their
 relative ordering.
 
+@cindex @code{non_owning} type attribute
+@item non_owning
+
+This attribute can be applied on a class type, function, or member
+function and indicates that it does not own its associated data.  For
+example, classes like @code{std::span} or @code{std::reference_wrapper}
+are considered non-owning.
+
+@smallexample
+class [[gnu::non_owning]] S @{ @dots{} @};
+@end smallexample
+
+This attribute takes an optional argument, which must be an expression that
+evaluates to true or false:
+
+@smallexample
+template <typename T>
+struct [[gnu::non_owning(std::is_reference_v<T>)]] S @{
+  @dots{}
+@};
+@end smallexample
+
+Currently, the only effect this attribute has is to suppress the
+@option{-Wdangling-reference} diagnostic.
+
 @cindex @code{warn_unused} type attribute
 @item warn_unused
 
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index b4e4ee9fb81..0df2e2ded34 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -3908,6 +3908,9 @@ const T& foo (const T&) @{ @dots{} @}
 #pragma GCC diagnostic pop
 @end smallexample
 
+The @code{#pragma} can also surround the class; in that case, the warning
+will be disabled for all the member functions.
+
 @option{-Wdangling-reference} also warns about code like
 
 @smallexample
@@ -3932,6 +3935,24 @@ struct Span @{
 as @code{std::span}-like; that is, the class is a non-union class
 that has a pointer data member and a trivial destructor.
 
+The warning can be disabled by using the @code{gnu::non_owning} attribute,
+which can be applied on the enclosing class type (in which case it disables
+the warning for all its member functions), member function, or a regular
+function.  For example:
+
+@smallexample
+class [[gnu::non_owning]] A @{
+  int *p;
+  int &foo() @{ return *p; @}
+@};
+
+[[gnu::non_owning]] const int &
+foo (const int &i)
+@{
+  @dots{}
+@}
+@end smallexample
+
 This warning is enabled by @option{-Wall}.
 
 @opindex Wdelete-non-virtual-dtor
diff --git a/gcc/testsuite/g++.dg/ext/attr-non-owning1.C b/gcc/testsuite/g++.dg/ext/attr-non-owning1.C
new file mode 100644
index 00000000000..000f7f4019d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/attr-non-owning1.C
@@ -0,0 +1,38 @@
+// { dg-do compile { target c++11 } }
+// { dg-options "-Wdangling-reference" }
+
+int g = 42;
+
+struct [[gnu::non_owning]] A {
+  int *i;
+  int &foo() { return *i; }
+};
+
+struct A2 {
+  int *i;
+  [[gnu::non_owning]] int &foo() { return *i; }
+  [[gnu::non_owning]] static int &bar (const int &) { return *&g; }
+};
+
+union [[gnu::non_owning]] U { };
+
+A a() { return A{&g}; }
+A2 a2() { return A2{&g}; }
+
+class X { };
+const X x1;
+const X x2;
+
+[[gnu::non_owning]] const X& get(const int& i)
+{
+   return i == 0 ? x1 : x2;
+}
+
+void
+test ()
+{
+  [[maybe_unused]] const X& x = get (10);	// { dg-bogus "dangling" }
+  [[maybe_unused]] const int &i = a().foo();	// { dg-bogus "dangling" }
+  [[maybe_unused]] const int &j = a2().foo();	// { dg-bogus "dangling" }
+  [[maybe_unused]] const int &k = a2().bar(10);	// { dg-bogus "dangling" }
+}
diff --git a/gcc/testsuite/g++.dg/ext/attr-non-owning2.C b/gcc/testsuite/g++.dg/ext/attr-non-owning2.C
new file mode 100644
index 00000000000..4d2037e8b78
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/attr-non-owning2.C
@@ -0,0 +1,29 @@
+// { dg-do compile { target c++11 } }
+// Negative tests.
+
+struct [[non_owning]] A {	    // { dg-warning "ignored" }
+ [[non_owning]] int &foo (int &);   // { dg-warning "ignored" }
+};
+
+[[non_owning]] int &bar (int &);    // { dg-warning "ignored" }
+
+[[gnu::non_owning]] int i;	    // { dg-warning "ignored" }
+[[gnu::non_owning]] double d;	    // { dg-warning "ignored" }
+[[gnu::non_owning]] typedef int T;  // { dg-warning "ignored" }
+
+[[gnu::non_owning()]] int &fn1 (int &);	    // { dg-error "parentheses" }
+[[gnu::non_owning("a")]] int &fn2 (int &);  // { dg-error "must be an expression" }
+[[gnu::non_owning(true, true)]] int &fn3 (int &);  // { dg-error "wrong number of arguments" }
+
+enum [[gnu::non_owning]] E {	    // { dg-warning "ignored" }
+  X [[gnu::non_owning]]		    // { dg-warning "ignored" }
+};
+
+[[gnu::non_owning]];		    // { dg-warning "ignored" }
+
+void
+g ()
+{
+  goto L;
+[[gnu::non_owning]] L:;		    // { dg-warning "ignored" }
+}
diff --git a/gcc/testsuite/g++.dg/ext/attr-non-owning3.C b/gcc/testsuite/g++.dg/ext/attr-non-owning3.C
new file mode 100644
index 00000000000..81c6491643b
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/attr-non-owning3.C
@@ -0,0 +1,24 @@
+// { dg-do compile { target c++11 } }
+// { dg-options "-Wdangling-reference" }
+
+template <typename T>
+struct [[gnu::non_owning]] Span {
+    T* data_;
+    int len_;
+    // So that our heuristic doesn't suppress the warning anyway.
+    ~Span();
+
+    [[nodiscard]] constexpr auto operator[](int n) const noexcept -> T& { return data_[n]; }
+    [[nodiscard]] constexpr auto front() const noexcept -> T& { return data_[0]; }
+    [[nodiscard]] constexpr auto back() const noexcept -> T& { return data_[len_ - 1]; }
+};
+
+auto get() -> Span<int>;
+
+auto f() -> int {
+    int const& a = get().front(); // { dg-bogus "dangling" }
+    int const& b = get().back();  // { dg-bogus "dangling" }
+    int const& c = get()[0];      // { dg-bogus "dangling" }
+
+    return a + b + c;
+}
diff --git a/gcc/testsuite/g++.dg/ext/attr-non-owning4.C b/gcc/testsuite/g++.dg/ext/attr-non-owning4.C
new file mode 100644
index 00000000000..c50382c3e8f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/attr-non-owning4.C
@@ -0,0 +1,14 @@
+// { dg-do compile { target c++11 } }
+
+#if !__has_attribute(non_owning)
+#error unsupported
+#endif
+
+#ifdef __has_cpp_attribute
+# if !__has_cpp_attribute(non_owning)
+#  error non_owning
+# endif
+#endif
+
+struct [[gnu::non_owning]] S { };
+static_assert (__builtin_has_attribute (S, non_owning), "");
diff --git a/gcc/testsuite/g++.dg/ext/attr-non-owning5.C b/gcc/testsuite/g++.dg/ext/attr-non-owning5.C
new file mode 100644
index 00000000000..d297bb615fe
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/attr-non-owning5.C
@@ -0,0 +1,31 @@
+// PR c++/110358
+// { dg-do compile { target c++20 } }
+// { dg-options "-Wdangling-reference" }
+
+template <typename T>
+struct Span {
+    T* data_;
+    int len_;
+    ~Span();
+
+    [[nodiscard]] constexpr auto operator[](int n) const noexcept -> T& { return data_[n]; }
+};
+
+template <>
+struct [[gnu::non_owning]] Span<int> {
+    int* data_;
+    int len_;
+    ~Span();
+
+    [[nodiscard]] constexpr auto operator[](int n) const noexcept -> int& { return data_[n]; }
+};
+
+auto getch() -> Span<char>;
+auto geti() -> Span<int>;
+
+void
+f ()
+{
+  [[maybe_unused]] const auto &a = getch()[0];	// { dg-warning "dangling reference" }
+  [[maybe_unused]] const auto &b = geti()[0];   // { dg-bogus "dangling reference" }
+}
diff --git a/gcc/testsuite/g++.dg/ext/attr-non-owning6.C b/gcc/testsuite/g++.dg/ext/attr-non-owning6.C
new file mode 100644
index 00000000000..10ce1842852
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/attr-non-owning6.C
@@ -0,0 +1,65 @@
+// PR c++/110358
+// { dg-do compile { target c++20 } }
+// { dg-options "-Wdangling-reference" }
+
+class X { };
+const X x1;
+const X x2;
+
+constexpr bool val () { return true; }
+struct ST { static constexpr bool value = true; };
+struct SF { static constexpr bool value = false; };
+
+template<typename T>
+[[gnu::non_owning(T::value)]]
+const X& get (const int& i)
+{
+   return i == 0 ? x1 : x2;
+}
+
+template<bool B = true>
+[[gnu::non_owning(B)]]
+const X& foo (const int& i)
+{
+   return i == 0 ? x1 : x2;
+}
+
+[[gnu::non_owning(val ())]]
+const X& bar (const int& i)
+{
+   return i == 0 ? x1 : x2;
+}
+
+[[gnu::non_owning(!val ())]]
+const X& baz (const int& i)
+{
+   return i == 0 ? x1 : x2;
+}
+
+template <typename T>
+struct [[gnu::non_owning(T::value)]]
+Span {
+    T* data_;
+    int len_;
+    ~Span();
+
+    [[nodiscard]] constexpr auto operator[](int n) const noexcept -> T& { return data_[n]; }
+};
+
+auto geti() -> Span<ST>;
+auto gety() -> Span<SF>;
+
+void
+test ()
+{
+  [[maybe_unused]] const X& x1 = get<ST> (10);	  // { dg-bogus "dangling" }
+  [[maybe_unused]] const X& x2 = get<SF> (10);	  // { dg-warning "dangling" }
+  [[maybe_unused]] const X& x3 = foo<true> (10);  // { dg-bogus "dangling" }
+  [[maybe_unused]] const X& x4 = foo<false> (10); // { dg-warning "dangling" }
+  [[maybe_unused]] const X& x7 = foo<> (10);	  // { dg-bogus "dangling" }
+  [[maybe_unused]] const X& x5 = bar (10);	  // { dg-bogus "dangling" }
+  [[maybe_unused]] const X& x6 = baz (10);	  // { dg-warning "dangling" }
+
+  [[maybe_unused]] const auto &b1 = geti()[0];	  // { dg-bogus "dangling" }
+  [[maybe_unused]] const auto &b2 = gety()[0];	  // { dg-warning "dangling" }
+}
diff --git a/gcc/testsuite/g++.dg/ext/attr-non-owning7.C b/gcc/testsuite/g++.dg/ext/attr-non-owning7.C
new file mode 100644
index 00000000000..bba69871918
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/attr-non-owning7.C
@@ -0,0 +1,31 @@
+// PR c++/110358
+// { dg-do compile { target c++20 } }
+// { dg-options "-Wdangling-reference" }
+
+class X { };
+const X x1;
+const X x2;
+
+template<bool... N>
+[[gnu::non_owning(N)]] const X& get(const int& i); // { dg-error "parameter packs not expanded" }
+
+template<typename T>
+[[gnu::non_owning(T::x)]] // { dg-error "member" }
+const X& foo(const int& i);
+
+bool val () { return true; }
+
+[[gnu::non_owning(val ())]]   // { dg-error "call" }
+const X& bar (const int& i);
+
+[[gnu::non_owning(20)]] const X& fn1 (const int &);
+
+void
+test ()
+{
+  [[maybe_unused]] const X& x1 = bar (10);	  // { dg-warning "dangling" }
+  [[maybe_unused]] const X& x2 = foo<int> (10);	  // { dg-error "no matching" }
+  [[maybe_unused]] const X& x3			  // { dg-warning "dangling" }
+    = fn1 (10);					  // { dg-error "narrowing" }
+}
+
diff --git a/gcc/testsuite/g++.dg/ext/attr-non-owning8.C b/gcc/testsuite/g++.dg/ext/attr-non-owning8.C
new file mode 100644
index 00000000000..1bfed4ed33c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/attr-non-owning8.C
@@ -0,0 +1,30 @@
+// PR c++/110358
+// { dg-do compile { target c++20 } }
+// { dg-options "-Wdangling-reference" }
+
+template<class T> constexpr bool is_reference_v = false;
+template<class T> constexpr bool is_reference_v<T&> = true;
+template<class T> constexpr bool is_reference_v<T&&> = true;
+
+template <typename T>
+struct [[gnu::non_owning(is_reference_v<T>)]] S {
+  int &foo (const int &);
+};
+
+template <typename T1, typename T2>
+struct X {
+  template <typename U1 = T1, typename U2 = T2>
+  struct [[gnu::non_owning(is_reference_v<U1> && is_reference_v<U2>)]] Y {
+    int &foo (const int &);
+  };
+};
+
+void
+g ()
+{
+  [[maybe_unused]] const int &x0 = S<int&>().foo (42);  // { dg-bogus "dangling" }
+  [[maybe_unused]] const int &x1 = S<int>().foo (42);   // { dg-warning "dangling" }
+  [[maybe_unused]] const auto &x2 = X<int, int&>::Y<>().foo (42); // { dg-warning "dangling" }
+  [[maybe_unused]] const auto &x3 = X<int&, int&>::Y<>().foo (42); // { dg-bogus "dangling" }
+}
+
diff --git a/gcc/testsuite/g++.dg/ext/attr-non-owning9.C b/gcc/testsuite/g++.dg/ext/attr-non-owning9.C
new file mode 100644
index 00000000000..6f6a72736ce
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/attr-non-owning9.C
@@ -0,0 +1,25 @@
+// PR c++/110358
+// { dg-do compile { target c++20 } }
+// { dg-options "-Wdangling-reference" }
+
+template<bool B>
+struct bool_constant {
+  static constexpr bool value = B;
+  constexpr operator bool() const { return value; }
+};
+
+using true_type = bool_constant<true>;
+using false_type = bool_constant<false>;
+
+struct S {
+  template<bool B>
+  [[gnu::non_owning(B)]] int &foo (const int &);
+};
+
+void
+g ()
+{
+  [[maybe_unused]] const int &x0 = S().foo<false_type{}> (42);  // { dg-warning "dangling" }
+  [[maybe_unused]] const int &x1 = S().foo<true_type{}> (42);  // { dg-bogus "dangling" }
+}
+
