_Z29continuation_handler_void_ptrIN14EventProcessor10ThreadInitE5EventEM12ContinuationFiiPvEMT_FiiPT0_E:
   72|      2|{
   73|      2|  auto fp2 = reinterpret_cast<int (C::*)(int, void *)>(fp);
   74|       |
   75|       |  // We keep this a static_cast for added static type analysis from the
   76|       |  // compiler. If a compiler warning is generated for the following line of
   77|       |  // code of the type "-Werror=shift-negative-value", then this may be an issue
   78|       |  // with multiple inheritance of the C templated type. Make sure that for type
   79|       |  // C the Continuation parent is listed first (either directly or indirectly
   80|       |  // via the inheritance tree) before any other parent in the multiple class
   81|       |  // hierarchy of C.
   82|      2|  return static_cast<ContinuationHandler>(fp2);
   83|      2|}
_ZN12ContinuationC2EP10ProxyMutex:
  277|      6|inline Continuation::Continuation(ProxyMutex *amutex) : mutex(amutex)
  278|      6|{
  279|       |  // Pick up the control flags from the creating thread
  280|      6|  this->control_flags.set_flags(get_cont_flags().get_flags());
  281|      6|}
_Z29continuation_handler_void_ptrI25ThreadAffinityInitializer5EventEM12ContinuationFiiPvEMT_FiiPT0_E:
   72|      2|{
   73|      2|  auto fp2 = reinterpret_cast<int (C::*)(int, void *)>(fp);
   74|       |
   75|       |  // We keep this a static_cast for added static type analysis from the
   76|       |  // compiler. If a compiler warning is generated for the following line of
   77|       |  // code of the type "-Werror=shift-negative-value", then this may be an issue
   78|       |  // with multiple inheritance of the C templated type. Make sure that for type
   79|       |  // C the Continuation parent is listed first (either directly or indirectly
   80|       |  // via the inheritance tree) before any other parent in the multiple class
   81|       |  // hierarchy of C.
   82|      2|  return static_cast<ContinuationHandler>(fp2);
   83|      2|}
UnixEventProcessor.cc:_Z29continuation_handler_void_ptrIN12_GLOBAL__N_116ThreadInitByFuncE5EventEM12ContinuationFiiPvEMT_FiiPT0_E:
   72|      2|{
   73|      2|  auto fp2 = reinterpret_cast<int (C::*)(int, void *)>(fp);
   74|       |
   75|       |  // We keep this a static_cast for added static type analysis from the
   76|       |  // compiler. If a compiler warning is generated for the following line of
   77|       |  // code of the type "-Werror=shift-negative-value", then this may be an issue
   78|       |  // with multiple inheritance of the C templated type. Make sure that for type
   79|       |  // C the Continuation parent is listed first (either directly or indirectly
   80|       |  // via the inheritance tree) before any other parent in the multiple class
   81|       |  // hierarchy of C.
   82|      2|  return static_cast<ContinuationHandler>(fp2);
   83|      2|}

_ZN14EventProcessor10ThreadInitC2EPS_:
  385|      2|    explicit ThreadInit(EventProcessor *evp) : _evp(evp) { SET_HANDLER(&self::init); }
  ------------------
  |  |  253|      2|#define SET_HANDLER(_h) (handler = continuation_handler_void_ptr(_h))
  ------------------

_ZNK18SessionProtocolSet11indexToMaskEi:
   72|  2.56k|  {
   73|  2.56k|    return 0 <= idx && idx < static_cast<int>(MAX) ? static_cast<uint32_t>(1) << idx : 0;
  ------------------
  |  Branch (73:12): [True: 2.56k, False: 0]
  |  Branch (73:24): [True: 2.56k, False: 0]
  ------------------
   74|  2.56k|  }
_ZN18SessionProtocolSet6markInEi:
   79|  1.78k|  {
   80|  1.78k|    m_bits |= this->indexToMask(idx);
   81|  1.78k|  }
_ZN18SessionProtocolSet7markOutEi:
   92|    446|  {
   93|    446|    m_bits &= ~this->indexToMask(idx);
   94|    446|  }
_ZNK18SessionProtocolSet8containsEi:
  104|    330|  {
  105|    330|    return 0 != (m_bits & this->indexToMask(idx));
  106|    330|  }
_ZN18SessionProtocolSet9markAllInEv:
  116|    223|  {
  117|    223|    m_bits = ~static_cast<uint32_t>(0);
  118|    223|  }
_ZN27SessionProtocolNameRegistryC2Ev:
  183|      2|  SessionProtocolNameRegistry() = default;

_ZN17FreelistAllocatorC2EPKcjjjb:
  101|      4|  {
  102|      4|    ink_freelist_init(&fl, name, element_size, chunk_size, alignment, use_hugepages);
  103|      4|  }
_ZN14ClassAllocatorI10ProxyMutexLb0E17FreelistAllocatorEC2EPKcjj:
  370|      2|    : BaseAllocator(name, static_cast<unsigned int>(RND16(sizeof(C))), chunk_size, static_cast<unsigned int>(RND16(alignment)))
  ------------------
  |  |   49|      2|#define RND16(_x) (((_x) + 15) & ~15)
  ------------------
                  : BaseAllocator(name, static_cast<unsigned int>(RND16(sizeof(C))), chunk_size, static_cast<unsigned int>(RND16(alignment)))
  ------------------
  |  |   49|      2|#define RND16(_x) (((_x) + 15) & ~15)
  ------------------
  371|      2|  {
  372|      2|  }
_ZN14ClassAllocatorI5EventLb0E17FreelistAllocatorEC2EPKcjj:
  370|      2|    : BaseAllocator(name, static_cast<unsigned int>(RND16(sizeof(C))), chunk_size, static_cast<unsigned int>(RND16(alignment)))
  ------------------
  |  |   49|      2|#define RND16(_x) (((_x) + 15) & ~15)
  ------------------
                  : BaseAllocator(name, static_cast<unsigned int>(RND16(sizeof(C))), chunk_size, static_cast<unsigned int>(RND16(alignment)))
  ------------------
  |  |   49|      2|#define RND16(_x) (((_x) + 15) & ~15)
  ------------------
  371|      2|  {
  372|      2|  }

_ZN11BaseLogFile7is_openEv:
  190|    446|  {
  191|    446|    return (m_fp != nullptr);
  192|    446|  }

_ZN9ContFlagsC2Ev:
   44|      8|  ContFlags() {}
_ZN9ContFlags9set_flagsEj:
   49|      6|  {
   50|      6|    raw_flags = new_flags;
   51|      6|  }
_ZNK9ContFlags9get_flagsEv:
   61|      6|  {
   62|      6|    return raw_flags;
   63|      6|  }

_Z5diagsv:
   72|    651|{
   73|    651|  return DiagsPtr::_diags_ptr;
   74|    651|}

_ZNK5Diags19debug_tag_activatedEPKc:
  169|  2.67k|  {
  170|  2.67k|    return tag_activated(tag);
  171|  2.67k|  }
_ZNK5Diags4lockEv:
  268|  6.00k|  {
  269|  6.00k|    ink_mutex_acquire(&tag_table_lock);
  270|  6.00k|  }
_ZNK5Diags6unlockEv:
  274|  6.00k|  {
  275|  6.00k|    ink_mutex_release(&tag_table_lock);
  276|  6.00k|  }

_ZN4LinkI12ContinuationEC2Ev:
  103|      6|  Link() : prev(nullptr) {}
_ZN5SLinkI12ContinuationEC2Ev:
   69|      6|  SLink() : next(nullptr){};
_ZN5QueueI5EventNS0_9Link_linkEEC2Ev:
  567|     16|  Queue() : tail(nullptr) {}
_ZN3DLLI5EventNS0_9Link_linkEEC2Ev:
  264|     16|  DLL() : head(nullptr) {}

_ZN3PtrI10ProxyMutexEC2EPS0_:
  207|      6|template <class T> inline Ptr<T>::Ptr(T *ptr /* = 0 */) : m_ptr(ptr)
  208|      6|{
  209|      6|  if (m_ptr) {
  ------------------
  |  Branch (209:7): [True: 0, False: 6]
  ------------------
  210|      0|    m_ptr->refcount_inc();
  211|      0|  }
  212|      6|}

_ZN9Throttler9TimePointC2Ev:
  122|      5|    constexpr TimePoint() noexcept : time_point() {}

_ZN6IpAddrC2Ev:
 1288|    225|  IpAddr() {}
_ZN6IpAddr4AddrC2Ev:
 1443|    225|    constexpr Addr() : _ip4(0) {}

_ZN14ats_scoped_strC2EPc:
  533|    446|  explicit ats_scoped_str(char *s) : super(s) {}
_ZN19ats_scoped_resourceIN6detail20SCOPED_MALLOC_TRAITSIcEEE5clearEv:
  317|    892|  {
  318|    892|    if (Traits::isValid(_r)) {
  ------------------
  |  Branch (318:9): [True: 446, False: 446]
  ------------------
  319|    446|      Traits::destroy(_r);
  320|    446|    }
  321|    892|    _r = Traits::initValue();
  322|    892|  }
_ZN6detail20SCOPED_MALLOC_TRAITSIcE7isValidEPc:
  471|    892|  {
  472|    892|    return nullptr != t;
  473|    892|  }
_ZN6detail20SCOPED_MALLOC_TRAITSIcE7destroyEPc:
  476|    446|  {
  477|    446|    ats_free(t);
  478|    446|  }
_ZN6detail20SCOPED_MALLOC_TRAITSIcE9initValueEv:
  466|  1.33k|  {
  467|  1.33k|    return nullptr;
  468|  1.33k|  }
_ZN19ats_scoped_resourceIN6detail20SCOPED_MALLOC_TRAITSIcEEEC2EPc:
  308|    446|  explicit ats_scoped_resource(value_type rt) : _r(rt) {}
_ZN19ats_scoped_resourceIN6detail20SCOPED_MALLOC_TRAITSIcEEED2Ev:
  310|    892|  ~ats_scoped_resource() { this->clear(); }
_ZNK19ats_scoped_resourceIN6detail20SCOPED_MALLOC_TRAITSIcEEE3getEv:
  331|  1.11k|  {
  332|  1.11k|    return _r;
  333|  1.11k|  }
_ZN19ats_scoped_resourceIN6detail20SCOPED_MALLOC_TRAITSIcEEEC2Ev:
  306|    446|  ats_scoped_resource() : _r(Traits::initValue()) {}
_ZN14ats_scoped_strC2Ev:
  516|    446|  ats_scoped_str() = default;
ink_queue.cc:_ZL12ats_pagesizev:
  112|      8|{
  113|      8|  static size_t page_size;
  114|       |
  115|      8|  if (page_size) {
  ------------------
  |  Branch (115:7): [True: 6, False: 2]
  ------------------
  116|      6|    return page_size;
  117|      6|  }
  118|       |
  119|      2|#if defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
  120|      2|  long ret  = sysconf(_SC_PAGESIZE);
  121|      2|  page_size = static_cast<size_t>((ret > -1) ? ret : 8192);
  ------------------
  |  Branch (121:35): [True: 2, False: 0]
  ------------------
  122|       |#elif defined(HAVE_GETPAGESIZE)
  123|       |  page_size = (size_t)getpagesize();
  124|       |#else
  125|       |  page_size = static_cast<size_t>(8192);
  126|       |#endif
  127|       |
  128|      2|  return page_size;
  129|      8|}
_Z8ink_zeroI12_InkFreeListEvRT_:
  213|      4|{
  214|      4|  memset(static_cast<void *>(&t), 0, sizeof(t));
  215|      4|}
_Z8ink_zeroIA4096_P7EThreadEvRT_:
  213|      4|{
  214|      4|  memset(static_cast<void *>(&t), 0, sizeof(t));
  215|      4|}

Diags.cc:_ZL17ink_mutex_acquireP15pthread_mutex_t:
   47|  6.00k|{
   48|  6.00k|  int error = pthread_mutex_lock(m);
   49|  6.00k|  if (unlikely(error != 0)) {
  ------------------
  |  |   31|  6.00k|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 6.00k]
  |  |  ------------------
  ------------------
   50|      0|    ink_abort("pthread_mutex_lock(%p) failed: %s (%d)", static_cast<void *>(m), strerror(error), error);
   51|      0|  }
   52|  6.00k|}
Diags.cc:_ZL17ink_mutex_releaseP15pthread_mutex_t:
   56|  6.00k|{
   57|  6.00k|  int error = pthread_mutex_unlock(m);
   58|  6.00k|  if (unlikely(error != 0)) {
  ------------------
  |  |   31|  6.00k|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 6.00k]
  |  |  ------------------
  ------------------
   59|      0|    ink_abort("pthread_mutex_unlock(%p) failed: %s (%d)", static_cast<void *>(m), strerror(error), error);
   60|      0|  }
   61|  6.00k|}

_ZN6DbgCtlC2EPKc:
   64|     26|  DbgCtl(char const *tag) : _ptr{_new_reference(tag)} {}
_ZNK6DbgCtl2onEv:
  104|     30|  {
  105|     30|    auto m{_config_mode.load(std::memory_order_relaxed)};
  106|     30|    if (!m) {
  ------------------
  |  Branch (106:9): [True: 30, False: 0]
  ------------------
  107|     30|      return false;
  108|     30|    }
  109|      0|    if (!_ptr->second) {
  ------------------
  |  Branch (109:9): [True: 0, False: 0]
  ------------------
  110|      0|      return false;
  111|      0|    }
  112|      0|    if (m & 1) {
  ------------------
  |  Branch (112:9): [True: 0, False: 0]
  ------------------
  113|      0|      return true;
  114|      0|    }
  115|      0|    return (2 == m) && (_override_global_on());
  ------------------
  |  Branch (115:12): [True: 0, False: 0]
  |  Branch (115:24): [True: 0, False: 0]
  ------------------
  116|      0|  }
_ZN14DebugInterfaceD2Ev:
   42|    223|  virtual ~DebugInterface()                            = default;

_ZN14SourceLocationC2EPKcS1_i:
   44|      5|  SourceLocation(const char *_file, const char *_func, int _line) : file(_file), func(_func), line(_line) {}
_ZNK14SourceLocation5validEv:
   48|    205|  {
   49|    205|    return file && line;
  ------------------
  |  Branch (49:12): [True: 205, False: 0]
  |  Branch (49:20): [True: 205, False: 0]
  ------------------
   50|    205|  }

_ZN2ts10UnitParserC2EON4swoc7_1_5_157LexiconImEEb:
   91|      2|  : _unit_required_p(unit_required_p), _units(std::move(units))
   92|      2|{
   93|      2|  _units.set_default(value_type{0}); // Used to check for bad unit names.
   94|      2|}

_ZN4swoc7_1_5_1517FixedBufferWriter5writeEc:
  545|    410|FixedBufferWriter::write(char c) {
  546|    410|  if (_attempted < _capacity) {
  ------------------
  |  Branch (546:7): [True: 410, False: 0]
  ------------------
  547|    410|    _buffer[_attempted] = c;
  548|    410|  }
  549|    410|  ++_attempted;
  550|       |
  551|    410|  return *this;
  552|    410|}
_ZN4swoc7_1_5_1512BufferWriter5writeENS0_7MemSpanIKvEE:
  478|  2.05k|BufferWriter::write(MemSpan<void const> span) {
  479|  2.05k|  return this->write(span.data(), span.size());
  480|  2.05k|}
_ZNK4swoc7_1_5_1512BufferWriter9remainingEv:
  493|  1.02k|BufferWriter::remaining() const {
  494|  1.02k|  return this->capacity() - this->size();
  495|  1.02k|}
_ZNK4swoc7_1_5_1512BufferWriter4sizeEv:
  488|  1.64k|BufferWriter::size() const {
  489|  1.64k|  return std::min(this->extent(), this->capacity());
  490|  1.64k|}
_ZN4swoc7_1_5_1517FixedBufferWriterC2EPcm:
  498|  1.02k|inline FixedBufferWriter::FixedBufferWriter(char *buffer, size_t capacity) : _buffer(buffer), _capacity(capacity) {
  499|  1.02k|  if (_capacity != 0 && buffer == nullptr) {
  ------------------
  |  Branch (499:7): [True: 1.02k, False: 0]
  |  Branch (499:25): [True: 0, False: 1.02k]
  ------------------
  500|      0|    throw(std::invalid_argument{"FixedBufferWriter created with null buffer and non-zero size."});
  501|  1.02k|  };
  502|  1.02k|}
_ZN4swoc7_1_5_1512BufferWriterD2Ev:
  458|  1.43k|inline BufferWriter::~BufferWriter() {}
_ZN4swoc7_1_5_1517FixedBufferWriter5writeEPKvm:
  555|  2.05k|FixedBufferWriter::write(const void *data, size_t length) {
  556|  2.05k|  const size_t newSize = _attempted + length;
  557|       |
  558|  2.05k|  if (_buffer) {
  ------------------
  |  Branch (558:7): [True: 2.05k, False: 0]
  ------------------
  559|  2.05k|    if (newSize <= _capacity) {
  ------------------
  |  Branch (559:9): [True: 2.05k, False: 0]
  ------------------
  560|  2.05k|      std::memcpy(_buffer + _attempted, data, length);
  561|  2.05k|    } else if (_attempted < _capacity) {
  ------------------
  |  Branch (561:16): [True: 0, False: 0]
  ------------------
  562|      0|      std::memcpy(_buffer + _attempted, data, _capacity - _attempted);
  563|      0|    }
  564|  2.05k|  }
  565|  2.05k|  _attempted = newSize;
  566|       |
  567|  2.05k|  return *this;
  568|  2.05k|}
_ZNK4swoc7_1_5_1517FixedBufferWriter5errorEv:
  577|  1.43k|FixedBufferWriter::error() const {
  578|  1.43k|  return _attempted > _capacity;
  579|  1.43k|}
_ZN4swoc7_1_5_1517FixedBufferWriter8aux_dataEv:
  582|  1.23k|FixedBufferWriter::aux_data() {
  583|  1.23k|  return error() ? nullptr : _buffer + _attempted;
  ------------------
  |  Branch (583:10): [True: 0, False: 1.23k]
  ------------------
  584|  1.23k|}
_ZNK4swoc7_1_5_1517FixedBufferWriter8capacityEv:
  594|  2.66k|FixedBufferWriter::capacity() const {
  595|  2.66k|  return _capacity;
  596|  2.66k|}
_ZNK4swoc7_1_5_1517FixedBufferWriter6extentEv:
  599|  4.71k|FixedBufferWriter::extent() const {
  600|  4.71k|  return _attempted;
  601|  4.71k|}
_ZN4swoc7_1_5_1517FixedBufferWriter6commitEm:
  587|  1.23k|FixedBufferWriter::commit(size_t n) {
  588|  1.23k|  _attempted += n;
  589|       |
  590|  1.23k|  return true;
  591|  1.23k|}
_ZN4swoc7_1_5_1517FixedBufferWriter8restrictEm:
  603|    205|inline auto FixedBufferWriter::restrict(size_t n) -> self_type & {
  604|    205|  if (n > _capacity) {
  ------------------
  |  Branch (604:7): [True: 0, False: 205]
  ------------------
  605|      0|    throw(std::invalid_argument{"FixedBufferWriter restrict value more than capacity"});
  606|      0|  }
  607|    205|  _capacity -= n;
  608|    205|  return *this;
  609|    205|}
_ZN4swoc7_1_5_1517FixedBufferWriter7restoreEm:
  612|    205|FixedBufferWriter::restore(size_t n) -> self_type & {
  613|    205|  if (error()) {
  ------------------
  |  Branch (613:7): [True: 0, False: 205]
  ------------------
  614|      0|    _attempted = _capacity;
  615|      0|  }
  616|    205|  _capacity += n;
  617|    205|  return *this;
  618|    205|}
_ZNK4swoc7_1_5_1517FixedBufferWriter4viewEv:
  642|    410|FixedBufferWriter::view() const {
  643|    410|  return {_buffer, size()};
  644|    410|}
_ZN4swoc7_1_5_1517FixedBufferWriterC2EPcmb:
  504|    410|inline FixedBufferWriter::FixedBufferWriter(char *buffer, size_t capacity, bool /* noexcept_flag */) noexcept : _buffer(buffer), _capacity(capacity) {
  505|    410|}
_ZN4swoc7_1_5_1517LocalBufferWriterILm1024EEC2Ev:
  655|    205|template <size_t N> LocalBufferWriter<N>::LocalBufferWriter() noexcept : super_type(_arr, N, true) {}
_ZN4swoc7_1_5_1517LocalBufferWriterILm48EEC2Ev:
  655|    205|template <size_t N> LocalBufferWriter<N>::LocalBufferWriter() noexcept : super_type(_arr, N, true) {}

_ZN4swoc7_1_5_157IP6AddrC2Emm:
  488|      4|    : _addr{
  489|      4|        {msw, lsw}
  490|      4|  } {}

_ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE4headEv:
 1019|    110|IntrusiveDList<L>::head() -> value_type * {
 1020|    110|  return _head;
 1021|    110|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEEC2Ev:
  227|     10|  IntrusiveDList() = default;
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE5clearEv:
 1031|      2|IntrusiveDList<L>::clear() -> self_type & {
 1032|      2|  _head = _tail = nullptr;
 1033|      2|  _count        = 0;
 1034|      2|  return *this;
 1035|      2|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7LinkageEE5clearEv:
 1031|      2|IntrusiveDList<L>::clear() -> self_type & {
 1032|      2|  _head = _tail = nullptr;
 1033|      2|  _count        = 0;
 1034|      2|  return *this;
 1035|      2|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE5clearEv:
 1031|      2|IntrusiveDList<L>::clear() -> self_type & {
 1032|      2|  _head = _tail = nullptr;
 1033|      2|  _count        = 0;
 1034|      2|  return *this;
 1035|      2|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7LinkageEE5clearEv:
 1031|      2|IntrusiveDList<L>::clear() -> self_type & {
 1032|      2|  _head = _tail = nullptr;
 1033|      2|  _count        = 0;
 1034|      2|  return *this;
 1035|      2|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEEC2EOS6_:
  676|      2|IntrusiveDList<L>::IntrusiveDList(self_type &&that) : _head(that._head), _tail(that._tail), _count(that._count) {
  677|      2|  that.clear();
  678|      2|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7LinkageEEC2EOSA_:
  676|      2|IntrusiveDList<L>::IntrusiveDList(self_type &&that) : _head(that._head), _tail(that._tail), _count(that._count) {
  677|      2|  that.clear();
  678|      2|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEEC2EOS6_:
  676|      2|IntrusiveDList<L>::IntrusiveDList(self_type &&that) : _head(that._head), _tail(that._tail), _count(that._count) {
  677|      2|  that.clear();
  678|      2|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7LinkageEEC2EOSA_:
  676|      2|IntrusiveDList<L>::IntrusiveDList(self_type &&that) : _head(that._head), _tail(that._tail), _count(that._count) {
  677|      2|  that.clear();
  678|      2|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE3endEv:
  989|     96|IntrusiveDList<L>::end() -> iterator {
  990|     96|  return iterator{this, nullptr};
  991|     96|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE8iteratorC2EPS6_PS4_:
  575|     96|template <typename L> IntrusiveDList<L>::iterator::iterator(list_type *list, value_type *v) : super_type(list, v) {}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE14const_iteratorC2EPKS6_PKS4_:
  571|     96|  : _list(const_cast<list_type *>(list)), _v(const_cast<typename list_type::value_type *>(v)) {}
_ZNK4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE14const_iteratorneERKS7_:
  704|     48|IntrusiveDList<L>::const_iterator::operator!=(self_type const &that) const {
  705|     48|  return this->_v != that._v;
  706|     48|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEEC2Ev:
  227|      2|  IntrusiveDList() = default;
_ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7LinkageEEC2Ev:
  227|      2|  IntrusiveDList() = default;
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEEC2Ev:
  227|      2|  IntrusiveDList() = default;
_ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7LinkageEEC2Ev:
  227|      2|  IntrusiveDList() = default;
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE6appendEPS4_:
  748|     24|IntrusiveDList<L>::append(value_type *v) -> self_type & {
  749|     24|  L::next_ptr(v) = nullptr;
  750|     24|  if (nullptr != (L::prev_ptr(v) = _tail)) {
  ------------------
  |  Branch (750:7): [True: 22, False: 2]
  ------------------
  751|     22|    L::next_ptr(_tail) = v;
  752|     22|  } else {
  753|      2|    _head = v; // transition empty -> non-empty
  754|      2|  }
  755|     24|  _tail = v;
  756|     24|  ++_count;
  757|     24|  return *this;
  758|     24|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7LinkageEE6appendEPS8_:
  748|     14|IntrusiveDList<L>::append(value_type *v) -> self_type & {
  749|     14|  L::next_ptr(v) = nullptr;
  750|     14|  if (nullptr != (L::prev_ptr(v) = _tail)) {
  ------------------
  |  Branch (750:7): [True: 12, False: 2]
  ------------------
  751|     12|    L::next_ptr(_tail) = v;
  752|     12|  } else {
  753|      2|    _head = v; // transition empty -> non-empty
  754|      2|  }
  755|     14|  _tail = v;
  756|     14|  ++_count;
  757|     14|  return *this;
  758|     14|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE13insert_beforeEPS4_S7_:
  819|     34|IntrusiveDList<L>::insert_before(value_type *target, value_type *v) -> self_type & {
  820|     34|  if (target) {
  ------------------
  |  Branch (820:7): [True: 24, False: 10]
  ------------------
  821|     24|    if (nullptr != (L::prev_ptr(v) = L::prev_ptr(target))) {
  ------------------
  |  Branch (821:9): [True: 24, False: 0]
  ------------------
  822|     24|      L::next_ptr(L::prev_ptr(v)) = v;
  823|     24|    } else if (target == _head) {
  ------------------
  |  Branch (823:16): [True: 0, False: 0]
  ------------------
  824|      0|      _head = v;
  825|      0|    }
  826|     24|    L::next_ptr(v)      = target;
  827|     24|    L::prev_ptr(target) = v;
  828|       |
  829|     24|    ++_count;
  830|     24|  } else {
  831|     10|    this->append(v);
  832|     10|  }
  833|     34|  return *this;
  834|     34|}
_ZNK4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item11NameLinkageEE5countEv:
  965|     48|IntrusiveDList<L>::count() const {
  966|     48|  return _count;
  967|     48|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE3endEv:
  989|     64|IntrusiveDList<L>::end() -> iterator {
  990|     64|  return iterator{this, nullptr};
  991|     64|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE8iteratorC2EPS6_PS4_:
  575|     96|template <typename L> IntrusiveDList<L>::iterator::iterator(list_type *list, value_type *v) : super_type(list, v) {}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE14const_iteratorC2EPKS6_PKS4_:
  571|     96|  : _list(const_cast<list_type *>(list)), _v(const_cast<typename list_type::value_type *>(v)) {}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE12iterator_forEPS4_:
  995|     32|IntrusiveDList<L>::iterator_for(value_type *v) -> iterator {
  996|     32|  return iterator{this, v};
  997|     32|}
_ZNK4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE14const_iteratoreqERKS7_:
  698|     48|IntrusiveDList<L>::const_iterator::operator==(self_type const &that) const {
  699|     48|  return this->_v == that._v;
  700|     48|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE6appendEPS4_:
  748|     12|IntrusiveDList<L>::append(value_type *v) -> self_type & {
  749|     12|  L::next_ptr(v) = nullptr;
  750|     12|  if (nullptr != (L::prev_ptr(v) = _tail)) {
  ------------------
  |  Branch (750:7): [True: 10, False: 2]
  ------------------
  751|     10|    L::next_ptr(_tail) = v;
  752|     10|  } else {
  753|      2|    _head = v; // transition empty -> non-empty
  754|      2|  }
  755|     12|  _tail = v;
  756|     12|  ++_count;
  757|     12|  return *this;
  758|     12|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_16IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7LinkageEE6appendEPS8_:
  748|     10|IntrusiveDList<L>::append(value_type *v) -> self_type & {
  749|     10|  L::next_ptr(v) = nullptr;
  750|     10|  if (nullptr != (L::prev_ptr(v) = _tail)) {
  ------------------
  |  Branch (750:7): [True: 8, False: 2]
  ------------------
  751|      8|    L::next_ptr(_tail) = v;
  752|      8|  } else {
  753|      2|    _head = v; // transition empty -> non-empty
  754|      2|  }
  755|     10|  _tail = v;
  756|     10|  ++_count;
  757|     10|  return *this;
  758|     10|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE13insert_beforeEPS4_S7_:
  819|      6|IntrusiveDList<L>::insert_before(value_type *target, value_type *v) -> self_type & {
  820|      6|  if (target) {
  ------------------
  |  Branch (820:7): [True: 4, False: 2]
  ------------------
  821|      4|    if (nullptr != (L::prev_ptr(v) = L::prev_ptr(target))) {
  ------------------
  |  Branch (821:9): [True: 4, False: 0]
  ------------------
  822|      4|      L::next_ptr(L::prev_ptr(v)) = v;
  823|      4|    } else if (target == _head) {
  ------------------
  |  Branch (823:16): [True: 0, False: 0]
  ------------------
  824|      0|      _head = v;
  825|      0|    }
  826|      4|    L::next_ptr(v)      = target;
  827|      4|    L::prev_ptr(target) = v;
  828|       |
  829|      4|    ++_count;
  830|      4|  } else {
  831|      2|    this->append(v);
  832|      2|  }
  833|      6|  return *this;
  834|      6|}
_ZNK4swoc7_1_5_1514IntrusiveDListINS0_7LexiconImE4Item12ValueLinkageEE5countEv:
  965|     16|IntrusiveDList<L>::count() const {
  966|     16|  return _count;
  967|     16|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE14const_iteratorC2EPKS5_PKS3_:
  571|    382|  : _list(const_cast<list_type *>(list)), _v(const_cast<typename list_type::value_type *>(v)) {}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE7prependEPS3_:
  734|      2|IntrusiveDList<L>::prepend(value_type *v) -> self_type & {
  735|      2|  L::prev_ptr(v) = nullptr;
  736|      2|  if (nullptr != (L::next_ptr(v) = _head)) {
  ------------------
  |  Branch (736:7): [True: 0, False: 2]
  ------------------
  737|      0|    L::prev_ptr(_head) = v;
  738|      2|  } else {
  739|      2|    _tail = v; // transition empty -> non-empty
  740|      2|  }
  741|      2|  _head = v;
  742|      2|  ++_count;
  743|      2|  return *this;
  744|      2|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEEC2EOS5_:
  676|      4|IntrusiveDList<L>::IntrusiveDList(self_type &&that) : _head(that._head), _tail(that._tail), _count(that._count) {
  677|      4|  that.clear();
  678|      4|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE5beginEv:
  977|    190|IntrusiveDList<L>::begin() -> iterator {
  978|    190|  return iterator{this, _head};
  979|    190|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE8iteratorC2EPS5_PS3_:
  575|    382|template <typename L> IntrusiveDList<L>::iterator::iterator(list_type *list, value_type *v) : super_type(list, v) {}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE3endEv:
  989|    192|IntrusiveDList<L>::end() -> iterator {
  990|    192|  return iterator{this, nullptr};
  991|    192|}
_ZNK4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE14const_iteratorneERKS6_:
  704|    190|IntrusiveDList<L>::const_iterator::operator!=(self_type const &that) const {
  705|    190|  return this->_v != that._v;
  706|    190|}
_ZNK4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE8iteratorptEv:
  649|     94|IntrusiveDList<L>::iterator::operator->() const -> value_type * {
  650|     94|  return super_type::_v;
  651|     94|}
_ZNK4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE14const_iteratoreqERKS6_:
  698|     96|IntrusiveDList<L>::const_iterator::operator==(self_type const &that) const {
  699|     96|  return this->_v == that._v;
  700|     96|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE5clearEv:
 1031|     18|IntrusiveDList<L>::clear() -> self_type & {
 1032|     18|  _head = _tail = nullptr;
 1033|     18|  _count        = 0;
 1034|     18|  return *this;
 1035|     18|}

_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEEC2EOS6_:
  179|      2|  IntrusiveHashMap(self_type &&that) = default;
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEEC2EOS6_:
  179|      2|  IntrusiveHashMap(self_type &&that) = default;
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE4findENSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
  434|     48|IntrusiveHashMap<H>::find(key_type key) -> iterator {
  435|     48|  Bucket *b         = this->bucket_for(key);
  436|     48|  value_type *v     = b->_v;
  437|     48|  value_type *limit = b->limit();
  438|    140|  while (v != limit && !H::equal(key, H::key_of(v))) {
  ------------------
  |  Branch (438:10): [True: 92, False: 48]
  |  Branch (438:10): [True: 92, False: 48]
  |  Branch (438:24): [True: 92, False: 0]
  ------------------
  439|     92|    v = H::next_ptr(v);
  440|     92|  }
  441|     48|  return v == limit ? _list.end() : _list.iterator_for(v);
  ------------------
  |  Branch (441:10): [True: 48, False: 0]
  ------------------
  442|     48|}
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE10bucket_forENSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
  392|     96|IntrusiveHashMap<H>::bucket_for(key_type key) -> Bucket * {
  393|     96|  return &_table[H::hash_of(key) % _table.size()];
  394|     96|}
_ZNK4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket5limitEv:
  331|     82|IntrusiveHashMap<H>::Bucket::limit() const -> value_type * {
  332|     82|  Bucket *n{_link._next};
  333|     82|  return n ? n->_v : nullptr;
  ------------------
  |  Branch (333:10): [True: 48, False: 34]
  ------------------
  334|     82|};
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEEC2Em:
  384|      2|template <typename H> IntrusiveHashMap<H>::IntrusiveHashMap(size_t n) {
  385|      2|  if (n) {
  ------------------
  |  Branch (385:7): [True: 2, False: 0]
  ------------------
  386|      2|    _table.resize(*std::lower_bound(PRIME.begin(), PRIME.end(), n));
  387|      2|  }
  388|      2|}
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEEC2Em:
  384|      2|template <typename H> IntrusiveHashMap<H>::IntrusiveHashMap(size_t n) {
  385|      2|  if (n) {
  ------------------
  |  Branch (385:7): [True: 2, False: 0]
  ------------------
  386|      2|    _table.resize(*std::lower_bound(PRIME.begin(), PRIME.end(), n));
  387|      2|  }
  388|      2|}
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE3endEv:
  410|     48|IntrusiveHashMap<H>::end() -> iterator {
  411|     48|  return _list.end();
  412|     48|}
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6insertEPS4_:
  497|     48|IntrusiveHashMap<H>::insert(value_type *v) {
  498|     48|  auto key         = H::key_of(v);
  499|     48|  Bucket *bucket   = this->bucket_for(key);
  500|     48|  value_type *spot = bucket->_v;
  501|     48|  bool mixed_p     = false; // Found a different key in the bucket.
  502|       |
  503|     48|  if (nullptr == spot) { // currently empty bucket, set it and add to active list.
  ------------------
  |  Branch (503:7): [True: 14, False: 34]
  ------------------
  504|     14|    _list.append(v);
  505|     14|    bucket->_v = v;
  506|     14|    _active_buckets.append(bucket);
  507|     34|  } else {
  508|     34|    value_type *limit = bucket->limit();
  509|       |
  510|       |    // First search the bucket to see if the key is already in it.
  511|    126|    while (spot != limit && !H::equal(key, H::key_of(spot))) {
  ------------------
  |  Branch (511:12): [True: 92, False: 34]
  |  Branch (511:12): [True: 92, False: 34]
  |  Branch (511:29): [True: 92, False: 0]
  ------------------
  512|     92|      spot = H::next_ptr(spot);
  513|     92|    }
  514|     34|    if (spot != bucket->_v) {
  ------------------
  |  Branch (514:9): [True: 34, False: 0]
  ------------------
  515|     34|      mixed_p = true; // found some other key, it's going to be mixed.
  516|     34|    }
  517|     34|    if (spot != limit) {
  ------------------
  |  Branch (517:9): [True: 0, False: 34]
  ------------------
  518|       |      // If an equal key was found, walk past those to insert at the upper end of the range.
  519|      0|      do {
  520|      0|        spot = H::next_ptr(spot);
  521|      0|      } while (spot != limit && H::equal(key, H::key_of(spot)));
  ------------------
  |  Branch (521:16): [True: 0, False: 0]
  |  Branch (521:16): [True: 0, False: 0]
  |  Branch (521:33): [True: 0, False: 0]
  ------------------
  522|      0|      if (spot != limit) { // something not equal past last equivalent, it's going to be mixed.
  ------------------
  |  Branch (522:11): [True: 0, False: 0]
  ------------------
  523|      0|        mixed_p = true;
  524|      0|      }
  525|      0|    }
  526|       |
  527|     34|    _list.insert_before(spot, v);
  528|     34|    if (spot == bucket->_v) { // added before the bucket start, update the start.
  ------------------
  |  Branch (528:9): [True: 0, False: 34]
  ------------------
  529|      0|      bucket->_v = v;
  530|      0|    }
  531|     34|    bucket->_mixed_p = mixed_p;
  532|     34|  }
  533|     48|  ++bucket->_count;
  534|       |
  535|       |  // auto expand if appropriate.
  536|     48|  if ((AVERAGE == _expansion_policy && (_list.count() / _table.size()) > _expansion_limit) ||
  ------------------
  |  Branch (536:8): [True: 48, False: 0]
  |  Branch (536:40): [True: 0, False: 48]
  ------------------
  537|     48|      (MAXIMUM == _expansion_policy && bucket->_count > _expansion_limit && bucket->_mixed_p)) {
  ------------------
  |  Branch (537:8): [True: 0, False: 48]
  |  Branch (537:40): [True: 0, False: 0]
  |  Branch (537:77): [True: 0, False: 0]
  ------------------
  538|      0|    this->expand();
  539|      0|  }
  540|     48|}
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7Linkage8next_ptrEPS7_:
  317|     26|IntrusiveHashMap<H>::Bucket::Linkage::next_ptr(Bucket *b) -> Bucket *& {
  318|     26|  return b->_link._next;
  319|     26|}
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item11NameLinkageEE6Bucket7Linkage8prev_ptrEPS7_:
  323|     14|IntrusiveHashMap<H>::Bucket::Linkage::prev_ptr(Bucket *b) -> Bucket *& {
  324|     14|  return b->_link._prev;
  325|     14|}
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE4findEm:
  434|     48|IntrusiveHashMap<H>::find(key_type key) -> iterator {
  435|     48|  Bucket *b         = this->bucket_for(key);
  436|     48|  value_type *v     = b->_v;
  437|     48|  value_type *limit = b->limit();
  438|     72|  while (v != limit && !H::equal(key, H::key_of(v))) {
  ------------------
  |  Branch (438:10): [True: 56, False: 16]
  |  Branch (438:24): [True: 24, False: 32]
  ------------------
  439|     24|    v = H::next_ptr(v);
  440|     24|  }
  441|     48|  return v == limit ? _list.end() : _list.iterator_for(v);
  ------------------
  |  Branch (441:10): [True: 16, False: 32]
  ------------------
  442|     48|}
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE10bucket_forEm:
  392|     64|IntrusiveHashMap<H>::bucket_for(key_type key) -> Bucket * {
  393|     64|  return &_table[H::hash_of(key) % _table.size()];
  394|     64|}
_ZNK4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket5limitEv:
  331|     54|IntrusiveHashMap<H>::Bucket::limit() const -> value_type * {
  332|     54|  Bucket *n{_link._next};
  333|     54|  return n ? n->_v : nullptr;
  ------------------
  |  Branch (333:10): [True: 16, False: 38]
  ------------------
  334|     54|};
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE3endEv:
  410|     48|IntrusiveHashMap<H>::end() -> iterator {
  411|     48|  return _list.end();
  412|     48|}
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6insertEPS4_:
  497|     16|IntrusiveHashMap<H>::insert(value_type *v) {
  498|     16|  auto key         = H::key_of(v);
  499|     16|  Bucket *bucket   = this->bucket_for(key);
  500|     16|  value_type *spot = bucket->_v;
  501|     16|  bool mixed_p     = false; // Found a different key in the bucket.
  502|       |
  503|     16|  if (nullptr == spot) { // currently empty bucket, set it and add to active list.
  ------------------
  |  Branch (503:7): [True: 10, False: 6]
  ------------------
  504|     10|    _list.append(v);
  505|     10|    bucket->_v = v;
  506|     10|    _active_buckets.append(bucket);
  507|     10|  } else {
  508|      6|    value_type *limit = bucket->limit();
  509|       |
  510|       |    // First search the bucket to see if the key is already in it.
  511|     14|    while (spot != limit && !H::equal(key, H::key_of(spot))) {
  ------------------
  |  Branch (511:12): [True: 8, False: 6]
  |  Branch (511:29): [True: 8, False: 0]
  ------------------
  512|      8|      spot = H::next_ptr(spot);
  513|      8|    }
  514|      6|    if (spot != bucket->_v) {
  ------------------
  |  Branch (514:9): [True: 6, False: 0]
  ------------------
  515|      6|      mixed_p = true; // found some other key, it's going to be mixed.
  516|      6|    }
  517|      6|    if (spot != limit) {
  ------------------
  |  Branch (517:9): [True: 0, False: 6]
  ------------------
  518|       |      // If an equal key was found, walk past those to insert at the upper end of the range.
  519|      0|      do {
  520|      0|        spot = H::next_ptr(spot);
  521|      0|      } while (spot != limit && H::equal(key, H::key_of(spot)));
  ------------------
  |  Branch (521:16): [True: 0, False: 0]
  |  Branch (521:33): [True: 0, False: 0]
  ------------------
  522|      0|      if (spot != limit) { // something not equal past last equivalent, it's going to be mixed.
  ------------------
  |  Branch (522:11): [True: 0, False: 0]
  ------------------
  523|      0|        mixed_p = true;
  524|      0|      }
  525|      0|    }
  526|       |
  527|      6|    _list.insert_before(spot, v);
  528|      6|    if (spot == bucket->_v) { // added before the bucket start, update the start.
  ------------------
  |  Branch (528:9): [True: 0, False: 6]
  ------------------
  529|      0|      bucket->_v = v;
  530|      0|    }
  531|      6|    bucket->_mixed_p = mixed_p;
  532|      6|  }
  533|     16|  ++bucket->_count;
  534|       |
  535|       |  // auto expand if appropriate.
  536|     16|  if ((AVERAGE == _expansion_policy && (_list.count() / _table.size()) > _expansion_limit) ||
  ------------------
  |  Branch (536:8): [True: 16, False: 0]
  |  Branch (536:40): [True: 0, False: 16]
  ------------------
  537|     16|      (MAXIMUM == _expansion_policy && bucket->_count > _expansion_limit && bucket->_mixed_p)) {
  ------------------
  |  Branch (537:8): [True: 0, False: 16]
  |  Branch (537:40): [True: 0, False: 0]
  |  Branch (537:77): [True: 0, False: 0]
  ------------------
  538|      0|    this->expand();
  539|      0|  }
  540|     16|}
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7Linkage8next_ptrEPS7_:
  317|     18|IntrusiveHashMap<H>::Bucket::Linkage::next_ptr(Bucket *b) -> Bucket *& {
  318|     18|  return b->_link._next;
  319|     18|}
_ZN4swoc7_1_5_1516IntrusiveHashMapINS0_7LexiconImE4Item12ValueLinkageEE6Bucket7Linkage8prev_ptrEPS7_:
  323|     10|IntrusiveHashMap<H>::Bucket::Linkage::prev_ptr(Bucket *b) -> Bucket *& {
  324|     10|  return b->_link._prev;
  325|     10|}

_ZN4swoc7_1_5_157LexiconImE11set_defaultERKNSt3__17variantIJNS3_9monostateEmNS0_8TextViewENS3_8functionIFmS6_EEENS7_IFS6_mEEEEEE:
  692|      6|Lexicon<E>::set_default(Default const &handler) -> self_type & {
  693|      6|  switch (handler.index()) {
  ------------------
  |  Branch (693:11): [True: 6, False: 0]
  ------------------
  694|      4|  case 0:
  ------------------
  |  Branch (694:3): [True: 4, False: 2]
  ------------------
  695|      4|    break;
  696|      2|  case 1:
  ------------------
  |  Branch (696:3): [True: 2, False: 4]
  ------------------
  697|      2|    _value_default = std::get<1>(handler);
  698|      2|    break;
  699|      0|  case 3:
  ------------------
  |  Branch (699:3): [True: 0, False: 6]
  ------------------
  700|      0|    _value_default = std::get<3>(handler);
  701|      0|    break;
  702|      0|  case 2:
  ------------------
  |  Branch (702:3): [True: 0, False: 6]
  ------------------
  703|      0|    _name_default = std::get<2>(handler);
  704|      0|    break;
  705|      0|  case 4:
  ------------------
  |  Branch (705:3): [True: 0, False: 6]
  ------------------
  706|      0|    _name_default = std::get<4>(handler);
  707|      0|    break;
  708|      6|  }
  709|      6|  return *this;
  710|      6|}
_ZN4swoc7_1_5_157LexiconImEC2EOS2_:
  187|      2|  Lexicon(self_type &&that) = default;
_ZN4swoc7_1_5_157LexiconImE4Item11NameLinkage7hash_ofENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  570|     96|Lexicon<E>::Item::NameLinkage::hash_of(std::string_view s) {
  571|     96|  return Hash32FNV1a().hash_immediate(transform_view_of(&::toupper, s));
  572|     96|}
_ZN4swoc7_1_5_157LexiconImE4Item11NameLinkage5equalERKNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEESB_:
  582|    184|Lexicon<E>::Item::NameLinkage::equal(std::string_view const &lhs, std::string_view const &rhs) {
  583|    184|  return 0 == strcasecmp(lhs, rhs);
  584|    184|}
_ZN4swoc7_1_5_157LexiconImE4Item11NameLinkage6key_ofEPS3_:
  558|    232|Lexicon<E>::Item::NameLinkage::key_of(Item *item) {
  559|    232|  return item->_payload._name;
  560|    232|}
_ZN4swoc7_1_5_157LexiconImE4Item11NameLinkage8next_ptrEPS3_:
  534|    278|Lexicon<E>::Item::NameLinkage::next_ptr(Item *item) -> Item *& {
  535|    278|  return item->_name_link._next;
  536|    278|}
_ZN4swoc7_1_5_157LexiconImEC2ERKSt16initializer_listINS2_10DefinitionEENSt3__17variantIJNS8_9monostateEmNS0_8TextViewENS8_8functionIFmSB_EEENSC_IFSB_mEEEEEESH_:
  598|      2|template <typename E> Lexicon<E>::Lexicon(with_multi items, Default handler_1, Default handler_2) {
  599|     16|  for (auto const &item : items) {
  ------------------
  |  Branch (599:25): [True: 16, False: 2]
  ------------------
  600|     16|    this->define(item.value, item.names);
  601|     16|  }
  602|       |
  603|      4|  for (auto &&h : {handler_1, handler_2}) {
  ------------------
  |  Branch (603:17): [True: 4, False: 2]
  ------------------
  604|      4|    this->set_default(h);
  605|      4|  }
  606|      2|}
_ZN4swoc7_1_5_157LexiconImE6defineEmRKSt16initializer_listINS0_8TextViewEE:
  652|     16|Lexicon<E>::define(E value, const std::initializer_list<TextView> &names) -> self_type & {
  653|     16|  if (names.size() < 1) {
  ------------------
  |  Branch (653:7): [True: 0, False: 16]
  ------------------
  654|      0|    throw std::invalid_argument("A defined value must have at least a primary name");
  655|      0|  }
  656|     48|  for (auto const &name : names) {
  ------------------
  |  Branch (656:25): [True: 48, False: 16]
  ------------------
  657|     48|    if (_by_name.find(name) != _by_name.end()) {
  ------------------
  |  Branch (657:9): [True: 0, False: 48]
  ------------------
  658|      0|      throw std::invalid_argument(detail::what("Duplicate name '{}' in Lexicon", name));
  659|      0|    }
  660|     48|    auto i = _arena.make<Item>(value, this->localize(name));
  661|     48|    _by_name.insert(i);
  662|       |    // Only put primary names in the value table.
  663|     48|    if (_by_value.find(value) == _by_value.end()) {
  ------------------
  |  Branch (663:9): [True: 16, False: 32]
  ------------------
  664|     16|      _by_value.insert(i);
  665|     16|    }
  666|     48|  }
  667|     16|  return *this;
  668|     16|}
_ZN4swoc7_1_5_157LexiconImE4ItemC2EmNS0_8TextViewE:
  529|     48|template <typename E> Lexicon<E>::Item::Item(E value, TextView name) : _payload{value, name} {}
_ZN4swoc7_1_5_156detail17lexicon_pair_typeImEC2EmNS0_8TextViewE:
   52|     48|  lexicon_pair_type(E value, TextView name) : _value(value), _name(name) {}
_ZN4swoc7_1_5_157LexiconImE8localizeERKNS0_8TextViewE:
  626|     48|Lexicon<E>::localize(TextView const &name) {
  627|     48|  auto span = _arena.alloc_span<char>(name.size());
  628|     48|  memcpy(span, name);
  629|     48|  return {span.data(), span.size()};
  630|     48|}
_ZN4swoc7_1_5_157LexiconImE4Item11NameLinkage8prev_ptrEPS3_:
  540|    120|Lexicon<E>::Item::NameLinkage::prev_ptr(Item *item) -> Item *& {
  541|    120|  return item->_name_link._prev;
  542|    120|}
_ZN4swoc7_1_5_157LexiconImE4Item12ValueLinkage7hash_ofEm:
  576|     64|Lexicon<E>::Item::ValueLinkage::hash_of(E value) {
  577|     64|  return Lexicon_Hash<E>(value);
  578|     64|}
_ZN4swoc7_1_5_1512Lexicon_HashImEEmT_:
   61|     64|Lexicon_Hash(E e) {
   62|     64|  static constexpr std::hash<E> hasher;
   63|     64|  return hasher(e);
   64|     64|}
_ZN4swoc7_1_5_157LexiconImE4Item12ValueLinkage5equalEmm:
  588|     64|Lexicon<E>::Item::ValueLinkage::equal(E lhs, E rhs) {
  589|     64|  return lhs == rhs;
  590|     64|}
_ZN4swoc7_1_5_157LexiconImE4Item12ValueLinkage6key_ofEPS3_:
  564|     80|Lexicon<E>::Item::ValueLinkage::key_of(Item *item) {
  565|     80|  return item->_payload._value;
  566|     80|}
_ZN4swoc7_1_5_157LexiconImE4Item12ValueLinkage8next_ptrEPS3_:
  546|     62|Lexicon<E>::Item::ValueLinkage::next_ptr(Item *item) -> Item *& {
  547|     62|  return item->_value_link._next;
  548|     62|}
_ZN4swoc7_1_5_157LexiconImE4Item12ValueLinkage8prev_ptrEPS3_:
  552|     28|Lexicon<E>::Item::ValueLinkage::prev_ptr(Item *item) -> Item *& {
  553|     28|  return item->_value_link._prev;
  554|     28|}

_ZN4swoc7_1_5_158MemArena5Block4dataEv:
  605|    192|MemArena::Block::data() {
  606|    192|  return reinterpret_cast<char *>(this + 1);
  607|    192|}
_ZNK4swoc7_1_5_158MemArena5Block9remainingEv:
  631|    382|MemArena::Block::remaining() const {
  632|    382|  return size - allocated;
  633|    382|}
_ZN4swoc7_1_5_158MemArena5Block7remnantEv:
  654|     96|MemArena::Block::remnant() {
  655|     96|  return {this->data() + allocated, this->remaining()};
  656|     96|}
_ZN4swoc7_1_5_158MemArenaC2Em:
  701|      5|inline MemArena::MemArena(size_t n) : _reserve_hint(n) {}
_ZN4swoc7_1_5_158MemArena4makeINS0_7LexiconImE4ItemEJRmNS0_8TextViewEEEEPT_DpOT0_:
  711|     48|MemArena::make(Args &&...args) {
  712|     48|  return new (this->alloc(sizeof(T), alignof(T)).data()) T(std::forward<Args>(args)...);
  713|     48|}
_ZN4swoc7_1_5_158MemArena10alloc_spanIcEENS0_7MemSpanIT_EEm:
  705|     48|MemArena::alloc_span(size_t n) {
  706|     48|  return this->alloc(sizeof(T) * n, alignof(T)).rebind<T>();
  707|     48|}
_ZN4swoc7_1_5_158MemArena5Block7Linkage8next_ptrEPS2_:
  593|      2|MemArena::Block::Linkage::next_ptr(Block *b) -> Block *& {
  594|      2|  return b->_link._next;
  595|      2|}
_ZN4swoc7_1_5_158MemArena5Block7Linkage8prev_ptrEPS2_:
  598|      2|MemArena::Block::Linkage::prev_ptr(Block *b) -> Block *& {
  599|      2|  return b->_link._prev;
  600|      2|}
_ZNK4swoc7_1_5_158MemArena5Block4dataEv:
  610|     94|MemArena::Block::data() const {
  611|     94|  return reinterpret_cast<const char *>(this + 1);
  612|     94|}
_ZNK4swoc7_1_5_158MemArena5Block7is_fullEv:
  636|     96|MemArena::Block::is_full() const {
  637|     96|  return this->remaining() < MIN_FREE_SPACE;
  638|     96|}
_ZN4swoc7_1_5_158MemArena5Block5allocEmm:
  641|     96|MemArena::Block::alloc(size_t n, size_t align) {
  642|     96|  auto base = this->data() + allocated;
  643|     96|  auto pad  = align_padding(base, align);
  644|     96|  if ((n + pad) > this->remaining()) {
  ------------------
  |  Branch (644:7): [True: 0, False: 96]
  ------------------
  645|      0|    throw(std::invalid_argument{"MemArena::Block::alloc size is more than remaining."});
  646|      0|  }
  647|     96|  MemSpan<void> zret = this->remnant().prefix(n + pad);
  648|     96|  zret.remove_prefix(pad);
  649|     96|  allocated += n + pad;
  650|     96|  return zret;
  651|     96|}
_ZN4swoc7_1_5_158MemArena5BlocknwEmm:
  666|      2|{
  667|      2|  if (n < block_size) {
  ------------------
  |  Branch (667:7): [True: 0, False: 2]
  ------------------
  668|      0|    throw std::invalid_argument("MemArena::Block::operator new size is less than object size.");
  669|      0|  }
  670|       |  // In theory we could use ::operator new(n) but this causes a size mismatch during ::operator delete.
  671|       |  // Easier to use malloc here and also override @c delete.
  672|      2|  auto b = static_cast<Block *>(::malloc(n));
  673|      2|  if (b == nullptr) {
  ------------------
  |  Branch (673:7): [True: 0, False: 2]
  ------------------
  674|      0|    throw std::bad_alloc();
  675|      0|  }
  676|      2|  return b;
  677|      2|}
_ZN4swoc7_1_5_158MemArena5BlockdlEPv:
  685|      2|MemArena::Block::operator delete(void *ptr) noexcept {
  686|      2|  ::free(ptr);
  687|      2|}
_ZN4swoc7_1_5_158MemArena5Block13align_paddingEPKvm:
  694|    190|MemArena::Block::align_padding(void const *ptr, size_t align) {
  695|    190|  if (auto delta = uintptr_t(ptr) & (align - 1); delta > 0) {
  ------------------
  |  Branch (695:50): [True: 88, False: 102]
  ------------------
  696|     88|    return align - delta;
  697|     88|  }
  698|    102|  return 0;
  699|    190|}
_ZN4swoc7_1_5_158MemArena5BlockC2Em:
  602|      2|inline MemArena::Block::Block(size_t n) noexcept : size(n) {}

_ZNK4swoc7_1_5_157MemSpanIKvE4dataEv:
 1462|  2.05k|MemSpan<void const>::data() const {
 1463|  2.05k|  return _ptr;
 1464|  2.05k|}
_ZNK4swoc7_1_5_157MemSpanIKvE4sizeEv:
 1482|  2.05k|MemSpan<void const>::size() const {
 1483|  2.05k|  return _size;
 1484|  2.05k|}
_ZN4swoc7_1_5_157MemSpanIKvEC2INSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEvEERKT_:
 1363|  1.84k|  : _ptr(const_cast<std::remove_const_t<std::remove_reference_t<decltype(*(std::declval<C>().data()))>> *>(c.data())),
 1364|  1.84k|    _size(c.size() * sizeof(*(std::declval<C>().data()))) {}
_ZN4swoc7_1_5_157MemSpanIcEC2EPcm:
 1064|     48|template <typename T> constexpr MemSpan<T>::MemSpan(T *ptr, size_t count) : _ptr{ptr}, _count{count} {}
_ZNK4swoc7_1_5_157MemSpanIcE4dataEv:
 1154|     96|MemSpan<T>::data() const {
 1155|     96|  return _ptr;
 1156|     96|}
_ZNK4swoc7_1_5_157MemSpanIcE4sizeEv:
 1178|     48|MemSpan<T>::size() const {
 1179|     48|  return _count;
 1180|     48|}
_ZN4swoc7_1_5_156memcpyERNS0_7MemSpanIcEENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
 1002|     48|memcpy(MemSpan<char> &span, std::string_view view) {
 1003|     48|  return static_cast<char *>(std::memcpy(span.data(), view.data(), std::min(view.size(), view.size())));
 1004|     48|}
_ZNK4swoc7_1_5_157MemSpanIvE4dataEv:
 1467|     48|MemSpan<void>::data() const {
 1468|     48|  return _ptr;
 1469|     48|}
_ZNK4swoc7_1_5_157MemSpanIvE6rebindIcEENS1_IT_EEv:
 1658|     48|MemSpan<void>::rebind() const {
 1659|     48|  return {static_cast<U *>(_ptr), detail::is_span_compatible<value_type, U>::count(_size)};
 1660|     48|}
_ZN4swoc7_1_5_156detail18is_span_compatibleIvcE5countEm:
  920|     48|is_span_compatible<T, U>::count(size_t size) {
  921|     48|  if (size % sizeof(U)) {
  ------------------
  |  Branch (921:7): [True: 0, False: 48]
  ------------------
  922|      0|    throw std::invalid_argument("MemSpan rebind where span size is not a multiple of the element size");
  923|      0|  }
  924|     48|  return size / sizeof(U);
  925|     48|}
_ZN4swoc7_1_5_157MemSpanIvEC2Ev:
  660|     96|  constexpr MemSpan() = default;
_ZN4swoc7_1_5_157MemSpanIKvEC2Ev:
  400|     96|  constexpr MemSpan() = default;
_ZN4swoc7_1_5_157MemSpanIvEC2EPvm:
 1342|    192|inline constexpr MemSpan<void>::MemSpan(value_type *ptr, size_t n) : super_type(ptr, n) {}
_ZN4swoc7_1_5_157MemSpanIKvEC2EPS2_m:
 1341|    192|inline constexpr MemSpan<void const>::MemSpan(value_type *ptr, size_t n) : _ptr{const_cast<void *>(ptr)}, _size{n} {}
_ZN4swoc7_1_5_157MemSpanIKvEC2INS0_8TextViewEvEERKT_:
 1363|    205|  : _ptr(const_cast<std::remove_const_t<std::remove_reference_t<decltype(*(std::declval<C>().data()))>> *>(c.data())),
 1364|    205|    _size(c.size() * sizeof(*(std::declval<C>().data()))) {}
_ZN4swoc7_1_5_156detail7ptr_addEPvm:
  880|     96|ptr_add(void *ptr, size_t count) {
  881|     96|  return static_cast<char *>(ptr) + count;
  882|     96|}
_ZNK4swoc7_1_5_157MemSpanIvE6prefixEm:
 1512|     96|MemSpan<void>::prefix(size_t n) const -> self_type {
 1513|     96|  return {_ptr, std::min(n, _size)};
 1514|     96|}
_ZN4swoc7_1_5_157MemSpanIKvE13remove_prefixEm:
 1517|     96|MemSpan<void const>::remove_prefix(size_t n) -> self_type & {
 1518|     96|  n      = std::min(_size, n);
 1519|     96|  _size -= n;
 1520|     96|  _ptr   = detail::ptr_add(_ptr, n);
 1521|     96|  return *this;
 1522|     96|}
_ZN4swoc7_1_5_157MemSpanIvE13remove_prefixEm:
 1525|     96|MemSpan<void>::remove_prefix(size_t n) -> self_type & {
 1526|     96|  super_type::remove_prefix(n);
 1527|     96|  return *this;
 1528|     96|}

_ZN4swoc7_1_5_158round_upImEENS0_6detail22scalar_unit_round_up_tIT_EES4_:
  559|      4|round_up(C n) {
  560|      4|  return {n};
  561|      4|}
_ZNK4swoc7_1_5_156detail22scalar_unit_round_up_tImE5scaleILl16EiEET0_v:
  106|      2|  scale() const {
  107|      2|    return static_cast<I>(_n / N + (0 != (_n % N)));
  108|      2|  }
_ZNK4swoc7_1_5_156ScalarILl16EiNS0_3tag7genericEEcviEv:
  443|      2|template <intmax_t N, typename C, typename T> constexpr Scalar<N, C, T>::operator Counter() const {
  444|      2|  return _n * SCALE;
  445|      2|}
_ZN4swoc7_1_5_156ScalarILl16EiNS0_3tag7genericEEC2ImEENS0_6detail22scalar_unit_round_up_tIT_EE:
  425|      2|constexpr Scalar<N, C, T>::Scalar(detail::scalar_unit_round_up_t<I> v) : _n(v.template scale<N, C>()) {}
_ZN4swoc7_1_5_156ScalarILl1024EiNS0_3tag7genericEEC2ImEENS0_6detail22scalar_unit_round_up_tIT_EE:
  425|      2|constexpr Scalar<N, C, T>::Scalar(detail::scalar_unit_round_up_t<I> v) : _n(v.template scale<N, C>()) {}
_ZNK4swoc7_1_5_156detail22scalar_unit_round_up_tImE5scaleILl1024EiEET0_v:
  106|      2|  scale() const {
  107|      2|    return static_cast<I>(_n / N + (0 != (_n % N)));
  108|      2|  }
_ZNK4swoc7_1_5_156ScalarILl1024EiNS0_3tag7genericEEcviEv:
  443|      2|template <intmax_t N, typename C, typename T> constexpr Scalar<N, C, T>::operator Counter() const {
  444|      2|  return _n * SCALE;
  445|      2|}

_ZNK4swoc7_1_5_158TextViewdeEv:
 1153|  1.23k|TextView::operator*() const {
 1154|  1.23k|  return this->empty() ? char(0) : *(this->data());
  ------------------
  |  Branch (1154:10): [True: 0, False: 1.23k]
  ------------------
 1155|  1.23k|}
_ZNK4swoc7_1_5_158TextViewcvbEv:
 1162|    396|inline constexpr TextView::operator bool() const noexcept {
 1163|    396|  return !this->empty();
 1164|    396|}
_ZN4swoc7_1_5_158TextViewppEv:
 1167|    410|TextView::operator++() -> self_type & {
 1168|    410|  this->remove_prefix(1);
 1169|    410|  return *this;
 1170|    410|}
_ZN4swoc7_1_5_158TextViewaSERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
 1192|  1.02k|TextView::operator=(super_type const &that) -> self_type & {
 1193|  1.02k|  this->super_type::operator=(that);
 1194|  1.02k|  return *this;
 1195|  1.02k|}
_ZNK4swoc7_1_5_158TextView6prefixEm:
 1250|  2.63k|TextView::prefix(size_t n) const noexcept -> self_type {
 1251|  2.63k|  return {this->data(), std::min(n, this->size())};
 1252|  2.63k|}
_ZN4swoc7_1_5_158TextView13remove_prefixEm:
 1288|  4.85k|TextView::remove_prefix(size_t n) -> self_type & {
 1289|  4.85k|  this->super_type::remove_prefix(std::min(n, this->size()));
 1290|  4.85k|  return *this;
 1291|  4.85k|}
_ZN4swoc7_1_5_158TextView11take_prefixEm:
 1350|  2.63k|TextView::take_prefix(size_t n) {
 1351|  2.63k|  n              = std::min(n, this->size());
 1352|  2.63k|  self_type zret = this->prefix(n);
 1353|  2.63k|  this->remove_prefix(std::min(n + 1, this->size()));
 1354|  2.63k|  return zret;
 1355|  2.63k|}
_ZN4swoc7_1_5_158TextView14take_prefix_atEc:
 1358|  1.60k|TextView::take_prefix_at(char c) {
 1359|  1.60k|  return this->take_prefix(this->find(c));
 1360|  1.60k|}
_ZN4swoc7_1_5_158TextView13remove_suffixEm:
 1416|    378|TextView::remove_suffix(size_t n) -> self_type & {
 1417|    378|  this->super_type::remove_suffix(std::min(n, this->size()));
 1418|    378|  return *this;
 1419|    378|}
_ZNK4swoc7_1_5_158TextView4dataEv:
 1639|  11.6k|TextView::data() const noexcept -> value_type const * {
 1640|  11.6k|  return super_type::data();
 1641|  11.6k|}
_ZNK4swoc7_1_5_158TextView8data_endEv:
 1644|  2.56k|TextView::data_end() const noexcept -> value_type const * {
 1645|  2.56k|  return this->data() + this->size();
 1646|  2.56k|}
_ZNK4swoc7_1_5_158TextView6substrEmm:
 1649|    205|TextView::substr(size_type pos, size_type count) const noexcept {
 1650|    205|  if (pos >= this->size()) {
  ------------------
  |  Branch (1650:7): [True: 0, False: 205]
  ------------------
 1651|      0|    return {};
 1652|      0|  }
 1653|    205|  count = std::min(this->size() - pos, count);
 1654|    205|  return {this->data() + pos, count};
 1655|    205|}
_ZN4swoc7_1_5_158TextViewC2ERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
 1135|  3.03k|inline constexpr TextView::TextView(super_type const &that) noexcept : super_type(that) {}
_ZN4swoc7_1_5_158TextViewC2EPKcm:
 1127|  3.29k|  : super_type(ptr, n == npos ? (ptr ? ::strlen(ptr) : 0) : n) {}
  ------------------
  |  Branch (1127:21): [True: 0, False: 3.29k]
  |  Branch (1127:34): [True: 0, False: 0]
  ------------------
_ZN4swoc7_1_5_158TextViewC2ILm3EEERAT__Kc:
 1136|    205|template <size_t N> constexpr TextView::TextView(const char (&s)[N]) noexcept : super_type(s, s[N - 1] ? N : N - 1) {}
  ------------------
  |  Branch (1136:95): [True: 0, False: 205]
  ------------------
_ZN4swoc7_1_5_158TextViewC2Ev:
  100|  1.31k|  constexpr TextView() noexcept = default;
_ZN4swoc7_1_5_158TextView7trim_ifIPDoFiiEEERS1_RKT_:
 1634|    378|TextView::trim_if(F const &pred) {
 1635|    378|  return this->ltrim_if(pred).rtrim_if(pred);
 1636|    378|}
_ZN4swoc7_1_5_158TextView8ltrim_ifIPDoFiiEEERS1_RKT_:
 1612|    378|TextView::ltrim_if(F const &pred) {
 1613|    378|  const char *spot;
 1614|    378|  const char *limit;
 1615|  2.83k|  for (spot = this->data(), limit = this->data_end(); spot < limit && pred(*spot); ++spot)
  ------------------
  |  Branch (1615:55): [True: 2.81k, False: 20]
  |  Branch (1615:71): [True: 2.45k, False: 358]
  ------------------
 1616|  2.45k|    ;
 1617|    378|  this->remove_prefix(spot - this->data());
 1618|    378|  return *this;
 1619|    378|}
_ZN4swoc7_1_5_158TextView8rtrim_ifIPDoFiiEEERS1_RKT_:
 1623|    378|TextView::rtrim_if(F const &pred) {
 1624|    378|  const char *spot  = this->data_end();
 1625|    378|  const char *limit = this->data();
 1626|  2.68k|  while (limit < spot-- && pred(*spot))
  ------------------
  |  Branch (1626:10): [True: 2.66k, False: 20]
  |  Branch (1626:28): [True: 2.30k, False: 358]
  ------------------
 1627|  2.30k|    ;
 1628|    378|  this->remove_suffix(this->data_end() - (spot + 1));
 1629|    378|  return *this;
 1630|    378|}
_ZN4swoc7_1_5_158TextViewC2ILm8EEERAT__Kc:
 1136|    205|template <size_t N> constexpr TextView::TextView(const char (&s)[N]) noexcept : super_type(s, s[N - 1] ? N : N - 1) {}
  ------------------
  |  Branch (1136:95): [True: 0, False: 205]
  ------------------
_ZN4swoc7_1_5_158TextViewC2ILm6EEERAT__Kc:
 1136|    205|template <size_t N> constexpr TextView::TextView(const char (&s)[N]) noexcept : super_type(s, s[N - 1] ? N : N - 1) {}
  ------------------
  |  Branch (1136:95): [True: 0, False: 205]
  ------------------
_ZN4swoc7_1_5_158TextViewC2ILm7EEERAT__Kc:
 1136|    205|template <size_t N> constexpr TextView::TextView(const char (&s)[N]) noexcept : super_type(s, s[N - 1] ? N : N - 1) {}
  ------------------
  |  Branch (1136:95): [True: 0, False: 205]
  ------------------
_ZNK4swoc7_1_5_1513TransformViewIPDoFiiENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEcvbEv:
 1907|    552|template <typename X, typename V> TransformView<X, V>::operator bool() const {
 1908|    552|  return _spot != _limit;
 1909|    552|}
_ZNK4swoc7_1_5_1513TransformViewIPDoFiiENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEdeEv:
 1882|    456|TransformView<X, V>::operator*() const -> value_type {
 1883|    456|  return _xf(*_spot);
 1884|    456|}
_ZN4swoc7_1_5_1513TransformViewIPDoFiiENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEppEv:
 1888|    456|TransformView<X, V>::operator++() -> self_type & {
 1889|    456|  ++_spot;
 1890|    456|  return *this;
 1891|    456|}
_ZN4swoc7_1_5_1517transform_view_ofIPDoFiiENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEENS0_13TransformViewIT_T0_EERKSA_RKSB_:
 1933|     96|transform_view_of(X const &xf, V const &src) {
 1934|     96|  return TransformView<X, V>(xf, src);
 1935|     96|}
_ZN4swoc7_1_5_1513TransformViewIPDoFiiENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEC2ERKS3_RKS8_:
 1878|     96|  : _xf(xf), _spot(v.begin()), _limit(v.end()) {}
_ZN4swoc7_1_5_1510svto_radixILi10EEEmRNS0_8TextViewE:
 1059|  1.23k|svto_radix(TextView &src) {
 1060|  1.23k|  static_assert(1 <= RADIX && RADIX <= 36, "Radix must be in the range 2..36");
 1061|  1.23k|  static constexpr auto MAX            = std::numeric_limits<uintmax_t>::max();
 1062|  1.23k|  static constexpr auto OVERFLOW_LIMIT = MAX / RADIX;
 1063|  1.23k|  uintmax_t zret                       = 0;
 1064|  1.23k|  uintmax_t v;
 1065|  1.43k|  while (src.size() && ((v = swoc::svtoi_convert[uint8_t(*src)]) < RADIX)) {
  ------------------
  |  Branch (1065:10): [True: 205, False: 1.23k]
  |  Branch (1065:24): [True: 205, False: 0]
  ------------------
 1066|       |    // Tweaked for performance - need to check range after @a RADIX multiply.
 1067|    205|    ++src; // Update view iff the character is parsed.
 1068|    205|    if (zret <= OVERFLOW_LIMIT && v <= (MAX - (zret *= RADIX)) ) {
  ------------------
  |  Branch (1068:9): [True: 205, False: 0]
  |  Branch (1068:35): [True: 205, False: 0]
  ------------------
 1069|    205|      zret += v;
 1070|    205|    } else {
 1071|      0|      zret = MAX; // clamp to max - once set will always hit this case for subsequent input.
 1072|      0|    }
 1073|    205|  }
 1074|  1.23k|  return zret;
 1075|  1.23k|}
bw_format.cc:_ZNK4swoc7_1_5_158TextView7find_ifIZNS0_3bwf6Format17TextViewExtractor5parseERS1_RNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEESC_E3$_0EEmRKT_:
 1508|  1.43k|TextView::find_if(F const &pred) const {
 1509|  2.87k|  for (const char *spot = this->data(), *limit = this->data_end(); spot < limit; ++spot)
  ------------------
  |  Branch (1509:68): [True: 2.46k, False: 410]
  ------------------
 1510|  2.46k|    if (pred(*spot))
  ------------------
  |  Branch (1510:9): [True: 1.02k, False: 1.43k]
  ------------------
 1511|  1.02k|      return spot - this->data();
 1512|    410|  return npos;
 1513|  1.43k|}

_ZN4swoc7_1_5_1512BufferWriter9print_nfvIRKNS0_3bwf11NameBindingENS3_6Format17TextViewExtractorEEERS1_OT_OT0_RKNS3_7ArgPackE:
  865|    820|BufferWriter::print_nfv(Binding &&names, Extractor &&ex, bwf::ArgPack const &args) {
  866|    820|  using namespace std::literals;
  867|       |  // This gets the actual specifier type from the Extractor - it must be a subclass of @c bwf::Spec
  868|       |  // but this enables format extractors to use a subclass if additional data needs to be passed
  869|       |  // via the specifier.
  870|    820|  using spec_type =
  871|    820|    typename std::remove_reference<decltype(bwf::extractor_spec_type(&std::remove_reference<Extractor>::type::operator()))>::type;
  872|    820|  int N       = args.count();
  873|    820|  int arg_idx = 0; // the next argument index to be processed.
  874|       |
  875|       |  // Parser is required to return @c false if there's no more data, @c true if something was parsed.
  876|  2.25k|  while (ex) {
  ------------------
  |  Branch (876:10): [True: 1.43k, False: 820]
  ------------------
  877|  1.43k|    std::string_view lit_v;
  878|  1.43k|    spec_type spec;
  879|  1.43k|    bool spec_p = ex(lit_v, spec);
  880|       |
  881|       |    // If there's a literal, just ship it.
  882|  1.43k|    if (lit_v.size()) {
  ------------------
  |  Branch (882:9): [True: 1.02k, False: 410]
  ------------------
  883|  1.02k|      this->write(lit_v);
  884|  1.02k|    }
  885|       |
  886|  1.43k|    if (spec_p) {
  ------------------
  |  Branch (886:9): [True: 1.02k, False: 410]
  ------------------
  887|  1.02k|      if (spec._name.size() == 0) {
  ------------------
  |  Branch (887:11): [True: 1.02k, False: 0]
  ------------------
  888|  1.02k|        spec._idx = arg_idx++;
  889|  1.02k|      }
  890|       |
  891|  1.02k|      while (true) {
  ------------------
  |  Branch (891:14): [True: 1.02k, Folded]
  ------------------
  892|  1.02k|        size_t width = this->remaining();
  893|  1.02k|        if (spec._max < width) {
  ------------------
  |  Branch (893:13): [True: 0, False: 1.02k]
  ------------------
  894|      0|          width = spec._max;
  895|      0|        }
  896|       |
  897|  1.02k|        FixedBufferWriter lw{this->aux_data(), width};
  898|       |
  899|  1.02k|        if (0 <= spec._idx) {
  ------------------
  |  Branch (899:13): [True: 1.02k, False: 0]
  ------------------
  900|  1.02k|          if (spec._idx < N) {
  ------------------
  |  Branch (900:15): [True: 1.02k, False: 0]
  ------------------
  901|  1.02k|            if (spec._type == bwf::Spec::CAPTURE_TYPE) {
  ------------------
  |  Branch (901:17): [True: 0, False: 1.02k]
  ------------------
  902|      0|              bwf::arg_capture(ex, lw, spec, args.capture(spec._idx), swoc::meta::CaseArg);
  903|  1.02k|            } else {
  904|  1.02k|              args.print(lw, spec, spec._idx);
  905|  1.02k|            }
  906|  1.02k|          } else {
  907|      0|            bwf::Err_Bad_Arg_Index(lw, spec._idx, N);
  908|      0|          }
  909|  1.02k|        } else if (spec._name.size()) {
  ------------------
  |  Branch (909:20): [True: 0, False: 0]
  ------------------
  910|      0|          names(lw, spec);
  911|      0|        }
  912|  1.02k|        if (lw.extent()) {
  ------------------
  |  Branch (912:13): [True: 1.02k, False: 0]
  ------------------
  913|  1.02k|          bwf::Adjust_Alignment(lw, spec);
  914|  1.02k|          if (!this->commit(lw.extent())) {
  ------------------
  |  Branch (914:15): [True: 0, False: 1.02k]
  ------------------
  915|      0|            continue;
  916|      0|          }
  917|  1.02k|        }
  918|  1.02k|        break;
  919|  1.02k|      }
  920|  1.02k|    }
  921|  1.43k|  }
  922|    820|  return *this;
  923|    820|}
_ZNK4swoc7_1_5_153bwf6Format17TextViewExtractorcvbEv:
  536|  2.25k|inline Format::TextViewExtractor::operator bool() const {
  537|  2.25k|  return !_fmt.empty();
  538|  2.25k|}
_ZN4swoc7_1_5_153bwf4SpecC2Ev:
   50|  1.43k|  constexpr Spec() {}
_ZNK4swoc7_1_5_153bwf13ExternalNames4bindEv:
  617|    820|ExternalNames::bind() const {
  618|    820|  return *this;
  619|    820|}
_ZN4swoc7_1_5_153bwf6Format4bindENS0_8TextViewE:
  527|    820|Format::bind(swoc::TextView fmt) -> TextViewExtractor {
  528|    820|  return {fmt};
  529|    820|}
_ZN4swoc7_1_5_153bwf7ArgPackD2Ev:
  790|    820|  virtual ~ArgPack() = default; /// Force virtual destructor for subclasses.
_ZN4swoc7_1_5_153bwf4Spec8Get_PropEv:
  124|    615|  {
  125|    615|    static const Property prop;
  126|    615|    return prop;
  127|    615|  } ///< Character property map.
_ZN4swoc7_1_5_158bwformatERNS0_12BufferWriterERKNS0_3bwf4SpecEPKc:
 1046|    410|bwformat(BufferWriter &w, bwf::Spec const &spec, const char *v) {
 1047|    410|  if (spec._type == 'x' || spec._type == 'X' || spec._type == 'p' || spec._type == 'P') {
  ------------------
  |  Branch (1047:7): [True: 0, False: 410]
  |  Branch (1047:28): [True: 0, False: 410]
  |  Branch (1047:49): [True: 0, False: 410]
  |  Branch (1047:70): [True: 0, False: 410]
  ------------------
 1048|      0|    bwformat(w, spec, static_cast<const void *>(v));
 1049|    410|  } else if (v != nullptr) {
  ------------------
  |  Branch (1049:14): [True: 410, False: 0]
  ------------------
 1050|    410|    bwformat(w, spec, std::string_view(v));
 1051|    410|  } else {
 1052|      0|    bwformat(w, spec, nullptr);
 1053|      0|  }
 1054|    410|  return w;
 1055|    410|}
_ZN4swoc7_1_5_1512BufferWriter7print_vIJRPKcEEERS1_RKNS0_8TextViewERKNSt3__15tupleIJDpT_EEE:
  939|    205|BufferWriter::print_v(TextView const &fmt, std::tuple<Args...> const &args) {
  940|    205|  return this->print_nfv(bwf::Global_Names().bind(), bwf::Format::bind(fmt), bwf::ArgTuple{args});
  941|    205|}
_ZN4swoc7_1_5_153bwf8ArgTupleIJRPKcEEC2ERKNSt3__15tupleIJS5_EEE:
  826|    205|  ArgTuple(std::tuple<Args...> const &tuple) : _tuple(tuple) {}
_ZNK4swoc7_1_5_153bwf8ArgTupleIJRPKcEE5printERNS0_12BufferWriterERKNS1_4SpecEj:
  850|    205|ArgTuple<Args...>::print(BufferWriter &w, Spec const &spec, unsigned idx) const {
  851|    205|  static const auto _fa{bwf::Get_Arg_Formatter_Array<std::tuple<Args...>>(std::index_sequence_for<Args...>{})};
  852|    205|  return _fa[idx](w, spec, _tuple);
  853|    205|}
_ZN4swoc7_1_5_153bwf23Get_Arg_Formatter_ArrayINSt3__15tupleIJRPKcEEEJLm0EEEEPPFRNS0_12BufferWriterESA_RKNS1_4SpecERKT_ENS3_16integer_sequenceImJXspT0_EEEE:
  663|      1|Get_Arg_Formatter_Array(std::index_sequence<N...>) {
  664|      1|  static ArgFormatterSignature<TUPLE> fa[sizeof...(N)] = {&bwf::Arg_Formatter<TUPLE, N>...};
  665|      1|  return fa;
  666|      1|}
_ZN4swoc7_1_5_153bwf13Arg_FormatterINSt3__15tupleIJRPKcEEELm0EEERNS0_12BufferWriterESA_RKNS1_4SpecERKT_:
  653|    205|Arg_Formatter(BufferWriter &w, Spec const &spec, TUPLE const &args) {
  654|    205|  return bwformat(w, spec, std::get<I>(args));
  655|    205|}
_ZNK4swoc7_1_5_153bwf8ArgTupleIJRPKcEE5countEv:
  844|    205|ArgTuple<Args...>::count() const {
  845|    205|  return sizeof...(Args);
  846|    205|}
_ZN4swoc7_1_5_158bwformatIRxEENSt3__19enable_ifIXaasr3std9is_signedINS3_16remove_referenceIT_E4typeEEE5valuesr3std11is_integralIS8_EE5valueERNS0_12BufferWriterEE4typeESA_RKNS0_3bwf4SpecEOS6_:
 1109|    205|                          BufferWriter &>::type {
 1110|    205|  bool neg_p  = false;
 1111|    205|  uintmax_t n = static_cast<uintmax_t>(i);
 1112|    205|  if (i < 0) {
  ------------------
  |  Branch (1112:7): [True: 0, False: 205]
  ------------------
 1113|      0|    n     = static_cast<uintmax_t>(-i);
 1114|      0|    neg_p = true;
 1115|      0|  }
 1116|    205|  return bwf::Format_Integer(w, spec, n, neg_p);
 1117|    205|}
_ZN4swoc7_1_5_1517FixedBufferWriter5printIJRPKcEEERS1_NS0_8TextViewEDpOT_:
 1220|    205|FixedBufferWriter::print(TextView fmt, Args &&...args) -> self_type & {
 1221|    205|  return static_cast<self_type &>(this->super_type::print_v(fmt, std::forward_as_tuple(args...)));
 1222|    205|}
DbgCtl.cc:_ZN4swoc7_1_5_1517FixedBufferWriter5printIJN12_GLOBAL__N_113DiagTimestampEEEERS1_NS0_8TextViewEDpOT_:
 1220|    205|FixedBufferWriter::print(TextView fmt, Args &&...args) -> self_type & {
 1221|    205|  return static_cast<self_type &>(this->super_type::print_v(fmt, std::forward_as_tuple(args...)));
 1222|    205|}
DbgCtl.cc:_ZN4swoc7_1_5_1512BufferWriter7print_vIJRN12_GLOBAL__N_113DiagTimestampEEEERS1_RKNS0_8TextViewERKNSt3__15tupleIJDpT_EEE:
  939|    205|BufferWriter::print_v(TextView const &fmt, std::tuple<Args...> const &args) {
  940|    205|  return this->print_nfv(bwf::Global_Names().bind(), bwf::Format::bind(fmt), bwf::ArgTuple{args});
  941|    205|}
DbgCtl.cc:_ZN4swoc7_1_5_153bwf8ArgTupleIJRN12_GLOBAL__N_113DiagTimestampEEEC2ERKNSt3__15tupleIJS5_EEE:
  826|    205|  ArgTuple(std::tuple<Args...> const &tuple) : _tuple(tuple) {}
DbgCtl.cc:_ZNK4swoc7_1_5_153bwf8ArgTupleIJRN12_GLOBAL__N_113DiagTimestampEEE5printERNS0_12BufferWriterERKNS1_4SpecEj:
  850|    205|ArgTuple<Args...>::print(BufferWriter &w, Spec const &spec, unsigned idx) const {
  851|    205|  static const auto _fa{bwf::Get_Arg_Formatter_Array<std::tuple<Args...>>(std::index_sequence_for<Args...>{})};
  852|    205|  return _fa[idx](w, spec, _tuple);
  853|    205|}
DbgCtl.cc:_ZN4swoc7_1_5_153bwf23Get_Arg_Formatter_ArrayINSt3__15tupleIJRN12_GLOBAL__N_113DiagTimestampEEEEJLm0EEEEPPFRNS0_12BufferWriterESA_RKNS1_4SpecERKT_ENS3_16integer_sequenceImJXspT0_EEEE:
  663|      1|Get_Arg_Formatter_Array(std::index_sequence<N...>) {
  664|      1|  static ArgFormatterSignature<TUPLE> fa[sizeof...(N)] = {&bwf::Arg_Formatter<TUPLE, N>...};
  665|      1|  return fa;
  666|      1|}
DbgCtl.cc:_ZN4swoc7_1_5_153bwf13Arg_FormatterINSt3__15tupleIJRN12_GLOBAL__N_113DiagTimestampEEEELm0EEERNS0_12BufferWriterESA_RKNS1_4SpecERKT_:
  653|    205|Arg_Formatter(BufferWriter &w, Spec const &spec, TUPLE const &args) {
  654|    205|  return bwformat(w, spec, std::get<I>(args));
  655|    205|}
_ZN4swoc7_1_5_1517FixedBufferWriter5printIJxEEERS1_NS0_8TextViewEDpOT_:
 1220|    205|FixedBufferWriter::print(TextView fmt, Args &&...args) -> self_type & {
 1221|    205|  return static_cast<self_type &>(this->super_type::print_v(fmt, std::forward_as_tuple(args...)));
 1222|    205|}
_ZN4swoc7_1_5_1512BufferWriter7print_vIJRxEEERS1_RKNS0_8TextViewERKNSt3__15tupleIJDpT_EEE:
  939|    205|BufferWriter::print_v(TextView const &fmt, std::tuple<Args...> const &args) {
  940|    205|  return this->print_nfv(bwf::Global_Names().bind(), bwf::Format::bind(fmt), bwf::ArgTuple{args});
  941|    205|}
_ZN4swoc7_1_5_153bwf8ArgTupleIJRxEEC2ERKNSt3__15tupleIJS3_EEE:
  826|    205|  ArgTuple(std::tuple<Args...> const &tuple) : _tuple(tuple) {}
_ZNK4swoc7_1_5_153bwf8ArgTupleIJRxEE5printERNS0_12BufferWriterERKNS1_4SpecEj:
  850|    205|ArgTuple<Args...>::print(BufferWriter &w, Spec const &spec, unsigned idx) const {
  851|    205|  static const auto _fa{bwf::Get_Arg_Formatter_Array<std::tuple<Args...>>(std::index_sequence_for<Args...>{})};
  852|    205|  return _fa[idx](w, spec, _tuple);
  853|    205|}
_ZN4swoc7_1_5_153bwf23Get_Arg_Formatter_ArrayINSt3__15tupleIJRxEEEJLm0EEEEPPFRNS0_12BufferWriterES8_RKNS1_4SpecERKT_ENS3_16integer_sequenceImJXspT0_EEEE:
  663|      1|Get_Arg_Formatter_Array(std::index_sequence<N...>) {
  664|      1|  static ArgFormatterSignature<TUPLE> fa[sizeof...(N)] = {&bwf::Arg_Formatter<TUPLE, N>...};
  665|      1|  return fa;
  666|      1|}
_ZN4swoc7_1_5_153bwf13Arg_FormatterINSt3__15tupleIJRxEEELm0EEERNS0_12BufferWriterES8_RKNS1_4SpecERKT_:
  653|    205|Arg_Formatter(BufferWriter &w, Spec const &spec, TUPLE const &args) {
  654|    205|  return bwformat(w, spec, std::get<I>(args));
  655|    205|}
_ZNK4swoc7_1_5_153bwf8ArgTupleIJRxEE5countEv:
  844|    205|ArgTuple<Args...>::count() const {
  845|    205|  return sizeof...(Args);
  846|    205|}
DbgCtl.cc:_ZNK4swoc7_1_5_153bwf8ArgTupleIJRN12_GLOBAL__N_113DiagTimestampEEE5countEv:
  844|    205|ArgTuple<Args...>::count() const {
  845|    205|  return sizeof...(Args);
  846|    205|}
DbgCtl.cc:_ZN4swoc7_1_5_1517FixedBufferWriter5printIJN12_GLOBAL__N_114DiagThreadnameEPKcEEERS1_NS0_8TextViewEDpOT_:
 1220|    205|FixedBufferWriter::print(TextView fmt, Args &&...args) -> self_type & {
 1221|    205|  return static_cast<self_type &>(this->super_type::print_v(fmt, std::forward_as_tuple(args...)));
 1222|    205|}
DbgCtl.cc:_ZN4swoc7_1_5_1512BufferWriter7print_vIJRN12_GLOBAL__N_114DiagThreadnameERPKcEEERS1_RKNS0_8TextViewERKNSt3__15tupleIJDpT_EEE:
  939|    205|BufferWriter::print_v(TextView const &fmt, std::tuple<Args...> const &args) {
  940|    205|  return this->print_nfv(bwf::Global_Names().bind(), bwf::Format::bind(fmt), bwf::ArgTuple{args});
  941|    205|}
DbgCtl.cc:_ZN4swoc7_1_5_153bwf8ArgTupleIJRN12_GLOBAL__N_114DiagThreadnameERPKcEEC2ERKNSt3__15tupleIJS5_S8_EEE:
  826|    205|  ArgTuple(std::tuple<Args...> const &tuple) : _tuple(tuple) {}
DbgCtl.cc:_ZNK4swoc7_1_5_153bwf8ArgTupleIJRN12_GLOBAL__N_114DiagThreadnameERPKcEE5printERNS0_12BufferWriterERKNS1_4SpecEj:
  850|    410|ArgTuple<Args...>::print(BufferWriter &w, Spec const &spec, unsigned idx) const {
  851|    410|  static const auto _fa{bwf::Get_Arg_Formatter_Array<std::tuple<Args...>>(std::index_sequence_for<Args...>{})};
  852|    410|  return _fa[idx](w, spec, _tuple);
  853|    410|}
DbgCtl.cc:_ZN4swoc7_1_5_153bwf23Get_Arg_Formatter_ArrayINSt3__15tupleIJRN12_GLOBAL__N_114DiagThreadnameERPKcEEEJLm0ELm1EEEEPPFRNS0_12BufferWriterESD_RKNS1_4SpecERKT_ENS3_16integer_sequenceImJXspT0_EEEE:
  663|      1|Get_Arg_Formatter_Array(std::index_sequence<N...>) {
  664|      1|  static ArgFormatterSignature<TUPLE> fa[sizeof...(N)] = {&bwf::Arg_Formatter<TUPLE, N>...};
  665|      1|  return fa;
  666|      1|}
DbgCtl.cc:_ZN4swoc7_1_5_153bwf13Arg_FormatterINSt3__15tupleIJRN12_GLOBAL__N_114DiagThreadnameERPKcEEELm0EEERNS0_12BufferWriterESD_RKNS1_4SpecERKT_:
  653|    205|Arg_Formatter(BufferWriter &w, Spec const &spec, TUPLE const &args) {
  654|    205|  return bwformat(w, spec, std::get<I>(args));
  655|    205|}
DbgCtl.cc:_ZN4swoc7_1_5_153bwf13Arg_FormatterINSt3__15tupleIJRN12_GLOBAL__N_114DiagThreadnameERPKcEEELm1EEERNS0_12BufferWriterESD_RKNS1_4SpecERKT_:
  653|    205|Arg_Formatter(BufferWriter &w, Spec const &spec, TUPLE const &args) {
  654|    205|  return bwformat(w, spec, std::get<I>(args));
  655|    205|}
DbgCtl.cc:_ZNK4swoc7_1_5_153bwf8ArgTupleIJRN12_GLOBAL__N_114DiagThreadnameERPKcEE5countEv:
  844|    205|ArgTuple<Args...>::count() const {
  845|    205|  return sizeof...(Args);
  846|    205|}
_ZN4swoc7_1_5_153bwf7NameMapIFRNS0_12BufferWriterES4_RKNS1_4SpecEEEC2Ev:
  575|      1|template <typename F> NameMap<F>::NameMap() {}
_ZN4swoc7_1_5_153bwf4Spec8align_ofEc:
  482|    410|Spec::align_of(char c) {
  483|    410|  return static_cast<Align>(Get_Prop()._data[static_cast<unsigned>(c)] & Property::ALIGN_MASK);
  484|    410|}
_ZN4swoc7_1_5_153bwf4Spec7is_signEc:
  487|    205|Spec::is_sign(char c) {
  488|    205|  return Get_Prop()._data[static_cast<unsigned>(c)] & Property::SIGN_CHAR;
  489|    205|}

_ZNK4swoc7_1_5_1511Hash32FNV1a3getEv:
  197|     96|Hash32FNV1a::get() const -> value_type {
  198|     96|  return hval;
  199|     96|}
_ZN4swoc7_1_5_1511Hash32FNV1aC2Ev:
   41|     96|  Hash32FNV1a() = default;
_ZN4swoc7_1_5_1511Hash32FNV1a14hash_immediateIPDoFiiENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEjRKNS0_13TransformViewIT_T0_EE:
  203|     96|Hash32FNV1a::hash_immediate(swoc::TransformView<X, V> const &view) -> value_type {
  204|     96|  return this->update(view).get();
  205|     96|}
_ZN4swoc7_1_5_1511Hash32FNV1a6updateIPDoFiiENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEERS1_NS0_13TransformViewIT_T0_EE:
  178|     96|Hash32FNV1a::update(TransformView<X, V> view) -> self_type & {
  179|    552|  for (; view; ++view) {
  ------------------
  |  Branch (179:10): [True: 456, False: 96]
  ------------------
  180|    456|    hval ^= static_cast<value_type>(*view);
  181|    456|    hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
  182|    456|  }
  183|     96|  return *this;
  184|     96|}

_ZN4swoc7_1_5_158MemArenaC2EOS1_:
   38|      2|  : _active_allocated(that._active_allocated),
   39|      2|    _active_reserved(that._active_reserved),
   40|      2|    _frozen_allocated(that._frozen_allocated),
   41|      2|    _frozen_reserved(that._frozen_reserved),
   42|      2|    _reserve_hint(that._reserve_hint),
   43|      2|    _frozen(std::move(that._frozen)),
   44|      2|    _active(std::move(that._active)),
   45|      2|    _static_block(that._static_block) {
   46|       |  // Clear data in @a that to indicate all of the memory has been moved.
   47|      2|  that._active_allocated = that._active_reserved = 0;
   48|      2|  that._frozen_allocated = that._frozen_reserved = 0;
   49|      2|  that._reserve_hint                             = 0;
   50|      2|  that._static_block                             = nullptr;
   51|      2|}
_ZN4swoc7_1_5_158MemArena10make_blockEm:
   73|      2|MemArena::make_block(size_t n) {
   74|       |  // If there's no reservation hint, use the extent. This is transient because the hint is cleared.
   75|      2|  if (_reserve_hint == 0) {
  ------------------
  |  Branch (75:7): [True: 0, False: 2]
  ------------------
   76|      0|    if (_active_reserved) {
  ------------------
  |  Branch (76:9): [True: 0, False: 0]
  ------------------
   77|      0|      _reserve_hint = _active_reserved;
   78|      0|    } else if (_frozen_allocated) { // immediately after freezing - use that extent.
  ------------------
  |  Branch (78:16): [True: 0, False: 0]
  ------------------
   79|      0|      _reserve_hint = _frozen_allocated;
   80|      0|    }
   81|      0|  }
   82|      2|  n             = std::max<size_t>(n, _reserve_hint);
   83|      2|  _reserve_hint = 0; // did this, clear for next time.
   84|       |  // Add in overhead and round up to paragraph units.
   85|      2|  n = Paragraph{round_up(n + ALLOC_HEADER_SIZE + sizeof(Block))};
   86|       |  // If more than a page or withing a quarter page of a full page,
   87|       |  // round up to page unit size and clip back to account for alloc header.
   88|      2|  if (n >= (Page::SCALE - QuarterPage::SCALE)) {
  ------------------
  |  Branch (88:7): [True: 0, False: 2]
  ------------------
   89|      0|    n = Page{round_up(n)} - ALLOC_HEADER_SIZE;
   90|      2|  } else if (n >= QuarterPage::SCALE) { // if at least a quarter page, round up to quarter pages.
  ------------------
  |  Branch (90:14): [True: 2, False: 0]
  ------------------
   91|      2|    n = QuarterPage{round_up(n)};
   92|      2|  }
   93|       |
   94|       |  // Allocate space for the Block instance and the requested memory and construct a Block at the front.
   95|      2|  auto free_space   = n - sizeof(Block);
   96|      2|  _active_reserved += free_space;
   97|      2|  return new (n) Block(free_space);
   98|      2|}
_ZN4swoc7_1_5_158MemArena5allocEmm:
  101|     96|MemArena::alloc(size_t n, size_t align) {
  102|     96|  MemSpan<void> zret;
  103|     96|  this->require(n, align);
  104|     96|  auto block         = _active.head();
  105|     96|  zret               = block->alloc(n, align);
  106|     96|  _active_allocated += n;
  107|       |  // If this block is now full, move it to the back.
  108|     96|  if (block->is_full() && block != _active.tail()) {
  ------------------
  |  Branch (108:7): [True: 0, False: 96]
  |  Branch (108:27): [True: 0, False: 0]
  ------------------
  109|      0|    _active.erase(block);
  110|      0|    _active.append(block);
  111|      0|  }
  112|     96|  return zret;
  113|     96|}
_ZN4swoc7_1_5_158MemArena7requireEmm:
  150|     96|MemArena::require(size_t n, size_t align) {
  151|     96|  auto spot = _active.begin();
  152|     96|  Block *block{nullptr};
  153|       |
  154|       |  // Search back through the list until a full block is hit, which is a miss.
  155|     96|  while (spot != _active.end() && !spot->satisfies(n, align)) {
  ------------------
  |  Branch (155:10): [True: 94, False: 2]
  |  Branch (155:10): [True: 0, False: 96]
  |  Branch (155:35): [True: 0, False: 94]
  ------------------
  156|      0|    if (spot->is_full()) {
  ------------------
  |  Branch (156:9): [True: 0, False: 0]
  ------------------
  157|      0|      spot = _active.end();
  158|      0|    } else {
  159|      0|      ++spot;
  160|      0|    }
  161|      0|  }
  162|     96|  if (spot == _active.end()) {   // no block has enough free space
  ------------------
  |  Branch (162:7): [True: 2, False: 94]
  ------------------
  163|      2|    block = this->make_block(n); // assuming a new block is sufficiently aligned.
  164|      2|    _active.prepend(block);
  165|     94|  } else if (spot != _active.begin()) {
  ------------------
  |  Branch (165:14): [True: 0, False: 94]
  ------------------
  166|       |    // big enough space, move to the head of the list.
  167|      0|    block = spot;
  168|      0|    _active.erase(block);
  169|      0|    _active.prepend(block);
  170|      0|  }
  171|       |  // Invariant - the head active block has at least @a n bytes of free storage.
  172|     96|  return *this;
  173|     96|}
_ZN4swoc7_1_5_158MemArenaD2Ev:
  254|      7|MemArena::~MemArena() {
  255|       |  // Destruct in a way that makes it safe for the instance to be in one of its own memory blocks.
  256|       |  // This means copying members that will be used during the delete.
  257|      7|  Block *ba = _active.head();
  258|      7|  Block *bf = _frozen.head();
  259|      7|  Block *sb = _static_block;
  260|       |
  261|      7|  _active.clear();
  262|      7|  _frozen.clear();
  263|      7|  while (bf) {
  ------------------
  |  Branch (263:10): [True: 0, False: 7]
  ------------------
  264|      0|    Block *b = bf;
  265|      0|    bf       = bf->_link._next;
  266|      0|    if (b != sb) {
  ------------------
  |  Branch (266:9): [True: 0, False: 0]
  ------------------
  267|      0|      delete b;
  268|      0|    }
  269|      0|  }
  270|      9|  while (ba) {
  ------------------
  |  Branch (270:10): [True: 2, False: 7]
  ------------------
  271|      2|    Block *b = ba;
  272|      2|    ba       = ba->_link._next;
  273|      2|    if (b != sb) {
  ------------------
  |  Branch (273:9): [True: 2, False: 0]
  ------------------
  274|      2|      delete b;
  275|      2|    }
  276|      2|  }
  277|      7|}
_ZNK4swoc7_1_5_158MemArena5Block9satisfiesEmm:
   16|     94|MemArena::Block::satisfies(size_t n, size_t align) const {
   17|     94|  auto r = this->remaining();
   18|     94|  return r >= (n + align_padding(this->data() + allocated, align));
   19|     94|}

_ZN4swoc7_1_5_153bwf12Global_NamesEv:
   33|    820|ExternalNames& Global_Names() {
   34|    820|  static swoc::bwf::ExternalNames Global_Names;
   35|    820|  return Global_Names;
   36|    820|}
_ZN4swoc7_1_5_153bwf4Spec8PropertyC2Ev:
   42|      1|Spec::Property::Property() {
   43|      1|  memset(_data, 0, sizeof(_data));
   44|      1|  _data['b'] = TYPE_CHAR | NUMERIC_TYPE_CHAR;
   45|      1|  _data['B'] = TYPE_CHAR | NUMERIC_TYPE_CHAR | UPPER_TYPE_CHAR;
   46|      1|  _data['d'] = TYPE_CHAR | NUMERIC_TYPE_CHAR;
   47|      1|  _data['g'] = TYPE_CHAR;
   48|      1|  _data['o'] = TYPE_CHAR | NUMERIC_TYPE_CHAR;
   49|      1|  _data['p'] = TYPE_CHAR;
   50|      1|  _data['P'] = TYPE_CHAR | UPPER_TYPE_CHAR;
   51|      1|  _data['s'] = TYPE_CHAR;
   52|      1|  _data['S'] = TYPE_CHAR | UPPER_TYPE_CHAR;
   53|      1|  _data['x'] = TYPE_CHAR | NUMERIC_TYPE_CHAR;
   54|      1|  _data['X'] = TYPE_CHAR | NUMERIC_TYPE_CHAR | UPPER_TYPE_CHAR;
   55|       |
   56|      1|  _data[SIGN_NEVER]  = SIGN_CHAR;
   57|      1|  _data[SIGN_NEG]    = SIGN_CHAR;
   58|      1|  _data[SIGN_ALWAYS] = SIGN_CHAR;
   59|       |
   60|      1|  _data['<'] = static_cast<uint8_t>(Spec::Align::LEFT);
   61|      1|  _data['>'] = static_cast<uint8_t>(Spec::Align::RIGHT);
   62|      1|  _data['^'] = static_cast<uint8_t>(Spec::Align::CENTER);
   63|      1|  _data['='] = static_cast<uint8_t>(Spec::Align::SIGN);
   64|      1|}
_ZN4swoc7_1_5_153bwf4Spec5parseENS0_8TextViewE:
   72|  1.02k|Spec::parse(TextView fmt) {
   73|  1.02k|  TextView num; // temporary for number parsing.
   74|       |
   75|  1.02k|  _name = fmt.take_prefix_at(':');
   76|       |  // if it's parsable as a number, treat it as an index.
   77|  1.02k|  num    = _name;
   78|  1.02k|  auto n = svto_radix<10>(num);
   79|  1.02k|  if (num.empty()) {
  ------------------
  |  Branch (79:7): [True: 1.02k, False: 0]
  ------------------
   80|  1.02k|    _idx = static_cast<decltype(_idx)>(n);
   81|  1.02k|  }
   82|       |
   83|  1.02k|  if (fmt.size()) {
  ------------------
  |  Branch (83:7): [True: 205, False: 820]
  ------------------
   84|    205|    TextView sz = fmt.take_prefix_at(':'); // the format specifier.
   85|    205|    _ext        = fmt;                     // anything past the second ':' is the extension.
   86|    205|    if (sz.size()) {
  ------------------
  |  Branch (86:9): [True: 205, False: 0]
  ------------------
   87|       |      // fill and alignment
   88|    205|      if ('%' == *sz) { // enable URI encoding of the fill character so
  ------------------
  |  Branch (88:11): [True: 0, False: 205]
  ------------------
   89|       |        // metasyntactic chars can be used if needed.
   90|      0|        if (sz.size() < 4) {
  ------------------
  |  Branch (90:13): [True: 0, False: 0]
  ------------------
   91|      0|          throw std::invalid_argument("Fill URI encoding without 2 hex characters and align mark");
   92|      0|        }
   93|      0|        if (Align::NONE == (_align = align_of(sz[3]))) {
  ------------------
  |  Branch (93:13): [True: 0, False: 0]
  ------------------
   94|      0|          throw std::invalid_argument("Fill URI without alignment mark");
   95|      0|        }
   96|      0|        char d1 = sz[1], d0 = sz[2];
   97|      0|        if (!isxdigit(d0) || !isxdigit(d1)) {
  ------------------
  |  Branch (97:13): [True: 0, False: 0]
  |  Branch (97:30): [True: 0, False: 0]
  ------------------
   98|      0|          throw std::invalid_argument("URI encoding with non-hex characters");
   99|      0|        }
  100|      0|        _fill  = isdigit(d0) ? d0 - '0' : tolower(d0) - 'a' + 10;
  ------------------
  |  Branch (100:18): [True: 0, False: 0]
  ------------------
  101|      0|        _fill += (isdigit(d1) ? d1 - '0' : tolower(d1) - 'a' + 10) << 4;
  ------------------
  |  Branch (101:19): [True: 0, False: 0]
  ------------------
  102|      0|        sz    += 4;
  103|    205|      } else if (sz.size() > 1 && Align::NONE != (_align = align_of(sz[1]))) {
  ------------------
  |  Branch (103:18): [True: 205, False: 0]
  |  Branch (103:35): [True: 0, False: 205]
  ------------------
  104|      0|        _fill  = *sz;
  105|      0|        sz    += 2;
  106|    205|      } else if (Align::NONE != (_align = align_of(*sz))) {
  ------------------
  |  Branch (106:18): [True: 0, False: 205]
  ------------------
  107|      0|        ++sz;
  108|      0|      }
  109|    205|      if (!sz.size()) {
  ------------------
  |  Branch (109:11): [True: 0, False: 205]
  ------------------
  110|      0|        return true;
  111|      0|      }
  112|       |      // sign
  113|    205|      if (is_sign(*sz)) {
  ------------------
  |  Branch (113:11): [True: 0, False: 205]
  ------------------
  114|      0|        _sign = *sz;
  115|      0|        if (!(++sz).size()) {
  ------------------
  |  Branch (115:13): [True: 0, False: 0]
  ------------------
  116|      0|          return true;
  117|      0|        }
  118|      0|      }
  119|       |      // radix prefix
  120|    205|      if ('#' == *sz) {
  ------------------
  |  Branch (120:11): [True: 0, False: 205]
  ------------------
  121|      0|        _radix_lead_p = true;
  122|      0|        if (!(++sz).size()) {
  ------------------
  |  Branch (122:13): [True: 0, False: 0]
  ------------------
  123|      0|          return true;
  124|      0|        }
  125|      0|      }
  126|       |      // 0 fill for integers
  127|    205|      if ('0' == *sz) {
  ------------------
  |  Branch (127:11): [True: 205, False: 0]
  ------------------
  128|    205|        if (Align::NONE == _align) {
  ------------------
  |  Branch (128:13): [True: 205, False: 0]
  ------------------
  129|    205|          _align = Align::SIGN;
  130|    205|        }
  131|    205|        _fill = '0';
  132|    205|        ++sz;
  133|    205|      }
  134|    205|      num = sz;
  135|    205|      n   = svto_radix<10>(num);
  136|    205|      if (num.size() < sz.size()) {
  ------------------
  |  Branch (136:11): [True: 205, False: 0]
  ------------------
  137|    205|        _min = static_cast<decltype(_min)>(n);
  138|    205|        sz   = num;
  139|    205|        if (!sz.size()) {
  ------------------
  |  Branch (139:13): [True: 205, False: 0]
  ------------------
  140|    205|          return true;
  141|    205|        }
  142|    205|      }
  143|       |      // precision
  144|      0|      if ('.' == *sz) {
  ------------------
  |  Branch (144:11): [True: 0, False: 0]
  ------------------
  145|      0|        num = ++sz;
  146|      0|        n   = svto_radix<10>(num);
  147|      0|        if (num.size() < sz.size()) {
  ------------------
  |  Branch (147:13): [True: 0, False: 0]
  ------------------
  148|      0|          _prec = static_cast<decltype(_prec)>(n);
  149|      0|          sz    = num;
  150|      0|          if (!sz.size()) {
  ------------------
  |  Branch (150:15): [True: 0, False: 0]
  ------------------
  151|      0|            return true;
  152|      0|          }
  153|      0|        } else {
  154|      0|          throw std::invalid_argument("Precision mark without precision");
  155|      0|        }
  156|      0|      }
  157|       |      // style (type). Hex, octal, etc.
  158|      0|      if (is_type(*sz)) {
  ------------------
  |  Branch (158:11): [True: 0, False: 0]
  ------------------
  159|      0|        _type = *sz;
  160|      0|        if (!(++sz).size()) {
  ------------------
  |  Branch (160:13): [True: 0, False: 0]
  ------------------
  161|      0|          return true;
  162|      0|        }
  163|      0|      }
  164|       |      // maximum width
  165|      0|      if (',' == *sz) {
  ------------------
  |  Branch (165:11): [True: 0, False: 0]
  ------------------
  166|      0|        num = ++sz;
  167|      0|        n   = svto_radix<10>(num);
  168|      0|        if (num.size() < sz.size()) {
  ------------------
  |  Branch (168:13): [True: 0, False: 0]
  ------------------
  169|      0|          _max = static_cast<decltype(_max)>(n);
  170|      0|          sz   = num;
  171|      0|          if (!sz.size()) {
  ------------------
  |  Branch (171:15): [True: 0, False: 0]
  ------------------
  172|      0|            return true;
  173|      0|          }
  174|      0|        } else {
  175|      0|          throw std::invalid_argument("Maximum width mark without width");
  176|      0|        }
  177|       |        // Can only have a type indicator here if there was a max width.
  178|      0|        if (is_type(*sz)) {
  ------------------
  |  Branch (178:13): [True: 0, False: 0]
  ------------------
  179|      0|          _type = *sz;
  180|      0|          if (!(++sz).size()) {
  ------------------
  |  Branch (180:15): [True: 0, False: 0]
  ------------------
  181|      0|            return true;
  182|      0|          }
  183|      0|        }
  184|      0|      }
  185|      0|    }
  186|    205|  }
  187|    820|  return true;
  188|  1.02k|}
_ZN4swoc7_1_5_153bwf6Format17TextViewExtractor5parseERNS0_8TextViewERNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEESB_:
  195|  1.43k|Format::TextViewExtractor::parse(TextView &fmt, std::string_view &literal, std::string_view &specifier) {
  196|  1.43k|  TextView::size_type off = 0;
  197|       |
  198|       |  // Check for brace delimiters.
  199|  1.43k|  off = fmt.find_if([](char c) { return '{' == c || '}' == c; });
  200|  1.43k|  if (off == TextView::npos) {
  ------------------
  |  Branch (200:7): [True: 410, False: 1.02k]
  ------------------
  201|       |    // not found, it's a literal, ship it.
  202|    410|    literal = fmt;
  203|    410|    fmt.remove_prefix(literal.size());
  204|    410|    return false;
  205|    410|  }
  206|       |
  207|       |  // Processing for braces that don't enclose specifiers.
  208|  1.02k|  if (fmt.size() > off + 1) {
  ------------------
  |  Branch (208:7): [True: 1.02k, False: 0]
  ------------------
  209|  1.02k|    char c1 = fmt[off];
  210|  1.02k|    char c2 = fmt[off + 1];
  211|  1.02k|    if (c1 == c2) {
  ------------------
  |  Branch (211:9): [True: 0, False: 1.02k]
  ------------------
  212|       |      // double braces count as literals, but must tweak to output only 1 brace.
  213|      0|      literal = fmt.take_prefix(off + 1);
  214|      0|      return false;
  215|  1.02k|    } else if ('}' == c1) {
  ------------------
  |  Branch (215:16): [True: 0, False: 1.02k]
  ------------------
  216|      0|      throw std::invalid_argument("Unopened } in format string.");
  217|  1.02k|    } else {
  218|  1.02k|      literal = std::string_view{fmt.data(), off};
  219|  1.02k|      fmt.remove_prefix(off + 1);
  220|  1.02k|    }
  221|  1.02k|  } else {
  222|      0|    throw std::invalid_argument("Invalid trailing character in format string.");
  223|      0|  }
  224|       |
  225|  1.02k|  if (fmt.size()) {
  ------------------
  |  Branch (225:7): [True: 1.02k, False: 0]
  ------------------
  226|       |    // Need to be careful, because an empty format is OK and it's hard to tell
  227|       |    // if take_prefix_at failed to find the delimiter or found it as the first
  228|       |    // byte.
  229|  1.02k|    off = fmt.find('}');
  230|  1.02k|    if (off == TextView::npos) {
  ------------------
  |  Branch (230:9): [True: 0, False: 1.02k]
  ------------------
  231|      0|      throw std::invalid_argument("BWFormat: Unclosed { in format string");
  232|      0|    }
  233|  1.02k|    specifier = fmt.take_prefix(off);
  234|  1.02k|    return true;
  235|  1.02k|  }
  236|      0|  return false;
  237|  1.02k|}
_ZN4swoc7_1_5_153bwf6Format17TextViewExtractorclERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEERNS1_4SpecE:
  240|  1.43k|Format::TextViewExtractor::operator()(std::string_view &literal_v, Spec &spec) {
  241|  1.43k|  if (!_fmt.empty()) {
  ------------------
  |  Branch (241:7): [True: 1.43k, False: 0]
  ------------------
  242|  1.43k|    std::string_view spec_v;
  243|  1.43k|    if (parse(_fmt, literal_v, spec_v)) {
  ------------------
  |  Branch (243:9): [True: 1.02k, False: 410]
  ------------------
  244|  1.02k|      return spec.parse(spec_v);
  245|  1.02k|    }
  246|  1.43k|  }
  247|    410|  return false;
  248|  1.43k|}
_ZN4swoc7_1_5_153bwf16Adjust_AlignmentERNS0_12BufferWriterERKNS1_4SpecE:
  276|  1.02k|Adjust_Alignment(BufferWriter &aux, Spec const &spec) {
  277|  1.02k|  size_t extent = aux.extent();
  278|  1.02k|  size_t min    = spec._min;
  279|  1.02k|  if (extent < min) {
  ------------------
  |  Branch (279:7): [True: 0, False: 1.02k]
  ------------------
  280|      0|    size_t delta      = min - extent;
  281|      0|    size_t left_delta = 0, right_delta = delta; // left justify values
  282|      0|    if (Spec::Align::RIGHT == spec._align) {
  ------------------
  |  Branch (282:9): [True: 0, False: 0]
  ------------------
  283|      0|      left_delta  = delta;
  284|      0|      right_delta = 0;
  285|      0|    } else if (Spec::Align::CENTER == spec._align) {
  ------------------
  |  Branch (285:16): [True: 0, False: 0]
  ------------------
  286|      0|      left_delta  = delta / 2;
  287|      0|      right_delta = (delta + 1) / 2;
  288|      0|    }
  289|      0|    if (left_delta > 0) {
  ------------------
  |  Branch (289:9): [True: 0, False: 0]
  ------------------
  290|      0|      size_t work_area = extent + left_delta;
  291|      0|      aux.commit(left_delta);          // cover work area.
  292|      0|      aux.copy(left_delta, 0, extent); // move to create space for left fill.
  293|      0|      aux.discard(work_area);          // roll back to write the left fill.
  294|      0|      for (int i = left_delta; i > 0; --i) {
  ------------------
  |  Branch (294:32): [True: 0, False: 0]
  ------------------
  295|      0|        aux.write(spec._fill);
  296|      0|      }
  297|      0|      aux.commit(extent);
  298|      0|    }
  299|      0|    for (int i = right_delta; i > 0; --i) {
  ------------------
  |  Branch (299:31): [True: 0, False: 0]
  ------------------
  300|      0|      aux.write(spec._fill);
  301|      0|    }
  302|       |
  303|  1.02k|  } else {
  304|  1.02k|    size_t max = spec._max;
  305|  1.02k|    if (max < extent) {
  ------------------
  |  Branch (305:9): [True: 0, False: 1.02k]
  ------------------
  306|      0|      aux.discard(extent - max);
  307|      0|    }
  308|  1.02k|  }
  309|  1.02k|}
_ZN4swoc7_1_5_153bwf14Format_IntegerERNS0_12BufferWriterERKNS1_4SpecEmb:
  404|    205|Format_Integer(BufferWriter &w, Spec const &spec, uintmax_t i, bool neg_p) {
  405|    205|  size_t n     = 0;
  406|    205|  int width    = static_cast<int>(spec._min); // amount left to fill.
  407|    205|  char neg     = 0;
  408|    205|  char prefix1 = spec._radix_lead_p ? '0' : 0;
  ------------------
  |  Branch (408:18): [True: 0, False: 205]
  ------------------
  409|    205|  char prefix2 = 0;
  410|    205|  char buff[std::numeric_limits<uintmax_t>::digits + 1];
  411|       |
  412|    205|  if (spec._sign != Spec::SIGN_NEVER) {
  ------------------
  |  Branch (412:7): [True: 205, False: 0]
  ------------------
  413|    205|    if (neg_p) {
  ------------------
  |  Branch (413:9): [True: 0, False: 205]
  ------------------
  414|      0|      neg = '-';
  415|    205|    } else if (spec._sign == Spec::SIGN_ALWAYS) {
  ------------------
  |  Branch (415:16): [True: 0, False: 205]
  ------------------
  416|      0|      neg = spec._sign;
  417|      0|    }
  418|    205|  }
  419|       |
  420|    205|  switch (spec._type) {
  421|      0|  case 'x':
  ------------------
  |  Branch (421:3): [True: 0, False: 205]
  ------------------
  422|      0|    prefix2 = 'x';
  423|      0|    n       = bwf::To_Radix<16>(i, buff, sizeof(buff), bwf::LOWER_DIGITS);
  424|      0|    break;
  425|      0|  case 'X':
  ------------------
  |  Branch (425:3): [True: 0, False: 205]
  ------------------
  426|      0|    prefix2 = 'X';
  427|      0|    n       = bwf::To_Radix<16>(i, buff, sizeof(buff), bwf::UPPER_DIGITS);
  428|      0|    break;
  429|      0|  case 'b':
  ------------------
  |  Branch (429:3): [True: 0, False: 205]
  ------------------
  430|      0|    prefix2 = 'b';
  431|      0|    n       = bwf::To_Radix<2>(i, buff, sizeof(buff), bwf::LOWER_DIGITS);
  432|      0|    break;
  433|      0|  case 'B':
  ------------------
  |  Branch (433:3): [True: 0, False: 205]
  ------------------
  434|      0|    prefix2 = 'B';
  435|      0|    n       = bwf::To_Radix<2>(i, buff, sizeof(buff), bwf::UPPER_DIGITS);
  436|      0|    break;
  437|      0|  case 'o':
  ------------------
  |  Branch (437:3): [True: 0, False: 205]
  ------------------
  438|      0|    n = bwf::To_Radix<8>(i, buff, sizeof(buff), bwf::LOWER_DIGITS);
  439|      0|    break;
  440|    205|  default:
  ------------------
  |  Branch (440:3): [True: 205, False: 0]
  ------------------
  441|    205|    prefix1 = 0;
  442|    205|    n       = bwf::To_Radix<10>(i, buff, sizeof(buff), bwf::LOWER_DIGITS);
  443|    205|    break;
  444|    205|  }
  445|       |  // Clip fill width by stuff that's already committed to be written.
  446|    205|  if (neg) {
  ------------------
  |  Branch (446:7): [True: 0, False: 205]
  ------------------
  447|      0|    --width;
  448|      0|  }
  449|    205|  if (prefix1) {
  ------------------
  |  Branch (449:7): [True: 0, False: 205]
  ------------------
  450|      0|    --width;
  451|      0|    if (prefix2) {
  ------------------
  |  Branch (451:9): [True: 0, False: 0]
  ------------------
  452|      0|      --width;
  453|      0|    }
  454|      0|  }
  455|    205|  width -= static_cast<int>(n);
  456|    205|  std::string_view digits{buff + sizeof(buff) - n, n};
  457|       |
  458|    205|  if (spec._align == Spec::Align::SIGN) { // custom for signed case because
  ------------------
  |  Branch (458:7): [True: 205, False: 0]
  ------------------
  459|       |    // prefix and digits are seperated.
  460|    205|    if (neg) {
  ------------------
  |  Branch (460:9): [True: 0, False: 205]
  ------------------
  461|      0|      w.write(neg);
  462|      0|    }
  463|    205|    if (prefix1) {
  ------------------
  |  Branch (463:9): [True: 0, False: 205]
  ------------------
  464|      0|      w.write(prefix1);
  465|      0|      if (prefix2) {
  ------------------
  |  Branch (465:11): [True: 0, False: 0]
  ------------------
  466|      0|        w.write(prefix2);
  467|      0|      }
  468|      0|    }
  469|    205|    while (width-- > 0) {
  ------------------
  |  Branch (469:12): [True: 0, False: 205]
  ------------------
  470|      0|      w.write(spec._fill);
  471|      0|    }
  472|    205|    w.write(digits);
  473|    205|  } else { // use generic Write_Aligned
  474|      0|    Write_Aligned(
  475|      0|      w,
  476|      0|      [&]() {
  477|      0|        if (prefix1) {
  478|      0|          w.write(prefix1);
  479|      0|          if (prefix2) {
  480|      0|            w.write(prefix2);
  481|      0|          }
  482|      0|        }
  483|      0|        w.write(digits);
  484|      0|      },
  485|      0|      spec._align, width, spec._fill, neg);
  486|      0|  }
  487|    205|  return w;
  488|    205|}
_ZN4swoc7_1_5_153bwf11NameBindingD2Ev:
  644|      1|NameBinding::~NameBinding() = default;
_ZN4swoc7_1_5_158bwformatERNS0_12BufferWriterERKNS0_3bwf4SpecENSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
  649|    615|bwformat(BufferWriter &w, bwf::Spec const &spec, std::string_view sv) {
  650|    615|  auto width = int(spec._min); // amount to fill.
  651|    615|  if (spec._prec > 0) {
  ------------------
  |  Branch (651:7): [True: 0, False: 615]
  ------------------
  652|      0|    sv = sv.substr(0, spec._prec);
  653|      0|  }
  654|    615|  if ('x' == spec._type || 'X' == spec._type) {
  ------------------
  |  Branch (654:7): [True: 0, False: 615]
  |  Branch (654:28): [True: 0, False: 615]
  ------------------
  655|      0|    return bwformat(w, spec, bwf::HexDump(sv.data(), sv.size()));
  656|    615|  } else if ('s' == spec._type) {
  ------------------
  |  Branch (656:14): [True: 0, False: 615]
  ------------------
  657|      0|    bwformat(w, spec, transform_view_of(&tolower, sv));
  658|    615|  } else if ('S' == spec._type) {
  ------------------
  |  Branch (658:14): [True: 0, False: 615]
  ------------------
  659|      0|    bwformat(w, spec, transform_view_of(&toupper, sv));
  660|    615|  } else {
  661|    615|    width -= sv.size();
  662|    615|    bwf::Write_Aligned(
  663|    615|      w, [&w, &sv]() { w.write(sv); }, spec._align, width, spec._fill, 0);
  664|    615|  }
  665|    615|  return w;
  666|    615|}
bw_format.cc:_ZZN4swoc7_1_5_153bwf6Format17TextViewExtractor5parseERNS0_8TextViewERNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEESB_ENK3$_0clEc:
  199|  2.46k|  off = fmt.find_if([](char c) { return '{' == c || '}' == c; });
  ------------------
  |  Branch (199:41): [True: 1.02k, False: 1.43k]
  |  Branch (199:53): [True: 0, False: 1.43k]
  ------------------
_ZN4swoc7_1_5_153bwf8To_RadixILm10EEEmmPcmS3_:
  327|    205|To_Radix(uintmax_t n, char *buff, size_t width, char *digits) {
  328|    205|  static_assert(1 < RADIX && RADIX <= 36, "RADIX must be in the range 2..36");
  329|    205|  char *out = buff + width;
  330|    205|  if (n) {
  ------------------
  |  Branch (330:7): [True: 205, False: 0]
  ------------------
  331|    820|    while (n) {
  ------------------
  |  Branch (331:12): [True: 615, False: 205]
  ------------------
  332|    615|      *--out  = digits[n % RADIX];
  333|    615|      n      /= RADIX;
  334|    615|    }
  335|    205|  } else {
  336|      0|    *--out = '0';
  337|      0|  }
  338|    205|  return (buff + width) - out;
  339|    205|}
bw_format.cc:_ZN4swoc7_1_5_153bwf13Write_AlignedIZNS0_8bwformatERNS0_12BufferWriterERKNS1_4SpecENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEEE3$_0EEvS4_RKT_NS5_5AlignEicc:
  353|    615|Write_Aligned(BufferWriter &w, F const &f, Spec::Align align, int width, char fill, char neg) {
  354|    615|  switch (align) {
  355|      0|  case Spec::Align::LEFT:
  ------------------
  |  Branch (355:3): [True: 0, False: 615]
  ------------------
  356|      0|    if (neg) {
  ------------------
  |  Branch (356:9): [True: 0, False: 0]
  ------------------
  357|      0|      w.write(neg);
  358|      0|    }
  359|      0|    f();
  360|      0|    while (width-- > 0) {
  ------------------
  |  Branch (360:12): [True: 0, False: 0]
  ------------------
  361|      0|      w.write(fill);
  362|      0|    }
  363|      0|    break;
  364|      0|  case Spec::Align::RIGHT:
  ------------------
  |  Branch (364:3): [True: 0, False: 615]
  ------------------
  365|      0|    while (width-- > 0) {
  ------------------
  |  Branch (365:12): [True: 0, False: 0]
  ------------------
  366|      0|      w.write(fill);
  367|      0|    }
  368|      0|    if (neg) {
  ------------------
  |  Branch (368:9): [True: 0, False: 0]
  ------------------
  369|      0|      w.write(neg);
  370|      0|    }
  371|      0|    f();
  372|      0|    break;
  373|      0|  case Spec::Align::CENTER:
  ------------------
  |  Branch (373:3): [True: 0, False: 615]
  ------------------
  374|      0|    for (int i = width / 2; i > 0; --i) {
  ------------------
  |  Branch (374:29): [True: 0, False: 0]
  ------------------
  375|      0|      w.write(fill);
  376|      0|    }
  377|      0|    if (neg) {
  ------------------
  |  Branch (377:9): [True: 0, False: 0]
  ------------------
  378|      0|      w.write(neg);
  379|      0|    }
  380|      0|    f();
  381|      0|    for (int i = (width + 1) / 2; i > 0; --i) {
  ------------------
  |  Branch (381:35): [True: 0, False: 0]
  ------------------
  382|      0|      w.write(fill);
  383|      0|    }
  384|      0|    break;
  385|      0|  case Spec::Align::SIGN:
  ------------------
  |  Branch (385:3): [True: 0, False: 615]
  ------------------
  386|      0|    if (neg) {
  ------------------
  |  Branch (386:9): [True: 0, False: 0]
  ------------------
  387|      0|      w.write(neg);
  388|      0|    }
  389|      0|    while (width-- > 0) {
  ------------------
  |  Branch (389:12): [True: 0, False: 0]
  ------------------
  390|      0|      w.write(fill);
  391|      0|    }
  392|      0|    f();
  393|      0|    break;
  394|    615|  default:
  ------------------
  |  Branch (394:3): [True: 615, False: 0]
  ------------------
  395|    615|    if (neg) {
  ------------------
  |  Branch (395:9): [True: 0, False: 615]
  ------------------
  396|      0|      w.write(neg);
  397|      0|    }
  398|    615|    f();
  399|    615|    break;
  400|    615|  }
  401|    615|}
bw_format.cc:_ZZN4swoc7_1_5_158bwformatERNS0_12BufferWriterERKNS0_3bwf4SpecENSt3__117basic_string_viewIcNS7_11char_traitsIcEEEEENK3$_0clEv:
  663|    615|      w, [&w, &sv]() { w.write(sv); }, spec._align, width, spec._fill, 0);

_Z10strcasecmpRKNSt3__117basic_string_viewIcNS_11char_traitsIcEEEES5_:
   30|    184|strcasecmp(const std::string_view &lhs, const std::string_view &rhs) {
   31|    184|  int zret = 0;
   32|    184|  size_t n = rhs.size();
   33|       |
   34|       |  // Seems a bit ugly but size comparisons must be done anyway to get the @c strncasecmp args.
   35|    184|  if (lhs.size() < rhs.size()) {
  ------------------
  |  Branch (35:7): [True: 92, False: 92]
  ------------------
   36|     92|    zret = 1;
   37|     92|    n    = lhs.size();
   38|     92|  } else if (lhs.size() > rhs.size()) {
  ------------------
  |  Branch (38:14): [True: 72, False: 20]
  ------------------
   39|     72|    zret = -1;
   40|     72|  } else if (lhs.data() == rhs.data()) { // the same memory, obviously equal.
  ------------------
  |  Branch (40:14): [True: 0, False: 20]
  ------------------
   41|      0|    return 0;
   42|      0|  }
   43|       |
   44|    184|  int r = ::strncasecmp(lhs.data(), rhs.data(), n);
   45|       |
   46|    184|  return r ? r : zret;
  ------------------
  |  Branch (46:10): [True: 168, False: 16]
  ------------------
   47|    184|}

_ZN9ProcessorC2Ev:
   54|      4|Processor::Processor() {} /* End Processor::Processor() */

_ZN14EventProcessorC2Ev:
  366|      2|EventProcessor::EventProcessor() : thread_initializer(this)
  367|      2|{
  368|      2|  ink_zero(all_ethreads);
  369|      2|  ink_zero(all_dthreads);
  370|      2|  ink_mutex_init(&dedicated_thread_spawn_mutex);
  371|       |  // Because ET_NET is compile time set to 0 it *must* be the first type registered.
  372|      2|  this->register_event_type("ET_NET");
  373|      2|}
_ZN14EventProcessor19register_event_typeEPKc:
  416|      2|{
  417|      2|  ThreadGroupDescriptor *tg = &(thread_group[n_thread_groups++]);
  418|      2|  ink_release_assert(n_thread_groups <= MAX_EVENT_TYPES); // check for overflow
  ------------------
  |  |   48|      2|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  419|       |
  420|      2|  tg->_name = name;
  421|      2|  return n_thread_groups - 1;
  422|      2|}
_ZN25ThreadAffinityInitializerC2Ev:
   59|      2|  ThreadAffinityInitializer() { SET_HANDLER(&self::set_affinity); }
  ------------------
  |  |  253|      2|#define SET_HANDLER(_h) (handler = continuation_handler_void_ptr(_h))
  ------------------
UnixEventProcessor.cc:_ZN12_GLOBAL__N_116ThreadInitByFuncC2Ev:
  160|      2|  ThreadInitByFunc() { SET_HANDLER(&ThreadInitByFunc::invoke); }
  ------------------
  |  |  253|      2|#define SET_HANDLER(_h) (handler = continuation_handler_void_ptr(_h))
  ------------------

_Z48ts_session_protocol_well_known_name_indices_initv:
  759|    223|{
  760|       |  // register all the well known protocols and get the indices set.
  761|    223|  TS_ALPN_PROTOCOL_INDEX_HTTP_0_9   = globalSessionProtocolNameRegistry.toIndexConst(std::string_view{TS_ALPN_PROTOCOL_HTTP_0_9});
  762|    223|  TS_ALPN_PROTOCOL_INDEX_HTTP_1_0   = globalSessionProtocolNameRegistry.toIndexConst(std::string_view{TS_ALPN_PROTOCOL_HTTP_1_0});
  763|    223|  TS_ALPN_PROTOCOL_INDEX_HTTP_1_1   = globalSessionProtocolNameRegistry.toIndexConst(std::string_view{TS_ALPN_PROTOCOL_HTTP_1_1});
  764|    223|  TS_ALPN_PROTOCOL_INDEX_HTTP_2_0   = globalSessionProtocolNameRegistry.toIndexConst(std::string_view{TS_ALPN_PROTOCOL_HTTP_2_0});
  765|    223|  TS_ALPN_PROTOCOL_INDEX_HTTP_3     = globalSessionProtocolNameRegistry.toIndexConst(std::string_view{TS_ALPN_PROTOCOL_HTTP_3});
  766|    223|  TS_ALPN_PROTOCOL_INDEX_HTTP_3_D29 = globalSessionProtocolNameRegistry.toIndexConst(std::string_view{TS_ALPN_PROTOCOL_HTTP_3_D29});
  767|    223|  TS_ALPN_PROTOCOL_INDEX_HTTP_QUIC  = globalSessionProtocolNameRegistry.toIndexConst(std::string_view{TS_ALPN_PROTOCOL_HTTP_QUIC});
  768|    223|  TS_ALPN_PROTOCOL_INDEX_HTTP_QUIC_D29 =
  769|    223|    globalSessionProtocolNameRegistry.toIndexConst(std::string_view{TS_ALPN_PROTOCOL_HTTP_QUIC_D29});
  770|       |
  771|       |  // Now do the predefined protocol sets.
  772|    223|  HTTP_PROTOCOL_SET.markIn(TS_ALPN_PROTOCOL_INDEX_HTTP_0_9);
  773|    223|  HTTP_PROTOCOL_SET.markIn(TS_ALPN_PROTOCOL_INDEX_HTTP_1_0);
  774|    223|  HTTP_PROTOCOL_SET.markIn(TS_ALPN_PROTOCOL_INDEX_HTTP_1_1);
  775|    223|  HTTP2_PROTOCOL_SET.markIn(TS_ALPN_PROTOCOL_INDEX_HTTP_2_0);
  776|       |
  777|    223|  DEFAULT_TLS_SESSION_PROTOCOL_SET.markAllIn();
  778|    223|  DEFAULT_TLS_SESSION_PROTOCOL_SET.markOut(TS_ALPN_PROTOCOL_INDEX_HTTP_3);
  779|    223|  DEFAULT_TLS_SESSION_PROTOCOL_SET.markOut(TS_ALPN_PROTOCOL_INDEX_HTTP_QUIC);
  780|       |
  781|    223|  DEFAULT_QUIC_SESSION_PROTOCOL_SET.markIn(TS_ALPN_PROTOCOL_INDEX_HTTP_3);
  782|    223|  DEFAULT_QUIC_SESSION_PROTOCOL_SET.markIn(TS_ALPN_PROTOCOL_INDEX_HTTP_QUIC);
  783|    223|  DEFAULT_QUIC_SESSION_PROTOCOL_SET.markIn(TS_ALPN_PROTOCOL_INDEX_HTTP_3_D29);
  784|    223|  DEFAULT_QUIC_SESSION_PROTOCOL_SET.markIn(TS_ALPN_PROTOCOL_INDEX_HTTP_QUIC_D29);
  785|       |
  786|    223|  DEFAULT_NON_TLS_SESSION_PROTOCOL_SET = HTTP_PROTOCOL_SET;
  787|       |
  788|    223|  TSProtoTags.insert(TS_PROTO_TAG_HTTP_1_0);
  789|    223|  TSProtoTags.insert(TS_PROTO_TAG_HTTP_1_1);
  790|    223|  TSProtoTags.insert(TS_PROTO_TAG_HTTP_2_0);
  791|    223|  TSProtoTags.insert(TS_PROTO_TAG_HTTP_3);
  792|    223|  TSProtoTags.insert(TS_PROTO_TAG_HTTP_QUIC);
  793|    223|  TSProtoTags.insert(TS_PROTO_TAG_HTTP_3_D29);
  794|    223|  TSProtoTags.insert(TS_PROTO_TAG_HTTP_QUIC_D29);
  795|    223|  TSProtoTags.insert(TS_PROTO_TAG_TLS_1_3);
  796|    223|  TSProtoTags.insert(TS_PROTO_TAG_TLS_1_2);
  797|    223|  TSProtoTags.insert(TS_PROTO_TAG_TLS_1_1);
  798|    223|  TSProtoTags.insert(TS_PROTO_TAG_TLS_1_0);
  799|    223|  TSProtoTags.insert(TS_PROTO_TAG_TCP);
  800|    223|  TSProtoTags.insert(TS_PROTO_TAG_UDP);
  801|    223|  TSProtoTags.insert(TS_PROTO_TAG_IPV4);
  802|    223|  TSProtoTags.insert(TS_PROTO_TAG_IPV6);
  803|    223|}
_ZN27SessionProtocolNameRegistry32convert_openssl_alpn_wire_formatEi:
  821|    180|{
  822|    180|  if (index == TS_ALPN_PROTOCOL_INDEX_HTTP_0_9) {
  ------------------
  |  Branch (822:7): [True: 0, False: 180]
  ------------------
  823|      0|    return TS_ALPN_PROTO_ID_OPENSSL_HTTP_0_9;
  824|    180|  } else if (index == TS_ALPN_PROTOCOL_INDEX_HTTP_1_0) {
  ------------------
  |  Branch (824:14): [True: 15, False: 165]
  ------------------
  825|     15|    return TS_ALPN_PROTO_ID_OPENSSL_HTTP_1_0;
  826|    165|  } else if (index == TS_ALPN_PROTOCOL_INDEX_HTTP_1_1) {
  ------------------
  |  Branch (826:14): [True: 25, False: 140]
  ------------------
  827|     25|    return TS_ALPN_PROTO_ID_OPENSSL_HTTP_1_1;
  828|    140|  } else if (index == TS_ALPN_PROTOCOL_INDEX_HTTP_2_0) {
  ------------------
  |  Branch (828:14): [True: 140, False: 0]
  ------------------
  829|    140|    return TS_ALPN_PROTO_ID_OPENSSL_HTTP_2;
  830|    140|  } else if (index == TS_ALPN_PROTOCOL_INDEX_HTTP_3) {
  ------------------
  |  Branch (830:14): [True: 0, False: 0]
  ------------------
  831|      0|    return TS_ALPN_PROTO_ID_OPENSSL_HTTP_3;
  832|      0|  }
  833|       |
  834|      0|  return {};
  835|    180|}
_ZN27SessionProtocolNameRegistry12toIndexConstEN4swoc7_1_5_158TextViewE:
  858|  1.78k|{
  859|  1.78k|  int zret = this->indexFor(name);
  860|  1.78k|  if (INVALID == zret) {
  ------------------
  |  Branch (860:7): [True: 8, False: 1.77k]
  ------------------
  861|      8|    if (m_n < MAX) {
  ------------------
  |  Branch (861:9): [True: 8, False: 0]
  ------------------
  862|      8|      m_names[m_n] = name;
  863|      8|      zret         = m_n++;
  864|      8|    } else {
  865|      0|      ink_release_assert(!"Session protocol name registry overflow");
  ------------------
  |  |   48|      0|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [Folded, False: 0]
  |  |  ------------------
  ------------------
  866|      0|    }
  867|      8|  }
  868|  1.78k|  return zret;
  869|  1.78k|}
_ZNK27SessionProtocolNameRegistry8indexForEN4swoc7_1_5_158TextViewE:
  873|  2.12k|{
  874|  2.12k|  const swoc::TextView *end  = m_names.begin() + m_n;
  875|  2.12k|  auto                  spot = std::find(m_names.begin(), end, name);
  876|  2.12k|  if (spot != end) {
  ------------------
  |  Branch (876:7): [True: 1.96k, False: 161]
  ------------------
  877|  1.96k|    return static_cast<int>(spot - m_names.begin());
  878|  1.96k|  }
  879|    161|  return INVALID;
  880|  2.12k|}
_Z27convert_alpn_to_wire_formatNSt3__117basic_string_viewIcNS_11char_traitsIcEEEEPhRi:
  890|    223|{
  891|       |  // TODO: once the protocols_sv is switched to be a TextView (see the TODO
  892|       |  // comment in this functions doxygen comment), then rename the input
  893|       |  // parameter to be simply `protocols` and remove this next line.
  894|    223|  TextView protocols(protocols_sv);
  895|       |  // Callers expect wire_format_buffer_len to be zero'd out in the event of an
  896|       |  // error. To simplify the error handling from doing this on every return, we
  897|       |  // simply zero them out here at the start.
  898|    223|  auto const orig_wire_format_buffer_len = wire_format_buffer_len;
  899|    223|  memset(wire_format_buffer, 0, wire_format_buffer_len);
  900|    223|  wire_format_buffer_len = 0;
  901|       |
  902|    223|  if (protocols.empty()) {
  ------------------
  |  Branch (902:7): [True: 0, False: 223]
  ------------------
  903|      0|    return false;
  904|      0|  }
  905|       |
  906|       |  // Parse the comma separated protocol string into a list of protocol names.
  907|    223|  std::vector<std::string_view> alpn_protocols;
  908|    223|  TextView                      protocol;
  909|    223|  int                           computed_alpn_array_len = 0;
  910|       |
  911|    396|  while (protocols) {
  ------------------
  |  Branch (911:10): [True: 378, False: 18]
  ------------------
  912|    378|    protocol = protocols.take_prefix_at(',').trim_if(&isspace);
  913|    378|    if (protocol.empty()) {
  ------------------
  |  Branch (913:9): [True: 20, False: 358]
  ------------------
  914|     20|      Error("Empty protocol name in configured ALPN list: \"%.*s\"", static_cast<int>(protocols.size()), protocols.data());
  ------------------
  |  |   89|     20|#define Error(...)     DiagsError(DL_Error, __VA_ARGS__)     // Log operational failure, fail CI
  |  |  ------------------
  |  |  |  |   80|     20|  do {                                                                  \
  |  |  |  |   81|     20|    static const SourceLocation DiagsError_loc = MakeSourceLocation();  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   32|     20|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  |  |  ------------------
  |  |  |  |   82|     20|    static LogMessage           DiagsError_log_message;                 \
  |  |  |  |   83|     20|    DiagsError_log_message.message(LEVEL, DiagsError_loc, __VA_ARGS__); \
  |  |  |  |   84|     20|  } while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (84:12): [Folded, False: 20]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  915|     20|      return false;
  916|     20|    }
  917|    358|    if (protocol.size() > 255) {
  ------------------
  |  Branch (917:9): [True: 19, False: 339]
  ------------------
  918|       |      // The length has to fit in one byte.
  919|     19|      Error("A protocol name larger than 255 bytes in configured ALPN list: \"%.*s\"", static_cast<int>(protocols.size()),
  ------------------
  |  |   89|     19|#define Error(...)     DiagsError(DL_Error, __VA_ARGS__)     // Log operational failure, fail CI
  |  |  ------------------
  |  |  |  |   80|     19|  do {                                                                  \
  |  |  |  |   81|     19|    static const SourceLocation DiagsError_loc = MakeSourceLocation();  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   32|     19|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  |  |  ------------------
  |  |  |  |   82|     19|    static LogMessage           DiagsError_log_message;                 \
  |  |  |  |   83|     19|    DiagsError_log_message.message(LEVEL, DiagsError_loc, __VA_ARGS__); \
  |  |  |  |   84|     19|  } while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (84:12): [Folded, False: 19]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  920|     19|            protocols.data());
  921|     19|      return false;
  922|     19|    }
  923|       |    // Check whether we recognize the protocol.
  924|    339|    auto const protocol_index = globalSessionProtocolNameRegistry.indexFor(protocol);
  925|    339|    if (protocol_index == SessionProtocolNameRegistry::INVALID) {
  ------------------
  |  Branch (925:9): [True: 153, False: 186]
  ------------------
  926|    153|      Error("Unknown protocol name in configured ALPN list: \"%.*s\"", static_cast<int>(protocol.size()), protocol.data());
  ------------------
  |  |   89|    153|#define Error(...)     DiagsError(DL_Error, __VA_ARGS__)     // Log operational failure, fail CI
  |  |  ------------------
  |  |  |  |   80|    153|  do {                                                                  \
  |  |  |  |   81|    153|    static const SourceLocation DiagsError_loc = MakeSourceLocation();  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   32|    153|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  |  |  ------------------
  |  |  |  |   82|    153|    static LogMessage           DiagsError_log_message;                 \
  |  |  |  |   83|    153|    DiagsError_log_message.message(LEVEL, DiagsError_loc, __VA_ARGS__); \
  |  |  |  |   84|    153|  } while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (84:12): [Folded, False: 153]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  927|    153|      return false;
  928|    153|    }
  929|       |    // Make sure the protocol is one of our supported protocols.
  930|    186|    if (protocol_index == TS_ALPN_PROTOCOL_INDEX_HTTP_0_9 ||
  ------------------
  |  Branch (930:9): [True: 1, False: 185]
  ------------------
  931|    185|        (!HTTP_PROTOCOL_SET.contains(protocol_index) && !HTTP2_PROTOCOL_SET.contains(protocol_index))) {
  ------------------
  |  Branch (931:10): [True: 145, False: 40]
  |  Branch (931:57): [True: 5, False: 140]
  ------------------
  932|      6|      Error("Unsupported protocol name in configured ALPN list: %.*s", static_cast<int>(protocol.size()), protocol.data());
  ------------------
  |  |   89|      6|#define Error(...)     DiagsError(DL_Error, __VA_ARGS__)     // Log operational failure, fail CI
  |  |  ------------------
  |  |  |  |   80|      6|  do {                                                                  \
  |  |  |  |   81|      6|    static const SourceLocation DiagsError_loc = MakeSourceLocation();  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   32|      6|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  |  |  ------------------
  |  |  |  |   82|      6|    static LogMessage           DiagsError_log_message;                 \
  |  |  |  |   83|      6|    DiagsError_log_message.message(LEVEL, DiagsError_loc, __VA_ARGS__); \
  |  |  |  |   84|      6|  } while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (84:12): [Folded, False: 6]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  933|      6|      return false;
  934|      6|    }
  935|       |
  936|    180|    auto const protocol_wire_format  = globalSessionProtocolNameRegistry.convert_openssl_alpn_wire_format(protocol_index);
  937|    180|    computed_alpn_array_len         += protocol_wire_format.size();
  938|    180|    if (computed_alpn_array_len > orig_wire_format_buffer_len) {
  ------------------
  |  Branch (938:9): [True: 7, False: 173]
  ------------------
  939|       |      // We have exceeded the size of the output buffer.
  940|      7|      Error("The output ALPN length (%d bytes) is larger than the output buffer size of %d bytes", computed_alpn_array_len,
  ------------------
  |  |   89|      7|#define Error(...)     DiagsError(DL_Error, __VA_ARGS__)     // Log operational failure, fail CI
  |  |  ------------------
  |  |  |  |   80|      7|  do {                                                                  \
  |  |  |  |   81|      7|    static const SourceLocation DiagsError_loc = MakeSourceLocation();  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   32|      7|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  |  |  ------------------
  |  |  |  |   82|      7|    static LogMessage           DiagsError_log_message;                 \
  |  |  |  |   83|      7|    DiagsError_log_message.message(LEVEL, DiagsError_loc, __VA_ARGS__); \
  |  |  |  |   84|      7|  } while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (84:12): [Folded, False: 7]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  941|      7|            orig_wire_format_buffer_len);
  942|      7|      return false;
  943|      7|    }
  944|       |
  945|    173|    alpn_protocols.push_back(protocol_wire_format);
  946|    173|  }
  947|     18|  if (alpn_protocols.empty()) {
  ------------------
  |  Branch (947:7): [True: 0, False: 18]
  ------------------
  948|      0|    Error("No protocols specified in ALPN list: \"%.*s\"", static_cast<int>(protocols.size()), protocols.data());
  ------------------
  |  |   89|      0|#define Error(...)     DiagsError(DL_Error, __VA_ARGS__)     // Log operational failure, fail CI
  |  |  ------------------
  |  |  |  |   80|      0|  do {                                                                  \
  |  |  |  |   81|      0|    static const SourceLocation DiagsError_loc = MakeSourceLocation();  \
  |  |  |  |  ------------------
  |  |  |  |  |  |   32|      0|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  |  |  ------------------
  |  |  |  |   82|      0|    static LogMessage           DiagsError_log_message;                 \
  |  |  |  |   83|      0|    DiagsError_log_message.message(LEVEL, DiagsError_loc, __VA_ARGS__); \
  |  |  |  |   84|      0|  } while (false)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (84:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  949|      0|    return false;
  950|      0|  }
  951|       |
  952|       |  // All checks pass and the protocols are parsed. Write the result to the
  953|       |  // output buffer.
  954|     18|  auto *end = wire_format_buffer;
  955|     64|  for (auto &protocol : alpn_protocols) {
  ------------------
  |  Branch (955:23): [True: 64, False: 18]
  ------------------
  956|     64|    auto const len = protocol.size();
  957|     64|    memcpy(end, protocol.data(), len);
  958|     64|    end += len;
  959|     64|  }
  960|     18|  wire_format_buffer_len = computed_alpn_array_len;
  961|     18|  Dbg(dbg_ctl_ssl_alpn, "Successfully converted ALPN list to wire format: \"%.*s\"", static_cast<int>(protocols.size()),
  ------------------
  |  |  173|     18|  do {                              \
  |  |  174|     18|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 18]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|     18|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
  962|     18|      protocols.data());
  963|     18|  return true;
  964|     18|}

_ZN11BaseLogFileC2EPKc:
   31|    446|BaseLogFile::BaseLogFile(const char *name) : m_name(ats_strdup(name))
  ------------------
  |  |  134|    446|#define ats_strdup(p) _xstrdup((p), -1, nullptr)
  ------------------
   32|    446|{
   33|    446|  log_log_trace("exiting BaseLogFile constructor, m_name=%s, this=%p\n", m_name.get(), this);
  ------------------
  |  |   59|    446|  do {                                             \
  |  |   60|    446|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|    446|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 446]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|    446|      BaseLogFile::log_log(LL_Debug, __VA_ARGS__); \
  |  |   62|    446|  } while (0)
  |  |  ------------------
  |  |  |  Branch (62:12): [Folded, False: 446]
  |  |  ------------------
  ------------------
   34|    446|}
_ZN11BaseLogFileD2Ev:
   67|    446|{
   68|    446|  log_log_trace("entering BaseLogFile destructor, m_name=%s, this=%p\n", m_name.get(), this);
  ------------------
  |  |   59|    446|  do {                                             \
  |  |   60|    446|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|    446|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 446]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|    446|      BaseLogFile::log_log(LL_Debug, __VA_ARGS__); \
  |  |   62|    446|  } while (0)
  |  |  ------------------
  |  |  |  Branch (62:12): [Folded, False: 446]
  |  |  ------------------
  ------------------
   69|       |
   70|    446|  if (m_is_regfile) {
  ------------------
  |  Branch (70:7): [True: 0, False: 446]
  ------------------
   71|      0|    close_file();
   72|    446|  } else {
   73|    446|    log_log_trace("not a regular file, not closing, m_name=%s, this=%p\n", m_name.get(), this);
  ------------------
  |  |   59|    446|  do {                                             \
  |  |   60|    446|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|    446|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 446]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|    446|      BaseLogFile::log_log(LL_Debug, __VA_ARGS__); \
  |  |   62|    446|  } while (0)
  |  |  ------------------
  |  |  |  Branch (62:12): [Folded, False: 446]
  |  |  ------------------
  ------------------
   74|    446|  }
   75|       |
   76|    446|  log_log_trace("exiting BaseLogFile destructor, this=%p\n", this);
  ------------------
  |  |   59|    446|  do {                                             \
  |  |   60|    446|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|    446|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 446]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|    446|      BaseLogFile::log_log(LL_Debug, __VA_ARGS__); \
  |  |   62|    446|  } while (0)
  |  |  ------------------
  |  |  |  Branch (62:12): [Folded, False: 446]
  |  |  ------------------
  ------------------
   77|    446|}
_ZN11BaseLogFile9open_fileEi:
  267|    446|{
  268|    446|  log_log_trace("BaseLogFile: entered open_file()\n");
  ------------------
  |  |   59|    446|  do {                                             \
  |  |   60|    446|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|    446|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 446]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|    446|      BaseLogFile::log_log(LL_Debug, __VA_ARGS__); \
  |  |   62|    446|  } while (0)
  |  |  ------------------
  |  |  |  Branch (62:12): [Folded, False: 446]
  |  |  ------------------
  ------------------
  269|    446|  if (is_open()) {
  ------------------
  |  Branch (269:7): [True: 0, False: 446]
  ------------------
  270|      0|    return LOG_FILE_NO_ERROR;
  271|      0|  }
  272|       |
  273|    446|  if (!m_name.get()) {
  ------------------
  |  Branch (273:7): [True: 0, False: 446]
  ------------------
  274|      0|    log_log_error("BaseLogFile: m_name is nullptr, aborting open_file()\n");
  ------------------
  |  |   65|      0|  do {                                             \
  |  |   66|      0|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|      0|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|      BaseLogFile::log_log(LL_Error, __VA_ARGS__); \
  |  |   68|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (68:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  275|      0|    return LOG_FILE_COULD_NOT_OPEN_FILE;
  276|    446|  } else if (!strcmp(m_name.get(), "stdout")) {
  ------------------
  |  Branch (276:14): [True: 223, False: 223]
  ------------------
  277|    223|    log_log_trace("BaseLogFile: stdout opened\n");
  ------------------
  |  |   59|    223|  do {                                             \
  |  |   60|    223|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|    223|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 223]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|    223|      BaseLogFile::log_log(LL_Debug, __VA_ARGS__); \
  |  |   62|    223|  } while (0)
  |  |  ------------------
  |  |  |  Branch (62:12): [Folded, False: 223]
  |  |  ------------------
  ------------------
  278|    223|    m_fp      = stdout;
  279|    223|    m_is_init = true;
  280|    223|    return LOG_FILE_NO_ERROR;
  281|    223|  } else if (!strcmp(m_name.get(), "stderr")) {
  ------------------
  |  Branch (281:14): [True: 223, False: 0]
  ------------------
  282|    223|    log_log_trace("BaseLogFile: stderr opened\n");
  ------------------
  |  |   59|    223|  do {                                             \
  |  |   60|    223|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|    223|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 223]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|    223|      BaseLogFile::log_log(LL_Debug, __VA_ARGS__); \
  |  |   62|    223|  } while (0)
  |  |  ------------------
  |  |  |  Branch (62:12): [Folded, False: 223]
  |  |  ------------------
  ------------------
  283|    223|    m_fp      = stderr;
  284|    223|    m_is_init = true;
  285|    223|    return LOG_FILE_NO_ERROR;
  286|    223|  }
  287|       |
  288|       |  // means this object is representing a real file on disk
  289|      0|  m_is_regfile = true;
  290|       |
  291|       |  // Check to see if the file exists BEFORE we try to open it, since
  292|       |  // opening it will also create it.
  293|      0|  bool file_exists = BaseLogFile::exists(m_name.get());
  294|       |
  295|      0|  if (file_exists) {
  ------------------
  |  Branch (295:7): [True: 0, False: 0]
  ------------------
  296|      0|    if (!m_meta_info) {
  ------------------
  |  Branch (296:9): [True: 0, False: 0]
  ------------------
  297|       |      // This object must be fresh since it has not built its MetaInfo
  298|       |      // so we create a new MetaInfo object that will read right away
  299|       |      // (in the constructor) the corresponding metafile
  300|      0|      m_meta_info = std::make_unique<BaseMetaInfo>(m_name.get());
  301|      0|    }
  302|      0|  } else {
  303|       |    // The log file does not exist, so we create a new MetaInfo object
  304|       |    //  which will save itself to disk right away (in the constructor)
  305|      0|    if (m_has_signature) {
  ------------------
  |  Branch (305:9): [True: 0, False: 0]
  ------------------
  306|      0|      m_meta_info = std::make_unique<BaseMetaInfo>(m_name.get(), static_cast<long>(time(nullptr)), m_signature);
  307|      0|    } else {
  308|      0|      m_meta_info = std::make_unique<BaseMetaInfo>(m_name.get(), static_cast<long>(time(nullptr)));
  309|      0|    }
  310|      0|  }
  311|       |
  312|       |  // open actual log file (not metainfo)
  313|      0|  log_log_trace("BaseLogFile: attempting to open %s\n", m_name.get());
  ------------------
  |  |   59|      0|  do {                                             \
  |  |   60|      0|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|      0|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|      0|      BaseLogFile::log_log(LL_Debug, __VA_ARGS__); \
  |  |   62|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (62:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  314|       |
  315|      0|  m_fp = elevating_fopen(m_name.get(), "a+");
  316|       |
  317|       |  // error check
  318|      0|  if (m_fp) {
  ------------------
  |  Branch (318:7): [True: 0, False: 0]
  ------------------
  319|      0|    setlinebuf(m_fp);
  320|      0|  } else {
  321|      0|    log_log_error("Error opening log file %s: %s\n", m_name.get(), strerror(errno));
  ------------------
  |  |   65|      0|  do {                                             \
  |  |   66|      0|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|      0|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|      BaseLogFile::log_log(LL_Error, __VA_ARGS__); \
  |  |   68|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (68:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  322|      0|    log_log_error("Actual error: %s\n", (errno == EINVAL ? "einval" : "something else"));
  ------------------
  |  |   65|      0|  do {                                             \
  |  |   66|      0|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|      0|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|      BaseLogFile::log_log(LL_Error, __VA_ARGS__); \
  |  |  ------------------
  |  |  |  Branch (67:38): [True: 0, False: 0]
  |  |  ------------------
  |  |   68|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (68:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  323|      0|    return LOG_FILE_COULD_NOT_OPEN_FILE;
  324|      0|  }
  325|       |
  326|       |  // set permissions if necessary
  327|      0|  if (perm != -1) {
  ------------------
  |  Branch (327:7): [True: 0, False: 0]
  ------------------
  328|       |    // means LogFile passed in some permissions we need to set
  329|      0|    log_log_trace("BaseLogFile attempting to change %s's permissions to %o\n", m_name.get(), perm);
  ------------------
  |  |   59|      0|  do {                                             \
  |  |   60|      0|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|      0|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|      0|      BaseLogFile::log_log(LL_Debug, __VA_ARGS__); \
  |  |   62|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (62:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  330|      0|    if (elevating_chmod(m_name.get(), perm) != 0) {
  ------------------
  |  Branch (330:9): [True: 0, False: 0]
  ------------------
  331|      0|      log_log_error("Error changing logfile=%s permissions: %s\n", m_name.get(), strerror(errno));
  ------------------
  |  |   65|      0|  do {                                             \
  |  |   66|      0|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|      0|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|      BaseLogFile::log_log(LL_Error, __VA_ARGS__); \
  |  |   68|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (68:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  332|      0|    }
  333|      0|  }
  334|       |
  335|       |  // set m_bytes_written to force the rolling based on file size.
  336|      0|  fseek(m_fp, 0, SEEK_END);
  337|      0|  m_bytes_written = ftell(m_fp);
  338|       |
  339|      0|  log_log_trace("BaseLogFile %s is now open (fd=%d)\n", m_name.get(), fileno(m_fp));
  ------------------
  |  |   59|      0|  do {                                             \
  |  |   60|      0|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|      0|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   61|      0|      BaseLogFile::log_log(LL_Debug, __VA_ARGS__); \
  |  |   62|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (62:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  340|      0|  m_is_init = true;
  341|      0|  return LOG_FILE_NO_ERROR;
  342|      0|}

_Z14get_cont_flagsv:
   42|      6|{
   43|      6|  return local_flags;
   44|      6|}

_ZN16DiagsConfigState7enabledE12DiagsTagTypei:
   59|    446|{
   60|    446|  if (_enabled[dtt] == new_value) {
  ------------------
  |  Branch (60:7): [True: 446, False: 0]
  ------------------
   61|    446|    return;
   62|    446|  }
   63|      0|  _enabled[dtt] = new_value;
   64|       |
   65|      0|  if (DiagsTagType_Debug == dtt) {
  ------------------
  |  Branch (65:7): [True: 0, False: 0]
  ------------------
   66|      0|    DbgCtl::_config_mode.store(new_value, std::memory_order_relaxed);
   67|      0|  }
   68|      0|}
_ZN8DiagsPtr3setEP5Diags:
   75|    223|{
   76|    223|  _diags_ptr = new_ptr;
   77|       |
   78|    223|  DebugInterface::set_instance(new_ptr);
   79|    223|}
_ZN5DiagsC2ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEPKcS6_P11BaseLogFileii:
  108|    223|  : diags_log(nullptr),
  109|    223|    stdout_log(nullptr),
  110|    223|    stderr_log(nullptr),
  111|    223|    magic(DIAGS_MAGIC),
  ------------------
  |  |   48|    223|#define DIAGS_MAGIC 0x12345678
  ------------------
  112|    223|    show_location(SHOW_LOCATION_NONE),
  113|    223|    base_debug_tags(nullptr),
  114|    223|    base_action_tags(nullptr),
  115|    223|    prefix_str(prefix_string)
  116|    223|{
  117|    223|  ink_release_assert(!prefix_str.empty());
  ------------------
  |  |   48|    223|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 223, False: 0]
  |  |  ------------------
  ------------------
  118|    223|  int i;
  119|       |
  120|    223|  cleanup_func = nullptr;
  121|    223|  ink_mutex_init(&tag_table_lock);
  122|       |
  123|       |  ////////////////////////////////////////////////////////
  124|       |  // initialize the default, base debugging/action tags //
  125|       |  ////////////////////////////////////////////////////////
  126|       |
  127|    223|  if (bdt && *bdt) {
  ------------------
  |  Branch (127:7): [True: 223, False: 0]
  |  Branch (127:14): [True: 0, False: 223]
  ------------------
  128|      0|    base_debug_tags = ats_strdup(bdt);
  ------------------
  |  |  134|      0|#define ats_strdup(p) _xstrdup((p), -1, nullptr)
  ------------------
  129|      0|  }
  130|    223|  if (bat && *bat) {
  ------------------
  |  Branch (130:7): [True: 223, False: 0]
  |  Branch (130:14): [True: 0, False: 223]
  ------------------
  131|      0|    base_action_tags = ats_strdup(bat);
  ------------------
  |  |  134|      0|#define ats_strdup(p) _xstrdup((p), -1, nullptr)
  ------------------
  132|      0|  }
  133|       |
  134|    223|  config.enabled(DiagsTagType_Debug, base_debug_tags != nullptr ? 1 : 0);
  ------------------
  |  Branch (134:38): [True: 0, False: 223]
  ------------------
  135|    223|  config.enabled(DiagsTagType_Action, base_action_tags != nullptr ? 1 : 0);
  ------------------
  |  Branch (135:39): [True: 0, False: 223]
  ------------------
  136|       |
  137|       |  // The caller must always provide a non-empty prefix.
  138|       |
  139|  2.23k|  for (i = 0; i < DiagsLevel_Count; i++) {
  ------------------
  |  |   67|  2.23k|#define DiagsLevel_Count DL_Undefined
  ------------------
  |  Branch (139:15): [True: 2.00k, False: 223]
  ------------------
  140|  2.00k|    config.outputs[i].to_stdout   = false;
  141|  2.00k|    config.outputs[i].to_stderr   = false;
  142|  2.00k|    config.outputs[i].to_syslog   = false;
  143|  2.00k|    config.outputs[i].to_diagslog = true;
  144|  2.00k|  }
  145|       |
  146|       |  // create default stdout and stderr BaseLogFile objects
  147|       |  // (in case the user of this class doesn't specify in the future)
  148|    223|  stdout_log = new BaseLogFile("stdout");
  149|    223|  stderr_log = new BaseLogFile("stderr");
  150|    223|  stdout_log->open_file(); // should never fail
  151|    223|  stderr_log->open_file(); // should never fail
  152|       |
  153|       |  //////////////////////////////////////////////////////////////////
  154|       |  // start off with empty tag tables, will build in reconfigure() //
  155|       |  //////////////////////////////////////////////////////////////////
  156|       |
  157|    223|  activated_tags[DiagsTagType_Debug]  = nullptr;
  158|    223|  activated_tags[DiagsTagType_Action] = nullptr;
  159|       |
  160|    223|  outputlog_rolling_enabled  = RollingEnabledValues::NO_ROLLING;
  161|    223|  outputlog_rolling_interval = -1;
  162|    223|  outputlog_rolling_size     = -1;
  163|    223|  diagslog_rolling_enabled   = RollingEnabledValues::NO_ROLLING;
  164|    223|  diagslog_rolling_interval  = -1;
  165|    223|  diagslog_rolling_size      = -1;
  166|       |
  167|    223|  outputlog_time_last_roll = time(nullptr);
  168|    223|  diagslog_time_last_roll  = time(nullptr);
  169|       |
  170|    223|  diags_logfile_perm  = dl_perm;
  171|    223|  output_logfile_perm = ol_perm;
  172|       |
  173|    223|  if (setup_diagslog(_diags_log)) {
  ------------------
  |  Branch (173:7): [True: 223, False: 0]
  ------------------
  174|    223|    diags_log = _diags_log;
  175|    223|  }
  176|    223|}
_ZN5DiagsD2Ev:
  179|    223|{
  180|    223|  if (diags_log) {
  ------------------
  |  Branch (180:7): [True: 0, False: 223]
  ------------------
  181|      0|    delete diags_log;
  182|      0|    diags_log = nullptr;
  183|      0|  }
  184|       |
  185|    223|  if (stdout_log) {
  ------------------
  |  Branch (185:7): [True: 223, False: 0]
  ------------------
  186|    223|    delete stdout_log;
  187|    223|    stdout_log = nullptr;
  188|    223|  }
  189|       |
  190|    223|  if (stderr_log) {
  ------------------
  |  Branch (190:7): [True: 223, False: 0]
  ------------------
  191|    223|    delete stderr_log;
  192|    223|    stderr_log = nullptr;
  193|    223|  }
  194|       |
  195|    223|  ats_free((void *)base_debug_tags);
  196|    223|  ats_free((void *)base_action_tags);
  197|       |
  198|    223|  deactivate_all(DiagsTagType_Debug);
  199|    223|  deactivate_all(DiagsTagType_Action);
  200|    223|}
_ZNK5Diags8print_vaEPKc10DiagsLevelPK14SourceLocationS1_P13__va_list_tag:
  232|    205|{
  233|    205|  ink_release_assert(diags_level < DiagsLevel_Count);
  ------------------
  |  |   48|    205|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 205, False: 0]
  |  |  ------------------
  ------------------
  234|    205|  swoc::LocalBufferWriter<1024> format_writer;
  235|    205|  auto timestamp_offset = generate_format_string(format_writer, debug_tag, diags_level, loc, show_location, format_string);
  236|       |
  237|       |  //////////////////////////////////////
  238|       |  // now, finally, output the message //
  239|       |  //////////////////////////////////////
  240|       |
  241|    205|  lock();
  242|    205|  if (config.outputs[diags_level].to_diagslog) {
  ------------------
  |  Branch (242:7): [True: 205, False: 0]
  ------------------
  243|    205|    if (diags_log && diags_log->m_fp) {
  ------------------
  |  Branch (243:9): [True: 0, False: 205]
  |  Branch (243:22): [True: 0, False: 0]
  ------------------
  244|      0|      va_list tmp;
  245|      0|      va_copy(tmp, ap);
  246|      0|      vfprintf(diags_log->m_fp, format_writer.data(), tmp);
  247|      0|      va_end(tmp);
  248|      0|    }
  249|    205|  }
  250|       |
  251|    205|  if (config.outputs[diags_level].to_stdout) {
  ------------------
  |  Branch (251:7): [True: 0, False: 205]
  ------------------
  252|      0|    if (stdout_log && stdout_log->m_fp) {
  ------------------
  |  Branch (252:9): [True: 0, False: 0]
  |  Branch (252:23): [True: 0, False: 0]
  ------------------
  253|      0|      va_list tmp;
  254|      0|      va_copy(tmp, ap);
  255|      0|      vfprintf(stdout_log->m_fp, format_writer.data(), tmp);
  256|      0|      va_end(tmp);
  257|      0|    }
  258|      0|  }
  259|       |
  260|    205|  if (config.outputs[diags_level].to_stderr || regression_testing_on) {
  ------------------
  |  Branch (260:7): [True: 0, False: 205]
  |  Branch (260:48): [True: 0, False: 205]
  ------------------
  261|      0|    if (stderr_log && stderr_log->m_fp) {
  ------------------
  |  Branch (261:9): [True: 0, False: 0]
  |  Branch (261:23): [True: 0, False: 0]
  ------------------
  262|      0|      va_list tmp;
  263|      0|      va_copy(tmp, ap);
  264|      0|      vfprintf(stderr_log->m_fp, format_writer.data(), tmp);
  265|      0|      va_end(tmp);
  266|      0|    }
  267|      0|  }
  268|       |
  269|    205|#if !defined(freebsd)
  270|    205|  unlock();
  271|    205|#endif
  272|       |
  273|    205|  if (config.outputs[diags_level].to_syslog) {
  ------------------
  |  Branch (273:7): [True: 0, False: 205]
  ------------------
  274|      0|    int  priority;
  275|      0|    char syslog_buffer[2048];
  276|       |
  277|      0|    switch (diags_level) {
  278|      0|    case DL_Diag:
  ------------------
  |  Branch (278:5): [True: 0, False: 0]
  ------------------
  279|      0|    case DL_Debug:
  ------------------
  |  Branch (279:5): [True: 0, False: 0]
  ------------------
  280|      0|      priority = LOG_DEBUG;
  281|       |
  282|      0|      break;
  283|      0|    case DL_Status:
  ------------------
  |  Branch (283:5): [True: 0, False: 0]
  ------------------
  284|      0|      priority = LOG_INFO;
  285|      0|      break;
  286|      0|    case DL_Note:
  ------------------
  |  Branch (286:5): [True: 0, False: 0]
  ------------------
  287|      0|      priority = LOG_NOTICE;
  288|      0|      break;
  289|      0|    case DL_Warning:
  ------------------
  |  Branch (289:5): [True: 0, False: 0]
  ------------------
  290|      0|      priority = LOG_WARNING;
  291|      0|      break;
  292|      0|    case DL_Error:
  ------------------
  |  Branch (292:5): [True: 0, False: 0]
  ------------------
  293|      0|      priority = LOG_ERR;
  294|      0|      break;
  295|      0|    case DL_Fatal:
  ------------------
  |  Branch (295:5): [True: 0, False: 0]
  ------------------
  296|      0|      priority = LOG_CRIT;
  297|      0|      break;
  298|      0|    case DL_Alert:
  ------------------
  |  Branch (298:5): [True: 0, False: 0]
  ------------------
  299|      0|      priority = LOG_ALERT;
  300|      0|      break;
  301|      0|    case DL_Emergency:
  ------------------
  |  Branch (301:5): [True: 0, False: 0]
  ------------------
  302|      0|      priority = LOG_EMERG;
  303|      0|      break;
  304|      0|    default:
  ------------------
  |  Branch (304:5): [True: 0, False: 0]
  ------------------
  305|      0|      priority = LOG_NOTICE;
  306|      0|      break;
  307|      0|    }
  308|      0|    vsnprintf(syslog_buffer, sizeof(syslog_buffer), format_writer.data() + timestamp_offset, ap);
  309|      0|    syslog(priority, "%s", syslog_buffer);
  310|      0|  }
  311|       |
  312|       |#if defined(freebsd)
  313|       |  unlock();
  314|       |#endif
  315|    205|}
_ZNK5Diags13tag_activatedEPKc12DiagsTagType:
  330|  5.35k|{
  331|  5.35k|  if (tag == nullptr) {
  ------------------
  |  Branch (331:7): [True: 0, False: 5.35k]
  ------------------
  332|      0|    return true;
  333|      0|  }
  334|       |
  335|       |  // Snapshot the regex under the lock, then release the lock before running
  336|       |  // Regex::exec().  exec() can lazily construct a thread_local RegexContext
  337|       |  // whose destructor registration via __cxa_thread_atexit_impl takes the
  338|       |  // dynamic loader lock.  Holding tag_table_lock across exec() therefore
  339|       |  // creates a lock-order inversion with dlopen() callers that construct a
  340|       |  // DbgCtl during a plugin's static initialization (which takes
  341|       |  // tag_table_lock while already holding the dl loader lock).  See the
  342|       |  // analogous fix in DbgCtl::_new_reference.
  343|  5.35k|  std::shared_ptr<Regex> regex;
  344|  5.35k|  {
  345|  5.35k|    lock();
  346|  5.35k|    regex = activated_tags[mode];
  347|  5.35k|    unlock();
  348|  5.35k|  }
  349|       |
  350|  5.35k|  return regex ? regex->exec(tag, RE_ANCHORED) : false;
  ------------------
  |  Branch (350:10): [True: 0, False: 5.35k]
  ------------------
  351|  5.35k|}
_ZN5Diags14deactivate_allE12DiagsTagType:
  395|    446|{
  396|    446|  lock();
  397|    446|  activated_tags[mode].reset();
  398|    446|  unlock();
  399|    446|  if ((DiagsTagType_Debug == mode) && (this == diags())) {
  ------------------
  |  Branch (399:7): [True: 223, False: 223]
  |  Branch (399:39): [True: 223, False: 0]
  ------------------
  400|    223|    DbgCtl::update([&](const char *tag) -> bool { return tag_activated(tag, DiagsTagType_Debug); });
  401|    223|  }
  402|    446|}
_ZNK5Diags8error_vaE10DiagsLevelPK14SourceLocationPKcP13__va_list_tag:
  429|    205|{
  430|    205|  print_va(nullptr, level, loc, format_string, ap);
  431|       |
  432|    205|  if (DiagsLevel_IsTerminal(level)) {
  ------------------
  |  |   69|    205|#define DiagsLevel_IsTerminal(_l) (((_l) >= DL_Fatal) && ((_l) < DL_Undefined))
  |  |  ------------------
  |  |  |  Branch (69:36): [True: 0, False: 205]
  |  |  |  Branch (69:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  433|      0|    va_list ap2;
  434|       |
  435|      0|    va_copy(ap2, ap);
  436|      0|    if (cleanup_func) {
  ------------------
  |  Branch (436:9): [True: 0, False: 0]
  ------------------
  437|      0|      cleanup_func();
  438|      0|    }
  439|       |
  440|       |    // DL_Emergency means the process cannot recover from a reboot
  441|      0|    if (level == DL_Emergency) {
  ------------------
  |  Branch (441:9): [True: 0, False: 0]
  ------------------
  442|      0|      ink_emergency_va(format_string, ap2);
  443|      0|    } else {
  444|      0|      ink_fatal_va(format_string, ap2);
  445|      0|    }
  446|      0|    va_end(ap2);
  447|      0|  }
  448|    205|}
_ZN5Diags14setup_diagslogEP11BaseLogFile:
  458|    223|{
  459|    223|  if (blf != nullptr) {
  ------------------
  |  Branch (459:7): [True: 0, False: 223]
  ------------------
  460|      0|    if (blf->open_file(diags_logfile_perm) != BaseLogFile::LOG_FILE_NO_ERROR) {
  ------------------
  |  Branch (460:9): [True: 0, False: 0]
  ------------------
  461|      0|      log_log_error("Could not open diags log file: %s\n", strerror(errno));
  ------------------
  |  |   65|      0|  do {                                             \
  |  |   66|      0|    if (BASELOGFILE_DEBUG_MODE)                    \
  |  |  ------------------
  |  |  |  |   47|      0|  0 // change this to 1 to enable debug messages
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:3): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   67|      0|      BaseLogFile::log_log(LL_Error, __VA_ARGS__); \
  |  |   68|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (68:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  462|      0|      delete blf;
  463|      0|      return false;
  464|      0|    }
  465|      0|  }
  466|       |
  467|    223|  return true;
  468|    223|}
Diags.cc:_ZZN5Diags14deactivate_allE12DiagsTagTypeENK3$_0clEPKc:
  400|  2.67k|    DbgCtl::update([&](const char *tag) -> bool { return tag_activated(tag, DiagsTagType_Debug); });

_ZN12je_mi_malloc25globalJeMiNodumpAllocatorEv:
  173|      2|{
  174|      2|  static auto instance = new JeMiNodumpAllocator();
  175|      2|  return *instance;
  176|      2|}

_ZN10LogMessage14message_helperENSt3__16chrono8durationIxNS0_5ratioILl1ELl1000000EEEEERKNS0_8functionIFvPKcP13__va_list_tagEEES8_SA_:
   50|    205|{
   51|    205|  if (!_is_throttled) {
  ------------------
  |  Branch (51:7): [True: 205, False: 0]
  ------------------
   52|       |    // If throttling is disabled, make this operation as efficient as possible.
   53|       |    // Simply log and exit without consulting the Throttler API.
   54|       |    //
   55|       |    // If the user changes the throttling value from some non-zero value to
   56|       |    // zero, then we may miss out on some "The following message was
   57|       |    // suppressed" logs. However we accept this as a tradeoff to make this
   58|       |    // common case as fast as possible.
   59|    205|    log_function(fmt, args);
   60|    205|    return;
   61|    205|  }
   62|      0|  if (!_throttling_value_is_explicitly_set) {
  ------------------
  |  Branch (62:7): [True: 0, False: 0]
  ------------------
   63|      0|    set_throttling_interval(current_configured_interval);
   64|      0|  }
   65|      0|  uint64_t number_of_suppressions = 0;
   66|      0|  if (is_throttled(number_of_suppressions)) {
  ------------------
  |  Branch (66:7): [True: 0, False: 0]
  ------------------
   67|       |    // The messages are the same and but we're still within the throttling
   68|       |    // interval. Suppress this message.
   69|      0|    return;
   70|      0|  }
   71|       |  // If we get here, the message should not be suppressed.
   72|      0|  if (number_of_suppressions > 0) {
  ------------------
  |  Branch (72:7): [True: 0, False: 0]
  ------------------
   73|       |    // We use no format parameters, so we just need an empty va_list.
   74|      0|    va_list     empty_args{};
   75|      0|    std::string message =
   76|      0|      std::string("The following message was suppressed ") + std::to_string(number_of_suppressions) + std::string(" times.");
   77|      0|    log_function(message.c_str(), empty_args);
   78|      0|  }
   79|      0|  log_function(fmt, args);
   80|      0|}
_ZN10LogMessage23standard_message_helperE10DiagsLevelRK14SourceLocationPKcP13__va_list_tag:
   84|    205|{
   85|    205|  message_helper(
   86|    205|    _default_log_throttling_interval.load(),
   87|    205|    [level, &loc](const char *fmt, va_list args) { diags()->error_va(level, &loc, fmt, args); }, fmt, args);
   88|    205|}
_ZN10LogMessageC2Eb:
  109|      5|  : Throttler{std::chrono::milliseconds{0}}, _throttling_value_is_explicitly_set{false}, _is_throttled{is_throttled}
  110|      5|{
  111|      5|}
_ZN10LogMessage7messageE10DiagsLevelRK14SourceLocationPKcz:
  192|    205|{
  193|    205|  va_list args;
  194|    205|  va_start(args, fmt);
  195|    205|  standard_message_helper(level, loc, fmt, args);
  196|       |  va_end(args);
  197|    205|}
LogMessage.cc:_ZZN10LogMessage23standard_message_helperE10DiagsLevelRK14SourceLocationPKcP13__va_list_tagENK3$_0clES5_S7_:
   87|    205|    [level, &loc](const char *fmt, va_list args) { diags()->error_va(level, &loc, fmt, args); }, fmt, args);

_ZN9ThrottlerC2ENSt3__16chrono8durationIxNS0_5ratioILl1ELl1000000EEEEE:
   26|      5|Throttler::Throttler(std::chrono::microseconds interval) : _interval{interval} {}

_Z20ats_hugepage_enabledv:
   61|      4|{
   62|      4|#ifdef MAP_HUGETLB
   63|      4|  return hugepage_enabled;
   64|       |#else
   65|       |  return false;
   66|       |#endif
   67|      4|}

_Z10ats_mallocm:
   52|    450|{
   53|    450|  void *ptr = nullptr;
   54|       |
   55|       |  /*
   56|       |   * There's some nasty code in libts that expects
   57|       |   * a MALLOC of a zero-sized item to work properly. Rather
   58|       |   * than allocate any space, we simply return a nullptr to make
   59|       |   * certain they die quickly & don't trash things.
   60|       |   */
   61|       |
   62|       |  // Useful for tracing bad mallocs
   63|       |  // ink_stack_trace_dump();
   64|    450|  if (likely(size > 0)) {
  ------------------
  |  |   28|    450|#define likely(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (28:19): [True: 450, False: 0]
  |  |  ------------------
  ------------------
   65|    450|    if (unlikely((ptr = malloc(size)) == nullptr)) {
  ------------------
  |  |   31|    450|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 450]
  |  |  ------------------
  ------------------
   66|      0|      ink_abort("couldn't allocate %zu bytes", size);
   67|      0|    }
   68|    450|  }
   69|    450|  return ptr;
   70|    450|} /* End ats_malloc */
_Z12ats_memalignmm:
   96|      4|{
   97|      4|  void *ptr;
   98|       |
   99|      4|  if (alignment <= 8) {
  ------------------
  |  Branch (99:7): [True: 0, False: 4]
  ------------------
  100|      0|    return ats_malloc(size);
  101|      0|  }
  102|       |
  103|       |#if defined(openbsd)
  104|       |  if (alignment > PAGE_SIZE)
  105|       |    alignment = PAGE_SIZE;
  106|       |#endif
  107|       |
  108|      4|  int retcode = posix_memalign(&ptr, alignment, size);
  109|       |
  110|      4|  if (unlikely(retcode)) {
  ------------------
  |  |   31|      4|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 4]
  |  |  ------------------
  ------------------
  111|      0|    if (retcode == EINVAL) {
  ------------------
  |  Branch (111:9): [True: 0, False: 0]
  ------------------
  112|      0|      ink_abort("couldn't allocate %zu bytes at alignment %zu - invalid alignment parameter", size, alignment);
  113|      0|    } else if (retcode == ENOMEM) {
  ------------------
  |  Branch (113:16): [True: 0, False: 0]
  ------------------
  114|      0|      ink_abort("couldn't allocate %zu bytes at alignment %zu - insufficient memory", size, alignment);
  115|      0|    } else {
  116|      0|      ink_abort("couldn't allocate %zu bytes at alignment %zu - unknown error %d", size, alignment, retcode);
  117|      0|    }
  118|      0|  }
  119|       |
  120|      4|  return ptr;
  121|      4|} /* End ats_memalign */
_Z8ats_freePv:
  125|    892|{
  126|    892|  if (likely(ptr != nullptr)) {
  ------------------
  |  |   28|    892|#define likely(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (28:19): [True: 446, False: 446]
  |  |  ------------------
  ------------------
  127|    446|    free(ptr);
  128|    446|  }
  129|    892|} /* End ats_free */
_Z8_xstrdupPKciS0_:
  242|    446|{
  243|    446|  char *newstr;
  244|       |
  245|    446|  if (likely(str)) {
  ------------------
  |  |   28|    446|#define likely(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (28:19): [True: 446, False: 0]
  |  |  ------------------
  ------------------
  246|    446|    if (length < 0) {
  ------------------
  |  Branch (246:9): [True: 446, False: 0]
  ------------------
  247|    446|      length = strlen(str);
  248|    446|    }
  249|       |
  250|    446|    newstr = static_cast<char *>(ats_malloc(length + 1));
  251|       |    // If this is a zero length string just null terminate and return.
  252|    446|    if (unlikely(length == 0)) {
  ------------------
  |  |   31|    446|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 446]
  |  |  ------------------
  ------------------
  253|      0|      *newstr = '\0';
  254|    446|    } else {
  255|    446|      strncpy(newstr, str, length); // we cannot do length + 1 because the string isn't
  256|    446|      newstr[length] = '\0';        // guaranteed to be null terminated!
  257|    446|    }
  258|    446|    return newstr;
  259|    446|  }
  260|      0|  return nullptr;
  261|    446|}

_Z14ink_mutex_initP15pthread_mutex_t:
   50|    225|{
   51|    225|  int                          error;
   52|    225|  static x_pthread_mutexattr_t attr;
   53|       |
   54|    225|  error = pthread_mutex_init(m, &attr.attr);
   55|    225|  if (unlikely(error != 0)) {
  ------------------
  |  |   31|    225|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 225]
  |  |  ------------------
  ------------------
   56|      0|    ink_abort("pthread_mutex_init(%p) failed: %s (%d)", m, strerror(error), error);
   57|      0|  }
   58|    225|}
_ZN21x_pthread_mutexattr_tC2Ev:
   36|      2|  {
   37|      2|    pthread_mutexattr_init(&attr);
   38|       |#if DEBUG
   39|       |    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
   40|       |#endif
   41|      2|  }

_Z17ink_freelist_initPP12_InkFreeListPKcjjjb:
  139|      4|{
  140|      4|  InkFreeList       *f;
  141|      4|  ink_freelist_list *fll;
  142|       |
  143|       |  /* its safe to add to this global list because ink_freelist_init()
  144|       |     is only called from single-threaded initialization code. */
  145|      4|  f = static_cast<InkFreeList *>(ats_memalign(alignment, sizeof(InkFreeList)));
  146|      4|  ink_zero(*f);
  147|       |
  148|      4|  fll       = static_cast<ink_freelist_list *>(ats_malloc(sizeof(ink_freelist_list)));
  149|      4|  fll->fl   = f;
  150|      4|  fll->next = freelists;
  151|      4|  freelists = fll;
  152|       |
  153|      4|  f->name = name;
  154|       |  /* quick test for power of 2 */
  155|      4|  ink_assert(!(alignment & (alignment - 1)));
  ------------------
  |  |   45|      4|#define ink_assert(EX) (void)(EX)
  ------------------
  156|       |  // It is never useful to have alignment requirement looser than a page size
  157|       |  // so clip it. This makes the item alignment checks in the actual allocator simpler.
  158|      4|  f->alignment         = alignment;
  159|      4|  f->use_hugepages     = ats_hugepage_enabled() && use_hugepages;
  ------------------
  |  Branch (159:26): [True: 0, False: 4]
  |  Branch (159:52): [True: 0, False: 0]
  ------------------
  160|      4|  f->hugepages_failure = 0;
  161|      4|  if (f->use_hugepages) {
  ------------------
  |  Branch (161:7): [True: 0, False: 4]
  ------------------
  162|       |    // for hugepages, always make the allocation alignment on a hugepage boundary
  163|      0|    f->alignment = ats_hugepage_size();
  164|      0|    f->type_size = type_size;
  165|      4|  } else {
  166|      4|    if (f->alignment > ats_pagesize()) {
  ------------------
  |  Branch (166:9): [True: 0, False: 4]
  ------------------
  167|      0|      f->alignment = ats_pagesize();
  168|      0|    }
  169|       |    // Make sure we align *all* the objects in the allocation, not just the first one
  170|      4|    f->type_size = INK_ALIGN(type_size, f->alignment);
  ------------------
  |  |   50|      4|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1))
  ------------------
  171|      4|  }
  172|      4|  Dbg(dbg_ctl_freelist_init, "<%s> Alignment request/actual (%" PRIu32 "/%" PRIu32 ")", name, alignment, f->alignment);
  ------------------
  |  |  173|      4|  do {                              \
  |  |  174|      4|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 4]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|      4|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 4]
  |  |  ------------------
  ------------------
  173|      4|  Dbg(dbg_ctl_freelist_init, "<%s> Type Size request/actual (%" PRIu32 "/%" PRIu32 ")", name, type_size, f->type_size);
  ------------------
  |  |  173|      4|  do {                              \
  |  |  174|      4|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 4]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|      4|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 4]
  |  |  ------------------
  ------------------
  174|      4|  ink_assert(f->type_size != 0);
  ------------------
  |  |   45|      4|#define ink_assert(EX) (void)(EX)
  ------------------
  175|      4|  if (f->use_hugepages) {
  ------------------
  |  Branch (175:7): [True: 0, False: 4]
  ------------------
  176|      0|    f->chunk_size = INK_ALIGN(chunk_size * f->type_size, ats_hugepage_size()) / f->type_size;
  ------------------
  |  |   50|      0|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1))
  ------------------
  177|      4|  } else {
  178|      4|    f->chunk_size = INK_ALIGN(chunk_size * f->type_size, ats_pagesize()) / f->type_size;
  ------------------
  |  |   50|      4|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1))
  ------------------
  179|      4|  }
  180|      4|  Dbg(dbg_ctl_freelist_init, "<%s> Chunk Size request/actual (%" PRIu32 "/%" PRIu32 ")", name, chunk_size, f->chunk_size);
  ------------------
  |  |  173|      4|  do {                              \
  |  |  174|      4|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 4]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|      4|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 4]
  |  |  ------------------
  ------------------
  181|      4|  SET_FREELIST_POINTER_VERSION(f->head, FROM_PTR(0), 0);
  ------------------
  |  |  131|      4|  (_x).s.pointer = _p;                           \
  |  |  132|      4|  (_x).s.version = _v
  ------------------
  182|       |
  183|      4|  *fl = f;
  184|      4|}

_ZN6DbgCtl14_new_referenceEPKc:
  125|     26|{
  126|     26|  DebugInterface *p = DebugInterface::get_instance();
  127|     26|  debug_assert(tag != nullptr);
  ------------------
  |  |   45|     26|#define debug_assert(EX)              (void)(EX)
  ------------------
  128|       |
  129|     26|  _TagData *new_tag_data{nullptr};
  130|       |
  131|     26|  {
  132|     26|    _RegistryAccessor ra;
  133|       |
  134|     26|    auto &d{ra.data()};
  135|       |
  136|     26|    if (auto it = d.map.find(tag); it != d.map.end()) {
  ------------------
  |  Branch (136:36): [True: 2, False: 24]
  ------------------
  137|      2|      return &*it;
  138|      2|    }
  139|       |
  140|     24|    auto sz = std::strlen(tag);
  141|       |
  142|     24|    debug_assert(sz > 0);
  ------------------
  |  |   45|     24|#define debug_assert(EX)              (void)(EX)
  ------------------
  143|       |
  144|     24|    char *t = new char[sz + 1]; // Never deleted (leaky singleton) - reclaimed by OS at process exit.
  145|     24|    std::memcpy(t, tag, sz + 1);
  146|     24|    _TagData new_elem{t, false};
  147|       |
  148|     24|    auto res = d.map.insert(new_elem);
  149|       |
  150|     24|    debug_assert(res.second);
  ------------------
  |  |   45|     24|#define debug_assert(EX)              (void)(EX)
  ------------------
  151|       |
  152|     24|    new_tag_data = &*res.first;
  153|     24|  }
  154|     24|  new_tag_data->second = p && p->debug_tag_activated(tag);
  ------------------
  |  Branch (154:26): [True: 0, False: 24]
  |  Branch (154:31): [True: 0, False: 0]
  ------------------
  155|       |
  156|       |  // It is important that debug_tag_activated() is NOT called while the ra object exists, and the registry mutex is
  157|       |  // locked.  There is a mutex in the C/C++ runtime that both dlopen() and _cxa_thread_atexit() lock while running.
  158|       |  // Creating a _RegistryAccessor instance locks the registry mutex.  If the subsequent code in this function triggers
  159|       |  // the construction of a thread_local variable (with a non-trivial destructor), with the registry mutex locked, the
  160|       |  // following deadlock scenario is possible:
  161|       |  // 1.  Thread 1 calls a DbgCtl constructor, which locks the registry mutex, but then is suspended.
  162|       |  // 2.  Thread 2 calls dlopen() for a plugin, locking the runtime mutex.  It then executes the constructor for a
  163|       |  //     statically allocated DbgCtl object, which blocks on locking the registry mutex.
  164|       |  // 3.  Thread 1 resumes, and calls a function that causes the the construction of a thread_local variable with a
  165|       |  //     non-trivial destructor.  This causes a call to _cxa_thread_atexit(), to set up a call of the variable's
  166|       |  //     destructor at thread exit.  The call to _cxa_thread_atexit() will block on the runtime mutex (held by Thread 2).
  167|       |  //     So Thread 1 holds the registry mutex and is blocked waiting for the runtime mutex.  And Thread 2 holds the
  168|       |  //     runtime mutex and is blocked waiting for the registry mutex.  Deadlock.
  169|       |
  170|     24|  return new_tag_data;
  171|     26|}
_ZN6DbgCtl6updateERKNSt3__18functionIFbPKcEEE:
  183|    446|{
  184|    446|  _RegistryAccessor ra;
  185|    446|  auto             &d{ra.data()};
  186|       |
  187|  5.35k|  for (auto &i : d.map) {
  ------------------
  |  Branch (187:16): [True: 5.35k, False: 446]
  ------------------
  188|  5.35k|    i.second = f(i.first);
  189|  5.35k|  }
  190|    446|}
_ZN14DebugInterface12get_instanceEv:
  259|     26|{
  260|     26|  return di_inst;
  261|     26|}
_ZN14DebugInterface12set_instanceEPS_:
  265|    223|{
  266|    223|  di_inst = i;
  267|    223|  DbgCtl::update([&](const char *t) { return i->debug_tag_activated(t); });
  268|    223|}
_ZN14DebugInterface10level_nameE10DiagsLevel:
  272|    205|{
  273|    205|  switch (dl) {
  274|      0|  case DL_Diag:
  ------------------
  |  Branch (274:3): [True: 0, False: 205]
  ------------------
  275|      0|    return ("DIAG");
  276|      0|  case DL_Debug:
  ------------------
  |  Branch (276:3): [True: 0, False: 205]
  ------------------
  277|      0|    return ("DEBUG");
  278|      0|  case DL_Status:
  ------------------
  |  Branch (278:3): [True: 0, False: 205]
  ------------------
  279|      0|    return ("STATUS");
  280|      0|  case DL_Note:
  ------------------
  |  Branch (280:3): [True: 0, False: 205]
  ------------------
  281|      0|    return ("NOTE");
  282|      0|  case DL_Warning:
  ------------------
  |  Branch (282:3): [True: 0, False: 205]
  ------------------
  283|      0|    return ("WARNING");
  284|    205|  case DL_Error:
  ------------------
  |  Branch (284:3): [True: 205, False: 0]
  ------------------
  285|    205|    return ("ERROR");
  286|      0|  case DL_Fatal:
  ------------------
  |  Branch (286:3): [True: 0, False: 205]
  ------------------
  287|      0|    return ("FATAL");
  288|      0|  case DL_Alert:
  ------------------
  |  Branch (288:3): [True: 0, False: 205]
  ------------------
  289|      0|    return ("ALERT");
  290|      0|  case DL_Emergency:
  ------------------
  |  Branch (290:3): [True: 0, False: 205]
  ------------------
  291|      0|    return ("EMERGENCY");
  292|      0|  default:
  ------------------
  |  Branch (292:3): [True: 0, False: 205]
  ------------------
  293|      0|    return ("DIAG");
  294|    205|  }
  295|    205|}
_ZN14DebugInterface22generate_format_stringERN4swoc7_1_5_1517LocalBufferWriterILm1024EEEPKc10DiagsLevelPK14SourceLocation17DiagsShowLocationS6_:
  347|    205|{
  348|       |  // Save room for optional newline and terminating NUL bytes.
  349|    205|  format_writer.restrict(2);
  350|       |
  351|    205|  format_writer.print("[{}] ", DiagTimestamp{});
  352|    205|  auto timestamp_offset = format_writer.size();
  353|       |
  354|    205|  format_writer.print("{} {}: ", DiagThreadname{}, level_name(diags_level));
  355|       |
  356|    205|  if (location(loc, show_location, diags_level)) {
  ------------------
  |  Branch (356:7): [True: 0, False: 205]
  ------------------
  357|      0|    format_writer.print("<{}> ", *loc);
  358|      0|  }
  359|       |
  360|    205|  if (debug_tag) {
  ------------------
  |  Branch (360:7): [True: 0, False: 205]
  ------------------
  361|      0|    format_writer.print("({}) ", debug_tag);
  362|      0|  }
  363|       |
  364|    205|  format_writer.print("{}", format_string);
  365|       |
  366|    205|  format_writer.restore(2);                  // restore the space for required termination.
  367|    205|  if (format_writer.view().back() != '\n') { // safe because always some chars in the buffer.
  ------------------
  |  Branch (367:7): [True: 205, False: 0]
  ------------------
  368|    205|    format_writer.write('\n');
  369|    205|  }
  370|    205|  format_writer.write('\0');
  371|       |
  372|    205|  return timestamp_offset;
  373|    205|}
_ZN6DbgCtl17_RegistryAccessorC2Ev:
   88|    472|  {
   89|    472|    if (!_registry_instance) {
  ------------------
  |  Branch (89:9): [True: 2, False: 470]
  ------------------
   90|      2|      Registry *expected{nullptr};
   91|      2|      Registry *r{new Registry};
   92|      2|      if (!_registry_instance.compare_exchange_strong(expected, r)) {
  ------------------
  |  Branch (92:11): [True: 0, False: 2]
  ------------------
   93|      0|        r->_mtx.lock();
   94|      0|        delete r;
   95|      0|      }
   96|      2|    }
   97|    472|    _registry_instance.load()->_mtx.lock();
   98|    472|    _mtx_is_locked = true;
   99|    472|  }
_ZN6DbgCtl17_RegistryAccessor8RegistryC2Ev:
   77|      2|    Registry() = default;
_ZN6DbgCtl17_RegistryAccessor4dataEv:
  113|    472|  {
  114|    472|    return *_registry_instance;
  115|    472|  }
_ZN6DbgCtl17_RegistryAccessorD2Ev:
  102|    472|  {
  103|    472|    if (_mtx_is_locked) {
  ------------------
  |  Branch (103:9): [True: 472, False: 0]
  ------------------
  104|    472|      _registry_instance.load()->_mtx.unlock();
  105|    472|    }
  106|    472|  }
DbgCtl.cc:_ZN12_GLOBAL__N_114DiagThreadnameC2Ev:
  322|    205|  {
  323|    205|#if defined(HAVE_PTHREAD_GETNAME_NP)
  324|    205|    pthread_getname_np(pthread_self(), name, sizeof(name));
  325|       |#elif defined(HAVE_PTHREAD_GET_NAME_NP)
  326|       |    pthread_get_name_np(pthread_self(), name, sizeof(name));
  327|       |#elif defined(HAVE_PRCTL) && defined(PR_GET_NAME)
  328|       |    prctl(PR_GET_NAME, name, 0, 0, 0);
  329|       |#else
  330|       |    snprintf(name, sizeof(name), "0x%" PRIx64, (uint64_t)pthread_self());
  331|       |#endif
  332|    205|  }
DbgCtl.cc:_ZN12_GLOBAL__N_18locationEPK14SourceLocation17DiagsShowLocation10DiagsLevel:
  231|    205|{
  232|    205|  if (loc && loc->valid()) {
  ------------------
  |  Branch (232:7): [True: 205, False: 0]
  |  Branch (232:14): [True: 205, False: 0]
  ------------------
  233|    205|    switch (show) {
  234|      0|    case SHOW_LOCATION_ALL:
  ------------------
  |  Branch (234:5): [True: 0, False: 205]
  ------------------
  235|      0|      return true;
  236|      0|    case SHOW_LOCATION_DEBUG:
  ------------------
  |  Branch (236:5): [True: 0, False: 205]
  ------------------
  237|      0|      return level <= DL_Debug;
  238|    205|    default:
  ------------------
  |  Branch (238:5): [True: 205, False: 0]
  ------------------
  239|    205|      return false;
  240|    205|    }
  241|    205|  }
  242|       |
  243|      0|  return false;
  244|    205|}
_ZNK6DbgCtl17_RegistryAccessor6TagCmpclEPKcS3_:
   63|    190|    {
   64|    190|      return std::strcmp(a, b) < 0;
   65|    190|    }
DbgCtl.cc:_ZZN14DebugInterface12set_instanceEPS_ENK3$_0clEPKc:
  267|  2.67k|  DbgCtl::update([&](const char *t) { return i->debug_tag_activated(t); });
DbgCtl.cc:_ZN12_GLOBAL__N_18bwformatERN4swoc7_1_5_1512BufferWriterERKNS1_3bwf4SpecERKNS_13DiagTimestampE:
  306|    205|{
  307|    205|  auto                        epoch = std::chrono::system_clock::to_time_t(ts.ts);
  308|    205|  swoc::LocalBufferWriter<48> lw;
  309|       |
  310|    205|  ctime_r(&epoch, lw.aux_data());
  311|    205|  lw.commit(19); // keep only leading text.
  312|    205|  lw.print(".{:03}", std::chrono::time_point_cast<std::chrono::milliseconds>(ts.ts).time_since_epoch().count() % 1000);
  313|    205|  w.write(lw.view().substr(4));
  314|       |
  315|    205|  return w;
  316|    205|}
DbgCtl.cc:_ZN12_GLOBAL__N_18bwformatERN4swoc7_1_5_1512BufferWriterERKNS1_3bwf4SpecERKNS_14DiagThreadnameE:
  337|    205|{
  338|    205|  bwformat(w, spec, std::string_view{n.name});
  339|    205|  return w;
  340|    205|}

LLVMFuzzerTestOneInput:
   30|    250|{
   31|    250|  if (Size < kMinInputLength || Size > kMaxInputLength) {
  ------------------
  |  |   25|    500|#define kMinInputLength 8
  ------------------
                if (Size < kMinInputLength || Size > kMaxInputLength) {
  ------------------
  |  |   26|    246|#define kMaxInputLength 1024
  ------------------
  |  Branch (31:7): [True: 4, False: 246]
  |  Branch (31:33): [True: 23, False: 223]
  ------------------
   32|     27|    return 1;
   33|     27|  }
   34|       |
   35|    223|  std::string alpn_input((char *)input_data, Size);
   36|       |
   37|    223|  unsigned char alpn_wire_format[MAX_ALPN_STRING] = {0xab};
   38|    223|  int           alpn_wire_format_len              = MAX_ALPN_STRING;
  ------------------
  |  |   83|    223|#define MAX_ALPN_STRING 30
  ------------------
   39|       |
   40|    223|  DiagsPtr::set(new Diags("fuzzing", "", "", nullptr));
   41|    223|  ts_session_protocol_well_known_name_indices_init();
   42|       |
   43|    223|  convert_alpn_to_wire_format(alpn_input, alpn_wire_format, alpn_wire_format_len);
   44|       |
   45|    223|  delete diags();
   46|       |
   47|    223|  return 0;
   48|    250|}