_ZN8firebase9firestore5model4impl8BasePathINS1_12ResourcePathEEC2EONSt3__16vectorINS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEENSB_ISD_EEEE: 172| 318| explicit BasePath(SegmentsT&& segments) : segments_{std::move(segments)} { 173| 318| } _ZN8firebase9firestore5model12ResourcePath10FromStringERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 32| 399|ResourcePath ResourcePath::FromString(const std::string& path) { 33| 399| return FromStringView(path); 34| 399|} _ZN8firebase9firestore5model12ResourcePath14FromStringViewEN4absl12lts_2021110211string_viewE: 36| 399|ResourcePath ResourcePath::FromStringView(absl::string_view path) { 37| | // NOTE: The client is ignorant of any path segments containing escape 38| | // sequences (e.g. __id123__) and just passes them through raw (they exist 39| | // for legacy reasons and should not be used frequently). 40| | 41| 399| if (absl::StrContains(path, "//")) { ------------------ | Branch (41:7): [True: 81, False: 318] ------------------ 42| 81| util::ThrowInvalidArgument( 43| 81| "Invalid path (%s). Paths must not contain // in them.", path); 44| 81| } 45| | 46| | // SkipEmpty because we may still have an empty segment at the beginning or 47| | // end if they had a leading or trailing slash (which we allow). 48| 318| std::vector segments = 49| 318| absl::StrSplit(path, '/', absl::SkipEmpty()); 50| 318| return ResourcePath{std::move(segments)}; 51| 399|} _ZN8firebase9firestore5model12ResourcePathC2EONSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE: 50| 318| explicit ResourcePath(SegmentsT&& segments) : BasePath{std::move(segments)} { 51| 318| } _ZN8firebase9firestore4util5ThrowENS1_13ExceptionTypeEPKcS4_iRKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 92| 81| const std::string& message) { 93| 81| throw_handler(exception, file, func, line, message); 94| | 95| | // It's expected that the throw handler above does not return. If it does, 96| | // just terminate. 97| 81| std::terminate(); 98| 81|} exception.cc:_ZN8firebase9firestore4util12_GLOBAL__N_119DefaultThrowHandlerENS1_13ExceptionTypeEPKcS5_iRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE: 48| 81| const std::string& message) { 49| 81| std::string what = absl::StrCat(ExceptionName(type), ": "); 50| 81| if (file && func) { ------------------ | Branch (50:7): [True: 0, False: 81] | Branch (50:15): [True: 0, False: 0] ------------------ 51| 0| absl::StrAppend(&what, file, "(", line, ") ", func, ": "); 52| 0| } 53| 81| absl::StrAppend(&what, message); 54| | 55| | // Always log the error -- it helps if there are any issues with the exception 56| | // propagation mechanism and also makes sure the exception makes it into the 57| | // log regardless of how it's handled. 58| 81| LOG_ERROR("%s", what); ------------------ | | 77| 81| do { \ | | 78| 81| namespace _util = firebase::firestore::util; \ | | 79| 81| if (_util::LogIsLoggable(_util::kLogLevelError)) { \ | | ------------------ | | | Branch (79:9): [True: 81, False: 0] | | ------------------ | | 80| 81| std::string _message = _util::StringFormat(__VA_ARGS__); \ | | 81| 81| _util::LogMessage(_util::kLogLevelError, _message); \ | | 82| 81| } \ | | 83| 81| } while (0) | | ------------------ | | | Branch (83:12): [Folded - Ignored] | | ------------------ ------------------ 59| | 60| 81|#if ABSL_HAVE_EXCEPTIONS 61| 81| switch (type) { ------------------ | Branch (61:11): [True: 0, False: 81] ------------------ 62| 0| case ExceptionType::AssertionFailure: ------------------ | Branch (62:5): [True: 0, False: 81] ------------------ 63| 0| throw FirestoreInternalError(what); 64| 0| case ExceptionType::IllegalState: ------------------ | Branch (64:5): [True: 0, False: 81] ------------------ 65| | // Omit descriptive text since the type already encodes the kind of error. 66| 0| throw std::logic_error(message); 67| 81| case ExceptionType::InvalidArgument: ------------------ | Branch (67:5): [True: 81, False: 0] ------------------ 68| | // Omit descriptive text since the type already encodes the kind of error. 69| 81| throw std::invalid_argument(message); 70| 81| } 71| |#else 72| | std::terminate(); 73| |#endif 74| | 75| 0| UNREACHABLE(); ------------------ | | 82| 0|#define UNREACHABLE() abort() ------------------ 76| 81|} exception.cc:_ZN8firebase9firestore4util12_GLOBAL__N_113ExceptionNameENS1_13ExceptionTypeE: 32| 81|const char* ExceptionName(ExceptionType exception) { 33| 81| switch (exception) { ------------------ | Branch (33:11): [True: 0, False: 81] ------------------ 34| 0| case ExceptionType::AssertionFailure: ------------------ | Branch (34:5): [True: 0, False: 81] ------------------ 35| 0| return "FIRESTORE INTERNAL ASSERTION FAILED"; 36| 0| case ExceptionType::IllegalState: ------------------ | Branch (36:5): [True: 0, False: 81] ------------------ 37| 0| return "Illegal state"; 38| 81| case ExceptionType::InvalidArgument: ------------------ | Branch (38:5): [True: 81, False: 0] ------------------ 39| 81| return "Invalid argument"; 40| 81| } 41| 0| UNREACHABLE(); ------------------ | | 82| 0|#define UNREACHABLE() abort() ------------------ 42| 81|} _ZN8firebase9firestore4util20ThrowInvalidArgumentIJN4absl12lts_2021110211string_viewEEEEvPKcDpRKT_: 93| 81| const FA&... args) { 94| 81| Throw(ExceptionType::InvalidArgument, nullptr, nullptr, 0, 95| 81| StringFormat(format, args...)); 96| 81|} _ZN8firebase9firestore4util13LogIsLoggableENS1_8LogLevelE: 38| 81|bool LogIsLoggable(LogLevel level) { 39| 81| return level >= g_log_level; 40| 81|} _ZN8firebase9firestore4util10LogMessageENS1_8LogLevelERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 42| 81|void LogMessage(LogLevel log_level, const std::string& message) { 43| 81| if (log_level < g_log_level) { ------------------ | Branch (43:7): [True: 0, False: 81] ------------------ 44| 0| return; 45| 0| } 46| | 47| 81| const char* level_word; 48| | 49| 81| switch (log_level) { 50| 0| case kLogLevelDebug: ------------------ | Branch (50:5): [True: 0, False: 81] ------------------ 51| 0| level_word = "DEBUG"; 52| 0| break; 53| 0| case kLogLevelWarning: ------------------ | Branch (53:5): [True: 0, False: 81] ------------------ 54| 0| level_word = "WARNING"; 55| 0| break; 56| 81| case kLogLevelError: ------------------ | Branch (56:5): [True: 81, False: 0] ------------------ 57| 81| level_word = "ERROR"; 58| 81| break; 59| 0| case kLogLevelNotice: ------------------ | Branch (59:5): [True: 0, False: 81] ------------------ 60| 0| level_word = "INFO"; 61| 0| break; 62| 0| default: ------------------ | Branch (62:5): [True: 0, False: 81] ------------------ 63| 0| UNREACHABLE(); ------------------ | | 82| 0|#define UNREACHABLE() abort() ------------------ 64| 0| break; 65| 81| } 66| | 67| 81| printf("%s: %s\n", level_word, message.c_str()); 68| 81|} _ZN8firebase9firestore4util8internal18StringFormatPiecesEPKcSt16initializer_listIN4absl12lts_2021110211string_viewEE: 28| 162| const char* format, std::initializer_list pieces) { 29| 162| std::string result; 30| | 31| 162| const char* format_iter = format; 32| 162| const char* format_end = format + strlen(format); 33| | 34| 162| auto pieces_iter = pieces.begin(); 35| 162| auto pieces_end = pieces.end(); 36| 162| auto append_next_piece = [&](std::string* dest) { 37| 162| if (pieces_iter == pieces_end) { 38| 162| dest->append(kMissing); 39| 162| } else { 40| | // Pass a piece through 41| 162| dest->append(pieces_iter->data(), pieces_iter->size()); 42| 162| ++pieces_iter; 43| 162| } 44| 162| }; 45| | 46| 162| auto append_specifier = [&](char spec) { 47| 162| switch (spec) { 48| 162| case '%': 49| | // Pass through literal %. 50| 162| result.push_back('%'); 51| 162| break; 52| | 53| 162| case 's': { 54| 162| append_next_piece(&result); 55| 162| break; 56| 162| } 57| | 58| 162| default: 59| 162| result.append(kInvalid); 60| 162| break; 61| 162| } 62| 162| }; 63| | 64| | // Iterate through the format string, advancing `format_iter` as we go. 65| 324| while (true) { ------------------ | Branch (65:10): [Folded - Ignored] ------------------ 66| 324| const char* percent_ptr = std::find(format_iter, format_end, '%'); 67| | 68| | // percent either points to the next format specifier or the end of the 69| | // format string. Either is safe to append here: 70| 324| result.append(format_iter, percent_ptr); 71| 324| if (percent_ptr == format_end) { ------------------ | Branch (71:9): [True: 162, False: 162] ------------------ 72| | // No further pieces to format 73| 162| break; 74| 162| } 75| | 76| | // Examine the specifier: 77| 162| const char* spec_ptr = percent_ptr + 1; 78| 162| if (spec_ptr == format_end) { ------------------ | Branch (78:9): [True: 0, False: 162] ------------------ 79| | // Incomplete specifier, treat as a literal "%" and be done. 80| 0| append_specifier('%'); 81| 0| break; 82| 0| } 83| 162| append_specifier(*spec_ptr); 84| | 85| 162| format_iter = spec_ptr + 1; 86| 162| } 87| | 88| 162| return result; 89| 162|} string_format.cc:_ZZN8firebase9firestore4util8internal18StringFormatPiecesEPKcSt16initializer_listIN4absl12lts_2021110211string_viewEEENK3$_1clEc: 46| 162| auto append_specifier = [&](char spec) { 47| 162| switch (spec) { 48| 0| case '%': ------------------ | Branch (48:7): [True: 0, False: 162] ------------------ 49| | // Pass through literal %. 50| 0| result.push_back('%'); 51| 0| break; 52| | 53| 162| case 's': { ------------------ | Branch (53:7): [True: 162, False: 0] ------------------ 54| 162| append_next_piece(&result); 55| 162| break; 56| 0| } 57| | 58| 0| default: ------------------ | Branch (58:7): [True: 0, False: 162] ------------------ 59| 0| result.append(kInvalid); 60| 0| break; 61| 162| } 62| 162| }; string_format.cc:_ZZN8firebase9firestore4util8internal18StringFormatPiecesEPKcSt16initializer_listIN4absl12lts_2021110211string_viewEEENK3$_0clEPNSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEE: 36| 162| auto append_next_piece = [&](std::string* dest) { 37| 162| if (pieces_iter == pieces_end) { ------------------ | Branch (37:9): [True: 0, False: 162] ------------------ 38| 0| dest->append(kMissing); 39| 162| } else { 40| | // Pass a piece through 41| 162| dest->append(pieces_iter->data(), pieces_iter->size()); 42| 162| ++pieces_iter; 43| 162| } 44| 162| }; _ZN8firebase9firestore4util12StringFormatIJN4absl12lts_2021110211string_viewEEEENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEPKcDpRKT_: 159| 81|std::string StringFormat(const char* format, const FA&... args) { 160| 81| return internal::StringFormatPieces( 161| 81| format, {static_cast(args).Piece()...}); 162| 81|} _ZN8firebase9firestore4util9FormatArgC2IRKN4absl12lts_2021110211string_viewEEEOT_: 69| 81| : FormatArg{std::forward(value), internal::FormatChoice<0>{}} { 70| 81| } _ZN8firebase9firestore4util9FormatArgC2IRKN4absl12lts_2021110211string_viewEEEOT_NS1_8internal12FormatChoiceILi5EEE: 138| 81| : AlphaNum{std::forward(value)} { 139| 81| } _ZN8firebase9firestore4util12StringFormatIJNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEES9_PKcDpRKT_: 159| 81|std::string StringFormat(const char* format, const FA&... args) { 160| 81| return internal::StringFormatPieces( 161| 81| format, {static_cast(args).Piece()...}); 162| 81|} _ZN8firebase9firestore4util9FormatArgC2IRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEOT_: 69| 81| : FormatArg{std::forward(value), internal::FormatChoice<0>{}} { 70| 81| } _ZN8firebase9firestore4util9FormatArgC2IRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEOT_NS1_8internal12FormatChoiceILi5EEE: 138| 81| : AlphaNum{std::forward(value)} { 139| 81| } LLVMFuzzerTestOneInput: 25| 399|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 26| 399| const char* str_ptr = reinterpret_cast(data); 27| 399| std::string str{str_ptr, size}; 28| | 29| 399| try { 30| 399| ResourcePath rp = ResourcePath::FromString(str); 31| 399| } catch (...) { 32| | // Ignore caught errors and assertions. 33| 81| } 34| | 35| 399| return 0; 36| 399|} _ZN4absl12lts_2021110216strings_internal8memmatchEPKcmS3_m: 90| 399| size_t neelen) { 91| 399| if (0 == neelen) { ------------------ | Branch (91:7): [True: 0, False: 399] ------------------ 92| 0| return phaystack; // even if haylen is 0 93| 0| } 94| 399| if (haylen < neelen) return nullptr; ------------------ | Branch (94:7): [True: 2, False: 397] ------------------ 95| | 96| 397| const char* match; 97| 397| const char* hayend = phaystack + haylen - neelen + 1; 98| | // A static cast is used here to work around the fact that memchr returns 99| | // a void* on Posix-compliant systems and const void* on Windows. 100| 4.59M| while ((match = static_cast( ------------------ | Branch (100:10): [True: 4.59M, False: 316] ------------------ 101| 4.59M| memchr(phaystack, pneedle[0], hayend - phaystack)))) { 102| 4.59M| if (memcmp(match, pneedle, neelen) == 0) ------------------ | Branch (102:9): [True: 81, False: 4.59M] ------------------ 103| 81| return match; 104| 4.59M| else 105| 4.59M| phaystack = match + 1; 106| 4.59M| } 107| 316| return nullptr; 108| 397|} _ZN4absl12lts_2021110216strings_internal28STLStringResizeUninitializedINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEEvPT_m: 67| 81|inline void STLStringResizeUninitialized(string_type* s, size_t new_size) { 68| 81| ResizeUninitializedTraits::Resize(s, new_size); 69| 81|} _ZN4absl12lts_2021110216strings_internal25ResizeUninitializedTraitsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE6ResizeEPS9_m: 47| 81| static void Resize(string_type* s, size_t new_size) { 48| 81| s->__resize_default_init(new_size); 49| 81| } _ZN4absl12lts_2021110216strings_internal23ConvertibleToStringViewC2ENS0_11string_viewE: 63| 318| : value_(s) {} _ZNK4absl12lts_2021110216strings_internal23ConvertibleToStringView5valueEv: 71| 318| absl::string_view value() const { return value_; } _ZN4absl12lts_2021110216strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEC2ES5_S3_S4_: 269| 318| predicate_(std::move(p)) {} _ZNK4absl12lts_2021110216strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEcvT_INSt3__16vectorINS9_12basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEENSE_ISG_EEEEvEEv: 286| 318| operator Container() const { // NOLINT(runtime/explicit) 287| 318| return ConvertToContainer::value>()(*this); 289| 318| } _ZNK4absl12lts_2021110216strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE18ConvertToContainerINSt3__16vectorINS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEENSD_ISF_EEEESF_Lb0EEclERKS6_: 368| 318| std::vector operator()(const Splitter& splitter) const { 369| 318| const std::vector v = splitter; 370| 318| return std::vector(v.begin(), v.end()); 371| 318| } _ZNK4absl12lts_2021110216strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEcvT_INSt3__16vectorIS5_NS9_9allocatorIS5_EEEEvEEv: 286| 318| operator Container() const { // NOLINT(runtime/explicit) 287| 318| return ConvertToContainer::value>()(*this); 289| 318| } _ZNK4absl12lts_2021110216strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE18ConvertToContainerINSt3__16vectorIS5_NS8_9allocatorIS5_EEEES5_Lb0EEclERKS6_: 337| 318| const Splitter& splitter) const { 338| 318| struct raw_view { 339| 318| const char* data; 340| 318| size_t size; 341| 318| operator absl::string_view() const { // NOLINT(runtime/explicit) 342| 318| return {data, size}; 343| 318| } 344| 318| }; 345| 318| std::vector v; 346| 318| std::array ar; 347| 245k| for (auto it = splitter.begin(); !it.at_end();) { ------------------ | Branch (347:40): [True: 245k, False: 318] ------------------ 348| 245k| size_t index = 0; 349| 3.91M| do { 350| 3.91M| ar[index].data = it->data(); 351| 3.91M| ar[index].size = it->size(); 352| 3.91M| ++it; 353| 3.91M| } while (++index != ar.size() && !it.at_end()); ------------------ | Branch (353:18): [True: 3.67M, False: 244k] | Branch (353:42): [True: 3.67M, False: 297] ------------------ 354| 245k| v.insert(v.end(), ar.begin(), ar.begin() + index); 355| 245k| } 356| 318| return v; 357| 318| } _ZNK4absl12lts_2021110216strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE5beginEv: 278| 318| const_iterator begin() const { return {const_iterator::kInitState, this}; } _ZN4absl12lts_2021110216strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEEEC2ENS8_5StateEPKS7_: 98| 318| predicate_(splitter->predicate()) { 99| | // Hack to maintain backward compatibility. This one block makes it so an 100| | // empty absl::string_view whose .data() happens to be nullptr behaves 101| | // *differently* from an otherwise empty absl::string_view whose .data() is 102| | // not nullptr. This is an undesirable difference in general, but this 103| | // behavior is maintained to avoid breaking existing code that happens to 104| | // depend on this old behavior/bug. Perhaps it will be fixed one day. The 105| | // difference in behavior is as follows: 106| | // Split(absl::string_view(""), '-'); // {""} 107| | // Split(absl::string_view(), '-'); // {} 108| 318| if (splitter_->text().data() == nullptr) { ------------------ | Branch (108:9): [True: 0, False: 318] ------------------ 109| 0| state_ = kEndState; 110| 0| pos_ = splitter_->text().size(); 111| 0| return; 112| 0| } 113| | 114| 318| if (state_ == kEndState) { ------------------ | Branch (114:9): [True: 0, False: 318] ------------------ 115| 0| pos_ = splitter_->text().size(); 116| 318| } else { 117| 318| ++(*this); 118| 318| } 119| 318| } _ZNK4absl12lts_2021110216strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE9delimiterEv: 272| 318| const Delimiter& delimiter() const { return delimiter_; } _ZNK4absl12lts_2021110216strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE9predicateEv: 273| 318| const Predicate& predicate() const { return predicate_; } _ZNK4absl12lts_2021110216strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE4textEv: 271| 3.91M| absl::string_view text() const { return text_; } _ZNK4absl12lts_2021110216strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEEE6at_endEv: 121| 3.91M| bool at_end() const { return state_ == kEndState; } _ZNK4absl12lts_2021110216strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEEEptEv: 124| 7.83M| pointer operator->() const { return &curr_; } _ZN4absl12lts_2021110216strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEEEppEv: 126| 3.91M| SplitIterator& operator++() { 127| 3.91M| do { 128| 3.91M| if (state_ == kLastState) { ------------------ | Branch (128:11): [True: 318, False: 3.91M] ------------------ 129| 318| state_ = kEndState; 130| 318| return *this; 131| 318| } 132| 3.91M| const absl::string_view text = splitter_->text(); 133| 3.91M| const absl::string_view d = delimiter_.Find(text, pos_); 134| 3.91M| if (d.data() == text.data() + text.size()) state_ = kLastState; ------------------ | Branch (134:11): [True: 318, False: 3.91M] ------------------ 135| 3.91M| curr_ = text.substr(pos_, d.data() - (text.data() + pos_)); 136| 3.91M| pos_ += curr_.size() + d.size(); 137| 3.91M| } while (!predicate_(curr_)); ------------------ | Branch (137:14): [True: 146, False: 3.91M] ------------------ 138| 3.91M| return *this; 139| 3.91M| } _ZZNK4absl12lts_2021110216strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE18ConvertToContainerINSt3__16vectorIS5_NS8_9allocatorIS5_EEEES5_Lb0EEclERKS6_ENK8raw_viewcvS5_Ev: 341| 3.91M| operator absl::string_view() const { // NOLINT(runtime/explicit) 342| 3.91M| return {data, size}; 343| 3.91M| } _ZN4absl12lts_2021110211StrContainsENS0_11string_viewES1_: 47| 399| absl::string_view needle) noexcept { 48| 399| return haystack.find(needle, 0) != haystack.npos; 49| 399|} _ZN4absl12lts_202111026StrCatERKNS0_8AlphaNumES3_: 98| 81|std::string StrCat(const AlphaNum& a, const AlphaNum& b) { 99| 81| std::string result; 100| 81| absl::strings_internal::STLStringResizeUninitialized(&result, 101| 81| a.size() + b.size()); 102| 81| char* const begin = &result[0]; 103| 81| char* out = begin; 104| 81| out = Append(out, a); 105| 81| out = Append(out, b); 106| 81| assert(out == begin + result.size()); 107| 0| return result; 108| 81|} _ZN4absl12lts_202111029StrAppendEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS0_8AlphaNumE: 193| 81|void StrAppend(std::string* dest, const AlphaNum& a) { 194| 81| ASSERT_NO_OVERLAP(*dest, a); ------------------ | | 166| 81| assert(((src).size() == 0) || \ | | 167| 81| (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size()))) ------------------ 195| 0| dest->append(a.data(), a.size()); 196| 81|} str_cat.cc:_ZN4absl12lts_20211102L6AppendEPcRKNS0_8AlphaNumE: 88| 162|static char* Append(char* out, const AlphaNum& x) { 89| | // memcpy is allowed to overwrite arbitrary memory, so doing this after the 90| | // call would force an extra fetch of x.size(). 91| 162| char* after = out + x.size(); 92| 162| if (x.size() != 0) { ------------------ | Branch (92:7): [True: 162, False: 0] ------------------ 93| 162| memcpy(out, x.data(), x.size()); 94| 162| } 95| 162| return after; 96| 162|} _ZN4absl12lts_202111028AlphaNumC2EPKc: 248| 162| AlphaNum(const char* c_str) : piece_(c_str) {} // NOLINT(runtime/explicit) _ZN4absl12lts_202111028AlphaNumC2ENS0_11string_viewE: 249| 81| AlphaNum(absl::string_view pc) : piece_(pc) {} // NOLINT(runtime/explicit) _ZNK4absl12lts_202111028AlphaNum4sizeEv: 262| 810| absl::string_view::size_type size() const { return piece_.size(); } _ZNK4absl12lts_202111028AlphaNum4dataEv: 263| 324| const char* data() const { return piece_.data(); } _ZNK4absl12lts_202111028AlphaNum5PieceEv: 264| 162| absl::string_view Piece() const { return piece_; } _ZN4absl12lts_202111028AlphaNumC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE: 254| 162| : piece_(str) {} _ZNK4absl12lts_202111026ByChar4FindENS0_11string_viewEm: 102| 3.91M|absl::string_view ByChar::Find(absl::string_view text, size_t pos) const { 103| 3.91M| size_t found_pos = text.find(c_, pos); 104| 3.91M| if (found_pos == absl::string_view::npos) ------------------ | Branch (104:7): [True: 318, False: 3.91M] ------------------ 105| 318| return absl::string_view(text.data() + text.size(), 0); 106| 3.91M| return text.substr(found_pos, 1); 107| 3.91M|} _ZN4absl12lts_202111028StrSplitIcNS0_9SkipEmptyEEENS0_16strings_internal8SplitterINS3_15SelectDelimiterIT_E4typeET0_NS0_11string_viewEEENS3_23ConvertibleToStringViewES6_S9_: 525| 318| Predicate p) { 526| 318| using DelimiterType = 527| 318| typename strings_internal::SelectDelimiter::type; 528| 318| return strings_internal::Splitter( 530| 318| text.value(), DelimiterType(d), std::move(p)); 531| 318|} _ZN4absl12lts_202111026ByCharC2Ec: 158| 318| explicit ByChar(char c) : c_(c) {} _ZNK4absl12lts_202111029SkipEmptyclENS0_11string_viewE: 348| 3.91M| bool operator()(absl::string_view sp) const { return !sp.empty(); } _ZNK4absl12lts_2021110211string_view4findES1_m: 82| 399| size_type pos) const noexcept { 83| 399| if (empty() || pos > length_) { ------------------ | Branch (83:7): [True: 0, False: 399] | Branch (83:18): [True: 0, False: 399] ------------------ 84| 0| if (empty() && pos == 0 && s.empty()) return 0; ------------------ | Branch (84:9): [True: 0, False: 0] | Branch (84:20): [True: 0, False: 0] | Branch (84:32): [True: 0, False: 0] ------------------ 85| 0| return npos; 86| 0| } 87| 399| const char* result = 88| 399| strings_internal::memmatch(ptr_ + pos, length_ - pos, s.ptr_, s.length_); 89| 399| return result ? result - ptr_ : npos; ------------------ | Branch (89:10): [True: 81, False: 318] ------------------ 90| 399|} _ZNK4absl12lts_2021110211string_view4findEcm: 92| 3.91M|string_view::size_type string_view::find(char c, size_type pos) const noexcept { 93| 3.91M| if (empty() || pos >= length_) { ------------------ | Branch (93:7): [True: 0, False: 3.91M] | Branch (93:18): [True: 59, False: 3.91M] ------------------ 94| 59| return npos; 95| 59| } 96| 3.91M| const char* result = 97| 3.91M| static_cast(memchr(ptr_ + pos, c, length_ - pos)); 98| 3.91M| return result != nullptr ? result - ptr_ : npos; ------------------ | Branch (98:10): [True: 3.91M, False: 259] ------------------ 99| 3.91M|} _ZN4absl12lts_2021110211string_viewC2Ev: 184| 318| constexpr string_view() noexcept : ptr_(nullptr), length_(0) {} _ZN4absl12lts_2021110211string_viewC2EPKc: 203| 561| : ptr_(str), length_(str ? StrlenInternal(str) : 0) {} _ZN4absl12lts_2021110211string_viewC2EPKcm: 207| 11.7M| : ptr_(data), length_(CheckLengthInternal(len)) {} _ZNK4absl12lts_2021110211string_view4sizeEv: 276| 19.5M| constexpr size_type size() const noexcept { return length_; } _ZNK4absl12lts_2021110211string_view5emptyEv: 291| 7.83M| constexpr bool empty() const noexcept { return length_ == 0; } _ZNK4absl12lts_2021110211string_view4dataEv: 335| 27.4M| constexpr const_pointer data() const noexcept { return ptr_; } _ZNK4absl12lts_2021110211string_view6substrEmm: 398| 7.83M| constexpr string_view substr(size_type pos = 0, size_type n = npos) const { 399| 7.83M| return ABSL_PREDICT_FALSE(pos > length_) ------------------ | | 177| 7.83M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (177:31): [True: 0, False: 7.83M] | | | Branch (177:49): [Folded - Ignored] | | | Branch (177:58): [True: 0, False: 7.83M] | | ------------------ ------------------ 400| 7.83M| ? (base_internal::ThrowStdOutOfRange( 401| 0| "absl::string_view::substr"), 402| 0| string_view()) 403| 7.83M| : string_view(ptr_ + pos, Min(n, length_ - pos)); 404| 7.83M| } _ZN4absl12lts_2021110211string_viewC2EPKcmNS1_18SkipCheckLengthTagE: 603| 561| : ptr_(data), length_(len) {} _ZN4absl12lts_2021110211string_view19CheckLengthInternalEm: 608| 11.7M| static constexpr size_type CheckLengthInternal(size_type len) { 609| 11.7M| return ABSL_HARDENING_ASSERT(len <= kMaxSize), len; ------------------ | | 134| 11.7M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr) | | ------------------ | | | | 98| 11.7M| (ABSL_PREDICT_TRUE((expr)) ? static_cast(0) \ | | | | ------------------ | | | | | | 178| 11.7M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true)) | | | | | | ------------------ | | | | | | | Branch (178:30): [True: 11.7M, False: 0] | | | | | | | Branch (178:48): [Folded - Ignored] | | | | | | | Branch (178:57): [True: 11.7M, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 99| 11.7M| : [] { assert(false && #expr); }()) // NOLINT | | ------------------ ------------------ 610| 11.7M| } _ZN4absl12lts_2021110211string_view14StrlenInternalEPKc: 612| 561| static constexpr size_type StrlenInternal(const char* str) { 613| |#if defined(_MSC_VER) && _MSC_VER >= 1910 && !defined(__clang__) 614| | // MSVC 2017+ can evaluate this at compile-time. 615| | const char* begin = str; 616| | while (*str != '\0') ++str; 617| | return str - begin; 618| |#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \ 619| | (defined(__GNUC__) && !defined(__clang__)) 620| | // GCC has __builtin_strlen according to 621| | // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but 622| | // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above. 623| | // __builtin_strlen is constexpr. 624| 561| return __builtin_strlen(str); 625| |#else 626| | return str ? strlen(str) : 0; 627| |#endif 628| 561| } _ZN4absl12lts_2021110211string_view3MinEmm: 630| 7.83M| static constexpr size_t Min(size_type length_a, size_type length_b) { 631| 7.83M| return length_a < length_b ? length_a : length_b; ------------------ | Branch (631:12): [True: 7.83M, False: 377] ------------------ 632| 7.83M| } _ZN4absl12lts_2021110211string_viewC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE: 196| 561| : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {} _ZNK4absl12lts_2021110211string_viewcvNSt3__112basic_stringIcNS2_11char_traitsIcEET_EEINS2_9allocatorIcEEEEv: 371| 3.91M| explicit operator std::basic_string() const { 372| 3.91M| if (!data()) return {}; ------------------ | Branch (372:9): [True: 0, False: 3.91M] ------------------ 373| 3.91M| return std::basic_string(data(), size()); 374| 3.91M| }