Implements multiline regex support

[Mordante]

Summary

It implements the multiline support as described at https://wg21.link/LWG2503

[mclow.lists]

To keep the code easier to read, I would be tempted to remove almost all of the #ifdefs here, and just make __use_multiline and the constants depend on the language level.
[ Note that I haven't tried this; just looking to make the code simpler. ]

[mclow.lists]

libcxx/include/regex

2008

I think that this is going to have to go behind an "ABI break" flag, because it changes the size of __l_anchor. I'll look into it some more.

[mclow.lists]

Note: Since this was resolved by an LWG issue (rather than a paper), we should provide this capability back to C++11.
(So you can get rid of all the #ifdefs

[Mordante]

Thanks for the review.

Once it's known whether or not the __l_anchor changes are an ABI break I'll update the patch.
Is there a way to test what is and what is not an ABI break?

[Mordante]

@mclow.lists, @ldionne is the change of the size of __l_anchor an ABI break?

[ldionne]

In D63059#1915624, @Mordante wrote:

@mclow.lists, @ldionne is the change of the size of __l_anchor an ABI break?

Yes, I think it is. Imagine a program compiled with an old version of libc++ (which assumes that __l_anchor doesn't have a bool) which creates a regex with a __l_anchor node in it, and then passes that regex to a shared library that was compiled with the new headers (which assumes __l_anchor has a bool). The new library will try to read the field which doesn't exist. This can be a problem because the <regex> code is free to be inlined into users programs and libraries too.

If we added a new derived class instead, I think this could solve our problem. Indeed, __l_anchor would stay unchanged, however we could have something like a __multiline_l_anchor?

The other option is that we just take that ABI break. Do we have a way of quantifying how bad it would be? What regexes would be impacted? Is it regexes with ^ or $ used as anchors, passed through ABI boundaries? If we want to go down this route, we could also try to see what the extent of the ABI break is, i.e. if we tend to crash it's better than if we silently run and do something weird.

[Mordante]

Thanks for the confirmation it's an ABI break. I like your suggestion to use a derived class, so I'll try that solution first.

[ldionne]

In D63059#1920398, @Mordante wrote:

Thanks for the confirmation it's an ABI break. I like your suggestion to use a derived class, so I'll try that solution first.

I'm not 100% sure that solution addresses the ABI break problem, though. I'd have to think about it harder and run it through at least another person to be confident.

Can you comment on that:

Do we have a way of quantifying how bad it would be? What regexes would be impacted? Is it regexes with ^ or $ used as anchors, passed through ABI boundaries?

If that's an ABI break we can afford to make, it would be great cause it would avoid increasing the code complexity.

[Mordante]

In D63059#1920509, @ldionne wrote:

In D63059#1920398, @Mordante wrote:

Thanks for the confirmation it's an ABI break. I like your suggestion to use a derived class, so I'll try that solution first.

I'm not 100% sure that solution addresses the ABI break problem, though. I'd have to think about it harder and run it through at least another person to be confident.

I'll update the diff with this approach in a sec.

Can you comment on that:

Do we have a way of quantifying how bad it would be? What regexes would be impacted? Is it regexes with ^ or $ used as anchors, passed through ABI boundaries?

Yes it requires a regex with a ^ or $ anchor. It should only break if created with the old version (no bool in the struct) and executed by the new version (with a bool in the struct)

If that's an ABI break we can afford to make, it would be great cause it would avoid increasing the code complexity.

Googling/looking in GitHub is hard since it ignores special characters. I searched on https://codesearch.debian.net
and found 318 hits looking for std::regex("^ 205 were in the llvm projects so about 100 in other projects.
Looking at std::regex\(".*\$ found 309 matches with 177 in the llvm projects. This regex hit some false positives.

So at least in Debian it is not used that often. So we have 3 options:

1. Use the version with inheritance if ABI safe. Pro no #ifdefs, Con adds some 'dead code' for ABI compatibility
2. Replace #if _LIBCPP_STD_VER > 14 of the current patch with an ABI flag. Pro ABI compatible, Con adds a lot if #ifdefs
3. Break the ABI, Pro cleanest code, Con an ABI breakage

If 1 is ABI safe I would prefer that option, else I would slightly prefer to avoid an ABI breakage.

What's your opinion?

[Mordante]

Implements the multiline using a derived class.

[ldionne]

libcxx/include/regex

2105

To avoid code duplication, we could create a helper function that takes a bool __multiline parameter. Then, __r_anchor_multiline<_CharT>::__exec would call that helper function with __multiline as an argument, and __r_anchor<_CharT>::__exec would call the helper function with false.

4787

Do we ever create a __l_anchor anymore? If not, then we could in theory delete that code. Actually, now that I think of it, I believe we could simply add the functionality to __l_anchor itself, but rename the class to something else. The idea is:

• No new code needs to use __l_anchor, it can all start using the new class
• Existing code using __l_anchor already has a vtable for __l_anchor, and that contains the old implementation of execute they need to keep using to avoid and ABI break.

I believe the ABI break only happens if we change __l_anchor::execute without changing the name of the class, since that's when two libraries compiled at different times (and hence with different versions of __l_anchor) can disagree on the layout of __l_anchor. If we change the name of the class, I think it should all work out.

WDYT?

[Mordante]

libcxx/include/regex

2105

That's indeed possible. I can create an updated patch with that approach.
(Before updating I want to look what approach we take regarding your comments on __l_anchor.)

4787

No after this change we'll never create a __l_anchor. I expected removing the __l_anchor class from the header would be an ABI break. But I think you're right since this is a templated class. So that means I:

• Let the __l_anchor_multiline directly inherit from __owns_one_state<_CharT>
• Remove the __l_anchor class
• Do the same for the 'right' part and thus don't need the helper function as suggested before

Agreed?

[Mordante]

libcxx/include/regex

4787

@ldionne Do you agree with the proposed approach?

[ldionne]

libcxx/include/regex

4787

Sorry this got dropped. Yes, we agree on the approach.

Regarding

No after this change we'll never create a l_anchor. I expected removing the l_anchor class from the header would be an ABI break. But I think you're right since this is a templated class. [...]

My reasoning is that since it's a class template that isn't explicitly instantiated in and exported from the dylib, any code that references __l_anchor already has a weak definition for the vtable. It needs to, because that vtable isn't defined anywhere else the linker can tell upfront.

So, just removing that class from the headers isn't going to break anything, because

1. already-compiled code already has the definitions it needs, and
2. we're not changing an existing definition to do something incompatible (since we're introducing a new one).

ABIs are tricky, so I hope I'm not missing something. But if my reasoning holds, your approach LGTM. Let's go with that.

[Mordante]

• Removed __[rl]_anchor
• Changed __is_eol to use _LIBCPP_INLINE_VISIBILITY

[Mordante]

libcxx/include/regex

4787

Thanks for the explanation.

[ldionne]

LGTM, thanks a lot for this! Consider my comment about the comments you left behind, but feel free to commit without implementing my suggestion.

I don't understand why CI isn't running -- it seems to be doing that with a few patches. If you commit this, can you please keep an eye on https://buildkite.com/llvm-project/libcxx-ci/builds?branch=master for the next build?

libcxx/include/regex

1995

I don't think this comment is relevant, since __l_anchor doesn't exist anymore. I feel like questions of this nature can be answered best via git blame and following the link back to this review. If you feel strongly that it adds value, please feel free to leave it in.

2041

Ditto.

[Mordante]

Thanks for the review!

In D63059#2400880, @ldionne wrote:

LGTM, thanks a lot for this! Consider my comment about the comments you left behind, but feel free to commit without implementing my suggestion.

I'll remove them.

I don't understand why CI isn't running -- it seems to be doing that with a few patches. If you commit this, can you please keep an eye on https://buildkite.com/llvm-project/libcxx-ci/builds?branch=master for the next build?

I'll keep an eye on the build bot.
I update the patches in the review using Phabricator's web-interface. Can the fact that I don't use arc be the reason the CI builds aren't triggered?

[ldionne]

In D63059#2403131, @Mordante wrote:

I'll keep an eye on the build bot.
I update the patches in the review using Phabricator's web-interface. Can the fact that I don't use arc be the reason the CI builds aren't triggered?

I think that's most likely it. It seems like CI isn't triggered when the repository isn't set on the review. I think Mikhail is looking into it. Don't worry about it.

[Mordante]

This has landed as https://github.com/llvm/llvm-project/commit/3abaf6cde7a92f38db2f5b3cb87e653f89f3bd26

libcxx/include/regex

enum syntax_option_type
     nosubs     = unspecified,
     optimize   = unspecified,
     collate    = unspecified,
     ECMAScript = unspecified,
     basic      = unspecified,
     extended   = unspecified,
     awk        = unspecified,
     grep       = unspecified,
-    egrep      = unspecified
+    egrep      = unspecified,
+    multiline  = unspecified
 };
 
 constexpr syntax_option_type operator~(syntax_option_type f);
 constexpr syntax_option_type operator&(syntax_option_type lhs, syntax_option_type rhs);
 constexpr syntax_option_type operator|(syntax_option_type lhs, syntax_option_type rhs);
 
 enum match_flag_type
 {
public:
     static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize;
     static constexpr regex_constants::syntax_option_type collate = regex_constants::collate;
     static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
     static constexpr regex_constants::syntax_option_type basic = regex_constants::basic;
     static constexpr regex_constants::syntax_option_type extended = regex_constants::extended;
     static constexpr regex_constants::syntax_option_type awk = regex_constants::awk;
     static constexpr regex_constants::syntax_option_type grep = regex_constants::grep;
     static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep;
+    static constexpr regex_constants::syntax_option_type multiline = regex_constants::multiline;
 
     // construct/copy/destroy:
     basic_regex();
     explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
     basic_regex(const charT* p, size_t len, flag_type f = regex_constants::ECMAScript);
     basic_regex(const basic_regex&);
     basic_regex(basic_regex&&) noexcept;
     template <class ST, class SA>
#ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
     ECMAScript = 1 << 9,
 #else
     ECMAScript = 0,
 #endif
     basic      = 1 << 4,
     extended   = 1 << 5,
     awk        = 1 << 6,
     grep       = 1 << 7,
-    egrep      = 1 << 8
+    egrep      = 1 << 8,
+    // 1 << 9 may be used by ECMAScript
+    multiline  = 1 << 10
 };
 
 inline _LIBCPP_CONSTEXPR
 syntax_option_type __get_grammar(syntax_option_type __g)
 {
 #ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
     return static_cast<syntax_option_type>(__g & 0x3F0);
 #else
else
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __l_anchor
 
 template <class _CharT>
-class __l_anchor
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+bool __is_eol(_CharT c)
+{
+    return c == '\r' || c == '\n';
+}
+
+// LWG-2503 Added the multiline flag. In order to avoid an ABI break the
+// __l_anchor has not been modified, it has been replaced with a new class.
+template <class _CharT>
+class __l_anchor_multiline
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
+    bool __multiline;
+
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
-    __l_anchor(__node<_CharT>* __s)
-        : base(__s) {}
+    __l_anchor_multiline(bool __multiline, __node<_CharT>* __s)
+        : base(__s), __multiline(__multiline) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
-__l_anchor<_CharT>::__exec(__state& __s) const
+__l_anchor_multiline<_CharT>::__exec(__state& __s) const
 {
     if (__s.__at_first_ && __s.__current_ == __s.__first_ &&
         !(__s.__flags_ & regex_constants::match_not_bol))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
+    else if (__multiline &&
+             !__s.__at_first_ &&
+             __is_eol(*_VSTD::prev(__s.__current_)))
+    {
+        __s.__do_ = __state::__accept_but_not_consume;
+        __s.__node_ = this->first();
+    }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __r_anchor
 
+// LWG-2503 Added the multiline flag. In order to avoid an ABI break the
+// __r_anchor has not been modified, it has been replaced with a new class.
 template <class _CharT>
-class __r_anchor
+class __r_anchor_multiline
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
+    bool __multiline;
+
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
-    __r_anchor(__node<_CharT>* __s)
-        : base(__s) {}
+    __r_anchor_multiline(bool __multiline, __node<_CharT>* __s)
+        : base(__s), __multiline(__multiline) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
-__r_anchor<_CharT>::__exec(__state& __s) const
+__r_anchor_multiline<_CharT>::__exec(__state& __s) const
 {
     if (__s.__current_ == __s.__last_ &&
         !(__s.__flags_ & regex_constants::match_not_eol))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
+    else if (__multiline && __is_eol(*__s.__current_))
+    {
+        __s.__do_ = __state::__accept_but_not_consume;
+        __s.__node_ = this->first();
+    }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;
     }
 }
 
 // __match_any
public:
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __match_any<_CharT>::__exec(__state& __s) const
 {
     if (__s.__current_ != __s.__last_ && *__s.__current_ != 0)
     {
         __s.__do_ = __state::__accept_and_consume;
         ++__s.__current_;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
public:
     static const regex_constants::syntax_option_type optimize = regex_constants::optimize;
     static const regex_constants::syntax_option_type collate = regex_constants::collate;
     static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
     static const regex_constants::syntax_option_type basic = regex_constants::basic;
     static const regex_constants::syntax_option_type extended = regex_constants::extended;
     static const regex_constants::syntax_option_type awk = regex_constants::awk;
     static const regex_constants::syntax_option_type grep = regex_constants::grep;
     static const regex_constants::syntax_option_type egrep = regex_constants::egrep;
+    static const regex_constants::syntax_option_type multiline = regex_constants::multiline;
 
     // construct/copy/destroy:
     _LIBCPP_INLINE_VISIBILITY
     basic_regex()
         : __flags_(regex_constants::ECMAScript), __marked_count_(0), __loop_count_(0), __open_count_(0),
           __end_(0)
         {}
     _LIBCPP_INLINE_VISIBILITY
#endif  // _LIBCPP_CXX03_LANG
 
     // swap:
     void swap(basic_regex& __r);
 
 private:
     _LIBCPP_INLINE_VISIBILITY
     unsigned __loop_count() const {return __loop_count_;}
 
+    _LIBCPP_INLINE_VISIBILITY
+    bool __use_multiline() const
+    {
+        return __get_grammar(__flags_) == ECMAScript && (__flags_ & multiline);
+    }
+
     template <class _ForwardIterator>
         void
         __init(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
         __parse(_ForwardIterator __first, _ForwardIterator __last);
     template <class _ForwardIterator>
         _ForwardIterator
if (!(__flags_ & nosubs))
         __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
     }
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_l_anchor()
 {
-    __end_->first() = new __l_anchor<_CharT>(__end_->first());
+    __end_->first() = new __l_anchor_multiline<_CharT>(__use_multiline(), __end_->first());
     __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_r_anchor()
 {
-    __end_->first() = new __r_anchor<_CharT>(__end_->first());
+    __end_->first() = new __r_anchor_multiline<_CharT>(__use_multiline(), __end_->first());
     __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_match_any()
 {
     __end_->first() = new __match_any<_CharT>(__end_->first());

libcxx/test/std/re/re.const/re.matchflag/match_multiline.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <regex>
+
+// multiline:
+//     Specifies that ^ shall match the beginning of a line and $ shall match
+//     the end of a line, if the ECMAScript engine is selected.
+
+#include <regex>
+#include <cassert>
+#include "test_macros.h"
+
+static void search(const char* pat, std::regex_constants::syntax_option_type f,
+                   const char* target, bool expected)
+{
+    std::regex re(pat, f);
+    std::cmatch m;
+    assert(std::regex_search(target, m, re) == expected);
+
+    if(expected) {
+        assert(m.size() == 1);
+        assert(m.length(0) == 3);
+        assert(m.str(0) == "foo");
+    }
+    else
+    {
+        assert(m.size() == 0);
+    }
+}
+
+int main(int, char**)
+{
+    using std::regex_constants::ECMAScript;
+    using std::regex_constants::basic;
+    using std::regex_constants::extended;
+    using std::regex_constants::awk;
+    using std::regex_constants::grep;
+    using std::regex_constants::egrep;
+    using std::regex_constants::multiline;
+
+    {
+        const char* pat = "^foo";
+        const char* target = "foo";
+
+        search(pat, ECMAScript, target, true);
+        search(pat, basic, target, true);
+        search(pat, extended, target, true);
+        search(pat, awk, target, true);
+        search(pat, grep, target, true);
+        search(pat, egrep, target, true);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, true);
+        search(pat, extended | multiline, target, true);
+        search(pat, awk | multiline, target, true);
+        search(pat, grep | multiline, target, true);
+        search(pat, egrep | multiline, target, true);
+    }
+    {
+        const char* pat = "^foo";
+        const char* target = "\nfoo";
+
+        search(pat, ECMAScript, target, false);
+        search(pat, basic, target, false);
+        search(pat, extended, target, false);
+        search(pat, awk, target, false);
+        search(pat, grep, target, false);
+        search(pat, egrep, target, false);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, false);
+        search(pat, extended | multiline, target, false);
+        search(pat, awk | multiline, target, false);
+        search(pat, grep | multiline, target, false);
+        search(pat, egrep | multiline, target, false);
+    }
+    {
+        const char* pat = "^foo";
+        const char* target = "bar\nfoo";
+
+        search(pat, ECMAScript, target, false);
+        search(pat, basic, target, false);
+        search(pat, extended, target, false);
+        search(pat, awk, target, false);
+        search(pat, grep, target, false);
+        search(pat, egrep, target, false);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, false);
+        search(pat, extended | multiline, target, false);
+        search(pat, awk | multiline, target, false);
+        search(pat, grep | multiline, target, false);
+        search(pat, egrep | multiline, target, false);
+    }
+
+    {
+        const char* pat = "foo$";
+        const char* target = "foo";
+
+        search(pat, ECMAScript, target, true);
+        search(pat, basic, target, true);
+        search(pat, extended, target, true);
+        search(pat, awk, target, true);
+        search(pat, grep, target, true);
+        search(pat, egrep, target, true);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, true);
+        search(pat, extended | multiline, target, true);
+        search(pat, awk | multiline, target, true);
+        search(pat, grep | multiline, target, true);
+        search(pat, egrep | multiline, target, true);
+    }
+    {
+        const char* pat = "foo$";
+        const char* target = "foo\n";
+
+        search(pat, ECMAScript, target, false);
+        search(pat, basic, target, false);
+        search(pat, extended, target, false);
+        search(pat, awk, target, false);
+        search(pat, grep, target, false);
+        search(pat, egrep, target, false);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, false);
+        search(pat, extended | multiline, target, false);
+        search(pat, awk | multiline, target, false);
+        search(pat, grep | multiline, target, false);
+        search(pat, egrep | multiline, target, false);
+    }
+    {
+        const char* pat = "foo$";
+        const char* target = "foo\nbar";
+
+        search(pat, ECMAScript, target, false);
+        search(pat, basic, target, false);
+        search(pat, extended, target, false);
+        search(pat, awk, target, false);
+        search(pat, grep, target, false);
+        search(pat, egrep, target, false);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, false);
+        search(pat, extended | multiline, target, false);
+        search(pat, awk | multiline, target, false);
+        search(pat, grep | multiline, target, false);
+        search(pat, egrep | multiline, target, false);
+    }
+
+
+    {
+        const char* pat = "^foo";
+        const char* target = "foo";
+
+        search(pat, ECMAScript, target, true);
+        search(pat, basic, target, true);
+        search(pat, extended, target, true);
+        search(pat, awk, target, true);
+        search(pat, grep, target, true);
+        search(pat, egrep, target, true);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, true);
+        search(pat, extended | multiline, target, true);
+        search(pat, awk | multiline, target, true);
+        search(pat, grep | multiline, target, true);
+        search(pat, egrep | multiline, target, true);
+    }
+    {
+        const char* pat = "^foo";
+        const char* target = "\rfoo";
+
+        search(pat, ECMAScript, target, false);
+        search(pat, basic, target, false);
+        search(pat, extended, target, false);
+        search(pat, awk, target, false);
+        search(pat, grep, target, false);
+        search(pat, egrep, target, false);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, false);
+        search(pat, extended | multiline, target, false);
+        search(pat, awk | multiline, target, false);
+        search(pat, grep | multiline, target, false);
+        search(pat, egrep | multiline, target, false);
+    }
+    {
+        const char* pat = "^foo";
+        const char* target = "bar\rfoo";
+
+        search(pat, ECMAScript, target, false);
+        search(pat, basic, target, false);
+        search(pat, extended, target, false);
+        search(pat, awk, target, false);
+        search(pat, grep, target, false);
+        search(pat, egrep, target, false);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, false);
+        search(pat, extended | multiline, target, false);
+        search(pat, awk | multiline, target, false);
+        search(pat, grep | multiline, target, false);
+        search(pat, egrep | multiline, target, false);
+    }
+
+    {
+        const char* pat = "foo$";
+        const char* target = "foo";
+
+        search(pat, ECMAScript, target, true);
+        search(pat, basic, target, true);
+        search(pat, extended, target, true);
+        search(pat, awk, target, true);
+        search(pat, grep, target, true);
+        search(pat, egrep, target, true);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, true);
+        search(pat, extended | multiline, target, true);
+        search(pat, awk | multiline, target, true);
+        search(pat, grep | multiline, target, true);
+        search(pat, egrep | multiline, target, true);
+    }
+    {
+        const char* pat = "foo$";
+        const char* target = "foo\r";
+
+        search(pat, ECMAScript, target, false);
+        search(pat, basic, target, false);
+        search(pat, extended, target, false);
+        search(pat, awk, target, false);
+        search(pat, grep, target, false);
+        search(pat, egrep, target, false);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, false);
+        search(pat, extended | multiline, target, false);
+        search(pat, awk | multiline, target, false);
+        search(pat, grep | multiline, target, false);
+        search(pat, egrep | multiline, target, false);
+    }
+    {
+        const char* pat = "foo$";
+        const char* target = "foo\rbar";
+
+        search(pat, ECMAScript, target, false);
+        search(pat, basic, target, false);
+        search(pat, extended, target, false);
+        search(pat, awk, target, false);
+        search(pat, grep, target, false);
+        search(pat, egrep, target, false);
+
+        search(pat, ECMAScript | multiline, target, true);
+        search(pat, basic | multiline, target, false);
+        search(pat, extended | multiline, target, false);
+        search(pat, awk | multiline, target, false);
+        search(pat, grep | multiline, target, false);
+        search(pat, egrep | multiline, target, false);
+    }
+
+    return 0;
+}

libcxx/test/std/re/re.const/re.synopt/syntax_option_type.pass.cpp

 //     nosubs     = unspecified,
 //     optimize   = unspecified,
 //     collate    = unspecified,
 //     ECMAScript = unspecified,
 //     basic      = unspecified,
 //     extended   = unspecified,
 //     awk        = unspecified,
 //     grep       = unspecified,
-//     egrep      = unspecified
+//     egrep      = unspecified,
+//     multiline  = unspecified
 // };
 //
 // }
 
 #include <regex>
 #include <cassert>
 #include "test_macros.h"
 
 int main(int, char**)
 {
     assert(std::regex_constants::icase != 0);
     assert(std::regex_constants::nosubs != 0);
     assert(std::regex_constants::optimize != 0);
     assert(std::regex_constants::collate != 0);
 #ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO  // https://bugs.llvm.org/show_bug.cgi?id=35967
     assert(std::regex_constants::ECMAScript != 0);
 #else
     assert(std::regex_constants::ECMAScript == 0);
 #endif
     assert(std::regex_constants::basic != 0);
     assert(std::regex_constants::extended != 0);
     assert(std::regex_constants::awk != 0);
     assert(std::regex_constants::grep != 0);
     assert(std::regex_constants::egrep != 0);
+    assert(std::regex_constants::multiline != 0);
 
     assert((std::regex_constants::icase & std::regex_constants::nosubs) == 0);
     assert((std::regex_constants::icase & std::regex_constants::optimize) == 0);
     assert((std::regex_constants::icase & std::regex_constants::collate) == 0);
     assert((std::regex_constants::icase & std::regex_constants::ECMAScript) == 0);
     assert((std::regex_constants::icase & std::regex_constants::basic) == 0);
     assert((std::regex_constants::icase & std::regex_constants::extended) == 0);
     assert((std::regex_constants::icase & std::regex_constants::awk) == 0);
     assert((std::regex_constants::icase & std::regex_constants::grep) == 0);
     assert((std::regex_constants::icase & std::regex_constants::egrep) == 0);
+    assert((std::regex_constants::icase & std::regex_constants::multiline) == 0);
 
     assert((std::regex_constants::nosubs & std::regex_constants::optimize) == 0);
     assert((std::regex_constants::nosubs & std::regex_constants::collate) == 0);
     assert((std::regex_constants::nosubs & std::regex_constants::ECMAScript) == 0);
     assert((std::regex_constants::nosubs & std::regex_constants::basic) == 0);
     assert((std::regex_constants::nosubs & std::regex_constants::extended) == 0);
     assert((std::regex_constants::nosubs & std::regex_constants::awk) == 0);
     assert((std::regex_constants::nosubs & std::regex_constants::grep) == 0);
     assert((std::regex_constants::nosubs & std::regex_constants::egrep) == 0);
+    assert((std::regex_constants::nosubs & std::regex_constants::multiline) == 0);
 
     assert((std::regex_constants::optimize & std::regex_constants::collate) == 0);
     assert((std::regex_constants::optimize & std::regex_constants::ECMAScript) == 0);
     assert((std::regex_constants::optimize & std::regex_constants::basic) == 0);
     assert((std::regex_constants::optimize & std::regex_constants::extended) == 0);
     assert((std::regex_constants::optimize & std::regex_constants::awk) == 0);
     assert((std::regex_constants::optimize & std::regex_constants::grep) == 0);
     assert((std::regex_constants::optimize & std::regex_constants::egrep) == 0);
+    assert((std::regex_constants::optimize & std::regex_constants::multiline) == 0);
 
     assert((std::regex_constants::collate & std::regex_constants::ECMAScript) == 0);
     assert((std::regex_constants::collate & std::regex_constants::basic) == 0);
     assert((std::regex_constants::collate & std::regex_constants::extended) == 0);
     assert((std::regex_constants::collate & std::regex_constants::awk) == 0);
     assert((std::regex_constants::collate & std::regex_constants::grep) == 0);
     assert((std::regex_constants::collate & std::regex_constants::egrep) == 0);
+    assert((std::regex_constants::collate & std::regex_constants::multiline) == 0);
 
     assert((std::regex_constants::ECMAScript & std::regex_constants::basic) == 0);
     assert((std::regex_constants::ECMAScript & std::regex_constants::extended) == 0);
     assert((std::regex_constants::ECMAScript & std::regex_constants::awk) == 0);
     assert((std::regex_constants::ECMAScript & std::regex_constants::grep) == 0);
     assert((std::regex_constants::ECMAScript & std::regex_constants::egrep) == 0);
+    assert((std::regex_constants::ECMAScript & std::regex_constants::multiline) == 0);
 
     assert((std::regex_constants::basic & std::regex_constants::extended) == 0);
     assert((std::regex_constants::basic & std::regex_constants::awk) == 0);
     assert((std::regex_constants::basic & std::regex_constants::grep) == 0);
     assert((std::regex_constants::basic & std::regex_constants::egrep) == 0);
+    assert((std::regex_constants::basic & std::regex_constants::multiline) == 0);
 
     assert((std::regex_constants::extended & std::regex_constants::awk) == 0);
     assert((std::regex_constants::extended & std::regex_constants::grep) == 0);
     assert((std::regex_constants::extended & std::regex_constants::egrep) == 0);
+    assert((std::regex_constants::extended & std::regex_constants::multiline) == 0);
 
     assert((std::regex_constants::awk & std::regex_constants::grep) == 0);
     assert((std::regex_constants::awk & std::regex_constants::egrep) == 0);
+    assert((std::regex_constants::awk & std::regex_constants::multiline) == 0);
 
     assert((std::regex_constants::grep & std::regex_constants::egrep) == 0);
+    assert((std::regex_constants::grep & std::regex_constants::multiline) == 0);
+
+    assert((std::regex_constants::egrep & std::regex_constants::multiline) == 0);
 
     assert((std::regex_constants::icase | std::regex_constants::nosubs) != 0);
     assert((std::regex_constants::icase ^ std::regex_constants::nosubs) != 0);
 
     std::regex_constants::syntax_option_type e1 = std::regex_constants::icase;
     std::regex_constants::syntax_option_type e2 = std::regex_constants::nosubs;
     e1 = ~e1;
     e1 = e1 & e2;
     e1 = e1 | e2;
     e1 = e1 ^ e2;
     e1 &= e2;
     e1 |= e2;
     e1 ^= e2;
 
   return 0;
 }

libcxx/www/cxx1z_status.html

<!--   <I>Note: "NAD" means that the issue was deemed "Not a defect"</I> -->
   <tr><td><a href="https://wg21.link/LWG2166">2166</a></td><td>Heap property underspecified?</td><td>Issaquah</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG2221">2221</a></td><td>No formatted output operator for nullptr</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2223">2223</a></td><td>shrink_to_fit effect on iterator validity</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2261">2261</a></td><td>Are containers required to use their 'pointer' type internally?</td><td>Issaquah</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG2394">2394</a></td><td>locale::name specification unclear - what is implementation-defined?</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2460">2460</a></td><td>LWG issue 2408 and value categories</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2468">2468</a></td><td>Self-move-assignment of library types</td><td>Issaquah</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG2475">2475</a></td><td>Allow overwriting of std::basic_string terminator with charT() to allow cleaner interoperation with legacy APIs</td><td>Issaquah</td><td>Complete</td></tr>
-  <tr><td><a href="https://wg21.link/LWG2503">2503</a></td><td>multiline option should be added to syntax_option_type</td><td>Issaquah</td><td></td></tr>
+  <tr><td><a href="https://wg21.link/LWG2503">2503</a></td><td>multiline option should be added to syntax_option_type</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2510">2510</a></td><td>Tag types should not be DefaultConstructible</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2514">2514</a></td><td>Type traits must not be final</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2518">2518</a></td><td>[fund.ts.v2] Non-member swap for propagate_const should call member swap</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2519">2519</a></td><td>Iterator operator-= has gratuitous undefined behaviour</td><td>Issaquah</td><td>Complete</td></tr>
   <tr><td><a href="https://wg21.link/LWG2521">2521</a></td><td>[fund.ts.v2] weak_ptr's converting move constructor should be modified as well for array support</td><td>Issaquah</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG2525">2525</a></td><td>[fund.ts.v2] get_memory_resource should be const and noexcept</td><td>Issaquah</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG2527">2527</a></td><td>[fund.ts.v2] ALLOCATOR_OF for function::operator= has incorrect default</td><td>Issaquah</td><td></td></tr>
   <tr><td><a href="https://wg21.link/LWG2531">2531</a></td><td>future::get should explicitly state that the shared state is released</td><td>Issaquah</td><td></td></tr>
<!--   <I>Note: "NAD" means that the issue was deemed "Not a defect"</I> -->
   <tr><td><a href="https://wg21.link/LWG2956">2956</a></td><td><tt>filesystem::canonical()</tt> still defined in terms of <tt>absolute(p, base)</tt></td><td>Toronto</td><td>Complete</td></tr>
 
 <!--
   <tr><td><a href="https://wg21.link/LWG1214">1214</a></td><td>Insufficient/inconsistent key immutability requirements for associative containers</td><td>Urbana</td><td></td></tr>
 -->
 <!--   <tr><td></td><td></td><td></td><td></td></tr> -->
   </table>
 
-  <p>Last Updated: 3-Jul-2019</p>
+  <p>Last Updated: 17-Nov-2020</p>
 </div>
 </body>
 </html>