_ZN11ArgsManagerD2Ev: 130| 2|ArgsManager::~ArgsManager() = default; _Z16htole16_internalt: 19| 946|{ 20| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(host_16bits); 21| 946| else return host_16bits; 22| 946|} _Z16htole32_internalj: 39| 17.1M|{ 40| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits); 41| 17.1M| else return host_32bits; 42| 17.1M|} _ZN15ChaCha20AlignedD2Ev: 42| 4|{ 43| 4| memory_cleanse(input, sizeof(input)); 44| 4|} _ZN8ChaCha20D2Ev: 332| 4|{ 333| 4| memory_cleanse(m_buffer.data(), m_buffer.size()); 334| 4|} _ZN9ChainCodeD2Ev: 28| 2| ~ChainCode() { memory_cleanse(data(), size()); } _ZN11CNetCleanupD2Ev: 3676| 2| { 3677| |#ifdef WIN32 3678| | // Shutdown Windows Sockets 3679| | WSACleanup(); 3680| |#endif 3681| 2| } _ZN9prevectorILj8EijiEC2Ev: 196| 4.08k| prevector() = default; _ZN9prevectorILj8EijiED2Ev: 422| 8.16k| ~prevector() { 423| 8.16k| if (!is_direct()) { ------------------ | Branch (423:13): [True: 3.08k, False: 5.07k] ------------------ 424| 3.08k| free(_union.indirect_contents.indirect); 425| 3.08k| _union.indirect_contents.indirect = nullptr; 426| 3.08k| } 427| 8.16k| } _ZNK9prevectorILj8EijiE9is_directEv: 126| 71.8M| bool is_direct() const { return _size <= N; } _ZN9prevectorILj8EijiE6insertENS0_8iteratorERKi: 307| 113k| iterator insert(iterator pos, const T& value) { 308| 113k| size_type p = pos - begin(); 309| 113k| size_type new_size = size() + 1; 310| 113k| if (capacity() < new_size) { ------------------ | Branch (310:13): [True: 3.94k, False: 109k] ------------------ 311| 3.94k| change_capacity(new_size + (new_size >> 1)); 312| 3.94k| } 313| 113k| T* ptr = item_ptr(p); 314| 113k| T* dst = ptr + 1; 315| 113k| memmove(dst, ptr, (size() - p) * sizeof(T)); 316| 113k| _size++; 317| 113k| new(static_cast(ptr)) T(value); 318| 113k| return iterator(ptr); 319| 113k| } _ZmiN9prevectorILj8EijiE8iteratorES1_: 68| 342k| difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); } _ZNK9prevectorILj8EijiE8iteratordeEv: 61| 1.37M| T& operator*() const { return *ptr; } _ZNK9prevectorILj8EijiE4sizeEv: 247| 9.72M| size_type size() const { 248| 9.72M| return is_direct() ? _size : _size - N - 1; ------------------ | Branch (248:16): [True: 338k, False: 9.39M] ------------------ 249| 9.72M| } _ZNK9prevectorILj8EijiE8capacityEv: 260| 378k| size_t capacity() const { 261| 378k| if (is_direct()) { ------------------ | Branch (261:13): [True: 97.7k, False: 280k] ------------------ 262| 97.7k| return N; 263| 280k| } else { 264| 280k| return _union.indirect_contents.capacity; 265| 280k| } 266| 378k| } _ZN9prevectorILj8EijiE15change_capacityEj: 128| 78.1k| void change_capacity(size_type new_capacity) { 129| 78.1k| if (new_capacity <= N) { ------------------ | Branch (129:13): [True: 21.7k, False: 56.4k] ------------------ 130| 21.7k| if (!is_direct()) { ------------------ | Branch (130:17): [True: 5.53k, False: 16.1k] ------------------ 131| 5.53k| T* indirect = indirect_ptr(0); 132| 5.53k| T* src = indirect; 133| 5.53k| T* dst = direct_ptr(0); 134| 5.53k| memcpy(dst, src, size() * sizeof(T)); 135| 5.53k| free(indirect); 136| 5.53k| _size -= N + 1; 137| 5.53k| } 138| 56.4k| } else { 139| 56.4k| if (!is_direct()) { ------------------ | Branch (139:17): [True: 30.4k, False: 25.9k] ------------------ 140| | /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert 141| | success. These should instead use an allocator or new/delete so that handlers 142| | are called as necessary, but performance would be slightly degraded by doing so. */ 143| 30.4k| _union.indirect_contents.indirect = static_cast(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity)); 144| 30.4k| assert(_union.indirect_contents.indirect); ------------------ | Branch (144:17): [True: 30.4k, False: 0] ------------------ 145| 30.4k| _union.indirect_contents.capacity = new_capacity; 146| 30.4k| } else { 147| 25.9k| char* new_indirect = static_cast(malloc(((size_t)sizeof(T)) * new_capacity)); 148| 25.9k| assert(new_indirect); ------------------ | Branch (148:17): [True: 25.9k, False: 0] ------------------ 149| 25.9k| T* src = direct_ptr(0); 150| 25.9k| T* dst = reinterpret_cast(new_indirect); 151| 25.9k| memcpy(dst, src, size() * sizeof(T)); 152| 25.9k| _union.indirect_contents.indirect = new_indirect; 153| 25.9k| _union.indirect_contents.capacity = new_capacity; 154| 25.9k| _size += N + 1; 155| 25.9k| } 156| 56.4k| } 157| 78.1k| } _ZN9prevectorILj8EijiE12indirect_ptrEi: 124| 1.07M| T* indirect_ptr(difference_type pos) { return reinterpret_cast(_union.indirect_contents.indirect) + pos; } _ZN9prevectorILj8EijiE10direct_ptrEi: 122| 308k| T* direct_ptr(difference_type pos) { return reinterpret_cast(_union.direct) + pos; } _ZN9prevectorILj8EijiE8item_ptrEi: 159| 1.34M| T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); } ------------------ | Branch (159:47): [True: 277k, False: 1.06M] ------------------ _ZN9prevectorILj8EijiE8iteratorC2EPi: 60| 1.26M| iterator(T* ptr_) : ptr(ptr_) {} _ZN9prevectorILj8EijiE5beginEv: 255| 438k| iterator begin() { return iterator(item_ptr(0)); } _ZNK9prevectorILj8EijiE8iteratorplEj: 69| 290k| iterator operator+(size_type n) const { return iterator(ptr + n); } _ZN9prevectorILj8EijiE6resizeEj: 276| 158k| void resize(size_type new_size) { 277| 158k| size_type cur_size = size(); 278| 158k| if (cur_size == new_size) { ------------------ | Branch (278:13): [True: 71.8k, False: 86.6k] ------------------ 279| 71.8k| return; 280| 71.8k| } 281| 86.6k| if (cur_size > new_size) { ------------------ | Branch (281:13): [True: 75.5k, False: 11.0k] ------------------ 282| 75.5k| erase(item_ptr(new_size), end()); 283| 75.5k| return; 284| 75.5k| } 285| 11.0k| if (new_size > capacity()) { ------------------ | Branch (285:13): [True: 1.66k, False: 9.40k] ------------------ 286| 1.66k| change_capacity(new_size); 287| 1.66k| } 288| 11.0k| ptrdiff_t increase = new_size - cur_size; 289| 11.0k| fill(item_ptr(cur_size), increase); 290| 11.0k| _size += increase; 291| 11.0k| } _ZN9prevectorILj8EijiE5eraseENS0_8iteratorES1_: 368| 173k| iterator erase(iterator first, iterator last) { 369| | // Erase is not allowed to the change the object's capacity. That means 370| | // that when starting with an indirectly allocated prevector with 371| | // size and capacity > N, the result may be a still indirectly allocated 372| | // prevector with size <= N and capacity > N. A shrink_to_fit() call is 373| | // necessary to switch to the (more efficient) directly allocated 374| | // representation (with capacity N and size <= N). 375| 173k| iterator p = first; 376| 173k| char* endp = (char*)&(*end()); 377| 173k| _size -= last - p; 378| 173k| memmove(&(*first), &(*last), endp - ((char*)(&(*last)))); 379| 173k| return first; 380| 173k| } _ZN9prevectorILj8EijiE3endEv: 257| 307k| iterator end() { return iterator(item_ptr(size())); } _ZN9prevectorILj8EijiE4fillEPilRKi: 162| 69.1k| void fill(T* dst, ptrdiff_t count, const T& value = T{}) { 163| 69.1k| std::fill_n(dst, count, value); 164| 69.1k| } _ZN9prevectorILj8EijiE6insertENS0_8iteratorEjRKi: 321| 26.4k| void insert(iterator pos, size_type count, const T& value) { 322| 26.4k| size_type p = pos - begin(); 323| 26.4k| size_type new_size = size() + count; 324| 26.4k| if (capacity() < new_size) { ------------------ | Branch (324:13): [True: 1.89k, False: 24.5k] ------------------ 325| 1.89k| change_capacity(new_size + (new_size >> 1)); 326| 1.89k| } 327| 26.4k| T* ptr = item_ptr(p); 328| 26.4k| T* dst = ptr + count; 329| 26.4k| memmove(dst, ptr, (size() - p) * sizeof(T)); 330| 26.4k| _size += count; 331| 26.4k| fill(item_ptr(p), count, value); 332| 26.4k| } _ZN9prevectorILj8EijiE9push_backERKi: 392| 32.5k| void push_back(const T& value) { 393| 32.5k| emplace_back(value); 394| 32.5k| } _ZN9prevectorILj8EijiE12emplace_backIJRKiEEEvDpOT_: 383| 32.5k| void emplace_back(Args&&... args) { 384| 32.5k| size_type new_size = size() + 1; 385| 32.5k| if (capacity() < new_size) { ------------------ | Branch (385:13): [True: 1.81k, False: 30.7k] ------------------ 386| 1.81k| change_capacity(new_size + (new_size >> 1)); 387| 1.81k| } 388| 32.5k| new(item_ptr(size())) T(std::forward(args)...); 389| 32.5k| _size++; 390| 32.5k| } _ZN9prevectorILj8EijiE6insertITkNSt3__114input_iteratorEPiEEvNS0_8iteratorET_S5_: 335| 29.2k| void insert(iterator pos, InputIterator first, InputIterator last) { 336| 29.2k| size_type p = pos - begin(); 337| 29.2k| difference_type count = last - first; 338| 29.2k| size_type new_size = size() + count; 339| 29.2k| if (capacity() < new_size) { ------------------ | Branch (339:13): [True: 2.54k, False: 26.6k] ------------------ 340| 2.54k| change_capacity(new_size + (new_size >> 1)); 341| 2.54k| } 342| 29.2k| T* ptr = item_ptr(p); 343| 29.2k| T* dst = ptr + count; 344| 29.2k| memmove(dst, ptr, (size() - p) * sizeof(T)); 345| 29.2k| _size += count; 346| 29.2k| fill(ptr, first, last); 347| 29.2k| } _ZN9prevectorILj8EijiE4fillITkNSt3__114input_iteratorEPiEEvS3_T_S4_: 167| 29.2k| void fill(T* dst, InputIterator first, InputIterator last) { 168| 95.4k| while (first != last) { ------------------ | Branch (168:16): [True: 66.1k, False: 29.2k] ------------------ 169| 66.1k| new(static_cast(dst)) T(*first); 170| 66.1k| ++dst; 171| 66.1k| ++first; 172| 66.1k| } 173| 29.2k| } _ZN9prevectorILj8EijiE20resize_uninitializedEj: 349| 47.7k| inline void resize_uninitialized(size_type new_size) { 350| | // resize_uninitialized changes the size of the prevector but does not initialize it. 351| | // If size < new_size, the added elements must be initialized explicitly. 352| 47.7k| if (capacity() < new_size) { ------------------ | Branch (352:13): [True: 3.81k, False: 43.9k] ------------------ 353| 3.81k| change_capacity(new_size); 354| 3.81k| _size += new_size - size(); 355| 3.81k| return; 356| 3.81k| } 357| 43.9k| if (new_size < size()) { ------------------ | Branch (357:13): [True: 15.0k, False: 28.8k] ------------------ 358| 15.0k| erase(item_ptr(new_size), end()); 359| 28.8k| } else { 360| 28.8k| _size += new_size - size(); 361| 28.8k| } 362| 43.9k| } _ZN9prevectorILj8EijiEixEj: 268| 200k| T& operator[](size_type pos) { 269| 200k| return *item_ptr(pos); 270| 200k| } _ZN9prevectorILj8EijiE7reserveEj: 293| 27.3k| void reserve(size_type new_capacity) { 294| 27.3k| if (new_capacity > capacity()) { ------------------ | Branch (294:13): [True: 17.9k, False: 9.37k] ------------------ 295| 17.9k| change_capacity(new_capacity); 296| 17.9k| } 297| 27.3k| } _ZN9prevectorILj8EijiE13shrink_to_fitEv: 299| 27.5k| void shrink_to_fit() { 300| 27.5k| change_capacity(size()); 301| 27.5k| } _ZN9prevectorILj8EijiE5clearEv: 303| 113k| void clear() { 304| 113k| resize(0); 305| 113k| } _ZN9prevectorILj8EijiE6assignEjRKi: 176| 31.6k| void assign(size_type n, const T& val) { 177| 31.6k| clear(); 178| 31.6k| if (capacity() < n) { ------------------ | Branch (178:13): [True: 10.9k, False: 20.6k] ------------------ 179| 10.9k| change_capacity(n); 180| 10.9k| } 181| 31.6k| _size += n; 182| 31.6k| fill(item_ptr(0), n, val); 183| 31.6k| } _ZN9prevectorILj8EijiE4swapERS0_: 417| 32.7k| { 418| 32.7k| std::swap(_union, other._union); 419| 32.7k| std::swap(_size, other._size); 420| 32.7k| } _ZN9prevectorILj8EijiEaSERKS0_: 229| 31.2k| prevector& operator=(const prevector& other) { 230| 31.2k| if (&other == this) { ------------------ | Branch (230:13): [True: 0, False: 31.2k] ------------------ 231| 0| return *this; 232| 0| } 233| 31.2k| assign(other.begin(), other.end()); 234| 31.2k| return *this; 235| 31.2k| } _ZN9prevectorILj8EijiE6assignITkNSt3__114input_iteratorENS0_14const_iteratorEEEvT_S4_: 186| 31.2k| void assign(InputIterator first, InputIterator last) { 187| 31.2k| size_type n = last - first; 188| 31.2k| clear(); 189| 31.2k| if (capacity() < n) { ------------------ | Branch (189:13): [True: 2.00k, False: 29.2k] ------------------ 190| 2.00k| change_capacity(n); 191| 2.00k| } 192| 31.2k| _size += n; 193| 31.2k| fill(item_ptr(0), first, last); 194| 31.2k| } _ZmiN9prevectorILj8EijiE14const_iteratorES1_: 96| 33.3k| difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); } _ZNK9prevectorILj8EijiE14const_iteratordeEv: 89| 120M| const T& operator*() const { return *ptr; } _ZN9prevectorILj8EijiE4fillITkNSt3__114input_iteratorENS0_14const_iteratorEEEvPiT_S5_: 167| 33.3k| void fill(T* dst, InputIterator first, InputIterator last) { 168| 59.9M| while (first != last) { ------------------ | Branch (168:16): [True: 59.9M, False: 33.3k] ------------------ 169| 59.9M| new(static_cast(dst)) T(*first); 170| 59.9M| ++dst; 171| 59.9M| ++first; 172| 59.9M| } 173| 33.3k| } _ZNK9prevectorILj8EijiE14const_iteratoreqES1_: 102| 102M| bool operator==(const_iterator x) const { return ptr == x.ptr; } _ZN9prevectorILj8EijiE14const_iteratorppEv: 92| 85.7M| const_iterator& operator++() { ptr++; return *this; } _ZNK9prevectorILj8EijiE5beginEv: 256| 17.2M| const_iterator begin() const { return const_iterator(item_ptr(0)); } _ZNK9prevectorILj8EijiE8item_ptrEi: 160| 60.2M| const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); } ------------------ | Branch (160:59): [True: 69.1k, False: 60.1M] ------------------ _ZNK9prevectorILj8EijiE10direct_ptrEi: 123| 69.1k| const T* direct_ptr(difference_type pos) const { return reinterpret_cast(_union.direct) + pos; } _ZNK9prevectorILj8EijiE12indirect_ptrEi: 125| 60.1M| const T* indirect_ptr(difference_type pos) const { return reinterpret_cast(_union.indirect_contents.indirect) + pos; } _ZN9prevectorILj8EijiE14const_iteratorC2EPKi: 87| 51.6M| const_iterator(const T* ptr_) : ptr(ptr_) {} _ZNK9prevectorILj8EijiE3endEv: 258| 8.64M| const_iterator end() const { return const_iterator(item_ptr(size())); } _ZN9prevectorILj8EijiEaSEOS0_: 237| 31.3k| prevector& operator=(prevector&& other) noexcept { 238| 31.3k| if (!is_direct()) { ------------------ | Branch (238:13): [True: 17.3k, False: 13.9k] ------------------ 239| 17.3k| free(_union.indirect_contents.indirect); 240| 17.3k| } 241| 31.3k| _union = std::move(other._union); 242| 31.3k| _size = other._size; 243| 31.3k| other._size = 0; 244| 31.3k| return *this; 245| 31.3k| } _ZN9prevectorILj8EijiE5eraseENS0_8iteratorE: 364| 21.1k| iterator erase(iterator pos) { 365| 21.1k| return erase(pos, pos + 1); 366| 21.1k| } _ZN9prevectorILj8EijiE8pop_backEv: 396| 21.6k| void pop_back() { 397| 21.6k| erase(end() - 1, end()); 398| 21.6k| } _ZNK9prevectorILj8EijiE8iteratormiEj: 72| 21.6k| iterator operator-(size_type n) const { return iterator(ptr - n); } _ZNK9prevectorILj8EijiE5emptyEv: 251| 2.04k| bool empty() const { 252| 2.04k| return size() == 0; 253| 2.04k| } _ZNK9prevectorILj8EijiEixEj: 272| 34.3M| const T& operator[](size_type pos) const { 273| 34.3M| return *item_ptr(pos); 274| 34.3M| } _ZNK9prevectorILj8EijiE14const_iteratorixEj: 91| 8.59M| const T& operator[](size_type pos) const { return ptr[pos]; } _ZNK9prevectorILj8EijiE14const_iteratorplEj: 97| 17.1M| const_iterator operator+(size_type n) const { return const_iterator(ptr + n); } _ZNK9prevectorILj8EijiE14const_iteratormiEj: 100| 8.59M| const_iterator operator-(size_type n) const { return const_iterator(ptr - n); } _ZN9prevectorILj8EijiEC2ITkNSt3__114input_iteratorENS2_11__wrap_iterIPKiEEEET_S7_: 209| 2.04k| prevector(InputIterator first, InputIterator last) { 210| 2.04k| size_type n = last - first; 211| 2.04k| change_capacity(n); 212| 2.04k| _size += n; 213| 2.04k| fill(item_ptr(0), first, last); 214| 2.04k| } _ZN9prevectorILj8EijiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPKiEEEEvPiT_S8_: 167| 2.04k| void fill(T* dst, InputIterator first, InputIterator last) { 168| 8.59M| while (first != last) { ------------------ | Branch (168:16): [True: 8.59M, False: 2.04k] ------------------ 169| 8.59M| new(static_cast(dst)) T(*first); 170| 8.59M| ++dst; 171| 8.59M| ++first; 172| 8.59M| } 173| 2.04k| } _ZNK9prevectorILj8EijiEeqERKS0_: 429| 4.08k| constexpr bool operator==(const prevector& other) const { 430| 4.08k| return std::ranges::equal(*this, other); 431| 4.08k| } _ZNK9prevectorILj8EijiE14const_iteratorptEv: 90| 16.3k| const T* operator->() const { return ptr; } _ZN9prevectorILj8EijiEC2ITkNSt3__114input_iteratorENS0_14const_iteratorEEET_S4_: 209| 2.04k| prevector(InputIterator first, InputIterator last) { 210| 2.04k| size_type n = last - first; 211| 2.04k| change_capacity(n); 212| 2.04k| _size += n; 213| 2.04k| fill(item_ptr(0), first, last); 214| 2.04k| } _ZN9prevectorILj8EijiE14const_iteratormmEv: 93| 34.3M| const_iterator& operator--() { ptr--; return *this; } _ZNK9prevectorILj16EhjiE9is_directEv: 126| 16| bool is_direct() const { return _size <= N; } _ZN9prevectorILj16EhjiED2Ev: 422| 16| ~prevector() { 423| 16| if (!is_direct()) { ------------------ | Branch (423:13): [True: 0, False: 16] ------------------ 424| 0| free(_union.indirect_contents.indirect); 425| 0| _union.indirect_contents.indirect = nullptr; 426| 0| } 427| 16| } _ZNK9prevectorILj36EhjiE9is_directEv: 126| 14| bool is_direct() const { return _size <= N; } _ZN9prevectorILj36EhjiED2Ev: 422| 14| ~prevector() { 423| 14| if (!is_direct()) { ------------------ | Branch (423:13): [True: 0, False: 14] ------------------ 424| 0| free(_union.indirect_contents.indirect); 425| 0| _union.indirect_contents.indirect = nullptr; 426| 0| } 427| 14| } random.cpp:_ZN12_GLOBAL__N_18RNGStateD2Ev: 367| 2| ~RNGState() = default; _ZN20BaseSignatureCheckerD2Ev: 298| 2| virtual ~BaseSignatureChecker() = default; _ZN20BaseSignatureCreatorD2Ev: 41| 4| virtual ~BaseSignatureCreator() = default; _ZN15SigningProviderD2Ev: 170| 2| virtual ~SigningProvider() = default; _Z9SerializeI10DataStreamiNSt3__19allocatorIiEEEvRT_RKNS1_6vectorIT0_T1_EE: 899| 2.04k|{ 900| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 901| | WriteCompactSize(os, v.size()); 902| | if (!v.empty()) os.write(MakeByteSpan(v)); 903| | } else if constexpr (std::is_same_v) { 904| | // A special case for std::vector, as dereferencing 905| | // std::vector::const_iterator does not result in a const bool& 906| | // due to std::vector's special casing for bool arguments. 907| | WriteCompactSize(os, v.size()); 908| | for (bool elem : v) { 909| | ::Serialize(os, elem); 910| | } 911| 2.04k| } else { 912| 2.04k| Serialize(os, Using>(v)); 913| 2.04k| } 914| 2.04k|} _Z9SerializeI10DataStream7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorIiNS5_9allocatorIiEEEEEQ12SerializableIT0_T_EEvRSE_RKSD_: 767| 2.04k|{ 768| 2.04k| a.Serialize(os); 769| 2.04k|} _ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorIiNS3_9allocatorIiEEEEE9SerializeI10DataStreamEEvRT_: 476| 2.04k| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE3SerI10DataStreamNSt3__16vectorIiNS4_9allocatorIiEEEEEEvRT_RKT0_: 670| 2.04k| { 671| 2.04k| Formatter formatter; 672| 2.04k| WriteCompactSize(s, v.size()); 673| 8.59M| for (const typename V::value_type& elem : v) { ------------------ | Branch (673:49): [True: 8.59M, False: 2.04k] ------------------ 674| 8.59M| formatter.Ser(s, elem); 675| 8.59M| } 676| 2.04k| } _ZN16DefaultFormatter3SerI10DataStreamiEEvRT_RKT0_: 788| 17.1M| static void Ser(Stream& s, const T& t) { Serialize(s, t); } prevector.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorIiNS3_9allocatorIiEEEEE7WrapperIT_RT0_EOSC_: 491| 2.04k|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorIiNS3_9allocatorIiEEEEEC2ES9_: 475| 2.04k| explicit Wrapper(T obj) : m_object(obj) {} _Z9SerializeI10DataStreamLj8EiEvRT_RK9prevectorIXT0_ET1_jiE: 864| 2.04k|{ 865| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 866| | WriteCompactSize(os, v.size()); 867| | if (!v.empty()) os.write(MakeByteSpan(v)); 868| 2.04k| } else { 869| 2.04k| Serialize(os, Using>(v)); 870| 2.04k| } 871| 2.04k|} _Z9SerializeI10DataStream7WrapperI15VectorFormatterI16DefaultFormatterERK9prevectorILj8EijiEEQ12SerializableIT0_T_EEvRSB_RKSA_: 767| 2.04k|{ 768| 2.04k| a.Serialize(os); 769| 2.04k|} _ZNK7WrapperI15VectorFormatterI16DefaultFormatterERK9prevectorILj8EijiEE9SerializeI10DataStreamEEvRT_: 476| 2.04k| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE3SerI10DataStream9prevectorILj8EijiEEEvRT_RKT0_: 670| 2.04k| { 671| 2.04k| Formatter formatter; 672| 2.04k| WriteCompactSize(s, v.size()); 673| 8.59M| for (const typename V::value_type& elem : v) { ------------------ | Branch (673:49): [True: 8.59M, False: 2.04k] ------------------ 674| 8.59M| formatter.Ser(s, elem); 675| 8.59M| } 676| 2.04k| } prevector.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERK9prevectorILj8EijiEE7WrapperIT_RT0_EOS9_: 491| 2.04k|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI15VectorFormatterI16DefaultFormatterERK9prevectorILj8EijiEEC2ES6_: 475| 2.04k| explicit Wrapper(T obj) : m_object(obj) {} _Z9SerializeI10DataStreamEvRT_i: 253| 17.1M|template void Serialize(Stream& s, int32_t a) { ser_writedata32(s, uint32_t(a)); } _Z14ser_writedata8I10DataStreamEvRT_h: 58| 4.08k|{ 59| 4.08k| s.write(std::as_bytes(std::span{&obj, 1})); 60| 4.08k|} _Z16WriteCompactSizeI10DataStreamEvRT_m: 303| 4.08k|{ 304| 4.08k| if (nSize < 253) ------------------ | Branch (304:9): [True: 3.13k, False: 946] ------------------ 305| 3.13k| { 306| 3.13k| ser_writedata8(os, nSize); 307| 3.13k| } 308| 946| else if (nSize <= std::numeric_limits::max()) ------------------ | Branch (308:14): [True: 946, False: 0] ------------------ 309| 946| { 310| 946| ser_writedata8(os, 253); 311| 946| ser_writedata16(os, nSize); 312| 946| } 313| 0| else if (nSize <= std::numeric_limits::max()) ------------------ | Branch (313:14): [True: 0, False: 0] ------------------ 314| 0| { 315| 0| ser_writedata8(os, 254); 316| 0| ser_writedata32(os, nSize); 317| 0| } 318| 0| else 319| 0| { 320| 0| ser_writedata8(os, 255); 321| 0| ser_writedata64(os, nSize); 322| 0| } 323| 4.08k| return; 324| 4.08k|} _Z15ser_writedata16I10DataStreamEvRT_t: 62| 946|{ 63| 946| obj = htole16_internal(obj); 64| 946| s.write(std::as_bytes(std::span{&obj, 1})); 65| 946|} _Z15ser_writedata32I10DataStreamEvRT_j: 67| 17.1M|{ 68| 17.1M| obj = htole32_internal(obj); 69| 17.1M| s.write(std::as_bytes(std::span{&obj, 1})); 70| 17.1M|} _ZN10DataStreamlsINSt3__16vectorIiNS1_9allocatorIiEEEEEERS_RKT_: 252| 2.04k| { 253| 2.04k| ::Serialize(*this, obj); 254| 2.04k| return (*this); 255| 2.04k| } _ZN10DataStreamlsI9prevectorILj8EijiEEERS_RKT_: 252| 2.04k| { 253| 2.04k| ::Serialize(*this, obj); 254| 2.04k| return (*this); 255| 2.04k| } _ZN10DataStreamixEm: 203| 68.7M| reference operator[](size_type pos) { return vch[pos + m_read_pos]; } _ZN10DataStream5writeENSt3__14spanIKSt4byteLm18446744073709551615EEE: 245| 17.1M| { 246| | // Write to the end of the buffer 247| 17.1M| vch.insert(vch.end(), src.begin(), src.end()); 248| 17.1M| } _ZNK10DataStream4sizeEv: 198| 34.3M| size_type size() const { return vch.size() - m_read_pos; } _ZN10DataStreamC2Ev: 182| 4.08k| explicit DataStream() = default; random.cpp:_ZN16secure_allocatorIN12_GLOBAL__N_18RNGStateEE10deallocateEPS1_m: 37| 2| { 38| 2| if (p != nullptr) { ------------------ | Branch (38:13): [True: 2, False: 0] ------------------ 39| 2| memory_cleanse(p, sizeof(T) * n); 40| 2| } 41| 2| LockedPoolManager::Instance().free(p); 42| 2| } _ZN25zero_after_free_allocatorISt4byteE8allocateEm: 25| 26.0k| { 26| 26.0k| return std::allocator{}.allocate(n); 27| 26.0k| } _ZN25zero_after_free_allocatorISt4byteE10deallocateEPS0_m: 30| 26.0k| { 31| 26.0k| if (p != nullptr) ------------------ | Branch (31:13): [True: 26.0k, False: 0] ------------------ 32| 26.0k| memory_cleanse(p, sizeof(T) * n); 33| 26.0k| std::allocator{}.deallocate(p, n); 34| 26.0k| } _Z14memory_cleansePvm: 15| 26.1k|{ 16| |#if defined(WIN32) 17| | /* SecureZeroMemory is guaranteed not to be optimized out. */ 18| | SecureZeroMemory(ptr, len); 19| |#else 20| 26.1k| std::memset(ptr, 0, len); 21| | 22| | /* Memory barrier that scares the compiler away from optimizing out the memset. 23| | * 24| | * Quoting Adam Langley in commit ad1907fe73334d6c696c8539646c21b11178f20f 25| | * in BoringSSL (ISC License): 26| | * As best as we can tell, this is sufficient to break any optimisations that 27| | * might try to eliminate "superfluous" memsets. 28| | * This method is used in memzero_explicit() the Linux kernel, too. Its advantage is that it 29| | * is pretty efficient because the compiler can still implement the memset() efficiently, 30| | * just not remove it entirely. See "Dead Store Elimination (Still) Considered Harmful" by 31| | * Yang et al. (USENIX Security 2017) for more background. 32| | */ 33| 26.1k| __asm__ __volatile__("" : : "r"(ptr) : "memory"); 34| 26.1k|#endif 35| 26.1k|} _ZN5ArenaD2Ev: 48| 2|Arena::~Arena() = default; _ZN5Arena4freeEPv: 87| 2|{ 88| | // Freeing the nullptr pointer is OK. 89| 2| if (ptr == nullptr) { ------------------ | Branch (89:9): [True: 0, False: 2] ------------------ 90| 0| return; 91| 0| } 92| | 93| | // Remove chunk from used map 94| 2| auto i = chunks_used.find(ptr); 95| 2| if (i == chunks_used.end()) { ------------------ | Branch (95:9): [True: 0, False: 2] ------------------ 96| 0| throw std::runtime_error("Arena: invalid or double free"); 97| 0| } 98| 2| auto freed = std::make_pair(static_cast(i->first), i->second); 99| 2| chunks_used.erase(i); 100| | 101| | // coalesce freed with previous chunk 102| 2| auto prev = chunks_free_end.find(freed.first); 103| 2| if (prev != chunks_free_end.end()) { ------------------ | Branch (103:9): [True: 2, False: 0] ------------------ 104| 2| freed.first -= prev->second->first; 105| 2| freed.second += prev->second->first; 106| 2| size_to_free_chunk.erase(prev->second); 107| 2| chunks_free_end.erase(prev); 108| 2| } 109| | 110| | // coalesce freed with chunk after freed 111| 2| auto next = chunks_free.find(freed.first + freed.second); 112| 2| if (next != chunks_free.end()) { ------------------ | Branch (112:9): [True: 0, False: 2] ------------------ 113| 0| freed.second += next->second->first; 114| 0| size_to_free_chunk.erase(next->second); 115| 0| chunks_free.erase(next); 116| 0| } 117| | 118| | // Add/set space with coalesced free chunk 119| 2| auto it = size_to_free_chunk.emplace(freed.second, freed.first); 120| 2| chunks_free[freed.first] = it; 121| 2| chunks_free_end[freed.first + freed.second] = it; 122| 2|} _ZN24PosixLockedPageAllocator10FreeLockedEPvm: 254| 2|{ 255| 2| len = align_up(len, page_size); 256| 2| memory_cleanse(addr, len); 257| 2| munlock(addr, len); 258| 2| munmap(addr, len); 259| 2|} _ZN10LockedPoolD2Ev: 283| 2|LockedPool::~LockedPool() = default; _ZN10LockedPool4freeEPv: 308| 2|{ 309| 2| std::lock_guard lock(mutex); 310| | // TODO we can do better than this linear search by keeping a map of arena 311| | // extents to arena, and looking up the address. 312| 2| for (auto &arena: arenas) { ------------------ | Branch (312:21): [True: 2, False: 0] ------------------ 313| 2| if (arena.addressInArena(ptr)) { ------------------ | Branch (313:13): [True: 2, False: 0] ------------------ 314| 2| arena.free(ptr); 315| 2| return; 316| 2| } 317| 2| } 318| 0| throw std::runtime_error("LockedPool: invalid address not pointing to any arena"); 319| 2|} _ZN10LockedPool15LockedPageArenaD2Ev: 370| 2|{ 371| 2| allocator->FreeLocked(base, size); 372| 2|} _ZN17LockedPoolManager8InstanceEv: 405| 2|{ 406| 2| static std::once_flag init_flag; 407| 2| std::call_once(init_flag, LockedPoolManager::CreateInstance); 408| 2| return *LockedPoolManager::_instance; 409| 2|} lockedpool.cpp:_ZL8align_upmm: 32| 2|{ 33| 2| return (x + align - 1) & ~(align - 1); 34| 2|} _ZNK5Arena14addressInArenaEPv: 90| 2| bool addressInArena(void *ptr) const { return ptr >= base && ptr < end; } ------------------ | Branch (90:51): [True: 2, False: 0] | Branch (90:66): [True: 2, False: 0] ------------------ _ZN19LockedPageAllocatorD2Ev: 22| 2| virtual ~LockedPageAllocator() = default; _ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev: 96| 2| ~AnnotatedMixin() { 97| 2| DeleteLock((void*)this); 98| 2| } _ZN14AnnotatedMixinINSt3__15mutexEED2Ev: 96| 64| ~AnnotatedMixin() { 97| 64| DeleteLock((void*)this); 98| 64| } _Z10DeleteLockPv: 74| 66|inline void DeleteLock(void* cs) {} _Z17MaybeCheckNotHeldR14AnnotatedMixinINSt3__15mutexEE: 258| 30|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; } _ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib: 181| 30| UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock) 182| 30| { 183| 30| if (fTry) ------------------ | Branch (183:13): [True: 0, False: 30] ------------------ 184| 0| TryEnter(pszName, pszFile, nLine); 185| 30| else 186| 30| Enter(pszName, pszFile, nLine); 187| 30| } _Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b: 67| 30|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {} _Z13LeaveCriticalv: 68| 30|inline void LeaveCritical() {} _ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i: 159| 30| { 160| 30| EnterCritical(pszName, pszFile, nLine, Base::mutex()); 161| |#ifdef DEBUG_LOCKCONTENTION 162| | if (!Base::try_lock()) { 163| | ContendedLock(pszName, pszFile, nLine, static_cast(*this)); 164| | } 165| |#else 166| 30| Base::lock(); 167| 30|#endif 168| 30| } _ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev: 201| 30| { 202| 30| if (Base::owns_lock()) ------------------ | Branch (202:13): [True: 30, False: 0] ------------------ 203| 30| LeaveCritical(); 204| 30| } _ZN18FuzzedDataProvider15remaining_bytesEv: 85| 588k| size_t remaining_bytes() { return remaining_bytes_; } _ZN18FuzzedDataProvider15ConsumeIntegralIiEET_v: 195| 471k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 471k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 471k| std::numeric_limits::max()); 198| 471k|} _ZN18FuzzedDataProviderC2EPKhm: 37| 2.04k| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider11ConsumeBoolEv: 289| 26.4k|inline bool FuzzedDataProvider::ConsumeBool() { 290| 26.4k| return 1 & ConsumeIntegral(); 291| 26.4k|} _ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v: 195| 26.4k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 26.4k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 26.4k| std::numeric_limits::max()); 198| 26.4k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_: 205| 26.4k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 26.4k| static_assert(std::is_integral_v, "An integral type is required."); 207| 26.4k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 26.4k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 26.4k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 26.4k| uint64_t range = static_cast(max) - static_cast(min); 214| 26.4k| uint64_t result = 0; 215| 26.4k| size_t offset = 0; 216| | 217| 52.7k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 26.4k, False: 26.3k] | Branch (217:43): [True: 26.4k, False: 0] ------------------ 218| 26.4k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 26.3k, False: 141] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 26.3k| --remaining_bytes_; 226| 26.3k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 26.3k| offset += CHAR_BIT; 228| 26.3k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 26.4k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 26.4k, False: 0] ------------------ 232| 26.4k| result = result % (range + 1); 233| | 234| 26.4k| return static_cast(static_cast(min) + result); 235| 26.4k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_: 205| 281k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 281k| static_assert(std::is_integral_v, "An integral type is required."); 207| 281k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 281k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 281k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 281k| uint64_t range = static_cast(max) - static_cast(min); 214| 281k| uint64_t result = 0; 215| 281k| size_t offset = 0; 216| | 217| 635k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 635k, False: 0] | Branch (217:43): [True: 354k, False: 280k] ------------------ 218| 354k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 354k, False: 570] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 354k| --remaining_bytes_; 226| 354k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 354k| offset += CHAR_BIT; 228| 354k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 281k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 281k, False: 0] ------------------ 232| 281k| result = result % (range + 1); 233| | 234| 281k| return static_cast(static_cast(min) + result); 235| 281k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_: 205| 1.23M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 1.23M| static_assert(std::is_integral_v, "An integral type is required."); 207| 1.23M| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 1.23M| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 1.23M] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 1.23M| uint64_t range = static_cast(max) - static_cast(min); 214| 1.23M| uint64_t result = 0; 215| 1.23M| size_t offset = 0; 216| | 217| 3.84M| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 3.38M, False: 469k] | Branch (217:43): [True: 2.61M, False: 763k] ------------------ 218| 2.61M| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 2.61M, False: 2.18k] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 2.61M| --remaining_bytes_; 226| 2.61M| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 2.61M| offset += CHAR_BIT; 228| 2.61M| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 1.23M| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 1.23M, False: 0] ------------------ 232| 1.23M| result = result % (range + 1); 233| | 234| 1.23M| return static_cast(static_cast(min) + result); 235| 1.23M|} LLVMFuzzerTestOneInput: 213| 2.04k|{ 214| 2.04k| test_one_input({data, size}); 215| 2.04k| return 0; 216| 2.04k|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 84| 2.04k|{ 85| 2.04k| CheckGlobals check{}; 86| 2.04k| (*Assert(g_test_one_input))(buffer); ------------------ | | 116| 2.04k|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 87| 2.04k|} _Z21prevector_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 206| 2.04k|{ 207| 2.04k| FuzzedDataProvider prov(buffer.data(), buffer.size()); 208| 2.04k| prevector_tester<8, int> test; 209| | 210| 586k| LIMITED_WHILE (prov.remaining_bytes(), 3000) { ------------------ | | 23| 588k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 586k, False: 1.88k] | | | Branch (23:49): [True: 586k, False: 154] | | ------------------ ------------------ 211| 586k| switch (prov.ConsumeIntegralInRange(0, 13 + 3 * (test.size() > 0))) { ------------------ | Branch (211:17): [True: 586k, False: 0] ------------------ 212| 113k| case 0: { ------------------ | Branch (212:9): [True: 113k, False: 472k] ------------------ 213| 113k| auto position = prov.ConsumeIntegralInRange(0, test.size()); 214| 113k| auto value = prov.ConsumeIntegral(); 215| 113k| test.insert(position, value); 216| 113k| } break; 217| 44.5k| case 1: ------------------ | Branch (217:9): [True: 44.5k, False: 541k] ------------------ 218| 44.5k| test.resize(std::max(0, std::min(30, (int)test.size() + prov.ConsumeIntegralInRange(0, 4) - 2))); 219| 44.5k| break; 220| 26.4k| case 2: { ------------------ | Branch (220:9): [True: 26.4k, False: 559k] ------------------ 221| 26.4k| auto position = prov.ConsumeIntegralInRange(0, test.size()); 222| 26.4k| auto count = 1 + prov.ConsumeBool(); 223| 26.4k| auto value = prov.ConsumeIntegral(); 224| 26.4k| test.insert(position, count, value); 225| 26.4k| } break; 226| 39.7k| case 3: { ------------------ | Branch (226:9): [True: 39.7k, False: 546k] ------------------ 227| 39.7k| int del = prov.ConsumeIntegralInRange(0, test.size()); 228| 39.7k| int beg = prov.ConsumeIntegralInRange(0, test.size() - del); 229| 39.7k| test.erase(beg, beg + del); 230| 39.7k| break; 231| 0| } 232| 32.5k| case 4: ------------------ | Branch (232:9): [True: 32.5k, False: 553k] ------------------ 233| 32.5k| test.push_back(prov.ConsumeIntegral()); 234| 32.5k| break; 235| 29.2k| case 5: { ------------------ | Branch (235:9): [True: 29.2k, False: 557k] ------------------ 236| 29.2k| int values[4]; 237| 29.2k| int num = 1 + prov.ConsumeIntegralInRange(0, 3); 238| 95.4k| for (int k = 0; k < num; ++k) { ------------------ | Branch (238:29): [True: 66.1k, False: 29.2k] ------------------ 239| 66.1k| values[k] = prov.ConsumeIntegral(); 240| 66.1k| } 241| 29.2k| test.insert_range(prov.ConsumeIntegralInRange(0, test.size()), values, values + num); 242| 29.2k| break; 243| 0| } 244| 23.8k| case 6: { ------------------ | Branch (244:9): [True: 23.8k, False: 562k] ------------------ 245| 23.8k| int num = 1 + prov.ConsumeIntegralInRange(0, 15); 246| 23.8k| std::vector values(num); 247| 168k| for (auto& v : values) { ------------------ | Branch (247:26): [True: 168k, False: 23.8k] ------------------ 248| 168k| v = prov.ConsumeIntegral(); 249| 168k| } 250| 23.8k| test.resize_uninitialized(values); 251| 23.8k| break; 252| 0| } 253| 27.3k| case 7: ------------------ | Branch (253:9): [True: 27.3k, False: 558k] ------------------ 254| 27.3k| test.reserve(prov.ConsumeIntegralInRange(0, 32767)); 255| 27.3k| break; 256| 27.5k| case 8: ------------------ | Branch (256:9): [True: 27.5k, False: 558k] ------------------ 257| 27.5k| test.shrink_to_fit(); 258| 27.5k| break; 259| 19.8k| case 9: ------------------ | Branch (259:9): [True: 19.8k, False: 566k] ------------------ 260| 19.8k| test.clear(); 261| 19.8k| break; 262| 31.6k| case 10: { ------------------ | Branch (262:9): [True: 31.6k, False: 554k] ------------------ 263| 31.6k| auto n = prov.ConsumeIntegralInRange(0, 32767); 264| 31.6k| auto value = prov.ConsumeIntegral(); 265| 31.6k| test.assign(n, value); 266| 31.6k| } break; 267| 32.7k| case 11: ------------------ | Branch (267:9): [True: 32.7k, False: 553k] ------------------ 268| 32.7k| test.swap(); 269| 32.7k| break; 270| 31.2k| case 12: ------------------ | Branch (270:9): [True: 31.2k, False: 555k] ------------------ 271| 31.2k| test.copy(); 272| 31.2k| break; 273| 31.3k| case 13: ------------------ | Branch (273:9): [True: 31.3k, False: 554k] ------------------ 274| 31.3k| test.move(); 275| 31.3k| break; 276| 32.0k| case 14: { ------------------ | Branch (276:9): [True: 32.0k, False: 554k] ------------------ 277| 32.0k| auto pos = prov.ConsumeIntegralInRange(0, test.size() - 1); 278| 32.0k| auto value = prov.ConsumeIntegral(); 279| 32.0k| test.update(pos, value); 280| 32.0k| } break; 281| 21.1k| case 15: ------------------ | Branch (281:9): [True: 21.1k, False: 565k] ------------------ 282| 21.1k| test.erase(prov.ConsumeIntegralInRange(0, test.size() - 1)); 283| 21.1k| break; 284| 21.6k| case 16: ------------------ | Branch (284:9): [True: 21.6k, False: 564k] ------------------ 285| 21.6k| test.pop_back(); 286| 21.6k| break; 287| 586k| } 288| 586k| } 289| | 290| 2.04k| test.test(); 291| 2.04k|} prevector.cpp:_ZNK12_GLOBAL__N_116prevector_testerILj8EiE4sizeEv: 148| 932k| { 149| 932k| return real_vector.size(); 150| 932k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE6insertEjRKi: 87| 113k| { 88| 113k| real_vector.insert(real_vector.begin() + position, value); 89| 113k| pre_vector.insert(pre_vector.begin() + position, value); 90| 113k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE6resizeEj: 71| 44.5k| { 72| 44.5k| real_vector.resize(s); 73| 44.5k| assert(real_vector.size() == s); ------------------ | Branch (73:9): [True: 44.5k, False: 0] ------------------ 74| 44.5k| pre_vector.resize(s); 75| | assert(pre_vector.size() == s); ------------------ | Branch (75:9): [True: 44.5k, False: 0] ------------------ 76| 44.5k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE6insertEjjRKi: 93| 26.4k| { 94| 26.4k| real_vector.insert(real_vector.begin() + position, count, value); 95| 26.4k| pre_vector.insert(pre_vector.begin() + position, count, value); 96| 26.4k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE5eraseEjj: 112| 39.7k| { 113| 39.7k| real_vector.erase(real_vector.begin() + first, real_vector.begin() + last); 114| 39.7k| pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last); 115| 39.7k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE9push_backERKi: 124| 32.5k| { 125| 32.5k| real_vector.push_back(value); 126| 32.5k| pre_vector.push_back(value); 127| 32.5k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE12insert_rangeIPiEEvjT_S4_: 100| 29.2k| { 101| 29.2k| real_vector.insert(real_vector.begin() + position, first, last); 102| 29.2k| pre_vector.insert(pre_vector.begin() + position, first, last); 103| 29.2k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE20resize_uninitializedENSt3__16vectorIiNS2_9allocatorIiEEEE: 183| 23.8k| { 184| 23.8k| size_t r = values.size(); 185| 23.8k| size_t s = real_vector.size() / 2; 186| 23.8k| if (real_vector.capacity() < s + r) { ------------------ | Branch (186:13): [True: 5.51k, False: 18.3k] ------------------ 187| 5.51k| real_vector.reserve(s + r); 188| 5.51k| } 189| 23.8k| real_vector.resize(s); 190| 23.8k| pre_vector.resize_uninitialized(s); 191| 168k| for (auto v : values) { ------------------ | Branch (191:21): [True: 168k, False: 23.8k] ------------------ 192| 168k| real_vector.push_back(v); 193| 168k| } 194| 23.8k| auto p = pre_vector.size(); 195| 23.8k| pre_vector.resize_uninitialized(p + r); 196| 168k| for (auto v : values) { ------------------ | Branch (196:21): [True: 168k, False: 23.8k] ------------------ 197| 168k| pre_vector[p] = v; 198| 168k| ++p; 199| 168k| } 200| 23.8k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE7reserveEj: 79| 27.3k| { 80| 27.3k| real_vector.reserve(s); 81| 27.3k| assert(real_vector.capacity() >= s); ------------------ | Branch (81:9): [True: 27.3k, False: 0] ------------------ 82| 27.3k| pre_vector.reserve(s); 83| | assert(pre_vector.capacity() >= s); ------------------ | Branch (83:9): [True: 27.3k, False: 0] ------------------ 84| 27.3k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE13shrink_to_fitEv: 158| 27.5k| { 159| 27.5k| pre_vector.shrink_to_fit(); 160| 27.5k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE5clearEv: 136| 19.8k| { 137| 19.8k| real_vector.clear(); 138| 19.8k| pre_vector.clear(); 139| 19.8k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE6assignEjRKi: 142| 31.6k| { 143| 31.6k| real_vector.assign(n, value); 144| 31.6k| pre_vector.assign(n, value); 145| 31.6k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE4swapEv: 163| 32.7k| { 164| 32.7k| real_vector.swap(real_vector_alt); 165| 32.7k| pre_vector.swap(pre_vector_alt); 166| 32.7k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE4copyEv: 177| 31.2k| { 178| 31.2k| real_vector = real_vector_alt; 179| 31.2k| pre_vector = pre_vector_alt; 180| 31.2k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE4moveEv: 169| 31.3k| { 170| 31.3k| real_vector = std::move(real_vector_alt); 171| 31.3k| real_vector_alt.clear(); 172| 31.3k| pre_vector = std::move(pre_vector_alt); 173| 31.3k| pre_vector_alt.clear(); 174| 31.3k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE6updateEjRKi: 118| 32.0k| { 119| 32.0k| real_vector[pos] = value; 120| 32.0k| pre_vector[pos] = value; 121| 32.0k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE5eraseEj: 106| 21.1k| { 107| 21.1k| real_vector.erase(real_vector.begin() + position); 108| 21.1k| pre_vector.erase(pre_vector.begin() + position); 109| 21.1k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE8pop_backEv: 130| 21.6k| { 131| 21.6k| real_vector.pop_back(); 132| 21.6k| pre_vector.pop_back(); 133| 21.6k| } prevector.cpp:_ZNK12_GLOBAL__N_116prevector_testerILj8EiE4testEv: 30| 2.04k| { 31| 2.04k| const pretype& const_pre_vector = pre_vector; 32| 2.04k| assert(real_vector.size() == pre_vector.size()); ------------------ | Branch (32:9): [True: 2.04k, False: 0] ------------------ 33| 2.04k| assert(real_vector.empty() == pre_vector.empty()); ------------------ | Branch (33:9): [True: 2.04k, False: 0] ------------------ 34| 8.59M| for (Size s = 0; s < real_vector.size(); s++) { ------------------ | Branch (34:26): [True: 8.59M, False: 2.04k] ------------------ 35| 8.59M| assert(real_vector[s] == pre_vector[s]); ------------------ | Branch (35:13): [True: 8.59M, False: 0] ------------------ 36| 8.59M| assert(&(pre_vector[s]) == &(pre_vector.begin()[s])); ------------------ | Branch (36:13): [True: 8.59M, False: 0] ------------------ 37| 8.59M| assert(&(pre_vector[s]) == &*(pre_vector.begin() + s)); ------------------ | Branch (37:13): [True: 8.59M, False: 0] ------------------ 38| 8.59M| assert(&(pre_vector[s]) == &*((pre_vector.end() + s) - real_vector.size())); ------------------ | Branch (38:13): [True: 8.59M, False: 0] ------------------ 39| 8.59M| } 40| | // assert(realtype(pre_vector) == real_vector); 41| 2.04k| assert(pretype(real_vector.begin(), real_vector.end()) == pre_vector); ------------------ | Branch (41:9): [True: 2.04k, False: 0] ------------------ 42| 2.04k| assert(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector); ------------------ | Branch (42:9): [True: 2.04k, False: 0] ------------------ 43| 2.04k| size_t pos = 0; 44| 8.59M| for (const T& v : pre_vector) { ------------------ | Branch (44:25): [True: 8.59M, False: 2.04k] ------------------ 45| 8.59M| assert(v == real_vector[pos]); ------------------ | Branch (45:13): [True: 8.59M, False: 0] ------------------ 46| 8.59M| ++pos; 47| 8.59M| } 48| 8.59M| for (const T& v : pre_vector | std::views::reverse) { ------------------ | Branch (48:25): [True: 8.59M, False: 2.04k] ------------------ 49| 8.59M| --pos; 50| 8.59M| assert(v == real_vector[pos]); ------------------ | Branch (50:13): [True: 8.59M, False: 0] ------------------ 51| 8.59M| } 52| 8.59M| for (const T& v : const_pre_vector) { ------------------ | Branch (52:25): [True: 8.59M, False: 2.04k] ------------------ 53| 8.59M| assert(v == real_vector[pos]); ------------------ | Branch (53:13): [True: 8.59M, False: 0] ------------------ 54| 8.59M| ++pos; 55| 8.59M| } 56| 8.59M| for (const T& v : const_pre_vector | std::views::reverse) { ------------------ | Branch (56:25): [True: 8.59M, False: 2.04k] ------------------ 57| 8.59M| --pos; 58| 8.59M| assert(v == real_vector[pos]); ------------------ | Branch (58:13): [True: 8.59M, False: 0] ------------------ 59| 8.59M| } 60| 2.04k| DataStream ss1{}; 61| 2.04k| DataStream ss2{}; 62| 2.04k| ss1 << real_vector; 63| 2.04k| ss2 << pre_vector; 64| 2.04k| assert(ss1.size() == ss2.size()); ------------------ | Branch (64:9): [True: 2.04k, False: 0] ------------------ 65| 34.3M| for (Size s = 0; s < ss1.size(); s++) { ------------------ | Branch (65:26): [True: 34.3M, False: 2.04k] ------------------ 66| | assert(ss1[s] == ss2[s]); ------------------ | Branch (66:13): [True: 34.3M, False: 0] ------------------ 67| 34.3M| } 68| 2.04k| } _ZN12CheckGlobalsC2Ev: 59| 2.04k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 60| 2.04k|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 2.04k| { 18| 2.04k| g_used_g_prng = false; 19| 2.04k| g_seeded_g_prng_zero = false; 20| 2.04k| g_used_system_time = false; 21| 2.04k| SetMockTime(0s); 22| 2.04k| MockableSteadyClock::ClearMockTime(); 23| 2.04k| } _ZN16CheckGlobalsImplD2Ev: 25| 2.04k| { 26| 2.04k| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (26:13): [True: 0, False: 2.04k] | Branch (26:30): [True: 0, False: 0] ------------------ 27| 0| std::cerr << "\n\n" 28| 0| "The current fuzz target used the global random state.\n\n" 29| | 30| 0| "This is acceptable, but requires the fuzz target to call \n" 31| 0| "SeedRandomStateForTest(SeedRand::ZEROS) in the first line \n" 32| 0| "of the FUZZ_TARGET function.\n\n" 33| | 34| 0| "An alternative solution would be to avoid any use of globals.\n\n" 35| | 36| 0| "Without a solution, fuzz instability and non-determinism can lead \n" 37| 0| "to non-reproducible bugs or inefficient fuzzing.\n\n" 38| 0| << std::endl; 39| 0| std::abort(); // Abort, because AFL may try to recover from a std::exit 40| 0| } 41| | 42| 2.04k| if (g_used_system_time) { ------------------ | Branch (42:13): [True: 0, False: 2.04k] ------------------ 43| 0| std::cerr << "\n\n" 44| 0| "The current fuzz target accessed system time.\n\n" 45| | 46| 0| "This is acceptable, but requires the fuzz target to use \n" 47| 0| "a FakeNodeClock, FakeSteadyClock or call \n" 48| 0| "SetMockTime() at the \n" "beginning of processing the \n" 49| 0| "fuzz input.\n\n" 50| | 51| 0| "Without setting mock time, time-dependent behavior can lead \n" 52| 0| "to non-reproducible bugs or inefficient fuzzing.\n\n" 53| 0| << std::endl; 54| 0| std::abort(); 55| 0| } 56| 2.04k| } __gcov_reset: 13| 2|extern "C" __attribute__((weak)) void __gcov_reset(void) {} _ZN9base_blobILj256EE4dataEv: 99| 2| constexpr unsigned char* data() { return m_data.data(); } _ZN9base_blobILj256EE4sizeEv: 107| 2| static constexpr unsigned int size() { return WIDTH; } _ZN10btcsignals6signalIFvvENS_10null_valueEED2Ev: 175| 6| ~signal() = default; _ZN10btcsignals6signalIFv20SynchronizationStatellbENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFv20SynchronizationStateRK11CBlockIndexdENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEibENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvbENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFviENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFbRK13bilingual_strRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEjENS_6any_ofEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvRK13bilingual_strjENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_RKNS0_15source_locationENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE: 90| 2.04k|{ 91| 2.04k| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 2.04k, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 2.04k| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 2.04k] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 2.04k| } 96| 2.04k| return std::forward(val); 97| 2.04k|} _Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE: 90| 2.04k|{ 91| 2.04k| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 2.04k, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 2.04k| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 2.04k] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 2.04k| } 96| 2.04k| return std::forward(val); 97| 2.04k|} _Z22inline_assertion_checkILb0EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE: 90| 10|{ 91| 10| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [Folded, False: 0] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 10| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 10] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 10| } 96| 10| return std::forward(val); 97| 10|} _ZN16CThreadInterruptD2Ev: 32| 4| virtual ~CThreadInterrupt() = default; _ZN10ThreadPoolD2Ev: 93| 10| { 94| 10| Stop(); // In case it hasn't been stopped. 95| 10| } _ZN10ThreadPool4StopEv: 129| 10| { 130| | // Notify workers and join them 131| 10| std::vector threads_to_join; 132| 10| { 133| 10| LOCK(m_mutex); ------------------ | | 268| 10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 10|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 10|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 134| | // Ensure Stop() is not called from a worker thread while workers are still registered, 135| | // otherwise a self-join deadlock would occur. 136| 10| auto id = std::this_thread::get_id(); 137| 10| for (const auto& worker : m_workers) assert(worker.get_id() != id); ------------------ | Branch (137:37): [True: 0, False: 10] | Branch (137:50): [True: 0, False: 0] ------------------ 138| | // Early shutdown to return right away on any concurrent Submit() call 139| 10| m_interrupt = true; 140| 10| threads_to_join.swap(m_workers); 141| 10| } 142| 0| m_cv.notify_all(); 143| | // Help draining queue 144| 10| while (ProcessTask()) {} ------------------ | Branch (144:16): [True: 0, False: 10] ------------------ 145| | // Free resources 146| 10| for (auto& worker : threads_to_join) worker.join(); ------------------ | Branch (146:27): [True: 0, False: 10] ------------------ 147| | 148| | // Since we currently wait for tasks completion, sanity-check empty queue 149| 10| LOCK(m_mutex); ------------------ | | 268| 10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 10|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 10|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 150| 10| Assume(m_work_queue.empty()); ------------------ | | 128| 10|#define Assume(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 151| | // Re-allow Start() now that all workers have exited 152| 10| m_interrupt = false; 153| 10| } _ZN10ThreadPool11ProcessTaskEv: 244| 10| { 245| 10| std::packaged_task task; 246| 10| { 247| 10| LOCK(m_mutex); ------------------ | | 268| 10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 10|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 10|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 248| 10| if (m_work_queue.empty()) return false; ------------------ | Branch (248:17): [True: 10, False: 0] ------------------ 249| | 250| | // Pop the task 251| 0| task = std::move(m_work_queue.front()); 252| 0| m_work_queue.pop(); 253| 0| } 254| 0| task(); 255| 0| return true; 256| 10| } _Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE: 54| 2.04k|{ 55| 2.04k| Assert(mock_time_in >= 0s); ------------------ | | 116| 2.04k|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 56| 2.04k| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 57| 2.04k|} _ZN19MockableSteadyClock13ClearMockTimeEv: 84| 2.04k|{ 85| 2.04k| g_mock_steady_time.store(0ms, std::memory_order_relaxed); 86| 2.04k|} _ZN19WalletInitInterfaceD2Ev: 25| 2| virtual ~WalletInitInterface() = default;