_Z16htole32_internalj: 39| 3.04M|{ 40| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits); 41| 3.04M| else return host_32bits; 42| 3.04M|} _Z16le32toh_internalj: 49| 46.6k|{ 50| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits); 51| 46.6k| else return little_endian_32bits; 52| 46.6k|} _Z16le64toh_internalm: 69| 1.49M|{ 70| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits); 71| 1.49M| else return little_endian_64bits; 72| 1.49M|} _ZN15ChaCha20Aligned6SetKeyE4SpanIKSt4byteE: 26| 5.83k|{ 27| 5.83k| assert(key.size() == KEYLEN); 28| 5.83k| input[0] = ReadLE32(key.data() + 0); 29| 5.83k| input[1] = ReadLE32(key.data() + 4); 30| 5.83k| input[2] = ReadLE32(key.data() + 8); 31| 5.83k| input[3] = ReadLE32(key.data() + 12); 32| 5.83k| input[4] = ReadLE32(key.data() + 16); 33| 5.83k| input[5] = ReadLE32(key.data() + 20); 34| 5.83k| input[6] = ReadLE32(key.data() + 24); 35| 5.83k| input[7] = ReadLE32(key.data() + 28); 36| 5.83k| input[8] = 0; 37| 5.83k| input[9] = 0; 38| 5.83k| input[10] = 0; 39| 5.83k| input[11] = 0; 40| 5.83k|} _ZN15ChaCha20AlignedD2Ev: 43| 5.83k|{ 44| 5.83k| memory_cleanse(input, sizeof(input)); 45| 5.83k|} _ZN15ChaCha20AlignedC2E4SpanIKSt4byteE: 48| 5.83k|{ 49| 5.83k| SetKey(key); 50| 5.83k|} _ZN8ChaCha209KeystreamE4SpanISt4byteE: 283| 1.49M|{ 284| 1.49M| if (out.empty()) return; ------------------ | Branch (284:9): [True: 0, False: 1.49M] ------------------ 285| 1.49M| if (m_bufleft) { ------------------ | Branch (285:9): [True: 1.30M, False: 190k] ------------------ 286| 1.30M| unsigned reuse = std::min(m_bufleft, out.size()); 287| 1.30M| std::copy(m_buffer.end() - m_bufleft, m_buffer.end() - m_bufleft + reuse, out.begin()); 288| 1.30M| m_bufleft -= reuse; 289| 1.30M| out = out.subspan(reuse); 290| 1.30M| } 291| 1.49M| if (out.size() >= m_aligned.BLOCKLEN) { ------------------ | Branch (291:9): [True: 0, False: 1.49M] ------------------ 292| 0| size_t blocks = out.size() / m_aligned.BLOCKLEN; 293| 0| m_aligned.Keystream(out.first(blocks * m_aligned.BLOCKLEN)); 294| 0| out = out.subspan(blocks * m_aligned.BLOCKLEN); 295| 0| } 296| 1.49M| if (!out.empty()) { ------------------ | Branch (296:9): [True: 190k, False: 1.30M] ------------------ 297| 190k| m_aligned.Keystream(m_buffer); 298| 190k| std::copy(m_buffer.begin(), m_buffer.begin() + out.size(), out.begin()); 299| 190k| m_bufleft = m_aligned.BLOCKLEN - out.size(); 300| 190k| } 301| 1.49M|} _ZN8ChaCha20D2Ev: 333| 5.83k|{ 334| 5.83k| memory_cleanse(m_buffer.data(), m_buffer.size()); 335| 5.83k|} _ZN15ChaCha20Aligned9KeystreamE4SpanISt4byteE: 61| 190k|{ 62| 190k| std::byte* c = output.data(); 63| 190k| size_t blocks = output.size() / BLOCKLEN; 64| 190k| assert(blocks * BLOCKLEN == output.size()); 65| | 66| 190k| uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15; 67| 190k| uint32_t j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15; 68| | 69| 190k| if (!blocks) return; ------------------ | Branch (69:9): [True: 0, False: 190k] ------------------ 70| | 71| 190k| j4 = input[0]; 72| 190k| j5 = input[1]; 73| 190k| j6 = input[2]; 74| 190k| j7 = input[3]; 75| 190k| j8 = input[4]; 76| 190k| j9 = input[5]; 77| 190k| j10 = input[6]; 78| 190k| j11 = input[7]; 79| 190k| j12 = input[8]; 80| 190k| j13 = input[9]; 81| 190k| j14 = input[10]; 82| 190k| j15 = input[11]; 83| | 84| 190k| for (;;) { 85| 190k| x0 = 0x61707865; 86| 190k| x1 = 0x3320646e; 87| 190k| x2 = 0x79622d32; 88| 190k| x3 = 0x6b206574; 89| 190k| x4 = j4; 90| 190k| x5 = j5; 91| 190k| x6 = j6; 92| 190k| x7 = j7; 93| 190k| x8 = j8; 94| 190k| x9 = j9; 95| 190k| x10 = j10; 96| 190k| x11 = j11; 97| 190k| x12 = j12; 98| 190k| x13 = j13; 99| 190k| x14 = j14; 100| 190k| x15 = j15; 101| | 102| | // The 20 inner ChaCha20 rounds are unrolled here for performance. 103| 190k| REPEAT10( ------------------ | | 23| 190k|#define REPEAT10(a) do { {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; } while(0) | | ------------------ | | | Branch (23:84): [Folded - Ignored] | | ------------------ ------------------ 104| 190k| QUARTERROUND( x0, x4, x8,x12); 105| 190k| QUARTERROUND( x1, x5, x9,x13); 106| 190k| QUARTERROUND( x2, x6,x10,x14); 107| 190k| QUARTERROUND( x3, x7,x11,x15); 108| 190k| QUARTERROUND( x0, x5,x10,x15); 109| 190k| QUARTERROUND( x1, x6,x11,x12); 110| 190k| QUARTERROUND( x2, x7, x8,x13); 111| 190k| QUARTERROUND( x3, x4, x9,x14); 112| 190k| ); 113| | 114| 190k| x0 += 0x61707865; 115| 190k| x1 += 0x3320646e; 116| 190k| x2 += 0x79622d32; 117| 190k| x3 += 0x6b206574; 118| 190k| x4 += j4; 119| 190k| x5 += j5; 120| 190k| x6 += j6; 121| 190k| x7 += j7; 122| 190k| x8 += j8; 123| 190k| x9 += j9; 124| 190k| x10 += j10; 125| 190k| x11 += j11; 126| 190k| x12 += j12; 127| 190k| x13 += j13; 128| 190k| x14 += j14; 129| 190k| x15 += j15; 130| | 131| 190k| ++j12; 132| 190k| if (!j12) ++j13; ------------------ | Branch (132:13): [True: 0, False: 190k] ------------------ 133| | 134| 190k| WriteLE32(c + 0, x0); 135| 190k| WriteLE32(c + 4, x1); 136| 190k| WriteLE32(c + 8, x2); 137| 190k| WriteLE32(c + 12, x3); 138| 190k| WriteLE32(c + 16, x4); 139| 190k| WriteLE32(c + 20, x5); 140| 190k| WriteLE32(c + 24, x6); 141| 190k| WriteLE32(c + 28, x7); 142| 190k| WriteLE32(c + 32, x8); 143| 190k| WriteLE32(c + 36, x9); 144| 190k| WriteLE32(c + 40, x10); 145| 190k| WriteLE32(c + 44, x11); 146| 190k| WriteLE32(c + 48, x12); 147| 190k| WriteLE32(c + 52, x13); 148| 190k| WriteLE32(c + 56, x14); 149| 190k| WriteLE32(c + 60, x15); 150| | 151| 190k| if (blocks == 1) { ------------------ | Branch (151:13): [True: 190k, False: 0] ------------------ 152| 190k| input[8] = j12; 153| 190k| input[9] = j13; 154| 190k| return; 155| 190k| } 156| 0| blocks -= 1; 157| 0| c += BLOCKLEN; 158| 0| } 159| 190k|} _ZN8ChaCha20C2E4SpanIKSt4byteE: 92| 5.83k| ChaCha20(Span key) noexcept : m_aligned(key) {} _Z8ReadLE64ITk8ByteTypeSt4byteEmPKT_: 36| 1.49M|{ 37| 1.49M| uint64_t x; 38| 1.49M| memcpy(&x, ptr, 8); 39| 1.49M| return le64toh_internal(x); 40| 1.49M|} _Z9WriteLE32ITk8ByteTypeSt4byteEvPT_j: 51| 3.04M|{ 52| 3.04M| uint32_t v = htole32_internal(x); 53| 3.04M| memcpy(ptr, &v, 4); 54| 3.04M|} _Z8ReadLE32ITk8ByteTypeSt4byteEjPKT_: 28| 46.6k|{ 29| 46.6k| uint32_t x; 30| 46.6k| memcpy(&x, ptr, 4); 31| 46.6k| return le32toh_internal(x); 32| 46.6k|} _ZN17FastRandomContextC2Eb: 764| 5.83k|FastRandomContext::FastRandomContext(bool fDeterministic) noexcept : requires_seed(!fDeterministic), rng(ZERO_KEY) 765| 5.83k|{ 766| | // Note that despite always initializing with ZERO_KEY, requires_seed is set to true if not 767| | // fDeterministic. That means the rng will be reinitialized with a secure random key upon first 768| | // use. 769| 5.83k|} _ZN11RandomMixinI17FastRandomContextE4ImplEv: 185| 96.1M| RandomNumberGenerator auto& Impl() noexcept { return static_cast(*this); } _ZN11RandomMixinI17FastRandomContextE8randbitsEi: 205| 53.2k| { 206| 53.2k| Assume(bits <= 64); ------------------ | | 97| 53.2k|#define Assume(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 207| | // Requests for the full 64 bits are passed through. 208| 53.2k| if (bits == 64) return Impl().rand64(); ------------------ | Branch (208:13): [True: 0, False: 53.2k] ------------------ 209| 53.2k| uint64_t ret; 210| 53.2k| if (bits <= bitbuf_size) { ------------------ | Branch (210:13): [True: 38.1k, False: 15.1k] ------------------ 211| | // If there is enough entropy left in bitbuf, return its bottom bits bits. 212| 38.1k| ret = bitbuf; 213| 38.1k| bitbuf >>= bits; 214| 38.1k| bitbuf_size -= bits; 215| 38.1k| } else { 216| | // If not, return all of bitbuf, supplemented with the (bits - bitbuf_size) bottom 217| | // bits of a newly generated 64-bit number on top. The remainder of that generated 218| | // number becomes the new bitbuf. 219| 15.1k| uint64_t gen = Impl().rand64(); 220| 15.1k| ret = (gen << bitbuf_size) | bitbuf; 221| 15.1k| bitbuf = gen >> (bits - bitbuf_size); 222| 15.1k| bitbuf_size = 64 + bitbuf_size - bits; 223| 15.1k| } 224| | // Return the bottom bits bits of ret. 225| 53.2k| return ret & ((uint64_t{1} << bits) - 1); 226| 53.2k| } _ZN17FastRandomContext6rand64Ev: 396| 1.49M| { 397| 1.49M| if (requires_seed) RandomSeed(); ------------------ | Branch (397:13): [True: 0, False: 1.49M] ------------------ 398| 1.49M| std::array buf; 399| 1.49M| rng.Keystream(buf); 400| 1.49M| return ReadLE64(buf.data()); 401| 1.49M| } _ZN11RandomMixinI17FastRandomContextE8randboolEv: 316| 94.6M| bool randbool() noexcept { return Impl().template randbits<1>(); } _ZN11RandomMixinI17FastRandomContextE8randbitsILi1EEEmv: 231| 94.6M| { 232| 94.6M| static_assert(Bits >= 0 && Bits <= 64); 233| | if constexpr (Bits == 64) { 234| | return Impl().rand64(); 235| 94.6M| } else { 236| 94.6M| uint64_t ret; 237| 94.6M| if (Bits <= bitbuf_size) { ------------------ | Branch (237:17): [True: 93.1M, False: 1.48M] ------------------ 238| 93.1M| ret = bitbuf; 239| 93.1M| bitbuf >>= Bits; 240| 93.1M| bitbuf_size -= Bits; 241| 93.1M| } else { 242| 1.48M| uint64_t gen = Impl().rand64(); 243| 1.48M| ret = (gen << bitbuf_size) | bitbuf; 244| 1.48M| bitbuf = gen >> (Bits - bitbuf_size); 245| 1.48M| bitbuf_size = 64 + bitbuf_size - Bits; 246| 1.48M| } 247| 94.6M| constexpr uint64_t MASK = (uint64_t{1} << Bits) - 1; 248| 94.6M| return ret & MASK; 249| 94.6M| } 250| 94.6M| } _ZN11RandomMixinI17FastRandomContextEC2Ev: 195| 5.83k| constexpr RandomMixin() noexcept = default; _ZNK4SpanIKSt4byteE4sizeEv: 187| 5.83k| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanIKSt4byteE4dataEv: 174| 46.6k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanISt4byteE4sizeEv: 187| 6.56M| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanISt4byteE4dataEv: 174| 190k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanISt4byteE7subspanEm: 196| 1.30M| { 197| 1.30M| ASSERT_IF_DEBUG(size() >= offset); 198| 1.30M| return Span(m_data + offset, m_size - offset); 199| 1.30M| } _ZN4SpanISt4byteEC2INSt3__15arrayIS0_Lm8EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE: 165| 1.49M| : m_data(other.data()), m_size(other.size()){} _ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m: 119| 1.30M| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZN4SpanIKSt4byteEC2INSt3__15arrayIS0_Lm32EEEEERKT_NS4_9enable_ifIXaaaantsr7is_SpanIS7_EE5valuesr3std14is_convertibleIPA_NS4_14remove_pointerIDTcldtclsr3stdE7declvalIS9_EE4dataEEE4typeEPA_S1_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS9_EE4sizeEEmEE5valueEDnE4typeE: 172| 5.83k| : m_data(other.data()), m_size(other.size()){} _ZNK4SpanISt4byteE5beginEv: 175| 1.49M| constexpr C* begin() const noexcept { return m_data; } _ZNK4SpanISt4byteE5emptyEv: 189| 2.99M| constexpr bool empty() const noexcept { return size() == 0; } _ZN4SpanISt4byteEC2INSt3__15arrayIS0_Lm64EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE: 165| 190k| : m_data(other.data()), m_size(other.size()){} _Z14memory_cleansePvm: 15| 11.6k|{ 16| |#if defined(WIN32) 17| | /* SecureZeroMemory is guaranteed not to be optimized out. */ 18| | SecureZeroMemory(ptr, len); 19| |#else 20| 11.6k| 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| 11.6k| __asm__ __volatile__("" : : "r"(ptr) : "memory"); 34| 11.6k|#endif 35| 11.6k|} _ZN18FuzzedDataProviderC2EPKhm: 37| 5.83k| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIlEET_S1_S1_: 205| 23.9k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 23.9k| static_assert(std::is_integral::value, "An integral type is required."); 207| 23.9k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 23.9k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 23.9k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 23.9k| uint64_t range = static_cast(max) - static_cast(min); 214| 23.9k| uint64_t result = 0; 215| 23.9k| size_t offset = 0; 216| | 217| 53.1k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 53.1k, False: 0] | Branch (217:43): [True: 29.4k, False: 23.7k] ------------------ 218| 53.1k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 29.2k, 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| 29.2k| --remaining_bytes_; 226| 29.2k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 29.2k| offset += CHAR_BIT; 228| 29.2k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 23.9k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 23.9k, False: 0] ------------------ 232| 23.9k| result = result % (range + 1); 233| | 234| 23.9k| return static_cast(static_cast(min) + result); 235| 23.9k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_: 205| 511k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 511k| static_assert(std::is_integral::value, "An integral type is required."); 207| 511k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 511k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 511k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 511k| uint64_t range = static_cast(max) - static_cast(min); 214| 511k| uint64_t result = 0; 215| 511k| size_t offset = 0; 216| | 217| 1.04M| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 1.04M, False: 0] | Branch (217:43): [True: 534k, False: 509k] ------------------ 218| 1.04M| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 532k, False: 1.99k] ------------------ 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| 532k| --remaining_bytes_; 226| 532k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 532k| offset += CHAR_BIT; 228| 532k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 511k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 511k, False: 0] ------------------ 232| 511k| result = result % (range + 1); 233| | 234| 511k| return static_cast(static_cast(min) + result); 235| 511k|} _ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v: 195| 33.3k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 33.3k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 33.3k| std::numeric_limits::max()); 198| 33.3k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_: 205| 33.3k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 33.3k| static_assert(std::is_integral::value, "An integral type is required."); 207| 33.3k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 33.3k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 33.3k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 33.3k| uint64_t range = static_cast(max) - static_cast(min); 214| 33.3k| uint64_t result = 0; 215| 33.3k| size_t offset = 0; 216| | 217| 65.9k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 33.3k, False: 32.6k] | Branch (217:43): [True: 33.3k, False: 0] ------------------ 218| 65.9k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 32.6k, False: 702] ------------------ 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| 32.6k| --remaining_bytes_; 226| 32.6k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 32.6k| offset += CHAR_BIT; 228| 32.6k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 33.3k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 33.3k, False: 0] ------------------ 232| 33.3k| result = result % (range + 1); 233| | 234| 33.3k| return static_cast(static_cast(min) + result); 235| 33.3k|} _ZN18FuzzedDataProvider15remaining_bytesEv: 85| 311k| size_t remaining_bytes() { return remaining_bytes_; } _ZN18FuzzedDataProvider11ConsumeBoolEv: 289| 33.3k|inline bool FuzzedDataProvider::ConsumeBool() { 290| 33.3k| return 1 & ConsumeIntegral(); 291| 33.3k|} _Z20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 35| 5.83k|{ 36| 5.83k| FuzzedDataProvider provider(buffer.data(), buffer.size()); 37| 5.83k| FastRandomContext ctx(true); 38| | 39| 5.83k| size_t maxlen = (1U << provider.ConsumeIntegralInRange(0, LEN_BITS)) - 1; 40| 5.83k| size_t limitlen = 4 * maxlen; 41| | 42| 5.83k| std::deque deq; 43| 5.83k| bitdeque_type bitdeq; 44| | 45| 5.83k| const auto& cdeq = deq; 46| 5.83k| const auto& cbitdeq = bitdeq; 47| | 48| 5.83k| size_t initlen = provider.ConsumeIntegralInRange(0, maxlen); 49| 94.4M| while (initlen) { ------------------ | Branch (49:12): [True: 94.4M, False: 5.83k] ------------------ 50| 94.4M| bool val = ctx.randbool(); 51| 94.4M| deq.push_back(val); 52| 94.4M| bitdeq.push_back(val); 53| 94.4M| --initlen; 54| 94.4M| } 55| | 56| 5.83k| const auto iter_limit{maxlen > 6000 ? 90U : 900U}; ------------------ | Branch (56:27): [True: 2.30k, False: 3.52k] ------------------ 57| 5.83k| LIMITED_WHILE(provider.remaining_bytes() > 0, iter_limit) ------------------ | | 23| 311k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 305k, False: 5.57k] | | | Branch (23:49): [True: 305k, False: 260] | | ------------------ ------------------ 58| 305k| { 59| 305k| CallOneOf( 60| 305k| provider, 61| 305k| [&] { 62| | // constructor() 63| 305k| deq = std::deque{}; 64| 305k| bitdeq = bitdeque_type{}; 65| 305k| }, 66| 305k| [&] { 67| | // clear() 68| 305k| deq.clear(); 69| 305k| bitdeq.clear(); 70| 305k| }, 71| 305k| [&] { 72| | // resize() 73| 305k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 74| 305k| deq.resize(count); 75| 305k| bitdeq.resize(count); 76| 305k| }, 77| 305k| [&] { 78| | // assign(count, val) 79| 305k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 80| 305k| bool val = ctx.randbool(); 81| 305k| deq.assign(count, val); 82| 305k| bitdeq.assign(count, val); 83| 305k| }, 84| 305k| [&] { 85| | // constructor(count, val) 86| 305k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 87| 305k| bool val = ctx.randbool(); 88| 305k| deq = std::deque(count, val); 89| 305k| bitdeq = bitdeque_type(count, val); 90| 305k| }, 91| 305k| [&] { 92| | // constructor(count) 93| 305k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 94| 305k| deq = std::deque(count); 95| 305k| bitdeq = bitdeque_type(count); 96| 305k| }, 97| 305k| [&] { 98| | // construct(begin, end) 99| 305k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 100| 305k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 101| 305k| auto rand_end = rand_begin + count; 102| 305k| deq = std::deque(rand_begin, rand_end); 103| 305k| bitdeq = bitdeque_type(rand_begin, rand_end); 104| 305k| }, 105| 305k| [&] { 106| | // assign(begin, end) 107| 305k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 108| 305k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 109| 305k| auto rand_end = rand_begin + count; 110| 305k| deq.assign(rand_begin, rand_end); 111| 305k| bitdeq.assign(rand_begin, rand_end); 112| 305k| }, 113| 305k| [&] { 114| | // construct(initializer_list) 115| 305k| std::initializer_list ilist{ctx.randbool(), ctx.randbool(), ctx.randbool(), ctx.randbool(), ctx.randbool()}; 116| 305k| deq = std::deque(ilist); 117| 305k| bitdeq = bitdeque_type(ilist); 118| 305k| }, 119| 305k| [&] { 120| | // assign(initializer_list) 121| 305k| std::initializer_list ilist{ctx.randbool(), ctx.randbool(), ctx.randbool()}; 122| 305k| deq.assign(ilist); 123| 305k| bitdeq.assign(ilist); 124| 305k| }, 125| 305k| [&] { 126| | // operator=(const&) 127| 305k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 128| 305k| bool val = ctx.randbool(); 129| 305k| const std::deque deq2(count, val); 130| 305k| deq = deq2; 131| 305k| const bitdeque_type bitdeq2(count, val); 132| 305k| bitdeq = bitdeq2; 133| 305k| }, 134| 305k| [&] { 135| | // operator=(&&) 136| 305k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 137| 305k| bool val = ctx.randbool(); 138| 305k| std::deque deq2(count, val); 139| 305k| deq = std::move(deq2); 140| 305k| bitdeque_type bitdeq2(count, val); 141| 305k| bitdeq = std::move(bitdeq2); 142| 305k| }, 143| 305k| [&] { 144| | // deque swap 145| 305k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 146| 305k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 147| 305k| auto rand_end = rand_begin + count; 148| 305k| std::deque deq2(rand_begin, rand_end); 149| 305k| bitdeque_type bitdeq2(rand_begin, rand_end); 150| 305k| using std::swap; 151| 305k| assert(deq.size() == bitdeq.size()); 152| 305k| assert(deq2.size() == bitdeq2.size()); 153| 305k| swap(deq, deq2); 154| 305k| swap(bitdeq, bitdeq2); 155| 305k| assert(deq.size() == bitdeq.size()); 156| 305k| assert(deq2.size() == bitdeq2.size()); 157| 305k| }, 158| 305k| [&] { 159| | // deque.swap 160| 305k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 161| 305k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 162| 305k| auto rand_end = rand_begin + count; 163| 305k| std::deque deq2(rand_begin, rand_end); 164| 305k| bitdeque_type bitdeq2(rand_begin, rand_end); 165| 305k| assert(deq.size() == bitdeq.size()); 166| 305k| assert(deq2.size() == bitdeq2.size()); 167| 305k| deq.swap(deq2); 168| 305k| bitdeq.swap(bitdeq2); 169| 305k| assert(deq.size() == bitdeq.size()); 170| 305k| assert(deq2.size() == bitdeq2.size()); 171| 305k| }, 172| 305k| [&] { 173| | // operator=(initializer_list) 174| 305k| std::initializer_list ilist{ctx.randbool(), ctx.randbool(), ctx.randbool()}; 175| 305k| deq = ilist; 176| 305k| bitdeq = ilist; 177| 305k| }, 178| 305k| [&] { 179| | // iterator arithmetic 180| 305k| auto pos1 = provider.ConsumeIntegralInRange(0, cdeq.size()); 181| 305k| auto pos2 = provider.ConsumeIntegralInRange(0, cdeq.size()); 182| 305k| auto it = deq.begin() + pos1; 183| 305k| auto bitit = bitdeq.begin() + pos1; 184| 305k| if ((size_t)pos1 != cdeq.size()) assert(*it == *bitit); 185| 305k| assert(it - deq.begin() == pos1); 186| 305k| assert(bitit - bitdeq.begin() == pos1); 187| 305k| if (provider.ConsumeBool()) { 188| 305k| it += pos2 - pos1; 189| 305k| bitit += pos2 - pos1; 190| 305k| } else { 191| 305k| it -= pos1 - pos2; 192| 305k| bitit -= pos1 - pos2; 193| 305k| } 194| 305k| if ((size_t)pos2 != cdeq.size()) assert(*it == *bitit); 195| 305k| assert(deq.end() - it == bitdeq.end() - bitit); 196| 305k| if (provider.ConsumeBool()) { 197| 305k| if ((size_t)pos2 != cdeq.size()) { 198| 305k| ++it; 199| 305k| ++bitit; 200| 305k| } 201| 305k| } else { 202| 305k| if (pos2 != 0) { 203| 305k| --it; 204| 305k| --bitit; 205| 305k| } 206| 305k| } 207| 305k| assert(deq.end() - it == bitdeq.end() - bitit); 208| 305k| }, 209| 305k| [&] { 210| | // begin() and end() 211| 305k| assert(deq.end() - deq.begin() == bitdeq.end() - bitdeq.begin()); 212| 305k| }, 213| 305k| [&] { 214| | // begin() and end() (const) 215| 305k| assert(cdeq.end() - cdeq.begin() == cbitdeq.end() - cbitdeq.begin()); 216| 305k| }, 217| 305k| [&] { 218| | // rbegin() and rend() 219| 305k| assert(deq.rend() - deq.rbegin() == bitdeq.rend() - bitdeq.rbegin()); 220| 305k| }, 221| 305k| [&] { 222| | // rbegin() and rend() (const) 223| 305k| assert(cdeq.rend() - cdeq.rbegin() == cbitdeq.rend() - cbitdeq.rbegin()); 224| 305k| }, 225| 305k| [&] { 226| | // cbegin() and cend() 227| 305k| assert(cdeq.cend() - cdeq.cbegin() == cbitdeq.cend() - cbitdeq.cbegin()); 228| 305k| }, 229| 305k| [&] { 230| | // crbegin() and crend() 231| 305k| assert(cdeq.crend() - cdeq.crbegin() == cbitdeq.crend() - cbitdeq.crbegin()); 232| 305k| }, 233| 305k| [&] { 234| | // size() and maxsize() 235| 305k| assert(cdeq.size() == cbitdeq.size()); 236| 305k| assert(cbitdeq.size() <= cbitdeq.max_size()); 237| 305k| }, 238| 305k| [&] { 239| | // empty 240| 305k| assert(cdeq.empty() == cbitdeq.empty()); 241| 305k| }, 242| 305k| [&] { 243| | // at (in range) and flip 244| 305k| if (!cdeq.empty()) { 245| 305k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 246| 305k| auto& ref = deq.at(pos); 247| 305k| auto bitref = bitdeq.at(pos); 248| 305k| assert(ref == bitref); 249| 305k| if (ctx.randbool()) { 250| 305k| ref = !ref; 251| 305k| bitref.flip(); 252| 305k| } 253| 305k| } 254| 305k| }, 255| 305k| [&] { 256| | // at (maybe out of range) and bit assign 257| 305k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() + maxlen); 258| 305k| bool newval = ctx.randbool(); 259| 305k| bool throw_deq{false}, throw_bitdeq{false}; 260| 305k| bool val_deq{false}, val_bitdeq{false}; 261| 305k| try { 262| 305k| auto& ref = deq.at(pos); 263| 305k| val_deq = ref; 264| 305k| ref = newval; 265| 305k| } catch (const std::out_of_range&) { 266| 305k| throw_deq = true; 267| 305k| } 268| 305k| try { 269| 305k| auto ref = bitdeq.at(pos); 270| 305k| val_bitdeq = ref; 271| 305k| ref = newval; 272| 305k| } catch (const std::out_of_range&) { 273| 305k| throw_bitdeq = true; 274| 305k| } 275| 305k| assert(throw_deq == throw_bitdeq); 276| 305k| assert(throw_bitdeq == (pos >= cdeq.size())); 277| 305k| if (!throw_deq) assert(val_deq == val_bitdeq); 278| 305k| }, 279| 305k| [&] { 280| | // at (maybe out of range) (const) 281| 305k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() + maxlen); 282| 305k| bool throw_deq{false}, throw_bitdeq{false}; 283| 305k| bool val_deq{false}, val_bitdeq{false}; 284| 305k| try { 285| 305k| auto& ref = cdeq.at(pos); 286| 305k| val_deq = ref; 287| 305k| } catch (const std::out_of_range&) { 288| 305k| throw_deq = true; 289| 305k| } 290| 305k| try { 291| 305k| auto ref = cbitdeq.at(pos); 292| 305k| val_bitdeq = ref; 293| 305k| } catch (const std::out_of_range&) { 294| 305k| throw_bitdeq = true; 295| 305k| } 296| 305k| assert(throw_deq == throw_bitdeq); 297| 305k| assert(throw_bitdeq == (pos >= cdeq.size())); 298| 305k| if (!throw_deq) assert(val_deq == val_bitdeq); 299| 305k| }, 300| 305k| [&] { 301| | // operator[] 302| 305k| if (!cdeq.empty()) { 303| 305k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 304| 305k| assert(deq[pos] == bitdeq[pos]); 305| 305k| if (ctx.randbool()) { 306| 305k| deq[pos] = !deq[pos]; 307| 305k| bitdeq[pos].flip(); 308| 305k| } 309| 305k| } 310| 305k| }, 311| 305k| [&] { 312| | // operator[] const 313| 305k| if (!cdeq.empty()) { 314| 305k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 315| 305k| assert(deq[pos] == bitdeq[pos]); 316| 305k| } 317| 305k| }, 318| 305k| [&] { 319| | // front() 320| 305k| if (!cdeq.empty()) { 321| 305k| auto& ref = deq.front(); 322| 305k| auto bitref = bitdeq.front(); 323| 305k| assert(ref == bitref); 324| 305k| if (ctx.randbool()) { 325| 305k| ref = !ref; 326| 305k| bitref = !bitref; 327| 305k| } 328| 305k| } 329| 305k| }, 330| 305k| [&] { 331| | // front() const 332| 305k| if (!cdeq.empty()) { 333| 305k| auto& ref = cdeq.front(); 334| 305k| auto bitref = cbitdeq.front(); 335| 305k| assert(ref == bitref); 336| 305k| } 337| 305k| }, 338| 305k| [&] { 339| | // back() and swap(bool, ref) 340| 305k| if (!cdeq.empty()) { 341| 305k| auto& ref = deq.back(); 342| 305k| auto bitref = bitdeq.back(); 343| 305k| assert(ref == bitref); 344| 305k| if (ctx.randbool()) { 345| 305k| ref = !ref; 346| 305k| bitref.flip(); 347| 305k| } 348| 305k| } 349| 305k| }, 350| 305k| [&] { 351| | // back() const 352| 305k| if (!cdeq.empty()) { 353| 305k| const auto& cdeq = deq; 354| 305k| const auto& cbitdeq = bitdeq; 355| 305k| auto& ref = cdeq.back(); 356| 305k| auto bitref = cbitdeq.back(); 357| 305k| assert(ref == bitref); 358| 305k| } 359| 305k| }, 360| 305k| [&] { 361| | // push_back() 362| 305k| if (cdeq.size() < limitlen) { 363| 305k| bool val = ctx.randbool(); 364| 305k| if (cdeq.empty()) { 365| 305k| deq.push_back(val); 366| 305k| bitdeq.push_back(val); 367| 305k| } else { 368| 305k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 369| 305k| auto& ref = deq[pos]; 370| 305k| auto bitref = bitdeq[pos]; 371| 305k| assert(ref == bitref); 372| 305k| deq.push_back(val); 373| 305k| bitdeq.push_back(val); 374| 305k| assert(ref == bitref); // references are not invalidated 375| 305k| } 376| 305k| } 377| 305k| }, 378| 305k| [&] { 379| | // push_front() 380| 305k| if (cdeq.size() < limitlen) { 381| 305k| bool val = ctx.randbool(); 382| 305k| if (cdeq.empty()) { 383| 305k| deq.push_front(val); 384| 305k| bitdeq.push_front(val); 385| 305k| } else { 386| 305k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 387| 305k| auto& ref = deq[pos]; 388| 305k| auto bitref = bitdeq[pos]; 389| 305k| assert(ref == bitref); 390| 305k| deq.push_front(val); 391| 305k| bitdeq.push_front(val); 392| 305k| assert(ref == bitref); // references are not invalidated 393| 305k| } 394| 305k| } 395| 305k| }, 396| 305k| [&] { 397| | // pop_back() 398| 305k| if (!cdeq.empty()) { 399| 305k| if (cdeq.size() == 1) { 400| 305k| deq.pop_back(); 401| 305k| bitdeq.pop_back(); 402| 305k| } else { 403| 305k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 2); 404| 305k| auto& ref = deq[pos]; 405| 305k| auto bitref = bitdeq[pos]; 406| 305k| assert(ref == bitref); 407| 305k| deq.pop_back(); 408| 305k| bitdeq.pop_back(); 409| 305k| assert(ref == bitref); // references to other elements are not invalidated 410| 305k| } 411| 305k| } 412| 305k| }, 413| 305k| [&] { 414| | // pop_front() 415| 305k| if (!cdeq.empty()) { 416| 305k| if (cdeq.size() == 1) { 417| 305k| deq.pop_front(); 418| 305k| bitdeq.pop_front(); 419| 305k| } else { 420| 305k| size_t pos = provider.ConsumeIntegralInRange(1, cdeq.size() - 1); 421| 305k| auto& ref = deq[pos]; 422| 305k| auto bitref = bitdeq[pos]; 423| 305k| assert(ref == bitref); 424| 305k| deq.pop_front(); 425| 305k| bitdeq.pop_front(); 426| 305k| assert(ref == bitref); // references to other elements are not invalidated 427| 305k| } 428| 305k| } 429| 305k| }, 430| 305k| [&] { 431| | // erase (in middle, single) 432| 305k| if (!cdeq.empty()) { 433| 305k| size_t before = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 434| 305k| size_t after = cdeq.size() - 1 - before; 435| 305k| auto it = deq.erase(cdeq.begin() + before); 436| 305k| auto bitit = bitdeq.erase(cbitdeq.begin() + before); 437| 305k| assert(it == cdeq.begin() + before && it == cdeq.end() - after); 438| 305k| assert(bitit == cbitdeq.begin() + before && bitit == cbitdeq.end() - after); 439| 305k| } 440| 305k| }, 441| 305k| [&] { 442| | // erase (at front, range) 443| 305k| size_t count = provider.ConsumeIntegralInRange(0, cdeq.size()); 444| 305k| auto it = deq.erase(cdeq.begin(), cdeq.begin() + count); 445| 305k| auto bitit = bitdeq.erase(cbitdeq.begin(), cbitdeq.begin() + count); 446| 305k| assert(it == deq.begin()); 447| 305k| assert(bitit == bitdeq.begin()); 448| 305k| }, 449| 305k| [&] { 450| | // erase (at back, range) 451| 305k| size_t count = provider.ConsumeIntegralInRange(0, cdeq.size()); 452| 305k| auto it = deq.erase(cdeq.end() - count, cdeq.end()); 453| 305k| auto bitit = bitdeq.erase(cbitdeq.end() - count, cbitdeq.end()); 454| 305k| assert(it == deq.end()); 455| 305k| assert(bitit == bitdeq.end()); 456| 305k| }, 457| 305k| [&] { 458| | // erase (in middle, range) 459| 305k| size_t count = provider.ConsumeIntegralInRange(0, cdeq.size()); 460| 305k| size_t before = provider.ConsumeIntegralInRange(0, cdeq.size() - count); 461| 305k| size_t after = cdeq.size() - count - before; 462| 305k| auto it = deq.erase(cdeq.begin() + before, cdeq.end() - after); 463| 305k| auto bitit = bitdeq.erase(cbitdeq.begin() + before, cbitdeq.end() - after); 464| 305k| assert(it == cdeq.begin() + before && it == cdeq.end() - after); 465| 305k| assert(bitit == cbitdeq.begin() + before && bitit == cbitdeq.end() - after); 466| 305k| }, 467| 305k| [&] { 468| | // insert/emplace (in middle, single) 469| 305k| if (cdeq.size() < limitlen) { 470| 305k| size_t before = provider.ConsumeIntegralInRange(0, cdeq.size()); 471| 305k| bool val = ctx.randbool(); 472| 305k| bool do_emplace = provider.ConsumeBool(); 473| 305k| auto it = deq.insert(cdeq.begin() + before, val); 474| 305k| auto bitit = do_emplace ? bitdeq.emplace(cbitdeq.begin() + before, val) 475| 305k| : bitdeq.insert(cbitdeq.begin() + before, val); 476| 305k| assert(it == deq.begin() + before); 477| 305k| assert(bitit == bitdeq.begin() + before); 478| 305k| } 479| 305k| }, 480| 305k| [&] { 481| | // insert (at front, begin/end) 482| 305k| if (cdeq.size() < limitlen) { 483| 305k| size_t count = provider.ConsumeIntegralInRange(0, maxlen); 484| 305k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 485| 305k| auto rand_end = rand_begin + count; 486| 305k| auto it = deq.insert(cdeq.begin(), rand_begin, rand_end); 487| 305k| auto bitit = bitdeq.insert(cbitdeq.begin(), rand_begin, rand_end); 488| 305k| assert(it == cdeq.begin()); 489| 305k| assert(bitit == cbitdeq.begin()); 490| 305k| } 491| 305k| }, 492| 305k| [&] { 493| | // insert (at back, begin/end) 494| 305k| if (cdeq.size() < limitlen) { 495| 305k| size_t count = provider.ConsumeIntegralInRange(0, maxlen); 496| 305k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 497| 305k| auto rand_end = rand_begin + count; 498| 305k| auto it = deq.insert(cdeq.end(), rand_begin, rand_end); 499| 305k| auto bitit = bitdeq.insert(cbitdeq.end(), rand_begin, rand_end); 500| 305k| assert(it == cdeq.end() - count); 501| 305k| assert(bitit == cbitdeq.end() - count); 502| 305k| } 503| 305k| }, 504| 305k| [&] { 505| | // insert (in middle, range) 506| 305k| if (cdeq.size() < limitlen) { 507| 305k| size_t count = provider.ConsumeIntegralInRange(0, maxlen); 508| 305k| size_t before = provider.ConsumeIntegralInRange(0, cdeq.size()); 509| 305k| bool val = ctx.randbool(); 510| 305k| auto it = deq.insert(cdeq.begin() + before, count, val); 511| 305k| auto bitit = bitdeq.insert(cbitdeq.begin() + before, count, val); 512| 305k| assert(it == deq.begin() + before); 513| 305k| assert(bitit == bitdeq.begin() + before); 514| 305k| } 515| 305k| }, 516| 305k| [&] { 517| | // insert (in middle, begin/end) 518| 305k| if (cdeq.size() < limitlen) { 519| 305k| size_t count = provider.ConsumeIntegralInRange(0, maxlen); 520| 305k| size_t before = provider.ConsumeIntegralInRange(0, cdeq.size()); 521| 305k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 522| 305k| auto rand_end = rand_begin + count; 523| 305k| auto it = deq.insert(cdeq.begin() + before, rand_begin, rand_end); 524| 305k| auto bitit = bitdeq.insert(cbitdeq.begin() + before, rand_begin, rand_end); 525| 305k| assert(it == deq.begin() + before); 526| 305k| assert(bitit == bitdeq.begin() + before); 527| 305k| } 528| 305k| }); 529| 305k| } 530| 5.83k| { 531| 5.83k| assert(deq.size() == bitdeq.size()); 532| 5.83k| auto it = deq.begin(); 533| 5.83k| auto bitit = bitdeq.begin(); 534| 5.83k| auto itend = deq.end(); 535| 148M| while (it != itend) { ------------------ | Branch (535:16): [True: 148M, False: 5.83k] ------------------ 536| 148M| assert(*it == *bitit); 537| 148M| ++it; 538| 148M| ++bitit; 539| 148M| } 540| 5.83k| } 541| 5.83k|} bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv: 61| 21.2k| [&] { 62| | // constructor() 63| 21.2k| deq = std::deque{}; 64| 21.2k| bitdeq = bitdeque_type{}; 65| 21.2k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_1clEv: 66| 6.31k| [&] { 67| | // clear() 68| 6.31k| deq.clear(); 69| 6.31k| bitdeq.clear(); 70| 6.31k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_2clEv: 71| 5.93k| [&] { 72| | // resize() 73| 5.93k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 74| 5.93k| deq.resize(count); 75| 5.93k| bitdeq.resize(count); 76| 5.93k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_3clEv: 77| 6.36k| [&] { 78| | // assign(count, val) 79| 6.36k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 80| 6.36k| bool val = ctx.randbool(); 81| 6.36k| deq.assign(count, val); 82| 6.36k| bitdeq.assign(count, val); 83| 6.36k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_4clEv: 84| 6.29k| [&] { 85| | // constructor(count, val) 86| 6.29k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 87| 6.29k| bool val = ctx.randbool(); 88| 6.29k| deq = std::deque(count, val); 89| 6.29k| bitdeq = bitdeque_type(count, val); 90| 6.29k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_5clEv: 91| 8.22k| [&] { 92| | // constructor(count) 93| 8.22k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 94| 8.22k| deq = std::deque(count); 95| 8.22k| bitdeq = bitdeque_type(count); 96| 8.22k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_6clEv: 97| 5.27k| [&] { 98| | // construct(begin, end) 99| 5.27k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 100| 5.27k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 101| 5.27k| auto rand_end = rand_begin + count; 102| 5.27k| deq = std::deque(rand_begin, rand_end); 103| 5.27k| bitdeq = bitdeque_type(rand_begin, rand_end); 104| 5.27k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_7clEv: 105| 8.12k| [&] { 106| | // assign(begin, end) 107| 8.12k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 108| 8.12k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 109| 8.12k| auto rand_end = rand_begin + count; 110| 8.12k| deq.assign(rand_begin, rand_end); 111| 8.12k| bitdeq.assign(rand_begin, rand_end); 112| 8.12k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_8clEv: 113| 11.6k| [&] { 114| | // construct(initializer_list) 115| 11.6k| std::initializer_list ilist{ctx.randbool(), ctx.randbool(), ctx.randbool(), ctx.randbool(), ctx.randbool()}; 116| 11.6k| deq = std::deque(ilist); 117| 11.6k| bitdeq = bitdeque_type(ilist); 118| 11.6k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_9clEv: 119| 11.0k| [&] { 120| | // assign(initializer_list) 121| 11.0k| std::initializer_list ilist{ctx.randbool(), ctx.randbool(), ctx.randbool()}; 122| 11.0k| deq.assign(ilist); 123| 11.0k| bitdeq.assign(ilist); 124| 11.0k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_10clEv: 125| 9.86k| [&] { 126| | // operator=(const&) 127| 9.86k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 128| 9.86k| bool val = ctx.randbool(); 129| 9.86k| const std::deque deq2(count, val); 130| 9.86k| deq = deq2; 131| 9.86k| const bitdeque_type bitdeq2(count, val); 132| 9.86k| bitdeq = bitdeq2; 133| 9.86k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_11clEv: 134| 4.97k| [&] { 135| | // operator=(&&) 136| 4.97k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 137| 4.97k| bool val = ctx.randbool(); 138| 4.97k| std::deque deq2(count, val); 139| 4.97k| deq = std::move(deq2); 140| 4.97k| bitdeque_type bitdeq2(count, val); 141| 4.97k| bitdeq = std::move(bitdeq2); 142| 4.97k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_12clEv: 143| 5.51k| [&] { 144| | // deque swap 145| 5.51k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 146| 5.51k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 147| 5.51k| auto rand_end = rand_begin + count; 148| 5.51k| std::deque deq2(rand_begin, rand_end); 149| 5.51k| bitdeque_type bitdeq2(rand_begin, rand_end); 150| 5.51k| using std::swap; 151| 5.51k| assert(deq.size() == bitdeq.size()); 152| 5.51k| assert(deq2.size() == bitdeq2.size()); 153| 5.51k| swap(deq, deq2); 154| 5.51k| swap(bitdeq, bitdeq2); 155| 5.51k| assert(deq.size() == bitdeq.size()); 156| 5.51k| assert(deq2.size() == bitdeq2.size()); 157| 5.51k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_13clEv: 158| 8.14k| [&] { 159| | // deque.swap 160| 8.14k| auto count = provider.ConsumeIntegralInRange(0, maxlen); 161| 8.14k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 162| 8.14k| auto rand_end = rand_begin + count; 163| 8.14k| std::deque deq2(rand_begin, rand_end); 164| 8.14k| bitdeque_type bitdeq2(rand_begin, rand_end); 165| 8.14k| assert(deq.size() == bitdeq.size()); 166| 8.14k| assert(deq2.size() == bitdeq2.size()); 167| 8.14k| deq.swap(deq2); 168| 8.14k| bitdeq.swap(bitdeq2); 169| 8.14k| assert(deq.size() == bitdeq.size()); 170| 8.14k| assert(deq2.size() == bitdeq2.size()); 171| 8.14k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_14clEv: 172| 6.82k| [&] { 173| | // operator=(initializer_list) 174| 6.82k| std::initializer_list ilist{ctx.randbool(), ctx.randbool(), ctx.randbool()}; 175| 6.82k| deq = ilist; 176| 6.82k| bitdeq = ilist; 177| 6.82k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_15clEv: 178| 11.9k| [&] { 179| | // iterator arithmetic 180| 11.9k| auto pos1 = provider.ConsumeIntegralInRange(0, cdeq.size()); 181| 11.9k| auto pos2 = provider.ConsumeIntegralInRange(0, cdeq.size()); 182| 11.9k| auto it = deq.begin() + pos1; 183| 11.9k| auto bitit = bitdeq.begin() + pos1; 184| 11.9k| if ((size_t)pos1 != cdeq.size()) assert(*it == *bitit); ------------------ | Branch (184:21): [True: 8.33k, False: 3.62k] ------------------ 185| 11.9k| assert(it - deq.begin() == pos1); 186| 11.9k| assert(bitit - bitdeq.begin() == pos1); 187| 11.9k| if (provider.ConsumeBool()) { ------------------ | Branch (187:21): [True: 9.14k, False: 2.81k] ------------------ 188| 9.14k| it += pos2 - pos1; 189| 9.14k| bitit += pos2 - pos1; 190| 9.14k| } else { 191| 2.81k| it -= pos1 - pos2; 192| 2.81k| bitit -= pos1 - pos2; 193| 2.81k| } 194| 11.9k| if ((size_t)pos2 != cdeq.size()) assert(*it == *bitit); ------------------ | Branch (194:21): [True: 8.05k, False: 3.89k] ------------------ 195| 11.9k| assert(deq.end() - it == bitdeq.end() - bitit); 196| 11.9k| if (provider.ConsumeBool()) { ------------------ | Branch (196:21): [True: 9.26k, False: 2.69k] ------------------ 197| 9.26k| if ((size_t)pos2 != cdeq.size()) { ------------------ | Branch (197:25): [True: 6.57k, False: 2.69k] ------------------ 198| 6.57k| ++it; 199| 6.57k| ++bitit; 200| 6.57k| } 201| 9.26k| } else { 202| 2.69k| if (pos2 != 0) { ------------------ | Branch (202:25): [True: 1.77k, False: 920] ------------------ 203| 1.77k| --it; 204| 1.77k| --bitit; 205| 1.77k| } 206| 2.69k| } 207| 11.9k| assert(deq.end() - it == bitdeq.end() - bitit); 208| 11.9k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_16clEv: 209| 3.99k| [&] { 210| | // begin() and end() 211| 3.99k| assert(deq.end() - deq.begin() == bitdeq.end() - bitdeq.begin()); 212| 3.99k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_17clEv: 213| 4.63k| [&] { 214| | // begin() and end() (const) 215| 4.63k| assert(cdeq.end() - cdeq.begin() == cbitdeq.end() - cbitdeq.begin()); 216| 4.63k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_18clEv: 217| 3.36k| [&] { 218| | // rbegin() and rend() 219| 3.36k| assert(deq.rend() - deq.rbegin() == bitdeq.rend() - bitdeq.rbegin()); 220| 3.36k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_19clEv: 221| 3.78k| [&] { 222| | // rbegin() and rend() (const) 223| 3.78k| assert(cdeq.rend() - cdeq.rbegin() == cbitdeq.rend() - cbitdeq.rbegin()); 224| 3.78k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_20clEv: 225| 4.52k| [&] { 226| | // cbegin() and cend() 227| 4.52k| assert(cdeq.cend() - cdeq.cbegin() == cbitdeq.cend() - cbitdeq.cbegin()); 228| 4.52k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_21clEv: 229| 3.53k| [&] { 230| | // crbegin() and crend() 231| 3.53k| assert(cdeq.crend() - cdeq.crbegin() == cbitdeq.crend() - cbitdeq.crbegin()); 232| 3.53k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_22clEv: 233| 3.17k| [&] { 234| | // size() and maxsize() 235| 3.17k| assert(cdeq.size() == cbitdeq.size()); 236| 3.17k| assert(cbitdeq.size() <= cbitdeq.max_size()); 237| 3.17k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_23clEv: 238| 3.12k| [&] { 239| | // empty 240| 3.12k| assert(cdeq.empty() == cbitdeq.empty()); 241| 3.12k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_24clEv: 242| 5.52k| [&] { 243| | // at (in range) and flip 244| 5.52k| if (!cdeq.empty()) { ------------------ | Branch (244:21): [True: 4.58k, False: 935] ------------------ 245| 4.58k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 246| 4.58k| auto& ref = deq.at(pos); 247| 4.58k| auto bitref = bitdeq.at(pos); 248| 4.58k| assert(ref == bitref); 249| 4.58k| if (ctx.randbool()) { ------------------ | Branch (249:25): [True: 2.25k, False: 2.32k] ------------------ 250| 2.25k| ref = !ref; 251| 2.25k| bitref.flip(); 252| 2.25k| } 253| 4.58k| } 254| 5.52k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_25clEv: 255| 7.21k| [&] { 256| | // at (maybe out of range) and bit assign 257| 7.21k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() + maxlen); 258| 7.21k| bool newval = ctx.randbool(); 259| 7.21k| bool throw_deq{false}, throw_bitdeq{false}; 260| 7.21k| bool val_deq{false}, val_bitdeq{false}; 261| 7.21k| try { 262| 7.21k| auto& ref = deq.at(pos); 263| 7.21k| val_deq = ref; 264| 7.21k| ref = newval; 265| 7.21k| } catch (const std::out_of_range&) { 266| 5.10k| throw_deq = true; 267| 5.10k| } 268| 7.21k| try { 269| 7.21k| auto ref = bitdeq.at(pos); 270| 7.21k| val_bitdeq = ref; 271| 7.21k| ref = newval; 272| 7.21k| } catch (const std::out_of_range&) { 273| 5.10k| throw_bitdeq = true; 274| 5.10k| } 275| 7.21k| assert(throw_deq == throw_bitdeq); 276| 7.21k| assert(throw_bitdeq == (pos >= cdeq.size())); 277| 7.21k| if (!throw_deq) assert(val_deq == val_bitdeq); ------------------ | Branch (277:21): [True: 2.10k, False: 5.10k] ------------------ 278| 7.21k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_26clEv: 279| 3.21k| [&] { 280| | // at (maybe out of range) (const) 281| 3.21k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() + maxlen); 282| 3.21k| bool throw_deq{false}, throw_bitdeq{false}; 283| 3.21k| bool val_deq{false}, val_bitdeq{false}; 284| 3.21k| try { 285| 3.21k| auto& ref = cdeq.at(pos); 286| 3.21k| val_deq = ref; 287| 3.21k| } catch (const std::out_of_range&) { 288| 2.10k| throw_deq = true; 289| 2.10k| } 290| 3.21k| try { 291| 3.21k| auto ref = cbitdeq.at(pos); 292| 3.21k| val_bitdeq = ref; 293| 3.21k| } catch (const std::out_of_range&) { 294| 2.10k| throw_bitdeq = true; 295| 2.10k| } 296| 3.21k| assert(throw_deq == throw_bitdeq); 297| 3.21k| assert(throw_bitdeq == (pos >= cdeq.size())); 298| 3.21k| if (!throw_deq) assert(val_deq == val_bitdeq); ------------------ | Branch (298:21): [True: 1.10k, False: 2.10k] ------------------ 299| 3.21k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_27clEv: 300| 5.06k| [&] { 301| | // operator[] 302| 5.06k| if (!cdeq.empty()) { ------------------ | Branch (302:21): [True: 4.18k, False: 881] ------------------ 303| 4.18k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 304| 4.18k| assert(deq[pos] == bitdeq[pos]); 305| 4.18k| if (ctx.randbool()) { ------------------ | Branch (305:25): [True: 2.13k, False: 2.05k] ------------------ 306| 2.13k| deq[pos] = !deq[pos]; 307| 2.13k| bitdeq[pos].flip(); 308| 2.13k| } 309| 4.18k| } 310| 5.06k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_28clEv: 311| 2.61k| [&] { 312| | // operator[] const 313| 2.61k| if (!cdeq.empty()) { ------------------ | Branch (313:21): [True: 1.93k, False: 676] ------------------ 314| 1.93k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 315| 1.93k| assert(deq[pos] == bitdeq[pos]); 316| 1.93k| } 317| 2.61k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_29clEv: 318| 6.67k| [&] { 319| | // front() 320| 6.67k| if (!cdeq.empty()) { ------------------ | Branch (320:21): [True: 6.04k, False: 637] ------------------ 321| 6.04k| auto& ref = deq.front(); 322| 6.04k| auto bitref = bitdeq.front(); 323| 6.04k| assert(ref == bitref); 324| 6.04k| if (ctx.randbool()) { ------------------ | Branch (324:25): [True: 2.96k, False: 3.08k] ------------------ 325| 2.96k| ref = !ref; 326| 2.96k| bitref = !bitref; 327| 2.96k| } 328| 6.04k| } 329| 6.67k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_30clEv: 330| 2.90k| [&] { 331| | // front() const 332| 2.90k| if (!cdeq.empty()) { ------------------ | Branch (332:21): [True: 2.40k, False: 498] ------------------ 333| 2.40k| auto& ref = cdeq.front(); 334| 2.40k| auto bitref = cbitdeq.front(); 335| 2.40k| assert(ref == bitref); 336| 2.40k| } 337| 2.90k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_31clEv: 338| 5.48k| [&] { 339| | // back() and swap(bool, ref) 340| 5.48k| if (!cdeq.empty()) { ------------------ | Branch (340:21): [True: 4.73k, False: 754] ------------------ 341| 4.73k| auto& ref = deq.back(); 342| 4.73k| auto bitref = bitdeq.back(); 343| 4.73k| assert(ref == bitref); 344| 4.73k| if (ctx.randbool()) { ------------------ | Branch (344:25): [True: 2.40k, False: 2.32k] ------------------ 345| 2.40k| ref = !ref; 346| 2.40k| bitref.flip(); 347| 2.40k| } 348| 4.73k| } 349| 5.48k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_32clEv: 350| 4.11k| [&] { 351| | // back() const 352| 4.11k| if (!cdeq.empty()) { ------------------ | Branch (352:21): [True: 3.15k, False: 952] ------------------ 353| 3.15k| const auto& cdeq = deq; 354| 3.15k| const auto& cbitdeq = bitdeq; 355| 3.15k| auto& ref = cdeq.back(); 356| 3.15k| auto bitref = cbitdeq.back(); 357| 3.15k| assert(ref == bitref); 358| 3.15k| } 359| 4.11k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_33clEv: 360| 7.40k| [&] { 361| | // push_back() 362| 7.40k| if (cdeq.size() < limitlen) { ------------------ | Branch (362:21): [True: 7.03k, False: 373] ------------------ 363| 7.03k| bool val = ctx.randbool(); 364| 7.03k| if (cdeq.empty()) { ------------------ | Branch (364:25): [True: 3.21k, False: 3.82k] ------------------ 365| 3.21k| deq.push_back(val); 366| 3.21k| bitdeq.push_back(val); 367| 3.82k| } else { 368| 3.82k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 369| 3.82k| auto& ref = deq[pos]; 370| 3.82k| auto bitref = bitdeq[pos]; 371| 3.82k| assert(ref == bitref); 372| 3.82k| deq.push_back(val); 373| 3.82k| bitdeq.push_back(val); 374| 3.82k| assert(ref == bitref); // references are not invalidated 375| 3.82k| } 376| 7.03k| } 377| 7.40k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_34clEv: 378| 7.92k| [&] { 379| | // push_front() 380| 7.92k| if (cdeq.size() < limitlen) { ------------------ | Branch (380:21): [True: 7.54k, False: 386] ------------------ 381| 7.54k| bool val = ctx.randbool(); 382| 7.54k| if (cdeq.empty()) { ------------------ | Branch (382:25): [True: 2.77k, False: 4.76k] ------------------ 383| 2.77k| deq.push_front(val); 384| 2.77k| bitdeq.push_front(val); 385| 4.76k| } else { 386| 4.76k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 387| 4.76k| auto& ref = deq[pos]; 388| 4.76k| auto bitref = bitdeq[pos]; 389| 4.76k| assert(ref == bitref); 390| 4.76k| deq.push_front(val); 391| 4.76k| bitdeq.push_front(val); 392| 4.76k| assert(ref == bitref); // references are not invalidated 393| 4.76k| } 394| 7.54k| } 395| 7.92k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_35clEv: 396| 4.85k| [&] { 397| | // pop_back() 398| 4.85k| if (!cdeq.empty()) { ------------------ | Branch (398:21): [True: 3.88k, False: 964] ------------------ 399| 3.88k| if (cdeq.size() == 1) { ------------------ | Branch (399:25): [True: 837, False: 3.05k] ------------------ 400| 837| deq.pop_back(); 401| 837| bitdeq.pop_back(); 402| 3.05k| } else { 403| 3.05k| size_t pos = provider.ConsumeIntegralInRange(0, cdeq.size() - 2); 404| 3.05k| auto& ref = deq[pos]; 405| 3.05k| auto bitref = bitdeq[pos]; 406| 3.05k| assert(ref == bitref); 407| 3.05k| deq.pop_back(); 408| 3.05k| bitdeq.pop_back(); 409| 3.05k| assert(ref == bitref); // references to other elements are not invalidated 410| 3.05k| } 411| 3.88k| } 412| 4.85k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_36clEv: 413| 5.35k| [&] { 414| | // pop_front() 415| 5.35k| if (!cdeq.empty()) { ------------------ | Branch (415:21): [True: 4.45k, False: 894] ------------------ 416| 4.45k| if (cdeq.size() == 1) { ------------------ | Branch (416:25): [True: 1.74k, False: 2.71k] ------------------ 417| 1.74k| deq.pop_front(); 418| 1.74k| bitdeq.pop_front(); 419| 2.71k| } else { 420| 2.71k| size_t pos = provider.ConsumeIntegralInRange(1, cdeq.size() - 1); 421| 2.71k| auto& ref = deq[pos]; 422| 2.71k| auto bitref = bitdeq[pos]; 423| 2.71k| assert(ref == bitref); 424| 2.71k| deq.pop_front(); 425| 2.71k| bitdeq.pop_front(); 426| 2.71k| assert(ref == bitref); // references to other elements are not invalidated 427| 2.71k| } 428| 4.45k| } 429| 5.35k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_37clEv: 430| 8.55k| [&] { 431| | // erase (in middle, single) 432| 8.55k| if (!cdeq.empty()) { ------------------ | Branch (432:21): [True: 7.57k, False: 989] ------------------ 433| 7.57k| size_t before = provider.ConsumeIntegralInRange(0, cdeq.size() - 1); 434| 7.57k| size_t after = cdeq.size() - 1 - before; 435| 7.57k| auto it = deq.erase(cdeq.begin() + before); 436| 7.57k| auto bitit = bitdeq.erase(cbitdeq.begin() + before); 437| 7.57k| assert(it == cdeq.begin() + before && it == cdeq.end() - after); 438| 7.57k| assert(bitit == cbitdeq.begin() + before && bitit == cbitdeq.end() - after); 439| 7.57k| } 440| 8.55k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_38clEv: 441| 3.77k| [&] { 442| | // erase (at front, range) 443| 3.77k| size_t count = provider.ConsumeIntegralInRange(0, cdeq.size()); 444| 3.77k| auto it = deq.erase(cdeq.begin(), cdeq.begin() + count); 445| 3.77k| auto bitit = bitdeq.erase(cbitdeq.begin(), cbitdeq.begin() + count); 446| 3.77k| assert(it == deq.begin()); 447| 3.77k| assert(bitit == bitdeq.begin()); 448| 3.77k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_39clEv: 449| 3.85k| [&] { 450| | // erase (at back, range) 451| 3.85k| size_t count = provider.ConsumeIntegralInRange(0, cdeq.size()); 452| 3.85k| auto it = deq.erase(cdeq.end() - count, cdeq.end()); 453| 3.85k| auto bitit = bitdeq.erase(cbitdeq.end() - count, cbitdeq.end()); 454| 3.85k| assert(it == deq.end()); 455| 3.85k| assert(bitit == bitdeq.end()); 456| 3.85k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_40clEv: 457| 5.56k| [&] { 458| | // erase (in middle, range) 459| 5.56k| size_t count = provider.ConsumeIntegralInRange(0, cdeq.size()); 460| 5.56k| size_t before = provider.ConsumeIntegralInRange(0, cdeq.size() - count); 461| 5.56k| size_t after = cdeq.size() - count - before; 462| 5.56k| auto it = deq.erase(cdeq.begin() + before, cdeq.end() - after); 463| 5.56k| auto bitit = bitdeq.erase(cbitdeq.begin() + before, cbitdeq.end() - after); 464| 5.56k| assert(it == cdeq.begin() + before && it == cdeq.end() - after); 465| 5.56k| assert(bitit == cbitdeq.begin() + before && bitit == cbitdeq.end() - after); 466| 5.56k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_41clEv: 467| 9.77k| [&] { 468| | // insert/emplace (in middle, single) 469| 9.77k| if (cdeq.size() < limitlen) { ------------------ | Branch (469:21): [True: 9.43k, False: 348] ------------------ 470| 9.43k| size_t before = provider.ConsumeIntegralInRange(0, cdeq.size()); 471| 9.43k| bool val = ctx.randbool(); 472| 9.43k| bool do_emplace = provider.ConsumeBool(); 473| 9.43k| auto it = deq.insert(cdeq.begin() + before, val); 474| 9.43k| auto bitit = do_emplace ? bitdeq.emplace(cbitdeq.begin() + before, val) ------------------ | Branch (474:34): [True: 6.74k, False: 2.68k] ------------------ 475| 9.43k| : bitdeq.insert(cbitdeq.begin() + before, val); 476| 9.43k| assert(it == deq.begin() + before); 477| 9.43k| assert(bitit == bitdeq.begin() + before); 478| 9.43k| } 479| 9.77k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_42clEv: 480| 10.1k| [&] { 481| | // insert (at front, begin/end) 482| 10.1k| if (cdeq.size() < limitlen) { ------------------ | Branch (482:21): [True: 9.58k, False: 610] ------------------ 483| 9.58k| size_t count = provider.ConsumeIntegralInRange(0, maxlen); 484| 9.58k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 485| 9.58k| auto rand_end = rand_begin + count; 486| 9.58k| auto it = deq.insert(cdeq.begin(), rand_begin, rand_end); 487| 9.58k| auto bitit = bitdeq.insert(cbitdeq.begin(), rand_begin, rand_end); 488| 9.58k| assert(it == cdeq.begin()); 489| 9.58k| assert(bitit == cbitdeq.begin()); 490| 9.58k| } 491| 10.1k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_43clEv: 492| 6.32k| [&] { 493| | // insert (at back, begin/end) 494| 6.32k| if (cdeq.size() < limitlen) { ------------------ | Branch (494:21): [True: 5.78k, False: 538] ------------------ 495| 5.78k| size_t count = provider.ConsumeIntegralInRange(0, maxlen); 496| 5.78k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 497| 5.78k| auto rand_end = rand_begin + count; 498| 5.78k| auto it = deq.insert(cdeq.end(), rand_begin, rand_end); 499| 5.78k| auto bitit = bitdeq.insert(cbitdeq.end(), rand_begin, rand_end); 500| 5.78k| assert(it == cdeq.end() - count); 501| 5.78k| assert(bitit == cbitdeq.end() - count); 502| 5.78k| } 503| 6.32k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_44clEv: 504| 9.88k| [&] { 505| | // insert (in middle, range) 506| 9.88k| if (cdeq.size() < limitlen) { ------------------ | Branch (506:21): [True: 8.93k, False: 949] ------------------ 507| 8.93k| size_t count = provider.ConsumeIntegralInRange(0, maxlen); 508| 8.93k| size_t before = provider.ConsumeIntegralInRange(0, cdeq.size()); 509| 8.93k| bool val = ctx.randbool(); 510| 8.93k| auto it = deq.insert(cdeq.begin() + before, count, val); 511| 8.93k| auto bitit = bitdeq.insert(cbitdeq.begin() + before, count, val); 512| 8.93k| assert(it == deq.begin() + before); 513| 8.93k| assert(bitit == bitdeq.begin() + before); 514| 8.93k| } 515| 9.88k| }, bitdeque.cpp:_ZZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_45clEv: 516| 11.3k| [&] { 517| | // insert (in middle, begin/end) 518| 11.3k| if (cdeq.size() < limitlen) { ------------------ | Branch (518:21): [True: 10.7k, False: 581] ------------------ 519| 10.7k| size_t count = provider.ConsumeIntegralInRange(0, maxlen); 520| 10.7k| size_t before = provider.ConsumeIntegralInRange(0, cdeq.size()); 521| 10.7k| auto rand_begin = RANDDATA.begin() + ctx.randbits(RANDDATA_BITS); 522| 10.7k| auto rand_end = rand_begin + count; 523| 10.7k| auto it = deq.insert(cdeq.begin() + before, rand_begin, rand_end); 524| 10.7k| auto bitit = bitdeq.insert(cbitdeq.begin() + before, rand_begin, rand_end); 525| 10.7k| assert(it == deq.begin() + before); 526| 10.7k| assert(bitit == bitdeq.begin() + before); 527| 10.7k| } 528| 11.3k| }); LLVMFuzzerTestOneInput: 222| 5.83k|{ 223| 5.83k| test_one_input({data, size}); 224| 5.83k| return 0; 225| 5.83k|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 83| 5.83k|{ 84| 5.83k| CheckGlobals check{}; 85| 5.83k| (*Assert(g_test_one_input))(buffer); ------------------ | | 85| 5.83k|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 86| 5.83k|} bitdeque.cpp:_Z9CallOneOfIJZ20bitdeque_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEE3$_0Z20bitdeque_fuzz_targetS3_E3$_1Z20bitdeque_fuzz_targetS3_E3$_2Z20bitdeque_fuzz_targetS3_E3$_3Z20bitdeque_fuzz_targetS3_E3$_4Z20bitdeque_fuzz_targetS3_E3$_5Z20bitdeque_fuzz_targetS3_E3$_6Z20bitdeque_fuzz_targetS3_E3$_7Z20bitdeque_fuzz_targetS3_E3$_8Z20bitdeque_fuzz_targetS3_E3$_9Z20bitdeque_fuzz_targetS3_E4$_10Z20bitdeque_fuzz_targetS3_E4$_11Z20bitdeque_fuzz_targetS3_E4$_12Z20bitdeque_fuzz_targetS3_E4$_13Z20bitdeque_fuzz_targetS3_E4$_14Z20bitdeque_fuzz_targetS3_E4$_15Z20bitdeque_fuzz_targetS3_E4$_16Z20bitdeque_fuzz_targetS3_E4$_17Z20bitdeque_fuzz_targetS3_E4$_18Z20bitdeque_fuzz_targetS3_E4$_19Z20bitdeque_fuzz_targetS3_E4$_20Z20bitdeque_fuzz_targetS3_E4$_21Z20bitdeque_fuzz_targetS3_E4$_22Z20bitdeque_fuzz_targetS3_E4$_23Z20bitdeque_fuzz_targetS3_E4$_24Z20bitdeque_fuzz_targetS3_E4$_25Z20bitdeque_fuzz_targetS3_E4$_26Z20bitdeque_fuzz_targetS3_E4$_27Z20bitdeque_fuzz_targetS3_E4$_28Z20bitdeque_fuzz_targetS3_E4$_29Z20bitdeque_fuzz_targetS3_E4$_30Z20bitdeque_fuzz_targetS3_E4$_31Z20bitdeque_fuzz_targetS3_E4$_32Z20bitdeque_fuzz_targetS3_E4$_33Z20bitdeque_fuzz_targetS3_E4$_34Z20bitdeque_fuzz_targetS3_E4$_35Z20bitdeque_fuzz_targetS3_E4$_36Z20bitdeque_fuzz_targetS3_E4$_37Z20bitdeque_fuzz_targetS3_E4$_38Z20bitdeque_fuzz_targetS3_E4$_39Z20bitdeque_fuzz_targetS3_E4$_40Z20bitdeque_fuzz_targetS3_E4$_41Z20bitdeque_fuzz_targetS3_E4$_42Z20bitdeque_fuzz_targetS3_E4$_43Z20bitdeque_fuzz_targetS3_E4$_44Z20bitdeque_fuzz_targetS3_E4$_45EEmR18FuzzedDataProviderDpT_: 36| 305k|{ 37| 305k| constexpr size_t call_size{sizeof...(callables)}; 38| 305k| static_assert(call_size >= 1); 39| 305k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 40| | 41| 305k| size_t i{0}; 42| 14.0M| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (42:7): [True: 21.2k, False: 284k] | Branch (42:7): [True: 6.31k, False: 299k] | Branch (42:7): [True: 5.93k, False: 299k] | Branch (42:7): [True: 6.36k, False: 299k] | Branch (42:7): [True: 6.29k, False: 299k] | Branch (42:7): [True: 8.22k, False: 297k] | Branch (42:7): [True: 5.27k, False: 300k] | Branch (42:7): [True: 8.12k, False: 297k] | Branch (42:7): [True: 11.6k, False: 293k] | Branch (42:7): [True: 11.0k, False: 294k] | Branch (42:7): [True: 9.86k, False: 295k] | Branch (42:7): [True: 4.97k, False: 300k] | Branch (42:7): [True: 5.51k, False: 299k] | Branch (42:7): [True: 8.14k, False: 297k] | Branch (42:7): [True: 6.82k, False: 298k] | Branch (42:7): [True: 11.9k, False: 293k] | Branch (42:7): [True: 3.99k, False: 301k] | Branch (42:7): [True: 4.63k, False: 300k] | Branch (42:7): [True: 3.36k, False: 302k] | Branch (42:7): [True: 3.78k, False: 301k] | Branch (42:7): [True: 4.52k, False: 300k] | Branch (42:7): [True: 3.53k, False: 301k] | Branch (42:7): [True: 3.17k, False: 302k] | Branch (42:7): [True: 3.12k, False: 302k] | Branch (42:7): [True: 5.52k, False: 299k] | Branch (42:7): [True: 7.21k, False: 298k] | Branch (42:7): [True: 3.21k, False: 302k] | Branch (42:7): [True: 5.06k, False: 300k] | Branch (42:7): [True: 2.61k, False: 302k] | Branch (42:7): [True: 6.67k, False: 298k] | Branch (42:7): [True: 2.90k, False: 302k] | Branch (42:7): [True: 5.48k, False: 299k] | Branch (42:7): [True: 4.11k, False: 301k] | Branch (42:7): [True: 7.40k, False: 298k] | Branch (42:7): [True: 7.92k, False: 297k] | Branch (42:7): [True: 4.85k, False: 300k] | Branch (42:7): [True: 5.35k, False: 300k] | Branch (42:7): [True: 8.55k, False: 296k] | Branch (42:7): [True: 3.77k, False: 301k] | Branch (42:7): [True: 3.85k, False: 301k] | Branch (42:7): [True: 5.56k, False: 299k] | Branch (42:7): [True: 9.77k, False: 295k] | Branch (42:7): [True: 10.1k, False: 295k] | Branch (42:7): [True: 6.32k, False: 299k] | Branch (42:7): [True: 9.88k, False: 295k] | Branch (42:7): [True: 11.3k, False: 294k] ------------------ 43| 305k| return call_size; 44| 305k|} _ZN12CheckGlobalsC2Ev: 56| 5.83k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 57| 5.83k|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 5.83k| { 18| 5.83k| g_used_g_prng = false; 19| 5.83k| g_seeded_g_prng_zero = false; 20| 5.83k| g_used_system_time = false; 21| 5.83k| SetMockTime(0s); 22| 5.83k| } _ZN16CheckGlobalsImplD2Ev: 24| 5.83k| { 25| 5.83k| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (25:13): [True: 0, False: 5.83k] | 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| 5.83k| if (g_used_system_time) { ------------------ | Branch (41:13): [True: 0, False: 5.83k] ------------------ 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| 5.83k| } _ZN8bitdequeILi128EEC2Ev: 212| 27.0k| explicit bitdeque() : m_pad_begin{0}, m_pad_end{0} {} _ZN8bitdequeILi128EE9push_backEb: 352| 94.4M| { 353| 94.4M| extend_back(1); 354| 94.4M| back() = val; 355| 94.4M| } _ZN8bitdequeILi128EE11extend_backEm: 156| 94.4M| { 157| 94.4M| if (n > static_cast(m_pad_end)) { ------------------ | Branch (157:13): [True: 753k, False: 93.6M] ------------------ 158| 753k| n -= m_pad_end + 1; 159| 753k| m_pad_end = BITS_PER_WORD - 1; 160| 753k| m_deque.insert(m_deque.end(), 1 + (n / BITS_PER_WORD), {}); 161| 753k| n %= BITS_PER_WORD; 162| 753k| } 163| 94.4M| m_pad_end -= n; 164| 94.4M| } _ZN8bitdequeILi128EE4backEv: 334| 94.4M| reference back() { return end()[-1]; } _ZN8bitdequeILi128EE3endEv: 249| 94.5M| iterator end() noexcept { return iterator{m_deque.end(), 0} - m_pad_end; } _ZmiN8bitdequeILi128EE8IteratorILb0EEEl: 101| 94.5M| friend Iterator operator-(Iterator x, difference_type dist) { x -= dist; return x; } _ZN8bitdequeILi128EE8IteratorILb0EEmIEl: 94| 94.5M| Iterator& operator-=(difference_type dist) { return operator+=(-dist); } _ZN8bitdequeILi128EE8IteratorILb0EEpLEl: 64| 189M| { 65| 189M| if (dist > 0) { ------------------ | Branch (65:17): [True: 189k, False: 189M] ------------------ 66| 189k| if (dist + m_bitpos >= BITS_PER_WORD) { ------------------ | Branch (66:21): [True: 103k, False: 85.5k] ------------------ 67| 103k| ++m_it; 68| 103k| dist -= BITS_PER_WORD - m_bitpos; 69| 103k| m_bitpos = 0; 70| 103k| } 71| 189k| auto jump = dist / BITS_PER_WORD; 72| 189k| m_it += jump; 73| 189k| m_bitpos += dist - jump * BITS_PER_WORD; 74| 189M| } else if (dist < 0) { ------------------ | Branch (74:24): [True: 188M, False: 881k] ------------------ 75| 188M| dist = -dist; 76| 188M| if (dist > m_bitpos) { ------------------ | Branch (76:21): [True: 94.5M, False: 93.6M] ------------------ 77| 94.5M| --m_it; 78| 94.5M| dist -= m_bitpos + 1; 79| 94.5M| m_bitpos = BITS_PER_WORD - 1; 80| 94.5M| } 81| 188M| auto jump = dist / BITS_PER_WORD; 82| 188M| m_it -= jump; 83| 188M| m_bitpos -= dist - jump * BITS_PER_WORD; 84| 188M| } 85| 189M| return *this; 86| 189M| } _ZN8bitdequeILi128EE8IteratorILb0EEC2ERKNSt3__116__deque_iteratorINS3_6bitsetILm128EEEPS6_RS6_PS7_lLl256EEEi: 41| 94.8M| Iterator(const deque_iterator& it, int bitpos) : m_it(it), m_bitpos(bitpos) {} _ZNK8bitdequeILi128EE8IteratorILb0EEixEl: 109| 94.4M| reference operator[](difference_type pos) const { return *(*this + pos); } _ZplN8bitdequeILi128EE8IteratorILb0EEEl: 99| 94.7M| friend Iterator operator+(Iterator x, difference_type dist) { x += dist; return x; } _ZNK8bitdequeILi128EE4sizeEv: 262| 138k| size_type size() const noexcept { return m_deque.size() * BITS_PER_WORD - m_pad_begin - m_pad_end; } _ZN8bitdequeILi128EE5beginEv: 248| 360k| iterator begin() noexcept { return {m_deque.begin(), m_pad_begin}; } _ZNK8bitdequeILi128EE8IteratorILb0EEdeEv: 108| 697M| reference operator*() const { return (*m_it)[m_bitpos]; } _ZN8bitdequeILi128EE8IteratorILb0EEppEv: 95| 524M| Iterator& operator++() { ++m_bitpos; if (m_bitpos == BITS_PER_WORD) { m_bitpos = 0; ++m_it; }; return *this; } ------------------ | Branch (95:50): [True: 4.09M, False: 520M] ------------------ _ZN8bitdequeILi128EEaSEOS0_: 245| 57.6k| bitdeque& operator=(bitdeque&& other) noexcept = default; _ZN8bitdequeILi128EE5clearEv: 345| 6.31k| { 346| 6.31k| m_deque.clear(); 347| 6.31k| m_pad_begin = m_pad_end = 0; 348| 6.31k| } _ZN8bitdequeILi128EE6resizeEm: 392| 5.93k| { 393| 5.93k| if (n < size()) { ------------------ | Branch (393:13): [True: 2.82k, False: 3.10k] ------------------ 394| 2.82k| erase_back(size() - n); 395| 3.10k| } else { 396| 3.10k| extend_back(n - size()); 397| 3.10k| } 398| 5.93k| } _ZN8bitdequeILi128EE10erase_backEm: 137| 91.5k| { 138| 91.5k| if (n >= static_cast(BITS_PER_WORD - m_pad_end)) { ------------------ | Branch (138:13): [True: 5.55k, False: 86.0k] ------------------ 139| 5.55k| n -= BITS_PER_WORD - m_pad_end; 140| 5.55k| m_pad_end = 0; 141| 5.55k| m_deque.erase(m_deque.end() - 1 - (n / BITS_PER_WORD), m_deque.end()); 142| 5.55k| n %= BITS_PER_WORD; 143| 5.55k| } 144| 91.5k| if (n) { ------------------ | Branch (144:13): [True: 84.6k, False: 6.89k] ------------------ 145| 84.6k| auto& last = m_deque.back(); 146| 7.51M| while (n) { ------------------ | Branch (146:20): [True: 7.42M, False: 84.6k] ------------------ 147| 7.42M| last.reset(BITS_PER_WORD - 1 - m_pad_end); 148| 7.42M| ++m_pad_end; 149| 7.42M| --n; 150| 7.42M| } 151| 84.6k| } 152| 91.5k| } _ZN8bitdequeILi128EE6assignEmb: 216| 92.2k| { 217| 92.2k| m_deque.clear(); 218| 92.2k| m_deque.resize((count + BITS_PER_WORD - 1) / BITS_PER_WORD); 219| 92.2k| m_pad_begin = 0; 220| 92.2k| m_pad_end = 0; 221| 92.2k| if (val) { ------------------ | Branch (221:13): [True: 13.6k, False: 78.6k] ------------------ 222| 506k| for (auto& elem : m_deque) elem.flip(); ------------------ | Branch (222:29): [True: 506k, False: 13.6k] ------------------ 223| 13.6k| } 224| 92.2k| if (count % BITS_PER_WORD) { ------------------ | Branch (224:13): [True: 72.6k, False: 19.6k] ------------------ 225| 72.6k| erase_back(BITS_PER_WORD - (count % BITS_PER_WORD)); 226| 72.6k| } 227| 92.2k| } _ZN8bitdequeILi128EEC2Emb: 230| 21.1k| bitdeque(size_type count, bool val) { assign(count, val); } _ZN8bitdequeILi128EEC2Em: 233| 8.22k| explicit bitdeque(size_t count) { assign(count, false); } _ZN8bitdequeILi128EEC2INSt3__114__bit_iteratorINS2_6vectorIbNS2_9allocatorIbEEEELb0ELm0EEEEET_S9_: 312| 18.9k| bitdeque(It first, It last) { assign(first, last); } _ZN8bitdequeILi128EE6assignINSt3__114__bit_iteratorINS2_6vectorIbNS2_9allocatorIbEEEELb0ELm0EEEEEvT_S9_: 283| 27.0k| { 284| 27.0k| size_type count = std::distance(first, last); 285| 27.0k| assign(count, false); 286| 27.0k| auto it = begin(); 287| 77.0M| while (first != last) { ------------------ | Branch (287:16): [True: 77.0M, False: 27.0k] ------------------ 288| 77.0M| *(it++) = *(first++); 289| 77.0M| } 290| 27.0k| } _ZN8bitdequeILi128EE8IteratorILb0EEppEi: 96| 308M| Iterator operator++(int) { auto ret{*this}; operator++(); return ret; } _ZN8bitdequeILi128EEC2ESt16initializer_listIbE: 315| 11.6k| bitdeque(std::initializer_list ilist) { assign(ilist); } _ZN8bitdequeILi128EE6assignESt16initializer_listIbE: 294| 29.4k| { 295| 29.4k| assign(ilist.size(), false); 296| 29.4k| auto it = begin(); 297| 29.4k| auto init = ilist.begin(); 298| 141k| while (init != ilist.end()) { ------------------ | Branch (298:16): [True: 111k, False: 29.4k] ------------------ 299| 111k| *(it++) = *(init++); 300| 111k| } 301| 29.4k| } _ZN8bitdequeILi128EEaSERKS0_: 242| 9.86k| bitdeque& operator=(const bitdeque& other) = default; _Z4swapR8bitdequeILi128EES1_: 407| 5.51k| friend void swap(bitdeque& b1, bitdeque& b2) noexcept { b1.swap(b2); } _ZN8bitdequeILi128EE4swapERS0_: 402| 13.6k| { 403| 13.6k| std::swap(m_deque, other.m_deque); 404| 13.6k| std::swap(m_pad_begin, other.m_pad_begin); 405| 13.6k| std::swap(m_pad_end, other.m_pad_end); 406| 13.6k| } _ZN8bitdequeILi128EEaSESt16initializer_listIbE: 305| 6.82k| { 306| 6.82k| assign(ilist); 307| 6.82k| return *this; 308| 6.82k| } _ZmiRKN8bitdequeILi128EE8IteratorILb0EEES4_: 89| 43.2k| { 90| 43.2k| return BITS_PER_WORD * (x.m_it - y.m_it) + x.m_bitpos - y.m_bitpos; 91| 43.2k| } _ZN8bitdequeILi128EE8IteratorILb0EEmmEv: 97| 78.4M| Iterator& operator--() { if (m_bitpos == 0) { m_bitpos = BITS_PER_WORD; --m_it; }; --m_bitpos; return *this; } ------------------ | Branch (97:38): [True: 613k, False: 77.8M] ------------------ _ZmiRKN8bitdequeILi128EE8IteratorILb1EEES4_: 89| 123k| { 90| 123k| return BITS_PER_WORD * (x.m_it - y.m_it) + x.m_bitpos - y.m_bitpos; 91| 123k| } _ZNK8bitdequeILi128EE3endEv: 252| 42.6k| const_iterator end() const noexcept { return const_iterator{m_deque.cend(), 0} - m_pad_end; } _ZmiN8bitdequeILi128EE8IteratorILb1EEEl: 101| 106k| friend Iterator operator-(Iterator x, difference_type dist) { x -= dist; return x; } _ZN8bitdequeILi128EE8IteratorILb1EEmIEl: 94| 106k| Iterator& operator-=(difference_type dist) { return operator+=(-dist); } _ZN8bitdequeILi128EE8IteratorILb1EEpLEl: 64| 177k| { 65| 177k| if (dist > 0) { ------------------ | Branch (65:17): [True: 49.2k, False: 128k] ------------------ 66| 49.2k| if (dist + m_bitpos >= BITS_PER_WORD) { ------------------ | Branch (66:21): [True: 21.5k, False: 27.7k] ------------------ 67| 21.5k| ++m_it; 68| 21.5k| dist -= BITS_PER_WORD - m_bitpos; 69| 21.5k| m_bitpos = 0; 70| 21.5k| } 71| 49.2k| auto jump = dist / BITS_PER_WORD; 72| 49.2k| m_it += jump; 73| 49.2k| m_bitpos += dist - jump * BITS_PER_WORD; 74| 128k| } else if (dist < 0) { ------------------ | Branch (74:24): [True: 87.7k, False: 40.8k] ------------------ 75| 87.7k| dist = -dist; 76| 87.7k| if (dist > m_bitpos) { ------------------ | Branch (76:21): [True: 73.9k, False: 13.7k] ------------------ 77| 73.9k| --m_it; 78| 73.9k| dist -= m_bitpos + 1; 79| 73.9k| m_bitpos = BITS_PER_WORD - 1; 80| 73.9k| } 81| 87.7k| auto jump = dist / BITS_PER_WORD; 82| 87.7k| m_it -= jump; 83| 87.7k| m_bitpos -= dist - jump * BITS_PER_WORD; 84| 87.7k| } 85| 177k| return *this; 86| 177k| } _ZN8bitdequeILi128EE8IteratorILb1EEC2ERKNSt3__116__deque_iteratorINS3_6bitsetILm128EEEPKS6_RS7_PKS8_lLl256EEEi: 41| 245k| Iterator(const deque_iterator& it, int bitpos) : m_it(it), m_bitpos(bitpos) {} _ZNK8bitdequeILi128EE5beginEv: 250| 86.8k| const_iterator begin() const noexcept { return const_iterator{m_deque.cbegin(), m_pad_begin}; } _ZN8bitdequeILi128EE4rendEv: 255| 3.36k| reverse_iterator rend() noexcept { return reverse_iterator{begin()}; } _ZN8bitdequeILi128EE6rbeginEv: 254| 3.36k| reverse_iterator rbegin() noexcept { return reverse_iterator{end()}; } _ZNK8bitdequeILi128EE4rendEv: 258| 3.78k| const_reverse_iterator rend() const noexcept { return const_reverse_iterator{cbegin()}; } _ZNK8bitdequeILi128EE6cbeginEv: 251| 80.6k| const_iterator cbegin() const noexcept { return const_iterator{m_deque.cbegin(), m_pad_begin}; } _ZNK8bitdequeILi128EE6rbeginEv: 256| 3.78k| const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator{cend()}; } _ZNK8bitdequeILi128EE4cendEv: 253| 35.7k| const_iterator cend() const noexcept { return const_iterator{m_deque.cend(), 0} - m_pad_end; } _ZNK8bitdequeILi128EE5crendEv: 259| 3.53k| const_reverse_iterator crend() const noexcept { return const_reverse_iterator{cbegin()}; } _ZNK8bitdequeILi128EE7crbeginEv: 257| 3.53k| const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator{cend()}; } _ZNK8bitdequeILi128EE8max_sizeEv: 272| 3.17k| { 273| 3.17k| if (m_deque.max_size() < std::numeric_limits::max() / BITS_PER_WORD) { ------------------ | Branch (273:13): [True: 0, False: 3.17k] ------------------ 274| 0| return m_deque.max_size() * BITS_PER_WORD; 275| 3.17k| } else { 276| 3.17k| return std::numeric_limits::max(); 277| 3.17k| } 278| 3.17k| } _ZNK8bitdequeILi128EE5emptyEv: 266| 3.12k| { 267| 3.12k| return m_deque.size() == 0 || (m_deque.size() == 1 && (m_pad_begin + m_pad_end == BITS_PER_WORD)); ------------------ | Branch (267:16): [True: 763, False: 2.36k] | Branch (267:40): [True: 1.21k, False: 1.14k] | Branch (267:63): [True: 2, False: 1.21k] ------------------ 268| 3.12k| } _ZN8bitdequeILi128EE2atEm: 319| 11.8k| { 320| 11.8k| if (position >= size()) throw std::out_of_range("bitdeque::at() out of range"); ------------------ | Branch (320:13): [True: 5.10k, False: 6.69k] ------------------ 321| 6.69k| return begin()[position]; 322| 11.8k| } _ZNK8bitdequeILi128EE2atEm: 324| 3.21k| { 325| 3.21k| if (position >= size()) throw std::out_of_range("bitdeque::at() out of range"); ------------------ | Branch (325:13): [True: 2.10k, False: 1.10k] ------------------ 326| 1.10k| return cbegin()[position]; 327| 3.21k| } _ZNK8bitdequeILi128EE8IteratorILb1EEixEl: 109| 4.26k| reference operator[](difference_type pos) const { return *(*this + pos); } _ZplN8bitdequeILi128EE8IteratorILb1EEEl: 99| 71.0k| friend Iterator operator+(Iterator x, difference_type dist) { x += dist; return x; } _ZNK8bitdequeILi128EE8IteratorILb1EEdeEv: 108| 6.67k| reference operator*() const { return (*m_it)[m_bitpos]; } _ZN8bitdequeILi128EEixEm: 330| 22.6k| reference operator[](size_type position) { return begin()[position]; } _ZN8bitdequeILi128EE5frontEv: 332| 13.5k| reference front() { return *begin(); } _ZNK8bitdequeILi128EE5frontEv: 333| 2.40k| const_reference front() const { return *cbegin(); } _ZNK8bitdequeILi128EE4backEv: 335| 3.15k| const_reference back() const { return cend()[-1]; } _ZN8bitdequeILi128EE10push_frontEb: 366| 7.54k| { 367| 7.54k| extend_front(1); 368| 7.54k| front() = val; 369| 7.54k| } _ZN8bitdequeILi128EE12extend_frontEm: 187| 27.1k| { 188| 27.1k| if (n > static_cast(m_pad_begin)) { ------------------ | Branch (188:13): [True: 17.8k, False: 9.28k] ------------------ 189| 17.8k| n -= m_pad_begin + 1; 190| 17.8k| m_pad_begin = BITS_PER_WORD - 1; 191| 17.8k| m_deque.insert(m_deque.begin(), 1 + (n / BITS_PER_WORD), {}); 192| 17.8k| n %= BITS_PER_WORD; 193| 17.8k| } 194| 27.1k| m_pad_begin -= n; 195| 27.1k| } _ZN8bitdequeILi128EE8pop_backEv: 380| 3.88k| { 381| 3.88k| erase_back(1); 382| 3.88k| } _ZN8bitdequeILi128EE9pop_frontEv: 386| 4.45k| { 387| 4.45k| erase_front(1); 388| 4.45k| } _ZN8bitdequeILi128EE11erase_frontEm: 168| 13.0k| { 169| 13.0k| if (n >= static_cast(BITS_PER_WORD - m_pad_begin)) { ------------------ | Branch (169:13): [True: 3.53k, False: 9.52k] ------------------ 170| 3.53k| n -= BITS_PER_WORD - m_pad_begin; 171| 3.53k| m_pad_begin = 0; 172| 3.53k| m_deque.erase(m_deque.begin(), m_deque.begin() + 1 + (n / BITS_PER_WORD)); 173| 3.53k| n %= BITS_PER_WORD; 174| 3.53k| } 175| 13.0k| if (n) { ------------------ | Branch (175:13): [True: 9.87k, False: 3.17k] ------------------ 176| 9.87k| auto& first = m_deque.front(); 177| 141k| while (n) { ------------------ | Branch (177:20): [True: 132k, False: 9.87k] ------------------ 178| 132k| first.reset(m_pad_begin); 179| 132k| ++m_pad_begin; 180| 132k| --n; 181| 132k| } 182| 9.87k| } 183| 13.0k| } _ZN8bitdequeILi128EE5eraseENS0_8IteratorILb1EEE: 427| 7.57k| iterator erase(const_iterator pos) { return erase(pos, pos + 1); } _ZN8bitdequeILi128EE5eraseENS0_8IteratorILb1EEES2_: 411| 20.7k| { 412| 20.7k| size_type before = std::distance(cbegin(), first); 413| 20.7k| size_type dist = std::distance(first, last); 414| 20.7k| size_type after = std::distance(last, cend()); 415| 20.7k| if (before < after) { ------------------ | Branch (415:13): [True: 8.59k, False: 12.1k] ------------------ 416| 8.59k| std::move_backward(begin(), begin() + before, end() - after); 417| 8.59k| erase_front(dist); 418| 8.59k| return begin() + before; 419| 12.1k| } else { 420| 12.1k| std::move(end() - after, end(), begin() + before); 421| 12.1k| erase_back(dist); 422| 12.1k| return end() - after; 423| 12.1k| } 424| 20.7k| } _ZneRKN8bitdequeILi128EE8IteratorILb0EEES4_: 107| 95.1M| friend bool operator!=(const Iterator& x, const Iterator& y) { return x.m_it != y.m_it || x.m_bitpos != y.m_bitpos; } ------------------ | Branch (107:79): [True: 93.9M, False: 1.18M] | Branch (107:99): [True: 1.11M, False: 74.2k] ------------------ _ZeqRKN8bitdequeILi128EE8IteratorILb1EEES4_: 106| 41.6k| friend bool operator==(const Iterator& x, const Iterator& y) { return x.m_it == y.m_it && x.m_bitpos == y.m_bitpos; } ------------------ | Branch (106:79): [True: 41.6k, False: 0] | Branch (106:99): [True: 41.6k, False: 0] ------------------ _ZN8bitdequeILi128EE8IteratorILb1EEC2ILb1EvEERKNS1_ILb0EEE: 61| 41.6k| Iterator(const Iterator& x) : m_it(x.m_it), m_bitpos(x.m_bitpos) {} _ZeqRKN8bitdequeILi128EE8IteratorILb0EEES4_: 106| 36.7k| friend bool operator==(const Iterator& x, const Iterator& y) { return x.m_it == y.m_it && x.m_bitpos == y.m_bitpos; } ------------------ | Branch (106:79): [True: 36.7k, False: 0] | Branch (106:99): [True: 36.7k, False: 0] ------------------ _ZN8bitdequeILi128EE7emplaceENS0_8IteratorILb1EEEb: 440| 6.74k| iterator emplace(const_iterator pos, bool val) { return insert(pos, val); } _ZN8bitdequeILi128EE6insertENS0_8IteratorILb1EEEb: 432| 9.43k| { 433| 9.43k| size_type before = pos - cbegin(); 434| 9.43k| insert_zeroes(before, 1); 435| 9.43k| auto it = begin() + before; 436| 9.43k| *it = val; 437| 9.43k| return it; 438| 9.43k| } _ZN8bitdequeILi128EE13insert_zeroesEmm: 199| 44.5k| { 200| 44.5k| size_type after = size() - before; 201| 44.5k| if (before < after) { ------------------ | Branch (201:13): [True: 19.5k, False: 24.9k] ------------------ 202| 19.5k| extend_front(count); 203| 19.5k| std::move(begin() + count, begin() + count + before, begin()); 204| 24.9k| } else { 205| 24.9k| extend_back(count); 206| 24.9k| std::move_backward(begin() + before, begin() + before + after, end()); 207| 24.9k| } 208| 44.5k| } _ZN8bitdequeILi128EE6insertINSt3__114__bit_iteratorINS2_6vectorIbNS2_9allocatorIbEEEELb0ELm0EEEEENS0_8IteratorILb0EEENS9_ILb1EEET_SC_: 455| 26.1k| { 456| 26.1k| size_type before = pos - cbegin(); 457| 26.1k| size_type count = std::distance(first, last); 458| 26.1k| insert_zeroes(before, count); 459| 26.1k| auto it_begin = begin() + before; 460| 26.1k| auto it = it_begin; 461| 209M| while (first != last) { ------------------ | Branch (461:16): [True: 209M, False: 26.1k] ------------------ 462| 209M| *(it++) = *(first++); 463| 209M| } 464| 26.1k| return it_begin; 465| 26.1k| } _ZN8bitdequeILi128EE6insertENS0_8IteratorILb1EEEmb: 443| 8.93k| { 444| 8.93k| size_type before = pos - cbegin(); 445| 8.93k| insert_zeroes(before, count); 446| 8.93k| auto it_begin = begin() + before; 447| 8.93k| auto it = it_begin; 448| 8.93k| auto it_end = it + count; 449| 22.5M| while (it != it_end) *(it++) = val; ------------------ | Branch (449:16): [True: 22.5M, False: 8.93k] ------------------ 450| 8.93k| return it_begin; 451| 8.93k| } _Z22inline_assertion_checkILb0EbEOT0_S1_PKciS3_S3_: 52| 53.2k|{ 53| 53.2k| 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| 53.2k| ) { 58| 53.2k| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 53.2k] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 53.2k| } 62| 53.2k| return std::forward(val); 63| 53.2k|} _Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_: 52| 5.83k|{ 53| 5.83k| 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| 5.83k| ) { 58| 5.83k| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 5.83k] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 5.83k| } 62| 5.83k| return std::forward(val); 63| 5.83k|} _Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_: 52| 5.83k|{ 53| 5.83k| 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| 5.83k| ) { 58| 5.83k| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 5.83k] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 5.83k| } 62| 5.83k| return std::forward(val); 63| 5.83k|} _Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE: 42| 5.83k|{ 43| 5.83k| Assert(mock_time_in >= 0s); ------------------ | | 85| 5.83k|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 44| 5.83k| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 45| 5.83k|}