avifGuessBufferFileFormat: 279| 98|{ 280| 98| if (size == 0) { ------------------ | Branch (280:9): [True: 0, False: 98] ------------------ 281| 0| return AVIF_APP_FILE_FORMAT_UNKNOWN; 282| 0| } 283| | 284| 98| avifROData header; 285| 98| header.data = data; 286| 98| header.size = size; 287| | 288| 98| if (avifPeekCompatibleFileType(&header)) { ------------------ | Branch (288:9): [True: 64, False: 34] ------------------ 289| 64| return AVIF_APP_FILE_FORMAT_AVIF; 290| 64| } 291| | 292| 34| static const uint8_t signatureJPEG[2] = { 0xFF, 0xD8 }; 293| 34| static const uint8_t signaturePNG[8] = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A }; 294| 34| static const uint8_t signatureY4M[9] = { 0x59, 0x55, 0x56, 0x34, 0x4D, 0x50, 0x45, 0x47, 0x32 }; // "YUV4MPEG2" 295| 34| struct avifHeaderSignature 296| 34| { 297| 34| avifAppFileFormat format; 298| 34| const uint8_t * magic; 299| 34| size_t magicSize; 300| 34| } signatures[] = { { AVIF_APP_FILE_FORMAT_JPEG, signatureJPEG, sizeof(signatureJPEG) }, 301| 34| { AVIF_APP_FILE_FORMAT_PNG, signaturePNG, sizeof(signaturePNG) }, 302| 34| { AVIF_APP_FILE_FORMAT_Y4M, signatureY4M, sizeof(signatureY4M) } }; 303| 34| const size_t signaturesCount = sizeof(signatures) / sizeof(signatures[0]); 304| | 305| 63| for (size_t signatureIndex = 0; signatureIndex < signaturesCount; ++signatureIndex) { ------------------ | Branch (305:37): [True: 61, False: 2] ------------------ 306| 61| const struct avifHeaderSignature * const signature = &signatures[signatureIndex]; 307| 61| if (header.size < signature->magicSize) { ------------------ | Branch (307:13): [True: 0, False: 61] ------------------ 308| 0| continue; 309| 0| } 310| 61| if (!memcmp(header.data, signature->magic, signature->magicSize)) { ------------------ | Branch (310:13): [True: 32, False: 29] ------------------ 311| 32| return signature->format; 312| 32| } 313| 61| } 314| | 315| 2| return AVIF_APP_FILE_FORMAT_UNKNOWN; 316| 34|} _ZN4absl12lts_2024011613base_internal16SchedulingHelperC2ENS1_14SchedulingModeE: 116| 16| explicit SchedulingHelper(base_internal::SchedulingMode mode) : mode_(mode) { 117| 16| if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) { ------------------ | Branch (117:9): [True: 0, False: 16] ------------------ 118| 0| guard_result_ = base_internal::SchedulingGuard::DisableRescheduling(); 119| 0| } 120| 16| } _ZN4absl12lts_2024011613base_internal16SchedulingHelperD2Ev: 122| 16| ~SchedulingHelper() { 123| 16| if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) { ------------------ | Branch (123:9): [True: 0, False: 16] ------------------ 124| 0| base_internal::SchedulingGuard::EnableRescheduling(guard_result_); 125| 0| } 126| 16| } _ZN4absl12lts_2024011613base_internal11ControlWordEPNS0_9once_flagE: 193| 30| absl::Nonnull flag) { 194| 30| return &flag->control_; 195| 30|} _ZN4absl12lts_202401169call_onceIMNS0_14flags_internal8FlagImplEFvvEJPS3_EEEvRNS0_9once_flagEOT_DpOT0_: 212| 29|void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) { 213| 29| std::atomic* once = base_internal::ControlWord(&flag); 214| 29| uint32_t s = once->load(std::memory_order_acquire); 215| 29| if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) { ------------------ | | 178| 29|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 15, False: 14] | | | Branch (178:49): [Folded, False: 29] | | | Branch (178:58): [True: 15, False: 14] | | ------------------ ------------------ 216| 15| base_internal::CallOnceImpl( 217| 15| once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL, 218| 15| std::forward(fn), std::forward(args)...); 219| 15| } 220| 29|} _ZN4absl12lts_2024011613base_internal12CallOnceImplIMNS0_14flags_internal8FlagImplEFvvEJPS4_EEEvPNSt3__16atomicIjEENS1_14SchedulingModeEOT_DpOT0_: 153| 15| Args&&... args) { 154| |#ifndef NDEBUG 155| | { 156| | uint32_t old_control = control->load(std::memory_order_relaxed); 157| | if (old_control != kOnceInit && 158| | old_control != kOnceRunning && 159| | old_control != kOnceWaiter && 160| | old_control != kOnceDone) { 161| | ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx", 162| | static_cast(old_control)); // NOLINT 163| | } 164| | } 165| |#endif // NDEBUG 166| 15| static const base_internal::SpinLockWaitTransition trans[] = { 167| 15| {kOnceInit, kOnceRunning, true}, 168| 15| {kOnceRunning, kOnceWaiter, false}, 169| 15| {kOnceDone, kOnceDone, true}}; 170| | 171| | // Must do this before potentially modifying control word's state. 172| 15| base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode); 173| | // Short circuit the simplest case to avoid procedure call overhead. 174| | // The base_internal::SpinLockWait() call returns either kOnceInit or 175| | // kOnceDone. If it returns kOnceDone, it must have loaded the control word 176| | // with std::memory_order_acquire and seen a value of kOnceDone. 177| 15| uint32_t old_control = kOnceInit; 178| 15| if (control->compare_exchange_strong(old_control, kOnceRunning, ------------------ | Branch (178:7): [True: 15, False: 0] ------------------ 179| 15| std::memory_order_relaxed) || 180| 0| base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans, ------------------ | | 45| 0| (sizeof(::absl::macros_internal::ArraySizeHelper(array))) ------------------ | Branch (180:7): [True: 0, False: 0] ------------------ 181| 15| scheduling_mode) == kOnceInit) { 182| 15| base_internal::invoke(std::forward(fn), 183| 15| std::forward(args)...); 184| 15| old_control = 185| 15| control->exchange(base_internal::kOnceDone, std::memory_order_release); 186| 15| if (old_control == base_internal::kOnceWaiter) { ------------------ | Branch (186:9): [True: 0, False: 15] ------------------ 187| 0| base_internal::SpinLockWake(control, true); 188| 0| } 189| 15| } // else *control is already kOnceDone 190| 15|} _ZN4absl12lts_202401169call_onceIRFvvEJEEEvRNS0_9once_flagEOT_DpOT0_: 212| 1|void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) { 213| 1| std::atomic* once = base_internal::ControlWord(&flag); 214| 1| uint32_t s = once->load(std::memory_order_acquire); 215| 1| if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) { ------------------ | | 178| 1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 1, False: 0] | | | Branch (178:49): [Folded, False: 1] | | | Branch (178:58): [True: 1, False: 0] | | ------------------ ------------------ 216| 1| base_internal::CallOnceImpl( 217| 1| once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL, 218| 1| std::forward(fn), std::forward(args)...); 219| 1| } 220| 1|} _ZN4absl12lts_2024011613base_internal12CallOnceImplIRFvvEJEEEvPNSt3__16atomicIjEENS1_14SchedulingModeEOT_DpOT0_: 153| 1| Args&&... args) { 154| |#ifndef NDEBUG 155| | { 156| | uint32_t old_control = control->load(std::memory_order_relaxed); 157| | if (old_control != kOnceInit && 158| | old_control != kOnceRunning && 159| | old_control != kOnceWaiter && 160| | old_control != kOnceDone) { 161| | ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx", 162| | static_cast(old_control)); // NOLINT 163| | } 164| | } 165| |#endif // NDEBUG 166| 1| static const base_internal::SpinLockWaitTransition trans[] = { 167| 1| {kOnceInit, kOnceRunning, true}, 168| 1| {kOnceRunning, kOnceWaiter, false}, 169| 1| {kOnceDone, kOnceDone, true}}; 170| | 171| | // Must do this before potentially modifying control word's state. 172| 1| base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode); 173| | // Short circuit the simplest case to avoid procedure call overhead. 174| | // The base_internal::SpinLockWait() call returns either kOnceInit or 175| | // kOnceDone. If it returns kOnceDone, it must have loaded the control word 176| | // with std::memory_order_acquire and seen a value of kOnceDone. 177| 1| uint32_t old_control = kOnceInit; 178| 1| if (control->compare_exchange_strong(old_control, kOnceRunning, ------------------ | Branch (178:7): [True: 1, False: 0] ------------------ 179| 1| std::memory_order_relaxed) || 180| 0| base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans, ------------------ | | 45| 0| (sizeof(::absl::macros_internal::ArraySizeHelper(array))) ------------------ | Branch (180:7): [True: 0, False: 0] ------------------ 181| 1| scheduling_mode) == kOnceInit) { 182| 1| base_internal::invoke(std::forward(fn), 183| 1| std::forward(args)...); 184| 1| old_control = 185| 1| control->exchange(base_internal::kOnceDone, std::memory_order_release); 186| 1| if (old_control == base_internal::kOnceWaiter) { ------------------ | Branch (186:9): [True: 0, False: 1] ------------------ 187| 0| base_internal::SpinLockWake(control, true); 188| 0| } 189| 1| } // else *control is already kOnceDone 190| 1|} _ZN4absl12lts_202401168bit_castINS0_14flags_internal19FlagValueAndInitBitIN8fuzztest8internal14TimeBudgetTypeEEElTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableISB_EE5valuesr3std21is_trivially_copyableISA_EE5valueEiE4typeELi0EEESA_RKSB_: 163| 1|inline constexpr Dest bit_cast(const Source& source) { 164| 1| return __builtin_bit_cast(Dest, source); 165| 1|} _ZN4absl12lts_202401168bit_castINS0_14flags_internal19FlagValueAndInitBitIbEElTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS8_EE5valuesr3std21is_trivially_copyableIS7_EE5valueEiE4typeELi0EEES7_RKS8_: 163| 3|inline constexpr Dest bit_cast(const Source& source) { 164| 3| return __builtin_bit_cast(Dest, source); 165| 3|} _ZN4absl12lts_202401168bit_castIlNSt3__15arrayIcLm8EEETnNS2_9enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS7_EE5valuesr3std21is_trivially_copyableIS6_EE5valueEiE4typeELi0EEES6_RKS7_: 163| 5|inline constexpr Dest bit_cast(const Source& source) { 164| 5| return __builtin_bit_cast(Dest, source); 165| 5|} _ZN4absl12lts_202401169gbswap_32Ej: 48| 10|inline uint32_t gbswap_32(uint32_t host_int) { 49| 10|#if ABSL_HAVE_BUILTIN(__builtin_bswap32) || defined(__GNUC__) 50| 10| return __builtin_bswap32(host_int); 51| |#elif defined(_MSC_VER) 52| | return _byteswap_ulong(host_int); 53| |#else 54| | return (((host_int & uint32_t{0xFF}) << 24) | 55| | ((host_int & uint32_t{0xFF00}) << 8) | 56| | ((host_int & uint32_t{0xFF0000}) >> 8) | 57| | ((host_int & uint32_t{0xFF000000}) >> 24)); 58| |#endif 59| 10|} _ZN4absl12lts_202401169gbswap_16Et: 61| 1|inline uint16_t gbswap_16(uint16_t host_int) { 62| 1|#if ABSL_HAVE_BUILTIN(__builtin_bswap16) || defined(__GNUC__) 63| 1| return __builtin_bswap16(host_int); 64| |#elif defined(_MSC_VER) 65| | return _byteswap_ushort(host_int); 66| |#else 67| | return (((host_int & uint16_t{0xFF}) << 8) | 68| | ((host_int & uint16_t{0xFF00}) >> 8)); 69| |#endif 70| 1|} _ZN4absl12lts_2024011613little_endian8ToHost64Em: 114| 8|inline uint64_t ToHost64(uint64_t x) { return x; } _ZN4absl12lts_2024011613little_endian6ToHostEm: 140| 8|inline uint64_t ToHost(uint64_t x) { return ToHost64(x); } _ZN4absl12lts_2024011610big_endian8ToHost16Et: 198| 1|inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); } _ZN4absl12lts_2024011610big_endian8ToHost32Ej: 201| 10|inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); } _ZN4absl12lts_2024011610big_endian6Load16EPKv: 254| 1|inline uint16_t Load16(absl::Nonnull p) { 255| 1| return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p)); ------------------ | | 74| 1| (absl::base_internal::UnalignedLoad16(_p)) ------------------ 256| 1|} _ZN4absl12lts_2024011610big_endian6Load32EPKv: 262| 10|inline uint32_t Load32(absl::Nonnull p) { 263| 10| return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p)); ------------------ | | 76| 10| (absl::base_internal::UnalignedLoad32(_p)) ------------------ 264| 10|} _ZN4absl12lts_2024011613base_internal10FastTypeIdIbEEPKvv: 42| 2|constexpr inline FastTypeIdType FastTypeId() { 43| 2| return &FastTypeTag::dummy_var; 44| 2|} _ZN4absl12lts_2024011613base_internal10FastTypeIdINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEPKvv: 42| 1|constexpr inline FastTypeIdType FastTypeId() { 43| 1| return &FastTypeTag::dummy_var; 44| 1|} _ZN4absl12lts_2024011613base_internal10FastTypeIdImEEPKvv: 42| 1|constexpr inline FastTypeIdType FastTypeId() { 43| 1| return &FastTypeTag::dummy_var; 44| 1|} _ZN4absl12lts_2024011613base_internal8SpinLockC2Ev: 58| 8| SpinLock() : lockword_(kSpinLockCooperative) { 59| 8| ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static); 60| 8| } _ZN4absl12lts_2024011613base_internal8SpinLock4LockEv: 80| 9| inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() { 81| 9| ABSL_TSAN_MUTEX_PRE_LOCK(this, 0); 82| 9| if (!TryLockImpl()) { ------------------ | Branch (82:9): [True: 0, False: 9] ------------------ 83| 0| SlowLock(); 84| 0| } 85| 9| ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0); 86| 9| } _ZN4absl12lts_2024011613base_internal8SpinLock6UnlockEv: 102| 9| inline void Unlock() ABSL_UNLOCK_FUNCTION() { 103| 9| ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0); 104| 9| uint32_t lock_value = lockword_.load(std::memory_order_relaxed); 105| 9| lock_value = lockword_.exchange(lock_value & kSpinLockCooperative, 106| 9| std::memory_order_release); 107| | 108| 9| if ((lock_value & kSpinLockDisabledScheduling) != 0) { ------------------ | Branch (108:9): [True: 0, False: 9] ------------------ 109| 0| base_internal::SchedulingGuard::EnableRescheduling(true); 110| 0| } 111| 9| if ((lock_value & kWaitTimeMask) != 0) { ------------------ | Branch (111:9): [True: 0, False: 9] ------------------ 112| | // Collect contentionz profile info, and speed the wakeup of any waiter. 113| | // The wait_cycles value indicates how long this thread spent waiting 114| | // for the lock. 115| 0| SlowUnlock(lock_value); 116| 0| } 117| 9| ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0); 118| 9| } _ZN4absl12lts_2024011613base_internal8SpinLock11TryLockImplEv: 192| 9| inline bool TryLockImpl() { 193| 9| uint32_t lock_value = lockword_.load(std::memory_order_relaxed); 194| 9| return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0; 195| 9| } _ZN4absl12lts_2024011613base_internal14SpinLockHolderC2EPNS1_8SpinLockE: 208| 9| : lock_(l) { 209| 9| l->Lock(); 210| 9| } _ZN4absl12lts_2024011613base_internal14SpinLockHolderD2Ev: 211| 9| inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() { lock_->Unlock(); } _ZN4absl12lts_2024011613base_internal8SpinLock15TryLockInternalEjj: 237| 9| uint32_t wait_cycles) { 238| 9| if ((lock_value & kSpinLockHeld) != 0) { ------------------ | Branch (238:7): [True: 0, False: 9] ------------------ 239| 0| return lock_value; 240| 0| } 241| | 242| 9| uint32_t sched_disabled_bit = 0; 243| 9| if ((lock_value & kSpinLockCooperative) == 0) { ------------------ | Branch (243:7): [True: 0, False: 9] ------------------ 244| | // For non-cooperative locks we must make sure we mark ourselves as 245| | // non-reschedulable before we attempt to CompareAndSwap. 246| 0| if (base_internal::SchedulingGuard::DisableRescheduling()) { ------------------ | Branch (246:9): [True: 0, False: 0] ------------------ 247| 0| sched_disabled_bit = kSpinLockDisabledScheduling; 248| 0| } 249| 0| } 250| | 251| 9| if (!lockword_.compare_exchange_strong( ------------------ | Branch (251:7): [True: 0, False: 9] ------------------ 252| 9| lock_value, 253| 9| kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit, 254| 9| std::memory_order_acquire, std::memory_order_relaxed)) { 255| 0| base_internal::SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0); 256| 0| } 257| | 258| 9| return lock_value; 259| 9|} _ZN4absl12lts_2024011613base_internal15UnalignedLoad16EPKv: 39| 1|inline uint16_t UnalignedLoad16(absl::Nonnull p) { 40| 1| uint16_t t; 41| 1| memcpy(&t, p, sizeof t); 42| 1| return t; 43| 1|} _ZN4absl12lts_2024011613base_internal15UnalignedLoad32EPKv: 45| 100|inline uint32_t UnalignedLoad32(absl::Nonnull p) { 46| 100| uint32_t t; 47| 100| memcpy(&t, p, sizeof t); 48| 100| return t; 49| 100|} _ZN4absl12lts_2024011613base_internal15UnalignedLoad64EPKv: 51| 42|inline uint64_t UnalignedLoad64(absl::Nonnull p) { 52| 42| uint64_t t; 53| 42| memcpy(&t, p, sizeof t); 54| 42| return t; 55| 42|} _ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEEC2IJETnNSt3__19enable_ifIXntsr3std7is_sameIFvDpRu7__decayIT_EEFvRS4_EEE5valueEiE4typeELi0EEEDpOS8_: 127| 1| : impl_(std::forward(args)...) {} _ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE13PlacementImplC2IJEEEDpOT_: 165| 1| explicit PlacementImpl(Args&&... args) { 166| 1| new (&space_) T(std::forward(args)...); 167| 1| } _ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEEdeEv: 142| 19| T& operator*() { return *get(); } _ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE3getEv: 144| 19| T* get() { return impl_.get(); } _ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE13PlacementImpl3getEv: 171| 19| T* get() { return Launder(reinterpret_cast(&space_)); } _ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE13PlacementImpl7LaunderIS3_EEPT_S8_: 175| 19| static P* Launder(P* p) { 176| 19|#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606L 177| 19| return std::launder(p); 178| |#elif ABSL_HAVE_BUILTIN(__builtin_launder) 179| | return __builtin_launder(p); 180| |#else 181| | // When `std::launder` or equivalent are not available, we rely on 182| | // undefined behavior, which works as intended on Abseil's officially 183| | // supported platforms as of Q3 2023. 184| |#if defined(__GNUC__) && !defined(__clang__) 185| |#pragma GCC diagnostic push 186| |#pragma GCC diagnostic ignored "-Wstrict-aliasing" 187| |#endif 188| | return p; 189| |#if defined(__GNUC__) && !defined(__clang__) 190| |#pragma GCC diagnostic pop 191| |#endif 192| |#endif 193| 19| } _ZN4absl12lts_2024011620PrefetchToLocalCacheEPKv: 146| 6| const void* addr) { 147| 6| __builtin_prefetch(addr, 0, 3); 148| 6|} _ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7destroyINS3_9allocatorINS3_4pairIKS7_S9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EE: 577| 16| static void destroy(Allocator* alloc, slot_type* slot) { 578| 16| slot_policy::destroy(alloc, slot); 579| 16| } _ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE5applyINS1_12raw_hash_setISA_NS1_10StringHashENS1_8StringEqENS3_9allocatorINS3_4pairIKS7_S9_EEEEE12EqualElementIS7_EEJRSI_EEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSO_DpOSP_: 590| 4| apply(F&& f, Args&&... args) { 591| 4| return absl::container_internal::DecomposePair(std::forward(f), 592| 4| std::forward(args)...); 593| 4| } _ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7elementEPNS1_13map_slot_typeIS7_S9_EE: 597| 34| static std::pair& element(slot_type* slot) { return slot->value; } _ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE5applyINS1_12raw_hash_setISA_NS1_10StringHashENS1_8StringEqENS3_9allocatorINS3_4pairIKS7_S9_EEEEE19EmplaceDecomposableEJSI_EEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSM_DpOSN_: 590| 16| apply(F&& f, Args&&... args) { 591| 16| return absl::container_internal::DecomposePair(std::forward(f), 592| 16| std::forward(args)...); 593| 16| } _ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE5applyINS1_12raw_hash_setISA_NS1_10StringHashENS1_8StringEqENS3_9allocatorINS3_4pairIKS7_S9_EEEEE11HashElementEJRSI_EEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSN_DpOSO_: 590| 14| apply(F&& f, Args&&... args) { 591| 14| return absl::container_internal::DecomposePair(std::forward(f), 592| 14| std::forward(args)...); 593| 14| } _ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE8transferINS3_9allocatorINS3_4pairIKS7_S9_EEEEEEDaPT_PNS1_13map_slot_typeIS7_S9_EESL_: 583| 14| slot_type* old_slot) { 584| 14| return slot_policy::transfer(alloc, new_slot, old_slot); 585| 14| } _ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE9constructINS3_9allocatorINS3_4pairIKS7_S9_EEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOSE_EEENSK_IJOS9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EEDpOT0_: 572| 16| static void construct(Allocator* alloc, slot_type* slot, Args&&... args) { 573| 16| slot_policy::construct(alloc, slot, std::forward(args)...); 574| 16| } _ZN4absl12lts_2024011613flat_hash_mapINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS0_15CommandLineFlagENS0_18container_internal10StringHashENS9_8StringEqENS2_9allocatorINS2_4pairIKS6_S8_EEEEEC2Ev: 159| 1| flat_hash_map() {} _ZN4absl12lts_2024011618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE7destroyINS4_9allocatorINS4_4pairIKS8_SA_EEEEEEvPT_PNS1_13map_slot_typeIS8_SA_EE: 49| 16| static void destroy(Alloc* alloc, slot_type* slot) { 50| 16| Policy::destroy(alloc, slot); 51| 16| } _ZN4absl12lts_2024011618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIS8_SA_EE: 75| 34| -> decltype(P::element(slot)) { 76| 34| return P::element(slot); 77| 34| } _ZN4absl12lts_2024011618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE8transferINS4_9allocatorINS4_4pairIKS8_SA_EEEEEEvPT_PNS1_13map_slot_typeIS8_SA_EESN_: 65| 14| static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) { 66| 14| transfer_impl(alloc, new_slot, old_slot, Rank0{}); 67| 14| } _ZN4absl12lts_2024011618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE13transfer_implINS4_9allocatorINS4_4pairIKS8_SA_EEEESB_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeIS8_SA_EESP_NSC_5Rank0E: 101| 14| -> decltype(P::transfer(alloc, new_slot, old_slot)) { 102| 14| return P::transfer(alloc, new_slot, old_slot); 103| 14| } _ZN4absl12lts_2024011618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE9constructINS4_9allocatorINS4_4pairIKS8_SA_EEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSM_IJOSA_EEEEEEvPT_PNS1_13map_slot_typeIS8_SA_EEDpOT0_: 42| 16| static void construct(Alloc* alloc, slot_type* slot, Args&&... args) { 43| 16| Policy::construct(alloc, slot, std::forward(args)...); 44| 16| } _ZNKR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EE3getEv: 91| 160| constexpr const T& get() const& { return value; } _ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EE3getEv: 92| 198| T& get() & { return value; } _ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EEC2IS4_EENSt3__110in_place_tEOT_: 90| 1| : value(absl::forward(v)) {} _ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ELb1EE3getEv: 106| 30| T& get() & { return *this; } _ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ELb1EE3getEv: 106| 4| T& get() & { return *this; } _ZNKR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv: 246| 160| constexpr const ElemT& get() const& { 247| 160| return StorageT::get(); 248| 160| } _ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv: 241| 52| ElemT& get() & { 242| 52| return StorageT::get(); 243| 52| } _ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS4_4pairIKNS4_17basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEELm3ELb1EE3getEv: 106| 52| T& get() & { return *this; } _ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv: 241| 198| ElemT& get() & { 242| 198| return StorageT::get(); 243| 198| } _ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi2EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv: 241| 4| ElemT& get() & { 242| 4| return StorageT::get(); 243| 4| } _ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv: 241| 30| ElemT& get() & { 242| 30| return StorageT::get(); 243| 30| } _ZN4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEEC2IS3_JS4_S5_SH_ETnNS6_9enable_ifIXsr4absl11conjunctionINS0_8negationINS6_7is_sameIFvSI_EFvNS6_5decayIT_E4typeEEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleISI_JSP_DpT0_EEEEE5valueEbE4typeELb1EEEOSP_DpOSX_: 236| 1| : CompressedTuple::CompressedTupleImpl(absl::in_place, 237| 1| absl::forward(first), 238| 1| absl::forward(base)...) {} _ZN4absl12lts_2024011618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS8_4pairIKNS8_17basic_string_viewIcNS8_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S6_S7_SJ_EEENS8_10in_place_tEDpOT_: 126| 4| : Storage(absl::in_place, absl::forward(args))... {} _ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ELb1EEC2IS4_EENSt3__110in_place_tEOT_: 103| 1| : T(absl::forward(v)) {} _ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ELb1EEC2IS4_EENSt3__110in_place_tEOT_: 103| 1| : T(absl::forward(v)) {} _ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS4_4pairIKNS4_17basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEELm3ELb1EEC2ISF_EENS4_10in_place_tEOT_: 103| 1| : T(absl::forward(v)) {} _ZN4absl12lts_2024011618container_internal27SanitizerPoisonMemoryRegionEPKvm: 220| 17|inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) { 221| |#ifdef ABSL_HAVE_ADDRESS_SANITIZER 222| | ASAN_POISON_MEMORY_REGION(m, s); 223| |#endif 224| |#ifdef ABSL_HAVE_MEMORY_SANITIZER 225| | __msan_poison(m, s); 226| |#endif 227| 17| (void)m; 228| 17| (void)s; 229| 17|} _ZN4absl12lts_2024011618container_internal29SanitizerUnpoisonMemoryRegionEPKvm: 231| 37|inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) { 232| |#ifdef ABSL_HAVE_ADDRESS_SANITIZER 233| | ASAN_UNPOISON_MEMORY_REGION(m, s); 234| |#endif 235| |#ifdef ABSL_HAVE_MEMORY_SANITIZER 236| | __msan_unpoison(m, s); 237| |#endif 238| 37| (void)m; 239| 37| (void)s; 240| 37|} _ZN4absl12lts_2024011618container_internal8AllocateILm8ENSt3__19allocatorIcEEEEPvPT0_m: 55| 5|void* Allocate(Alloc* alloc, size_t n) { 56| 5| static_assert(Alignment > 0, ""); 57| 5| assert(n && "n must be positive"); 58| 5| using M = AlignedType; 59| 5| using A = typename absl::allocator_traits::template rebind_alloc; 60| 5| using AT = typename absl::allocator_traits::template rebind_traits; 61| | // On macOS, "mem_alloc" is a #define with one argument defined in 62| | // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it 63| | // with the "foo(bar)" syntax. 64| 5| A my_mem_alloc(*alloc); 65| 5| void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M)); 66| | assert(reinterpret_cast(p) % Alignment == 0 && 67| 5| "allocator does not respect alignment"); 68| 5| return p; 69| 5|} _ZN4absl12lts_2024011618container_internal10DeallocateILm8ENSt3__19allocatorIcEEEEvPT0_Pvm: 74| 4|void Deallocate(Alloc* alloc, void* p, size_t n) { 75| 4| static_assert(Alignment > 0, ""); 76| 4| assert(n && "n must be positive"); 77| 4| using M = AlignedType; 78| 4| using A = typename absl::allocator_traits::template rebind_alloc; 79| 4| using AT = typename absl::allocator_traits::template rebind_traits; 80| | // On macOS, "mem_alloc" is a #define with one argument defined in 81| | // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it 82| | // with the "foo(bar)" syntax. 83| 4| A my_mem_alloc(*alloc); 84| 4| AT::deallocate(my_mem_alloc, static_cast(p), 85| 4| (n + sizeof(M) - 1) / sizeof(M)); 86| 4|} _ZN4absl12lts_2024011618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7destroyINS3_9allocatorINS3_4pairIKS7_S9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EE: 417| 16| static void destroy(Allocator* alloc, slot_type* slot) { 418| 16| if (kMutableKeys::value) { ------------------ | Branch (418:9): [True: 16, Folded] ------------------ 419| 16| absl::allocator_traits::destroy(*alloc, &slot->mutable_value); 420| 16| } else { 421| 0| absl::allocator_traits::destroy(*alloc, &slot->value); 422| 0| } 423| 16| } _ZN4absl12lts_2024011618container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS5_9allocatorINS5_4pairIKS9_SB_EEEEE12EqualElementIS9_EEJRSI_EEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSO_DpOSP_: 206| 4| std::forward(f), PairArgs(std::forward(args)...))) { 207| 4| return memory_internal::DecomposePairImpl( 208| 4| std::forward(f), PairArgs(std::forward(args)...)); 209| 4|} _ZN4absl12lts_2024011618container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS6_9allocatorINS6_4pairIKSA_SC_EEEEE12EqualElementISA_EERSI_NS6_5tupleIJRKSC_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSP_IJSU_EEEEEclsr3stdE7declvalIT1_EEEEOST_NSH_ISX_SY_EE: 138| 4|DecomposePairImpl(F&& f, std::pair, V> p) { 139| 4| const auto& key = std::get<0>(p.first); 140| 4| return std::forward(f)(key, std::piecewise_construct, std::move(p.first), 141| 4| std::move(p.second)); 142| 4|} _ZN4absl12lts_2024011618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE: 187| 18| const std::pair& p) { 188| 18| return PairArgs(p.first, p.second); 189| 18|} _ZN4absl12lts_2024011618container_internal8PairArgsIRKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERKPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_: 181| 18|std::pair, std::tuple> PairArgs(F&& f, S&& s) { 182| 18| return {std::piecewise_construct, std::forward_as_tuple(std::forward(f)), 183| 18| std::forward_as_tuple(std::forward(s))}; 184| 18|} _ZN4absl12lts_2024011618container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS5_9allocatorINS5_4pairIKS9_SB_EEEEE19EmplaceDecomposableEJSI_EEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSM_DpOSN_: 206| 16| std::forward(f), PairArgs(std::forward(args)...))) { 207| 16| return memory_internal::DecomposePairImpl( 208| 16| std::forward(f), PairArgs(std::forward(args)...)); 209| 16|} _ZN4absl12lts_2024011618container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS6_9allocatorINS6_4pairIKSA_SC_EEEEE19EmplaceDecomposableEOSI_NS6_5tupleIJOSC_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSO_IJSS_EEEEEclsr3stdE7declvalIT1_EEEEOSR_NSH_ISV_SW_EE: 138| 16|DecomposePairImpl(F&& f, std::pair, V> p) { 139| 16| const auto& key = std::get<0>(p.first); 140| 16| return std::forward(f)(key, std::piecewise_construct, std::move(p.first), 141| 16| std::move(p.second)); 142| 16|} _ZN4absl12lts_2024011618container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS5_9allocatorINS5_4pairIKS9_SB_EEEEE11HashElementEJRSI_EEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSN_DpOSO_: 206| 14| std::forward(f), PairArgs(std::forward(args)...))) { 207| 14| return memory_internal::DecomposePairImpl( 208| 14| std::forward(f), PairArgs(std::forward(args)...)); 209| 14|} _ZN4absl12lts_2024011618container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS6_9allocatorINS6_4pairIKSA_SC_EEEEE11HashElementERSI_NS6_5tupleIJRKSC_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSO_IJST_EEEEEclsr3stdE7declvalIT1_EEEEOSS_NSH_ISW_SX_EE: 138| 14|DecomposePairImpl(F&& f, std::pair, V> p) { 139| 14| const auto& key = std::get<0>(p.first); 140| 14| return std::forward(f)(key, std::piecewise_construct, std::move(p.first), 141| 14| std::move(p.second)); 142| 14|} _ZN4absl12lts_2024011618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE8transferINS3_9allocatorINS3_4pairIKS7_S9_EEEEEEDaPT_PNS1_13map_slot_typeIS7_S9_EESL_: 427| 14| slot_type* old_slot) { 428| 14| auto is_relocatable = 429| 14| typename absl::is_trivially_relocatable::type(); 430| | 431| 14| emplace(new_slot); 432| 14|#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 433| 14| if (is_relocatable) { ------------------ | Branch (433:9): [True: 14, Folded] ------------------ 434| | // TODO(b/247130232,b/251814870): remove casts after fixing warnings. 435| 14| std::memcpy(static_cast(std::launder(&new_slot->value)), 436| 14| static_cast(&old_slot->value), 437| 14| sizeof(value_type)); 438| 14| return is_relocatable; 439| 14| } 440| 0|#endif 441| | 442| 0| if (kMutableKeys::value) { ------------------ | Branch (442:9): [True: 0, Folded] ------------------ 443| 0| absl::allocator_traits::construct( 444| 0| *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value)); 445| 0| } else { 446| 0| absl::allocator_traits::construct(*alloc, &new_slot->value, 447| 0| std::move(old_slot->value)); 448| 0| } 449| 0| destroy(alloc, old_slot); 450| 0| return is_relocatable; 451| 14| } _ZN4absl12lts_2024011618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7emplaceEPNS1_13map_slot_typeIS7_S9_EE: 348| 30| static void emplace(slot_type* slot) { 349| | // The construction of union doesn't do anything at runtime but it allows us 350| | // to access its members without violating aliasing rules. 351| 30| new (slot) slot_type; 352| 30| } _ZN4absl12lts_2024011618container_internal13map_slot_typeINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEC2Ev: 329| 30| map_slot_type() {} _ZN4absl12lts_2024011618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE9constructINS3_9allocatorINS3_4pairIKS7_S9_EEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOSE_EEENSK_IJOS9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EEDpOT0_: 383| 16| static void construct(Allocator* alloc, slot_type* slot, Args&&... args) { 384| 16| emplace(slot); 385| 16| if (kMutableKeys::value) { ------------------ | Branch (385:9): [True: 16, Folded] ------------------ 386| 16| absl::allocator_traits::construct(*alloc, &slot->mutable_value, 387| 16| std::forward(args)...); 388| 16| } else { 389| 0| absl::allocator_traits::construct(*alloc, &slot->value, 390| 0| std::forward(args)...); 391| 0| } 392| 16| } _ZN4absl12lts_2024011618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSC_IJOT0_EEEEEONSB_ISD_SG_EE: 191| 16|std::pair, std::tuple> PairArgs(std::pair&& p) { 192| 16| return PairArgs(std::forward(p.first), std::forward(p.second)); 193| 16|} _ZN4absl12lts_2024011618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSC_IJOT0_EEEEESE_SH_: 181| 16|std::pair, std::tuple> PairArgs(F&& f, S&& s) { 182| 16| return {std::piecewise_construct, std::forward_as_tuple(std::forward(f)), 183| 16| std::forward_as_tuple(std::forward(s))}; 184| 16|} _ZNK4absl12lts_2024011618container_internal10StringHashclENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE: 77| 30| size_t operator()(absl::string_view v) const { 78| 30| return absl::Hash{}(v); 79| 30| } _ZNK4absl12lts_2024011618container_internal8StringEqclENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEES7_: 87| 4| bool operator()(absl::string_view lhs, absl::string_view rhs) const { 88| 4| return lhs == rhs; 89| 4| } _ZN4absl12lts_2024011618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE5applyINS1_12raw_hash_setISB_NS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE12EqualElementIS8_EEJRSK_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSR_DpOSS_: 133| 4| -> decltype(P::apply(std::forward(f), std::forward(ts)...)) { 134| 4| return P::apply(std::forward(f), std::forward(ts)...); 135| 4| } _ZN4absl12lts_2024011618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE5applyINS1_12raw_hash_setISB_NS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE19EmplaceDecomposableEJSK_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSP_DpOSQ_: 133| 16| -> decltype(P::apply(std::forward(f), std::forward(ts)...)) { 134| 16| return P::apply(std::forward(f), std::forward(ts)...); 135| 16| } _ZN4absl12lts_2024011618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE5applyINS1_12raw_hash_setISB_NS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE11HashElementEJRSK_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSQ_DpOSR_: 133| 14| -> decltype(P::apply(std::forward(f), std::forward(ts)...)) { 134| 14| return P::apply(std::forward(f), std::forward(ts)...); 135| 14| } _ZN4absl12lts_2024011618container_internal20HashtablezInfoHandleC2EDn: 187| 1| explicit HashtablezInfoHandle(std::nullptr_t) {} _ZNK4absl12lts_2024011618container_internal20HashtablezInfoHandle9IsSampledEv: 190| 5| inline bool IsSampled() const { return false; } _ZN4absl12lts_2024011618container_internal20HashtablezInfoHandle20RecordStorageChangedEmm: 191| 1| inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {} _ZN4absl12lts_2024011618container_internal20HashtablezInfoHandle12RecordRehashEm: 192| 1| inline void RecordRehash(size_t /*total_probe_length*/) {} _ZN4absl12lts_2024011618container_internal20HashtablezInfoHandle12RecordInsertEmm: 195| 16| inline void RecordInsert(size_t /*hash*/, size_t /*distance_from_desired*/) {} _ZN4absl12lts_2024011618container_internal6SampleEm: 210| 1| size_t inline_element_size ABSL_ATTRIBUTE_UNUSED) { 211| |#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE) 212| | if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0)) { 213| | return HashtablezInfoHandle(nullptr); 214| | } 215| | return HashtablezInfoHandle( 216| | SampleSlow(global_next_sample, inline_element_size)); 217| |#else 218| 1| return HashtablezInfoHandle(nullptr); 219| 1|#endif // !ABSL_PER_THREAD_TLS 220| 1|} _ZN4absl12lts_2024011618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEEC2Ev: 64| 1| raw_hash_map() {} _ZN4absl12lts_2024011618container_internal17ClearBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEb: 256| 1| bool reuse) { 257| 1| c.set_size(0); 258| 1| if (reuse) { ------------------ | Branch (258:7): [True: 1, False: 0] ------------------ 259| 1| ResetCtrl(c, policy.slot_size); 260| 1| ResetGrowthLeft(c); 261| 1| c.infoz().RecordStorageChanged(0, c.capacity()); 262| 1| } else { 263| | // We need to record infoz before calling dealloc, which will unregister 264| | // infoz. 265| 0| c.infoz().RecordClearedReservation(); 266| 0| c.infoz().RecordStorageChanged(0, 0); 267| 0| (*policy.dealloc)(c, policy); 268| 0| c.set_control(EmptyGroup()); 269| 0| c.set_generation_ptr(EmptyGeneration()); 270| 0| c.set_slots(nullptr); 271| 0| c.set_capacity(0); 272| 0| } 273| 1|} _ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper38GrowIntoSingleGroupShuffleControlBytesEPNS1_6ctrl_tEm: 276| 3| ctrl_t* new_ctrl, size_t new_capacity) const { 277| 3| assert(is_single_group(new_capacity)); 278| 3| constexpr size_t kHalfWidth = Group::kWidth / 2; 279| 3| assert(old_capacity_ < kHalfWidth); 280| | 281| 3| const size_t half_old_capacity = old_capacity_ / 2; 282| | 283| | // NOTE: operations are done with compile time known size = kHalfWidth. 284| | // Compiler optimizes that into single ASM operation. 285| | 286| | // Copy second half of bytes to the beginning. 287| | // We potentially copy more bytes in order to have compile time known size. 288| | // Mirrored bytes from the old_ctrl_ will also be copied. 289| | // In case of old_capacity_ == 3, we will copy 1st element twice. 290| | // Examples: 291| | // old_ctrl = 0S0EEEEEEE... 292| | // new_ctrl = S0EEEEEEEE... 293| | // 294| | // old_ctrl = 01S01EEEEE... 295| | // new_ctrl = 1S01EEEEEE... 296| | // 297| | // old_ctrl = 0123456S0123456EE... 298| | // new_ctrl = 456S0123?????????... 299| 3| std::memcpy(new_ctrl, old_ctrl_ + half_old_capacity + 1, kHalfWidth); 300| | // Clean up copied kSentinel from old_ctrl. 301| 3| new_ctrl[half_old_capacity] = ctrl_t::kEmpty; 302| | 303| | // Clean up damaged or uninitialized bytes. 304| | 305| | // Clean bytes after the intended size of the copy. 306| | // Example: 307| | // new_ctrl = 1E01EEEEEEE???? 308| | // *new_ctrl= 1E0EEEEEEEE???? 309| | // position / 310| 3| std::memset(new_ctrl + old_capacity_ + 1, static_cast(ctrl_t::kEmpty), 311| 3| kHalfWidth); 312| | // Clean non-mirrored bytes that are not initialized. 313| | // For small old_capacity that may be inside of mirrored bytes zone. 314| | // Examples: 315| | // new_ctrl = 1E0EEEEEEEE??????????.... 316| | // *new_ctrl= 1E0EEEEEEEEEEEEE?????.... 317| | // position / 318| | // 319| | // new_ctrl = 456E0123???????????... 320| | // *new_ctrl= 456E0123EEEEEEEE???... 321| | // position / 322| 3| std::memset(new_ctrl + kHalfWidth, static_cast(ctrl_t::kEmpty), 323| 3| kHalfWidth); 324| | // Clean last mirrored bytes that are not initialized 325| | // and will not be overwritten by mirroring. 326| | // Examples: 327| | // new_ctrl = 1E0EEEEEEEEEEEEE???????? 328| | // *new_ctrl= 1E0EEEEEEEEEEEEEEEEEEEEE 329| | // position S / 330| | // 331| | // new_ctrl = 456E0123EEEEEEEE??????????????? 332| | // *new_ctrl= 456E0123EEEEEEEE???????EEEEEEEE 333| | // position S / 334| 3| std::memset(new_ctrl + new_capacity + kHalfWidth, 335| 3| static_cast(ctrl_t::kEmpty), kHalfWidth); 336| | 337| | // Create mirrored bytes. old_capacity_ < kHalfWidth 338| | // Example: 339| | // new_ctrl = 456E0123EEEEEEEE???????EEEEEEEE 340| | // *new_ctrl= 456E0123EEEEEEEE456E0123EEEEEEE 341| | // position S/ 342| 3| ctrl_t g[kHalfWidth]; 343| 3| std::memcpy(g, new_ctrl, kHalfWidth); 344| 3| std::memcpy(new_ctrl + new_capacity + 1, g, kHalfWidth); 345| | 346| | // Finally set sentinel to its place. 347| 3| new_ctrl[new_capacity] = ctrl_t::kSentinel; 348| 3|} _ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper43GrowIntoSingleGroupShuffleTransferableSlotsEPvS3_m: 351| 3| void* old_slots, void* new_slots, size_t slot_size) const { 352| 3| assert(old_capacity_ > 0); 353| 3| const size_t half_old_capacity = old_capacity_ / 2; 354| | 355| 3| SanitizerUnpoisonMemoryRegion(old_slots, slot_size * old_capacity_); 356| 3| std::memcpy(new_slots, 357| 3| SlotAddress(old_slots, half_old_capacity + 1, slot_size), 358| 3| slot_size * half_old_capacity); 359| 3| std::memcpy(SlotAddress(new_slots, half_old_capacity + 1, slot_size), 360| 3| old_slots, slot_size * (half_old_capacity + 1)); 361| 3|} _ZN4absl12lts_2024011618container_internal19HashSetResizeHelper35GrowSizeIntoSingleGroupTransferableERNS1_12CommonFieldsEPvm: 364| 3| CommonFields& c, void* old_slots, size_t slot_size) { 365| 3| assert(old_capacity_ < Group::kWidth / 2); 366| 3| assert(is_single_group(c.capacity())); 367| 3| assert(IsGrowingIntoSingleGroupApplicable(old_capacity_, c.capacity())); 368| | 369| 3| GrowIntoSingleGroupShuffleControlBytes(c.control(), c.capacity()); 370| 3| GrowIntoSingleGroupShuffleTransferableSlots(old_slots, c.slot_array(), 371| 3| slot_size); 372| | 373| | // We poison since GrowIntoSingleGroupShuffleTransferableSlots 374| | // may leave empty slots unpoisoned. 375| 3| PoisonSingleGroupEmptySlots(c, slot_size); 376| 3|} _ZN4absl12lts_2024011618container_internal13GroupSse2ImplC2EPKNS1_6ctrl_tE: 615| 55| explicit GroupSse2Impl(const ctrl_t* pos) { 616| 55| ctrl = _mm_loadu_si128(reinterpret_cast(pos)); 617| 55| } _ZNK4absl12lts_2024011618container_internal13GroupSse2Impl5MatchEh: 620| 16| BitMask Match(h2_t hash) const { 621| 16| auto match = _mm_set1_epi8(static_cast(hash)); 622| 16| BitMask result = BitMask(0); 623| 16| result = BitMask( 624| 16| static_cast(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl)))); 625| 16| return result; 626| 16| } _ZNK4absl12lts_2024011618container_internal13GroupSse2Impl9MaskEmptyEv: 629| 16| NonIterableBitMask MaskEmpty() const { 630| |#ifdef ABSL_INTERNAL_HAVE_SSSE3 631| | // This only works because ctrl_t::kEmpty is -128. 632| | return NonIterableBitMask( 633| | static_cast(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl)))); 634| |#else 635| 16| auto match = _mm_set1_epi8(static_cast(ctrl_t::kEmpty)); 636| 16| return NonIterableBitMask( 637| 16| static_cast(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl)))); 638| 16|#endif 639| 16| } _ZNK4absl12lts_2024011618container_internal13GroupSse2Impl18MaskEmptyOrDeletedEv: 650| 31| NonIterableBitMask MaskEmptyOrDeleted() const { 651| 31| auto special = _mm_set1_epi8(static_cast(ctrl_t::kSentinel)); 652| 31| return NonIterableBitMask(static_cast( 653| 31| _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)))); 654| 31| } _ZNK4absl12lts_2024011618container_internal13GroupSse2Impl26CountLeadingEmptyOrDeletedEv: 657| 8| uint32_t CountLeadingEmptyOrDeleted() const { 658| 8| auto special = _mm_set1_epi8(static_cast(ctrl_t::kSentinel)); 659| 8| return TrailingZeros(static_cast( 660| 8| _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1)); 661| 8| } _ZNK4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled41should_rehash_for_bug_detection_on_insertEPKNS1_6ctrl_tEm: 926| 16| bool should_rehash_for_bug_detection_on_insert(const ctrl_t*, size_t) const { 927| 16| return false; 928| 16| } _ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled36maybe_increment_generation_on_insertEv: 932| 16| void maybe_increment_generation_on_insert() {} _ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled19set_reserved_growthEm: 936| 1| void set_reserved_growth(size_t) {} _ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled20set_reservation_sizeEm: 938| 1| void set_reservation_size(size_t) {} _ZNK4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled10generationEv: 939| 5| GenerationType generation() const { return 0; } _ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled14set_generationEh: 940| 5| void set_generation(GenerationType) {} _ZNK4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled14generation_ptrEv: 941| 18| GenerationType* generation_ptr() const { return nullptr; } _ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled18set_generation_ptrEPh: 942| 5| void set_generation_ptr(GenerationType*) {} _ZN4absl12lts_2024011618container_internal37HashSetIteratorGenerationInfoDisabledC2EPKh: 965| 18| explicit HashSetIteratorGenerationInfoDisabled(const GenerationType*) {} _ZNK4absl12lts_2024011618container_internal37HashSetIteratorGenerationInfoDisabled10generationEv: 967| 66| GenerationType generation() const { return 0; } _ZNK4absl12lts_2024011618container_internal37HashSetIteratorGenerationInfoDisabled14generation_ptrEv: 969| 100| const GenerationType* generation_ptr() const { return nullptr; } _ZNK4absl12lts_2024011618container_internal12CommonFields7controlEv: 1038| 289| ctrl_t* control() const { return control_; } _ZN4absl12lts_2024011618container_internal12CommonFields11set_controlEPNS1_6ctrl_tE: 1039| 5| void set_control(ctrl_t* c) { control_ = c; } _ZNK4absl12lts_2024011618container_internal12CommonFields10slot_arrayEv: 1047| 99| void* slot_array() const { return slots_; } _ZN4absl12lts_2024011618container_internal12CommonFields9set_slotsEPv: 1048| 5| void set_slots(void* s) { slots_ = s; } _ZNK4absl12lts_2024011618container_internal12CommonFields4sizeEv: 1051| 12| size_t size() const { return size_ >> HasInfozShift(); } _ZN4absl12lts_2024011618container_internal12CommonFields8set_sizeEm: 1052| 1| void set_size(size_t s) { 1053| 1| size_ = (s << HasInfozShift()) | (size_ & HasInfozMask()); 1054| 1| } _ZN4absl12lts_2024011618container_internal12CommonFields14increment_sizeEv: 1055| 16| void increment_size() { 1056| | assert(size() < capacity()); 1057| 16| size_ += size_t{1} << HasInfozShift(); 1058| 16| } _ZNK4absl12lts_2024011618container_internal12CommonFields8capacityEv: 1065| 170| size_t capacity() const { return capacity_; } _ZN4absl12lts_2024011618container_internal12CommonFields12set_capacityEm: 1066| 5| void set_capacity(size_t c) { 1067| | assert(c == 0 || IsValidCapacity(c)); 1068| 5| capacity_ = c; 1069| 5| } _ZNK4absl12lts_2024011618container_internal12CommonFields11growth_leftEv: 1073| 32| size_t growth_left() const { 1074| 32| const size_t* gl_ptr = reinterpret_cast(control()) - 1; 1075| | assert(reinterpret_cast(gl_ptr) % alignof(size_t) == 0); 1076| 32| return *gl_ptr; 1077| 32| } _ZN4absl12lts_2024011618container_internal12CommonFields15set_growth_leftEm: 1078| 22| void set_growth_left(size_t gl) { 1079| 22| size_t* gl_ptr = reinterpret_cast(control()) - 1; 1080| | assert(reinterpret_cast(gl_ptr) % alignof(size_t) == 0); 1081| 22| *gl_ptr = gl; 1082| 22| } _ZNK4absl12lts_2024011618container_internal12CommonFields9has_infozEv: 1084| 27| bool has_infoz() const { 1085| 27| return ABSL_PREDICT_FALSE((size_ & HasInfozMask()) != 0); ------------------ | | 178| 27|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:49): [Folded, False: 27] | | | Branch (178:58): [True: 0, False: 27] | | ------------------ ------------------ 1086| 27| } _ZN4absl12lts_2024011618container_internal12CommonFields13set_has_infozEb: 1087| 5| void set_has_infoz(bool has_infoz) { 1088| 5| size_ = (size() << HasInfozShift()) | static_cast(has_infoz); 1089| 5| } _ZN4absl12lts_2024011618container_internal12CommonFields5infozEv: 1091| 22| HashtablezInfoHandle infoz() { 1092| 22| return has_infoz() ------------------ | Branch (1092:12): [True: 0, False: 22] ------------------ 1093| 22| ? *reinterpret_cast(backing_array_start()) 1094| 22| : HashtablezInfoHandle(); 1095| 22| } _ZNK4absl12lts_2024011618container_internal12CommonFields41should_rehash_for_bug_detection_on_insertEv: 1101| 16| bool should_rehash_for_bug_detection_on_insert() const { 1102| 16| return CommonFieldsGenerationInfo:: 1103| 16| should_rehash_for_bug_detection_on_insert(control(), capacity()); 1104| 16| } _ZN4absl12lts_2024011618container_internal12CommonFields13HasInfozShiftEv: 1130| 62| static constexpr size_t HasInfozShift() { return 1; } _ZN4absl12lts_2024011618container_internal12CommonFields12HasInfozMaskEv: 1131| 28| static constexpr size_t HasInfozMask() { 1132| 28| return (size_t{1} << HasInfozShift()) - 1; 1133| 28| } _ZN4absl12lts_2024011618container_internal19HashSetResizeHelperC2ERNS1_12CommonFieldsE: 1525| 5| : old_ctrl_(c.control()), 1526| 5| old_capacity_(c.capacity()), 1527| 5| had_infoz_(c.has_infoz()) {} _ZN4absl12lts_2024011618container_internal19HashSetResizeHelper27FindFirstNonFullAfterResizeERKNS1_12CommonFieldsEmm: 1537| 5| size_t hash) { 1538| 5| if (!IsGrowingIntoSingleGroupApplicable(old_capacity, c.capacity())) { ------------------ | Branch (1538:9): [True: 1, False: 4] ------------------ 1539| 1| return find_first_non_full(c, hash); 1540| 1| } 1541| | // Find a location for the new element non-deterministically. 1542| | // Note that any position is correct. 1543| | // It will located at `half_old_capacity` or one of the other 1544| | // empty slots with approximately 50% probability each. 1545| 4| size_t offset = probe(c, hash).offset(); 1546| | 1547| | // Note that we intentionally use unsigned int underflow. 1548| 4| if (offset - (old_capacity + 1) >= old_capacity) { ------------------ | Branch (1548:9): [True: 3, False: 1] ------------------ 1549| | // Offset fall on kSentinel or into the mostly occupied first half. 1550| 3| offset = old_capacity / 2; 1551| 3| } 1552| | assert(IsEmpty(c.control()[offset])); 1553| 4| return FindInfo{offset, 0}; 1554| 5| } _ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper8old_ctrlEv: 1556| 15| ctrl_t* old_ctrl() const { return old_ctrl_; } _ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper12old_capacityEv: 1557| 21| size_t old_capacity() const { return old_capacity_; } _ZN4absl12lts_2024011618container_internal19HashSetResizeHelper34IsGrowingIntoSingleGroupApplicableEmm: 1686| 10| size_t new_capacity) { 1687| | // NOTE that `old_capacity < new_capacity` in order to have 1688| | // `old_capacity < Group::kWidth / 2` to make faster copies of 8 bytes. 1689| 10| return is_single_group(new_capacity) && old_capacity < new_capacity; ------------------ | Branch (1689:12): [True: 8, False: 2] | Branch (1689:45): [True: 8, False: 0] ------------------ 1690| 10| } _ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper27PoisonSingleGroupEmptySlotsERNS1_12CommonFieldsEm: 1753| 3| void PoisonSingleGroupEmptySlots(CommonFields& c, size_t slot_size) const { 1754| | // poison non full items 1755| 28| for (size_t i = 0; i < c.capacity(); ++i) { ------------------ | Branch (1755:24): [True: 25, False: 3] ------------------ 1756| 25| if (!IsFull(c.control()[i])) { ------------------ | Branch (1756:11): [True: 14, False: 11] ------------------ 1757| 14| SanitizerPoisonMemoryRegion(SlotAddress(c.slot_array(), i, slot_size), 1758| 14| slot_size); 1759| 14| } 1760| 25| } 1761| 3| } _ZN4absl12lts_2024011618container_internal23SentinelEmptyGenerationEv: 252| 5|constexpr GenerationType SentinelEmptyGeneration() { return 0; } _ZN4absl12lts_2024011618container_internal14NextGenerationEh: 254| 5|constexpr GenerationType NextGeneration(GenerationType generation) { 255| 5| return ++generation == SentinelEmptyGeneration() ? ++generation : generation; ------------------ | Branch (255:10): [True: 0, False: 5] ------------------ 256| 5|} _ZN4absl12lts_2024011618container_internal18NumGenerationBytesEv: 263| 14|constexpr size_t NumGenerationBytes() { return 0; } _ZN4absl12lts_2024011618container_internal10EmptyGroupEv: 521| 1|inline ctrl_t* EmptyGroup() { 522| | // Const must be cast away here; no uses of this function will actually write 523| | // to it, because it is only used for empty tables. 524| 1| return const_cast(kEmptyGroup + 16); 525| 1|} _ZN4absl12lts_2024011618container_internal12PerTableSaltEPKNS1_6ctrl_tE: 545| 51|inline size_t PerTableSalt(const ctrl_t* ctrl) { 546| | // The low bits of the pointer have little or no entropy because of 547| | // alignment. We shift the pointer to try to use higher entropy bits. A 548| | // good number seems to be 12 bits, because that aligns with page size. 549| 51| return reinterpret_cast(ctrl) >> 12; 550| 51|} _ZN4absl12lts_2024011618container_internal2H1EmPKNS1_6ctrl_tE: 552| 51|inline size_t H1(size_t hash, const ctrl_t* ctrl) { 553| 51| return (hash >> 7) ^ PerTableSalt(ctrl); 554| 51|} _ZN4absl12lts_2024011618container_internal2H2Em: 559| 46|inline h2_t H2(size_t hash) { return hash & 0x7F; } _ZN4absl12lts_2024011618container_internal7IsEmptyENS1_6ctrl_tE: 562| 16|inline bool IsEmpty(ctrl_t c) { return c == ctrl_t::kEmpty; } _ZN4absl12lts_2024011618container_internal6IsFullENS1_6ctrl_tE: 563| 101|inline bool IsFull(ctrl_t c) { return c >= static_cast(0); } _ZN4absl12lts_2024011618container_internal9IsDeletedENS1_6ctrl_tE: 564| 5|inline bool IsDeleted(ctrl_t c) { return c == ctrl_t::kDeleted; } _ZN4absl12lts_2024011618container_internal16IsEmptyOrDeletedENS1_6ctrl_tE: 565| 25|inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; } _ZN4absl12lts_2024011618container_internal20_mm_cmpgt_epi8_fixedEDv2_xS2_: 601| 39|inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) { 602| |#if defined(__GNUC__) && !defined(__clang__) 603| | if (std::is_unsigned::value) { 604| | const __m128i mask = _mm_set1_epi8(0x80); 605| | const __m128i diff = _mm_subs_epi8(b, a); 606| | return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask); 607| | } 608| |#endif 609| 39| return _mm_cmpgt_epi8(a, b); 610| 39|} _ZN4absl12lts_2024011618container_internal13ControlOffsetEb: 988| 28|inline size_t ControlOffset(bool has_infoz) { 989| 28| return (has_infoz ? sizeof(HashtablezInfoHandle) : 0) + sizeof(size_t); ------------------ | Branch (989:11): [True: 0, False: 28] ------------------ 990| 28|} _ZN4absl12lts_2024011618container_internal14NumClonedBytesEv: 997| 82|constexpr size_t NumClonedBytes() { return Group::kWidth - 1; } _ZN4absl12lts_2024011618container_internal16GenerationOffsetEmb: 1001| 19|inline size_t GenerationOffset(size_t capacity, bool has_infoz) { 1002| | assert(IsValidCapacity(capacity)); 1003| 19| const size_t num_control_bytes = capacity + 1 + NumClonedBytes(); 1004| 19| return ControlOffset(has_infoz) + num_control_bytes; 1005| 19|} _ZN4absl12lts_2024011618container_internal10SlotOffsetEmmb: 1009| 14|inline size_t SlotOffset(size_t capacity, size_t slot_align, bool has_infoz) { 1010| | assert(IsValidCapacity(capacity)); 1011| 14| return (GenerationOffset(capacity, has_infoz) + NumGenerationBytes() + 1012| 14| slot_align - 1) & 1013| 14| (~slot_align + 1); 1014| 14|} _ZN4absl12lts_2024011618container_internal9AllocSizeEmmmb: 1019| 9| bool has_infoz) { 1020| 9| return SlotOffset(capacity, slot_align, has_infoz) + capacity * slot_size; 1021| 9|} _ZN4absl12lts_2024011618container_internal12NextCapacityEm: 1167| 5|inline size_t NextCapacity(size_t n) { 1168| | assert(IsValidCapacity(n) || n == 0); 1169| 5| return n * 2 + 1; 1170| 5|} _ZN4absl12lts_2024011618container_internal16CapacityToGrowthEm: 1197| 6|inline size_t CapacityToGrowth(size_t capacity) { 1198| 6| assert(IsValidCapacity(capacity)); 1199| | // `capacity*7/8` 1200| 6| if (Group::kWidth == 8 && capacity == 7) { ------------------ | Branch (1200:7): [Folded, False: 6] | Branch (1200:29): [True: 0, False: 0] ------------------ 1201| | // x-x/8 does not work when x==7. 1202| 0| return 6; 1203| 0| } 1204| 6| return capacity - capacity / 8; 1205| 6|} _ZN4absl12lts_2024011618container_internal12AssertIsFullEPKNS1_6ctrl_tEhPKhPKc: 1248| 32| const char* operation) { 1249| 32| if (!SwisstableDebugEnabled()) return; ------------------ | Branch (1249:7): [True: 32, Folded] ------------------ 1250| | // `SwisstableDebugEnabled()` is also true for release builds with hardening 1251| | // enabled. To minimize their impact in those builds: 1252| | // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout 1253| | // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve 1254| | // the chances that the hot paths will be inlined. 1255| 0| if (ABSL_PREDICT_FALSE(ctrl == nullptr)) { ------------------ | | 178| 0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 0] | | | Branch (178:49): [Folded, False: 0] | | | Branch (178:58): [True: 0, False: 0] | | ------------------ ------------------ 1256| 0| ABSL_RAW_LOG(FATAL, "%s called on end() iterator.", operation); ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1257| 0| } 1258| 0| if (ABSL_PREDICT_FALSE(ctrl == EmptyGroup())) { ------------------ | | 178| 0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 0] | | | Branch (178:49): [Folded, False: 0] | | | Branch (178:58): [True: 0, False: 0] | | ------------------ ------------------ 1259| 0| ABSL_RAW_LOG(FATAL, "%s called on default-constructed iterator.", ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1260| 0| operation); 1261| 0| } 1262| 0| if (SwisstableGenerationsEnabled()) { ------------------ | Branch (1262:7): [Folded, False: 0] ------------------ 1263| 0| if (ABSL_PREDICT_FALSE(generation != *generation_ptr)) { ------------------ | | 178| 0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 0] | | | Branch (178:49): [Folded, False: 0] | | | Branch (178:58): [True: 0, False: 0] | | ------------------ ------------------ 1264| 0| ABSL_RAW_LOG(FATAL, ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1265| 0| "%s called on invalid iterator. The table could have " 1266| 0| "rehashed or moved since this iterator was initialized.", 1267| 0| operation); 1268| 0| } 1269| 0| if (ABSL_PREDICT_FALSE(!IsFull(*ctrl))) { ------------------ | | 178| 0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 0] | | | Branch (178:49): [Folded, False: 0] | | | Branch (178:58): [True: 0, False: 0] | | ------------------ ------------------ 1270| 0| ABSL_RAW_LOG( ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1271| 0| FATAL, 1272| 0| "%s called on invalid iterator. The element was likely erased.", 1273| 0| operation); 1274| 0| } 1275| 0| } else { 1276| 0| if (ABSL_PREDICT_FALSE(!IsFull(*ctrl))) { ------------------ | | 178| 0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 0] | | | Branch (178:49): [Folded, False: 0] | | | Branch (178:58): [True: 0, False: 0] | | ------------------ ------------------ 1277| | ABSL_RAW_LOG( ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1278| 0| FATAL, 1279| 0| "%s called on invalid iterator. The element might have been erased " 1280| 0| "or the table might have rehashed. Consider running with " 1281| 0| "--config=asan to diagnose rehashing issues.", 1282| 0| operation); 1283| 0| } 1284| 0| } 1285| 0|} _ZN4absl12lts_2024011618container_internal26AssertIsValidForComparisonEPKNS1_6ctrl_tEhPKh: 1290| 34| const GenerationType* generation_ptr) { 1291| 34| if (!SwisstableDebugEnabled()) return; ------------------ | Branch (1291:7): [True: 34, Folded] ------------------ 1292| 0| const bool ctrl_is_valid_for_comparison = 1293| 0| ctrl == nullptr || ctrl == EmptyGroup() || IsFull(*ctrl); ------------------ | Branch (1293:7): [True: 0, False: 0] | Branch (1293:26): [True: 0, False: 0] | Branch (1293:50): [True: 0, False: 0] ------------------ 1294| 0| if (SwisstableGenerationsEnabled()) { ------------------ | Branch (1294:7): [Folded, False: 0] ------------------ 1295| 0| if (ABSL_PREDICT_FALSE(generation != *generation_ptr)) { ------------------ | | 178| 0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 0] | | | Branch (178:49): [Folded, False: 0] | | | Branch (178:58): [True: 0, False: 0] | | ------------------ ------------------ 1296| 0| ABSL_RAW_LOG(FATAL, ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1297| 0| "Invalid iterator comparison. The table could have rehashed " 1298| 0| "or moved since this iterator was initialized."); 1299| 0| } 1300| 0| if (ABSL_PREDICT_FALSE(!ctrl_is_valid_for_comparison)) { ------------------ | | 178| 0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 0] | | | Branch (178:49): [Folded, False: 0] | | | Branch (178:58): [True: 0, False: 0] | | ------------------ ------------------ 1301| 0| ABSL_RAW_LOG( ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1302| 0| FATAL, "Invalid iterator comparison. The element was likely erased."); 1303| 0| } 1304| 0| } else { 1305| 0| ABSL_HARDENING_ASSERT( ------------------ | | 128| 0|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr) | | ------------------ | | | | 95| 0| (false ? static_cast(expr) : static_cast(0)) | | | | ------------------ | | | | | Branch (95:4): [Folded, False: 0] | | | | | Branch (95:30): [True: 0, False: 0] | | | | | Branch (95:30): [True: 0, Folded] | | | | ------------------ | | ------------------ ------------------ 1306| 0| ctrl_is_valid_for_comparison && 1307| 0| "Invalid iterator comparison. The element might have been erased or " 1308| 0| "the table might have rehashed. Consider running with --config=asan to " 1309| 0| "diagnose rehashing issues."); 1310| 0| } 1311| 0|} _ZN4absl12lts_2024011618container_internal19AssertSameContainerEPKNS1_6ctrl_tES4_RKPKvS8_PKhSA_: 1339| 17| const GenerationType* generation_ptr_b) { 1340| 17| if (!SwisstableDebugEnabled()) return; ------------------ | Branch (1340:7): [True: 17, Folded] ------------------ 1341| | // `SwisstableDebugEnabled()` is also true for release builds with hardening 1342| | // enabled. To minimize their impact in those builds: 1343| | // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout 1344| | // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve 1345| | // the chances that the hot paths will be inlined. 1346| 0| const bool a_is_default = ctrl_a == EmptyGroup(); 1347| 0| const bool b_is_default = ctrl_b == EmptyGroup(); 1348| 0| if (ABSL_PREDICT_FALSE(a_is_default != b_is_default)) { ------------------ | | 178| 0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 0] | | | Branch (178:49): [Folded, False: 0] | | | Branch (178:58): [True: 0, False: 0] | | ------------------ ------------------ 1349| 0| ABSL_RAW_LOG( ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1350| 0| FATAL, 1351| 0| "Invalid iterator comparison. Comparing default-constructed iterator " 1352| 0| "with non-default-constructed iterator."); 1353| 0| } 1354| 0| if (a_is_default && b_is_default) return; ------------------ | Branch (1354:7): [True: 0, False: 0] | Branch (1354:23): [True: 0, False: 0] ------------------ 1355| | 1356| 0| if (SwisstableGenerationsEnabled()) { ------------------ | Branch (1356:7): [Folded, False: 0] ------------------ 1357| 0| if (ABSL_PREDICT_TRUE(generation_ptr_a == generation_ptr_b)) return; ------------------ | | 179| 0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true)) | | ------------------ | | | Branch (179:30): [True: 0, False: 0] | | | Branch (179:48): [Folded, False: 0] | | | Branch (179:57): [True: 0, False: 0] | | ------------------ ------------------ 1358| 0| const bool a_is_empty = IsEmptyGeneration(generation_ptr_a); 1359| 0| const bool b_is_empty = IsEmptyGeneration(generation_ptr_b); 1360| 0| if (a_is_empty != b_is_empty) { ------------------ | Branch (1360:9): [True: 0, False: 0] ------------------ 1361| 0| ABSL_RAW_LOG(FATAL, ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1362| 0| "Invalid iterator comparison. Comparing iterator from a " 1363| 0| "non-empty hashtable with an iterator from an empty " 1364| 0| "hashtable."); 1365| 0| } 1366| 0| if (a_is_empty && b_is_empty) { ------------------ | Branch (1366:9): [True: 0, False: 0] | Branch (1366:23): [True: 0, False: 0] ------------------ 1367| 0| ABSL_RAW_LOG(FATAL, ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1368| 0| "Invalid iterator comparison. Comparing iterators from " 1369| 0| "different empty hashtables."); 1370| 0| } 1371| 0| const bool a_is_end = ctrl_a == nullptr; 1372| 0| const bool b_is_end = ctrl_b == nullptr; 1373| 0| if (a_is_end || b_is_end) { ------------------ | Branch (1373:9): [True: 0, False: 0] | Branch (1373:21): [True: 0, False: 0] ------------------ 1374| 0| ABSL_RAW_LOG(FATAL, ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1375| 0| "Invalid iterator comparison. Comparing iterator with an " 1376| 0| "end() iterator from a different hashtable."); 1377| 0| } 1378| 0| ABSL_RAW_LOG(FATAL, ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1379| 0| "Invalid iterator comparison. Comparing non-end() iterators " 1380| 0| "from different hashtables."); 1381| 0| } else { 1382| 0| ABSL_HARDENING_ASSERT( ------------------ | | 128| 0|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr) | | ------------------ | | | | 95| 0| (false ? static_cast(expr) : static_cast(0)) | | | | ------------------ | | | | | Branch (95:4): [Folded, False: 0] | | | | | Branch (95:30): [True: 0, False: 0] | | | | | Branch (95:30): [True: 0, Folded] | | | | ------------------ | | ------------------ ------------------ 1383| 0| AreItersFromSameContainer(ctrl_a, ctrl_b, slot_a, slot_b) && 1384| 0| "Invalid iterator comparison. The iterators may be from different " 1385| 0| "containers or the container might have rehashed or moved. Consider " 1386| 0| "running with --config=asan to diagnose issues."); 1387| 0| } 1388| 0|} _ZN4absl12lts_2024011618container_internal15is_single_groupEm: 1411| 10|inline bool is_single_group(size_t capacity) { 1412| 10| return capacity <= Group::kWidth; 1413| 10|} _ZN4absl12lts_2024011618container_internal5probeEPKNS1_6ctrl_tEmm: 1417| 51| size_t hash) { 1418| 51| return probe_seq(H1(hash, ctrl), capacity); 1419| 51|} _ZN4absl12lts_2024011618container_internal5probeERKNS1_12CommonFieldsEm: 1420| 51|inline probe_seq probe(const CommonFields& common, size_t hash) { 1421| 51| return probe(common.control(), common.capacity(), hash); 1422| 51|} _ZN4absl12lts_2024011618container_internal15ResetGrowthLeftERNS1_12CommonFieldsE: 1464| 6|inline void ResetGrowthLeft(CommonFields& common) { 1465| 6| common.set_growth_left(CapacityToGrowth(common.capacity()) - common.size()); 1466| 6|} _ZN4absl12lts_2024011618container_internal9ResetCtrlERNS1_12CommonFieldsEm: 1470| 3|inline void ResetCtrl(CommonFields& common, size_t slot_size) { 1471| 3| const size_t capacity = common.capacity(); 1472| 3| ctrl_t* ctrl = common.control(); 1473| 3| std::memset(ctrl, static_cast(ctrl_t::kEmpty), 1474| 3| capacity + 1 + NumClonedBytes()); 1475| 3| ctrl[capacity] = ctrl_t::kSentinel; 1476| 3| SanitizerPoisonMemoryRegion(common.slot_array(), slot_size * capacity); 1477| 3|} _ZN4absl12lts_2024011618container_internal7SetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm: 1484| 30| size_t slot_size) { 1485| 30| const size_t capacity = common.capacity(); 1486| 30| assert(i < capacity); 1487| | 1488| 30| auto* slot_i = static_cast(common.slot_array()) + i * slot_size; 1489| 30| if (IsFull(h)) { ------------------ | Branch (1489:7): [True: 30, False: 0] ------------------ 1490| 30| SanitizerUnpoisonMemoryRegion(slot_i, slot_size); 1491| 30| } else { 1492| 0| SanitizerPoisonMemoryRegion(slot_i, slot_size); 1493| 0| } 1494| | 1495| 30| ctrl_t* ctrl = common.control(); 1496| 30| ctrl[i] = h; 1497| 30| ctrl[((i - NumClonedBytes()) & capacity) + (NumClonedBytes() & capacity)] = h; 1498| 30|} _ZN4absl12lts_2024011618container_internal7SetCtrlERKNS1_12CommonFieldsEmhm: 1502| 30| size_t slot_size) { 1503| 30| SetCtrl(common, i, static_cast(h), slot_size); 1504| 30|} _ZN4absl12lts_2024011618container_internal11SlotAddressEPvmm: 1513| 20|inline void* SlotAddress(void* slot_array, size_t slot, size_t slot_size) { 1514| 20| return reinterpret_cast(reinterpret_cast(slot_array) + 1515| 20| (slot * slot_size)); 1516| 20|} _ZN4absl12lts_2024011618container_internal13TrailingZerosIjEEjT_: 372| 8|uint32_t TrailingZeros(T x) { 373| 8| ABSL_ASSUME(x != 0); ------------------ | | 259| 8|#define ABSL_ASSUME(cond) __builtin_assume(cond) ------------------ 374| 8| return static_cast(countr_zero(x)); 375| 8|} _ZN4absl12lts_2024011618container_internal19find_first_non_fullIvEENS1_8FindInfoERKNS1_12CommonFieldsEm: 1432| 31|inline FindInfo find_first_non_full(const CommonFields& common, size_t hash) { 1433| 31| auto seq = probe(common, hash); 1434| 31| const ctrl_t* ctrl = common.control(); 1435| 31| while (true) { ------------------ | Branch (1435:10): [True: 31, Folded] ------------------ 1436| 31| GroupEmptyOrDeleted g{ctrl + seq.offset()}; 1437| 31| auto mask = g.MaskEmptyOrDeleted(); 1438| 31| if (mask) { ------------------ | Branch (1438:9): [True: 31, False: 0] ------------------ 1439| |#if !defined(NDEBUG) 1440| | // We want to add entropy even when ASLR is not enabled. 1441| | // In debug build we will randomly insert in either the front or back of 1442| | // the group. 1443| | // TODO(kfm,sbenza): revisit after we do unconditional mixing 1444| | if (!is_small(common.capacity()) && ShouldInsertBackwards(hash, ctrl)) { 1445| | return {seq.offset(mask.HighestBitSet()), seq.index()}; 1446| | } 1447| |#endif 1448| 31| return {seq.offset(mask.LowestBitSet()), seq.index()}; 1449| 31| } 1450| 0| seq.next(); 1451| | assert(seq.index() <= common.capacity() && "full table!"); 1452| 0| } 1453| 31|} _ZNK4absl12lts_2024011618container_internal18NonIterableBitMaskItLi16ELi0EEcvbEv: 391| 47| explicit operator bool() const { return this->mask_ != 0; } _ZNK4absl12lts_2024011618container_internal9probe_seqILm16EE6offsetEm: 324| 35| size_t offset(size_t i) const { return (offset_ + i) & mask_; } _ZNK4absl12lts_2024011618container_internal18NonIterableBitMaskItLi16ELi0EE12LowestBitSetEv: 394| 35| uint32_t LowestBitSet() const { 395| 35| return container_internal::TrailingZeros(mask_) >> Shift; 396| 35| } _ZN4absl12lts_2024011618container_internal13TrailingZerosItEEjT_: 372| 35|uint32_t TrailingZeros(T x) { 373| 35| ABSL_ASSUME(x != 0); ------------------ | | 259| 35|#define ABSL_ASSUME(cond) __builtin_assume(cond) ------------------ 374| 35| return static_cast(countr_zero(x)); 375| 35|} _ZNK4absl12lts_2024011618container_internal9probe_seqILm16EE5indexEv: 332| 31| size_t index() const { return index_; } _ZNK4absl12lts_2024011618container_internal9probe_seqILm16EE6offsetEv: 323| 51| size_t offset() const { return offset_; } _ZNK4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EE5beginEv: 454| 16| BitMask begin() const { return *this; } _ZNK4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EE3endEv: 455| 16| BitMask end() const { return BitMask(0); } _ZN4absl12lts_2024011618container_internalneERKNS1_7BitMaskItLi16ELi0EEES5_: 461| 20| friend bool operator!=(const BitMask& a, const BitMask& b) { 462| 20| return a.mask_ != b.mask_; 463| 20| } _ZN4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EEppEv: 443| 4| BitMask& operator++() { 444| 4| if (Shift == 3) { ------------------ | Branch (444:9): [Folded, False: 4] ------------------ 445| 0| constexpr uint64_t msbs = 0x8080808080808080ULL; 446| 0| this->mask_ &= msbs; 447| 0| } 448| 4| this->mask_ &= (this->mask_ - 1); 449| 4| return *this; 450| 4| } _ZNK4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EEdeEv: 452| 4| uint32_t operator*() const { return Base::LowestBitSet(); } _ZN4absl12lts_2024011618container_internal19HashSetResizeHelper13DeallocateOldILm8ENSt3__19allocatorIcEEEEvT0_mPv: 1676| 4| void DeallocateOld(CharAlloc alloc_ref, size_t slot_size, void* old_slots) { 1677| 4| SanitizerUnpoisonMemoryRegion(old_slots, slot_size * old_capacity_); 1678| 4| Deallocate( 1679| 4| &alloc_ref, old_ctrl_ - ControlOffset(had_infoz_), 1680| 4| AllocSize(old_capacity_, slot_size, AlignOfSlot, had_infoz_)); 1681| 4| } _ZN4absl12lts_2024011618container_internal12CommonFieldsC2Ev: 1028| 1| CommonFields() = default; _ZN4absl12lts_2024011618container_internal9probe_seqILm16EEC2Emm: 316| 51| probe_seq(size_t hash, size_t mask) { 317| | assert(((mask + 1) & mask) == 0 && "not a mask"); 318| 51| mask_ = mask; 319| 51| offset_ = hash & mask_; 320| 51| } _ZN4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EEC2Et: 437| 48| explicit BitMask(T mask) : Base(mask) {} _ZN4absl12lts_2024011618container_internal18NonIterableBitMaskItLi16ELi0EEC2Et: 389| 95| explicit NonIterableBitMask(T mask) : mask_(mask) {} _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8capacityEv: 2288| 12| size_t capacity() const { return common().capacity(); } _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6commonEv: 3194| 160| const CommonFields& common() const { return settings_.template get<0>(); } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE13destroy_slotsEv: 2861| 1| inline void destroy_slots() { 2862| 1| const size_t cap = capacity(); 2863| 1| const ctrl_t* ctrl = control(); 2864| 1| slot_type* slot = slot_array(); 2865| 32| for (size_t i = 0; i != cap; ++i) { ------------------ | Branch (2865:24): [True: 31, False: 1] ------------------ 2866| 31| if (IsFull(ctrl[i])) { ------------------ | Branch (2866:11): [True: 16, False: 15] ------------------ 2867| 16| destroy(slot + i); 2868| 16| } 2869| 31| } 2870| 1| } _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE7controlEv: 3196| 71| ctrl_t* control() const { return common().control(); } _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE10slot_arrayEv: 3197| 44| slot_type* slot_array() const { 3198| 44| return static_cast(common().slot_array()); 3199| 44| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE7destroyEPNS1_13map_slot_typeIS8_SA_EE: 2854| 16| inline void destroy(slot_type* slot) { 2855| 16| PolicyTraits::destroy(&alloc_ref(), slot); 2856| 16| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE9alloc_refEv: 3206| 52| allocator_type& alloc_ref() { return settings_.template get<3>(); } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE5infozEv: 3200| 17| HashtablezInfoHandle infoz() { return common().infoz(); } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6commonEv: 3193| 198| CommonFields& common() { return settings_.template get<0>(); } _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE19prefetch_heap_blockEv: 3187| 16| void prefetch_heap_block() const { 3188| 16|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__) 3189| 16| __builtin_prefetch(control(), 0, 1); 3190| 16|#endif 3191| 16| } _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE12EqualElementIS8_EclIS8_JRKNS4_21piecewise_construct_tENS4_5tupleIJRSG_EEENSQ_IJRKSA_EEEEEEbRKT_DpOT0_: 2813| 4| bool operator()(const K2& lhs, Args&&...) const { 2814| 4| return eq(lhs, rhs); 2815| 4| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6eq_refEv: 3204| 4| key_equal& eq_ref() { return settings_.template get<2>(); } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE11iterator_atEm: 3159| 17| iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND { 3160| 17| return {control() + i, slot_array() + i, common().generation_ptr()}; 3161| 17| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIS8_SA_EEPKh: 1984| 17| : HashSetIteratorGenerationInfo(generation_ptr), 1985| 17| ctrl_(ctrl), 1986| 17| slot_(slot) { 1987| | // This assumption helps the compiler know that any non-end iterator is 1988| | // not equal to any end iterator. 1989| 17| ABSL_ASSUME(ctrl != nullptr); ------------------ | | 259| 17|#define ABSL_ASSUME(cond) __builtin_assume(cond) ------------------ 1990| 17| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8hash_refEv: 3202| 30| hasher& hash_ref() { return settings_.template get<1>(); } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE3endEv: 2271| 1| iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND { 2272| 1| return iterator(common().generation_ptr()); 2273| 1| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorC2EPKh: 1993| 1| : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {} _ZN4absl12lts_2024011618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorESM_: 1977| 17| friend bool operator!=(const iterator& a, const iterator& b) { 1978| 17| return !(a == b); 1979| 17| } _ZN4absl12lts_2024011618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorESM_: 1970| 17| friend bool operator==(const iterator& a, const iterator& b) { 1971| 17| AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr()); 1972| 17| AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr()); 1973| 17| AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_, 1974| 17| a.generation_ptr(), b.generation_ptr()); 1975| 17| return a.ctrl_ == b.ctrl_; 1976| 17| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6insertISH_TnNS4_9enable_ifIXsr4absl11disjunctionINS4_14is_convertibleIT_NSF_IS8_SA_EEEENSJ_22SameAsElementReferenceISN_EEEE5valueEiE4typeELi0ESH_TnNSL_IXsr14IsDecomposableIT1_EE5valueEiE4typeELi0ETnPSN_LPSH_0EEENSF_INSJ_8iteratorEbEEOSN_: 2320| 16| std::pair insert(T&& value) ABSL_ATTRIBUTE_LIFETIME_BOUND { 2321| 16| return emplace(std::forward(value)); 2322| 16| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE7emplaceIJSH_ETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSF_INSJ_8iteratorEbEEDpOSM_: 2422| 16| ABSL_ATTRIBUTE_LIFETIME_BOUND { 2423| 16| return PolicyTraits::apply(EmplaceDecomposable{*this}, 2424| 16| std::forward(args)...); 2425| 16| } _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE19EmplaceDecomposableclIS8_JRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSP_IJOSA_EEEEEENSF_INSJ_8iteratorEbEERKT_DpOT0_: 2822| 16| std::pair operator()(const K& key, Args&&... args) const { 2823| 16| auto res = s.find_or_prepare_insert(key); 2824| 16| if (res.second) { ------------------ | Branch (2824:11): [True: 16, False: 0] ------------------ 2825| 16| s.emplace_at(res.first, std::forward(args)...); 2826| 16| } 2827| 16| return {s.iterator_at(res.first), res.second}; 2828| 16| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE22find_or_prepare_insertIS8_EENSF_ImbEERKT_: 3086| 16| std::pair find_or_prepare_insert(const K& key) { 3087| 16| prefetch_heap_block(); 3088| 16| auto hash = hash_ref()(key); 3089| 16| auto seq = probe(common(), hash); 3090| 16| const ctrl_t* ctrl = control(); 3091| 16| while (true) { ------------------ | Branch (3091:12): [True: 16, Folded] ------------------ 3092| 16| Group g{ctrl + seq.offset()}; 3093| 16| for (uint32_t i : g.Match(H2(hash))) { ------------------ | Branch (3093:23): [True: 4, False: 16] ------------------ 3094| 4| if (ABSL_PREDICT_TRUE(PolicyTraits::apply( ------------------ | | 179| 4|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true)) | | ------------------ | | | Branch (179:30): [True: 0, False: 4] | | | Branch (179:48): [Folded, False: 4] | | | Branch (179:57): [True: 0, False: 4] | | ------------------ ------------------ 3095| 4| EqualElement{key, eq_ref()}, 3096| 4| PolicyTraits::element(slot_array() + seq.offset(i))))) 3097| 0| return {seq.offset(i), false}; 3098| 4| } 3099| 16| if (ABSL_PREDICT_TRUE(g.MaskEmpty())) break; ------------------ | | 179| 16|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true)) | | ------------------ | | | Branch (179:30): [True: 16, False: 0] | | | Branch (179:48): [Folded, False: 16] | | | Branch (179:57): [True: 16, False: 0] | | ------------------ ------------------ 3100| 0| seq.next(); 3101| 0| assert(seq.index() <= capacity() && "full table!"); 3102| 0| } 3103| 16| return {prepare_insert(hash), true}; 3104| 16| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE14prepare_insertEm: 3110| 16| size_t prepare_insert(size_t hash) ABSL_ATTRIBUTE_NOINLINE { 3111| 16| const bool rehash_for_bug_detection = 3112| 16| common().should_rehash_for_bug_detection_on_insert(); 3113| 16| if (rehash_for_bug_detection) { ------------------ | Branch (3113:9): [True: 0, False: 16] ------------------ 3114| | // Move to a different heap allocation in order to detect bugs. 3115| 0| const size_t cap = capacity(); 3116| 0| resize(growth_left() > 0 ? cap : NextCapacity(cap)); ------------------ | Branch (3116:14): [True: 0, False: 0] ------------------ 3117| 0| } 3118| 16| auto target = find_first_non_full(common(), hash); 3119| 16| if (!rehash_for_bug_detection && ------------------ | Branch (3119:9): [True: 16, False: 0] ------------------ 3120| 16| ABSL_PREDICT_FALSE(growth_left() == 0 && ------------------ | | 178| 21|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 5, False: 11] | | | Branch (178:49): [Folded, False: 16] | | | Branch (178:59): [True: 5, False: 11] | | | Branch (178:59): [True: 5, False: 0] | | ------------------ ------------------ 3121| 16| !IsDeleted(control()[target.offset]))) { 3122| 5| size_t old_capacity = capacity(); 3123| 5| rehash_and_grow_if_necessary(); 3124| | // NOTE: It is safe to use `FindFirstNonFullAfterResize`. 3125| | // `FindFirstNonFullAfterResize` must be called right after resize. 3126| | // `rehash_and_grow_if_necessary` may *not* call `resize` 3127| | // and perform `drop_deletes_without_resize` instead. But this 3128| | // could happen only on big tables. 3129| | // For big tables `FindFirstNonFullAfterResize` will always 3130| | // fallback to normal `find_first_non_full`, so it is safe to use it. 3131| 5| target = HashSetResizeHelper::FindFirstNonFullAfterResize( 3132| 5| common(), old_capacity, hash); 3133| 5| } 3134| 16| common().increment_size(); 3135| 16| set_growth_left(growth_left() - IsEmpty(control()[target.offset])); 3136| 16| SetCtrl(common(), target.offset, H2(hash), sizeof(slot_type)); 3137| 16| common().maybe_increment_generation_on_insert(); 3138| 16| infoz().RecordInsert(hash, target.probe_length); 3139| 16| return target.offset; 3140| 16| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6resizeEm: 2905| 5| ABSL_ATTRIBUTE_NOINLINE void resize(size_t new_capacity) { 2906| 5| assert(IsValidCapacity(new_capacity)); 2907| 5| HashSetResizeHelper resize_helper(common()); 2908| 5| auto* old_slots = slot_array(); 2909| 5| common().set_capacity(new_capacity); 2910| | // Note that `InitializeSlots` does different number initialization steps 2911| | // depending on the values of `transfer_uses_memcpy` and capacities. 2912| | // Refer to the comment in `InitializeSlots` for more details. 2913| 5| const bool grow_single_group = 2914| 5| resize_helper.InitializeSlots( 2917| 5| common(), const_cast*>(old_slots), 2918| 5| CharAlloc(alloc_ref())); 2919| | 2920| 5| if (resize_helper.old_capacity() == 0) { ------------------ | Branch (2920:9): [True: 1, False: 4] ------------------ 2921| | // InitializeSlots did all the work including infoz().RecordRehash(). 2922| 1| return; 2923| 1| } 2924| | 2925| 4| if (grow_single_group) { ------------------ | Branch (2925:9): [True: 3, False: 1] ------------------ 2926| 3| if (PolicyTraits::transfer_uses_memcpy()) { ------------------ | Branch (2926:11): [True: 3, Folded] ------------------ 2927| | // InitializeSlots did all the work. 2928| 3| return; 2929| 3| } 2930| | // We want GrowSizeIntoSingleGroup to be called here in order to make 2931| | // InitializeSlots not depend on PolicyTraits. 2932| 0| resize_helper.GrowSizeIntoSingleGroup(common(), alloc_ref(), 2933| 0| old_slots); 2934| 1| } else { 2935| | // InitializeSlots prepares control bytes to correspond to empty table. 2936| 1| auto* new_slots = slot_array(); 2937| 1| size_t total_probe_length = 0; 2938| 16| for (size_t i = 0; i != resize_helper.old_capacity(); ++i) { ------------------ | Branch (2938:26): [True: 15, False: 1] ------------------ 2939| 15| if (IsFull(resize_helper.old_ctrl()[i])) { ------------------ | Branch (2939:13): [True: 14, False: 1] ------------------ 2940| 14| size_t hash = PolicyTraits::apply( 2941| 14| HashElement{hash_ref()}, PolicyTraits::element(old_slots + i)); 2942| 14| auto target = find_first_non_full(common(), hash); 2943| 14| size_t new_i = target.offset; 2944| 14| total_probe_length += target.probe_length; 2945| 14| SetCtrl(common(), new_i, H2(hash), sizeof(slot_type)); 2946| 14| transfer(new_slots + new_i, old_slots + i); 2947| 14| } 2948| 15| } 2949| 1| infoz().RecordRehash(total_probe_length); 2950| 1| } 2951| 1| resize_helper.DeallocateOld( 2952| 1| CharAlloc(alloc_ref()), sizeof(slot_type), 2953| 1| const_cast*>(old_slots)); 2954| 1| } _ZN4absl12lts_2024011618container_internal19HashSetResizeHelper15InitializeSlotsINSt3__19allocatorIcEELm24ELb1ELm8EEEbRNS1_12CommonFieldsEPvT_: 1595| 5| Alloc alloc) { 1596| 5| assert(c.capacity()); 1597| | // Folks with custom allocators often make unwarranted assumptions about the 1598| | // behavior of their classes vis-a-vis trivial destructability and what 1599| | // calls they will or won't make. Avoid sampling for people with custom 1600| | // allocators to get us out of this mess. This is not a hard guarantee but 1601| | // a workaround while we plan the exact guarantee we want to provide. 1602| 5| const size_t sample_size = 1603| 5| (std::is_same>::value && ------------------ | Branch (1603:10): [True: 5, Folded] ------------------ 1604| 5| c.slot_array() == nullptr) ------------------ | Branch (1604:10): [True: 1, False: 4] ------------------ 1605| 5| ? SizeOfSlot 1606| 5| : 0; 1607| 5| HashtablezInfoHandle infoz = 1608| 5| sample_size > 0 ? Sample(sample_size) : c.infoz(); ------------------ | Branch (1608:9): [True: 1, False: 4] ------------------ 1609| | 1610| 5| const bool has_infoz = infoz.IsSampled(); 1611| 5| const size_t cap = c.capacity(); 1612| 5| const size_t alloc_size = 1613| 5| AllocSize(cap, SizeOfSlot, AlignOfSlot, has_infoz); 1614| 5| char* mem = static_cast( 1615| 5| Allocate(&alloc, alloc_size)); 1616| 5| const GenerationType old_generation = c.generation(); 1617| 5| c.set_generation_ptr(reinterpret_cast( 1618| 5| mem + GenerationOffset(cap, has_infoz))); 1619| 5| c.set_generation(NextGeneration(old_generation)); 1620| 5| c.set_control(reinterpret_cast(mem + ControlOffset(has_infoz))); 1621| 5| c.set_slots(mem + SlotOffset(cap, AlignOfSlot, has_infoz)); 1622| 5| ResetGrowthLeft(c); 1623| | 1624| 5| const bool grow_single_group = 1625| 5| IsGrowingIntoSingleGroupApplicable(old_capacity_, c.capacity()); 1626| 5| if (old_capacity_ != 0 && grow_single_group) { ------------------ | Branch (1626:9): [True: 4, False: 1] | Branch (1626:31): [True: 3, False: 1] ------------------ 1627| 3| if (TransferUsesMemcpy) { ------------------ | Branch (1627:11): [True: 3, Folded] ------------------ 1628| 3| GrowSizeIntoSingleGroupTransferable(c, old_slots, SizeOfSlot); 1629| 3| DeallocateOld(alloc, SizeOfSlot, old_slots); 1630| 3| } else { 1631| 0| GrowIntoSingleGroupShuffleControlBytes(c.control(), c.capacity()); 1632| 0| } 1633| 3| } else { 1634| 2| ResetCtrl(c, SizeOfSlot); 1635| 2| } 1636| | 1637| 5| c.set_has_infoz(has_infoz); 1638| 5| if (has_infoz) { ------------------ | Branch (1638:9): [True: 0, False: 5] ------------------ 1639| 0| infoz.RecordStorageChanged(c.size(), cap); 1640| 0| if (grow_single_group || old_capacity_ == 0) { ------------------ | Branch (1640:11): [True: 0, False: 0] | Branch (1640:32): [True: 0, False: 0] ------------------ 1641| 0| infoz.RecordRehash(0); 1642| 0| } 1643| 0| c.set_infoz(infoz); 1644| 0| } 1645| 5| return grow_single_group; 1646| 5| } _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE11HashElementclIS8_JRKNS4_21piecewise_construct_tENS4_5tupleIJRSG_EEENSP_IJRKSA_EEEEEEmRKT_DpOT0_: 2804| 14| size_t operator()(const K& key, Args&&...) const { 2805| 14| return h(key); 2806| 14| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8transferEPNS1_13map_slot_typeIS8_SA_EESM_: 2857| 14| inline void transfer(slot_type* to, slot_type* from) { 2858| 14| PolicyTraits::transfer(&alloc_ref(), to, from); 2859| 14| } _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE11growth_leftEv: 3181| 32| size_t growth_left() const { return common().growth_left(); } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE28rehash_and_grow_if_necessaryEv: 2970| 5| void rehash_and_grow_if_necessary() { 2971| 5| const size_t cap = capacity(); 2972| 5| if (cap > Group::kWidth && ------------------ | Branch (2972:9): [True: 0, False: 5] ------------------ 2973| | // Do these calculations in 64-bit to avoid overflow. 2974| 0| size() * uint64_t{32} <= cap * uint64_t{25}) { ------------------ | Branch (2974:9): [True: 0, False: 0] ------------------ 2975| | // Squash DELETED without growing if there is enough capacity. 2976| | // 2977| | // Rehash in place if the current size is <= 25/32 of capacity. 2978| | // Rationale for such a high factor: 1) drop_deletes_without_resize() is 2979| | // faster than resize, and 2) it takes quite a bit of work to add 2980| | // tombstones. In the worst case, seems to take approximately 4 2981| | // insert/erase pairs to create a single tombstone and so if we are 2982| | // rehashing because of tombstones, we can afford to rehash-in-place as 2983| | // long as we are reclaiming at least 1/8 the capacity without doing more 2984| | // than 2X the work. (Where "work" is defined to be size() for rehashing 2985| | // or rehashing in place, and 1 for an insert or erase.) But rehashing in 2986| | // place is faster per operation than inserting or even doubling the size 2987| | // of the table, so we actually afford to reclaim even less space from a 2988| | // resize-in-place. The decision is to rehash in place if we can reclaim 2989| | // at about 1/8th of the usable capacity (specifically 3/28 of the 2990| | // capacity) which means that the total cost of rehashing will be a small 2991| | // fraction of the total work. 2992| | // 2993| | // Here is output of an experiment using the BM_CacheInSteadyState 2994| | // benchmark running the old case (where we rehash-in-place only if we can 2995| | // reclaim at least 7/16*capacity) vs. this code (which rehashes in place 2996| | // if we can recover 3/32*capacity). 2997| | // 2998| | // Note that although in the worst-case number of rehashes jumped up from 2999| | // 15 to 190, but the number of operations per second is almost the same. 3000| | // 3001| | // Abridged output of running BM_CacheInSteadyState benchmark from 3002| | // raw_hash_set_benchmark. N is the number of insert/erase operations. 3003| | // 3004| | // | OLD (recover >= 7/16 | NEW (recover >= 3/32) 3005| | // size | N/s LoadFactor NRehashes | N/s LoadFactor NRehashes 3006| | // 448 | 145284 0.44 18 | 140118 0.44 19 3007| | // 493 | 152546 0.24 11 | 151417 0.48 28 3008| | // 538 | 151439 0.26 11 | 151152 0.53 38 3009| | // 583 | 151765 0.28 11 | 150572 0.57 50 3010| | // 628 | 150241 0.31 11 | 150853 0.61 66 3011| | // 672 | 149602 0.33 12 | 150110 0.66 90 3012| | // 717 | 149998 0.35 12 | 149531 0.70 129 3013| | // 762 | 149836 0.37 13 | 148559 0.74 190 3014| | // 807 | 149736 0.39 14 | 151107 0.39 14 3015| | // 852 | 150204 0.42 15 | 151019 0.42 15 3016| 0| drop_deletes_without_resize(); 3017| 5| } else { 3018| | // Otherwise grow the container. 3019| 5| resize(NextCapacity(cap)); 3020| 5| } 3021| 5| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE18GetPolicyFunctionsEv: 3236| 1| static const PolicyFunctions& GetPolicyFunctions() { 3237| 1| static constexpr PolicyFunctions value = { 3238| 1| sizeof(slot_type), 3239| 1| &raw_hash_set::hash_slot_fn, 3240| 1| PolicyTraits::transfer_uses_memcpy() ------------------ | Branch (3240:9): [True: 0, Folded] ------------------ 3241| 1| ? TransferRelocatable 3242| 1| : &raw_hash_set::transfer_slot_fn, 3243| 1| (std::is_same>::value ------------------ | Branch (3243:10): [True: 0, Folded] ------------------ 3244| 1| ? &DeallocateStandard 3245| 1| : &raw_hash_set::dealloc_fn), 3246| 1| }; 3247| 1| return value; 3248| 1| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE15set_growth_leftEm: 3182| 16| void set_growth_left(size_t gl) { return common().set_growth_left(gl); } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSO_IJOSA_EEEEEEvmDpOT_: 3151| 16| void emplace_at(size_t i, Args&&... args) { 3152| 16| construct(slot_array() + i, std::forward(args)...); 3153| | 3154| | assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) == 3155| 16| iterator_at(i) && 3156| 16| "constructed value does not match the lookup key"); 3157| 16| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSO_IJOSA_EEEEEEvPNS1_13map_slot_typeIS8_SA_EEDpOT_: 2851| 16| inline void construct(slot_type* slot, Args&&... args) { 2852| 16| PolicyTraits::construct(&alloc_ref(), slot, std::forward(args)...); 2853| 16| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE5beginEv: 2266| 1| iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND { 2267| 1| auto it = iterator_at(0); 2268| 1| it.skip_empty_or_deleted(); 2269| 1| return it; 2270| 1| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iterator21skip_empty_or_deletedEv: 1999| 17| void skip_empty_or_deleted() { 2000| 25| while (IsEmptyOrDeleted(*ctrl_)) { ------------------ | Branch (2000:14): [True: 8, False: 17] ------------------ 2001| 8| uint32_t shift = 2002| 8| GroupEmptyOrDeleted{ctrl_}.CountLeadingEmptyOrDeleted(); 2003| 8| ctrl_ += shift; 2004| 8| slot_ += shift; 2005| 8| } 2006| 17| if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr; ------------------ | | 178| 17|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 1, False: 16] | | | Branch (178:49): [Folded, False: 17] | | | Branch (178:58): [True: 1, False: 16] | | ------------------ ------------------ 2007| 17| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorppEv: 1956| 16| iterator& operator++() { 1957| 16| AssertIsFull(ctrl_, generation(), generation_ptr(), "operator++"); 1958| 16| ++ctrl_; 1959| 16| ++slot_; 1960| 16| skip_empty_or_deleted(); 1961| 16| return *this; 1962| 16| } _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratordeEv: 1944| 16| reference operator*() const { 1945| 16| AssertIsFull(ctrl_, generation(), generation_ptr(), "operator*()"); 1946| 16| return unchecked_deref(); 1947| 16| } _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iterator15unchecked_derefEv: 2029| 16| reference unchecked_deref() const { return PolicyTraits::element(slot_); } _ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE4sizeEv: 2287| 1| size_t size() const { return common().size(); } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE5clearEv: 2291| 1| ABSL_ATTRIBUTE_REINITIALIZES void clear() { 2292| | // Iterating over this container is O(bucket_count()). When bucket_count() 2293| | // is much greater than size(), iteration becomes prohibitively expensive. 2294| | // For clear() it is more important to reuse the allocated array when the 2295| | // container is small because allocation takes comparatively long time 2296| | // compared to destruction of the elements of the container. So we pick the 2297| | // largest bucket_count() threshold for which iteration is still fast and 2298| | // past that we simply deallocate the array. 2299| 1| const size_t cap = capacity(); 2300| 1| if (cap == 0) { ------------------ | Branch (2300:9): [True: 0, False: 1] ------------------ 2301| | // Already guaranteed to be empty; so nothing to do. 2302| 1| } else { 2303| 1| destroy_slots(); 2304| 1| ClearBackingArray(common(), GetPolicyFunctions(), /*reuse=*/cap < 128); 2305| 1| } 2306| 1| common().set_reserved_growth(0); 2307| 1| common().set_reservation_size(0); 2308| 1| } _ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEEC2Ev: 2088| 1| std::is_nothrow_default_constructible::value) {} _ZNK4absl12lts_2024011615CommandLineFlag8IsOfTypeIbEEbv: 74| 2| inline bool IsOfType() const { 75| 2| return TypeId() == base_internal::FastTypeId(); 76| 2| } _ZN25AbslFlagDefaultGenForfuzz3GenEPv: 252| 2| static void Gen(void* absl_flag_default_loc) { \ 253| 2| new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \ 254| 2| } \ _ZN29AbslFlagDefaultGenForfuzz_for3GenEPv: 252| 1| static void Gen(void* absl_flag_default_loc) { \ 253| 1| new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \ 254| 1| } \ _ZN36AbslFlagDefaultGenForcorpus_database3GenEPv: 252| 1| static void Gen(void* absl_flag_default_loc) { \ 253| 1| new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \ 254| 1| } \ _ZN34AbslFlagDefaultGenForreplay_corpus3GenEPv: 252| 1| static void Gen(void* absl_flag_default_loc) { \ 253| 1| new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \ 254| 1| } \ _ZN38AbslFlagDefaultGenForreplay_corpus_for3GenEPv: 252| 1| static void Gen(void* absl_flag_default_loc) { \ 253| 1| new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \ 254| 1| } \ _ZN37AbslFlagDefaultGenFortime_budget_type3GenEPv: 252| 1| static void Gen(void* absl_flag_default_loc) { \ 253| 1| new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \ 254| 1| } \ _ZN41AbslFlagDefaultGenFortime_limit_per_input3GenEPv: 252| 1| static void Gen(void* absl_flag_default_loc) { \ 253| 1| new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \ 254| 1| } \ _ZN25AbslFlagDefaultGenForjobs3GenEPv: 252| 1| static void Gen(void* absl_flag_default_loc) { \ 253| 1| new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \ 254| 1| } \ _ZN4absl12lts_202401167GetFlagINSt3__18optionalImEEEET_RKNS0_14flags_internal4FlagIS5_EE: 95| 1|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag& flag) { 96| 1| return flags_internal::FlagImplPeer::InvokeGet(flag); 97| 1|} _ZN4absl12lts_202401167GetFlagImEET_RKNS0_14flags_internal4FlagIS2_EE: 95| 2|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag& flag) { 96| 2| return flags_internal::FlagImplPeer::InvokeGet(flag); 97| 2|} _ZN4absl12lts_202401167GetFlagINS0_8DurationEEET_RKNS0_14flags_internal4FlagIS3_EE: 95| 5|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag& flag) { 96| 5| return flags_internal::FlagImplPeer::InvokeGet(flag); 97| 5|} _ZN4absl12lts_202401167GetFlagIN8fuzztest8internal14TimeBudgetTypeEEET_RKNS0_14flags_internal4FlagIS5_EE: 95| 1|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag& flag) { 96| 1| return flags_internal::FlagImplPeer::InvokeGet(flag); 97| 1|} _ZN4absl12lts_202401167GetFlagIbEET_RKNS0_14flags_internal4FlagIS2_EE: 95| 3|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag& flag) { 96| 3| return flags_internal::FlagImplPeer::InvokeGet(flag); 97| 3|} _ZN4absl12lts_202401167GetFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEET_RKNS0_14flags_internal4FlagIS9_EE: 95| 7|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag& flag) { 96| 7| return flags_internal::FlagImplPeer::InvokeGet(flag); 97| 7|} _ZN29AbslFlagDefaultGenForflagfile3GenEPv: 252| 1| static void Gen(void* absl_flag_default_loc) { \ 253| 1| new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \ 254| 1| } \ _ZN28AbslFlagDefaultGenForfromenv3GenEPv: 252| 1| static void Gen(void* absl_flag_default_loc) { \ 253| 1| new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \ 254| 1| } \ _ZN31AbslFlagDefaultGenFortryfromenv3GenEPv: 252| 1| static void Gen(void* absl_flag_default_loc) { \ 253| 1| new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value); \ 254| 1| } \ _ZN4absl12lts_202401167GetFlagINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEET_RKNS0_14flags_internal4FlagISC_EE: 95| 5|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag& flag) { 96| 5| return flags_internal::FlagImplPeer::InvokeGet(flag); 97| 5|} _ZN4absl12lts_2024011614flags_internal15DynValueDeleterC2EPFPvNS1_6FlagOpEPKvS3_S3_E: 135| 2|DynValueDeleter::DynValueDeleter(FlagOpFn op_arg) : op(op_arg) {} _ZNK4absl12lts_2024011614flags_internal15DynValueDeleterclEPv: 137| 2|void DynValueDeleter::operator()(void* ptr) const { 138| 2| if (op == nullptr) return; ------------------ | Branch (138:7): [True: 0, False: 2] ------------------ 139| | 140| 2| Delete(op, ptr); 141| 2|} _ZN4absl12lts_2024011614flags_internal8FlagImpl4InitEv: 143| 15|void FlagImpl::Init() { 144| 15| new (&data_guard_) absl::Mutex; 145| | 146| 15| auto def_kind = static_cast(def_kind_); 147| | 148| 15| switch (ValueStorageKind()) { ------------------ | Branch (148:11): [True: 15, False: 0] ------------------ 149| 3| case FlagValueStorageKind::kValueAndInitBit: ------------------ | Branch (149:5): [True: 3, False: 12] ------------------ 150| 5| case FlagValueStorageKind::kOneWordAtomic: { ------------------ | Branch (150:5): [True: 2, False: 13] ------------------ 151| 5| alignas(int64_t) std::array buf{}; 152| 5| if (def_kind == FlagDefaultKind::kGenFunc) { ------------------ | Branch (152:11): [True: 1, False: 4] ------------------ 153| 1| (*default_value_.gen_func)(buf.data()); 154| 4| } else { 155| 4| assert(def_kind != FlagDefaultKind::kDynamicValue); 156| 4| std::memcpy(buf.data(), &default_value_, Sizeof(op_)); 157| 4| } 158| 5| if (ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit) { ------------------ | Branch (158:11): [True: 3, False: 2] ------------------ 159| | // We presume here the memory layout of FlagValueAndInitBit struct. 160| 3| uint8_t initialized = 1; 161| 3| std::memcpy(buf.data() + Sizeof(op_), &initialized, 162| 3| sizeof(initialized)); 163| 3| } 164| | // Type can contain valid uninitialized bits, e.g. padding. 165| 5| ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buf.data(), buf.size()); 166| 5| OneWordValue().store(absl::bit_cast(buf), 167| 5| std::memory_order_release); 168| 5| break; 169| 3| } 170| 4| case FlagValueStorageKind::kSequenceLocked: { ------------------ | Branch (170:5): [True: 4, False: 11] ------------------ 171| | // For this storage kind the default_value_ always points to gen_func 172| | // during initialization. 173| 4| assert(def_kind == FlagDefaultKind::kGenFunc); 174| 4| (*default_value_.gen_func)(AtomicBufferValue()); 175| 4| break; 176| 3| } 177| 6| case FlagValueStorageKind::kAlignedBuffer: ------------------ | Branch (177:5): [True: 6, False: 9] ------------------ 178| | // For this storage kind the default_value_ always points to gen_func 179| | // during initialization. 180| 6| assert(def_kind == FlagDefaultKind::kGenFunc); 181| 6| (*default_value_.gen_func)(AlignedBufferValue()); 182| 6| break; 183| 15| } 184| 15| seq_lock_.MarkInitialized(); 185| 15|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl9DataGuardEv: 187| 29|absl::Mutex* FlagImpl::DataGuard() const { 188| 29| absl::call_once(const_cast(this)->init_control_, &FlagImpl::Init, 189| 29| const_cast(this)); 190| | 191| | // data_guard_ is initialized inside Init. 192| 29| return reinterpret_cast(&data_guard_); 193| 29|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl13MakeInitValueEv: 220| 2|std::unique_ptr FlagImpl::MakeInitValue() const { 221| 2| void* res = nullptr; 222| 2| switch (DefaultKind()) { 223| 0| case FlagDefaultKind::kDynamicValue: ------------------ | Branch (223:5): [True: 0, False: 2] ------------------ 224| 0| res = flags_internal::Clone(op_, default_value_.dynamic_value); 225| 0| break; 226| 1| case FlagDefaultKind::kGenFunc: ------------------ | Branch (226:5): [True: 1, False: 1] ------------------ 227| 1| res = flags_internal::Alloc(op_); 228| 1| (*default_value_.gen_func)(res); 229| 1| break; 230| 1| default: ------------------ | Branch (230:5): [True: 1, False: 1] ------------------ 231| 1| res = flags_internal::Clone(op_, &default_value_); 232| 1| break; 233| 2| } 234| 2| return {res, DynValueDeleter{op_}}; 235| 2|} _ZN4absl12lts_2024011614flags_internal8FlagImpl10StoreValueEPKv: 237| 2|void FlagImpl::StoreValue(const void* src) { 238| 2| switch (ValueStorageKind()) { ------------------ | Branch (238:11): [True: 2, False: 0] ------------------ 239| 0| case FlagValueStorageKind::kValueAndInitBit: ------------------ | Branch (239:5): [True: 0, False: 2] ------------------ 240| 1| case FlagValueStorageKind::kOneWordAtomic: { ------------------ | Branch (240:5): [True: 1, False: 1] ------------------ 241| | // Load the current value to avoid setting 'init' bit manually. 242| 1| int64_t one_word_val = OneWordValue().load(std::memory_order_acquire); 243| 1| std::memcpy(&one_word_val, src, Sizeof(op_)); 244| 1| OneWordValue().store(one_word_val, std::memory_order_release); 245| 1| seq_lock_.IncrementModificationCount(); 246| 1| break; 247| 0| } 248| 0| case FlagValueStorageKind::kSequenceLocked: { ------------------ | Branch (248:5): [True: 0, False: 2] ------------------ 249| 0| seq_lock_.Write(AtomicBufferValue(), src, Sizeof(op_)); 250| 0| break; 251| 0| } 252| 1| case FlagValueStorageKind::kAlignedBuffer: ------------------ | Branch (252:5): [True: 1, False: 1] ------------------ 253| 1| Copy(op_, src, AlignedBufferValue()); 254| 1| seq_lock_.IncrementModificationCount(); 255| 1| break; 256| 2| } 257| 2| modified_ = true; 258| 2| InvokeCallback(); 259| 2|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl4NameEv: 261| 134|absl::string_view FlagImpl::Name() const { return name_; } _ZNK4absl12lts_2024011614flags_internal8FlagImpl8FilenameEv: 263| 16|std::string FlagImpl::Filename() const { 264| 16| return flags_internal::GetUsageConfig().normalize_filename(filename_); 265| 16|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl6TypeIdEv: 272| 2|FlagFastTypeId FlagImpl::TypeId() const { 273| 2| return flags_internal::FastTypeId(op_); 274| 2|} _ZN4absl12lts_2024011614flags_internal8FlagImpl11SetCallbackEPFvvE: 317| 4|void FlagImpl::SetCallback(const FlagCallbackFunc mutation_callback) { 318| 4| absl::MutexLock l(DataGuard()); 319| | 320| 4| if (callback_ == nullptr) { ------------------ | Branch (320:7): [True: 4, False: 0] ------------------ 321| 4| callback_ = new FlagCallback; 322| 4| } 323| 4| callback_->func = mutation_callback; 324| | 325| 4| InvokeCallback(); 326| 4|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl14InvokeCallbackEv: 328| 6|void FlagImpl::InvokeCallback() const { 329| 6| if (!callback_) return; ------------------ | Branch (329:7): [True: 2, False: 4] ------------------ 330| | 331| | // Make a copy of the C-style function pointer that we are about to invoke 332| | // before we release the lock guarding it. 333| 4| FlagCallbackFunc cb = callback_->func; 334| | 335| | // If the flag has a mutation callback this function invokes it. While the 336| | // callback is being invoked the primary flag's mutex is unlocked and it is 337| | // re-locked back after call to callback is completed. Callback invocation is 338| | // guarded by flag's secondary mutex instead which prevents concurrent 339| | // callback invocation. Note that it is possible for other thread to grab the 340| | // primary lock and update flag's value at any time during the callback 341| | // invocation. This is by design. Callback can get a value of the flag if 342| | // necessary, but it might be different from the value initiated the callback 343| | // and it also can be different by the time the callback invocation is 344| | // completed. Requires that *primary_lock be held in exclusive mode; it may be 345| | // released and reacquired by the implementation. 346| 4| MutexRelock relock(*DataGuard()); 347| 4| absl::MutexLock lock(&callback_->guard); 348| 4| cb(); 349| 4|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl18AlignedBufferValueEv: 414| 19|void* FlagImpl::AlignedBufferValue() const { 415| | assert(ValueStorageKind() == FlagValueStorageKind::kAlignedBuffer); 416| 19| return OffsetValue(); 417| 19|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl17AtomicBufferValueEv: 419| 8|std::atomic* FlagImpl::AtomicBufferValue() const { 420| | assert(ValueStorageKind() == FlagValueStorageKind::kSequenceLocked); 421| 8| return OffsetValue>(); 422| 8|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl12OneWordValueEv: 424| 10|std::atomic& FlagImpl::OneWordValue() const { 425| | assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic || 426| 10| ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit); 427| 10| return OffsetValue()->value; 428| 10|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl8TryParseENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEE: 435| 2| absl::string_view value, std::string& err) const { 436| 2| std::unique_ptr tentative_value = MakeInitValue(); 437| | 438| 2| std::string parse_err; 439| 2| if (!flags_internal::Parse(op_, value, tentative_value.get(), &parse_err)) { ------------------ | Branch (439:7): [True: 0, False: 2] ------------------ 440| 0| absl::string_view err_sep = parse_err.empty() ? "" : "; "; ------------------ | Branch (440:33): [True: 0, False: 0] ------------------ 441| 0| err = absl::StrCat("Illegal value '", value, "' specified for flag '", 442| 0| Name(), "'", err_sep, parse_err); 443| 0| return nullptr; 444| 0| } 445| | 446| 2| return tentative_value; 447| 2|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl4ReadEPv: 449| 16|void FlagImpl::Read(void* dst) const { 450| 16| auto* guard = DataGuard(); // Make sure flag initialized 451| 16| switch (ValueStorageKind()) { ------------------ | Branch (451:11): [True: 16, False: 0] ------------------ 452| 0| case FlagValueStorageKind::kValueAndInitBit: ------------------ | Branch (452:5): [True: 0, False: 16] ------------------ 453| 0| case FlagValueStorageKind::kOneWordAtomic: { ------------------ | Branch (453:5): [True: 0, False: 16] ------------------ 454| 0| const int64_t one_word_val = 455| 0| OneWordValue().load(std::memory_order_acquire); 456| 0| std::memcpy(dst, &one_word_val, Sizeof(op_)); 457| 0| break; 458| 0| } 459| 4| case FlagValueStorageKind::kSequenceLocked: { ------------------ | Branch (459:5): [True: 4, False: 12] ------------------ 460| 4| ReadSequenceLockedData(dst); 461| 4| break; 462| 0| } 463| 12| case FlagValueStorageKind::kAlignedBuffer: { ------------------ | Branch (463:5): [True: 12, False: 4] ------------------ 464| 12| absl::MutexLock l(guard); 465| 12| flags_internal::CopyConstruct(op_, AlignedBufferValue(), dst); 466| 12| break; 467| 0| } 468| 16| } 469| 16|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl11ReadOneWordEv: 471| 2|int64_t FlagImpl::ReadOneWord() const { 472| | assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic || 473| 2| ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit); 474| 2| auto* guard = DataGuard(); // Make sure flag initialized 475| 2| (void)guard; 476| 2| return OneWordValue().load(std::memory_order_acquire); 477| 2|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl11ReadOneBoolEv: 479| 1|bool FlagImpl::ReadOneBool() const { 480| | assert(ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit); 481| 1| auto* guard = DataGuard(); // Make sure flag initialized 482| 1| (void)guard; 483| 1| return absl::bit_cast>( 484| 1| OneWordValue().load(std::memory_order_acquire)) 485| 1| .value; 486| 1|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl22ReadSequenceLockedDataEPv: 488| 4|void FlagImpl::ReadSequenceLockedData(void* dst) const { 489| 4| size_t size = Sizeof(op_); 490| | // Attempt to read using the sequence lock. 491| 4| if (ABSL_PREDICT_TRUE(seq_lock_.TryRead(dst, AtomicBufferValue(), size))) { ------------------ | | 179| 4|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true)) | | ------------------ | | | Branch (179:30): [True: 4, False: 0] | | | Branch (179:48): [Folded, False: 4] | | | Branch (179:57): [True: 4, False: 0] | | ------------------ ------------------ 492| 4| return; 493| 4| } 494| | // We failed due to contention. Acquire the lock to prevent contention 495| | // and try again. 496| 0| absl::ReaderMutexLock l(DataGuard()); 497| 0| bool success = seq_lock_.TryRead(dst, AtomicBufferValue(), size); 498| | assert(success); 499| 0| static_cast(success); 500| 0|} _ZN4absl12lts_2024011614flags_internal8FlagImpl9ParseFromENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_15FlagSettingModeENS1_11ValueSourceERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEE: 528| 2| ValueSource source, std::string& err) { 529| 2| absl::MutexLock l(DataGuard()); 530| | 531| 2| switch (set_mode) { ------------------ | Branch (531:11): [True: 2, False: 0] ------------------ 532| 2| case SET_FLAGS_VALUE: { ------------------ | Branch (532:5): [True: 2, False: 0] ------------------ 533| | // set or modify the flag's value 534| 2| auto tentative_value = TryParse(value, err); 535| 2| if (!tentative_value) return false; ------------------ | Branch (535:11): [True: 0, False: 2] ------------------ 536| | 537| 2| StoreValue(tentative_value.get()); 538| | 539| 2| if (source == kCommandLine) { ------------------ | Branch (539:11): [True: 2, False: 0] ------------------ 540| 2| on_command_line_ = true; 541| 2| } 542| 2| break; 543| 2| } 544| 0| case SET_FLAG_IF_DEFAULT: { ------------------ | Branch (544:5): [True: 0, False: 2] ------------------ 545| | // set the flag's value, but only if it hasn't been set by someone else 546| 0| if (modified_) { ------------------ | Branch (546:11): [True: 0, False: 0] ------------------ 547| | // TODO(rogeeff): review and fix this semantic. Currently we do not fail 548| | // in this case if flag is modified. This is misleading since the flag's 549| | // value is not updated even though we return true. 550| | // *err = absl::StrCat(Name(), " is already set to ", 551| | // CurrentValue(), "\n"); 552| | // return false; 553| 0| return true; 554| 0| } 555| 0| auto tentative_value = TryParse(value, err); 556| 0| if (!tentative_value) return false; ------------------ | Branch (556:11): [True: 0, False: 0] ------------------ 557| | 558| 0| StoreValue(tentative_value.get()); 559| 0| break; 560| 0| } 561| 0| case SET_FLAGS_DEFAULT: { ------------------ | Branch (561:5): [True: 0, False: 2] ------------------ 562| 0| auto tentative_value = TryParse(value, err); 563| 0| if (!tentative_value) return false; ------------------ | Branch (563:11): [True: 0, False: 0] ------------------ 564| | 565| 0| if (DefaultKind() == FlagDefaultKind::kDynamicValue) { ------------------ | Branch (565:11): [True: 0, False: 0] ------------------ 566| 0| void* old_value = default_value_.dynamic_value; 567| 0| default_value_.dynamic_value = tentative_value.release(); 568| 0| tentative_value.reset(old_value); 569| 0| } else { 570| 0| default_value_.dynamic_value = tentative_value.release(); 571| 0| def_kind_ = static_cast(FlagDefaultKind::kDynamicValue); 572| 0| } 573| | 574| 0| if (!modified_) { ------------------ | Branch (574:11): [True: 0, False: 0] ------------------ 575| | // Need to set both default value *and* current, in this case. 576| 0| StoreValue(default_value_.dynamic_value); 577| 0| modified_ = false; 578| 0| } 579| 0| break; 580| 0| } 581| 2| } 582| | 583| 2| return true; 584| 2|} flag.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_111MutexRelockC2ERNS0_5MutexE: 71| 4| explicit MutexRelock(absl::Mutex& mu) : mu_(mu) { mu_.Unlock(); } flag.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_111MutexRelockD2Ev: 72| 4| ~MutexRelock() { mu_.Lock(); } _ZNK4absl12lts_2024011614flags_internal8FlagImpl11OffsetValueIvEEPT_v: 406| 19|StorageT* FlagImpl::OffsetValue() const { 407| 19| char* p = reinterpret_cast(const_cast(this)); 408| | // The offset is deduced via Flag value type specific op_. 409| 19| ptrdiff_t offset = flags_internal::ValueOffset(op_); 410| | 411| 19| return reinterpret_cast(p + offset); 412| 19|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl11OffsetValueINSt3__16atomicImEEEEPT_v: 406| 8|StorageT* FlagImpl::OffsetValue() const { 407| 8| char* p = reinterpret_cast(const_cast(this)); 408| | // The offset is deduced via Flag value type specific op_. 409| 8| ptrdiff_t offset = flags_internal::ValueOffset(op_); 410| | 411| 8| return reinterpret_cast(p + offset); 412| 8|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl11OffsetValueINS1_16FlagOneWordValueEEEPT_v: 406| 10|StorageT* FlagImpl::OffsetValue() const { 407| 10| char* p = reinterpret_cast(const_cast(this)); 408| | // The offset is deduced via Flag value type specific op_. 409| 10| ptrdiff_t offset = flags_internal::ValueOffset(op_); 410| | 411| 10| return reinterpret_cast(p + offset); 412| 10|} _ZN4absl12lts_2024011614flags_internal16InitDefaultValueINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEET_SA_: 277| 4|constexpr T InitDefaultValue(T t) { 278| 4| return t; 279| 4|} _ZN4absl12lts_2024011614flags_internal16InitDefaultValueINS0_8DurationEEET_S4_: 277| 3|constexpr T InitDefaultValue(T t) { 278| 3| return t; 279| 3|} _ZN4absl12lts_2024011614flags_internal16InitDefaultValueIN8fuzztest8internal14TimeBudgetTypeEEET_S6_: 277| 1|constexpr T InitDefaultValue(T t) { 278| 1| return t; 279| 1|} _ZN4absl12lts_2024011614flags_internal16InitDefaultValueINSt3__18optionalImEEEET_S6_: 277| 1|constexpr T InitDefaultValue(T t) { 278| 1| return t; 279| 1|} _ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetINSt3__18optionalImEENS1_4FlagIS6_EEEET_RKT0_: 697| 1| static T InvokeGet(const FlagType& flag) { 698| 1| return flag.Get(); 699| 1| } _ZNK4absl12lts_2024011614flags_internal4FlagINSt3__18optionalImEEE3GetEv: 657| 1| T Get() const { 658| | // See implementation notes in CommandLineFlag::Get(). 659| 1| union U { 660| 1| T value; 661| 1| U() {} 662| 1| ~U() { value.~T(); } 663| 1| }; 664| 1| U u; 665| | 666| |#if !defined(NDEBUG) 667| | impl_.AssertValidType(base_internal::FastTypeId(), &GenRuntimeTypeId); 668| |#endif 669| | 670| 1| if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) { ------------------ | | 178| 1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 1, False: 0] | | | Branch (178:49): [Folded, False: 1] | | | Branch (178:58): [True: 1, False: 0] | | ------------------ ------------------ 671| 1| impl_.Read(&u.value); 672| 1| } 673| 1| return std::move(u.value); 674| 1| } _ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__18optionalImEEE3GetEvEN1UC2Ev: 661| 1| U() {} _ZNK4absl12lts_2024011614flags_internal9FlagValueINSt3__18optionalImEELNS1_20FlagValueStorageKindE2EE3GetERKNS1_12SequenceLockERS5_: 384| 1| bool Get(const SequenceLock& lock, T& dst) const { 385| 1| return lock.TryRead(&dst, value_words, sizeof(T)); 386| 1| } _ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__18optionalImEEE3GetEvEN1UD2Ev: 662| 1| ~U() { value.~T(); } _ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetImNS1_4FlagImEEEET_RKT0_: 697| 2| static T InvokeGet(const FlagType& flag) { 698| 2| return flag.Get(); 699| 2| } _ZNK4absl12lts_2024011614flags_internal4FlagImE3GetEv: 657| 2| T Get() const { 658| | // See implementation notes in CommandLineFlag::Get(). 659| 2| union U { 660| 2| T value; 661| 2| U() {} 662| 2| ~U() { value.~T(); } 663| 2| }; 664| 2| U u; 665| | 666| |#if !defined(NDEBUG) 667| | impl_.AssertValidType(base_internal::FastTypeId(), &GenRuntimeTypeId); 668| |#endif 669| | 670| 2| if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) { ------------------ | | 178| 2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 1, False: 1] | | | Branch (178:49): [Folded, False: 2] | | | Branch (178:58): [True: 1, False: 1] | | ------------------ ------------------ 671| 1| impl_.Read(&u.value); 672| 1| } 673| 2| return std::move(u.value); 674| 2| } _ZZNK4absl12lts_2024011614flags_internal4FlagImE3GetEvEN1UC2Ev: 661| 2| U() {} _ZNK4absl12lts_2024011614flags_internal9FlagValueImLNS1_20FlagValueStorageKindE1EE3GetERKNS1_12SequenceLockERm: 372| 2| bool Get(const SequenceLock&, T& dst) const { 373| 2| int64_t one_word_val = value.load(std::memory_order_acquire); 374| 2| if (ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue())) { ------------------ | | 178| 2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 1, False: 1] | | | Branch (178:49): [Folded, False: 2] | | | Branch (178:58): [True: 1, False: 1] | | ------------------ ------------------ 375| 1| return false; 376| 1| } 377| 1| std::memcpy(&dst, static_cast(&one_word_val), sizeof(T)); 378| 1| return true; 379| 2| } _ZN4absl12lts_2024011614flags_internal22UninitializedFlagValueEv: 301| 2|constexpr int64_t UninitializedFlagValue() { 302| 2| return static_cast(0xababababababababll); 303| 2|} _ZNK4absl12lts_2024011614flags_internal8FlagImpl4ReadImTnNSt3__19enable_ifIXeqclsr14flags_internalE11StorageKindIT_EELNS1_20FlagValueStorageKindE1EEiE4typeELi0EEEvPS6_: 457| 1| void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) { 458| 1| int64_t v = ReadOneWord(); 459| 1| std::memcpy(value, static_cast(&v), sizeof(T)); 460| 1| } _ZZNK4absl12lts_2024011614flags_internal4FlagImE3GetEvEN1UD2Ev: 662| 2| ~U() { value.~T(); } _ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetINS0_8DurationENS1_4FlagIS4_EEEET_RKT0_: 697| 5| static T InvokeGet(const FlagType& flag) { 698| 5| return flag.Get(); 699| 5| } _ZNK4absl12lts_2024011614flags_internal4FlagINS0_8DurationEE3GetEv: 657| 5| T Get() const { 658| | // See implementation notes in CommandLineFlag::Get(). 659| 5| union U { 660| 5| T value; 661| 5| U() {} 662| 5| ~U() { value.~T(); } 663| 5| }; 664| 5| U u; 665| | 666| |#if !defined(NDEBUG) 667| | impl_.AssertValidType(base_internal::FastTypeId(), &GenRuntimeTypeId); 668| |#endif 669| | 670| 5| if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) { ------------------ | | 178| 5|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 3, False: 2] | | | Branch (178:49): [Folded, False: 5] | | | Branch (178:58): [True: 3, False: 2] | | ------------------ ------------------ 671| 3| impl_.Read(&u.value); 672| 3| } 673| 5| return std::move(u.value); 674| 5| } _ZZNK4absl12lts_2024011614flags_internal4FlagINS0_8DurationEE3GetEvEN1UC2Ev: 661| 5| U() {} _ZNK4absl12lts_2024011614flags_internal9FlagValueINS0_8DurationELNS1_20FlagValueStorageKindE2EE3GetERKNS1_12SequenceLockERS3_: 384| 5| bool Get(const SequenceLock& lock, T& dst) const { 385| 5| return lock.TryRead(&dst, value_words, sizeof(T)); 386| 5| } _ZZNK4absl12lts_2024011614flags_internal4FlagINS0_8DurationEE3GetEvEN1UD2Ev: 662| 5| ~U() { value.~T(); } _ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetIN8fuzztest8internal14TimeBudgetTypeENS1_4FlagIS6_EEEET_RKT0_: 697| 1| static T InvokeGet(const FlagType& flag) { 698| 1| return flag.Get(); 699| 1| } _ZNK4absl12lts_2024011614flags_internal4FlagIN8fuzztest8internal14TimeBudgetTypeEE3GetEv: 657| 1| T Get() const { 658| | // See implementation notes in CommandLineFlag::Get(). 659| 1| union U { 660| 1| T value; 661| 1| U() {} 662| 1| ~U() { value.~T(); } 663| 1| }; 664| 1| U u; 665| | 666| |#if !defined(NDEBUG) 667| | impl_.AssertValidType(base_internal::FastTypeId(), &GenRuntimeTypeId); 668| |#endif 669| | 670| 1| if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) { ------------------ | | 178| 1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 1, False: 0] | | | Branch (178:49): [Folded, False: 1] | | | Branch (178:58): [True: 1, False: 0] | | ------------------ ------------------ 671| 1| impl_.Read(&u.value); 672| 1| } 673| 1| return std::move(u.value); 674| 1| } _ZZNK4absl12lts_2024011614flags_internal4FlagIN8fuzztest8internal14TimeBudgetTypeEE3GetEvEN1UC2Ev: 661| 1| U() {} _ZNK4absl12lts_2024011614flags_internal9FlagValueIN8fuzztest8internal14TimeBudgetTypeELNS1_20FlagValueStorageKindE0EE3GetERKNS1_12SequenceLockERS5_: 359| 1| bool Get(const SequenceLock&, T& dst) const { 360| 1| int64_t storage = value.load(std::memory_order_acquire); 361| 1| if (ABSL_PREDICT_FALSE(storage == 0)) { ------------------ | | 178| 1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 1, False: 0] | | | Branch (178:49): [Folded, False: 1] | | | Branch (178:58): [True: 1, False: 0] | | ------------------ ------------------ 362| 1| return false; 363| 1| } 364| 0| dst = absl::bit_cast>(storage).value; 365| 0| return true; 366| 1| } _ZNK4absl12lts_2024011614flags_internal8FlagImpl4ReadIN8fuzztest8internal14TimeBudgetTypeETnNSt3__19enable_ifIXeqclsr14flags_internalE11StorageKindIT_EELNS1_20FlagValueStorageKindE0EEiE4typeELi0EEEvPS9_: 465| 1| void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) { 466| 1| *value = absl::bit_cast>(ReadOneWord()).value; 467| 1| } _ZZNK4absl12lts_2024011614flags_internal4FlagIN8fuzztest8internal14TimeBudgetTypeEE3GetEvEN1UD2Ev: 662| 1| ~U() { value.~T(); } _ZN4absl12lts_2024011614flags_internal7FlagOpsIbEEPvNS1_6FlagOpEPKvS3_S3_: 713| 7|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) { 714| 7| switch (op) { ------------------ | Branch (714:11): [True: 7, False: 0] ------------------ 715| 0| case FlagOp::kAlloc: { ------------------ | Branch (715:5): [True: 0, False: 7] ------------------ 716| 0| std::allocator alloc; 717| 0| return std::allocator_traits>::allocate(alloc, 1); 718| 0| } 719| 0| case FlagOp::kDelete: { ------------------ | Branch (719:5): [True: 0, False: 7] ------------------ 720| 0| T* p = static_cast(v2); 721| 0| p->~T(); 722| 0| std::allocator alloc; 723| 0| std::allocator_traits>::deallocate(alloc, p, 1); 724| 0| return nullptr; 725| 0| } 726| 0| case FlagOp::kCopy: ------------------ | Branch (726:5): [True: 0, False: 7] ------------------ 727| 0| *static_cast(v2) = *static_cast(v1); 728| 0| return nullptr; 729| 0| case FlagOp::kCopyConstruct: ------------------ | Branch (729:5): [True: 0, False: 7] ------------------ 730| 0| new (v2) T(*static_cast(v1)); 731| 0| return nullptr; 732| 4| case FlagOp::kSizeof: ------------------ | Branch (732:5): [True: 4, False: 3] ------------------ 733| 4| return reinterpret_cast(static_cast(sizeof(T))); 734| 0| case FlagOp::kFastTypeId: ------------------ | Branch (734:5): [True: 0, False: 7] ------------------ 735| 0| return const_cast(base_internal::FastTypeId()); 736| 0| case FlagOp::kRuntimeTypeId: ------------------ | Branch (736:5): [True: 0, False: 7] ------------------ 737| 0| return const_cast(GenRuntimeTypeId()); 738| 0| case FlagOp::kParse: { ------------------ | Branch (738:5): [True: 0, False: 7] ------------------ 739| | // Initialize the temporary instance of type T based on current value in 740| | // destination (which is going to be flag's default value). 741| 0| T temp(*static_cast(v2)); 742| 0| if (!absl::ParseFlag(*static_cast(v1), &temp, ------------------ | Branch (742:11): [True: 0, False: 0] ------------------ 743| 0| static_cast(v3))) { 744| 0| return nullptr; 745| 0| } 746| 0| *static_cast(v2) = std::move(temp); 747| 0| return v2; 748| 0| } 749| 0| case FlagOp::kUnparse: ------------------ | Branch (749:5): [True: 0, False: 7] ------------------ 750| 0| *static_cast(v2) = 751| 0| absl::UnparseFlag(*static_cast(v1)); 752| 0| return nullptr; 753| 3| case FlagOp::kValueOffset: { ------------------ | Branch (753:5): [True: 3, False: 4] ------------------ 754| | // Round sizeof(FlagImp) to a multiple of alignof(FlagValue) to get the 755| | // offset of the data. 756| 3| size_t round_to = alignof(FlagValue); 757| 3| size_t offset = 758| 3| (sizeof(FlagImpl) + round_to - 1) / round_to * round_to; 759| 3| return reinterpret_cast(offset); 760| 0| } 761| 7| } 762| 0| return nullptr; 763| 7|} _ZN4absl12lts_2024011614flags_internal13FlagRegistrarIbLb1EEC2ERNS1_4FlagIbEEPKc: 773| 2| explicit FlagRegistrar(Flag& flag, const char* filename) : flag_(flag) { 774| 2| if (do_register) ------------------ | Branch (774:9): [True: 2, Folded] ------------------ 775| 2| flags_internal::RegisterCommandLineFlag(flag_.impl_, filename); 776| 2| } _ZNO4absl12lts_2024011614flags_internal13FlagRegistrarIbLb1EE8OnUpdateEPFvvE: 778| 1| FlagRegistrar OnUpdate(FlagCallbackFunc cb) && { 779| 1| flag_.impl_.SetCallback(cb); 780| 1| return *this; 781| 1| } _ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetIbNS1_4FlagIbEEEET_RKT0_: 697| 3| static T InvokeGet(const FlagType& flag) { 698| 3| return flag.Get(); 699| 3| } _ZNK4absl12lts_2024011614flags_internal4FlagIbE3GetEv: 657| 3| T Get() const { 658| | // See implementation notes in CommandLineFlag::Get(). 659| 3| union U { 660| 3| T value; 661| 3| U() {} 662| 3| ~U() { value.~T(); } 663| 3| }; 664| 3| U u; 665| | 666| |#if !defined(NDEBUG) 667| | impl_.AssertValidType(base_internal::FastTypeId(), &GenRuntimeTypeId); 668| |#endif 669| | 670| 3| if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) { ------------------ | | 178| 3|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 1, False: 2] | | | Branch (178:49): [Folded, False: 3] | | | Branch (178:58): [True: 1, False: 2] | | ------------------ ------------------ 671| 1| impl_.Read(&u.value); 672| 1| } 673| 3| return std::move(u.value); 674| 3| } _ZZNK4absl12lts_2024011614flags_internal4FlagIbE3GetEvEN1UC2Ev: 661| 3| U() {} _ZNK4absl12lts_2024011614flags_internal9FlagValueIbLNS1_20FlagValueStorageKindE0EE3GetERKNS1_12SequenceLockERb: 359| 3| bool Get(const SequenceLock&, T& dst) const { 360| 3| int64_t storage = value.load(std::memory_order_acquire); 361| 3| if (ABSL_PREDICT_FALSE(storage == 0)) { ------------------ | | 178| 3|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 1, False: 2] | | | Branch (178:49): [Folded, False: 3] | | | Branch (178:58): [True: 1, False: 2] | | ------------------ ------------------ 362| 1| return false; 363| 1| } 364| 2| dst = absl::bit_cast>(storage).value; 365| 2| return true; 366| 3| } _ZNK4absl12lts_2024011614flags_internal8FlagImpl4ReadEPb: 450| 1| void Read(bool* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) { 451| 1| *value = ReadOneBool(); 452| 1| } _ZZNK4absl12lts_2024011614flags_internal4FlagIbE3GetEvEN1UD2Ev: 662| 3| ~U() { value.~T(); } _ZNK4absl12lts_2024011614flags_internal13FlagRegistrarIbLb1EEcvNS1_18FlagRegistrarEmptyEEv: 786| 2| operator FlagRegistrarEmpty() const { return {}; } // NOLINT _ZN4absl12lts_2024011614flags_internal7FlagOpsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEPvNS1_6FlagOpEPKvSA_SA_: 713| 23|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) { 714| 23| switch (op) { ------------------ | Branch (714:11): [True: 23, False: 0] ------------------ 715| 1| case FlagOp::kAlloc: { ------------------ | Branch (715:5): [True: 1, False: 22] ------------------ 716| 1| std::allocator alloc; 717| 1| return std::allocator_traits>::allocate(alloc, 1); 718| 0| } 719| 1| case FlagOp::kDelete: { ------------------ | Branch (719:5): [True: 1, False: 22] ------------------ 720| 1| T* p = static_cast(v2); 721| 1| p->~T(); 722| 1| std::allocator alloc; 723| 1| std::allocator_traits>::deallocate(alloc, p, 1); 724| 1| return nullptr; 725| 0| } 726| 1| case FlagOp::kCopy: ------------------ | Branch (726:5): [True: 1, False: 22] ------------------ 727| 1| *static_cast(v2) = *static_cast(v1); 728| 1| return nullptr; 729| 7| case FlagOp::kCopyConstruct: ------------------ | Branch (729:5): [True: 7, False: 16] ------------------ 730| 7| new (v2) T(*static_cast(v1)); 731| 7| return nullptr; 732| 0| case FlagOp::kSizeof: ------------------ | Branch (732:5): [True: 0, False: 23] ------------------ 733| 0| return reinterpret_cast(static_cast(sizeof(T))); 734| 1| case FlagOp::kFastTypeId: ------------------ | Branch (734:5): [True: 1, False: 22] ------------------ 735| 1| return const_cast(base_internal::FastTypeId()); 736| 0| case FlagOp::kRuntimeTypeId: ------------------ | Branch (736:5): [True: 0, False: 23] ------------------ 737| 0| return const_cast(GenRuntimeTypeId()); 738| 1| case FlagOp::kParse: { ------------------ | Branch (738:5): [True: 1, False: 22] ------------------ 739| | // Initialize the temporary instance of type T based on current value in 740| | // destination (which is going to be flag's default value). 741| 1| T temp(*static_cast(v2)); 742| 1| if (!absl::ParseFlag(*static_cast(v1), &temp, ------------------ | Branch (742:11): [True: 0, False: 1] ------------------ 743| 1| static_cast(v3))) { 744| 0| return nullptr; 745| 0| } 746| 1| *static_cast(v2) = std::move(temp); 747| 1| return v2; 748| 1| } 749| 0| case FlagOp::kUnparse: ------------------ | Branch (749:5): [True: 0, False: 23] ------------------ 750| 0| *static_cast(v2) = 751| 0| absl::UnparseFlag(*static_cast(v1)); 752| 0| return nullptr; 753| 11| case FlagOp::kValueOffset: { ------------------ | Branch (753:5): [True: 11, False: 12] ------------------ 754| | // Round sizeof(FlagImp) to a multiple of alignof(FlagValue) to get the 755| | // offset of the data. 756| 11| size_t round_to = alignof(FlagValue); 757| 11| size_t offset = 758| 11| (sizeof(FlagImpl) + round_to - 1) / round_to * round_to; 759| 11| return reinterpret_cast(offset); 760| 1| } 761| 23| } 762| 0| return nullptr; 763| 23|} _ZN4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELb1EEC2ERNS1_4FlagIS9_EEPKc: 773| 3| explicit FlagRegistrar(Flag& flag, const char* filename) : flag_(flag) { 774| 3| if (do_register) ------------------ | Branch (774:9): [True: 3, Folded] ------------------ 775| 3| flags_internal::RegisterCommandLineFlag(flag_.impl_, filename); 776| 3| } _ZNK4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELb1EEcvNS1_18FlagRegistrarEmptyEEv: 786| 3| operator FlagRegistrarEmpty() const { return {}; } // NOLINT _ZN4absl12lts_2024011614flags_internal7FlagOpsINS0_8DurationEEEPvNS1_6FlagOpEPKvS4_S4_: 713| 9|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) { 714| 9| switch (op) { ------------------ | Branch (714:11): [True: 9, False: 0] ------------------ 715| 0| case FlagOp::kAlloc: { ------------------ | Branch (715:5): [True: 0, False: 9] ------------------ 716| 0| std::allocator alloc; 717| 0| return std::allocator_traits>::allocate(alloc, 1); 718| 0| } 719| 0| case FlagOp::kDelete: { ------------------ | Branch (719:5): [True: 0, False: 9] ------------------ 720| 0| T* p = static_cast(v2); 721| 0| p->~T(); 722| 0| std::allocator alloc; 723| 0| std::allocator_traits>::deallocate(alloc, p, 1); 724| 0| return nullptr; 725| 0| } 726| 0| case FlagOp::kCopy: ------------------ | Branch (726:5): [True: 0, False: 9] ------------------ 727| 0| *static_cast(v2) = *static_cast(v1); 728| 0| return nullptr; 729| 0| case FlagOp::kCopyConstruct: ------------------ | Branch (729:5): [True: 0, False: 9] ------------------ 730| 0| new (v2) T(*static_cast(v1)); 731| 0| return nullptr; 732| 3| case FlagOp::kSizeof: ------------------ | Branch (732:5): [True: 3, False: 6] ------------------ 733| 3| return reinterpret_cast(static_cast(sizeof(T))); 734| 0| case FlagOp::kFastTypeId: ------------------ | Branch (734:5): [True: 0, False: 9] ------------------ 735| 0| return const_cast(base_internal::FastTypeId()); 736| 0| case FlagOp::kRuntimeTypeId: ------------------ | Branch (736:5): [True: 0, False: 9] ------------------ 737| 0| return const_cast(GenRuntimeTypeId()); 738| 0| case FlagOp::kParse: { ------------------ | Branch (738:5): [True: 0, False: 9] ------------------ 739| | // Initialize the temporary instance of type T based on current value in 740| | // destination (which is going to be flag's default value). 741| 0| T temp(*static_cast(v2)); 742| 0| if (!absl::ParseFlag(*static_cast(v1), &temp, ------------------ | Branch (742:11): [True: 0, False: 0] ------------------ 743| 0| static_cast(v3))) { 744| 0| return nullptr; 745| 0| } 746| 0| *static_cast(v2) = std::move(temp); 747| 0| return v2; 748| 0| } 749| 0| case FlagOp::kUnparse: ------------------ | Branch (749:5): [True: 0, False: 9] ------------------ 750| 0| *static_cast(v2) = 751| 0| absl::UnparseFlag(*static_cast(v1)); 752| 0| return nullptr; 753| 6| case FlagOp::kValueOffset: { ------------------ | Branch (753:5): [True: 6, False: 3] ------------------ 754| | // Round sizeof(FlagImp) to a multiple of alignof(FlagValue) to get the 755| | // offset of the data. 756| 6| size_t round_to = alignof(FlagValue); 757| 6| size_t offset = 758| 6| (sizeof(FlagImpl) + round_to - 1) / round_to * round_to; 759| 6| return reinterpret_cast(offset); 760| 0| } 761| 9| } 762| 0| return nullptr; 763| 9|} _ZN4absl12lts_2024011614flags_internal13FlagRegistrarINS0_8DurationELb1EEC2ERNS1_4FlagIS3_EEPKc: 773| 3| explicit FlagRegistrar(Flag& flag, const char* filename) : flag_(flag) { 774| 3| if (do_register) ------------------ | Branch (774:9): [True: 3, Folded] ------------------ 775| 3| flags_internal::RegisterCommandLineFlag(flag_.impl_, filename); 776| 3| } _ZNK4absl12lts_2024011614flags_internal13FlagRegistrarINS0_8DurationELb1EEcvNS1_18FlagRegistrarEmptyEEv: 786| 3| operator FlagRegistrarEmpty() const { return {}; } // NOLINT _ZN4absl12lts_2024011614flags_internal7FlagOpsIN8fuzztest8internal14TimeBudgetTypeEEEPvNS1_6FlagOpEPKvS6_S6_: 713| 3|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) { 714| 3| switch (op) { ------------------ | Branch (714:11): [True: 3, False: 0] ------------------ 715| 0| case FlagOp::kAlloc: { ------------------ | Branch (715:5): [True: 0, False: 3] ------------------ 716| 0| std::allocator alloc; 717| 0| return std::allocator_traits>::allocate(alloc, 1); 718| 0| } 719| 0| case FlagOp::kDelete: { ------------------ | Branch (719:5): [True: 0, False: 3] ------------------ 720| 0| T* p = static_cast(v2); 721| 0| p->~T(); 722| 0| std::allocator alloc; 723| 0| std::allocator_traits>::deallocate(alloc, p, 1); 724| 0| return nullptr; 725| 0| } 726| 0| case FlagOp::kCopy: ------------------ | Branch (726:5): [True: 0, False: 3] ------------------ 727| 0| *static_cast(v2) = *static_cast(v1); 728| 0| return nullptr; 729| 0| case FlagOp::kCopyConstruct: ------------------ | Branch (729:5): [True: 0, False: 3] ------------------ 730| 0| new (v2) T(*static_cast(v1)); 731| 0| return nullptr; 732| 1| case FlagOp::kSizeof: ------------------ | Branch (732:5): [True: 1, False: 2] ------------------ 733| 1| return reinterpret_cast(static_cast(sizeof(T))); 734| 0| case FlagOp::kFastTypeId: ------------------ | Branch (734:5): [True: 0, False: 3] ------------------ 735| 0| return const_cast(base_internal::FastTypeId()); 736| 0| case FlagOp::kRuntimeTypeId: ------------------ | Branch (736:5): [True: 0, False: 3] ------------------ 737| 0| return const_cast(GenRuntimeTypeId()); 738| 0| case FlagOp::kParse: { ------------------ | Branch (738:5): [True: 0, False: 3] ------------------ 739| | // Initialize the temporary instance of type T based on current value in 740| | // destination (which is going to be flag's default value). 741| 0| T temp(*static_cast(v2)); 742| 0| if (!absl::ParseFlag(*static_cast(v1), &temp, ------------------ | Branch (742:11): [True: 0, False: 0] ------------------ 743| 0| static_cast(v3))) { 744| 0| return nullptr; 745| 0| } 746| 0| *static_cast(v2) = std::move(temp); 747| 0| return v2; 748| 0| } 749| 0| case FlagOp::kUnparse: ------------------ | Branch (749:5): [True: 0, False: 3] ------------------ 750| 0| *static_cast(v2) = 751| 0| absl::UnparseFlag(*static_cast(v1)); 752| 0| return nullptr; 753| 2| case FlagOp::kValueOffset: { ------------------ | Branch (753:5): [True: 2, False: 1] ------------------ 754| | // Round sizeof(FlagImp) to a multiple of alignof(FlagValue) to get the 755| | // offset of the data. 756| 2| size_t round_to = alignof(FlagValue); 757| 2| size_t offset = 758| 2| (sizeof(FlagImpl) + round_to - 1) / round_to * round_to; 759| 2| return reinterpret_cast(offset); 760| 0| } 761| 3| } 762| 0| return nullptr; 763| 3|} _ZN4absl12lts_2024011614flags_internal13FlagRegistrarIN8fuzztest8internal14TimeBudgetTypeELb1EEC2ERNS1_4FlagIS5_EEPKc: 773| 1| explicit FlagRegistrar(Flag& flag, const char* filename) : flag_(flag) { 774| 1| if (do_register) ------------------ | Branch (774:9): [True: 1, Folded] ------------------ 775| 1| flags_internal::RegisterCommandLineFlag(flag_.impl_, filename); 776| 1| } _ZNK4absl12lts_2024011614flags_internal13FlagRegistrarIN8fuzztest8internal14TimeBudgetTypeELb1EEcvNS1_18FlagRegistrarEmptyEEv: 786| 1| operator FlagRegistrarEmpty() const { return {}; } // NOLINT _ZN4absl12lts_2024011614flags_internal7FlagOpsImEEPvNS1_6FlagOpEPKvS3_S3_: 713| 13|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) { 714| 13| switch (op) { ------------------ | Branch (714:11): [True: 13, False: 0] ------------------ 715| 1| case FlagOp::kAlloc: { ------------------ | Branch (715:5): [True: 1, False: 12] ------------------ 716| 1| std::allocator alloc; 717| 1| return std::allocator_traits>::allocate(alloc, 1); 718| 0| } 719| 1| case FlagOp::kDelete: { ------------------ | Branch (719:5): [True: 1, False: 12] ------------------ 720| 1| T* p = static_cast(v2); 721| 1| p->~T(); 722| 1| std::allocator alloc; 723| 1| std::allocator_traits>::deallocate(alloc, p, 1); 724| 1| return nullptr; 725| 0| } 726| 0| case FlagOp::kCopy: ------------------ | Branch (726:5): [True: 0, False: 13] ------------------ 727| 0| *static_cast(v2) = *static_cast(v1); 728| 0| return nullptr; 729| 1| case FlagOp::kCopyConstruct: ------------------ | Branch (729:5): [True: 1, False: 12] ------------------ 730| 1| new (v2) T(*static_cast(v1)); 731| 1| return nullptr; 732| 3| case FlagOp::kSizeof: ------------------ | Branch (732:5): [True: 3, False: 10] ------------------ 733| 3| return reinterpret_cast(static_cast(sizeof(T))); 734| 1| case FlagOp::kFastTypeId: ------------------ | Branch (734:5): [True: 1, False: 12] ------------------ 735| 1| return const_cast(base_internal::FastTypeId()); 736| 0| case FlagOp::kRuntimeTypeId: ------------------ | Branch (736:5): [True: 0, False: 13] ------------------ 737| 0| return const_cast(GenRuntimeTypeId()); 738| 1| case FlagOp::kParse: { ------------------ | Branch (738:5): [True: 1, False: 12] ------------------ 739| | // Initialize the temporary instance of type T based on current value in 740| | // destination (which is going to be flag's default value). 741| 1| T temp(*static_cast(v2)); 742| 1| if (!absl::ParseFlag(*static_cast(v1), &temp, ------------------ | Branch (742:11): [True: 0, False: 1] ------------------ 743| 1| static_cast(v3))) { 744| 0| return nullptr; 745| 0| } 746| 1| *static_cast(v2) = std::move(temp); 747| 1| return v2; 748| 1| } 749| 0| case FlagOp::kUnparse: ------------------ | Branch (749:5): [True: 0, False: 13] ------------------ 750| 0| *static_cast(v2) = 751| 0| absl::UnparseFlag(*static_cast(v1)); 752| 0| return nullptr; 753| 5| case FlagOp::kValueOffset: { ------------------ | Branch (753:5): [True: 5, False: 8] ------------------ 754| | // Round sizeof(FlagImp) to a multiple of alignof(FlagValue) to get the 755| | // offset of the data. 756| 5| size_t round_to = alignof(FlagValue); 757| 5| size_t offset = 758| 5| (sizeof(FlagImpl) + round_to - 1) / round_to * round_to; 759| 5| return reinterpret_cast(offset); 760| 1| } 761| 13| } 762| 0| return nullptr; 763| 13|} _ZN4absl12lts_2024011614flags_internal13FlagRegistrarImLb1EEC2ERNS1_4FlagImEEPKc: 773| 2| explicit FlagRegistrar(Flag& flag, const char* filename) : flag_(flag) { 774| 2| if (do_register) ------------------ | Branch (774:9): [True: 2, Folded] ------------------ 775| 2| flags_internal::RegisterCommandLineFlag(flag_.impl_, filename); 776| 2| } _ZNK4absl12lts_2024011614flags_internal13FlagRegistrarImLb1EEcvNS1_18FlagRegistrarEmptyEEv: 786| 2| operator FlagRegistrarEmpty() const { return {}; } // NOLINT _ZN4absl12lts_2024011614flags_internal7FlagOpsINSt3__18optionalImEEEEPvNS1_6FlagOpEPKvS6_S6_: 713| 3|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) { 714| 3| switch (op) { ------------------ | Branch (714:11): [True: 3, False: 0] ------------------ 715| 0| case FlagOp::kAlloc: { ------------------ | Branch (715:5): [True: 0, False: 3] ------------------ 716| 0| std::allocator alloc; 717| 0| return std::allocator_traits>::allocate(alloc, 1); 718| 0| } 719| 0| case FlagOp::kDelete: { ------------------ | Branch (719:5): [True: 0, False: 3] ------------------ 720| 0| T* p = static_cast(v2); 721| 0| p->~T(); 722| 0| std::allocator alloc; 723| 0| std::allocator_traits>::deallocate(alloc, p, 1); 724| 0| return nullptr; 725| 0| } 726| 0| case FlagOp::kCopy: ------------------ | Branch (726:5): [True: 0, False: 3] ------------------ 727| 0| *static_cast(v2) = *static_cast(v1); 728| 0| return nullptr; 729| 0| case FlagOp::kCopyConstruct: ------------------ | Branch (729:5): [True: 0, False: 3] ------------------ 730| 0| new (v2) T(*static_cast(v1)); 731| 0| return nullptr; 732| 1| case FlagOp::kSizeof: ------------------ | Branch (732:5): [True: 1, False: 2] ------------------ 733| 1| return reinterpret_cast(static_cast(sizeof(T))); 734| 0| case FlagOp::kFastTypeId: ------------------ | Branch (734:5): [True: 0, False: 3] ------------------ 735| 0| return const_cast(base_internal::FastTypeId()); 736| 0| case FlagOp::kRuntimeTypeId: ------------------ | Branch (736:5): [True: 0, False: 3] ------------------ 737| 0| return const_cast(GenRuntimeTypeId()); 738| 0| case FlagOp::kParse: { ------------------ | Branch (738:5): [True: 0, False: 3] ------------------ 739| | // Initialize the temporary instance of type T based on current value in 740| | // destination (which is going to be flag's default value). 741| 0| T temp(*static_cast(v2)); 742| 0| if (!absl::ParseFlag(*static_cast(v1), &temp, ------------------ | Branch (742:11): [True: 0, False: 0] ------------------ 743| 0| static_cast(v3))) { 744| 0| return nullptr; 745| 0| } 746| 0| *static_cast(v2) = std::move(temp); 747| 0| return v2; 748| 0| } 749| 0| case FlagOp::kUnparse: ------------------ | Branch (749:5): [True: 0, False: 3] ------------------ 750| 0| *static_cast(v2) = 751| 0| absl::UnparseFlag(*static_cast(v1)); 752| 0| return nullptr; 753| 2| case FlagOp::kValueOffset: { ------------------ | Branch (753:5): [True: 2, False: 1] ------------------ 754| | // Round sizeof(FlagImp) to a multiple of alignof(FlagValue) to get the 755| | // offset of the data. 756| 2| size_t round_to = alignof(FlagValue); 757| 2| size_t offset = 758| 2| (sizeof(FlagImpl) + round_to - 1) / round_to * round_to; 759| 2| return reinterpret_cast(offset); 760| 0| } 761| 3| } 762| 0| return nullptr; 763| 3|} _ZN4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__18optionalImEELb1EEC2ERNS1_4FlagIS5_EEPKc: 773| 1| explicit FlagRegistrar(Flag& flag, const char* filename) : flag_(flag) { 774| 1| if (do_register) ------------------ | Branch (774:9): [True: 1, Folded] ------------------ 775| 1| flags_internal::RegisterCommandLineFlag(flag_.impl_, filename); 776| 1| } _ZNK4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__18optionalImEELb1EEcvNS1_18FlagRegistrarEmptyEEv: 786| 1| operator FlagRegistrarEmpty() const { return {}; } // NOLINT _ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_4FlagISA_EEEET_RKT0_: 697| 7| static T InvokeGet(const FlagType& flag) { 698| 7| return flag.Get(); 699| 7| } _ZNK4absl12lts_2024011614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEv: 657| 7| T Get() const { 658| | // See implementation notes in CommandLineFlag::Get(). 659| 7| union U { 660| 7| T value; 661| 7| U() {} 662| 7| ~U() { value.~T(); } 663| 7| }; 664| 7| U u; 665| | 666| |#if !defined(NDEBUG) 667| | impl_.AssertValidType(base_internal::FastTypeId(), &GenRuntimeTypeId); 668| |#endif 669| | 670| 7| if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) { ------------------ | | 178| 7|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 7, False: 0] | | | Branch (178:49): [Folded, False: 7] | | | Branch (178:58): [True: 7, False: 0] | | ------------------ ------------------ 671| 7| impl_.Read(&u.value); 672| 7| } 673| 7| return std::move(u.value); 674| 7| } _ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEvEN1UC2Ev: 661| 7| U() {} _ZNK4absl12lts_2024011614flags_internal9FlagValueINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELNS1_20FlagValueStorageKindE3EE3GetERKNS1_12SequenceLockERS9_: 397| 7| bool Get(const SequenceLock&, T&) const { return false; } _ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEvEN1UD2Ev: 662| 7| ~U() { value.~T(); } _ZNK4absl12lts_2024011614flags_internal8FlagImpl16ValueStorageKindEv: 537| 38| FlagValueStorageKind ValueStorageKind() const { 538| 38| return static_cast(value_storage_kind_); 539| 38| } _ZNK4absl12lts_2024011614flags_internal8FlagImpl11DefaultKindEv: 541| 2| ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()) { 542| 2| return static_cast(def_kind_); 543| 2| } _ZN4absl12lts_2024011614flags_internal5AllocEPFPvNS1_6FlagOpEPKvS2_S2_E: 97| 2|inline void* Alloc(FlagOpFn op) { 98| 2| return op(FlagOp::kAlloc, nullptr, nullptr, nullptr); 99| 2|} _ZN4absl12lts_2024011614flags_internal6DeleteEPFPvNS1_6FlagOpEPKvS2_S2_ES2_: 101| 2|inline void Delete(FlagOpFn op, void* obj) { 102| 2| op(FlagOp::kDelete, nullptr, obj, nullptr); 103| 2|} _ZN4absl12lts_2024011614flags_internal4CopyEPFPvNS1_6FlagOpEPKvS2_S2_ES5_S2_: 105| 1|inline void Copy(FlagOpFn op, const void* src, void* dst) { 106| 1| op(FlagOp::kCopy, src, dst, nullptr); 107| 1|} _ZN4absl12lts_2024011614flags_internal13CopyConstructEPFPvNS1_6FlagOpEPKvS2_S2_ES5_S2_: 110| 13|inline void CopyConstruct(FlagOpFn op, const void* src, void* dst) { 111| 13| op(FlagOp::kCopyConstruct, src, dst, nullptr); 112| 13|} _ZN4absl12lts_2024011614flags_internal5CloneEPFPvNS1_6FlagOpEPKvS2_S2_ES5_: 114| 1|inline void* Clone(FlagOpFn op, const void* obj) { 115| 1| void* res = flags_internal::Alloc(op); 116| 1| flags_internal::CopyConstruct(op, obj, res); 117| 1| return res; 118| 1|} _ZN4absl12lts_2024011614flags_internal5ParseEPFPvNS1_6FlagOpEPKvS2_S2_ENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEES2_PNS8_12basic_stringIcSB_NS8_9allocatorIcEEEE: 121| 2| std::string* error) { 122| 2| return op(FlagOp::kParse, &text, dst, error) != nullptr; 123| 2|} _ZN4absl12lts_2024011614flags_internal6SizeofEPFPvNS1_6FlagOpEPKvS2_S2_E: 131| 12|inline size_t Sizeof(FlagOpFn op) { 132| | // This sequence of casts reverses the sequence from 133| | // `flags_internal::FlagOps()` 134| 12| return static_cast(reinterpret_cast( 135| 12| op(FlagOp::kSizeof, nullptr, nullptr, nullptr))); 136| 12|} _ZN4absl12lts_2024011614flags_internal10FastTypeIdEPFPvNS1_6FlagOpEPKvS2_S2_E: 138| 2|inline FlagFastTypeId FastTypeId(FlagOpFn op) { 139| 2| return reinterpret_cast( 140| 2| op(FlagOp::kFastTypeId, nullptr, nullptr, nullptr)); 141| 2|} _ZN4absl12lts_2024011614flags_internal11ValueOffsetEPFPvNS1_6FlagOpEPKvS2_S2_E: 151| 37|inline ptrdiff_t ValueOffset(FlagOpFn op) { 152| | // This sequence of casts reverses the sequence from 153| | // `flags_internal::FlagOps()` 154| 37| return static_cast(reinterpret_cast( 155| 37| op(FlagOp::kValueOffset, nullptr, nullptr, nullptr))); 156| 37|} _ZN4absl12lts_2024011614flags_internal16InitDefaultValueINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEET_NS1_11EmptyBracesE: 282| 3|constexpr T InitDefaultValue(EmptyBraces) { 283| 3| return T{}; 284| 3|} _ZN4absl12lts_2024011614flags_internal7FlagOpsINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEEPvNS1_6FlagOpEPKvSD_SD_: 713| 13|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) { 714| 13| switch (op) { ------------------ | Branch (714:11): [True: 13, False: 0] ------------------ 715| 0| case FlagOp::kAlloc: { ------------------ | Branch (715:5): [True: 0, False: 13] ------------------ 716| 0| std::allocator alloc; 717| 0| return std::allocator_traits>::allocate(alloc, 1); 718| 0| } 719| 0| case FlagOp::kDelete: { ------------------ | Branch (719:5): [True: 0, False: 13] ------------------ 720| 0| T* p = static_cast(v2); 721| 0| p->~T(); 722| 0| std::allocator alloc; 723| 0| std::allocator_traits>::deallocate(alloc, p, 1); 724| 0| return nullptr; 725| 0| } 726| 0| case FlagOp::kCopy: ------------------ | Branch (726:5): [True: 0, False: 13] ------------------ 727| 0| *static_cast(v2) = *static_cast(v1); 728| 0| return nullptr; 729| 5| case FlagOp::kCopyConstruct: ------------------ | Branch (729:5): [True: 5, False: 8] ------------------ 730| 5| new (v2) T(*static_cast(v1)); 731| 5| return nullptr; 732| 0| case FlagOp::kSizeof: ------------------ | Branch (732:5): [True: 0, False: 13] ------------------ 733| 0| return reinterpret_cast(static_cast(sizeof(T))); 734| 0| case FlagOp::kFastTypeId: ------------------ | Branch (734:5): [True: 0, False: 13] ------------------ 735| 0| return const_cast(base_internal::FastTypeId()); 736| 0| case FlagOp::kRuntimeTypeId: ------------------ | Branch (736:5): [True: 0, False: 13] ------------------ 737| 0| return const_cast(GenRuntimeTypeId()); 738| 0| case FlagOp::kParse: { ------------------ | Branch (738:5): [True: 0, False: 13] ------------------ 739| | // Initialize the temporary instance of type T based on current value in 740| | // destination (which is going to be flag's default value). 741| 0| T temp(*static_cast(v2)); 742| 0| if (!absl::ParseFlag(*static_cast(v1), &temp, ------------------ | Branch (742:11): [True: 0, False: 0] ------------------ 743| 0| static_cast(v3))) { 744| 0| return nullptr; 745| 0| } 746| 0| *static_cast(v2) = std::move(temp); 747| 0| return v2; 748| 0| } 749| 0| case FlagOp::kUnparse: ------------------ | Branch (749:5): [True: 0, False: 13] ------------------ 750| 0| *static_cast(v2) = 751| 0| absl::UnparseFlag(*static_cast(v1)); 752| 0| return nullptr; 753| 8| case FlagOp::kValueOffset: { ------------------ | Branch (753:5): [True: 8, False: 5] ------------------ 754| | // Round sizeof(FlagImp) to a multiple of alignof(FlagValue) to get the 755| | // offset of the data. 756| 8| size_t round_to = alignof(FlagValue); 757| 8| size_t offset = 758| 8| (sizeof(FlagImpl) + round_to - 1) / round_to * round_to; 759| 8| return reinterpret_cast(offset); 760| 0| } 761| 13| } 762| 0| return nullptr; 763| 13|} _ZN4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EEC2ERNS1_4FlagISC_EEPKc: 773| 4| explicit FlagRegistrar(Flag& flag, const char* filename) : flag_(flag) { 774| 4| if (do_register) ------------------ | Branch (774:9): [True: 4, Folded] ------------------ 775| 4| flags_internal::RegisterCommandLineFlag(flag_.impl_, filename); 776| 4| } _ZNO4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EE8OnUpdateEPFvvE: 778| 3| FlagRegistrar OnUpdate(FlagCallbackFunc cb) && { 779| 3| flag_.impl_.SetCallback(cb); 780| 3| return *this; 781| 3| } _ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetINSt3__16vectorINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS9_ISB_EEEENS1_4FlagISD_EEEET_RKT0_: 697| 5| static T InvokeGet(const FlagType& flag) { 698| 5| return flag.Get(); 699| 5| } _ZNK4absl12lts_2024011614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEv: 657| 5| T Get() const { 658| | // See implementation notes in CommandLineFlag::Get(). 659| 5| union U { 660| 5| T value; 661| 5| U() {} 662| 5| ~U() { value.~T(); } 663| 5| }; 664| 5| U u; 665| | 666| |#if !defined(NDEBUG) 667| | impl_.AssertValidType(base_internal::FastTypeId(), &GenRuntimeTypeId); 668| |#endif 669| | 670| 5| if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) { ------------------ | | 178| 5|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 5, False: 0] | | | Branch (178:49): [Folded, False: 5] | | | Branch (178:58): [True: 5, False: 0] | | ------------------ ------------------ 671| 5| impl_.Read(&u.value); 672| 5| } 673| 5| return std::move(u.value); 674| 5| } _ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEvEN1UC2Ev: 661| 5| U() {} _ZNK4absl12lts_2024011614flags_internal9FlagValueINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELNS1_20FlagValueStorageKindE3EE3GetERKNS1_12SequenceLockERSC_: 397| 5| bool Get(const SequenceLock&, T&) const { return false; } _ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEvEN1UD2Ev: 662| 5| ~U() { value.~T(); } _ZNK4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EEcvNS1_18FlagRegistrarEmptyEEv: 786| 4| operator FlagRegistrarEmpty() const { return {}; } // NOLINT _ZN4absl12lts_2024011614flags_internal21PrivateHandleAccessor9ParseFromERNS0_15CommandLineFlagENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_15FlagSettingModeENS1_11ValueSourceERNS5_12basic_stringIcS8_NS5_9allocatorIcEEEE: 58| 2| std::string& error) { 59| 2| return flag.ParseFrom(value, set_mode, source, error); 60| 2|} _ZN4absl12lts_2024011614flags_internal21ProgramInvocationNameEv: 36| 1|std::string ProgramInvocationName() { 37| 1| absl::MutexLock l(&program_name_guard); 38| | 39| 1| return program_name ? *program_name : "UNKNOWN"; ------------------ | Branch (39:10): [True: 0, False: 1] ------------------ 40| 1|} _ZN4absl12lts_2024011614flags_internal24SetProgramInvocationNameENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 49| 1|void SetProgramInvocationName(absl::string_view prog_name_str) { 50| 1| absl::MutexLock l(&program_name_guard); 51| | 52| 1| if (!program_name) ------------------ | Branch (52:7): [True: 1, False: 0] ------------------ 53| 1| program_name = new std::string(prog_name_str); 54| 0| else 55| 0| program_name->assign(prog_name_str.data(), prog_name_str.size()); 56| 1|} _ZNK4absl12lts_2024011614flags_internal12SequenceLock7TryReadEPvPKNSt3__16atomicImEEm: 80| 10| bool TryRead(void* dst, const std::atomic* src, size_t size) const { 81| | // Acquire barrier ensures that no loads done by f() are reordered 82| | // above the first load of the sequence counter. 83| 10| int64_t seq_before = lock_.load(std::memory_order_acquire); 84| 10| if (ABSL_PREDICT_FALSE(seq_before & 1) == 1) return false; ------------------ | | 178| 10|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:49): [Folded, False: 10] | | | Branch (178:58): [True: 4, False: 6] | | ------------------ ------------------ | Branch (84:9): [True: 4, False: 6] ------------------ 85| 6| RelaxedCopyFromAtomic(dst, src, size); 86| | // Another acquire fence ensures that the load of 'lock_' below is 87| | // strictly ordered after the RelaxedCopyToAtomic call above. 88| 6| std::atomic_thread_fence(std::memory_order_acquire); 89| 6| int64_t seq_after = lock_.load(std::memory_order_relaxed); 90| 6| return ABSL_PREDICT_TRUE(seq_before == seq_after); ------------------ | | 179| 6|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true)) | | ------------------ | | | Branch (179:48): [Folded, False: 6] | | | Branch (179:57): [True: 6, False: 0] | | ------------------ ------------------ 91| 10| } _ZN4absl12lts_2024011614flags_internal12SequenceLock21RelaxedCopyFromAtomicEPvPKNSt3__16atomicImEEm: 144| 6| size_t size) { 145| 6| char* dst_byte = static_cast(dst); 146| 13| while (size >= sizeof(uint64_t)) { ------------------ | Branch (146:12): [True: 7, False: 6] ------------------ 147| 7| uint64_t word = src->load(std::memory_order_relaxed); 148| 7| std::memcpy(dst_byte, &word, sizeof(word)); 149| 7| dst_byte += sizeof(word); 150| 7| src++; 151| 7| size -= sizeof(word); 152| 7| } 153| 6| if (size > 0) { ------------------ | Branch (153:9): [True: 5, False: 1] ------------------ 154| 5| uint64_t word = src->load(std::memory_order_relaxed); 155| 5| std::memcpy(dst_byte, &word, size); 156| 5| } 157| 6| } _ZN4absl12lts_2024011614flags_internal12SequenceLock15MarkInitializedEv: 63| 15| void MarkInitialized() { 64| | assert(lock_.load(std::memory_order_relaxed) == kUninitialized); 65| 15| lock_.store(0, std::memory_order_release); 66| 15| } _ZN4absl12lts_2024011614flags_internal12SequenceLock26IncrementModificationCountEv: 134| 2| void IncrementModificationCount() { 135| 2| int64_t val = lock_.load(std::memory_order_relaxed); 136| | assert(val != kUninitialized); 137| 2| lock_.store(val + 2, std::memory_order_relaxed); 138| 2| } _ZN4absl12lts_2024011614flags_internal16HandleUsageFlagsERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEENS2_17basic_string_viewIcS5_EE: 373| 1| absl::string_view program_usage_message) { 374| 1| switch (GetFlagsHelpMode()) { ------------------ | Branch (374:11): [True: 1, False: 0] ------------------ 375| 1| case HelpMode::kNone: ------------------ | Branch (375:5): [True: 1, False: 0] ------------------ 376| 1| break; 377| 0| case HelpMode::kImportant: ------------------ | Branch (377:5): [True: 0, False: 1] ------------------ 378| 0| flags_internal::FlagsHelpImpl( 379| 0| out, flags_internal::GetUsageConfig().contains_help_flags, 380| 0| GetFlagsHelpFormat(), program_usage_message); 381| 0| break; 382| | 383| 0| case HelpMode::kShort: ------------------ | Branch (383:5): [True: 0, False: 1] ------------------ 384| 0| flags_internal::FlagsHelpImpl( 385| 0| out, flags_internal::GetUsageConfig().contains_helpshort_flags, 386| 0| GetFlagsHelpFormat(), program_usage_message); 387| 0| break; 388| | 389| 0| case HelpMode::kFull: ------------------ | Branch (389:5): [True: 0, False: 1] ------------------ 390| 0| flags_internal::FlagsHelp(out, "", GetFlagsHelpFormat(), 391| 0| program_usage_message); 392| 0| break; 393| | 394| 0| case HelpMode::kPackage: ------------------ | Branch (394:5): [True: 0, False: 1] ------------------ 395| 0| flags_internal::FlagsHelpImpl( 396| 0| out, flags_internal::GetUsageConfig().contains_helppackage_flags, 397| 0| GetFlagsHelpFormat(), program_usage_message); 398| 0| break; 399| | 400| 0| case HelpMode::kMatch: { ------------------ | Branch (400:5): [True: 0, False: 1] ------------------ 401| 0| std::string substr = GetFlagsHelpMatchSubstr(); 402| 0| if (substr.empty()) { ------------------ | Branch (402:11): [True: 0, False: 0] ------------------ 403| | // show all options 404| 0| flags_internal::FlagsHelp(out, substr, GetFlagsHelpFormat(), 405| 0| program_usage_message); 406| 0| } else { 407| 0| auto filter_cb = [&substr](const absl::CommandLineFlag& flag) { 408| 0| if (absl::StrContains(flag.Name(), substr)) return true; 409| 0| if (absl::StrContains(flag.Filename(), substr)) return true; 410| 0| if (absl::StrContains(flag.Help(), substr)) return true; 411| | 412| 0| return false; 413| 0| }; 414| 0| flags_internal::FlagsHelpImpl( 415| 0| out, filter_cb, HelpFormat::kHumanReadable, program_usage_message); 416| 0| } 417| 0| break; 418| 0| } 419| 0| case HelpMode::kVersion: ------------------ | Branch (419:5): [True: 0, False: 1] ------------------ 420| 0| if (flags_internal::GetUsageConfig().version_string) ------------------ | Branch (420:11): [True: 0, False: 0] ------------------ 421| 0| out << flags_internal::GetUsageConfig().version_string(); 422| | // Unlike help, we may be asking for version in a script, so return 0 423| 0| break; 424| | 425| 0| case HelpMode::kOnlyCheckArgs: ------------------ | Branch (425:5): [True: 0, False: 1] ------------------ 426| 0| break; 427| 1| } 428| | 429| 1| return GetFlagsHelpMode(); 430| 1|} _ZN4absl12lts_2024011614flags_internal16GetFlagsHelpModeEv: 459| 2|HelpMode GetFlagsHelpMode() { 460| 2| absl::MutexLock l(&help_attributes_guard); 461| 2| return help_mode; 462| 2|} _ZN4absl12lts_2024011614flags_internal9MaybeExitENS1_8HelpModeE: 539| 1|void MaybeExit(HelpMode mode) { 540| 1| switch (mode) { 541| 1| case flags_internal::HelpMode::kNone: ------------------ | Branch (541:5): [True: 1, False: 0] ------------------ 542| 1| return; 543| 0| case flags_internal::HelpMode::kOnlyCheckArgs: ------------------ | Branch (543:5): [True: 0, False: 1] ------------------ 544| 0| case flags_internal::HelpMode::kVersion: ------------------ | Branch (544:5): [True: 0, False: 1] ------------------ 545| 0| std::exit(0); 546| 0| default: // For all the other modes we exit with 1 ------------------ | Branch (546:5): [True: 0, False: 1] ------------------ 547| 0| std::exit(1); 548| 1| } 549| 1|} _ZN4absl12lts_2024011614flags_internal13AbslParseFlagENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPmPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEE: 119| 1|bool AbslParseFlag(absl::string_view text, unsigned long* dst, std::string*) { 120| 1| return ParseFlagImpl(text, *dst); 121| 1|} _ZN4absl12lts_2024011614flags_internal13AbslParseFlagENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEESB_: 172| 1|bool AbslParseFlag(absl::string_view text, std::string* dst, std::string*) { 173| 1| dst->assign(text.data(), text.size()); 174| 1| return true; 175| 1|} marshalling.cc:_ZN4absl12lts_2024011614flags_internalL11NumericBaseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 72| 1|static int NumericBase(absl::string_view text) { 73| 1| if (text.empty()) return 0; ------------------ | Branch (73:7): [True: 0, False: 1] ------------------ 74| 1| size_t num_start = (text[0] == '-' || text[0] == '+') ? 1 : 0; ------------------ | Branch (74:23): [True: 0, False: 1] | Branch (74:41): [True: 0, False: 1] ------------------ 75| 1| const bool hex = (text.size() >= num_start + 2 && text[num_start] == '0' && ------------------ | Branch (75:21): [True: 1, False: 0] | Branch (75:53): [True: 0, False: 1] ------------------ 76| 0| (text[num_start + 1] == 'x' || text[num_start + 1] == 'X')); ------------------ | Branch (76:22): [True: 0, False: 0] | Branch (76:52): [True: 0, False: 0] ------------------ 77| 1| return hex ? 16 : 10; ------------------ | Branch (77:10): [True: 0, False: 1] ------------------ 78| 1|} _ZN4absl12lts_2024011614flags_internal13ParseFlagImplImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERT_: 81| 1|inline bool ParseFlagImpl(absl::string_view text, IntType& dst) { 82| 1| text = absl::StripAsciiWhitespace(text); 83| | 84| 1| return absl::numbers_internal::safe_strtoi_base(text, &dst, 85| 1| NumericBase(text)); 86| 1|} _ZN4absl12lts_202401169ParseFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbNS2_17basic_string_viewIcS5_EEPT_PS8_: 333| 1|inline bool ParseFlag(absl::string_view input, T* dst, std::string* error) { 334| 1| return flags_internal::InvokeParseFlag(input, dst, error); 335| 1|} _ZN4absl12lts_2024011614flags_internal15InvokeParseFlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEbNS3_17basic_string_viewIcS6_EEPT_PS9_: 275| 1|bool InvokeParseFlag(absl::string_view input, T* dst, std::string* err) { 276| | // Comment on next line provides a good compiler error message if T 277| | // does not have AbslParseFlag(absl::string_view, T*, std::string*). 278| 1| return AbslParseFlag(input, dst, err); // Is T missing AbslParseFlag? 279| 1|} _ZN4absl12lts_202401169ParseFlagImEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_PNS2_12basic_stringIcS5_NS2_9allocatorIcEEEE: 333| 1|inline bool ParseFlag(absl::string_view input, T* dst, std::string* error) { 334| 1| return flags_internal::InvokeParseFlag(input, dst, error); 335| 1|} _ZN4absl12lts_2024011614flags_internal15InvokeParseFlagImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_PNS3_12basic_stringIcS6_NS3_9allocatorIcEEEE: 275| 1|bool InvokeParseFlag(absl::string_view input, T* dst, std::string* err) { 276| | // Comment on next line provides a good compiler error message if T 277| | // does not have AbslParseFlag(absl::string_view, T*, std::string*). 278| 1| return AbslParseFlag(input, dst, err); // Is T missing AbslParseFlag? 279| 1|} _ZN4absl12lts_2024011614flags_internal24ParseAbseilFlagsOnlyImplEiPPcRNSt3__16vectorIS2_NS4_9allocatorIS2_EEEERNS5_INS0_16UnrecognizedFlagENS6_ISA_EEEENS1_16UsageFlagsActionE: 744| 1| UsageFlagsAction usage_flag_action) { 745| 1| ABSL_INTERNAL_CHECK(argc > 0, "Missing argv[0]"); ------------------ | | 85| 1| do { \ | | 86| 1| if (ABSL_PREDICT_FALSE(!(condition))) { \ | | ------------------ | | | | 178| 1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | | | ------------------ | | | | | Branch (178:31): [True: 0, False: 1] | | | | | Branch (178:49): [Folded, False: 1] | | | | | Branch (178:58): [True: 0, False: 1] | | | | ------------------ | | ------------------ | | 87| 0| std::string death_message = "Check " #condition " failed: "; \ | | 88| 0| death_message += std::string(message); \ | | 89| 0| ABSL_INTERNAL_LOG(FATAL, death_message); \ | | ------------------ | | | | 76| 0| do { \ | | | | 77| 0| constexpr const char* absl_raw_log_internal_filename = __FILE__; \ | | | | 78| 0| ::absl::raw_log_internal::internal_log_function( \ | | | | 79| 0| ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \ | | | | ------------------ | | | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | | | ------------------ | | | | 80| 0| __LINE__, message); \ | | | | 81| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | | | ------------------ | | | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 225| 0| do { \ | | | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | | | ------------------ | | | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | | | ------------------ | | | | | | | | 229| 0| } while (false) | | | | | | | | ------------------ | | | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 82| 0| } while (0) | | | | ------------------ | | | | | Branch (82:12): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 90| 0| } \ | | 91| 1| } while (0) | | ------------------ | | | Branch (91:12): [Folded, False: 1] | | ------------------ ------------------ 746| | 747| 1| using flags_internal::ArgsList; 748| 1| using flags_internal::specified_flags; 749| | 750| 1| std::vector flagfile_value; 751| 1| std::vector input_args; 752| | 753| | // Once parsing has started we will not allow more flag registrations. 754| 1| flags_internal::FinalizeRegistry(); 755| | 756| | // This routine does not return anything since we abort on failure. 757| 1| flags_internal::CheckDefaultValuesParsingRoundtrip(); 758| | 759| 1| input_args.push_back(ArgsList(argc, argv)); 760| | 761| | // Set program invocation name if it is not set before. 762| 1| if (flags_internal::ProgramInvocationName() == "UNKNOWN") { ------------------ | Branch (762:7): [True: 1, False: 0] ------------------ 763| 1| flags_internal::SetProgramInvocationName(argv[0]); 764| 1| } 765| 1| positional_args.push_back(argv[0]); 766| | 767| 1| absl::MutexLock l(&flags_internal::specified_flags_guard); 768| 1| if (specified_flags == nullptr) { ------------------ | Branch (768:7): [True: 1, False: 0] ------------------ 769| 1| specified_flags = new std::vector; 770| 1| } else { 771| 0| specified_flags->clear(); 772| 0| } 773| | 774| | // Iterate through the list of the input arguments. First level are 775| | // arguments originated from argc/argv. Following levels are arguments 776| | // originated from recursive parsing of flagfile(s). 777| 1| bool success = true; 778| 3| while (!input_args.empty()) { ------------------ | Branch (778:10): [True: 3, False: 0] ------------------ 779| | // First we process the built-in generator flags. 780| 3| success &= flags_internal::HandleGeneratorFlags(input_args, flagfile_value); 781| | 782| | // Select top-most (most recent) arguments list. If it is empty drop it 783| | // and re-try. 784| 3| ArgsList& curr_list = input_args.back(); 785| | 786| | // Every ArgsList starts with real or fake program name, so we can always 787| | // start by skipping it. 788| 3| curr_list.PopFront(); 789| | 790| 3| if (curr_list.Size() == 0) { ------------------ | Branch (790:9): [True: 0, False: 3] ------------------ 791| 0| input_args.pop_back(); 792| 0| continue; 793| 0| } 794| | 795| | // Handle the next argument in the current list. If the stack of argument 796| | // lists contains only one element - we are processing an argument from 797| | // the original argv. 798| 3| absl::string_view arg(curr_list.Front()); 799| 3| bool arg_from_argv = input_args.size() == 1; 800| | 801| | // If argument does not start with '-' or is just "-" - this is 802| | // positional argument. 803| 3| if (!absl::ConsumePrefix(&arg, "-") || arg.empty()) { ------------------ | Branch (803:9): [True: 0, False: 3] | Branch (803:44): [True: 0, False: 3] ------------------ 804| 0| ABSL_INTERNAL_CHECK(arg_from_argv, ------------------ | | 85| 0| do { \ | | 86| 0| if (ABSL_PREDICT_FALSE(!(condition))) { \ | | ------------------ | | | | 178| 0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | | | ------------------ | | | | | Branch (178:31): [True: 0, False: 0] | | | | | Branch (178:49): [Folded, False: 0] | | | | | Branch (178:58): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 87| 0| std::string death_message = "Check " #condition " failed: "; \ | | 88| 0| death_message += std::string(message); \ | | 89| 0| ABSL_INTERNAL_LOG(FATAL, death_message); \ | | ------------------ | | | | 76| 0| do { \ | | | | 77| 0| constexpr const char* absl_raw_log_internal_filename = __FILE__; \ | | | | 78| 0| ::absl::raw_log_internal::internal_log_function( \ | | | | 79| 0| ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \ | | | | ------------------ | | | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | | | ------------------ | | | | 80| 0| __LINE__, message); \ | | | | 81| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | | | ------------------ | | | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 225| 0| do { \ | | | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | | | ------------------ | | | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | | | ------------------ | | | | | | | | 229| 0| } while (false) | | | | | | | | ------------------ | | | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 82| 0| } while (0) | | | | ------------------ | | | | | Branch (82:12): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 90| 0| } \ | | 91| 0| } while (0) | | ------------------ | | | Branch (91:12): [Folded, False: 0] | | ------------------ ------------------ 805| 0| "Flagfile cannot contain positional argument"); 806| | 807| 0| positional_args.push_back(argv[curr_list.FrontIndex()]); 808| 0| continue; 809| 0| } 810| | 811| | // Split the current argument on '=' to deduce the argument flag name and 812| | // value. If flag name is empty it means we've got an "--" argument. Value 813| | // can be empty either if there were no '=' in argument string at all or 814| | // an argument looked like "--foo=". In a latter case is_empty_value is 815| | // true. 816| 3| absl::string_view flag_name; 817| 3| absl::string_view value; 818| 3| bool is_empty_value = false; 819| | 820| 3| std::tie(flag_name, value, is_empty_value) = 821| 3| flags_internal::SplitNameAndValue(arg); 822| | 823| | // Standalone "--" argument indicates that the rest of the arguments are 824| | // positional. We do not support positional arguments in flagfiles. 825| 3| if (flag_name.empty()) { ------------------ | Branch (825:9): [True: 1, False: 2] ------------------ 826| 1| ABSL_INTERNAL_CHECK(arg_from_argv, ------------------ | | 85| 1| do { \ | | 86| 1| if (ABSL_PREDICT_FALSE(!(condition))) { \ | | ------------------ | | | | 178| 1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | | | ------------------ | | | | | Branch (178:31): [True: 0, False: 1] | | | | | Branch (178:49): [Folded, False: 1] | | | | | Branch (178:58): [True: 0, False: 1] | | | | ------------------ | | ------------------ | | 87| 0| std::string death_message = "Check " #condition " failed: "; \ | | 88| 0| death_message += std::string(message); \ | | 89| 0| ABSL_INTERNAL_LOG(FATAL, death_message); \ | | ------------------ | | | | 76| 0| do { \ | | | | 77| 0| constexpr const char* absl_raw_log_internal_filename = __FILE__; \ | | | | 78| 0| ::absl::raw_log_internal::internal_log_function( \ | | | | 79| 0| ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \ | | | | ------------------ | | | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | | | ------------------ | | | | 80| 0| __LINE__, message); \ | | | | 81| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | | | ------------------ | | | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 225| 0| do { \ | | | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | | | ------------------ | | | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | | | ------------------ | | | | | | | | 229| 0| } while (false) | | | | | | | | ------------------ | | | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 82| 0| } while (0) | | | | ------------------ | | | | | Branch (82:12): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 90| 0| } \ | | 91| 1| } while (0) | | ------------------ | | | Branch (91:12): [Folded, False: 1] | | ------------------ ------------------ 827| 1| "Flagfile cannot contain positional argument"); 828| | 829| 1| curr_list.PopFront(); 830| 1| break; 831| 1| } 832| | 833| | // Locate the flag based on flag name. Handle both --foo and --nofoo. 834| 2| CommandLineFlag* flag = nullptr; 835| 2| bool is_negative = false; 836| 2| std::tie(flag, is_negative) = flags_internal::LocateFlag(flag_name); 837| | 838| 2| if (flag == nullptr) { ------------------ | Branch (838:9): [True: 0, False: 2] ------------------ 839| | // Usage flags are not modeled as Abseil flags. Locate them separately. 840| 0| if (flags_internal::DeduceUsageFlags(flag_name, value)) { ------------------ | Branch (840:11): [True: 0, False: 0] ------------------ 841| 0| continue; 842| 0| } 843| 0| unrecognized_flags.emplace_back(arg_from_argv ------------------ | Branch (843:39): [True: 0, False: 0] ------------------ 844| 0| ? UnrecognizedFlag::kFromArgv 845| 0| : UnrecognizedFlag::kFromFlagfile, 846| 0| flag_name); 847| 0| continue; 848| 0| } 849| | 850| | // Deduce flag's value (from this or next argument). 851| 2| bool value_success = true; 852| 2| std::tie(value_success, value) = flags_internal::DeduceFlagValue( 853| 2| *flag, value, is_negative, is_empty_value, &curr_list); 854| 2| success &= value_success; 855| | 856| | // Set the located flag to a new value, unless it is retired. Setting 857| | // retired flag fails, but we ignoring it here while also reporting access 858| | // to retired flag. 859| 2| std::string error; 860| 2| if (!flags_internal::PrivateHandleAccessor::ParseFrom( ------------------ | Branch (860:9): [True: 0, False: 2] ------------------ 861| 2| *flag, value, flags_internal::SET_FLAGS_VALUE, 862| 2| flags_internal::kCommandLine, error)) { 863| 0| if (flag->IsRetired()) continue; ------------------ | Branch (863:11): [True: 0, False: 0] ------------------ 864| | 865| 0| flags_internal::ReportUsageError(error, true); 866| 0| success = false; 867| 2| } else { 868| 2| specified_flags->push_back(flag); 869| 2| } 870| 2| } 871| | 872| 1| flags_internal::ResetGeneratorFlags(flagfile_value); 873| | 874| | // All the remaining arguments are positional. 875| 1| if (!input_args.empty()) { ------------------ | Branch (875:7): [True: 1, False: 0] ------------------ 876| 1| for (size_t arg_index = input_args.back().FrontIndex(); 877| 5| arg_index < static_cast(argc); ++arg_index) { ------------------ | Branch (877:10): [True: 4, False: 1] ------------------ 878| 4| positional_args.push_back(argv[arg_index]); 879| 4| } 880| 1| } 881| | 882| | // Trim and sort the vector. 883| 1| specified_flags->shrink_to_fit(); 884| 1| std::sort(specified_flags->begin(), specified_flags->end(), 885| 1| flags_internal::SpecifiedFlagsCompare{}); 886| | 887| | // Filter out unrecognized flags, which are ok to ignore. 888| 1| std::vector filtered; 889| 1| filtered.reserve(unrecognized_flags.size()); 890| 1| for (const auto& unrecognized : unrecognized_flags) { ------------------ | Branch (890:33): [True: 0, False: 1] ------------------ 891| 0| if (flags_internal::CanIgnoreUndefinedFlag(unrecognized.flag_name)) ------------------ | Branch (891:9): [True: 0, False: 0] ------------------ 892| 0| continue; 893| 0| filtered.push_back(unrecognized); 894| 0| } 895| | 896| 1| std::swap(unrecognized_flags, filtered); 897| | 898| 1| if (!success) { ------------------ | Branch (898:7): [True: 0, False: 1] ------------------ 899| |#if ABSL_FLAGS_STRIP_NAMES 900| | flags_internal::ReportUsageError( 901| | "NOTE: command line flags are disabled in this build", true); 902| |#else 903| 0| flags_internal::HandleUsageFlags(std::cerr, ProgramUsageMessage()); 904| 0|#endif 905| 0| return HelpMode::kFull; // We just need to make sure the exit with 906| | // code 1. 907| 0| } 908| | 909| 1| return usage_flag_action == UsageFlagsAction::kHandleUsage ------------------ | Branch (909:10): [True: 1, False: 0] ------------------ 910| 1| ? flags_internal::HandleUsageFlags(std::cout, 911| 1| ProgramUsageMessage()) 912| 1| : HelpMode::kNone; 913| 1|} _ZN4absl12lts_2024011620ParseAbseilFlagsOnlyEiPPcRNSt3__16vectorIS1_NS3_9allocatorIS1_EEEERNS4_INS0_16UnrecognizedFlagENS5_IS9_EEEE: 919| 1| std::vector& unrecognized_flags) { 920| 1| auto help_mode = flags_internal::ParseAbseilFlagsOnlyImpl( 921| 1| argc, argv, positional_args, unrecognized_flags, 922| 1| flags_internal::UsageFlagsAction::kHandleUsage); 923| | 924| 1| flags_internal::MaybeExit(help_mode); 925| 1|} parse.cc:_ZNK3$_0clEv: 106| 1| .OnUpdate([]() { 107| 1| if (absl::GetFlag(FLAGS_flagfile).empty()) return; ------------------ | Branch (107:11): [True: 1, False: 0] ------------------ 108| | 109| 0| absl::MutexLock l(&absl::flags_internal::processing_checks_guard); 110| | 111| | // Setting this flag twice before it is handled most likely an internal 112| | // error and should be reviewed by developers. 113| 0| if (absl::flags_internal::flagfile_needs_processing) { ------------------ | Branch (113:11): [True: 0, False: 0] ------------------ 114| 0| ABSL_INTERNAL_LOG(WARNING, "flagfile set twice before it is handled"); ------------------ | | 76| 0| do { \ | | 77| 0| constexpr const char* absl_raw_log_internal_filename = __FILE__; \ | | 78| 0| ::absl::raw_log_internal::internal_log_function( \ | | 79| 0| ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \ | | ------------------ | | | | 108| 0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning | | ------------------ | | 80| 0| __LINE__, message); \ | | 81| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | 82| 0| } while (0) | | ------------------ | | | Branch (82:12): [Folded, False: 0] | | ------------------ ------------------ 115| 0| } 116| | 117| 0| absl::flags_internal::flagfile_needs_processing = true; 118| 0| }); parse.cc:_ZNK3$_1clEv: 122| 1| .OnUpdate([]() { 123| 1| if (absl::GetFlag(FLAGS_fromenv).empty()) return; ------------------ | Branch (123:11): [True: 1, False: 0] ------------------ 124| | 125| 0| absl::MutexLock l(&absl::flags_internal::processing_checks_guard); 126| | 127| | // Setting this flag twice before it is handled most likely an internal 128| | // error and should be reviewed by developers. 129| 0| if (absl::flags_internal::fromenv_needs_processing) { ------------------ | Branch (129:11): [True: 0, False: 0] ------------------ 130| 0| ABSL_INTERNAL_LOG(WARNING, "fromenv set twice before it is handled."); ------------------ | | 76| 0| do { \ | | 77| 0| constexpr const char* absl_raw_log_internal_filename = __FILE__; \ | | 78| 0| ::absl::raw_log_internal::internal_log_function( \ | | 79| 0| ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \ | | ------------------ | | | | 108| 0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning | | ------------------ | | 80| 0| __LINE__, message); \ | | 81| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | 82| 0| } while (0) | | ------------------ | | | Branch (82:12): [Folded, False: 0] | | ------------------ ------------------ 131| 0| } 132| | 133| 0| absl::flags_internal::fromenv_needs_processing = true; 134| 0| }); parse.cc:_ZNK3$_2clEv: 138| 1| .OnUpdate([]() { 139| 1| if (absl::GetFlag(FLAGS_tryfromenv).empty()) return; ------------------ | Branch (139:11): [True: 1, False: 0] ------------------ 140| | 141| 0| absl::MutexLock l(&absl::flags_internal::processing_checks_guard); 142| | 143| | // Setting this flag twice before it is handled most likely an internal 144| | // error and should be reviewed by developers. 145| 0| if (absl::flags_internal::tryfromenv_needs_processing) { ------------------ | Branch (145:11): [True: 0, False: 0] ------------------ 146| 0| ABSL_INTERNAL_LOG(WARNING, ------------------ | | 76| 0| do { \ | | 77| 0| constexpr const char* absl_raw_log_internal_filename = __FILE__; \ | | 78| 0| ::absl::raw_log_internal::internal_log_function( \ | | 79| 0| ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \ | | ------------------ | | | | 108| 0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning | | ------------------ | | 80| 0| __LINE__, message); \ | | 81| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | 82| 0| } while (0) | | ------------------ | | | Branch (82:12): [Folded, False: 0] | | ------------------ ------------------ 147| 0| "tryfromenv set twice before it is handled."); 148| 0| } 149| | 150| 0| absl::flags_internal::tryfromenv_needs_processing = true; 151| 0| }); parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_134CheckDefaultValuesParsingRoundtripEv: 322| 1|void CheckDefaultValuesParsingRoundtrip() { 323| |#ifndef NDEBUG 324| | flags_internal::ForEachFlag([&](CommandLineFlag& flag) { 325| | if (flag.IsRetired()) return; 326| | 327| |#define ABSL_FLAGS_INTERNAL_IGNORE_TYPE(T, _) \ 328| | if (flag.IsOfType()) return; 329| | 330| | ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(ABSL_FLAGS_INTERNAL_IGNORE_TYPE) 331| |#undef ABSL_FLAGS_INTERNAL_IGNORE_TYPE 332| | 333| | flags_internal::PrivateHandleAccessor::CheckDefaultValueParsingRoundtrip( 334| | flag); 335| | }); 336| |#endif 337| 1|} parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsListC2EiPPc: 169| 1| ArgsList(int argc, char* argv[]) : args_(argv, argv + argc), next_arg_(0) {} parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_120HandleGeneratorFlagsERNSt3__16vectorINS2_8ArgsListENS3_9allocatorIS5_EEEERNS4_INS3_12basic_stringIcNS3_11char_traitsIcEENS6_IcEEEENS6_ISE_EEEE: 415| 3| std::vector& flagfile_value) { 416| 3| bool success = true; 417| | 418| 3| absl::MutexLock l(&flags_internal::processing_checks_guard); 419| | 420| | // flagfile could have been set either on a command line or 421| | // programmatically before invoking ParseCommandLine. Note that we do not 422| | // actually process arguments specified in the flagfile, but instead 423| | // create a secondary arguments list to be processed along with the rest 424| | // of the command line arguments. Since we always the process most recently 425| | // created list of arguments first, this will result in flagfile argument 426| | // being processed before any other argument in the command line. If 427| | // FLAGS_flagfile contains more than one file name we create multiple new 428| | // levels of arguments in a reverse order of file names. Thus we always 429| | // process arguments from first file before arguments containing in a 430| | // second file, etc. If flagfile contains another 431| | // --flagfile inside of it, it will produce new level of arguments and 432| | // processed before the rest of the flagfile. We are also collecting all 433| | // flagfiles set on original command line. Unlike the rest of the flags, 434| | // this flag can be set multiple times and is expected to be handled 435| | // multiple times. We are collecting them all into a single list and set 436| | // the value of FLAGS_flagfile to that value at the end of the parsing. 437| 3| if (flags_internal::flagfile_needs_processing) { ------------------ | Branch (437:7): [True: 0, False: 3] ------------------ 438| 0| auto flagfiles = absl::GetFlag(FLAGS_flagfile); 439| | 440| 0| if (input_args.size() == 1) { ------------------ | Branch (440:9): [True: 0, False: 0] ------------------ 441| 0| flagfile_value.insert(flagfile_value.end(), flagfiles.begin(), 442| 0| flagfiles.end()); 443| 0| } 444| | 445| 0| success &= ReadFlagfiles(flagfiles, input_args); 446| | 447| 0| flags_internal::flagfile_needs_processing = false; 448| 0| } 449| | 450| | // Similar to flagfile fromenv/tryfromemv can be set both 451| | // programmatically and at runtime on a command line. Unlike flagfile these 452| | // can't be recursive. 453| 3| if (flags_internal::fromenv_needs_processing) { ------------------ | Branch (453:7): [True: 0, False: 3] ------------------ 454| 0| auto flags_list = absl::GetFlag(FLAGS_fromenv); 455| | 456| 0| success &= ReadFlagsFromEnv(flags_list, input_args, true); 457| | 458| 0| flags_internal::fromenv_needs_processing = false; 459| 0| } 460| | 461| 3| if (flags_internal::tryfromenv_needs_processing) { ------------------ | Branch (461:7): [True: 0, False: 3] ------------------ 462| 0| auto flags_list = absl::GetFlag(FLAGS_tryfromenv); 463| | 464| 0| success &= ReadFlagsFromEnv(flags_list, input_args, false); 465| | 466| 0| flags_internal::tryfromenv_needs_processing = false; 467| 0| } 468| | 469| 3| return success; 470| 3|} parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList8PopFrontEv: 179| 4| void PopFront() { next_arg_++; } parse.cc:_ZNK4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList4SizeEv: 176| 3| size_t Size() const { return args_.size() - next_arg_; } parse.cc:_ZNK4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList5FrontEv: 178| 3| absl::string_view Front() const { return args_[next_arg_]; } parse.cc:_ZNK4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList10FrontIndexEv: 177| 1| size_t FrontIndex() const { return next_arg_; } parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_117SplitNameAndValueENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE: 278| 3| absl::string_view arg) { 279| | // Allow -foo and --foo 280| 3| absl::ConsumePrefix(&arg, "-"); 281| | 282| 3| if (arg.empty()) { ------------------ | Branch (282:7): [True: 1, False: 2] ------------------ 283| 1| return std::make_tuple("", "", false); 284| 1| } 285| | 286| 2| auto equal_sign_pos = arg.find('='); 287| | 288| 2| absl::string_view flag_name = arg.substr(0, equal_sign_pos); 289| | 290| 2| absl::string_view value; 291| 2| bool is_empty_value = false; 292| | 293| 2| if (equal_sign_pos != absl::string_view::npos) { ------------------ | Branch (293:7): [True: 2, False: 0] ------------------ 294| 2| value = arg.substr(equal_sign_pos + 1); 295| 2| is_empty_value = value.empty(); 296| 2| } 297| | 298| 2| return std::make_tuple(flag_name, value, is_empty_value); 299| 3|} parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_110LocateFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE: 306| 2|std::tuple LocateFlag(absl::string_view flag_name) { 307| 2| CommandLineFlag* flag = absl::FindCommandLineFlag(flag_name); 308| 2| bool is_negative = false; 309| | 310| 2| if (!flag && absl::ConsumePrefix(&flag_name, "no")) { ------------------ | Branch (310:7): [True: 0, False: 2] | Branch (310:16): [True: 0, False: 0] ------------------ 311| 0| flag = absl::FindCommandLineFlag(flag_name); 312| 0| is_negative = true; 313| 0| } 314| | 315| 2| return std::make_tuple(flag, is_negative); 316| 2|} parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_115DeduceFlagValueERKNS0_15CommandLineFlagENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEbbPNS2_8ArgsListE: 509| 2| ArgsList* curr_list) { 510| | // Value is either an argument suffix after `=` in "--foo=" 511| | // or separate argument in case of "--foo" "". 512| | 513| | // boolean flags have these forms: 514| | // --foo 515| | // --nofoo 516| | // --foo=true 517| | // --foo=false 518| | // --nofoo= is not supported 519| | // --foo is not supported 520| | 521| | // non boolean flags have these forms: 522| | // --foo= 523| | // --foo 524| | // --nofoo is not supported 525| | 526| 2| if (flag.IsOfType()) { ------------------ | Branch (526:7): [True: 0, False: 2] ------------------ 527| 0| if (value.empty()) { ------------------ | Branch (527:9): [True: 0, False: 0] ------------------ 528| 0| if (is_empty_value) { ------------------ | Branch (528:11): [True: 0, False: 0] ------------------ 529| | // "--bool_flag=" case 530| 0| flags_internal::ReportUsageError( 531| 0| absl::StrCat( 532| 0| "Missing the value after assignment for the boolean flag '", 533| 0| flag.Name(), "'"), 534| 0| true); 535| 0| return std::make_tuple(false, ""); 536| 0| } 537| | 538| | // "--bool_flag" case 539| 0| value = is_negative ? "0" : "1"; ------------------ | Branch (539:15): [True: 0, False: 0] ------------------ 540| 0| } else if (is_negative) { ------------------ | Branch (540:16): [True: 0, False: 0] ------------------ 541| | // "--nobool_flag=Y" case 542| 0| flags_internal::ReportUsageError( 543| 0| absl::StrCat("Negative form with assignment is not valid for the " 544| 0| "boolean flag '", 545| 0| flag.Name(), "'"), 546| 0| true); 547| 0| return std::make_tuple(false, ""); 548| 0| } 549| 2| } else if (is_negative) { ------------------ | Branch (549:14): [True: 0, False: 2] ------------------ 550| | // "--noint_flag=1" case 551| 0| flags_internal::ReportUsageError( 552| 0| absl::StrCat("Negative form is not valid for the flag '", flag.Name(), 553| 0| "'"), 554| 0| true); 555| 0| return std::make_tuple(false, ""); 556| 2| } else if (value.empty() && (!is_empty_value)) { ------------------ | Branch (556:14): [True: 0, False: 2] | Branch (556:31): [True: 0, False: 0] ------------------ 557| 0| if (curr_list->Size() == 1) { ------------------ | Branch (557:9): [True: 0, False: 0] ------------------ 558| | // "--int_flag" case 559| 0| flags_internal::ReportUsageError( 560| 0| absl::StrCat("Missing the value for the flag '", flag.Name(), "'"), 561| 0| true); 562| 0| return std::make_tuple(false, ""); 563| 0| } 564| | 565| | // "--int_flag" "10" case 566| 0| curr_list->PopFront(); 567| 0| value = curr_list->Front(); 568| | 569| | // Heuristic to detect the case where someone treats a string arg 570| | // like a bool or just forgets to pass a value: 571| | // --my_string_var --foo=bar 572| | // We look for a flag of string type, whose value begins with a 573| | // dash and corresponds to known flag or standalone --. 574| 0| if (!value.empty() && value[0] == '-' && flag.IsOfType()) { ------------------ | Branch (574:9): [True: 0, False: 0] | Branch (574:27): [True: 0, False: 0] | Branch (574:46): [True: 0, False: 0] ------------------ 575| 0| auto maybe_flag_name = std::get<0>(SplitNameAndValue(value.substr(1))); 576| | 577| 0| if (maybe_flag_name.empty() || ------------------ | Branch (577:11): [True: 0, False: 0] | Branch (577:11): [True: 0, False: 0] ------------------ 578| 0| std::get<0>(LocateFlag(maybe_flag_name)) != nullptr) { ------------------ | Branch (578:11): [True: 0, False: 0] ------------------ 579| | // "--string_flag" "--known_flag" case 580| 0| ABSL_INTERNAL_LOG( ------------------ | | 76| 0| do { \ | | 77| 0| constexpr const char* absl_raw_log_internal_filename = __FILE__; \ | | 78| 0| ::absl::raw_log_internal::internal_log_function( \ | | 79| 0| ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \ | | ------------------ | | | | 108| 0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning | | ------------------ | | 80| 0| __LINE__, message); \ | | 81| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | 82| 0| } while (0) | | ------------------ | | | Branch (82:12): [Folded, False: 0] | | ------------------ ------------------ 581| 0| WARNING, 582| 0| absl::StrCat("Did you really mean to set flag '", flag.Name(), 583| 0| "' to the value '", value, "'?")); 584| 0| } 585| 0| } 586| 0| } 587| | 588| 2| return std::make_tuple(true, value); 589| 2|} parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_119ResetGeneratorFlagsERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE: 474| 1|void ResetGeneratorFlags(const std::vector& flagfile_value) { 475| | // Setting flagfile to the value which collates all the values set on a 476| | // command line and programmatically. So if command line looked like 477| | // --flagfile=f1 --flagfile=f2 the final value of the FLAGS_flagfile flag is 478| | // going to be {"f1", "f2"} 479| 1| if (!flagfile_value.empty()) { ------------------ | Branch (479:7): [True: 0, False: 1] ------------------ 480| 0| absl::SetFlag(&FLAGS_flagfile, flagfile_value); 481| 0| absl::MutexLock l(&flags_internal::processing_checks_guard); 482| 0| flags_internal::flagfile_needs_processing = false; 483| 0| } 484| | 485| | // fromenv/tryfromenv are set to value. 486| 1| if (!absl::GetFlag(FLAGS_fromenv).empty()) { ------------------ | Branch (486:7): [True: 0, False: 1] ------------------ 487| 0| absl::SetFlag(&FLAGS_fromenv, {}); 488| 0| } 489| 1| if (!absl::GetFlag(FLAGS_tryfromenv).empty()) { ------------------ | Branch (489:7): [True: 0, False: 1] ------------------ 490| 0| absl::SetFlag(&FLAGS_tryfromenv, {}); 491| 0| } 492| | 493| 1| absl::MutexLock l(&flags_internal::processing_checks_guard); 494| 1| flags_internal::fromenv_needs_processing = false; 495| 1| flags_internal::tryfromenv_needs_processing = false; 496| 1|} parse.cc:_ZNK4absl12lts_2024011614flags_internal12_GLOBAL__N_121SpecifiedFlagsCompareclEPKNS0_15CommandLineFlagES6_: 86| 1| bool operator()(const CommandLineFlag* a, const CommandLineFlag* b) const { 87| 1| return a->Name() < b->Name(); 88| 1| } _ZN4absl12lts_2024011614flags_internal12FlagRegistry8FindFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE: 99| 2|CommandLineFlag* FlagRegistry::FindFlag(absl::string_view name) { 100| 2| if (finalized_flags_.load(std::memory_order_acquire)) { ------------------ | Branch (100:7): [True: 2, False: 0] ------------------ 101| | // We could save some gcus here if we make `Name()` be non-virtual. 102| | // We could move the `const char*` name to the base class. 103| 2| auto it = std::partition_point( 104| 2| flat_flags_.begin(), flat_flags_.end(), 105| 2| [=](CommandLineFlag* f) { return f->Name() < name; }); 106| 2| if (it != flat_flags_.end() && (*it)->Name() == name) return *it; ------------------ | Branch (106:9): [True: 2, False: 0] | Branch (106:9): [True: 2, False: 0] | Branch (106:36): [True: 2, False: 0] ------------------ 107| 2| } 108| | 109| 0| FlagRegistryLock frl(*this); 110| 0| auto it = flags_.find(name); 111| 0| return it != flags_.end() ? it->second : nullptr; ------------------ | Branch (111:10): [True: 0, False: 0] ------------------ 112| 2|} _ZN4absl12lts_2024011614flags_internal12FlagRegistry12RegisterFlagERNS0_15CommandLineFlagEPKc: 114| 16|void FlagRegistry::RegisterFlag(CommandLineFlag& flag, const char* filename) { 115| 16| if (filename != nullptr && ------------------ | Branch (115:7): [True: 16, False: 0] | Branch (115:7): [True: 0, False: 16] ------------------ 116| 16| flag.Filename() != GetUsageConfig().normalize_filename(filename)) { ------------------ | Branch (116:7): [True: 0, False: 16] ------------------ 117| 0| flags_internal::ReportUsageError( 118| 0| absl::StrCat( 119| 0| "Inconsistency between flag object and registration for flag '", 120| 0| flag.Name(), 121| 0| "', likely due to duplicate flags or an ODR violation. Relevant " 122| 0| "files: ", 123| 0| flag.Filename(), " and ", filename), 124| 0| true); 125| 0| std::exit(1); 126| 0| } 127| | 128| 16| FlagRegistryLock registry_lock(*this); 129| | 130| 16| std::pair ins = 131| 16| flags_.insert(FlagMap::value_type(flag.Name(), &flag)); 132| 16| if (ins.second == false) { // means the name was already in the map ------------------ | Branch (132:7): [True: 0, False: 16] ------------------ 133| 0| CommandLineFlag& old_flag = *ins.first->second; 134| 0| if (flag.IsRetired() != old_flag.IsRetired()) { ------------------ | Branch (134:9): [True: 0, False: 0] ------------------ 135| | // All registrations must agree on the 'retired' flag. 136| 0| flags_internal::ReportUsageError( 137| 0| absl::StrCat( 138| 0| "Retired flag '", flag.Name(), "' was defined normally in file '", 139| 0| (flag.IsRetired() ? old_flag.Filename() : flag.Filename()), "'."), ------------------ | Branch (139:16): [True: 0, False: 0] ------------------ 140| 0| true); 141| 0| } else if (flags_internal::PrivateHandleAccessor::TypeId(flag) != ------------------ | Branch (141:16): [True: 0, False: 0] ------------------ 142| 0| flags_internal::PrivateHandleAccessor::TypeId(old_flag)) { 143| 0| flags_internal::ReportUsageError( 144| 0| absl::StrCat("Flag '", flag.Name(), 145| 0| "' was defined more than once but with " 146| 0| "differing types. Defined in files '", 147| 0| old_flag.Filename(), "' and '", flag.Filename(), "'."), 148| 0| true); 149| 0| } else if (old_flag.IsRetired()) { ------------------ | Branch (149:16): [True: 0, False: 0] ------------------ 150| 0| return; 151| 0| } else if (old_flag.Filename() != flag.Filename()) { ------------------ | Branch (151:16): [True: 0, False: 0] ------------------ 152| 0| flags_internal::ReportUsageError( 153| 0| absl::StrCat("Flag '", flag.Name(), 154| 0| "' was defined more than once (in files '", 155| 0| old_flag.Filename(), "' and '", flag.Filename(), "')."), 156| 0| true); 157| 0| } else { 158| 0| flags_internal::ReportUsageError( 159| 0| absl::StrCat( 160| 0| "Something is wrong with flag '", flag.Name(), "' in file '", 161| 0| flag.Filename(), "'. One possibility: file '", flag.Filename(), 162| 0| "' is being linked both statically and dynamically into this " 163| 0| "executable. e.g. some files listed as srcs to a test and also " 164| 0| "listed as srcs of some shared lib deps of the same test."), 165| 0| true); 166| 0| } 167| | // All cases above are fatal, except for the retired flags. 168| 0| std::exit(1); 169| 0| } 170| 16|} _ZN4absl12lts_2024011614flags_internal12FlagRegistry14GlobalRegistryEv: 172| 19|FlagRegistry& FlagRegistry::GlobalRegistry() { 173| 19| static absl::NoDestructor global_registry; 174| 19| return *global_registry; 175| 19|} _ZN4absl12lts_2024011614flags_internal23RegisterCommandLineFlagERNS0_15CommandLineFlagEPKc: 192| 16|bool RegisterCommandLineFlag(CommandLineFlag& flag, const char* filename) { 193| 16| FlagRegistry::GlobalRegistry().RegisterFlag(flag, filename); 194| 16| return true; 195| 16|} _ZN4absl12lts_2024011614flags_internal16FinalizeRegistryEv: 197| 1|void FinalizeRegistry() { 198| 1| auto& registry = FlagRegistry::GlobalRegistry(); 199| 1| FlagRegistryLock frl(registry); 200| 1| if (registry.finalized_flags_.load(std::memory_order_relaxed)) { ------------------ | Branch (200:7): [True: 0, False: 1] ------------------ 201| | // Was already finalized. Ignore the second time. 202| 0| return; 203| 0| } 204| 1| registry.flat_flags_.reserve(registry.flags_.size()); 205| 16| for (const auto& f : registry.flags_) { ------------------ | Branch (205:22): [True: 16, False: 1] ------------------ 206| 16| registry.flat_flags_.push_back(f.second); 207| 16| } 208| 1| std::sort(std::begin(registry.flat_flags_), std::end(registry.flat_flags_), 209| 1| [](const CommandLineFlag* lhs, const CommandLineFlag* rhs) { 210| 1| return lhs->Name() < rhs->Name(); 211| 1| }); 212| 1| registry.flags_.clear(); 213| 1| registry.finalized_flags_.store(true, std::memory_order_release); 214| 1|} _ZN4absl12lts_2024011619FindCommandLineFlagENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE: 337| 2|CommandLineFlag* FindCommandLineFlag(absl::string_view name) { 338| 2| if (name.empty()) return nullptr; ------------------ | Branch (338:7): [True: 0, False: 2] ------------------ 339| 2| flags_internal::FlagRegistry& registry = 340| 2| flags_internal::FlagRegistry::GlobalRegistry(); 341| 2| return registry.FindFlag(name); 342| 2|} reflection.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_116FlagRegistryLockC2ERNS1_12FlagRegistryE: 90| 17| explicit FlagRegistryLock(FlagRegistry& fr) : fr_(fr) { fr_.Lock(); } _ZN4absl12lts_2024011614flags_internal12FlagRegistry4LockEv: 56| 17| void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock_.Lock(); } reflection.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_116FlagRegistryLockD2Ev: 91| 17| ~FlagRegistryLock() { fr_.Unlock(); } _ZN4absl12lts_2024011614flags_internal12FlagRegistry6UnlockEv: 57| 17| void Unlock() ABSL_UNLOCK_FUNCTION(lock_) { lock_.Unlock(); } _ZN4absl12lts_2024011614flags_internal12FlagRegistryC2Ev: 50| 1| FlagRegistry() = default; reflection.cc:_ZZN4absl12lts_2024011614flags_internal12FlagRegistry8FindFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENK3$_0clEPNS0_15CommandLineFlagE: 105| 8| [=](CommandLineFlag* f) { return f->Name() < name; }); reflection.cc:_ZZN4absl12lts_2024011614flags_internal16FinalizeRegistryEvENK3$_0clEPKNS0_15CommandLineFlagES5_: 209| 53| [](const CommandLineFlag* lhs, const CommandLineFlag* rhs) { 210| 53| return lhs->Name() < rhs->Name(); 211| 53| }); _ZN4absl12lts_2024011619ProgramUsageMessageEv: 57| 1|absl::string_view ProgramUsageMessage() { 58| 1| absl::MutexLock l(&flags_internal::usage_message_guard); 59| | 60| 1| return flags_internal::program_usage_message != nullptr ------------------ | Branch (60:10): [True: 0, False: 1] ------------------ 61| 1| ? absl::string_view(*flags_internal::program_usage_message) 62| 1| : "Warning: SetProgramUsageMessage() never called"; 63| 1|} _ZN4absl12lts_2024011614flags_internal14GetUsageConfigEv: 113| 32|FlagsUsageConfig GetUsageConfig() { 114| 32| absl::MutexLock l(&custom_usage_config_guard); 115| | 116| 32| if (custom_usage_config) return *custom_usage_config; ------------------ | Branch (116:7): [True: 0, False: 32] ------------------ 117| | 118| 32| FlagsUsageConfig default_config; 119| 32| default_config.contains_helpshort_flags = &ContainsHelpshortFlags; 120| 32| default_config.contains_help_flags = &ContainsHelppackageFlags; 121| 32| default_config.contains_helppackage_flags = &ContainsHelppackageFlags; 122| 32| default_config.version_string = &VersionString; 123| 32| default_config.normalize_filename = &NormalizeFilename; 124| | 125| 32| return default_config; 126| 32|} usage_config.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_117NormalizeFilenameENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE: 96| 32|std::string NormalizeFilename(absl::string_view filename) { 97| | // Skip any leading slashes 98| 32| auto pos = filename.find_first_not_of("\\/"); 99| 32| if (pos == absl::string_view::npos) return ""; ------------------ | Branch (99:7): [True: 0, False: 32] ------------------ 100| | 101| 32| filename.remove_prefix(pos); 102| 32| return std::string(filename); 103| 32|} avif_fuzztest_read_image.cc:_ZN4absl12lts_2024011612AnyInvocableIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS2_14default_deleteIS6_EEEERKNS5_8FuzzTestEEEC2IZNS5_17RegistrationToken24GetFuzzTestFuzzerFactoryINS5_27RegistrationWithDomainsBaseIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS5_9NoFixtureEPFvRKSO_SP_iSQ_bbbbtEPvEESE_ONS5_12RegistrationIT0_T1_T_T2_EEEUlSC_E_vEEOS12_: 186| 1| : Impl(internal_any_invocable::ConversionConstruct(), 187| 1| std::forward(f)) {} _ZN4absl12lts_2024011612AnyInvocableIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS2_14default_deleteIS6_EEEERKNS5_8FuzzTestEEEC2EOSE_: 176| 2| AnyInvocable(AnyInvocable&& /*f*/) noexcept = default; init_fuzztest.cc:_ZN4absl12lts_2024011611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEC2IZNS2_19ListRegisteredTestsEvE3$_0vEERKT_: 105| 3| : invoker_(&absl::functional_internal::InvokeObject) { 106| 3| absl::functional_internal::AssertNonNull(f); 107| 3| ptr_.obj = &f; 108| 3| } googletest_adaptor.cc:_ZN4absl12lts_2024011611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEC2IZNS3_30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS3_13ConfigurationEE3$_0vEERKT_: 105| 1| : invoker_(&absl::functional_internal::InvokeObject) { 106| 1| absl::functional_internal::AssertNonNull(f); 107| 1| ptr_.obj = &f; 108| 1| } _ZNK4absl12lts_2024011611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEclES5_: 131| 4| R operator()(Args... args) const { 132| 4| return invoker_(ptr_, std::forward(args)...); 133| 4| } _ZN4absl12lts_2024011622internal_any_invocable12EmptyManagerENS1_14FunctionToCallEPNS1_15TypeErasedStateES4_: 246| 2| TypeErasedState* /*to*/) noexcept {} _ZNK4absl12lts_2024011622internal_any_invocable4ImplIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKNS6_8FuzzTestEEE14ExtractInvokerEv: 831| 1| InvokerType* ExtractInvoker() cv { \ 832| 1| using QualifiedTestType = int cv ref; \ 833| 1| auto* invoker = this->invoker_; \ 834| 1| if (!std::is_const::value && \ ------------------ | Branch (834:11): [Folded, False: 1] ------------------ 835| 1| std::is_rvalue_reference::value) { \ ------------------ | Branch (835:11): [Folded, False: 0] ------------------ 836| 0| ABSL_ASSERT([this]() { \ ------------------ | | 95| 0| (false ? static_cast(expr) : static_cast(0)) | | ------------------ | | | Branch (95:4): [Folded, False: 0] | | ------------------ ------------------ 837| 0| /* We checked that this isn't const above, so const_cast is safe */ \ 838| 0| const_cast(this)->invoker_ = InvokedAfterMove; \ 839| 0| return this->HasValue(); \ 840| 0| }()); \ 841| 0| } \ 842| 1| return invoker; \ 843| 1| } \ avif_fuzztest_read_image.cc:_ZN4absl12lts_2024011622internal_any_invocable4ImplIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKNS6_8FuzzTestEEEC2IZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS6_9NoFixtureEPFvRKSP_SQ_iSR_bbbbtEPvEENS0_12AnyInvocableISE_EEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_EENS1_19ConversionConstructEOS15_: 813| 1| : Core(TypedConversionConstruct< \ 814| 1| typename std::decay::type inv_quals>(), \ 815| 1| std::forward(f)) {} \ avif_fuzztest_read_image.cc:_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEEC2IRKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS6_9NoFixtureEPFvRKSO_SP_iSQ_bbbbtEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_S19_EENS1_24TypedConversionConstructIS15_EEOS13_: 454| 1| explicit CoreImpl(TypedConversionConstruct, F&& f) { 455| 1| using DecayedT = RemoveCVRef; 456| | 457| 1| constexpr TargetType kTargetType = 458| 1| (std::is_pointer::value || ------------------ | Branch (458:10): [Folded, False: 0] ------------------ 459| 0| std::is_member_pointer::value) ------------------ | Branch (459:10): [Folded, False: 0] ------------------ 460| 1| ? TargetType::kPointer 461| 1| : IsCompatibleAnyInvocable::value ------------------ | Branch (461:11): [Folded, False: 1] ------------------ 462| 1| ? TargetType::kCompatibleAnyInvocable 463| 1| : IsAnyInvocable::value ------------------ | Branch (463:11): [Folded, False: 1] ------------------ 464| 1| ? TargetType::kIncompatibleAnyInvocable 465| 1| : TargetType::kOther; 466| | // NOTE: We only use integers instead of enums as template parameters in 467| | // order to work around a bug on C++14 under MSVC 2017. 468| | // See b/236131881. 469| 1| Initialize(std::forward(f)); 470| 1| } avif_fuzztest_read_image.cc:_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEE10InitializeILNSE_10TargetTypeE3ERKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS6_9NoFixtureEPFvRKSP_SQ_iSR_bbbbtEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_S1A_vEEvOS15_: 572| 1| void Initialize(F&& f) { 573| 1| InitializeStorage(std::forward(f)); 574| 1| } avif_fuzztest_read_image.cc:_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEE17InitializeStorageIRKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS6_9NoFixtureEPFvRKSO_SP_iSQ_bbbbtEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_JS19_ETnNS3_9enable_ifIXntsr15IsStoredLocallyINS3_9remove_cvINS3_16remove_referenceIS15_E4typeEE4typeEEE5valueEiE4typeELi0EEEvDpOT0_: 594| 1| void InitializeStorage(Args&&... args) { 595| 1| InitializeRemoteManager>(std::forward(args)...); 596| | // This is set after everything else in case an exception is thrown in an 597| | // earlier step of the initialization. 598| 1| invoker_ = RemoteInvoker; 599| 1| } avif_fuzztest_read_image.cc:_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEE23InitializeRemoteManagerIZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS6_9NoFixtureEPFvRKSO_SP_iSQ_bbbbtEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_JS19_ETnNS3_9enable_ifIXntsr23HasTrivialRemoteStorageIS15_EE5valueEiE4typeELi0EEEvDpOT0_: 633| 1| void InitializeRemoteManager(Args&&... args) { 634| 1| state_.remote.target = ::new T(std::forward(args)...); 635| 1| manager_ = RemoteManagerNontrivial; 636| 1| } avif_fuzztest_read_image.cc:_ZN4absl12lts_2024011622internal_any_invocable23RemoteManagerNontrivialIZN8fuzztest8internal17RegistrationToken24GetFuzzTestFuzzerFactoryINS4_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS4_9NoFixtureEPFvRKSE_SF_iSG_bbbbtEPvEENS0_12AnyInvocableIKFNS8_10unique_ptrINS4_14FuzzTestFuzzerENS8_14default_deleteISR_EEEERKNS4_8FuzzTestEEEEONS4_12RegistrationIT0_T1_T_T2_EEEUlSX_E_EEvNS1_14FunctionToCallEPNS1_15TypeErasedStateES1A_: 340| 2| TypeErasedState* const to) noexcept { 341| 2| static_assert(!IsStoredLocally::value, 342| 2| "Remote storage must only be used for types that do not " 343| 2| "qualify for local storage."); 344| | 345| 2| switch (operation) { ------------------ | Branch (345:11): [True: 2, False: 0] ------------------ 346| 2| case FunctionToCall::relocate_from_to: ------------------ | Branch (346:5): [True: 2, False: 0] ------------------ 347| | // NOTE: Requires that the left-hand operand is already empty. 348| 2| to->remote.target = from->remote.target; 349| 2| return; 350| 0| case FunctionToCall::dispose: ------------------ | Branch (350:5): [True: 0, False: 2] ------------------ 351| 0| ::delete static_cast(from->remote.target); // Must not throw. 352| 0| return; 353| 2| } 354| 0| ABSL_UNREACHABLE(); ------------------ | | 225| 0| do { \ | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | ------------------ | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | ------------------ | | 229| 0| } while (false) | | ------------------ | | | Branch (229:12): [Folded, False: 0] | | ------------------ ------------------ 355| 0|} avif_fuzztest_read_image.cc:_ZN4absl12lts_2024011622internal_any_invocable13RemoteInvokerILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS6_9NoFixtureEPFvRKSJ_SK_iSL_bbbbtEPvEENS0_12AnyInvocableIKFSA_RKNS6_8FuzzTestEEEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSX_E_JSX_EEES11_PNS1_15TypeErasedStateEDpNS1_18ForwardedParameterIT2_E4typeE: 361| 1| ForwardedParameterType

... args) noexcept(SigIsNoexcept) { 362| 1| using RawT = RemoveCVRef; 363| 1| static_assert(!IsStoredLocally::value, 364| 1| "Target object must be in remote storage in order to be " 365| 1| "invoked from it."); 366| | 367| 1| auto& f = *static_cast(state->remote.target); 368| 1| return (InvokeR)(static_cast(f), 369| 1| static_cast>(args)...); 370| 1|} avif_fuzztest_read_image.cc:_ZN4absl12lts_2024011622internal_any_invocable7InvokeRINSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS6_9NoFixtureEPFvRKSJ_SK_iSL_bbbbtEPvEENS0_12AnyInvocableIKFSA_RKNS6_8FuzzTestEEEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSX_E_JSX_ETnNS3_9enable_ifIXntsr3std7is_voidIS13_EE5valueEiE4typeELi0EEES13_OS11_DpOT1_: 137| 1|ReturnType InvokeR(F&& f, P&&... args) { 138| | // GCC 12 has a false-positive -Wmaybe-uninitialized warning here. 139| |#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0) 140| |#pragma GCC diagnostic push 141| |#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" 142| |#endif 143| 1| return absl::base_internal::invoke(std::forward(f), 144| 1| std::forward

(args)...); 145| |#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0) 146| |#pragma GCC diagnostic pop 147| |#endif 148| 1|} _ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEED2Ev: 508| 2| ~CoreImpl() { manager_(FunctionToCall::dispose, &state_, &state_); } _ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEEC2EOSE_: 480| 2| CoreImpl(CoreImpl&& other) noexcept { 481| 2| other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_); 482| 2| manager_ = other.manager_; 483| 2| invoker_ = other.invoker_; 484| 2| other.manager_ = EmptyManager; 485| 2| other.invoker_ = nullptr; 486| 2| } init_fuzztest.cc:_ZN4absl12lts_2024011619functional_internal12InvokeObjectIZN8fuzztest19ListRegisteredTestsEvE3$_0vJRNS3_8internal8FuzzTestEEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE: 75| 3|R InvokeObject(VoidPtr ptr, typename ForwardT::type... args) { 76| 3| auto o = static_cast(ptr.obj); 77| 3| return static_cast( 78| 3| absl::base_internal::invoke(*o, std::forward(args)...)); 79| 3|} init_fuzztest.cc:_ZN4absl12lts_2024011619functional_internal13AssertNonNullIZN8fuzztest19ListRegisteredTestsEvE3$_0EEvRKT_: 101| 3|void AssertNonNull(const F&) {} googletest_adaptor.cc:_ZN4absl12lts_2024011619functional_internal12InvokeObjectIZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS4_13ConfigurationEE3$_0vJRNS4_8FuzzTestEEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE: 75| 1|R InvokeObject(VoidPtr ptr, typename ForwardT::type... args) { 76| 1| auto o = static_cast(ptr.obj); 77| 1| return static_cast( 78| 1| absl::base_internal::invoke(*o, std::forward(args)...)); 79| 1|} googletest_adaptor.cc:_ZN4absl12lts_2024011619functional_internal13AssertNonNullIZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS4_13ConfigurationEE3$_0EEvRKT_: 101| 1|void AssertNonNull(const F&) {} _ZN4absl12lts_2024011613hash_internal15MixingHashState16LowLevelHashImplEPKhm: 63| 6| size_t len) { 64| 6| return LowLevelHash(data, len, Seed(), kHashSalt); 65| 6|} _ZN4absl12lts_2024011613hash_internal15MixingHashState18combine_contiguousES2_PKhm: 1023| 60| size_t size) { 1024| 60| return MixingHashState( 1025| 60| CombineContiguousImpl(hash_state.state_, first, size, 1026| 60| std::integral_constant{})); 1027| 60| } _ZN4absl12lts_2024011613hash_internal15MixingHashStateC2Ev: 1052| 30| MixingHashState() : state_(Seed()) {} _ZN4absl12lts_2024011613hash_internal15MixingHashStateC2Em: 1085| 60| explicit MixingHashState(uint64_t state) : state_(state) {} _ZN4absl12lts_2024011613hash_internal15MixingHashState9Read9To16EPKhm: 1114| 13| size_t len) { 1115| 13| uint64_t low_mem = absl::base_internal::UnalignedLoad64(p); 1116| 13| uint64_t high_mem = absl::base_internal::UnalignedLoad64(p + len - 8); 1117| 13|#ifdef ABSL_IS_LITTLE_ENDIAN 1118| 13| uint64_t most_significant = high_mem; 1119| 13| uint64_t least_significant = low_mem; 1120| |#else 1121| | uint64_t most_significant = low_mem; 1122| | uint64_t least_significant = high_mem; 1123| |#endif 1124| 13| return {least_significant, most_significant}; 1125| 13| } _ZN4absl12lts_2024011613hash_internal15MixingHashState8Read4To8EPKhm: 1128| 41| static uint64_t Read4To8(const unsigned char* p, size_t len) { 1129| 41| uint32_t low_mem = absl::base_internal::UnalignedLoad32(p); 1130| 41| uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4); 1131| 41|#ifdef ABSL_IS_LITTLE_ENDIAN 1132| 41| uint32_t most_significant = high_mem; 1133| 41| uint32_t least_significant = low_mem; 1134| |#else 1135| | uint32_t most_significant = low_mem; 1136| | uint32_t least_significant = high_mem; 1137| |#endif 1138| 41| return (static_cast(most_significant) << (len - 4) * 8) | 1139| 41| least_significant; 1140| 41| } _ZN4absl12lts_2024011613hash_internal15MixingHashState3MixEmm: 1162| 47| ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) { 1163| | // Though the 128-bit product on AArch64 needs two instructions, it is 1164| | // still a good balance between speed and hash quality. 1165| 47| using MultType = 1166| 47| absl::conditional_t; 1167| | // We do the addition in 64-bit space to make sure the 128-bit 1168| | // multiplication is fast. If we were to do it as MultType the compiler has 1169| | // to assume that the high word is non-zero and needs to perform 2 1170| | // multiplications instead of one. 1171| 47| MultType m = state + v; 1172| 47| m *= kMul; 1173| 47| return static_cast(m ^ (m >> (sizeof(m) * 8 / 2))); 1174| 47| } _ZN4absl12lts_2024011613hash_internal15MixingHashState6Hash64EPKhm: 1181| 6| size_t len) { 1182| 6|#ifdef ABSL_HAVE_INTRINSIC_INT128 1183| 6| return LowLevelHashImpl(data, len); 1184| |#else 1185| | return hash_internal::CityHash64(reinterpret_cast(data), len); 1186| |#endif 1187| 6| } _ZN4absl12lts_2024011613hash_internal15MixingHashState4SeedEv: 1205| 36| ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() { 1206| 36|#if (!defined(__clang__) || __clang_major__ > 11) && \ 1207| 36| (!defined(__apple_build_version__) || \ 1208| 36| __apple_build_version__ >= 19558921) // Xcode 12 1209| 36| return static_cast(reinterpret_cast(&kSeed)); 1210| |#else 1211| | // Workaround the absence of 1212| | // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021. 1213| | return static_cast(reinterpret_cast(kSeed)); 1214| |#endif 1215| 36| } _ZN4absl12lts_2024011613hash_internal18PiecewiseChunkSizeEv: 82| 6|constexpr size_t PiecewiseChunkSize() { return 1024; } _ZN4absl12lts_2024011613hash_internal15MixingHashState21CombineContiguousImplEmPKhmNSt3__117integral_constantIiLi8EEE: 1247| 60| std::integral_constant /* sizeof_size_t */) { 1248| | // For large values we use LowLevelHash or CityHash depending on the platform, 1249| | // for small ones we just use a multiplicative hash. 1250| 60| uint64_t v; 1251| 60| if (len > 16) { ------------------ | Branch (1251:7): [True: 6, False: 54] ------------------ 1252| 6| if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) { ------------------ | | 178| 6|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 6] | | | Branch (178:49): [Folded, False: 6] | | | Branch (178:58): [True: 0, False: 6] | | ------------------ ------------------ 1253| 0| return CombineLargeContiguousImpl64(state, first, len); 1254| 0| } 1255| 6| v = Hash64(first, len); 1256| 54| } else if (len > 8) { ------------------ | Branch (1256:14): [True: 13, False: 41] ------------------ 1257| | // This hash function was constructed by the ML-driven algorithm discovery 1258| | // using reinforcement learning. We fed the agent lots of inputs from 1259| | // microbenchmarks, SMHasher, low hamming distance from generated inputs and 1260| | // picked up the one that was good on micro and macrobenchmarks. 1261| 13| auto p = Read9To16(first, len); 1262| 13| uint64_t lo = p.first; 1263| 13| uint64_t hi = p.second; 1264| | // Rotation by 53 was found to be most often useful when discovering these 1265| | // hashing algorithms with ML techniques. 1266| 13| lo = absl::rotr(lo, 53); 1267| 13| state += kMul; 1268| 13| lo += state; 1269| 13| state ^= hi; 1270| 13| uint128 m = state; 1271| 13| m *= lo; 1272| 13| return static_cast(m ^ (m >> 64)); 1273| 41| } else if (len >= 4) { ------------------ | Branch (1273:14): [True: 41, False: 0] ------------------ 1274| 41| v = Read4To8(first, len); 1275| 41| } else if (len > 0) { ------------------ | Branch (1275:14): [True: 0, False: 0] ------------------ 1276| 0| v = Read1To3(first, len); 1277| 0| } else { 1278| | // Empty ranges have no effect. 1279| 0| return state; 1280| 0| } 1281| 47| return Mix(state, v); 1282| 60|} _ZNK4absl12lts_2024011613hash_internal8HashImplINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEclERKS7_: 1299| 30| size_t operator()(const T& value) const { 1300| 30| return MixingHashState::hash(value); 1301| 30| } _ZN4absl12lts_2024011613hash_internal15MixingHashState4hashINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETnNS4_9enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSA_: 1045| 30| static size_t hash(const T& value) { 1046| 30| return static_cast(combine(MixingHashState{}, value).state_); 1047| 30| } _ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEES3_S3_RKT_DpRKT0_: 1310| 30|H HashStateBase::combine(H state, const T& value, const Ts&... values) { 1311| 30| return H::combine(hash_internal::HashSelect::template Apply::Invoke( 1312| 30| std::move(state), value), 1313| 30| values...); 1314| 30|} _ZN4absl12lts_2024011613hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEENS6_9enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESC_E4typeESC_RKT0_: 937| 30| H> { 938| 30| return AbslHashValue(std::move(state), value); 939| 30| } _ZN4absl12lts_2024011613hash_internal13AbslHashValueINS1_15MixingHashStateEEET_S4_NSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE: 557| 30|H AbslHashValue(H hash_state, absl::string_view str) { 558| 30| return H::combine( 559| 30| H::combine_contiguous(std::move(hash_state), str.data(), str.size()), 560| 30| str.size()); 561| 30|} _ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE18combine_contiguousIcEES3_S3_PKT_m: 1319| 30|H HashStateBase::combine_contiguous(H state, const T* data, size_t size) { 1320| 30| return hash_internal::hash_range_or_bytes(std::move(state), data, size); 1321| 30|} _ZN4absl12lts_2024011613hash_internal19hash_range_or_bytesINS1_15MixingHashStateEcEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES7_PKS6_m: 885| 30|hash_range_or_bytes(H hash_state, const T* data, size_t size) { 886| 30| const auto* bytes = reinterpret_cast(data); 887| 30| return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size); 888| 30|} _ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineImJEEES3_S3_RKT_DpRKT0_: 1310| 30|H HashStateBase::combine(H state, const T& value, const Ts&... values) { 1311| 30| return H::combine(hash_internal::HashSelect::template Apply::Invoke( 1312| 30| std::move(state), value), 1313| 30| values...); 1314| 30|} _ZN4absl12lts_2024011613hash_internal10HashSelect24UniquelyRepresentedProbe6InvokeINS1_15MixingHashStateEmEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES9_RKS8_: 927| 30| -> absl::enable_if_t::value, H> { 928| 30| return hash_internal::hash_bytes(std::move(state), value); 929| 30| } _ZN4absl12lts_2024011613hash_internal10hash_bytesINS1_15MixingHashStateEmEET_S4_RKT0_: 340| 30|H hash_bytes(H hash_state, const T& value) { 341| 30| const unsigned char* start = reinterpret_cast(&value); 342| 30| return H::combine_contiguous(std::move(hash_state), start, sizeof(value)); 343| 30|} _ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineES3_: 234| 60| static H combine(H state) { return state; } _ZN4absl12lts_2024011613hash_internal12LowLevelHashEPKvmmPKm: 32| 6| const uint64_t salt[5]) { 33| | // Prefetch the cacheline that data resides in. 34| 6| PrefetchToLocalCache(data); 35| 6| const uint8_t* ptr = static_cast(data); 36| 6| uint64_t starting_length = static_cast(len); 37| 6| uint64_t current_state = seed ^ salt[0]; 38| | 39| 6| if (len > 64) { ------------------ | Branch (39:7): [True: 0, False: 6] ------------------ 40| | // If we have more than 64 bytes, we're going to handle chunks of 64 41| | // bytes at a time. We're going to build up two separate hash states 42| | // which we will then hash together. 43| 0| uint64_t duplicated_state = current_state; 44| | 45| 0| do { 46| | // Always prefetch the next cacheline. 47| 0| PrefetchToLocalCache(ptr + ABSL_CACHELINE_SIZE); ------------------ | | 77| 0|#define ABSL_CACHELINE_SIZE 64 ------------------ 48| | 49| 0| uint64_t a = absl::base_internal::UnalignedLoad64(ptr); 50| 0| uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8); 51| 0| uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16); 52| 0| uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24); 53| 0| uint64_t e = absl::base_internal::UnalignedLoad64(ptr + 32); 54| 0| uint64_t f = absl::base_internal::UnalignedLoad64(ptr + 40); 55| 0| uint64_t g = absl::base_internal::UnalignedLoad64(ptr + 48); 56| 0| uint64_t h = absl::base_internal::UnalignedLoad64(ptr + 56); 57| | 58| 0| uint64_t cs0 = Mix(a ^ salt[1], b ^ current_state); 59| 0| uint64_t cs1 = Mix(c ^ salt[2], d ^ current_state); 60| 0| current_state = (cs0 ^ cs1); 61| | 62| 0| uint64_t ds0 = Mix(e ^ salt[3], f ^ duplicated_state); 63| 0| uint64_t ds1 = Mix(g ^ salt[4], h ^ duplicated_state); 64| 0| duplicated_state = (ds0 ^ ds1); 65| | 66| 0| ptr += 64; 67| 0| len -= 64; 68| 0| } while (len > 64); ------------------ | Branch (68:14): [True: 0, False: 0] ------------------ 69| | 70| 0| current_state = current_state ^ duplicated_state; 71| 0| } 72| | 73| | // We now have a data `ptr` with at most 64 bytes and the current state 74| | // of the hashing state machine stored in current_state. 75| 14| while (len > 16) { ------------------ | Branch (75:10): [True: 8, False: 6] ------------------ 76| 8| uint64_t a = absl::base_internal::UnalignedLoad64(ptr); 77| 8| uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8); 78| | 79| 8| current_state = Mix(a ^ salt[1], b ^ current_state); 80| | 81| 8| ptr += 16; 82| 8| len -= 16; 83| 8| } 84| | 85| | // We now have a data `ptr` with at most 16 bytes. 86| 6| uint64_t a = 0; 87| 6| uint64_t b = 0; 88| 6| if (len > 8) { ------------------ | Branch (88:7): [True: 0, False: 6] ------------------ 89| | // When we have at least 9 and at most 16 bytes, set A to the first 64 90| | // bits of the input and B to the last 64 bits of the input. Yes, they will 91| | // overlap in the middle if we are working with less than the full 16 92| | // bytes. 93| 0| a = absl::base_internal::UnalignedLoad64(ptr); 94| 0| b = absl::base_internal::UnalignedLoad64(ptr + len - 8); 95| 6| } else if (len > 3) { ------------------ | Branch (95:14): [True: 4, False: 2] ------------------ 96| | // If we have at least 4 and at most 8 bytes, set A to the first 32 97| | // bits and B to the last 32 bits. 98| 4| a = absl::base_internal::UnalignedLoad32(ptr); 99| 4| b = absl::base_internal::UnalignedLoad32(ptr + len - 4); 100| 4| } else if (len > 0) { ------------------ | Branch (100:14): [True: 2, False: 0] ------------------ 101| | // If we have at least 1 and at most 3 bytes, read all of the provided 102| | // bits into A, with some adjustments. 103| 2| a = static_cast((ptr[0] << 16) | (ptr[len >> 1] << 8) | 104| 2| ptr[len - 1]); 105| 2| b = 0; 106| 2| } else { 107| 0| a = 0; 108| 0| b = 0; 109| 0| } 110| | 111| 6| uint64_t w = Mix(a ^ salt[1], b ^ current_state); 112| 6| uint64_t z = salt[1] ^ starting_length; 113| 6| return Mix(w, z); 114| 6|} low_level_hash.cc:_ZN4absl12lts_2024011613hash_internalL3MixEmm: 25| 20|static uint64_t Mix(uint64_t v0, uint64_t v1) { 26| 20| absl::uint128 p = v0; 27| 20| p *= v1; 28| 20| return absl::Uint128Low64(p) ^ absl::Uint128High64(p); 29| 20|} _ZN4absl12lts_202401164rotrImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueES4_E4typeES4_i: 75| 13| rotr(T x, int s) noexcept { 76| 13| return numeric_internal::RotateRight(x, s); 77| 13|} _ZN4absl12lts_2024011611countr_zeroIjEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_: 118| 8| countr_zero(T x) noexcept { 119| 8| return numeric_internal::CountTrailingZeroes(x); 120| 8|} _ZN4absl12lts_2024011611countr_zeroItEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_: 118| 35| countr_zero(T x) noexcept { 119| 35| return numeric_internal::CountTrailingZeroes(x); 120| 35|} _ZN4absl12lts_202401167uint128mLES1_: 628| 20|inline uint128& uint128::operator*=(uint128 other) { 629| 20| *this = *this * other; 630| 20| return *this; 631| 20|} _ZN4absl12lts_2024011612Uint128Low64ENS0_7uint128E: 643| 20|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; } _ZN4absl12lts_2024011613Uint128High64ENS0_7uint128E: 645| 20|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; } _ZNK4absl12lts_202401167uint128cvoEv: 776| 40|constexpr uint128::operator unsigned __int128() const { 777| 40| return (static_cast(hi_) << 64) + lo_; 778| 40|} _ZN4absl12lts_20240116mlENS0_7uint128ES1_: 982| 20|inline uint128 operator*(uint128 lhs, uint128 rhs) { 983| 20|#if defined(ABSL_HAVE_INTRINSIC_INT128) 984| | // TODO(strel) Remove once alignment issues are resolved and unsigned __int128 985| | // can be used for uint128 storage. 986| 20| return static_cast(lhs) * 987| 20| static_cast(rhs); 988| |#elif defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC) 989| | uint64_t carry; 990| | uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry); 991| | return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) + 992| | Uint128High64(lhs) * Uint128Low64(rhs) + carry, 993| | low); 994| |#else // ABSL_HAVE_INTRINSIC128 995| | uint64_t a32 = Uint128Low64(lhs) >> 32; 996| | uint64_t a00 = Uint128Low64(lhs) & 0xffffffff; 997| | uint64_t b32 = Uint128Low64(rhs) >> 32; 998| | uint64_t b00 = Uint128Low64(rhs) & 0xffffffff; 999| | uint128 result = 1000| | MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) + 1001| | Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32, 1002| | a00 * b00); 1003| | result += uint128(a32 * b00) << 32; 1004| | result += uint128(a00 * b32) << 32; 1005| | return result; 1006| |#endif // ABSL_HAVE_INTRINSIC128 1007| 20|} _ZN4absl12lts_202401167uint128C2Eo: 674| 20| : lo_{static_cast(v & ~uint64_t{0})}, 675| 20| hi_{static_cast(v >> 64)} {} _ZN4absl12lts_202401167uint128C2Em: 665| 40|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {} _ZN4absl12lts_2024011616numeric_internal28CountTrailingZeroesNonzero32Ej: 251| 8|CountTrailingZeroesNonzero32(uint32_t x) { 252| 8|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz) 253| 8| static_assert(sizeof(unsigned int) == sizeof(x), 254| 8| "__builtin_ctz does not take 32-bit arg"); 255| 8| return __builtin_ctz(x); 256| |#elif defined(_MSC_VER) && !defined(__clang__) 257| | unsigned long result = 0; // NOLINT(runtime/int) 258| | _BitScanForward(&result, x); 259| | return result; 260| |#else 261| | int c = 31; 262| | x &= ~x + 1; 263| | if (x & 0x0000FFFF) c -= 16; 264| | if (x & 0x00FF00FF) c -= 8; 265| | if (x & 0x0F0F0F0F) c -= 4; 266| | if (x & 0x33333333) c -= 2; 267| | if (x & 0x55555555) c -= 1; 268| | return c; 269| |#endif 270| 8|} _ZN4absl12lts_2024011616numeric_internal28CountTrailingZeroesNonzero16Et: 305| 35|CountTrailingZeroesNonzero16(uint16_t x) { 306| 35|#if ABSL_HAVE_BUILTIN(__builtin_ctzs) 307| 35| static_assert(sizeof(unsigned short) == sizeof(x), // NOLINT(runtime/int) 308| 35| "__builtin_ctzs does not take 16-bit arg"); 309| 35| return __builtin_ctzs(x); 310| |#else 311| | return CountTrailingZeroesNonzero32(x); 312| |#endif 313| 35|} _ZN4absl12lts_2024011616numeric_internal11RotateRightImEET_S3_i: 75| 13| T x, int s) noexcept { 76| 13| static_assert(std::is_unsigned::value, "T must be unsigned"); 77| 13| static_assert(IsPowerOf2(std::numeric_limits::digits), 78| 13| "T must have a power-of-2 size"); 79| | 80| 13| return static_cast(x >> (s & (std::numeric_limits::digits - 1))) | 81| 13| static_cast(x << ((-s) & (std::numeric_limits::digits - 1))); 82| 13|} _ZN4absl12lts_2024011616numeric_internal19CountTrailingZeroesIjEEiT_: 317| 8|CountTrailingZeroes(T x) noexcept { 318| 8| static_assert(std::is_unsigned::value, "T must be unsigned"); 319| 8| static_assert(IsPowerOf2(std::numeric_limits::digits), 320| 8| "T must have a power-of-2 size"); 321| 8| static_assert(sizeof(T) <= sizeof(uint64_t), "T too large"); 322| 8| return x == 0 ? std::numeric_limits::digits ------------------ | Branch (322:10): [True: 0, False: 8] ------------------ 323| 8| : (sizeof(T) <= sizeof(uint16_t) ------------------ | Branch (323:20): [Folded, False: 8] ------------------ 324| 8| ? CountTrailingZeroesNonzero16(static_cast(x)) 325| 8| : (sizeof(T) <= sizeof(uint32_t) ------------------ | Branch (325:27): [True: 8, Folded] ------------------ 326| 8| ? CountTrailingZeroesNonzero32( 327| 8| static_cast(x)) 328| 8| : CountTrailingZeroesNonzero64(x))); 329| 8|} _ZN4absl12lts_2024011616numeric_internal19CountTrailingZeroesItEEiT_: 317| 35|CountTrailingZeroes(T x) noexcept { 318| 35| static_assert(std::is_unsigned::value, "T must be unsigned"); 319| 35| static_assert(IsPowerOf2(std::numeric_limits::digits), 320| 35| "T must have a power-of-2 size"); 321| 35| static_assert(sizeof(T) <= sizeof(uint64_t), "T too large"); 322| 35| return x == 0 ? std::numeric_limits::digits ------------------ | Branch (322:10): [True: 0, False: 35] ------------------ 323| 35| : (sizeof(T) <= sizeof(uint16_t) ------------------ | Branch (323:20): [True: 35, Folded] ------------------ 324| 35| ? CountTrailingZeroesNonzero16(static_cast(x)) 325| 35| : (sizeof(T) <= sizeof(uint32_t) ------------------ | Branch (325:27): [True: 0, Folded] ------------------ 326| 0| ? CountTrailingZeroesNonzero32( 327| 0| static_cast(x)) 328| 0| : CountTrailingZeroesNonzero64(x))); 329| 35|} _ZN4absl12lts_2024011615random_internal24InitDiscreteDistributionEPNSt3__16vectorIdNS2_9allocatorIdEEEE: 24| 1| std::vector* probabilities) { 25| | // The empty-case should already be handled by the constructor. 26| 1| assert(probabilities); 27| 1| assert(!probabilities->empty()); 28| | 29| | // Step 1. Normalize the input probabilities to 1.0. 30| 1| double sum = std::accumulate(std::begin(*probabilities), 31| 1| std::end(*probabilities), 0.0); 32| 1| if (std::fabs(sum - 1.0) > 1e-6) { ------------------ | Branch (32:7): [True: 1, False: 0] ------------------ 33| | // Scale `probabilities` only when the sum is too far from 1.0. Scaling 34| | // unconditionally will alter the probabilities slightly. 35| 1| for (double& item : *probabilities) { ------------------ | Branch (35:23): [True: 1, False: 1] ------------------ 36| 1| item = item / sum; 37| 1| } 38| 1| } 39| | 40| | // Step 2. At this point `probabilities` is set to the conditional 41| | // probabilities of each element which sum to 1.0, to within reasonable error. 42| | // These values are used to construct the proportional probability tables for 43| | // the selection phases of Walker's Aliasing algorithm. 44| | // 45| | // To construct the table, pick an element which is under-full (i.e., an 46| | // element for which `(*probabilities)[i] < 1.0/n`), and pair it with an 47| | // element which is over-full (i.e., an element for which 48| | // `(*probabilities)[i] > 1.0/n`). The smaller value can always be retired. 49| | // The larger may still be greater than 1.0/n, or may now be less than 1.0/n, 50| | // and put back onto the appropriate collection. 51| 1| const size_t n = probabilities->size(); 52| 1| std::vector> q; 53| 1| q.reserve(n); 54| | 55| 1| std::vector over; 56| 1| std::vector under; 57| 1| size_t idx = 0; 58| 1| for (const double item : *probabilities) { ------------------ | Branch (58:26): [True: 1, False: 1] ------------------ 59| 1| assert(item >= 0); 60| 1| const double v = item * n; 61| 1| q.emplace_back(v, 0); 62| 1| if (v < 1.0) { ------------------ | Branch (62:9): [True: 0, False: 1] ------------------ 63| 0| under.push_back(idx++); 64| 1| } else { 65| 1| over.push_back(idx++); 66| 1| } 67| 1| } 68| 1| while (!over.empty() && !under.empty()) { ------------------ | Branch (68:10): [True: 1, False: 0] | Branch (68:27): [True: 0, False: 1] ------------------ 69| 0| auto lo = under.back(); 70| 0| under.pop_back(); 71| 0| auto hi = over.back(); 72| 0| over.pop_back(); 73| | 74| 0| q[lo].second = hi; 75| 0| const double r = q[hi].first - (1.0 - q[lo].first); 76| 0| q[hi].first = r; 77| 0| if (r < 1.0) { ------------------ | Branch (77:9): [True: 0, False: 0] ------------------ 78| 0| under.push_back(hi); 79| 0| } else { 80| 0| over.push_back(hi); 81| 0| } 82| 0| } 83| | 84| | // Due to rounding errors, there may be un-paired elements in either 85| | // collection; these should all be values near 1.0. For these values, set `q` 86| | // to 1.0 and set the alternate to the identity. 87| 1| for (auto i : over) { ------------------ | Branch (87:15): [True: 1, False: 1] ------------------ 88| 1| q[i] = {1.0, i}; 89| 1| } 90| 1| for (auto i : under) { ------------------ | Branch (90:15): [True: 0, False: 1] ------------------ 91| 0| q[i] = {1.0, i}; 92| 0| } 93| 1| return q; 94| 1|} _ZN4absl12lts_2024011621discrete_distributionIiEC2Ev: 111| 1| discrete_distribution() : param_() {} _ZN4absl12lts_2024011621discrete_distributionIiE10param_typeC2Ev: 60| 1| param_type() { init(); } _ZN4absl12lts_2024011621discrete_distributionIiE10param_type4initEv: 183| 2|void discrete_distribution::param_type::init() { 184| 2| if (p_.empty()) { ------------------ | Branch (184:7): [True: 1, False: 1] ------------------ 185| 1| p_.push_back(1.0); 186| 1| q_.emplace_back(1.0, 0); 187| 1| } else { 188| | assert(n() <= (std::numeric_limits::max)()); 189| 1| q_ = random_internal::InitDiscreteDistribution(&p_); 190| 1| } 191| 2|} _ZN4absl12lts_2024011621discrete_distributionIiEC2INSt3__111__wrap_iterIPdEEEET_S8_: 117| 1| : param_(begin, end) {} _ZN4absl12lts_2024011621discrete_distributionIiE10param_typeC2INSt3__111__wrap_iterIPdEEEET_S9_: 64| 1| : p_(begin, end) { 65| 1| init(); 66| 1| } _ZN4absl12lts_202401167UniformIjRNS0_15random_internal17NonsecureURBGBaseINS2_13randen_engineImEENS2_17RandenPoolSeedSeqEEEEENSt3__19enable_ifIXntsr3std9is_signedIT_EE5valueESB_E4typeEOT0_: 212| 8|Uniform(URBG&& urbg) { // NOLINT(runtime/references) 213| 8| using gen_t = absl::decay_t; 214| 8| using distribution_t = random_internal::UniformDistributionWrapper; 215| | 216| 8| return random_internal::DistributionCaller::template Call< 217| 8| distribution_t>(&urbg); 218| 8|} _ZN4absl12lts_2024011615random_internal18DistributionCallerINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEE4CallINS1_26UniformDistributionWrapperIjEEJEEENT_11result_typeEPS7_DpOT0_: 85| 8| static typename DistrT::result_type Call(URBG* urbg, Args&&... args) { 86| 8| return Impl(HasInvokeMock{}, urbg, 87| 8| std::forward(args)...); 88| 8| } _ZN4absl12lts_2024011615random_internal18DistributionCallerINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEE4ImplINS1_26UniformDistributionWrapperIjEEJEEENT_11result_typeENSt3__117integral_constantIbLb0EEEPS7_DpOT0_: 59| 8| Args&&... args) { 60| 8| DistrT dist(std::forward(args)...); 61| 8| return dist(*urbg); 62| 8| } _ZN4absl12lts_2024011615random_internal15FastUniformBitsIjEclINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEEEjRT_: 122| 8|FastUniformBits::operator()(URBG& g) { // NOLINT(runtime/references) 123| | // kRangeMask is the mask used when sampling variates from the URBG when the 124| | // width of the URBG range is not a power of 2. 125| | // Y = (2 ^ kRange) - 1 126| 8| static_assert((URBG::max)() > (URBG::min)(), 127| 8| "URBG::max and URBG::min may not be equal."); 128| | 129| 8| using tag = absl::conditional_t()), 130| 8| SimplifiedLoopTag, RejectionLoopTag>; 131| 8| return Generate(g, tag{}); 132| 8|} _ZN4absl12lts_2024011615random_internal15FastUniformBitsIjE8GenerateINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEEEjRT_NS1_17SimplifiedLoopTagE: 138| 8| SimplifiedLoopTag) { 139| | // The simplified version of FastUniformBits works only on URBGs that have 140| | // a range that is a power of 2. In this case we simply loop and shift without 141| | // attempting to balance the bits across calls. 142| 8| static_assert(IsPowerOfTwoOrZero(RangeSize()), 143| 8| "incorrect Generate tag for URBG instance"); 144| | 145| 8| static constexpr size_t kResultBits = 146| 8| std::numeric_limits::digits; 147| 8| static constexpr size_t kUrbgBits = NumBits(); 148| 8| static constexpr size_t kIters = 149| 8| (kResultBits / kUrbgBits) + (kResultBits % kUrbgBits != 0); 150| 8| static constexpr size_t kShift = (kIters == 1) ? 0 : kUrbgBits; ------------------ | Branch (150:36): [True: 0, Folded] ------------------ 151| 8| static constexpr auto kMin = (URBG::min)(); 152| | 153| 8| result_type r = static_cast(g() - kMin); 154| 8| for (size_t n = 1; n < kIters; ++n) { ------------------ | Branch (154:22): [True: 0, False: 8] ------------------ 155| 0| r = static_cast(r << kShift) + 156| 0| static_cast(g() - kMin); 157| 0| } 158| 8| return r; 159| 8|} _ZN4absl12lts_2024011615random_internal17RandenPoolSeedSeq4sizeEv: 67| 1| size_t size() { return 0; } _ZN4absl12lts_2024011615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEC2Ev: 101| 1| NonsecureURBGBase() : urbg_(ConstructURBG()) {} _ZN4absl12lts_2024011615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEE13ConstructURBGEv: 142| 1| static URBG ConstructURBG() { 143| 1| Seeder seeder; 144| 1| return URBG(seeder); 145| 1| } _ZN4absl12lts_2024011615random_internal17RandenPoolSeedSeq8generateIPjEEvT_S5_: 73| 1| void generate(RandomAccessIterator begin, RandomAccessIterator end) { 74| | // RandomAccessIterator must be assignable from uint32_t 75| 1| if (begin != end) { ------------------ | Branch (75:9): [True: 1, False: 0] ------------------ 76| 1| using U = typename std::iterator_traits::value_type; 77| | // ContiguousTag indicates the common case of a known contiguous buffer, 78| | // which allows directly filling the buffer. In C++20, 79| | // std::contiguous_iterator_tag provides a mechanism for testing this 80| | // capability, however until Abseil's support requirements allow us to 81| | // assume C++20, limit checks to a few common cases. 82| 1| using TagType = absl::conditional_t< 83| 1| (std::is_pointer::value || 84| 1| std::is_same::iterator>::value), 86| 1| ContiguousTag, BufferTag>; 87| | 88| 1| generate_impl(TagType{}, begin, end); 89| 1| } 90| 1| } _ZN4absl12lts_2024011615random_internal17RandenPoolSeedSeq13generate_implIPjEEvNS2_13ContiguousTagET_S6_: 46| 1| void generate_impl(ContiguousTag, Contiguous begin, Contiguous end) { 47| 1| const size_t n = static_cast(std::distance(begin, end)); 48| 1| auto* a = &(*begin); 49| 1| RandenPool::Fill( 50| 1| absl::MakeSpan(reinterpret_cast(a), sizeof(*a) * n)); 51| 1| } _ZN4absl12lts_2024011615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEclEv: 126| 8| result_type operator()() { return urbg_(); } _ZN4absl12lts_2024011615random_internal10RandenPoolIhE4FillENS0_4SpanIhEE: 240| 1|void RandenPool::Fill(absl::Span data) { 241| 1| auto* pool = GetPoolForCurrentThread(); 242| 1| pool->Fill(reinterpret_cast(data.data()), 243| 1| data.size() * sizeof(result_type)); 244| 1|} pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_115RandenPoolEntry11MaybeRefillEv: 69| 1| inline void MaybeRefill() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) { 70| 1| if (next_ >= kState) { ------------------ | Branch (70:9): [True: 1, False: 0] ------------------ 71| 1| next_ = kCapacity; 72| 1| impl_.Generate(state_); 73| 1| } 74| 1| } pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_115RandenPoolEntry4FillEPhm: 120| 1|void RandenPoolEntry::Fill(uint8_t* out, size_t bytes) { 121| 1| SpinLockHolder l(&mu_); 122| 2| while (bytes > 0) { ------------------ | Branch (122:10): [True: 1, False: 1] ------------------ 123| 1| MaybeRefill(); 124| 1| size_t remaining = (kState - next_) * sizeof(state_[0]); 125| 1| size_t to_copy = std::min(bytes, remaining); 126| 1| std::memcpy(out, &state_[next_], to_copy); 127| 1| out += to_copy; 128| 1| bytes -= to_copy; 129| 1| next_ += (to_copy + sizeof(state_[0]) - 1) / sizeof(state_[0]); 130| 1| } 131| 1|} pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_123GetPoolForCurrentThreadEv: 226| 1|RandenPoolEntry* GetPoolForCurrentThread() { 227| 1| absl::call_once(pool_once, InitPoolURBG); 228| 1| return shared_pools[GetPoolID()]; 229| 1|} pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_112InitPoolURBGEv: 209| 1|void InitPoolURBG() { 210| 1| static constexpr size_t kSeedSize = 211| 1| RandenTraits::kStateBytes / sizeof(uint32_t); 212| | // Read the seed data from OS entropy once. 213| 1| uint32_t seed_material[kPoolSize * kSeedSize]; 214| 1| if (!random_internal::ReadSeedMaterialFromOSEntropy( ------------------ | Branch (214:7): [True: 0, False: 1] ------------------ 215| 1| absl::MakeSpan(seed_material))) { 216| 0| random_internal::ThrowSeedGenException(); 217| 0| } 218| 9| for (size_t i = 0; i < kPoolSize; i++) { ------------------ | Branch (218:22): [True: 8, False: 1] ------------------ 219| 8| shared_pools[i] = PoolAlignedAlloc(); 220| 8| shared_pools[i]->Init( 221| 8| absl::MakeSpan(&seed_material[i * kSeedSize], kSeedSize)); 222| 8| } 223| 1|} pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_116PoolAlignedAllocEv: 190| 8|RandenPoolEntry* PoolAlignedAlloc() { 191| 8| constexpr size_t kAlignment = 192| 8| ABSL_CACHELINE_SIZE > 32 ? ABSL_CACHELINE_SIZE : 32; ------------------ | | 77| 8|#define ABSL_CACHELINE_SIZE 64 ------------------ ABSL_CACHELINE_SIZE > 32 ? ABSL_CACHELINE_SIZE : 32; ------------------ | | 77| 0|#define ABSL_CACHELINE_SIZE 64 ------------------ | Branch (192:7): [True: 0, Folded] ------------------ 193| | 194| | // Not all the platforms that we build for have std::aligned_alloc, however 195| | // since we never free these objects, we can over allocate and munge the 196| | // pointers to the correct alignment. 197| 8| uintptr_t x = reinterpret_cast( 198| 8| new char[sizeof(RandenPoolEntry) + kAlignment]); 199| 8| auto y = x % kAlignment; 200| 8| void* aligned = reinterpret_cast(y == 0 ? x : (x + kAlignment - y)); ------------------ | Branch (200:43): [True: 1, False: 7] ------------------ 201| 8| return new (aligned) RandenPoolEntry(); 202| 8|} pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_115RandenPoolEntry4InitENS0_4SpanIKjEE: 56| 8| void Init(absl::Span data) { 57| 8| SpinLockHolder l(&mu_); // Always uncontested. 58| 8| std::copy(data.begin(), data.end(), std::begin(state_)); 59| 8| next_ = kState; 60| 8| } pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_19GetPoolIDEv: 150| 1|size_t GetPoolID() { 151| 1| static_assert(kPoolSize >= 1, 152| 1| "At least one urbg instance is required for PoolURBG"); 153| | 154| 1| ABSL_CONST_INIT static std::atomic sequence{0}; ------------------ | | 745| 1|#define ABSL_CONST_INIT [[clang::require_constant_initialization]] ------------------ 155| | 156| 1|#ifdef ABSL_HAVE_THREAD_LOCAL 157| 1| static thread_local size_t my_pool_id = kPoolSize; 158| 1| if (ABSL_PREDICT_FALSE(my_pool_id == kPoolSize)) { ------------------ | | 178| 1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 1, False: 0] | | | Branch (178:49): [Folded, False: 1] | | | Branch (178:58): [True: 1, False: 0] | | ------------------ ------------------ 159| 1| my_pool_id = (sequence++ % kPoolSize); 160| 1| } 161| 1| return my_pool_id; 162| |#else 163| | static pthread_key_t tid_key = [] { 164| | pthread_key_t tmp_key; 165| | int err = pthread_key_create(&tmp_key, nullptr); 166| | if (err) { 167| | ABSL_RAW_LOG(FATAL, "pthread_key_create failed with %d", err); 168| | } 169| | return tmp_key; 170| | }(); 171| | 172| | // Store the value in the pthread_{get/set}specific. However an uninitialized 173| | // value is 0, so add +1 to distinguish from the null value. 174| | uintptr_t my_pool_id = 175| | reinterpret_cast(pthread_getspecific(tid_key)); 176| | if (ABSL_PREDICT_FALSE(my_pool_id == 0)) { 177| | // No allocated ID, allocate the next value, cache it, and return. 178| | my_pool_id = (sequence++ % kPoolSize) + 1; 179| | int err = pthread_setspecific(tid_key, reinterpret_cast(my_pool_id)); 180| | if (err) { 181| | ABSL_RAW_LOG(FATAL, "pthread_setspecific failed with %d", err); 182| | } 183| | } 184| | return my_pool_id - 1; 185| |#endif 186| 1|} _ZN4absl12lts_2024011615random_internal6RandenC2Ev: 81| 9|Randen::Randen() { 82| 9| auto tmp = GetRandenState(); 83| 9| keys_ = tmp.keys; 84| 9|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH 85| 9| has_crypto_ = tmp.has_crypto; 86| 9|#endif 87| 9|} randen.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_114GetRandenStateEv: 53| 9|RandenState GetRandenState() { 54| 9| static const RandenState state = []() { 55| 9| RandenState tmp; 56| 9|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH 57| | // HW AES Dispatch. 58| 9| if (HasRandenHwAesImplementation() && CPUSupportsRandenHwAes()) { 59| 9| tmp.has_crypto = true; 60| 9| tmp.keys = RandenHwAes::GetKeys(); 61| 9| } else { 62| 9| tmp.has_crypto = false; 63| 9| tmp.keys = RandenSlow::GetKeys(); 64| 9| } 65| |#elif ABSL_HAVE_ACCELERATED_AES 66| | // HW AES is enabled. 67| | tmp.has_crypto = true; 68| | tmp.keys = RandenHwAes::GetKeys(); 69| |#else 70| | // HW AES is disabled. 71| | tmp.has_crypto = false; 72| | tmp.keys = RandenSlow::GetKeys(); 73| |#endif 74| 9| return tmp; 75| 9| }(); 76| 9| return state; 77| 9|} randen.cc:_ZZN4absl12lts_2024011615random_internal12_GLOBAL__N_114GetRandenStateEvENK3$_0clEv: 54| 1| static const RandenState state = []() { 55| 1| RandenState tmp; 56| 1|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH 57| | // HW AES Dispatch. 58| 1| if (HasRandenHwAesImplementation() && CPUSupportsRandenHwAes()) { ------------------ | Branch (58:9): [True: 1, False: 0] | Branch (58:43): [True: 1, False: 0] ------------------ 59| 1| tmp.has_crypto = true; 60| 1| tmp.keys = RandenHwAes::GetKeys(); 61| 1| } else { 62| 0| tmp.has_crypto = false; 63| 0| tmp.keys = RandenSlow::GetKeys(); 64| 0| } 65| |#elif ABSL_HAVE_ACCELERATED_AES 66| | // HW AES is enabled. 67| | tmp.has_crypto = true; 68| | tmp.keys = RandenHwAes::GetKeys(); 69| |#else 70| | // HW AES is disabled. 71| | tmp.has_crypto = false; 72| | tmp.keys = RandenSlow::GetKeys(); 73| |#endif 74| 1| return tmp; 75| 1| }(); _ZNK4absl12lts_2024011615random_internal6Randen8GenerateEPv: 47| 2| inline void Generate(void* state) const { 48| 2|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH 49| | // HW AES Dispatch. 50| 2| if (has_crypto_) { ------------------ | Branch (50:9): [True: 2, False: 0] ------------------ 51| 2| RandenHwAes::Generate(keys_, state); 52| 2| } else { 53| 0| RandenSlow::Generate(keys_, state); 54| 0| } 55| |#elif ABSL_HAVE_ACCELERATED_AES 56| | // HW AES is enabled. 57| | RandenHwAes::Generate(keys_, state); 58| |#else 59| | // HW AES is disabled. 60| | RandenSlow::Generate(keys_, state); 61| |#endif 62| 2| } _ZNK4absl12lts_2024011615random_internal6Randen6AbsorbEPKvPv: 68| 1| inline void Absorb(const void* seed, void* state) const { 69| 1|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH 70| | // HW AES Dispatch. 71| 1| if (has_crypto_) { ------------------ | Branch (71:9): [True: 1, False: 0] ------------------ 72| 1| RandenHwAes::Absorb(seed, state); 73| 1| } else { 74| 0| RandenSlow::Absorb(seed, state); 75| 0| } 76| |#elif ABSL_HAVE_ACCELERATED_AES 77| | // HW AES is enabled. 78| | RandenHwAes::Absorb(seed, state); 79| |#else 80| | // HW AES is disabled. 81| | RandenSlow::Absorb(seed, state); 82| |#endif 83| 1| } _ZN4absl12lts_2024011615random_internal22CPUSupportsRandenHwAesEv: 135| 1|bool CPUSupportsRandenHwAes() { 136| 1|#if defined(ABSL_INTERNAL_USE_X86_CPUID) 137| | // 1. For x86: Use CPUID to detect the required AES instruction set. 138| 1| int regs[4]; 139| 1| __cpuid(reinterpret_cast(regs), 1); 140| 1| return regs[2] & (1 << 25); // AES 141| | 142| |#elif defined(ABSL_INTERNAL_USE_GETAUXVAL) 143| | // 2. Use getauxval() to read the hardware bits and determine 144| | // cpu capabilities. 145| | 146| |#define AT_HWCAP 16 147| |#define AT_HWCAP2 26 148| |#if defined(ABSL_ARCH_PPC) 149| | // For Power / PPC: Expect that the cpu supports VCRYPTO 150| | // See https://members.openpowerfoundation.org/document/dl/576 151| | // VCRYPTO should be present in POWER8 >= 2.07. 152| | // Uses Linux kernel constants from arch/powerpc/include/uapi/asm/cputable.h 153| | static const uint32_t kVCRYPTO = 0x02000000; 154| | const uint32_t hwcap = GetAuxval(AT_HWCAP2); 155| | return (hwcap & kVCRYPTO) != 0; 156| | 157| |#elif defined(ABSL_ARCH_ARM) 158| | // For ARM: Require crypto+neon 159| | // http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0500f/CIHBIBBA.html 160| | // Uses Linux kernel constants from arch/arm64/include/asm/hwcap.h 161| | static const uint32_t kNEON = 1 << 12; 162| | uint32_t hwcap = GetAuxval(AT_HWCAP); 163| | if ((hwcap & kNEON) == 0) { 164| | return false; 165| | } 166| | 167| | // And use it again to detect AES. 168| | static const uint32_t kAES = 1 << 0; 169| | const uint32_t hwcap2 = GetAuxval(AT_HWCAP2); 170| | return (hwcap2 & kAES) != 0; 171| | 172| |#elif defined(ABSL_ARCH_AARCH64) 173| | // For AARCH64: Require crypto+neon 174| | // http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0500f/CIHBIBBA.html 175| | static const uint32_t kNEON = 1 << 1; 176| | static const uint32_t kAES = 1 << 3; 177| | const uint32_t hwcap = GetAuxval(AT_HWCAP); 178| | return ((hwcap & kNEON) != 0) && ((hwcap & kAES) != 0); 179| |#endif 180| | 181| |#else // ABSL_INTERNAL_USE_GETAUXVAL 182| | // 3. By default, assume that the compiler default. 183| | return ABSL_HAVE_ACCELERATED_AES ? true : false; 184| | 185| |#endif 186| | // NOTE: There are some other techniques that may be worth trying: 187| | // 188| | // * Use an environment variable: ABSL_RANDOM_USE_HWAES 189| | // 190| | // * Rely on compiler-generated target-based dispatch. 191| | // Using x86/gcc it might look something like this: 192| | // 193| | // int __attribute__((target("aes"))) HasAes() { return 1; } 194| | // int __attribute__((target("default"))) HasAes() { return 0; } 195| | // 196| | // This does not work on all architecture/compiler combinations. 197| | // 198| | // * On Linux consider reading /proc/cpuinfo and/or /proc/self/auxv. 199| | // These files have lines which are easy to parse; for ARM/AARCH64 it is quite 200| | // easy to find the Features: line and extract aes / neon. Likewise for 201| | // PPC. 202| | // 203| | // * Fork a process and test for SIGILL: 204| | // 205| | // * Many architectures have instructions to read the ISA. Unfortunately 206| | // most of those require that the code is running in ring 0 / 207| | // protected-mode. 208| | // 209| | // There are several examples. e.g. Valgrind detects PPC ISA 2.07: 210| | // https://github.com/lu-zero/valgrind/blob/master/none/tests/ppc64/test_isa_2_07_part1.c 211| | // 212| | // MRS , ID_AA64ISAR0_EL1 ; Read ID_AA64ISAR0_EL1 into Xt 213| | // 214| | // uint64_t val; 215| | // __asm __volatile("mrs %0, id_aa64isar0_el1" :"=&r" (val)); 216| | // 217| | // * Use a CPUID-style heuristic database. 218| | // 219| | // * On Apple (__APPLE__), AES is available on Arm v8. 220| | // https://stackoverflow.com/questions/45637888/how-to-determine-armv8-features-at-runtime-on-ios 221| 1|} randen_detect.cc:_ZL7__cpuidPii: 54| 1|static void __cpuid(int cpu_info[4], int info_type) { 55| 1| __asm__ volatile("cpuid \n\t" 56| 1| : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]), 57| 1| "=d"(cpu_info[3]) 58| 1| : "a"(info_type), "c"(0)); 59| 1|} _ZN4absl12lts_2024011615random_internal13randen_engineImEC2IRNS1_17RandenPoolSeedSeqEvEEOT_: 67| 1| explicit randen_engine(SeedSequence&& seq) { 68| 1| seed(seq); 69| 1| } _ZN4absl12lts_2024011615random_internal13randen_engineImE4seedIRNS1_17RandenPoolSeedSeqEEENSt3__19enable_ifIXntsr3std14is_convertibleIT_mEE5valueEvE4typeEOS9_: 97| 1| seed(SeedSequence&& seq) { 98| | // Zeroes the state. 99| 1| seed(); 100| 1| reseed(seq); 101| 1| } _ZN4absl12lts_2024011615random_internal13randen_engineImE4seedEm: 103| 1| void seed(result_type seed_value = 0) { 104| 1| next_ = kStateSizeT; 105| | // Zeroes the inner state and fills the outer state with seed_value to 106| | // mimic the behaviour of reseed 107| 1| auto* begin = state(); 108| 1| std::fill(begin, begin + kCapacityT, 0); 109| 1| std::fill(begin + kCapacityT, begin + kStateSizeT, seed_value); 110| 1| } _ZN4absl12lts_2024011615random_internal13randen_engineImE5stateEv: 244| 10| result_type* state() { 245| 10| return reinterpret_cast( 246| 10| (reinterpret_cast(&raw_state_) & 0xf) ? (raw_state_ + 8) ------------------ | Branch (246:9): [True: 0, False: 10] ------------------ 247| 10| : raw_state_); 248| 10| } _ZN4absl12lts_2024011615random_internal13randen_engineImE6reseedINS1_17RandenPoolSeedSeqEEEvRT_: 116| 1| void reseed(SeedSequence& seq) { 117| 1| using sequence_result_type = typename SeedSequence::result_type; 118| 1| static_assert(sizeof(sequence_result_type) == 4, 119| 1| "SeedSequence::result_type must be 32-bit"); 120| 1| constexpr size_t kBufferSize = 121| 1| Randen::kSeedBytes / sizeof(sequence_result_type); 122| 1| alignas(16) sequence_result_type buffer[kBufferSize]; 123| | 124| | // Randen::Absorb XORs the seed into state, which is then mixed by a call 125| | // to Randen::Generate. Seeding with only the provided entropy is preferred 126| | // to using an arbitrary generate() call, so use [rand.req.seed_seq] 127| | // size as a proxy for the number of entropy units that can be generated 128| | // without relying on seed sequence mixing... 129| 1| const size_t entropy_size = seq.size(); 130| 1| if (entropy_size < kBufferSize) { ------------------ | Branch (130:9): [True: 1, False: 0] ------------------ 131| | // ... and only request that many values, or 256-bits, when unspecified. 132| 1| const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size; ------------------ | Branch (132:40): [True: 1, False: 0] ------------------ 133| 1| std::fill(buffer + requested_entropy, buffer + kBufferSize, 0); 134| 1| seq.generate(buffer, buffer + requested_entropy); 135| |#ifdef ABSL_IS_BIG_ENDIAN 136| | // Randen expects the seed buffer to be in Little Endian; reverse it on 137| | // Big Endian platforms. 138| | for (sequence_result_type& e : buffer) { 139| | e = absl::little_endian::FromHost(e); 140| | } 141| |#endif 142| | // The Randen paper suggests preferentially initializing even-numbered 143| | // 128-bit vectors of the randen state (there are 16 such vectors). 144| | // The seed data is merged into the state offset by 128-bits, which 145| | // implies preferring seed bytes [16..31, ..., 208..223]. Since the 146| | // buffer is 32-bit values, we swap the corresponding buffer positions in 147| | // 128-bit chunks. 148| 1| size_t dst = kBufferSize; 149| 8| while (dst > 7) { ------------------ | Branch (149:14): [True: 7, False: 1] ------------------ 150| | // leave the odd bucket as-is. 151| 7| dst -= 4; 152| 7| size_t src = dst >> 1; 153| | // swap 128-bits into the even bucket 154| 7| std::swap(buffer[--dst], buffer[--src]); 155| 7| std::swap(buffer[--dst], buffer[--src]); 156| 7| std::swap(buffer[--dst], buffer[--src]); 157| 7| std::swap(buffer[--dst], buffer[--src]); 158| 7| } 159| 1| } else { 160| 0| seq.generate(buffer, buffer + kBufferSize); 161| 0| } 162| 1| impl_.Absorb(buffer, state()); 163| | 164| | // Generate will be called when operator() is called 165| 1| next_ = kStateSizeT; 166| 1| } _ZN4absl12lts_2024011615random_internal13randen_engineImEclEv: 84| 8| result_type operator()() { 85| | // Refill the buffer if needed (unlikely). 86| 8| auto* begin = state(); 87| 8| if (next_ >= kStateSizeT) { ------------------ | Branch (87:9): [True: 1, False: 7] ------------------ 88| 1| next_ = kCapacityT; 89| 1| impl_.Generate(begin); 90| 1| } 91| 8| return little_endian::ToHost(begin[next_++]); 92| 8| } _ZN4absl12lts_2024011615random_internal28HasRandenHwAesImplementationEv: 408| 1|bool HasRandenHwAesImplementation() { return true; } _ZN4absl12lts_2024011615random_internal11RandenHwAes7GetKeysEv: 410| 1|const void* ABSL_TARGET_CRYPTO RandenHwAes::GetKeys() { 411| | // Round keys for one AES per Feistel round and branch. 412| | // The canonical implementation uses first digits of Pi. 413| |#if defined(ABSL_ARCH_PPC) 414| | return kRandenRoundKeysBE; 415| |#else 416| 1| return kRandenRoundKeys; 417| 1|#endif 418| 1|} _ZN4absl12lts_2024011615random_internal11RandenHwAes6AbsorbEPKvPv: 422| 1| void* state_void) { 423| 1| static_assert(RandenTraits::kCapacityBytes / sizeof(Vector128) == 1, 424| 1| "Unexpected Randen kCapacityBlocks"); 425| 1| static_assert(RandenTraits::kStateBytes / sizeof(Vector128) == 16, 426| 1| "Unexpected Randen kStateBlocks"); 427| | 428| 1| auto* state = reinterpret_cast( 429| 1| state_void); 430| 1| const auto* seed = 431| 1| reinterpret_cast( 432| 1| seed_void); 433| | 434| 1| Vector128 b1 = Vector128Load(state + 1); 435| 1| b1 ^= Vector128Load(seed + 0); 436| 1| Vector128Store(b1, state + 1); 437| | 438| 1| Vector128 b2 = Vector128Load(state + 2); 439| 1| b2 ^= Vector128Load(seed + 1); 440| 1| Vector128Store(b2, state + 2); 441| | 442| 1| Vector128 b3 = Vector128Load(state + 3); 443| 1| b3 ^= Vector128Load(seed + 2); 444| 1| Vector128Store(b3, state + 3); 445| | 446| 1| Vector128 b4 = Vector128Load(state + 4); 447| 1| b4 ^= Vector128Load(seed + 3); 448| 1| Vector128Store(b4, state + 4); 449| | 450| 1| Vector128 b5 = Vector128Load(state + 5); 451| 1| b5 ^= Vector128Load(seed + 4); 452| 1| Vector128Store(b5, state + 5); 453| | 454| 1| Vector128 b6 = Vector128Load(state + 6); 455| 1| b6 ^= Vector128Load(seed + 5); 456| 1| Vector128Store(b6, state + 6); 457| | 458| 1| Vector128 b7 = Vector128Load(state + 7); 459| 1| b7 ^= Vector128Load(seed + 6); 460| 1| Vector128Store(b7, state + 7); 461| | 462| 1| Vector128 b8 = Vector128Load(state + 8); 463| 1| b8 ^= Vector128Load(seed + 7); 464| 1| Vector128Store(b8, state + 8); 465| | 466| 1| Vector128 b9 = Vector128Load(state + 9); 467| 1| b9 ^= Vector128Load(seed + 8); 468| 1| Vector128Store(b9, state + 9); 469| | 470| 1| Vector128 b10 = Vector128Load(state + 10); 471| 1| b10 ^= Vector128Load(seed + 9); 472| 1| Vector128Store(b10, state + 10); 473| | 474| 1| Vector128 b11 = Vector128Load(state + 11); 475| 1| b11 ^= Vector128Load(seed + 10); 476| 1| Vector128Store(b11, state + 11); 477| | 478| 1| Vector128 b12 = Vector128Load(state + 12); 479| 1| b12 ^= Vector128Load(seed + 11); 480| 1| Vector128Store(b12, state + 12); 481| | 482| 1| Vector128 b13 = Vector128Load(state + 13); 483| 1| b13 ^= Vector128Load(seed + 12); 484| 1| Vector128Store(b13, state + 13); 485| | 486| 1| Vector128 b14 = Vector128Load(state + 14); 487| 1| b14 ^= Vector128Load(seed + 13); 488| 1| Vector128Store(b14, state + 14); 489| | 490| 1| Vector128 b15 = Vector128Load(state + 15); 491| 1| b15 ^= Vector128Load(seed + 14); 492| 1| Vector128Store(b15, state + 15); 493| 1|} _ZN4absl12lts_2024011615random_internal11RandenHwAes8GenerateEPKvPv: 497| 2| void* state_void) { 498| 2| static_assert(RandenTraits::kCapacityBytes == sizeof(Vector128), 499| 2| "Capacity mismatch"); 500| | 501| 2| auto* state = reinterpret_cast(state_void); 502| 2| const auto* keys = reinterpret_cast(keys_void); 503| | 504| 2| const Vector128 prev_inner = Vector128Load(state); 505| | 506| 2| SwapEndian(state); 507| | 508| 2| Permute(state, keys); 509| | 510| 2| SwapEndian(state); 511| | 512| | // Ensure backtracking resistance. 513| 2| Vector128 inner = Vector128Load(state); 514| 2| inner ^= prev_inner; 515| 2| Vector128Store(inner, state); 516| 2|} randen_hwaes.cc:_ZN12_GLOBAL__N_113Vector128LoadEPKv: 236| 1.39k|inline ABSL_TARGET_CRYPTO Vector128 Vector128Load(const void* from) { 237| 1.39k| return Vector128(_mm_load_si128(reinterpret_cast(from))); 238| 1.39k|} randen_hwaes.cc:_ZN12_GLOBAL__N_19Vector128C2ERKDv2_x: 223| 1.93k| inline explicit Vector128(const __m128i& v) : data_(v) {} randen_hwaes.cc:_ZN12_GLOBAL__N_19Vector128eOERKS0_: 227| 17| inline Vector128& operator^=(const Vector128& other) { 228| 17| data_ = _mm_xor_si128(data_, other.data()); 229| 17| return *this; 230| 17| } randen_hwaes.cc:_ZNK12_GLOBAL__N_19Vector1284dataEv: 225| 1.93k| inline __m128i data() const { return data_; } randen_hwaes.cc:_ZN12_GLOBAL__N_114Vector128StoreERKNS_9Vector128EPv: 240| 833|inline ABSL_TARGET_CRYPTO void Vector128Store(const Vector128& v, void* to) { 241| 833| _mm_store_si128(reinterpret_cast<__m128i*>(to), v.data()); 242| 833|} randen_hwaes.cc:_ZN12_GLOBAL__N_110SwapEndianEPv: 254| 4|inline ABSL_TARGET_CRYPTO void SwapEndian(void*) {} randen_hwaes.cc:_ZN12_GLOBAL__N_17PermuteEPN4absl12lts_202401167uint128EPKS2_: 391| 2| const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) { 392| | // (Successfully unrolled; the first iteration jumps into the second half) 393| 2|#ifdef __clang__ 394| 2|#pragma clang loop unroll_count(2) 395| 2|#endif 396| 36| for (size_t round = 0; round < RandenTraits::kFeistelRounds; ++round) { ------------------ | Branch (396:26): [True: 34, False: 2] ------------------ 397| 34| keys = FeistelRound(state, keys); 398| 34| BlockShuffle(state); 399| 34| } 400| 2|} randen_hwaes.cc:_ZN12_GLOBAL__N_112FeistelRoundEPN4absl12lts_202401167uint128EPKS2_: 329| 34| const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) { 330| 34| static_assert(RandenTraits::kFeistelBlocks == 16, 331| 34| "Expecting 16 FeistelBlocks."); 332| | 333| | // MSVC does a horrible job at unrolling loops. 334| | // So we unroll the loop by hand to improve the performance. 335| 34| const Vector128 s0 = Vector128Load(state + 0); 336| 34| const Vector128 s1 = Vector128Load(state + 1); 337| 34| const Vector128 s2 = Vector128Load(state + 2); 338| 34| const Vector128 s3 = Vector128Load(state + 3); 339| 34| const Vector128 s4 = Vector128Load(state + 4); 340| 34| const Vector128 s5 = Vector128Load(state + 5); 341| 34| const Vector128 s6 = Vector128Load(state + 6); 342| 34| const Vector128 s7 = Vector128Load(state + 7); 343| 34| const Vector128 s8 = Vector128Load(state + 8); 344| 34| const Vector128 s9 = Vector128Load(state + 9); 345| 34| const Vector128 s10 = Vector128Load(state + 10); 346| 34| const Vector128 s11 = Vector128Load(state + 11); 347| 34| const Vector128 s12 = Vector128Load(state + 12); 348| 34| const Vector128 s13 = Vector128Load(state + 13); 349| 34| const Vector128 s14 = Vector128Load(state + 14); 350| 34| const Vector128 s15 = Vector128Load(state + 15); 351| | 352| | // Encode even blocks with keys. 353| 34| const Vector128 e0 = AesRound(s0, Vector128Load(keys + 0)); 354| 34| const Vector128 e2 = AesRound(s2, Vector128Load(keys + 1)); 355| 34| const Vector128 e4 = AesRound(s4, Vector128Load(keys + 2)); 356| 34| const Vector128 e6 = AesRound(s6, Vector128Load(keys + 3)); 357| 34| const Vector128 e8 = AesRound(s8, Vector128Load(keys + 4)); 358| 34| const Vector128 e10 = AesRound(s10, Vector128Load(keys + 5)); 359| 34| const Vector128 e12 = AesRound(s12, Vector128Load(keys + 6)); 360| 34| const Vector128 e14 = AesRound(s14, Vector128Load(keys + 7)); 361| | 362| | // Encode odd blocks with even output from above. 363| 34| const Vector128 o1 = AesRound(e0, s1); 364| 34| const Vector128 o3 = AesRound(e2, s3); 365| 34| const Vector128 o5 = AesRound(e4, s5); 366| 34| const Vector128 o7 = AesRound(e6, s7); 367| 34| const Vector128 o9 = AesRound(e8, s9); 368| 34| const Vector128 o11 = AesRound(e10, s11); 369| 34| const Vector128 o13 = AesRound(e12, s13); 370| 34| const Vector128 o15 = AesRound(e14, s15); 371| | 372| | // Store odd blocks. (These will be shuffled later). 373| 34| Vector128Store(o1, state + 1); 374| 34| Vector128Store(o3, state + 3); 375| 34| Vector128Store(o5, state + 5); 376| 34| Vector128Store(o7, state + 7); 377| 34| Vector128Store(o9, state + 9); 378| 34| Vector128Store(o11, state + 11); 379| 34| Vector128Store(o13, state + 13); 380| 34| Vector128Store(o15, state + 15); 381| | 382| 34| return keys + 8; 383| 34|} randen_hwaes.cc:_ZN12_GLOBAL__N_18AesRoundERKNS_9Vector128ES2_: 247| 544| const Vector128& round_key) { 248| | // It is important to always use the full round function - omitting the 249| | // final MixColumns reduces security [https://eprint.iacr.org/2010/041.pdf] 250| | // and does not help because we never decrypt. 251| 544| return Vector128(_mm_aesenc_si128(state.data(), round_key.data())); 252| 544|} randen_hwaes.cc:_ZN12_GLOBAL__N_112BlockShuffleEPN4absl12lts_202401167uint128E: 280| 34|inline ABSL_TARGET_CRYPTO void BlockShuffle(absl::uint128* state) { 281| 34| static_assert(RandenTraits::kFeistelBlocks == 16, 282| 34| "Expecting 16 FeistelBlocks."); 283| | 284| 34| constexpr size_t shuffle[RandenTraits::kFeistelBlocks] = { 285| 34| 7, 2, 13, 4, 11, 8, 3, 6, 15, 0, 9, 10, 1, 14, 5, 12}; 286| | 287| 34| const Vector128 v0 = Vector128Load(state + shuffle[0]); 288| 34| const Vector128 v1 = Vector128Load(state + shuffle[1]); 289| 34| const Vector128 v2 = Vector128Load(state + shuffle[2]); 290| 34| const Vector128 v3 = Vector128Load(state + shuffle[3]); 291| 34| const Vector128 v4 = Vector128Load(state + shuffle[4]); 292| 34| const Vector128 v5 = Vector128Load(state + shuffle[5]); 293| 34| const Vector128 v6 = Vector128Load(state + shuffle[6]); 294| 34| const Vector128 v7 = Vector128Load(state + shuffle[7]); 295| 34| const Vector128 w0 = Vector128Load(state + shuffle[8]); 296| 34| const Vector128 w1 = Vector128Load(state + shuffle[9]); 297| 34| const Vector128 w2 = Vector128Load(state + shuffle[10]); 298| 34| const Vector128 w3 = Vector128Load(state + shuffle[11]); 299| 34| const Vector128 w4 = Vector128Load(state + shuffle[12]); 300| 34| const Vector128 w5 = Vector128Load(state + shuffle[13]); 301| 34| const Vector128 w6 = Vector128Load(state + shuffle[14]); 302| 34| const Vector128 w7 = Vector128Load(state + shuffle[15]); 303| | 304| 34| Vector128Store(v0, state + 0); 305| 34| Vector128Store(v1, state + 1); 306| 34| Vector128Store(v2, state + 2); 307| 34| Vector128Store(v3, state + 3); 308| 34| Vector128Store(v4, state + 4); 309| 34| Vector128Store(v5, state + 5); 310| 34| Vector128Store(v6, state + 6); 311| 34| Vector128Store(v7, state + 7); 312| 34| Vector128Store(w0, state + 8); 313| 34| Vector128Store(w1, state + 9); 314| 34| Vector128Store(w2, state + 10); 315| 34| Vector128Store(w3, state + 11); 316| 34| Vector128Store(w4, state + 12); 317| 34| Vector128Store(w5, state + 13); 318| 34| Vector128Store(w6, state + 14); 319| 34| Vector128Store(w7, state + 15); 320| 34|} _ZN4absl12lts_2024011615random_internal29ReadSeedMaterialFromOSEntropyENS0_4SpanIjEE: 205| 1|bool ReadSeedMaterialFromOSEntropy(absl::Span values) { 206| 1| assert(values.data() != nullptr); 207| 1| if (values.data() == nullptr) { ------------------ | Branch (207:7): [True: 0, False: 1] ------------------ 208| 0| return false; 209| 0| } 210| 1| if (values.empty()) { ------------------ | Branch (210:7): [True: 0, False: 1] ------------------ 211| 0| return true; 212| 0| } 213| 1| return ReadSeedMaterialFromOSEntropyImpl(values); 214| 1|} seed_material.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_133ReadSeedMaterialFromOSEntropyImplENS0_4SpanIjEE: 190| 1|bool ReadSeedMaterialFromOSEntropyImpl(absl::Span values) { 191| 1|#if defined(ABSL_RANDOM_USE_GET_ENTROPY) 192| 1| if (ReadSeedMaterialFromGetEntropy(values)) { ------------------ | Branch (192:7): [True: 1, False: 0] ------------------ 193| 1| return true; 194| 1| } 195| 0|#endif 196| | // Libc may support getentropy, but the kernel may not, so we still have 197| | // to fallback to ReadSeedMaterialFromDevURandom(). 198| 0| return ReadSeedMaterialFromDevURandom(values); 199| 1|} seed_material.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_130ReadSeedMaterialFromGetEntropyENS0_4SpanIjEE: 142| 1|bool ReadSeedMaterialFromGetEntropy(absl::Span values) { 143| 1| auto buffer = reinterpret_cast(values.data()); 144| 1| size_t buffer_size = sizeof(uint32_t) * values.size(); 145| 9| while (buffer_size > 0) { ------------------ | Branch (145:10): [True: 8, False: 1] ------------------ 146| | // getentropy() has a maximum permitted length of 256. 147| 8| size_t to_read = std::min(buffer_size, 256); 148| 8| int result = getentropy(buffer, to_read); 149| 8| if (result < 0) { ------------------ | Branch (149:9): [True: 0, False: 8] ------------------ 150| 0| return false; 151| 0| } 152| | // https://github.com/google/sanitizers/issues/1173 153| | // MemorySanitizer can't see through getentropy(). 154| 8| ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buffer, to_read); 155| 8| buffer += to_read; 156| 8| buffer_size -= to_read; 157| 8| } 158| 1| return true; 159| 1|} _ZN4absl12lts_2024011615random_internal26UniformDistributionWrapperIjEC2Ev: 236| 8| : UniformDistribution(std::numeric_limits::lowest(), 237| 8| (std::numeric_limits::max)()) {} _ZNK4absl12lts_2024011624uniform_int_distributionIjE5paramEv: 134| 8| param_type param() const { return param_; } _ZNK4absl12lts_2024011624uniform_int_distributionIjE10param_type1aEv: 80| 8| result_type a() const { return lo_; } _ZNK4absl12lts_2024011624uniform_int_distributionIjE10param_type5rangeEv: 95| 8| unsigned_type range() const { return range_; } _ZN4absl12lts_2024011624uniform_int_distributionIjEC2Ejj: 110| 8| : param_(lo, hi) {} _ZN4absl12lts_2024011624uniform_int_distributionIjE10param_typeC2Ejj: 73| 8| : lo_(lo), 74| 8| range_(static_cast(hi) - 75| 8| static_cast(lo)) { 76| | // [rand.dist.uni.int] precondition 2 77| | assert(lo <= hi); 78| 8| } _ZN4absl12lts_2024011624uniform_int_distributionIjEclINS0_15random_internal17NonsecureURBGBaseINS4_13randen_engineImEENS4_17RandenPoolSeedSeqEEEEEjRT_: 121| 8| result_type operator()(URBG& gen) { // NOLINT(runtime/references) 122| 8| return (*this)(gen, param()); 123| 8| } _ZN4absl12lts_2024011624uniform_int_distributionIjEclINS0_15random_internal17NonsecureURBGBaseINS4_13randen_engineImEENS4_17RandenPoolSeedSeqEEEEEjRT_RKNS2_10param_typeE: 127| 8| URBG& gen, const param_type& param) { // NOLINT(runtime/references) 128| 8| return static_cast(param.a() + Generate(gen, param.range())); 129| 8| } _ZN4absl12lts_2024011624uniform_int_distributionIjE8GenerateINS0_15random_internal17NonsecureURBGBaseINS4_13randen_engineImEENS4_17RandenPoolSeedSeqEEEEEjRT_j: 198| 8| typename random_internal::make_unsigned_bits::type R) { 199| 8| random_internal::FastUniformBits fast_bits; 200| 8| unsigned_type bits = fast_bits(g); 201| 8| const unsigned_type Lim = R + 1; 202| 8| if ((R & Lim) == 0) { ------------------ | Branch (202:7): [True: 8, False: 0] ------------------ 203| | // If the interval's length is a power of two range, just take the low bits. 204| 8| return bits & R; 205| 8| } 206| | 207| | // Generates a uniform variate on [0, Lim) using fixed-point multiplication. 208| | // The above fast-path guarantees that Lim is representable in unsigned_type. 209| | // 210| | // Algorithm adapted from 211| | // http://lemire.me/blog/2016/06/30/fast-random-shuffling/, with added 212| | // explanation. 213| | // 214| | // The algorithm creates a uniform variate `bits` in the interval [0, 2^N), 215| | // and treats it as the fractional part of a fixed-point real value in [0, 1), 216| | // multiplied by 2^N. For example, 0.25 would be represented as 2^(N - 2), 217| | // because 2^N * 0.25 == 2^(N - 2). 218| | // 219| | // Next, `bits` and `Lim` are multiplied with a wide-multiply to bring the 220| | // value into the range [0, Lim). The integral part (the high word of the 221| | // multiplication result) is then very nearly the desired result. However, 222| | // this is not quite accurate; viewing the multiplication result as one 223| | // double-width integer, the resulting values for the sample are mapped as 224| | // follows: 225| | // 226| | // If the result lies in this interval: Return this value: 227| | // [0, 2^N) 0 228| | // [2^N, 2 * 2^N) 1 229| | // ... ... 230| | // [K * 2^N, (K + 1) * 2^N) K 231| | // ... ... 232| | // [(Lim - 1) * 2^N, Lim * 2^N) Lim - 1 233| | // 234| | // While all of these intervals have the same size, the result of `bits * Lim` 235| | // must be a multiple of `Lim`, and not all of these intervals contain the 236| | // same number of multiples of `Lim`. In particular, some contain 237| | // `F = floor(2^N / Lim)` and some contain `F + 1 = ceil(2^N / Lim)`. This 238| | // difference produces a small nonuniformity, which is corrected by applying 239| | // rejection sampling to one of the values in the "larger intervals" (i.e., 240| | // the intervals containing `F + 1` multiples of `Lim`. 241| | // 242| | // An interval contains `F + 1` multiples of `Lim` if and only if its smallest 243| | // value modulo 2^N is less than `2^N % Lim`. The unique value satisfying 244| | // this property is used as the one for rejection. That is, a value of 245| | // `bits * Lim` is rejected if `(bit * Lim) % 2^N < (2^N % Lim)`. 246| | 247| 0| using helper = random_internal::wide_multiply; 248| 0| auto product = helper::multiply(bits, Lim); 249| | 250| | // Two optimizations here: 251| | // * Rejection occurs with some probability less than 1/2, and for reasonable 252| | // ranges considerably less (in particular, less than 1/(F+1)), so 253| | // ABSL_PREDICT_FALSE is apt. 254| | // * `Lim` is an overestimate of `threshold`, and doesn't require a divide. 255| 0| if (ABSL_PREDICT_FALSE(helper::lo(product) < Lim)) { ------------------ | | 178| 0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 0] | | | Branch (178:49): [Folded, False: 0] | | | Branch (178:58): [True: 0, False: 0] | | ------------------ ------------------ 256| | // This quantity is exactly equal to `2^N % Lim`, but does not require high 257| | // precision calculations: `2^N % Lim` is congruent to `(2^N - Lim) % Lim`. 258| | // Ideally this could be expressed simply as `-X` rather than `2^N - X`, but 259| | // for types smaller than int, this calculation is incorrect due to integer 260| | // promotion rules. 261| 0| const unsigned_type threshold = 262| 0| ((std::numeric_limits::max)() - Lim + 1) % Lim; 263| 0| while (helper::lo(product) < threshold) { ------------------ | Branch (263:12): [True: 0, False: 0] ------------------ 264| 0| bits = fast_bits(g); 265| 0| product = helper::multiply(bits, Lim); 266| 0| } 267| 0| } 268| | 269| 0| return helper::hi(product); 270| 8|} _ZN4absl12lts_202401166StatusC2Em: 619| 3.22M| explicit Status(uintptr_t rep) : rep_(rep) {} _ZNK4absl12lts_202401166Status2okEv: 816| 3.22M|inline bool Status::ok() const { 817| 3.22M| return rep_ == CodeToInlinedRep(absl::StatusCode::kOk); 818| 3.22M|} _ZN4absl12lts_202401166Status9IsInlinedEm: 888| 3.22M|constexpr bool Status::IsInlined(uintptr_t rep) { return (rep & 1) != 0; } _ZN4absl12lts_202401166Status16CodeToInlinedRepENS0_10StatusCodeE: 892| 6.44M|constexpr uintptr_t Status::CodeToInlinedRep(absl::StatusCode code) { 893| 6.44M| return (static_cast(code) << 2) + 1; 894| 6.44M|} _ZN4absl12lts_202401166Status5UnrefEm: 920| 3.22M|inline void Status::Unref(uintptr_t rep) { 921| 3.22M| if (!IsInlined(rep)) RepToPointer(rep)->Unref(); ------------------ | Branch (921:7): [True: 0, False: 3.22M] ------------------ 922| 3.22M|} _ZN4absl12lts_202401168OkStatusEv: 924| 3.22M|inline Status OkStatus() { return Status(); } _ZN4absl12lts_202401166StatusD2Ev: 814| 3.22M|inline Status::~Status() { Unref(rep_); } _ZN4absl12lts_202401166StatusC2Ev: 772| 3.22M|inline Status::Status() : Status(absl::StatusCode::kOk) {} _ZN4absl12lts_202401166StatusC2ENS0_10StatusCodeE: 774| 3.22M|inline Status::Status(absl::StatusCode code) : Status(CodeToInlinedRep(code)) {} _ZN4absl12lts_2024011613ascii_isspaceEh: 97| 4|inline bool ascii_isspace(unsigned char c) { 98| 4| return (ascii_internal::kPropertyBits[c] & 0x08) != 0; 99| 4|} _ZN4absl12lts_2024011627StripLeadingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE: 200| 1| absl::string_view str) { 201| 1| auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace); 202| 1| return str.substr(static_cast(it - str.begin())); 203| 1|} _ZN4absl12lts_2024011628StripTrailingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE: 214| 1| absl::string_view str) { 215| 1| auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace); 216| 1| return str.substr(0, static_cast(str.rend() - it)); 217| 1|} _ZN4absl12lts_2024011620StripAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE: 228| 1| absl::string_view str) { 229| 1| return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str)); 230| 1|} _ZN4absl12lts_2024011619WebSafeBase64EscapeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE: 914| 1|std::string WebSafeBase64Escape(absl::string_view src) { 915| 1| std::string dest; 916| 1| strings_internal::Base64EscapeInternal( 917| 1| reinterpret_cast(src.data()), src.size(), &dest, 918| 1| false, strings_internal::kWebSafeBase64Chars); 919| 1| return dest; 920| 1|} _ZN4absl12lts_2024011616strings_internal33CalculateBase64EscapedLenInternalEmb: 35| 1|size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding) { 36| | // Base64 encodes three bytes of input at a time. If the input is not 37| | // divisible by three, we pad as appropriate. 38| | // 39| | // Base64 encodes each three bytes of input into four bytes of output. 40| 1| size_t len = (input_len / 3) * 4; 41| | 42| | // Since all base 64 input is an integral number of octets, only the following 43| | // cases can arise: 44| 1| if (input_len % 3 == 0) { ------------------ | Branch (44:7): [True: 0, False: 1] ------------------ 45| | // (from https://tools.ietf.org/html/rfc3548) 46| | // (1) the final quantum of encoding input is an integral multiple of 24 47| | // bits; here, the final unit of encoded output will be an integral 48| | // multiple of 4 characters with no "=" padding, 49| 1| } else if (input_len % 3 == 1) { ------------------ | Branch (49:14): [True: 0, False: 1] ------------------ 50| | // (from https://tools.ietf.org/html/rfc3548) 51| | // (2) the final quantum of encoding input is exactly 8 bits; here, the 52| | // final unit of encoded output will be two characters followed by two 53| | // "=" padding characters, or 54| 0| len += 2; 55| 0| if (do_padding) { ------------------ | Branch (55:9): [True: 0, False: 0] ------------------ 56| 0| len += 2; 57| 0| } 58| 1| } else { // (input_len % 3 == 2) 59| | // (from https://tools.ietf.org/html/rfc3548) 60| | // (3) the final quantum of encoding input is exactly 16 bits; here, the 61| | // final unit of encoded output will be three characters followed by one 62| | // "=" padding character. 63| 1| len += 3; 64| 1| if (do_padding) { ------------------ | Branch (64:9): [True: 0, False: 1] ------------------ 65| 0| len += 1; 66| 0| } 67| 1| } 68| | 69| | assert(len >= input_len); // make sure we didn't overflow 70| 1| return len; 71| 1|} _ZN4absl12lts_2024011616strings_internal20Base64EscapeInternalEPKhmPcmPKcb: 90| 1| bool do_padding) { 91| 1| static const char kPad64 = '='; 92| | 93| 1| if (szsrc * 4 > szdest * 3) return 0; ------------------ | Branch (93:7): [True: 0, False: 1] ------------------ 94| | 95| 1| char* cur_dest = dest; 96| 1| const unsigned char* cur_src = src; 97| | 98| 1| char* const limit_dest = dest + szdest; 99| 1| const unsigned char* const limit_src = src + szsrc; 100| | 101| | // (from https://tools.ietf.org/html/rfc3548) 102| | // Special processing is performed if fewer than 24 bits are available 103| | // at the end of the data being encoded. A full encoding quantum is 104| | // always completed at the end of a quantity. When fewer than 24 input 105| | // bits are available in an input group, zero bits are added (on the 106| | // right) to form an integral number of 6-bit groups. 107| | // 108| | // If do_padding is true, padding at the end of the data is performed. This 109| | // output padding uses the '=' character. 110| | 111| | // Three bytes of data encodes to four characters of cyphertext. 112| | // So we can pump through three-byte chunks atomically. 113| 1| if (szsrc >= 3) { // "limit_src - 3" is UB if szsrc < 3. ------------------ | Branch (113:7): [True: 1, False: 0] ------------------ 114| 11| while (cur_src < limit_src - 3) { // While we have >= 32 bits. ------------------ | Branch (114:12): [True: 10, False: 1] ------------------ 115| 10| uint32_t in = absl::big_endian::Load32(cur_src) >> 8; 116| | 117| 10| cur_dest[0] = base64[in >> 18]; 118| 10| in &= 0x3FFFF; 119| 10| cur_dest[1] = base64[in >> 12]; 120| 10| in &= 0xFFF; 121| 10| cur_dest[2] = base64[in >> 6]; 122| 10| in &= 0x3F; 123| 10| cur_dest[3] = base64[in]; 124| | 125| 10| cur_dest += 4; 126| 10| cur_src += 3; 127| 10| } 128| 1| } 129| | // To save time, we didn't update szdest or szsrc in the loop. So do it now. 130| 1| szdest = static_cast(limit_dest - cur_dest); 131| 1| szsrc = static_cast(limit_src - cur_src); 132| | 133| | /* now deal with the tail (<=3 bytes) */ 134| 1| switch (szsrc) { 135| 0| case 0: ------------------ | Branch (135:5): [True: 0, False: 1] ------------------ 136| | // Nothing left; nothing more to do. 137| 0| break; 138| 0| case 1: { ------------------ | Branch (138:5): [True: 0, False: 1] ------------------ 139| | // One byte left: this encodes to two characters, and (optionally) 140| | // two pad characters to round out the four-character cypherblock. 141| 0| if (szdest < 2) return 0; ------------------ | Branch (141:11): [True: 0, False: 0] ------------------ 142| 0| uint32_t in = cur_src[0]; 143| 0| cur_dest[0] = base64[in >> 2]; 144| 0| in &= 0x3; 145| 0| cur_dest[1] = base64[in << 4]; 146| 0| cur_dest += 2; 147| 0| szdest -= 2; 148| 0| if (do_padding) { ------------------ | Branch (148:11): [True: 0, False: 0] ------------------ 149| 0| if (szdest < 2) return 0; ------------------ | Branch (149:13): [True: 0, False: 0] ------------------ 150| 0| cur_dest[0] = kPad64; 151| 0| cur_dest[1] = kPad64; 152| 0| cur_dest += 2; 153| 0| szdest -= 2; 154| 0| } 155| 0| break; 156| 0| } 157| 1| case 2: { ------------------ | Branch (157:5): [True: 1, False: 0] ------------------ 158| | // Two bytes left: this encodes to three characters, and (optionally) 159| | // one pad character to round out the four-character cypherblock. 160| 1| if (szdest < 3) return 0; ------------------ | Branch (160:11): [True: 0, False: 1] ------------------ 161| 1| uint32_t in = absl::big_endian::Load16(cur_src); 162| 1| cur_dest[0] = base64[in >> 10]; 163| 1| in &= 0x3FF; 164| 1| cur_dest[1] = base64[in >> 4]; 165| 1| in &= 0x00F; 166| 1| cur_dest[2] = base64[in << 2]; 167| 1| cur_dest += 3; 168| 1| szdest -= 3; 169| 1| if (do_padding) { ------------------ | Branch (169:11): [True: 0, False: 1] ------------------ 170| 0| if (szdest < 1) return 0; ------------------ | Branch (170:13): [True: 0, False: 0] ------------------ 171| 0| cur_dest[0] = kPad64; 172| 0| cur_dest += 1; 173| 0| szdest -= 1; 174| 0| } 175| 1| break; 176| 1| } 177| 1| case 3: { ------------------ | Branch (177:5): [True: 0, False: 1] ------------------ 178| | // Three bytes left: same as in the big loop above. We can't do this in 179| | // the loop because the loop above always reads 4 bytes, and the fourth 180| | // byte is past the end of the input. 181| 0| if (szdest < 4) return 0; ------------------ | Branch (181:11): [True: 0, False: 0] ------------------ 182| 0| uint32_t in = 183| 0| (uint32_t{cur_src[0]} << 16) + absl::big_endian::Load16(cur_src + 1); 184| 0| cur_dest[0] = base64[in >> 18]; 185| 0| in &= 0x3FFFF; 186| 0| cur_dest[1] = base64[in >> 12]; 187| 0| in &= 0xFFF; 188| 0| cur_dest[2] = base64[in >> 6]; 189| 0| in &= 0x3F; 190| 0| cur_dest[3] = base64[in]; 191| 0| cur_dest += 4; 192| 0| szdest -= 4; 193| 0| break; 194| 0| } 195| 0| default: ------------------ | Branch (195:5): [True: 0, False: 1] ------------------ 196| | // Should not be reached: blocks of 4 bytes are handled 197| | // in the while loop before this switch statement. 198| 0| ABSL_RAW_LOG(FATAL, "Logic problem? szsrc = %zu", szsrc); ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 199| 0| break; 200| 1| } 201| 1| return static_cast(cur_dest - dest); 202| 1|} _ZN4absl12lts_2024011616strings_internal20Base64EscapeInternalINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvPKhmPT_bPKc: 42| 1| bool do_padding, const char* base64_chars) { 43| 1| const size_t calc_escaped_size = 44| 1| CalculateBase64EscapedLenInternal(szsrc, do_padding); 45| 1| STLStringResizeUninitialized(dest, calc_escaped_size); 46| | 47| 1| const size_t escaped_len = Base64EscapeInternal( 48| 1| src, szsrc, &(*dest)[0], dest->size(), base64_chars, do_padding); 49| | assert(calc_escaped_size == escaped_len); 50| 1| dest->erase(escaped_len); 51| 1|} _ZN4absl12lts_2024011616strings_internal28STLStringResizeUninitializedINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEEvPT_m: 67| 8|inline void STLStringResizeUninitialized(string_type* s, size_t new_size) { 68| 8| ResizeUninitializedTraits::Resize(s, new_size); 69| 8|} _ZN4absl12lts_2024011616strings_internal25ResizeUninitializedTraitsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE6ResizeEPS9_m: 47| 8| static void Resize(string_type* s, size_t new_size) { 48| 8| s->__resize_default_init(new_size); 49| 8| } _ZN4absl12lts_2024011611StrContainsENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_: 47| 1| absl::string_view needle) noexcept { 48| 1| return haystack.find(needle, 0) != haystack.npos; 49| 1|} _ZN4absl12lts_2024011610StartsWithENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_: 59| 7| absl::string_view prefix) noexcept { 60| 7| return prefix.empty() || ------------------ | Branch (60:10): [True: 0, False: 7] ------------------ 61| 7| (text.size() >= prefix.size() && ------------------ | Branch (61:11): [True: 7, False: 0] ------------------ 62| 7| memcmp(text.data(), prefix.data(), prefix.size()) == 0); ------------------ | Branch (62:11): [True: 6, False: 1] ------------------ 63| 7|} _ZN4absl12lts_2024011616numbers_internal18safe_strtou64_baseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPmi: 1360| 1| int base) { 1361| 1| return safe_uint_internal(text, value, base); 1362| 1|} numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_124safe_parse_sign_and_baseEPNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPiPb: 923| 1| absl::Nonnull negative_ptr /*output*/) { 924| 1| if (text->data() == nullptr) { ------------------ | Branch (924:7): [True: 0, False: 1] ------------------ 925| 0| return false; 926| 0| } 927| | 928| 1| const char* start = text->data(); 929| 1| const char* end = start + text->size(); 930| 1| int base = *base_ptr; 931| | 932| | // Consume whitespace. 933| 1| while (start < end && ------------------ | Branch (933:10): [True: 1, False: 0] ------------------ 934| 1| absl::ascii_isspace(static_cast(start[0]))) { ------------------ | Branch (934:10): [True: 0, False: 1] ------------------ 935| 0| ++start; 936| 0| } 937| 1| while (start < end && ------------------ | Branch (937:10): [True: 1, False: 0] ------------------ 938| 1| absl::ascii_isspace(static_cast(end[-1]))) { ------------------ | Branch (938:10): [True: 0, False: 1] ------------------ 939| 0| --end; 940| 0| } 941| 1| if (start >= end) { ------------------ | Branch (941:7): [True: 0, False: 1] ------------------ 942| 0| return false; 943| 0| } 944| | 945| | // Consume sign. 946| 1| *negative_ptr = (start[0] == '-'); 947| 1| if (*negative_ptr || start[0] == '+') { ------------------ | Branch (947:7): [True: 0, False: 1] | Branch (947:24): [True: 0, False: 1] ------------------ 948| 0| ++start; 949| 0| if (start >= end) { ------------------ | Branch (949:9): [True: 0, False: 0] ------------------ 950| 0| return false; 951| 0| } 952| 0| } 953| | 954| | // Consume base-dependent prefix. 955| | // base 0: "0x" -> base 16, "0" -> base 8, default -> base 10 956| | // base 16: "0x" -> base 16 957| | // Also validate the base. 958| 1| if (base == 0) { ------------------ | Branch (958:7): [True: 0, False: 1] ------------------ 959| 0| if (end - start >= 2 && start[0] == '0' && ------------------ | Branch (959:9): [True: 0, False: 0] | Branch (959:29): [True: 0, False: 0] ------------------ 960| 0| (start[1] == 'x' || start[1] == 'X')) { ------------------ | Branch (960:10): [True: 0, False: 0] | Branch (960:29): [True: 0, False: 0] ------------------ 961| 0| base = 16; 962| 0| start += 2; 963| 0| if (start >= end) { ------------------ | Branch (963:11): [True: 0, False: 0] ------------------ 964| | // "0x" with no digits after is invalid. 965| 0| return false; 966| 0| } 967| 0| } else if (end - start >= 1 && start[0] == '0') { ------------------ | Branch (967:16): [True: 0, False: 0] | Branch (967:36): [True: 0, False: 0] ------------------ 968| 0| base = 8; 969| 0| start += 1; 970| 0| } else { 971| 0| base = 10; 972| 0| } 973| 1| } else if (base == 16) { ------------------ | Branch (973:14): [True: 0, False: 1] ------------------ 974| 0| if (end - start >= 2 && start[0] == '0' && ------------------ | Branch (974:9): [True: 0, False: 0] | Branch (974:29): [True: 0, False: 0] ------------------ 975| 0| (start[1] == 'x' || start[1] == 'X')) { ------------------ | Branch (975:10): [True: 0, False: 0] | Branch (975:29): [True: 0, False: 0] ------------------ 976| 0| start += 2; 977| 0| if (start >= end) { ------------------ | Branch (977:11): [True: 0, False: 0] ------------------ 978| | // "0x" with no digits after is invalid. 979| 0| return false; 980| 0| } 981| 0| } 982| 1| } else if (base >= 2 && base <= 36) { ------------------ | Branch (982:14): [True: 1, False: 0] | Branch (982:27): [True: 1, False: 0] ------------------ 983| | // okay 984| 1| } else { 985| 0| return false; 986| 0| } 987| 1| *text = absl::string_view(start, static_cast(end - start)); 988| 1| *base_ptr = base; 989| 1| return true; 990| 1|} numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118safe_uint_internalImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i: 1305| 1| absl::Nonnull value_p, int base) { 1306| 1| *value_p = 0; 1307| 1| bool negative; 1308| 1| if (!safe_parse_sign_and_base(&text, &base, &negative) || negative) { ------------------ | Branch (1308:7): [True: 0, False: 1] | Branch (1308:61): [True: 0, False: 1] ------------------ 1309| 0| return false; 1310| 0| } 1311| 1| return safe_parse_positive_int(text, base, value_p); 1312| 1|} numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_123safe_parse_positive_intImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiPT_: 1208| 1| absl::Nonnull value_p) { 1209| 1| IntType value = 0; 1210| 1| const IntType vmax = std::numeric_limits::max(); 1211| 1| assert(vmax > 0); 1212| 1| assert(base >= 0); 1213| 1| const IntType base_inttype = static_cast(base); 1214| 1| assert(vmax >= base_inttype); 1215| 1| const IntType vmax_over_base = LookupTables::kVmaxOverBase[base]; 1216| 1| assert(base < 2 || 1217| 1| std::numeric_limits::max() / base_inttype == vmax_over_base); 1218| 1| const char* start = text.data(); 1219| 1| const char* end = start + text.size(); 1220| | // loop over digits 1221| 4| for (; start < end; ++start) { ------------------ | Branch (1221:10): [True: 3, False: 1] ------------------ 1222| 3| unsigned char c = static_cast(start[0]); 1223| 3| IntType digit = static_cast(kAsciiToInt[c]); 1224| 3| if (digit >= base_inttype) { ------------------ | Branch (1224:9): [True: 0, False: 3] ------------------ 1225| 0| *value_p = value; 1226| 0| return false; 1227| 0| } 1228| 3| if (value > vmax_over_base) { ------------------ | Branch (1228:9): [True: 0, False: 3] ------------------ 1229| 0| *value_p = vmax; 1230| 0| return false; 1231| 0| } 1232| 3| value *= base_inttype; 1233| 3| if (value > vmax - digit) { ------------------ | Branch (1233:9): [True: 0, False: 3] ------------------ 1234| 0| *value_p = vmax; 1235| 0| return false; 1236| 0| } 1237| 3| value += digit; 1238| 3| } 1239| 1| *value_p = value; 1240| 1| return true; 1241| 1|} _ZN4absl12lts_2024011616numbers_internal16safe_strtoi_baseImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i: 354| 1| int base) { 355| 1| static_assert(sizeof(*out) == 4 || sizeof(*out) == 8, 356| 1| "SimpleAtoi works only with 32-bit or 64-bit integers."); 357| 1| static_assert(!std::is_floating_point::value, 358| 1| "Use SimpleAtof or SimpleAtod instead."); 359| 1| bool parsed; 360| | // TODO(jorg): This signed-ness check is used because it works correctly 361| | // with enums, and it also serves to check that int_type is not a pointer. 362| | // If one day something like std::is_signed works, switch to it. 363| | // These conditions are constexpr bools to suppress MSVC warning C4127. 364| 1| constexpr bool kIsSigned = static_cast(1) - 2 < 0; 365| 1| constexpr bool kUse64Bit = sizeof(*out) == 64 / 8; 366| 1| if (kIsSigned) { ------------------ | Branch (366:7): [Folded, False: 1] ------------------ 367| 0| if (kUse64Bit) { ------------------ | Branch (367:9): [True: 0, Folded] ------------------ 368| 0| int64_t val; 369| 0| parsed = numbers_internal::safe_strto64_base(s, &val, base); 370| 0| *out = static_cast(val); 371| 0| } else { 372| 0| int32_t val; 373| 0| parsed = numbers_internal::safe_strto32_base(s, &val, base); 374| 0| *out = static_cast(val); 375| 0| } 376| 1| } else { 377| 1| if (kUse64Bit) { ------------------ | Branch (377:9): [True: 1, Folded] ------------------ 378| 1| uint64_t val; 379| 1| parsed = numbers_internal::safe_strtou64_base(s, &val, base); 380| 1| *out = static_cast(val); 381| 1| } else { 382| 0| uint32_t val; 383| 0| parsed = numbers_internal::safe_strtou32_base(s, &val, base); 384| 0| *out = static_cast(val); 385| 0| } 386| 1| } 387| 1| return parsed; 388| 1|} _ZN4absl12lts_202401166StrCatERKNS0_8AlphaNumES3_: 58| 1|std::string StrCat(const AlphaNum& a, const AlphaNum& b) { 59| 1| std::string result; 60| 1| absl::strings_internal::STLStringResizeUninitialized(&result, 61| 1| a.size() + b.size()); 62| 1| char* const begin = &result[0]; 63| 1| char* out = begin; 64| 1| out = Append(out, a); 65| 1| out = Append(out, b); 66| | assert(out == begin + result.size()); 67| 1| return result; 68| 1|} _ZN4absl12lts_202401166StrCatERKNS0_8AlphaNumES3_S3_: 70| 6|std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c) { 71| 6| std::string result; 72| 6| strings_internal::STLStringResizeUninitialized( 73| 6| &result, a.size() + b.size() + c.size()); 74| 6| char* const begin = &result[0]; 75| 6| char* out = begin; 76| 6| out = Append(out, a); 77| 6| out = Append(out, b); 78| 6| out = Append(out, c); 79| | assert(out == begin + result.size()); 80| 6| return result; 81| 6|} str_cat.cc:_ZN4absl12lts_2024011612_GLOBAL__N_16AppendEPcRKNS0_8AlphaNumE: 46| 20|absl::Nonnull Append(absl::Nonnull out, const AlphaNum& x) { 47| | // memcpy is allowed to overwrite arbitrary memory, so doing this after the 48| | // call would force an extra fetch of x.size(). 49| 20| char* after = out + x.size(); 50| 20| if (x.size() != 0) { ------------------ | Branch (50:7): [True: 19, False: 1] ------------------ 51| 19| memcpy(out, x.data(), x.size()); 52| 19| } 53| 20| return after; 54| 20|} _ZN4absl12lts_202401168AlphaNumC2EPKc: 353| 8| : piece_(NullSafeStringView(c_str)) {} _ZN4absl12lts_202401168AlphaNumC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 356| 3| : piece_(pc) {} _ZNK4absl12lts_202401168AlphaNum4sizeEv: 377| 79| absl::string_view::size_type size() const { return piece_.size(); } _ZNK4absl12lts_202401168AlphaNum4dataEv: 378| 19| absl::Nullable data() const { return piece_.data(); } _ZN4absl12lts_202401168AlphaNumC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE: 369| 9| : piece_(str) {} _ZN4absl12lts_2024011618NullSafeStringViewEPKc: 762| 8|constexpr string_view NullSafeStringView(absl::Nullable p) { 763| 8| return p ? string_view(p) : string_view(); ------------------ | Branch (763:10): [True: 8, False: 0] ------------------ 764| 8|} _ZN4absl12lts_2024011613ConsumePrefixEPNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_: 48| 6| absl::string_view expected) { 49| 6| if (!absl::StartsWith(*str, expected)) return false; ------------------ | Branch (49:7): [True: 0, False: 6] ------------------ 50| 6| str->remove_prefix(expected.size()); 51| 6| return true; 52| 6|} _ZN4absl12lts_2024011624synchronization_internal14InvalidGraphIdEv: 58| 86|inline GraphId InvalidGraphId() { 59| 86| return GraphId{0}; 60| 86|} _ZN4absl12lts_202401165Mutex4LockEv: 1524| 86|void Mutex::Lock() { 1525| 86| ABSL_TSAN_MUTEX_PRE_LOCK(this, 0); 1526| 86| GraphId id = DebugOnlyDeadlockCheck(this); 1527| 86| intptr_t v = mu_.load(std::memory_order_relaxed); 1528| | // try fast acquire, then spin loop 1529| 86| if (ABSL_PREDICT_FALSE((v & (kMuWriter | kMuReader | kMuEvent)) != 0) || ------------------ | | 178| 172|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 86] | | | Branch (178:49): [Folded, False: 86] | | | Branch (178:58): [True: 0, False: 86] | | ------------------ ------------------ 1530| 86| ABSL_PREDICT_FALSE(!mu_.compare_exchange_strong( ------------------ | | 178| 86|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 86] | | | Branch (178:49): [Folded, False: 86] | | | Branch (178:58): [True: 0, False: 86] | | ------------------ ------------------ 1531| 86| v, kMuWriter | v, std::memory_order_acquire, 1532| 86| std::memory_order_relaxed))) { 1533| | // try spin acquire, then slow loop 1534| 0| if (ABSL_PREDICT_FALSE(!TryAcquireWithSpinning(&this->mu_))) { ------------------ | | 178| 0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 0] | | | Branch (178:49): [Folded, False: 0] | | | Branch (178:58): [True: 0, False: 0] | | ------------------ ------------------ 1535| 0| this->LockSlow(kExclusive, nullptr, 0); 1536| 0| } 1537| 0| } 1538| 86| DebugOnlyLockEnter(this, id); 1539| 86| ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0); 1540| 86|} _ZN4absl12lts_202401165Mutex6UnlockEv: 1702| 86|void Mutex::Unlock() { 1703| 86| ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0); 1704| 86| DebugOnlyLockLeave(this); 1705| 86| intptr_t v = mu_.load(std::memory_order_relaxed); 1706| | 1707| 86| if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) { ------------------ | Branch (1707:7): [Folded, False: 86] | Branch (1707:21): [True: 0, False: 0] ------------------ 1708| 0| ABSL_RAW_LOG(FATAL, "Mutex unlocked when destroyed or not locked: v=0x%x", ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1709| 0| static_cast(v)); 1710| 0| } 1711| | 1712| | // should_try_cas is whether we'll try a compare-and-swap immediately. 1713| | // NOTE: optimized out when kDebugMode is false. 1714| 86| bool should_try_cas = ((v & (kMuEvent | kMuWriter)) == kMuWriter && ------------------ | Branch (1714:26): [True: 86, False: 0] ------------------ 1715| 86| (v & (kMuWait | kMuDesig)) != kMuWait); ------------------ | Branch (1715:26): [True: 86, False: 0] ------------------ 1716| | // But, we can use an alternate computation of it, that compilers 1717| | // currently don't find on their own. When that changes, this function 1718| | // can be simplified. 1719| 86| intptr_t x = (v ^ (kMuWriter | kMuWait)) & (kMuWriter | kMuEvent); 1720| 86| intptr_t y = (v ^ (kMuWriter | kMuWait)) & (kMuWait | kMuDesig); 1721| | // Claim: "x == 0 && y > 0" is equal to should_try_cas. 1722| | // Also, because kMuWriter and kMuEvent exceed kMuDesig and kMuWait, 1723| | // all possible non-zero values for x exceed all possible values for y. 1724| | // Therefore, (x == 0 && y > 0) == (x < y). 1725| 86| if (kDebugMode && should_try_cas != (x < y)) { ------------------ | Branch (1725:7): [Folded, False: 86] | Branch (1725:21): [True: 0, False: 0] ------------------ 1726| | // We would usually use PRIdPTR here, but is not correctly implemented 1727| | // within the android toolchain. 1728| 0| ABSL_RAW_LOG(FATAL, "internal logic error %llx %llx %llx\n", ------------------ | | 45| 0| do { \ | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | ------------------ | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | ------------------ | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | 50| 0| __VA_ARGS__); \ | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | ------------------ | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | ------------------ | | | | | | 225| 0| do { \ | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | ------------------ | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | ------------------ | | | | | | 229| 0| } while (false) | | | | | | ------------------ | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 52| 0| } while (0) | | ------------------ | | | Branch (52:12): [Folded, False: 0] | | ------------------ ------------------ 1729| 0| static_cast(v), static_cast(x), 1730| 0| static_cast(y)); 1731| 0| } 1732| 86| if (x < y && mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter), ------------------ | Branch (1732:7): [True: 86, False: 0] | Branch (1732:16): [True: 86, False: 0] ------------------ 1733| 86| std::memory_order_release, 1734| 86| std::memory_order_relaxed)) { 1735| | // fast writer release (writer with no waiters or with designated waker) 1736| 86| } else { 1737| 0| this->UnlockSlow(nullptr /*no waitp*/); // take slow path 1738| 0| } 1739| 86| ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0); 1740| 86|} mutex.cc:_ZN4absl12lts_20240116L22DebugOnlyDeadlockCheckEPNS0_5MutexE: 1466| 86|static inline GraphId DebugOnlyDeadlockCheck(Mutex* mu) { 1467| 86| if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) != ------------------ | Branch (1467:7): [Folded, False: 86] | Branch (1467:21): [True: 0, False: 0] ------------------ 1468| 0| OnDeadlockCycle::kIgnore) { 1469| 0| return DeadlockCheck(mu); 1470| 86| } else { 1471| 86| return InvalidGraphId(); 1472| 86| } 1473| 86|} mutex.cc:_ZN4absl12lts_20240116L18DebugOnlyLockEnterEPNS0_5MutexENS0_24synchronization_internal7GraphIdE: 1298| 86|static inline void DebugOnlyLockEnter(Mutex* mu, GraphId id) { 1299| 86| if (kDebugMode) { ------------------ | Branch (1299:7): [Folded, False: 86] ------------------ 1300| 0| if (synch_deadlock_detection.load(std::memory_order_acquire) != ------------------ | Branch (1300:9): [True: 0, False: 0] ------------------ 1301| 0| OnDeadlockCycle::kIgnore) { 1302| 0| LockEnter(mu, id, Synch_GetAllLocks()); 1303| 0| } 1304| 0| } 1305| 86|} mutex.cc:_ZN4absl12lts_20240116L18DebugOnlyLockLeaveEPNS0_5MutexE: 1308| 86|static inline void DebugOnlyLockLeave(Mutex* mu) { 1309| 86| if (kDebugMode) { ------------------ | Branch (1309:7): [Folded, False: 86] ------------------ 1310| 0| if (synch_deadlock_detection.load(std::memory_order_acquire) != ------------------ | Branch (1310:9): [True: 0, False: 0] ------------------ 1311| 0| OnDeadlockCycle::kIgnore) { 1312| 0| LockLeave(mu, GetGraphId(mu), Synch_GetAllLocks()); 1313| 0| } 1314| 0| } 1315| 86|} _ZN4absl12lts_202401169MutexLockC2EPNS0_5MutexE: 583| 65| explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) { 584| 65| this->mu_->Lock(); 585| 65| } _ZN4absl12lts_202401169MutexLockD2Ev: 601| 65| ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->Unlock(); } _ZN4absl12lts_202401165MutexC2Ev: 1061| 20|inline Mutex::Mutex() : mu_(0) { 1062| 20| ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static); 1063| 20|} _ZN4absl12lts_202401163NowEv: 39| 1|Time Now() { 40| | // TODO(bww): Get a timespec instead so we don't have to divide. 41| 1| int64_t n = absl::GetCurrentTimeNanos(); 42| 1| if (n >= 0) { ------------------ | Branch (42:7): [True: 1, False: 0] ------------------ 43| 1| return time_internal::FromUnixDuration( 44| 1| time_internal::MakeDuration(n / 1000000000, n % 1000000000 * 4)); 45| 1| } 46| 0| return time_internal::FromUnixDuration(absl::Nanoseconds(n)); 47| 1|} _ZN4absl12lts_2024011619GetCurrentTimeNanosEv: 77| 1|int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); } ------------------ | | 71| 1| ::absl::time_internal::GetCurrentTimeNanosFromSystem() ------------------ clock.cc:_ZN4absl12lts_2024011613time_internalL29GetCurrentTimeNanosFromSystemEv: 13| 1|static int64_t GetCurrentTimeNanosFromSystem() { 14| 1| const int64_t kNanosPerSecond = 1000 * 1000 * 1000; 15| 1| struct timespec ts; 16| 1| ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0, ------------------ | | 60| 1| do { \ | | 61| 1| if (ABSL_PREDICT_FALSE(!(condition))) { \ | | ------------------ | | | | 178| 1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | | | ------------------ | | | | | Branch (178:31): [True: 0, False: 1] | | | | | Branch (178:49): [Folded, False: 1] | | | | | Branch (178:58): [True: 0, False: 1] | | | | ------------------ | | ------------------ | | 62| 0| ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \ | | ------------------ | | | | 45| 0| do { \ | | | | 46| 0| constexpr const char* absl_raw_log_internal_basename = \ | | | | 47| 0| ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1); \ | | | | 48| 0| ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity, \ | | | | ------------------ | | | | | | 110| 0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal | | | | ------------------ | | | | 49| 0| absl_raw_log_internal_basename, __LINE__, \ | | | | 50| 0| __VA_ARGS__); \ | | | | 51| 0| ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity; \ | | | | ------------------ | | | | | | 118| 0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 225| 0| do { \ | | | | | | | | 226| 0| /* NOLINTNEXTLINE: misc-static-assert */ \ | | | | | | | | 227| 0| assert(false && "ABSL_UNREACHABLE reached"); \ | | | | | | | | 228| 0| ABSL_INTERNAL_UNREACHABLE_IMPL(); \ | | | | | | | | ------------------ | | | | | | | | | | 203| 0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable() | | | | | | | | ------------------ | | | | | | | | 229| 0| } while (false) | | | | | | | | ------------------ | | | | | | | | | Branch (229:12): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 52| 0| } while (0) | | | | ------------------ | | | | | Branch (52:12): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 63| 0| } \ | | 64| 1| } while (0) | | ------------------ | | | Branch (64:12): [Folded, False: 1] | | ------------------ ------------------ 17| 1| "Failed to read real-time clock."); 18| 1| return (int64_t{ts.tv_sec} * kNanosPerSecond + 19| 1| int64_t{ts.tv_nsec}); 20| 1|} _ZN4absl12lts_202401168DurationC2Ev: 169| 7| constexpr Duration() : rep_hi_(0), rep_lo_(0) {} // zero-length duration _ZN4absl12lts_202401168DurationC2Elj: 231| 4| constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {} _ZN4absl12lts_202401168Duration5HiRepC2El: 251| 11| lo_(0), 252| 11| hi_(0) 253| |#endif 254| 11| { 255| 11| *this = value; 256| 11| } _ZNK4absl12lts_202401168Duration5HiRep3GetEv: 258| 8| constexpr int64_t Get() const { 259| 8| const uint64_t unsigned_value = 260| 8| (static_cast(hi_) << 32) | static_cast(lo_); 261| | // `static_cast(unsigned_value)` is implementation-defined 262| | // before c++20. On all supported platforms the behaviour is that mandated 263| | // by c++20, i.e. "If the destination type is signed, [...] the result is 264| | // the unique value of the destination type equal to the source value 265| | // modulo 2^n, where n is the number of bits used to represent the 266| | // destination type." 267| 8| static_assert( 268| 8| (static_cast((std::numeric_limits::max)()) == 269| 8| int64_t{-1}) && 270| 8| (static_cast(static_cast( 271| 8| (std::numeric_limits::max)()) + 272| 8| 1) == 273| 8| (std::numeric_limits::min)()), 274| 8| "static_cast(uint64_t) does not have c++20 semantics"); 275| 8| return static_cast(unsigned_value); 276| 8| } _ZN4absl12lts_202401168Duration5HiRepaSEl: 278| 11| constexpr HiRep& operator=(const int64_t value) { 279| | // "If the destination type is unsigned, the resulting value is the 280| | // smallest unsigned value equal to the source value modulo 2^n 281| | // where `n` is the number of bits used to represent the destination 282| | // type". 283| 11| const auto unsigned_value = static_cast(value); 284| 11| hi_ = static_cast(unsigned_value >> 32); 285| 11| lo_ = static_cast(unsigned_value); 286| 11| return *this; 287| 11| } _ZN4absl12lts_202401164TimeC2ENS0_8DurationE: 850| 2| constexpr explicit Time(Duration rep) : rep_(rep) {} _ZN4absl12lts_20240116leENS0_8DurationES1_: 320| 4| Duration rhs) { 321| 4| return !(rhs < lhs); 322| 4|} _ZN4absl12lts_2024011612ZeroDurationEv: 416| 5|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ZeroDuration() { 417| 5| return Duration(); 418| 5|} _ZN4absl12lts_2024011614InfiniteFutureEv: 907| 1|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time InfiniteFuture() { 908| 1| return Time(time_internal::MakeDuration((std::numeric_limits::max)(), 909| 1| ~uint32_t{0})); 910| 1|} _ZN4absl12lts_2024011613time_internal12MakeDurationElj: 1561| 4| uint32_t lo = 0) { 1562| 4| return Duration(hi, lo); 1563| 4|} _ZN4absl12lts_2024011613time_internal12MakeDurationEll: 1566| 1| int64_t lo) { 1567| 1| return MakeDuration(hi, static_cast(lo)); 1568| 1|} _ZN4absl12lts_2024011613time_internal8GetRepHiENS0_8DurationE: 1593| 8|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr int64_t GetRepHi(Duration d) { 1594| 8| return d.rep_hi_.Get(); 1595| 8|} _ZN4absl12lts_2024011613time_internal8GetRepLoENS0_8DurationE: 1596| 4|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr uint32_t GetRepLo(Duration d) { 1597| 4| return d.rep_lo_; 1598| 4|} _ZN4absl12lts_2024011613time_internal16FromUnixDurationENS0_8DurationE: 1626| 1|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixDuration(Duration d) { 1627| 1| return Time(d); 1628| 1|} _ZN4absl12lts_20240116ltENS0_8DurationES1_: 1721| 4| Duration rhs) { 1722| 4| return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs) ------------------ | Branch (1722:10): [True: 2, False: 2] ------------------ 1723| 4| ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs) 1724| 4| : time_internal::GetRepHi(lhs) == (std::numeric_limits::min)() ------------------ | Branch (1724:12): [True: 0, False: 2] ------------------ 1725| 2| ? time_internal::GetRepLo(lhs) + 1 < 1726| 0| time_internal::GetRepLo(rhs) + 1 1727| 2| : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs); 1728| 4|} _ZN4absl12lts_2024011616InfiniteDurationEv: 1762| 2|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration InfiniteDuration() { 1763| 2| return time_internal::MakeDuration((std::numeric_limits::max)(), 1764| 2| ~uint32_t{0}); 1765| 2|} _ZN4absl12lts_202401164TimeC2Ev: 780| 2| constexpr Time() = default; _ZN4absl12lts_2024011613span_internal7GetDataIKNSt3__16vectorIjNS3_9allocatorIjEEEEEEDTcl11GetDataImplfp_Li0EEERT_: 50| 1| -> decltype(GetDataImpl(c, 0)) { 51| 1| return GetDataImpl(c, 0); 52| 1|} _ZN4absl12lts_2024011613span_internal11GetDataImplIKNSt3__16vectorIjNS3_9allocatorIjEEEEEEDTcldtfp_4dataEERT_c: 38| 1| -> decltype(c.data()) { 39| 1| return c.data(); 40| 1|} _ZN4absl12lts_2024011613span_internal7GetDataIKNS0_4SpanIjEEEEDTcl11GetDataImplfp_Li0EEERT_: 50| 8| -> decltype(GetDataImpl(c, 0)) { 51| 8| return GetDataImpl(c, 0); 52| 8|} _ZN4absl12lts_2024011613span_internal11GetDataImplIKNS0_4SpanIjEEEEDTcldtfp_4dataEERT_c: 38| 8| -> decltype(c.data()) { 39| 8| return c.data(); 40| 8|} _ZNK4absl12lts_202401164SpanIjE4dataEv: 281| 10| constexpr pointer data() const noexcept { return ptr_; } _ZNK4absl12lts_202401164SpanIjE4sizeEv: 286| 10| constexpr size_type size() const noexcept { return len_; } _ZN4absl12lts_202401168MakeSpanITpTnRiJEhEENS0_4SpanIT0_EEPS4_m: 685| 1|constexpr Span MakeSpan(absl::Nullable ptr, size_t size) noexcept { 686| 1| return Span(ptr, size); 687| 1|} _ZNK4absl12lts_202401164SpanIhE4dataEv: 281| 1| constexpr pointer data() const noexcept { return ptr_; } _ZNK4absl12lts_202401164SpanIhE4sizeEv: 286| 1| constexpr size_type size() const noexcept { return len_; } _ZNK4absl12lts_202401164SpanIKjE4dataEv: 281| 17| constexpr pointer data() const noexcept { return ptr_; } _ZNK4absl12lts_202401164SpanIKjE5beginEv: 336| 8| constexpr iterator begin() const noexcept { return data(); } _ZNK4absl12lts_202401164SpanIKjE4sizeEv: 286| 9| constexpr size_type size() const noexcept { return len_; } _ZNK4absl12lts_202401164SpanIKjE3endEv: 349| 8| constexpr iterator end() const noexcept { return data() + size(); } _ZN4absl12lts_202401164SpanIhEC2EPhm: 193| 1| : ptr_(array), len_(length) {} _ZN4absl12lts_202401164SpanIKjEC2INSt3__16vectorIjNS5_9allocatorIjEEEEvS9_iEERKT_: 217| 1| : Span(span_internal::GetData(v), v.size()) {} _ZN4absl12lts_202401164SpanIKjEC2EPS2_m: 193| 9| : ptr_(array), len_(length) {} _ZN4absl12lts_202401168MakeSpanITpTnRiJEjLm512EEENS0_4SpanIT0_EERAT1__S4_: 702| 1|constexpr Span MakeSpan(T (&array)[N]) noexcept { 703| 1| return Span(array, N); 704| 1|} _ZN4absl12lts_202401164SpanIjEC2EPjm: 193| 9| : ptr_(array), len_(length) {} _ZN4absl12lts_202401168MakeSpanITpTnRiJEjEENS0_4SpanIT0_EEPS4_m: 685| 8|constexpr Span MakeSpan(absl::Nullable ptr, size_t size) noexcept { 686| 8| return Span(ptr, size); 687| 8|} _ZN4absl12lts_202401164SpanIKjEC2INS1_IjEEvS5_TnNSt3__19enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKS8_: 232| 8| : Span(span_internal::GetData(v), v.size()) {} _ZNK4absl12lts_202401164SpanIjE5emptyEv: 296| 1| constexpr bool empty() const noexcept { return size() == 0; } _ZN4absl12lts_202401167forwardINS0_18container_internal12CommonFieldsEEEOT_RNSt3__116remove_referenceIS4_E4typeE: 149| 3| absl::remove_reference_t& t) noexcept { // NOLINT(runtime/references) 150| 3| return static_cast(t); 151| 3|} _ZN4absl12lts_202401167forwardINS0_18container_internal10StringHashEEEOT_RNSt3__116remove_referenceIS4_E4typeE: 149| 3| absl::remove_reference_t& t) noexcept { // NOLINT(runtime/references) 150| 3| return static_cast(t); 151| 3|} _ZN4absl12lts_202401167forwardINS0_18container_internal8StringEqEEEOT_RNSt3__116remove_referenceIS4_E4typeE: 149| 3| absl::remove_reference_t& t) noexcept { // NOLINT(runtime/references) 150| 3| return static_cast(t); 151| 3|} _ZN4absl12lts_202401167forwardINSt3__19allocatorINS2_4pairIKNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEEOT_RNS2_16remove_referenceISE_E4typeE: 149| 3| absl::remove_reference_t& t) noexcept { // NOLINT(runtime/references) 150| 3| return static_cast(t); 151| 3|} _ZN8fuzztest15internal_no_adl9ArbitraryINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEDav: 283| 1|auto Arbitrary() { 284| 1| return internal::ArbitraryImpl{}; 285| 1|} _ZN8fuzztest15internal_no_adl9ElementOfI15avifPixelFormatEEDaSt16initializer_listIT_E: 295| 1|auto ElementOf(std::initializer_list values) { 296| 1| return internal::ElementOfImpl(values); 297| 1|} _ZN8fuzztest15internal_no_adl9ArbitraryIbEEDav: 283| 4|auto Arbitrary() { 284| 4| return internal::ArbitraryImpl{}; 285| 4|} _ZN8fuzztest15internal_no_adl9ElementOfIiEEDaSt16initializer_listIT_E: 295| 1|auto ElementOf(std::initializer_list values) { 296| 1| return internal::ElementOfImpl(values); 297| 1|} avif_fuzztest_read_image.cc:_ZN8fuzztest15internal_no_adl7TupleOfITpTnRiJEJNS_8internal23SequenceContainerOfImplINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS3_13ArbitraryImplIcvEEEENS3_13ElementOfImplI15avifPixelFormatEENSF_IiEENSF_I22avifChromaDownsamplingEENSC_IbvEESL_SL_SL_NSF_I3$_0EEEEEDaDpT0_: 584| 1|auto TupleOf(Inner... inner) { 585| 1| return internal::AggregateOfImpl...>, 586| 1| internal::RequireCustomCorpusType::kNo, 587| 1| Inner...>(std::in_place, 588| 1| std::move(inner)...); 589| 1|} _ZN8fuzztest15internal_no_adl9ElementOfI22avifChromaDownsamplingEEDaSt16initializer_listIT_E: 295| 1|auto ElementOf(std::initializer_list values) { 296| 1| return internal::ElementOfImpl(values); 297| 1|} avif_fuzztest_read_image.cc:_ZN8fuzztest15internal_no_adl9ElementOfI3$_0EEDaSt16initializer_listIT_E: 295| 1|auto ElementOf(std::initializer_list values) { 296| 1| return internal::ElementOfImpl(values); 297| 1|} main: 21| 1|int main(int argc, char** argv) { 22| 1| testing::InitGoogleTest(&argc, argv); 23| | // We call fuzztest::ParseAbslFlagsrather than absl::ParseCommandLine 24| | // since the latter would complain about any unknown flags that need 25| | // to be passed to legacy fuzzing engines (e.g. libfuzzer). 26| 1| fuzztest::ParseAbslFlags(argc, argv); 27| 1| fuzztest::InitFuzzTest(&argc, &argv); 28| 1| return RUN_ALL_TESTS(); 29| 1|} _ZN8fuzztest22ReadFilesFromDirectoryENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 67| 1| std::string_view dir) { 68| 1| std::vector> out; 69| 1| const std::filesystem::path fs_dir(dir); 70| 1| if (!std::filesystem::is_directory(fs_dir)) return out; ------------------ | Branch (70:7): [True: 0, False: 1] ------------------ 71| 1| for (const auto& entry : ------------------ | Branch (71:26): [True: 101, False: 1] ------------------ 72| 101| std::filesystem::recursive_directory_iterator(fs_dir)) { 73| 101| if (std::filesystem::is_directory(entry)) continue; ------------------ | Branch (73:9): [True: 0, False: 101] ------------------ 74| 101| std::ifstream stream(entry.path().string()); 75| 101| if (!stream.good()) { ------------------ | Branch (75:9): [True: 0, False: 101] ------------------ 76| | // Using stderr instead of GetStderr() to avoid 77| | // initialization-order-fiasco when reading files at static init time with 78| | // `.WithSeeds(fuzztest::ReadFilesFromDirectory(...))`. 79| 0| absl::FPrintF(stderr, "[!] %s:%d: Error reading %s: (%d) %s\n", __FILE__, 80| 0| __LINE__, entry.path().string(), errno, strerror(errno)); 81| 0| continue; 82| 0| } 83| 101| std::stringstream buffer; 84| 101| buffer << stream.rdbuf(); 85| 101| out.push_back({buffer.str()}); 86| 101| } 87| 1| return out; 88| 1|} _ZN8fuzztest19ListRegisteredTestsEv: 168| 3|std::vector ListRegisteredTests() { 169| 3| std::vector result; 170| 3| internal::ForEachTest( 171| 3| [&](const auto& test) { result.push_back(test.full_name()); }); 172| 3| return result; 173| 3|} _ZN8fuzztest25GetMatchingFuzzTestOrExitENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 175| 1|std::string GetMatchingFuzzTestOrExit(std::string_view name) { 176| 1| const std::string partial_name(name); 177| 1| const std::vector full_names = ListRegisteredTests(); 178| 1| std::vector matches; 179| 1| for (const std::string& full_name : full_names) { ------------------ | Branch (179:37): [True: 1, False: 0] ------------------ 180| 1| if (absl::StrContains(full_name, partial_name)) { ------------------ | Branch (180:9): [True: 1, False: 0] ------------------ 181| 1| if (full_name == partial_name) { ------------------ | Branch (181:11): [True: 1, False: 0] ------------------ 182| | // In case of an exact match, we end the search and use it. This is to 183| | // handle the case when we want to select `MySuite.MyTest`, but the 184| | // binary has both `MySuite.MyTest` and `MySuite.MyTestX`. 185| 1| return full_name; 186| 1| } else { 187| 0| matches.push_back(&full_name); 188| 0| } 189| 1| } 190| 1| } 191| | 192| 0| if (matches.empty()) { ------------------ | Branch (192:7): [True: 0, False: 0] ------------------ 193| 0| absl::FPrintF(stderr, "\n\nNo FUZZ_TEST matches the name: %s\n\n", 194| 0| partial_name); 195| 0| absl::FPrintF(stderr, "Valid tests:\n"); 196| 0| for (const std::string& full_name : full_names) { ------------------ | Branch (196:39): [True: 0, False: 0] ------------------ 197| 0| absl::FPrintF(stderr, " %s\n", full_name); 198| 0| } 199| 0| exit(1); 200| 0| } else if (matches.size() > 1) { ------------------ | Branch (200:14): [True: 0, False: 0] ------------------ 201| 0| absl::FPrintF(stderr, "\n\nMultiple FUZZ_TESTs match the name: %s\n\n", 202| 0| partial_name); 203| 0| absl::FPrintF(stderr, "Please select one. Matching tests:\n"); 204| 0| for (const std::string* full_name : matches) { ------------------ | Branch (204:39): [True: 0, False: 0] ------------------ 205| 0| absl::FPrintF(stderr, " %s\n", *full_name); 206| 0| } 207| 0| exit(1); 208| 0| } 209| 0| return *matches[0]; 210| 0|} _ZN8fuzztest12InitFuzzTestEPiPPPcNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE: 283| 1|void InitFuzzTest(int* argc, char*** argv, std::string_view binary_id) { 284| 1| const bool is_listing = absl::GetFlag(FUZZTEST_FLAG(list_fuzz_tests)); ------------------ | | 20| 1|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 285| 1| if (is_listing) { ------------------ | Branch (285:7): [True: 0, False: 1] ------------------ 286| 0| for (const auto& name : ListRegisteredTests()) { ------------------ | Branch (286:27): [True: 0, False: 0] ------------------ 287| 0| std::cout << "[*] Fuzz test: " << name << '\n'; 288| 0| } 289| 0| std::exit(0); 290| 0| } 291| 1| std::optional fuzzing_time_limit = GetFuzzingTime(); 292| 1| std::optional replay_corpus_time_limit = 293| 1| GetReplayCorpusTime(); 294| 1| FUZZTEST_INTERNAL_CHECK( ------------------ | | 48| 2| ((cond) ? (void)0 \ | | ------------------ | | | Branch (48:5): [True: 0, False: 1] | | | Branch (48:5): [True: 1, False: 0] | | ------------------ | | 49| 1| : ::fuzztest::internal::Abort( \ | | 50| 0| __FILE__, __LINE__, \ | | 51| 0| absl::StrCat("Internal error! Check (", #cond, \ | | 52| 0| ") failed: ", __VA_ARGS__))) ------------------ 295| 1| !fuzzing_time_limit || !replay_corpus_time_limit, 296| 1| "Cannot run in fuzzing and corpus replay mode at the same time."); 297| 1| const auto test_to_fuzz = absl::GetFlag(FUZZTEST_FLAG(fuzz)); ------------------ | | 20| 1|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 298| 1| const auto test_to_replay_corpus = 299| 1| absl::GetFlag(FUZZTEST_FLAG(replay_corpus)); ------------------ | | 20| 1|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 300| 1| const auto specified_test = 301| 1| test_to_fuzz != kUnspecified ? test_to_fuzz : test_to_replay_corpus; ------------------ | Branch (301:7): [True: 1, False: 0] ------------------ 302| 1| const bool is_test_specified = specified_test != kUnspecified; 303| 1| if (is_test_specified) { ------------------ | Branch (303:7): [True: 1, False: 0] ------------------ 304| 1| const std::string matching_fuzz_test = 305| 1| GetMatchingFuzzTestOrExit(specified_test); 306| | // Delegate the test to GoogleTest. 307| 1| GTEST_FLAG_SET(filter, matching_fuzz_test); 308| 1| } 309| | 310| 1| std::string derived_binary_id = 311| 1| binary_id.empty() ? std::string(internal::Basename(*argv[0])) ------------------ | Branch (311:7): [True: 1, False: 0] ------------------ 312| 1| : std::string(binary_id); 313| 1| std::optional reproduction_command_template; 314| 1| internal::Configuration configuration = 315| 1| CreateConfigurationsFromFlags(derived_binary_id); 316| 1| configuration.reproduction_command_template = reproduction_command_template; 317| 1| internal::RegisterFuzzTestsAsGoogleTests(argc, argv, configuration); 318| | 319| 1| const bool is_fuzzing_or_replaying = 320| 1| (fuzzing_time_limit || replay_corpus_time_limit); ------------------ | Branch (320:8): [True: 1, False: 0] | Branch (320:30): [True: 0, False: 0] ------------------ 321| 1| if (is_fuzzing_or_replaying && !is_test_specified) { ------------------ | Branch (321:7): [True: 1, False: 0] | Branch (321:34): [True: 0, False: 1] ------------------ 322| 0| absl::flat_hash_set fuzz_tests = { 323| 0| configuration.fuzz_tests.begin(), configuration.fuzz_tests.end()}; 324| 0| std::vector non_fuzz_tests; 325| 0| for (const auto* test : internal::GetRegisteredTests()) { ------------------ | Branch (325:27): [True: 0, False: 0] ------------------ 326| 0| const std::string test_name = 327| 0| absl::StrCat(test->test_suite_name(), ".", test->name()); 328| 0| if (!fuzz_tests.contains(test_name)) { ------------------ | Branch (328:11): [True: 0, False: 0] ------------------ 329| 0| non_fuzz_tests.push_back(test_name); 330| 0| } 331| 0| } 332| 0| if (!non_fuzz_tests.empty()) { ------------------ | Branch (332:9): [True: 0, False: 0] ------------------ 333| | // Run only the fuzz tests, and not the unit tests. 334| | // TODO: b/340232436 -- This is needed because we currently rely on a fuzz 335| | // test being the first test to run so that Centipede can get the 336| | // serialized configuration from the binary. 337| 0| std::string filter = absl::StrCat( 338| 0| GTEST_FLAG_GET(filter), 339| | // When the filter already includes the negative patterns, append to 340| | // the negative patterns. 341| 0| absl::StrContains(GTEST_FLAG_GET(filter), '-') ? ":" : "-", ------------------ | Branch (341:11): [True: 0, False: 0] ------------------ 342| 0| absl::StrJoin(non_fuzz_tests, ":")); 343| 0| GTEST_FLAG_SET(filter, filter); 344| 0| } 345| 0| } 346| 1| const bool is_runner_mode = std::getenv("CENTIPEDE_RUNNER_FLAGS") != nullptr; 347| 1| const bool is_fuzzing_mode = (is_runner_mode && is_fuzzing_or_replaying) || ------------------ | Branch (347:33): [True: 0, False: 1] | Branch (347:51): [True: 0, False: 0] ------------------ 348| 1| fuzzing_time_limit.has_value(); ------------------ | Branch (348:32): [True: 1, False: 0] ------------------ 349| 1| const RunMode run_mode = 350| 1| is_fuzzing_mode ? RunMode::kFuzz : RunMode::kUnitTest; ------------------ | Branch (350:7): [True: 1, False: 0] ------------------ 351| | // TODO(b/307513669): Use the Configuration class instead of Runtime. 352| 1| internal::Runtime::instance().SetRunMode(run_mode); 353| 1|} _ZN8fuzztest14ParseAbslFlagsEiPPc: 355| 1|void ParseAbslFlags(int argc, char** argv) { 356| 1| std::vector positional_args; 357| 1| std::vector unrecognized_flags; 358| 1| absl::ParseAbseilFlagsOnly(argc, argv, positional_args, unrecognized_flags); 359| 1|} init_fuzztest.cc:_ZNK3$_0clEv: 49| 1| .OnUpdate([]() { 50| 1| fuzztest::internal::SetFuzzTestListingModeValidatorForGoogleTest( 51| 1| absl::GetFlag(FUZZTEST_FLAG(list_fuzz_tests))); ------------------ | | 20| 1|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 52| 1| }); init_fuzztest.cc:_ZN8fuzztest12_GLOBAL__N_129CreateConfigurationsFromFlagsENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE: 241| 1| absl::string_view binary_identifier) { 242| 1| bool reproduce_findings_as_separate_tests = 243| 1| absl::GetFlag(FUZZTEST_FLAG(reproduce_findings_as_separate_tests)); ------------------ | | 20| 1|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 244| 1| std::optional fuzzing_time_limit = GetFuzzingTime(); 245| 1| std::optional replay_corpus_time_limit = 246| 1| GetReplayCorpusTime(); 247| 1| absl::Duration time_limit = fuzzing_time_limit ? *fuzzing_time_limit ------------------ | Branch (247:31): [True: 1, False: 0] ------------------ 248| 1| : replay_corpus_time_limit ------------------ | Branch (248:33): [True: 0, False: 0] ------------------ 249| 0| ? *replay_corpus_time_limit 250| 0| : absl::ZeroDuration(); 251| 1| std::optional jobs = absl::GetFlag(FUZZTEST_FLAG(jobs)); ------------------ | | 20| 1|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 252| 1| FUZZTEST_INTERNAL_CHECK(!jobs.has_value() || *jobs > 0, "If specified, --", ------------------ | | 48| 1| ((cond) ? (void)0 \ | | ------------------ | | | Branch (48:5): [True: 1, False: 0] | | | Branch (48:5): [True: 0, False: 0] | | ------------------ | | 49| 1| : ::fuzztest::internal::Abort( \ | | 50| 0| __FILE__, __LINE__, \ | | 51| 0| absl::StrCat("Internal error! Check (", #cond, \ | | 52| 0| ") failed: ", __VA_ARGS__))) ------------------ 253| 1| FUZZTEST_FLAG(jobs).Name(), " must be positive."); 254| 1| return internal::Configuration{ 255| 1| absl::GetFlag(FUZZTEST_FLAG(corpus_database)), ------------------ | | 20| 1|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 256| 1| /*stats_root=*/"", 257| 1| std::string(binary_identifier), 258| 1| /*fuzz_tests=*/ListRegisteredTests(), 259| 1| /*fuzz_tests_in_current_shard=*/ListRegisteredTests(), 260| 1| reproduce_findings_as_separate_tests, 261| | /*only_replay_corpus=*/ 262| 1| replay_corpus_time_limit.has_value(), 263| 1| /*stack_limit=*/absl::GetFlag(FUZZTEST_FLAG(stack_limit_kb)) * 1024, ------------------ | | 20| 1|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 264| 1| /*rss_limit=*/absl::GetFlag(FUZZTEST_FLAG(rss_limit_mb)) * 1024 * 1024, ------------------ | | 20| 1|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 265| 1| absl::GetFlag(FUZZTEST_FLAG(time_limit_per_input)), time_limit, ------------------ | | 20| 1|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 266| 1| absl::GetFlag(FUZZTEST_FLAG(time_budget_type)), jobs.value_or(0)}; ------------------ | | 20| 1|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 267| 1|} init_fuzztest.cc:_ZN8fuzztest12_GLOBAL__N_114GetFuzzingTimeEv: 214| 2|std::optional GetFuzzingTime() { 215| 2| absl::Duration fuzz_time_limit = absl::GetFlag(FUZZTEST_FLAG(fuzz_for)); ------------------ | | 20| 2|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 216| 2| if (fuzz_time_limit <= absl::ZeroDuration()) { ------------------ | Branch (216:7): [True: 0, False: 2] ------------------ 217| 0| fuzz_time_limit = absl::InfiniteDuration(); 218| 0| } 219| 2| if (absl::GetFlag(FUZZTEST_FLAG(fuzz)) == kUnspecified && ------------------ | | 20| 2|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ | Branch (219:7): [True: 0, False: 2] | Branch (219:7): [True: 0, False: 2] ------------------ 220| 0| fuzz_time_limit == absl::InfiniteDuration()) { ------------------ | Branch (220:7): [True: 0, False: 0] ------------------ 221| 0| return std::nullopt; 222| 0| } 223| 2| return fuzz_time_limit; 224| 2|} init_fuzztest.cc:_ZN8fuzztest12_GLOBAL__N_119GetReplayCorpusTimeEv: 226| 2|std::optional GetReplayCorpusTime() { 227| 2| absl::Duration replay_corpus_time_limit = 228| 2| absl::GetFlag(FUZZTEST_FLAG(replay_corpus_for)); ------------------ | | 20| 2|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ 229| 2| if (absl::GetFlag(FUZZTEST_FLAG(replay_corpus)) == kUnspecified && ------------------ | | 20| 2|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ | Branch (229:7): [True: 2, False: 0] | Branch (229:7): [True: 2, False: 0] ------------------ 230| 2| replay_corpus_time_limit <= absl::ZeroDuration()) { ------------------ | Branch (230:7): [True: 2, False: 0] ------------------ 231| 2| return std::nullopt; 232| 2| } 233| 0| if (absl::GetFlag(FUZZTEST_FLAG(replay_corpus)) != kUnspecified && ------------------ | | 20| 0|#define FUZZTEST_FLAG(name) FLAGS_##name ------------------ | Branch (233:7): [True: 0, False: 0] | Branch (233:7): [True: 0, False: 0] ------------------ 234| 0| replay_corpus_time_limit <= absl::ZeroDuration()) { ------------------ | Branch (234:7): [True: 0, False: 0] ------------------ 235| 0| replay_corpus_time_limit = absl::InfiniteDuration(); 236| 0| } 237| 0| return replay_corpus_time_limit; 238| 2|} init_fuzztest.cc:_ZZN8fuzztest19ListRegisteredTestsEvENK3$_0clINS_8internal8FuzzTestEEEDaRKT_: 171| 3| [&](const auto& test) { result.push_back(test.full_name()); }); _ZN8fuzztest8internal25SetExternalEngineCallbackEPNS0_22ExternalEngineCallbackE: 33| 1|void SetExternalEngineCallback(ExternalEngineCallback* callback) { 34| 1| external_engine_callback = callback; 35| 1|} _ZN8fuzztest8internal25GetExternalEngineCallbackEv: 37| 1|ExternalEngineCallback* GetExternalEngineCallback() { 38| 1| return external_engine_callback; 39| 1|} _ZN8fuzztest8internal29FuzzTestExternalEngineAdaptorC2ERKNS0_8FuzzTestENSt3__110unique_ptrINS0_20UntypedFixtureDriverENS5_14default_deleteIS7_EEEE: 66| 1| : test_(test), fixture_driver_staging_(std::move(fixture_driver)) {} _ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS0_13ConfigurationE: 74| 1| int* argc, char*** argv, const Configuration& configuration) { 75| 1| FUZZTEST_INTERNAL_CHECK(&LLVMFuzzerRunDriver, ------------------ | | 48| 1| ((cond) ? (void)0 \ | | ------------------ | | | Branch (48:4): [True: 1, Folded] | | ------------------ | | 49| 1| : ::fuzztest::internal::Abort( \ | | 50| 0| __FILE__, __LINE__, \ | | 51| 0| absl::StrCat("Internal error! Check (", #cond, \ | | 52| 0| ") failed: ", __VA_ARGS__))) ------------------ 76| 1| "LibFuzzer Driver API not defined."); 77| 1| FUZZTEST_INTERNAL_CHECK( ------------------ | | 48| 1| ((cond) ? (void)0 \ | | ------------------ | | | Branch (48:4): [True: 1, False: 0] | | ------------------ | | 49| 1| : ::fuzztest::internal::Abort( \ | | 50| 0| __FILE__, __LINE__, \ | | 51| 0| absl::StrCat("Internal error! Check (", #cond, \ | | 52| 0| ") failed: ", __VA_ARGS__))) ------------------ 78| 1| GetExternalEngineCallback() == nullptr, 79| 1| "External engine callback is already set while running a fuzz test."); 80| 1| SetExternalEngineCallback(this); 81| 1| runtime_.SetRunMode(RunMode::kFuzz); 82| 1| auto& impl = GetFuzzerImpl(); 83| 1| runtime_.EnableReporter(&impl.stats_, [] { return absl::Now(); }); 84| | 85| 1| FUZZTEST_INTERNAL_CHECK(impl.fixture_driver_ != nullptr, ------------------ | | 48| 1| ((cond) ? (void)0 \ | | ------------------ | | | Branch (48:4): [True: 1, False: 0] | | ------------------ | | 49| 1| : ::fuzztest::internal::Abort( \ | | 50| 0| __FILE__, __LINE__, \ | | 51| 0| absl::StrCat("Internal error! Check (", #cond, \ | | 52| 0| ") failed: ", __VA_ARGS__))) ------------------ 86| 1| "Invalid fixture driver!"); 87| 1| impl.fixture_driver_->SetUpFuzzTest(); 88| | 89| 1| static bool driver_started = false; 90| 1| FUZZTEST_INTERNAL_CHECK(!driver_started, "Driver started more than once!"); ------------------ | | 48| 1| ((cond) ? (void)0 \ | | ------------------ | | | Branch (48:4): [True: 1, False: 0] | | ------------------ | | 49| 1| : ::fuzztest::internal::Abort( \ | | 50| 0| __FILE__, __LINE__, \ | | 51| 0| absl::StrCat("Internal error! Check (", #cond, \ | | 52| 0| ") failed: ", __VA_ARGS__))) ------------------ 91| 1| driver_started = true; 92| 1| LLVMFuzzerRunDriver(argc, argv, [](const uint8_t* data, size_t size) -> int { 93| 1| GetExternalEngineCallback()->RunOneInputData( 94| 1| absl::string_view(reinterpret_cast(data), size)); 95| 1| return 0; 96| 1| }); 97| | 98| | // If we're here, we didn't exit from RunOneInputData(), and hence we didn't 99| | // tear down the fixture. 100| 1| FUZZTEST_INTERNAL_CHECK(impl.fixture_driver_ != nullptr, ------------------ | | 48| 1| ((cond) ? (void)0 \ | | ------------------ | | | Branch (48:4): [True: 0, False: 1] | | ------------------ | | 49| 1| : ::fuzztest::internal::Abort( \ | | 50| 1| __FILE__, __LINE__, \ | | 51| 1| absl::StrCat("Internal error! Check (", #cond, \ | | 52| 1| ") failed: ", __VA_ARGS__))) ------------------ 101| 1| "Invalid fixture driver!"); 102| 1| impl.fixture_driver_->TearDownFuzzTest(); 103| | 104| 1| return 0; 105| 1|} _ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor13GetFuzzerImplEv: 164| 1|FuzzTestExternalEngineAdaptor::GetFuzzerImpl() { 165| | // Postpone the creation to override libFuzzer signal setup. 166| 1| if (!fuzzer_impl_) { ------------------ | Branch (166:7): [True: 1, False: 0] ------------------ 167| 1| fuzzer_impl_ = 168| 1| std::make_unique(test_, std::move(fixture_driver_staging_)); 169| 1| fixture_driver_staging_ = nullptr; 170| 1| } 171| 1| return *fuzzer_impl_; 172| 1|} _ZN8fuzztest8internal14CorpusDatabaseC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_b: 44| 1| : corpus_path_for_test_binary_([=] () -> std::string { 45| 1| if (database_path.empty()) return ""; 46| 1| std::string corpus_path_for_test_binary = 47| 1| absl::StrCat(database_path, "/", binary_identifier); 48| 1| if (!absl::StartsWith(corpus_path_for_test_binary, "/") && 49| 1| std::getenv("TEST_SRCDIR")) { 50| 1| corpus_path_for_test_binary = absl::StrCat( 51| 1| std::getenv("TEST_SRCDIR"), "/", corpus_path_for_test_binary); 52| 1| } 53| 1| return corpus_path_for_test_binary; 54| 1| }()), 55| 1| use_crashing_inputs_(use_crashing_inputs) {} _ZN8fuzztest8internal14CorpusDatabaseC2ERKNS0_13ConfigurationE: 58| 1| : CorpusDatabase(configuration.corpus_database, 59| 1| configuration.binary_identifier, 60| | /*use_crashing_inputs=*/ 61| 1| configuration.reproduce_findings_as_separate_tests) {} _ZNK8fuzztest8internal14CorpusDatabase22GetCrashingInputsIfAnyENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 69| 1| absl::string_view test_name) const { 70| 1| if (!use_crashing_inputs_) return {}; ------------------ | Branch (70:7): [True: 1, False: 0] ------------------ 71| 0| return GetInputs(corpus_path_for_test_binary_, test_name, "crashing"); 72| 1|} corpus_database.cc:_ZZN8fuzztest8internal14CorpusDatabaseC1ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_bENK3$_0clEv: 44| 1| : corpus_path_for_test_binary_([=] () -> std::string { 45| 1| if (database_path.empty()) return ""; ------------------ | Branch (45:13): [True: 0, False: 1] ------------------ 46| 1| std::string corpus_path_for_test_binary = 47| 1| absl::StrCat(database_path, "/", binary_identifier); 48| 1| if (!absl::StartsWith(corpus_path_for_test_binary, "/") && ------------------ | Branch (48:13): [True: 1, False: 0] ------------------ 49| 1| std::getenv("TEST_SRCDIR")) { ------------------ | Branch (49:13): [True: 0, False: 1] ------------------ 50| 0| corpus_path_for_test_binary = absl::StrCat( 51| 0| std::getenv("TEST_SRCDIR"), "/", corpus_path_for_test_binary); 52| 0| } 53| 1| return corpus_path_for_test_binary; 54| 1| }()), _ZN8fuzztest8internal20GetExecutionCoverageEv: 86| 1|ExecutionCoverage* GetExecutionCoverage() { 87| 1| return execution_coverage_instance; 88| 1|} _ZN8fuzztest8internal14CorpusCoverageC2Em: 264| 1|CorpusCoverage::CorpusCoverage(size_t map_size) { 265| 1| size_t alignment = alignof(Vector); 266| | // Round up to a multiple of alignment. 267| 1| map_size += alignment - 1; 268| 1| map_size -= map_size % alignment; 269| | // And allocate an extra step to make sure the alignment logic has the 270| | // necessary space. 271| 1| map_size += alignment; 272| 1| corpus_map_size_ = map_size; 273| 1| corpus_map_ = static_cast(std::aligned_alloc(alignment, map_size)); 274| 1| std::fill(corpus_map_, corpus_map_ + corpus_map_size_, 0); 275| 1|} avif_fuzztest_read_image.cc:_ZN8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEENS0_13ElementOfImplISA_EENSJ_IiEENSJ_ISB_EENSG_IbvEESN_SN_SN_NSJ_ISC_EEEEC2ENS2_10in_place_tESI_SK_SL_SM_SN_SN_SN_SN_SO_: 58| 1| : inner_(std::move(inner)...) {} _ZNK8fuzztest8internal13ArbitraryImplIcvE19ValidateCorpusValueERKc: 188| 3.22M| absl::Status ValidateCorpusValue(const value_type&) const { 189| 3.22M| return absl::OkStatus(); // Nothing to validate. 190| 3.22M| } _ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E8min_sizeEv: 371| 32| size_t min_size() const { return min_size_; } _ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E8max_sizeEv: 372| 32| size_t max_size() const { 373| 32| return max_size_.value_or(std::max(min_size_, kDefaultContainerMaxSize)); 374| 32| } _ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E4SelfEv: 377| 1| Derived& Self() { return static_cast(*this); } _ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E19ValidateCorpusValueERKS9_: 317| 32| absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const { 318| | // Check size. 319| 32| if (corpus_value.size() < min_size()) { ------------------ | Branch (319:9): [True: 0, False: 32] ------------------ 320| 0| return absl::InvalidArgumentError(absl::StrCat( 321| 0| "Invalid size: ", corpus_value.size(), ". Min size: ", min_size())); 322| 0| } 323| 32| if (corpus_value.size() > max_size()) { ------------------ | Branch (323:9): [True: 0, False: 32] ------------------ 324| 0| return absl::InvalidArgumentError(absl::StrCat( 325| 0| "Invalid size: ", corpus_value.size(), ". Max size: ", max_size())); 326| 0| } 327| | // Check elements. 328| 32| int i = 0; 329| 3.22M| for (const auto& elem : corpus_value) { ------------------ | Branch (329:27): [True: 3.22M, False: 32] ------------------ 330| 3.22M| const absl::Status s = inner_.ValidateCorpusValue(elem); 331| 3.22M| if (!s.ok()) { ------------------ | Branch (331:11): [True: 0, False: 3.22M] ------------------ 332| 0| return Prefix(s, 333| 0| absl::StrCat("Invalid value in container at index ", i)); 334| 0| } 335| 3.22M| i++; 336| 3.22M| } 337| 32| return absl::OkStatus(); 338| 32| } _ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E9FromValueERKS9_: 269| 32| std::optional FromValue(const value_type& value) const { 270| 32| if constexpr (!has_custom_corpus_type) { 271| 32| return value; 272| | } else { 273| | corpus_type copus_value; 274| | for (const auto& elem : value) { 275| | auto inner_value = inner_.FromValue(elem); 276| | if (!inner_value) return std::nullopt; 277| | copus_value.push_back(*std::move(inner_value)); 278| | } 279| | return copus_value; 280| | } 281| 32| } _ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_E11WithMaxSizeEm: 222| 1| Derived& WithMaxSize(size_t s) { 223| 1| FUZZTEST_INTERNAL_CHECK_PRECONDITION( ------------------ | | 42| 1| ((P) ? (void)0 \ | | ------------------ | | | Branch (42:4): [True: 1, False: 0] | | ------------------ | | 43| 1| : ::fuzztest::internal::Abort( \ | | 44| 0| __FILE__, __LINE__, \ | | 45| 0| absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__))) ------------------ 224| 1| min_size_ <= s, "Maximal size ", s, 225| 1| " cannot be smaller than minimal size ", min_size_); 226| 1| max_size_ = s; 227| 1| return Self(); 228| 1| } _ZN8fuzztest8internal27SequenceContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_EC2Ev: 536| 1| SequenceContainerOfImplBase() = default; _ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEES9_SB_EC2Ev: 109| 1| ContainerOfImplBase() = default; avif_fuzztest_read_image.cc:_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEEEC2INS_8internal15AggregateOfImplISC_LNSF_23RequireCustomCorpusTypeE0EJNSF_23SequenceContainerOfImplIS8_NSF_13ArbitraryImplIcvEEEENSF_13ElementOfImplIS9_EENSM_IiEENSM_ISA_EENSJ_IbvEESQ_SQ_SQ_NSM_ISB_EEEEENS2_IJS8_NSF_23ElementOfImplCorpusTypeEST_ST_bbbbST_EEEEEONS_18domain_implementor10DomainBaseIT_SC_T0_EE: 109| 1| : inner_(std::make_unique>( 110| 1| static_cast(inner))) {} avif_fuzztest_read_image.cc:_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEEEC2ERKSD_: 112| 6| Domain(const Domain& other) { *this = other; } avif_fuzztest_read_image.cc:_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEEEaSERKSD_: 113| 6| Domain& operator=(const Domain& other) { 114| 6| inner_ = other.inner_->TypedClone(); 115| 6| return *this; 116| 6| } avif_fuzztest_read_image.cc:_ZN8fuzztest13UntypedDomainC2INSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEEEERKNS_6DomainIT_EE: 315| 1| : inner_(domain.inner_->UntypedClone()) {} _ZN8fuzztest18domain_implementor10DomainBaseINS_8internal23SequenceContainerOfImplINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS2_13ArbitraryImplIcvEEEESA_SA_E7derivedEv: 252| 65| Derived& derived() { return static_cast(*this); } _ZN8fuzztest18domain_implementor10DomainBaseINS_8internal23SequenceContainerOfImplINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS2_13ArbitraryImplIcvEEEESA_SA_E9WithSeedsERKNS4_6vectorISA_NS8_ISA_EEEE: 185| 1| WithSeeds(const std::vector& seeds) { 186| 1| seeds_.reserve(seeds_.size() + seeds.size()); 187| 32| for (const ValueType& seed : seeds) { ------------------ | Branch (187:32): [True: 32, False: 1] ------------------ 188| 32| std::optional corpus_value = derived().FromValue(seed); 189| 32| if (!corpus_value.has_value()) { ------------------ | Branch (189:11): [True: 0, False: 32] ------------------ 190| 0| ReportBadSeedAndExit( 191| 0| seed, 192| 0| absl::InvalidArgumentError( 193| 0| "Seed could not be converted to the internal corpus value")); 194| 0| } 195| | 196| 32| absl::Status valid = derived().ValidateCorpusValue(*corpus_value); 197| 32| if (!valid.ok()) ReportBadSeedAndExit(seed, valid); ------------------ | Branch (197:11): [True: 0, False: 32] ------------------ 198| | 199| 32| seeds_.push_back(*std::move(corpus_value)); 200| 32| } 201| 1| return derived(); 202| 1| } avif_fuzztest_read_image.cc:_ZN8fuzztest18domain_implementor10DomainBaseINS_8internal15AggregateOfImplINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEELNS2_23RequireCustomCorpusTypeE0EJNS2_23SequenceContainerOfImplISB_NS2_13ArbitraryImplIcvEEEENS2_13ElementOfImplISC_EENSL_IiEENSL_ISD_EENSI_IbvEESP_SP_SP_NSL_ISE_EEEEESF_NS5_IJSB_NS2_23ElementOfImplCorpusTypeESS_SS_bbbbSS_EEEEC2Ev: 115| 1| DomainBase() { 116| | // Check that the interface of `Derived` matches the requirements for a 117| | // domain implementation. We check these inside the constructor of 118| | // `DomainBase`, where `Derived` is already fully defined. If we try to 119| | // check them at class scope we would see an incomplete `Derived` class and 120| | // the checks would not work. 121| 1| fuzztest::internal::CheckIsSame< 122| 1| ValueType, fuzztest::internal::value_type_t>(); 123| 1| fuzztest::internal::CheckIsSame< 124| 1| CorpusType, fuzztest::internal::corpus_type_t>(); 125| 1| static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type); 126| | 127| | // Check that `Derived` type-checks against the type-erased `Domain` 128| | // interface by forcing the `DomainModel` template specialization. 129| 1| if (Derived* domain = nullptr) { ------------------ | Branch (129:18): [True: 0, False: 1] ------------------ 130| 0| (void)fuzztest::internal::DomainModel{*domain}; 131| 0| } 132| 1| } _ZN8fuzztest18domain_implementor10DomainBaseINS_8internal23SequenceContainerOfImplINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS2_13ArbitraryImplIcvEEEESA_SA_EC2Ev: 115| 1| DomainBase() { 116| | // Check that the interface of `Derived` matches the requirements for a 117| | // domain implementation. We check these inside the constructor of 118| | // `DomainBase`, where `Derived` is already fully defined. If we try to 119| | // check them at class scope we would see an incomplete `Derived` class and 120| | // the checks would not work. 121| 1| fuzztest::internal::CheckIsSame< 122| 1| ValueType, fuzztest::internal::value_type_t>(); 123| 1| fuzztest::internal::CheckIsSame< 124| 1| CorpusType, fuzztest::internal::corpus_type_t>(); 125| 1| static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type); 126| | 127| | // Check that `Derived` type-checks against the type-erased `Domain` 128| | // interface by forcing the `DomainModel` template specialization. 129| 1| if (Derived* domain = nullptr) { ------------------ | Branch (129:18): [True: 0, False: 1] ------------------ 130| 0| (void)fuzztest::internal::DomainModel{*domain}; 131| 0| } 132| 1| } _ZN8fuzztest18domain_implementor10DomainBaseINS_8internal13ArbitraryImplIcvEEccEC2Ev: 115| 1| DomainBase() { 116| | // Check that the interface of `Derived` matches the requirements for a 117| | // domain implementation. We check these inside the constructor of 118| | // `DomainBase`, where `Derived` is already fully defined. If we try to 119| | // check them at class scope we would see an incomplete `Derived` class and 120| | // the checks would not work. 121| 1| fuzztest::internal::CheckIsSame< 122| 1| ValueType, fuzztest::internal::value_type_t>(); 123| 1| fuzztest::internal::CheckIsSame< 124| 1| CorpusType, fuzztest::internal::corpus_type_t>(); 125| 1| static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type); 126| | 127| | // Check that `Derived` type-checks against the type-erased `Domain` 128| | // interface by forcing the `DomainModel` template specialization. 129| 1| if (Derived* domain = nullptr) { ------------------ | Branch (129:18): [True: 0, False: 1] ------------------ 130| 0| (void)fuzztest::internal::DomainModel{*domain}; 131| 0| } 132| 1| } _ZN8fuzztest18domain_implementor10DomainBaseINS_8internal13ElementOfImplI15avifPixelFormatEES4_NS2_23ElementOfImplCorpusTypeEEC2Ev: 115| 1| DomainBase() { 116| | // Check that the interface of `Derived` matches the requirements for a 117| | // domain implementation. We check these inside the constructor of 118| | // `DomainBase`, where `Derived` is already fully defined. If we try to 119| | // check them at class scope we would see an incomplete `Derived` class and 120| | // the checks would not work. 121| 1| fuzztest::internal::CheckIsSame< 122| 1| ValueType, fuzztest::internal::value_type_t>(); 123| 1| fuzztest::internal::CheckIsSame< 124| 1| CorpusType, fuzztest::internal::corpus_type_t>(); 125| 1| static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type); 126| | 127| | // Check that `Derived` type-checks against the type-erased `Domain` 128| | // interface by forcing the `DomainModel` template specialization. 129| 1| if (Derived* domain = nullptr) { ------------------ | Branch (129:18): [True: 0, False: 1] ------------------ 130| 0| (void)fuzztest::internal::DomainModel{*domain}; 131| 0| } 132| 1| } _ZN8fuzztest18domain_implementor10DomainBaseINS_8internal13ElementOfImplIiEEiNS2_23ElementOfImplCorpusTypeEEC2Ev: 115| 1| DomainBase() { 116| | // Check that the interface of `Derived` matches the requirements for a 117| | // domain implementation. We check these inside the constructor of 118| | // `DomainBase`, where `Derived` is already fully defined. If we try to 119| | // check them at class scope we would see an incomplete `Derived` class and 120| | // the checks would not work. 121| 1| fuzztest::internal::CheckIsSame< 122| 1| ValueType, fuzztest::internal::value_type_t>(); 123| 1| fuzztest::internal::CheckIsSame< 124| 1| CorpusType, fuzztest::internal::corpus_type_t>(); 125| 1| static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type); 126| | 127| | // Check that `Derived` type-checks against the type-erased `Domain` 128| | // interface by forcing the `DomainModel` template specialization. 129| 1| if (Derived* domain = nullptr) { ------------------ | Branch (129:18): [True: 0, False: 1] ------------------ 130| 0| (void)fuzztest::internal::DomainModel{*domain}; 131| 0| } 132| 1| } _ZN8fuzztest18domain_implementor10DomainBaseINS_8internal13ElementOfImplI22avifChromaDownsamplingEES4_NS2_23ElementOfImplCorpusTypeEEC2Ev: 115| 1| DomainBase() { 116| | // Check that the interface of `Derived` matches the requirements for a 117| | // domain implementation. We check these inside the constructor of 118| | // `DomainBase`, where `Derived` is already fully defined. If we try to 119| | // check them at class scope we would see an incomplete `Derived` class and 120| | // the checks would not work. 121| 1| fuzztest::internal::CheckIsSame< 122| 1| ValueType, fuzztest::internal::value_type_t>(); 123| 1| fuzztest::internal::CheckIsSame< 124| 1| CorpusType, fuzztest::internal::corpus_type_t>(); 125| 1| static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type); 126| | 127| | // Check that `Derived` type-checks against the type-erased `Domain` 128| | // interface by forcing the `DomainModel` template specialization. 129| 1| if (Derived* domain = nullptr) { ------------------ | Branch (129:18): [True: 0, False: 1] ------------------ 130| 0| (void)fuzztest::internal::DomainModel{*domain}; 131| 0| } 132| 1| } _ZN8fuzztest18domain_implementor10DomainBaseINS_8internal13ArbitraryImplIbvEEbbEC2Ev: 115| 4| DomainBase() { 116| | // Check that the interface of `Derived` matches the requirements for a 117| | // domain implementation. We check these inside the constructor of 118| | // `DomainBase`, where `Derived` is already fully defined. If we try to 119| | // check them at class scope we would see an incomplete `Derived` class and 120| | // the checks would not work. 121| 4| fuzztest::internal::CheckIsSame< 122| 4| ValueType, fuzztest::internal::value_type_t>(); 123| 4| fuzztest::internal::CheckIsSame< 124| 4| CorpusType, fuzztest::internal::corpus_type_t>(); 125| 4| static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type); 126| | 127| | // Check that `Derived` type-checks against the type-erased `Domain` 128| | // interface by forcing the `DomainModel` template specialization. 129| 4| if (Derived* domain = nullptr) { ------------------ | Branch (129:18): [True: 0, False: 4] ------------------ 130| 0| (void)fuzztest::internal::DomainModel{*domain}; 131| 0| } 132| 4| } avif_fuzztest_read_image.cc:_ZN8fuzztest18domain_implementor10DomainBaseINS_8internal13ElementOfImplI3$_0EES4_NS2_23ElementOfImplCorpusTypeEEC2Ev: 115| 1| DomainBase() { 116| | // Check that the interface of `Derived` matches the requirements for a 117| | // domain implementation. We check these inside the constructor of 118| | // `DomainBase`, where `Derived` is already fully defined. If we try to 119| | // check them at class scope we would see an incomplete `Derived` class and 120| | // the checks would not work. 121| 1| fuzztest::internal::CheckIsSame< 122| 1| ValueType, fuzztest::internal::value_type_t>(); 123| 1| fuzztest::internal::CheckIsSame< 124| 1| CorpusType, fuzztest::internal::corpus_type_t>(); 125| 1| static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type); 126| | 127| | // Check that `Derived` type-checks against the type-erased `Domain` 128| | // interface by forcing the `DomainModel` template specialization. 129| 1| if (Derived* domain = nullptr) { ------------------ | Branch (129:18): [True: 0, False: 1] ------------------ 130| 0| (void)fuzztest::internal::DomainModel{*domain}; 131| 0| } 132| 1| } avif_fuzztest_read_image.cc:_ZN8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEENS0_13ElementOfImplISB_EENSK_IiEENSK_ISC_EENSH_IbvEESO_SO_SO_NSK_ISD_EEEEEEC2EOSQ_: 130| 1| explicit DomainModel(D&& domain) : domain_(std::forward(domain)) {} _ZN8fuzztest8internal20UntypedDomainConceptD2Ev: 56| 5| virtual ~UntypedDomainConcept() = default; avif_fuzztest_read_image.cc:_ZNK8fuzztest8internal18TypedDomainConceptINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEEE12UntypedCloneEv: 108| 1| std::unique_ptr UntypedClone() const final { 109| 1| return TypedClone(); 110| 1| } avif_fuzztest_read_image.cc:_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEENS0_13ElementOfImplISB_EENSK_IiEENSK_ISC_EENSH_IbvEESO_SO_SO_NSK_ISD_EEEEEE10TypedCloneEv: 132| 7| std::unique_ptr> TypedClone() const final { 133| 7| return std::make_unique(*this); 134| 7| } _ZN8fuzztest8internal13ElementOfImplI15avifPixelFormatEC2ENSt3__16vectorIS2_NS4_9allocatorIS2_EEEE: 44| 1| explicit ElementOfImpl(std::vector values) : values_(values) { 45| 1| FUZZTEST_INTERNAL_CHECK_PRECONDITION( ------------------ | | 42| 1| ((P) ? (void)0 \ | | ------------------ | | | Branch (42:4): [True: 1, False: 0] | | ------------------ | | 43| 1| : ::fuzztest::internal::Abort( \ | | 44| 0| __FILE__, __LINE__, \ | | 45| 0| absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__))) ------------------ 46| 1| !values.empty(), "ElementOf requires a non empty list."); 47| 1| } _ZN8fuzztest8internal13ElementOfImplIiEC2ENSt3__16vectorIiNS3_9allocatorIiEEEE: 44| 1| explicit ElementOfImpl(std::vector values) : values_(values) { 45| 1| FUZZTEST_INTERNAL_CHECK_PRECONDITION( ------------------ | | 42| 1| ((P) ? (void)0 \ | | ------------------ | | | Branch (42:4): [True: 1, False: 0] | | ------------------ | | 43| 1| : ::fuzztest::internal::Abort( \ | | 44| 0| __FILE__, __LINE__, \ | | 45| 0| absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__))) ------------------ 46| 1| !values.empty(), "ElementOf requires a non empty list."); 47| 1| } _ZN8fuzztest8internal13ElementOfImplI22avifChromaDownsamplingEC2ENSt3__16vectorIS2_NS4_9allocatorIS2_EEEE: 44| 1| explicit ElementOfImpl(std::vector values) : values_(values) { 45| 1| FUZZTEST_INTERNAL_CHECK_PRECONDITION( ------------------ | | 42| 1| ((P) ? (void)0 \ | | ------------------ | | | Branch (42:4): [True: 1, False: 0] | | ------------------ | | 43| 1| : ::fuzztest::internal::Abort( \ | | 44| 0| __FILE__, __LINE__, \ | | 45| 0| absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__))) ------------------ 46| 1| !values.empty(), "ElementOf requires a non empty list."); 47| 1| } avif_fuzztest_read_image.cc:_ZN8fuzztest8internal13ElementOfImplI3$_0EC2ENSt3__16vectorIS2_NS4_9allocatorIS2_EEEE: 44| 1| explicit ElementOfImpl(std::vector values) : values_(values) { 45| 1| FUZZTEST_INTERNAL_CHECK_PRECONDITION( ------------------ | | 42| 1| ((P) ? (void)0 \ | | ------------------ | | | Branch (42:4): [True: 1, False: 0] | | ------------------ | | 43| 1| : ::fuzztest::internal::Abort( \ | | 44| 0| __FILE__, __LINE__, \ | | 45| 0| absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__))) ------------------ 46| 1| !values.empty(), "ElementOf requires a non empty list."); 47| 1| } _ZN8fuzztest8internal20UntypedFixtureDriver13SetUpFuzzTestEv: 20| 1|void UntypedFixtureDriver::SetUpFuzzTest() {} avif_fuzztest_read_image.cc:_ZN8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEEEENS0_9NoFixtureEPFvRKSA_SB_iSC_bbbbtEPvEC2ESK_SF_NS3_6vectorINS0_11CopyableAnyENS8_ISO_EEEERKSL_: 287| 1| : FixtureDriver::TypedFixtureDriver(std::move(domain), std::move(seeds), 288| 1| seed_provider), 289| 1| target_function_(target_function) {} avif_fuzztest_read_image.cc:_ZN8fuzztest8internal18TypedFixtureDriverINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEEPvEC2ENS_6DomainISD_EENS2_6vectorINS0_11CopyableAnyENS7_ISJ_EEEERKSE_: 104| 1| : domain_(std::move(domain)), 105| 1| seeds_(std::move(seeds)), 106| 1| seed_provider_(seed_provider) {} avif_fuzztest_read_image.cc:_ZNK8fuzztest8internal18TypedFixtureDriverINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEEPvE10GetDomainsEv: 120| 1| UntypedDomain GetDomains() const final { return domain_; } _ZNK8fuzztest8internal17GTest_TestAdaptor26GetFuzzTestsInCurrentShardEv: 23| 1|std::vector GTest_TestAdaptor::GetFuzzTestsInCurrentShard() const { 24| 1| std::vector result; 25| 1| for (const auto* test : GetRegisteredTests()) { ------------------ | Branch (25:25): [True: 1, False: 1] ------------------ 26| 1| if (!test->should_run()) continue; ------------------ | Branch (26:9): [True: 0, False: 1] ------------------ 27| 1| if (test->is_in_another_shard()) continue; ------------------ | Branch (27:9): [True: 0, False: 1] ------------------ 28| 1| for (const auto& fuzztest : configuration_.fuzz_tests) { ------------------ | Branch (28:31): [True: 1, False: 0] ------------------ 29| 1| if (fuzztest == ------------------ | Branch (29:11): [True: 1, False: 0] ------------------ 30| 1| absl::StrCat(test->test_suite_name(), ".", test->name())) { 31| 1| result.push_back(fuzztest); 32| 1| break; 33| 1| } 34| 1| } 35| 1| } 36| 1| return result; 37| 1|} _ZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS0_13ConfigurationE: 82| 1| const Configuration& configuration) { 83| 1| ::fuzztest::internal::ForEachTest([&](auto& test) { 84| 1| if (test.uses_fixture()) { 85| 1| RegisterTests<::fuzztest::internal::GTest_TestAdaptor>(argc, argv, test, 86| 1| configuration); 87| 1| } else { 88| 1| RegisterTests<::testing::Test>(argc, argv, test, configuration); 89| 1| } 90| 1| }); 91| | 92| 1| ::testing::UnitTest::GetInstance()->listeners().Append( 93| 1| new ::fuzztest::internal::GTest_EventListener< 94| 1| ::testing::EmptyTestEventListener, ::testing::TestPartResult>()); 95| 1|} _ZN8fuzztest8internal28FuzzTestListingModeValidator26RegisterGoogleTestListenerEv: 151| 1|void FuzzTestListingModeValidator::RegisterGoogleTestListener() { 152| 1| testing::UnitTest::GetInstance()->listeners().Append( 153| 1| new ValidatorProxyListener(this)); 154| 1|} _ZN8fuzztest8internal44SetFuzzTestListingModeValidatorForGoogleTestEb: 156| 1|void SetFuzzTestListingModeValidatorForGoogleTest(bool listing_mode) { 157| 1| FuzzTestListingModeValidator::GetInstance().set_listing_mode(listing_mode); 158| 1|} _ZN8fuzztest8internal18GetRegisteredTestsEv: 160| 1|std::vector GetRegisteredTests() { 161| 1| std::vector result; 162| 1| auto& unit_test = *testing::UnitTest::GetInstance(); 163| 2| for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { ------------------ | Branch (163:19): [True: 1, False: 1] ------------------ 164| 2| for (int j = 0; j < unit_test.GetTestSuite(i)->total_test_count(); ++j) { ------------------ | Branch (164:21): [True: 1, False: 1] ------------------ 165| 1| result.push_back(unit_test.GetTestSuite(i)->GetTestInfo(j)); 166| 1| } 167| 1| } 168| 1| return result; 169| 1|} _ZN8fuzztest8internal22ValidatorProxyListenerC2EPNS0_28FuzzTestListingModeValidatorE: 146| 1| : validator_(validator) {} _ZN8fuzztest8internal22ValidatorProxyListener18OnTestProgramStartERKN7testing8UnitTestE: 138| 1| void OnTestProgramStart(const testing::UnitTest& unit_test) override { 139| 1| validator_->Run(); 140| 1| } _ZN8fuzztest8internal28FuzzTestListingModeValidator3RunEv: 101| 1| void Run() { 102| 1| if (listing_mode_) { ------------------ | Branch (102:9): [True: 0, False: 1] ------------------ 103| | // Since InitFuzzTest calls std::exit after listing the fuzz tests, we 104| | // would not reach here if InitFuzzTest is called before. 105| | absl::FPrintF(stderr, 106| 0| "[!] --" FUZZTEST_FLAG_PREFIX 107| 0| "list_fuzz_tests not handled by InitFuzzTest - fuzz tests " 108| 0| "would not be listed even if defined.\n"); 109| 0| std::exit(0); 110| 0| } 111| 1| } _ZN8fuzztest8internal28FuzzTestListingModeValidator11GetInstanceEv: 115| 1| static FuzzTestListingModeValidator& GetInstance() { 116| 1| static auto* instance = [] { 117| 1| static_assert( 118| 1| std::is_trivially_destructible_v); 119| 1| static FuzzTestListingModeValidator instance; 120| 1| instance.RegisterGoogleTestListener(); 121| 1| return &instance; 122| 1| }(); 123| 1| return *instance; 124| 1| } _ZZN8fuzztest8internal28FuzzTestListingModeValidator11GetInstanceEvENKUlvE_clEv: 116| 1| static auto* instance = [] { 117| 1| static_assert( 118| 1| std::is_trivially_destructible_v); 119| 1| static FuzzTestListingModeValidator instance; 120| 1| instance.RegisterGoogleTestListener(); 121| 1| return &instance; 122| 1| }(); _ZN8fuzztest8internal28FuzzTestListingModeValidator16set_listing_modeEb: 113| 1| void set_listing_mode(bool listing_mode) { listing_mode_ = listing_mode; } googletest_adaptor.cc:_ZZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS0_13ConfigurationEENK3$_0clINS0_8FuzzTestEEEDaRT_: 83| 1| ::fuzztest::internal::ForEachTest([&](auto& test) { 84| 1| if (test.uses_fixture()) { ------------------ | Branch (84:9): [True: 0, False: 1] ------------------ 85| 0| RegisterTests<::fuzztest::internal::GTest_TestAdaptor>(argc, argv, test, 86| 0| configuration); 87| 1| } else { 88| 1| RegisterTests<::testing::Test>(argc, argv, test, configuration); 89| 1| } 90| 1| }); googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_113RegisterTestsIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationE: 73| 1| const Configuration& configuration) { 74| 1| RegisterFuzzTestAsGTest(argc, argv, test, configuration); 75| 1| RegisterSeparateRegressionTestForEachCrashingInput(argc, argv, test, 76| 1| configuration); 77| 1|} googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_123RegisterFuzzTestAsGTestIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationENSt3__117basic_string_viewIcNSE_11char_traitsIcEEEE: 43| 1| absl::string_view suffix = "") { 44| 1| auto fixture_factory = [argc, argv, &test, 45| 1| configuration = configuration]() -> T* { 46| 1| return new ::fuzztest::internal::GTest_TestAdaptor(test, argc, argv, 47| 1| configuration); 48| 1| }; 49| 1| const std::string test_name_with_suffix = 50| 1| absl::StrCat(test.test_name(), suffix); 51| 1| ::testing::RegisterTest( 52| 1| test.suite_name().c_str(), test_name_with_suffix.c_str(), nullptr, 53| 1| nullptr, test.file().c_str(), test.line(), std::move(fixture_factory)); 54| 1|} googletest_adaptor.cc:_ZZN8fuzztest8internal12_GLOBAL__N_123RegisterFuzzTestAsGTestIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationENSt3__117basic_string_viewIcNSE_11char_traitsIcEEEEENKUlvE_clEv: 45| 1| configuration = configuration]() -> T* { 46| 1| return new ::fuzztest::internal::GTest_TestAdaptor(test, argc, argv, 47| 1| configuration); 48| 1| }; googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_150RegisterSeparateRegressionTestForEachCrashingInputIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationE: 59| 1| const Configuration& configuration) { 60| 1| CorpusDatabase corpus_database(configuration); 61| 1| for (const std::string& input : ------------------ | Branch (61:33): [True: 0, False: 1] ------------------ 62| 1| corpus_database.GetCrashingInputsIfAny(test.full_name())) { 63| 0| Configuration updated_configuration = configuration; 64| 0| updated_configuration.crashing_input_to_reproduce = input; 65| 0| const std::string suffix = 66| 0| absl::StrCat("/Regression/", std::string(Basename(input))); 67| 0| RegisterFuzzTestAsGTest(argc, argv, test, updated_configuration, suffix); 68| 0| } 69| 1|} _ZN8fuzztest8internal17GTest_TestAdaptorC2ERNS0_8FuzzTestEPiPPPcNS0_13ConfigurationE: 35| 1| : test_(test), 36| 1| argc_(argc), 37| 1| argv_(argv), 38| 1| configuration_(std::move(configuration)) {} _ZN8fuzztest8internal17GTest_TestAdaptor8TestBodyEv: 40| 1| void TestBody() override { 41| 1| auto test = test_.make(); 42| 1| configuration_.fuzz_tests_in_current_shard = GetFuzzTestsInCurrentShard(); 43| 1| if (Runtime::instance().run_mode() == RunMode::kUnitTest) { ------------------ | Branch (43:9): [True: 0, False: 1] ------------------ 44| | // In "bug reproduction" mode, sometimes we need to reproduce multiple 45| | // bugs, i.e., run multiple tests that lead to a crash. 46| 0| bool needs_subprocess = false; 47| 0|#ifdef GTEST_HAS_DEATH_TEST 48| 0| needs_subprocess = 49| 0| configuration_.crashing_input_to_reproduce.has_value() && ------------------ | Branch (49:11): [True: 0, False: 0] ------------------ 50| 0| ( 51| | // When only a single test runs, it's okay to crash the process on 52| | // error, as we don't need to run other tests. 53| 0| testing::UnitTest::GetInstance()->test_to_run_count() > 1 || ------------------ | Branch (53:15): [True: 0, False: 0] ------------------ 54| | // EXPECT_EXIT is required in the death-test subprocess, but in 55| | // the subprocess there's only one test to run. 56| 0| testing::internal::InDeathTestChild()); ------------------ | Branch (56:15): [True: 0, False: 0] ------------------ 57| 0|#endif 58| 0| if (needs_subprocess) { ------------------ | Branch (58:11): [True: 0, False: 0] ------------------ 59| 0| configuration_.preprocess_crash_reproducing = [] { 60| | // EXPECT_EXIT disables event forwarding in gtest and as a result, 61| | // EXPECT/ASSERT-s are disabled. Here, we overwrite this option. 62| 0| testing::UnitTest::GetInstance()->listeners().SuppressEventForwarding( 63| 0| false); 64| 0| }; 65| | // `RunInUnitTestMode` is supposed to fail and we wish to show the 66| | // failure to the user. Directly running the test would terminate the 67| | // process and using `EXPECT_DEATH` causes the test to pass. We use 68| | // `EXPECT_EXIT` so that the test exit unsuccessfully, meaning that the 69| | // test below fails without terminating the process. 70| 0|#ifdef GTEST_HAS_DEATH_TEST 71| 0| EXPECT_EXIT( ------------------ | Branch (71:9): [True: 0, False: 0] | Branch (71:9): [True: 0, False: 0] | Branch (71:9): [True: 0, False: 0] | Branch (71:9): [True: 0, False: 0] | Branch (71:9): [True: 0, False: 0] | Branch (71:9): [True: 0, False: 0] | Branch (71:9): [True: 0, False: 0] | Branch (71:9): [True: 0, False: 0] | Branch (71:9): [True: 0, False: 0] | Branch (71:9): [True: 0, False: 0] ------------------ 72| 0| (test->RunInUnitTestMode(configuration_), 73| 0| void( 74| 0| R"( FuzzTest failure! Please see 'actual message' below for the crash report. )"), 75| 0| std::exit(0)), 76| 0| ::testing::ExitedWithCode(0), ""); 77| |#else 78| | EXPECT_TRUE(false) << "Death test is not supported."; 79| |#endif 80| 0| } else { 81| 0| test->RunInUnitTestMode(configuration_); 82| 0| } 83| 1| } else { 84| | // TODO(b/245753736): Consider using `tolerate_failure` when FuzzTest can 85| | // tolerate crashes in fuzzing mode. 86| 3| ASSERT_EQ(0, test->RunInFuzzingMode(argc_, argv_, configuration_)) ------------------ | Branch (86:7): [True: 0, False: 1] | Branch (86:7): [True: 0, False: 1] | Branch (86:7): [True: 1, False: 0] ------------------ 87| 3| << "Fuzzing failure."; 88| 1| } 89| 1| } _ZN8fuzztest8internal8BasenameENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE: 183| 1|absl::string_view Basename(absl::string_view filename) { 184| 1| auto last_slash_pos = filename.find_last_of("/\\"); 185| | 186| 1| return last_slash_pos == absl::string_view::npos ------------------ | Branch (186:10): [True: 0, False: 1] ------------------ 187| 1| ? filename 188| 1| : filename.substr(last_slash_pos + 1); 189| 1|} _ZN8fuzztest8internal9GetStderrEv: 125| 1|FILE* GetStderr() { 126| 1| absl::MutexLock lock(&stderr_file_guard_); 127| 1| if (!stderr_file_) { ------------------ | Branch (127:7): [True: 1, False: 0] ------------------ 128| | stderr_file_ = stderr; 129| 1| } 130| 1| return stderr_file_; 131| 1|} _ZN8fuzztest8internal11CheckIsSameINS0_23ElementOfImplCorpusTypeES2_EEvv: 806| 4|constexpr void CheckIsSame() { 807| 4| static_assert(std::is_same_v); 808| 4|} _ZN8fuzztest8internal11CheckIsSameIccEEvv: 806| 2|constexpr void CheckIsSame() { 807| 2| static_assert(std::is_same_v); 808| 2|} _ZN8fuzztest8internal11CheckIsSameINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES8_EEvv: 806| 2|constexpr void CheckIsSame() { 807| 2| static_assert(std::is_same_v); 808| 2|} _ZN8fuzztest8internal11CheckIsSameI15avifPixelFormatS2_EEvv: 806| 1|constexpr void CheckIsSame() { 807| 1| static_assert(std::is_same_v); 808| 1|} _ZN8fuzztest8internal11CheckIsSameIbbEEvv: 806| 8|constexpr void CheckIsSame() { 807| 8| static_assert(std::is_same_v); 808| 8|} _ZN8fuzztest8internal11CheckIsSameIiiEEvv: 806| 1|constexpr void CheckIsSame() { 807| 1| static_assert(std::is_same_v); 808| 1|} avif_fuzztest_read_image.cc:_ZN8fuzztest8internal11CheckIsSameINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEESD_EEvv: 806| 1|constexpr void CheckIsSame() { 807| 1| static_assert(std::is_same_v); 808| 1|} _ZN8fuzztest8internal11CheckIsSameINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_23ElementOfImplCorpusTypeESA_SA_bbbbSA_EEESB_EEvv: 806| 1|constexpr void CheckIsSame() { 807| 1| static_assert(std::is_same_v); 808| 1|} _ZN8fuzztest8internal11CheckIsSameI22avifChromaDownsamplingS2_EEvv: 806| 1|constexpr void CheckIsSame() { 807| 1| static_assert(std::is_same_v); 808| 1|} avif_fuzztest_read_image.cc:_ZN8fuzztest8internal11CheckIsSameI3$_0S2_EEvv: 806| 1|constexpr void CheckIsSame() { 807| 1| static_assert(std::is_same_v); 808| 1|} _ZN8fuzztest15GetRegistrationIPFvRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbbtEEEDaS7_S7_S7_iT_: 339| 1| TargetFunction target_function) { 340| 1| return ::fuzztest::internal::Registration<::fuzztest::internal::NoFixture, 341| 1| TargetFunction>( 342| 1| ::fuzztest::internal::BasicTestInfo{std::move(suite_name), 343| 1| std::move(test_name), std::move(file), 344| 1| line, false}, 345| 1| target_function); 346| 1|} _ZN8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbbtENS0_23DefaultRegistrationBaseIJS9_SC_iSD_bbbbtEEEPvEC2ENS0_13BasicTestInfoESF_: 134| 1| : test_info_(std::move(info)), target_function_(target_function) {} avif_fuzztest_read_image.cc:_ZNO8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbbtENS0_23DefaultRegistrationBaseIJS9_SC_iSD_bbbbtEEEPvE11WithDomainsIJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEENS0_13ElementOfImplISC_EENSP_IiEENSP_ISD_EENSM_IbvEEST_ST_ST_NSP_I3$_0EEEEEDaDpOT_: 172| 1| auto WithDomains(NewDomains&&... domains) && { 173| 1| return std::move(*this).WithDomains( 174| 1| TupleOf(std::forward(domains)...)); 175| 1| } avif_fuzztest_read_image.cc:_ZNO8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbbtENS0_23DefaultRegistrationBaseIJS9_SC_iSD_bbbbtEEEPvE11WithDomainsIJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEENS0_13ElementOfImplISC_EENSP_IiEENSP_ISD_EENSM_IbvEEST_ST_ST_NSP_I3$_0EEEEEDaNS0_15AggregateOfImplINS3_5tupleIJDpNT_10value_typeEEEELNS0_23RequireCustomCorpusTypeE0EJDpSY_EEE: 149| 1| domain) && { 150| 1| static_assert(!Registration::kHasDomain, 151| 1| "WithDomains can only be called once."); 152| 1| static_assert(!Registration::kHasSeeds, 153| 1| "WithDomains can not be called after WithSeeds."); 154| 1| static_assert(!Registration::kHasSeedProvider, 155| 1| "WithDomains can not be called after WithSeedProvider."); 156| 1| static_assert( 157| 1| Base::kNumArgs == sizeof...(NewDomains), 158| 1| "Number of domains specified in .WithDomains() does not match " 159| 1| "the number of function parameters."); 160| 1| using NewBase = RegistrationWithDomainsBase...>; 161| 1| return Registration( 162| 1| std::move(test_info_), target_function_, NewBase{std::move(domain)}); 163| 1| } avif_fuzztest_read_image.cc:_ZN8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbbtENS0_27RegistrationWithDomainsBaseIJS9_SC_iSD_bbbb3$_0EEEPvEC2ENS0_13BasicTestInfoESF_SI_: 294| 1| : Base(std::move(base)), 295| 1| test_info_(std::move(info)), 296| 1| target_function_(target_function) {} avif_fuzztest_read_image.cc:_ZNK8fuzztest8internal27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EE10GetDomainsEv: 95| 1| const auto& GetDomains() const { return domains_; } avif_fuzztest_read_image.cc:_ZNK8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbbtENS0_27RegistrationWithDomainsBaseIJS9_SC_iSD_bbbb3$_0EEEPvE5seedsEv: 272| 1| std::vector seeds() const { 273| | if constexpr (Base::kHasSeeds) { 274| | return this->seeds_; 275| 1| } else { 276| 1| return {}; 277| 1| } 278| 1| } avif_fuzztest_read_image.cc:_ZN8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbbtENS0_27RegistrationWithDomainsBaseIJS9_SC_iSD_bbbb3$_0EEEPvE13seed_providerEv: 280| 1| SeedProvider seed_provider() { 281| | if constexpr (Base::kHasSeedProvider) { 282| | return std::move(this->seed_provider_); 283| 1| } else { 284| 1| return {}; 285| 1| } 286| 1| } _ZN8fuzztest8internal11ForEachTestEN4absl12lts_2024011611FunctionRefIFvRNS0_8FuzzTestEEEE: 56| 4|void ForEachTest(absl::FunctionRef func) { 57| 4| for (auto& t : Regs()) func(t); ------------------ | Branch (57:16): [True: 4, False: 4] ------------------ 58| 4|} _ZN8fuzztest8internal12RegisterImplENS0_13BasicTestInfoEN4absl12lts_2024011612AnyInvocableIKFNSt3__110unique_ptrINS0_14FuzzTestFuzzerENS5_14default_deleteIS7_EEEERKNS0_8FuzzTestEEEE: 60| 1|void RegisterImpl(BasicTestInfo test_info, FuzzTestFuzzerFactory factory) { 61| 1| Regs().emplace_back(std::move(test_info), std::move(factory)); 62| 1|} registry.cc:_ZN8fuzztest8internal12_GLOBAL__N_14RegsEv: 30| 5|auto& Regs() { 31| | // We use a deque because FuzzTest is not copyable/movable. 32| 5| static auto* reg = new std::deque; 33| 5| return *reg; 34| 5|} avif_fuzztest_read_image.cc:_ZN8fuzztest8internal17RegistrationTokenaSINS0_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS0_9NoFixtureEPFvRKSA_SB_iSC_bbbbtEPvEERS1_ONS0_12RegistrationIT0_T1_T_T2_EE: 57| 1| Registration&& reg) { 58| | if constexpr (std::is_base_of_v) { 59| | RegisterSetUpTearDownTestSuiteFunctions(reg.test_info_.suite_name, 60| | &Fixture::SetUpTestSuite, 61| | &Fixture::TearDownTestSuite); 62| | } 63| 1| BasicTestInfo test_info = reg.test_info_; 64| 1| RegisterImpl(std::move(test_info), 65| 1| GetFuzzTestFuzzerFactory(std::move(reg))); 66| 1| return *this; 67| 1| } avif_fuzztest_read_image.cc:_ZN8fuzztest8internal17RegistrationToken24GetFuzzTestFuzzerFactoryINS0_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS0_9NoFixtureEPFvRKSA_SB_iSC_bbbbtEPvEEN4absl12lts_2024011612AnyInvocableIKFNS4_10unique_ptrINS0_14FuzzTestFuzzerENS4_14default_deleteISP_EEEERKNS0_8FuzzTestEEEEONS0_12RegistrationIT0_T1_T_T2_EE: 72| 1| Registration&& reg) { 73| |#if defined(FUZZTEST_COMPATIBILITY_MODE) && defined(FUZZTEST_USE_CENTIPEDE) 74| |#error FuzzTest compatibility mode cannot work together with Centipede. 75| |#endif 76| 1|#if defined(FUZZTEST_COMPATIBILITY_MODE) 77| 1| using FuzzerImpl = FuzzTestExternalEngineAdaptor; 78| |#elif defined(FUZZTEST_USE_CENTIPEDE) 79| | using FuzzerImpl = CentipedeFuzzerAdaptor; 80| |#else 81| | using FuzzerImpl = FuzzTestFuzzerImpl; 82| |#endif 83| | 84| 1| return [target_function = reg.target_function_, domain = reg.GetDomains(), 85| 1| seeds = reg.seeds(), seed_provider = reg.seed_provider()]( 86| 1| const FuzzTest& test) -> std::unique_ptr { 87| 1| return std::make_unique( 88| 1| test, 89| 1| std::make_unique>( 91| 1| target_function, domain, seeds, seed_provider)); 92| 1| }; 93| 1| } avif_fuzztest_read_image.cc:_ZZN8fuzztest8internal17RegistrationToken24GetFuzzTestFuzzerFactoryINS0_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE15avifPixelFormati22avifChromaDownsamplingbbbb3$_0EEENS0_9NoFixtureEPFvRKSA_SB_iSC_bbbbtEPvEEN4absl12lts_2024011612AnyInvocableIKFNS4_10unique_ptrINS0_14FuzzTestFuzzerENS4_14default_deleteISP_EEEERKNS0_8FuzzTestEEEEONS0_12RegistrationIT0_T1_T_T2_EEENKUlSV_E_clESV_: 86| 1| const FuzzTest& test) -> std::unique_ptr { 87| 1| return std::make_unique( 88| 1| test, 89| 1| std::make_unique>( 91| 1| target_function, domain, seeds, seed_provider)); 92| 1| }; _ZN8fuzztest8internal7RuntimeC2Ev: 226| 1|Runtime::Runtime() { 227| 1| if (const char* crash_metadata_path = 228| 1| std::getenv("FUZZTEST_CRASH_METADATA_PATH"); 229| 1| crash_metadata_path != nullptr) { ------------------ | Branch (229:7): [True: 0, False: 1] ------------------ 230| 0| RegisterCrashMetadataListener( 231| 0| [=](absl::string_view crash_type, 232| 0| absl::Span /*stack_frames*/) { 233| 0| WriteFile(crash_metadata_path, crash_type); 234| 0| }); 235| 0| } 236| 1|} _ZN8fuzztest8internal21InstallSignalHandlersEP8_IO_FILE: 517| 1|void InstallSignalHandlers(FILE* out) { 518| 1| if (signal_out != nullptr) { ------------------ | Branch (518:7): [True: 0, False: 1] ------------------ 519| | // Already installed. Noop. 520| 0| return; 521| 0| } 522| 1| signal_out = out; 523| | 524| |#if defined(FUZZTEST_HAS_SANITIZER) 525| | // An ASan failure might come without a signal. 526| | // Eg a divide by zero is intercepted by ASan and it terminates the process 527| | // after printing its output. This handler helps us print our output 528| | // afterwards. 529| | __sanitizer_set_death_callback([](auto...) { 530| | Runtime& runtime = Runtime::instance(); 531| |#if defined(ADDRESS_SANITIZER) 532| | runtime.SetCrashTypeIfUnset(__asan_get_report_description()); 533| |#else 534| | runtime.SetCrashTypeIfUnset("Sanitizer crash"); 535| |#endif 536| | runtime.PrintReport(&signal_out_sink); 537| | }); 538| |#endif 539| | 540| 6| for (OldSignalHandler& h : crash_handlers) { ------------------ | Branch (540:28): [True: 6, False: 1] ------------------ 541| 6| SetNewSigAction(h.signum, &HandleCrash, &h.action); 542| 6| } 543| | 544| 3| for (OldSignalHandler& h : termination_handlers) { ------------------ | Branch (544:28): [True: 3, False: 1] ------------------ 545| 3| SetNewSigAction(h.signum, &HandleTermination, nullptr); 546| 3| } 547| 1|} _ZN8fuzztest8internal18FuzzTestFuzzerImplC2ERKNS0_8FuzzTestENSt3__110unique_ptrINS0_20UntypedFixtureDriverENS5_14default_deleteIS7_EEEE: 570| 1| : test_(test), 571| 1| fixture_driver_(std::move(fixture_driver)), 572| 1| params_domain_(fixture_driver_->GetDomains()), 573| 1| execution_coverage_(internal::GetExecutionCoverage()), 574| 1| corpus_coverage_(execution_coverage_ != nullptr ------------------ | Branch (574:24): [True: 0, False: 1] ------------------ 575| 1| ? execution_coverage_->GetCounterMap().size() 576| 1| : 0) { 577| 1| FUZZTEST_INTERNAL_CHECK_PRECONDITION(fixture_driver_ != nullptr, ------------------ | | 42| 1| ((P) ? (void)0 \ | | ------------------ | | | Branch (42:4): [True: 1, False: 0] | | ------------------ | | 43| 1| : ::fuzztest::internal::Abort( \ | | 44| 0| __FILE__, __LINE__, \ | | 45| 0| absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__))) ------------------ 578| 1| "Invalid fixture driver!"); 579| 1| stats_.start_time = absl::Now(); 580| 1| const char* corpus_out_dir_chars = getenv("FUZZTEST_TESTSUITE_OUT_DIR"); 581| 1| if (corpus_out_dir_chars) corpus_out_dir_ = corpus_out_dir_chars; ------------------ | Branch (581:7): [True: 0, False: 1] ------------------ 582| | 583| 1| std::vector weights = {100.}; 584| 1| corpus_distribution_ = 585| 1| absl::discrete_distribution<>(weights.begin(), weights.end()); 586| 1|} runtime.cc:_ZN8fuzztest8internalL15SetNewSigActionEiPFviP9siginfo_tPvEP9sigaction: 500| 9| struct sigaction* old_sigact) { 501| 9| struct sigaction new_sigact = {}; 502| 9| sigemptyset(&new_sigact.sa_mask); 503| 9| new_sigact.sa_sigaction = handler; 504| | 505| | // We make use of the SA_ONSTACK flag so that signal handlers are executed on 506| | // a separate stack. This is needed to properly handle cases where stack space 507| | // is limited and the delivery of a signal needs to be properly handled. 508| 9| new_sigact.sa_flags = SA_SIGINFO | SA_ONSTACK; 509| | 510| 9| if (sigaction(signum, &new_sigact, old_sigact) == -1) { ------------------ | Branch (510:7): [True: 0, False: 9] ------------------ 511| 0| fprintf(GetStderr(), "Error installing signal handler: %s\n", 512| | strerror(errno)); 513| 0| exit(1); 514| 0| } 515| 9|} _ZN8fuzztest8internal8FuzzTestC2ENS0_13BasicTestInfoEN4absl12lts_2024011612AnyInvocableIKFNSt3__110unique_ptrINS0_14FuzzTestFuzzerENS6_14default_deleteIS8_EEEERKS1_EEE: 80| 1| : test_info_(std::move(test_info)), make_(std::move(factory)) {} _ZNK8fuzztest8internal8FuzzTest10suite_nameEv: 82| 1| const std::string& suite_name() const { return test_info_.suite_name; } _ZNK8fuzztest8internal8FuzzTest9test_nameEv: 83| 1| const std::string& test_name() const { return test_info_.test_name; } _ZNK8fuzztest8internal8FuzzTest9full_nameEv: 84| 4| std::string full_name() const { 85| 4| return absl::StrCat(test_info_.suite_name, ".", test_info_.test_name); 86| 4| } _ZNK8fuzztest8internal8FuzzTest4fileEv: 87| 1| const std::string& file() const { return test_info_.file; } _ZNK8fuzztest8internal8FuzzTest4lineEv: 88| 1| int line() const { return test_info_.line; } _ZNK8fuzztest8internal8FuzzTest12uses_fixtureEv: 89| 1| bool uses_fixture() const { return test_info_.uses_fixture; } _ZNK8fuzztest8internal8FuzzTest4makeEv: 90| 1| auto make() const { return make_(*this); } _ZN8fuzztest8internal7Runtime8instanceEv: 122| 4| static Runtime& instance() { 123| 4| static auto* runtime = new Runtime(); 124| 4| return *runtime; 125| 4| } _ZN8fuzztest8internal7Runtime10SetRunModeENS_7RunModeE: 160| 2| void SetRunMode(RunMode run_mode) { run_mode_ = run_mode; } _ZNK8fuzztest8internal7Runtime8run_modeEv: 161| 1| RunMode run_mode() const { return run_mode_; } _ZN8fuzztest8internal7Runtime14EnableReporterEPKNS0_12RuntimeStatsEPFN4absl12lts_202401164TimeEvE: 163| 1| void EnableReporter(const RuntimeStats* stats, absl::Time (*clock_fn)()) { 164| 1| reporter_enabled_ = true; 165| 1| stats_ = stats; 166| 1| clock_fn_ = clock_fn; 167| | // In case we have not installed them yet, do so now. 168| 1| InstallSignalHandlers(GetStderr()); 169| 1| ResetCrashType(); 170| 1| } _ZN8fuzztest8internal7Runtime14ResetCrashTypeEv: 207| 1| void ResetCrashType() { crash_type_ = std::nullopt; } _ZN8fuzztest8internal23GetFromEnvOrMakeSeedSeqERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS1_17basic_string_viewIcS4_EE: 63| 1| absl::string_view env_var) { 64| 1| const std::vector seed_material = 65| 1| GetFromEnvOrMakeSeedMaterial(env_var); 66| 1| const std::string encoded_seed_material = EncodeSeedMaterial(seed_material); 67| 1| out << env_var << "=" << encoded_seed_material << '\n'; 68| 1| return std::seed_seq(seed_material.begin(), seed_material.end()); 69| 1|} _ZN8fuzztest8internal18EncodeSeedMaterialEN4absl12lts_202401164SpanIKjEE: 71| 1|std::string EncodeSeedMaterial(absl::Span seed_material) { 72| 1| return absl::WebSafeBase64Escape( 73| 1| absl::string_view(reinterpret_cast(seed_material.data()), 74| 1| seed_material.size() * sizeof(uint32_t))); 75| 1|} seed_seq.cc:_ZN8fuzztest8internal12_GLOBAL__N_128GetFromEnvOrMakeSeedMaterialENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 47| 1|std::vector GetFromEnvOrMakeSeedMaterial(absl::string_view env_var) { 48| 1| const char* encoded_seed_material = std::getenv(env_var.data()); 49| 1| if (encoded_seed_material == nullptr) { ------------------ | Branch (49:7): [True: 1, False: 0] ------------------ 50| 1| return MakeSeedMaterial(); 51| 1| } 52| 0| std::optional> seed_material = 53| 0| DecodeSeedMaterial(encoded_seed_material); 54| 0| FUZZTEST_INTERNAL_CHECK_PRECONDITION( ------------------ | | 42| 0| ((P) ? (void)0 \ | | ------------------ | | | Branch (42:4): [True: 0, False: 0] | | ------------------ | | 43| 0| : ::fuzztest::internal::Abort( \ | | 44| 0| __FILE__, __LINE__, \ | | 45| 0| absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__))) ------------------ 55| 0| seed_material.has_value(), 56| 0| "Failed to decode seed material from the environment variable ", env_var); 57| 0| return *std::move(seed_material); 58| 1|} seed_seq.cc:_ZN8fuzztest8internal12_GLOBAL__N_116MakeSeedMaterialEv: 37| 1|std::vector MakeSeedMaterial() { 38| 1| absl::BitGen gen; 39| 1| static constexpr int kNumberOfEntropyBits = 256; 40| 1| std::vector seed_material(kNumberOfEntropyBits / 41| 1| (8 * sizeof(uint32_t))); 42| 1| std::generate(seed_material.begin(), seed_material.end(), 43| 1| [&gen] { return absl::Uniform(gen); }); 44| 1| return seed_material; 45| 1|} seed_seq.cc:_ZZN8fuzztest8internal12_GLOBAL__N_116MakeSeedMaterialEvENK3$_0clEv: 43| 8| [&gen] { return absl::Uniform(gen); }); _ZN7testing7MessagelsIKcEERS0_RKPT_: 182| 21| inline Message& operator<<(T* const& pointer) { // NOLINT 183| 21| if (pointer == nullptr) { ------------------ | Branch (183:9): [True: 0, False: 21] ------------------ 184| 0| *ss_ << "(null)"; 185| 21| } else { 186| 21| *ss_ << pointer; 187| 21| } 188| 21| return *this; 189| 21| } _ZN7testing8internal18StreamableToStringIiEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKT_: 243| 3|std::string StreamableToString(const T& streamable) { 244| 3| return (Message() << streamable).GetString(); 245| 3|} _ZN7testing7MessagelsIiEERS0_RKT_: 132| 3| inline Message& operator<<(const T& val) { 133| | // Some libraries overload << for STL containers. These 134| | // overloads are defined in the global namespace instead of ::std. 135| | // 136| | // C++'s symbol lookup rule (i.e. Koenig lookup) says that these 137| | // overloads are visible in either the std namespace or the global 138| | // namespace, but not other namespaces, including the testing 139| | // namespace which Google Test's Message class is in. 140| | // 141| | // To allow STL containers (and other types that has a << operator 142| | // defined in the global namespace) to be used in Google Test 143| | // assertions, testing::Message must access the custom << operator 144| | // from the global namespace. With this using declaration, 145| | // overloads of << defined in the global namespace and those 146| | // visible via Koenig lookup are both exposed in this function. 147| 3| using ::operator<<; 148| 3| *ss_ << val; 149| 3| return *this; 150| 3| } _ZN7testing7MessagelsIA7_cEERS0_RKT_: 132| 21| inline Message& operator<<(const T& val) { 133| | // Some libraries overload << for STL containers. These 134| | // overloads are defined in the global namespace instead of ::std. 135| | // 136| | // C++'s symbol lookup rule (i.e. Koenig lookup) says that these 137| | // overloads are visible in either the std namespace or the global 138| | // namespace, but not other namespaces, including the testing 139| | // namespace which Google Test's Message class is in. 140| | // 141| | // To allow STL containers (and other types that has a << operator 142| | // defined in the global namespace) to be used in Google Test 143| | // assertions, testing::Message must access the custom << operator 144| | // from the global namespace. With this using declaration, 145| | // overloads of << defined in the global namespace and those 146| | // visible via Koenig lookup are both exposed in this function. 147| 21| using ::operator<<; 148| 21| *ss_ << val; 149| 21| return *this; 150| 21| } _ZN7testing7MessagelsIcEERS0_RKT_: 132| 414| inline Message& operator<<(const T& val) { 133| | // Some libraries overload << for STL containers. These 134| | // overloads are defined in the global namespace instead of ::std. 135| | // 136| | // C++'s symbol lookup rule (i.e. Koenig lookup) says that these 137| | // overloads are visible in either the std namespace or the global 138| | // namespace, but not other namespaces, including the testing 139| | // namespace which Google Test's Message class is in. 140| | // 141| | // To allow STL containers (and other types that has a << operator 142| | // defined in the global namespace) to be used in Google Test 143| | // assertions, testing::Message must access the custom << operator 144| | // from the global namespace. With this using declaration, 145| | // overloads of << defined in the global namespace and those 146| | // visible via Koenig lookup are both exposed in this function. 147| 414| using ::operator<<; 148| 414| *ss_ << val; 149| 414| return *this; 150| 414| } _ZN7testing8internal18StreamableToStringIPcEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKT_: 243| 15|std::string StreamableToString(const T& streamable) { 244| 15| return (Message() << streamable).GetString(); 245| 15|} _ZN7testing7MessagelsIcEERS0_RKPT_: 182| 15| inline Message& operator<<(T* const& pointer) { // NOLINT 183| 15| if (pointer == nullptr) { ------------------ | Branch (183:9): [True: 0, False: 15] ------------------ 184| 0| *ss_ << "(null)"; 185| 15| } else { 186| 15| *ss_ << pointer; 187| 15| } 188| 15| return *this; 189| 15| } _ZNK7testing8TestInfo15test_suite_nameEv: 541| 2| const char* test_suite_name() const { return test_suite_name_.c_str(); } _ZNK7testing8TestInfo4nameEv: 549| 4| const char* name() const { return name_.c_str(); } _ZN7testing8UnitTest4implEv: 1267| 24| internal::UnitTestImpl* impl() { return impl_; } _ZNK7testing9TestSuite14test_info_listEv: 762| 1| const std::vector& test_info_list() const { 763| 1| return test_info_list_; 764| 1| } _ZN7testing10TestResult19set_start_timestampEl: 468| 1| void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; } _ZN7testing9TestSuite13ShouldRunTestEPKNS_8TestInfoE: 839| 2| static bool ShouldRunTest(const TestInfo* test_info) { 840| 2| return test_info->should_run(); 841| 2| } _ZN7testing9TestSuite17RunSetUpTestSuiteEv: 793| 1| void RunSetUpTestSuite() { 794| 1| if (set_up_tc_ != nullptr) { ------------------ | Branch (794:9): [True: 0, False: 1] ------------------ 795| 0| (*set_up_tc_)(); 796| 0| } 797| 1| } _ZNK7testing9TestSuite18ad_hoc_test_resultEv: 752| 2| const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; } _ZN7testing8TestInfo15ClearTestResultEPS0_: 639| 1| static void ClearTestResult(TestInfo* test_info) { 640| 1| test_info->result_.Clear(); 641| 1| } _ZNK7testing9TestSuite4nameEv: 695| 2| const char* name() const { return name_.c_str(); } _ZNK7testing9TestSuite10type_paramEv: 699| 1| const char* type_param() const { 700| 1| if (type_param_ != nullptr) return type_param_->c_str(); ------------------ | Branch (700:9): [True: 0, False: 1] ------------------ 701| 1| return nullptr; 702| 1| } _ZNK7testing9TestSuite10should_runEv: 705| 2| bool should_run() const { return should_run_; } _ZNK7testing8TestInfo10should_runEv: 590| 2| bool should_run() const { return should_run_; } _ZNK7testing8TestInfo10type_paramEv: 553| 1| const char* type_param() const { 554| 1| if (type_param_ != nullptr) return type_param_->c_str(); ------------------ | Branch (554:9): [True: 0, False: 1] ------------------ 555| 1| return nullptr; 556| 1| } _ZNK7testing8UnitTest4implEv: 1268| 7| const internal::UnitTestImpl* impl() const { return impl_; } _ZN7testing9TestSuite20ClearTestSuiteResultEPS0_: 781| 1| static void ClearTestSuiteResult(TestSuite* test_suite) { 782| 1| test_suite->ClearResult(); 783| 1| } _ZN7testing9TestSuite14set_should_runEb: 771| 2| void set_should_run(bool should) { should_run_ = should; } _ZN7testing9TestSuite14test_info_listEv: 759| 3| std::vector& test_info_list() { return test_info_list_; } _ZN7testing17TestEventListener16OnTestSuiteStartERKNS_9TestSuiteE: 946| 1| virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {} _ZN7testing8internal8FilePathC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 74| 1| explicit FilePath(const std::string& pathname) : pathname_(pathname) { 75| 1| Normalize(); 76| 1| } _ZNK7testing8internal8FilePath7IsEmptyEv: 118| 2| bool IsEmpty() const { return pathname_.empty(); } _ZN7testing8internal8FilePathC2Ev: 71| 1| FilePath() : pathname_("") {} _ZN7testing8internal8FilePath3SetERKS1_: 83| 1| void Set(const FilePath& rhs) { pathname_ = rhs.pathname_; } _ZN7testing8internal6RandomC2Ej: 859| 1| explicit Random(uint32_t seed) : state_(seed) {} _ZN7testing8internal9GetTypeIdINS_4TestEEEPKvv: 419| 1|TypeId GetTypeId() { 420| | // The compiler is required to allocate a different 421| | // TypeIdHelper::dummy_ variable for each T used to instantiate 422| | // the template. Therefore, the address of dummy_ is guaranteed to 423| | // be unique. 424| 1| return &(TypeIdHelper::dummy_); 425| 1|} _ZN7testing8internal30ParameterizedTestSuiteRegistry13RegisterTestsEv: 732| 1| void RegisterTests() { 733| 1| for (auto& test_suite_info : test_suite_infos_) { ------------------ | Branch (733:32): [True: 0, False: 1] ------------------ 734| 0| test_suite_info->RegisterTests(); 735| 0| } 736| 1| } _ZN7testing8internal30ParameterizedTestSuiteRegistryC2Ev: 694| 1| ParameterizedTestSuiteRegistry() = default; _ZN7testing8internal7ToUpperEc: 1971| 414|inline char ToUpper(char ch) { 1972| 414| return static_cast(toupper(static_cast(ch))); 1973| 414|} _ZN7testing8internal5posix6GetEnvEPKc: 2122| 31|inline const char* GetEnv(const char* name) { 2123| |#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \ 2124| | defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) || \ 2125| | defined(GTEST_OS_QURT) 2126| | // We are on an embedded platform, which has no environment variables. 2127| | static_cast(name); // To prevent 'unused argument' warning. 2128| | return nullptr; 2129| |#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) 2130| | // Environment variables which we programmatically clear will be set to the 2131| | // empty string rather than unset (NULL). Handle that case. 2132| | const char* const env = getenv(name); 2133| | return (env != nullptr && env[0] != '\0') ? env : nullptr; 2134| |#else 2135| 31| return getenv(name); 2136| 31|#endif 2137| 31|} _ZN7testing8internal5posix10StrCaseCmpEPKcS3_: 2059| 1|inline int StrCaseCmp(const char* s1, const char* s2) { 2060| 1| return strcasecmp(s1, s2); 2061| 1|} _ZN7testing8internal5MutexC2Ev: 1706| 5| Mutex() { 1707| 5| GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr)); ------------------ | | 1092| 5| if (const int gtest_error = (posix_call)) \ | | ------------------ | | | Branch (1092:17): [True: 0, False: 5] | | ------------------ | | 1093| 5| GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error | | ------------------ | | | | 1054| 0| ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ | | | | 1055| 0| __FILE__, __LINE__) \ | | | | 1056| 0| .GetStream() | | ------------------ ------------------ 1708| 5| has_owner_ = false; 1709| 5| } _ZN7testing8internal5posix6IsATTYEi: 2065| 1|inline int IsATTY(int fd) { 2066| | // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout 2067| | // to a file on Linux), which is unexpected, so save the previous value, and 2068| | // restore it after the call. 2069| 1| int savedErrno = errno; 2070| 1| int isAttyValue = DoIsATTY(fd); 2071| 1| errno = savedErrno; 2072| | 2073| 1| return isAttyValue; 2074| 1|} _ZN7testing8internal5posix8DoIsATTYEi: 2058| 1|inline int DoIsATTY(int fd) { return isatty(fd); } _ZN7testing8internal5posix6FileNoEP8_IO_FILE: 2021| 1|inline int FileNo(FILE* file) { return fileno(file); } _ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEEC2ERKS3_: 1761| 1| : key_(CreateKey()), 1762| 1| default_factory_(new InstanceValueHolderFactory(value)) {} _ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE9CreateKeyEv: 1793| 1| static pthread_key_t CreateKey() { 1794| 1| pthread_key_t key; 1795| | // When a thread exits, DeleteThreadLocalValue() will be called on 1796| | // the object managed for that thread. 1797| 1| GTEST_CHECK_POSIX_SUCCESS_( ------------------ | | 1092| 1| if (const int gtest_error = (posix_call)) \ | | ------------------ | | | Branch (1092:17): [True: 0, False: 1] | | ------------------ | | 1093| 1| GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error | | ------------------ | | | | 1054| 0| ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ | | | | 1055| 0| __FILE__, __LINE__) \ | | | | 1056| 0| .GetStream() | | ------------------ ------------------ 1798| 1| pthread_key_create(&key, &DeleteThreadLocalValue)); 1799| 1| return key; 1800| 1| } _ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE26InstanceValueHolderFactoryC2ERKS3_: 1839| 1| explicit InstanceValueHolderFactory(const T& value) : value_(value) {} _ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE18ValueHolderFactoryC2Ev: 1817| 1| ValueHolderFactory() = default; _ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEEC2Ev: 1759| 1| : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {} _ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE9CreateKeyEv: 1793| 1| static pthread_key_t CreateKey() { 1794| 1| pthread_key_t key; 1795| | // When a thread exits, DeleteThreadLocalValue() will be called on 1796| | // the object managed for that thread. 1797| 1| GTEST_CHECK_POSIX_SUCCESS_( ------------------ | | 1092| 1| if (const int gtest_error = (posix_call)) \ | | ------------------ | | | Branch (1092:17): [True: 0, False: 1] | | ------------------ | | 1093| 1| GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error | | ------------------ | | | | 1054| 0| ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ | | | | 1055| 0| __FILE__, __LINE__) \ | | | | 1056| 0| .GetStream() | | ------------------ ------------------ 1798| 1| pthread_key_create(&key, &DeleteThreadLocalValue)); 1799| 1| return key; 1800| 1| } _ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE25DefaultValueHolderFactoryC2Ev: 1828| 1| DefaultValueHolderFactory() = default; _ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE18ValueHolderFactoryC2Ev: 1817| 1| ValueHolderFactory() = default; _ZN7testing8internal29ParseInternalRunDeathTestFlagEv: 1531| 1|InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() { 1532| 1| if (GTEST_FLAG_GET(internal_run_death_test).empty()) return nullptr; ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ | Branch (1532:7): [True: 1, False: 0] ------------------ 1533| | 1534| | // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we 1535| | // can use it here. 1536| 0| int line = -1; 1537| 0| int index = -1; 1538| 0| ::std::vector< ::std::string> fields; 1539| 0| SplitString(GTEST_FLAG_GET(internal_run_death_test), '|', &fields); ------------------ | | 2293| 0|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 1540| 0| int write_fd = -1; 1541| | 1542| |#ifdef GTEST_OS_WINDOWS 1543| | 1544| | unsigned int parent_process_id = 0; 1545| | size_t write_handle_as_size_t = 0; 1546| | size_t event_handle_as_size_t = 0; 1547| | 1548| | if (fields.size() != 6 || !ParseNaturalNumber(fields[1], &line) || 1549| | !ParseNaturalNumber(fields[2], &index) || 1550| | !ParseNaturalNumber(fields[3], &parent_process_id) || 1551| | !ParseNaturalNumber(fields[4], &write_handle_as_size_t) || 1552| | !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) { 1553| | DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + 1554| | GTEST_FLAG_GET(internal_run_death_test)); 1555| | } 1556| | write_fd = GetStatusFileDescriptor(parent_process_id, write_handle_as_size_t, 1557| | event_handle_as_size_t); 1558| | 1559| |#elif defined(GTEST_OS_FUCHSIA) 1560| | 1561| | if (fields.size() != 3 || !ParseNaturalNumber(fields[1], &line) || 1562| | !ParseNaturalNumber(fields[2], &index)) { 1563| | DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + 1564| | GTEST_FLAG_GET(internal_run_death_test)); 1565| | } 1566| | 1567| |#else 1568| | 1569| 0| if (fields.size() != 4 || !ParseNaturalNumber(fields[1], &line) || ------------------ | Branch (1569:7): [True: 0, False: 0] | Branch (1569:29): [True: 0, False: 0] ------------------ 1570| 0| !ParseNaturalNumber(fields[2], &index) || ------------------ | Branch (1570:7): [True: 0, False: 0] ------------------ 1571| 0| !ParseNaturalNumber(fields[3], &write_fd)) { ------------------ | Branch (1571:7): [True: 0, False: 0] ------------------ 1572| 0| DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + 1573| 0| GTEST_FLAG_GET(internal_run_death_test)); ------------------ | | 2293| 0|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 1574| 0| } 1575| | 1576| 0|#endif // GTEST_OS_WINDOWS 1577| | 1578| 0| return new InternalRunDeathTestFlag(fields[0], line, index, write_fd); 1579| 1|} _ZN7testing8internal8FilePath13GetCurrentDirEv: 101| 1|FilePath FilePath::GetCurrentDir() { 102| |#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \ 103| | defined(GTEST_OS_WINDOWS_RT) || defined(GTEST_OS_ESP8266) || \ 104| | defined(GTEST_OS_ESP32) || defined(GTEST_OS_XTENSA) || \ 105| | defined(GTEST_OS_QURT) || defined(GTEST_OS_NXP_QN9090) || \ 106| | defined(GTEST_OS_NRF52) 107| | // These platforms do not have a current directory, so we just return 108| | // something reasonable. 109| | return FilePath(kCurrentDirectoryString); 110| |#elif defined(GTEST_OS_WINDOWS) 111| | char cwd[GTEST_PATH_MAX_ + 1] = {'\0'}; 112| | return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd); 113| |#else 114| 1| char cwd[GTEST_PATH_MAX_ + 1] = {'\0'}; 115| 1| char* result = getcwd(cwd, sizeof(cwd)); 116| |#ifdef GTEST_OS_NACL 117| | // getcwd will likely fail in NaCl due to the sandbox, so return something 118| | // reasonable. The user may have provided a shim implementation for getcwd, 119| | // however, so fallback only when failure is detected. 120| | return FilePath(result == nullptr ? kCurrentDirectoryString : cwd); 121| |#endif // GTEST_OS_NACL 122| 1| return FilePath(result == nullptr ? "" : cwd); ------------------ | Branch (122:19): [True: 0, False: 1] ------------------ 123| 1|#endif // GTEST_OS_WINDOWS_MOBILE 124| 1|} _ZN7testing8internal8FilePath9NormalizeEv: 386| 1|void FilePath::Normalize() { 387| 1| auto out = pathname_.begin(); 388| | 389| 1| auto i = pathname_.cbegin(); 390| |#ifdef GTEST_OS_WINDOWS 391| | // UNC paths are treated specially 392| | if (pathname_.end() - i >= 3 && IsPathSeparator(*i) && 393| | IsPathSeparator(*(i + 1)) && !IsPathSeparator(*(i + 2))) { 394| | *(out++) = kPathSeparator; 395| | *(out++) = kPathSeparator; 396| | } 397| |#endif 398| 41| while (i != pathname_.end()) { ------------------ | Branch (398:10): [True: 40, False: 1] ------------------ 399| 40| const char character = *i; 400| 40| if (!IsPathSeparator(character)) { ------------------ | Branch (400:9): [True: 37, False: 3] ------------------ 401| 37| *(out++) = character; 402| 37| } else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) { ------------------ | Branch (402:16): [True: 1, False: 2] | Branch (402:16): [True: 3, False: 0] | Branch (402:44): [True: 2, False: 0] ------------------ 403| 3| *(out++) = kPathSeparator; 404| 3| } 405| 40| ++i; 406| 40| } 407| | 408| 1| pathname_.erase(out, pathname_.end()); 409| 1|} gtest-all.cc:_ZN7testing8internalL15IsPathSeparatorEc: 92| 40|static bool IsPathSeparator(char c) { 93| |#if GTEST_HAS_ALT_PATH_SEP_ 94| | return (c == kPathSeparator) || (c == kAlternatePathSeparator); 95| |#else 96| 40| return c == kPathSeparator; 97| 40|#endif 98| 40|} _ZN7testing8internal15GetUnitTestImplEv: 966| 17|inline UnitTestImpl* GetUnitTestImpl() { 967| 17| return UnitTest::GetInstance()->impl(); 968| 17|} _ZN7testing8internal12UnitTestImpl17current_test_infoEv: 766| 1| TestInfo* current_test_info() { return current_test_info_; } _ZN7testing8internal12UnitTestImpl9listenersEv: 608| 6| TestEventListeners* listeners() { return &listeners_; } _ZN7testing8internal12UnitTestImpl33ignored_parameterized_test_suitesEv: 701| 1| std::set* ignored_parameterized_test_suites() { 702| 1| return &ignored_parameterized_test_suites_; 703| 1| } _ZN7testing8internal14GTestFlagSaverC2Ev: 143| 1| GTestFlagSaver() { 144| 1| also_run_disabled_tests_ = GTEST_FLAG_GET(also_run_disabled_tests); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 145| 1| break_on_failure_ = GTEST_FLAG_GET(break_on_failure); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 146| 1| catch_exceptions_ = GTEST_FLAG_GET(catch_exceptions); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 147| 1| color_ = GTEST_FLAG_GET(color); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 148| 1| death_test_style_ = GTEST_FLAG_GET(death_test_style); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 149| 1| death_test_use_fork_ = GTEST_FLAG_GET(death_test_use_fork); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 150| 1| fail_fast_ = GTEST_FLAG_GET(fail_fast); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 151| 1| filter_ = GTEST_FLAG_GET(filter); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 152| 1| internal_run_death_test_ = GTEST_FLAG_GET(internal_run_death_test); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 153| 1| list_tests_ = GTEST_FLAG_GET(list_tests); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 154| 1| output_ = GTEST_FLAG_GET(output); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 155| 1| brief_ = GTEST_FLAG_GET(brief); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 156| 1| print_time_ = GTEST_FLAG_GET(print_time); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 157| 1| print_utf8_ = GTEST_FLAG_GET(print_utf8); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 158| 1| random_seed_ = GTEST_FLAG_GET(random_seed); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 159| 1| repeat_ = GTEST_FLAG_GET(repeat); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 160| 1| recreate_environments_when_repeating_ = 161| 1| GTEST_FLAG_GET(recreate_environments_when_repeating); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 162| 1| shuffle_ = GTEST_FLAG_GET(shuffle); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 163| 1| stack_trace_depth_ = GTEST_FLAG_GET(stack_trace_depth); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 164| 1| stream_result_to_ = GTEST_FLAG_GET(stream_result_to); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 165| 1| throw_on_failure_ = GTEST_FLAG_GET(throw_on_failure); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 166| 1| } _ZNK7testing8internal12UnitTestImpl18current_test_suiteEv: 765| 1| const TestSuite* current_test_suite() const { return current_test_suite_; } _ZN7testing8internal12UnitTestImpl11AddTestInfoEPFvvES3_PNS_8TestInfoE: 674| 1| TestInfo* test_info) { 675| 1|#if GTEST_HAS_FILE_SYSTEM 676| | // In order to support thread-safe death tests, we need to 677| | // remember the original working directory when the test program 678| | // was first invoked. We cannot do this in RUN_ALL_TESTS(), as 679| | // the user may have changed the current directory before calling 680| | // RUN_ALL_TESTS(). Therefore we capture the current directory in 681| | // AddTestInfo(), which is called to register a TEST or TEST_F 682| | // before main() is reached. 683| 1| if (original_working_dir_.IsEmpty()) { ------------------ | Branch (683:9): [True: 1, False: 0] ------------------ 684| 1| original_working_dir_.Set(FilePath::GetCurrentDir()); 685| 2| GTEST_CHECK_(!original_working_dir_.IsEmpty()) ------------------ | | 1079| 1| GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ | | ------------------ | | | | 712| 2| switch (0) \ | | | | 713| 2| case 0: \ | | | | ------------------ | | | | | Branch (713:3): [True: 1, False: 0] | | | | ------------------ | | | | 714| 1| default: // NOLINT | | | | ------------------ | | | | | Branch (714:3): [True: 0, False: 1] | | | | ------------------ | | ------------------ | | 1080| 1| if (::testing::internal::IsTrue(condition)) \ | | ------------------ | | | Branch (1080:7): [True: 1, False: 0] | | ------------------ | | 1081| 1| ; \ | | 1082| 1| else \ | | 1083| 1| GTEST_LOG_(FATAL) << "Condition " #condition " failed. " | | ------------------ | | | | 1054| 0| ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ | | | | 1055| 0| __FILE__, __LINE__) \ | | | | 1056| 0| .GetStream() | | ------------------ ------------------ 686| 2| << "Failed to get the current working directory."; 687| 1| } 688| 1|#endif // GTEST_HAS_FILE_SYSTEM 689| | 690| 1| GetTestSuite(test_info->test_suite_name(), test_info->type_param(), 691| 1| set_up_tc, tear_down_tc) 692| 1| ->AddTestInfo(test_info); 693| 1| } _ZN7testing8internal12UnitTestImpl21set_current_test_infoEPNS_8TestInfoE: 720| 1| void set_current_test_info(TestInfo* a_current_test_info) { 721| 1| current_test_info_ = a_current_test_info; 722| 1| } _ZN7testing8internal12UnitTestImpl22set_current_test_suiteEPNS_9TestSuiteE: 713| 1| void set_current_test_suite(TestSuite* a_current_test_suite) { 714| 1| current_test_suite_ = a_current_test_suite; 715| 1| } _ZNK7testing8internal12UnitTestImpl12GetTestSuiteEi: 590| 3| const TestSuite* GetTestSuite(int i) const { 591| 3| const int index = GetElementOr(test_suite_indices_, i, -1); 592| 3| return index < 0 ? nullptr : test_suites_[static_cast(i)]; ------------------ | Branch (592:12): [True: 0, False: 3] ------------------ 593| 3| } _ZN7testing8internal12UnitTestImpl19GetMutableSuiteCaseEi: 602| 1| TestSuite* GetMutableSuiteCase(int i) { 603| 1| const int index = GetElementOr(test_suite_indices_, i, -1); 604| 1| return index < 0 ? nullptr : test_suites_[static_cast(index)]; ------------------ | Branch (604:12): [True: 0, False: 1] ------------------ 605| 1| } _ZN7testing8internal12UnitTestImpl20set_catch_exceptionsEb: 842| 1| void set_catch_exceptions(bool value) { catch_exceptions_ = value; } _ZN7testing8internal12UnitTestImpl34InitDeathTestSubprocessControlInfoEv: 782| 1| void InitDeathTestSubprocessControlInfo() { 783| 1| internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag()); 784| 1| } _ZN7testing8internal21GetRandomSeedFromFlagEi: 113| 1|inline int GetRandomSeedFromFlag(int32_t random_seed_flag) { 114| 1| const unsigned int raw_seed = 115| 1| (random_seed_flag == 0) ? static_cast(GetTimeInMillis()) ------------------ | Branch (115:7): [True: 1, False: 0] ------------------ 116| 1| : static_cast(random_seed_flag); 117| | 118| | // Normalizes the actual seed to range [1, kMaxRandomSeed] such that 119| | // it's easy to type. 120| 1| const int normalized_seed = 121| 1| static_cast((raw_seed - 1U) % 122| 1| static_cast(kMaxRandomSeed)) + 123| 1| 1; 124| 1| return normalized_seed; 125| 1|} _ZN7testing8internal12UnitTestImpl23ClearNonAdHocTestResultEv: 739| 1| void ClearNonAdHocTestResult() { 740| 1| ForEach(test_suites_, TestSuite::ClearTestSuiteResult); 741| 1| } _ZN7testing8internal18OsStackTraceGetterC2Ev: 439| 1| OsStackTraceGetter() = default; _ZN7testing8internal27OsStackTraceGetterInterfaceC2Ev: 410| 1| OsStackTraceGetterInterface() = default; _ZN7testing8internal12GetElementOrIiEET_RKNSt3__16vectorIS2_NS3_9allocatorIS2_EEEEiS2_: 294| 6|inline E GetElementOr(const std::vector& v, int i, E default_value) { 295| 6| return (i < 0 || i >= static_cast(v.size())) ? default_value ------------------ | Branch (295:11): [True: 0, False: 6] | Branch (295:20): [True: 0, False: 6] ------------------ 296| 6| : v[static_cast(i)]; 297| 6|} _ZN7testing8internal7ForEachINSt3__16vectorIPNS_9TestSuiteENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_: 287| 1|void ForEach(const Container& c, Functor functor) { 288| 1| std::for_each(c.begin(), c.end(), functor); 289| 1|} _ZN7testing8internal7CountIfINSt3__16vectorIPNS_9TestSuiteENS2_9allocatorIS5_EEEEPFbPKS4_EEEiRKT_T0_: 275| 1|inline int CountIf(const Container& c, Predicate predicate) { 276| | // Implemented as an explicit loop since std::count_if() in libCstd on 277| | // Solaris has a non-standard signature. 278| 1| int count = 0; 279| 2| for (auto it = c.begin(); it != c.end(); ++it) { ------------------ | Branch (279:29): [True: 1, False: 1] ------------------ 280| 1| if (predicate(*it)) ++count; ------------------ | Branch (280:9): [True: 1, False: 0] ------------------ 281| 1| } 282| 1| return count; 283| 1|} _ZN7testing8internal7CountIfINSt3__16vectorINS_14TestPartResultENS2_9allocatorIS4_EEEEPFbRKS4_EEEiRKT_T0_: 275| 7|inline int CountIf(const Container& c, Predicate predicate) { 276| | // Implemented as an explicit loop since std::count_if() in libCstd on 277| | // Solaris has a non-standard signature. 278| 7| int count = 0; 279| 7| for (auto it = c.begin(); it != c.end(); ++it) { ------------------ | Branch (279:29): [True: 0, False: 7] ------------------ 280| 0| if (predicate(*it)) ++count; ------------------ | Branch (280:9): [True: 0, False: 0] ------------------ 281| 0| } 282| 7| return count; 283| 7|} _ZNK7testing8internal12UnitTestImpl16catch_exceptionsEv: 835| 5| bool catch_exceptions() const { return catch_exceptions_; } _ZN7testing8internal7CountIfINSt3__16vectorIPNS_8TestInfoENS2_9allocatorIS5_EEEEPFbPKS4_EEEiRKT_T0_: 275| 2|inline int CountIf(const Container& c, Predicate predicate) { 276| | // Implemented as an explicit loop since std::count_if() in libCstd on 277| | // Solaris has a non-standard signature. 278| 2| int count = 0; 279| 4| for (auto it = c.begin(); it != c.end(); ++it) { ------------------ | Branch (279:29): [True: 2, False: 2] ------------------ 280| 2| if (predicate(*it)) ++count; ------------------ | Branch (280:9): [True: 2, False: 0] ------------------ 281| 2| } 282| 2| return count; 283| 2|} _ZN7testing8internal7ForEachINSt3__16vectorIPNS_8TestInfoENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_: 287| 1|void ForEach(const Container& c, Functor functor) { 288| 1| std::for_each(c.begin(), c.end(), functor); 289| 1|} _ZN7testing8internal7ForEachINSt3__16vectorIPNS_11EnvironmentENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_: 287| 1|void ForEach(const Container& c, Functor functor) { 288| 1| std::for_each(c.begin(), c.end(), functor); 289| 1|} _ZN7testing8internal16BoolFromGTestEnvEPKcb: 1324| 12|bool BoolFromGTestEnv(const char* flag, bool default_value) { 1325| |#if defined(GTEST_GET_BOOL_FROM_ENV_) 1326| | return GTEST_GET_BOOL_FROM_ENV_(flag, default_value); 1327| |#else 1328| 12| const std::string env_var = FlagToEnvVar(flag); 1329| 12| const char* const string_value = posix::GetEnv(env_var.c_str()); 1330| 12| return string_value == nullptr ? default_value ------------------ | Branch (1330:10): [True: 12, False: 0] ------------------ 1331| 12| : strcmp(string_value, "0") != 0; 1332| 12|#endif // defined(GTEST_GET_BOOL_FROM_ENV_) 1333| 12|} _ZN7testing8internal17Int32FromGTestEnvEPKci: 1338| 3|int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) { 1339| |#if defined(GTEST_GET_INT32_FROM_ENV_) 1340| | return GTEST_GET_INT32_FROM_ENV_(flag, default_value); 1341| |#else 1342| 3| const std::string env_var = FlagToEnvVar(flag); 1343| 3| const char* const string_value = posix::GetEnv(env_var.c_str()); 1344| 3| if (string_value == nullptr) { ------------------ | Branch (1344:7): [True: 3, False: 0] ------------------ 1345| | // The environment variable is not set. 1346| 3| return default_value; 1347| 3| } 1348| | 1349| 0| int32_t result = default_value; 1350| 0| if (!ParseInt32(Message() << "Environment variable " << env_var, string_value, ------------------ | Branch (1350:7): [True: 0, False: 0] ------------------ 1351| 0| &result)) { 1352| 0| printf("The default value %s is used.\n", 1353| 0| (Message() << default_value).GetString().c_str()); 1354| 0| fflush(stdout); 1355| 0| return default_value; 1356| 0| } 1357| | 1358| 0| return result; 1359| 0|#endif // defined(GTEST_GET_INT32_FROM_ENV_) 1360| 0|} _ZN7testing8internal25OutputFlagAlsoCheckEnvVarEv: 1370| 1|std::string OutputFlagAlsoCheckEnvVar() { 1371| 1| std::string default_value_for_output_flag = ""; 1372| 1| const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE"); 1373| 1| if (nullptr != xml_output_file_env) { ------------------ | Branch (1373:7): [True: 0, False: 1] ------------------ 1374| 0| default_value_for_output_flag = std::string("xml:") + xml_output_file_env; 1375| 0| } 1376| 1| return default_value_for_output_flag; 1377| 1|} _ZN7testing8internal18StringFromGTestEnvEPKcS2_: 1381| 6|const char* StringFromGTestEnv(const char* flag, const char* default_value) { 1382| |#if defined(GTEST_GET_STRING_FROM_ENV_) 1383| | return GTEST_GET_STRING_FROM_ENV_(flag, default_value); 1384| |#else 1385| 6| const std::string env_var = FlagToEnvVar(flag); 1386| 6| const char* const value = posix::GetEnv(env_var.c_str()); 1387| 6| return value == nullptr ? default_value : value; ------------------ | Branch (1387:10): [True: 6, False: 0] ------------------ 1388| 6|#endif // defined(GTEST_GET_STRING_FROM_ENV_) 1389| 6|} gtest-all.cc:_ZN7testing8internalL12FlagToEnvVarEPKc: 1267| 21|static std::string FlagToEnvVar(const char* flag) { 1268| 21| const std::string full_flag = 1269| 21| (Message() << GTEST_FLAG_PREFIX_ << flag).GetString(); ------------------ | | 331| 21|#define GTEST_FLAG_PREFIX_ "gtest_" ------------------ 1270| | 1271| 21| Message env_var; 1272| 435| for (size_t i = 0; i != full_flag.length(); i++) { ------------------ | Branch (1272:22): [True: 414, False: 21] ------------------ 1273| 414| env_var << ToUpper(full_flag.c_str()[i]); 1274| 414| } 1275| | 1276| 21| return env_var.GetString(); 1277| 21|} _ZN7testing8internal33GetIgnoredParameterizedTestSuitesEv: 502| 1|std::set* GetIgnoredParameterizedTestSuites() { 503| 1| return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites(); 504| 1|} _ZN7testing8internal34TypeParameterizedTestSuiteRegistry22CheckForInstantiationsEv: 585| 1|void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() { 586| 1| const auto& ignored = *GetIgnoredParameterizedTestSuites(); 587| 1| for (const auto& testcase : suites_) { ------------------ | Branch (587:29): [True: 0, False: 1] ------------------ 588| 0| if (testcase.second.instantiated) continue; ------------------ | Branch (588:9): [True: 0, False: 0] ------------------ 589| 0| if (ignored.find(testcase.first) != ignored.end()) continue; ------------------ | Branch (589:9): [True: 0, False: 0] ------------------ 590| | 591| 0| std::string message = 592| 0| "Type parameterized test suite " + testcase.first + 593| 0| " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated " 594| 0| "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run." 595| 0| "\n\n" 596| 0| "Ideally, TYPED_TEST_P definitions should only ever be included as " 597| 0| "part of binaries that intend to use them. (As opposed to, for " 598| 0| "example, being placed in a library that may be linked in to get other " 599| 0| "utilities.)" 600| 0| "\n\n" 601| 0| "To suppress this error for this test suite, insert the following line " 602| 0| "(in a non-header) in the namespace it is defined in:" 603| 0| "\n\n" 604| 0| "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + 605| 0| testcase.first + ");"; 606| | 607| 0| std::string full_name = 608| 0| "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">"; 609| 0| RegisterTest( // 610| 0| "GoogleTestVerification", full_name.c_str(), 611| 0| nullptr, // No type parameter. 612| 0| nullptr, // No value parameter. 613| 0| testcase.second.code_location.file.c_str(), 614| 0| testcase.second.code_location.line, [message, testcase] { 615| 0| return new FailureTest(testcase.second.code_location, message, 616| 0| kErrorOnUninstantiatedTypeParameterizedTest); 617| 0| }); 618| 0| } 619| 1|} _ZN7testing8internal8GetArgvsEv: 624| 2|::std::vector GetArgvs() { 625| |#if defined(GTEST_CUSTOM_GET_ARGVS_) 626| | // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or 627| | // ::string. This code converts it to the appropriate type. 628| | const auto& custom = GTEST_CUSTOM_GET_ARGVS_(); 629| | return ::std::vector(custom.begin(), custom.end()); 630| |#else // defined(GTEST_CUSTOM_GET_ARGVS_) 631| 2| return g_argvs; 632| 2|#endif // defined(GTEST_CUSTOM_GET_ARGVS_) 633| 2|} _ZN7testing8internal15UnitTestOptions15GetOutputFormatEv: 654| 1|std::string UnitTestOptions::GetOutputFormat() { 655| 1| std::string s = GTEST_FLAG_GET(output); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 656| 1| const char* const gtest_output_flag = s.c_str(); 657| 1| const char* const colon = strchr(gtest_output_flag, ':'); 658| 1| return (colon == nullptr) ------------------ | Branch (658:10): [True: 1, False: 0] ------------------ 659| 1| ? std::string(gtest_output_flag) 660| 1| : std::string(gtest_output_flag, 661| 0| static_cast(colon - gtest_output_flag)); 662| 1|} _ZN7testing8internal13GetTestTypeIdEv: 962| 1|TypeId GetTestTypeId() { return GetTypeId(); } _ZN7testing8internal35DefaultGlobalTestPartResultReporterC2EPNS0_12UnitTestImplE: 1025| 1| : unit_test_(unit_test) {} _ZN7testing8internal38DefaultPerThreadTestPartResultReporterC2EPNS0_12UnitTestImplE: 1035| 1| : unit_test_(unit_test) {} _ZNK7testing8internal12UnitTestImpl22total_test_suite_countEv: 1079| 3|int UnitTestImpl::total_test_suite_count() const { 1080| 3| return static_cast(test_suites_.size()); 1081| 3|} _ZNK7testing8internal12UnitTestImpl23test_suite_to_run_countEv: 1085| 1|int UnitTestImpl::test_suite_to_run_count() const { 1086| 1| return CountIf(test_suites_, ShouldRunTestSuite); 1087| 1|} _ZNK7testing8internal12UnitTestImpl17test_to_run_countEv: 1126| 1|int UnitTestImpl::test_to_run_count() const { 1127| 1| return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count); 1128| 1|} _ZN7testing8internal15GetTimeInMillisEv: 1174| 4|TimeInMillis GetTimeInMillis() { 1175| 4| return std::chrono::duration_cast( 1176| 4| std::chrono::system_clock::now() - 1177| 4| std::chrono::system_clock::from_time_t(0)) 1178| 4| .count(); 1179| 4|} _ZN7testing8internal6String13CStringEqualsEPKcS3_: 1224| 1|bool String::CStringEquals(const char* lhs, const char* rhs) { 1225| 1| if (lhs == nullptr) return rhs == nullptr; ------------------ | Branch (1225:7): [True: 0, False: 1] ------------------ 1226| | 1227| 1| if (rhs == nullptr) return false; ------------------ | Branch (1227:7): [True: 0, False: 1] ------------------ 1228| | 1229| 1| return strcmp(lhs, rhs) == 0; 1230| 1|} _ZN7testing8internal11SplitStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEcPNS1_6vectorIS7_NS5_IS7_EEEE: 1252| 4| ::std::vector< ::std::string>* dest) { 1253| 4| ::std::vector< ::std::string> parsed; 1254| 4| ::std::string::size_type pos = 0; 1255| 6| while (::testing::internal::AlwaysTrue()) { ------------------ | Branch (1255:10): [True: 6, False: 0] ------------------ 1256| 6| const ::std::string::size_type colon = str.find(delimiter, pos); 1257| 6| if (colon == ::std::string::npos) { ------------------ | Branch (1257:9): [True: 4, False: 2] ------------------ 1258| 4| parsed.push_back(str.substr(pos)); 1259| 4| break; 1260| 4| } else { 1261| 2| parsed.push_back(str.substr(pos, colon - pos)); 1262| 2| pos = colon + 1; 1263| 2| } 1264| 6| } 1265| 4| dest->swap(parsed); 1266| 4|} _ZN7testing7MessageC2Ev: 1275| 60|Message::Message() : ss_(new ::std::stringstream) { 1276| | // By default, we want there to be enough precision when printing 1277| | // a double to a Message. 1278| 60| *ss_ << std::setprecision(std::numeric_limits::digits10 + 2); 1279| 60|} _ZNK7testing7Message9GetStringEv: 1301| 60|std::string Message::GetString() const { 1302| 60| return internal::StringStreamToString(ss_.get()); 1303| 60|} _ZN7testing8internal6String28CaseInsensitiveCStringEqualsEPKcS3_: 2131| 1|bool String::CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) { 2132| 1| if (lhs == nullptr) return rhs == nullptr; ------------------ | Branch (2132:7): [True: 0, False: 1] ------------------ 2133| 1| if (rhs == nullptr) return false; ------------------ | Branch (2133:7): [True: 0, False: 1] ------------------ 2134| 1| return posix::StrCaseCmp(lhs, rhs) == 0; 2135| 1|} _ZN7testing8internal20StringStreamToStringEPNSt3__118basic_stringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 2216| 60|std::string StringStreamToString(::std::stringstream* ss) { 2217| 60| const ::std::string& str = ss->str(); 2218| 60| const char* const start = str.c_str(); 2219| 60| const char* const end = start + str.length(); 2220| | 2221| 60| std::string result; 2222| 60| result.reserve(static_cast(2 * (end - start))); 2223| 1.48k| for (const char* ch = start; ch != end; ++ch) { ------------------ | Branch (2223:32): [True: 1.42k, False: 60] ------------------ 2224| 1.42k| if (*ch == '\0') { ------------------ | Branch (2224:9): [True: 0, False: 1.42k] ------------------ 2225| 0| result += "\\0"; // Replaces NUL with "\\0"; 2226| 1.42k| } else { 2227| 1.42k| result += *ch; 2228| 1.42k| } 2229| 1.42k| } 2230| | 2231| 60| return result; 2232| 60|} _ZN7testing10TestResultC2Ev: 2254| 3| : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {} _ZN7testing10TestResult5ClearEv: 2400| 2|void TestResult::Clear() { 2401| 2| test_part_results_.clear(); 2402| 2| test_properties_.clear(); 2403| 2| death_test_count_ = 0; 2404| 2| elapsed_time_ = 0; 2405| 2|} _ZNK7testing10TestResult7SkippedEv: 2413| 4|bool TestResult::Skipped() const { 2414| 4| return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0; ------------------ | Branch (2414:10): [True: 4, False: 0] | Branch (2414:23): [True: 0, False: 4] ------------------ 2415| 4|} _ZNK7testing10TestResult6FailedEv: 2418| 5|bool TestResult::Failed() const { 2419| 5| for (int i = 0; i < total_part_count(); ++i) { ------------------ | Branch (2419:19): [True: 0, False: 5] ------------------ 2420| 0| if (GetTestPartResult(i).failed()) return true; ------------------ | Branch (2420:9): [True: 0, False: 0] ------------------ 2421| 0| } 2422| 5| return false; 2423| 5|} _ZNK7testing10TestResult15HasFatalFailureEv: 2431| 3|bool TestResult::HasFatalFailure() const { 2432| 3| return CountIf(test_part_results_, TestPartFatallyFailed) > 0; 2433| 3|} _ZNK7testing10TestResult16total_part_countEv: 2447| 5|int TestResult::total_part_count() const { 2448| 5| return static_cast(test_part_results_.size()); 2449| 5|} _ZN7testing4TestC2Ev: 2461| 1|Test::Test() : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {} ------------------ | | 2291| 1|#define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver ------------------ _ZN7testing4Test5SetUpEv: 2471| 1|void Test::SetUp() {} _ZN7testing4Test19HasSameFixtureClassEv: 2504| 1|bool Test::HasSameFixtureClass() { 2505| 1| internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 2506| 1| const TestSuite* const test_suite = impl->current_test_suite(); 2507| | 2508| | // Info about the first test in the current test suite. 2509| 1| const TestInfo* const first_test_info = test_suite->test_info_list()[0]; 2510| 1| const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_; 2511| 1| const char* const first_test_name = first_test_info->name(); 2512| | 2513| | // Info about the current test. 2514| 1| const TestInfo* const this_test_info = impl->current_test_info(); 2515| 1| const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_; 2516| 1| const char* const this_test_name = this_test_info->name(); 2517| | 2518| 1| if (this_fixture_id != first_fixture_id) { ------------------ | Branch (2518:7): [True: 0, False: 1] ------------------ 2519| | // Is the first test defined using TEST? 2520| 0| const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId(); 2521| | // Is this test defined using TEST? 2522| 0| const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId(); 2523| | 2524| 0| if (first_is_TEST || this_is_TEST) { ------------------ | Branch (2524:9): [True: 0, False: 0] | Branch (2524:26): [True: 0, False: 0] ------------------ 2525| | // Both TEST and TEST_F appear in same test suite, which is incorrect. 2526| | // Tell the user how to fix this. 2527| | 2528| | // Gets the name of the TEST and the name of the TEST_F. Note 2529| | // that first_is_TEST and this_is_TEST cannot both be true, as 2530| | // the fixture IDs are different for the two tests. 2531| 0| const char* const TEST_name = 2532| 0| first_is_TEST ? first_test_name : this_test_name; ------------------ | Branch (2532:11): [True: 0, False: 0] ------------------ 2533| 0| const char* const TEST_F_name = 2534| 0| first_is_TEST ? this_test_name : first_test_name; ------------------ | Branch (2534:11): [True: 0, False: 0] ------------------ 2535| | 2536| 0| ADD_FAILURE() ------------------ | | 1735| 0|#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed") | | ------------------ | | | | 1339| 0| GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure) | | | | ------------------ | | | | | | 1333| 0| GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type) | | | | | | ------------------ | | | | | | | | 1329| 0| ::testing::internal::AssertHelper(result_type, file, line, message) = \ | | | | | | | | 1330| 0| ::testing::Message() | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2537| 0| << "All tests in the same test suite must use the same test fixture\n" 2538| 0| << "class, so mixing TEST_F and TEST in the same test suite is\n" 2539| 0| << "illegal. In test suite " << this_test_info->test_suite_name() 2540| 0| << ",\n" 2541| 0| << "test " << TEST_F_name << " is defined using TEST_F but\n" 2542| 0| << "test " << TEST_name << " is defined using TEST. You probably\n" 2543| 0| << "want to change the TEST to TEST_F or move it to another test\n" 2544| 0| << "case."; 2545| 0| } else { 2546| | // Two fixture classes with the same name appear in two different 2547| | // namespaces, which is not allowed. Tell the user how to fix this. 2548| 0| ADD_FAILURE() ------------------ | | 1735| 0|#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed") | | ------------------ | | | | 1339| 0| GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure) | | | | ------------------ | | | | | | 1333| 0| GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type) | | | | | | ------------------ | | | | | | | | 1329| 0| ::testing::internal::AssertHelper(result_type, file, line, message) = \ | | | | | | | | 1330| 0| ::testing::Message() | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2549| 0| << "All tests in the same test suite must use the same test fixture\n" 2550| 0| << "class. However, in test suite " 2551| 0| << this_test_info->test_suite_name() << ",\n" 2552| 0| << "you defined test " << first_test_name << " and test " 2553| 0| << this_test_name << "\n" 2554| 0| << "using two different test fixture classes. This can happen if\n" 2555| 0| << "the two classes are from different namespaces or translation\n" 2556| 0| << "units and have the same name. You should probably rename one\n" 2557| 0| << "of the classes to put the tests into different test suites."; 2558| 0| } 2559| 0| return false; 2560| 0| } 2561| | 2562| 1| return true; 2563| 1|} _ZN7testing4Test3RunEv: 2677| 1|void Test::Run() { 2678| 1| if (!HasSameFixtureClass()) return; ------------------ | Branch (2678:7): [True: 0, False: 1] ------------------ 2679| | 2680| 1| internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 2681| 1| impl->os_stack_trace_getter()->UponLeavingGTest(); 2682| 1| internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()"); 2683| | // We will run the test only if SetUp() was successful and didn't call 2684| | // GTEST_SKIP(). 2685| 1| if (!HasFatalFailure() && !IsSkipped()) { ------------------ | Branch (2685:7): [True: 1, False: 0] | Branch (2685:29): [True: 1, False: 0] ------------------ 2686| 1| impl->os_stack_trace_getter()->UponLeavingGTest(); 2687| 1| internal::HandleExceptionsInMethodIfSupported(this, &Test::TestBody, 2688| 1| "the test body"); 2689| 1| } 2690| | 2691| | // However, we want to clean up as much as possible. Hence we will 2692| | // always call TearDown(), even if SetUp() or the test body has 2693| | // failed. 2694| 1| impl->os_stack_trace_getter()->UponLeavingGTest(); 2695| 1| internal::HandleExceptionsInMethodIfSupported(this, &Test::TearDown, 2696| 1| "TearDown()"); 2697| 1|} _ZN7testing4Test15HasFatalFailureEv: 2700| 3|bool Test::HasFatalFailure() { 2701| 3| return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure(); 2702| 3|} _ZN7testing4Test9IsSkippedEv: 2712| 3|bool Test::IsSkipped() { 2713| 3| return internal::GetUnitTestImpl()->current_test_result()->Skipped(); 2714| 3|} _ZN7testing8TestInfoC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_PKcSB_NS_8internal12CodeLocationEPKvPNSC_15TestFactoryBaseE: 2726| 1| : test_suite_name_(a_test_suite_name), 2727| | // begin()/end() is MSVC 17.3.3 ASAN crash workaround (GitHub issue #3997) 2728| 1| name_(a_name.begin(), a_name.end()), 2729| 1| type_param_(a_type_param ? new std::string(a_type_param) : nullptr), ------------------ | Branch (2729:19): [True: 0, False: 1] ------------------ 2730| 1| value_param_(a_value_param ? new std::string(a_value_param) : nullptr), ------------------ | Branch (2730:20): [True: 0, False: 1] ------------------ 2731| 1| location_(a_code_location), 2732| 1| fixture_class_id_(fixture_class_id), 2733| 1| should_run_(false), 2734| 1| is_disabled_(false), 2735| 1| matches_filter_(false), 2736| 1| is_in_another_shard_(false), 2737| 1| factory_(factory), 2738| 1| result_() {} _ZN7testing8internal23MakeAndRegisterTestInfoEPKcS2_S2_S2_NS0_12CodeLocationEPKvPFvvES7_PNS0_15TestFactoryBaseE: 2767| 1| TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) { 2768| 1| TestInfo* const test_info = 2769| 1| new TestInfo(test_suite_name, name, type_param, value_param, 2770| 1| code_location, fixture_class_id, factory); 2771| 1| GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info); 2772| 1| return test_info; 2773| 1|} _ZN7testing8internal12UnitTestImpl26RegisterParameterizedTestsEv: 2796| 1|void UnitTestImpl::RegisterParameterizedTests() { 2797| 1| if (!parameterized_tests_registered_) { ------------------ | Branch (2797:7): [True: 1, False: 0] ------------------ 2798| 1| parameterized_test_registry_.RegisterTests(); 2799| 1| type_parameterized_test_registry_.CheckForInstantiations(); 2800| 1| parameterized_tests_registered_ = true; 2801| 1| } 2802| 1|} _ZN7testing8TestInfo3RunEv: 2808| 1|void TestInfo::Run() { 2809| 1| TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); 2810| 1| if (!should_run_) { ------------------ | Branch (2810:7): [True: 0, False: 1] ------------------ 2811| 0| if (is_disabled_ && matches_filter_) repeater->OnTestDisabled(*this); ------------------ | Branch (2811:9): [True: 0, False: 0] | Branch (2811:25): [True: 0, False: 0] ------------------ 2812| 0| return; 2813| 0| } 2814| | 2815| | // Tells UnitTest where to store test result. 2816| 1| internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 2817| 1| impl->set_current_test_info(this); 2818| | 2819| | // Notifies the unit test event listeners that a test is about to start. 2820| 1| repeater->OnTestStart(*this); 2821| 1| result_.set_start_timestamp(internal::GetTimeInMillis()); 2822| 1| internal::Timer timer; 2823| 1| impl->os_stack_trace_getter()->UponLeavingGTest(); 2824| | 2825| | // Creates the test object. 2826| 1| Test* const test = internal::HandleExceptionsInMethodIfSupported( 2827| 1| factory_, &internal::TestFactoryBase::CreateTest, 2828| 1| "the test fixture's constructor"); 2829| | 2830| | // Runs the test if the constructor didn't generate a fatal failure or invoke 2831| | // GTEST_SKIP(). 2832| | // Note that the object will not be null 2833| 1| if (!Test::HasFatalFailure() && !Test::IsSkipped()) { ------------------ | Branch (2833:7): [True: 1, False: 0] | Branch (2833:35): [True: 1, False: 0] ------------------ 2834| | // This doesn't throw as all user code that can throw are wrapped into 2835| | // exception handling code. 2836| 1| test->Run(); 2837| 1| } 2838| | 2839| 1| if (test != nullptr) { ------------------ | Branch (2839:7): [True: 0, False: 1] ------------------ 2840| | // Deletes the test object. 2841| 0| impl->os_stack_trace_getter()->UponLeavingGTest(); 2842| 0| internal::HandleExceptionsInMethodIfSupported( 2843| 0| test, &Test::DeleteSelf_, "the test fixture's destructor"); 2844| 0| } 2845| | 2846| 1| result_.set_elapsed_time(timer.Elapsed()); 2847| | 2848| | // Notifies the unit test event listener that a test has just finished. 2849| 1| repeater->OnTestEnd(*this); 2850| | 2851| | // Tells UnitTest to stop associating assertion results to this 2852| | // test. 2853| 1| impl->set_current_test_info(nullptr); 2854| 1|} _ZNK7testing9TestSuite17test_to_run_countEv: 2911| 2|int TestSuite::test_to_run_count() const { 2912| 2| return CountIf(test_info_list_, ShouldRunTest); 2913| 2|} _ZNK7testing9TestSuite16total_test_countEv: 2916| 3|int TestSuite::total_test_count() const { 2917| 3| return static_cast(test_info_list_.size()); 2918| 3|} _ZN7testing9TestSuiteC2EPKcS2_PFvvES4_: 2932| 1| : name_(a_name), 2933| 1| type_param_(a_type_param ? new std::string(a_type_param) : nullptr), ------------------ | Branch (2933:19): [True: 0, False: 1] ------------------ 2934| 1| set_up_tc_(set_up_tc), 2935| 1| tear_down_tc_(tear_down_tc), 2936| 1| should_run_(false), 2937| 1| start_timestamp_(0), 2938| 1| elapsed_time_(0) {} _ZNK7testing9TestSuite11GetTestInfoEi: 2948| 1|const TestInfo* TestSuite::GetTestInfo(int i) const { 2949| 1| const int index = GetElementOr(test_indices_, i, -1); 2950| 1| return index < 0 ? nullptr : test_info_list_[static_cast(index)]; ------------------ | Branch (2950:10): [True: 0, False: 1] ------------------ 2951| 1|} _ZN7testing9TestSuite18GetMutableTestInfoEi: 2955| 1|TestInfo* TestSuite::GetMutableTestInfo(int i) { 2956| 1| const int index = GetElementOr(test_indices_, i, -1); 2957| 1| return index < 0 ? nullptr : test_info_list_[static_cast(index)]; ------------------ | Branch (2957:10): [True: 0, False: 1] ------------------ 2958| 1|} _ZN7testing9TestSuite11AddTestInfoEPNS_8TestInfoE: 2962| 1|void TestSuite::AddTestInfo(TestInfo* test_info) { 2963| 1| test_info_list_.push_back(test_info); 2964| 1| test_indices_.push_back(static_cast(test_indices_.size())); 2965| 1|} _ZN7testing9TestSuite3RunEv: 2968| 1|void TestSuite::Run() { 2969| 1| if (!should_run_) return; ------------------ | Branch (2969:7): [True: 0, False: 1] ------------------ 2970| | 2971| 1| internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); 2972| 1| impl->set_current_test_suite(this); 2973| | 2974| 1| TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); 2975| | 2976| | // Ensure our tests are in a deterministic order. 2977| | // 2978| | // We do this by sorting lexicographically on (file, line number), providing 2979| | // an order matching what the user can see in the source code. 2980| | // 2981| | // In the common case the line number comparison shouldn't be necessary, 2982| | // because the registrations made by the TEST macro are executed in order 2983| | // within a translation unit. But this is not true of the manual registration 2984| | // API, and in more exotic scenarios a single file may be part of multiple 2985| | // translation units. 2986| 1| std::stable_sort(test_info_list_.begin(), test_info_list_.end(), 2987| 1| [](const TestInfo* const a, const TestInfo* const b) { 2988| 1| if (const int result = std::strcmp(a->file(), b->file())) { 2989| 1| return result < 0; 2990| 1| } 2991| | 2992| 1| return a->line() < b->line(); 2993| 1| }); 2994| | 2995| | // Call both legacy and the new API 2996| 1| repeater->OnTestSuiteStart(*this); 2997| |// Legacy API is deprecated but still available 2998| 1|#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 2999| 1| repeater->OnTestCaseStart(*this); 3000| 1|#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 3001| | 3002| 1| impl->os_stack_trace_getter()->UponLeavingGTest(); 3003| 1| internal::HandleExceptionsInMethodIfSupported( 3004| 1| this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()"); 3005| | 3006| 1| const bool skip_all = 3007| 1| ad_hoc_test_result().Failed() || ad_hoc_test_result().Skipped(); ------------------ | Branch (3007:7): [True: 0, False: 1] | Branch (3007:40): [True: 0, False: 1] ------------------ 3008| | 3009| 1| start_timestamp_ = internal::GetTimeInMillis(); 3010| 1| internal::Timer timer; 3011| 2| for (int i = 0; i < total_test_count(); i++) { ------------------ | Branch (3011:19): [True: 1, False: 1] ------------------ 3012| 1| if (skip_all) { ------------------ | Branch (3012:9): [True: 0, False: 1] ------------------ 3013| 0| GetMutableTestInfo(i)->Skip(); 3014| 1| } else { 3015| 1| GetMutableTestInfo(i)->Run(); 3016| 1| } 3017| 1| if (GTEST_FLAG_GET(fail_fast) && ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ | | | Branch (2293:30): [True: 0, False: 1] | | ------------------ ------------------ 3018| 0| GetMutableTestInfo(i)->result()->Failed()) { ------------------ | Branch (3018:9): [True: 0, False: 0] ------------------ 3019| 0| for (int j = i + 1; j < total_test_count(); j++) { ------------------ | Branch (3019:27): [True: 0, False: 0] ------------------ 3020| 0| GetMutableTestInfo(j)->Skip(); 3021| 0| } 3022| 0| break; 3023| 0| } 3024| 1| } 3025| 1| elapsed_time_ = timer.Elapsed(); 3026| | 3027| 1| impl->os_stack_trace_getter()->UponLeavingGTest(); 3028| 1| internal::HandleExceptionsInMethodIfSupported( 3029| 1| this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()"); 3030| | 3031| | // Call both legacy and the new API 3032| 1| repeater->OnTestSuiteEnd(*this); 3033| |// Legacy API is deprecated but still available 3034| 1|#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 3035| 1| repeater->OnTestCaseEnd(*this); 3036| 1|#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 3037| | 3038| 1| impl->set_current_test_suite(nullptr); 3039| 1|} _ZN7testing9TestSuite11ClearResultEv: 3072| 1|void TestSuite::ClearResult() { 3073| 1| ad_hoc_test_result_.Clear(); 3074| 1| ForEach(test_info_list_, TestInfo::ClearTestResult); 3075| 1|} _ZN7testing8internal14ShouldUseColorEb: 3238| 1|bool ShouldUseColor(bool stdout_is_tty) { 3239| 1| std::string c = GTEST_FLAG_GET(color); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 3240| 1| const char* const gtest_color = c.c_str(); 3241| | 3242| 1| if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) { ------------------ | Branch (3242:7): [True: 1, False: 0] ------------------ 3243| |#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW) 3244| | // On Windows the TERM variable is usually not set, but the 3245| | // console there does support colors. 3246| | return stdout_is_tty; 3247| |#else 3248| | // On non-Windows platforms, we rely on the TERM variable. 3249| 1| const char* const term = posix::GetEnv("TERM"); 3250| 1| const bool term_supports_color = 3251| 1| term != nullptr && (String::CStringEquals(term, "xterm") || ------------------ | Branch (3251:9): [True: 0, False: 1] | Branch (3251:29): [True: 0, False: 0] ------------------ 3252| 0| String::CStringEquals(term, "xterm-color") || ------------------ | Branch (3252:29): [True: 0, False: 0] ------------------ 3253| 0| String::CStringEquals(term, "xterm-kitty") || ------------------ | Branch (3253:29): [True: 0, False: 0] ------------------ 3254| 0| String::CStringEquals(term, "screen") || ------------------ | Branch (3254:29): [True: 0, False: 0] ------------------ 3255| 0| String::CStringEquals(term, "tmux") || ------------------ | Branch (3255:29): [True: 0, False: 0] ------------------ 3256| 0| String::CStringEquals(term, "rxvt-unicode") || ------------------ | Branch (3256:29): [True: 0, False: 0] ------------------ 3257| 0| String::CStringEquals(term, "linux") || ------------------ | Branch (3257:29): [True: 0, False: 0] ------------------ 3258| 0| String::CStringEquals(term, "cygwin") || ------------------ | Branch (3258:29): [True: 0, False: 0] ------------------ 3259| 0| String::EndsWithCaseInsensitive(term, "-256color")); ------------------ | Branch (3259:29): [True: 0, False: 0] ------------------ 3260| 1| return stdout_is_tty && term_supports_color; ------------------ | Branch (3260:12): [True: 0, False: 1] | Branch (3260:29): [True: 0, False: 0] ------------------ 3261| 1|#endif // GTEST_OS_WINDOWS 3262| 1| } 3263| | 3264| 0| return String::CaseInsensitiveCStringEquals(gtest_color, "yes") || ------------------ | Branch (3264:10): [True: 0, False: 0] ------------------ 3265| 0| String::CaseInsensitiveCStringEquals(gtest_color, "true") || ------------------ | Branch (3265:10): [True: 0, False: 0] ------------------ 3266| 0| String::CaseInsensitiveCStringEquals(gtest_color, "t") || ------------------ | Branch (3266:10): [True: 0, False: 0] ------------------ 3267| 0| String::CStringEquals(gtest_color, "1"); ------------------ | Branch (3267:10): [True: 0, False: 0] ------------------ 3268| | // We take "yes", "true", "t", and "1" as meaning "yes". If the 3269| | // value is neither one of these nor "auto", we treat it as "no" to 3270| | // be conservative. 3271| 1|} _ZN7testing8internal27PrettyUnitTestResultPrinter20OnTestIterationStartERKNS_8UnitTestEi: 3394| 1| const UnitTest& unit_test, int iteration) { 3395| 1| if (GTEST_FLAG_GET(repeat) != 1) ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ | Branch (3395:7): [True: 0, False: 1] ------------------ 3396| 0| printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1); 3397| | 3398| 1| std::string f = GTEST_FLAG_GET(filter); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 3399| 1| const char* const filter = f.c_str(); 3400| | 3401| | // Prints the filter if it's not *. This reminds the user that some 3402| | // tests may be skipped. 3403| 1| if (!String::CStringEquals(filter, kUniversalFilter)) { ------------------ | Branch (3403:7): [True: 1, False: 0] ------------------ 3404| 1| ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_, ------------------ | | 334| 1|#define GTEST_NAME_ "Google Test" ------------------ 3405| 1| filter); 3406| 1| } 3407| | 3408| 1| if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) { ------------------ | Branch (3408:7): [True: 0, False: 1] ------------------ 3409| 0| const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1); 3410| 0| ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n", 3411| 0| static_cast(shard_index) + 1, 3412| 0| internal::posix::GetEnv(kTestTotalShards)); 3413| 0| } 3414| | 3415| 1| if (GTEST_FLAG_GET(shuffle)) { ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ | | | Branch (2293:30): [True: 0, False: 1] | | ------------------ ------------------ 3416| 0| ColoredPrintf(GTestColor::kYellow, 3417| 0| "Note: Randomizing tests' orders with a seed of %d .\n", 3418| 0| unit_test.random_seed()); 3419| 0| } 3420| | 3421| 1| ColoredPrintf(GTestColor::kGreen, "[==========] "); 3422| 1| printf("Running %s from %s.\n", 3423| 1| FormatTestCount(unit_test.test_to_run_count()).c_str(), 3424| 1| FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str()); 3425| | fflush(stdout); 3426| 1|} _ZN7testing8internal27PrettyUnitTestResultPrinter24OnEnvironmentsSetUpStartERKNS_8UnitTestE: 3429| 1| const UnitTest& /*unit_test*/) { 3430| 1| ColoredPrintf(GTestColor::kGreen, "[----------] "); 3431| 1| printf("Global test environment set-up.\n"); 3432| | fflush(stdout); 3433| 1|} _ZN7testing8internal27PrettyUnitTestResultPrinter15OnTestCaseStartERKNS_9TestSuiteE: 3436| 1|void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) { 3437| 1| const std::string counts = 3438| 1| FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); 3439| 1| ColoredPrintf(GTestColor::kGreen, "[----------] "); 3440| 1| printf("%s from %s", counts.c_str(), test_case.name()); 3441| 1| if (test_case.type_param() == nullptr) { ------------------ | Branch (3441:7): [True: 1, False: 0] ------------------ 3442| 1| printf("\n"); 3443| 1| } else { 3444| 0| printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param()); 3445| 0| } 3446| | fflush(stdout); 3447| 1|} _ZN7testing8internal27PrettyUnitTestResultPrinter11OnTestStartERKNS_8TestInfoE: 3464| 1|void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) { 3465| 1| ColoredPrintf(GTestColor::kGreen, "[ RUN ] "); 3466| 1| PrintTestName(test_info.test_suite_name(), test_info.name()); 3467| 1| printf("\n"); 3468| | fflush(stdout); 3469| 1|} _ZN7testing8internal17TestEventRepeater6AppendEPNS_17TestEventListenerE: 3815| 3|void TestEventRepeater::Append(TestEventListener* listener) { 3816| 3| listeners_.push_back(listener); 3817| 3|} _ZN7testing8internal17TestEventRepeater7ReleaseEPNS_17TestEventListenerE: 3819| 1|TestEventListener* TestEventRepeater::Release(TestEventListener* listener) { 3820| 1| for (size_t i = 0; i < listeners_.size(); ++i) { ------------------ | Branch (3820:22): [True: 0, False: 1] ------------------ 3821| 0| if (listeners_[i] == listener) { ------------------ | Branch (3821:9): [True: 0, False: 0] ------------------ 3822| 0| listeners_.erase(listeners_.begin() + static_cast(i)); 3823| 0| return listener; 3824| 0| } 3825| 0| } 3826| | 3827| 1| return nullptr; 3828| 1|} _ZN7testing8internal17TestEventRepeater18OnTestProgramStartERKNS_8UnitTestE: 3833| 1| void TestEventRepeater::Name(const Type& parameter) { \ 3834| 1| if (forwarding_enabled_) { \ ------------------ | Branch (3834:9): [True: 1, False: 0] ------------------ 3835| 4| for (size_t i = 0; i < listeners_.size(); i++) { \ ------------------ | Branch (3835:26): [True: 3, False: 1] ------------------ 3836| 3| listeners_[i]->Name(parameter); \ 3837| 3| } \ 3838| 1| } \ 3839| 1| } _ZN7testing8internal17TestEventRepeater24OnEnvironmentsSetUpStartERKNS_8UnitTestE: 3833| 1| void TestEventRepeater::Name(const Type& parameter) { \ 3834| 1| if (forwarding_enabled_) { \ ------------------ | Branch (3834:9): [True: 1, False: 0] ------------------ 3835| 4| for (size_t i = 0; i < listeners_.size(); i++) { \ ------------------ | Branch (3835:26): [True: 3, False: 1] ------------------ 3836| 3| listeners_[i]->Name(parameter); \ 3837| 3| } \ 3838| 1| } \ 3839| 1| } _ZN7testing8internal17TestEventRepeater15OnTestCaseStartERKNS_9TestSuiteE: 3833| 1| void TestEventRepeater::Name(const Type& parameter) { \ 3834| 1| if (forwarding_enabled_) { \ ------------------ | Branch (3834:9): [True: 1, False: 0] ------------------ 3835| 4| for (size_t i = 0; i < listeners_.size(); i++) { \ ------------------ | Branch (3835:26): [True: 3, False: 1] ------------------ 3836| 3| listeners_[i]->Name(parameter); \ 3837| 3| } \ 3838| 1| } \ 3839| 1| } _ZN7testing8internal17TestEventRepeater16OnTestSuiteStartERKNS_9TestSuiteE: 3833| 1| void TestEventRepeater::Name(const Type& parameter) { \ 3834| 1| if (forwarding_enabled_) { \ ------------------ | Branch (3834:9): [True: 1, False: 0] ------------------ 3835| 4| for (size_t i = 0; i < listeners_.size(); i++) { \ ------------------ | Branch (3835:26): [True: 3, False: 1] ------------------ 3836| 3| listeners_[i]->Name(parameter); \ 3837| 3| } \ 3838| 1| } \ 3839| 1| } _ZN7testing8internal17TestEventRepeater11OnTestStartERKNS_8TestInfoE: 3833| 1| void TestEventRepeater::Name(const Type& parameter) { \ 3834| 1| if (forwarding_enabled_) { \ ------------------ | Branch (3834:9): [True: 1, False: 0] ------------------ 3835| 4| for (size_t i = 0; i < listeners_.size(); i++) { \ ------------------ | Branch (3835:26): [True: 3, False: 1] ------------------ 3836| 3| listeners_[i]->Name(parameter); \ 3837| 3| } \ 3838| 1| } \ 3839| 1| } _ZN7testing8internal17TestEventRepeater22OnEnvironmentsSetUpEndERKNS_8UnitTestE: 3843| 1| void TestEventRepeater::Name(const Type& parameter) { \ 3844| 1| if (forwarding_enabled_) { \ ------------------ | Branch (3844:9): [True: 1, False: 0] ------------------ 3845| 4| for (size_t i = listeners_.size(); i != 0; i--) { \ ------------------ | Branch (3845:42): [True: 3, False: 1] ------------------ 3846| 3| listeners_[i - 1]->Name(parameter); \ 3847| 3| } \ 3848| 1| } \ 3849| 1| } _ZN7testing8internal17TestEventRepeater20OnTestIterationStartERKNS_8UnitTestEi: 3876| 1| int iteration) { 3877| 1| if (forwarding_enabled_) { ------------------ | Branch (3877:7): [True: 1, False: 0] ------------------ 3878| 4| for (size_t i = 0; i < listeners_.size(); i++) { ------------------ | Branch (3878:24): [True: 3, False: 1] ------------------ 3879| 3| listeners_[i]->OnTestIterationStart(unit_test, iteration); 3880| 3| } 3881| 1| } 3882| 1|} _ZN7testing8internal18OsStackTraceGetter16UponLeavingGTestEv: 5021| 4|void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) { 5022| |#ifdef GTEST_HAS_ABSL 5023| | void* caller_frame = nullptr; 5024| | if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) { 5025| | caller_frame = nullptr; 5026| | } 5027| | 5028| | MutexLock lock(&mutex_); 5029| | caller_frame_ = caller_frame; 5030| |#endif // GTEST_HAS_ABSL 5031| 4|} _ZN7testing18TestEventListenersC2Ev: 5078| 1| : repeater_(new internal::TestEventRepeater()), 5079| 1| default_result_printer_(nullptr), 5080| 1| default_xml_generator_(nullptr) {} _ZN7testing18TestEventListeners6AppendEPNS_17TestEventListenerE: 5088| 3|void TestEventListeners::Append(TestEventListener* listener) { 5089| 3| repeater_->Append(listener); 5090| 3|} _ZN7testing18TestEventListeners7ReleaseEPNS_17TestEventListenerE: 5095| 1|TestEventListener* TestEventListeners::Release(TestEventListener* listener) { 5096| 1| if (listener == default_result_printer_) ------------------ | Branch (5096:7): [True: 1, False: 0] ------------------ 5097| 1| default_result_printer_ = nullptr; 5098| 0| else if (listener == default_xml_generator_) ------------------ | Branch (5098:12): [True: 0, False: 0] ------------------ 5099| 0| default_xml_generator_ = nullptr; 5100| 1| return repeater_->Release(listener); 5101| 1|} _ZN7testing18TestEventListeners8repeaterEv: 5105| 3|TestEventListener* TestEventListeners::repeater() { return repeater_; } _ZN7testing18TestEventListeners23SetDefaultResultPrinterEPNS_17TestEventListenerE: 5112| 1|void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) { 5113| 1| if (default_result_printer_ != listener) { ------------------ | Branch (5113:7): [True: 1, False: 0] ------------------ 5114| | // It is an error to pass this method a listener that is already in the 5115| | // list. 5116| 1| delete Release(default_result_printer_); 5117| 1| default_result_printer_ = listener; 5118| 1| if (listener != nullptr) Append(listener); ------------------ | Branch (5118:9): [True: 1, False: 0] ------------------ 5119| 1| } 5120| 1|} _ZN7testing8UnitTest11GetInstanceEv: 5156| 24|UnitTest* UnitTest::GetInstance() { 5157| | // CodeGear C++Builder insists on a public destructor for the 5158| | // default implementation. Use this implementation to keep good OO 5159| | // design with private destructor. 5160| | 5161| |#if defined(__BORLANDC__) 5162| | static UnitTest* const instance = new UnitTest; 5163| | return instance; 5164| |#else 5165| 24| static UnitTest instance; 5166| 24| return &instance; 5167| 24|#endif // defined(__BORLANDC__) 5168| 24|} _ZNK7testing8UnitTest22total_test_suite_countEv: 5181| 2|int UnitTest::total_test_suite_count() const { 5182| 2| return impl()->total_test_suite_count(); 5183| 2|} _ZNK7testing8UnitTest23test_suite_to_run_countEv: 5187| 1|int UnitTest::test_suite_to_run_count() const { 5188| 1| return impl()->test_suite_to_run_count(); 5189| 1|} _ZNK7testing8UnitTest17test_to_run_countEv: 5239| 1|int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); } _ZNK7testing8UnitTest12GetTestSuiteEi: 5262| 3|const TestSuite* UnitTest::GetTestSuite(int i) const { 5263| 3| return impl()->GetTestSuite(i); 5264| 3|} _ZN7testing8UnitTest9listenersEv: 5287| 4|TestEventListeners& UnitTest::listeners() { return *impl()->listeners(); } _ZN7testing8UnitTest3RunEv: 5399| 1|int UnitTest::Run() { 5400| 1|#ifdef GTEST_HAS_DEATH_TEST 5401| 1| const bool in_death_test_child_process = 5402| 1| GTEST_FLAG_GET(internal_run_death_test).length() > 0; ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 5403| | 5404| | // Google Test implements this protocol for catching that a test 5405| | // program exits before returning control to Google Test: 5406| | // 5407| | // 1. Upon start, Google Test creates a file whose absolute path 5408| | // is specified by the environment variable 5409| | // TEST_PREMATURE_EXIT_FILE. 5410| | // 2. When Google Test has finished its work, it deletes the file. 5411| | // 5412| | // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before 5413| | // running a Google-Test-based test program and check the existence 5414| | // of the file at the end of the test execution to see if it has 5415| | // exited prematurely. 5416| | 5417| | // If we are in the child process of a death test, don't 5418| | // create/delete the premature exit file, as doing so is unnecessary 5419| | // and will confuse the parent process. Otherwise, create/delete 5420| | // the file upon entering/leaving this function. If the program 5421| | // somehow exits before this function has a chance to return, the 5422| | // premature-exit file will be left undeleted, causing a test runner 5423| | // that understands the premature-exit-file protocol to report the 5424| | // test as having failed. 5425| 1| const internal::ScopedPrematureExitFile premature_exit_file( 5426| 1| in_death_test_child_process ------------------ | Branch (5426:7): [True: 0, False: 1] ------------------ 5427| 1| ? nullptr 5428| 1| : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE")); 5429| |#else 5430| | const bool in_death_test_child_process = false; 5431| |#endif // GTEST_HAS_DEATH_TEST 5432| | 5433| | // Captures the value of GTEST_FLAG(catch_exceptions). This value will be 5434| | // used for the duration of the program. 5435| 1| impl()->set_catch_exceptions(GTEST_FLAG_GET(catch_exceptions)); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 5436| | 5437| |#ifdef GTEST_OS_WINDOWS 5438| | // Either the user wants Google Test to catch exceptions thrown by the 5439| | // tests or this is executing in the context of death test child 5440| | // process. In either case the user does not want to see pop-up dialogs 5441| | // about crashes - they are expected. 5442| | if (impl()->catch_exceptions() || in_death_test_child_process) { 5443| |#if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \ 5444| | !defined(GTEST_OS_WINDOWS_RT) 5445| | // SetErrorMode doesn't exist on CE. 5446| | SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT | 5447| | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); 5448| |#endif // !GTEST_OS_WINDOWS_MOBILE 5449| | 5450| |#if (defined(_MSC_VER) || defined(GTEST_OS_WINDOWS_MINGW)) && \ 5451| | !defined(GTEST_OS_WINDOWS_MOBILE) 5452| | // Death test children can be terminated with _abort(). On Windows, 5453| | // _abort() can show a dialog with a warning message. This forces the 5454| | // abort message to go to stderr instead. 5455| | _set_error_mode(_OUT_TO_STDERR); 5456| |#endif 5457| | 5458| |#if defined(_MSC_VER) && !defined(GTEST_OS_WINDOWS_MOBILE) 5459| | // In the debug version, Visual Studio pops up a separate dialog 5460| | // offering a choice to debug the aborted program. We need to suppress 5461| | // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement 5462| | // executed. Google Test will notify the user of any unexpected 5463| | // failure via stderr. 5464| | if (!GTEST_FLAG_GET(break_on_failure)) 5465| | _set_abort_behavior( 5466| | 0x0, // Clear the following flags: 5467| | _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump. 5468| | 5469| | // In debug mode, the Windows CRT can crash with an assertion over invalid 5470| | // input (e.g. passing an invalid file descriptor). The default handling 5471| | // for these assertions is to pop up a dialog and wait for user input. 5472| | // Instead ask the CRT to dump such assertions to stderr non-interactively. 5473| | if (!IsDebuggerPresent()) { 5474| | (void)_CrtSetReportMode(_CRT_ASSERT, 5475| | _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG); 5476| | (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR); 5477| | } 5478| |#endif 5479| | } 5480| |#else 5481| 1| (void)in_death_test_child_process; // Needed inside the #if block above 5482| 1|#endif // GTEST_OS_WINDOWS 5483| | 5484| 1| return internal::HandleExceptionsInMethodIfSupported( ------------------ | Branch (5484:10): [True: 0, False: 1] ------------------ 5485| 1| impl(), &internal::UnitTestImpl::RunAllTests, 5486| 1| "auxiliary test code (environments or event listeners)") 5487| 1| ? 0 5488| 1| : 1; 5489| 1|} _ZN7testing8UnitTestC2Ev: 5535| 1|UnitTest::UnitTest() { impl_ = new internal::UnitTestImpl(this); } _ZN7testing8internal12UnitTestImplC2EPNS_8UnitTestE: 5557| 1| : parent_(parent), 5558| | GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */) 5559| 1| default_global_test_part_result_reporter_(this), 5560| 1| default_per_thread_test_part_result_reporter_(this), 5561| | GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_reporter_( 5562| 1| &default_global_test_part_result_reporter_), 5563| 1| per_thread_test_part_result_reporter_( 5564| 1| &default_per_thread_test_part_result_reporter_), 5565| 1| parameterized_test_registry_(), 5566| 1| parameterized_tests_registered_(false), 5567| 1| last_death_test_suite_(-1), 5568| 1| current_test_suite_(nullptr), 5569| 1| current_test_info_(nullptr), 5570| 1| ad_hoc_test_result_(), 5571| 1| os_stack_trace_getter_(nullptr), 5572| 1| post_flag_parse_init_performed_(false), 5573| 1| random_seed_(0), // Will be overridden by the flag before first use. 5574| 1| random_(0), // Will be reseeded before first use. 5575| 1| start_timestamp_(0), 5576| 1| elapsed_time_(0), 5577| |#ifdef GTEST_HAS_DEATH_TEST 5578| 1| death_test_factory_(new DefaultDeathTestFactory), 5579| |#endif 5580| | // Will be overridden by the flag before first use. 5581| 1| catch_exceptions_(false) { 5582| 1| listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter); 5583| 1|} _ZN7testing8internal12UnitTestImpl32SuppressTestEventsIfInSubprocessEv: 5620| 1|void UnitTestImpl::SuppressTestEventsIfInSubprocess() { 5621| 1| if (internal_run_death_test_flag_ != nullptr) ------------------ | Branch (5621:7): [True: 0, False: 1] ------------------ 5622| 0| listeners()->SuppressEventForwarding(true); 5623| 1|} _ZN7testing8internal12UnitTestImpl18ConfigureXmlOutputEv: 5628| 1|void UnitTestImpl::ConfigureXmlOutput() { 5629| 1| const std::string& output_format = UnitTestOptions::GetOutputFormat(); 5630| 1|#if GTEST_HAS_FILE_SYSTEM 5631| 1| if (output_format == "xml") { ------------------ | Branch (5631:7): [True: 0, False: 1] ------------------ 5632| 0| listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter( 5633| 0| UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); 5634| 1| } else if (output_format == "json") { ------------------ | Branch (5634:14): [True: 0, False: 1] ------------------ 5635| 0| listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter( 5636| 0| UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); 5637| 1| } else if (!output_format.empty()) { ------------------ | Branch (5637:14): [True: 0, False: 1] ------------------ 5638| 0| GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \"" ------------------ | | 1054| 0| ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ | | 1055| 0| __FILE__, __LINE__) \ | | 1056| 0| .GetStream() ------------------ 5639| 0| << output_format << "\" ignored."; 5640| 0| } 5641| |#else 5642| | if (!output_format.empty()) { 5643| | GTEST_LOG_(ERROR) << "ERROR: alternative output formats require " 5644| | << "GTEST_HAS_FILE_SYSTEM to be enabled"; 5645| | } 5646| |#endif // GTEST_HAS_FILE_SYSTEM 5647| 1|} _ZN7testing8internal12UnitTestImpl24ConfigureStreamingOutputEv: 5652| 1|void UnitTestImpl::ConfigureStreamingOutput() { 5653| 1| const std::string& target = GTEST_FLAG_GET(stream_result_to); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 5654| 1| if (!target.empty()) { ------------------ | Branch (5654:7): [True: 0, False: 1] ------------------ 5655| 0| const size_t pos = target.find(':'); 5656| 0| if (pos != std::string::npos) { ------------------ | Branch (5656:9): [True: 0, False: 0] ------------------ 5657| 0| listeners()->Append( 5658| 0| new StreamingListener(target.substr(0, pos), target.substr(pos + 1))); 5659| 0| } else { 5660| 0| GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target ------------------ | | 1054| 0| ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ | | 1055| 0| __FILE__, __LINE__) \ | | 1056| 0| .GetStream() ------------------ 5661| 0| << "\" ignored."; 5662| 0| } 5663| 0| } 5664| 1|} _ZN7testing8internal12UnitTestImpl19PostFlagParsingInitEv: 5672| 2|void UnitTestImpl::PostFlagParsingInit() { 5673| | // Ensures that this function does not execute more than once. 5674| 2| if (!post_flag_parse_init_performed_) { ------------------ | Branch (5674:7): [True: 1, False: 1] ------------------ 5675| 1| post_flag_parse_init_performed_ = true; 5676| | 5677| |#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_) 5678| | // Register to send notifications about key process state changes. 5679| | listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_()); 5680| |#endif // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_) 5681| | 5682| 1|#ifdef GTEST_HAS_DEATH_TEST 5683| 1| InitDeathTestSubprocessControlInfo(); 5684| 1| SuppressTestEventsIfInSubprocess(); 5685| 1|#endif // GTEST_HAS_DEATH_TEST 5686| | 5687| | // Registers parameterized tests. This makes parameterized tests 5688| | // available to the UnitTest reflection API without running 5689| | // RUN_ALL_TESTS. 5690| 1| RegisterParameterizedTests(); 5691| | 5692| | // Configures listeners for XML output. This makes it possible for users 5693| | // to shut down the default XML output before invoking RUN_ALL_TESTS. 5694| 1| ConfigureXmlOutput(); 5695| | 5696| 1| if (GTEST_FLAG_GET(brief)) { ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ | | | Branch (2293:30): [True: 0, False: 1] | | ------------------ ------------------ 5697| 0| listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter); 5698| 0| } 5699| | 5700| 1|#if GTEST_CAN_STREAM_RESULTS_ 5701| | // Configures listeners for streaming test results to the specified server. 5702| 1| ConfigureStreamingOutput(); 5703| 1|#endif // GTEST_CAN_STREAM_RESULTS_ 5704| | 5705| |#ifdef GTEST_HAS_ABSL 5706| | if (GTEST_FLAG_GET(install_failure_signal_handler)) { 5707| | absl::FailureSignalHandlerOptions options; 5708| | absl::InstallFailureSignalHandler(options); 5709| | } 5710| |#endif // GTEST_HAS_ABSL 5711| 1| } 5712| 2|} _ZN7testing8internal12UnitTestImpl12GetTestSuiteEPKcS3_PFvvES5_: 5752| 1| internal::TearDownTestSuiteFunc tear_down_tc) { 5753| | // Can we find a TestSuite with the given name? 5754| 1| const auto test_suite = 5755| 1| std::find_if(test_suites_.rbegin(), test_suites_.rend(), 5756| 1| TestSuiteNameIs(test_suite_name)); 5757| | 5758| 1| if (test_suite != test_suites_.rend()) return *test_suite; ------------------ | Branch (5758:7): [True: 0, False: 1] ------------------ 5759| | 5760| | // No. Let's create one. 5761| 1| auto* const new_test_suite = 5762| 1| new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc); 5763| | 5764| 1| const UnitTestFilter death_test_suite_filter(kDeathTestSuiteFilter); 5765| | // Is this a death test suite? 5766| 1| if (death_test_suite_filter.MatchesName(test_suite_name)) { ------------------ | Branch (5766:7): [True: 0, False: 1] ------------------ 5767| | // Yes. Inserts the test suite after the last death test suite 5768| | // defined so far. This only works when the test suites haven't 5769| | // been shuffled. Otherwise we may end up running a death test 5770| | // after a non-death test. 5771| 0| ++last_death_test_suite_; 5772| 0| test_suites_.insert(test_suites_.begin() + last_death_test_suite_, 5773| 0| new_test_suite); 5774| 1| } else { 5775| | // No. Appends to the end of the list. 5776| 1| test_suites_.push_back(new_test_suite); 5777| 1| } 5778| | 5779| 1| test_suite_indices_.push_back(static_cast(test_suite_indices_.size())); 5780| 1| return new_test_suite; 5781| 1|} _ZN7testing8internal12UnitTestImpl11RunAllTestsEv: 5797| 1|bool UnitTestImpl::RunAllTests() { 5798| | // True if and only if Google Test is initialized before RUN_ALL_TESTS() is 5799| | // called. 5800| 1| const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized(); 5801| | 5802| | // Do not run any test if the --help flag was specified. 5803| 1| if (g_help_flag) return true; ------------------ | Branch (5803:7): [True: 0, False: 1] ------------------ 5804| | 5805| | // Repeats the call to the post-flag parsing initialization in case the 5806| | // user didn't call InitGoogleTest. 5807| 1| PostFlagParsingInit(); 5808| | 5809| 1|#if GTEST_HAS_FILE_SYSTEM 5810| | // Even if sharding is not on, test runners may want to use the 5811| | // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding 5812| | // protocol. 5813| 1| internal::WriteToShardStatusFileIfNeeded(); 5814| 1|#endif // GTEST_HAS_FILE_SYSTEM 5815| | 5816| | // True if and only if we are in a subprocess for running a thread-safe-style 5817| | // death test. 5818| 1| bool in_subprocess_for_death_test = false; 5819| | 5820| 1|#ifdef GTEST_HAS_DEATH_TEST 5821| 1| in_subprocess_for_death_test = (internal_run_death_test_flag_ != nullptr); 5822| |#if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_) 5823| | if (in_subprocess_for_death_test) { 5824| | GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_(); 5825| | } 5826| |#endif // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_) 5827| 1|#endif // GTEST_HAS_DEATH_TEST 5828| | 5829| 1| const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex, 5830| 1| in_subprocess_for_death_test); 5831| | 5832| | // Compares the full test names with the filter to decide which 5833| | // tests to run. 5834| 1| const bool has_tests_to_run = 5835| 1| FilterTests(should_shard ? HONOR_SHARDING_PROTOCOL ------------------ | Branch (5835:19): [True: 0, False: 1] ------------------ 5836| 1| : IGNORE_SHARDING_PROTOCOL) > 0; 5837| | 5838| | // Lists the tests and exits if the --gtest_list_tests flag was specified. 5839| 1| if (GTEST_FLAG_GET(list_tests)) { ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ | | | Branch (2293:30): [True: 0, False: 1] | | ------------------ ------------------ 5840| | // This must be called *after* FilterTests() has been called. 5841| 0| ListTestsMatchingFilter(); 5842| 0| return true; 5843| 0| } 5844| | 5845| 1| random_seed_ = GetRandomSeedFromFlag(GTEST_FLAG_GET(random_seed)); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 5846| | 5847| | // True if and only if at least one test has failed. 5848| 1| bool failed = false; 5849| | 5850| 1| TestEventListener* repeater = listeners()->repeater(); 5851| | 5852| 1| start_timestamp_ = GetTimeInMillis(); 5853| 1| repeater->OnTestProgramStart(*parent_); 5854| | 5855| | // How many times to repeat the tests? We don't want to repeat them 5856| | // when we are inside the subprocess of a death test. 5857| 1| const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG_GET(repeat); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ | Branch (5857:22): [True: 0, False: 1] ------------------ 5858| | 5859| | // Repeats forever if the repeat count is negative. 5860| 1| const bool gtest_repeat_forever = repeat < 0; 5861| | 5862| | // Should test environments be set up and torn down for each repeat, or only 5863| | // set up on the first and torn down on the last iteration? If there is no 5864| | // "last" iteration because the tests will repeat forever, always recreate the 5865| | // environments to avoid leaks in case one of the environments is using 5866| | // resources that are external to this process. Without this check there would 5867| | // be no way to clean up those external resources automatically. 5868| 1| const bool recreate_environments_when_repeating = 5869| 1| GTEST_FLAG_GET(recreate_environments_when_repeating) || ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ | | | Branch (2293:30): [True: 0, False: 1] | | ------------------ ------------------ 5870| 1| gtest_repeat_forever; ------------------ | Branch (5870:7): [True: 0, False: 1] ------------------ 5871| | 5872| 2| for (int i = 0; gtest_repeat_forever || i != repeat; i++) { ------------------ | Branch (5872:19): [True: 1, False: 1] | Branch (5872:43): [True: 1, False: 0] ------------------ 5873| | // We want to preserve failures generated by ad-hoc test 5874| | // assertions executed before RUN_ALL_TESTS(). 5875| 1| ClearNonAdHocTestResult(); 5876| | 5877| 1| Timer timer; 5878| | 5879| | // Shuffles test suites and tests if requested. 5880| 1| if (has_tests_to_run && GTEST_FLAG_GET(shuffle)) { ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ | | | Branch (2293:30): [True: 0, False: 1] | | ------------------ ------------------ | Branch (5880:9): [True: 1, False: 0] ------------------ 5881| 0| random()->Reseed(static_cast(random_seed_)); 5882| | // This should be done before calling OnTestIterationStart(), 5883| | // such that a test event listener can see the actual test order 5884| | // in the event. 5885| 0| ShuffleTests(); 5886| 0| } 5887| | 5888| | // Tells the unit test event listeners that the tests are about to start. 5889| 1| repeater->OnTestIterationStart(*parent_, i); 5890| | 5891| | // Runs each test suite if there is at least one test to run. 5892| 1| if (has_tests_to_run) { ------------------ | Branch (5892:9): [True: 1, False: 0] ------------------ 5893| | // Sets up all environments beforehand. If test environments aren't 5894| | // recreated for each iteration, only do so on the first iteration. 5895| 1| if (i == 0 || recreate_environments_when_repeating) { ------------------ | Branch (5895:11): [True: 1, False: 0] | Branch (5895:21): [True: 0, False: 0] ------------------ 5896| 1| repeater->OnEnvironmentsSetUpStart(*parent_); 5897| 1| ForEach(environments_, SetUpEnvironment); 5898| 1| repeater->OnEnvironmentsSetUpEnd(*parent_); 5899| 1| } 5900| | 5901| | // Runs the tests only if there was no fatal failure or skip triggered 5902| | // during global set-up. 5903| 1| if (Test::IsSkipped()) { ------------------ | Branch (5903:11): [True: 0, False: 1] ------------------ 5904| | // Emit diagnostics when global set-up calls skip, as it will not be 5905| | // emitted by default. 5906| 0| TestResult& test_result = 5907| 0| *internal::GetUnitTestImpl()->current_test_result(); 5908| 0| for (int j = 0; j < test_result.total_part_count(); ++j) { ------------------ | Branch (5908:25): [True: 0, False: 0] ------------------ 5909| 0| const TestPartResult& test_part_result = 5910| 0| test_result.GetTestPartResult(j); 5911| 0| if (test_part_result.type() == TestPartResult::kSkip) { ------------------ | Branch (5911:15): [True: 0, False: 0] ------------------ 5912| 0| const std::string& result = test_part_result.message(); 5913| 0| printf("%s\n", result.c_str()); 5914| 0| } 5915| 0| } 5916| 0| fflush(stdout); 5917| 1| } else if (!Test::HasFatalFailure()) { ------------------ | Branch (5917:18): [True: 1, False: 0] ------------------ 5918| 2| for (int test_index = 0; test_index < total_test_suite_count(); ------------------ | Branch (5918:34): [True: 1, False: 1] ------------------ 5919| 1| test_index++) { 5920| 1| GetMutableSuiteCase(test_index)->Run(); 5921| 1| if (GTEST_FLAG_GET(fail_fast) && ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ | | | Branch (2293:30): [True: 0, False: 1] | | ------------------ ------------------ 5922| 0| GetMutableSuiteCase(test_index)->Failed()) { ------------------ | Branch (5922:15): [True: 0, False: 0] ------------------ 5923| 0| for (int j = test_index + 1; j < total_test_suite_count(); j++) { ------------------ | Branch (5923:42): [True: 0, False: 0] ------------------ 5924| 0| GetMutableSuiteCase(j)->Skip(); 5925| 0| } 5926| 0| break; 5927| 0| } 5928| 1| } 5929| 1| } else if (Test::HasFatalFailure()) { ------------------ | Branch (5929:18): [True: 0, False: 0] ------------------ 5930| | // If there was a fatal failure during the global setup then we know we 5931| | // aren't going to run any tests. Explicitly mark all of the tests as 5932| | // skipped to make this obvious in the output. 5933| 0| for (int test_index = 0; test_index < total_test_suite_count(); ------------------ | Branch (5933:34): [True: 0, False: 0] ------------------ 5934| 0| test_index++) { 5935| 0| GetMutableSuiteCase(test_index)->Skip(); 5936| 0| } 5937| 0| } 5938| | 5939| | // Tears down all environments in reverse order afterwards. If test 5940| | // environments aren't recreated for each iteration, only do so on the 5941| | // last iteration. 5942| 1| if (i == repeat - 1 || recreate_environments_when_repeating) { ------------------ | Branch (5942:11): [True: 1, False: 0] | Branch (5942:30): [True: 0, False: 0] ------------------ 5943| 0| repeater->OnEnvironmentsTearDownStart(*parent_); 5944| 0| std::for_each(environments_.rbegin(), environments_.rend(), 5945| 0| TearDownEnvironment); 5946| 0| repeater->OnEnvironmentsTearDownEnd(*parent_); 5947| 0| } 5948| 1| } 5949| | 5950| 1| elapsed_time_ = timer.Elapsed(); 5951| | 5952| | // Tells the unit test event listener that the tests have just finished. 5953| 1| repeater->OnTestIterationEnd(*parent_, i); 5954| | 5955| | // Gets the result and clears it. 5956| 1| if (!Passed()) { ------------------ | Branch (5956:9): [True: 0, False: 1] ------------------ 5957| 0| failed = true; 5958| 0| } 5959| | 5960| | // Restores the original test order after the iteration. This 5961| | // allows the user to quickly repro a failure that happens in the 5962| | // N-th iteration without repeating the first (N - 1) iterations. 5963| | // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in 5964| | // case the user somehow changes the value of the flag somewhere 5965| | // (it's always safe to unshuffle the tests). 5966| 1| UnshuffleTests(); 5967| | 5968| 1| if (GTEST_FLAG_GET(shuffle)) { ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ | | | Branch (2293:30): [True: 0, False: 1] | | ------------------ ------------------ 5969| | // Picks a new random seed for each iteration. 5970| 0| random_seed_ = GetNextRandomSeed(random_seed_); 5971| 0| } 5972| 1| } 5973| | 5974| 1| repeater->OnTestProgramEnd(*parent_); 5975| | 5976| 1| if (!gtest_is_initialized_before_run_all_tests) { ------------------ | Branch (5976:7): [True: 0, False: 1] ------------------ 5977| 0| ColoredPrintf( 5978| 0| GTestColor::kRed, 5979| 0| "\nIMPORTANT NOTICE - DO NOT IGNORE:\n" 5980| 0| "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_ 5981| 0| "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_ 5982| 0| " will start to enforce the valid usage. " 5983| 0| "Please fix it ASAP, or IT WILL START TO FAIL.\n"); // NOLINT 5984| 0| } 5985| | 5986| 1| return !failed; 5987| 1|} _ZN7testing8internal30WriteToShardStatusFileIfNeededEv: 5994| 1|void WriteToShardStatusFileIfNeeded() { 5995| 1| const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile); 5996| 1| if (test_shard_file != nullptr) { ------------------ | Branch (5996:7): [True: 0, False: 1] ------------------ 5997| 0| FILE* const file = posix::FOpen(test_shard_file, "w"); 5998| 0| if (file == nullptr) { ------------------ | Branch (5998:9): [True: 0, False: 0] ------------------ 5999| 0| ColoredPrintf(GTestColor::kRed, 6000| 0| "Could not write to the test shard status file \"%s\" " 6001| 0| "specified by the %s environment variable.\n", 6002| 0| test_shard_file, kTestShardStatusFile); 6003| 0| fflush(stdout); 6004| 0| exit(EXIT_FAILURE); 6005| 0| } 6006| 0| fclose(file); 6007| 0| } 6008| 1|} _ZN7testing8internal11ShouldShardEPKcS2_b: 6018| 2| bool in_subprocess_for_death_test) { 6019| 2| if (in_subprocess_for_death_test) { ------------------ | Branch (6019:7): [True: 0, False: 2] ------------------ 6020| 0| return false; 6021| 0| } 6022| | 6023| 2| const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1); 6024| 2| const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1); 6025| | 6026| 2| if (total_shards == -1 && shard_index == -1) { ------------------ | Branch (6026:7): [True: 2, False: 0] | Branch (6026:29): [True: 2, False: 0] ------------------ 6027| 2| return false; 6028| 2| } else if (total_shards == -1 && shard_index != -1) { ------------------ | Branch (6028:14): [True: 0, False: 0] | Branch (6028:36): [True: 0, False: 0] ------------------ 6029| 0| const Message msg = Message() << "Invalid environment variables: you have " 6030| 0| << kTestShardIndex << " = " << shard_index 6031| 0| << ", but have left " << kTestTotalShards 6032| 0| << " unset.\n"; 6033| 0| ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); 6034| 0| fflush(stdout); 6035| 0| exit(EXIT_FAILURE); 6036| 0| } else if (total_shards != -1 && shard_index == -1) { ------------------ | Branch (6036:14): [True: 0, False: 0] | Branch (6036:36): [True: 0, False: 0] ------------------ 6037| 0| const Message msg = Message() 6038| 0| << "Invalid environment variables: you have " 6039| 0| << kTestTotalShards << " = " << total_shards 6040| 0| << ", but have left " << kTestShardIndex << " unset.\n"; 6041| 0| ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); 6042| 0| fflush(stdout); 6043| 0| exit(EXIT_FAILURE); 6044| 0| } else if (shard_index < 0 || shard_index >= total_shards) { ------------------ | Branch (6044:14): [True: 0, False: 0] | Branch (6044:33): [True: 0, False: 0] ------------------ 6045| 0| const Message msg = 6046| 0| Message() << "Invalid environment variables: we require 0 <= " 6047| 0| << kTestShardIndex << " < " << kTestTotalShards 6048| 0| << ", but you have " << kTestShardIndex << "=" << shard_index 6049| 0| << ", " << kTestTotalShards << "=" << total_shards << ".\n"; 6050| 0| ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str()); 6051| 0| fflush(stdout); 6052| 0| exit(EXIT_FAILURE); 6053| 0| } 6054| | 6055| 0| return total_shards > 1; 6056| 2|} _ZN7testing8internal17Int32FromEnvOrDieEPKci: 6061| 4|int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) { 6062| 4| const char* str_val = posix::GetEnv(var); 6063| 4| if (str_val == nullptr) { ------------------ | Branch (6063:7): [True: 4, False: 0] ------------------ 6064| 4| return default_val; 6065| 4| } 6066| | 6067| 0| int32_t result; 6068| 0| if (!ParseInt32(Message() << "The value of environment variable " << var, ------------------ | Branch (6068:7): [True: 0, False: 0] ------------------ 6069| 0| str_val, &result)) { 6070| 0| exit(EXIT_FAILURE); 6071| 0| } 6072| 0| return result; 6073| 0|} _ZN7testing8internal12UnitTestImpl11FilterTestsENS1_18ReactionToShardingE: 6090| 1|int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) { 6091| 1| const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ------------------ | Branch (6091:32): [True: 0, False: 1] ------------------ 6092| 1| ? Int32FromEnvOrDie(kTestTotalShards, -1) 6093| 1| : -1; 6094| 1| const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ------------------ | Branch (6094:31): [True: 0, False: 1] ------------------ 6095| 1| ? Int32FromEnvOrDie(kTestShardIndex, -1) 6096| 1| : -1; 6097| | 6098| 1| const PositiveAndNegativeUnitTestFilter gtest_flag_filter( 6099| 1| GTEST_FLAG_GET(filter)); ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 6100| 1| const UnitTestFilter disable_test_filter(kDisableTestFilter); 6101| | // num_runnable_tests are the number of tests that will 6102| | // run across all shards (i.e., match filter and are not disabled). 6103| | // num_selected_tests are the number of tests to be run on 6104| | // this shard. 6105| 1| int num_runnable_tests = 0; 6106| 1| int num_selected_tests = 0; 6107| 1| for (auto* test_suite : test_suites_) { ------------------ | Branch (6107:25): [True: 1, False: 1] ------------------ 6108| 1| const std::string& test_suite_name = test_suite->name(); 6109| 1| test_suite->set_should_run(false); 6110| | 6111| 2| for (size_t j = 0; j < test_suite->test_info_list().size(); j++) { ------------------ | Branch (6111:24): [True: 1, False: 1] ------------------ 6112| 1| TestInfo* const test_info = test_suite->test_info_list()[j]; 6113| 1| const std::string test_name(test_info->name()); 6114| | // A test is disabled if test suite name or test name matches 6115| | // kDisableTestFilter. 6116| 1| const bool is_disabled = 6117| 1| disable_test_filter.MatchesName(test_suite_name) || ------------------ | Branch (6117:11): [True: 0, False: 1] ------------------ 6118| 1| disable_test_filter.MatchesName(test_name); ------------------ | Branch (6118:11): [True: 0, False: 1] ------------------ 6119| 1| test_info->is_disabled_ = is_disabled; 6120| | 6121| 1| const bool matches_filter = 6122| 1| gtest_flag_filter.MatchesTest(test_suite_name, test_name); 6123| 1| test_info->matches_filter_ = matches_filter; 6124| | 6125| 1| const bool is_runnable = 6126| 1| (GTEST_FLAG_GET(also_run_disabled_tests) || !is_disabled) && ------------------ | | 2293| 1|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | ------------------ | | | | 2226| 1|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ | | | Branch (2293:30): [True: 0, False: 1] | | ------------------ ------------------ | Branch (6126:55): [True: 1, False: 0] ------------------ 6127| 1| matches_filter; ------------------ | Branch (6127:11): [True: 1, False: 0] ------------------ 6128| | 6129| 1| const bool is_in_another_shard = 6130| 1| shard_tests != IGNORE_SHARDING_PROTOCOL && ------------------ | Branch (6130:11): [True: 0, False: 1] ------------------ 6131| 0| !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests); ------------------ | Branch (6131:11): [True: 0, False: 0] ------------------ 6132| 1| test_info->is_in_another_shard_ = is_in_another_shard; 6133| 1| const bool is_selected = is_runnable && !is_in_another_shard; ------------------ | Branch (6133:32): [True: 1, False: 0] | Branch (6133:47): [True: 1, False: 0] ------------------ 6134| | 6135| 1| num_runnable_tests += is_runnable; 6136| 1| num_selected_tests += is_selected; 6137| | 6138| 1| test_info->should_run_ = is_selected; 6139| 1| test_suite->set_should_run(test_suite->should_run() || is_selected); ------------------ | Branch (6139:34): [True: 0, False: 1] | Branch (6139:62): [True: 1, False: 0] ------------------ 6140| 1| } 6141| 1| } 6142| 1| return num_selected_tests; 6143| 1|} _ZN7testing8internal12UnitTestImpl21os_stack_trace_getterEv: 6238| 4|OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() { 6239| 4| if (os_stack_trace_getter_ == nullptr) { ------------------ | Branch (6239:7): [True: 1, False: 3] ------------------ 6240| |#ifdef GTEST_OS_STACK_TRACE_GETTER_ 6241| | os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_; 6242| |#else 6243| 1| os_stack_trace_getter_ = new OsStackTraceGetter; 6244| 1|#endif // GTEST_OS_STACK_TRACE_GETTER_ 6245| 1| } 6246| | 6247| 4| return os_stack_trace_getter_; 6248| 4|} _ZN7testing8internal12UnitTestImpl19current_test_resultEv: 6251| 6|TestResult* UnitTestImpl::current_test_result() { 6252| 6| if (current_test_info_ != nullptr) { ------------------ | Branch (6252:7): [True: 4, False: 2] ------------------ 6253| 4| return ¤t_test_info_->result_; 6254| 4| } 6255| 2| if (current_test_suite_ != nullptr) { ------------------ | Branch (6255:7): [True: 0, False: 2] ------------------ 6256| 0| return ¤t_test_suite_->ad_hoc_test_result_; 6257| 0| } 6258| 2| return &ad_hoc_test_result_; 6259| 2|} _ZN7testing8internal6IsTrueEb: 6310| 9|bool IsTrue(bool condition) { return condition; } _ZN7testing8internal10AlwaysTrueEv: 6312| 6|bool AlwaysTrue() { 6313| 6|#if GTEST_HAS_EXCEPTIONS 6314| | // This condition is always false so AlwaysTrue() never actually throws, 6315| | // but it makes the compiler think that it may throw. 6316| 6| if (IsTrue(false)) throw ClassUniqueToAlwaysTrue(); ------------------ | Branch (6316:7): [True: 0, False: 6] ------------------ 6317| 6|#endif // GTEST_HAS_EXCEPTIONS 6318| 6| return true; 6319| 6|} _ZN7testing8internal10SkipPrefixEPKcPS2_: 6324| 34|bool SkipPrefix(const char* prefix, const char** pstr) { 6325| 34| const size_t prefix_len = strlen(prefix); 6326| 34| if (strncmp(*pstr, prefix, prefix_len) == 0) { ------------------ | Branch (6326:7): [True: 7, False: 27] ------------------ 6327| 7| *pstr += prefix_len; 6328| 7| return true; 6329| 7| } 6330| 27| return false; 6331| 34|} _ZN7testing8internal9ParseFlagEPKcS2_Pi: 6392| 21|bool ParseFlag(const char* str, const char* flag_name, int32_t* value) { 6393| | // Gets the value of the flag as a string. 6394| 21| const char* const value_str = ParseFlagValue(str, flag_name, false); 6395| | 6396| | // Aborts if the parsing failed. 6397| 21| if (value_str == nullptr) return false; ------------------ | Branch (6397:7): [True: 21, False: 0] ------------------ 6398| | 6399| | // Sets *value to the value of the flag. 6400| 0| return ParseInt32(Message() << "The value of flag --" << flag_name, value_str, 6401| 0| value); 6402| 21|} _ZN7testing8internal24ParseGoogleTestFlagsOnlyEPiPPc: 6685| 1|void ParseGoogleTestFlagsOnly(int* argc, char** argv) { 6686| |#ifdef GTEST_HAS_ABSL 6687| | if (*argc <= 0) return; 6688| | 6689| | std::vector positional_args; 6690| | std::vector unrecognized_flags; 6691| | absl::ParseAbseilFlagsOnly(*argc, argv, positional_args, unrecognized_flags); 6692| | absl::flat_hash_set unrecognized; 6693| | for (const auto& flag : unrecognized_flags) { 6694| | unrecognized.insert(flag.flag_name); 6695| | } 6696| | absl::flat_hash_set positional; 6697| | for (const auto& arg : positional_args) { 6698| | positional.insert(arg); 6699| | } 6700| | 6701| | int out_pos = 1; 6702| | int in_pos = 1; 6703| | for (; in_pos < *argc; ++in_pos) { 6704| | char* arg = argv[in_pos]; 6705| | absl::string_view arg_str(arg); 6706| | if (absl::ConsumePrefix(&arg_str, "--")) { 6707| | // Flag-like argument. If the flag was unrecognized, keep it. 6708| | // If it was a GoogleTest flag, remove it. 6709| | if (unrecognized.contains(arg_str)) { 6710| | argv[out_pos++] = argv[in_pos]; 6711| | continue; 6712| | } 6713| | } 6714| | 6715| | if (arg_str.empty()) { 6716| | ++in_pos; 6717| | break; // '--' indicates that the rest of the arguments are positional 6718| | } 6719| | 6720| | // Probably a positional argument. If it is in fact positional, keep it. 6721| | // If it was a value for the flag argument, remove it. 6722| | if (positional.contains(arg)) { 6723| | argv[out_pos++] = arg; 6724| | } 6725| | } 6726| | 6727| | // The rest are positional args for sure. 6728| | while (in_pos < *argc) { 6729| | argv[out_pos++] = argv[in_pos++]; 6730| | } 6731| | 6732| | *argc = out_pos; 6733| | argv[out_pos] = nullptr; 6734| |#else 6735| 1| ParseGoogleTestFlagsOnlyImpl(argc, argv); 6736| 1|#endif 6737| | 6738| | // Fix the value of *_NSGetArgc() on macOS, but if and only if 6739| | // *_NSGetArgv() == argv 6740| | // Only applicable to char** version of argv 6741| |#ifdef GTEST_OS_MAC 6742| |#ifndef GTEST_OS_IOS 6743| | if (*_NSGetArgv() == argv) { 6744| | *_NSGetArgc() = *argc; 6745| | } 6746| |#endif 6747| |#endif 6748| 1|} _ZN7testing14InitGoogleTestEPiPPc: 6794| 1|void InitGoogleTest(int* argc, char** argv) { 6795| |#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 6796| | GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv); 6797| |#else // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 6798| 1| internal::InitGoogleTestImpl(argc, argv); 6799| 1|#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_) 6800| 1|} gtest-all.cc:_ZN7testingL18GetDefaultFailFastEv: 239| 1|static bool GetDefaultFailFast() { 240| 1| const char* const testbridge_test_runner_fail_fast = 241| 1| internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST"); 242| 1| if (testbridge_test_runner_fail_fast != nullptr) { ------------------ | Branch (242:7): [True: 0, False: 1] ------------------ 243| 0| return strcmp(testbridge_test_runner_fail_fast, "1") == 0; 244| 0| } 245| 1| return false; 246| 1|} gtest-all.cc:_ZN7testingL16GetDefaultFilterEv: 228| 1|static const char* GetDefaultFilter() { 229| 1| const char* const testbridge_test_only = 230| 1| internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY"); 231| 1| if (testbridge_test_only != nullptr) { ------------------ | Branch (231:7): [True: 0, False: 1] ------------------ 232| 0| return testbridge_test_only; 233| 0| } 234| 1| return kUniversalFilter; 235| 1|} gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_114UnitTestFilterC2ERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 762| 3| explicit UnitTestFilter(const std::string& filter) { 763| | // By design "" filter matches "" string. 764| 3| std::vector all_patterns; 765| 3| SplitString(filter, ':', &all_patterns); 766| 3| const auto exact_match_patterns_begin = std::partition( 767| 3| all_patterns.begin(), all_patterns.end(), &IsGlobPattern); 768| | 769| 3| glob_patterns_.reserve(static_cast( 770| 3| std::distance(all_patterns.begin(), exact_match_patterns_begin))); 771| 3| std::move(all_patterns.begin(), exact_match_patterns_begin, 772| 3| std::inserter(glob_patterns_, glob_patterns_.begin())); 773| 3| std::move( 774| 3| exact_match_patterns_begin, all_patterns.end(), 775| 3| std::inserter(exact_match_patterns_, exact_match_patterns_.begin())); 776| 3| } gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_113IsGlobPatternERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 752| 5|bool IsGlobPattern(const std::string& pattern) { 753| 5| return std::any_of(pattern.begin(), pattern.end(), 754| 5| [](const char c) { return c == '?' || c == '*'; }); 755| 5|} gtest-all.cc:_ZZN7testing8internal12_GLOBAL__N_113IsGlobPatternERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEc: 754| 44| [](const char c) { return c == '?' || c == '*'; }); ------------------ | Branch (754:48): [True: 0, False: 44] | Branch (754:60): [True: 4, False: 40] ------------------ gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 780| 5| bool MatchesName(const std::string& name) const { 781| 5| return exact_match_patterns_.count(name) > 0 || ------------------ | Branch (781:12): [True: 1, False: 4] ------------------ 782| 4| std::any_of(glob_patterns_.begin(), glob_patterns_.end(), ------------------ | Branch (782:12): [True: 0, False: 4] ------------------ 783| 4| [&name](const std::string& pattern) { 784| 4| return PatternMatchesString( 785| 4| name, pattern.c_str(), 786| 4| pattern.c_str() + pattern.size()); 787| 4| }); 788| 5| } gtest-all.cc:_ZZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENKUlSB_E_clESB_: 783| 6| [&name](const std::string& pattern) { 784| 6| return PatternMatchesString( 785| 6| name, pattern.c_str(), 786| 6| pattern.c_str() + pattern.size()); 787| 6| }); gtest-all.cc:_ZN7testing8internalL20PatternMatchesStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcSB_: 704| 6| const char* pattern, const char* pattern_end) { 705| 6| const char* name = name_str.c_str(); 706| 6| const char* const name_begin = name; 707| 6| const char* const name_end = name + name_str.size(); 708| | 709| 6| const char* pattern_next = pattern; 710| 6| const char* name_next = name; 711| | 712| 138| while (pattern < pattern_end || name < name_end) { ------------------ | Branch (712:10): [True: 138, False: 0] | Branch (712:35): [True: 0, False: 0] ------------------ 713| 138| if (pattern < pattern_end) { ------------------ | Branch (713:9): [True: 138, False: 0] ------------------ 714| 138| switch (*pattern) { 715| 70| default: // Match an ordinary character. ------------------ | Branch (715:9): [True: 70, False: 68] ------------------ 716| 70| if (name < name_end && *name == *pattern) { ------------------ | Branch (716:15): [True: 66, False: 4] | Branch (716:34): [True: 0, False: 66] ------------------ 717| 0| ++pattern; 718| 0| ++name; 719| 0| continue; 720| 0| } 721| 70| break; 722| 70| case '?': // Match any single character. ------------------ | Branch (722:9): [True: 0, False: 138] ------------------ 723| 0| if (name < name_end) { ------------------ | Branch (723:15): [True: 0, False: 0] ------------------ 724| 0| ++pattern; 725| 0| ++name; 726| 0| continue; 727| 0| } 728| 0| break; 729| 68| case '*': ------------------ | Branch (729:9): [True: 68, False: 70] ------------------ 730| | // Match zero or more characters. Start by skipping over the wildcard 731| | // and matching zero characters from name. If that fails, restart and 732| | // match one more character than the last attempt. 733| 68| pattern_next = pattern; 734| 68| name_next = name + 1; 735| 68| ++pattern; 736| 68| continue; 737| 138| } 738| 138| } 739| | // Failed to match a character. Restart if possible. 740| 70| if (name_begin < name_next && name_next <= name_end) { ------------------ | Branch (740:9): [True: 68, False: 2] | Branch (740:35): [True: 64, False: 4] ------------------ 741| 64| pattern = pattern_next; 742| 64| name = name_next; 743| 64| continue; 744| 64| } 745| 6| return false; 746| 70| } 747| 0| return true; 748| 6|} gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilterC2ERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 802| 1| explicit PositiveAndNegativeUnitTestFilter(const std::string& filter) { 803| 1| std::vector positive_and_negative_filters; 804| | 805| | // NOTE: `SplitString` always returns a non-empty container. 806| 1| SplitString(filter, '-', &positive_and_negative_filters); 807| 1| const auto& positive_filter = positive_and_negative_filters.front(); 808| | 809| 1| if (positive_and_negative_filters.size() > 1) { ------------------ | Branch (809:9): [True: 0, False: 1] ------------------ 810| 0| positive_filter_ = UnitTestFilter( 811| 0| positive_filter.empty() ? kUniversalFilter : positive_filter); ------------------ | Branch (811:11): [True: 0, False: 0] ------------------ 812| | 813| | // TODO(b/214626361): Fail on multiple '-' characters 814| | // For the moment to preserve old behavior we concatenate the rest of the 815| | // string parts with `-` as separator to generate the negative filter. 816| 0| auto negative_filter_string = positive_and_negative_filters[1]; 817| 0| for (std::size_t i = 2; i < positive_and_negative_filters.size(); i++) ------------------ | Branch (817:31): [True: 0, False: 0] ------------------ 818| 0| negative_filter_string = 819| 0| negative_filter_string + '-' + positive_and_negative_filters[i]; 820| 0| negative_filter_ = UnitTestFilter(negative_filter_string); 821| 1| } else { 822| | // In case we don't have a negative filter and positive filter is "" 823| | // we do not use kUniversalFilter by design as opposed to when we have a 824| | // negative filter. 825| 1| positive_filter_ = UnitTestFilter(positive_filter); 826| 1| } 827| 1| } gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_114UnitTestFilterC2Ev: 759| 2| UnitTestFilter() = default; gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesTestERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_: 833| 1| const std::string& test_name) const { 834| 1| return MatchesName(test_suite_name + "." + test_name); 835| 1| } gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 839| 1| bool MatchesName(const std::string& name) const { 840| 1| return positive_filter_.MatchesName(name) && ------------------ | Branch (840:12): [True: 1, False: 0] ------------------ 841| 1| !negative_filter_.MatchesName(name); ------------------ | Branch (841:12): [True: 1, False: 0] ------------------ 842| 1| } gtest-all.cc:_ZN7testing8internalL18ShouldRunTestSuiteEPKNS_9TestSuiteE: 445| 1|static bool ShouldRunTestSuite(const TestSuite* test_suite) { 446| 1| return test_suite->should_run(); 447| 1|} gtest-all.cc:_ZN7testing8internalL20SumOverTestSuiteListERKNSt3__16vectorIPNS_9TestSuiteENS1_9allocatorIS4_EEEEMS3_KFivE: 425| 1| int (TestSuite::*method)() const) { 426| 1| int sum = 0; 427| 2| for (size_t i = 0; i < case_list.size(); i++) { ------------------ | Branch (427:22): [True: 1, False: 1] ------------------ 428| 1| sum += (case_list[i]->*method)(); 429| 1| } 430| 1| return sum; 431| 1|} _ZN7testing8internal5TimerC2Ev: 1151| 3| Timer() : start_(clock::now()) {} gtest-all.cc:_ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz: 3279| 5|static void ColoredPrintf(GTestColor color, const char* fmt, ...) { 3280| 5| va_list args; 3281| 5| va_start(args, fmt); 3282| | 3283| 5| static const bool in_color_mode = 3284| 5|#if GTEST_HAS_FILE_SYSTEM 3285| 5| ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0); 3286| |#else 3287| | false; 3288| |#endif // GTEST_HAS_FILE_SYSTEM 3289| | 3290| 5| const bool use_color = in_color_mode && (color != GTestColor::kDefault); ------------------ | Branch (3290:26): [True: 0, False: 5] | Branch (3290:43): [True: 0, False: 0] ------------------ 3291| | 3292| 5| if (!use_color) { ------------------ | Branch (3292:7): [True: 5, False: 0] ------------------ 3293| 5| vprintf(fmt, args); 3294| 5| va_end(args); 3295| 5| return; 3296| 5| } 3297| | 3298| |#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) && \ 3299| | !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \ 3300| | !defined(GTEST_OS_WINDOWS_MINGW) 3301| | const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); 3302| | 3303| | // Gets the current text color. 3304| | CONSOLE_SCREEN_BUFFER_INFO buffer_info; 3305| | GetConsoleScreenBufferInfo(stdout_handle, &buffer_info); 3306| | const WORD old_color_attrs = buffer_info.wAttributes; 3307| | const WORD new_color = GetNewColor(color, old_color_attrs); 3308| | 3309| | // We need to flush the stream buffers into the console before each 3310| | // SetConsoleTextAttribute call lest it affect the text that is already 3311| | // printed but has not yet reached the console. 3312| | fflush(stdout); 3313| | SetConsoleTextAttribute(stdout_handle, new_color); 3314| | 3315| | vprintf(fmt, args); 3316| | 3317| | fflush(stdout); 3318| | // Restores the text color. 3319| | SetConsoleTextAttribute(stdout_handle, old_color_attrs); 3320| |#else 3321| 0| printf("\033[0;3%sm", GetAnsiColorCode(color)); 3322| 0| vprintf(fmt, args); 3323| 0| printf("\033[m"); // Resets the terminal to default. 3324| 0|#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE 3325| | va_end(args); 3326| 0|} gtest-all.cc:_ZN7testingL15FormatTestCountEi: 3101| 1|static std::string FormatTestCount(int test_count) { 3102| 1| return FormatCountableNoun(test_count, "test", "tests"); 3103| 1|} gtest-all.cc:_ZN7testingL20FormatTestSuiteCountEi: 3106| 1|static std::string FormatTestSuiteCount(int test_suite_count) { 3107| 1| return FormatCountableNoun(test_suite_count, "test suite", "test suites"); 3108| 1|} gtest-all.cc:_ZN7testingL19FormatCountableNounEiPKcS1_: 3095| 3| const char* plural_form) { 3096| 3| return internal::StreamableToString(count) + " " + 3097| 3| (count == 1 ? singular_form : plural_form); ------------------ | Branch (3097:11): [True: 3, False: 0] ------------------ 3098| 3|} _ZN7testing8internal27PrettyUnitTestResultPrinter13PrintTestNameEPKcS3_: 3355| 1| static void PrintTestName(const char* test_suite, const char* test) { 3356| 1| printf("%s.%s", test_suite, test); 3357| 1| } _ZN7testing8internal17TestEventRepeaterC2Ev: 3767| 1| TestEventRepeater() : forwarding_enabled_(true) {} _ZN7testing8internal23ScopedPrematureExitFileC2EPKc: 5039| 1| : premature_exit_filepath_( 5040| 1| premature_exit_filepath ? premature_exit_filepath : "") { ------------------ | Branch (5040:13): [True: 0, False: 1] ------------------ 5041| | // If a path to the premature-exit file is specified... 5042| 1| if (!premature_exit_filepath_.empty()) { ------------------ | Branch (5042:9): [True: 0, False: 1] ------------------ 5043| | // create the file with a single "0" character in it. I/O 5044| | // errors are ignored as there's nothing better we can do and we 5045| | // don't want to fail the test because of this. 5046| 0| FILE* pfile = posix::FOpen(premature_exit_filepath_.c_str(), "w"); 5047| 0| fwrite("0", 1, 1, pfile); 5048| 0| fclose(pfile); 5049| 0| } 5050| 1| } _ZN7testing8internal27PrettyUnitTestResultPrinterC2Ev: 3354| 1| PrettyUnitTestResultPrinter() = default; _ZN7testing8internal15TestSuiteNameIsC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 5725| 1| explicit TestSuiteNameIs(const std::string& name) : name_(name) {} gtest-all.cc:_ZN7testing8internalL18GTestIsInitializedEv: 419| 2|static bool GTestIsInitialized() { return !GetArgvs().empty(); } gtest-all.cc:_ZN7testing8internalL14ParseFlagValueEPKcS2_b: 6339| 154| bool def_optional) { 6340| | // str and flag must not be NULL. 6341| 154| if (str == nullptr || flag_name == nullptr) return nullptr; ------------------ | Branch (6341:7): [True: 0, False: 154] | Branch (6341:25): [True: 0, False: 154] ------------------ 6342| | 6343| | // The flag must start with "--" followed by GTEST_FLAG_PREFIX_. 6344| 154| const std::string flag_str = 6345| 154| std::string("--") + GTEST_FLAG_PREFIX_ + flag_name; ------------------ | | 331| 154|#define GTEST_FLAG_PREFIX_ "gtest_" ------------------ 6346| 154| const size_t flag_len = flag_str.length(); 6347| 154| if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr; ------------------ | Branch (6347:7): [True: 154, False: 0] ------------------ 6348| | 6349| | // Skips the flag name. 6350| 0| const char* flag_end = str + flag_len; 6351| | 6352| | // When def_optional is true, it's OK to not have a "=value" part. 6353| 0| if (def_optional && (flag_end[0] == '\0')) { ------------------ | Branch (6353:7): [True: 0, False: 0] | Branch (6353:23): [True: 0, False: 0] ------------------ 6354| 0| return flag_end; 6355| 0| } 6356| | 6357| | // If def_optional is true and there are more characters after the 6358| | // flag name, or if def_optional is false, there must be a '=' after 6359| | // the flag name. 6360| 0| if (flag_end[0] != '=') return nullptr; ------------------ | Branch (6360:7): [True: 0, False: 0] ------------------ 6361| | 6362| | // Returns the string after "=". 6363| 0| return flag_end + 1; 6364| 0|} _ZN7testing8internal27PrettyUnitTestResultPrinter18OnTestProgramStartERKNS_8UnitTestE: 3360| 1| void OnTestProgramStart(const UnitTest& /*unit_test*/) override {} _ZN7testing8internal27PrettyUnitTestResultPrinter22OnEnvironmentsSetUpEndERKNS_8UnitTestE: 3363| 1| void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {} _ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc: 2621| 2| const char* location) { 2622| | // NOTE: The user code can affect the way in which Google Test handles 2623| | // exceptions by setting GTEST_FLAG(catch_exceptions), but only before 2624| | // RUN_ALL_TESTS() starts. It is technically possible to check the flag 2625| | // after the exception is caught and either report or re-throw the 2626| | // exception based on the flag's value: 2627| | // 2628| | // try { 2629| | // // Perform the test method. 2630| | // } catch (...) { 2631| | // if (GTEST_FLAG_GET(catch_exceptions)) 2632| | // // Report the exception as failure. 2633| | // else 2634| | // throw; // Re-throws the original exception. 2635| | // } 2636| | // 2637| | // However, the purpose of this flag is to allow the program to drop into 2638| | // the debugger when the exception is thrown. On most platforms, once the 2639| | // control enters the catch block, the exception origin information is 2640| | // lost and the debugger will stop the program at the point of the 2641| | // re-throw in this function -- instead of at the point of the original 2642| | // throw statement in the code under test. For this reason, we perform 2643| | // the check early, sacrificing the ability to affect Google Test's 2644| | // exception handling in the method where the exception is thrown. 2645| 2| if (internal::GetUnitTestImpl()->catch_exceptions()) { ------------------ | Branch (2645:7): [True: 2, False: 0] ------------------ 2646| 2|#if GTEST_HAS_EXCEPTIONS 2647| 2| try { 2648| 2| return HandleSehExceptionsInMethodIfSupported(object, method, location); 2649| 2| } catch (const AssertionException&) { // NOLINT 2650| | // This failure was reported already. 2651| 0| } catch (const internal::GoogleTestFailureException&) { // NOLINT 2652| | // This exception type can only be thrown by a failed Google 2653| | // Test assertion with the intention of letting another testing 2654| | // framework catch it. Therefore we just re-throw it. 2655| 0| throw; 2656| 0| } catch (const std::exception& e) { // NOLINT 2657| 0| internal::ReportFailureInUnknownLocation( 2658| 0| TestPartResult::kFatalFailure, 2659| 0| FormatCxxExceptionMessage(e.what(), location)); 2660| 0| } catch (...) { // NOLINT 2661| 0| internal::ReportFailureInUnknownLocation( 2662| 0| TestPartResult::kFatalFailure, 2663| 0| FormatCxxExceptionMessage(nullptr, location)); 2664| 0| } 2665| 0| return static_cast(0); 2666| |#else 2667| | return HandleSehExceptionsInMethodIfSupported(object, method, location); 2668| |#endif // GTEST_HAS_EXCEPTIONS 2669| 2| } else { 2670| 0| return (object->*method)(); 2671| 0| } 2672| 2|} _ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc: 2602| 2| const char* location) { 2603| |#if GTEST_HAS_SEH 2604| | __try { 2605| | return (object->*method)(); 2606| | } __except (internal::UnitTestOptions::GTestProcessSEH( // NOLINT 2607| | GetExceptionCode(), location)) { 2608| | return static_cast(0); 2609| | } 2610| |#else 2611| 2| (void)location; 2612| 2| return (object->*method)(); 2613| 2|#endif // GTEST_HAS_SEH 2614| 2|} _ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS0_15TestFactoryBaseEPNS_4TestEEET0_PT_MS6_FS5_vEPKc: 2621| 1| const char* location) { 2622| | // NOTE: The user code can affect the way in which Google Test handles 2623| | // exceptions by setting GTEST_FLAG(catch_exceptions), but only before 2624| | // RUN_ALL_TESTS() starts. It is technically possible to check the flag 2625| | // after the exception is caught and either report or re-throw the 2626| | // exception based on the flag's value: 2627| | // 2628| | // try { 2629| | // // Perform the test method. 2630| | // } catch (...) { 2631| | // if (GTEST_FLAG_GET(catch_exceptions)) 2632| | // // Report the exception as failure. 2633| | // else 2634| | // throw; // Re-throws the original exception. 2635| | // } 2636| | // 2637| | // However, the purpose of this flag is to allow the program to drop into 2638| | // the debugger when the exception is thrown. On most platforms, once the 2639| | // control enters the catch block, the exception origin information is 2640| | // lost and the debugger will stop the program at the point of the 2641| | // re-throw in this function -- instead of at the point of the original 2642| | // throw statement in the code under test. For this reason, we perform 2643| | // the check early, sacrificing the ability to affect Google Test's 2644| | // exception handling in the method where the exception is thrown. 2645| 1| if (internal::GetUnitTestImpl()->catch_exceptions()) { ------------------ | Branch (2645:7): [True: 1, False: 0] ------------------ 2646| 1|#if GTEST_HAS_EXCEPTIONS 2647| 1| try { 2648| 1| return HandleSehExceptionsInMethodIfSupported(object, method, location); 2649| 1| } catch (const AssertionException&) { // NOLINT 2650| | // This failure was reported already. 2651| 0| } catch (const internal::GoogleTestFailureException&) { // NOLINT 2652| | // This exception type can only be thrown by a failed Google 2653| | // Test assertion with the intention of letting another testing 2654| | // framework catch it. Therefore we just re-throw it. 2655| 0| throw; 2656| 0| } catch (const std::exception& e) { // NOLINT 2657| 0| internal::ReportFailureInUnknownLocation( 2658| 0| TestPartResult::kFatalFailure, 2659| 0| FormatCxxExceptionMessage(e.what(), location)); 2660| 0| } catch (...) { // NOLINT 2661| 0| internal::ReportFailureInUnknownLocation( 2662| 0| TestPartResult::kFatalFailure, 2663| 0| FormatCxxExceptionMessage(nullptr, location)); 2664| 0| } 2665| 0| return static_cast(0); 2666| |#else 2667| | return HandleSehExceptionsInMethodIfSupported(object, method, location); 2668| |#endif // GTEST_HAS_EXCEPTIONS 2669| 1| } else { 2670| 0| return (object->*method)(); 2671| 0| } 2672| 1|} _ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS0_15TestFactoryBaseEPNS_4TestEEET0_PT_MS6_FS5_vEPKc: 2602| 1| const char* location) { 2603| |#if GTEST_HAS_SEH 2604| | __try { 2605| | return (object->*method)(); 2606| | } __except (internal::UnitTestOptions::GTestProcessSEH( // NOLINT 2607| | GetExceptionCode(), location)) { 2608| | return static_cast(0); 2609| | } 2610| |#else 2611| 1| (void)location; 2612| 1| return (object->*method)(); 2613| 1|#endif // GTEST_HAS_SEH 2614| 1|} _ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_9TestSuiteEvEET0_PT_MS4_FS3_vEPKc: 2621| 1| const char* location) { 2622| | // NOTE: The user code can affect the way in which Google Test handles 2623| | // exceptions by setting GTEST_FLAG(catch_exceptions), but only before 2624| | // RUN_ALL_TESTS() starts. It is technically possible to check the flag 2625| | // after the exception is caught and either report or re-throw the 2626| | // exception based on the flag's value: 2627| | // 2628| | // try { 2629| | // // Perform the test method. 2630| | // } catch (...) { 2631| | // if (GTEST_FLAG_GET(catch_exceptions)) 2632| | // // Report the exception as failure. 2633| | // else 2634| | // throw; // Re-throws the original exception. 2635| | // } 2636| | // 2637| | // However, the purpose of this flag is to allow the program to drop into 2638| | // the debugger when the exception is thrown. On most platforms, once the 2639| | // control enters the catch block, the exception origin information is 2640| | // lost and the debugger will stop the program at the point of the 2641| | // re-throw in this function -- instead of at the point of the original 2642| | // throw statement in the code under test. For this reason, we perform 2643| | // the check early, sacrificing the ability to affect Google Test's 2644| | // exception handling in the method where the exception is thrown. 2645| 1| if (internal::GetUnitTestImpl()->catch_exceptions()) { ------------------ | Branch (2645:7): [True: 1, False: 0] ------------------ 2646| 1|#if GTEST_HAS_EXCEPTIONS 2647| 1| try { 2648| 1| return HandleSehExceptionsInMethodIfSupported(object, method, location); 2649| 1| } catch (const AssertionException&) { // NOLINT 2650| | // This failure was reported already. 2651| 0| } catch (const internal::GoogleTestFailureException&) { // NOLINT 2652| | // This exception type can only be thrown by a failed Google 2653| | // Test assertion with the intention of letting another testing 2654| | // framework catch it. Therefore we just re-throw it. 2655| 0| throw; 2656| 0| } catch (const std::exception& e) { // NOLINT 2657| 0| internal::ReportFailureInUnknownLocation( 2658| 0| TestPartResult::kFatalFailure, 2659| 0| FormatCxxExceptionMessage(e.what(), location)); 2660| 0| } catch (...) { // NOLINT 2661| 0| internal::ReportFailureInUnknownLocation( 2662| 0| TestPartResult::kFatalFailure, 2663| 0| FormatCxxExceptionMessage(nullptr, location)); 2664| 0| } 2665| 0| return static_cast(0); 2666| |#else 2667| | return HandleSehExceptionsInMethodIfSupported(object, method, location); 2668| |#endif // GTEST_HAS_EXCEPTIONS 2669| 1| } else { 2670| 0| return (object->*method)(); 2671| 0| } 2672| 1|} _ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_9TestSuiteEvEET0_PT_MS4_FS3_vEPKc: 2602| 1| const char* location) { 2603| |#if GTEST_HAS_SEH 2604| | __try { 2605| | return (object->*method)(); 2606| | } __except (internal::UnitTestOptions::GTestProcessSEH( // NOLINT 2607| | GetExceptionCode(), location)) { 2608| | return static_cast(0); 2609| | } 2610| |#else 2611| 1| (void)location; 2612| 1| return (object->*method)(); 2613| 1|#endif // GTEST_HAS_SEH 2614| 1|} _ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS0_12UnitTestImplEbEET0_PT_MS4_FS3_vEPKc: 2621| 1| const char* location) { 2622| | // NOTE: The user code can affect the way in which Google Test handles 2623| | // exceptions by setting GTEST_FLAG(catch_exceptions), but only before 2624| | // RUN_ALL_TESTS() starts. It is technically possible to check the flag 2625| | // after the exception is caught and either report or re-throw the 2626| | // exception based on the flag's value: 2627| | // 2628| | // try { 2629| | // // Perform the test method. 2630| | // } catch (...) { 2631| | // if (GTEST_FLAG_GET(catch_exceptions)) 2632| | // // Report the exception as failure. 2633| | // else 2634| | // throw; // Re-throws the original exception. 2635| | // } 2636| | // 2637| | // However, the purpose of this flag is to allow the program to drop into 2638| | // the debugger when the exception is thrown. On most platforms, once the 2639| | // control enters the catch block, the exception origin information is 2640| | // lost and the debugger will stop the program at the point of the 2641| | // re-throw in this function -- instead of at the point of the original 2642| | // throw statement in the code under test. For this reason, we perform 2643| | // the check early, sacrificing the ability to affect Google Test's 2644| | // exception handling in the method where the exception is thrown. 2645| 1| if (internal::GetUnitTestImpl()->catch_exceptions()) { ------------------ | Branch (2645:7): [True: 1, False: 0] ------------------ 2646| 1|#if GTEST_HAS_EXCEPTIONS 2647| 1| try { 2648| 1| return HandleSehExceptionsInMethodIfSupported(object, method, location); 2649| 1| } catch (const AssertionException&) { // NOLINT 2650| | // This failure was reported already. 2651| 0| } catch (const internal::GoogleTestFailureException&) { // NOLINT 2652| | // This exception type can only be thrown by a failed Google 2653| | // Test assertion with the intention of letting another testing 2654| | // framework catch it. Therefore we just re-throw it. 2655| 0| throw; 2656| 0| } catch (const std::exception& e) { // NOLINT 2657| 0| internal::ReportFailureInUnknownLocation( 2658| 0| TestPartResult::kFatalFailure, 2659| 0| FormatCxxExceptionMessage(e.what(), location)); 2660| 0| } catch (...) { // NOLINT 2661| 0| internal::ReportFailureInUnknownLocation( 2662| 0| TestPartResult::kFatalFailure, 2663| 0| FormatCxxExceptionMessage(nullptr, location)); 2664| 0| } 2665| 0| return static_cast(0); 2666| |#else 2667| | return HandleSehExceptionsInMethodIfSupported(object, method, location); 2668| |#endif // GTEST_HAS_EXCEPTIONS 2669| 1| } else { 2670| 0| return (object->*method)(); 2671| 0| } 2672| 1|} _ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS0_12UnitTestImplEbEET0_PT_MS4_FS3_vEPKc: 2602| 1| const char* location) { 2603| |#if GTEST_HAS_SEH 2604| | __try { 2605| | return (object->*method)(); 2606| | } __except (internal::UnitTestOptions::GTestProcessSEH( // NOLINT 2607| | GetExceptionCode(), location)) { 2608| | return static_cast(0); 2609| | } 2610| |#else 2611| 1| (void)location; 2612| 1| return (object->*method)(); 2613| 1|#endif // GTEST_HAS_SEH 2614| 1|} _ZN7testing8internal28ParseGoogleTestFlagsOnlyImplIcEEvPiPPT_: 6630| 1|void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { 6631| 1| std::string flagfile_value; 6632| 8| for (int i = 1; i < *argc; i++) { ------------------ | Branch (6632:19): [True: 7, False: 1] ------------------ 6633| 7| const std::string arg_string = StreamableToString(argv[i]); 6634| 7| const char* const arg = arg_string.c_str(); 6635| | 6636| 7| using internal::ParseFlag; 6637| | 6638| 7| bool remove_flag = false; 6639| 7| if (ParseGoogleTestFlag(arg)) { ------------------ | Branch (6639:9): [True: 0, False: 7] ------------------ 6640| 0| remove_flag = true; 6641| 0|#if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM 6642| 7| } else if (ParseFlag(arg, "flagfile", &flagfile_value)) { ------------------ | Branch (6642:16): [True: 0, False: 7] ------------------ 6643| 0| GTEST_FLAG_SET(flagfile, flagfile_value); ------------------ | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | ------------------ | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | ------------------ ------------------ 6644| 0| LoadFlagsFromFile(flagfile_value); 6645| 0| remove_flag = true; 6646| 0|#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM 6647| 7| } else if (arg_string == "--help" || HasGoogleTestFlagPrefix(arg)) { ------------------ | Branch (6647:16): [True: 0, False: 7] | Branch (6647:42): [True: 0, False: 7] ------------------ 6648| | // Both help flag and unrecognized Google Test flags (excluding 6649| | // internal ones) trigger help display. 6650| 0| g_help_flag = true; 6651| 0| } 6652| | 6653| 7| if (remove_flag) { ------------------ | Branch (6653:9): [True: 0, False: 7] ------------------ 6654| | // Shift the remainder of the argv list left by one. Note 6655| | // that argv has (*argc + 1) elements, the last one always being 6656| | // NULL. The following loop moves the trailing NULL element as 6657| | // well. 6658| 0| for (int j = i; j != *argc; j++) { ------------------ | Branch (6658:23): [True: 0, False: 0] ------------------ 6659| 0| argv[j] = argv[j + 1]; 6660| 0| } 6661| | 6662| | // Decrements the argument count. 6663| 0| (*argc)--; 6664| | 6665| | // We also need to decrement the iterator as we just removed 6666| | // an element. 6667| 0| i--; 6668| 0| } 6669| 7| } 6670| | 6671| 1| if (g_help_flag) { ------------------ | Branch (6671:7): [True: 0, False: 1] ------------------ 6672| | // We print the help here instead of in RUN_ALL_TESTS(), as the 6673| | // latter may not be called at all if the user is using Google 6674| | // Test with another testing framework. 6675| 0| PrintColorEncoded(kColorEncodedHelpMessage); 6676| 0| } 6677| 1|} gtest-all.cc:_ZN7testing8internalL19ParseGoogleTestFlagEPKc: 6574| 7|static bool ParseGoogleTestFlag(const char* const arg) { 6575| 7|#define GTEST_INTERNAL_PARSE_FLAG(flag_name) \ 6576| 7| do { \ 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ 6579| 7| GTEST_FLAG_SET(flag_name, value); \ 6580| 7| return true; \ 6581| 7| } \ 6582| 7| } while (false) 6583| | 6584| 7| GTEST_INTERNAL_PARSE_FLAG(also_run_disabled_tests); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6585| 7| GTEST_INTERNAL_PARSE_FLAG(break_on_failure); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6586| 7| GTEST_INTERNAL_PARSE_FLAG(catch_exceptions); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6587| 7| GTEST_INTERNAL_PARSE_FLAG(color); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6588| 7| GTEST_INTERNAL_PARSE_FLAG(death_test_style); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6589| 7| GTEST_INTERNAL_PARSE_FLAG(death_test_use_fork); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6590| 7| GTEST_INTERNAL_PARSE_FLAG(fail_fast); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6591| 7| GTEST_INTERNAL_PARSE_FLAG(filter); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6592| 7| GTEST_INTERNAL_PARSE_FLAG(internal_run_death_test); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6593| 7| GTEST_INTERNAL_PARSE_FLAG(list_tests); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6594| 7| GTEST_INTERNAL_PARSE_FLAG(output); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6595| 7| GTEST_INTERNAL_PARSE_FLAG(brief); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6596| 7| GTEST_INTERNAL_PARSE_FLAG(print_time); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6597| 7| GTEST_INTERNAL_PARSE_FLAG(print_utf8); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6598| 7| GTEST_INTERNAL_PARSE_FLAG(random_seed); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6599| 7| GTEST_INTERNAL_PARSE_FLAG(repeat); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6600| 7| GTEST_INTERNAL_PARSE_FLAG(recreate_environments_when_repeating); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6601| 7| GTEST_INTERNAL_PARSE_FLAG(shuffle); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6602| 7| GTEST_INTERNAL_PARSE_FLAG(stack_trace_depth); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6603| 7| GTEST_INTERNAL_PARSE_FLAG(stream_result_to); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6604| 7| GTEST_INTERNAL_PARSE_FLAG(throw_on_failure); ------------------ | | 6576| 7| do { \ | | 6577| 7| auto value = GTEST_FLAG_GET(flag_name); \ | | ------------------ | | | | 2293| 7|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) | | | | ------------------ | | | | | | 2226| 7|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6578| 7| if (ParseFlag(arg, #flag_name, &value)) { \ | | ------------------ | | | Branch (6578:9): [True: 0, False: 7] | | ------------------ | | 6579| 0| GTEST_FLAG_SET(flag_name, value); \ | | ------------------ | | | | 2294| 0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) | | | | ------------------ | | | | | | 2226| 0|#define GTEST_FLAG(name) FLAGS_gtest_##name | | | | ------------------ | | ------------------ | | 6580| 0| return true; \ | | 6581| 0| } \ | | 6582| 7| } while (false) | | ------------------ | | | Branch (6582:12): [Folded, False: 7] | | ------------------ ------------------ 6605| 7| return false; 6606| 7|} gtest-all.cc:_ZN7testing8internalL9ParseFlagEPKcS2_Pb: 6376| 84|static bool ParseFlag(const char* str, const char* flag_name, bool* value) { 6377| | // Gets the value of the flag as a string. 6378| 84| const char* const value_str = ParseFlagValue(str, flag_name, true); 6379| | 6380| | // Aborts if the parsing failed. 6381| 84| if (value_str == nullptr) return false; ------------------ | Branch (6381:7): [True: 84, False: 0] ------------------ 6382| | 6383| | // Converts the string value to a bool. 6384| 0| *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); ------------------ | Branch (6384:14): [True: 0, False: 0] | Branch (6384:35): [True: 0, False: 0] | Branch (6384:56): [True: 0, False: 0] ------------------ 6385| 0| return true; 6386| 84|} gtest-all.cc:_ZN7testing8internalL9ParseFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbPKcSA_PT_: 6409| 49|static bool ParseFlag(const char* str, const char* flag_name, String* value) { 6410| | // Gets the value of the flag as a string. 6411| 49| const char* const value_str = ParseFlagValue(str, flag_name, false); 6412| | 6413| | // Aborts if the parsing failed. 6414| 49| if (value_str == nullptr) return false; ------------------ | Branch (6414:7): [True: 49, False: 0] ------------------ 6415| | 6416| | // Sets *value to the value of the flag. 6417| 0| *value = value_str; 6418| 0| return true; 6419| 49|} gtest-all.cc:_ZN7testing8internalL23HasGoogleTestFlagPrefixEPKc: 6427| 7|static bool HasGoogleTestFlagPrefix(const char* str) { 6428| 7| return (SkipPrefix("--", &str) || SkipPrefix("-", &str) || ------------------ | Branch (6428:11): [True: 3, False: 4] | Branch (6428:37): [True: 2, False: 2] ------------------ 6429| 2| SkipPrefix("/", &str)) && ------------------ | Branch (6429:11): [True: 2, False: 0] ------------------ 6430| 7| !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) && ------------------ | | 331| 7|#define GTEST_FLAG_PREFIX_ "gtest_" ------------------ | Branch (6430:10): [True: 7, False: 0] ------------------ 6431| 7| (SkipPrefix(GTEST_FLAG_PREFIX_, &str) || ------------------ | | 331| 7|#define GTEST_FLAG_PREFIX_ "gtest_" ------------------ | Branch (6431:11): [True: 0, False: 7] ------------------ 6432| 7| SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str)); ------------------ | | 332| 7|#define GTEST_FLAG_PREFIX_DASH_ "gtest-" ------------------ | Branch (6432:11): [True: 0, False: 7] ------------------ 6433| 7|} _ZN7testing8internal18InitGoogleTestImplIcEEvPiPPT_: 6758| 1|void InitGoogleTestImpl(int* argc, CharType** argv) { 6759| | // We don't want to run the initialization code twice. 6760| 1| if (GTestIsInitialized()) return; ------------------ | Branch (6760:7): [True: 0, False: 1] ------------------ 6761| | 6762| 1| if (*argc <= 0) return; ------------------ | Branch (6762:7): [True: 0, False: 1] ------------------ 6763| | 6764| 1| g_argvs.clear(); 6765| 9| for (int i = 0; i != *argc; i++) { ------------------ | Branch (6765:19): [True: 8, False: 1] ------------------ 6766| 8| g_argvs.push_back(StreamableToString(argv[i])); 6767| 8| } 6768| | 6769| |#ifdef GTEST_HAS_ABSL 6770| | absl::InitializeSymbolizer(g_argvs[0].c_str()); 6771| | 6772| | // When using the Abseil Flags library, set the program usage message to the 6773| | // help message, but remove the color-encoding from the message first. 6774| | absl::SetProgramUsageMessage(absl::StrReplaceAll( 6775| | kColorEncodedHelpMessage, 6776| | {{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}})); 6777| |#endif // GTEST_HAS_ABSL 6778| | 6779| 1| ParseGoogleTestFlagsOnly(argc, argv); 6780| 1| GetUnitTestImpl()->PostFlagParsingInit(); 6781| 1|} avifPeekCompatibleFileType: 5039| 98|{ 5040| 98| BEGIN_STREAM(s, input->data, input->size, NULL, NULL); ------------------ | | 738| 98| avifROStream VARNAME; \ | | 739| 98| avifROData VARNAME##_roData; \ | | 740| 98| VARNAME##_roData.data = PTR; \ | | 741| 98| VARNAME##_roData.size = SIZE; \ | | 742| 98| avifROStreamStart(&VARNAME, &VARNAME##_roData, DIAG, CONTEXT) ------------------ 5041| | 5042| 98| avifBoxHeader header; 5043| 98| if (!avifROStreamReadBoxHeaderPartial(&s, &header, /*topLevel=*/AVIF_TRUE) || memcmp(header.type, "ftyp", 4)) { ------------------ | | 88| 98|#define AVIF_TRUE 1 ------------------ | Branch (5043:9): [True: 0, False: 98] | Branch (5043:83): [True: 34, False: 64] ------------------ 5044| 34| return AVIF_FALSE; ------------------ | | 89| 34|#define AVIF_FALSE 0 ------------------ 5045| 34| } 5046| 64| if (header.isSizeZeroBox) { ------------------ | Branch (5046:9): [True: 0, False: 64] ------------------ 5047| | // The ftyp box goes on till the end of the file. Either there is no brand requiring anything in the file but a 5048| | // FileTypebox (so not AVIF), or it is invalid. 5049| 0| return AVIF_FALSE; ------------------ | | 89| 0|#define AVIF_FALSE 0 ------------------ 5050| 0| } 5051| 64| AVIF_CHECK(avifROStreamHasBytesLeft(&s, header.size)); ------------------ | | 36| 64| do { \ | | 37| 64| if (!(A)) { \ | | ------------------ | | | Branch (37:13): [True: 0, False: 64] | | ------------------ | | 38| 0| avifBreakOnError(); \ | | 39| 0| return AVIF_FALSE; \ | | ------------------ | | | | 89| 0|#define AVIF_FALSE 0 | | ------------------ | | 40| 0| } \ | | 41| 64| } while (0) | | ------------------ | | | Branch (41:14): [Folded, False: 64] | | ------------------ ------------------ 5052| | 5053| 64| avifFileType ftyp; 5054| 64| memset(&ftyp, 0, sizeof(avifFileType)); 5055| 64| avifBool parsed = avifParseFileTypeBox(&ftyp, avifROStreamCurrent(&s), header.size, NULL); 5056| 64| if (!parsed) { ------------------ | Branch (5056:9): [True: 0, False: 64] ------------------ 5057| 0| return AVIF_FALSE; ------------------ | | 89| 0|#define AVIF_FALSE 0 ------------------ 5058| 0| } 5059| 64| return avifFileTypeIsCompatible(&ftyp); 5060| 64|} read.c:avifParseFileTypeBox: 4780| 64|{ 4781| 64| BEGIN_STREAM(s, raw, rawLen, diag, "Box[ftyp]"); ------------------ | | 738| 64| avifROStream VARNAME; \ | | 739| 64| avifROData VARNAME##_roData; \ | | 740| 64| VARNAME##_roData.data = PTR; \ | | 741| 64| VARNAME##_roData.size = SIZE; \ | | 742| 64| avifROStreamStart(&VARNAME, &VARNAME##_roData, DIAG, CONTEXT) ------------------ 4782| | 4783| 64| AVIF_CHECK(avifROStreamRead(&s, ftyp->majorBrand, 4)); ------------------ | | 36| 64| do { \ | | 37| 64| if (!(A)) { \ | | ------------------ | | | Branch (37:13): [True: 0, False: 64] | | ------------------ | | 38| 0| avifBreakOnError(); \ | | 39| 0| return AVIF_FALSE; \ | | ------------------ | | | | 89| 0|#define AVIF_FALSE 0 | | ------------------ | | 40| 0| } \ | | 41| 64| } while (0) | | ------------------ | | | Branch (41:14): [Folded, False: 64] | | ------------------ ------------------ 4784| 64| AVIF_CHECK(avifROStreamRead(&s, ftyp->minorVersion, 4)); ------------------ | | 36| 64| do { \ | | 37| 64| if (!(A)) { \ | | ------------------ | | | Branch (37:13): [True: 0, False: 64] | | ------------------ | | 38| 0| avifBreakOnError(); \ | | 39| 0| return AVIF_FALSE; \ | | ------------------ | | | | 89| 0|#define AVIF_FALSE 0 | | ------------------ | | 40| 0| } \ | | 41| 64| } while (0) | | ------------------ | | | Branch (41:14): [Folded, False: 64] | | ------------------ ------------------ 4785| | 4786| 64| size_t compatibleBrandsBytes = avifROStreamRemainingBytes(&s); 4787| 64| if ((compatibleBrandsBytes % 4) != 0) { ------------------ | Branch (4787:9): [True: 0, False: 64] ------------------ 4788| 0| avifDiagnosticsPrintf(diag, "Box[ftyp] contains a compatible brands section that isn't divisible by 4 [%zu]", compatibleBrandsBytes); 4789| 0| return AVIF_FALSE; ------------------ | | 89| 0|#define AVIF_FALSE 0 ------------------ 4790| 0| } 4791| 64| ftyp->compatibleBrands = avifROStreamCurrent(&s); 4792| 64| AVIF_CHECK(avifROStreamSkip(&s, compatibleBrandsBytes)); ------------------ | | 36| 64| do { \ | | 37| 64| if (!(A)) { \ | | ------------------ | | | Branch (37:13): [True: 0, False: 64] | | ------------------ | | 38| 0| avifBreakOnError(); \ | | 39| 0| return AVIF_FALSE; \ | | ------------------ | | | | 89| 0|#define AVIF_FALSE 0 | | ------------------ | | 40| 0| } \ | | 41| 64| } while (0) | | ------------------ | | | Branch (41:14): [Folded, False: 64] | | ------------------ ------------------ 4793| 64| ftyp->compatibleBrandsCount = (int)compatibleBrandsBytes / 4; 4794| | 4795| 64| return AVIF_TRUE; ------------------ | | 88| 64|#define AVIF_TRUE 1 ------------------ 4796| 64|} read.c:avifFileTypeIsCompatible: 5030| 64|{ 5031| 64| return avifFileTypeHasBrand(ftyp, "avif") || avifFileTypeHasBrand(ftyp, "avis") ------------------ | Branch (5031:12): [True: 64, False: 0] | Branch (5031:50): [True: 0, False: 0] ------------------ 5032| |#if defined(AVIF_ENABLE_EXPERIMENTAL_MINI) 5033| | || avifFileTypeHasBrand(ftyp, "mif3") 5034| |#endif // AVIF_ENABLE_EXPERIMENTAL_MINI 5035| 64| ; 5036| 64|} read.c:avifFileTypeHasBrand: 5015| 64|{ 5016| 64| if (!memcmp(ftyp->majorBrand, brand, 4)) { ------------------ | Branch (5016:9): [True: 58, False: 6] ------------------ 5017| 58| return AVIF_TRUE; ------------------ | | 88| 58|#define AVIF_TRUE 1 ------------------ 5018| 58| } 5019| | 5020| 6| for (int compatibleBrandIndex = 0; compatibleBrandIndex < ftyp->compatibleBrandsCount; ++compatibleBrandIndex) { ------------------ | Branch (5020:40): [True: 6, False: 0] ------------------ 5021| 6| const uint8_t * compatibleBrand = &ftyp->compatibleBrands[4 * compatibleBrandIndex]; 5022| 6| if (!memcmp(compatibleBrand, brand, 4)) { ------------------ | Branch (5022:13): [True: 6, False: 0] ------------------ 5023| 6| return AVIF_TRUE; ------------------ | | 88| 6|#define AVIF_TRUE 1 ------------------ 5024| 6| } 5025| 6| } 5026| 0| return AVIF_FALSE; ------------------ | | 89| 0|#define AVIF_FALSE 0 ------------------ 5027| 6|} avifROStreamCurrent: 15| 128|{ 16| 128| return stream->raw->data + stream->offset; 17| 128|} avifROStreamStart: 20| 162|{ 21| 162| stream->raw = raw; 22| 162| stream->offset = 0; 23| 162| stream->numUsedBitsInPartialByte = 0; 24| 162| stream->diag = diag; 25| 162| stream->diagContext = diagContext; 26| | 27| | // If diag is non-NULL, diagContext must also be non-NULL 28| | assert(!stream->diag || stream->diagContext); 29| 162|} avifROStreamHasBytesLeft: 32| 452|{ 33| 452| return byteCount <= (stream->raw->size - stream->offset); 34| 452|} avifROStreamRemainingBytes: 37| 64|{ 38| 64| return stream->raw->size - stream->offset; 39| 64|} avifROStreamSkip: 56| 64|{ 57| 64| assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required. 58| 64| if (!avifROStreamHasBytesLeft(stream, byteCount)) { ------------------ | Branch (58:9): [True: 0, False: 64] ------------------ 59| 0| avifDiagnosticsPrintf(stream->diag, "%s: Failed to skip %zu bytes, truncated data?", stream->diagContext, byteCount); 60| 0| return AVIF_FALSE; ------------------ | | 89| 0|#define AVIF_FALSE 0 ------------------ 61| 0| } 62| 64| stream->offset += byteCount; 63| 64| return AVIF_TRUE; ------------------ | | 88| 64|#define AVIF_TRUE 1 ------------------ 64| 64|} avifROStreamRead: 67| 324|{ 68| 324| assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required. 69| 324| if (!avifROStreamHasBytesLeft(stream, size)) { ------------------ | Branch (69:9): [True: 0, False: 324] ------------------ 70| 0| avifDiagnosticsPrintf(stream->diag, "%s: Failed to read %zu bytes, truncated data?", stream->diagContext, size); 71| 0| return AVIF_FALSE; ------------------ | | 89| 0|#define AVIF_FALSE 0 ------------------ 72| 0| } 73| | 74| 324| memcpy(data, stream->raw->data + stream->offset, size); 75| 324| stream->offset += size; 76| 324| return AVIF_TRUE; ------------------ | | 88| 324|#define AVIF_TRUE 1 ------------------ 77| 324|} avifROStreamReadU32: 126| 98|{ 127| 98| assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required. 128| 98| AVIF_CHECK(avifROStreamRead(stream, (uint8_t *)v, sizeof(uint32_t))); ------------------ | | 36| 98| do { \ | | 37| 98| if (!(A)) { \ | | ------------------ | | | Branch (37:13): [True: 0, False: 98] | | ------------------ | | 38| 0| avifBreakOnError(); \ | | 39| 0| return AVIF_FALSE; \ | | ------------------ | | | | 89| 0|#define AVIF_FALSE 0 | | ------------------ | | 40| 0| } \ | | 41| 98| } while (0) | | ------------------ | | | Branch (41:14): [Folded, False: 98] | | ------------------ ------------------ 129| 98| *v = avifNTOHL(*v); 130| 98| return AVIF_TRUE; ------------------ | | 88| 98|#define AVIF_TRUE 1 ------------------ 131| 98|} avifROStreamReadBoxHeaderPartial: 249| 98|{ 250| | // Section 4.2.2 of ISO/IEC 14496-12. 251| 98| size_t startOffset = stream->offset; 252| | 253| 98| uint32_t smallSize; 254| 98| AVIF_CHECK(avifROStreamReadU32(stream, &smallSize)); // unsigned int(32) size; ------------------ | | 36| 98| do { \ | | 37| 98| if (!(A)) { \ | | ------------------ | | | Branch (37:13): [True: 0, False: 98] | | ------------------ | | 38| 0| avifBreakOnError(); \ | | 39| 0| return AVIF_FALSE; \ | | ------------------ | | | | 89| 0|#define AVIF_FALSE 0 | | ------------------ | | 40| 0| } \ | | 41| 98| } while (0) | | ------------------ | | | Branch (41:14): [Folded, False: 98] | | ------------------ ------------------ 255| 98| AVIF_CHECK(avifROStreamRead(stream, header->type, 4)); // unsigned int(32) type = boxtype; ------------------ | | 36| 98| do { \ | | 37| 98| if (!(A)) { \ | | ------------------ | | | Branch (37:13): [True: 0, False: 98] | | ------------------ | | 38| 0| avifBreakOnError(); \ | | 39| 0| return AVIF_FALSE; \ | | ------------------ | | | | 89| 0|#define AVIF_FALSE 0 | | ------------------ | | 40| 0| } \ | | 41| 98| } while (0) | | ------------------ | | | Branch (41:14): [Folded, False: 98] | | ------------------ ------------------ 256| | 257| 98| uint64_t size = smallSize; 258| 98| if (size == 1) { ------------------ | Branch (258:9): [True: 0, False: 98] ------------------ 259| 0| AVIF_CHECK(avifROStreamReadU64(stream, &size)); // unsigned int(64) largesize; ------------------ | | 36| 0| do { \ | | 37| 0| if (!(A)) { \ | | ------------------ | | | Branch (37:13): [True: 0, False: 0] | | ------------------ | | 38| 0| avifBreakOnError(); \ | | 39| 0| return AVIF_FALSE; \ | | ------------------ | | | | 89| 0|#define AVIF_FALSE 0 | | ------------------ | | 40| 0| } \ | | 41| 0| } while (0) | | ------------------ | | | Branch (41:14): [Folded, False: 0] | | ------------------ ------------------ 260| 0| } 261| | 262| 98| if (!memcmp(header->type, "uuid", 4)) { ------------------ | Branch (262:9): [True: 0, False: 98] ------------------ 263| 0| AVIF_CHECK(avifROStreamRead(stream, header->usertype, 16)); // unsigned int(8) usertype[16] = extended_type; ------------------ | | 36| 0| do { \ | | 37| 0| if (!(A)) { \ | | ------------------ | | | Branch (37:13): [True: 0, False: 0] | | ------------------ | | 38| 0| avifBreakOnError(); \ | | 39| 0| return AVIF_FALSE; \ | | ------------------ | | | | 89| 0|#define AVIF_FALSE 0 | | ------------------ | | 40| 0| } \ | | 41| 0| } while (0) | | ------------------ | | | Branch (41:14): [Folded, False: 0] | | ------------------ ------------------ 264| 98| } else { 265| 98| memset(header->usertype, 0, sizeof(header->usertype)); 266| 98| } 267| | 268| 98| size_t bytesRead = stream->offset - startOffset; 269| 98| if (size == 0) { ------------------ | Branch (269:9): [True: 0, False: 98] ------------------ 270| | // Section 4.2.2 of ISO/IEC 14496-12. 271| | // if size is 0, then this box shall be in a top-level box (i.e. not contained in another 272| | // box), and be the last box in its 'file', and its payload extends to the end of that 273| | // enclosing 'file'. This is normally only used for a MediaDataBox ('mdat'). 274| 0| if (!topLevel) { ------------------ | Branch (274:13): [True: 0, False: 0] ------------------ 275| 0| avifDiagnosticsPrintf(stream->diag, "%s: Non-top-level box with size 0", stream->diagContext); 276| 0| return AVIF_FALSE; ------------------ | | 89| 0|#define AVIF_FALSE 0 ------------------ 277| 0| } 278| | 279| | // The given stream may be incomplete and there is no guarantee that sizeHint is available and accurate. 280| | // Otherwise size could be set to avifROStreamRemainingBytes(stream) + (stream->offset - startOffset) right now. 281| | 282| | // Wait for avifIOReadFunc() to return AVIF_RESULT_OK. 283| 0| header->isSizeZeroBox = AVIF_TRUE; ------------------ | | 88| 0|#define AVIF_TRUE 1 ------------------ 284| 0| header->size = 0; 285| 0| return AVIF_TRUE; ------------------ | | 88| 0|#define AVIF_TRUE 1 ------------------ 286| 0| } 287| | 288| 98| if ((size < bytesRead) || ((size - bytesRead) > SIZE_MAX)) { ------------------ | Branch (288:9): [True: 0, False: 98] | Branch (288:31): [True: 0, False: 98] ------------------ 289| 0| avifDiagnosticsPrintf(stream->diag, "%s: Header size overflow check failure", stream->diagContext); 290| 0| return AVIF_FALSE; ------------------ | | 89| 0|#define AVIF_FALSE 0 ------------------ 291| 0| } 292| 98| header->isSizeZeroBox = AVIF_FALSE; ------------------ | | 89| 98|#define AVIF_FALSE 0 ------------------ 293| 98| header->size = (size_t)(size - bytesRead); 294| 98| return AVIF_TRUE; ------------------ | | 88| 98|#define AVIF_TRUE 1 ------------------ 295| 98|} avifNTOHL: 51| 98|{ 52| 98| const uint8_t * data = (const uint8_t *)&l; 53| 98| return ((uint32_t)data[3] << 0) | ((uint32_t)data[2] << 8) | ((uint32_t)data[1] << 16) | ((uint32_t)data[0] << 24); 54| 98|} _ZN4avif8testutil15GetSeedDataDirsEv: 243| 1|std::vector GetSeedDataDirs() { 244| 1| const char* var = std::getenv("TEST_DATA_DIRS"); 245| 1| std::vector res; 246| 1| if (var == nullptr || *var == 0) return res; ------------------ | Branch (246:7): [True: 0, False: 1] | Branch (246:25): [True: 0, False: 1] ------------------ 247| 1| const char* var_start = var; 248| 48| while (true) { ------------------ | Branch (248:10): [True: 48, Folded] ------------------ 249| 48| if (*var == 0 || *var == ';') { ------------------ | Branch (249:9): [True: 1, False: 47] | Branch (249:22): [True: 0, False: 47] ------------------ 250| 1| res.push_back(std::string(var_start, var - var_start)); 251| 1| if (*var == 0) break; ------------------ | Branch (251:11): [True: 1, False: 0] ------------------ 252| 0| var_start = var + 1; 253| 0| } 254| 47| ++var; 255| 47| } 256| 1| return res; 257| 1|} _ZN4avif8testutil21GetTestImagesContentsEmRKNSt3__16vectorI17avifAppFileFormatNS1_9allocatorIS3_EEEE: 260| 1| size_t max_file_size, const std::vector& image_formats) { 261| | // Use an environment variable to get the test data directory because 262| | // fuzztest seeds are created before the main() function is called, so the 263| | // test has no chance to parse command line arguments. 264| 1| const std::vector test_data_dirs = GetSeedDataDirs(); 265| 1| if (test_data_dirs.empty()) { ------------------ | Branch (265:7): [True: 0, False: 1] ------------------ 266| | // Only a warning because this can happen when running the binary with 267| | // --list_fuzz_tests (such as with gtest_discover_tests() in cmake). 268| 0| std::cerr << "WARNING: TEST_DATA_DIRS env variable not set, unable to read " 269| 0| "seed files\n"; 270| 0| return {}; 271| 0| } 272| | 273| 1| std::vector seeds; 274| 1| for (const std::string& test_data_dir : test_data_dirs) { ------------------ | Branch (274:41): [True: 1, False: 1] ------------------ 275| 1| std::cout << "Reading seeds from " << test_data_dir 276| 1| << " (non recursively)\n"; 277| 1| auto tuple_vector = fuzztest::ReadFilesFromDirectory(test_data_dir); 278| 1| seeds.reserve(tuple_vector.size()); 279| 101| for (auto& [file_content] : tuple_vector) { ------------------ | Branch (279:31): [True: 101, False: 1] ------------------ 280| 101| if (file_content.size() > max_file_size) continue; ------------------ | Branch (280:11): [True: 3, False: 98] ------------------ 281| 98| if (!image_formats.empty()) { ------------------ | Branch (281:11): [True: 98, False: 0] ------------------ 282| 98| const avifAppFileFormat format = avifGuessBufferFileFormat( 283| 98| reinterpret_cast(file_content.data()), 284| 98| file_content.size()); 285| 98| if (std::find(image_formats.begin(), image_formats.end(), format) == ------------------ | Branch (285:13): [True: 66, False: 32] ------------------ 286| 98| image_formats.end()) { 287| 66| continue; 288| 66| } 289| 98| } 290| | 291| 32| seeds.push_back(std::move(file_content)); 292| 32| } 293| 1| } 294| 1| if (seeds.empty()) { ------------------ | Branch (294:7): [True: 0, False: 1] ------------------ 295| 0| std::cerr << "ERROR: no files found that match the given file size and " 296| 0| "format criteria\n"; 297| 0| std::abort(); 298| 0| } 299| 1| std::cout << "Returning " << seeds.size() << " seed images\n"; 300| 1| return seeds; 301| 1|} _ZN4avif8testutil20ArbitraryPixelFormatEv: 95| 1|inline auto ArbitraryPixelFormat() { 96| 1| return fuzztest::ElementOf( 97| 1| {AVIF_PIXEL_FORMAT_YUV444, AVIF_PIXEL_FORMAT_YUV422, 98| 1| AVIF_PIXEL_FORMAT_YUV420, AVIF_PIXEL_FORMAT_YUV400}); 99| 1|} _ZN4avif8testutil23ArbitraryImageWithSeedsERKNSt3__16vectorI17avifAppFileFormatNS1_9allocatorIS3_EEEE: 370| 1| const std::vector& image_formats) { 371| 1| constexpr uint32_t kMaxSeedFileSize = 1024 * 1024; // 1MB. 372| 1| return fuzztest::Arbitrary() 373| 1| .WithMaxSize(kMaxSeedFileSize) 374| 1| .WithSeeds(GetTestImagesContents(kMaxSeedFileSize, image_formats)); 375| 1|}