morganstanley / binlog Goto Github PK

[ 20%] Building CXX object CMakeFiles/UnitTest.dir/test/unit/mserialize/roundtrip.cpp.o
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/c++  -DBOOST_ALL_DYN_LINK -DBOOST_ALL_NO_LIB -DBOOST_TEST_NO_MAIN -DBOOST_UNIT_TEST_FRAMEWORK_DYN_LINK -I/tmp/build/binlog/bin -I/tmp/build/binlog/include -isystem /usr/local/include  -O2 -g -DNDEBUG -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.15.sdk   -Wall -Wextra -Werror -pedantic -Wconversion -Wsign-conversion -Wold-style-cast -Wshadow -std=c++14 -o CMakeFiles/UnitTest.dir/test/unit/mserialize/roundtrip.cpp.o -c /tmp/build/binlog/test/unit/mserialize/roundtrip.cpp
In file included from /tmp/build/binlog/test/unit/mserialize/roundtrip.cpp:6:
In file included from /tmp/build/binlog/include/mserialize/serialize.hpp:4:
/tmp/build/binlog/include/mserialize/detail/Serializer.hpp:39:5: error: static_assert failed due to requirement
      'always_false<std::__1::__bit_const_reference<std::__1::vector<bool, std::__1::allocator<bool> > > >::value' "T is not serializable"
    static_assert(always_false<T>::value, "T is not serializable");
    ^             ~~~~~~~~~~~~~~~~~~~~~~
/tmp/build/binlog/include/mserialize/serialize.hpp:34:32: note: in instantiation of function template specialization
      'mserialize::detail::BuiltinSerializer<std::__1::__bit_const_reference<std::__1::vector<bool, std::__1::allocator<bool> > >, void>::serialize<OutputStream>'
      requested here
  detail::Serializer<T>::type::serialize(in, ostream);
                               ^
/tmp/build/binlog/include/mserialize/detail/Serializer.hpp:133:19: note: in instantiation of function template specialization
      'mserialize::serialize<std::__1::__bit_const_reference<std::__1::vector<bool, std::__1::allocator<bool> > >, OutputStream>' requested here
      mserialize::serialize(elem, ostream);
                  ^
/tmp/build/binlog/include/mserialize/detail/Serializer.hpp:109:5: note: in instantiation of function template specialization
      'mserialize::detail::BuiltinSerializer<std::__1::vector<bool, std::__1::allocator<bool> >, void>::serialize_elems<OutputStream>' requested here
    serialize_elems(is_sequence_batch_serializable<const Sequence>{}, s, size32, ostream);
    ^
/tmp/build/binlog/include/mserialize/serialize.hpp:34:32: note: in instantiation of function template specialization
      'mserialize::detail::BuiltinSerializer<std::__1::vector<bool, std::__1::allocator<bool> >, void>::serialize<OutputStream>' requested here
  detail::Serializer<T>::type::serialize(in, ostream);
                               ^
/tmp/build/binlog/test/unit/mserialize/roundtrip.cpp:45:15: note: in instantiation of function template specialization 'mserialize::serialize<std::__1::vector<bool,
      std::__1::allocator<bool> >, OutputStream>' requested here
  mserialize::serialize(in, ostream);
              ^
/tmp/build/binlog/test/unit/mserialize/roundtrip.cpp:279:3: note: in instantiation of function template specialization '(anonymous
      namespace)::roundtrip_into<std::__1::vector<bool, std::__1::allocator<bool> >, std::__1::vector<bool, std::__1::allocator<bool> > >' requested here
  roundtrip_into(in, out);
  ^
In file included from /tmp/build/binlog/test/unit/mserialize/roundtrip.cpp:6:
In file included from /tmp/build/binlog/include/mserialize/serialize.hpp:4:
/tmp/build/binlog/include/mserialize/detail/Serializer.hpp:44:5: error: static_assert failed due to requirement
      'always_false<std::__1::__bit_const_reference<std::__1::vector<bool, std::__1::allocator<bool> > > >::value' "T is not serializable"
    static_assert(always_false<T>::value, "T is not serializable");
    ^             ~~~~~~~~~~~~~~~~~~~~~~
/tmp/build/binlog/include/mserialize/serialize.hpp:46:39: note: in instantiation of member function
      'mserialize::detail::BuiltinSerializer<std::__1::__bit_const_reference<std::__1::vector<bool, std::__1::allocator<bool> > >, void>::serialized_size' requested here
  return detail::Serializer<T>::type::serialized_size(in);
                                      ^
/tmp/build/binlog/include/mserialize/detail/Serializer.hpp:156:29: note: in instantiation of function template specialization
      'mserialize::serialized_size<std::__1::__bit_const_reference<std::__1::vector<bool, std::__1::allocator<bool> > > >' requested here
      result += mserialize::serialized_size(elem);
                            ^
/tmp/build/binlog/include/mserialize/detail/Serializer.hpp:121:12: note: in instantiation of member function 'mserialize::detail::BuiltinSerializer<std::__1::vector<bool,
      std::__1::allocator<bool> >, void>::sizeof_elems' requested here
         + sizeof_elems(std::is_arithmetic<sequence_data_t<const Sequence>>{}, s);
           ^
/tmp/build/binlog/include/mserialize/serialize.hpp:46:39: note: in instantiation of member function 'mserialize::detail::BuiltinSerializer<std::__1::vector<bool,
      std::__1::allocator<bool> >, void>::serialized_size' requested here
  return detail::Serializer<T>::type::serialized_size(in);
                                      ^
/tmp/build/binlog/test/unit/mserialize/roundtrip.cpp:48:57: note: in instantiation of function template specialization 'mserialize::serialized_size<std::__1::vector<bool,
      std::__1::allocator<bool> > >' requested here
  BOOST_TEST(std::size_t(stream.tellp()) == mserialize::serialized_size(in));
                                                        ^
/tmp/build/binlog/test/unit/mserialize/roundtrip.cpp:279:3: note: in instantiation of function template specialization '(anonymous
      namespace)::roundtrip_into<std::__1::vector<bool, std::__1::allocator<bool> >, std::__1::vector<bool, std::__1::allocator<bool> > >' requested here
  roundtrip_into(in, out);
  ^
2 errors generated.
make[2]: *** [CMakeFiles/UnitTest.dir/test/unit/mserialize/roundtrip.cpp.o] Error 1
make[1]: *** [CMakeFiles/UnitTest.dir/all] Error 2
make: *** [all] Error 2

CFLAGS += -fsanitize-address-use-after-scope
ASAN_OPTIONS=strict_string_checks=1:detect_stack_use_after_return=1:check_initialization_order=1:strict_init_order=1

class BinLoggerBinary
{
public:
	BinLoggerBinary(std::ostream& binary) :_binary(binary),
		_severity(binlog::Severity::trace),
		_writer(_session),
		_filter([this](const binlog::EventSource& source) {
		return source.severity >= this->_severity;
			})
	{
		// Create a ClockSync, that connects the TSC value to the wall clock time.
		const auto tscValue = __rdtsc();
		const binlog::ClockSync systemClockSync = binlog::systemClockSync();
		const binlog::ClockSync tscSync{
			tscValue,
			tscFrequency(),
			systemClockSync.nsSinceEpoch,
			systemClockSync.tzOffset,
			systemClockSync.tzName
		};

		// Add the created ClockSync to the metadata of the session.
		// Events consumed after this are assumed to be timestamped
		// with the clock defined by the ClockSync (this case, TSC)
		_session.setClockSync(tscSync);
	}
	std::uint64_t tscFrequency()
	{
#if defined(__linux__)
		long freq;

		// If the kernel is exporting the tsc frequency use that. There are issues
		// where cpuinfo_max_freq cannot be relied on because the BIOS may be
		// exporintg an invalid p-state (on x86) or p-states may be used to put the
		// processor in a new mode (turbo mode). Essentially, those frequencies
		// cannot always be relied upon. The same reasons apply to /proc/cpuinfo as
		// well.
		if (ReadFromFile("/sys/devices/system/cpu/cpu0/tsc_freq_khz", &freq)
			// If CPU scaling is in effect, we want to use the *maximum* frequency,
			// not whatever CPU speed some random processor happens to be using now.
			|| ReadFromFile("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq",
				&freq)) {
			// The value is in kHz (as the file name suggests).  For example, on a
			// 2GHz warpstation, the file contains the value "2000000".
			return freq * 1000.0;
		}
		else
		{
			throw std::runtime_error("Not found tsc freq in this OS,make sure cpuinfo_max_freq exist.");
			return 0;
		}
#else
		// In NT, read MHz from the registry. If we fail to do so or we're in win9x
		// then make a crude estimate.
		DWORD data, data_size = sizeof(data);
		if (IsWindowsXPOrGreater() &&
			SUCCEEDED(
				SHGetValueA(HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", "~MHz", nullptr, &data, &data_size)))
			return ((uint64_t)data *
				(uint64_t)(1000 * 1000));  // was mhz
		else
		{
			throw std::runtime_error("Not found tsc freq in this OS,make sure HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0 exist.");
			return 0;
		}
#endif
	}
	void consume()
	{
		_session.consume(_binary);
		_binary.flush();
	}

	binlog::SessionWriter& GetWriter()
	{
		return _writer;
	}

	void set_log_level(binlog::Severity level)
	{
		_severity = level;
	}
private:		
	std::ostream& _binary;
	binlog::Session _session;
	binlog::Severity _severity;
	binlog::SessionWriter _writer;		
	binlog::EventFilter _filter;		
};

class MultiOutputStream {
public:
  MultiOutputStream(/* ... */);

  MultiOutputStream& write(const char* buf, std::streamsize size)
  {
    _file.write(buf, size);
    _monitor.write(buf, size);
    _console.write(buf, size);
    return *this;
  }

private:
  std::ostream _file;
  Monitoring _monitor;
  Console _console;
};

tail -c0 -f logfile.blog | bread

std::error_code ec;
BINLOG_INFO("{}", ec);

BINLOG_ADAPT_STRUCT(Base, a, b)
BINLOG_ADAPT_STRUCT(Derived, c, d, Base)

BINLOG_ADAPT_STRUCT(Base, a, b)
BINLOAD_ADAPT_STRUCT(Dervied, c, d, a, b)

struct Base
{
   int a, b;
};
struct Derived : public Base
{
   int c,d;
};

$ ./my_app | bread

binlog::TextOutputStream tos(std::cout); // also takes optional format and date format
session.consume(tos); // text log appear on stdout

<FixedSizeArrayTag> := # `SizeInHex' <ElementTypeTag>

<MemcpyStructTag> :=
={SizeInHex [`OffsetInHex' <FieldTypeTag>]*}

namespace mserialize { namespace detail {
  template <typename T> struct is_optional<std::optional<T>> : std::true_type {};
}}

struct ABC {
  int a;
  short b[10];
  char c[12][2];
};

template<typename T, typename E, int N>
auto serializable_member_type(E(T::*)[N]) -> std::vector<E>;

template<typename T, typename E, int N, int M>
auto serializable_member_type(E(T::*)[N][M]) -> std::vector<std::vector<E>>;

template<typename T, typename E, int N, int M, int K>
auto serializable_member_type(E(T::*)[N][M][K]) -> std::vector<std::vector<std::vector<E>>>;

/opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/debug/safe_iterator.h:552:
    error:
    attempt
    to
    compare
    a
    singular

    iterator
    to
    a
    past-the-end

    iterator
    .

Objects involved in the operation:
iterator "lhs" @ 0x0x287e2e8 {
type = ▒hI1▒ (mutable iterator);
  state = singular;
  references sequence with type `NSt7__debug6vectorISt10shared_ptrIN6binlog7Session7ChannelEESaIS5_EEE' @ 0x0x287e2e8
}
iterator "rhs" @ 0x0x287e2e8 {
type = ▒hI1▒ (mutable iterator);
  state = past-the-end;
  references sequence with type `NSt7__debug6vectorISt10shared_ptrIN6binlog7Session7ChannelEESaIS5_EEE' @ 0x0x287e2e8
}

BINLOG_INFO("{}", std::vector<int>{});

binlog/detail/QueueWriter.hpp:78:38: runtime error: null pointer passed as argument 2, which is declared to never be null
/usr/include/string.h:43:28: note: nonnull attribute specified here```

LOG({'key1', Value1}, {'key2', Value2}, ...);

WRITE of size 1 at 0x60600000d830 thread T0
    #0 0x68fcc5 in std::__atomic_base<bool>::store(bool, std::memory_order) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/atomic_base.h:374:2
    #1 0x68fcc5 in std::__atomic_base<bool>::operator=(bool) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/atomic_base.h:267
    #2 0x68fa0d in std::atomic<bool>::operator=(bool) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/atomic:79:22
    #3 0x680c1d in binlog::SessionWriter::~SessionWriter() /Morgan-Stanley_binlog/20200306_0c86ccd/include/binlog/SessionWriter.hpp:135:22
    #4 0x7efc08019e08  (/lib64/libstdc++.so.6+0x5ce08)
    #5 0x7efc072faa68 in __run_exit_handlers (/lib64/libc.so.6+0x38a68)
    #6 0x7efc072faab4 in __GI_exit (/lib64/libc.so.6+0x38ab4)
    #7 0x7efc072e3c0b in __libc_start_main (/lib64/libc.so.6+0x21c0b)
    #8 0x512ea8 in _start (perf+0x512ea8)

0x60600000d830 is located 16 bytes inside of 56-byte region [0x60600000d820,0x60600000d858)
freed by thread T0 here:
    #0 0x6452e0 in operator delete(void*) (perf+0x6452e0)
    #1 0x687667 in __gnu_cxx::new_allocator<std::_List_node<binlog::Session::Channel> >::deallocate(std::_List_node<binlog::Session::Channel>*, unsigned long) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/ext/new_allocator.h:125:2
    #2 0x687614 in std::allocator_traits<std::allocator<std::_List_node<binlog::Session::Channel> > >::deallocate(std::allocator<std::_List_node<binlog::Session::Channel> >&, std::_List_node<binlog::Session::Channel>*, unsigned long) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/alloc_traits.h:462:13
    #3 0x68621e in std::_List_base<binlog::Session::Channel, std::allocator<binlog::Session::Channel> >::_M_put_node(std::_List_node<binlog::Session::Channel>*) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/stl_list.h:454:9
    #4 0x685f23 in std::_List_base<binlog::Session::Channel, std::allocator<binlog::Session::Channel> >::_M_clear() /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/list.tcc:81:4
    #5 0x685be1 in std::_List_base<binlog::Session::Channel, std::allocator<binlog::Session::Channel> >::~_List_base() /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/stl_list.h:507:9
    #6 0x681624 in std::list<binlog::Session::Channel, std::allocator<binlog::Session::Channel> >::~list() /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/stl_list.h:835:23
    #7 0x680e18 in binlog::Session::~Session() /Morgan-Stanley_binlog/20200306_0c86ccd/include/binlog/Session.hpp:46:7
    #8 0x7efc072faa68 in __run_exit_handlers (/lib64/libc.so.6+0x38a68)

previously allocated by thread T0 here:
    #0 0x644350 in operator new(unsigned long) (perf+0x644350)
    #1 0x68a4cc in __gnu_cxx::new_allocator<std::_List_node<binlog::Session::Channel> >::allocate(unsigned long, void const*) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/ext/new_allocator.h:111:27
    #2 0x68a430 in std::allocator_traits<std::allocator<std::_List_node<binlog::Session::Channel> > >::allocate(std::allocator<std::_List_node<binlog::Session::Channel> >&, unsigned long) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/alloc_traits.h:436:20
    #3 0x689ee6 in std::_List_base<binlog::Session::Channel, std::allocator<binlog::Session::Channel> >::_M_get_node() /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/stl_list.h:450:16
    #4 0x6899b3 in std::_List_node<binlog::Session::Channel>* std::list<binlog::Session::Channel, std::allocator<binlog::Session::Channel> >::_M_create_node<binlog::Session&, unsigned long&, binlog::WriterProp>(binlog::Session&, unsigned long&, binlog::WriterProp&&) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/stl_list.h:642:21
    #5 0x689393 in void std::list<binlog::Session::Channel, std::allocator<binlog::Session::Channel> >::_M_insert<binlog::Session&, unsigned long&, binlog::WriterProp>(std::_List_iterator<binlog::Session::Channel>, binlog::Session&, unsigned long&, binlog::WriterProp&&) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/stl_list.h:1903:18
    #6 0x688bb6 in binlog::Session::Channel& std::list<binlog::Session::Channel, std::allocator<binlog::Session::Channel> >::emplace_back<binlog::Session&, unsigned long&, binlog::WriterProp>(binlog::Session&, unsigned long&, binlog::WriterProp&&) /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/stl_list.h:1235:10
    #7 0x687f84 in binlog::Session::createChannel(unsigned long, binlog::WriterProp) /Morgan-Stanley_binlog/20200306_0c86ccd/include/binlog/Session.hpp:241:13
    #8 0x699e3c in binlog::SessionWriter::replaceChannel(unsigned long) /Morgan-Stanley_binlog/20200306_0c86ccd/include/binlog/SessionWriter.hpp:203:46
    #9 0x738732 in bool binlog::SessionWriter::addEvent<std::string const&, unsigned long, unsigned long, std::basic_string_view<char, std::char_traits<char> >, unsigned long, unsigned int>(unsigned long, unsigned long, std::string const&, unsigned long&&, unsigned long&&, std::basic_string_view<char, std::char_traits<char> >&&, unsigned long&&, unsigned int&&) /Morgan-Stanley_binlog/20200306_0c86ccd/include/binlog/SessionWriter.hpp:179:5
    #10 0x73597d in void binlog::detail::addEventIgnoreFirst<binlog::SessionWriter, char const (&) [104], std::string const&, unsigned long, unsigned long, std::basic_string_view<char, std::char_traits<char> >, unsigned long, unsigned int>(binlog::SessionWriter&, unsigned long, unsigned long, char const (&) [104], std::string const&, unsigned long&&, unsigned long&&, std::basic_string_view<char, std::char_traits<char> >&&, unsigned long&&, unsigned int&&) /Morgan-Stanley_binlog/20200306_0c86ccd/include/binlog/create_source_and_event.hpp:95:10
    #11
	
	snip
	
    #24 0x7efc072e3c04 in __libc_start_main (/lib64/libc.so.6+0x21c04)

SUMMARY: AddressSanitizer: heap-use-after-free /opt/rh/devtoolset-8/root/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/bits/atomic_base.h:374:2 in std::__atomic_base<bool>::store(bool, std::memory_order)
Shadow bytes around the buggy address:
  0x0c0c7fff9ab0: fd fd fd fd fd fd fd fd fa fa fa fa fd fd fd fd
  0x0c0c7fff9ac0: fd fd fd fd fa fa fa fa fd fd fd fd fd fd fd fd
  0x0c0c7fff9ad0: fa fa fa fa fd fd fd fd fd fd fd fd fa fa fa fa
  0x0c0c7fff9ae0: fd fd fd fd fd fd fd fd fa fa fa fa fd fd fd fd
  0x0c0c7fff9af0: fd fd fd fa fa fa fa fa fd fd fd fd fd fd fd fa
=>0x0c0c7fff9b00: fa fa fa fa fd fd[fd]fd fd fd fd fa fa fa fa fa
  0x0c0c7fff9b10: fd fd fd fd fd fd fd fd fa fa fa fa fd fd fd fd
  0x0c0c7fff9b20: fd fd fd fd fa fa fa fa fd fd fd fd fd fd fd fd
  0x0c0c7fff9b30: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c0c7fff9b40: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
  0x0c0c7fff9b50: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
Shadow byte legend (one shadow byte represents 8 application bytes):
  Addressable:           00
  Partially addressable: 01 02 03 04 05 06 07 
  Heap left redzone:       fa
  Freed heap region:       fd
  Stack left redzone:      f1
  Stack mid redzone:       f2
  Stack right redzone:     f3
  Stack after return:      f5
  Stack use after scope:   f8
  Global redzone:          f9
  Global init order:       f6
  Poisoned by user:        f7
  Container overflow:      fc
  Array cookie:            ac
  Intra object redzone:    bb
  ASan internal:           fe
  Left alloca redzone:     ca
  Right alloca redzone:    cb
  Shadow gap:              cc
==30054==ABORTING

$ brecovery myapp.1234.core recovered_log.blog

Scanning dependencies of target TextOutput
make[2]: Leaving directory 'RED/binlog/Release'
make  -f CMakeFiles/TextOutput.dir/build.make CMakeFiles/TextOutput.dir/build
make[2]: Entering directory 'RED/binlog/Release'
[ 29%] Building CXX object CMakeFiles/TextOutput.dir/example/TextOutput.cpp.o
/usr/bin/c++   -IRED/binlog/include  -O2 -g -DNDEBUG   -Wall -Wextra -Werror -pedantic -Wconversion -Wsign-conversion -Wold-style-cast -Wsuggest-override -Wshadow -std=c++14 -o CMakeFiles/TextOutput.dir/example/TextOutput.cpp.o -c RED/binlog/example/TextOutput.cpp
In file included from RED/binlog/include/binlog/Severity.hpp:4,
                 from RED/binlog/include/binlog/Entries.hpp:5,
                 from RED/binlog/include/binlog/EventStream.hpp:4,
                 from RED/binlog/include/binlog/TextOutputStream.hpp:4,
                 from RED/binlog/example/TextOutput.cpp:1:
RED/binlog/include/mserialize/cx_string.hpp: In instantiation of ‘constexpr mserialize::cx_string<N>::cx_string(const char*) [with long unsigned int N = 0]’:
RED/binlog/include/mserialize/cx_string.hpp:95:10:   required from ‘constexpr auto binlog::detail::concatenated_tags(Unused&&, T&& ...) [with Unused = const char (&)[19]; T = {}]’
RED/binlog/example/TextOutput.cpp:8:3:   required from here
RED/binlog/include/binlog/create_source_and_event.hpp:67:31:   in ‘constexpr’ expansion of ‘mserialize::cx_strcat<>()’
RED/binlog/include/mserialize/cx_string.hpp:36:31: error: comparison of unsigned expression in ‘< 0’ is always false [-Werror=type-limits]
   36 |     for (std::size_t i = 0; i < N; ++i)
      |                             ~~^~~
cc1plus: all warnings being treated as errors
CMakeFiles/TextOutput.dir/build.make:82: recipe for target 'CMakeFiles/TextOutput.dir/example/TextOutput.cpp.o' failed
make[2]: *** [CMakeFiles/TextOutput.dir/example/TextOutput.cpp.o] Error 1
make[2]: Leaving directory 'RED/binlog/Release'
CMakeFiles/Makefile2:203: recipe for target 'CMakeFiles/TextOutput.dir/all' failed
make[1]: *** [CMakeFiles/TextOutput.dir/all] Error 2
make[1]: Leaving directory 'RED/binlog/Release'
Makefile:160: recipe for target 'all' failed
make: *** [all] Error 2