LLVMFuzzerTestOneInput:
   26|    186|{
   27|    186|    if (size == 0)
  ------------------
  |  Branch (27:9): [True: 0, False: 186]
  ------------------
   28|      0|    {
   29|      0|        return 0;
   30|      0|    }
   31|       |
   32|    186|    std::string_view input(reinterpret_cast<const char*>(data), size);
   33|       |
   34|       |    // 1. Test intfFromRtm
   35|    186|    try
   36|    186|    {
   37|    186|        (void)phosphor::network::netlink::intfFromRtm(input);
   38|    186|    }
   39|    186|    catch (...)
   40|    186|    {
   41|    161|    }
   42|       |
   43|       |    // 2. Test addrFromRtm
   44|    186|    try
   45|    186|    {
   46|    186|        (void)phosphor::network::netlink::addrFromRtm(input);
   47|    186|    }
   48|    186|    catch (...)
   49|    186|    {
   50|    185|    }
   51|       |
   52|       |    // 3. Test neighFromRtm
   53|    186|    try
   54|    186|    {
   55|    186|        (void)phosphor::network::netlink::neighFromRtm(input);
   56|    186|    }
   57|    186|    catch (...)
   58|    186|    {
   59|    172|    }
   60|       |
   61|       |    // 4. Test gatewayFromRtm
   62|    186|    try
   63|    186|    {
   64|    186|        (void)phosphor::network::netlink::gatewayFromRtm(input);
   65|    186|    }
   66|    186|    catch (...)
   67|    186|    {
   68|     32|    }
   69|       |
   70|       |    // 5. Test extractRtAttr in a loop
   71|    186|    {
   72|    186|        std::string_view attrInput = input;
   73|    186|        while (!attrInput.empty())
  ------------------
  |  Branch (73:16): [True: 186, False: 0]
  ------------------
   74|    186|        {
   75|    186|            try
   76|    186|            {
   77|    186|                auto [hdr, attrData] =
   78|    186|                    phosphor::network::netlink::extractRtAttr(attrInput);
   79|    186|                (void)hdr;
   80|    186|                (void)attrData;
   81|    186|            }
   82|    186|            catch (...)
   83|    186|            {
   84|    186|                break;
   85|    186|            }
   86|    186|        }
   87|    186|    }
   88|       |
   89|       |    // 6. Test detail::processMsg
   90|    186|    {
   91|    186|        std::string_view msgInput = input;
   92|    186|        bool done = true;
   93|    186|        auto cb = [](const nlmsghdr&, std::string_view) {};
   94|    186|        try
   95|    186|        {
   96|    186|            phosphor::network::netlink::detail::processMsg(msgInput, done, cb);
   97|    186|        }
   98|    186|        catch (...)
   99|    186|        {
  100|    186|        }
  101|    186|    }
  102|       |
  103|    186|    return 0;
  104|    186|}

_ZN8phosphor7network7netlink6detail10processMsgERNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERbN7stdplus13function_viewIFvRK8nlmsghdrS7_EEE:
   27|    186|{
   28|       |    // Parse and update the message buffer
   29|    186|    const auto& hdr = stdplus::raw::refFrom<nlmsghdr, Aligned>(msgs);
   30|    186|    if (hdr.nlmsg_len < sizeof(hdr))
  ------------------
  |  Branch (30:9): [True: 0, False: 186]
  ------------------
   31|      0|    {
   32|      0|        throw std::runtime_error(
   33|      0|            std::format("nlmsg length shorter than header: {} < {}",
   34|      0|                        hdr.nlmsg_len, sizeof(hdr)));
   35|      0|    }
   36|    186|    if (msgs.size() < hdr.nlmsg_len)
  ------------------
  |  Branch (36:9): [True: 133, False: 53]
  ------------------
   37|    133|    {
   38|    133|        throw std::runtime_error(
   39|    133|            std::format("not enough message for nlmsg: {} < {}", msgs.size(),
   40|    133|                        hdr.nlmsg_len));
   41|    133|    }
   42|     53|    auto msg = msgs.substr(NLMSG_HDRLEN, hdr.nlmsg_len - NLMSG_HDRLEN);
   43|     53|    msgs.remove_prefix(NLMSG_ALIGN(hdr.nlmsg_len));
   44|       |
   45|       |    // Figure out how to handle the individual message
   46|     53|    bool doCallback = true;
   47|     53|    if (hdr.nlmsg_flags & NLM_F_MULTI)
  ------------------
  |  Branch (47:9): [True: 0, False: 53]
  ------------------
   48|      0|    {
   49|      0|        done = false;
   50|      0|    }
   51|     53|    if (hdr.nlmsg_type == NLMSG_NOOP)
  ------------------
  |  Branch (51:9): [True: 0, False: 53]
  ------------------
   52|      0|    {
   53|      0|        doCallback = false;
   54|      0|    }
   55|     53|    else if (hdr.nlmsg_type == NLMSG_DONE)
  ------------------
  |  Branch (55:14): [True: 0, False: 53]
  ------------------
   56|      0|    {
   57|      0|        if (done)
  ------------------
  |  Branch (57:13): [True: 0, False: 0]
  ------------------
   58|      0|        {
   59|      0|            throw std::runtime_error("Got done for non-multi msg");
   60|      0|        }
   61|      0|        done = true;
   62|      0|        doCallback = false;
   63|      0|    }
   64|     53|    else if (hdr.nlmsg_type == NLMSG_ERROR)
  ------------------
  |  Branch (64:14): [True: 0, False: 53]
  ------------------
   65|      0|    {
   66|      0|        const auto& err = stdplus::raw::refFrom<nlmsgerr, Aligned>(msg);
   67|       |        // This is just an ACK so don't do the callback
   68|      0|        if (err.error <= 0)
  ------------------
  |  Branch (68:13): [True: 0, False: 0]
  ------------------
   69|      0|        {
   70|      0|            doCallback = false;
   71|      0|        }
   72|      0|    }
   73|       |    // All multi-msg headers must have the multi flag
   74|     53|    if (!done && !(hdr.nlmsg_flags & NLM_F_MULTI))
  ------------------
  |  Branch (74:9): [True: 0, False: 53]
  |  Branch (74:18): [True: 0, False: 0]
  ------------------
   75|      0|    {
   76|      0|        throw std::runtime_error("Got non-multi msg before done");
   77|      0|    }
   78|     53|    if (doCallback)
  ------------------
  |  Branch (78:9): [True: 0, False: 53]
  ------------------
   79|      0|    {
   80|      0|        cb(hdr, msg);
   81|      0|    }
   82|     53|}
_ZN8phosphor7network7netlink13extractRtAttrERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  184|    632|{
  185|    632|    const auto& hdr = stdplus::raw::refFrom<rtattr, Aligned>(data);
  186|    632|    if (hdr.rta_len < RTA_LENGTH(0))
  ------------------
  |  Branch (186:9): [True: 37, False: 595]
  ------------------
  187|     37|    {
  188|     37|        throw std::runtime_error(std::format(
  189|     37|            "rtattr shorter than header: {} < {}", hdr.rta_len, RTA_LENGTH(0)));
  190|     37|    }
  191|    595|    if (data.size() < hdr.rta_len)
  ------------------
  |  Branch (191:9): [True: 525, False: 70]
  ------------------
  192|    525|    {
  193|    525|        throw std::runtime_error(
  194|    525|            std::format("not enough message for rtattr: {} < {}", data.size(),
  195|    525|                        hdr.rta_len));
  196|    525|    }
  197|     70|    auto attr = data.substr(RTA_LENGTH(0), hdr.rta_len - RTA_LENGTH(0));
  198|       |    data.remove_prefix(RTA_ALIGN(hdr.rta_len));
  199|     70|    return {hdr, attr};
  200|    595|}

_ZN8phosphor7network7netlink13extractRtDataI9ifinfomsgEERKT_RNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
   48|    186|{
   49|    186|    const T& ret = stdplus::raw::refFrom<T, stdplus::raw::Aligned>(data);
   50|       |    data.remove_prefix(NLMSG_ALIGN(sizeof(T)));
   51|    186|    return ret;
   52|    186|}
_ZN8phosphor7network7netlink13extractRtDataI5rtmsgEERKT_RNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
   48|    186|{
   49|    186|    const T& ret = stdplus::raw::refFrom<T, stdplus::raw::Aligned>(data);
   50|       |    data.remove_prefix(NLMSG_ALIGN(sizeof(T)));
   51|    186|    return ret;
   52|    186|}
_ZN8phosphor7network7netlink13extractRtDataI9ifaddrmsgEERKT_RNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
   48|    186|{
   49|    186|    const T& ret = stdplus::raw::refFrom<T, stdplus::raw::Aligned>(data);
   50|       |    data.remove_prefix(NLMSG_ALIGN(sizeof(T)));
   51|    186|    return ret;
   52|    186|}
_ZN8phosphor7network7netlink13extractRtDataI5ndmsgEERKT_RNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
   48|    186|{
   49|    186|    const T& ret = stdplus::raw::refFrom<T, stdplus::raw::Aligned>(data);
   50|       |    data.remove_prefix(NLMSG_ALIGN(sizeof(T)));
   51|    186|    return ret;
   52|    186|}

_ZN8phosphor7network7netlink11intfFromRtmENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   55|    186|{
   56|    186|    const auto& ifinfo = netlink::extractRtData<ifinfomsg>(msg);
   57|    186|    InterfaceInfo ret;
   58|    186|    ret.type = ifinfo.ifi_type;
   59|    186|    ret.idx = ifinfo.ifi_index;
   60|    186|    ret.flags = ifinfo.ifi_flags;
   61|    196|    while (!msg.empty())
  ------------------
  |  Branch (61:12): [True: 118, False: 78]
  ------------------
   62|    118|    {
   63|    118|        auto [hdr, data] = netlink::extractRtAttr(msg);
   64|    118|        switch (hdr.rta_type)
  ------------------
  |  Branch (64:17): [True: 1, False: 117]
  ------------------
   65|    118|        {
   66|      1|            case IFLA_IFNAME:
  ------------------
  |  Branch (66:13): [True: 1, False: 117]
  ------------------
   67|      1|                ret.name.emplace(data.begin(), data.end() - 1);
   68|      1|                break;
   69|      0|            case IFLA_ADDRESS:
  ------------------
  |  Branch (69:13): [True: 0, False: 118]
  ------------------
   70|      0|                if (data.size() == sizeof(stdplus::EtherAddr))
  ------------------
  |  Branch (70:21): [True: 0, False: 0]
  ------------------
   71|      0|                {
   72|      0|                    ret.mac.emplace(
   73|      0|                        stdplus::raw::copyFrom<stdplus::EtherAddr>(data));
   74|      0|                }
   75|      0|                break;
   76|      0|            case IFLA_MTU:
  ------------------
  |  Branch (76:13): [True: 0, False: 118]
  ------------------
   77|      0|                ret.mtu.emplace(stdplus::raw::copyFrom<unsigned>(data));
   78|      0|                break;
   79|      0|            case IFLA_LINK:
  ------------------
  |  Branch (79:13): [True: 0, False: 118]
  ------------------
   80|      0|                ret.parent_idx.emplace(stdplus::raw::copyFrom<unsigned>(data));
   81|      0|                break;
   82|      0|            case IFLA_LINKINFO:
  ------------------
  |  Branch (82:13): [True: 0, False: 118]
  ------------------
   83|      0|                parseLinkInfo(ret, data);
   84|      0|                break;
   85|    118|        }
   86|    118|    }
   87|     78|    return ret;
   88|    186|}
_ZN8phosphor7network7netlink14gatewayFromRtmENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  118|    186|{
  119|    186|    const auto& rtm = extractRtData<rtmsg>(msg);
  120|    186|    if (rtm.rtm_table != RT_TABLE_MAIN || rtm.rtm_dst_len != 0)
  ------------------
  |  Branch (120:9): [True: 186, False: 0]
  |  Branch (120:43): [True: 0, False: 0]
  ------------------
  121|    154|    {
  122|    154|        return std::nullopt;
  123|    154|    }
  124|     32|    switch (rtm.rtm_family)
  ------------------
  |  Branch (124:13): [True: 0, False: 32]
  ------------------
  125|     32|    {
  126|      0|        case AF_INET:
  ------------------
  |  Branch (126:9): [True: 0, False: 32]
  ------------------
  127|      0|            return parse<stdplus::In4Addr>(msg);
  128|      0|        case AF_INET6:
  ------------------
  |  Branch (128:9): [True: 0, False: 32]
  ------------------
  129|      0|            return parse<stdplus::In6Addr>(msg);
  130|     32|    }
  131|      0|    return std::nullopt;
  132|     32|}
_ZN8phosphor7network7netlink11addrFromRtmENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  135|    186|{
  136|    186|    const auto& ifa = extractRtData<ifaddrmsg>(msg);
  137|       |
  138|    186|    uint32_t flags = ifa.ifa_flags;
  139|    186|    std::optional<stdplus::InAnyAddr> addr;
  140|    356|    while (!msg.empty())
  ------------------
  |  Branch (140:12): [True: 170, False: 186]
  ------------------
  141|    170|    {
  142|    170|        auto [hdr, data] = extractRtAttr(msg);
  143|    170|        if (hdr.rta_type == IFA_ADDRESS)
  ------------------
  |  Branch (143:13): [True: 1, False: 169]
  ------------------
  144|      1|        {
  145|      1|            addr.emplace(addrFromBuf(ifa.ifa_family, data));
  146|      1|        }
  147|    169|        else if (hdr.rta_type == IFA_FLAGS)
  ------------------
  |  Branch (147:18): [True: 0, False: 169]
  ------------------
  148|      0|        {
  149|      0|            flags = stdplus::raw::copyFromStrict<uint32_t>(data);
  150|      0|        }
  151|    170|    }
  152|    186|    if (!addr)
  ------------------
  |  Branch (152:9): [True: 1, False: 185]
  ------------------
  153|      1|    {
  154|      1|        throw std::runtime_error("Missing address");
  155|      1|    }
  156|    185|    return AddressInfo{.ifidx = ifa.ifa_index,
  157|    185|                       .ifaddr = stdplus::SubnetAny{*addr, ifa.ifa_prefixlen},
  158|    185|                       .scope = ifa.ifa_scope,
  159|    185|                       .flags = flags};
  160|    186|}
_ZN8phosphor7network7netlink12neighFromRtmENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  163|    186|{
  164|    186|    const auto& ndm = netlink::extractRtData<ndmsg>(msg);
  165|       |
  166|    186|    NeighborInfo ret;
  167|    186|    ret.ifidx = ndm.ndm_ifindex;
  168|    186|    ret.state = ndm.ndm_state;
  169|    344|    while (!msg.empty())
  ------------------
  |  Branch (169:12): [True: 158, False: 186]
  ------------------
  170|    158|    {
  171|    158|        auto [hdr, data] = netlink::extractRtAttr(msg);
  172|    158|        if (hdr.rta_type == NDA_LLADDR)
  ------------------
  |  Branch (172:13): [True: 0, False: 158]
  ------------------
  173|      0|        {
  174|      0|            ret.mac = stdplus::raw::copyFrom<stdplus::EtherAddr>(data);
  175|      0|        }
  176|    158|        else if (hdr.rta_type == NDA_DST)
  ------------------
  |  Branch (176:18): [True: 0, False: 158]
  ------------------
  177|      0|        {
  178|      0|            ret.addr = addrFromBuf(ndm.ndm_family, data);
  179|      0|        }
  180|    158|    }
  181|    186|    return ret;
  182|    186|}

_ZN8phosphor7network11addrFromBufEiNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   28|      1|{
   29|      1|    switch (family)
  ------------------
  |  Branch (29:13): [True: 1, False: 0]
  ------------------
   30|      1|    {
   31|      1|        case AF_INET:
  ------------------
  |  Branch (31:9): [True: 1, False: 0]
  ------------------
   32|      1|            return stdplus::raw::copyFromStrict<stdplus::In4Addr>(buf);
   33|      0|        case AF_INET6:
  ------------------
  |  Branch (33:9): [True: 0, False: 1]
  ------------------
   34|      0|            return stdplus::raw::copyFromStrict<stdplus::In6Addr>(buf);
   35|      1|    }
   36|      0|    throw std::invalid_argument("Unrecognized family");
   37|      1|}

rtnetlink_fuzzer.cpp:_ZN7stdplus13function_viewIFvRK8nlmsghdrNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEC2ITkNS_6detail8NonFViewERZ22LLVMFuzzerTestOneInputE3$_0EEOT_:
  155|    186|    inline function_view(F&& f) noexcept : _Base(std::forward<F>(f))
  156|    186|    {}
rtnetlink_fuzzer.cpp:_ZN7stdplus6detail18function_view_baseIvLb0ELb0EJRK8nlmsghdrNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEC2ITkNS5_9invocableIDpT2_EEZ22LLVMFuzzerTestOneInputE3$_0QaantT0_sr3stdE7same_asINS5_20__invoke_result_implIvJTL0__SE_EE4typeET_EEERSK_:
   80|    186|        memfun([](void* v, Args... args) {
   81|    186|            return (*reinterpret_cast<F*>(v))(std::forward<Args>(args)...);
   82|    186|        }),
   83|    186|        obj(std::addressof(f))
   84|    186|    {}

_ZN7stdplus7In4AddrC2Ev:
   36|      1|    constexpr In4Addr() noexcept : In4AddrInner({.s4_addr = {}}) {}
_ZN7stdplus9InAnyAddrC2ENS_7In4AddrE:
  397|      1|    constexpr InAnyAddr(In4Addr a) noexcept : detail::InAnyAddrV(a) {}

_ZN7stdplus6detail8addrBitsINS_7In4AddrEEEmT_:
   71|      1|{
   72|      1|    return sizeof(a) << 3;
   73|      1|}
_ZN7stdplus9SubnetAnyC2ENS_9InAnyAddrEh:
  186|      1|    constexpr SubnetAny(InAnyAddr addr, Pfx pfx) : addr(addr), pfx(pfx)
  187|      1|    {
  188|      1|        if (std::visit([](auto v) { return detail::addrBits(v); }, addr) < pfx)
  ------------------
  |  Branch (188:13): [True: 0, False: 1]
  ------------------
  189|      0|        {
  190|      0|            detail::invalidSubnetPfx(pfx);
  191|      0|        }
  192|      1|    }
_ZZN7stdplus9SubnetAnyC1ENS_9InAnyAddrEhENKUlT_E_clINS_7In4AddrEEEDaS2_:
  188|      1|        if (std::visit([](auto v) { return detail::addrBits(v); }, addr) < pfx)

_ZN7stdplus3raw7refFromITkNS_17TriviallyCopyableE8nlmsghdrNS0_7AlignedETkNS0_6detail15ContainsTrivialERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEKS2_EERT2_OT1_:
  115|    186|    {                                                                          \
  116|    186|        static_assert(std::is_same_v<A, Aligned> ||                            \
  117|    186|                      sizeof(*std::data(c)) % alignof(Tp) == 0);               \
  118|    186|        const size_t bytes = std::size(c) * sizeof(*std::data(c));             \
  119|    186|        if (bytes comp sizeof(Tp))                                             \
  ------------------
  |  Branch (119:13): [True: 53, False: 133]
  ------------------
  120|    186|        {                                                                      \
  121|     53|            throw exception::Incomplete(                                       \
  122|     53|                std::format(#func ": {} < {}", bytes, sizeof(Tp)));            \
  123|     53|        }                                                                      \
  124|    186|        return *reinterpret_cast<Tp*>(std::data(c));                           \
  125|    186|    }
_ZN7stdplus3raw7refFromITkNS_17TriviallyCopyableE6rtattrNS0_7AlignedETkNS0_6detail15ContainsTrivialERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEKS2_EERT2_OT1_:
  115|    632|    {                                                                          \
  116|    632|        static_assert(std::is_same_v<A, Aligned> ||                            \
  117|    632|                      sizeof(*std::data(c)) % alignof(Tp) == 0);               \
  118|    632|        const size_t bytes = std::size(c) * sizeof(*std::data(c));             \
  119|    632|        if (bytes comp sizeof(Tp))                                             \
  ------------------
  |  Branch (119:13): [True: 33, False: 599]
  ------------------
  120|    632|        {                                                                      \
  121|     33|            throw exception::Incomplete(                                       \
  122|     33|                std::format(#func ": {} < {}", bytes, sizeof(Tp)));            \
  123|     33|        }                                                                      \
  124|    632|        return *reinterpret_cast<Tp*>(std::data(c));                           \
  125|    632|    }
_ZN7stdplus3raw7refFromITkNS_17TriviallyCopyableE9ifinfomsgNS0_7AlignedETkNS0_6detail15ContainsTrivialERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEKS2_EERT2_OT1_:
  115|    186|    {                                                                          \
  116|    186|        static_assert(std::is_same_v<A, Aligned> ||                            \
  117|    186|                      sizeof(*std::data(c)) % alignof(Tp) == 0);               \
  118|    186|        const size_t bytes = std::size(c) * sizeof(*std::data(c));             \
  119|    186|        if (bytes comp sizeof(Tp))                                             \
  ------------------
  |  Branch (119:13): [True: 53, False: 133]
  ------------------
  120|    186|        {                                                                      \
  121|     53|            throw exception::Incomplete(                                       \
  122|     53|                std::format(#func ": {} < {}", bytes, sizeof(Tp)));            \
  123|     53|        }                                                                      \
  124|    186|        return *reinterpret_cast<Tp*>(std::data(c));                           \
  125|    186|    }
_ZN7stdplus3raw7refFromITkNS_17TriviallyCopyableE5rtmsgNS0_7AlignedETkNS0_6detail15ContainsTrivialERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEKS2_EERT2_OT1_:
  115|    186|    {                                                                          \
  116|    186|        static_assert(std::is_same_v<A, Aligned> ||                            \
  117|    186|                      sizeof(*std::data(c)) % alignof(Tp) == 0);               \
  118|    186|        const size_t bytes = std::size(c) * sizeof(*std::data(c));             \
  119|    186|        if (bytes comp sizeof(Tp))                                             \
  ------------------
  |  Branch (119:13): [True: 32, False: 154]
  ------------------
  120|    186|        {                                                                      \
  121|     32|            throw exception::Incomplete(                                       \
  122|     32|                std::format(#func ": {} < {}", bytes, sizeof(Tp)));            \
  123|     32|        }                                                                      \
  124|    186|        return *reinterpret_cast<Tp*>(std::data(c));                           \
  125|    186|    }
_ZN7stdplus3raw7refFromITkNS_17TriviallyCopyableE9ifaddrmsgNS0_7AlignedETkNS0_6detail15ContainsTrivialERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEKS2_EERT2_OT1_:
  115|    186|    {                                                                          \
  116|    186|        static_assert(std::is_same_v<A, Aligned> ||                            \
  117|    186|                      sizeof(*std::data(c)) % alignof(Tp) == 0);               \
  118|    186|        const size_t bytes = std::size(c) * sizeof(*std::data(c));             \
  119|    186|        if (bytes comp sizeof(Tp))                                             \
  ------------------
  |  Branch (119:13): [True: 23, False: 163]
  ------------------
  120|    186|        {                                                                      \
  121|     23|            throw exception::Incomplete(                                       \
  122|     23|                std::format(#func ": {} < {}", bytes, sizeof(Tp)));            \
  123|     23|        }                                                                      \
  124|    186|        return *reinterpret_cast<Tp*>(std::data(c));                           \
  125|    186|    }
_ZN7stdplus3raw14copyFromStrictITkNS_17TriviallyCopyableENS_7In4AddrETkNS0_6detail15ContainsTrivialENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEET_RKT0_:
   81|      1|    {                                                                          \
   82|      1|        T ret;                                                                 \
   83|      1|        const size_t bytes = std::size(c) * sizeof(*std::data(c));             \
   84|      1|        if (bytes comp sizeof(ret))                                            \
  ------------------
  |  Branch (84:13): [True: 0, False: 1]
  ------------------
   85|      1|        {                                                                      \
   86|      0|            throw exception::Incomplete(                                       \
   87|      0|                std::format(#func ": {} < {}", bytes, sizeof(ret)));           \
   88|      0|        }                                                                      \
   89|      1|        const auto c_bytes = reinterpret_cast<const std::byte*>(std::data(c)); \
   90|      1|        const auto ret_bytes = reinterpret_cast<std::byte*>(&ret);             \
   91|      1|        std::copy(c_bytes, c_bytes + sizeof(ret), ret_bytes);                  \
   92|      1|        return ret;                                                            \
   93|      1|    }
_ZN7stdplus3raw7refFromITkNS_17TriviallyCopyableE5ndmsgNS0_7AlignedETkNS0_6detail15ContainsTrivialERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEKS2_EERT2_OT1_:
  115|    186|    {                                                                          \
  116|    186|        static_assert(std::is_same_v<A, Aligned> ||                            \
  117|    186|                      sizeof(*std::data(c)) % alignof(Tp) == 0);               \
  118|    186|        const size_t bytes = std::size(c) * sizeof(*std::data(c));             \
  119|    186|        if (bytes comp sizeof(Tp))                                             \
  ------------------
  |  Branch (119:13): [True: 32, False: 154]
  ------------------
  120|    186|        {                                                                      \
  121|     32|            throw exception::Incomplete(                                       \
  122|     32|                std::format(#func ": {} < {}", bytes, sizeof(Tp)));            \
  123|     32|        }                                                                      \
  124|    186|        return *reinterpret_cast<Tp*>(std::data(c));                           \
  125|    186|    }

_ZN7stdplus9exception10IncompleteC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   30|    226|    std::system_error(std::make_error_code(std::errc::illegal_byte_sequence),
   31|    226|                      what)
   32|    226|{}