_ZN4absl10big_endian7Store64EPvm: 273| 631|inline void Store64(void *p, uint64_t v) { 274| 631| ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v)); ------------------ | | 78| 631| (absl::base_internal::UnalignedStore64(_p, _val)) ------------------ 275| 631|} _ZN4absl10big_endian10FromHost64Em: 202| 631|inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); } _ZN4absl9gbswap_64Em: 30| 1.26k|inline uint64_t gbswap_64(uint64_t host_int) { 31| 1.26k|#if ABSL_HAVE_BUILTIN(__builtin_bswap64) || defined(__GNUC__) 32| 1.26k| return __builtin_bswap64(host_int); 33| |#elif defined(_MSC_VER) 34| | return _byteswap_uint64(host_int); 35| |#else 36| | return (((host_int & uint64_t{0xFF}) << 56) | 37| | ((host_int & uint64_t{0xFF00}) << 40) | 38| | ((host_int & uint64_t{0xFF0000}) << 24) | 39| | ((host_int & uint64_t{0xFF000000}) << 8) | 40| | ((host_int & uint64_t{0xFF00000000}) >> 8) | 41| | ((host_int & uint64_t{0xFF0000000000}) >> 24) | 42| | ((host_int & uint64_t{0xFF000000000000}) >> 40) | 43| | ((host_int & uint64_t{0xFF00000000000000}) >> 56)); 44| |#endif 45| 1.26k|} _ZN4absl10big_endian8ToHost64Em: 203| 630|inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); } _ZN4absl13little_endian10FromHost16Et: 106| 48|inline uint16_t FromHost16(uint16_t x) { return x; } _ZN4absl13little_endian10FromHost32Ej: 109| 84|inline uint32_t FromHost32(uint32_t x) { return x; } _ZN4absl13little_endian10FromHost64Em: 112| 719|inline uint64_t FromHost64(uint64_t x) { return x; } _ZN4absl13little_endian7Store16EPvt: 167| 48|inline void Store16(void *p, uint16_t v) { 168| 48| ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v)); ------------------ | | 74| 48| (absl::base_internal::UnalignedStore16(_p, _val)) ------------------ 169| 48|} _ZN4absl13little_endian7Store32EPvj: 175| 84|inline void Store32(void *p, uint32_t v) { 176| 84| ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v)); ------------------ | | 76| 84| (absl::base_internal::UnalignedStore32(_p, _val)) ------------------ 177| 84|} _ZN4absl13little_endian7Store64EPvm: 183| 719|inline void Store64(void *p, uint64_t v) { 184| 719| ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v)); ------------------ | | 78| 719| (absl::base_internal::UnalignedStore64(_p, _val)) ------------------ 185| 719|} _ZN4absl13base_internal16UnalignedStore64EPvm: 60| 1.35k|inline void UnalignedStore64(void *p, uint64_t v) { memcpy(p, &v, sizeof v); } _ZN4absl13base_internal16UnalignedStore16EPvt: 56| 48|inline void UnalignedStore16(void *p, uint16_t v) { memcpy(p, &v, sizeof v); } _ZN4absl13base_internal16UnalignedStore32EPvj: 58| 84|inline void UnalignedStore32(void *p, uint32_t v) { memcpy(p, &v, sizeof v); } _ZN4absl11countr_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES3_: 118| 304| countr_zero(T x) noexcept { 119| 304| return numeric_internal::CountTrailingZeroes(x); 120| 304|} _ZN4absl11countr_zeroIjEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES3_: 118| 84| countr_zero(T x) noexcept { 119| 84| return numeric_internal::CountTrailingZeroes(x); 120| 84|} _ZN4absl16numeric_internal28CountTrailingZeroesNonzero32Ej: 251| 84|CountTrailingZeroesNonzero32(uint32_t x) { 252| 84|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz) 253| 84| static_assert(sizeof(unsigned int) == sizeof(x), 254| 84| "__builtin_ctz does not take 32-bit arg"); 255| 84| 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| 84|} _ZN4absl16numeric_internal28CountTrailingZeroesNonzero64Em: 273| 304|CountTrailingZeroesNonzero64(uint64_t x) { 274| 304|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll) 275| 304| static_assert(sizeof(unsigned long long) == sizeof(x), // NOLINT(runtime/int) 276| 304| "__builtin_ctzll does not take 64-bit arg"); 277| 304| return __builtin_ctzll(x); 278| |#elif defined(_MSC_VER) && !defined(__clang__) && \ 279| | (defined(_M_X64) || defined(_M_ARM64)) 280| | unsigned long result = 0; // NOLINT(runtime/int) 281| | _BitScanForward64(&result, x); 282| | return result; 283| |#elif defined(_MSC_VER) && !defined(__clang__) 284| | unsigned long result = 0; // NOLINT(runtime/int) 285| | if (static_cast(x) == 0) { 286| | _BitScanForward(&result, static_cast(x >> 32)); 287| | return result + 32; 288| | } 289| | _BitScanForward(&result, static_cast(x)); 290| | return result; 291| |#else 292| | int c = 63; 293| | x &= ~x + 1; 294| | if (x & 0x00000000FFFFFFFF) c -= 32; 295| | if (x & 0x0000FFFF0000FFFF) c -= 16; 296| | if (x & 0x00FF00FF00FF00FF) c -= 8; 297| | if (x & 0x0F0F0F0F0F0F0F0F) c -= 4; 298| | if (x & 0x3333333333333333) c -= 2; 299| | if (x & 0x5555555555555555) c -= 1; 300| | return c; 301| |#endif 302| 304|} _ZN4absl16numeric_internal19CountTrailingZeroesImEEiT_: 317| 304|CountTrailingZeroes(T x) noexcept { 318| 304| static_assert(std::is_unsigned::value, "T must be unsigned"); 319| 304| static_assert(IsPowerOf2(std::numeric_limits::digits), 320| 304| "T must have a power-of-2 size"); 321| 304| static_assert(sizeof(T) <= sizeof(uint64_t), "T too large"); 322| 304| return x == 0 ? std::numeric_limits::digits ------------------ | Branch (322:10): [True: 0, False: 304] ------------------ 323| 304| : (sizeof(T) <= sizeof(uint16_t) ------------------ | Branch (323:20): [Folded - Ignored] ------------------ 324| 304| ? CountTrailingZeroesNonzero16(static_cast(x)) 325| 304| : (sizeof(T) <= sizeof(uint32_t) ------------------ | Branch (325:27): [Folded - Ignored] ------------------ 326| 304| ? CountTrailingZeroesNonzero32( 327| 0| static_cast(x)) 328| 304| : CountTrailingZeroesNonzero64(x))); 329| 304|} _ZN4absl16numeric_internal19CountTrailingZeroesIjEEiT_: 317| 84|CountTrailingZeroes(T x) noexcept { 318| 84| static_assert(std::is_unsigned::value, "T must be unsigned"); 319| 84| static_assert(IsPowerOf2(std::numeric_limits::digits), 320| 84| "T must have a power-of-2 size"); 321| 84| static_assert(sizeof(T) <= sizeof(uint64_t), "T too large"); 322| 84| return x == 0 ? std::numeric_limits::digits ------------------ | Branch (322:10): [True: 0, False: 84] ------------------ 323| 84| : (sizeof(T) <= sizeof(uint16_t) ------------------ | Branch (323:20): [Folded - Ignored] ------------------ 324| 84| ? CountTrailingZeroesNonzero16(static_cast(x)) 325| 84| : (sizeof(T) <= sizeof(uint32_t) ------------------ | Branch (325:27): [Folded - Ignored] ------------------ 326| 84| ? CountTrailingZeroesNonzero32( 327| 84| static_cast(x)) 328| 84| : CountTrailingZeroesNonzero64(x))); 329| 84|} _ZN4absl14ascii_isxdigitEh: 125| 20.9k|inline bool ascii_isxdigit(unsigned char c) { 126| 20.9k| return (ascii_internal::kPropertyBits[c] & 0x80) != 0; 127| 20.9k|} _ZN4absl13ascii_isspaceEh: 96| 3.39M|inline bool ascii_isspace(unsigned char c) { 97| 3.39M| return (ascii_internal::kPropertyBits[c] & 0x08) != 0; 98| 3.39M|} _ZN4absl16HexStringToBytesENS_11string_viewE: 922| 631|std::string HexStringToBytes(absl::string_view from) { 923| 631| std::string result; 924| 631| const auto num = from.size() / 2; 925| 631| strings_internal::STLStringResizeUninitialized(&result, num); 926| 631| absl::HexStringToBytesInternal(from.data(), result, num); 927| 631| return result; 928| 631|} _ZN4absl16BytesToHexStringENS_11string_viewE: 930| 630|std::string BytesToHexString(absl::string_view from) { 931| 630| std::string result; 932| 630| strings_internal::STLStringResizeUninitialized(&result, 2 * from.size()); 933| 630| absl::BytesToHexStringInternal( 934| 630| reinterpret_cast(from.data()), result, from.size()); 935| 630| return result; 936| 630|} escaping.cc:_ZN4absl12_GLOBAL__N_124HexStringToBytesInternalIRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvPKcT_m: 838| 631|void HexStringToBytesInternal(const char* from, T to, size_t num) { 839| 10.7k| for (size_t i = 0; i < num; i++) { ------------------ | Branch (839:22): [True: 10.0k, False: 631] ------------------ 840| 10.0k| to[i] = static_cast(kHexValueLenient[from[i * 2] & 0xFF] << 4) + 841| 10.0k| (kHexValueLenient[from[i * 2 + 1] & 0xFF]); 842| 10.0k| } 843| 631|} escaping.cc:_ZN4absl12_GLOBAL__N_124BytesToHexStringInternalIRNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvPKhT_m: 848| 630|void BytesToHexStringInternal(const unsigned char* src, T dest, size_t num) { 849| 630| auto dest_ptr = &dest[0]; 850| 10.7k| for (auto src_ptr = src; src_ptr != (src + num); ++src_ptr, dest_ptr += 2) { ------------------ | Branch (850:28): [True: 10.0k, False: 630] ------------------ 851| 10.0k| const char* hex_p = &numbers_internal::kHexTable[*src_ptr * 2]; 852| 10.0k| std::copy(hex_p, hex_p + 2, dest_ptr); 853| 10.0k| } 854| 630|} _ZN4absl16strings_internal28STLStringResizeUninitializedINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvEEvPT_m: 67| 1.89k|inline void STLStringResizeUninitialized(string_type* s, size_t new_size) { 68| 1.89k| ResizeUninitializedTraits::Resize(s, new_size); 69| 1.89k|} _ZN4absl16strings_internal25ResizeUninitializedTraitsINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEvE6ResizeEPS8_m: 47| 1.89k| static void Resize(string_type* s, size_t new_size) { 48| 1.89k| s->__resize_default_init(new_size); 49| 1.89k| } _ZN4absl16numbers_internal15FastIntToBufferEmPc: 314| 630|char* numbers_internal::FastIntToBuffer(uint64_t i, char* buffer) { 315| 630| buffer = EncodeFullU64(i, buffer); 316| 630| *buffer = '\0'; 317| 630| return buffer; 318| 630|} _ZN4absl16numbers_internal18safe_strtou64_baseENS_11string_viewEPmi: 1122| 910|bool safe_strtou64_base(absl::string_view text, uint64_t* value, int base) { 1123| 910| return safe_uint_internal(text, value, base); 1124| 910|} numbers.cc:_ZN4absl12_GLOBAL__N_113EncodeFullU32EjPc: 236| 546| char* out_str) { 237| 546| if (n < 10) { ------------------ | Branch (237:7): [True: 194, False: 352] ------------------ 238| 194| *out_str = static_cast('0' + n); 239| 194| return out_str + 1; 240| 194| } 241| 352| if (n < 100'000'000) { ------------------ | Branch (241:7): [True: 304, False: 48] ------------------ 242| 304| uint64_t bottom = PrepareEightDigits(n); 243| 304| ABSL_ASSUME(bottom != 0); ------------------ | | 259| 304|#define ABSL_ASSUME(cond) __builtin_assume(cond) ------------------ 244| | // 0 minus 8 to make MSVC happy. 245| 304| uint32_t zeroes = 246| 304| static_cast(absl::countr_zero(bottom)) & (0 - 8u); 247| 304| little_endian::Store64(out_str, (bottom + kEightZeroBytes) >> zeroes); 248| 304| return out_str + sizeof(bottom) - zeroes / 8; 249| 304| } 250| 48| uint32_t div08 = n / 100'000'000; 251| 48| uint32_t mod08 = n % 100'000'000; 252| 48| uint64_t bottom = PrepareEightDigits(mod08) + kEightZeroBytes; 253| 48| out_str = EncodeHundred(div08, out_str); 254| 48| little_endian::Store64(out_str, bottom); 255| 48| return out_str + sizeof(bottom); 256| 352|} numbers.cc:_ZN4absl12_GLOBAL__N_118PrepareEightDigitsEj: 219| 719|inline uint64_t PrepareEightDigits(uint32_t i) { 220| 719| ABSL_ASSUME(i < 10000'0000); ------------------ | | 259| 719|#define ABSL_ASSUME(cond) __builtin_assume(cond) ------------------ 221| | // Prepare 2 blocks of 4 digits "in parallel". 222| 719| uint32_t hi = i / 10000; 223| 719| uint32_t lo = i % 10000; 224| 719| uint64_t merged = hi | (uint64_t{lo} << 32); 225| 719| uint64_t div100 = ((merged * kDivisionBy100Mul) / kDivisionBy100Div) & 226| 719| ((0x7Full << 32) | 0x7Full); 227| 719| uint64_t mod100 = merged - 100ull * div100; 228| 719| uint64_t hundreds = (mod100 << 16) + div100; 229| 719| uint64_t tens = (hundreds * kDivisionBy10Mul) / kDivisionBy10Div; 230| 719| tens &= (0xFull << 48) | (0xFull << 32) | (0xFull << 16) | 0xFull; 231| 719| tens += (hundreds - 10ull * tens) << 8; 232| 719| return tens; 233| 719|} numbers.cc:_ZN4absl12_GLOBAL__N_113EncodeHundredEjPc: 169| 48|inline char* EncodeHundred(uint32_t n, char* out_str) { 170| 48| int num_digits = static_cast(n - 10) >> 8; 171| 48| uint32_t div10 = (n * kDivisionBy10Mul) / kDivisionBy10Div; 172| 48| uint32_t mod10 = n - 10u * div10; 173| 48| uint32_t base = kTwoZeroBytes + div10 + (mod10 << 8); 174| 48| base >>= num_digits & 8; 175| 48| little_endian::Store16(out_str, static_cast(base)); 176| 48| return out_str + 2 + num_digits; 177| 48|} numbers.cc:_ZN4absl12_GLOBAL__N_113EncodeFullU64EmPc: 259| 630| char* buffer) { 260| 630| if (i <= std::numeric_limits::max()) { ------------------ | Branch (260:7): [True: 347, False: 283] ------------------ 261| 347| return EncodeFullU32(static_cast(i), buffer); 262| 347| } 263| 283| uint32_t mod08; 264| 283| if (i < 1'0000'0000'0000'0000ull) { ------------------ | Branch (264:7): [True: 199, False: 84] ------------------ 265| 199| uint32_t div08 = static_cast(i / 100'000'000ull); 266| 199| mod08 = static_cast(i % 100'000'000ull); 267| 199| buffer = EncodeFullU32(div08, buffer); 268| 199| } else { 269| 84| uint64_t div08 = i / 100'000'000ull; 270| 84| mod08 = static_cast(i % 100'000'000ull); 271| 84| uint32_t div016 = static_cast(div08 / 100'000'000ull); 272| 84| uint32_t div08mod08 = static_cast(div08 % 100'000'000ull); 273| 84| uint64_t mid_result = PrepareEightDigits(div08mod08) + kEightZeroBytes; 274| 84| buffer = EncodeTenThousand(div016, buffer); 275| 84| little_endian::Store64(buffer, mid_result); 276| 84| buffer += sizeof(mid_result); 277| 84| } 278| 283| uint64_t mod_result = PrepareEightDigits(mod08) + kEightZeroBytes; 279| 283| little_endian::Store64(buffer, mod_result); 280| 283| return buffer + sizeof(mod_result); 281| 630|} numbers.cc:_ZN4absl12_GLOBAL__N_117EncodeTenThousandEjPc: 179| 84|inline char* EncodeTenThousand(uint32_t n, char* out_str) { 180| | // We split lower 2 digits and upper 2 digits of n into 2 byte consecutive 181| | // blocks. 123 -> [\0\1][\0\23]. We divide by 10 both blocks 182| | // (it's 1 division + zeroing upper bits), and compute modulo 10 as well "in 183| | // parallel". Then we combine both results to have both ASCII digits, 184| | // strip trailing zeros, add ASCII '0000' and return. 185| 84| uint32_t div100 = (n * kDivisionBy100Mul) / kDivisionBy100Div; 186| 84| uint32_t mod100 = n - 100ull * div100; 187| 84| uint32_t hundreds = (mod100 << 16) + div100; 188| 84| uint32_t tens = (hundreds * kDivisionBy10Mul) / kDivisionBy10Div; 189| 84| tens &= (0xFull << 16) | 0xFull; 190| 84| tens += (hundreds - 10ull * tens) << 8; 191| 84| ABSL_ASSUME(tens != 0); ------------------ | | 259| 84|#define ABSL_ASSUME(cond) __builtin_assume(cond) ------------------ 192| | // The result can contain trailing zero bits, we need to strip them to a first 193| | // significant byte in a final representation. For example, for n = 123, we 194| | // have tens to have representation \0\1\2\3. We do `& -8` to round 195| | // to a multiple to 8 to strip zero bytes, not all zero bits. 196| | // countr_zero to help. 197| | // 0 minus 8 to make MSVC happy. 198| 84| uint32_t zeroes = static_cast(absl::countr_zero(tens)) & (0 - 8u); 199| 84| tens += kFourZeroBytes; 200| 84| tens >>= zeroes; 201| 84| little_endian::Store32(out_str, tens); 202| 84| return out_str + sizeof(tens) - zeroes / 8; 203| 84|} numbers.cc:_ZN4absl12_GLOBAL__N_124safe_parse_sign_and_baseEPNS_11string_viewEPiPb: 690| 910| bool* negative_ptr /*output*/) { 691| 910| if (text->data() == nullptr) { ------------------ | Branch (691:7): [True: 0, False: 910] ------------------ 692| 0| return false; 693| 0| } 694| | 695| 910| const char* start = text->data(); 696| 910| const char* end = start + text->size(); 697| 910| int base = *base_ptr; 698| | 699| | // Consume whitespace. 700| 402k| while (start < end && ------------------ | Branch (700:10): [True: 402k, False: 12] ------------------ 701| 402k| absl::ascii_isspace(static_cast(start[0]))) { ------------------ | Branch (701:10): [True: 401k, False: 898] ------------------ 702| 401k| ++start; 703| 401k| } 704| 2.99M| while (start < end && ------------------ | Branch (704:10): [True: 2.99M, False: 12] ------------------ 705| 2.99M| absl::ascii_isspace(static_cast(end[-1]))) { ------------------ | Branch (705:10): [True: 2.99M, False: 898] ------------------ 706| 2.99M| --end; 707| 2.99M| } 708| 910| if (start >= end) { ------------------ | Branch (708:7): [True: 12, False: 898] ------------------ 709| 12| return false; 710| 12| } 711| | 712| | // Consume sign. 713| 898| *negative_ptr = (start[0] == '-'); 714| 898| if (*negative_ptr || start[0] == '+') { ------------------ | Branch (714:7): [True: 2, False: 896] | Branch (714:24): [True: 2, False: 894] ------------------ 715| 4| ++start; 716| 4| if (start >= end) { ------------------ | Branch (716:9): [True: 3, False: 1] ------------------ 717| 3| return false; 718| 3| } 719| 4| } 720| | 721| | // Consume base-dependent prefix. 722| | // base 0: "0x" -> base 16, "0" -> base 8, default -> base 10 723| | // base 16: "0x" -> base 16 724| | // Also validate the base. 725| 895| if (base == 0) { ------------------ | Branch (725:7): [True: 0, False: 895] ------------------ 726| 0| if (end - start >= 2 && start[0] == '0' && ------------------ | Branch (726:9): [True: 0, False: 0] | Branch (726:29): [True: 0, False: 0] ------------------ 727| 0| (start[1] == 'x' || start[1] == 'X')) { ------------------ | Branch (727:10): [True: 0, False: 0] | Branch (727:29): [True: 0, False: 0] ------------------ 728| 0| base = 16; 729| 0| start += 2; 730| 0| if (start >= end) { ------------------ | Branch (730:11): [True: 0, False: 0] ------------------ 731| | // "0x" with no digits after is invalid. 732| 0| return false; 733| 0| } 734| 0| } else if (end - start >= 1 && start[0] == '0') { ------------------ | Branch (734:16): [True: 0, False: 0] | Branch (734:36): [True: 0, False: 0] ------------------ 735| 0| base = 8; 736| 0| start += 1; 737| 0| } else { 738| 0| base = 10; 739| 0| } 740| 895| } else if (base == 16) { ------------------ | Branch (740:14): [True: 0, False: 895] ------------------ 741| 0| if (end - start >= 2 && start[0] == '0' && ------------------ | Branch (741:9): [True: 0, False: 0] | Branch (741:29): [True: 0, False: 0] ------------------ 742| 0| (start[1] == 'x' || start[1] == 'X')) { ------------------ | Branch (742:10): [True: 0, False: 0] | Branch (742:29): [True: 0, False: 0] ------------------ 743| 0| start += 2; 744| 0| if (start >= end) { ------------------ | Branch (744:11): [True: 0, False: 0] ------------------ 745| | // "0x" with no digits after is invalid. 746| 0| return false; 747| 0| } 748| 0| } 749| 895| } else if (base >= 2 && base <= 36) { ------------------ | Branch (749:14): [True: 895, False: 0] | Branch (749:27): [True: 895, False: 0] ------------------ 750| | // okay 751| 895| } else { 752| 0| return false; 753| 0| } 754| 895| *text = absl::string_view(start, static_cast(end - start)); 755| 895| *base_ptr = base; 756| 895| return true; 757| 895|} numbers.cc:_ZN4absl12_GLOBAL__N_118safe_uint_internalImEEbNS_11string_viewEPT_i: 1072| 910| int base) { 1073| 910| *value_p = 0; 1074| 910| bool negative; 1075| 910| if (!safe_parse_sign_and_base(&text, &base, &negative) || negative) { ------------------ | Branch (1075:7): [True: 15, False: 895] | Branch (1075:61): [True: 1, False: 894] ------------------ 1076| 16| return false; 1077| 16| } 1078| 894| return safe_parse_positive_int(text, base, value_p); 1079| 910|} numbers.cc:_ZN4absl12_GLOBAL__N_123safe_parse_positive_intImEEbNS_11string_viewEiPT_: 975| 894| IntType* value_p) { 976| 894| IntType value = 0; 977| 894| const IntType vmax = std::numeric_limits::max(); 978| 894| assert(vmax > 0); 979| 894| assert(base >= 0); 980| 894| const IntType base_inttype = static_cast(base); 981| 894| assert(vmax >= base_inttype); 982| 894| const IntType vmax_over_base = LookupTables::kVmaxOverBase[base]; 983| 894| assert(base < 2 || 984| 894| std::numeric_limits::max() / base_inttype == vmax_over_base); 985| 894| const char* start = text.data(); 986| 894| const char* end = start + text.size(); 987| | // loop over digits 988| 9.45k| for (; start < end; ++start) { ------------------ | Branch (988:10): [True: 8.73k, False: 720] ------------------ 989| 8.73k| unsigned char c = static_cast(start[0]); 990| 8.73k| IntType digit = static_cast(kAsciiToInt[c]); 991| 8.73k| if (digit >= base_inttype) { ------------------ | Branch (991:9): [True: 108, False: 8.63k] ------------------ 992| 108| *value_p = value; 993| 108| return false; 994| 108| } 995| 8.63k| if (value > vmax_over_base) { ------------------ | Branch (995:9): [True: 65, False: 8.56k] ------------------ 996| 65| *value_p = vmax; 997| 65| return false; 998| 65| } 999| 8.56k| value *= base_inttype; 1000| 8.56k| if (value > vmax - digit) { ------------------ | Branch (1000:9): [True: 1, False: 8.56k] ------------------ 1001| 1| *value_p = vmax; 1002| 1| return false; 1003| 1| } 1004| 8.56k| value += digit; 1005| 8.56k| } 1006| 720| *value_p = value; 1007| 720| return true; 1008| 894|} _ZN4absl10SimpleAtoiImEEbNS_11string_viewEPT_: 266| 910|ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type* out) { 267| 910| return numbers_internal::safe_strtoi_base(str, out, 10); 268| 910|} _ZN4absl16numbers_internal16safe_strtoi_baseImEEbNS_11string_viewEPT_i: 198| 910| int base) { 199| 910| static_assert(sizeof(*out) == 4 || sizeof(*out) == 8, 200| 910| "SimpleAtoi works only with 32-bit or 64-bit integers."); 201| 910| static_assert(!std::is_floating_point::value, 202| 910| "Use SimpleAtof or SimpleAtod instead."); 203| 910| bool parsed; 204| | // TODO(jorg): This signed-ness check is used because it works correctly 205| | // with enums, and it also serves to check that int_type is not a pointer. 206| | // If one day something like std::is_signed works, switch to it. 207| | // These conditions are constexpr bools to suppress MSVC warning C4127. 208| 910| constexpr bool kIsSigned = static_cast(1) - 2 < 0; 209| 910| constexpr bool kUse64Bit = sizeof(*out) == 64 / 8; 210| 910| if (kIsSigned) { ------------------ | Branch (210:7): [Folded - Ignored] ------------------ 211| 0| if (kUse64Bit) { ------------------ | Branch (211:9): [Folded - Ignored] ------------------ 212| 0| int64_t val; 213| 0| parsed = numbers_internal::safe_strto64_base(s, &val, base); 214| 0| *out = static_cast(val); 215| 0| } else { 216| 0| int32_t val; 217| 0| parsed = numbers_internal::safe_strto32_base(s, &val, base); 218| 0| *out = static_cast(val); 219| 0| } 220| 910| } else { 221| 910| if (kUse64Bit) { ------------------ | Branch (221:9): [Folded - Ignored] ------------------ 222| 910| uint64_t val; 223| 910| parsed = numbers_internal::safe_strtou64_base(s, &val, base); 224| 910| *out = static_cast(val); 225| 910| } else { 226| 0| uint32_t val; 227| 0| parsed = numbers_internal::safe_strtou32_base(s, &val, base); 228| 0| *out = static_cast(val); 229| 0| } 230| 910| } 231| 910| return parsed; 232| 910|} _ZN4absl6StrCatERKNS_8AlphaNumES2_S2_S2_: 86| 630| const AlphaNum& d) { 87| 630| std::string result; 88| 630| strings_internal::STLStringResizeUninitialized( 89| 630| &result, a.size() + b.size() + c.size() + d.size()); 90| 630| char* const begin = &result[0]; 91| 630| char* out = begin; 92| 630| out = Append(out, a); 93| 630| out = Append(out, b); 94| 630| out = Append(out, c); 95| 630| out = Append(out, d); 96| 630| assert(out == begin + result.size()); 97| 630| return result; 98| 630|} str_cat.cc:_ZN4absl12_GLOBAL__N_16AppendEPcRKNS_8AlphaNumE: 43| 2.52k|inline char* Append(char* out, const AlphaNum& x) { 44| | // memcpy is allowed to overwrite arbitrary memory, so doing this after the 45| | // call would force an extra fetch of x.size(). 46| 2.52k| char* after = out + x.size(); 47| 2.52k| if (x.size() != 0) { ------------------ | Branch (47:7): [True: 2.52k, False: 0] ------------------ 48| 2.52k| memcpy(out, x.data(), x.size()); 49| 2.52k| } 50| 2.52k| return after; 51| 2.52k|} _ZN4absl8AlphaNumC2EPKc: 354| 1.26k| : piece_(NullSafeStringView(c_str)) {} _ZN4absl8AlphaNumC2Em: 331| 630| &digits_[0])) {} _ZN4absl8AlphaNumC2INSt3__19allocatorIcEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEET_EE: 370| 630| : piece_(str) {} _ZNK4absl8AlphaNum4sizeEv: 378| 10.0k| absl::string_view::size_type size() const { return piece_.size(); } _ZNK4absl8AlphaNum4dataEv: 379| 2.52k| const char* data() const { return piece_.data(); } _ZN4absl11string_viewC2EPKcm: 202| 5.68k| : ptr_(data), length_(CheckLengthInternal(len)) {} _ZN4absl11string_view19CheckLengthInternalEm: 603| 5.68k| static constexpr size_type CheckLengthInternal(size_type len) { 604| 5.68k| return ABSL_HARDENING_ASSERT(len <= kMaxSize), len; ------------------ | | 128| 5.68k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr) | | ------------------ | | | | 95| 5.68k| (false ? static_cast(expr) : static_cast(0)) | | | | ------------------ | | | | | Branch (95:4): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 605| 5.68k| } _ZN4absl11string_viewC2EPKc: 198| 1.26k| : ptr_(str), length_(str ? StrlenInternal(str) : 0) {} _ZNK4absl11string_view4sizeEv: 271| 37.3k| constexpr size_type size() const noexcept { return length_; } _ZNK4absl11string_view6lengthEv: 276| 21.5k| constexpr size_type length() const noexcept { return size(); } _ZNK4absl11string_viewixEm: 292| 22.8k| constexpr const_reference operator[](size_type i) const { 293| 22.8k| return ABSL_HARDENING_ASSERT(i < size()), ptr_[i]; ------------------ | | 128| 22.8k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr) | | ------------------ | | | | 95| 22.8k| (false ? static_cast(expr) : static_cast(0)) | | | | ------------------ | | | | | Branch (95:4): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 294| 22.8k| } _ZNK4absl11string_view4backEv: 319| 121| constexpr const_reference back() const { 320| 121| return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1]; ------------------ | | 128| 121|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr) | | ------------------ | | | | 95| 121| (false ? static_cast(expr) : static_cast(0)) | | | | ------------------ | | | | | Branch (95:4): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 321| 121| } _ZNK4absl11string_view4dataEv: 330| 6.49k| constexpr const_pointer data() const noexcept { return ptr_; } _ZNK4absl11string_view6substrEmm: 393| 2.57k| constexpr string_view substr(size_type pos = 0, size_type n = npos) const { 394| 2.57k| return ABSL_PREDICT_FALSE(pos > length_) ------------------ | | 178| 2.57k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 2.57k] | | | Branch (178:49): [Folded - Ignored] | | | Branch (178:58): [True: 0, False: 2.57k] | | ------------------ ------------------ 395| 2.57k| ? (base_internal::ThrowStdOutOfRange( 396| 0| "absl::string_view::substr"), 397| 0| string_view()) 398| 2.57k| : string_view(ptr_ + pos, Min(n, length_ - pos)); 399| 2.57k| } _ZN4absl11string_viewC2EPKcmNS0_18SkipCheckLengthTagE: 598| 630| : ptr_(data), length_(len) {} _ZN4absl11string_view14StrlenInternalEPKc: 607| 1.26k| static constexpr size_type StrlenInternal(const char* str) { 608| |#if defined(_MSC_VER) && _MSC_VER >= 1910 && !defined(__clang__) 609| | // MSVC 2017+ can evaluate this at compile-time. 610| | const char* begin = str; 611| | while (*str != '\0') ++str; 612| | return str - begin; 613| |#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \ 614| | (defined(__GNUC__) && !defined(__clang__)) 615| | // GCC has __builtin_strlen according to 616| | // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but 617| | // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above. 618| | // __builtin_strlen is constexpr. 619| 1.26k| return __builtin_strlen(str); 620| |#else 621| | return str ? strlen(str) : 0; 622| |#endif 623| 1.26k| } _ZN4absl11string_view3MinEmm: 625| 2.57k| static constexpr size_t Min(size_type length_a, size_type length_b) { 626| 2.57k| return length_a < length_b ? length_a : length_b; ------------------ | Branch (626:12): [True: 743, False: 1.83k] ------------------ 627| 2.57k| } _ZN4absl18NullSafeStringViewEPKc: 697| 1.26k|constexpr string_view NullSafeStringView(const char* p) { 698| 1.26k| return p ? string_view(p) : string_view(); ------------------ | Branch (698:10): [True: 1.26k, False: 0] ------------------ 699| 1.26k|} _ZN4absl11string_viewC2INSt3__19allocatorIcEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEET_EE: 191| 630| : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {} _ZN10opencensus5trace11propagation27FromCloudTraceContextHeaderEN4absl11string_viewE: 60| 953|SpanContext FromCloudTraceContextHeader(absl::string_view header) { 61| 953| constexpr int kTraceIdLen = 16; 62| 953| constexpr int kTraceIdLenHex = 2 * kTraceIdLen; 63| 953| constexpr int kOptionsLen = 4; // e.g. ";o=1" 64| 953| static SpanContext invalid; 65| | 66| 953| if (header.size() < kTraceIdLenHex + 2 || header[kTraceIdLenHex] != '/') { ------------------ | Branch (66:7): [True: 11, False: 942] | Branch (66:45): [True: 17, False: 925] ------------------ 67| | // Too short to contain a valid trace_id/span_id, or missing slash. 68| 28| return invalid; 69| 28| } 70| | 71| | // Check if options are present. 72| 925| absl::string_view options = header.substr(header.size() - kOptionsLen); 73| 925| uint8_t sampled = 0; 74| 925| if (options[0] == ';' && options[1] == 'o' && options[2] == '=') { ------------------ | Branch (74:7): [True: 68, False: 857] | Branch (74:28): [True: 55, False: 13] | Branch (74:49): [True: 43, False: 12] ------------------ 75| 43| if (options.back() < '0' || options.back() > '3') { ------------------ | Branch (75:9): [True: 8, False: 35] | Branch (75:33): [True: 7, False: 28] ------------------ 76| 15| return invalid; // Invalid option. 77| 15| } 78| 28| if (options.back() == '1' || options.back() == '3') { ------------------ | Branch (78:9): [True: 13, False: 15] | Branch (78:34): [True: 7, False: 8] ------------------ 79| 20| sampled = 1; 80| 20| } 81| | // Remove from header to make parsing span_id easier. 82| 28| header = header.substr(0, header.size() - kOptionsLen); 83| 28| } 84| | 85| | // Parse decimal span_id. 86| 910| absl::string_view span_id = header.substr(kTraceIdLenHex + 1); 87| 910| uint64_t n_span_id; 88| 910| if (!absl::SimpleAtoi(span_id, &n_span_id) || n_span_id == 0) { ------------------ | Branch (88:7): [True: 190, False: 720] | Branch (88:49): [True: 5, False: 715] ------------------ 89| 195| return invalid; // Invalid span_id. 90| 195| } 91| | 92| | // Parse trace_id. 93| 715| absl::string_view trace_id = header.substr(0, kTraceIdLenHex); 94| 715| if (!IsHexDigits(trace_id)) { ------------------ | Branch (94:7): [True: 84, False: 631] ------------------ 95| 84| return invalid; // Invalid hex digit. 96| 84| } 97| 631| std::string trace_id_binary = absl::HexStringToBytes(trace_id); 98| | 99| 631| return SpanContext( 100| 631| TraceId(reinterpret_cast(trace_id_binary.data())), 101| 631| FromDecimal(n_span_id), TraceOptions(&sampled)); 102| 715|} _ZN10opencensus5trace11propagation25ToCloudTraceContextHeaderERKNS0_11SpanContextE: 104| 630|std::string ToCloudTraceContextHeader(const SpanContext& ctx) { 105| 630| return absl::StrCat(ctx.trace_id().ToHex(), "/", ToDecimal(ctx.span_id()), 106| 630| ctx.trace_options().IsSampled() ? ";o=1" : ";o=0"); ------------------ | Branch (106:23): [True: 2, False: 628] ------------------ 107| 630|} cloud_trace_context.cc:_ZN10opencensus5trace11propagation12_GLOBAL__N_111IsHexDigitsEN4absl11string_viewE: 37| 715|bool IsHexDigits(absl::string_view s) { 38| 21.5k| for (int i = 0; i < s.length(); ++i) { ------------------ | Branch (38:19): [True: 20.9k, False: 631] ------------------ 39| 20.9k| if (!absl::ascii_isxdigit(s[i])) return false; ------------------ | Branch (39:9): [True: 84, False: 20.8k] ------------------ 40| 20.9k| } 41| 631| return true; 42| 715|} cloud_trace_context.cc:_ZN10opencensus5trace11propagation12_GLOBAL__N_111FromDecimalEm: 45| 631|SpanId FromDecimal(uint64_t n) { 46| 631| uint8_t buf[8]; 47| 631| absl::big_endian::Store64(buf, n); 48| 631| return SpanId(buf); 49| 631|} cloud_trace_context.cc:_ZN10opencensus5trace11propagation12_GLOBAL__N_19ToDecimalERKNS0_6SpanIdE: 52| 630|uint64_t ToDecimal(const SpanId& span_id) { 53| 630| uint64_t n; 54| 630| span_id.CopyTo(reinterpret_cast(&n)); 55| 630| return absl::big_endian::ToHost64(n); 56| 630|} LLVMFuzzerTestOneInput: 23| 953|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { 24| 953| absl::string_view header(reinterpret_cast(Data), Size); 25| 953| SpanContext ctx = FromCloudTraceContextHeader(header); 26| 953| if (ctx.IsValid()) { ------------------ | Branch (26:7): [True: 630, False: 323] ------------------ 27| 630| ToCloudTraceContextHeader(ctx); 28| 630| } 29| 953| return 0; 30| 953|} _ZNK10opencensus5trace11SpanContext7IsValidEv: 30| 953|bool SpanContext::IsValid() const { 31| 953| return trace_id_.IsValid() && span_id_.IsValid(); ------------------ | Branch (31:10): [True: 630, False: 323] | Branch (31:33): [True: 630, False: 0] ------------------ 32| 953|} _ZN10opencensus5trace6SpanIdC2EPKh: 26| 631|SpanId::SpanId(const uint8_t *buf) { memcpy(rep_, buf, kSize); } _ZNK10opencensus5trace6SpanId7IsValidEv: 39| 630|bool SpanId::IsValid() const { 40| 630| static_assert(kSize == 8, 41| 630| "IsValid assumes the internal representation is 8 bytes."); 42| 630| uint64_t tmp; 43| 630| memcpy(&tmp, rep_, kSize); 44| 630| return tmp != 0; 45| 630|} _ZNK10opencensus5trace6SpanId6CopyToEPh: 47| 630|void SpanId::CopyTo(uint8_t *buf) const { memcpy(buf, rep_, kSize); } _ZN10opencensus5trace7TraceIdC2EPKh: 26| 631|TraceId::TraceId(const uint8_t *buf) { memcpy(rep_, buf, kSize); } _ZNK10opencensus5trace7TraceId5ToHexEv: 28| 630|std::string TraceId::ToHex() const { 29| 630| return absl::BytesToHexString( 30| 630| absl::string_view(reinterpret_cast(rep_), kSize)); 31| 630|} _ZNK10opencensus5trace7TraceId7IsValidEv: 39| 953|bool TraceId::IsValid() const { 40| 953| static_assert(kSize == 16, "Internal representation must be 16 bytes."); 41| 953| uint64_t tmp1; 42| 953| uint64_t tmp2; 43| 953| memcpy(&tmp1, &rep_[0], 8); 44| 953| memcpy(&tmp2, &rep_[8], 8); 45| 953| return (tmp1 != 0 || tmp2 != 0); ------------------ | Branch (45:11): [True: 523, False: 430] | Branch (45:24): [True: 107, False: 323] ------------------ 46| 953|} _ZN10opencensus5trace12TraceOptionsC2EPKh: 30| 631|TraceOptions::TraceOptions(const uint8_t* buf) { memcpy(rep_, buf, kSize); } _ZNK10opencensus5trace12TraceOptions9IsSampledEv: 32| 630|bool TraceOptions::IsSampled() const { return rep_[0] & kIsSampled; } _ZN10opencensus5trace11SpanContextC2Ev: 34| 1| SpanContext() {} _ZN10opencensus5trace11SpanContextC2ENS0_7TraceIdENS0_6SpanIdENS0_12TraceOptionsE: 44| 631| : trace_id_(trace_id), span_id_(span_id), trace_options_(trace_options) {} _ZNK10opencensus5trace11SpanContext8trace_idEv: 47| 630| TraceId trace_id() const { return trace_id_; } _ZNK10opencensus5trace11SpanContext7span_idEv: 50| 630| SpanId span_id() const { return span_id_; } _ZNK10opencensus5trace11SpanContext13trace_optionsEv: 53| 630| TraceOptions trace_options() const { return trace_options_; } _ZN10opencensus5trace6SpanIdC2Ev: 32| 1| SpanId() : rep_{0} {} _ZN10opencensus5trace7TraceIdC2Ev: 32| 1| TraceId() : rep_{0} {} _ZN10opencensus5trace12TraceOptionsC2Ev: 36| 1| TraceOptions() : rep_{0} {}