_ZN6ActionC2Ev:
  184|      5|  Action() {}
_ZN6ActionD2Ev:
  185|      1|  virtual ~Action() {}

_ZN15ConfigProcessor13scoped_configIN2ts11Http3ConfigENS1_17Http3ConfigParamsEEC2Ev:
   50|    149|    scoped_config() : ptr(ClassType::acquire()) {}
_ZN15ConfigProcessor13scoped_configIN2ts11Http3ConfigENS1_17Http3ConfigParamsEED2Ev:
   51|    149|    ~scoped_config() { ClassType::release(ptr); }
_ZNK15ConfigProcessor13scoped_configIN2ts11Http3ConfigENS1_17Http3ConfigParamsEEptEv:
   56|      5|    {
   57|      5|      return ptr;
   58|      5|    }

_ZN12Continuation11handleEventEiPv:
  225|      3|  {
  226|       |    // If there is a lock, we must be holding it on entry
  227|      3|    ink_release_assert(!mutex || mutex->thread_holding == this_ethread());
  ------------------
  |  |   48|      3|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 3, False: 0]
  |  |  |  Branch (48:60): [True: 3, False: 0]
  |  |  |  Branch (48:60): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  228|      3|    return (this->*handler)(event, data);
  229|      3|  }
_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|}

_ZN7EThread18DefaultTailHandlerC2ER14ProtectedQueue:
  389|      1|    explicit DefaultTailHandler(ProtectedQueue &q) : _q(q) {}
_ZN7EThread18DefaultTailHandler15waitForActivityEl:
  393|      1|    {
  394|      1|      _q.wait(ink_get_hrtime() + timeout);
  395|      1|      return 0;
  396|      1|    }
_ZN7EThread7Metrics5Slice6EventsC2Ev:
  438|  1.02k|        Events() {}
_ZN7EThread7Metrics5Slice17record_loop_startEl:
  598|      1|{
  599|      1|  _duration._start = t;
  600|      1|  return *this;
  601|      1|}
_ZN7EThread7Metrics10prev_sliceEPNS0_5SliceE:
  659|      1|{
  660|      1|  return --current < _slice.data() ? &_slice[N_SLICES - 1] : current;
  ------------------
  |  Branch (660:10): [True: 0, False: 1]
  ------------------
  661|      1|}
_ZN7EThread7Metrics10next_sliceEPNS0_5SliceE:
  665|      1|{
  666|      1|  return ++current > &_slice[N_SLICES - 1] ? _slice.data() : current;
  ------------------
  |  Branch (666:10): [True: 0, False: 1]
  ------------------
  667|      1|}
_Z12this_ethreadv:
  715|      1|{
  716|      1|  return EThread::this_ethread_ptr;
  717|      1|}
_ZN7EThread10free_eventEP5Event:
  732|      1|{
  733|      1|  ink_assert(!e->in_the_priority_queue && !e->in_the_prot_queue);
  ------------------
  |  |   45|      2|#define ink_assert(EX) (void)(EX)
  |  |  ------------------
  |  |  |  Branch (45:31): [True: 1, False: 0]
  |  |  |  Branch (45:31): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  734|      1|  e->mutex = nullptr;
  735|      1|  EVENT_FREE(e, eventAllocator, this);
  ------------------
  |  |  289|      1|  _p->mutex = nullptr;         \
  |  |  290|      1|  if (_p->globally_allocated)  \
  |  |  ------------------
  |  |  |  Branch (290:7): [True: 1, False: 0]
  |  |  ------------------
  |  |  291|      1|    ::_a.free(_p);             \
  |  |  292|      1|  else                         \
  |  |  293|      1|    THREAD_FREE(_p, _a, _t)
  |  |  ------------------
  |  |  |  |   97|      0|  do {                                                                                             \
  |  |  |  |   98|      0|    ::_a.destroy_if_enabled(_p);                                                                   \
  |  |  |  |   99|      0|    Thread *_t = (_tin);                                                                           \
  |  |  |  |  100|      0|    if (_t && !cmd_disable_pfreelist) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (100:9): [True: 0, False: 0]
  |  |  |  |  |  Branch (100:15): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  101|      0|      *(char **)_p    = (char *)_t->_a.freelist;                                                   \
  |  |  |  |  102|      0|      _t->_a.freelist = _p;                                                                        \
  |  |  |  |  103|      0|      _t->_a.allocated++;                                                                          \
  |  |  |  |  104|      0|      UPDATE_FREE_METRICS(::_a);                                                                   \
  |  |  |  |  105|      0|      if (thread_freelist_high_watermark > 0 && _t->_a.allocated > thread_freelist_high_watermark) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (105:11): [True: 0, False: 0]
  |  |  |  |  |  Branch (105:49): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  106|      0|        thread_freeup(::_a.raw(), _t->_a);                                                         \
  |  |  |  |  107|      0|    } else {                                                                                       \
  |  |  |  |  108|      0|      ::_a.raw().free_void(_p);                                                                    \
  |  |  |  |  109|      0|    }                                                                                              \
  |  |  |  |  110|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (110:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  736|      1|}
_ZN7EThread7Metrics5SliceC2Ev:
  507|  1.02k|      Slice() = default;
_ZN7EThread7Metrics5Slice8DurationC2Ev:
  430|  1.02k|        Duration()                  = default;

_ZN5EventC2Ev:
  231|      5|  Event() : in_the_prot_queue(false), in_the_priority_queue(false), immediate(false), globally_allocated(true), in_heap(false) {}
_ZN5Event4initEP12Continuationll:
  235|      5|  {
  236|      5|    continuation = c;
  237|      5|    timeout_at   = atimeout_at;
  238|      5|    period       = aperiod;
  239|      5|    immediate    = !period && !atimeout_at;
  ------------------
  |  Branch (239:20): [True: 5, False: 0]
  |  Branch (239:31): [True: 5, False: 0]
  ------------------
  240|      5|    cancelled    = false;
  241|      5|    return this;
  242|      5|  }
_ZN5Event4freeEv:
  282|      1|{
  283|      1|  mutex = nullptr;
  284|      1|  eventAllocator.free(this);
  285|      1|}

_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))
  ------------------
_ZN14EventProcessor10ThreadInit4initEiP5Event:
  389|      1|    {
  390|      1|      _evp->initThreadState(ev->ethread);
  391|      1|      return 0;
  392|      1|    }

_ZN17MIOBuffer_trackerC2EPKc:
 1308|    149|  explicit MIOBuffer_tracker(const char *_loc) : loc(_loc) {}
_ZN17MIOBuffer_trackerclEl:
 1311|    149|  {
 1312|    149|    return new_MIOBuffer_internal(loc, size_index);
 1313|    149|  }
_ZN12IOBufferDataC2Ev:
  247|    240|  IOBufferData() : _size_index(BUFFER_SIZE_NOT_ALLOCATED) {}
_ZN13IOBufferBlock3bufEv:
  276|    480|  {
  277|    480|    return data->_data;
  278|    480|  }
_ZN13IOBufferBlock5startEv:
  289|    447|  {
  290|    447|    return _start;
  291|    447|  }
_ZN13IOBufferBlock3endEv:
  302|    240|  {
  303|    240|    return _end;
  304|    240|  }
_ZNK13IOBufferBlock10read_availEv:
  338|    797|  {
  339|    797|    return static_cast<int64_t>(_end - _start);
  340|    797|  }
_ZN13IOBufferBlock11write_availEv:
  350|    422|  {
  351|    422|    return static_cast<int64_t>(_buf_end - _end);
  352|    422|  }
_ZNK14IOBufferReader9allocatedEv:
  863|  2.38k|  {
  864|  2.38k|    return mbuf;
  865|  2.38k|  }
_ZN14IOBufferReaderC2Ev:
  886|    745|  IOBufferReader() {}
_ZN9MIOBuffer12init_readersEv:
 1205|    149|  {
 1206|    745|    for (auto &reader : readers) {
  ------------------
  |  Branch (1206:23): [True: 745, False: 149]
  ------------------
 1207|    745|      if (reader.allocated() && !reader.block) {
  ------------------
  |  Branch (1207:11): [True: 0, False: 745]
  |  Branch (1207:33): [True: 0, False: 0]
  ------------------
 1208|      0|        reader.block = _writer;
 1209|      0|      }
 1210|    745|    }
 1211|    149|  }
_ZN9MIOBuffer7deallocEv:
 1215|    149|  {
 1216|    149|    _writer = nullptr;
 1217|    149|    dealloc_all_readers();
 1218|    149|  }
_ZN9MIOBuffer5clearEv:
 1222|    149|  {
 1223|    149|    dealloc();
 1224|    149|    size_index = BUFFER_SIZE_NOT_ALLOCATED;
  ------------------
  |  |  100|    149|#define BUFFER_SIZE_NOT_ALLOCATED                        DEFAULT_BUFFER_SIZES
  |  |  ------------------
  |  |  |  |   88|    149|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|    149|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1225|    149|    water_mark = 0;
 1226|    149|  }
_Z20index_to_buffer_sizel:
 1546|    240|{
 1547|    240|  if (BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(idx)) {
  ------------------
  |  |  102|    240|#define BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index) (((uint64_t)_size_index) < DEFAULT_BUFFER_SIZES)
  |  |  ------------------
  |  |  |  |   88|    240|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|    240|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (102:58): [True: 240, False: 0]
  |  |  ------------------
  ------------------
 1548|    240|    return BUFFER_SIZE_FOR_INDEX(idx);
  ------------------
  |  |   90|    240|#define BUFFER_SIZE_FOR_INDEX(_i) (DEFAULT_BUFFER_BASE_SIZE * (1 << (_i)))
  |  |  ------------------
  |  |  |  |   63|    240|#define DEFAULT_BUFFER_BASE_SIZE            128
  |  |  ------------------
  ------------------
 1549|    240|  } else if (BUFFER_SIZE_INDEX_IS_XMALLOCED(idx)) {
  ------------------
  |  |  101|      0|#define BUFFER_SIZE_INDEX_IS_XMALLOCED(_size_index)      (_size_index < 0)
  |  |  ------------------
  |  |  |  Branch (101:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1550|      0|    return BUFFER_SIZE_FOR_XMALLOC(idx);
  ------------------
  |  |  105|      0|#define BUFFER_SIZE_FOR_XMALLOC(_size) (-(_size))
  ------------------
 1551|       |    // coverity[dead_error_condition]
 1552|      0|  } else if (BUFFER_SIZE_INDEX_IS_CONSTANT(idx)) {
  ------------------
  |  |  103|      0|#define BUFFER_SIZE_INDEX_IS_CONSTANT(_size_index)       (_size_index >= DEFAULT_BUFFER_SIZES)
  |  |  ------------------
  |  |  |  |   88|      0|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (103:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1553|      0|    return BUFFER_SIZE_FOR_CONSTANT(idx);
  ------------------
  |  |  116|      0|#define BUFFER_SIZE_FOR_CONSTANT(_size)            (_size - DEFAULT_BUFFER_SIZES)
  |  |  ------------------
  |  |  |  |   88|      0|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1554|      0|  }
 1555|       |  // coverity[dead_error_line]
 1556|      0|  return 0;
 1557|    240|}

_ZN10ProxyMutexC2Ev:
  212|      1|  {
  213|      1|    thread_holding  = nullptr;
  214|      1|    nthread_holding = 0;
  215|       |#ifdef DEBUG
  216|       |    hold_time = 0;
  217|       |    handler   = nullptr;
  218|       |#ifdef MAX_LOCK_TAKEN
  219|       |    taken = 0;
  220|       |#endif // MAX_LOCK_TAKEN
  221|       |#ifdef LOCK_CONTENTION_PROFILING
  222|       |    total_acquires                    = 0;
  223|       |    blocking_acquires                 = 0;
  224|       |    nonblocking_acquires              = 0;
  225|       |    successful_nonblocking_acquires   = 0;
  226|       |    unsuccessful_nonblocking_acquires = 0;
  227|       |#endif // LOCK_CONTENTION_PROFILING
  228|       |#endif // DEBUG
  229|       |    // coverity[uninit_member]
  230|      1|  }
_ZN10ProxyMutex4initEv:
  244|      1|  {
  245|      1|    ink_mutex_init(&the_mutex);
  246|      1|  }
_Z10Mutex_lockP10ProxyMutexP7EThread:
  316|      2|{
  317|      2|  ink_assert(t != nullptr);
  ------------------
  |  |   45|      2|#define ink_assert(EX) (void)(EX)
  ------------------
  318|      2|  if (m->thread_holding != t) {
  ------------------
  |  Branch (318:7): [True: 1, False: 1]
  ------------------
  319|      1|    ink_mutex_acquire(&m->the_mutex);
  320|      1|    m->thread_holding = t;
  321|      1|    ink_assert(m->thread_holding);
  ------------------
  |  |   45|      1|#define ink_assert(EX) (void)(EX)
  ------------------
  322|       |#ifdef DEBUG
  323|       |    m->srcloc    = location;
  324|       |    m->handler   = ahandler;
  325|       |    m->hold_time = ink_get_hrtime();
  326|       |#ifdef MAX_LOCK_TAKEN
  327|       |    m->taken++;
  328|       |#endif // MAX_LOCK_TAKEN
  329|       |#endif // DEBUG
  330|      1|  }
  331|       |#ifdef DEBUG
  332|       |#ifdef LOCK_CONTENTION_PROFILING
  333|       |  m->blocking_acquires++;
  334|       |  m->total_acquires++;
  335|       |  m->print_lock_stats(0);
  336|       |#endif // LOCK_CONTENTION_PROFILING
  337|       |#endif // DEBUG
  338|      2|  m->nthread_holding++;
  339|      2|  return true;
  340|      2|}
_Z10Mutex_lockR3PtrI10ProxyMutexEP7EThread:
  348|      2|{
  349|      2|  return Mutex_lock(
  350|       |#ifdef DEBUG
  351|       |    location, ahandler,
  352|       |#endif
  353|      2|    m.get(), t);
  354|      2|}
_Z12Mutex_unlockP10ProxyMutexP7EThread:
  358|      1|{
  359|      1|  if (m->nthread_holding) {
  ------------------
  |  Branch (359:7): [True: 1, False: 0]
  ------------------
  360|      1|    ink_assert(t == m->thread_holding);
  ------------------
  |  |   45|      1|#define ink_assert(EX) (void)(EX)
  ------------------
  361|      1|    m->nthread_holding--;
  362|      1|    if (!m->nthread_holding) {
  ------------------
  |  Branch (362:9): [True: 0, False: 1]
  ------------------
  363|       |#ifdef DEBUG
  364|       |      if (ink_get_hrtime() - m->hold_time > MAX_LOCK_TIME)
  365|       |        lock_holding(m->srcloc, m->handler);
  366|       |#ifdef MAX_LOCK_TAKEN
  367|       |      if (m->taken > MAX_LOCK_TAKEN)
  368|       |        lock_taken(m->srcloc, m->handler);
  369|       |#endif // MAX_LOCK_TAKEN
  370|       |      m->srcloc  = SourceLocation(nullptr, nullptr, 0);
  371|       |      m->handler = nullptr;
  372|       |#endif // DEBUG
  373|      0|      ink_assert(m->thread_holding);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  374|      0|      m->thread_holding = nullptr;
  375|      0|      ink_mutex_release(&m->the_mutex);
  376|      0|    }
  377|      1|  }
  378|      1|}
_Z12Mutex_unlockR3PtrI10ProxyMutexEP7EThread:
  382|      1|{
  383|      1|  Mutex_unlock(m.get(), t);
  384|      1|}
_ZN9MutexLockC2ER3PtrI10ProxyMutexEP7EThread:
  453|      1|    : m(am), locked_p(true)
  454|      1|  {
  455|      1|    Mutex_lock(
  456|       |#ifdef DEBUG
  457|       |      location, ahandler,
  458|       |#endif // DEBUG
  459|      1|      m, t);
  460|      1|  }
_ZN9MutexLock7releaseEv:
  478|      1|  {
  479|      1|    if (locked_p) {
  ------------------
  |  Branch (479:9): [True: 1, False: 0]
  ------------------
  480|      1|      Mutex_unlock(m, m->thread_holding);
  481|      1|    }
  482|      1|    locked_p = false;
  483|      1|  }
_ZN9MutexLockD2Ev:
  485|      1|  ~MutexLock() { this->release(); }
_Z14new_ProxyMutexv:
  675|      1|{
  676|      1|  ProxyMutex *m = mutexAllocator.alloc();
  677|      1|  m->init();
  678|      1|  return m;
  679|      1|}

_ZN18PriorityEventQueue13dequeue_readyEl:
   98|      1|  {
   99|      1|    (void)t;
  100|      1|    Event *e = after[0].dequeue();
  101|      1|    if (e) {
  ------------------
  |  Branch (101:9): [True: 0, False: 1]
  ------------------
  102|      0|      ink_assert(e->in_the_priority_queue);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  103|      0|      e->in_the_priority_queue = 0;
  104|      0|    }
  105|      1|    return e;
  106|      1|  }
_ZN18PriorityEventQueue16earliest_timeoutEv:
  112|      1|  {
  113|     11|    for (int i = 0; i < N_PQ_LIST; i++) {
  ------------------
  |  |   30|     11|#define N_PQ_LIST          10
  ------------------
  |  Branch (113:21): [True: 10, False: 1]
  ------------------
  114|     10|      if (after[i].head) {
  ------------------
  |  Branch (114:11): [True: 0, False: 10]
  ------------------
  115|      0|        return last_check_time + (PQ_BUCKET_TIME(i) / 2);
  ------------------
  |  |   31|      0|#define PQ_BUCKET_TIME(_i) (HRTIME_MSECONDS(5) << (_i))
  |  |  ------------------
  |  |  |  |   80|      0|#define HRTIME_MSECONDS(_x) ((_x) * HRTIME_MSECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   60|      0|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   61|      0|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  116|      0|      }
  117|     10|    }
  118|      1|    return last_check_time + HRTIME_FOREVER;
  ------------------
  |  |   51|      1|#define HRTIME_FOREVER (10 * HRTIME_DECADE)
  |  |  ------------------
  |  |  |  |   52|      1|#define HRTIME_DECADE  (10 * HRTIME_YEAR)
  |  |  |  |  ------------------
  |  |  |  |  |  |   53|      1|#define HRTIME_YEAR    (365 * HRTIME_DAY + HRTIME_DAY / 4)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   55|      1|#define HRTIME_DAY     (24 * HRTIME_HOUR)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   56|      1|#define HRTIME_HOUR    (60 * HRTIME_MINUTE)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   57|      1|#define HRTIME_MINUTE  (60 * HRTIME_SECOND)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   58|      1|#define HRTIME_SECOND  (1000 * HRTIME_MSECOND)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   59|      1|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   60|      1|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   61|      1|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               #define HRTIME_YEAR    (365 * HRTIME_DAY + HRTIME_DAY / 4)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   55|      1|#define HRTIME_DAY     (24 * HRTIME_HOUR)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   56|      1|#define HRTIME_HOUR    (60 * HRTIME_MINUTE)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   57|      1|#define HRTIME_MINUTE  (60 * HRTIME_SECOND)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   58|      1|#define HRTIME_SECOND  (1000 * HRTIME_MSECOND)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   59|      1|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   60|      1|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   61|      1|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  119|      1|  }

_ZN14ProtectedQueue13dequeue_localEv:
   97|      1|{
   98|      1|  Event *e = localQueue.dequeue();
   99|      1|  if (e) {
  ------------------
  |  Branch (99:7): [True: 0, False: 1]
  ------------------
  100|      0|    ink_assert(e->in_the_prot_queue);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  101|      0|    e->in_the_prot_queue = 0;
  102|      0|  }
  103|      1|  return e;
  104|      1|}
_ZN14ProtectedQueueC2Ev:
   57|      1|{
   58|      1|  Event e;
   59|      1|  ink_mutex_init(&lock);
   60|      1|  ink_atomiclist_init(&al, "ProtectedQueue", (char *)&e.link.next - (char *)&e);
   61|      1|  ink_cond_init(&might_have_data);
   62|      1|}

_ZN14ProxyAllocatorC2Ev:
   49|     27|  ProxyAllocator() {}
_Z12thread_allocI14ClassAllocatorI12IOBufferDataLb0E17FreelistAllocatorEJEEPNT_10Value_typeERS4_R14ProxyAllocatorDpOT0_:
   55|    240|{
   56|    240|  if (!cmd_disable_pfreelist && l.freelist) {
  ------------------
  |  Branch (56:7): [True: 0, False: 240]
  |  Branch (56:33): [True: 0, False: 0]
  ------------------
   57|      0|    void *v    = l.freelist;
   58|      0|    l.freelist = *reinterpret_cast<void **>(l.freelist);
   59|      0|    --(l.allocated);
   60|       |#if TS_USE_ALLOCATOR_METRICS
   61|       |    a.increment_for_alloc();
   62|       |#endif
   63|      0|    ::new (v) typename CAlloc::Value_type(std::forward<Args>(args)...);
   64|      0|    return static_cast<typename CAlloc::Value_type *>(v);
   65|      0|  }
   66|    240|  return a.alloc(std::forward<Args>(args)...);
   67|    240|}
_Z12thread_allocI14ClassAllocatorI13IOBufferBlockLb0E17FreelistAllocatorEJEEPNT_10Value_typeERS4_R14ProxyAllocatorDpOT0_:
   55|    240|{
   56|    240|  if (!cmd_disable_pfreelist && l.freelist) {
  ------------------
  |  Branch (56:7): [True: 0, False: 240]
  |  Branch (56:33): [True: 0, False: 0]
  ------------------
   57|      0|    void *v    = l.freelist;
   58|      0|    l.freelist = *reinterpret_cast<void **>(l.freelist);
   59|      0|    --(l.allocated);
   60|       |#if TS_USE_ALLOCATOR_METRICS
   61|       |    a.increment_for_alloc();
   62|       |#endif
   63|      0|    ::new (v) typename CAlloc::Value_type(std::forward<Args>(args)...);
   64|      0|    return static_cast<typename CAlloc::Value_type *>(v);
   65|      0|  }
   66|    240|  return a.alloc(std::forward<Args>(args)...);
   67|    240|}
_Z12thread_allocI14ClassAllocatorI9MIOBufferLb0E17FreelistAllocatorEJEEPNT_10Value_typeERS4_R14ProxyAllocatorDpOT0_:
   55|    149|{
   56|    149|  if (!cmd_disable_pfreelist && l.freelist) {
  ------------------
  |  Branch (56:7): [True: 0, False: 149]
  |  Branch (56:33): [True: 0, False: 0]
  ------------------
   57|      0|    void *v    = l.freelist;
   58|      0|    l.freelist = *reinterpret_cast<void **>(l.freelist);
   59|      0|    --(l.allocated);
   60|       |#if TS_USE_ALLOCATOR_METRICS
   61|       |    a.increment_for_alloc();
   62|       |#endif
   63|      0|    ::new (v) typename CAlloc::Value_type(std::forward<Args>(args)...);
   64|      0|    return static_cast<typename CAlloc::Value_type *>(v);
   65|      0|  }
   66|    149|  return a.alloc(std::forward<Args>(args)...);
   67|    149|}
_Z12thread_allocI14ClassAllocatorI5EventLb0E17FreelistAllocatorEJEEPNT_10Value_typeERS4_R14ProxyAllocatorDpOT0_:
   55|      1|{
   56|      1|  if (!cmd_disable_pfreelist && l.freelist) {
  ------------------
  |  Branch (56:7): [True: 0, False: 1]
  |  Branch (56:33): [True: 0, False: 0]
  ------------------
   57|      0|    void *v    = l.freelist;
   58|      0|    l.freelist = *reinterpret_cast<void **>(l.freelist);
   59|      0|    --(l.allocated);
   60|       |#if TS_USE_ALLOCATOR_METRICS
   61|       |    a.increment_for_alloc();
   62|       |#endif
   63|      0|    ::new (v) typename CAlloc::Value_type(std::forward<Args>(args)...);
   64|      0|    return static_cast<typename CAlloc::Value_type *>(v);
   65|      0|  }
   66|      1|  return a.alloc(std::forward<Args>(args)...);
   67|      1|}

_ZN6Thread12set_specificEv:
  112|      1|  {
  113|      1|    this_thread_ptr = this;
  114|      1|  }
_Z11this_threadv:
  179|  1.25k|{
  180|  1.25k|  return Thread::this_thread_ptr;
  181|  1.25k|}

_ZN2ts17Http3ConfigParamsC2Ev:
   33|      1|  Http3ConfigParams(){};

_ZN10Http3FrameC2Ev:
   37|    144|  Http3Frame() {}
_ZN14Http3DataFrameC2Ev:
   86|     10|  Http3DataFrame() : Http3Frame() {}
_ZN17Http3HeadersFrameC2Ev:
  110|      5|  Http3HeadersFrame() : Http3Frame() {}
_ZN18Http3SettingsFrameC2Ev:
  137|      5|  Http3SettingsFrame() : Http3Frame(Http3FrameType::SETTINGS) {}
_ZN17Http3FrameDeleter12delete_frameEP10Http3Frame:
  194|    129|  {
  195|    129|    frame->~Http3Frame();
  196|    129|    http3FrameAllocator.free(static_cast<Http3Frame *>(frame));
  197|    129|  }
_ZN17Http3FrameDeleter17delete_data_frameEP10Http3Frame:
  201|     10|  {
  202|     10|    frame->~Http3Frame();
  203|     10|    http3DataFrameAllocator.free(static_cast<Http3DataFrame *>(frame));
  204|     10|  }
_ZN17Http3FrameDeleter20delete_headers_frameEP10Http3Frame:
  208|      5|  {
  209|      5|    frame->~Http3Frame();
  210|      5|    http3HeadersFrameAllocator.free(static_cast<Http3HeadersFrame *>(frame));
  211|      5|  }
_ZN17Http3FrameDeleter21delete_settings_frameEP10Http3Frame:
  215|      5|  {
  216|      5|    frame->~Http3Frame();
  217|      5|    http3SettingsFrameAllocator.free(static_cast<Http3SettingsFrame *>(frame));
  218|      5|  }

_Z29RecEstablishStaticConfigInt32RiPKcb:
  210|      3|{
  211|      3|  RecLinkConfigInt32(name, &rec_int);
  212|      3|  auto tmp{RecGetRecordInt(name, lock)};
  213|      3|  rec_int = static_cast<int32_t>(tmp.value_or(0));
  214|      3|  return tmp ? REC_ERR_OKAY : REC_ERR_FAIL;
  ------------------
  |  Branch (214:10): [True: 3, False: 0]
  ------------------
  215|      3|}
_Z30RecEstablishStaticConfigUInt32RjPKcb:
  220|      5|{
  221|      5|  RecLinkConfigUInt32(name, &rec_int);
  222|      5|  auto tmp{RecGetRecordInt(name, lock)};
  223|      5|  rec_int = static_cast<uint32_t>(tmp.value_or(0));
  224|      5|  return tmp ? REC_ERR_OKAY : REC_ERR_FAIL;
  ------------------
  |  Branch (224:10): [True: 5, False: 0]
  ------------------
  225|      5|}

_ZN17FreelistAllocator9free_voidEPv:
   72|  1.02k|  {
   73|  1.02k|    ink_freelist_free(this->fl, ptr);
   74|  1.02k|  }
_ZN17FreelistAllocator10alloc_voidEv:
   61|  1.02k|  {
   62|  1.02k|    return ink_freelist_new(this->fl);
   63|  1.02k|  }
_ZN17FreelistAllocatorC2Ev:
   89|     30|  FreelistAllocator() { fl = nullptr; }
_ZN17FreelistAllocatorC2EPKcjjjb:
  101|     18|  {
  102|     18|    ink_freelist_init(&fl, name, element_size, chunk_size, alignment, use_hugepages);
  103|     18|  }
_ZN17FreelistAllocator7re_initEPKcjjjbi:
  109|     15|  {
  110|     15|    ink_freelist_madvise_init(&this->fl, name, element_size, chunk_size, alignment, use_hugepages, advice);
  111|     15|  }
_ZN14ClassAllocatorI10ProxyMutexLb0E17FreelistAllocatorE5allocIJEEEPS0_DpOT_:
  342|      1|  {
  343|      1|    void *ptr = this->alloc_void();
  344|       |
  345|      1|    ::new (ptr) C(std::forward<Args>(args)...);
  346|      1|    return reinterpret_cast<C *>(ptr);
  347|      1|  }
_ZN14ClassAllocatorI5EventLb0E17FreelistAllocatorE4freeEPS0_:
  356|      2|  {
  357|      2|    destroy_if_enabled(ptr);
  358|       |
  359|      2|    this->free_void(ptr);
  360|      2|  }
_ZN14ClassAllocatorI5EventLb0E17FreelistAllocatorE18destroy_if_enabledEPS0_:
  382|      2|  {
  383|       |    if constexpr (Destruct_on_free) {
  384|       |      std::destroy_at(ptr);
  385|       |    }
  386|      2|  }
_ZN14ClassAllocatorI10Http3FrameLb0E17FreelistAllocatorE4freeEPS0_:
  356|    129|  {
  357|    129|    destroy_if_enabled(ptr);
  358|       |
  359|    129|    this->free_void(ptr);
  360|    129|  }
_ZN14ClassAllocatorI10Http3FrameLb0E17FreelistAllocatorE18destroy_if_enabledEPS0_:
  382|    129|  {
  383|       |    if constexpr (Destruct_on_free) {
  384|       |      std::destroy_at(ptr);
  385|       |    }
  386|    129|  }
_ZN14ClassAllocatorI14Http3DataFrameLb0E17FreelistAllocatorE4freeEPS0_:
  356|     10|  {
  357|     10|    destroy_if_enabled(ptr);
  358|       |
  359|     10|    this->free_void(ptr);
  360|     10|  }
_ZN14ClassAllocatorI14Http3DataFrameLb0E17FreelistAllocatorE18destroy_if_enabledEPS0_:
  382|     10|  {
  383|       |    if constexpr (Destruct_on_free) {
  384|       |      std::destroy_at(ptr);
  385|       |    }
  386|     10|  }
_ZN14ClassAllocatorI17Http3HeadersFrameLb0E17FreelistAllocatorE4freeEPS0_:
  356|      5|  {
  357|      5|    destroy_if_enabled(ptr);
  358|       |
  359|      5|    this->free_void(ptr);
  360|      5|  }
_ZN14ClassAllocatorI17Http3HeadersFrameLb0E17FreelistAllocatorE18destroy_if_enabledEPS0_:
  382|      5|  {
  383|       |    if constexpr (Destruct_on_free) {
  384|       |      std::destroy_at(ptr);
  385|       |    }
  386|      5|  }
_ZN14ClassAllocatorI18Http3SettingsFrameLb0E17FreelistAllocatorE4freeEPS0_:
  356|      5|  {
  357|      5|    destroy_if_enabled(ptr);
  358|       |
  359|      5|    this->free_void(ptr);
  360|      5|  }
_ZN14ClassAllocatorI18Http3SettingsFrameLb0E17FreelistAllocatorE18destroy_if_enabledEPS0_:
  382|      5|  {
  383|       |    if constexpr (Destruct_on_free) {
  384|       |      std::destroy_at(ptr);
  385|       |    }
  386|      5|  }
_ZN14ClassAllocatorI10Http3FrameLb0E17FreelistAllocatorEC2EPKcjj:
  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|  }
_ZN14ClassAllocatorI14Http3DataFrameLb0E17FreelistAllocatorEC2EPKcjj:
  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|  }
_ZN14ClassAllocatorI17Http3HeadersFrameLb0E17FreelistAllocatorEC2EPKcjj:
  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|  }
_ZN14ClassAllocatorI18Http3SettingsFrameLb0E17FreelistAllocatorEC2EPKcjj:
  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|  }
_ZN14ClassAllocatorI17Http3HeadersFrameLb0E17FreelistAllocatorE5allocIJEEEPS0_DpOT_:
  342|      5|  {
  343|      5|    void *ptr = this->alloc_void();
  344|       |
  345|      5|    ::new (ptr) C(std::forward<Args>(args)...);
  346|      5|    return reinterpret_cast<C *>(ptr);
  347|      5|  }
_ZN14ClassAllocatorI14Http3DataFrameLb0E17FreelistAllocatorE5allocIJEEEPS0_DpOT_:
  342|     10|  {
  343|     10|    void *ptr = this->alloc_void();
  344|       |
  345|     10|    ::new (ptr) C(std::forward<Args>(args)...);
  346|     10|    return reinterpret_cast<C *>(ptr);
  347|     10|  }
_ZN14ClassAllocatorI18Http3SettingsFrameLb0E17FreelistAllocatorE5allocIJEEEPS0_DpOT_:
  342|      5|  {
  343|      5|    void *ptr = this->alloc_void();
  344|       |
  345|      5|    ::new (ptr) C(std::forward<Args>(args)...);
  346|      5|    return reinterpret_cast<C *>(ptr);
  347|      5|  }
_ZN14ClassAllocatorI10Http3FrameLb0E17FreelistAllocatorE5allocIJEEEPS0_DpOT_:
  342|    129|  {
  343|    129|    void *ptr = this->alloc_void();
  344|       |
  345|    129|    ::new (ptr) C(std::forward<Args>(args)...);
  346|    129|    return reinterpret_cast<C *>(ptr);
  347|    129|  }
_ZN14ClassAllocatorI12IOBufferDataLb0E17FreelistAllocatorE5allocIJEEEPS0_DpOT_:
  342|    240|  {
  343|    240|    void *ptr = this->alloc_void();
  344|       |
  345|    240|    ::new (ptr) C(std::forward<Args>(args)...);
  346|    240|    return reinterpret_cast<C *>(ptr);
  347|    240|  }
_ZN14ClassAllocatorI12IOBufferDataLb0E17FreelistAllocatorE18destroy_if_enabledEPS0_:
  382|    240|  {
  383|       |    if constexpr (Destruct_on_free) {
  384|       |      std::destroy_at(ptr);
  385|       |    }
  386|    240|  }
_ZN14ClassAllocatorI12IOBufferDataLb0E17FreelistAllocatorE3rawEv:
  376|    240|  {
  377|    240|    return *this;
  378|    240|  }
_ZN14ClassAllocatorI13IOBufferBlockLb0E17FreelistAllocatorE5allocIJEEEPS0_DpOT_:
  342|    240|  {
  343|    240|    void *ptr = this->alloc_void();
  344|       |
  345|    240|    ::new (ptr) C(std::forward<Args>(args)...);
  346|    240|    return reinterpret_cast<C *>(ptr);
  347|    240|  }
_ZN14ClassAllocatorI13IOBufferBlockLb0E17FreelistAllocatorE18destroy_if_enabledEPS0_:
  382|    240|  {
  383|       |    if constexpr (Destruct_on_free) {
  384|       |      std::destroy_at(ptr);
  385|       |    }
  386|    240|  }
_ZN14ClassAllocatorI13IOBufferBlockLb0E17FreelistAllocatorE3rawEv:
  376|    240|  {
  377|    240|    return *this;
  378|    240|  }
_ZN14ClassAllocatorI9MIOBufferLb0E17FreelistAllocatorE5allocIJEEEPS0_DpOT_:
  342|    149|  {
  343|    149|    void *ptr = this->alloc_void();
  344|       |
  345|    149|    ::new (ptr) C(std::forward<Args>(args)...);
  346|    149|    return reinterpret_cast<C *>(ptr);
  347|    149|  }
_ZN14ClassAllocatorI9MIOBufferLb0E17FreelistAllocatorE18destroy_if_enabledEPS0_:
  382|    149|  {
  383|       |    if constexpr (Destruct_on_free) {
  384|       |      std::destroy_at(ptr);
  385|       |    }
  386|    149|  }
_ZN14ClassAllocatorI9MIOBufferLb0E17FreelistAllocatorE3rawEv:
  376|    149|  {
  377|    149|    return *this;
  378|    149|  }
_ZN14ClassAllocatorI9MIOBufferLb0E17FreelistAllocatorEC2EPKcjj:
  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|  }
_ZN14ClassAllocatorI12IOBufferDataLb0E17FreelistAllocatorEC2EPKcjj:
  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|  }
_ZN14ClassAllocatorI13IOBufferBlockLb0E17FreelistAllocatorEC2EPKcjj:
  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|  }
_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|  }
_ZN14ClassAllocatorI5EventLb0E17FreelistAllocatorE5allocIJEEEPS0_DpOT_:
  342|      4|  {
  343|      4|    void *ptr = this->alloc_void();
  344|       |
  345|      4|    ::new (ptr) C(std::forward<Args>(args)...);
  346|      4|    return reinterpret_cast<C *>(ptr);
  347|      4|  }
_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|  }

_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|  }

_ZN5Event9Link_link9next_linkEPS_:
  111|      5|    {                                 \
  112|      5|      return c->_f.next;              \
  113|      5|    }                                 \
_ZN5Event9Link_link9prev_linkEPS_:
  116|      1|    {                                 \
  117|      1|      return c->_f.prev;              \
  118|      1|    }                                 \
_ZN5QueueI5EventNS0_9Link_linkEE7enqueueEPS0_:
  656|      1|{
  657|      1|  if (tail) {
  ------------------
  |  Branch (657:7): [True: 1, False: 0]
  ------------------
  658|      1|    insert(e, tail);
  659|      1|  } else {
  660|      0|    push(e);
  661|      0|  }
  662|      1|}
_ZN5QueueI5EventNS0_9Link_linkEE6insertEPS0_S3_:
  596|      1|{
  597|      1|  DLL<C, L>::insert(e, after);
  598|      1|  if (!tail) {
  ------------------
  |  Branch (598:7): [True: 0, False: 1]
  ------------------
  599|      0|    tail = head;
  600|      1|  } else if (tail == after) {
  ------------------
  |  Branch (600:14): [True: 1, False: 0]
  ------------------
  601|      1|    tail = e;
  602|      1|  }
  603|      1|}
_ZN3DLLI5EventNS0_9Link_linkEE6insertEPS0_S3_:
  407|      1|{
  408|      1|  if (!after) {
  ------------------
  |  Branch (408:7): [True: 0, False: 1]
  ------------------
  409|      0|    push(e);
  410|      0|    return;
  411|      0|  }
  412|      1|  prev(e)     = after;
  413|      1|  next(e)     = next(after);
  414|      1|  next(after) = e;
  415|      1|  if (next(e)) {
  ------------------
  |  Branch (415:7): [True: 0, False: 1]
  ------------------
  416|      0|    prev(next(e)) = e;
  417|      0|  }
  418|      1|}
_ZN3DLLI5EventNS0_9Link_linkEE4pushEPS0_:
  359|      1|{
  360|      1|  if (head) {
  ------------------
  |  Branch (360:7): [True: 0, False: 1]
  ------------------
  361|      0|    prev(head) = e;
  362|      0|  }
  363|      1|  next(e) = head;
  364|      1|  head    = e;
  365|      1|}
_ZN3DLLI5EventNS0_9Link_linkEE4prevEPS0_:
  250|      1|  {
  251|      1|    return reinterpret_cast<C *&>(L::prev_link(e));
  252|      1|  }
_ZN3DLLI5EventNS0_9Link_linkEE4nextEPS0_:
  245|      5|  {
  246|      5|    return reinterpret_cast<C *&>(L::next_link(e));
  247|      5|  }
_ZN5QueueI5EventNS0_9Link_linkEE4pushEPS0_:
  575|      1|{
  576|      1|  DLL<C, L>::push(e);
  577|      1|  if (!tail) {
  ------------------
  |  Branch (577:7): [True: 1, False: 0]
  ------------------
  578|      1|    tail = head;
  579|      1|  }
  580|      1|}
_ZN5QueueI5EventNS0_9Link_linkEE7dequeueEv:
  676|      2|{
  677|      2|  return pop();
  678|      2|}
_ZN5QueueI5EventNS0_9Link_linkEE3popEv:
  585|      2|{
  586|      2|  C *ret = DLL<C, L>::pop();
  587|      2|  if (!head) {
  ------------------
  |  Branch (587:7): [True: 2, False: 0]
  ------------------
  588|      2|    tail = nullptr;
  589|      2|  }
  590|      2|  return ret;
  591|      2|}
_ZN3DLLI5EventNS0_9Link_linkEE3popEv:
  390|      2|{
  391|      2|  C *ret = head;
  392|      2|  if (ret) {
  ------------------
  |  Branch (392:7): [True: 0, False: 2]
  ------------------
  393|      0|    head = next(ret);
  394|      0|    if (head) {
  ------------------
  |  Branch (394:9): [True: 0, False: 0]
  ------------------
  395|      0|      prev(head) = nullptr;
  396|      0|    }
  397|      0|    next(ret) = nullptr;
  398|      0|    return ret;
  399|      2|  } else {
  400|      2|    return nullptr;
  401|      2|  }
  402|      2|}
_ZN4LinkI5EventEC2Ev:
  103|      5|  Link() : prev(nullptr) {}
_ZN5SLinkI5EventEC2Ev:
   69|      5|  SLink() : next(nullptr){};
_ZN5QueueI5EventNS0_9Link_linkEEC2Ev:
  567|     28|  Queue() : tail(nullptr) {}
_ZN3DLLI5EventNS0_9Link_linkEEC2Ev:
  264|     28|  DLL() : head(nullptr) {}
_ZN5QueueI12ContinuationNS0_9Link_linkEEC2Ev:
  567|      1|  Queue() : tail(nullptr) {}
_ZN3DLLI12ContinuationNS0_9Link_linkEEC2Ev:
  264|      1|  DLL() : head(nullptr) {}
_ZNK5QueueI5EventNS0_9Link_linkEE5emptyEv:
  563|      2|  {
  564|      2|    return head == nullptr;
  565|      2|  }
_ZN3SLLI5EventNS0_9Link_linkEEC2Ev:
  192|      2|  SLL() : head(nullptr) {}
_ZN3SLLI5EventNS0_9Link_linkEE3popEv:
  210|      2|{
  211|      2|  C *ret = head;
  212|      2|  if (ret) {
  ------------------
  |  Branch (212:7): [True: 0, False: 2]
  ------------------
  213|      0|    head      = next(ret);
  214|      0|    next(ret) = nullptr;
  215|      0|  }
  216|      2|  return ret;
  217|      2|}
_ZN4LinkI12ContinuationEC2Ev:
  103|      6|  Link() : prev(nullptr) {}
_ZN5SLinkI12ContinuationEC2Ev:
   69|      6|  SLink() : next(nullptr){};

_ZN10ParseRules8is_digitEc:
  220|    797|{
  221|    797|#ifndef COMPILE_PARSE_RULES
  222|    797|  return (parseRulesCType[static_cast<unsigned char>(c)] & is_digit_BIT);
  ------------------
  |  |   42|    797|#define is_digit_BIT           (1 << 4)
  ------------------
  223|       |#else
  224|       |  return (c >= '0' && c <= '9');
  225|       |#endif
  226|    797|}
_ZN10ParseRules6is_hexEc:
  260|      6|{
  261|      6|#ifndef COMPILE_PARSE_RULES
  262|      6|  return (parseRulesCType[static_cast<unsigned char>(c)] & is_hex_BIT);
  ------------------
  |  |   45|      6|#define is_hex_BIT             (1 << 7)
  ------------------
  263|       |#else
  264|       |  return ((c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f') || (c >= '0' && c <= '9'));
  265|       |#endif
  266|      6|}
_ZN10ParseRules9is_wslfcrEc:
  302|    432|{
  303|    432|#ifndef COMPILE_PARSE_RULES
  304|    432|  return (parseRulesCType[static_cast<unsigned char>(c)] & is_wslfcr_BIT);
  ------------------
  |  |   58|    432|#define is_wslfcr_BIT          (1 << 20)
  ------------------
  305|       |#else
  306|       |  return ParseRules::is_ws(c) || ParseRules::is_splf(c) || ParseRules::is_spcr(c);
  307|       |#endif
  308|    432|}
_ZN10ParseRules11ink_toupperEc:
  553|  19.7k|{
  554|  19.7k|#ifndef COMPILE_PARSE_RULES
  555|  19.7k|  return parseRulesCTypeToUpper[static_cast<unsigned char>(c)];
  556|       |#else
  557|       |  int       up_case      = c;
  558|       |  const int up_case_diff = 'a' - 'A';
  559|       |
  560|       |  if (c >= 'a' && c <= 'z') {
  561|       |    up_case = c - up_case_diff;
  562|       |  }
  563|       |  return (up_case);
  564|       |#endif
  565|  19.7k|}
ParseRules.cc:_ZL11ink_get_hexc:
  850|      6|{
  851|      6|  if (ParseRules::is_digit(c)) {
  ------------------
  |  Branch (851:7): [True: 6, False: 0]
  ------------------
  852|      6|    return (c - '0');
  853|      6|  }
  854|      0|  c = ParseRules::ink_tolower(c);
  855|      0|  return ((c - 'a') + 10);
  856|      6|}

_ZN11RefCountObjC2Ev:
   49|    482|  RefCountObj() {}
_ZN11RefCountObj12refcount_incEv:
   58|    873|  {
   59|    873|    return ++m_refcount;
   60|    873|  }
_ZN11RefCountObj12refcount_decEv:
   65|    871|  {
   66|    871|    return --m_refcount;
   67|    871|  }
_ZNK3PtrI12IOBufferDataEptEv:
  117|    720|  {
  118|    720|    return (m_ptr);
  119|    720|  }
_ZNK3PtrI13IOBufferBlockEcvbEv:
  129|    875|  {
  130|    875|    return m_ptr != nullptr;
  131|    875|  }
_ZNK3PtrI13IOBufferBlockEptEv:
  117|  1.95k|  {
  118|  1.95k|    return (m_ptr);
  119|  1.95k|  }
_ZNK3PtrI13IOBufferBlockE3getEv:
  160|  1.30k|  {
  161|  1.30k|    return m_ptr;
  162|  1.30k|  }
_ZN3PtrI13IOBufferBlockEaSERKS1_:
  271|    240|{
  272|    240|  return (operator=(src.m_ptr));
  273|    240|}
_ZN3PtrI13IOBufferBlockEaSEPS0_:
  236|  1.07k|{
  237|  1.07k|  T *temp_ptr = m_ptr;
  238|       |
  239|  1.07k|  if (m_ptr == p) {
  ------------------
  |  Branch (239:7): [True: 298, False: 778]
  ------------------
  240|    298|    return (*this);
  241|    298|  }
  242|       |
  243|    778|  m_ptr = p;
  244|       |
  245|    778|  if (m_ptr) {
  ------------------
  |  Branch (245:7): [True: 480, False: 298]
  ------------------
  246|    480|    m_ptr->refcount_inc();
  247|    480|  }
  248|       |
  249|    778|  if (temp_ptr && temp_ptr->refcount_dec() == 0) {
  ------------------
  |  Branch (249:7): [True: 389, False: 389]
  |  Branch (249:19): [True: 240, False: 149]
  ------------------
  250|    240|    temp_ptr->free();
  251|    240|  }
  252|       |
  253|    778|  return (*this);
  254|  1.07k|}
_ZN3PtrI13IOBufferBlockEeqEPKS0_:
  135|    182|  {
  136|    182|    return (m_ptr == p);
  137|    182|  }
_ZNK3PtrI10ProxyMutexE3getEv:
  160|      3|  {
  161|      3|    return m_ptr;
  162|      3|  }
_ZNK3PtrI10ProxyMutexEptEv:
  117|      2|  {
  118|      2|    return (m_ptr);
  119|      2|  }
_ZNK3PtrI10ProxyMutexEcvbEv:
  129|      3|  {
  130|      3|    return m_ptr != nullptr;
  131|      3|  }
_ZN3PtrI10ProxyMutexEaSERKS1_:
  271|      5|{
  272|      5|  return (operator=(src.m_ptr));
  273|      5|}
_ZN3PtrI10ProxyMutexEaSEPS0_:
  236|      9|{
  237|      9|  T *temp_ptr = m_ptr;
  238|       |
  239|      9|  if (m_ptr == p) {
  ------------------
  |  Branch (239:7): [True: 6, False: 3]
  ------------------
  240|      6|    return (*this);
  241|      6|  }
  242|       |
  243|      3|  m_ptr = p;
  244|       |
  245|      3|  if (m_ptr) {
  ------------------
  |  Branch (245:7): [True: 2, False: 1]
  ------------------
  246|      2|    m_ptr->refcount_inc();
  247|      2|  }
  248|       |
  249|      3|  if (temp_ptr && temp_ptr->refcount_dec() == 0) {
  ------------------
  |  Branch (249:7): [True: 1, False: 2]
  |  Branch (249:19): [True: 0, False: 1]
  ------------------
  250|      0|    temp_ptr->free();
  251|      0|  }
  252|       |
  253|      3|  return (*this);
  254|      9|}
_ZN3PtrI13IOBufferBlockEC2EPS0_:
  207|  1.15k|template <class T> inline Ptr<T>::Ptr(T *ptr /* = 0 */) : m_ptr(ptr)
  208|  1.15k|{
  209|  1.15k|  if (m_ptr) {
  ------------------
  |  Branch (209:7): [True: 0, False: 1.15k]
  ------------------
  210|      0|    m_ptr->refcount_inc();
  211|      0|  }
  212|  1.15k|}
_ZN3PtrI13IOBufferBlockED2Ev:
  227|     10|{
  228|     10|  if (m_ptr && m_ptr->refcount_dec() == 0) {
  ------------------
  |  Branch (228:7): [True: 0, False: 10]
  |  Branch (228:16): [True: 0, False: 0]
  ------------------
  229|      0|    m_ptr->free();
  230|      0|  }
  231|     10|}
_ZN3PtrI12IOBufferDataEC2EPS0_:
  207|    240|template <class T> inline Ptr<T>::Ptr(T *ptr /* = 0 */) : m_ptr(ptr)
  208|    240|{
  209|    240|  if (m_ptr) {
  ------------------
  |  Branch (209:7): [True: 0, False: 240]
  ------------------
  210|      0|    m_ptr->refcount_inc();
  211|      0|  }
  212|    240|}
_ZN3PtrI12IOBufferDataEaSEPS0_:
  236|    480|{
  237|    480|  T *temp_ptr = m_ptr;
  238|       |
  239|    480|  if (m_ptr == p) {
  ------------------
  |  Branch (239:7): [True: 0, False: 480]
  ------------------
  240|      0|    return (*this);
  241|      0|  }
  242|       |
  243|    480|  m_ptr = p;
  244|       |
  245|    480|  if (m_ptr) {
  ------------------
  |  Branch (245:7): [True: 240, False: 240]
  ------------------
  246|    240|    m_ptr->refcount_inc();
  247|    240|  }
  248|       |
  249|    480|  if (temp_ptr && temp_ptr->refcount_dec() == 0) {
  ------------------
  |  Branch (249:7): [True: 240, False: 240]
  |  Branch (249:19): [True: 240, False: 0]
  ------------------
  250|    240|    temp_ptr->free();
  251|    240|  }
  252|       |
  253|    480|  return (*this);
  254|    480|}
_ZN3PtrI13IOBufferBlockE6detachEv:
  176|    240|  {
  177|    240|    T *tmp = m_ptr;
  178|    240|    m_ptr  = nullptr;
  179|    240|    return tmp;
  180|    240|  }
_ZN3PtrI10ProxyMutexED2Ev:
  227|      2|{
  228|      2|  if (m_ptr && m_ptr->refcount_dec() == 0) {
  ------------------
  |  Branch (228:7): [True: 1, False: 1]
  |  Branch (228:16): [True: 0, False: 1]
  ------------------
  229|      0|    m_ptr->free();
  230|      0|  }
  231|      2|}
_ZN3PtrI10ProxyMutexEC2EPS0_:
  207|     12|template <class T> inline Ptr<T>::Ptr(T *ptr /* = 0 */) : m_ptr(ptr)
  208|     12|{
  209|     12|  if (m_ptr) {
  ------------------
  |  Branch (209:7): [True: 0, False: 12]
  ------------------
  210|      0|    m_ptr->refcount_inc();
  211|      0|  }
  212|     12|}
_ZN3PtrI10ProxyMutexEC2ERKS1_:
  214|      1|template <class T> inline Ptr<T>::Ptr(const Ptr<T> &src) : m_ptr(src.m_ptr)
  215|      1|{
  216|      1|  if (m_ptr) {
  ------------------
  |  Branch (216:7): [True: 1, False: 0]
  ------------------
  217|      1|    m_ptr->refcount_inc();
  218|      1|  }
  219|      1|}

_ZN13TSSystemState25is_event_system_shut_downEv:
   56|      1|  {
   57|      1|    return unlikely(_instance().event_system_shut_down);
  ------------------
  |  |   31|      1|#define unlikely(x) __builtin_expect(!!(x), 0)
  ------------------
   58|      1|  }
_ZN13TSSystemState9_instanceEv:
  102|      1|  {
  103|      1|    static Data d;
  104|       |
  105|      1|    return d;
  106|      1|  }

_ZN2ts13ModuleVersion5checkERKS0_:
  124|      1|{
  125|      1|  switch (_type) {
  ------------------
  |  Branch (125:11): [True: 1, False: 0]
  ------------------
  126|      1|  case PUBLIC:
  ------------------
  |  Branch (126:3): [True: 1, False: 0]
  ------------------
  127|      1|    return _major == that._major && _minor <= that._minor;
  ------------------
  |  Branch (127:12): [True: 1, False: 0]
  |  Branch (127:37): [True: 1, False: 0]
  ------------------
  128|      0|  case PRIVATE:
  ------------------
  |  Branch (128:3): [True: 0, False: 1]
  ------------------
  129|      0|    return _major == that._major && _minor == that._minor;
  ------------------
  |  Branch (129:12): [True: 0, False: 0]
  |  Branch (129:37): [True: 0, False: 0]
  ------------------
  130|      1|  }
  131|      0|  return false;
  132|      1|};

ink_queue.cc:_ZL20ink_atomic_incrementIijET_PS0_T0_:
   77|     10|{
   78|     10|  return __sync_fetch_and_add(mem, (Type)count);
   79|     10|}
ink_queue.cc:_ZL20ink_atomic_incrementIiiET_PS0_T0_:
   77|  1.02k|{
   78|  1.02k|  return __sync_fetch_and_add(mem, (Type)count);
   79|  1.02k|}
ink_queue.cc:_ZL14ink_atomic_casInEbPT_S0_S0_:
   68|  3.57k|{
   69|  3.57k|  return __sync_bool_compare_and_swap(mem, prev, next);
   70|  3.57k|}
ink_queue.cc:_ZL20ink_atomic_decrementIiiET_PS0_T0_:
   86|  1.02k|{
   87|  1.02k|  return __sync_fetch_and_sub(mem, (Type)count);
   88|  1.02k|}
RecDebug.cc:_ZL15ink_atomic_swapIP5DiagsET_PS2_S2_:
   58|      1|{
   59|      1|  return __sync_lock_test_and_set(mem, value);
   60|      1|}

RecordsConfig.cc:_ZL7countofI13RecordElementLj559EEjRAT0__KT_:
   60|    560|{
   61|    560|  return N;
   62|    560|}

UnixEThread.cc:_ZL14ink_get_hrtimev:
  231|      3|{
  232|      3|#if defined(freebsd) || HAVE_CLOCK_GETTIME
  233|      3|  timespec ts;
  234|      3|  clock_gettime(static_cast<clockid_t>(gSystemClock), &ts);
  235|      3|  return ink_hrtime_from_timespec(&ts);
  236|       |#else
  237|       |  timeval tv;
  238|       |  gettimeofday(&tv, nullptr);
  239|       |  return ink_hrtime_from_timeval(&tv);
  240|       |#endif
  241|      3|}
UnixEThread.cc:_ZL24ink_hrtime_from_timespecPK8timespec:
  136|      3|{
  137|      3|  return ink_hrtime_from_sec(ts->tv_sec) + ink_hrtime_from_nsec(ts->tv_nsec);
  138|      3|}
UnixEThread.cc:_ZL19ink_hrtime_from_secj:
  112|      3|{
  113|      3|  return (HRTIME_SECONDS(sec));
  ------------------
  |  |   79|      3|#define HRTIME_SECONDS(_x)  ((_x) * HRTIME_SECOND)
  |  |  ------------------
  |  |  |  |   58|      3|#define HRTIME_SECOND  (1000 * HRTIME_MSECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      3|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   60|      3|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   61|      3|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  114|      3|}
UnixEThread.cc:_ZL20ink_hrtime_from_nsecj:
  130|      3|{
  131|      3|  return (HRTIME_NSECONDS(nsec));
  ------------------
  |  |   82|      3|#define HRTIME_NSECONDS(_x) ((_x) * HRTIME_NSECOND)
  |  |  ------------------
  |  |  |  |   61|      3|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  ------------------
  ------------------
  132|      3|}
PQ-List.cc:_ZL14ink_get_hrtimev:
  231|      1|{
  232|      1|#if defined(freebsd) || HAVE_CLOCK_GETTIME
  233|      1|  timespec ts;
  234|      1|  clock_gettime(static_cast<clockid_t>(gSystemClock), &ts);
  235|      1|  return ink_hrtime_from_timespec(&ts);
  236|       |#else
  237|       |  timeval tv;
  238|       |  gettimeofday(&tv, nullptr);
  239|       |  return ink_hrtime_from_timeval(&tv);
  240|       |#endif
  241|      1|}
PQ-List.cc:_ZL24ink_hrtime_from_timespecPK8timespec:
  136|      1|{
  137|      1|  return ink_hrtime_from_sec(ts->tv_sec) + ink_hrtime_from_nsec(ts->tv_nsec);
  138|      1|}
PQ-List.cc:_ZL19ink_hrtime_from_secj:
  112|      1|{
  113|      1|  return (HRTIME_SECONDS(sec));
  ------------------
  |  |   79|      1|#define HRTIME_SECONDS(_x)  ((_x) * HRTIME_SECOND)
  |  |  ------------------
  |  |  |  |   58|      1|#define HRTIME_SECOND  (1000 * HRTIME_MSECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      1|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   60|      1|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   61|      1|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  114|      1|}
PQ-List.cc:_ZL20ink_hrtime_from_nsecj:
  130|      1|{
  131|      1|  return (HRTIME_NSECONDS(nsec));
  ------------------
  |  |   82|      1|#define HRTIME_NSECONDS(_x) ((_x) * HRTIME_NSECOND)
  |  |  ------------------
  |  |  |  |   61|      1|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  ------------------
  ------------------
  132|      1|}
ProtectedQueue.cc:_ZL22ink_hrtime_to_timespecl:
  202|      1|{
  203|      1|  struct timespec ts;
  204|       |
  205|      1|  ts.tv_sec  = ink_hrtime_to_sec(t);
  206|      1|  ts.tv_nsec = t % HRTIME_SECOND;
  ------------------
  |  |   58|      1|#define HRTIME_SECOND  (1000 * HRTIME_MSECOND)
  |  |  ------------------
  |  |  |  |   59|      1|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|      1|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   61|      1|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  207|      1|  return (ts);
  208|      1|}
ProtectedQueue.cc:_ZL17ink_hrtime_to_secl:
  178|      1|{
  179|      1|  return (t / HRTIME_SECOND);
  ------------------
  |  |   58|      1|#define HRTIME_SECOND  (1000 * HRTIME_MSECOND)
  |  |  ------------------
  |  |  |  |   59|      1|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|      1|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   61|      1|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  180|      1|}

_Z13ats_stringdupRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE:
  145|      1|{
  146|      1|  return p.empty() ? nullptr : _xstrdup(p.data(), p.size(), nullptr);
  ------------------
  |  Branch (146:10): [True: 0, False: 1]
  ------------------
  147|      1|}
_Z12ats_as_c_strRKNSt3__18optionalINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEEE:
  163|      1|{
  164|      1|  return p ? p.value().c_str() : nullptr;
  ------------------
  |  Branch (164:10): [True: 0, False: 1]
  ------------------
  165|      1|}
_ZN14ats_scoped_strC2EPc:
  533|    559|  explicit ats_scoped_str(char *s) : super(s) {}
_ZN19ats_scoped_resourceIN6detail20SCOPED_MALLOC_TRAITSIcEEE5clearEv:
  317|    561|  {
  318|    561|    if (Traits::isValid(_r)) {
  ------------------
  |  Branch (318:9): [True: 560, False: 1]
  ------------------
  319|    560|      Traits::destroy(_r);
  320|    560|    }
  321|    561|    _r = Traits::initValue();
  322|    561|  }
_ZN6detail20SCOPED_MALLOC_TRAITSIcE7isValidEPc:
  471|    561|  {
  472|    561|    return nullptr != t;
  473|    561|  }
_ZN6detail20SCOPED_MALLOC_TRAITSIcE7destroyEPc:
  476|    560|  {
  477|    560|    ats_free(t);
  478|    560|  }
_ZN6detail20SCOPED_MALLOC_TRAITSIcE9initValueEv:
  466|    562|  {
  467|    562|    return nullptr;
  468|    562|  }
_ZNK19ats_scoped_resourceIN6detail20SCOPED_MALLOC_TRAITSIcEEEcvPcEv:
  325|    561|  operator value_type() const { return _r; }
ink_queue.cc:_ZL12ats_pagesizev:
  112|     76|{
  113|     76|  static size_t page_size;
  114|       |
  115|     76|  if (page_size) {
  ------------------
  |  Branch (115:7): [True: 74, False: 2]
  ------------------
  116|     74|    return page_size;
  117|     74|  }
  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|     76|}
_Z8ink_zeroI12_InkFreeListEvRT_:
  213|     33|{
  214|     33|  memset(static_cast<void *>(&t), 0, sizeof(t));
  215|     33|}
_ZN19ats_scoped_resourceIN6detail20SCOPED_MALLOC_TRAITSIcEEEC2EPc:
  308|    559|  explicit ats_scoped_resource(value_type rt) : _r(rt) {}
_ZN19ats_scoped_resourceIN6detail20SCOPED_MALLOC_TRAITSIcEEEC2Ev:
  306|      1|  ats_scoped_resource() : _r(Traits::initValue()) {}
_ZN19ats_scoped_resourceIN6detail20SCOPED_MALLOC_TRAITSIcEEED2Ev:
  310|    560|  ~ats_scoped_resource() { this->clear(); }
_ZNK19ats_scoped_resourceIN6detail20SCOPED_MALLOC_TRAITSIcEEE3getEv:
  331|    559|  {
  332|    559|    return _r;
  333|    559|  }
_Z8ink_zeroIA16_cEvRT_:
  213|      1|{
  214|      1|  memset(static_cast<void *>(&t), 0, sizeof(t));
  215|      1|}
UnixEventProcessor.cc:_ZL12ats_pagesizev:
  112|      3|{
  113|      3|  static size_t page_size;
  114|       |
  115|      3|  if (page_size) {
  ------------------
  |  Branch (115:7): [True: 2, False: 1]
  ------------------
  116|      2|    return page_size;
  117|      2|  }
  118|       |
  119|      1|#if defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
  120|      1|  long ret  = sysconf(_SC_PAGESIZE);
  121|      1|  page_size = static_cast<size_t>((ret > -1) ? ret : 8192);
  ------------------
  |  Branch (121:35): [True: 1, 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|      1|  return page_size;
  129|      3|}
_Z8ink_zeroIA4096_P7EThreadEvRT_:
  213|      4|{
  214|      4|  memset(static_cast<void *>(&t), 0, sizeof(t));
  215|      4|}
_ZN14ats_scoped_strC2ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  565|      1|{
  566|      1|  if (!s.empty()) {
  ------------------
  |  Branch (566:7): [True: 1, False: 0]
  ------------------
  567|      1|    *this = s;
  568|      1|  }
  569|      1|}
_Z8ink_zeroI9RecRecordEvRT_:
  213|    559|{
  214|    559|  memset(static_cast<void *>(&t), 0, sizeof(t));
  215|    559|}

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

_ZN6head_pC2Ev:
   77|  7.15k|  head_p() : data(){};
_ZN13InkAtomicListC2Ev:
  215|      1|  InkAtomicList() {}

_Z17ink_rwlock_rdlockP16pthread_rwlock_t:
   52|     19|{
   53|     19|  int error = pthread_rwlock_rdlock(rw);
   54|     19|  if (unlikely(error != 0)) {
  ------------------
  |  |   31|     19|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 19]
  |  |  ------------------
  ------------------
   55|      0|    ink_abort("pthread_rwlock_rdlock(%p) failed: %s (%d)", static_cast<void *>(rw), strerror(error), error);
   56|      0|  }
   57|     19|}
_Z17ink_rwlock_wrlockP16pthread_rwlock_t:
   74|    560|{
   75|    560|  int error = pthread_rwlock_wrlock(rw);
   76|    560|  if (unlikely(error != 0)) {
  ------------------
  |  |   31|    560|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 560]
  |  |  ------------------
  ------------------
   77|      0|    ink_abort("pthread_rwlock_wrlock(%p) failed: %s (%d)", static_cast<void *>(rw), strerror(error), error);
   78|      0|  }
   79|    560|}
_Z17ink_rwlock_unlockP16pthread_rwlock_t:
   96|    579|{
   97|    579|  int error = pthread_rwlock_unlock(rw);
   98|    579|  if (unlikely(error != 0)) {
  ------------------
  |  |   31|    579|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 579]
  |  |  ------------------
  ------------------
   99|      0|    ink_abort("pthread_rwlock_unlock(%p) failed: %s (%d)", static_cast<void *>(rw), strerror(error), error);
  100|      0|  }
  101|    579|}

Thread.cc:_ZL17ink_thread_createPmPFPvS0_ES0_imS0_:
  105|      1|{
  106|      1|  ink_thread     t;
  107|      1|  int            ret;
  108|      1|  pthread_attr_t attr;
  109|       |
  110|      1|  if (tid == nullptr) {
  ------------------
  |  Branch (110:7): [True: 0, False: 1]
  ------------------
  111|      0|    tid = &t;
  112|      0|  }
  113|       |
  114|      1|  pthread_attr_init(&attr);
  115|      1|  pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
  116|       |
  117|      1|  if (stacksize) {
  ------------------
  |  Branch (117:7): [True: 1, False: 0]
  ------------------
  118|      1|    if (stack) {
  ------------------
  |  Branch (118:9): [True: 1, False: 0]
  ------------------
  119|      1|      pthread_attr_setstack(&attr, stack, stacksize);
  120|      1|    } else {
  121|      0|      pthread_attr_setstacksize(&attr, stacksize);
  122|      0|    }
  123|      1|  }
  124|       |
  125|      1|  if (detached) {
  ------------------
  |  Branch (125:7): [True: 0, False: 1]
  ------------------
  126|      0|    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  127|      0|  }
  128|       |
  129|      1|  ret = pthread_create(tid, &attr, f, a);
  130|      1|  if (ret != 0) {
  ------------------
  |  Branch (130:7): [True: 0, False: 1]
  ------------------
  131|      0|    ink_abort("pthread_create() failed: %s (%d)", strerror(ret), ret);
  132|      0|  }
  133|      1|  pthread_attr_destroy(&attr);
  134|      1|}
Thread.cc:_ZL19ink_set_thread_namePKc:
  266|      1|{
  267|       |#if defined(HAVE_PTHREAD_SETNAME_NP_1)
  268|       |  pthread_setname_np(name);
  269|       |#elif defined(HAVE_PTHREAD_SETNAME_NP_2)
  270|       |  pthread_setname_np(pthread_self(), name);
  271|       |#elif defined(HAVE_PTHREAD_SET_NAME_NP_2)
  272|       |  pthread_set_name_np(pthread_self(), name);
  273|       |#elif HAVE_PRCTL && defined(PR_SET_NAME)
  274|       |  prctl(PR_SET_NAME, name, 0, 0, 0);
  275|       |#endif
  276|      1|}
UnixEThread.cc:_ZL13ink_cond_initP14pthread_cond_t:
  204|      1|{
  205|      1|  ink_assert(pthread_cond_init(cp, nullptr) == 0);
  ------------------
  |  |   45|      1|#define ink_assert(EX) (void)(EX)
  ------------------
  206|      1|}
ProtectedQueue.cc:_ZL18ink_cond_timedwaitP14pthread_cond_tP15pthread_mutex_tP8timespec:
  222|      1|{
  223|      1|  int err;
  224|      1|  while (EINTR == (err = pthread_cond_timedwait(cp, mp, t))) {
  ------------------
  |  Branch (224:10): [True: 0, False: 1]
  ------------------
  225|      0|    ;
  226|      0|  }
  227|       |#ifndef ETIME
  228|       |// ink_defs.h aliases ETIME to ETIMEDOUT and this path should never happen
  229|       |#warning Unknown ETIME return condition for pthread_cond_timedwait
  230|       |  ink_assert((err == 0) || (err == ETIMEDOUT));
  231|       |#else
  232|      1|  ink_assert((err == 0) || (err == ETIME) || (err == ETIMEDOUT));
  ------------------
  |  |   45|      2|#define ink_assert(EX) (void)(EX)
  |  |  ------------------
  |  |  |  Branch (45:31): [True: 1, False: 0]
  |  |  |  Branch (45:31): [True: 0, False: 0]
  |  |  |  Branch (45:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  233|      1|#endif
  234|      1|  return err;
  235|      1|}
RecMutex.cc:_ZL15ink_thread_nullv:
  159|    578|{
  160|       |  // The implementation of ink_thread (the alias of pthread_t) is different on platforms
  161|       |  // - e.g. `struct pthread *` on Unix and `unsigned long int` on Linux
  162|       |  // NOLINTNEXTLINE(modernize-use-nullptr)
  163|    578|  return static_cast<ink_thread>(0);
  164|    578|}
RecMutex.cc:_ZL15ink_thread_selfv:
  153|     19|{
  154|     19|  return (pthread_self());
  155|     19|}

_ZN6DbgCtlC2EPKc:
   64|     32|  DbgCtl(char const *tag) : _ptr{_new_reference(tag)} {}
_ZNK6DbgCtl2onEv:
  104|    234|  {
  105|    234|    auto m{_config_mode.load(std::memory_order_relaxed)};
  106|    234|    if (!m) {
  ------------------
  |  Branch (106:9): [True: 234, False: 0]
  ------------------
  107|    234|      return false;
  108|    234|    }
  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|  }

_ZN2ts9HistogramILi7ELi2EE14min_for_bucketEj:
  170|     66|{
  171|     66|  auto     range     = idx / N_SPAN_BUCKETS;
  172|     66|  raw_type base      = 0; // minimum value for the range (not span!).
  173|     66|  raw_type span_size = 1; // for @a range 0 or 1
  174|     66|  if (range > 0) {
  ------------------
  |  Branch (174:7): [True: 58, False: 8]
  ------------------
  175|     58|    base = 1 << (range + N_SPAN_BITS - 1);
  176|     58|    if (range > 1) { // at @a range == 1 this would be 0, which is wrong.
  ------------------
  |  Branch (176:9): [True: 50, False: 8]
  ------------------
  177|     50|      span_size = base >> N_SPAN_BITS;
  178|     50|    }
  179|     58|  }
  180|     66|  return base + span_size * (idx & SPAN_MASK);
  181|     66|}

_ZN2ts7MetricsD2Ev:
  112|      1|  virtual ~Metrics() {}
_ZNK2ts7Metrics6lookupENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  121|      1|  {
  122|      1|    return _storage->lookup(name);
  123|      1|  }
_ZNK2ts7Metrics6lookupEiPNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPNS0_10MetricTypeE:
  131|     96|  {
  132|     96|    return _storage->lookup(id, out_name, type);
  133|     96|  }
_ZN2ts7Metrics8iteratorC2ERKS0_i:
  196|      2|    iterator(const Metrics &m, IdType pos) : _metrics(m), _it(pos) {}
_ZNK2ts7Metrics8iteratorneERKS1_:
  234|      1|    {
  235|      1|      return _it != o._it || std::addressof(_metrics) != std::addressof(o._metrics);
  ------------------
  |  Branch (235:14): [True: 0, False: 1]
  |  Branch (235:30): [True: 0, False: 1]
  ------------------
  236|      1|    }
_ZNK2ts7Metrics3endEv:
  253|      2|  {
  254|      2|    auto [blob, offset] = _storage->current();
  255|       |
  256|      2|    return iterator(*this, _makeId(blob, offset, MetricType::COUNTER));
  257|      2|  }
_ZNK2ts7Metrics4findENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  261|      1|  {
  262|      1|    auto id = lookup(name);
  263|       |
  264|      1|    if (id == NOT_FOUND) {
  ------------------
  |  Branch (264:9): [True: 1, False: 0]
  ------------------
  265|      1|      return end();
  266|      1|    } else {
  267|      0|      return iterator(*this, id);
  268|      0|    }
  269|      1|  }
_ZN2ts7Metrics7_createENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS0_10MetricTypeE:
  275|     96|  {
  276|     96|    return _storage->create(name, type);
  277|     96|  }
_ZN2ts7Metrics8_splitIDEi:
  288|     96|  {
  289|     96|    return std::make_tuple(static_cast<uint16_t>(value >> 16) & METRIC_TYPE_MASK, static_cast<uint16_t>(value & 0xFFFF));
  290|     96|  }
_ZN2ts7Metrics7_makeIdEttNS0_10MetricTypeE:
  300|     99|  {
  301|     99|    int t = static_cast<int>(type);
  302|     99|    return (t << METRIC_TYPE_BITS | blob << 16 | offset);
  303|     99|  }
_ZN2ts7Metrics7StorageC2Ev:
  318|      1|    {
  319|      1|      _blobs[0] = std::make_unique<NamesAndAtomics>();
  320|      1|      release_assert(_blobs[0]);
  ------------------
  |  |   50|      1|  if (!(EX)) {                               \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 1]
  |  |  ------------------
  |  |   51|      0|    ts::do_abort(MakeSourceLocation(), #EX); \
  |  |  ------------------
  |  |  |  |   32|      0|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  |  |   52|      0|  }
  ------------------
  321|       |      // Reserve slot 0 for errors, this should always be 0
  322|      1|      release_assert(0 == create("proxy.process.api.metrics.bad_id", MetricType::COUNTER));
  ------------------
  |  |   50|      1|  if (!(EX)) {                               \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 1]
  |  |  ------------------
  |  |   51|      0|    ts::do_abort(MakeSourceLocation(), #EX); \
  |  |  ------------------
  |  |  |  |   32|      0|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  |  |   52|      0|  }
  ------------------
  323|      1|    }
_ZN2ts7Metrics7StorageD2Ev:
  325|      1|    ~Storage() {}
_ZNK2ts7Metrics7Storage7currentEv:
  339|      2|    {
  340|      2|      std::lock_guard lock(_mutex);
  341|      2|      return {_cur_blob, _cur_off};
  342|      2|    }
_ZN2ts7MetricsC2ERNSt3__110shared_ptrINS0_7StorageEEE:
  353|      1|  Metrics(std::shared_ptr<Storage> &str) : _storage(str) {}
_ZN2ts7Metrics5Gauge9createPtrENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  403|     96|    {
  404|     96|      auto &instance = Metrics::instance();
  405|       |
  406|     96|      return reinterpret_cast<AtomicType *>(instance.lookup(instance._create(name, MetricType::GAUGE)));
  407|     96|    }
_ZN2ts7Metrics10AtomicTypeC2Ev:
   55|  1.02k|    AtomicType() = default;

_ZN14SourceLocationC2EPKcS1_i:
   44|      9|  SourceLocation(const char *_file, const char *_func, int _line) : file(_file), func(_func), line(_line) {}

_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_157IP6AddrC2Emm:
  488|      4|    : _addr{
  489|      4|        {msw, lsw}
  490|      4|  } {}

_ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEE4headEv:
 1019|    104|IntrusiveDList<L>::head() -> value_type * {
 1020|    104|  return _head;
 1021|    104|}
_ZN4swoc7_1_5_1514IntrusiveDListINS0_8MemArena5Block7LinkageEEC2Ev:
  227|      4|  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|     12|IntrusiveDList<L>::clear() -> self_type & {
 1032|     12|  _head = _tail = nullptr;
 1033|     12|  _count        = 0;
 1034|     12|  return *this;
 1035|     12|}

_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|      2|inline MemArena::MemArena(size_t n) : _reserve_hint(n) {}
_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_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_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) {}

_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_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_158TextView4dataEv:
 1639|     66|TextView::data() const noexcept -> value_type const * {
 1640|     66|  return super_type::data();
 1641|     66|}
_ZN4swoc7_1_5_158TextViewC2EPKcm:
 1127|     48|  : super_type(ptr, n == npos ? (ptr ? ::strlen(ptr) : 0) : n) {}
  ------------------
  |  Branch (1127:21): [True: 0, False: 48]
  |  Branch (1127:34): [True: 0, False: 0]
  ------------------
_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_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|}
_ZNK4swoc7_1_5_1511Hash32FNV1a3getEv:
  197|     96|Hash32FNV1a::get() const -> value_type {
  198|     96|  return hval;
  199|     96|}

_ZN4swoc7_1_5_154file4pathC2EONSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  372|      1|inline path::path(std::string &&that) : _path(std::move(that)) {}
_ZNK4swoc7_1_5_154file4path5c_strEv:
  399|      1|path::c_str() const {
  400|      1|  return _path.c_str();
  401|      1|}

_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|      4|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|      4|  Block *ba = _active.head();
  258|      4|  Block *bf = _frozen.head();
  259|      4|  Block *sb = _static_block;
  260|       |
  261|      4|  _active.clear();
  262|      4|  _frozen.clear();
  263|      4|  while (bf) {
  ------------------
  |  Branch (263:10): [True: 0, False: 4]
  ------------------
  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|      6|  while (ba) {
  ------------------
  |  Branch (270:10): [True: 2, False: 4]
  ------------------
  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|      4|}
_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|}

_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|}

_ZN4swoc7_1_5_154file11is_readableERKNS1_4pathE:
  219|      1|is_readable(const path &p) {
  220|       |  return 0 == access(p.c_str(), R_OK);
  221|      1|}

_ZN15ConfigProcessor3setEjP17RefCountObjInHeapj:
   62|      1|{
   63|      1|  ConfigInfo *old_info;
   64|      1|  int         idx;
   65|       |
   66|      1|  if (id == 0) {
  ------------------
  |  Branch (66:7): [True: 1, False: 0]
  ------------------
   67|      1|    id = ++ninfos;
   68|      1|    ink_assert(id != 0);
  ------------------
  |  |   45|      1|#define ink_assert(EX) (void)(EX)
  ------------------
   69|      1|    ink_assert(id <= MAX_CONFIGS);
  ------------------
  |  |   45|      1|#define ink_assert(EX) (void)(EX)
  ------------------
   70|      1|  }
   71|       |
   72|       |  // Don't be an idiot and use a zero timeout ...
   73|      1|  ink_assert(timeout_secs > 0);
  ------------------
  |  |   45|      1|#define ink_assert(EX) (void)(EX)
  ------------------
   74|       |
   75|      1|  if (info) {
  ------------------
  |  Branch (75:7): [True: 1, False: 0]
  ------------------
   76|       |    // New objects *must* start with a zero refcount. The config
   77|       |    // processor holds it's own refcount. We should be the only
   78|       |    // refcount holder at this point.
   79|      1|    ink_release_assert(info->refcount_inc() == 1);
  ------------------
  |  |   48|      1|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 1, False: 0]
  |  |  ------------------
  ------------------
   80|      1|  }
   81|       |
   82|      1|  if (id > MAX_CONFIGS) {
  ------------------
  |  |   34|      1|#define MAX_CONFIGS 100
  ------------------
  |  Branch (82:7): [True: 0, False: 1]
  ------------------
   83|       |    // invalid index
   84|      0|    Error("[ConfigProcessor::set] invalid index");
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   85|      0|    return 0;
   86|      0|  }
   87|       |
   88|      1|  idx      = id - 1;
   89|      1|  old_info = infos[idx].exchange(info);
   90|       |
   91|      1|  Dbg(dbg_ctl_config, "Set for slot %d %p was %p with ref count %d", id, info, old_info, old_info ? old_info->refcount() : 0);
  ------------------
  |  |  173|      1|  do {                              \
  |  |  174|      1|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 1]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (170:90): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|      1|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
   92|       |
   93|      1|  if (old_info) {
  ------------------
  |  Branch (93:7): [True: 0, False: 1]
  ------------------
   94|       |    // The ConfigInfoReleaser now takes our refcount, but
   95|       |    // some other thread might also have one ...
   96|      0|    ink_assert(old_info->refcount() > 0);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
   97|      0|    eventProcessor.schedule_in(new ConfigInfoReleaser(id, old_info), HRTIME_SECONDS(timeout_secs));
  ------------------
  |  |   79|      0|#define HRTIME_SECONDS(_x)  ((_x) * HRTIME_SECOND)
  |  |  ------------------
  |  |  |  |   58|      0|#define HRTIME_SECOND  (1000 * HRTIME_MSECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   60|      0|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   61|      0|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   98|      0|  }
   99|       |
  100|      1|  return id;
  101|      1|}
_ZN15ConfigProcessor3getEj:
  105|    149|{
  106|    149|  ConfigInfo *info;
  107|    149|  int         idx;
  108|       |
  109|    149|  ink_assert(id <= MAX_CONFIGS);
  ------------------
  |  |   45|    149|#define ink_assert(EX) (void)(EX)
  ------------------
  110|       |
  111|    149|  if (id == 0 || id > MAX_CONFIGS) {
  ------------------
  |  |   34|    149|#define MAX_CONFIGS 100
  ------------------
  |  Branch (111:7): [True: 0, False: 149]
  |  Branch (111:18): [True: 0, False: 149]
  ------------------
  112|       |    // because of an invalid index
  113|      0|    return nullptr;
  114|      0|  }
  115|       |
  116|    149|  idx  = id - 1;
  117|    149|  info = infos[idx];
  118|       |
  119|    149|  if (info) {
  ------------------
  |  Branch (119:7): [True: 149, False: 0]
  ------------------
  120|       |    // Hand out a refcount to the caller. We should still have out
  121|       |    // own refcount, so it should be at least 2.
  122|    149|    ink_release_assert(info->refcount_inc() > 1);
  ------------------
  |  |   48|    149|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 149, False: 0]
  |  |  ------------------
  ------------------
  123|    149|  }
  124|    149|  return info;
  125|    149|}
_ZN15ConfigProcessor7releaseEjP17RefCountObjInHeap:
  129|    149|{
  130|    149|  int idx;
  131|       |
  132|    149|  if (id == 0 || id > MAX_CONFIGS) {
  ------------------
  |  |   34|    149|#define MAX_CONFIGS 100
  ------------------
  |  Branch (132:7): [True: 0, False: 149]
  |  Branch (132:18): [True: 0, False: 149]
  ------------------
  133|       |    // nothing to delete since we have an invalid index
  134|      0|    ink_abort("released an invalid id '%u'", id);
  135|      0|  }
  136|       |
  137|    149|  idx = id - 1;
  138|       |
  139|    149|  if (info && info->refcount_dec() == 0) {
  ------------------
  |  Branch (139:7): [True: 149, False: 0]
  |  Branch (139:15): [True: 0, False: 149]
  ------------------
  140|       |    // When we release, we should already have replaced this object in the index.
  141|      0|    Dbg(dbg_ctl_config, "Release config %d %p", id, info);
  ------------------
  |  |  173|      0|  do {                              \
  |  |  174|      0|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 0]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|      0|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  142|      0|    ink_release_assert(info != this->infos[idx]);
  ------------------
  |  |   48|      0|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  143|      0|    delete info;
  144|      0|  }
  145|    149|}

_Z21ink_event_system_initN2ts13ModuleVersionE:
   40|      1|{
   41|      1|  ink_release_assert(v.check(EVENT_SYSTEM_MODULE_INTERNAL_VERSION));
  ------------------
  |  |   48|      1|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 1, False: 0]
  |  |  ------------------
  ------------------
   42|      1|  int iobuffer_advice = 0;
   43|       |
   44|       |  // For backwards compatibility make sure to allow thread_freelist_size
   45|       |  // This needs to change in 6.0
   46|      1|  RecEstablishStaticConfigInt32(thread_freelist_high_watermark, "proxy.config.allocator.thread_freelist_size");
   47|       |
   48|      1|  RecEstablishStaticConfigInt32(thread_freelist_low_watermark, "proxy.config.allocator.thread_freelist_low_watermark");
   49|       |
   50|      1|  extern int loop_time_update_probability;
   51|      1|  RecEstablishStaticConfigInt32(loop_time_update_probability, "proxy.config.exec_thread.loop_time_update_probability");
   52|       |
   53|      1|  int chunk_sizes[DEFAULT_BUFFER_SIZES] = {0};
   54|      1|  {
   55|      1|    auto chunk_sizes_string{RecGetRecordStringAlloc("proxy.config.allocator.iobuf_chunk_sizes")};
   56|      1|    if (auto chunk_sizes_c_str{ats_as_c_str(chunk_sizes_string)};
   57|      1|        chunk_sizes_c_str && !parse_buffer_chunk_sizes(chunk_sizes_c_str, chunk_sizes)) {
  ------------------
  |  Branch (57:9): [True: 0, False: 1]
  |  Branch (57:30): [True: 0, False: 0]
  ------------------
   58|       |      // If we can't parse the string then we can't be sure of the chunk sizes so just exit
   59|      0|      Fatal("Failed to parse proxy.config.allocator.iobuf_chunk_sizes");
  ------------------
  |  |   90|      0|#define Fatal(...)     DiagsError(DL_Fatal, __VA_ARGS__)     // Log recoverable crash, fail CI, exit & allow restart
  |  |  ------------------
  |  |  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   60|      0|    }
   61|      1|  }
   62|       |
   63|      1|  bool use_hugepages = ats_hugepage_enabled();
   64|       |
   65|      1|#ifdef MADV_DONTDUMP // This should only exist on Linux 3.4 and higher.
   66|      1|  RecBool dont_dump_enabled = true;
   67|      1|  if (auto tmp{RecGetRecordInt("proxy.config.allocator.dontdump_iobuffers", false)}; tmp) {
  ------------------
  |  Branch (67:86): [True: 1, False: 0]
  ------------------
   68|      1|    dont_dump_enabled = tmp.value();
   69|      1|  }
   70|       |
   71|      1|  if (dont_dump_enabled) {
  ------------------
  |  Branch (71:7): [True: 1, False: 0]
  ------------------
   72|      1|    iobuffer_advice |= MADV_DONTDUMP;
   73|      1|  }
   74|      1|#endif
   75|       |
   76|      1|  init_buffer_allocators(iobuffer_advice, chunk_sizes, use_hugepages);
   77|      1|}

_Z16iobuffer_mem_incPKcl:
  118|    240|{
  119|    240|  if (!res_track_memory) {
  ------------------
  |  Branch (119:7): [True: 240, False: 0]
  ------------------
  120|    240|    return;
  121|    240|  }
  122|       |
  123|      0|  if (!BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index)) {
  ------------------
  |  |  102|      0|#define BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index) (((uint64_t)_size_index) < DEFAULT_BUFFER_SIZES)
  |  |  ------------------
  |  |  |  |   88|      0|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (123:7): [True: 0, False: 0]
  ------------------
  124|      0|    return;
  125|      0|  }
  126|       |
  127|      0|  if (!_loc) {
  ------------------
  |  Branch (127:7): [True: 0, False: 0]
  ------------------
  128|      0|    _loc = "memory/IOBuffer/UNKNOWN-LOCATION";
  129|      0|  }
  130|      0|  ResourceTracker::increment(_loc, index_to_buffer_size(_size_index));
  131|      0|}
_Z16iobuffer_mem_decPKcl:
  135|    240|{
  136|    240|  if (!res_track_memory) {
  ------------------
  |  Branch (136:7): [True: 240, False: 0]
  ------------------
  137|    240|    return;
  138|    240|  }
  139|       |
  140|      0|  if (!BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index)) {
  ------------------
  |  |  102|      0|#define BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index) (((uint64_t)_size_index) < DEFAULT_BUFFER_SIZES)
  |  |  ------------------
  |  |  |  |   88|      0|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (140:7): [True: 0, False: 0]
  ------------------
  141|      0|    return;
  142|      0|  }
  143|      0|  if (!_loc) {
  ------------------
  |  Branch (143:7): [True: 0, False: 0]
  ------------------
  144|      0|    _loc = "memory/IOBuffer/UNKNOWN-LOCATION";
  145|      0|  }
  146|      0|  ResourceTracker::increment(_loc, -index_to_buffer_size(_size_index));
  147|      0|}
_ZN12IOBufferData10block_sizeEv:
  162|    240|{
  163|    240|  return index_to_buffer_size(_size_index);
  164|    240|}
_Z25new_IOBufferData_internalPKcl9AllocType:
  186|    240|{
  187|    240|  IOBufferData *d = THREAD_ALLOC(ioDataAllocator, this_thread());
  ------------------
  |  |   77|    240|#define THREAD_ALLOC(_a, _t, ...)      thread_alloc(::_a, _t->_a, ##__VA_ARGS__)
  ------------------
  188|    240|  d->_location    = loc;
  189|    240|  d->alloc(size_index, type);
  190|    240|  return d;
  191|    240|}
_ZN12IOBufferData5allocEl9AllocType:
  199|    240|{
  200|    240|  if (_data) {
  ------------------
  |  Branch (200:7): [True: 0, False: 240]
  ------------------
  201|      0|    dealloc();
  202|      0|  }
  203|    240|  _size_index = size_index;
  204|    240|  _mem_type   = type;
  205|    240|  iobuffer_mem_inc(_location, size_index);
  206|    240|  switch (type) {
  207|      0|  case MEMALIGNED:
  ------------------
  |  Branch (207:3): [True: 0, False: 240]
  ------------------
  208|      0|    if (BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(size_index)) {
  ------------------
  |  |  102|      0|#define BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index) (((uint64_t)_size_index) < DEFAULT_BUFFER_SIZES)
  |  |  ------------------
  |  |  |  |   88|      0|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (102:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  209|      0|      _data = static_cast<char *>(ioBufAllocator[size_index].alloc_void());
  210|       |      // coverity[dead_error_condition]
  211|      0|    } else if (BUFFER_SIZE_INDEX_IS_XMALLOCED(size_index)) {
  ------------------
  |  |  101|      0|#define BUFFER_SIZE_INDEX_IS_XMALLOCED(_size_index)      (_size_index < 0)
  |  |  ------------------
  |  |  |  Branch (101:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  212|      0|      _data = static_cast<char *>(ats_memalign(ats_pagesize(), index_to_buffer_size(size_index)));
  213|      0|    }
  214|      0|    break;
  215|      0|  default:
  ------------------
  |  Branch (215:3): [True: 0, False: 240]
  ------------------
  216|    240|  case DEFAULT_ALLOC:
  ------------------
  |  Branch (216:3): [True: 240, False: 0]
  ------------------
  217|    240|    if (BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(size_index)) {
  ------------------
  |  |  102|    240|#define BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index) (((uint64_t)_size_index) < DEFAULT_BUFFER_SIZES)
  |  |  ------------------
  |  |  |  |   88|    240|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|    240|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (102:58): [True: 240, False: 0]
  |  |  ------------------
  ------------------
  218|    240|      _data = static_cast<char *>(ioBufAllocator[size_index].alloc_void());
  219|    240|    } else if (BUFFER_SIZE_INDEX_IS_XMALLOCED(size_index)) {
  ------------------
  |  |  101|      0|#define BUFFER_SIZE_INDEX_IS_XMALLOCED(_size_index)      (_size_index < 0)
  |  |  ------------------
  |  |  |  Branch (101:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  220|      0|      _data = static_cast<char *>(ats_malloc(BUFFER_SIZE_FOR_XMALLOC(size_index)));
  ------------------
  |  |  105|      0|#define BUFFER_SIZE_FOR_XMALLOC(_size) (-(_size))
  ------------------
  221|      0|    }
  222|    240|    break;
  223|    240|  }
  224|    240|}
_ZN12IOBufferData7deallocEv:
  230|    240|{
  231|    240|  iobuffer_mem_dec(_location, _size_index);
  232|    240|  switch (_mem_type) {
  233|      0|  case MEMALIGNED:
  ------------------
  |  Branch (233:3): [True: 0, False: 240]
  ------------------
  234|      0|    if (BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index)) {
  ------------------
  |  |  102|      0|#define BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index) (((uint64_t)_size_index) < DEFAULT_BUFFER_SIZES)
  |  |  ------------------
  |  |  |  |   88|      0|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (102:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  235|      0|      ioBufAllocator[_size_index].free_void(_data);
  236|      0|    } else if (BUFFER_SIZE_INDEX_IS_XMALLOCED(_size_index)) {
  ------------------
  |  |  101|      0|#define BUFFER_SIZE_INDEX_IS_XMALLOCED(_size_index)      (_size_index < 0)
  |  |  ------------------
  |  |  |  Branch (101:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  237|      0|      ::free(_data);
  238|      0|    }
  239|      0|    break;
  240|      0|  default:
  ------------------
  |  Branch (240:3): [True: 0, False: 240]
  ------------------
  241|    240|  case DEFAULT_ALLOC:
  ------------------
  |  Branch (241:3): [True: 240, False: 0]
  ------------------
  242|    240|    if (BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index)) {
  ------------------
  |  |  102|    240|#define BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index) (((uint64_t)_size_index) < DEFAULT_BUFFER_SIZES)
  |  |  ------------------
  |  |  |  |   88|    240|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|    240|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (102:58): [True: 240, False: 0]
  |  |  ------------------
  ------------------
  243|    240|      ioBufAllocator[_size_index].free_void(_data);
  244|    240|    } else if (BUFFER_SIZE_INDEX_IS_XMALLOCED(_size_index)) {
  ------------------
  |  |  101|      0|#define BUFFER_SIZE_INDEX_IS_XMALLOCED(_size_index)      (_size_index < 0)
  |  |  ------------------
  |  |  |  Branch (101:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  245|      0|      ats_free(_data);
  246|      0|    }
  247|    240|    break;
  248|    240|  }
  249|    240|  _data       = nullptr;
  250|    240|  _size_index = BUFFER_SIZE_NOT_ALLOCATED;
  ------------------
  |  |  100|    240|#define BUFFER_SIZE_NOT_ALLOCATED                        DEFAULT_BUFFER_SIZES
  |  |  ------------------
  |  |  |  |   88|    240|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|    240|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  251|    240|  _mem_type   = NO_ALLOC;
  252|    240|}
_ZN12IOBufferData4freeEv:
  256|    240|{
  257|    240|  dealloc();
  258|    240|  THREAD_FREE(this, ioDataAllocator, this_thread());
  ------------------
  |  |   97|    240|  do {                                                                                             \
  |  |   98|    240|    ::_a.destroy_if_enabled(_p);                                                                   \
  |  |   99|    240|    Thread *_t = (_tin);                                                                           \
  |  |  100|    240|    if (_t && !cmd_disable_pfreelist) {                                                            \
  |  |  ------------------
  |  |  |  Branch (100:9): [True: 0, False: 240]
  |  |  |  Branch (100:15): [True: 0, False: 0]
  |  |  ------------------
  |  |  101|      0|      *(char **)_p    = (char *)_t->_a.freelist;                                                   \
  |  |  102|      0|      _t->_a.freelist = _p;                                                                        \
  |  |  103|      0|      _t->_a.allocated++;                                                                          \
  |  |  104|      0|      UPDATE_FREE_METRICS(::_a);                                                                   \
  |  |  105|      0|      if (thread_freelist_high_watermark > 0 && _t->_a.allocated > thread_freelist_high_watermark) \
  |  |  ------------------
  |  |  |  Branch (105:11): [True: 0, False: 0]
  |  |  |  Branch (105:49): [True: 0, False: 0]
  |  |  ------------------
  |  |  106|      0|        thread_freeup(::_a.raw(), _t->_a);                                                         \
  |  |  107|    240|    } else {                                                                                       \
  |  |  108|    240|      ::_a.raw().free_void(_p);                                                                    \
  |  |  109|    240|    }                                                                                              \
  |  |  110|    240|  } while (0)
  |  |  ------------------
  |  |  |  Branch (110:12): [Folded, False: 240]
  |  |  ------------------
  ------------------
  259|    240|}
_Z26new_IOBufferBlock_internalPKc:
  269|    240|{
  270|    240|  IOBufferBlock *b = THREAD_ALLOC(ioBlockAllocator, this_thread());
  ------------------
  |  |   77|    240|#define THREAD_ALLOC(_a, _t, ...)      thread_alloc(::_a, _t->_a, ##__VA_ARGS__)
  ------------------
  271|    240|  b->_location     = location;
  272|    240|  return b;
  273|    240|}
_ZN13IOBufferBlockC2Ev:
  285|    240|{
  286|    240|  return;
  287|    240|}
_ZN13IOBufferBlock4fillEl:
  298|    240|{
  299|    240|  _end += len;
  300|    240|  ink_assert(_end <= _buf_end);
  ------------------
  |  |   45|    240|#define ink_assert(EX) (void)(EX)
  ------------------
  301|    240|}
_ZN13IOBufferBlock5resetEv:
  305|    240|{
  306|    240|  _end = _start = buf();
  307|    240|  _buf_end      = buf() + data->block_size();
  308|    240|}
_ZN13IOBufferBlock5allocEl:
  312|    240|{
  313|    240|  ink_assert(BUFFER_SIZE_ALLOCATED(i));
  ------------------
  |  |   45|    240|#define ink_assert(EX) (void)(EX)
  |  |  ------------------
  |  |  |  Branch (45:31): [True: 240, False: 0]
  |  |  |  Branch (45:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  314|    240|  data = new_IOBufferData_internal(_location, i);
  315|    240|  reset();
  316|    240|}
_ZN13IOBufferBlock5clearEv:
  320|    240|{
  321|    240|  data = nullptr;
  322|       |
  323|    240|  IOBufferBlock *p = next.get();
  324|    240|  while (p) {
  ------------------
  |  Branch (324:10): [True: 91, False: 149]
  ------------------
  325|       |    // If our block pointer refcount dropped to zero,
  326|       |    // recursively free the list.
  327|     91|    if (p->refcount_dec() == 0) {
  ------------------
  |  Branch (327:9): [True: 0, False: 91]
  ------------------
  328|      0|      IOBufferBlock *n = p->next.detach();
  329|      0|      p->free();
  330|      0|      p = n;
  331|     91|    } else {
  332|       |      // We don't hold the last refcount, so we are done.
  333|     91|      break;
  334|     91|    }
  335|     91|  }
  336|       |
  337|       |  // Nuke the next pointer without dropping the refcount
  338|       |  // because we already manually did that.
  339|    240|  next.detach();
  340|       |
  341|    240|  _buf_end = _end = _start = nullptr;
  342|    240|}
_ZN13IOBufferBlock7deallocEv:
  358|    240|{
  359|    240|  clear();
  360|    240|}
_ZN13IOBufferBlock4freeEv:
  364|    240|{
  365|    240|  dealloc();
  366|    240|  THREAD_FREE(this, ioBlockAllocator, this_thread());
  ------------------
  |  |   97|    240|  do {                                                                                             \
  |  |   98|    240|    ::_a.destroy_if_enabled(_p);                                                                   \
  |  |   99|    240|    Thread *_t = (_tin);                                                                           \
  |  |  100|    240|    if (_t && !cmd_disable_pfreelist) {                                                            \
  |  |  ------------------
  |  |  |  Branch (100:9): [True: 0, False: 240]
  |  |  |  Branch (100:15): [True: 0, False: 0]
  |  |  ------------------
  |  |  101|      0|      *(char **)_p    = (char *)_t->_a.freelist;                                                   \
  |  |  102|      0|      _t->_a.freelist = _p;                                                                        \
  |  |  103|      0|      _t->_a.allocated++;                                                                          \
  |  |  104|      0|      UPDATE_FREE_METRICS(::_a);                                                                   \
  |  |  105|      0|      if (thread_freelist_high_watermark > 0 && _t->_a.allocated > thread_freelist_high_watermark) \
  |  |  ------------------
  |  |  |  Branch (105:11): [True: 0, False: 0]
  |  |  |  Branch (105:49): [True: 0, False: 0]
  |  |  ------------------
  |  |  106|      0|        thread_freeup(::_a.raw(), _t->_a);                                                         \
  |  |  107|    240|    } else {                                                                                       \
  |  |  108|    240|      ::_a.raw().free_void(_p);                                                                    \
  |  |  109|    240|    }                                                                                              \
  |  |  110|    240|  } while (0)
  |  |  ------------------
  |  |  |  Branch (110:12): [Folded, False: 240]
  |  |  ------------------
  ------------------
  367|    240|}
_ZN14IOBufferReader10read_availEv:
  484|     84|{
  485|     84|  int64_t        t = 0;
  486|     84|  IOBufferBlock *b = block.get();
  487|       |
  488|    168|  while (b) {
  ------------------
  |  Branch (488:10): [True: 84, False: 84]
  ------------------
  489|     84|    t += b->read_avail();
  490|     84|    b  = b->next.get();
  491|     84|  }
  492|       |
  493|     84|  t -= start_offset;
  494|     84|  if (size_limit != INT64_MAX && t > size_limit) {
  ------------------
  |  Branch (494:7): [True: 0, False: 84]
  |  Branch (494:34): [True: 0, False: 0]
  ------------------
  495|      0|    t = size_limit;
  496|      0|  }
  497|       |
  498|     84|  return t;
  499|     84|}
_ZN14IOBufferReader7consumeEl:
  519|     84|{
  520|     84|  ink_assert(read_avail() >= n);
  ------------------
  |  |   45|     84|#define ink_assert(EX) (void)(EX)
  ------------------
  521|     84|  start_offset += n;
  522|     84|  if (size_limit != INT64_MAX) {
  ------------------
  |  Branch (522:7): [True: 0, False: 84]
  ------------------
  523|      0|    size_limit -= n;
  524|      0|  }
  525|       |
  526|     84|  ink_assert(size_limit >= 0);
  ------------------
  |  |   45|     84|#define ink_assert(EX) (void)(EX)
  ------------------
  527|     84|  if (!block) {
  ------------------
  |  Branch (527:7): [True: 0, False: 84]
  ------------------
  528|      0|    return;
  529|      0|  }
  530|       |
  531|     84|  int64_t r = block->read_avail();
  532|     84|  int64_t s = start_offset;
  533|     84|  while (r <= s && block->next && block->next->read_avail()) {
  ------------------
  |  Branch (533:10): [True: 5, False: 79]
  |  Branch (533:20): [True: 0, False: 5]
  |  Branch (533:35): [True: 0, False: 0]
  ------------------
  534|      0|    s            -= r;
  535|      0|    start_offset  = s;
  536|      0|    block         = block->next;
  537|      0|    r             = block->read_avail();
  538|      0|  }
  539|     84|}
_ZN14IOBufferReader5clearEv:
  564|    298|{
  565|    298|  accessor     = nullptr;
  566|    298|  block        = nullptr;
  567|    298|  mbuf         = nullptr;
  568|    298|  start_offset = 0;
  569|       |  size_limit   = INT64_MAX;
  570|    298|}
_ZN14IOBufferReader5resetEv:
  574|    149|{
  575|    149|  block        = mbuf->_writer;
  576|    149|  start_offset = 0;
  577|       |  size_limit   = INT64_MAX;
  578|    149|}
_ZN9MIOBufferC2Ev:
  597|    149|{
  598|    149|  clear();
  599|    149|  _location = nullptr;
  600|    149|  return;
  601|    149|}
_Z22new_MIOBuffer_internalPKcl:
  611|    149|{
  612|    149|  MIOBuffer *b = THREAD_ALLOC(ioAllocator, this_thread());
  ------------------
  |  |   77|    149|#define THREAD_ALLOC(_a, _t, ...)      thread_alloc(::_a, _t->_a, ##__VA_ARGS__)
  ------------------
  613|    149|  b->_location = location;
  614|    149|  b->alloc(size_index);
  615|    149|  b->water_mark = 0;
  616|    149|  return b;
  617|    149|}
_Z14free_MIOBufferP9MIOBuffer:
  621|    149|{
  622|    149|  mio->_writer = nullptr;
  623|    149|  mio->dealloc_all_readers();
  624|    149|  THREAD_FREE(mio, ioAllocator, this_thread());
  ------------------
  |  |   97|    149|  do {                                                                                             \
  |  |   98|    149|    ::_a.destroy_if_enabled(_p);                                                                   \
  |  |   99|    149|    Thread *_t = (_tin);                                                                           \
  |  |  100|    149|    if (_t && !cmd_disable_pfreelist) {                                                            \
  |  |  ------------------
  |  |  |  Branch (100:9): [True: 0, False: 149]
  |  |  |  Branch (100:15): [True: 0, False: 0]
  |  |  ------------------
  |  |  101|      0|      *(char **)_p    = (char *)_t->_a.freelist;                                                   \
  |  |  102|      0|      _t->_a.freelist = _p;                                                                        \
  |  |  103|      0|      _t->_a.allocated++;                                                                          \
  |  |  104|      0|      UPDATE_FREE_METRICS(::_a);                                                                   \
  |  |  105|      0|      if (thread_freelist_high_watermark > 0 && _t->_a.allocated > thread_freelist_high_watermark) \
  |  |  ------------------
  |  |  |  Branch (105:11): [True: 0, False: 0]
  |  |  |  Branch (105:49): [True: 0, False: 0]
  |  |  ------------------
  |  |  106|      0|        thread_freeup(::_a.raw(), _t->_a);                                                         \
  |  |  107|    149|    } else {                                                                                       \
  |  |  108|    149|      ::_a.raw().free_void(_p);                                                                    \
  |  |  109|    149|    }                                                                                              \
  |  |  110|    149|  } while (0)
  |  |  ------------------
  |  |  |  Branch (110:12): [Folded, False: 149]
  |  |  ------------------
  ------------------
  625|    149|}
_ZN9MIOBuffer12alloc_readerEv:
  666|    149|{
  667|    149|  int i;
  668|    149|  for (i = 0; i < MAX_MIOBUFFER_READERS; i++) {
  ------------------
  |  |   61|    149|#define MAX_MIOBUFFER_READERS               5
  ------------------
  |  Branch (668:15): [True: 149, False: 0]
  ------------------
  669|    149|    if (!readers[i].allocated()) {
  ------------------
  |  Branch (669:9): [True: 149, False: 0]
  ------------------
  670|    149|      break;
  671|    149|    }
  672|    149|  }
  673|       |
  674|       |  // TODO refactor code to return nullptr at some point
  675|    149|  ink_release_assert(i < MAX_MIOBUFFER_READERS);
  ------------------
  |  |   48|    149|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 149, False: 0]
  |  |  ------------------
  ------------------
  676|       |
  677|    149|  IOBufferReader *e = &readers[i];
  678|    149|  e->mbuf           = this;
  679|    149|  e->reset();
  680|    149|  e->accessor = nullptr;
  681|       |
  682|    149|  return e;
  683|    149|}
_ZN9MIOBuffer21append_block_internalEP13IOBufferBlock:
  738|     91|{
  739|       |  // It would be nice to remove an empty buffer at the beginning,
  740|       |  // but this breaks HTTP.
  741|     91|  if (!_writer) {
  ------------------
  |  Branch (741:7): [True: 0, False: 91]
  ------------------
  742|      0|    _writer = b;
  743|      0|    init_readers();
  744|     91|  } else {
  745|     91|    ink_assert(!_writer->next || !_writer->next->read_avail());
  ------------------
  |  |   45|     91|#define ink_assert(EX) (void)(EX)
  |  |  ------------------
  |  |  |  Branch (45:31): [True: 91, False: 0]
  |  |  |  Branch (45:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  746|     91|    _writer->next = b;
  747|     91|    while (b->read_avail()) {
  ------------------
  |  Branch (747:12): [True: 0, False: 91]
  ------------------
  748|      0|      _writer = b;
  749|      0|      b       = b->next.get();
  750|      0|      if (!b) {
  ------------------
  |  Branch (750:11): [True: 0, False: 0]
  ------------------
  751|      0|        break;
  752|      0|      }
  753|      0|    }
  754|     91|  }
  755|     91|  while (_writer->next && !_writer->write_avail() && _writer->next->read_avail()) {
  ------------------
  |  Branch (755:10): [True: 91, False: 0]
  |  Branch (755:27): [True: 91, False: 0]
  |  Branch (755:54): [True: 0, False: 91]
  ------------------
  756|      0|    _writer = _writer->next;
  757|      0|  }
  758|     91|}
_ZN9MIOBuffer12append_blockEl:
  777|     91|{
  778|     91|  ink_assert(BUFFER_SIZE_ALLOCATED(asize_index));
  ------------------
  |  |   45|     91|#define ink_assert(EX) (void)(EX)
  |  |  ------------------
  |  |  |  Branch (45:31): [True: 91, False: 0]
  |  |  |  Branch (45:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  779|     91|  IOBufferBlock *b = new_IOBufferBlock_internal(_location);
  780|     91|  b->alloc(asize_index);
  781|     91|  append_block_internal(b);
  782|     91|  return;
  783|     91|}
_ZN9MIOBuffer9add_blockEv:
  787|     91|{
  788|     91|  if (this->_writer == nullptr || this->_writer->next == nullptr) {
  ------------------
  |  Branch (788:7): [True: 0, False: 91]
  |  Branch (788:35): [True: 91, False: 0]
  ------------------
  789|     91|    append_block(size_index);
  790|     91|  }
  791|     91|}
_ZN9MIOBuffer5allocEl:
  925|    149|{
  926|    149|  _writer = new_IOBufferBlock_internal(_location);
  927|    149|  _writer->alloc(i);
  928|    149|  size_index = i;
  929|    149|  init_readers();
  930|    149|}
_ZN9MIOBuffer14dealloc_readerEP14IOBufferReader:
  934|    298|{
  935|    298|  if (e->accessor) {
  ------------------
  |  Branch (935:7): [True: 0, False: 298]
  ------------------
  936|      0|    ink_assert(e->accessor->writer() == this);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  937|      0|    ink_assert(e->accessor->reader() == e);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  938|      0|    e->accessor->clear();
  939|      0|  }
  940|    298|  e->clear();
  941|    298|}
_ZN14IOBufferReader7deallocEv:
  951|    149|{
  952|    149|  mbuf->dealloc_reader(this);
  953|    149|}
_ZN9MIOBuffer19dealloc_all_readersEv:
  957|    298|{
  958|  1.49k|  for (auto &reader : readers) {
  ------------------
  |  Branch (958:21): [True: 1.49k, False: 298]
  ------------------
  959|  1.49k|    if (reader.allocated()) {
  ------------------
  |  Branch (959:9): [True: 149, False: 1.34k]
  ------------------
  960|    149|      dealloc_reader(&reader);
  961|    149|    }
  962|  1.49k|  }
  963|    298|}
_Z22init_buffer_allocatorsiPib:
 1016|      1|{
 1017|     16|  for (int i = 0; i < DEFAULT_BUFFER_SIZES; i++) {
  ------------------
  |  |   88|     16|#define DEFAULT_BUFFER_SIZES   (MAX_BUFFER_SIZE_INDEX + 1)
  |  |  ------------------
  |  |  |  |   87|     16|#define MAX_BUFFER_SIZE_INDEX  14
  |  |  ------------------
  ------------------
  |  Branch (1017:19): [True: 15, False: 1]
  ------------------
 1018|     15|    int64_t s = DEFAULT_BUFFER_BASE_SIZE * ((static_cast<int64_t>(1)) << i);
  ------------------
  |  |   63|     15|#define DEFAULT_BUFFER_BASE_SIZE            128
  ------------------
 1019|     15|    int64_t a = DEFAULT_BUFFER_ALIGNMENT;
  ------------------
  |  |   62|     15|#define DEFAULT_BUFFER_ALIGNMENT            8192 // should be disk/page size
  ------------------
 1020|     15|    int     n = chunk_sizes[i];
 1021|     15|    if (n == 0) {
  ------------------
  |  Branch (1021:9): [True: 15, False: 0]
  ------------------
 1022|     15|      n = i <= default_large_iobuffer_size ? DEFAULT_BUFFER_NUMBER : DEFAULT_HUGE_BUFFER_NUMBER;
  ------------------
  |  |   59|      6|#define DEFAULT_BUFFER_NUMBER               128
  ------------------
                    n = i <= default_large_iobuffer_size ? DEFAULT_BUFFER_NUMBER : DEFAULT_HUGE_BUFFER_NUMBER;
  ------------------
  |  |   60|     24|#define DEFAULT_HUGE_BUFFER_NUMBER          32
  ------------------
  |  Branch (1022:11): [True: 6, False: 9]
  ------------------
 1023|     15|    }
 1024|     15|    if (s < a) {
  ------------------
  |  Branch (1024:9): [True: 6, False: 9]
  ------------------
 1025|      6|      a = s;
 1026|      6|    }
 1027|       |
 1028|     15|    auto name = new char[64];
 1029|     15|    if (use_hugepages) {
  ------------------
  |  Branch (1029:9): [True: 0, False: 15]
  ------------------
 1030|      0|      snprintf(name, 64, "ioBufAllocatorHP[%d]", i);
 1031|     15|    } else {
 1032|     15|      snprintf(name, 64, "ioBufAllocator[%d]", i);
 1033|     15|    }
 1034|     15|    ioBufAllocator[i].re_init(name, s, n, a, use_hugepages, iobuffer_advice);
 1035|     15|  }
 1036|      1|}
_ZN9MIOBuffer5writeEPKvl:
 1126|    149|{
 1127|    149|  const char *buf = static_cast<const char *>(abuf);
 1128|    149|  int64_t     len = alen;
 1129|    480|  while (len) {
  ------------------
  |  Branch (1129:10): [True: 331, False: 149]
  ------------------
 1130|    331|    if (!_writer) {
  ------------------
  |  Branch (1130:9): [True: 0, False: 331]
  ------------------
 1131|      0|      add_block();
 1132|      0|    }
 1133|    331|    int64_t f = _writer->write_avail();
 1134|    331|    f         = f < len ? f : len;
  ------------------
  |  Branch (1134:17): [True: 182, False: 149]
  ------------------
 1135|    331|    if (f > 0) {
  ------------------
  |  Branch (1135:9): [True: 240, False: 91]
  ------------------
 1136|    240|      ::memcpy(_writer->end(), buf, f);
 1137|    240|      _writer->fill(f);
 1138|    240|      buf += f;
 1139|    240|      len -= f;
 1140|    240|    }
 1141|    331|    if (len) {
  ------------------
  |  Branch (1141:9): [True: 182, False: 149]
  ------------------
 1142|    182|      if (!_writer->next) {
  ------------------
  |  Branch (1142:11): [True: 91, False: 91]
  ------------------
 1143|     91|        add_block();
 1144|     91|      } else {
 1145|     91|        _writer = _writer->next;
 1146|     91|      }
 1147|    182|    }
 1148|    331|  }
 1149|    149|  return alen;
 1150|    149|}
_ZN14IOBufferReader6memcpyEPvll:
 1278|    447|{
 1279|    447|  char          *p  = static_cast<char *>(ap);
 1280|    447|  IOBufferBlock *b  = block.get();
 1281|    447|  offset           += start_offset;
 1282|       |
 1283|    894|  while (b && len) {
  ------------------
  |  Branch (1283:10): [True: 447, False: 447]
  |  Branch (1283:15): [True: 447, False: 0]
  ------------------
 1284|    447|    int64_t max_bytes  = b->read_avail();
 1285|    447|    max_bytes         -= offset;
 1286|    447|    if (max_bytes <= 0) {
  ------------------
  |  Branch (1286:9): [True: 0, False: 447]
  ------------------
 1287|      0|      offset = -max_bytes;
 1288|      0|      b      = b->next.get();
 1289|      0|      continue;
 1290|      0|    }
 1291|    447|    int64_t bytes;
 1292|    447|    if (len < 0 || len >= max_bytes) {
  ------------------
  |  Branch (1292:9): [True: 0, False: 447]
  |  Branch (1292:20): [True: 278, False: 169]
  ------------------
 1293|    278|      bytes = max_bytes;
 1294|    278|    } else {
 1295|    169|      bytes = len;
 1296|    169|    }
 1297|    447|    ::memcpy(p, b->start() + offset, bytes);
 1298|    447|    p      += bytes;
 1299|    447|    len    -= bytes;
 1300|    447|    b       = b->next.get();
 1301|    447|    offset  = 0;
 1302|    447|  }
 1303|       |
 1304|    447|  return p;
 1305|    447|}

_ZN18PriorityEventQueueC2Ev:
   28|      1|{
   29|      1|  last_check_time    = ink_get_hrtime();
   30|      1|  last_check_buckets = last_check_time / PQ_BUCKET_TIME(0);
  ------------------
  |  |   31|      1|#define PQ_BUCKET_TIME(_i) (HRTIME_MSECONDS(5) << (_i))
  |  |  ------------------
  |  |  |  |   80|      1|#define HRTIME_MSECONDS(_x) ((_x) * HRTIME_MSECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      1|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   60|      1|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   61|      1|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   31|      1|}
_ZN18PriorityEventQueue11check_readyElP7EThread:
   35|      1|{
   36|      1|  int      i, j, k = 0;
   37|      1|  uint32_t check_buckets  = static_cast<uint32_t>(now / PQ_BUCKET_TIME(0));
  ------------------
  |  |   31|      1|#define PQ_BUCKET_TIME(_i) (HRTIME_MSECONDS(5) << (_i))
  |  |  ------------------
  |  |  |  |   80|      1|#define HRTIME_MSECONDS(_x) ((_x) * HRTIME_MSECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      1|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   60|      1|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   61|      1|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   38|      1|  uint32_t todo_buckets   = check_buckets ^ last_check_buckets;
   39|      1|  last_check_time         = now;
   40|      1|  last_check_buckets      = check_buckets;
   41|      1|  todo_buckets           &= ((1 << (N_PQ_LIST - 1)) - 1);
  ------------------
  |  |   30|      1|#define N_PQ_LIST          10
  ------------------
   42|      1|  while (todo_buckets) {
  ------------------
  |  Branch (42:10): [True: 0, False: 1]
  ------------------
   43|      0|    k++;
   44|      0|    todo_buckets >>= 1;
   45|      0|  }
   46|      1|  for (i = 1; i <= k; i++) {
  ------------------
  |  Branch (46:15): [True: 0, False: 1]
  ------------------
   47|      0|    Event *e;
   48|      0|    Que(Event, link) q = after[i];
  ------------------
  |  |  569|      0|#define Que(_c, _f)           Queue<_c, _c::Link##_##_f>
  ------------------
   49|      0|    after[i].clear();
   50|      0|    while ((e = q.dequeue()) != nullptr) {
  ------------------
  |  Branch (50:12): [True: 0, False: 0]
  ------------------
   51|      0|      if (e->cancelled) {
  ------------------
  |  Branch (51:11): [True: 0, False: 0]
  ------------------
   52|      0|        e->in_the_priority_queue = 0;
   53|      0|        e->cancelled             = 0;
   54|      0|        EVENT_FREE(e, eventAllocator, t);
  ------------------
  |  |  289|      0|  _p->mutex = nullptr;         \
  |  |  290|      0|  if (_p->globally_allocated)  \
  |  |  ------------------
  |  |  |  Branch (290:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  291|      0|    ::_a.free(_p);             \
  |  |  292|      0|  else                         \
  |  |  293|      0|    THREAD_FREE(_p, _a, _t)
  |  |  ------------------
  |  |  |  |   97|      0|  do {                                                                                             \
  |  |  |  |   98|      0|    ::_a.destroy_if_enabled(_p);                                                                   \
  |  |  |  |   99|      0|    Thread *_t = (_tin);                                                                           \
  |  |  |  |  100|      0|    if (_t && !cmd_disable_pfreelist) {                                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (100:9): [True: 0, False: 0]
  |  |  |  |  |  Branch (100:15): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  101|      0|      *(char **)_p    = (char *)_t->_a.freelist;                                                   \
  |  |  |  |  102|      0|      _t->_a.freelist = _p;                                                                        \
  |  |  |  |  103|      0|      _t->_a.allocated++;                                                                          \
  |  |  |  |  104|      0|      UPDATE_FREE_METRICS(::_a);                                                                   \
  |  |  |  |  105|      0|      if (thread_freelist_high_watermark > 0 && _t->_a.allocated > thread_freelist_high_watermark) \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (105:11): [True: 0, False: 0]
  |  |  |  |  |  Branch (105:49): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  106|      0|        thread_freeup(::_a.raw(), _t->_a);                                                         \
  |  |  |  |  107|      0|    } else {                                                                                       \
  |  |  |  |  108|      0|      ::_a.raw().free_void(_p);                                                                    \
  |  |  |  |  109|      0|    }                                                                                              \
  |  |  |  |  110|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (110:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   55|      0|      } else {
   56|      0|        ink_hrtime tt = e->timeout_at - now;
   57|      0|        for (j = i; j > 0 && tt <= PQ_BUCKET_TIME(j - 1);) {
  ------------------
  |  |   31|      0|#define PQ_BUCKET_TIME(_i) (HRTIME_MSECONDS(5) << (_i))
  |  |  ------------------
  |  |  |  |   80|      0|#define HRTIME_MSECONDS(_x) ((_x) * HRTIME_MSECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   60|      0|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   61|      0|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (57:21): [True: 0, False: 0]
  |  Branch (57:30): [True: 0, False: 0]
  ------------------
   58|      0|          j--;
   59|      0|        }
   60|      0|        e->in_heap = j;
   61|      0|        after[j].enqueue(e);
   62|      0|      }
   63|      0|    }
   64|      0|  }
   65|      1|}

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

_ZN14ProtectedQueue16dequeue_externalEv:
   67|      1|{
   68|      1|  Event *e = static_cast<Event *>(ink_atomiclist_popall(&al));
   69|       |  // invert the list, to preserve order
   70|      1|  SLL<Event, Event::Link_link> l, t;
   71|      1|  t.head = e;
   72|      1|  while ((e = t.pop())) {
  ------------------
  |  Branch (72:10): [True: 0, False: 1]
  ------------------
   73|      0|    l.push(e);
   74|      0|  }
   75|       |  // insert into localQueue
   76|      1|  while ((e = l.pop())) {
  ------------------
  |  Branch (76:10): [True: 0, False: 1]
  ------------------
   77|      0|    if (!e->cancelled) {
  ------------------
  |  Branch (77:9): [True: 0, False: 0]
  ------------------
   78|      0|      localQueue.enqueue(e);
   79|      0|    } else {
   80|      0|      e->mutex = nullptr;
   81|      0|      eventAllocator.free(e);
   82|      0|    }
   83|      0|  }
   84|      1|}
_ZN14ProtectedQueue4waitEl:
   88|      1|{
   89|       |  /* If there are no external events available, will do a cond_timedwait.
   90|       |   *
   91|       |   *   - The `EThread::lock` will be released,
   92|       |   *   - And then the Event Thread goes to sleep and waits for the wakeup signal of `EThread::might_have_data`,
   93|       |   *   - The `EThread::lock` will be locked again when the Event Thread wakes up.
   94|       |   */
   95|      1|  if (INK_ATOMICLIST_EMPTY(al) && localQueue.empty()) {
  ------------------
  |  |  222|      2|#define INK_ATOMICLIST_EMPTY(_x) (!(TO_PTR(FREELIST_POINTER((_x.head)))))
  |  |  ------------------
  |  |  |  |  118|      1|#define TO_PTR(_x)   ((void *)(_x))
  |  |  ------------------
  |  |  |  Branch (222:34): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (95:35): [True: 1, False: 0]
  ------------------
   96|      1|    timespec ts = ink_hrtime_to_timespec(timeout);
   97|      1|    ink_cond_timedwait(&might_have_data, &lock, &ts);
   98|      1|  }
   99|      1|}

_Z14RecProcessInitP5Diags:
  149|      1|{
  150|      1|  static bool initialized_p = false;
  151|       |
  152|      1|  SetupRecRawStatBlockAllocator();
  153|       |
  154|      1|  if (initialized_p) {
  ------------------
  |  Branch (154:7): [True: 0, False: 1]
  ------------------
  155|      0|    return REC_ERR_OKAY;
  156|      0|  }
  157|       |
  158|      1|  if (RecCoreInit(_diags) == REC_ERR_FAIL) {
  ------------------
  |  Branch (158:7): [True: 0, False: 1]
  ------------------
  159|      0|    return REC_ERR_FAIL;
  160|      0|  }
  161|       |
  162|      1|  initialized_p = true;
  163|       |
  164|      1|  return REC_ERR_OKAY;
  165|      1|}

_Z29SetupRecRawStatBlockAllocatorv:
   77|      1|{
   78|      1|  SetRecAllocateRawStatBlockAllocator(RecAllocateRawStatBlockImpl);
   79|      1|}

_ZN6ThreadC2Ev:
   43|      1|{
   44|      1|  mutex = new_ProxyMutex();
   45|      1|}
_ZN6Thread5startEPKcPvmRKNSt3__18functionIFvvEEE:
   84|      1|{
   85|      1|  auto *p = new thread_data_internal{f, this, ""};
   86|       |
   87|      1|  ink_zero(p->name);
   88|      1|  ink_strlcpy(p->name, name, MAX_THREAD_NAME_LENGTH);
  ------------------
  |  |   62|      1|#define ink_strlcpy strlcpy
  ------------------
   89|      1|  if (stacksize == 0) {
  ------------------
  |  Branch (89:7): [True: 0, False: 1]
  ------------------
   90|      0|    stacksize = DEFAULT_STACKSIZE;
   91|      0|  }
   92|      1|  ink_thread_create(&tid, spawn_thread_internal, p, 0, stacksize, stack);
   93|      1|}
Thread.cc:_ZL21spawn_thread_internalPv:
   66|      1|{
   67|      1|  auto *p = static_cast<thread_data_internal *>(a);
   68|       |
   69|      1|  p->me->set_specific();
   70|      1|  ink_set_thread_name(p->name);
   71|       |
   72|      1|  if (p->f) {
  ------------------
  |  Branch (72:7): [True: 0, False: 1]
  ------------------
   73|      0|    p->f();
   74|      1|  } else {
   75|      1|    p->me->execute();
   76|      1|  }
   77|       |
   78|      1|  delete p;
   79|      1|  return nullptr;
   80|      1|}

_ZN7EThread12set_specificEv:
   78|      1|{
   79|      1|  this_ethread_ptr = this;
   80|      1|  Thread::set_specific();
   81|      1|}
_ZN7EThread11cons_commonEv:
   85|      1|{
   86|      1|  MUTEX_TAKE_LOCK(mutex, this);
  ------------------
  |  |  116|      1|#define MUTEX_TAKE_LOCK(_m, _t) Mutex_lock(_m, _t)
  ------------------
   87|      1|  mutex->nthread_holding += THREAD_MUTEX_THREAD_HOLDING;
  ------------------
  |  |   31|      1|#define THREAD_MUTEX_THREAD_HOLDING (-1024 * 1024)
  ------------------
   88|       |
   89|      1|  memset(thread_private, 0, PER_THREAD_DATA);
  ------------------
  |  |   44|      1|#define PER_THREAD_DATA (1024 * 1024)
  ------------------
   90|      1|}
_ZN7EThreadC2E10ThreadTypei:
   97|      1|EThread::EThread(ThreadType att, int anid) : id(anid), tt(att)
   98|      1|{
   99|      1|  cons_common();
  100|      1|#if HAVE_EVENTFD
  101|      1|  evfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
  102|      1|  if (evfd < 0) {
  ------------------
  |  Branch (102:7): [True: 0, False: 1]
  ------------------
  103|      0|    if (errno == EINVAL) { // flags invalid for kernel <= 2.6.26
  ------------------
  |  Branch (103:9): [True: 0, False: 0]
  ------------------
  104|      0|      evfd = eventfd(0, 0);
  105|      0|      if (evfd < 0) {
  ------------------
  |  Branch (105:11): [True: 0, False: 0]
  ------------------
  106|      0|        Fatal("EThread::EThread: %d=eventfd(0,0),errno(%d)", evfd, errno);
  ------------------
  |  |   90|      0|#define Fatal(...)     DiagsError(DL_Fatal, __VA_ARGS__)     // Log recoverable crash, fail CI, exit & allow restart
  |  |  ------------------
  |  |  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  107|      0|      }
  108|      0|    } else {
  109|      0|      Fatal("EThread::EThread: %d=eventfd(0,EFD_NONBLOCK | EFD_CLOEXEC),errno(%d)", evfd, errno);
  ------------------
  |  |   90|      0|#define Fatal(...)     DiagsError(DL_Fatal, __VA_ARGS__)     // Log recoverable crash, fail CI, exit & allow restart
  |  |  ------------------
  |  |  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  110|      0|    }
  111|      0|  }
  112|       |#else
  113|       |  ink_release_assert(pipe(evpipe) >= 0);
  114|       |  fcntl(evpipe[0], F_SETFD, FD_CLOEXEC);
  115|       |  fcntl(evpipe[0], F_SETFL, O_NONBLOCK);
  116|       |  fcntl(evpipe[1], F_SETFD, FD_CLOEXEC);
  117|       |  fcntl(evpipe[1], F_SETFL, O_NONBLOCK);
  118|       |#endif
  119|      1|}
_ZN7EThread13is_event_typeEi:
  142|      9|{
  143|      9|  return (event_types & (1 << static_cast<int>(et))) != 0;
  144|      9|}
_ZN7EThread14set_event_typeEi:
  148|      1|{
  149|      1|  event_types |= (1 << static_cast<int>(et));
  150|      1|}
_ZN7EThread13process_queueEP5QueueI5EventNS1_9Link_linkEEPiS5_l:
  200|      1|{
  201|      1|  Event *e;
  202|       |
  203|       |  // Move events from the external thread safe queues to the local queue.
  204|      1|  EventQueueExternal.dequeue_external();
  205|       |
  206|       |  // execute all the available external events that have
  207|       |  // already been dequeued
  208|      1|  while ((e = EventQueueExternal.dequeue_local())) {
  ------------------
  |  Branch (208:10): [True: 0, False: 1]
  ------------------
  209|      0|    ++(*ev_count);
  210|      0|    if (e->cancelled) {
  ------------------
  |  Branch (210:9): [True: 0, False: 0]
  ------------------
  211|      0|      free_event(e);
  212|      0|    } else if (!e->timeout_at) { // IMMEDIATE
  ------------------
  |  Branch (212:16): [True: 0, False: 0]
  ------------------
  213|      0|      ink_assert(e->period == 0);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  214|      0|      event_time = process_event(e, e->callback_event, event_time);
  215|      0|    } else if (e->timeout_at > 0) { // INTERVAL
  ------------------
  |  Branch (215:16): [True: 0, False: 0]
  ------------------
  216|      0|      EventQueue.enqueue(e, event_time);
  217|      0|    } else { // NEGATIVE
  218|      0|      Event *p = nullptr;
  219|      0|      Event *a = NegativeQueue->head;
  220|      0|      while (a && a->timeout_at > e->timeout_at) {
  ------------------
  |  Branch (220:14): [True: 0, False: 0]
  |  Branch (220:19): [True: 0, False: 0]
  ------------------
  221|      0|        p = a;
  222|      0|        a = a->link.next;
  223|      0|      }
  224|      0|      if (!a) {
  ------------------
  |  Branch (224:11): [True: 0, False: 0]
  ------------------
  225|      0|        NegativeQueue->enqueue(e);
  226|      0|      } else {
  227|      0|        NegativeQueue->insert(e, p);
  228|      0|      }
  229|      0|    }
  230|      0|    ++(*nq_count);
  231|      0|  }
  232|      1|  return event_time;
  233|      1|}
_ZN7EThread15execute_regularEv:
  237|      1|{
  238|      1|  Event *e;
  239|      1|  Que(Event, link) NegativeQueue;
  ------------------
  |  |  569|      1|#define Que(_c, _f)           Queue<_c, _c::Link##_##_f>
  ------------------
  240|      1|  ink_hrtime next_time;
  241|      1|  ink_hrtime delta;            // time spent in the event loop
  242|      1|  ink_hrtime loop_start_time;  // Time the loop started.
  243|      1|  ink_hrtime loop_finish_time; // Time at the end of the loop.
  244|       |
  245|      1|  loop_start_time = ink_get_hrtime();
  246|       |
  247|       |  // Track this so we can update on boundary crossing.
  248|      1|  auto prev_slice = this->metrics.prev_slice(metrics._slice.data() + (loop_start_time / HRTIME_SECOND) % Metrics::N_SLICES);
  ------------------
  |  |   58|      1|#define HRTIME_SECOND  (1000 * HRTIME_MSECOND)
  |  |  ------------------
  |  |  |  |   59|      1|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|      1|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   61|      1|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  249|       |
  250|      1|  int nq_count;
  251|      1|  int ev_count;
  252|       |
  253|       |  // A statically initialized instance we can use as a prototype for initializing other instances.
  254|      1|  static const Metrics::Slice SLICE_INIT;
  255|       |
  256|      1|  Metrics::Slice *current_slice{nullptr};
  257|       |
  258|       |  // give priority to immediate events
  259|      2|  while (!TSSystemState::is_event_system_shut_down()) {
  ------------------
  |  Branch (259:10): [True: 1, False: 1]
  ------------------
  260|      1|    nq_count = 0; // count # of elements put on negative queue.
  261|      1|    ev_count = 0; // # of events handled.
  262|       |
  263|      1|    current_slice = metrics._slice.data() + (loop_start_time / HRTIME_SECOND) % Metrics::N_SLICES;
  ------------------
  |  |   58|      1|#define HRTIME_SECOND  (1000 * HRTIME_MSECOND)
  |  |  ------------------
  |  |  |  |   59|      1|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|      1|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   61|      1|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  264|      1|    metrics.current_slice.store(current_slice, std::memory_order_release);
  265|      1|    if (current_slice != prev_slice) {
  ------------------
  |  Branch (265:9): [True: 1, False: 0]
  ------------------
  266|       |      // I have observed multi-second event loops in production, making this necessary. [amc]
  267|      1|      do {
  268|      1|        memcpy(prev_slice = this->metrics.next_slice(prev_slice), &SLICE_INIT, sizeof(SLICE_INIT));
  269|      1|      } while (current_slice != prev_slice);
  ------------------
  |  Branch (269:16): [True: 0, False: 1]
  ------------------
  270|      1|      current_slice->record_loop_start(loop_start_time);
  271|      1|    }
  272|      1|    ++(current_slice->_count); // loop started, bump count.
  273|       |
  274|      1|    ink_hrtime event_time = process_queue(&NegativeQueue, &ev_count, &nq_count, loop_start_time);
  275|       |
  276|      1|    bool done_one;
  277|      1|    do {
  278|      1|      done_one = false;
  279|       |      // execute all the eligible internal events
  280|      1|      EventQueue.check_ready(event_time, this);
  281|      1|      while ((e = EventQueue.dequeue_ready(event_time))) {
  ------------------
  |  Branch (281:14): [True: 0, False: 1]
  ------------------
  282|      0|        ink_assert(e);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  283|      0|        ink_assert(e->timeout_at > 0);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  284|      0|        if (e->cancelled) {
  ------------------
  |  Branch (284:13): [True: 0, False: 0]
  ------------------
  285|      0|          free_event(e);
  286|      0|        } else {
  287|      0|          done_one   = true;
  288|      0|          event_time = process_event(e, e->callback_event, event_time);
  289|      0|        }
  290|      0|      }
  291|      1|    } while (done_one);
  ------------------
  |  Branch (291:14): [True: 0, False: 1]
  ------------------
  292|       |
  293|       |    // execute any negative (poll) events
  294|      1|    if (NegativeQueue.head) {
  ------------------
  |  Branch (294:9): [True: 0, False: 1]
  ------------------
  295|      0|      event_time = process_queue(&NegativeQueue, &ev_count, &nq_count, event_time);
  296|       |
  297|       |      // execute poll events
  298|      0|      while ((e = NegativeQueue.dequeue())) {
  ------------------
  |  Branch (298:14): [True: 0, False: 0]
  ------------------
  299|      0|        event_time = process_event(e, EVENT_POLL, event_time);
  ------------------
  |  |   42|      0|#define EVENT_POLL      5 // negative event; activated on poll or epoll
  ------------------
  300|      0|      }
  301|      0|    }
  302|       |
  303|      1|    next_time             = EventQueue.earliest_timeout();
  304|      1|    ink_hrtime sleep_time = next_time - event_time;
  305|      1|    if (sleep_time > 0) {
  ------------------
  |  Branch (305:9): [True: 1, False: 0]
  ------------------
  306|      1|      if (EventQueueExternal.localQueue.empty()) {
  ------------------
  |  Branch (306:11): [True: 1, False: 0]
  ------------------
  307|      1|        sleep_time = std::min(sleep_time, HRTIME_MSECONDS(thread_max_heartbeat_mseconds));
  ------------------
  |  |   80|      1|#define HRTIME_MSECONDS(_x) ((_x) * HRTIME_MSECOND)
  |  |  ------------------
  |  |  |  |   59|      1|#define HRTIME_MSECOND (1000 * HRTIME_USECOND)
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|      1|#define HRTIME_USECOND (1000 * HRTIME_NSECOND)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   61|      1|#define HRTIME_NSECOND (static_cast<ink_hrtime>(1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  308|      1|      } else {
  309|       |        // Because of a missed lock, Timed-Event and Negative-Event have been pushed into localQueue for retry in awhile.
  310|       |        // Therefore, we have to set the limitation of sleep time in order to handle the next retry in time.
  311|      0|        sleep_time = std::min(sleep_time, DELAY_FOR_RETRY);
  312|      0|      }
  313|      1|      ++(current_slice->_wait);
  314|      1|    } else {
  315|      0|      sleep_time = 0;
  316|      0|    }
  317|       |
  318|       |    // drained the queue by this point
  319|      1|    ink_hrtime post_drain  = event_time;
  320|      1|    ink_hrtime drain_queue = post_drain - loop_start_time;
  321|       |
  322|       |    // watchdog kick - pre-sleep
  323|       |    // Relaxed store because this EThread is the only writer and the watchdog only needs a coherent timestamp.
  324|      1|    this->heartbeat_state.last_sleep.store(std::chrono::steady_clock::now(), std::memory_order_relaxed);
  325|       |
  326|      1|    tail_cb->waitForActivity(sleep_time);
  327|       |
  328|       |    // watchdog kick - post-wake
  329|       |    // Relaxed store/fetch because the monitor thread is the single reader and per-field coherence is sufficient.
  330|      1|    this->heartbeat_state.last_wake.store(std::chrono::steady_clock::now(), std::memory_order_relaxed);
  331|      1|    this->heartbeat_state.seq.fetch_add(1, std::memory_order_relaxed);
  332|       |
  333|       |    // loop cleanup
  334|      1|    loop_finish_time = ink_get_hrtime();
  335|       |    // @a delta can be negative due to time of day adjustments (which apparently happen quite frequently). I
  336|       |    // tried using the monotonic clock to get around this but it was *very* stuttery (up to hundreds
  337|       |    // of milliseconds), far too much to be actually used.
  338|      1|    delta           = std::max<ink_hrtime>(0, loop_finish_time - loop_start_time);
  339|      1|    loop_start_time = loop_finish_time;
  340|       |
  341|      1|    metrics.decay();
  342|      1|    metrics.record_loop_time(delta);
  343|      1|    current_slice->record_event_count(ev_count);
  344|      1|    current_slice->record_drain_queue(drain_queue);
  345|      1|  }
  346|      1|}
_ZN7EThread7executeEv:
  361|      1|{
  362|       |  // Do the start event first.
  363|       |  // coverity[lock]
  364|      1|  if (start_event) {
  ------------------
  |  Branch (364:7): [True: 1, False: 0]
  ------------------
  365|      1|    {
  366|      1|      SCOPED_MUTEX_LOCK(lock, start_event->mutex, this);
  ------------------
  |  |   62|      1|#define SCOPED_MUTEX_LOCK(_l, _m, _t) MutexLock _l(_m, _t)
  ------------------
  367|      1|      start_event->continuation->handleEvent(EVENT_IMMEDIATE, start_event);
  ------------------
  |  |   38|      1|#define EVENT_IMMEDIATE 1
  ------------------
  368|      1|    }
  369|      1|    free_event(start_event);
  370|      1|    start_event = nullptr;
  371|      1|  }
  372|       |
  373|      1|  switch (tt) {
  374|      1|  case REGULAR: {
  ------------------
  |  Branch (374:3): [True: 1, False: 0]
  ------------------
  375|       |    /* The Event Thread has two status: busy and sleep:
  376|       |     *   - Keep `EThread::lock` locked while Event Thread is busy,
  377|       |     *   - The `EThread::lock` is released while Event Thread is sleep.
  378|       |     * When other threads try to acquire the `EThread::lock` of the target Event Thread:
  379|       |     *   - Acquired, indicating that the target Event Thread is sleep,
  380|       |     *   - Failed, indicating that the target Event Thread is busy.
  381|       |     */
  382|      1|    ink_mutex_acquire(&EventQueueExternal.lock);
  383|      1|    this->execute_regular();
  384|      1|    ink_mutex_release(&EventQueueExternal.lock);
  385|      1|    break;
  386|      0|  }
  387|      0|  case DEDICATED: {
  ------------------
  |  Branch (387:3): [True: 0, False: 1]
  ------------------
  388|      0|    break;
  389|      0|  }
  390|      0|  default:
  ------------------
  |  Branch (390:3): [True: 0, False: 1]
  ------------------
  391|      0|    ink_assert(!"bad case value (execute)");
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  392|      0|    break;
  393|      1|  } /* End switch */
  394|       |  // coverity[missing_unlock]
  395|      1|}
_ZN7EThread14schedule_spawnEP12ContinuationiPv:
  630|      1|{
  631|      1|  ink_assert(this != this_ethread()); // really broken to call this from the same thread.
  ------------------
  |  |   45|      1|#define ink_assert(EX) (void)(EX)
  ------------------
  632|      1|  if (start_event) {
  ------------------
  |  Branch (632:7): [True: 0, False: 1]
  ------------------
  633|      0|    free_event(start_event);
  634|      0|  }
  635|      1|  start_event          = EVENT_ALLOC(eventAllocator, this);
  ------------------
  |  |  287|      1|#define EVENT_ALLOC(_a, _t) THREAD_ALLOC(_a, _t)
  |  |  ------------------
  |  |  |  |   77|      1|#define THREAD_ALLOC(_a, _t, ...)      thread_alloc(::_a, _t->_a, ##__VA_ARGS__)
  |  |  ------------------
  ------------------
  636|      1|  start_event->ethread = this;
  637|      1|  start_event->mutex   = this->mutex;
  638|      1|  start_event->init(c);
  639|      1|  start_event->callback_event = ev;
  640|      1|  start_event->cookie         = cookie;
  641|      1|  return start_event;
  642|      1|}

_ZN25ThreadAffinityInitializer17setup_stack_guardEPvi:
  173|      1|{
  174|       |#if !(defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__arm64__) || defined(__aarch64__) || \
  175|       |      defined(__mips__) || defined(__powerpc64__))
  176|       |#error Unknown stack growth direction.  Determine the stack growth direction of your platform.
  177|       |// If your stack grows upwards, you need to change this function and the calculation of stack_begin in do_alloc_stack.
  178|       |#endif
  179|       |  // Assumption: stack grows down
  180|      1|  if (stackguard_pages <= 0) {
  ------------------
  |  Branch (180:7): [True: 0, False: 1]
  ------------------
  181|      0|    return;
  182|      0|  }
  183|       |
  184|      1|  size_t pagesize  = ats_hugepage_enabled() ? ats_hugepage_size() : ats_pagesize();
  ------------------
  |  Branch (184:22): [True: 0, False: 1]
  ------------------
  185|      1|  size_t guardsize = stackguard_pages * pagesize;
  186|      1|  int    ret       = mprotect(stack, guardsize, 0);
  187|      1|  if (ret != 0) {
  ------------------
  |  Branch (187:7): [True: 0, False: 1]
  ------------------
  188|      0|    Fatal("Failed to set up stack guard pages: %s (%d)", strerror(errno), errno);
  ------------------
  |  |   90|      0|#define Fatal(...)     DiagsError(DL_Fatal, __VA_ARGS__)     // Log recoverable crash, fail CI, exit & allow restart
  |  |  ------------------
  |  |  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  189|      0|  }
  190|      1|}
_ZN25ThreadAffinityInitializer14do_alloc_stackEm:
  194|      1|{
  195|      1|  size_t pagesize = ats_hugepage_enabled() ? ats_hugepage_size() : ats_pagesize();
  ------------------
  |  Branch (195:21): [True: 0, False: 1]
  ------------------
  196|      1|  int    stackguard_pages;
  197|      1|  stackguard_pages = RecGetRecordInt("proxy.config.thread.default.stackguard_pages").value_or(0);
  198|      1|  ink_release_assert(stackguard_pages >= 0);
  ------------------
  |  |   48|      1|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  199|       |
  200|      1|  size_t size       = INK_ALIGN(stacksize + stackguard_pages * pagesize, pagesize);
  ------------------
  |  |   50|      1|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1))
  ------------------
  201|      1|  int    mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS;
  202|      1|#ifdef MAP_HUGETLB
  203|      1|  if (ats_hugepage_enabled()) {
  ------------------
  |  Branch (203:7): [True: 0, False: 1]
  ------------------
  204|      0|    mmap_flags |= MAP_HUGETLB;
  205|      0|  }
  206|      1|#endif
  207|      1|  void *stack_and_guard = mmap(nullptr, size, PROT_READ | PROT_WRITE, mmap_flags, -1, 0);
  208|      1|  if (stack_and_guard == MAP_FAILED) {
  ------------------
  |  Branch (208:7): [True: 0, False: 1]
  ------------------
  209|      0|    Error("Failed to allocate stack pages: size = %zu", size);
  ------------------
  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  210|      0|    return nullptr;
  211|      0|  }
  212|       |
  213|      1|  setup_stack_guard(stack_and_guard, stackguard_pages);
  214|       |
  215|      1|  void *stack_begin = static_cast<char *>(stack_and_guard) + stackguard_pages * pagesize;
  216|      1|  Dbg(dbg_ctl_iocore_thread, "Allocated %zu bytes (%zu bytes in guard pages) for stack {%p-%p guard, %p-%p stack}", size,
  ------------------
  |  |  173|      1|  do {                              \
  |  |  174|      1|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 1]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|      1|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  217|      1|      stackguard_pages * pagesize, stack_and_guard, stack_begin, stack_begin, static_cast<char *>(stack_begin) + stacksize);
  218|       |
  219|      1|  return stack_begin;
  220|      1|}
_ZN25ThreadAffinityInitializer4initEv:
  349|      1|{
  350|      1|}
_ZN25ThreadAffinityInitializer12set_affinityEiP5Event:
  354|      1|{
  355|      1|  return 0;
  356|      1|}
_ZN25ThreadAffinityInitializer11alloc_stackEP7EThreadm:
  360|      1|{
  361|      1|  return this->do_alloc_stack(stacksize);
  362|      1|}
_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|}
_ZN14EventProcessor14schedule_spawnEPFvP7EThreadEi:
  407|      1|{
  408|      1|  Event *e = make_event_for_scheduling(&Thread_Init_Func, EVENT_IMMEDIATE, reinterpret_cast<void *>(f));
  ------------------
  |  |   38|      1|#define EVENT_IMMEDIATE 1
  ------------------
  409|      1|  ink_assert(ev_type < MAX_EVENT_TYPES);
  ------------------
  |  |   45|      1|#define ink_assert(EX) (void)(EX)
  ------------------
  410|      1|  thread_group[ev_type]._spawnQueue.enqueue(e);
  411|      1|  return e;
  412|      1|}
_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|}
_ZN14EventProcessor19spawn_event_threadsEiim:
  434|      1|{
  435|      1|  char                   thr_name[MAX_THREAD_NAME_LENGTH];
  436|      1|  int                    i;
  437|      1|  ThreadGroupDescriptor *tg = &(thread_group[ev_type]);
  438|       |
  439|      1|  ink_release_assert(n_threads > 0);
  ------------------
  |  |   48|      1|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  440|      1|  ink_release_assert((n_ethreads + n_threads) <= MAX_EVENT_THREADS);
  ------------------
  |  |   48|      1|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  441|      1|  ink_release_assert(ev_type < MAX_EVENT_TYPES);
  ------------------
  |  |   48|      1|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  442|       |
  443|      1|  stacksize = std::max(stacksize, static_cast<decltype(stacksize)>(INK_THREAD_STACK_MIN));
  ------------------
  |  |   54|      1|#define INK_THREAD_STACK_MIN PTHREAD_STACK_MIN
  ------------------
  444|       |  // Make sure it is a multiple of our page size
  445|      1|  if (ats_hugepage_enabled()) {
  ------------------
  |  Branch (445:7): [True: 0, False: 1]
  ------------------
  446|      0|    stacksize = INK_ALIGN(stacksize, ats_hugepage_size());
  ------------------
  |  |   50|      0|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1))
  ------------------
  447|      1|  } else {
  448|      1|    stacksize = INK_ALIGN(stacksize, ats_pagesize());
  ------------------
  |  |   50|      1|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1))
  ------------------
  449|      1|  }
  450|       |
  451|      1|  Dbg(dbg_ctl_iocore_thread, "Thread stack size set to %zu", stacksize);
  ------------------
  |  |  173|      1|  do {                              \
  |  |  174|      1|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 1]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|      1|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  452|       |
  453|      2|  for (i = 0; i < n_threads; ++i) {
  ------------------
  |  Branch (453:15): [True: 1, False: 1]
  ------------------
  454|      1|    EThread *t                   = new EThread(REGULAR, n_ethreads + i);
  455|      1|    all_ethreads[n_ethreads + i] = t;
  456|      1|    tg->_thread[i]               = t;
  457|      1|    t->id                        = i; // unfortunately needed to support affinity and NUMA logic.
  458|      1|    t->set_event_type(ev_type);
  459|      1|    t->schedule_spawn(&thread_initializer);
  460|      1|  }
  461|      1|  tg->_count  = n_threads;
  462|      1|  n_ethreads += n_threads;
  463|      1|  schedule_spawn(&thread_started, ev_type);
  464|       |
  465|       |  // Separate loop to avoid race conditions between spawn events and updating the thread table for
  466|       |  // the group. Some thread set up depends on knowing the total number of threads but that can't be
  467|       |  // safely updated until all the EThread instances are created and stored in the table.
  468|      2|  for (i = 0; i < n_threads; ++i) {
  ------------------
  |  Branch (468:15): [True: 1, False: 1]
  ------------------
  469|      1|    Dbg(dbg_ctl_iocore_thread_start, "Created %s thread #%d", tg->_name.c_str(), i + 1);
  ------------------
  |  |  173|      1|  do {                              \
  |  |  174|      1|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 1]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|      1|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  470|      1|    snprintf(thr_name, MAX_THREAD_NAME_LENGTH, "[%s %d]", tg->_name.c_str(), i);
  471|      1|    void *stack = Thread_Affinity_Initializer.alloc_stack(tg->_thread[i], stacksize);
  472|      1|    tg->_thread[i]->start(thr_name, stack, stacksize);
  473|      1|  }
  474|       |
  475|      1|  Dbg(dbg_ctl_iocore_thread, "Created thread group '%s' id %d with %d threads", tg->_name.c_str(), ev_type, n_threads);
  ------------------
  |  |  173|      1|  do {                              \
  |  |  174|      1|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 1]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|      1|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  476|       |
  477|      1|  return ev_type; // useless but not sure what would be better.
  478|      1|}
_ZN14EventProcessor15initThreadStateEP7EThread:
  484|      1|{
  485|       |  // Run all thread type initialization continuations that match the event types for this thread.
  486|      9|  for (int i = 0; i < MAX_EVENT_TYPES; ++i) {
  ------------------
  |  Branch (486:19): [True: 8, False: 1]
  ------------------
  487|      8|    if (t->is_event_type(i)) {
  ------------------
  |  Branch (487:9): [True: 1, False: 7]
  ------------------
  488|       |      // To avoid race conditions on the event in the spawn queue, create a local one to actually send.
  489|       |      // Use the spawn queue event as a read only model.
  490|      1|      Event *nev = eventAllocator.alloc();
  491|      3|      for (Event *ev = thread_group[i]._spawnQueue.head; nullptr != ev; ev = ev->link.next) {
  ------------------
  |  Branch (491:58): [True: 2, False: 1]
  ------------------
  492|      2|        nev->init(ev->continuation, 0, 0);
  493|      2|        nev->ethread        = t;
  494|      2|        nev->callback_event = ev->callback_event;
  495|      2|        nev->mutex          = ev->continuation->mutex;
  496|      2|        nev->cookie         = ev->cookie;
  497|      2|        ev->continuation->handleEvent(ev->callback_event, nev);
  498|      2|      }
  499|      1|      nev->free();
  500|      1|    }
  501|      8|  }
  502|      1|}
_ZN14EventProcessor5startEim:
  506|      1|{
  507|      1|  using Graph = EThread::Metrics::Graph;
  508|       |  // do some sanity checking.
  509|      1|  static bool started = false;
  510|      1|  ink_release_assert(!started);
  ------------------
  |  |   48|      1|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  511|      1|  ink_release_assert(n_event_threads > 0 && n_event_threads <= MAX_EVENT_THREADS);
  ------------------
  |  |   48|      2|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 1, False: 0]
  |  |  |  Branch (48:60): [True: 1, False: 0]
  |  |  |  Branch (48:60): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  512|      1|  started = true;
  513|       |
  514|      1|  Thread_Affinity_Initializer.init();
  515|       |  // Least ugly thing - this needs to be the first callback from the thread but by the time this
  516|       |  // method is called other spawn callbacks have been registered. This forces thread affinity
  517|       |  // first. The other alternative would be to require a call to an @c init method which I like even
  518|       |  // less because this cannot be done in the constructor - that depends on too much other
  519|       |  // infrastructure being in place (e.g. the proxy allocators).
  520|      1|  thread_group[ET_CALL]._spawnQueue.push(make_event_for_scheduling(&Thread_Affinity_Initializer, EVENT_IMMEDIATE, nullptr));
  ------------------
  |  |   38|      1|#define EVENT_IMMEDIATE 1
  ------------------
  521|       |
  522|       |  // Get our statistics set up
  523|      1|  unsigned stat_idx = 0;
  524|      1|  char     name[256];
  525|       |
  526|       |  // Enumerated statistics, one set per time scale.
  527|      4|  for (unsigned ts_idx = 0; ts_idx < EThread::Metrics::N_TIMESCALES; ++ts_idx) {
  ------------------
  |  Branch (527:29): [True: 3, False: 1]
  ------------------
  528|      3|    auto sample_count = EThread::Metrics::SLICE_SAMPLE_COUNT[ts_idx];
  529|     30|    for (auto id : EThread::Metrics::Slice::STAT_NAME) {
  ------------------
  |  Branch (529:18): [True: 30, False: 3]
  ------------------
  530|     30|      snprintf(name, sizeof(name), "%s.%ds", id, sample_count);
  531|     30|      events_rsb.stats[stat_idx++] = ts::Metrics::Gauge::createPtr(name);
  532|     30|    }
  533|      3|  }
  534|       |
  535|       |  // Event loop timings.
  536|     34|  for (Graph::raw_type id = 0; id < Graph::N_BUCKETS; ++id) {
  ------------------
  |  Branch (536:32): [True: 33, False: 1]
  ------------------
  537|     33|    snprintf(name, sizeof(name), "%s%zums", EThread::Metrics::LOOP_HISTOGRAM_STAT_STEM.data(),
  538|     33|             static_cast<size_t>(EThread::Metrics::LOOP_HISTOGRAM_BUCKET_SIZE.count() * Graph::min_for_bucket(id)));
  539|     33|    events_rsb.stats[stat_idx++] = ts::Metrics::Gauge::createPtr(name);
  540|     33|  }
  541|       |
  542|       |  // plugin API timings
  543|     34|  for (Graph::raw_type id = 0; id < Graph::N_BUCKETS; ++id) {
  ------------------
  |  Branch (543:32): [True: 33, False: 1]
  ------------------
  544|     33|    snprintf(name, sizeof(name), "%s%zums", EThread::Metrics::API_HISTOGRAM_STAT_STEM.data(),
  545|     33|             static_cast<size_t>(EThread::Metrics::API_HISTOGRAM_BUCKET_SIZE.count() * Graph::min_for_bucket(id)));
  546|     33|    events_rsb.stats[stat_idx++] = ts::Metrics::Gauge::createPtr(name);
  547|     33|  }
  548|       |
  549|      1|  debug_assert_message(stat_idx == events_rsb.stats.size(), "events_rsp stats overrun!");
  ------------------
  |  |   46|      1|#define debug_assert_message(EX, MSG) (void)(EX)
  ------------------
  550|       |
  551|      1|  RecRegNewSyncStatSync(EventMetricStatSync);
  552|       |
  553|      1|  this->spawn_event_threads(ET_CALL, n_event_threads, stacksize);
  554|       |
  555|      1|  Dbg(dbg_ctl_iocore_thread, "Created event thread group id %d with %d threads", ET_CALL, n_event_threads);
  ------------------
  |  |  173|      1|  do {                              \
  |  |  174|      1|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 1]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|      1|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  556|      1|  return 0;
  557|      1|}
_Z14thread_startedP7EThread:
  608|      1|{
  609|       |  // Find what type of thread this is, and increment the "_started" counter of that thread type.
  610|      1|  for (int i = 0; i < MAX_EVENT_TYPES; ++i) {
  ------------------
  |  Branch (610:19): [True: 1, False: 0]
  ------------------
  611|      1|    if (t->is_event_type(i)) {
  ------------------
  |  Branch (611:9): [True: 1, False: 0]
  ------------------
  612|      1|      if (++eventProcessor.thread_group[i]._started == eventProcessor.thread_group[i]._count &&
  ------------------
  |  Branch (612:11): [True: 1, False: 0]
  ------------------
  613|      1|          eventProcessor.thread_group[i]._afterStartCallback != nullptr) {
  ------------------
  |  Branch (613:11): [True: 0, False: 1]
  ------------------
  614|      0|        eventProcessor.thread_group[i]._afterStartCallback();
  615|      0|      }
  616|      1|      break;
  617|      1|    }
  618|      1|  }
  619|      1|}
_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))
  ------------------
UnixEventProcessor.cc:_ZN12_GLOBAL__N_116ThreadInitByFunc6invokeEiP5Event:
  163|      1|  {
  164|      1|    void (*f)(EThread *) = reinterpret_cast<void (*)(EThread *)>(ev->cookie);
  165|      1|    f(ev->ethread);
  166|      1|    return 0;
  167|      1|  }
UnixEventProcessor.cc:_ZN12_GLOBAL__N_125make_event_for_schedulingEP12ContinuationiPv:
  384|      2|{
  385|      2|  Event *e = eventAllocator.alloc();
  386|       |
  387|      2|  e->init(c);
  388|      2|  e->mutex          = c->mutex;
  389|      2|  e->callback_event = event_code;
  390|      2|  e->cookie         = cookie;
  391|       |
  392|      2|  return e;
  393|      2|}

_ZN15QUICVariableInt6decodeERmS0_PKhm:
   85|    543|{
   86|    543|  if (src_len < 1) {
  ------------------
  |  Branch (86:7): [True: 0, False: 543]
  ------------------
   87|      0|    return -1;
   88|      0|  }
   89|    543|  len = 1 << (src[0] >> 6);
   90|    543|  if (src_len < len) {
  ------------------
  |  Branch (90:7): [True: 18, False: 525]
  ------------------
   91|     18|    return 1;
   92|     18|  }
   93|       |
   94|    525|  uint8_t buf[8] = {0};
   95|    525|  memcpy(buf, src, len);
   96|    525|  buf[0] &= 0x3f;
   97|       |
   98|    525|  dst = QUICIntUtil::read_nbytes_as_uint(buf, len);
   99|       |
  100|    525|  return 0;
  101|    543|}
_ZN11QUICIntUtil19read_nbytes_as_uintEPKhh:
  120|    525|{
  121|    525|  uint64_t value = 0;
  122|    525|  memcpy(&value, buf, n);
  123|       |  return be64toh(value << (64 - n * 8));
  124|    525|}

_ZN2ts17Http3ConfigParams10initializeEv:
   33|      1|{
   34|      1|  RecEstablishStaticConfigUInt32(this->_header_table_size, "proxy.config.http3.header_table_size");
   35|      1|  RecEstablishStaticConfigUInt32(this->_max_field_section_size, "proxy.config.http3.max_field_section_size");
   36|      1|  RecEstablishStaticConfigUInt32(this->_qpack_blocked_streams, "proxy.config.http3.qpack_blocked_streams");
   37|      1|  RecEstablishStaticConfigUInt32(this->_num_placeholders, "proxy.config.http3.num_placeholders");
   38|      1|  RecEstablishStaticConfigUInt32(this->_max_settings, "proxy.config.http3.max_settings");
   39|      1|}
_ZNK2ts17Http3ConfigParams12max_settingsEv:
   67|      5|{
   68|      5|  return this->_max_settings;
   69|      5|}
_ZN2ts11Http3Config7startupEv:
   76|      1|{
   77|      1|  reconfigure();
   78|      1|}
_ZN2ts11Http3Config11reconfigureEv:
   82|      1|{
   83|      1|  Http3ConfigParams *params;
   84|      1|  params = new Http3ConfigParams;
   85|       |  // re-read configuration
   86|      1|  params->initialize();
   87|      1|  ts::Http3Config::_config_id = configProcessor.set(ts::Http3Config::_config_id, params);
   88|      1|}
_ZN2ts11Http3Config7acquireEv:
   92|    149|{
   93|    149|  return static_cast<ts::Http3ConfigParams *>(configProcessor.get(ts::Http3Config::_config_id));
   94|    149|}
_ZN2ts11Http3Config7releaseEPNS_17Http3ConfigParamsE:
   98|    149|{
   99|    149|  configProcessor.release(ts::Http3Config::_config_id, params);
  100|    149|}

_ZN10Http3Frame4typeEPKhm:
   58|    298|{
   59|    298|  uint64_t type              = 0;
   60|    298|  size_t   type_field_length = 0;
   61|    298|  int      ret               = QUICVariableInt::decode(type, type_field_length, buf, buf_len);
   62|    298|  ink_assert(ret != 1);
  ------------------
  |  |   45|    298|#define ink_assert(EX) (void)(EX)
  ------------------
   63|    298|  if (type <= static_cast<uint64_t>(Http3FrameType::X_MAX_DEFINED)) {
  ------------------
  |  Branch (63:7): [True: 56, False: 242]
  ------------------
   64|     56|    return static_cast<Http3FrameType>(type);
   65|    242|  } else {
   66|    242|    return Http3FrameType::UNKNOWN;
   67|    242|  }
   68|    298|}
_ZN10Http3FrameC2ER14IOBufferReader:
   74|    149|Http3Frame::Http3Frame(IOBufferReader &reader) : _reader(&reader)
   75|    149|{
   76|       |  // Type field and Length field are variable-length integers, which can be 64 bits for each.
   77|       |  // 16 bytes (128 bits) is large enough to contain the two fields.
   78|    149|  constexpr int MAX_HEADER_SIZE = 16;
   79|    149|  uint8_t       header[MAX_HEADER_SIZE];
   80|    149|  uint8_t      *p          = reinterpret_cast<uint8_t *>(reader.memcpy(header, MAX_HEADER_SIZE));
   81|    149|  uint64_t      header_len = p - header;
   82|       |
   83|       |  // Type
   84|    149|  size_t   type_field_length = 0;
   85|    149|  uint64_t type              = 0;
   86|       |  // Ideally we'd simply pass this->_type to decode, but arm compilers complain with:
   87|       |  // error: dereferencing type-punned pointer will break strict-aliasing rules
   88|    149|  int ret = QUICVariableInt::decode(type, type_field_length, header, header_len);
   89|    149|  if (ret != 0) {
  ------------------
  |  Branch (89:7): [True: 6, False: 143]
  ------------------
   90|      6|    this->_is_valid = false;
   91|      6|    return;
   92|      6|  }
   93|    143|  this->_type = static_cast<Http3FrameType>(type);
   94|       |
   95|       |  // Check if we can proceed to read Length field
   96|    143|  if (header_len <= type_field_length) {
  ------------------
  |  Branch (96:7): [True: 47, False: 96]
  ------------------
   97|     47|    this->_is_valid = false;
   98|     47|    return;
   99|     47|  }
  100|       |
  101|       |  // Length
  102|     96|  size_t length_field_length = 0;
  103|     96|  ret = QUICVariableInt::decode(this->_length, length_field_length, header + type_field_length, header_len - type_field_length);
  104|     96|  if (ret != 0) {
  ------------------
  |  Branch (104:7): [True: 12, False: 84]
  ------------------
  105|     12|    this->_is_valid = false;
  106|     12|    return;
  107|     12|  }
  108|       |
  109|       |  // Rest of the data is Frame Payload
  110|     84|  this->_reader->consume(type_field_length + length_field_length);
  111|     84|  this->_payload_offset = type_field_length + length_field_length;
  112|     84|}
_ZN10Http3FrameC2E14Http3FrameType:
  114|      5|Http3Frame::Http3Frame(Http3FrameType type) : _type(type) {}
_ZN10Http3FrameD2Ev:
  117|    149|{
  118|    149|  if (this->_reader) {
  ------------------
  |  Branch (118:7): [True: 149, False: 0]
  ------------------
  119|    149|    this->_reader->dealloc();
  120|    149|  }
  121|    149|}
_ZN14Http3DataFrameC2ER14IOBufferReader:
  207|     10|Http3DataFrame::Http3DataFrame(IOBufferReader &reader) : Http3Frame(reader)
  208|     10|{
  209|     10|  this->_payload_len = this->_length;
  210|     10|}
_ZN17Http3HeadersFrameC2ER14IOBufferReader:
  263|      5|Http3HeadersFrame::Http3HeadersFrame(IOBufferReader &reader) : Http3Frame(reader) {}
_ZN17Http3HeadersFrameD2Ev:
  273|      5|{
  274|      5|  if (this->_header_block_uptr == nullptr) {
  ------------------
  |  Branch (274:7): [True: 5, False: 0]
  ------------------
  275|      5|    ats_free(this->_header_block);
  276|      5|  }
  277|      5|}
_ZN18Http3SettingsFrameC2ER14IOBufferReaderj:
  340|      5|  : Http3Frame(reader), _max_settings(max_settings)
  341|      5|{
  342|      5|}
_ZN17Http3FrameFactory6createER14IOBufferReader:
  504|    149|{
  505|    149|  ts::Http3Config::scoped_config params;
  506|    149|  Http3Frame                    *frame = nullptr;
  507|       |
  508|    149|  uint8_t type_buf[FRAME_TYPE_MAX_BYTES]{};
  509|    149|  reader.memcpy(type_buf, sizeof(type_buf));
  510|    149|  Http3FrameType type = Http3Frame::type(type_buf, sizeof(type_buf));
  511|       |
  512|    149|  switch (type) {
  513|      5|  case Http3FrameType::HEADERS:
  ------------------
  |  Branch (513:3): [True: 5, False: 144]
  ------------------
  514|      5|    frame = http3HeadersFrameAllocator.alloc();
  515|      5|    new (frame) Http3HeadersFrame(reader);
  516|      5|    return Http3FrameUPtr(frame, &Http3FrameDeleter::delete_headers_frame);
  517|     10|  case Http3FrameType::DATA:
  ------------------
  |  Branch (517:3): [True: 10, False: 139]
  ------------------
  518|     10|    frame = http3DataFrameAllocator.alloc();
  519|     10|    new (frame) Http3DataFrame(reader);
  520|     10|    return Http3FrameUPtr(frame, &Http3FrameDeleter::delete_data_frame);
  521|      5|  case Http3FrameType::SETTINGS:
  ------------------
  |  Branch (521:3): [True: 5, False: 144]
  ------------------
  522|      5|    frame = http3SettingsFrameAllocator.alloc();
  523|      5|    new (frame) Http3SettingsFrame(reader, params->max_settings());
  524|      5|    return Http3FrameUPtr(frame, &Http3FrameDeleter::delete_settings_frame);
  525|    129|  default:
  ------------------
  |  Branch (525:3): [True: 129, False: 20]
  ------------------
  526|       |    // Unknown frame
  527|    129|    Dbg(dbg_ctl_http3_frame_factory, "Unknown frame type %hhx", static_cast<uint8_t>(type));
  ------------------
  |  |  173|    129|  do {                              \
  |  |  174|    129|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 129]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|    129|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 129]
  |  |  ------------------
  ------------------
  528|    129|    frame = http3FrameAllocator.alloc();
  529|    129|    new (frame) Http3Frame(reader);
  530|    129|    return Http3FrameUPtr(frame, &Http3FrameDeleter::delete_frame);
  531|    149|  }
  532|    149|}
_ZN17Http3FrameFactory11fast_createER14IOBufferReader:
  536|    149|{
  537|    149|  uint8_t type_buf[FRAME_TYPE_MAX_BYTES]{};
  538|    149|  reader.memcpy(type_buf, sizeof(type_buf));
  539|    149|  Http3FrameType type = Http3Frame::type(type_buf, sizeof(type_buf));
  540|    149|  if (type == Http3FrameType::UNKNOWN) {
  ------------------
  |  Branch (540:7): [True: 121, False: 28]
  ------------------
  541|    121|    if (!this->_unknown_frame) {
  ------------------
  |  Branch (541:9): [True: 121, False: 0]
  ------------------
  542|    121|      this->_unknown_frame = Http3FrameFactory::create(reader);
  543|    121|    } else {
  544|      0|      this->_unknown_frame->reset(reader);
  545|      0|    }
  546|    121|    return this->_unknown_frame;
  547|    121|  }
  548|       |
  549|     28|  std::shared_ptr<Http3Frame> frame = this->_reusable_frames[static_cast<uint8_t>(type)];
  550|       |
  551|     28|  if (frame == nullptr) {
  ------------------
  |  Branch (551:7): [True: 28, False: 0]
  ------------------
  552|     28|    frame = Http3FrameFactory::create(reader);
  553|     28|    if (frame != nullptr) {
  ------------------
  |  Branch (553:9): [True: 28, False: 0]
  ------------------
  554|     28|      this->_reusable_frames[static_cast<uint8_t>(type)] = frame;
  555|     28|    }
  556|     28|  } else {
  557|      0|    frame->reset(reader);
  558|      0|  }
  559|       |
  560|     28|  return frame;
  561|    149|}

_Z20RecRegisterConfigInt4RecTPKcl10RecUpdateT9RecCheckTS1_10RecSourceT10RecAccessT:
  164|    432|{
  165|    432|  return RecRegisterConfigImpl<rec_detail::IntTag>(rec_type, name, data_default, update_type, check_type, check_regex, source,
  166|    432|                                                   access_type);
  167|    432|}
_Z22RecRegisterConfigFloat4RecTPKcf10RecUpdateT9RecCheckTS1_10RecSourceT10RecAccessT:
  172|      7|{
  173|      7|  return RecRegisterConfigImpl<rec_detail::FloatTag>(rec_type, name, data_default, update_type, check_type, check_regex, source,
  174|      7|                                                     access_type);
  175|      7|}
_Z23RecRegisterConfigString4RecTPKcS1_10RecUpdateT9RecCheckTS1_10RecSourceT10RecAccessT:
  180|    120|{
  181|    120|  return RecRegisterConfigImpl<rec_detail::StringTag>(rec_type, name, const_cast<RecString>(data_default), update_type, check_type,
  182|    120|                                                      check_regex, source, access_type);
  183|    120|}
_Z16RecReadStatsFilev:
  333|      1|{
  334|      1|  RecRecord     *r;
  335|      1|  RecMessage    *m;
  336|      1|  RecMessageItr  itr;
  337|      1|  RecPersistT    persist_type = RECP_NULL;
  338|      1|  ats_scoped_str snap_fpath(RecConfigReadPersistentStatsPath());
  339|       |
  340|       |  // lock our hash table
  341|      1|  ink_rwlock_wrlock(&g_records_rwlock);
  342|       |
  343|      1|  CheckSnapFileVersion(snap_fpath);
  344|       |
  345|      1|  if ((m = RecMessageReadFromDisk(snap_fpath)) != nullptr) {
  ------------------
  |  Branch (345:7): [True: 0, False: 1]
  ------------------
  346|      0|    if (RecMessageUnmarshalFirst(m, &itr, &r) != REC_ERR_FAIL) {
  ------------------
  |  Branch (346:9): [True: 0, False: 0]
  ------------------
  347|      0|      do {
  348|      0|        if ((r->name == nullptr) || (!strlen(r->name))) {
  ------------------
  |  Branch (348:13): [True: 0, False: 0]
  |  Branch (348:37): [True: 0, False: 0]
  ------------------
  349|      0|          continue;
  350|      0|        }
  351|       |
  352|       |        // If we don't have a persistence type for this record, it means that it is not a stat, or it is
  353|       |        // not registered yet. Either way, it's ok to just set the persisted value and keep going.
  354|      0|        if (RecGetRecordPersistenceType(r->name, &persist_type, false /* lock */) != REC_ERR_OKAY) {
  ------------------
  |  Branch (354:13): [True: 0, False: 0]
  ------------------
  355|      0|          RecDebug(DL_Debug, "restoring value for persisted stat '%s'", r->name);
  ------------------
  |  |   78|      0|#define RecDebug(level, fmt, ...) _RecDebug(level, MakeSourceLocation(), fmt, ##__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   32|      0|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  ------------------
  356|      0|          RecSetRecord(r->rec_type, r->name, r->data_type, &(r->data), &(r->stat_meta.data_raw), REC_SOURCE_EXPLICIT, false);
  357|      0|          continue;
  358|      0|        }
  359|       |
  360|      0|        if (!REC_TYPE_IS_STAT(r->rec_type)) {
  ------------------
  |  |   35|      0|#define REC_TYPE_IS_STAT(rec_type) (((rec_type) == RECT_PROCESS) || ((rec_type) == RECT_PLUGIN) || ((rec_type) == RECT_NODE))
  |  |  ------------------
  |  |  |  Branch (35:37): [True: 0, False: 0]
  |  |  |  Branch (35:69): [True: 0, False: 0]
  |  |  |  Branch (35:100): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  361|       |          // This should not happen, but be defensive against records changing their type ..
  362|      0|          RecLog(DL_Warning, "skipping restore of non-stat record '%s'", r->name);
  ------------------
  |  |   77|      0|#define RecLog(level, fmt, ...)   _RecLog(level, MakeSourceLocation(), fmt, ##__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   32|      0|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  ------------------
  363|      0|          continue;
  364|      0|        }
  365|       |
  366|       |        // Check whether the persistence type was changed by a new software version. If the record is
  367|       |        // already registered with an updated persistence type, then we don't want to set it. We should
  368|       |        // keep the registered value.
  369|      0|        if (persist_type == RECP_NON_PERSISTENT) {
  ------------------
  |  Branch (369:13): [True: 0, False: 0]
  ------------------
  370|      0|          RecDebug(DL_Debug, "preserving current value of formerly persistent stat '%s'", r->name);
  ------------------
  |  |   78|      0|#define RecDebug(level, fmt, ...) _RecDebug(level, MakeSourceLocation(), fmt, ##__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   32|      0|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  ------------------
  371|      0|          continue;
  372|      0|        }
  373|       |
  374|      0|        RecDebug(DL_Debug, "restoring value for persisted stat '%s'", r->name);
  ------------------
  |  |   78|      0|#define RecDebug(level, fmt, ...) _RecDebug(level, MakeSourceLocation(), fmt, ##__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   32|      0|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  ------------------
  375|      0|        RecSetRecord(r->rec_type, r->name, r->data_type, &(r->data), &(r->stat_meta.data_raw), REC_SOURCE_EXPLICIT, false);
  376|      0|      } while (RecMessageUnmarshalNext(m, &itr, &r) != REC_ERR_FAIL);
  ------------------
  |  Branch (376:16): [True: 0, False: 0]
  ------------------
  377|      0|    }
  378|      0|  }
  379|       |
  380|      1|  ink_rwlock_unlock(&g_records_rwlock);
  381|      1|  ats_free(m);
  382|       |
  383|      1|  return REC_ERR_OKAY;
  384|      1|}
P_RecCore.cc:_ZL20CheckSnapFileVersionPKc:
  310|      1|{
  311|      1|  std::ifstream f(path, std::ios::binary);
  312|      1|  if (f.good()) {
  ------------------
  |  Branch (312:7): [True: 0, False: 1]
  ------------------
  313|       |    // get version, compare and remove
  314|      0|    char data[VERSION_HDR_SIZE];
  315|      0|    if (!f.read(data, VERSION_HDR_SIZE)) {
  ------------------
  |  Branch (315:9): [True: 0, False: 0]
  ------------------
  316|      0|      return;
  317|      0|    }
  318|      0|    if (data[0] != 'V' || data[1] != PACKAGE_VERSION[0] || data[2] != PACKAGE_VERSION[2] || data[3] != PACKAGE_VERSION[4] ||
  ------------------
  |  Branch (318:9): [True: 0, False: 0]
  |  Branch (318:27): [True: 0, False: 0]
  |  Branch (318:60): [True: 0, False: 0]
  |  Branch (318:93): [True: 0, False: 0]
  ------------------
  319|      0|        data[4] != '\0') {
  ------------------
  |  Branch (319:9): [True: 0, False: 0]
  ------------------
  320|       |      // not the right version found
  321|      0|      if (remove(path) != 0) {
  ------------------
  |  Branch (321:11): [True: 0, False: 0]
  ------------------
  322|      0|        ink_warning("unable to remove incompatible snap file '%s'", path);
  323|      0|      }
  324|      0|    }
  325|      0|  }
  326|      1|}
P_RecCore.cc:_ZN12_GLOBAL__N_121RecRegisterConfigImplINS_10rec_detail6IntTagEEE7RecErrT4RecTPKcNT_4typeE10RecUpdateT9RecCheckTS6_10RecSourceT10RecAccessT:
  131|    432|{
  132|    432|  ink_assert((rec_type == RECT_CONFIG) || (rec_type == RECT_LOCAL));
  ------------------
  |  |   45|    433|#define ink_assert(EX) (void)(EX)
  |  |  ------------------
  |  |  |  Branch (45:31): [True: 431, False: 1]
  |  |  |  Branch (45:31): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  133|       |
  134|    432|  RecData my_data_default;
  135|       |
  136|    432|  if constexpr (std::is_same_v<Tag, rec_detail::IntTag>) {
  137|    432|    my_data_default.rec_int = data_default;
  138|       |  } else if constexpr (std::is_same_v<Tag, rec_detail::CounterTag>) {
  139|       |    my_data_default.rec_counter = data_default;
  140|       |  } else if constexpr (std::is_same_v<Tag, rec_detail::FloatTag>) {
  141|       |    my_data_default.rec_float = data_default;
  142|       |  } else if constexpr (std::is_same_v<Tag, rec_detail::StringTag>) {
  143|       |    my_data_default.rec_string = data_default;
  144|       |  } else {
  145|       |    static_assert(always_false<Tag>::value, "Unsupported tag for RecRegisterConfig");
  146|       |  }
  147|       |
  148|    432|  if (RecRecord *r = RecRegisterConfig(rec_type, name, Tag::data_type, my_data_default, update_type, check_type, check_regex,
  149|    432|                                       source, access_type);
  150|    432|      r != nullptr) {
  ------------------
  |  Branch (150:7): [True: 432, False: 0]
  ------------------
  151|    432|    if (i_am_the_record_owner(r->rec_type)) {
  ------------------
  |  Branch (151:9): [True: 432, False: 0]
  ------------------
  152|    432|      r->sync_required = r->sync_required | REC_PEER_SYNC_REQUIRED;
  ------------------
  |  |   49|    432|#define REC_PEER_SYNC_REQUIRED (REC_DISK_SYNC_REQUIRED << 1)
  |  |  ------------------
  |  |  |  |   48|    432|#define REC_DISK_SYNC_REQUIRED 1
  |  |  ------------------
  ------------------
  153|    432|    }
  154|    432|    return REC_ERR_OKAY;
  155|    432|  }
  156|       |
  157|      0|  return REC_ERR_FAIL;
  158|    432|}
P_RecCore.cc:_ZN12_GLOBAL__N_121RecRegisterConfigImplINS_10rec_detail8FloatTagEEE7RecErrT4RecTPKcNT_4typeE10RecUpdateT9RecCheckTS6_10RecSourceT10RecAccessT:
  131|      7|{
  132|      7|  ink_assert((rec_type == RECT_CONFIG) || (rec_type == RECT_LOCAL));
  ------------------
  |  |   45|      7|#define ink_assert(EX) (void)(EX)
  |  |  ------------------
  |  |  |  Branch (45:31): [True: 7, False: 0]
  |  |  |  Branch (45:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  133|       |
  134|      7|  RecData my_data_default;
  135|       |
  136|       |  if constexpr (std::is_same_v<Tag, rec_detail::IntTag>) {
  137|       |    my_data_default.rec_int = data_default;
  138|       |  } else if constexpr (std::is_same_v<Tag, rec_detail::CounterTag>) {
  139|       |    my_data_default.rec_counter = data_default;
  140|      7|  } else if constexpr (std::is_same_v<Tag, rec_detail::FloatTag>) {
  141|      7|    my_data_default.rec_float = data_default;
  142|       |  } else if constexpr (std::is_same_v<Tag, rec_detail::StringTag>) {
  143|       |    my_data_default.rec_string = data_default;
  144|       |  } else {
  145|       |    static_assert(always_false<Tag>::value, "Unsupported tag for RecRegisterConfig");
  146|       |  }
  147|       |
  148|      7|  if (RecRecord *r = RecRegisterConfig(rec_type, name, Tag::data_type, my_data_default, update_type, check_type, check_regex,
  149|      7|                                       source, access_type);
  150|      7|      r != nullptr) {
  ------------------
  |  Branch (150:7): [True: 7, False: 0]
  ------------------
  151|      7|    if (i_am_the_record_owner(r->rec_type)) {
  ------------------
  |  Branch (151:9): [True: 7, False: 0]
  ------------------
  152|      7|      r->sync_required = r->sync_required | REC_PEER_SYNC_REQUIRED;
  ------------------
  |  |   49|      7|#define REC_PEER_SYNC_REQUIRED (REC_DISK_SYNC_REQUIRED << 1)
  |  |  ------------------
  |  |  |  |   48|      7|#define REC_DISK_SYNC_REQUIRED 1
  |  |  ------------------
  ------------------
  153|      7|    }
  154|      7|    return REC_ERR_OKAY;
  155|      7|  }
  156|       |
  157|      0|  return REC_ERR_FAIL;
  158|      7|}
P_RecCore.cc:_ZN12_GLOBAL__N_121RecRegisterConfigImplINS_10rec_detail9StringTagEEE7RecErrT4RecTPKcNT_4typeE10RecUpdateT9RecCheckTS6_10RecSourceT10RecAccessT:
  131|    120|{
  132|    120|  ink_assert((rec_type == RECT_CONFIG) || (rec_type == RECT_LOCAL));
  ------------------
  |  |   45|    122|#define ink_assert(EX) (void)(EX)
  |  |  ------------------
  |  |  |  Branch (45:31): [True: 118, False: 2]
  |  |  |  Branch (45:31): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  133|       |
  134|    120|  RecData my_data_default;
  135|       |
  136|       |  if constexpr (std::is_same_v<Tag, rec_detail::IntTag>) {
  137|       |    my_data_default.rec_int = data_default;
  138|       |  } else if constexpr (std::is_same_v<Tag, rec_detail::CounterTag>) {
  139|       |    my_data_default.rec_counter = data_default;
  140|       |  } else if constexpr (std::is_same_v<Tag, rec_detail::FloatTag>) {
  141|       |    my_data_default.rec_float = data_default;
  142|    120|  } else if constexpr (std::is_same_v<Tag, rec_detail::StringTag>) {
  143|    120|    my_data_default.rec_string = data_default;
  144|       |  } else {
  145|       |    static_assert(always_false<Tag>::value, "Unsupported tag for RecRegisterConfig");
  146|       |  }
  147|       |
  148|    120|  if (RecRecord *r = RecRegisterConfig(rec_type, name, Tag::data_type, my_data_default, update_type, check_type, check_regex,
  149|    120|                                       source, access_type);
  150|    120|      r != nullptr) {
  ------------------
  |  Branch (150:7): [True: 120, False: 0]
  ------------------
  151|    120|    if (i_am_the_record_owner(r->rec_type)) {
  ------------------
  |  Branch (151:9): [True: 120, False: 0]
  ------------------
  152|    120|      r->sync_required = r->sync_required | REC_PEER_SYNC_REQUIRED;
  ------------------
  |  |   49|    120|#define REC_PEER_SYNC_REQUIRED (REC_DISK_SYNC_REQUIRED << 1)
  |  |  ------------------
  |  |  |  |   48|    120|#define REC_DISK_SYNC_REQUIRED 1
  |  |  ------------------
  ------------------
  153|    120|    }
  154|    120|    return REC_ERR_OKAY;
  155|    120|  }
  156|       |
  157|      0|  return REC_ERR_FAIL;
  158|    120|}

_ZN21RecConfigUpdateCbListC2ERKNSt3__18functionIFiPKc8RecDataT7RecDataPvEEES6_:
   56|      8|    : update_cb(update_cb), update_cookie(update_cookie)
   57|      8|  {
   58|      8|  }

_Z17RecConfigFileInitv:
   51|      1|{
   52|      1|  ink_mutex_init(&g_rec_config_lock);
   53|      1|}
_Z32RecConfigOverrideFromEnvironmentPKcS0_:
  102|    559|{
  103|    559|  ats_scoped_str envname(ats_strdup(name));
  ------------------
  |  |  134|    559|#define ats_strdup(p) _xstrdup((p), -1, nullptr)
  ------------------
  104|    559|  const char    *envval = nullptr;
  105|       |
  106|       |  // Munge foo.bar.config into FOO_BAR_CONFIG.
  107|  22.2k|  for (char *c = envname; *c != '\0'; ++c) {
  ------------------
  |  Branch (107:27): [True: 21.6k, False: 559]
  ------------------
  108|  21.6k|    switch (*c) {
  109|  1.92k|    case '.':
  ------------------
  |  Branch (109:5): [True: 1.92k, False: 19.7k]
  ------------------
  110|  1.92k|      *c = '_';
  111|  1.92k|      break;
  112|  19.7k|    default:
  ------------------
  |  Branch (112:5): [True: 19.7k, False: 1.92k]
  ------------------
  113|  19.7k|      *c = ParseRules::ink_toupper(*c);
  114|  19.7k|      break;
  115|  21.6k|    }
  116|  21.6k|  }
  117|       |
  118|    559|  envval = getenv(envname.get());
  119|    559|  if (envval) {
  ------------------
  |  Branch (119:7): [True: 0, False: 559]
  ------------------
  120|      0|    return {envval, RecConfigOverrideSource::ENV};
  121|      0|  }
  122|       |
  123|    559|  if (!get_runroot().empty()) {
  ------------------
  |  Branch (123:7): [True: 0, False: 559]
  ------------------
  124|      0|    for (auto const &[rec_name, member] : runroot_records) {
  ------------------
  |  Branch (124:41): [True: 0, False: 0]
  ------------------
  125|      0|      if (rec_name == name) {
  ------------------
  |  Branch (125:11): [True: 0, False: 0]
  ------------------
  126|      0|        return {Layout::get()->*member, RecConfigOverrideSource::RUNROOT};
  127|      0|      }
  128|      0|    }
  129|      0|  }
  130|       |
  131|    559|  return {value ? value : "", RecConfigOverrideSource::NONE};
  ------------------
  |  Branch (131:11): [True: 526, False: 33]
  ------------------
  132|    559|}

_Z11RecCoreInitP5Diags:
  202|      1|{
  203|      1|  if (g_initialized) {
  ------------------
  |  Branch (203:7): [True: 0, False: 1]
  ------------------
  204|      0|    return REC_ERR_OKAY;
  205|      0|  }
  206|       |
  207|       |  // set our diags
  208|      1|  RecSetDiags(_diags);
  209|       |
  210|       |  // Initialize config file parsing data structures.
  211|      1|  RecConfigFileInit();
  212|       |
  213|      1|  g_num_records = 0;
  214|       |
  215|       |  // initialize record array for our internal stats (this can be reallocated later)
  216|      1|  g_records = static_cast<RecRecord *>(ats_malloc(max_records_entries * sizeof(RecRecord)));
  217|       |
  218|       |  // initialize record rwlock
  219|      1|  ink_rwlock_init(&g_records_rwlock);
  220|       |
  221|       |  // read stats
  222|      1|  RecReadStatsFile();
  223|       |
  224|       |  // read configs
  225|      1|  bool file_exists = true;
  226|       |
  227|      1|  ink_mutex_init(&g_rec_config_lock);
  228|       |
  229|      1|  g_rec_config_fpath = ats_stringdup(RecConfigReadConfigPath(nullptr, ts::filename::RECORDS));
  230|       |
  231|       |  // Make sure there is no legacy file, if so we drop a BIG WARNING and fail.
  232|       |  // This is to avoid issues with someone ignoring that we now use records.yaml
  233|      1|  swoc::file::path old_config{RecConfigReadConfigPath(nullptr, "records.config")};
  234|      1|  if (swoc::file::is_readable(old_config)) {
  ------------------
  |  Branch (234:7): [True: 0, False: 1]
  ------------------
  235|      0|    RecLog(DL_Fatal,
  ------------------
  |  |   77|      0|#define RecLog(level, fmt, ...)   _RecLog(level, MakeSourceLocation(), fmt, ##__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   32|      0|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  ------------------
  236|      0|           "**** Found a legacy config file (%s). Please remove it and migrate to the new YAML format before continuing. ****",
  237|      0|           old_config.c_str());
  238|      0|  }
  239|       |
  240|      1|  if (RecFileExists(g_rec_config_fpath) == REC_ERR_FAIL) {
  ------------------
  |  Branch (240:7): [True: 1, False: 0]
  ------------------
  241|      1|    RecLog(DL_Warning, "Could not find '%s', system will run with defaults\n", ts::filename::RECORDS);
  ------------------
  |  |   77|      1|#define RecLog(level, fmt, ...)   _RecLog(level, MakeSourceLocation(), fmt, ##__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   32|      1|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  ------------------
  242|      1|    file_exists = false;
  243|      1|  }
  244|       |
  245|      1|  if (file_exists) {
  ------------------
  |  Branch (245:7): [True: 0, False: 1]
  ------------------
  246|      0|    auto err = RecReadYamlConfigFile();
  247|      0|    RecLog(DL_Note, "records parsing completed.");
  ------------------
  |  |   77|      0|#define RecLog(level, fmt, ...)   _RecLog(level, MakeSourceLocation(), fmt, ##__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   32|      0|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  ------------------
  248|      0|    if (!err.empty()) {
  ------------------
  |  Branch (248:9): [True: 0, False: 0]
  ------------------
  249|      0|      std::string text;
  250|      0|      RecLog(DL_Warning, "%s",
  ------------------
  |  |   77|      0|#define RecLog(level, fmt, ...)   _RecLog(level, MakeSourceLocation(), fmt, ##__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   32|      0|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  ------------------
  251|      0|             swoc::bwprint(text, "We have found the following issues when reading the records node:\n {}", err).c_str());
  252|      0|    }
  253|      1|  } else {
  254|      1|    RecLog(DL_Note, "%s does not exist.", g_rec_config_fpath);
  ------------------
  |  |   77|      1|#define RecLog(level, fmt, ...)   _RecLog(level, MakeSourceLocation(), fmt, ##__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   32|      1|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  ------------------
  255|      1|  }
  256|       |
  257|      1|  RecLog(DL_Note, "%s finished loading", std::string{g_rec_config_fpath}.c_str());
  ------------------
  |  |   77|      1|#define RecLog(level, fmt, ...)   _RecLog(level, MakeSourceLocation(), fmt, ##__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   32|      1|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  ------------------
  258|      1|  g_initialized = true;
  259|       |
  260|      1|  return REC_ERR_OKAY;
  261|      1|}
_Z18RecLinkConfigInt32PKcPi:
  279|      3|{
  280|      3|  return RecRegisterConfigUpdateCb(name, link_int32, (void *)p_int32);
  281|      3|}
_Z19RecLinkConfigUInt32PKcPj:
  285|      5|{
  286|      5|  return RecRegisterConfigUpdateCb(name, link_uint32, (void *)p_uint32);
  287|      5|}
_Z25RecRegisterConfigUpdateCbPKcRKNSt3__18functionIFiS0_8RecDataT7RecDataPvEEES5_:
  340|      8|{
  341|      8|  RecErrT err = REC_ERR_FAIL;
  342|       |
  343|      8|  ink_rwlock_rdlock(&g_records_rwlock);
  344|       |
  345|      8|  if (auto it = g_records_ht.find(name); it != g_records_ht.end()) {
  ------------------
  |  Branch (345:42): [True: 8, False: 0]
  ------------------
  346|      8|    RecRecord *r = it->second;
  347|       |
  348|      8|    rec_mutex_acquire(&(r->lock));
  349|      8|    if (REC_TYPE_IS_CONFIG(r->rec_type)) {
  ------------------
  |  |   37|      8|#define REC_TYPE_IS_CONFIG(rec_type) (((rec_type) == RECT_CONFIG) || ((rec_type) == RECT_LOCAL))
  |  |  ------------------
  |  |  |  Branch (37:39): [True: 8, False: 0]
  |  |  |  Branch (37:70): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  350|       |      /* -- upgrade to support a list of callback functions
  351|       |         if (!(r->config_meta.update_cb)) {
  352|       |         r->config_meta.update_cb = update_cb;
  353|       |         r->config_meta.update_cookie = cookie;
  354|       |         err = REC_ERR_OKAY;
  355|       |         }
  356|       |       */
  357|       |
  358|      8|      RecConfigUpdateCbList *new_callback = new RecConfigUpdateCbList(update_cb, cookie);
  359|      8|      ink_assert(new_callback);
  ------------------
  |  |   45|      8|#define ink_assert(EX) (void)(EX)
  ------------------
  360|      8|      if (!r->config_meta.update_cb_list) {
  ------------------
  |  Branch (360:11): [True: 8, False: 0]
  ------------------
  361|      8|        r->config_meta.update_cb_list = new_callback;
  362|      8|      } else {
  363|      0|        RecConfigUpdateCbList *cur_callback  = nullptr;
  364|      0|        RecConfigUpdateCbList *prev_callback = nullptr;
  365|      0|        for (cur_callback = r->config_meta.update_cb_list; cur_callback; cur_callback = cur_callback->next) {
  ------------------
  |  Branch (365:60): [True: 0, False: 0]
  ------------------
  366|      0|          prev_callback = cur_callback;
  367|      0|        }
  368|      0|        ink_assert(prev_callback);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  369|      0|        ink_assert(!prev_callback->next);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  370|      0|        prev_callback->next = new_callback;
  371|      0|      }
  372|      8|      err = REC_ERR_OKAY;
  373|      8|    }
  374|       |
  375|      8|    rec_mutex_release(&(r->lock));
  376|      8|  }
  377|       |
  378|      8|  ink_rwlock_unlock(&g_records_rwlock);
  379|       |
  380|      8|  return err;
  381|      8|}
_Z15RecGetRecordIntPKcb:
  419|     10|{
  420|     10|  RecData               data;
  421|     10|  std::optional<RecInt> rec_int;
  422|       |
  423|     10|  if (RecGetRecord_Xmalloc(name, RECD_INT, &data, lock) == REC_ERR_OKAY) {
  ------------------
  |  Branch (423:7): [True: 10, False: 0]
  ------------------
  424|     10|    rec_int = data.rec_int;
  425|     10|  }
  426|     10|  return rec_int;
  427|     10|}
_Z18RecGetRecordStringPKcPcib:
  443|      1|{
  444|      1|  std::optional<std::string_view> ret;
  445|       |
  446|      1|  if (lock) {
  ------------------
  |  Branch (446:7): [True: 1, False: 0]
  ------------------
  447|      1|    ink_rwlock_rdlock(&g_records_rwlock);
  448|      1|  }
  449|      1|  if (auto it = g_records_ht.find(name); it != g_records_ht.end()) {
  ------------------
  |  Branch (449:42): [True: 0, False: 1]
  ------------------
  450|      0|    RecRecord *r = it->second;
  451|       |
  452|      0|    rec_mutex_acquire(&(r->lock));
  453|      0|    if (r->registered && r->data_type == RECD_STRING) {
  ------------------
  |  Branch (453:9): [True: 0, False: 0]
  |  Branch (453:26): [True: 0, False: 0]
  ------------------
  454|      0|      if (r->data.rec_string == nullptr) {
  ------------------
  |  Branch (454:11): [True: 0, False: 0]
  ------------------
  455|      0|        buf[0] = '\0';
  456|      0|      } else {
  457|      0|        ink_strlcpy(buf, r->data.rec_string, buf_len);
  ------------------
  |  |   62|      0|#define ink_strlcpy strlcpy
  ------------------
  458|      0|      }
  459|      0|      ret = std::string_view{buf};
  460|      0|    }
  461|      0|    rec_mutex_release(&(r->lock));
  462|      0|  }
  463|      1|  if (lock) {
  ------------------
  |  Branch (463:7): [True: 1, False: 0]
  ------------------
  464|      1|    ink_rwlock_unlock(&g_records_rwlock);
  465|      1|  }
  466|      1|  return ret;
  467|      1|}
_Z23RecGetRecordStringAllocPKcb:
  471|      1|{
  472|       |  // Must use this indirection because the API requires a pure function, therefore no values can
  473|       |  // be bound in the lambda.
  474|      1|  using Context = std::optional<std::string>;
  475|      1|  Context ret{};
  476|       |
  477|      1|  RecLookupRecord(
  478|      1|    name,
  479|      1|    [](RecRecord const *r, void *ctx) -> void {
  480|      1|      auto &&str = *static_cast<Context *>(ctx);
  481|      1|      if (r->registered && r->data_type == RECD_STRING) {
  482|      1|        if (auto rec_str{r->data.rec_string}; rec_str) {
  483|      1|          auto len{strlen(rec_str)};
  484|      1|          if (len) {
  485|       |            // Chop trailing spaces
  486|      1|            auto end{rec_str + len - 1};
  487|      1|            while (end >= rec_str && isspace(*end)) {
  488|      1|              end--;
  489|      1|            }
  490|      1|            len = static_cast<std::string::size_type>(end + 1 - rec_str);
  491|      1|          }
  492|      1|          str = len ? std::string{rec_str, len} : std::string{};
  493|      1|        }
  494|      1|      }
  495|      1|    },
  496|      1|    &ret, lock);
  497|      1|  return ret;
  498|      1|}
_Z15RecLookupRecordPKcPFvPK9RecRecordPvES4_b:
  518|      1|{
  519|      1|  RecErrT      err     = REC_ERR_FAIL;
  520|      1|  ts::Metrics &metrics = ts::Metrics::instance();
  521|      1|  auto         it      = metrics.find(name);
  522|       |
  523|      1|  if (it != metrics.end()) {
  ------------------
  |  Branch (523:7): [True: 0, False: 1]
  ------------------
  524|      0|    RecRecord r;
  525|      0|    auto &&[name, type, val] = *it;
  526|       |
  527|      0|    r.rec_type     = RECT_PLUGIN;
  528|      0|    r.data_type    = type == ts::Metrics::MetricType::COUNTER ? RECD_COUNTER : RECD_INT;
  ------------------
  |  Branch (528:22): [True: 0, False: 0]
  ------------------
  529|      0|    r.name         = name.data();
  530|      0|    r.data.rec_int = val;
  531|       |
  532|      0|    callback(&r, data);
  533|      0|    err = REC_ERR_OKAY;
  534|      1|  } else {
  535|      1|    if (lock) {
  ------------------
  |  Branch (535:9): [True: 1, False: 0]
  ------------------
  536|      1|      ink_rwlock_rdlock(&g_records_rwlock);
  537|      1|    }
  538|       |
  539|      1|    if (auto it = g_records_ht.find(name); it != g_records_ht.end()) {
  ------------------
  |  Branch (539:44): [True: 1, False: 0]
  ------------------
  540|      1|      RecRecord *r = it->second;
  541|       |
  542|      1|      rec_mutex_acquire(&(r->lock));
  543|      1|      callback(r, data);
  544|      1|      err = REC_ERR_OKAY;
  545|      1|      rec_mutex_release(&(r->lock));
  546|      1|    }
  547|       |
  548|      1|    if (lock) {
  ------------------
  |  Branch (548:9): [True: 1, False: 0]
  ------------------
  549|      1|      ink_rwlock_unlock(&g_records_rwlock);
  550|      1|    }
  551|       |
  552|       |    // Also check for StaticString metrics
  553|      1|    if (err == REC_ERR_FAIL) {
  ------------------
  |  Branch (553:9): [True: 0, False: 1]
  ------------------
  554|      0|      auto &strings = ts::Metrics::StaticString::instance();
  555|       |
  556|      0|      if (auto m = strings.lookup(std::string{name}); m) {
  ------------------
  |  Branch (556:55): [True: 0, False: 0]
  ------------------
  557|      0|        RecRecord r;
  558|      0|        r.rec_type                = RECT_PLUGIN;
  559|      0|        r.data_type               = RECD_STRING;
  560|      0|        r.name                    = name;
  561|      0|        r.data.rec_string         = const_cast<char *>(m->data());
  562|      0|        r.data_default.rec_string = const_cast<char *>(m->data());
  563|       |
  564|      0|        callback(&r, data);
  565|      0|        err = REC_ERR_OKAY;
  566|      0|      }
  567|      0|    }
  568|      1|  }
  569|       |
  570|      1|  return err;
  571|      1|}
_Z17RecRegisterConfig4RecTPKc8RecDataT7RecData10RecUpdateT9RecCheckTS1_10RecSourceT10RecAccessT:
  779|    559|{
  780|    559|  RecRecord *r;
  781|    559|  bool       updated_p;
  782|       |
  783|    559|  ink_rwlock_wrlock(&g_records_rwlock);
  784|    559|  if ((r = register_record(rec_type, name, data_type, data_default, RECP_NULL, &updated_p)) != nullptr) {
  ------------------
  |  Branch (784:7): [True: 559, False: 0]
  ------------------
  785|       |    // Note: do not modify 'record->config_meta.update_required'
  786|    559|    r->config_meta.update_type = update_type;
  787|    559|    r->config_meta.check_type  = check_type;
  788|       |
  789|    559|    ats_free(r->config_meta.check_expr);
  790|       |
  791|    559|    r->config_meta.check_expr     = ats_strdup(check_expr);
  ------------------
  |  |  134|    559|#define ats_strdup(p) _xstrdup((p), -1, nullptr)
  ------------------
  792|    559|    r->config_meta.update_cb_list = nullptr;
  793|    559|    r->config_meta.access_type    = access_type;
  794|    559|    if (!updated_p) {
  ------------------
  |  Branch (794:9): [True: 559, False: 0]
  ------------------
  795|    559|      r->config_meta.source = source;
  796|    559|    }
  797|    559|  }
  798|    559|  ink_rwlock_unlock(&g_records_rwlock);
  799|       |
  800|    559|  return r;
  801|    559|}
_Z20RecGetRecord_XmallocPKc8RecDataTP7RecDatab:
  808|     10|{
  809|     10|  RecErrT err = REC_ERR_OKAY;
  810|       |
  811|     10|  if (lock) {
  ------------------
  |  Branch (811:7): [True: 9, False: 1]
  ------------------
  812|      9|    ink_rwlock_rdlock(&g_records_rwlock);
  813|      9|  }
  814|       |
  815|     10|  if (auto it = g_records_ht.find(name); it != g_records_ht.end()) {
  ------------------
  |  Branch (815:42): [True: 10, False: 0]
  ------------------
  816|     10|    RecRecord *r = it->second;
  817|       |
  818|     10|    rec_mutex_acquire(&(r->lock));
  819|     10|    if (!r->registered || (r->data_type != data_type)) {
  ------------------
  |  Branch (819:9): [True: 0, False: 10]
  |  Branch (819:27): [True: 0, False: 10]
  ------------------
  820|      0|      err = REC_ERR_FAIL;
  821|     10|    } else {
  822|       |      // Clear the caller's record just in case it has trash in it.
  823|       |      // Passing trashy records to RecDataSet will cause confusion.
  824|     10|      memset(data, 0, sizeof(RecData));
  825|     10|      RecDataSet(data_type, data, &(r->data));
  826|     10|    }
  827|     10|    rec_mutex_release(&(r->lock));
  828|     10|  } else {
  829|      0|    err = REC_ERR_FAIL;
  830|      0|  }
  831|       |
  832|     10|  if (lock) {
  ------------------
  |  Branch (832:7): [True: 9, False: 1]
  ------------------
  833|      9|    ink_rwlock_unlock(&g_records_rwlock);
  834|      9|  }
  835|       |
  836|     10|  return err;
  837|     10|}
_Z22RecConfigReadConfigDirv:
  964|      2|{
  965|      2|  if (const char *env = getenv("PROXY_CONFIG_CONFIG_DIR")) {
  ------------------
  |  Branch (965:19): [True: 0, False: 2]
  ------------------
  966|      0|    return Layout::get()->relative(env);
  967|      2|  } else {
  968|      2|    return Layout::get()->sysconfdir;
  969|      2|  }
  970|      2|}
_Z23RecConfigReadRuntimeDirv:
  977|      1|{
  978|      1|  char buf[PATH_NAME_MAX];
  979|       |
  980|      1|  buf[0] = '\0';
  981|      1|  RecGetRecordString("proxy.config.local_state_dir", buf, PATH_NAME_MAX);
  ------------------
  |  |  137|      1|  4096 // instead of PATH_MAX which is inconsistent
  ------------------
  982|      1|  if (strlen(buf) > 0) {
  ------------------
  |  Branch (982:7): [True: 0, False: 1]
  ------------------
  983|      0|    return Layout::get()->relative(buf);
  984|      1|  } else {
  985|      1|    return Layout::get()->runtimedir;
  986|      1|  }
  987|      1|}
_Z23RecConfigReadConfigPathPKcS0_:
 1045|      2|{
 1046|      2|  std::string sysconfdir(RecConfigReadConfigDir());
 1047|       |
 1048|       |  // If the file name is in a configuration variable, look it up first ...
 1049|      2|  if (file_variable) {
  ------------------
  |  Branch (1049:7): [True: 0, False: 2]
  ------------------
 1050|      0|    char buf[PATH_NAME_MAX];
 1051|       |
 1052|      0|    buf[0] = '\0';
 1053|      0|    RecGetRecordString(file_variable, buf, PATH_NAME_MAX);
  ------------------
  |  |  137|      0|  4096 // instead of PATH_MAX which is inconsistent
  ------------------
 1054|      0|    if (strlen(buf) > 0) {
  ------------------
  |  Branch (1054:9): [True: 0, False: 0]
  ------------------
 1055|      0|      return Layout::get()->relative_to(sysconfdir, buf);
 1056|      0|    }
 1057|      0|  }
 1058|       |
 1059|       |  // Otherwise take the default ...
 1060|      2|  if (default_value) {
  ------------------
  |  Branch (1060:7): [True: 2, False: 0]
  ------------------
 1061|      2|    return Layout::get()->relative_to(sysconfdir, default_value);
 1062|      2|  }
 1063|       |
 1064|      0|  return {};
 1065|      2|}
_Z32RecConfigReadPersistentStatsPathv:
 1072|      1|{
 1073|      1|  std::string rundir(RecConfigReadRuntimeDir());
 1074|      1|  return Layout::relative_to(rundir, ts::filename::RECORDS_STATS);
 1075|      1|}
_Z21i_am_the_record_owner4RecT:
 1103|    559|{
 1104|    559|  switch (rec_type) {
 1105|    556|  case RECT_CONFIG:
  ------------------
  |  Branch (1105:3): [True: 556, False: 3]
  ------------------
 1106|    556|  case RECT_PROCESS:
  ------------------
  |  Branch (1106:3): [True: 0, False: 559]
  ------------------
 1107|    556|  case RECT_NODE:
  ------------------
  |  Branch (1107:3): [True: 0, False: 559]
  ------------------
 1108|    559|  case RECT_LOCAL:
  ------------------
  |  Branch (1108:3): [True: 3, False: 556]
  ------------------
 1109|    559|  case RECT_PLUGIN:
  ------------------
  |  Branch (1109:3): [True: 0, False: 559]
  ------------------
 1110|    559|    return true;
 1111|      0|  default:
  ------------------
  |  Branch (1111:3): [True: 0, False: 559]
  ------------------
 1112|      0|    ink_assert(!"Unexpected RecT type");
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
 1113|      0|    return false;
 1114|    559|  }
 1115|       |
 1116|      0|  return false;
 1117|    559|}
RecCore.cc:_ZZ23RecGetRecordStringAllocPKcbENK3$_0clEPK9RecRecordPv:
  479|      1|    [](RecRecord const *r, void *ctx) -> void {
  480|      1|      auto &&str = *static_cast<Context *>(ctx);
  481|      1|      if (r->registered && r->data_type == RECD_STRING) {
  ------------------
  |  Branch (481:11): [True: 1, False: 0]
  |  Branch (481:28): [True: 1, False: 0]
  ------------------
  482|      1|        if (auto rec_str{r->data.rec_string}; rec_str) {
  ------------------
  |  Branch (482:47): [True: 0, False: 1]
  ------------------
  483|      0|          auto len{strlen(rec_str)};
  484|      0|          if (len) {
  ------------------
  |  Branch (484:15): [True: 0, False: 0]
  ------------------
  485|       |            // Chop trailing spaces
  486|      0|            auto end{rec_str + len - 1};
  487|      0|            while (end >= rec_str && isspace(*end)) {
  ------------------
  |  Branch (487:20): [True: 0, False: 0]
  |  Branch (487:38): [True: 0, False: 0]
  ------------------
  488|      0|              end--;
  489|      0|            }
  490|      0|            len = static_cast<std::string::size_type>(end + 1 - rec_str);
  491|      0|          }
  492|      0|          str = len ? std::string{rec_str, len} : std::string{};
  ------------------
  |  Branch (492:17): [True: 0, False: 0]
  ------------------
  493|      0|        }
  494|      1|      }
  495|      1|    },
RecCore.cc:_ZL15register_record4RecTPKc8RecDataT7RecData11RecPersistTPb:
   62|    559|{
   63|    559|  RecRecord *r = nullptr;
   64|       |
   65|       |  // Metrics are restored from persistence before they are registered. In this case, when the registration arrives, we
   66|       |  // might find that they have changed. For example, a metric might change it's type due to a software upgrade. Records
   67|       |  // must not flip between config and metrics, but changing within those classes is OK.
   68|    559|  if (auto it = g_records_ht.find(name); it != g_records_ht.end()) {
  ------------------
  |  Branch (68:42): [True: 0, False: 559]
  ------------------
   69|      0|    r = it->second;
   70|      0|    if (REC_TYPE_IS_STAT(rec_type)) {
  ------------------
  |  |   35|      0|#define REC_TYPE_IS_STAT(rec_type) (((rec_type) == RECT_PROCESS) || ((rec_type) == RECT_PLUGIN) || ((rec_type) == RECT_NODE))
  |  |  ------------------
  |  |  |  Branch (35:37): [True: 0, False: 0]
  |  |  |  Branch (35:69): [True: 0, False: 0]
  |  |  |  Branch (35:100): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   71|      0|      ink_release_assert(REC_TYPE_IS_STAT(r->rec_type));
  ------------------
  |  |   48|      0|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 0, False: 0]
  |  |  |  Branch (48:60): [True: 0, False: 0]
  |  |  |  Branch (48:60): [True: 0, False: 0]
  |  |  |  Branch (48:60): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   72|      0|    }
   73|       |
   74|      0|    if (REC_TYPE_IS_CONFIG(rec_type)) {
  ------------------
  |  |   37|      0|#define REC_TYPE_IS_CONFIG(rec_type) (((rec_type) == RECT_CONFIG) || ((rec_type) == RECT_LOCAL))
  |  |  ------------------
  |  |  |  Branch (37:39): [True: 0, False: 0]
  |  |  |  Branch (37:70): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   75|      0|      ink_release_assert(REC_TYPE_IS_CONFIG(r->rec_type));
  ------------------
  |  |   48|      0|#define ink_release_assert(EX) ((void)(__builtin_expect(!!(EX), 0) ? (void)0 : _ink_assert(#EX, __FILE__, __LINE__)))
  |  |  ------------------
  |  |  |  Branch (48:40): [True: 0, False: 0]
  |  |  |  Branch (48:60): [True: 0, False: 0]
  |  |  |  Branch (48:60): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   76|      0|    }
   77|       |
   78|      0|    if (data_type != r->data_type) {
  ------------------
  |  Branch (78:9): [True: 0, False: 0]
  ------------------
   79|       |      // Clear with the old type before resetting with the new type.
   80|      0|      RecDataZero(r->data_type, &(r->data));
   81|      0|      RecDataZero(r->data_type, &(r->data_default));
   82|       |
   83|       |      // If the data type changed, reset the current value to the default.
   84|      0|      RecDataSet(data_type, &(r->data), &(data_default));
   85|      0|    }
   86|       |
   87|       |    // NOTE: Do not set r->data as we want to keep the previous value because we almost certainly restored a persisted
   88|       |    // value before the metric was registered.
   89|      0|    RecDataSet(data_type, &(r->data_default), &(data_default));
   90|       |
   91|      0|    r->data_type = data_type;
   92|      0|    r->rec_type  = rec_type;
   93|       |
   94|      0|    if (updated_p) {
  ------------------
  |  Branch (94:9): [True: 0, False: 0]
  ------------------
   95|      0|      *updated_p = true;
   96|      0|    }
   97|    559|  } else {
   98|    559|    if ((r = RecAlloc(rec_type, name, data_type)) == nullptr) {
  ------------------
  |  Branch (98:9): [True: 0, False: 559]
  ------------------
   99|      0|      return nullptr;
  100|      0|    }
  101|       |
  102|       |    // Set the r->data to its default value as this is a new record
  103|    559|    RecDataSet(r->data_type, &(r->data), &(data_default));
  104|    559|    RecDataSet(r->data_type, &(r->data_default), &(data_default));
  105|    559|    g_records_ht.emplace(name, r);
  106|       |
  107|    559|    if (REC_TYPE_IS_STAT(r->rec_type)) {
  ------------------
  |  |   35|    559|#define REC_TYPE_IS_STAT(rec_type) (((rec_type) == RECT_PROCESS) || ((rec_type) == RECT_PLUGIN) || ((rec_type) == RECT_NODE))
  |  |  ------------------
  |  |  |  Branch (35:37): [True: 0, False: 559]
  |  |  |  Branch (35:69): [True: 0, False: 559]
  |  |  |  Branch (35:100): [True: 0, False: 559]
  |  |  ------------------
  ------------------
  108|      0|      r->stat_meta.persist_type = persist_type;
  109|      0|    }
  110|       |
  111|    559|    if (updated_p) {
  ------------------
  |  Branch (111:9): [True: 559, False: 0]
  ------------------
  112|    559|      *updated_p = false;
  113|    559|    }
  114|    559|  }
  115|       |
  116|       |  // we're now registered
  117|    559|  r->registered = true;
  118|    559|  r->version    = 0;
  119|       |
  120|    559|  return r;
  121|    559|}

_Z11RecSetDiagsP5Diags:
   34|      1|{
   35|       |  // Warning! It's very dangerous to change diags on the fly!  This
   36|       |  // function only exists so that we can boot-strap TM on startup.
   37|      1|  ink_atomic_swap(&g_diags, _diags);
   38|      1|  return REC_ERR_OKAY;
   39|      1|}
_Z7_RecLog10DiagsLevelRK14SourceLocationPKcz:
   46|      3|{
   47|      3|  va_list ap;
   48|       |
   49|      3|  va_start(ap, fmt);
   50|      3|  if (g_diags) {
  ------------------
  |  Branch (50:7): [True: 0, False: 3]
  ------------------
   51|      0|    g_diags->error_va(dl, &loc, fmt, ap);
   52|      0|  }
   53|       |  va_end(ap);
   54|      3|}

_Z12RecFileOpenRPKc:
   38|      2|{
   39|      2|  RecHandle h_file;
   40|      2|  return ((h_file = ::open(file, O_RDONLY)) < 0) ? REC_HANDLE_INVALID : h_file;
  ------------------
  |  |   30|      2|#define REC_HANDLE_INVALID -1
  ------------------
  |  Branch (40:10): [True: 2, False: 0]
  ------------------
   41|      2|}
_Z13RecFileExistsPKc:
  161|      1|{
  162|      1|  RecHandle h_file;
  163|      1|  if ((h_file = RecFileOpenR(file)) == REC_HANDLE_INVALID) {
  ------------------
  |  |   30|      1|#define REC_HANDLE_INVALID -1
  ------------------
  |  Branch (163:7): [True: 1, False: 0]
  ------------------
  164|      1|    return REC_ERR_FAIL;
  165|      1|  }
  166|      0|  RecFileClose(h_file);
  167|      0|  return REC_ERR_OKAY;
  168|      1|}

_Z22RecMessageReadFromDiskPKc:
  249|      1|{
  250|      1|  RecMessageHdr msg_hdr;
  251|      1|  RecMessage   *msg = nullptr;
  252|      1|  RecHandle     h_file;
  253|      1|  int           bytes_read;
  254|       |
  255|      1|  if ((h_file = RecFileOpenR(fpath)) == REC_HANDLE_INVALID) {
  ------------------
  |  |   30|      1|#define REC_HANDLE_INVALID -1
  ------------------
  |  Branch (255:7): [True: 1, False: 0]
  ------------------
  256|      1|    goto Lerror;
  257|      1|  }
  258|      0|  if (RecFileRead(h_file, reinterpret_cast<char *>(&msg_hdr), sizeof(RecMessageHdr), &bytes_read) == REC_ERR_FAIL) {
  ------------------
  |  Branch (258:7): [True: 0, False: 0]
  ------------------
  259|      0|    goto Lerror;
  260|      0|  }
  261|      0|  msg = static_cast<RecMessage *>(ats_malloc((msg_hdr.o_end - msg_hdr.o_start) + sizeof(RecMessageHdr)));
  262|      0|  memcpy(msg, &msg_hdr, sizeof(RecMessageHdr));
  263|      0|  if (RecSnapFileRead(h_file, reinterpret_cast<char *>(msg) + msg_hdr.o_start, msg_hdr.o_end - msg_hdr.o_start, &bytes_read) ==
  ------------------
  |  Branch (263:7): [True: 0, False: 0]
  ------------------
  264|      0|      REC_ERR_FAIL) {
  265|      0|    goto Lerror;
  266|      0|  }
  267|       |
  268|      0|  goto Ldone;
  269|       |
  270|      1|Lerror:
  271|      1|  ats_free(msg);
  272|      1|  msg = nullptr;
  273|       |
  274|      1|Ldone:
  275|      1|  if (h_file != REC_HANDLE_INVALID) {
  ------------------
  |  |   30|      1|#define REC_HANDLE_INVALID -1
  ------------------
  |  Branch (275:7): [True: 0, False: 1]
  ------------------
  276|      0|    RecFileClose(h_file);
  277|      0|  }
  278|       |
  279|      1|  return msg;
  280|      1|}

_Z14rec_mutex_initP8RecMutexPKc:
   29|    559|{
   30|    559|  m->nthread_holding = 0;
   31|    559|  m->thread_holding  = ink_thread_null();
   32|    559|  ink_mutex_init(&(m->the_mutex));
   33|    559|}
_Z17rec_mutex_acquireP8RecMutex:
   45|     19|{
   46|     19|  ink_thread this_thread = ink_thread_self();
   47|       |
   48|     19|  if (!pthread_equal(m->thread_holding, this_thread)) {
  ------------------
  |  Branch (48:7): [True: 19, False: 0]
  ------------------
   49|     19|    ink_mutex_acquire(&(m->the_mutex));
   50|     19|    m->thread_holding = this_thread;
   51|     19|  }
   52|       |
   53|     19|  m->nthread_holding++;
   54|     19|}
_Z17rec_mutex_releaseP8RecMutex:
   58|     19|{
   59|     19|  if (m->nthread_holding != 0) {
  ------------------
  |  Branch (59:7): [True: 19, False: 0]
  ------------------
   60|     19|    m->nthread_holding--;
   61|     19|    if (m->nthread_holding == 0) {
  ------------------
  |  Branch (61:9): [True: 19, False: 0]
  ------------------
   62|     19|      m->thread_holding = ink_thread_null();
   63|     19|      ink_mutex_release(&(m->the_mutex));
   64|     19|    }
   65|     19|  }
   66|     19|}

_Z35SetRecAllocateRawStatBlockAllocatorPFP15RecRawStatBlockiE:
   40|      1|{
   41|      1|  raw_stat_block_allocator = f;
   42|      1|}
_Z21RecRegNewSyncStatSyncNSt3__18functionIFvvEEE:
  363|      1|{
  364|      1|  _newCbs.push_back(callback);
  365|      1|}

_Z13RecRecordInitP9RecRecord:
   40|    559|{
   41|    559|  ink_zero(*r);
   42|    559|  rec_mutex_init(&(r->lock), nullptr);
   43|    559|}
_Z8RecAlloc4RecTPKc8RecDataT:
   56|    559|{
   57|    559|  if (g_num_records >= max_records_entries) {
  ------------------
  |  Branch (57:7): [True: 0, False: 559]
  ------------------
   58|      0|    Fatal("Too many config records already registered (%d). Hint: increase --maxRecords param.", max_records_entries);
  ------------------
  |  |   90|      0|#define Fatal(...)     DiagsError(DL_Fatal, __VA_ARGS__)     // Log recoverable crash, fail CI, exit & allow restart
  |  |  ------------------
  |  |  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   59|      0|    return nullptr;
   60|      0|  }
   61|       |
   62|    559|  int        i = g_num_records++;
   63|    559|  RecRecord *r = &(g_records[i]);
   64|       |
   65|    559|  RecRecordInit(r);
   66|    559|  r->rec_type  = rec_type;
   67|    559|  r->name      = ats_strdup(name);
  ------------------
  |  |  134|    559|#define ats_strdup(p) _xstrdup((p), -1, nullptr)
  ------------------
   68|    559|  r->order     = i;
   69|    559|  r->data_type = data_type;
   70|       |
   71|    559|  return r;
   72|    559|}
_Z11RecDataZero8RecDataTP7RecData:
   79|    559|{
   80|    559|  if ((data_type == RECD_STRING) && (data->rec_string)) {
  ------------------
  |  Branch (80:7): [True: 120, False: 439]
  |  Branch (80:37): [True: 87, False: 33]
  ------------------
   81|     87|    ats_free(data->rec_string);
   82|     87|  }
   83|    559|  memset(data, 0, sizeof(RecData));
   84|    559|}
_Z10RecDataSet8RecDataTP7RecDataS1_:
  123|  1.68k|{
  124|  1.68k|  bool rec_set = false;
  125|       |
  126|  1.68k|  switch (data_type) {
  127|    360|  case RECD_STRING:
  ------------------
  |  Branch (127:3): [True: 360, False: 1.32k]
  ------------------
  128|    360|    if (data_src->rec_string == nullptr) {
  ------------------
  |  Branch (128:9): [True: 99, False: 261]
  ------------------
  129|     99|      if (data_dst->rec_string != nullptr) {
  ------------------
  |  Branch (129:11): [True: 0, False: 99]
  ------------------
  130|      0|        ats_free(data_dst->rec_string);
  131|      0|        data_dst->rec_string = nullptr;
  132|      0|        rec_set              = true;
  133|      0|      }
  134|    261|    } else if (((data_dst->rec_string) && (strcmp(data_dst->rec_string, data_src->rec_string) != 0)) ||
  ------------------
  |  Branch (134:17): [True: 0, False: 261]
  |  Branch (134:43): [True: 0, False: 0]
  ------------------
  135|    261|               ((data_dst->rec_string == nullptr) && (data_src->rec_string != nullptr))) {
  ------------------
  |  Branch (135:17): [True: 261, False: 0]
  |  Branch (135:54): [True: 261, False: 0]
  ------------------
  136|    261|      ats_free(data_dst->rec_string);
  137|       |
  138|    261|      data_dst->rec_string = ats_strdup(data_src->rec_string);
  ------------------
  |  |  134|    261|#define ats_strdup(p) _xstrdup((p), -1, nullptr)
  ------------------
  139|    261|      rec_set              = true;
  140|       |      // Chop trailing spaces
  141|    261|      char *end = data_dst->rec_string + strlen(data_dst->rec_string) - 1;
  142|       |
  143|    261|      while (end >= data_dst->rec_string && isspace(*end)) {
  ------------------
  |  Branch (143:14): [True: 234, False: 27]
  |  Branch (143:45): [True: 0, False: 234]
  ------------------
  144|      0|        end--;
  145|      0|      }
  146|    261|      *(end + 1) = '\0';
  147|    261|    }
  148|    360|    break;
  149|  1.30k|  case RECD_INT:
  ------------------
  |  Branch (149:3): [True: 1.30k, False: 381]
  ------------------
  150|  1.30k|    if (data_dst->rec_int != data_src->rec_int) {
  ------------------
  |  Branch (150:9): [True: 827, False: 479]
  ------------------
  151|    827|      data_dst->rec_int = data_src->rec_int;
  152|    827|      rec_set           = true;
  153|    827|    }
  154|  1.30k|    break;
  155|     21|  case RECD_FLOAT:
  ------------------
  |  Branch (155:3): [True: 21, False: 1.66k]
  ------------------
  156|     21|    if (data_dst->rec_float != data_src->rec_float) {
  ------------------
  |  Branch (156:9): [True: 18, False: 3]
  ------------------
  157|     18|      data_dst->rec_float = data_src->rec_float;
  158|     18|      rec_set             = true;
  159|     18|    }
  160|     21|    break;
  161|      0|  case RECD_COUNTER:
  ------------------
  |  Branch (161:3): [True: 0, False: 1.68k]
  ------------------
  162|      0|    if (data_dst->rec_counter != data_src->rec_counter) {
  ------------------
  |  Branch (162:9): [True: 0, False: 0]
  ------------------
  163|      0|      data_dst->rec_counter = data_src->rec_counter;
  164|      0|      rec_set               = true;
  165|      0|    }
  166|      0|    break;
  167|      0|  default:
  ------------------
  |  Branch (167:3): [True: 0, False: 1.68k]
  ------------------
  168|      0|    ink_assert(!"Wrong RECD type!");
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  169|  1.68k|  }
  170|  1.68k|  return rec_set;
  171|  1.68k|}
_Z20RecDataSetFromString8RecDataTP7RecDataPKc:
  353|    559|{
  354|    559|  RecData data_src;
  355|       |
  356|    559|  switch (data_type) {
  357|    432|  case RECD_INT:
  ------------------
  |  Branch (357:3): [True: 432, False: 127]
  ------------------
  358|    432|    data_src.rec_int = ink_atoi64(data_string);
  359|    432|    break;
  360|      7|  case RECD_FLOAT:
  ------------------
  |  Branch (360:3): [True: 7, False: 552]
  ------------------
  361|      7|    data_src.rec_float = atof(data_string);
  362|      7|    break;
  363|    120|  case RECD_STRING:
  ------------------
  |  Branch (363:3): [True: 120, False: 439]
  ------------------
  364|    120|    if (data_string && (strlen(data_string) == 4) && strncasecmp((data_string), "NULL", 4) == 0) {
  ------------------
  |  Branch (364:9): [True: 87, False: 33]
  |  Branch (364:24): [True: 7, False: 80]
  |  Branch (364:54): [True: 0, False: 7]
  ------------------
  365|      0|      data_src.rec_string = nullptr;
  366|    120|    } else {
  367|       |      // It's OK to cast away the const here, because RecDataSet will copy the string.
  368|    120|      data_src.rec_string = const_cast<char *>(data_string);
  369|    120|    }
  370|    120|    break;
  371|      0|  case RECD_COUNTER:
  ------------------
  |  Branch (371:3): [True: 0, False: 559]
  ------------------
  372|      0|    data_src.rec_counter = ink_atoi64(data_string);
  373|      0|    break;
  374|      0|  default:
  ------------------
  |  Branch (374:3): [True: 0, False: 559]
  ------------------
  375|      0|    ink_assert(!"Unexpected RecD type");
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  376|      0|    return false;
  377|    559|  }
  378|       |
  379|    559|  return RecDataSet(data_type, data_dst, &data_src);
  380|    559|}

_Z20RecordsConfigIteratePFvPK13RecordElementPvES2_:
 1719|      1|{
 1720|    560|  for (unsigned i = 0; i < countof(RecordsConfig); ++i) {
  ------------------
  |  Branch (1720:24): [True: 559, False: 1]
  ------------------
 1721|    559|    callback(&RecordsConfig[i], data);
 1722|    559|  }
 1723|      1|}

_Z20LibRecordsConfigInitv:
  128|      1|{
  129|      1|  RecordsConfigIterate(initialize_record, nullptr);
  130|      1|}
RecordsConfigUtils.cc:_ZL17initialize_recordPK13RecordElementPv:
   35|    559|{
   36|    559|  RecInt     tempInt     = 0;
   37|    559|  RecFloat   tempFloat   = 0.0;
   38|    559|  RecCounter tempCounter = 0;
   39|       |
   40|    559|  RecUpdateT update;
   41|    559|  RecCheckT  check;
   42|    559|  RecAccessT access;
   43|    559|  RecT       type;
   44|       |
   45|       |  // Less typing ...
   46|    559|  type   = record->type;
   47|    559|  update = record->update;
   48|    559|  check  = record->check;
   49|    559|  access = record->access;
   50|       |
   51|    559|  if (REC_TYPE_IS_CONFIG(type)) {
  ------------------
  |  |   37|    559|#define REC_TYPE_IS_CONFIG(rec_type) (((rec_type) == RECT_CONFIG) || ((rec_type) == RECT_LOCAL))
  |  |  ------------------
  |  |  |  Branch (37:39): [True: 556, False: 3]
  |  |  |  Branch (37:70): [True: 3, False: 0]
  |  |  ------------------
  ------------------
   52|    559|    auto [value, override_source] = RecConfigOverrideFromEnvironment(record->name, record->value);
   53|    559|    RecData    data               = {0};
   54|    559|    RecSourceT source             = (override_source == RecConfigOverrideSource::NONE) ? REC_SOURCE_DEFAULT : REC_SOURCE_ENV;
  ------------------
  |  Branch (54:37): [True: 559, False: 0]
  ------------------
   55|       |
   56|    559|    if (override_source != RecConfigOverrideSource::NONE) {
  ------------------
  |  Branch (56:9): [True: 0, False: 559]
  ------------------
   57|      0|      RecDebug(DL_Debug, "'%s' overridden with '%s' by %s", record->name, value.c_str(),
  ------------------
  |  |   78|      0|#define RecDebug(level, fmt, ...) _RecDebug(level, MakeSourceLocation(), fmt, ##__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   32|      0|#define MakeSourceLocation() SourceLocation(__FILE__, __FUNCTION__, __LINE__)
  |  |  ------------------
  ------------------
   58|      0|               RecConfigOverrideSourceName(override_source));
   59|      0|    }
   60|       |
   61|       |    // If you specify a consistency check, you have to specify a regex expression. We abort here
   62|       |    // so that this breaks QA completely.
   63|    559|    if (record->check != RECC_NULL && record->regex == nullptr) {
  ------------------
  |  Branch (63:9): [True: 291, False: 268]
  |  Branch (63:39): [True: 0, False: 291]
  ------------------
   64|      0|      ink_fatal("%s has a consistency check but no regular expression", record->name);
   65|      0|    }
   66|       |
   67|       |    // When the built-in default is nullptr and no override was applied, preserve
   68|       |    // nullptr so optional records (e.g. keylog_file, groups_list) stay unset.
   69|    559|    const char *value_ptr =
   70|    559|      (override_source == RecConfigOverrideSource::NONE && record->value == nullptr) ? nullptr : value.c_str();
  ------------------
  |  Branch (70:8): [True: 559, False: 0]
  |  Branch (70:60): [True: 33, False: 526]
  ------------------
   71|    559|    RecDataSetFromString(record->value_type, &data, value_ptr);
   72|    559|    RecErrT reg_status{REC_ERR_FAIL};
   73|    559|    switch (record->value_type) {
   74|    432|    case RECD_INT:
  ------------------
  |  Branch (74:5): [True: 432, False: 127]
  ------------------
   75|    432|      reg_status = RecRegisterConfigInt(type, record->name, data.rec_int, update, check, record->regex, source, access);
   76|    432|      break;
   77|       |
   78|      7|    case RECD_FLOAT:
  ------------------
  |  Branch (78:5): [True: 7, False: 552]
  ------------------
   79|      7|      reg_status = RecRegisterConfigFloat(type, record->name, data.rec_float, update, check, record->regex, source, access);
   80|      7|      break;
   81|       |
   82|    120|    case RECD_STRING:
  ------------------
  |  Branch (82:5): [True: 120, False: 439]
  ------------------
   83|    120|      reg_status = RecRegisterConfigString(type, record->name, data.rec_string, update, check, record->regex, source, access);
   84|    120|      break;
   85|       |
   86|      0|    case RECD_COUNTER:
  ------------------
  |  Branch (86:5): [True: 0, False: 559]
  ------------------
   87|      0|      reg_status = RecRegisterConfigCounter(type, record->name, data.rec_counter, update, check, record->regex, source, access);
   88|      0|      break;
   89|       |
   90|      0|    default:
  ------------------
  |  Branch (90:5): [True: 0, False: 559]
  ------------------
   91|      0|      ink_assert(true);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
   92|      0|      break;
   93|    559|    } // switch
   94|       |
   95|    559|    if (reg_status != REC_ERR_OKAY) {
  ------------------
  |  Branch (95:9): [True: 0, False: 559]
  ------------------
   96|      0|      ink_fatal("%s cannot be registered. Please check the logs.", record->name);
   97|      0|    }
   98|       |
   99|    559|    RecDataZero(record->value_type, &data);
  100|    559|  } else { // Everything else, except PROCESS, are stats. TODO: Should modularize this too like PROCESS was done.
  101|      0|    ink_assert(REC_TYPE_IS_STAT(type));
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  |  |  ------------------
  |  |  |  Branch (45:31): [True: 0, False: 0]
  |  |  |  Branch (45:31): [True: 0, False: 0]
  |  |  |  Branch (45:31): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  102|       |
  103|      0|    switch (record->value_type) {
  104|      0|    case RECD_INT:
  ------------------
  |  Branch (104:5): [True: 0, False: 0]
  ------------------
  105|      0|      tempInt = static_cast<RecInt>(ink_atoi64(record->value));
  106|      0|      RecRegisterStatInt(type, record->name, tempInt, RECP_NON_PERSISTENT);
  ------------------
  |  |  109|      0|  _RecRegisterStatInt((rec_type), (name), (data_default), REC_PERSISTENCE_TYPE(persist_type))
  |  |  ------------------
  |  |  |  |   99|      0|#define REC_PERSISTENCE_TYPE(P) rec::detail::is_valid_persistence<P>::value
  |  |  ------------------
  ------------------
  107|      0|      break;
  108|       |
  109|      0|    case RECD_FLOAT:
  ------------------
  |  Branch (109:5): [True: 0, False: 0]
  ------------------
  110|      0|      tempFloat = static_cast<RecFloat>(atof(record->value));
  111|      0|      RecRegisterStatFloat(type, record->name, tempFloat, RECP_NON_PERSISTENT);
  ------------------
  |  |  113|      0|  _RecRegisterStatFloat((rec_type), (name), (data_default), REC_PERSISTENCE_TYPE(persist_type))
  |  |  ------------------
  |  |  |  |   99|      0|#define REC_PERSISTENCE_TYPE(P) rec::detail::is_valid_persistence<P>::value
  |  |  ------------------
  ------------------
  112|      0|      break;
  113|       |
  114|      0|    case RECD_COUNTER:
  ------------------
  |  Branch (114:5): [True: 0, False: 0]
  ------------------
  115|      0|      tempCounter = static_cast<RecCounter>(ink_atoi64(record->value));
  116|      0|      RecRegisterStatCounter(type, record->name, tempCounter, RECP_NON_PERSISTENT);
  ------------------
  |  |  117|      0|  _RecRegisterStatCounter((rec_type), (name), (data_default), REC_PERSISTENCE_TYPE(persist_type))
  |  |  ------------------
  |  |  |  |   99|      0|#define REC_PERSISTENCE_TYPE(P) rec::detail::is_valid_persistence<P>::value
  |  |  ------------------
  ------------------
  117|      0|      break;
  118|       |
  119|      0|    default:
  ------------------
  |  Branch (119:5): [True: 0, False: 0]
  ------------------
  120|      0|      ink_assert(true);
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
  121|      0|      break;
  122|      0|    } // switch
  123|      0|  }
  124|    559|}

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

_ZN11EventNotifyC2Ev:
   41|      2|{
   42|      2|#if defined(HAVE_EVENTFD) && TS_USE_EPOLL == 1
   43|      2|  int                ret;
   44|      2|  struct epoll_event ev;
   45|       |
   46|      2|  m_event_fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
   47|      2|  ink_release_assert(m_event_fd != -1);
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
   48|       |
   49|      2|  ev.events  = EPOLLIN;
   50|      2|  ev.data.fd = m_event_fd;
   51|       |
   52|      2|  m_epoll_fd = epoll_create(1);
   53|      2|  ink_release_assert(m_epoll_fd != -1);
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
   54|       |
   55|      2|  ret = epoll_ctl(m_epoll_fd, EPOLL_CTL_ADD, m_event_fd, &ev);
   56|      2|  ink_release_assert(ret != -1);
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
   57|       |#else
   58|       |  ink_cond_init(&m_cond);
   59|       |  ink_mutex_init(&m_mutex);
   60|       |#endif
   61|      2|}

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

_ZN6Layout3getEv:
   38|      5|{
   39|      5|  if (layout == nullptr) {
  ------------------
  |  Branch (39:7): [True: 0, False: 5]
  ------------------
   40|      0|    ink_assert("need to call create_default_layout before accessing"
  ------------------
  |  |   45|      0|#define ink_assert(EX) (void)(EX)
  ------------------
   41|      0|               "default_layout()");
   42|      0|  }
   43|      5|  return layout;
   44|      5|}
_ZN6Layout6createENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
   48|      1|{
   49|      1|  if (layout == nullptr) {
  ------------------
  |  Branch (49:7): [True: 1, False: 0]
  ------------------
   50|      1|    layout = new Layout(prefix);
   51|      1|  }
   52|      1|}
_ZN6Layout11relative_toENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEES4_:
   96|      3|{
   97|      3|  return layout_relative(dir, file);
   98|      3|}
_ZN6Layout13runroot_setupEv:
  116|      1|{
  117|      1|  std::string runroot_file = get_runroot().data();
  118|      1|  if (runroot_file.empty()) {
  ------------------
  |  Branch (118:7): [True: 1, False: 0]
  ------------------
  119|       |    // runroot is not used
  120|      1|    return false;
  121|      1|  }
  122|      0|  RunrootMapType dir_map = check_runroot();
  123|      0|  if (dir_map.empty()) {
  ------------------
  |  Branch (123:7): [True: 0, False: 0]
  ------------------
  124|      0|    ink_warning("No value provided in runroot.yaml\n");
  125|      0|  }
  126|       |  // If some path values are not in runroot.yaml, we give it a default value instead of error out.
  127|      0|  prefix      = dir_map[LAYOUT_PREFIX].empty() ? runroot_file.substr(0, runroot_file.find_last_of('/')) : dir_map[LAYOUT_PREFIX];
  ------------------
  |  Branch (127:17): [True: 0, False: 0]
  ------------------
  128|      0|  exec_prefix = dir_map[LAYOUT_EXEC_PREFIX].empty() ? prefix : dir_map[LAYOUT_EXEC_PREFIX];
  ------------------
  |  Branch (128:17): [True: 0, False: 0]
  ------------------
  129|      0|  bindir      = dir_map[LAYOUT_BINDIR].empty() ? layout_relative(prefix, TS_BUILD_BINDIR) : bindir = dir_map[LAYOUT_BINDIR];
  ------------------
  |  |  117|      0|#define TS_BUILD_BINDIR "bin"
  ------------------
  |  Branch (129:17): [True: 0, False: 0]
  ------------------
  130|      0|  sbindir     = dir_map[LAYOUT_SBINDIR].empty() ? layout_relative(prefix, TS_BUILD_SBINDIR) : dir_map[LAYOUT_SBINDIR];
  ------------------
  |  |  118|      0|#define TS_BUILD_SBINDIR "bin"
  ------------------
  |  Branch (130:17): [True: 0, False: 0]
  ------------------
  131|      0|  sysconfdir  = dir_map[LAYOUT_SYSCONFDIR].empty() ? layout_relative(prefix, TS_BUILD_SYSCONFDIR) : dir_map[LAYOUT_SYSCONFDIR];
  ------------------
  |  |  119|      0|#define TS_BUILD_SYSCONFDIR "etc/trafficserver"
  ------------------
  |  Branch (131:17): [True: 0, False: 0]
  ------------------
  132|      0|  datadir     = dir_map[LAYOUT_DATADIR].empty() ? layout_relative(prefix, TS_BUILD_DATADIR) : dir_map[LAYOUT_DATADIR];
  ------------------
  |  |  120|      0|#define TS_BUILD_DATADIR "share/trafficserver"
  ------------------
  |  Branch (132:17): [True: 0, False: 0]
  ------------------
  133|      0|  includedir  = dir_map[LAYOUT_INCLUDEDIR].empty() ? layout_relative(prefix, TS_BUILD_INCLUDEDIR) : dir_map[LAYOUT_INCLUDEDIR];
  ------------------
  |  |  121|      0|#define TS_BUILD_INCLUDEDIR "include"
  ------------------
  |  Branch (133:17): [True: 0, False: 0]
  ------------------
  134|      0|  libdir      = dir_map[LAYOUT_LIBDIR].empty() ? layout_relative(prefix, TS_BUILD_LIBDIR) : dir_map[LAYOUT_LIBDIR];
  ------------------
  |  |  122|      0|#define TS_BUILD_LIBDIR "lib"
  ------------------
  |  Branch (134:17): [True: 0, False: 0]
  ------------------
  135|      0|  libexecdir  = dir_map[LAYOUT_LIBEXECDIR].empty() ? layout_relative(prefix, TS_BUILD_LIBEXECDIR) : dir_map[LAYOUT_LIBEXECDIR];
  ------------------
  |  |  123|      0|#define TS_BUILD_LIBEXECDIR "libexec/trafficserver"
  ------------------
  |  Branch (135:17): [True: 0, False: 0]
  ------------------
  136|      0|  localstatedir =
  137|      0|    dir_map[LAYOUT_LOCALSTATEDIR].empty() ? layout_relative(prefix, TS_BUILD_LOCALSTATEDIR) : dir_map[LAYOUT_LOCALSTATEDIR];
  ------------------
  |  |  124|      0|#define TS_BUILD_LOCALSTATEDIR "var"
  ------------------
  |  Branch (137:5): [True: 0, False: 0]
  ------------------
  138|      0|  runtimedir = dir_map[LAYOUT_RUNTIMEDIR].empty() ? layout_relative(prefix, TS_BUILD_RUNTIMEDIR) : dir_map[LAYOUT_RUNTIMEDIR];
  ------------------
  |  |  125|      0|#define TS_BUILD_RUNTIMEDIR "/usr/local/trafficserver/var/trafficserver"
  ------------------
  |  Branch (138:16): [True: 0, False: 0]
  ------------------
  139|      0|  logdir     = dir_map[LAYOUT_LOGDIR].empty() ? layout_relative(prefix, TS_BUILD_LOGDIR) : dir_map[LAYOUT_LOGDIR];
  ------------------
  |  |  126|      0|#define TS_BUILD_LOGDIR "var/log/trafficserver"
  ------------------
  |  Branch (139:16): [True: 0, False: 0]
  ------------------
  140|      0|  mandir     = dir_map[LAYOUT_MANDIR].empty() ? layout_relative(prefix, TS_BUILD_MANDIR) : dir_map[LAYOUT_MANDIR];
  ------------------
  |  |  127|      0|#define TS_BUILD_MANDIR "share/man"
  ------------------
  |  Branch (140:16): [True: 0, False: 0]
  ------------------
  141|      0|  infodir    = dir_map[LAYOUT_INFODIR].empty() ? layout_relative(prefix, TS_BUILD_INFODIR) : dir_map[LAYOUT_INFODIR];
  ------------------
  |  |  129|      0|#define TS_BUILD_INFODIR "share/info"
  ------------------
  |  Branch (141:16): [True: 0, False: 0]
  ------------------
  142|      0|  cachedir   = dir_map[LAYOUT_CACHEDIR].empty() ? layout_relative(prefix, TS_BUILD_CACHEDIR) : dir_map[LAYOUT_CACHEDIR];
  ------------------
  |  |  128|      0|#define TS_BUILD_CACHEDIR "var/trafficserver"
  ------------------
  |  Branch (142:16): [True: 0, False: 0]
  ------------------
  143|      0|  return true;
  144|      1|}
_ZN6LayoutC2ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  147|      1|{
  148|       |  // if runroot is used, we set it up directly
  149|      1|  if (runroot_setup()) {
  ------------------
  |  Branch (149:7): [True: 0, False: 1]
  ------------------
  150|      0|    return;
  151|      0|  }
  152|      1|  if (!_prefix.empty()) {
  ------------------
  |  Branch (152:7): [True: 0, False: 1]
  ------------------
  153|      0|    prefix.assign(_prefix.data(), _prefix.size());
  154|      1|  } else {
  155|      1|    std::string path;
  156|      1|    int         len;
  157|      1|    if (getenv("TS_ROOT") != nullptr) {
  ------------------
  |  Branch (157:9): [True: 0, False: 1]
  ------------------
  158|      0|      const char *const env = getenv("TS_ROOT");
  159|      0|      std::string       env_path(nullptr != env ? env : "");
  ------------------
  |  Branch (159:34): [True: 0, False: 0]
  ------------------
  160|      0|      len = env_path.size();
  161|      0|      if ((len + 1) > PATH_NAME_MAX) {
  ------------------
  |  |  137|      0|  4096 // instead of PATH_MAX which is inconsistent
  ------------------
  |  Branch (161:11): [True: 0, False: 0]
  ------------------
  162|      0|        ink_fatal("TS_ROOT environment variable is too big: %d, max %d\n", len, PATH_NAME_MAX - 1);
  ------------------
  |  |  137|      0|  4096 // instead of PATH_MAX which is inconsistent
  ------------------
  163|      0|      }
  164|      0|      path = env_path;
  165|      0|      while (path.back() == '/') {
  ------------------
  |  Branch (165:14): [True: 0, False: 0]
  ------------------
  166|      0|        path.pop_back();
  167|      0|      }
  168|      1|    } else {
  169|       |      // Use compile time --prefix
  170|      1|      path = TS_BUILD_PREFIX;
  ------------------
  |  |  115|      1|#define TS_BUILD_PREFIX "/usr/local/trafficserver"
  ------------------
  171|      1|    }
  172|      1|    prefix = path;
  173|      1|  }
  174|      1|  exec_prefix   = layout_relative(prefix, TS_BUILD_EXEC_PREFIX);
  ------------------
  |  |  116|      1|#define TS_BUILD_EXEC_PREFIX TS_BUILD_PREFIX
  |  |  ------------------
  |  |  |  |  115|      1|#define TS_BUILD_PREFIX "/usr/local/trafficserver"
  |  |  ------------------
  ------------------
  175|      1|  bindir        = layout_relative(prefix, TS_BUILD_BINDIR);
  ------------------
  |  |  117|      1|#define TS_BUILD_BINDIR "bin"
  ------------------
  176|      1|  sbindir       = layout_relative(prefix, TS_BUILD_SBINDIR);
  ------------------
  |  |  118|      1|#define TS_BUILD_SBINDIR "bin"
  ------------------
  177|      1|  sysconfdir    = layout_relative(prefix, TS_BUILD_SYSCONFDIR);
  ------------------
  |  |  119|      1|#define TS_BUILD_SYSCONFDIR "etc/trafficserver"
  ------------------
  178|      1|  datadir       = layout_relative(prefix, TS_BUILD_DATADIR);
  ------------------
  |  |  120|      1|#define TS_BUILD_DATADIR "share/trafficserver"
  ------------------
  179|      1|  includedir    = layout_relative(prefix, TS_BUILD_INCLUDEDIR);
  ------------------
  |  |  121|      1|#define TS_BUILD_INCLUDEDIR "include"
  ------------------
  180|      1|  libdir        = layout_relative(prefix, TS_BUILD_LIBDIR);
  ------------------
  |  |  122|      1|#define TS_BUILD_LIBDIR "lib"
  ------------------
  181|      1|  libexecdir    = layout_relative(prefix, TS_BUILD_LIBEXECDIR);
  ------------------
  |  |  123|      1|#define TS_BUILD_LIBEXECDIR "libexec/trafficserver"
  ------------------
  182|      1|  localstatedir = layout_relative(prefix, TS_BUILD_LOCALSTATEDIR);
  ------------------
  |  |  124|      1|#define TS_BUILD_LOCALSTATEDIR "var"
  ------------------
  183|      1|  runtimedir    = layout_relative(prefix, TS_BUILD_RUNTIMEDIR);
  ------------------
  |  |  125|      1|#define TS_BUILD_RUNTIMEDIR "/usr/local/trafficserver/var/trafficserver"
  ------------------
  184|      1|  logdir        = layout_relative(prefix, TS_BUILD_LOGDIR);
  ------------------
  |  |  126|      1|#define TS_BUILD_LOGDIR "var/log/trafficserver"
  ------------------
  185|      1|  mandir        = layout_relative(prefix, TS_BUILD_MANDIR);
  ------------------
  |  |  127|      1|#define TS_BUILD_MANDIR "share/man"
  ------------------
  186|      1|  infodir       = layout_relative(prefix, TS_BUILD_INFODIR);
  ------------------
  |  |  129|      1|#define TS_BUILD_INFODIR "share/info"
  ------------------
  187|      1|  cachedir      = layout_relative(prefix, TS_BUILD_CACHEDIR);
  ------------------
  |  |  128|      1|#define TS_BUILD_CACHEDIR "var/trafficserver"
  ------------------
  188|      1|}
Layout.cc:_ZL15layout_relativeNSt3__117basic_string_viewIcNS_11char_traitsIcEEEES3_:
   73|     17|{
   74|     17|  char        path[PATH_NAME_MAX];
   75|     17|  std::string ret;
   76|     17|  _relative(path, PATH_NAME_MAX, root, file);
  ------------------
  |  |  137|     17|  4096 // instead of PATH_MAX which is inconsistent
  ------------------
   77|     17|  ret = path;
   78|     17|  return ret;
   79|     17|}
Layout.cc:_ZL9_relativePcmNSt3__117basic_string_viewIcNS0_11char_traitsIcEEEES4_:
   56|     17|{
   57|     17|  if (ink_filepath_merge(path, buffsz, root.data(), file.data(), INK_FILEPATH_TRUENAME)) {
  ------------------
  |  |   82|     17|#define INK_FILEPATH_TRUENAME 0x20
  ------------------
  |  Branch (57:7): [True: 0, False: 17]
  ------------------
   58|      0|    int err = errno;
   59|       |    // Log error
   60|      0|    if (err == EACCES) {
  ------------------
  |  Branch (60:9): [True: 0, False: 0]
  ------------------
   61|      0|      ink_fatal("Cannot merge path '%s' above the root '%s'\n", file.data(), root.data());
   62|      0|    } else if (err == E2BIG) {
  ------------------
  |  Branch (62:16): [True: 0, False: 0]
  ------------------
   63|      0|      ink_fatal("Exceeding file name length limit of %d characters\n", PATH_NAME_MAX);
  ------------------
  |  |  137|      0|  4096 // instead of PATH_MAX which is inconsistent
  ------------------
   64|      0|    } else {
   65|       |      // TODO: Make some pretty errors.
   66|      0|      ink_fatal("Cannot merge '%s' with '%s' error=%d\n", file.data(), root.data(), err);
   67|      0|    }
   68|      0|  }
   69|     17|}

_Z10ink_atoi64PKcPS0_:
   52|    432|{
   53|    432|  int64_t num      = 0;
   54|    432|  int     negative = 0;
   55|       |
   56|    432|  while (*str && ParseRules::is_wslfcr(*str)) {
  ------------------
  |  Branch (56:10): [True: 432, False: 0]
  |  Branch (56:18): [True: 0, False: 432]
  ------------------
   57|      0|    str += 1;
   58|      0|  }
   59|       |
   60|    432|  if (unlikely(str[0] == '0' && str[1] == 'x')) {
  ------------------
  |  |   80|    593|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (80:21): [True: 6, False: 426]
  |  |  |  Branch (80:41): [True: 161, False: 271]
  |  |  |  Branch (80:41): [True: 6, False: 155]
  |  |  ------------------
  ------------------
   61|      6|    str += 2;
   62|     12|    while (*str && ParseRules::is_hex(*str)) {
  ------------------
  |  Branch (62:12): [True: 6, False: 6]
  |  Branch (62:20): [True: 6, False: 0]
  ------------------
   63|      6|      num = (num << 4) + ink_get_hex(*str++);
   64|      6|    }
   65|    426|  } else {
   66|    426|    if (unlikely(*str == '-')) {
  ------------------
  |  |   80|    426|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (80:21): [True: 15, False: 411]
  |  |  ------------------
  ------------------
   67|     15|      negative  = 1;
   68|     15|      str      += 1;
   69|     15|    }
   70|       |
   71|       |    /*
   72|       |      NOTE: we first compute the value as negative then correct the
   73|       |      sign back to positive. This enables us to correctly parse MININT.
   74|       |    */
   75|  1.21k|    while (*str && ParseRules::is_digit(*str)) {
  ------------------
  |  Branch (75:12): [True: 791, False: 425]
  |  Branch (75:20): [True: 790, False: 1]
  ------------------
   76|    790|      num = (num * 10) - (*str++ - '0');
   77|    790|    }
   78|    426|#if USE_SI_MULTIPLIERS
   79|    426|    if (*str) {
  ------------------
  |  Branch (79:9): [True: 1, False: 425]
  ------------------
   80|      1|      if (*str == 'K') {
  ------------------
  |  Branch (80:11): [True: 0, False: 1]
  ------------------
   81|      0|        num = num * (1LL << 10);
   82|      0|        str++;
   83|      1|      } else if (*str == 'M') {
  ------------------
  |  Branch (83:18): [True: 1, False: 0]
  ------------------
   84|      1|        num = num * (1LL << 20);
   85|      1|        str++;
   86|      1|      } else if (*str == 'G') {
  ------------------
  |  Branch (86:18): [True: 0, False: 0]
  ------------------
   87|      0|        num = num * (1LL << 30);
   88|      0|        str++;
   89|      0|      } else if (*str == 'T') {
  ------------------
  |  Branch (89:18): [True: 0, False: 0]
  ------------------
   90|      0|        num = num * (1LL << 40);
   91|      0|        str++;
   92|      0|      }
   93|      1|    }
   94|    426|#endif
   95|    426|    if (!negative) {
  ------------------
  |  Branch (95:9): [True: 411, False: 15]
  ------------------
   96|    411|      num = -num;
   97|    411|    }
   98|    426|  }
   99|       |
  100|    432|  if (end != nullptr) {
  ------------------
  |  Branch (100:7): [True: 0, False: 432]
  ------------------
  101|      0|    *end = str;
  102|      0|  }
  103|       |
  104|    432|  return num;
  105|    432|}

_ZN14RegressionTestC2EPKcRK14SourceLocationPFvPS_iPiEi:
   62|      6|  : name(_n), location(_l), function(_f), next(nullptr), status(REGRESSION_TEST_NOT_RUN), printed(false), opt(_o)
  ------------------
  |  |   49|      6|#define REGRESSION_TEST_NOT_RUN    -2
  ------------------
   63|      6|{
   64|      6|  if (opt == REGRESSION_OPT_EXCLUSIVE) {
  ------------------
  |  |   58|      6|#define REGRESSION_OPT_EXCLUSIVE (1 << 0)
  ------------------
  |  Branch (64:7): [True: 4, False: 2]
  ------------------
   65|      4|    if (exclusive_test) {
  ------------------
  |  Branch (65:9): [True: 2, False: 2]
  ------------------
   66|      2|      this->next = exclusive_test;
   67|      2|    }
   68|      4|    exclusive_test = this;
   69|      4|  } else {
   70|      2|    if (test) {
  ------------------
  |  Branch (70:9): [True: 0, False: 2]
  ------------------
   71|      0|      this->next = test;
   72|      0|    }
   73|      2|    test = this;
   74|      2|  }
   75|      6|}

_ZN14AppVersionInfoC2Ev:
   30|      2|{
   31|      2|  defined = 0;
   32|      2|  ink_strlcpy(PkgStr, "?", sizeof(PkgStr));
  ------------------
  |  |   62|      2|#define ink_strlcpy strlcpy
  ------------------
   33|      2|  ink_strlcpy(AppStr, "?", sizeof(AppStr));
  ------------------
  |  |   62|      2|#define ink_strlcpy strlcpy
  ------------------
   34|      2|  ink_strlcpy(VersionStr, "?", sizeof(VersionStr));
  ------------------
  |  |   62|      2|#define ink_strlcpy strlcpy
  ------------------
   35|      2|  ink_strlcpy(BldNumStr, "?", sizeof(BldNumStr));
  ------------------
  |  |   62|      2|#define ink_strlcpy strlcpy
  ------------------
   36|      2|  ink_strlcpy(BldTimeStr, "?", sizeof(BldTimeStr));
  ------------------
  |  |   62|      2|#define ink_strlcpy strlcpy
  ------------------
   37|      2|  ink_strlcpy(BldDateStr, "?", sizeof(BldDateStr));
  ------------------
  |  |   62|      2|#define ink_strlcpy strlcpy
  ------------------
   38|      2|  ink_strlcpy(BldMachineStr, "?", sizeof(BldMachineStr));
  ------------------
  |  |   62|      2|#define ink_strlcpy strlcpy
  ------------------
   39|      2|  ink_strlcpy(BldPersonStr, "?", sizeof(BldPersonStr));
  ------------------
  |  |   62|      2|#define ink_strlcpy strlcpy
  ------------------
   40|      2|  ink_strlcpy(BldCompileFlagsStr, "?", sizeof(BldCompileFlagsStr));
  ------------------
  |  |   62|      2|#define ink_strlcpy strlcpy
  ------------------
   41|      2|  ink_strlcpy(FullVersionInfoStr, "?", sizeof(FullVersionInfoStr));
  ------------------
  |  |   62|      2|#define ink_strlcpy strlcpy
  ------------------
   42|       |  // coverity[uninit_member]
   43|      2|}

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

_Z18ink_filepath_mergePciPKcS1_i:
  140|     17|{
  141|     17|  size_t rootlen; // is the length of the src rootpath
  142|     17|  size_t maxlen;  // maximum total path length
  143|     17|  size_t keptlen; // is the length of the retained rootpath
  144|     17|  size_t pathlen; // is the length of the result path
  145|     17|  size_t seglen;  // is the end of the current segment
  146|     17|  char   curdir[PATH_NAME_MAX];
  147|       |
  148|       |  /* Treat null as an empty path.
  149|       |   */
  150|     17|  if (!addpath) {
  ------------------
  |  Branch (150:7): [True: 0, False: 17]
  ------------------
  151|      0|    addpath = "";
  152|      0|  }
  153|       |
  154|     17|  if (addpath[0] == '/') {
  ------------------
  |  Branch (154:7): [True: 2, False: 15]
  ------------------
  155|       |    // If addpath is rooted, then rootpath is unused.
  156|       |    // Ths violates any INK_FILEPATH_SECUREROOTTEST and
  157|       |    // INK_FILEPATH_NOTABSOLUTE flags specified.
  158|       |    //
  159|      2|    if (flags & INK_FILEPATH_SECUREROOTTEST) {
  ------------------
  |  |   66|      2|#define INK_FILEPATH_SECUREROOTTEST 0x02
  ------------------
  |  Branch (159:9): [True: 0, False: 2]
  ------------------
  160|      0|      return EACCES; // APR_EABOVEROOT;
  161|      0|    }
  162|      2|    if (flags & INK_FILEPATH_NOTABSOLUTE) {
  ------------------
  |  |   74|      2|#define INK_FILEPATH_NOTABSOLUTE 0x08
  ------------------
  |  Branch (162:9): [True: 0, False: 2]
  ------------------
  163|      0|      return EISDIR; // APR_EABSOLUTE;
  164|      0|    }
  165|       |
  166|       |    // If INK_FILEPATH_NOTABOVEROOT wasn't specified,
  167|       |    // we won't test the root again, it's ignored.
  168|       |    // Waste no CPU retrieving the working path.
  169|       |    //
  170|      2|    if (!rootpath && !(flags & INK_FILEPATH_NOTABOVEROOT)) {
  ------------------
  |  |   64|      0|#define INK_FILEPATH_NOTABOVEROOT 0x01
  ------------------
  |  Branch (170:9): [True: 0, False: 2]
  |  Branch (170:22): [True: 0, False: 0]
  ------------------
  171|      0|      rootpath = "";
  172|      0|    }
  173|     15|  } else {
  174|       |    // If INK_FILEPATH_NOTABSOLUTE is specified, the caller
  175|       |    // requires a relative result.  If the rootpath is
  176|       |    // omitted, we do not retrieve the working path,
  177|       |    // if rootpath was supplied as absolute then fail.
  178|       |    //
  179|     15|    if (flags & INK_FILEPATH_NOTABSOLUTE) {
  ------------------
  |  |   74|     15|#define INK_FILEPATH_NOTABSOLUTE 0x08
  ------------------
  |  Branch (179:9): [True: 0, False: 15]
  ------------------
  180|      0|      if (!rootpath) {
  ------------------
  |  Branch (180:11): [True: 0, False: 0]
  ------------------
  181|      0|        rootpath = "";
  182|      0|      } else if (rootpath[0] == '/') {
  ------------------
  |  Branch (182:18): [True: 0, False: 0]
  ------------------
  183|      0|        return EISDIR; // APR_EABSOLUTE;
  184|      0|      }
  185|      0|    }
  186|     15|  }
  187|     17|  if (!rootpath) {
  ------------------
  |  Branch (187:7): [True: 0, False: 17]
  ------------------
  188|       |    // Start with the current working path.  This is bass akwards,
  189|       |    // but required since the compiler (at least vc) doesn't like
  190|       |    // passing the address of a const char* for a char** arg.
  191|       |    //
  192|      0|    if (!getcwd(curdir, sizeof(curdir))) {
  ------------------
  |  Branch (192:9): [True: 0, False: 0]
  ------------------
  193|      0|      return errno;
  194|      0|    }
  195|      0|    rootpath = curdir;
  196|      0|  }
  197|     17|  rootlen = strlen(rootpath);
  198|     17|  maxlen  = rootlen + strlen(addpath) + 4; // 4 for slashes at start, after
  199|       |                                           // root, and at end, plus trailing
  200|       |                                           // null
  201|     17|  if (maxlen > static_cast<size_t>(pathsz)) {
  ------------------
  |  Branch (201:7): [True: 0, False: 17]
  ------------------
  202|      0|    return E2BIG; // APR_ENAMETOOLONG;
  203|      0|  }
  204|     17|  if (addpath[0] == '/') {
  ------------------
  |  Branch (204:7): [True: 2, False: 15]
  ------------------
  205|       |    // Ignore the given root path, strip off leading
  206|       |    // '/'s to a single leading '/' from the addpath,
  207|       |    // and leave addpath at the first non-'/' character.
  208|       |    //
  209|      2|    keptlen = 0;
  210|      4|    while (addpath[0] == '/') {
  ------------------
  |  Branch (210:12): [True: 2, False: 2]
  ------------------
  211|      2|      ++addpath;
  212|      2|    }
  213|      2|    path[0] = '/';
  214|      2|    pathlen = 1;
  215|     15|  } else {
  216|       |    // If both paths are relative, fail early
  217|       |    //
  218|     15|    if (rootpath[0] != '/' && (flags & INK_FILEPATH_NOTRELATIVE)) {
  ------------------
  |  |   72|      0|#define INK_FILEPATH_NOTRELATIVE 0x04
  ------------------
  |  Branch (218:9): [True: 0, False: 15]
  |  Branch (218:31): [True: 0, False: 0]
  ------------------
  219|      0|      return EBADF; // APR_ERELATIVE;
  220|      0|    }
  221|       |
  222|       |    // Base the result path on the rootpath
  223|       |    //
  224|     15|    keptlen = rootlen;
  225|     15|    memcpy(path, rootpath, rootlen);
  226|       |
  227|       |    // Always '/' terminate the given root path
  228|       |    //
  229|     15|    if (keptlen && path[keptlen - 1] != '/') {
  ------------------
  |  Branch (229:9): [True: 15, False: 0]
  |  Branch (229:20): [True: 15, False: 0]
  ------------------
  230|     15|      path[keptlen++] = '/';
  231|     15|    }
  232|     15|    pathlen = keptlen;
  233|     15|  }
  234|       |
  235|     48|  while (*addpath) {
  ------------------
  |  Branch (235:10): [True: 31, False: 17]
  ------------------
  236|       |    // Parse each segment, find the closing '/'
  237|       |    //
  238|     31|    const char *next = addpath;
  239|    252|    while (*next && (*next != '/')) {
  ------------------
  |  Branch (239:12): [True: 235, False: 17]
  |  Branch (239:21): [True: 221, False: 14]
  ------------------
  240|    221|      ++next;
  241|    221|    }
  242|     31|    seglen = next - addpath;
  243|       |
  244|     31|    if (seglen == 0 || (seglen == 1 && addpath[0] == '.')) {
  ------------------
  |  Branch (244:9): [True: 0, False: 31]
  |  Branch (244:25): [True: 0, False: 31]
  |  Branch (244:40): [True: 0, False: 0]
  ------------------
  245|       |      // noop segment (/ or ./) so skip it
  246|       |      //
  247|     31|    } else if (seglen == 2 && addpath[0] == '.' && addpath[1] == '.') {
  ------------------
  |  Branch (247:16): [True: 0, False: 31]
  |  Branch (247:31): [True: 0, False: 0]
  |  Branch (247:52): [True: 0, False: 0]
  ------------------
  248|       |      // backpath (../)
  249|      0|      if (pathlen == 1 && path[0] == '/') {
  ------------------
  |  Branch (249:11): [True: 0, False: 0]
  |  Branch (249:27): [True: 0, False: 0]
  ------------------
  250|       |        // Attempt to move above root.  Always die if the
  251|       |        // INK_FILEPATH_SECUREROOTTEST flag is specified.
  252|       |        //
  253|      0|        if (flags & INK_FILEPATH_SECUREROOTTEST) {
  ------------------
  |  |   66|      0|#define INK_FILEPATH_SECUREROOTTEST 0x02
  ------------------
  |  Branch (253:13): [True: 0, False: 0]
  ------------------
  254|      0|          return EACCES; // APR_EABOVEROOT;
  255|      0|        }
  256|       |
  257|       |        // Otherwise this is simply a noop, above root is root.
  258|       |        // Flag that rootpath was entirely replaced.
  259|       |        //
  260|      0|        keptlen = 0;
  261|      0|      } else if (pathlen == 0 || (pathlen == 3 && !memcmp(path + pathlen - 3, "../", 3)) ||
  ------------------
  |  Branch (261:18): [True: 0, False: 0]
  |  Branch (261:35): [True: 0, False: 0]
  |  Branch (261:51): [True: 0, False: 0]
  ------------------
  262|      0|                 (pathlen > 3 && !memcmp(path + pathlen - 4, "/../", 4))) {
  ------------------
  |  Branch (262:19): [True: 0, False: 0]
  |  Branch (262:34): [True: 0, False: 0]
  ------------------
  263|       |        // Path is already backpathed or empty, if the
  264|       |        // INK_FILEPATH_SECUREROOTTEST.was given die now.
  265|       |        //
  266|      0|        if (flags & INK_FILEPATH_SECUREROOTTEST) {
  ------------------
  |  |   66|      0|#define INK_FILEPATH_SECUREROOTTEST 0x02
  ------------------
  |  Branch (266:13): [True: 0, False: 0]
  ------------------
  267|      0|          return EACCES; // APR_EABOVEROOT;
  268|      0|        }
  269|       |
  270|       |        // Otherwise append another backpath, including
  271|       |        // trailing slash if present.
  272|       |        //
  273|      0|        memcpy(path + pathlen, "../", *next ? 3 : 2);
  ------------------
  |  Branch (273:39): [True: 0, False: 0]
  ------------------
  274|      0|        pathlen += *next ? 3 : 2;
  ------------------
  |  Branch (274:20): [True: 0, False: 0]
  ------------------
  275|      0|      } else {
  276|       |        // otherwise crop the prior segment
  277|       |        //
  278|      0|        do {
  279|      0|          --pathlen;
  280|      0|        } while (pathlen && path[pathlen - 1] != '/');
  ------------------
  |  Branch (280:18): [True: 0, False: 0]
  |  Branch (280:29): [True: 0, False: 0]
  ------------------
  281|      0|      }
  282|       |
  283|       |      // Now test if we are above where we started and back up
  284|       |      // the keptlen offset to reflect the added/altered path.
  285|       |      //
  286|      0|      if (pathlen < keptlen) {
  ------------------
  |  Branch (286:11): [True: 0, False: 0]
  ------------------
  287|      0|        if (flags & INK_FILEPATH_SECUREROOTTEST) {
  ------------------
  |  |   66|      0|#define INK_FILEPATH_SECUREROOTTEST 0x02
  ------------------
  |  Branch (287:13): [True: 0, False: 0]
  ------------------
  288|      0|          return EACCES; // APR_EABOVEROOT;
  289|      0|        }
  290|      0|        keptlen = pathlen;
  291|      0|      }
  292|     31|    } else {
  293|       |      // An actual segment, append it to the destination path
  294|       |      //
  295|     31|      if (*next) {
  ------------------
  |  Branch (295:11): [True: 14, False: 17]
  ------------------
  296|     14|        seglen++;
  297|     14|      }
  298|     31|      memcpy(path + pathlen, addpath, seglen);
  299|     31|      pathlen += seglen;
  300|     31|    }
  301|       |
  302|       |    // Skip over trailing slash to the next segment
  303|       |    //
  304|     31|    if (*next) {
  ------------------
  |  Branch (304:9): [True: 14, False: 17]
  ------------------
  305|     14|      ++next;
  306|     14|    }
  307|       |
  308|     31|    addpath = next;
  309|     31|  }
  310|     17|  path[pathlen] = '\0';
  311|     17|  if (pathlen > 1 && path[pathlen - 1] == '/') {
  ------------------
  |  Branch (311:7): [True: 17, False: 0]
  |  Branch (311:22): [True: 0, False: 17]
  ------------------
  312|       |    // Trim trailing slash unless requested
  313|      0|    size_t es = strlen(addpath);
  314|      0|    if (es == 0 || addpath[es - 1] != '/') {
  ------------------
  |  Branch (314:9): [True: 0, False: 0]
  |  Branch (314:20): [True: 0, False: 0]
  ------------------
  315|      0|      --pathlen;
  316|      0|      path[pathlen] = '\0';
  317|      0|    }
  318|      0|  }
  319|       |
  320|       |  // keptlen will be the rootlen unless the addpath contained
  321|       |  // backpath elements.  If so, and INK_FILEPATH_NOTABOVEROOT
  322|       |  // is specified (INK_FILEPATH_SECUREROOTTEST was caught above),
  323|       |  // compare the original root to assure the result path is
  324|       |  // still within given root path.
  325|       |  //
  326|     17|  if ((flags & INK_FILEPATH_NOTABOVEROOT) && keptlen < rootlen) {
  ------------------
  |  |   64|     17|#define INK_FILEPATH_NOTABOVEROOT 0x01
  ------------------
  |  Branch (326:7): [True: 0, False: 17]
  |  Branch (326:46): [True: 0, False: 0]
  ------------------
  327|      0|    if (strncmp(rootpath, path, rootlen)) {
  ------------------
  |  Branch (327:9): [True: 0, False: 0]
  ------------------
  328|      0|      return EACCES; // APR_EABOVEROOT;
  329|      0|    }
  330|      0|    if (rootpath[rootlen - 1] != '/' && path[rootlen] && path[rootlen] != '/') {
  ------------------
  |  Branch (330:9): [True: 0, False: 0]
  |  Branch (330:41): [True: 0, False: 0]
  |  Branch (330:58): [True: 0, False: 0]
  ------------------
  331|      0|      return EACCES; // APR_EABOVEROOT;
  332|      0|    }
  333|      0|  }
  334|       |
  335|     17|  return 0;
  336|     17|}

_Z10ats_mallocm:
   52|  1.70k|{
   53|  1.70k|  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|  1.70k|  if (likely(size > 0)) {
  ------------------
  |  |   28|  1.70k|#define likely(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (28:19): [True: 1.70k, False: 0]
  |  |  ------------------
  ------------------
   65|  1.70k|    if (unlikely((ptr = malloc(size)) == nullptr)) {
  ------------------
  |  |   31|  1.70k|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 1.70k]
  |  |  ------------------
  ------------------
   66|      0|      ink_abort("couldn't allocate %zu bytes", size);
   67|      0|    }
   68|  1.70k|  }
   69|  1.70k|  return ptr;
   70|  1.70k|} /* End ats_malloc */
_Z12ats_memalignmm:
   96|     43|{
   97|     43|  void *ptr;
   98|       |
   99|     43|  if (alignment <= 8) {
  ------------------
  |  Branch (99:7): [True: 0, False: 43]
  ------------------
  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|     43|  int retcode = posix_memalign(&ptr, alignment, size);
  109|       |
  110|     43|  if (unlikely(retcode)) {
  ------------------
  |  |   31|     43|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 43]
  |  |  ------------------
  ------------------
  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|     43|  return ptr;
  121|     43|} /* End ats_memalign */
_Z8ats_freePv:
  125|  1.47k|{
  126|  1.47k|  if (likely(ptr != nullptr)) {
  ------------------
  |  |   28|  1.47k|#define likely(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (28:19): [True: 647, False: 827]
  |  |  ------------------
  ------------------
  127|    647|    free(ptr);
  128|    647|  }
  129|  1.47k|} /* End ats_free */
_Z11ats_madvisePcmi:
  176|      1|{
  177|      1|#if HAVE_POSIX_MADVISE
  178|      1|  return posix_madvise(addr, len, flags);
  179|       |#else
  180|       |  return madvise(addr, len, flags);
  181|       |#endif
  182|      1|}
_Z8_xstrdupPKciS0_:
  242|  1.93k|{
  243|  1.93k|  char *newstr;
  244|       |
  245|  1.93k|  if (likely(str)) {
  ------------------
  |  |   28|  1.93k|#define likely(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (28:19): [True: 1.67k, False: 268]
  |  |  ------------------
  ------------------
  246|  1.67k|    if (length < 0) {
  ------------------
  |  Branch (246:9): [True: 1.67k, False: 1]
  ------------------
  247|  1.67k|      length = strlen(str);
  248|  1.67k|    }
  249|       |
  250|  1.67k|    newstr = static_cast<char *>(ats_malloc(length + 1));
  251|       |    // If this is a zero length string just null terminate and return.
  252|  1.67k|    if (unlikely(length == 0)) {
  ------------------
  |  |   31|  1.67k|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 27, False: 1.64k]
  |  |  ------------------
  ------------------
  253|     27|      *newstr = '\0';
  254|  1.64k|    } else {
  255|  1.64k|      strncpy(newstr, str, length); // we cannot do length + 1 because the string isn't
  256|  1.64k|      newstr[length] = '\0';        // guaranteed to be null terminated!
  257|  1.64k|    }
  258|  1.67k|    return newstr;
  259|  1.67k|  }
  260|    268|  return nullptr;
  261|  1.93k|}
_ZN14ats_scoped_straSENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  265|      1|{
  266|      1|  this->clear();
  267|      1|  if (!s.empty()) {
  ------------------
  |  Branch (267:7): [True: 1, False: 0]
  ------------------
  268|      1|    _r = static_cast<char *>(ats_malloc(s.size() + 1));
  269|      1|    memcpy(_r, s.data(), s.size());
  270|      1|    _r[s.size()] = '\0';
  271|      1|  }
  272|      1|  return *this;
  273|      1|}

_Z14ink_mutex_initP15pthread_mutex_t:
   50|    565|{
   51|    565|  int                          error;
   52|    565|  static x_pthread_mutexattr_t attr;
   53|       |
   54|    565|  error = pthread_mutex_init(m, &attr.attr);
   55|    565|  if (unlikely(error != 0)) {
  ------------------
  |  |   31|    565|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 565]
  |  |  ------------------
  ------------------
   56|      0|    ink_abort("pthread_mutex_init(%p) failed: %s (%d)", m, strerror(error), error);
   57|      0|  }
   58|    565|}
_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|     33|{
  140|     33|  InkFreeList       *f;
  141|     33|  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|     33|  f = static_cast<InkFreeList *>(ats_memalign(alignment, sizeof(InkFreeList)));
  146|     33|  ink_zero(*f);
  147|       |
  148|     33|  fll       = static_cast<ink_freelist_list *>(ats_malloc(sizeof(ink_freelist_list)));
  149|     33|  fll->fl   = f;
  150|     33|  fll->next = freelists;
  151|     33|  freelists = fll;
  152|       |
  153|     33|  f->name = name;
  154|       |  /* quick test for power of 2 */
  155|     33|  ink_assert(!(alignment & (alignment - 1)));
  ------------------
  |  |   45|     33|#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|     33|  f->alignment         = alignment;
  159|     33|  f->use_hugepages     = ats_hugepage_enabled() && use_hugepages;
  ------------------
  |  Branch (159:26): [True: 0, False: 33]
  |  Branch (159:52): [True: 0, False: 0]
  ------------------
  160|     33|  f->hugepages_failure = 0;
  161|     33|  if (f->use_hugepages) {
  ------------------
  |  Branch (161:7): [True: 0, False: 33]
  ------------------
  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|     33|  } else {
  166|     33|    if (f->alignment > ats_pagesize()) {
  ------------------
  |  Branch (166:9): [True: 9, False: 24]
  ------------------
  167|      9|      f->alignment = ats_pagesize();
  168|      9|    }
  169|       |    // Make sure we align *all* the objects in the allocation, not just the first one
  170|     33|    f->type_size = INK_ALIGN(type_size, f->alignment);
  ------------------
  |  |   50|     33|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1))
  ------------------
  171|     33|  }
  172|     33|  Dbg(dbg_ctl_freelist_init, "<%s> Alignment request/actual (%" PRIu32 "/%" PRIu32 ")", name, alignment, f->alignment);
  ------------------
  |  |  173|     33|  do {                              \
  |  |  174|     33|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 33]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|     33|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 33]
  |  |  ------------------
  ------------------
  173|     33|  Dbg(dbg_ctl_freelist_init, "<%s> Type Size request/actual (%" PRIu32 "/%" PRIu32 ")", name, type_size, f->type_size);
  ------------------
  |  |  173|     33|  do {                              \
  |  |  174|     33|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 33]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|     33|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 33]
  |  |  ------------------
  ------------------
  174|     33|  ink_assert(f->type_size != 0);
  ------------------
  |  |   45|     33|#define ink_assert(EX) (void)(EX)
  ------------------
  175|     33|  if (f->use_hugepages) {
  ------------------
  |  Branch (175:7): [True: 0, False: 33]
  ------------------
  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|     33|  } else {
  178|     33|    f->chunk_size = INK_ALIGN(chunk_size * f->type_size, ats_pagesize()) / f->type_size;
  ------------------
  |  |   50|     33|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1))
  ------------------
  179|     33|  }
  180|     33|  Dbg(dbg_ctl_freelist_init, "<%s> Chunk Size request/actual (%" PRIu32 "/%" PRIu32 ")", name, chunk_size, f->chunk_size);
  ------------------
  |  |  173|     33|  do {                              \
  |  |  174|     33|    if ((CTL).on()) {               \
  |  |  ------------------
  |  |  |  Branch (174:9): [True: 0, False: 33]
  |  |  ------------------
  |  |  175|      0|      DbgPrint((CTL), __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |  170|      0|#define DbgPrint(CTL, ...) (DbgCtl::print((CTL).tag(), __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__))
  |  |  ------------------
  |  |  176|      0|    }                               \
  |  |  177|     33|  } while (false)
  |  |  ------------------
  |  |  |  Branch (177:12): [Folded, False: 33]
  |  |  ------------------
  ------------------
  181|     33|  SET_FREELIST_POINTER_VERSION(f->head, FROM_PTR(0), 0);
  ------------------
  |  |  131|     33|  (_x).s.pointer = _p;                           \
  |  |  132|     33|  (_x).s.version = _v
  ------------------
  182|       |
  183|     33|  *fl = f;
  184|     33|}
_Z25ink_freelist_madvise_initPP12_InkFreeListPKcjjjbi:
  189|     15|{
  190|     15|  ink_freelist_init(fl, name, type_size, chunk_size, alignment, use_hugepages);
  191|     15|  (*fl)->advice = advice;
  192|     15|}
_Z16ink_freelist_newP12_InkFreeList:
  207|  1.02k|{
  208|  1.02k|  void *ptr;
  209|       |
  210|  1.02k|  if (likely(ptr = freelist_global_ops->fl_new(f))) {
  ------------------
  |  |   77|  1.02k|#define likely(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:19): [True: 1.02k, False: 0]
  |  |  ------------------
  ------------------
  211|  1.02k|    ink_atomic_increment(reinterpret_cast<int *>(&f->used), 1);
  212|  1.02k|  }
  213|       |
  214|  1.02k|  return ptr;
  215|  1.02k|}
_Z17ink_freelist_freeP12_InkFreeListPv:
  309|  1.02k|{
  310|  1.02k|  if (likely(item != nullptr)) {
  ------------------
  |  |   77|  1.02k|#define likely(x) __builtin_expect(!!(x), 1)
  |  |  ------------------
  |  |  |  Branch (77:19): [True: 1.02k, False: 0]
  |  |  ------------------
  ------------------
  311|  1.02k|    ink_assert(f->used != 0);
  ------------------
  |  |   45|  1.02k|#define ink_assert(EX) (void)(EX)
  ------------------
  312|  1.02k|    freelist_global_ops->fl_free(f, item);
  313|  1.02k|    ink_atomic_decrement(reinterpret_cast<int *>(&f->used), 1);
  314|  1.02k|  }
  315|  1.02k|}
_Z19ink_atomiclist_initP13InkAtomicListPKcj:
  519|      1|{
  520|      1|  l->name   = name;
  521|      1|  l->offset = offset_to_next;
  522|      1|  SET_FREELIST_POINTER_VERSION(l->head, FROM_PTR(0), 0);
  ------------------
  |  |  131|      1|  (_x).s.pointer = _p;                           \
  |  |  132|      1|  (_x).s.version = _v
  ------------------
  523|      1|}
_Z21ink_atomiclist_popallP13InkAtomicList:
  548|      1|{
  549|      1|  head_p item;
  550|      1|  head_p next;
  551|      1|  int    result = 0;
  552|      1|  do {
  553|      1|    INK_QUEUE_LD(item, l->head);
  ------------------
  |  |   63|      1|  do {                                                                                             \
  |  |   64|      1|    const volatile __int128_t iqld0 = 0;                                                           \
  |  |   65|      1|    *(__int128_t *)&(dst)           = __sync_val_compare_and_swap((__int128_t *)&(src), 0, iqld0); \
  |  |   66|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (66:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  554|      1|    if (TO_PTR(FREELIST_POINTER(item)) == nullptr) {
  ------------------
  |  |  118|      1|#define TO_PTR(_x)   ((void *)(_x))
  ------------------
  |  Branch (554:9): [True: 1, False: 0]
  ------------------
  555|      1|      return nullptr;
  556|      1|    }
  557|      0|    SET_FREELIST_POINTER_VERSION(next, FROM_PTR(nullptr), FREELIST_VERSION(item) + 1);
  ------------------
  |  |  131|      0|  (_x).s.pointer = _p;                           \
  |  |  132|      0|  (_x).s.version = _v
  ------------------
  558|      0|    result = ink_atomic_cas(&l->head.data, item.data, next.data);
  559|      0|  } while (result == 0);
  ------------------
  |  Branch (559:12): [True: 0, False: 0]
  ------------------
  560|      0|  {
  561|      0|    void *ret = TO_PTR(FREELIST_POINTER(item));
  ------------------
  |  |  118|      0|#define TO_PTR(_x)   ((void *)(_x))
  ------------------
  562|      0|    void *e   = ret;
  563|       |    /* fixup forward pointers */
  564|      0|    while (e) {
  ------------------
  |  Branch (564:12): [True: 0, False: 0]
  ------------------
  565|      0|      void *n                        = TO_PTR(*ADDRESS_OF_NEXT(e, l->offset));
  ------------------
  |  |  118|      0|#define TO_PTR(_x)   ((void *)(_x))
  ------------------
  566|      0|      *ADDRESS_OF_NEXT(e, l->offset) = n;
  ------------------
  |  |  203|      0|#define ADDRESS_OF_NEXT(x, offset) ((void **)((char *)x + offset))
  ------------------
  567|      0|      e                              = n;
  568|      0|    }
  569|      0|    return ret;
  570|      1|  }
  571|      1|}
ink_queue.cc:_ZN12_GLOBAL__N_112freelist_newEP12_InkFreeList:
  222|  1.02k|{
  223|  1.02k|  head_p item;
  224|  1.02k|  head_p next;
  225|  1.02k|  int    result = 0;
  226|       |
  227|  1.03k|  do {
  228|  1.03k|    INK_QUEUE_LD(item, f->head);
  ------------------
  |  |   63|  1.03k|  do {                                                                                             \
  |  |   64|  1.03k|    const volatile __int128_t iqld0 = 0;                                                           \
  |  |   65|  1.03k|    *(__int128_t *)&(dst)           = __sync_val_compare_and_swap((__int128_t *)&(src), 0, iqld0); \
  |  |   66|  1.03k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (66:12): [Folded, False: 1.03k]
  |  |  ------------------
  ------------------
  229|  1.03k|    if (TO_PTR(FREELIST_POINTER(item)) == nullptr) {
  ------------------
  |  |  118|  1.03k|#define TO_PTR(_x)   ((void *)(_x))
  ------------------
  |  Branch (229:9): [True: 10, False: 1.02k]
  ------------------
  230|     10|      uint32_t i;
  231|     10|      void    *newp       = nullptr;
  232|     10|      size_t   alloc_size = static_cast<size_t>(f->chunk_size) * f->type_size;
  233|     10|      size_t   alignment  = 0;
  234|       |
  235|     10|      if (f->use_hugepages) {
  ------------------
  |  Branch (235:11): [True: 0, False: 10]
  ------------------
  236|      0|        alignment = ats_hugepage_size();
  237|      0|        newp      = ats_alloc_hugepage(alloc_size);
  238|      0|        if (newp == nullptr) {
  ------------------
  |  Branch (238:13): [True: 0, False: 0]
  ------------------
  239|      0|          f->hugepages_failure++;
  240|      0|        }
  241|      0|      }
  242|       |
  243|     10|      if (newp == nullptr) {
  ------------------
  |  Branch (243:11): [True: 10, False: 0]
  ------------------
  244|     10|        alignment = ats_pagesize();
  245|     10|        newp      = ats_memalign(alignment, INK_ALIGN(alloc_size, alignment));
  ------------------
  |  |   50|     10|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1))
  ------------------
  246|     10|      }
  247|       |
  248|     10|      if (f->advice) {
  ------------------
  |  Branch (248:11): [True: 1, False: 9]
  ------------------
  249|      1|        ats_madvise(static_cast<caddr_t>(newp), INK_ALIGN(alloc_size, alignment), f->advice);
  ------------------
  |  |   50|      1|#define INK_ALIGN(size, boundary) (((size) + ((boundary) - 1)) & ~((boundary) - 1))
  ------------------
  250|      1|      }
  251|     10|      SET_FREELIST_POINTER_VERSION(item, newp, 0);
  ------------------
  |  |  131|     10|  (_x).s.pointer = _p;                           \
  |  |  132|     10|  (_x).s.version = _v
  ------------------
  252|       |
  253|     10|      ink_atomic_increment(reinterpret_cast<int *>(&f->allocated), f->chunk_size);
  254|       |
  255|       |      /* free each of the new elements */
  256|  1.54k|      for (i = 0; i < f->chunk_size; i++) {
  ------------------
  |  Branch (256:19): [True: 1.53k, False: 10]
  ------------------
  257|  1.53k|        char *a = (static_cast<char *>(FREELIST_POINTER(item))) + i * f->type_size;
  ------------------
  |  |  128|  1.53k|#define FREELIST_POINTER(_x) (_x).s.pointer
  ------------------
  258|       |#ifdef DEADBEEF
  259|       |        const char str[4] = {static_cast<char>(0xde), static_cast<char>(0xad), static_cast<char>(0xbe), static_cast<char>(0xef)};
  260|       |        for (int j = 0; j < static_cast<int>(f->type_size); j++) {
  261|       |          a[j] = str[j % 4];
  262|       |        }
  263|       |#endif
  264|  1.53k|        freelist_free(f, a);
  265|  1.53k|      }
  266|       |
  267|  1.02k|    } else {
  268|  1.02k|      SET_FREELIST_POINTER_VERSION(next, *ADDRESS_OF_NEXT(TO_PTR(FREELIST_POINTER(item)), 0), FREELIST_VERSION(item) + 1);
  ------------------
  |  |  131|  1.02k|  (_x).s.pointer = _p;                           \
  |  |  132|  1.02k|  (_x).s.version = _v
  ------------------
  269|  1.02k|      result = ink_atomic_cas(&f->head.data, item.data, next.data);
  270|       |
  271|       |#ifdef SANITY
  272|       |      if (result) {
  273|       |        if (FREELIST_POINTER(item) == TO_PTR(FREELIST_POINTER(next))) {
  274|       |          ink_abort("ink_freelist_new: loop detected");
  275|       |        }
  276|       |        if (((uintptr_t)(TO_PTR(FREELIST_POINTER(next)))) & 3) {
  277|       |          ink_abort("ink_freelist_new: bad list");
  278|       |        }
  279|       |        if (TO_PTR(FREELIST_POINTER(next))) {
  280|       |          dummy_forced_read(TO_PTR(FREELIST_POINTER(next)));
  281|       |        }
  282|       |      }
  283|       |#endif /* SANITY */
  284|  1.02k|    }
  285|  1.03k|  } while (result == 0);
  ------------------
  |  Branch (285:12): [True: 10, False: 1.02k]
  ------------------
  286|  1.02k|  ink_assert(!((uintptr_t)TO_PTR(FREELIST_POINTER(item)) & (((uintptr_t)f->alignment) - 1)));
  ------------------
  |  |   45|  1.02k|#define ink_assert(EX) (void)(EX)
  ------------------
  287|       |
  288|  1.02k|  return TO_PTR(FREELIST_POINTER(item));
  ------------------
  |  |  118|  1.02k|#define TO_PTR(_x)   ((void *)(_x))
  ------------------
  289|  1.02k|}
ink_queue.cc:_ZN12_GLOBAL__N_113freelist_freeEP12_InkFreeListPv:
  322|  2.55k|{
  323|  2.55k|  void **adr_of_next = ADDRESS_OF_NEXT(item, 0);
  ------------------
  |  |  203|  2.55k|#define ADDRESS_OF_NEXT(x, offset) ((void **)((char *)x + offset))
  ------------------
  324|  2.55k|  head_p h;
  325|  2.55k|  head_p item_pair;
  326|  2.55k|  int    result = 0;
  327|       |
  328|       |  // ink_assert(!((long)item&(f->alignment-1))); XXX - why is this no longer working? -bcall
  329|       |
  330|       |#ifdef DEADBEEF
  331|       |  {
  332|       |    static const char str[4] = {static_cast<char>(0xde), static_cast<char>(0xad), static_cast<char>(0xbe), static_cast<char>(0xef)};
  333|       |
  334|       |    // set the entire item to DEADBEEF
  335|       |    for (int j = 0; j < static_cast<int>(f->type_size); j++) {
  336|       |      (static_cast<char *>(item))[j] = str[j % 4];
  337|       |    }
  338|       |  }
  339|       |#endif /* DEADBEEF */
  340|       |
  341|  5.10k|  while (!result) {
  ------------------
  |  Branch (341:10): [True: 2.55k, False: 2.55k]
  ------------------
  342|  2.55k|    INK_QUEUE_LD(h, f->head);
  ------------------
  |  |   63|  2.55k|  do {                                                                                             \
  |  |   64|  2.55k|    const volatile __int128_t iqld0 = 0;                                                           \
  |  |   65|  2.55k|    *(__int128_t *)&(dst)           = __sync_val_compare_and_swap((__int128_t *)&(src), 0, iqld0); \
  |  |   66|  2.55k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (66:12): [Folded, False: 2.55k]
  |  |  ------------------
  ------------------
  343|       |#ifdef SANITY
  344|       |    if (TO_PTR(FREELIST_POINTER(h)) == item) {
  345|       |      ink_abort("ink_freelist_free: trying to free item twice");
  346|       |    }
  347|       |    if (((uintptr_t)(TO_PTR(FREELIST_POINTER(h)))) & 3) {
  348|       |      ink_abort("ink_freelist_free: bad list");
  349|       |    }
  350|       |    if (TO_PTR(FREELIST_POINTER(h))) {
  351|       |      dummy_forced_read(TO_PTR(FREELIST_POINTER(h)));
  352|       |    }
  353|       |#endif /* SANITY */
  354|  2.55k|    *adr_of_next = FREELIST_POINTER(h);
  ------------------
  |  |  128|  2.55k|#define FREELIST_POINTER(_x) (_x).s.pointer
  ------------------
  355|  2.55k|    SET_FREELIST_POINTER_VERSION(item_pair, FROM_PTR(item), FREELIST_VERSION(h));
  ------------------
  |  |  131|  2.55k|  (_x).s.pointer = _p;                           \
  |  |  132|  2.55k|  (_x).s.version = _v
  ------------------
  356|  2.55k|    INK_MEMORY_BARRIER;
  357|  2.55k|    result = ink_atomic_cas(&f->head.data, h.data, item_pair.data);
  358|  2.55k|  }
  359|  2.55k|}

_ZN7InkRandC2Em:
   69|      1|{
   70|      1|  seed(d);
   71|      1|}
_ZN7InkRand4seedEm:
   75|      1|{
   76|      1|  mt[0] = seed;
   77|    312|  for (mti = 1; mti < NN; mti++) {
  ------------------
  |  |   60|    312|#define NN       312
  ------------------
  |  Branch (77:17): [True: 311, False: 1]
  ------------------
   78|    311|    mt[mti] = (6364136223846793005ULL * (mt[mti - 1] ^ (mt[mti - 1] >> 62)) + mti);
   79|    311|  }
   80|      1|}

_Z15ink_rwlock_initP16pthread_rwlock_t:
   34|      1|{
   35|      1|  int error = pthread_rwlock_init(rw, nullptr);
   36|      1|  if (unlikely(error != 0)) {
  ------------------
  |  |   31|      1|#define unlikely(x) __builtin_expect(!!(x), 0)
  |  |  ------------------
  |  |  |  Branch (31:21): [True: 0, False: 1]
  |  |  ------------------
  ------------------
   37|      0|    ink_abort("pthread_rwlock_init(%p) failed: %s (%d)", rw, strerror(error), error);
   38|      0|  }
   39|      1|}

_Z11get_runrootv:
  282|    560|{
  283|    560|  return runroot_file;
  284|    560|}

_ZN6DbgCtl14_new_referenceEPKc:
  125|     32|{
  126|     32|  DebugInterface *p = DebugInterface::get_instance();
  127|     32|  debug_assert(tag != nullptr);
  ------------------
  |  |   45|     32|#define debug_assert(EX)              (void)(EX)
  ------------------
  128|       |
  129|     32|  _TagData *new_tag_data{nullptr};
  130|       |
  131|     32|  {
  132|     32|    _RegistryAccessor ra;
  133|       |
  134|     32|    auto &d{ra.data()};
  135|       |
  136|     32|    if (auto it = d.map.find(tag); it != d.map.end()) {
  ------------------
  |  Branch (136:36): [True: 4, False: 28]
  ------------------
  137|      4|      return &*it;
  138|      4|    }
  139|       |
  140|     28|    auto sz = std::strlen(tag);
  141|       |
  142|     28|    debug_assert(sz > 0);
  ------------------
  |  |   45|     28|#define debug_assert(EX)              (void)(EX)
  ------------------
  143|       |
  144|     28|    char *t = new char[sz + 1]; // Never deleted (leaky singleton) - reclaimed by OS at process exit.
  145|     28|    std::memcpy(t, tag, sz + 1);
  146|     28|    _TagData new_elem{t, false};
  147|       |
  148|     28|    auto res = d.map.insert(new_elem);
  149|       |
  150|     28|    debug_assert(res.second);
  ------------------
  |  |   45|     28|#define debug_assert(EX)              (void)(EX)
  ------------------
  151|       |
  152|     28|    new_tag_data = &*res.first;
  153|     28|  }
  154|     28|  new_tag_data->second = p && p->debug_tag_activated(tag);
  ------------------
  |  Branch (154:26): [True: 0, False: 28]
  |  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|     28|  return new_tag_data;
  171|     32|}
_ZN14DebugInterface12get_instanceEv:
  259|     32|{
  260|     32|  return di_inst;
  261|     32|}
_ZN6DbgCtl17_RegistryAccessorC2Ev:
   88|     32|  {
   89|     32|    if (!_registry_instance) {
  ------------------
  |  Branch (89:9): [True: 2, False: 30]
  ------------------
   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|     32|    _registry_instance.load()->_mtx.lock();
   98|     32|    _mtx_is_locked = true;
   99|     32|  }
_ZN6DbgCtl17_RegistryAccessor8RegistryC2Ev:
   77|      2|    Registry() = default;
_ZN6DbgCtl17_RegistryAccessor4dataEv:
  113|     32|  {
  114|     32|    return *_registry_instance;
  115|     32|  }
_ZN6DbgCtl17_RegistryAccessorD2Ev:
  102|     32|  {
  103|     32|    if (_mtx_is_locked) {
  ------------------
  |  Branch (103:9): [True: 32, False: 0]
  ------------------
  104|     32|      _registry_instance.load()->_mtx.unlock();
  105|     32|    }
  106|     32|  }
_ZNK6DbgCtl17_RegistryAccessor6TagCmpclEPKcS3_:
   63|    244|    {
   64|    244|      return std::strcmp(a, b) < 0;
   65|    244|    }

_ZN2ts7Metrics8instanceEv:
   37|     97|{
   38|       |  // This is the singleton instance of the metrics storage class.
   39|     97|  static std::shared_ptr<Storage> _metrics_store = std::make_shared<Storage>();
   40|     97|  thread_local Metrics            _instance(_metrics_store);
   41|       |
   42|     97|  return _instance;
   43|     97|}
_ZN2ts7Metrics7Storage6createENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS0_10MetricTypeE:
   59|     97|{
   60|     97|  std::lock_guard lock(_mutex);
   61|     97|  auto            it = _lookups.find(name);
   62|       |
   63|     97|  if (it != _lookups.end()) {
  ------------------
  |  Branch (63:7): [True: 0, False: 97]
  ------------------
   64|      0|    return it->second;
   65|      0|  }
   66|       |
   67|     97|  Metrics::IdType           id    = _makeId(_cur_blob, _cur_off, type);
   68|     97|  Metrics::NamesAndAtomics *blob  = _blobs[_cur_blob].get();
   69|     97|  Metrics::NameStorage     &names = std::get<0>(*blob);
   70|       |
   71|     97|  names[_cur_off] = std::make_tuple(std::string(name), id);
   72|     97|  _lookups.emplace(std::get<0>(names[_cur_off]), id);
   73|       |
   74|     97|  if (++_cur_off >= MAX_SIZE) {
  ------------------
  |  Branch (74:7): [True: 0, False: 97]
  ------------------
   75|      0|    addBlob(); // This resets _cur_off to 0 as well
   76|      0|  }
   77|       |
   78|     97|  return id;
   79|     97|}
_ZNK2ts7Metrics7Storage6lookupENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   83|      1|{
   84|      1|  std::lock_guard lock(_mutex);
   85|      1|  auto            it = _lookups.find(name);
   86|       |
   87|      1|  if (it != _lookups.end()) {
  ------------------
  |  Branch (87:7): [True: 0, False: 1]
  ------------------
   88|      0|    return it->second;
   89|      0|  }
   90|       |
   91|      1|  return NOT_FOUND;
   92|      1|}
_ZNK2ts7Metrics7Storage6lookupEiPNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS0_10MetricTypeE:
   96|     96|{
   97|     96|  auto [blob_ix, offset]         = _splitID(id);
   98|     96|  Metrics::NamesAndAtomics *blob = _blobs[blob_ix].get();
   99|       |
  100|       |  // Do a sanity check on the ID, to make sure we don't index outside of the realm of possibility.
  101|     96|  if (!blob || (blob_ix == _cur_blob && offset > _cur_off)) {
  ------------------
  |  Branch (101:7): [True: 0, False: 96]
  |  Branch (101:17): [True: 96, False: 0]
  |  Branch (101:41): [True: 0, False: 96]
  ------------------
  102|      0|    blob   = _blobs[0].get();
  103|      0|    offset = 0;
  104|      0|  }
  105|       |
  106|     96|  if (out_name) {
  ------------------
  |  Branch (106:7): [True: 0, False: 96]
  ------------------
  107|      0|    *out_name = std::get<0>(std::get<0>(*blob)[offset]);
  108|      0|  }
  109|       |
  110|     96|  if (out_type) {
  ------------------
  |  Branch (110:7): [True: 0, False: 96]
  ------------------
  111|       |    // don't trust the passed in id to get the type as it might have been manufactured (i.e. from iterators)
  112|       |    // so get the type from the storage tuple.
  113|      0|    *out_type = _extractType(std::get<1>(std::get<0>(*blob)[offset]));
  114|      0|  }
  115|       |
  116|     96|  return &((std::get<1>(*blob)[offset]));
  117|     96|}

_Z16DoInitializationv:
   36|      1|{
   37|      1|  Layout::create();
   38|      1|  RecProcessInit();
   39|      1|  LibRecordsConfigInit();
   40|       |
   41|      1|  ink_event_system_init(EVENT_SYSTEM_MODULE_PUBLIC_VERSION);
   42|      1|  eventProcessor.start(TEST_THREADS);
  ------------------
  |  |   30|      1|#define TEST_THREADS 1
  ------------------
   43|      1|  ts::Http3Config::startup();
   44|       |
   45|      1|  return true;
   46|      1|}
LLVMFuzzerTestOneInput:
   50|    176|{
   51|    176|  if (size_data < kMinInputLength || size_data > kMaxInputLength) {
  ------------------
  |  |   27|    352|#define kMinInputLength 8
  ------------------
                if (size_data < kMinInputLength || size_data > kMaxInputLength) {
  ------------------
  |  |   28|    172|#define kMaxInputLength 1024
  ------------------
  |  Branch (51:7): [True: 4, False: 172]
  |  Branch (51:38): [True: 23, False: 149]
  ------------------
   52|     27|    return 1;
   53|     27|  }
   54|       |
   55|    149|  cmd_disable_pfreelist = true;
   56|       |
   57|    149|  static bool Initialized = DoInitialization();
   58|       |
   59|    149|  MIOBuffer *input1 = new_MIOBuffer(BUFFER_SIZE_INDEX_128);
  ------------------
  |  | 1332|    298|#define new_MIOBuffer       MIOBuffer_tracker(RES_PATH("memory/IOBuffer/"))
  |  |  ------------------
  |  |  |  |   36|    149|#define RES_PATH(x)   x __FILE__ ":" _RES_PATH(__LINE__)
  |  |  |  |  ------------------
  |  |  |  |  |  |   35|    149|#define _RES_PATH(x)  __RES_PATH(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   34|    149|#define __RES_PATH(x) #x
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                MIOBuffer *input1 = new_MIOBuffer(BUFFER_SIZE_INDEX_128);
  ------------------
  |  |   72|    149|#define BUFFER_SIZE_INDEX_128  0
  ------------------
   60|    149|  input1->write(input_data, size_data);
   61|    149|  IOBufferReader *input_reader1 = input1->alloc_reader();
   62|       |
   63|    149|  Http3FrameFactory frame_factory;
   64|    149|  frame_factory.fast_create(*input_reader1);
   65|       |
   66|    149|  free_MIOBuffer(input1);
   67|       |
   68|    149|  return 0;
   69|    176|}