_Z16htole16_internalt: 19| 918|{ 20| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(host_16bits); 21| 918| else return host_16bits; 22| 918|} _Z16htole32_internalj: 39| 15.8M|{ 40| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits); 41| 15.8M| else return host_32bits; 42| 15.8M|} _ZN9prevectorILj8EijiEC2Ev: 243| 3.97k| prevector() = default; _ZN9prevectorILj8EijiED2Ev: 474| 7.94k| ~prevector() { 475| 7.94k| if (!is_direct()) { ------------------ | Branch (475:13): [True: 2.97k, False: 4.97k] ------------------ 476| 2.97k| free(_union.indirect_contents.indirect); 477| 2.97k| _union.indirect_contents.indirect = nullptr; 478| 2.97k| } 479| 7.94k| } _ZNK9prevectorILj8EijiE9is_directEv: 173| 66.1M| bool is_direct() const { return _size <= N; } _ZN9prevectorILj8EijiE6insertENS0_8iteratorERKi: 359| 88.0k| iterator insert(iterator pos, const T& value) { 360| 88.0k| size_type p = pos - begin(); 361| 88.0k| size_type new_size = size() + 1; 362| 88.0k| if (capacity() < new_size) { ------------------ | Branch (362:13): [True: 2.75k, False: 85.2k] ------------------ 363| 2.75k| change_capacity(new_size + (new_size >> 1)); 364| 2.75k| } 365| 88.0k| T* ptr = item_ptr(p); 366| 88.0k| T* dst = ptr + 1; 367| 88.0k| memmove(dst, ptr, (size() - p) * sizeof(T)); 368| 88.0k| _size++; 369| 88.0k| new(static_cast(ptr)) T(value); 370| 88.0k| return iterator(ptr); 371| 88.0k| } _ZmiN9prevectorILj8EijiE8iteratorES1_: 66| 300k| difference_type friend operator-(iterator a, iterator b) { return (&(*a) - &(*b)); } _ZNK9prevectorILj8EijiE8iteratordeEv: 59| 1.23M| T& operator*() const { return *ptr; } _ZNK9prevectorILj8EijiE4sizeEv: 294| 8.94M| size_type size() const { 295| 8.94M| return is_direct() ? _size : _size - N - 1; ------------------ | Branch (295:16): [True: 323k, False: 8.62M] ------------------ 296| 8.94M| } _ZNK9prevectorILj8EijiE8capacityEv: 312| 343k| size_t capacity() const { 313| 343k| if (is_direct()) { ------------------ | Branch (313:13): [True: 92.8k, False: 250k] ------------------ 314| 92.8k| return N; 315| 250k| } else { 316| 250k| return _union.indirect_contents.capacity; 317| 250k| } 318| 343k| } _ZN9prevectorILj8EijiE15change_capacityEj: 175| 66.7k| void change_capacity(size_type new_capacity) { 176| 66.7k| if (new_capacity <= N) { ------------------ | Branch (176:13): [True: 15.3k, False: 51.3k] ------------------ 177| 15.3k| if (!is_direct()) { ------------------ | Branch (177:17): [True: 4.57k, False: 10.7k] ------------------ 178| 4.57k| T* indirect = indirect_ptr(0); 179| 4.57k| T* src = indirect; 180| 4.57k| T* dst = direct_ptr(0); 181| 4.57k| memcpy(dst, src, size() * sizeof(T)); 182| 4.57k| free(indirect); 183| 4.57k| _size -= N + 1; 184| 4.57k| } 185| 51.3k| } else { 186| 51.3k| if (!is_direct()) { ------------------ | Branch (186:17): [True: 27.1k, False: 24.1k] ------------------ 187| | /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert 188| | success. These should instead use an allocator or new/delete so that handlers 189| | are called as necessary, but performance would be slightly degraded by doing so. */ 190| 27.1k| _union.indirect_contents.indirect = static_cast(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity)); 191| 27.1k| assert(_union.indirect_contents.indirect); 192| 27.1k| _union.indirect_contents.capacity = new_capacity; 193| 27.1k| } else { 194| 24.1k| char* new_indirect = static_cast(malloc(((size_t)sizeof(T)) * new_capacity)); 195| 24.1k| assert(new_indirect); 196| 24.1k| T* src = direct_ptr(0); 197| 24.1k| T* dst = reinterpret_cast(new_indirect); 198| 24.1k| memcpy(dst, src, size() * sizeof(T)); 199| 24.1k| _union.indirect_contents.indirect = new_indirect; 200| 24.1k| _union.indirect_contents.capacity = new_capacity; 201| 24.1k| _size += N + 1; 202| 24.1k| } 203| 51.3k| } 204| 66.7k| } _ZN9prevectorILj8EijiE12indirect_ptrEi: 171| 959k| T* indirect_ptr(difference_type pos) { return reinterpret_cast(_union.indirect_contents.indirect) + pos; } _ZN9prevectorILj8EijiE10direct_ptrEi: 169| 295k| T* direct_ptr(difference_type pos) { return reinterpret_cast(_union.direct) + pos; } _ZN9prevectorILj8EijiE8item_ptrEi: 206| 1.22M| T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); } ------------------ | Branch (206:47): [True: 266k, False: 955k] ------------------ _ZN9prevectorILj8EijiE8iteratorC2EPi: 58| 1.09M| iterator(T* ptr_) : ptr(ptr_) {} _ZN9prevectorILj8EijiE5beginEv: 302| 369k| iterator begin() { return iterator(item_ptr(0)); } _ZNK9prevectorILj8EijiE8iteratorplEj: 67| 246k| iterator operator+(size_type n) const { return iterator(ptr + n); } _ZN9prevectorILj8EijiE6resizeEj: 328| 151k| void resize(size_type new_size) { 329| 151k| size_type cur_size = size(); 330| 151k| if (cur_size == new_size) { ------------------ | Branch (330:13): [True: 71.7k, False: 79.6k] ------------------ 331| 71.7k| return; 332| 71.7k| } 333| 79.6k| if (cur_size > new_size) { ------------------ | Branch (333:13): [True: 71.3k, False: 8.26k] ------------------ 334| 71.3k| erase(item_ptr(new_size), end()); 335| 71.3k| return; 336| 71.3k| } 337| 8.26k| if (new_size > capacity()) { ------------------ | Branch (337:13): [True: 658, False: 7.60k] ------------------ 338| 658| change_capacity(new_size); 339| 658| } 340| 8.26k| ptrdiff_t increase = new_size - cur_size; 341| 8.26k| fill(item_ptr(cur_size), increase); 342| 8.26k| _size += increase; 343| 8.26k| } _ZN9prevectorILj8EijiE5eraseENS0_8iteratorES1_: 420| 159k| iterator erase(iterator first, iterator last) { 421| | // Erase is not allowed to the change the object's capacity. That means 422| | // that when starting with an indirectly allocated prevector with 423| | // size and capacity > N, the result may be a still indirectly allocated 424| | // prevector with size <= N and capacity > N. A shrink_to_fit() call is 425| | // necessary to switch to the (more efficient) directly allocated 426| | // representation (with capacity N and size <= N). 427| 159k| iterator p = first; 428| 159k| char* endp = (char*)&(*end()); 429| 159k| _size -= last - p; 430| 159k| memmove(&(*first), &(*last), endp - ((char*)(&(*last)))); 431| 159k| return first; 432| 159k| } _ZN9prevectorILj8EijiE3endEv: 304| 288k| iterator end() { return iterator(item_ptr(size())); } _ZN9prevectorILj8EijiE4fillEPilRKi: 209| 68.2k| void fill(T* dst, ptrdiff_t count, const T& value = T{}) { 210| 68.2k| std::fill_n(dst, count, value); 211| 68.2k| } _ZN9prevectorILj8EijiE6insertENS0_8iteratorEjRKi: 373| 30.6k| void insert(iterator pos, size_type count, const T& value) { 374| 30.6k| size_type p = pos - begin(); 375| 30.6k| size_type new_size = size() + count; 376| 30.6k| if (capacity() < new_size) { ------------------ | Branch (376:13): [True: 2.19k, False: 28.4k] ------------------ 377| 2.19k| change_capacity(new_size + (new_size >> 1)); 378| 2.19k| } 379| 30.6k| T* ptr = item_ptr(p); 380| 30.6k| T* dst = ptr + count; 381| 30.6k| memmove(dst, ptr, (size() - p) * sizeof(T)); 382| 30.6k| _size += count; 383| 30.6k| fill(item_ptr(p), count, value); 384| 30.6k| } _ZN9prevectorILj8EijiE9push_backERKi: 444| 29.2k| void push_back(const T& value) { 445| 29.2k| emplace_back(value); 446| 29.2k| } _ZN9prevectorILj8EijiE12emplace_backIJRKiEEEvDpOT_: 435| 29.2k| void emplace_back(Args&&... args) { 436| 29.2k| size_type new_size = size() + 1; 437| 29.2k| if (capacity() < new_size) { ------------------ | Branch (437:13): [True: 2.07k, False: 27.1k] ------------------ 438| 2.07k| change_capacity(new_size + (new_size >> 1)); 439| 2.07k| } 440| 29.2k| new(item_ptr(size())) T(std::forward(args)...); 441| 29.2k| _size++; 442| 29.2k| } _ZN9prevectorILj8EijiE6insertITkNSt3__114input_iteratorEPiEEvNS0_8iteratorET_S5_: 387| 21.7k| void insert(iterator pos, InputIterator first, InputIterator last) { 388| 21.7k| size_type p = pos - begin(); 389| 21.7k| difference_type count = last - first; 390| 21.7k| size_type new_size = size() + count; 391| 21.7k| if (capacity() < new_size) { ------------------ | Branch (391:13): [True: 1.93k, False: 19.7k] ------------------ 392| 1.93k| change_capacity(new_size + (new_size >> 1)); 393| 1.93k| } 394| 21.7k| T* ptr = item_ptr(p); 395| 21.7k| T* dst = ptr + count; 396| 21.7k| memmove(dst, ptr, (size() - p) * sizeof(T)); 397| 21.7k| _size += count; 398| 21.7k| fill(ptr, first, last); 399| 21.7k| } _ZN9prevectorILj8EijiE4fillITkNSt3__114input_iteratorEPiEEvS3_T_S4_: 214| 21.7k| void fill(T* dst, InputIterator first, InputIterator last) { 215| 68.7k| while (first != last) { ------------------ | Branch (215:16): [True: 47.0k, False: 21.7k] ------------------ 216| 47.0k| new(static_cast(dst)) T(*first); 217| 47.0k| ++dst; 218| 47.0k| ++first; 219| 47.0k| } 220| 21.7k| } _ZN9prevectorILj8EijiE20resize_uninitializedEj: 401| 46.1k| inline void resize_uninitialized(size_type new_size) { 402| | // resize_uninitialized changes the size of the prevector but does not initialize it. 403| | // If size < new_size, the added elements must be initialized explicitly. 404| 46.1k| if (capacity() < new_size) { ------------------ | Branch (404:13): [True: 3.99k, False: 42.1k] ------------------ 405| 3.99k| change_capacity(new_size); 406| 3.99k| _size += new_size - size(); 407| 3.99k| return; 408| 3.99k| } 409| 42.1k| if (new_size < size()) { ------------------ | Branch (409:13): [True: 13.2k, False: 28.9k] ------------------ 410| 13.2k| erase(item_ptr(new_size), end()); 411| 28.9k| } else { 412| 28.9k| _size += new_size - size(); 413| 28.9k| } 414| 42.1k| } _ZN9prevectorILj8EijiEixEj: 320| 204k| T& operator[](size_type pos) { 321| 204k| return *item_ptr(pos); 322| 204k| } _ZN9prevectorILj8EijiE7reserveEj: 345| 28.6k| void reserve(size_type new_capacity) { 346| 28.6k| if (new_capacity > capacity()) { ------------------ | Branch (346:13): [True: 16.1k, False: 12.5k] ------------------ 347| 16.1k| change_capacity(new_capacity); 348| 16.1k| } 349| 28.6k| } _ZN9prevectorILj8EijiE13shrink_to_fitEv: 351| 20.9k| void shrink_to_fit() { 352| 20.9k| change_capacity(size()); 353| 20.9k| } _ZN9prevectorILj8EijiE5clearEv: 355| 118k| void clear() { 356| 118k| resize(0); 357| 118k| } _ZN9prevectorILj8EijiE6assignEjRKi: 223| 29.3k| void assign(size_type n, const T& val) { 224| 29.3k| clear(); 225| 29.3k| if (capacity() < n) { ------------------ | Branch (225:13): [True: 10.6k, False: 18.7k] ------------------ 226| 10.6k| change_capacity(n); 227| 10.6k| } 228| 29.3k| _size += n; 229| 29.3k| fill(item_ptr(0), n, val); 230| 29.3k| } _ZN9prevectorILj8EijiE4swapERS0_: 469| 28.3k| { 470| 28.3k| std::swap(_union, other._union); 471| 28.3k| std::swap(_size, other._size); 472| 28.3k| } _ZN9prevectorILj8EijiEaSERKS0_: 276| 32.8k| prevector& operator=(const prevector& other) { 277| 32.8k| if (&other == this) { ------------------ | Branch (277:13): [True: 0, False: 32.8k] ------------------ 278| 0| return *this; 279| 0| } 280| 32.8k| assign(other.begin(), other.end()); 281| 32.8k| return *this; 282| 32.8k| } _ZN9prevectorILj8EijiE6assignITkNSt3__114input_iteratorENS0_14const_iteratorEEEvT_S4_: 233| 32.8k| void assign(InputIterator first, InputIterator last) { 234| 32.8k| size_type n = last - first; 235| 32.8k| clear(); 236| 32.8k| if (capacity() < n) { ------------------ | Branch (236:13): [True: 1.45k, False: 31.3k] ------------------ 237| 1.45k| change_capacity(n); 238| 1.45k| } 239| 32.8k| _size += n; 240| 32.8k| fill(item_ptr(0), first, last); 241| 32.8k| } _ZmiN9prevectorILj8EijiE14const_iteratorES1_: 118| 34.7k| difference_type friend operator-(const_iterator a, const_iterator b) { return (&(*a) - &(*b)); } _ZNK9prevectorILj8EijiE14const_iteratordeEv: 111| 161M| const T& operator*() const { return *ptr; } _ZN9prevectorILj8EijiE4fillITkNSt3__114input_iteratorENS0_14const_iteratorEEEvPiT_S5_: 214| 34.7k| void fill(T* dst, InputIterator first, InputIterator last) { 215| 74.2M| while (first != last) { ------------------ | Branch (215:16): [True: 74.1M, False: 34.7k] ------------------ 216| 74.1M| new(static_cast(dst)) T(*first); 217| 74.1M| ++dst; 218| 74.1M| ++first; 219| 74.1M| } 220| 34.7k| } _ZNK9prevectorILj8EijiE14const_iteratorneES1_: 125| 129M| bool operator!=(const_iterator x) const { return ptr != x.ptr; } _ZN9prevectorILj8EijiE14const_iteratorppEv: 114| 129M| const_iterator& operator++() { ptr++; return *this; } _ZNK9prevectorILj8EijiE5beginEv: 303| 15.8M| const_iterator begin() const { return const_iterator(item_ptr(0)); } _ZNK9prevectorILj8EijiE8item_ptrEi: 207| 55.5M| const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); } ------------------ | Branch (207:59): [True: 70.7k, False: 55.4M] ------------------ _ZNK9prevectorILj8EijiE10direct_ptrEi: 170| 70.7k| const T* direct_ptr(difference_type pos) const { return reinterpret_cast(_union.direct) + pos; } _ZNK9prevectorILj8EijiE12indirect_ptrEi: 172| 55.4M| const T* indirect_ptr(difference_type pos) const { return reinterpret_cast(_union.indirect_contents.indirect) + pos; } _ZN9prevectorILj8EijiE14const_iteratorC2EPKi: 109| 47.6M| const_iterator(const T* ptr_) : ptr(ptr_) {} _ZNK9prevectorILj8EijiE3endEv: 305| 7.97M| const_iterator end() const { return const_iterator(item_ptr(size())); } _ZN9prevectorILj8EijiEaSEOS0_: 284| 37.2k| prevector& operator=(prevector&& other) noexcept { 285| 37.2k| if (!is_direct()) { ------------------ | Branch (285:13): [True: 16.6k, False: 20.5k] ------------------ 286| 16.6k| free(_union.indirect_contents.indirect); 287| 16.6k| } 288| 37.2k| _union = std::move(other._union); 289| 37.2k| _size = other._size; 290| 37.2k| other._size = 0; 291| 37.2k| return *this; 292| 37.2k| } _ZN9prevectorILj8EijiE5eraseENS0_8iteratorE: 416| 17.3k| iterator erase(iterator pos) { 417| 17.3k| return erase(pos, pos + 1); 418| 17.3k| } _ZN9prevectorILj8EijiE8pop_backEv: 448| 21.9k| void pop_back() { 449| 21.9k| erase(end() - 1, end()); 450| 21.9k| } _ZNK9prevectorILj8EijiE8iteratormiEj: 70| 21.9k| iterator operator-(size_type n) const { return iterator(ptr - n); } _ZNK9prevectorILj8EijiE5emptyEv: 298| 1.98k| bool empty() const { 299| 1.98k| return size() == 0; 300| 1.98k| } _ZNK9prevectorILj8EijiEixEj: 324| 31.6M| const T& operator[](size_type pos) const { 325| 31.6M| return *item_ptr(pos); 326| 31.6M| } _ZNK9prevectorILj8EijiE14const_iteratorixEj: 113| 7.92M| const T& operator[](size_type pos) const { return ptr[pos]; } _ZNK9prevectorILj8EijiE14const_iteratorplEj: 119| 15.8M| const_iterator operator+(size_type n) const { return const_iterator(ptr + n); } _ZNK9prevectorILj8EijiE14const_iteratormiEj: 122| 7.92M| const_iterator operator-(size_type n) const { return const_iterator(ptr - n); } _ZN9prevectorILj8EijiEC2ITkNSt3__114input_iteratorENS2_11__wrap_iterIPKiEEEET_S7_: 256| 1.98k| prevector(InputIterator first, InputIterator last) { 257| 1.98k| size_type n = last - first; 258| 1.98k| change_capacity(n); 259| 1.98k| _size += n; 260| 1.98k| fill(item_ptr(0), first, last); 261| 1.98k| } _ZN9prevectorILj8EijiE4fillITkNSt3__114input_iteratorENS2_11__wrap_iterIPKiEEEEvPiT_S8_: 214| 1.98k| void fill(T* dst, InputIterator first, InputIterator last) { 215| 7.92M| while (first != last) { ------------------ | Branch (215:16): [True: 7.92M, False: 1.98k] ------------------ 216| 7.92M| new(static_cast(dst)) T(*first); 217| 7.92M| ++dst; 218| 7.92M| ++first; 219| 7.92M| } 220| 1.98k| } _ZNK9prevectorILj8EijiEeqERKS0_: 481| 3.97k| bool operator==(const prevector& other) const { 482| 3.97k| if (other.size() != size()) { ------------------ | Branch (482:13): [True: 0, False: 3.97k] ------------------ 483| 0| return false; 484| 0| } 485| 3.97k| const_iterator b1 = begin(); 486| 3.97k| const_iterator b2 = other.begin(); 487| 3.97k| const_iterator e1 = end(); 488| 15.8M| while (b1 != e1) { ------------------ | Branch (488:16): [True: 15.8M, False: 3.97k] ------------------ 489| 15.8M| if ((*b1) != (*b2)) { ------------------ | Branch (489:17): [True: 0, False: 15.8M] ------------------ 490| 0| return false; 491| 0| } 492| 15.8M| ++b1; 493| 15.8M| ++b2; 494| 15.8M| } 495| 3.97k| return true; 496| 3.97k| } _ZN9prevectorILj8EijiEC2ITkNSt3__114input_iteratorENS0_14const_iteratorEEET_S4_: 256| 1.98k| prevector(InputIterator first, InputIterator last) { 257| 1.98k| size_type n = last - first; 258| 1.98k| change_capacity(n); 259| 1.98k| _size += n; 260| 1.98k| fill(item_ptr(0), first, last); 261| 1.98k| } _ZN9prevectorILj8EijiE14const_iteratormmEv: 115| 31.6M| const_iterator& operator--() { ptr--; return *this; } _Z14ser_writedata8I10DataStreamEvRT_h: 55| 3.97k|{ 56| 3.97k| s.write(AsBytes(Span{&obj, 1})); 57| 3.97k|} _Z16WriteCompactSizeI10DataStreamEvRT_m: 309| 3.97k|{ 310| 3.97k| if (nSize < 253) ------------------ | Branch (310:9): [True: 3.05k, False: 918] ------------------ 311| 3.05k| { 312| 3.05k| ser_writedata8(os, nSize); 313| 3.05k| } 314| 918| else if (nSize <= std::numeric_limits::max()) ------------------ | Branch (314:14): [True: 918, False: 0] ------------------ 315| 918| { 316| 918| ser_writedata8(os, 253); 317| 918| ser_writedata16(os, nSize); 318| 918| } 319| 0| else if (nSize <= std::numeric_limits::max()) ------------------ | Branch (319:14): [True: 0, False: 0] ------------------ 320| 0| { 321| 0| ser_writedata8(os, 254); 322| 0| ser_writedata32(os, nSize); 323| 0| } 324| 0| else 325| 0| { 326| 0| ser_writedata8(os, 255); 327| 0| ser_writedata64(os, nSize); 328| 0| } 329| 3.97k| return; 330| 3.97k|} _Z15ser_writedata16I10DataStreamEvRT_t: 59| 918|{ 60| 918| obj = htole16_internal(obj); 61| 918| s.write(AsBytes(Span{&obj, 1})); 62| 918|} _Z15ser_writedata32I10DataStreamEvRT_j: 69| 15.8M|{ 70| 15.8M| obj = htole32_internal(obj); 71| 15.8M| s.write(AsBytes(Span{&obj, 1})); 72| 15.8M|} _Z9SerializeI10DataStreamEvRT_i: 261| 15.8M|template inline void Serialize(Stream& s, int32_t a ) { ser_writedata32(s, a); } _Z9SerializeI10DataStreamiNSt3__19allocatorIiEEEvRT_RKNS1_6vectorIT0_T1_EE: 846| 1.98k|{ 847| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 848| | WriteCompactSize(os, v.size()); 849| | if (!v.empty()) os.write(MakeByteSpan(v)); 850| | } else if constexpr (std::is_same_v) { 851| | // A special case for std::vector, as dereferencing 852| | // std::vector::const_iterator does not result in a const bool& 853| | // due to std::vector's special casing for bool arguments. 854| | WriteCompactSize(os, v.size()); 855| | for (bool elem : v) { 856| | ::Serialize(os, elem); 857| | } 858| 1.98k| } else { 859| 1.98k| Serialize(os, Using>(v)); 860| 1.98k| } 861| 1.98k|} _Z9SerializeI10DataStream7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorIiNS5_9allocatorIiEEEEEQ12SerializableIT0_T_EEvRSE_RKSD_: 753| 1.98k|{ 754| 1.98k| a.Serialize(os); 755| 1.98k|} _ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorIiNS3_9allocatorIiEEEEE9SerializeI10DataStreamEEvRT_: 482| 1.98k| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE3SerI10DataStreamNSt3__16vectorIiNS4_9allocatorIiEEEEEEvRT_RKT0_: 662| 1.98k| { 663| 1.98k| Formatter formatter; 664| 1.98k| WriteCompactSize(s, v.size()); 665| 7.92M| for (const typename V::value_type& elem : v) { ------------------ | Branch (665:49): [True: 7.92M, False: 1.98k] ------------------ 666| 7.92M| formatter.Ser(s, elem); 667| 7.92M| } 668| 1.98k| } _ZN16DefaultFormatter3SerI10DataStreamiEEvRT_RKT0_: 774| 15.8M| static void Ser(Stream& s, const T& t) { Serialize(s, t); } prevector.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorIiNS3_9allocatorIiEEEEE7WrapperIT_RT0_EOSC_: 497| 1.98k|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorIiNS3_9allocatorIiEEEEEC2ES9_: 481| 1.98k| explicit Wrapper(T obj) : m_object(obj) {} _Z9SerializeI10DataStreamLj8EiEvRT_RK9prevectorIXT0_ET1_jiE: 811| 1.98k|{ 812| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 813| | WriteCompactSize(os, v.size()); 814| | if (!v.empty()) os.write(MakeByteSpan(v)); 815| 1.98k| } else { 816| 1.98k| Serialize(os, Using>(v)); 817| 1.98k| } 818| 1.98k|} _Z9SerializeI10DataStream7WrapperI15VectorFormatterI16DefaultFormatterERK9prevectorILj8EijiEEQ12SerializableIT0_T_EEvRSB_RKSA_: 753| 1.98k|{ 754| 1.98k| a.Serialize(os); 755| 1.98k|} _ZNK7WrapperI15VectorFormatterI16DefaultFormatterERK9prevectorILj8EijiEE9SerializeI10DataStreamEEvRT_: 482| 1.98k| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE3SerI10DataStream9prevectorILj8EijiEEEvRT_RKT0_: 662| 1.98k| { 663| 1.98k| Formatter formatter; 664| 1.98k| WriteCompactSize(s, v.size()); 665| 7.92M| for (const typename V::value_type& elem : v) { ------------------ | Branch (665:49): [True: 7.92M, False: 1.98k] ------------------ 666| 7.92M| formatter.Ser(s, elem); 667| 7.92M| } 668| 1.98k| } prevector.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERK9prevectorILj8EijiEE7WrapperIT_RT0_EOS9_: 497| 1.98k|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI15VectorFormatterI16DefaultFormatterERK9prevectorILj8EijiEEC2ES6_: 481| 1.98k| explicit Wrapper(T obj) : m_object(obj) {} _ZNK4SpanIhE4dataEv: 174| 3.97k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIKSt4byteE5beginEv: 175| 15.8M| constexpr C* begin() const noexcept { return m_data; } _ZNK4SpanIKSt4byteE3endEv: 176| 15.8M| constexpr C* end() const noexcept { return m_data + m_size; } _ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m: 119| 15.8M| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZNK4SpanIjE4dataEv: 174| 15.8M| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIjE10size_bytesEv: 188| 15.8M| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _Z7AsBytesIjE4SpanIKSt4byteES0_IT_E: 259| 15.8M|{ 260| 15.8M| return {reinterpret_cast(s.data()), s.size_bytes()}; 261| 15.8M|} _ZNK4SpanIhE10size_bytesEv: 188| 3.97k| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _Z7AsBytesIhE4SpanIKSt4byteES0_IT_E: 259| 3.97k|{ 260| 3.97k| return {reinterpret_cast(s.data()), s.size_bytes()}; 261| 3.97k|} _ZNK4SpanItE4dataEv: 174| 918| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanItE10size_bytesEv: 188| 918| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _Z7AsBytesItE4SpanIKSt4byteES0_IT_E: 259| 918|{ 260| 918| return {reinterpret_cast(s.data()), s.size_bytes()}; 261| 918|} _ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m: 119| 3.97k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m: 119| 918| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m: 119| 15.8M| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZNK10DataStream4sizeEv: 181| 31.6M| size_type size() const { return vch.size() - m_read_pos; } _ZN10DataStreamixEm: 186| 63.3M| reference operator[](size_type pos) { return vch[pos + m_read_pos]; } _ZN10DataStream5writeE4SpanIKSt4byteE: 252| 15.8M| { 253| | // Write to the end of the buffer 254| 15.8M| vch.insert(vch.end(), src.begin(), src.end()); 255| 15.8M| } _ZN10DataStreamC2Ev: 164| 3.97k| explicit DataStream() = default; _ZN10DataStreamlsINSt3__16vectorIiNS1_9allocatorIiEEEEEERS_RKT_: 259| 1.98k| { 260| 1.98k| ::Serialize(*this, obj); 261| 1.98k| return (*this); 262| 1.98k| } _ZN10DataStreamlsI9prevectorILj8EijiEEERS_RKT_: 259| 1.98k| { 260| 1.98k| ::Serialize(*this, obj); 261| 1.98k| return (*this); 262| 1.98k| } _ZN25zero_after_free_allocatorISt4byteE10deallocateEPS0_m: 30| 24.9k| { 31| 24.9k| if (p != nullptr) ------------------ | Branch (31:13): [True: 24.9k, False: 0] ------------------ 32| 24.9k| memory_cleanse(p, sizeof(T) * n); 33| 24.9k| std::allocator{}.deallocate(p, n); 34| 24.9k| } _ZN25zero_after_free_allocatorISt4byteE8allocateEm: 25| 24.9k| { 26| 24.9k| return std::allocator{}.allocate(n); 27| 24.9k| } _Z14memory_cleansePvm: 15| 24.9k|{ 16| |#if defined(WIN32) 17| | /* SecureZeroMemory is guaranteed not to be optimized out. */ 18| | SecureZeroMemory(ptr, len); 19| |#else 20| 24.9k| 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| 24.9k| __asm__ __volatile__("" : : "r"(ptr) : "memory"); 34| 24.9k|#endif 35| 24.9k|} _ZN18FuzzedDataProviderC2EPKhm: 37| 1.98k| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_: 205| 250k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 250k| static_assert(std::is_integral::value, "An integral type is required."); 207| 250k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 250k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 250k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 250k| uint64_t range = static_cast(max) - static_cast(min); 214| 250k| uint64_t result = 0; 215| 250k| size_t offset = 0; 216| | 217| 575k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 575k, False: 0] | Branch (217:43): [True: 326k, False: 249k] ------------------ 218| 575k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 325k, False: 545] ------------------ 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| 325k| --remaining_bytes_; 226| 325k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 325k| offset += CHAR_BIT; 228| 325k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 250k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 250k, False: 0] ------------------ 232| 250k| result = result % (range + 1); 233| | 234| 250k| return static_cast(static_cast(min) + result); 235| 250k|} _ZN18FuzzedDataProvider15ConsumeIntegralIiEET_v: 195| 429k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 429k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 429k| std::numeric_limits::max()); 198| 429k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_: 205| 1.10M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 1.10M| static_assert(std::is_integral::value, "An integral type is required."); 207| 1.10M| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 1.10M| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 1.10M] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 1.10M| uint64_t range = static_cast(max) - static_cast(min); 214| 1.10M| uint64_t result = 0; 215| 1.10M| size_t offset = 0; 216| | 217| 3.47M| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 3.05M, False: 427k] | Branch (217:43): [True: 2.37M, False: 680k] ------------------ 218| 3.47M| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 2.36M, False: 2.14k] ------------------ 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.36M| --remaining_bytes_; 226| 2.36M| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 2.36M| offset += CHAR_BIT; 228| 2.36M| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 1.10M| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 1.10M, False: 0] ------------------ 232| 1.10M| result = result % (range + 1); 233| | 234| 1.10M| return static_cast(static_cast(min) + result); 235| 1.10M|} _ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v: 195| 30.6k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 30.6k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 30.6k| std::numeric_limits::max()); 198| 30.6k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_: 205| 30.6k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 30.6k| static_assert(std::is_integral::value, "An integral type is required."); 207| 30.6k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 30.6k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 30.6k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 30.6k| uint64_t range = static_cast(max) - static_cast(min); 214| 30.6k| uint64_t result = 0; 215| 30.6k| size_t offset = 0; 216| | 217| 61.2k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 30.6k, False: 30.5k] | Branch (217:43): [True: 30.6k, False: 0] ------------------ 218| 61.2k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 30.5k, False: 137] ------------------ 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| 30.5k| --remaining_bytes_; 226| 30.5k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 30.5k| offset += CHAR_BIT; 228| 30.5k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 30.6k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 30.6k, False: 0] ------------------ 232| 30.6k| result = result % (range + 1); 233| | 234| 30.6k| return static_cast(static_cast(min) + result); 235| 30.6k|} _ZN18FuzzedDataProvider15remaining_bytesEv: 85| 533k| size_t remaining_bytes() { return remaining_bytes_; } _ZN18FuzzedDataProvider11ConsumeBoolEv: 289| 30.6k|inline bool FuzzedDataProvider::ConsumeBool() { 290| 30.6k| return 1 & ConsumeIntegral(); 291| 30.6k|} LLVMFuzzerTestOneInput: 222| 1.98k|{ 223| 1.98k| test_one_input({data, size}); 224| 1.98k| return 0; 225| 1.98k|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 83| 1.98k|{ 84| 1.98k| CheckGlobals check{}; 85| 1.98k| (*Assert(g_test_one_input))(buffer); ------------------ | | 85| 1.98k|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 86| 1.98k|} _Z21prevector_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 206| 1.98k|{ 207| 1.98k| FuzzedDataProvider prov(buffer.data(), buffer.size()); 208| 1.98k| prevector_tester<8, int> test; 209| | 210| 1.98k| LIMITED_WHILE(prov.remaining_bytes(), 3000) ------------------ | | 23| 533k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 531k, False: 1.84k] | | | Branch (23:49): [True: 531k, False: 145] | | ------------------ ------------------ 211| 531k| { 212| 531k| switch (prov.ConsumeIntegralInRange(0, 13 + 3 * (test.size() > 0))) { ------------------ | Branch (212:17): [True: 0, False: 531k] ------------------ 213| 88.0k| case 0: { ------------------ | Branch (213:9): [True: 88.0k, False: 443k] ------------------ 214| 88.0k| auto position = prov.ConsumeIntegralInRange(0, test.size()); 215| 88.0k| auto value = prov.ConsumeIntegral(); 216| 88.0k| test.insert(position, value); 217| 88.0k| } break; 218| 32.9k| case 1: ------------------ | Branch (218:9): [True: 32.9k, False: 498k] ------------------ 219| 32.9k| test.resize(std::max(0, std::min(30, (int)test.size() + prov.ConsumeIntegralInRange(0, 4) - 2))); 220| 32.9k| break; 221| 30.6k| case 2: { ------------------ | Branch (221:9): [True: 30.6k, False: 500k] ------------------ 222| 30.6k| auto position = prov.ConsumeIntegralInRange(0, test.size()); 223| 30.6k| auto count = 1 + prov.ConsumeBool(); 224| 30.6k| auto value = prov.ConsumeIntegral(); 225| 30.6k| test.insert(position, count, value); 226| 30.6k| } break; 227| 35.6k| case 3: { ------------------ | Branch (227:9): [True: 35.6k, False: 495k] ------------------ 228| 35.6k| int del = prov.ConsumeIntegralInRange(0, test.size()); 229| 35.6k| int beg = prov.ConsumeIntegralInRange(0, test.size() - del); 230| 35.6k| test.erase(beg, beg + del); 231| 35.6k| break; 232| 0| } 233| 29.2k| case 4: ------------------ | Branch (233:9): [True: 29.2k, False: 502k] ------------------ 234| 29.2k| test.push_back(prov.ConsumeIntegral()); 235| 29.2k| break; 236| 21.7k| case 5: { ------------------ | Branch (236:9): [True: 21.7k, False: 509k] ------------------ 237| 21.7k| int values[4]; 238| 21.7k| int num = 1 + prov.ConsumeIntegralInRange(0, 3); 239| 68.7k| for (int k = 0; k < num; ++k) { ------------------ | Branch (239:29): [True: 47.0k, False: 21.7k] ------------------ 240| 47.0k| values[k] = prov.ConsumeIntegral(); 241| 47.0k| } 242| 21.7k| test.insert_range(prov.ConsumeIntegralInRange(0, test.size()), values, values + num); 243| 21.7k| break; 244| 0| } 245| 23.0k| case 6: { ------------------ | Branch (245:9): [True: 23.0k, False: 508k] ------------------ 246| 23.0k| int num = 1 + prov.ConsumeIntegralInRange(0, 15); 247| 23.0k| std::vector values(num); 248| 170k| for (auto& v : values) { ------------------ | Branch (248:26): [True: 170k, False: 23.0k] ------------------ 249| 170k| v = prov.ConsumeIntegral(); 250| 170k| } 251| 23.0k| test.resize_uninitialized(values); 252| 23.0k| break; 253| 0| } 254| 28.6k| case 7: ------------------ | Branch (254:9): [True: 28.6k, False: 502k] ------------------ 255| 28.6k| test.reserve(prov.ConsumeIntegralInRange(0, 32767)); 256| 28.6k| break; 257| 20.9k| case 8: ------------------ | Branch (257:9): [True: 20.9k, False: 510k] ------------------ 258| 20.9k| test.shrink_to_fit(); 259| 20.9k| break; 260| 19.1k| case 9: ------------------ | Branch (260:9): [True: 19.1k, False: 512k] ------------------ 261| 19.1k| test.clear(); 262| 19.1k| break; 263| 29.3k| case 10: { ------------------ | Branch (263:9): [True: 29.3k, False: 502k] ------------------ 264| 29.3k| auto n = prov.ConsumeIntegralInRange(0, 32767); 265| 29.3k| auto value = prov.ConsumeIntegral(); 266| 29.3k| test.assign(n, value); 267| 29.3k| } break; 268| 28.3k| case 11: ------------------ | Branch (268:9): [True: 28.3k, False: 503k] ------------------ 269| 28.3k| test.swap(); 270| 28.3k| break; 271| 32.8k| case 12: ------------------ | Branch (271:9): [True: 32.8k, False: 498k] ------------------ 272| 32.8k| test.copy(); 273| 32.8k| break; 274| 37.2k| case 13: ------------------ | Branch (274:9): [True: 37.2k, False: 494k] ------------------ 275| 37.2k| test.move(); 276| 37.2k| break; 277| 34.5k| case 14: { ------------------ | Branch (277:9): [True: 34.5k, False: 497k] ------------------ 278| 34.5k| auto pos = prov.ConsumeIntegralInRange(0, test.size() - 1); 279| 34.5k| auto value = prov.ConsumeIntegral(); 280| 34.5k| test.update(pos, value); 281| 34.5k| } break; 282| 17.3k| case 15: ------------------ | Branch (282:9): [True: 17.3k, False: 514k] ------------------ 283| 17.3k| test.erase(prov.ConsumeIntegralInRange(0, test.size() - 1)); 284| 17.3k| break; 285| 21.9k| case 16: ------------------ | Branch (285:9): [True: 21.9k, False: 509k] ------------------ 286| 21.9k| test.pop_back(); 287| 21.9k| break; 288| 531k| } 289| 531k| } 290| | 291| 1.98k| test.test(); 292| 1.98k|} prevector.cpp:_ZNK12_GLOBAL__N_116prevector_testerILj8EiE4sizeEv: 148| 828k| { 149| 828k| return real_vector.size(); 150| 828k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE6insertEjRKi: 87| 88.0k| { 88| 88.0k| real_vector.insert(real_vector.begin() + position, value); 89| 88.0k| pre_vector.insert(pre_vector.begin() + position, value); 90| 88.0k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE6resizeEj: 71| 32.9k| { 72| 32.9k| real_vector.resize(s); 73| 32.9k| assert(real_vector.size() == s); 74| 32.9k| pre_vector.resize(s); 75| 32.9k| assert(pre_vector.size() == s); 76| 32.9k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE6insertEjjRKi: 93| 30.6k| { 94| 30.6k| real_vector.insert(real_vector.begin() + position, count, value); 95| 30.6k| pre_vector.insert(pre_vector.begin() + position, count, value); 96| 30.6k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE5eraseEjj: 112| 35.6k| { 113| 35.6k| real_vector.erase(real_vector.begin() + first, real_vector.begin() + last); 114| 35.6k| pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last); 115| 35.6k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE9push_backERKi: 124| 29.2k| { 125| 29.2k| real_vector.push_back(value); 126| 29.2k| pre_vector.push_back(value); 127| 29.2k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE12insert_rangeIPiEEvjT_S4_: 100| 21.7k| { 101| 21.7k| real_vector.insert(real_vector.begin() + position, first, last); 102| 21.7k| pre_vector.insert(pre_vector.begin() + position, first, last); 103| 21.7k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE20resize_uninitializedENSt3__16vectorIiNS2_9allocatorIiEEEE: 183| 23.0k| { 184| 23.0k| size_t r = values.size(); 185| 23.0k| size_t s = real_vector.size() / 2; 186| 23.0k| if (real_vector.capacity() < s + r) { ------------------ | Branch (186:13): [True: 5.61k, False: 17.4k] ------------------ 187| 5.61k| real_vector.reserve(s + r); 188| 5.61k| } 189| 23.0k| real_vector.resize(s); 190| 23.0k| pre_vector.resize_uninitialized(s); 191| 170k| for (auto v : values) { ------------------ | Branch (191:21): [True: 170k, False: 23.0k] ------------------ 192| 170k| real_vector.push_back(v); 193| 170k| } 194| 23.0k| auto p = pre_vector.size(); 195| 23.0k| pre_vector.resize_uninitialized(p + r); 196| 170k| for (auto v : values) { ------------------ | Branch (196:21): [True: 170k, False: 23.0k] ------------------ 197| 170k| pre_vector[p] = v; 198| 170k| ++p; 199| 170k| } 200| 23.0k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE7reserveEj: 79| 28.6k| { 80| 28.6k| real_vector.reserve(s); 81| 28.6k| assert(real_vector.capacity() >= s); 82| 28.6k| pre_vector.reserve(s); 83| 28.6k| assert(pre_vector.capacity() >= s); 84| 28.6k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE13shrink_to_fitEv: 158| 20.9k| { 159| 20.9k| pre_vector.shrink_to_fit(); 160| 20.9k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE5clearEv: 136| 19.1k| { 137| 19.1k| real_vector.clear(); 138| 19.1k| pre_vector.clear(); 139| 19.1k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE6assignEjRKi: 142| 29.3k| { 143| 29.3k| real_vector.assign(n, value); 144| 29.3k| pre_vector.assign(n, value); 145| 29.3k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE4swapEv: 163| 28.3k| { 164| 28.3k| real_vector.swap(real_vector_alt); 165| 28.3k| pre_vector.swap(pre_vector_alt); 166| 28.3k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE4copyEv: 177| 32.8k| { 178| 32.8k| real_vector = real_vector_alt; 179| 32.8k| pre_vector = pre_vector_alt; 180| 32.8k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE4moveEv: 169| 37.2k| { 170| 37.2k| real_vector = std::move(real_vector_alt); 171| 37.2k| real_vector_alt.clear(); 172| 37.2k| pre_vector = std::move(pre_vector_alt); 173| 37.2k| pre_vector_alt.clear(); 174| 37.2k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE6updateEjRKi: 118| 34.5k| { 119| 34.5k| real_vector[pos] = value; 120| 34.5k| pre_vector[pos] = value; 121| 34.5k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE5eraseEj: 106| 17.3k| { 107| 17.3k| real_vector.erase(real_vector.begin() + position); 108| 17.3k| pre_vector.erase(pre_vector.begin() + position); 109| 17.3k| } prevector.cpp:_ZN12_GLOBAL__N_116prevector_testerILj8EiE8pop_backEv: 130| 21.9k| { 131| 21.9k| real_vector.pop_back(); 132| 21.9k| pre_vector.pop_back(); 133| 21.9k| } prevector.cpp:_ZNK12_GLOBAL__N_116prevector_testerILj8EiE4testEv: 30| 1.98k| { 31| 1.98k| const pretype& const_pre_vector = pre_vector; 32| 1.98k| assert(real_vector.size() == pre_vector.size()); 33| 1.98k| assert(real_vector.empty() == pre_vector.empty()); 34| 7.92M| for (Size s = 0; s < real_vector.size(); s++) { ------------------ | Branch (34:26): [True: 7.92M, False: 1.98k] ------------------ 35| 7.92M| assert(real_vector[s] == pre_vector[s]); 36| 7.92M| assert(&(pre_vector[s]) == &(pre_vector.begin()[s])); 37| 7.92M| assert(&(pre_vector[s]) == &*(pre_vector.begin() + s)); 38| 7.92M| assert(&(pre_vector[s]) == &*((pre_vector.end() + s) - real_vector.size())); 39| 7.92M| } 40| | // assert(realtype(pre_vector) == real_vector); 41| 1.98k| assert(pretype(real_vector.begin(), real_vector.end()) == pre_vector); 42| 1.98k| assert(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector); 43| 1.98k| size_t pos = 0; 44| 7.92M| for (const T& v : pre_vector) { ------------------ | Branch (44:25): [True: 7.92M, False: 1.98k] ------------------ 45| 7.92M| assert(v == real_vector[pos]); 46| 7.92M| ++pos; 47| 7.92M| } 48| 7.92M| for (const T& v : pre_vector | std::views::reverse) { ------------------ | Branch (48:25): [True: 7.92M, False: 1.98k] ------------------ 49| 7.92M| --pos; 50| 7.92M| assert(v == real_vector[pos]); 51| 7.92M| } 52| 7.92M| for (const T& v : const_pre_vector) { ------------------ | Branch (52:25): [True: 7.92M, False: 1.98k] ------------------ 53| 7.92M| assert(v == real_vector[pos]); 54| 7.92M| ++pos; 55| 7.92M| } 56| 7.92M| for (const T& v : const_pre_vector | std::views::reverse) { ------------------ | Branch (56:25): [True: 7.92M, False: 1.98k] ------------------ 57| 7.92M| --pos; 58| 7.92M| assert(v == real_vector[pos]); 59| 7.92M| } 60| 1.98k| DataStream ss1{}; 61| 1.98k| DataStream ss2{}; 62| 1.98k| ss1 << real_vector; 63| 1.98k| ss2 << pre_vector; 64| 1.98k| assert(ss1.size() == ss2.size()); 65| 31.6M| for (Size s = 0; s < ss1.size(); s++) { ------------------ | Branch (65:26): [True: 31.6M, False: 1.98k] ------------------ 66| 31.6M| assert(ss1[s] == ss2[s]); 67| 31.6M| } 68| 1.98k| } _ZN12CheckGlobalsC2Ev: 56| 1.98k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 57| 1.98k|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 1.98k| { 18| 1.98k| g_used_g_prng = false; 19| 1.98k| g_seeded_g_prng_zero = false; 20| 1.98k| g_used_system_time = false; 21| 1.98k| SetMockTime(0s); 22| 1.98k| } _ZN16CheckGlobalsImplD2Ev: 24| 1.98k| { 25| 1.98k| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (25:13): [True: 0, False: 1.98k] | Branch (25:30): [True: 0, False: 0] ------------------ 26| 0| std::cerr << "\n\n" 27| 0| "The current fuzz target used the global random state.\n\n" 28| | 29| 0| "This is acceptable, but requires the fuzz target to call \n" 30| 0| "SeedRandomStateForTest(SeedRand::ZEROS) in the first line \n" 31| 0| "of the FUZZ_TARGET function.\n\n" 32| | 33| 0| "An alternative solution would be to avoid any use of globals.\n\n" 34| | 35| 0| "Without a solution, fuzz instability and non-determinism can lead \n" 36| 0| "to non-reproducible bugs or inefficient fuzzing.\n\n" 37| 0| << std::endl; 38| 0| std::abort(); // Abort, because AFL may try to recover from a std::exit 39| 0| } 40| | 41| 1.98k| if (g_used_system_time) { ------------------ | Branch (41:13): [True: 0, False: 1.98k] ------------------ 42| 0| std::cerr << "\n\n" 43| 0| "The current fuzz target accessed system time.\n\n" 44| | 45| 0| "This is acceptable, but requires the fuzz target to call \n" 46| 0| "SetMockTime() at the beginning of processing the fuzz input.\n\n" 47| | 48| 0| "Without setting mock time, time-dependent behavior can lead \n" 49| 0| "to non-reproducible bugs or inefficient fuzzing.\n\n" 50| 0| << std::endl; 51| 0| std::abort(); 52| 0| } 53| 1.98k| } _Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_: 52| 1.98k|{ 53| 1.98k| if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING ------------------ | Branch (53:9): [Folded - Ignored] | Branch (53:22): [Folded - Ignored] | Branch (53:54): [Folded - Ignored] ------------------ 54| |#ifdef ABORT_ON_FAILED_ASSUME 55| | || true 56| |#endif 57| 1.98k| ) { 58| 1.98k| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 1.98k] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 1.98k| } 62| 1.98k| return std::forward(val); 63| 1.98k|} _Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_: 52| 1.98k|{ 53| 1.98k| if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING ------------------ | Branch (53:9): [Folded - Ignored] | Branch (53:22): [Folded - Ignored] | Branch (53:54): [Folded - Ignored] ------------------ 54| |#ifdef ABORT_ON_FAILED_ASSUME 55| | || true 56| |#endif 57| 1.98k| ) { 58| 1.98k| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 1.98k] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 1.98k| } 62| 1.98k| return std::forward(val); 63| 1.98k|} _Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE: 42| 1.98k|{ 43| 1.98k| Assert(mock_time_in >= 0s); ------------------ | | 85| 1.98k|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 44| 1.98k| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 45| 1.98k|}