_ZN8firebase9firestore5model4impl8BasePathINS1_12ResourcePathEEC2EONSt3__16vectorINS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEENSB_ISD_EEEE: 182| 375| explicit BasePath(SegmentsT&& segments) : segments_{std::move(segments)} { 183| 375| } _ZN8firebase9firestore5model12ResourcePath10FromStringERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 32| 486|ResourcePath ResourcePath::FromString(const std::string& path) { 33| 486| return FromStringView(path); 34| 486|} _ZN8firebase9firestore5model12ResourcePath14FromStringViewEN4absl12lts_2024011611string_viewE: 36| 486|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| 486| if (absl::StrContains(path, "//")) { ------------------ | Branch (41:7): [True: 111, False: 375] ------------------ 42| 111| util::ThrowInvalidArgument( 43| 111| "Invalid path (%s). Paths must not contain // in them.", path); 44| 111| } 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| 375| std::vector segments = 49| 375| absl::StrSplit(path, '/', absl::SkipEmpty()); 50| 375| return ResourcePath{std::move(segments)}; 51| 486|} _ZN8firebase9firestore5model12ResourcePathC2EONSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE: 50| 375| explicit ResourcePath(SegmentsT&& segments) : BasePath{std::move(segments)} { 51| 375| } _ZN8firebase9firestore4util5ThrowENS1_13ExceptionTypeEPKcS4_iRKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 92| 111| const std::string& message) { 93| 111| 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| 111| std::terminate(); 98| 111|} exception.cc:_ZN8firebase9firestore4util12_GLOBAL__N_119DefaultThrowHandlerENS1_13ExceptionTypeEPKcS5_iRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE: 48| 111| const std::string& message) { 49| 111| std::string what = absl::StrCat(ExceptionName(type), ": "); 50| 111| if (file && func) { ------------------ | Branch (50:7): [True: 0, False: 111] | Branch (50:15): [True: 0, False: 0] ------------------ 51| 0| absl::StrAppend(&what, file, "(", line, ") ", func, ": "); 52| 0| } 53| 111| 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| 111| LOG_ERROR("%s", what); ------------------ | | 77| 111| do { \ | | 78| 111| namespace _util = firebase::firestore::util; \ | | 79| 111| if (_util::LogIsLoggable(_util::kLogLevelError)) { \ | | ------------------ | | | Branch (79:9): [True: 111, False: 0] | | ------------------ | | 80| 111| std::string _message = _util::StringFormat(__VA_ARGS__); \ | | 81| 111| _util::LogMessage(_util::kLogLevelError, _message); \ | | 82| 111| } \ | | 83| 111| } while (0) | | ------------------ | | | Branch (83:12): [Folded - Ignored] | | ------------------ ------------------ 59| | 60| 111|#if ABSL_HAVE_EXCEPTIONS 61| 111| switch (type) { ------------------ | Branch (61:11): [True: 0, False: 111] ------------------ 62| 0| case ExceptionType::AssertionFailure: ------------------ | Branch (62:5): [True: 0, False: 111] ------------------ 63| 0| throw FirestoreInternalError(what); 64| 0| case ExceptionType::IllegalState: ------------------ | Branch (64:5): [True: 0, False: 111] ------------------ 65| | // Omit descriptive text since the type already encodes the kind of error. 66| 0| throw std::logic_error(message); 67| 111| case ExceptionType::InvalidArgument: ------------------ | Branch (67:5): [True: 111, False: 0] ------------------ 68| | // Omit descriptive text since the type already encodes the kind of error. 69| 111| throw std::invalid_argument(message); 70| 111| } 71| |#else 72| | std::terminate(); 73| |#endif 74| | 75| 0| UNREACHABLE(); ------------------ | | 82| 0|#define UNREACHABLE() abort() ------------------ 76| 111|} exception.cc:_ZN8firebase9firestore4util12_GLOBAL__N_113ExceptionNameENS1_13ExceptionTypeE: 32| 111|const char* ExceptionName(ExceptionType exception) { 33| 111| switch (exception) { ------------------ | Branch (33:11): [True: 0, False: 111] ------------------ 34| 0| case ExceptionType::AssertionFailure: ------------------ | Branch (34:5): [True: 0, False: 111] ------------------ 35| 0| return "FIRESTORE INTERNAL ASSERTION FAILED"; 36| 0| case ExceptionType::IllegalState: ------------------ | Branch (36:5): [True: 0, False: 111] ------------------ 37| 0| return "Illegal state"; 38| 111| case ExceptionType::InvalidArgument: ------------------ | Branch (38:5): [True: 111, False: 0] ------------------ 39| 111| return "Invalid argument"; 40| 111| } 41| 0| UNREACHABLE(); ------------------ | | 82| 0|#define UNREACHABLE() abort() ------------------ 42| 111|} _ZN8firebase9firestore4util20ThrowInvalidArgumentIJN4absl12lts_2024011611string_viewEEEEvPKcDpRKT_: 93| 111| const FA&... args) { 94| 111| Throw(ExceptionType::InvalidArgument, nullptr, nullptr, 0, 95| 111| StringFormat(format, args...)); 96| 111|} _ZN8firebase9firestore4util13LogIsLoggableENS1_8LogLevelE: 38| 111|bool LogIsLoggable(LogLevel level) { 39| 111| return level >= g_log_level; 40| 111|} _ZN8firebase9firestore4util10LogMessageENS1_8LogLevelERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 42| 111|void LogMessage(LogLevel log_level, const std::string& message) { 43| 111| if (log_level < g_log_level) { ------------------ | Branch (43:7): [True: 0, False: 111] ------------------ 44| 0| return; 45| 0| } 46| | 47| 111| const char* level_word; 48| | 49| 111| switch (log_level) { 50| 0| case kLogLevelDebug: ------------------ | Branch (50:5): [True: 0, False: 111] ------------------ 51| 0| level_word = "DEBUG"; 52| 0| break; 53| 0| case kLogLevelWarning: ------------------ | Branch (53:5): [True: 0, False: 111] ------------------ 54| 0| level_word = "WARNING"; 55| 0| break; 56| 111| case kLogLevelError: ------------------ | Branch (56:5): [True: 111, False: 0] ------------------ 57| 111| level_word = "ERROR"; 58| 111| break; 59| 0| case kLogLevelNotice: ------------------ | Branch (59:5): [True: 0, False: 111] ------------------ 60| 0| level_word = "INFO"; 61| 0| break; 62| 0| default: ------------------ | Branch (62:5): [True: 0, False: 111] ------------------ 63| 0| UNREACHABLE(); ------------------ | | 82| 0|#define UNREACHABLE() abort() ------------------ 64| 0| break; 65| 111| } 66| | 67| 111| printf("%s: %s\n", level_word, message.c_str()); 68| 111|} _ZN8firebase9firestore4util8internal18StringFormatPiecesEPKcSt16initializer_listIN4absl12lts_2024011611string_viewEE: 38| 222| const char* format, std::initializer_list pieces) { 39| 222| std::string result; 40| | 41| 222| const char* format_iter = format; 42| 222| const char* format_end = format + strlen(format); 43| | 44| 222| auto pieces_iter = pieces.begin(); 45| 222| auto pieces_end = pieces.end(); 46| 222| auto append_next_string_piece = [&](std::string* dest) { 47| 222| if (pieces_iter == pieces_end) { 48| 222| dest->append(kMissing); 49| 222| } else { 50| | // Pass a piece through 51| 222| dest->append(pieces_iter->data(), pieces_iter->size()); 52| 222| ++pieces_iter; 53| 222| } 54| 222| }; 55| | 56| 222| auto append_next_hex_piece = [&](std::string* dest) { 57| 222| if (pieces_iter == pieces_end) { 58| 222| dest->append(kMissing); 59| 222| } else { 60| 222| std::string hex = 61| 222| absl::BytesToHexString(absl::string_view(pieces_iter->data())); 62| 222| dest->append(hex.data(), hex.size()); 63| 222| ++pieces_iter; 64| 222| } 65| 222| }; 66| | 67| 222| auto append_specifier = [&](char spec) { 68| 222| switch (spec) { 69| 222| case '%': 70| | // Pass through literal %. 71| 222| result.push_back('%'); 72| 222| break; 73| | 74| 222| case 's': { 75| 222| append_next_string_piece(&result); 76| 222| break; 77| 222| } 78| | 79| 222| case 'x': { 80| 222| append_next_hex_piece(&result); 81| 222| break; 82| 222| } 83| | 84| 222| default: 85| 222| result.append(kInvalid); 86| 222| break; 87| 222| } 88| 222| }; 89| | 90| | // Iterate through the format string, advancing `format_iter` as we go. 91| 444| while (true) { ------------------ | Branch (91:10): [Folded - Ignored] ------------------ 92| 444| const char* percent_ptr = std::find(format_iter, format_end, '%'); 93| | 94| | // percent either points to the next format specifier or the end of the 95| | // format string. Either is safe to append here: 96| 444| result.append(format_iter, percent_ptr); 97| 444| if (percent_ptr == format_end) { ------------------ | Branch (97:9): [True: 222, False: 222] ------------------ 98| | // No further pieces to format 99| 222| break; 100| 222| } 101| | 102| | // Examine the specifier: 103| 222| const char* spec_ptr = percent_ptr + 1; 104| 222| if (spec_ptr == format_end) { ------------------ | Branch (104:9): [True: 0, False: 222] ------------------ 105| | // Incomplete specifier, treat as a literal "%" and be done. 106| 0| append_specifier('%'); 107| 0| break; 108| 0| } 109| 222| append_specifier(*spec_ptr); 110| | 111| 222| format_iter = spec_ptr + 1; 112| 222| } 113| | 114| 222| return result; 115| 222|} string_format.cc:_ZZN8firebase9firestore4util8internal18StringFormatPiecesEPKcSt16initializer_listIN4absl12lts_2024011611string_viewEEENK3$_2clEc: 67| 222| auto append_specifier = [&](char spec) { 68| 222| switch (spec) { 69| 0| case '%': ------------------ | Branch (69:7): [True: 0, False: 222] ------------------ 70| | // Pass through literal %. 71| 0| result.push_back('%'); 72| 0| break; 73| | 74| 222| case 's': { ------------------ | Branch (74:7): [True: 222, False: 0] ------------------ 75| 222| append_next_string_piece(&result); 76| 222| break; 77| 0| } 78| | 79| 0| case 'x': { ------------------ | Branch (79:7): [True: 0, False: 222] ------------------ 80| 0| append_next_hex_piece(&result); 81| 0| break; 82| 0| } 83| | 84| 0| default: ------------------ | Branch (84:7): [True: 0, False: 222] ------------------ 85| 0| result.append(kInvalid); 86| 0| break; 87| 222| } 88| 222| }; string_format.cc:_ZZN8firebase9firestore4util8internal18StringFormatPiecesEPKcSt16initializer_listIN4absl12lts_2024011611string_viewEEENK3$_0clEPNSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEE: 46| 222| auto append_next_string_piece = [&](std::string* dest) { 47| 222| if (pieces_iter == pieces_end) { ------------------ | Branch (47:9): [True: 0, False: 222] ------------------ 48| 0| dest->append(kMissing); 49| 222| } else { 50| | // Pass a piece through 51| 222| dest->append(pieces_iter->data(), pieces_iter->size()); 52| 222| ++pieces_iter; 53| 222| } 54| 222| }; _ZN8firebase9firestore4util12StringFormatIJN4absl12lts_2024011611string_viewEEEENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEPKcDpRKT_: 184| 111|std::string StringFormat(const char* format, const FA&... args) { 185| 111| return internal::StringFormatPieces( 186| 111| format, {static_cast(args).Piece()...}); 187| 111|} _ZN8firebase9firestore4util9FormatArgC2IRKN4absl12lts_2024011611string_viewEEEOT_ONS5_16strings_internal13StringifySinkE: 77| 111| : FormatArg{std::forward(value), std::move(sink), 78| 111| internal::FormatChoice<0>{}} { 79| 111| } _ZN8firebase9firestore4util9FormatArgC2IRKN4absl12lts_2024011611string_viewEEEOT_ONS5_16strings_internal13StringifySinkENS1_8internal12FormatChoiceILi5EEE: 163| 111| : AlphaNum(std::forward(value)) { 164| 111| } _ZN8firebase9firestore4util12StringFormatIJNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEES9_PKcDpRKT_: 184| 111|std::string StringFormat(const char* format, const FA&... args) { 185| 111| return internal::StringFormatPieces( 186| 111| format, {static_cast(args).Piece()...}); 187| 111|} _ZN8firebase9firestore4util9FormatArgC2IRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEOT_ON4absl12lts_2024011616strings_internal13StringifySinkE: 77| 111| : FormatArg{std::forward(value), std::move(sink), 78| 111| internal::FormatChoice<0>{}} { 79| 111| } _ZN8firebase9firestore4util9FormatArgC2IRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEOT_ON4absl12lts_2024011616strings_internal13StringifySinkENS1_8internal12FormatChoiceILi5EEE: 163| 111| : AlphaNum(std::forward(value)) { 164| 111| } LLVMFuzzerTestOneInput: 25| 486|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 26| 486| const char* str_ptr = reinterpret_cast(data); 27| 486| std::string str{str_ptr, size}; 28| | 29| 486| try { 30| 486| ResourcePath rp = ResourcePath::FromString(str); 31| 486| } catch (...) { 32| | // Ignore caught errors and assertions. 33| 111| } 34| | 35| 486| return 0; 36| 486|} _ZN4absl12lts_2024011616strings_internal28STLStringResizeUninitializedINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEEvPT_m: 67| 111|inline void STLStringResizeUninitialized(string_type* s, size_t new_size) { 68| 111| ResizeUninitializedTraits::Resize(s, new_size); 69| 111|} _ZN4absl12lts_2024011616strings_internal25ResizeUninitializedTraitsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE6ResizeEPS9_m: 47| 111| static void Resize(string_type* s, size_t new_size) { 48| 111| s->__resize_default_init(new_size); 49| 111| } _ZN4absl12lts_2024011616strings_internal25AppendUninitializedTraitsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE6AppendEPS9_m: 96| 111| static void Append(string_type* s, size_t n) { 97| 111| s->__append_default_init(n); 98| 111| } _ZN4absl12lts_2024011616strings_internal23ConvertibleToStringViewC2ENS0_11string_viewE: 63| 375| : value_(s) {} _ZNK4absl12lts_2024011616strings_internal23ConvertibleToStringView5valueEv: 71| 375| absl::string_view value() const { return value_; } _ZN4absl12lts_2024011616strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEC2ES5_S3_S4_: 286| 375| : text_(std::move(input_text)), 287| 375| delimiter_(std::move(d)), 288| 375| predicate_(std::move(p)) {} _ZNK4absl12lts_2024011616strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEcvT_INSt3__16vectorINS9_12basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEENSE_ISG_EEEETnNS9_9enable_ifIXaantsr22ShouldUseLifetimeBoundIS5_S7_EE5valuesr23SplitterIsConvertibleToIS7_EE5valueEDnE4typeELDn0EEEv: 319| 375| operator Container() const { 320| 375| return ConvertToContainer::value>()(*this); 322| 375| } _ZNK4absl12lts_2024011616strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE18ConvertToContainerINSt3__16vectorINS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEENSD_ISF_EEEESF_Lb0EEclERKS6_: 419| 375| std::vector operator()(const Splitter& splitter) const { 420| 375| const std::vector v = splitter; 421| 375| return std::vector(v.begin(), v.end()); 422| 375| } _ZNK4absl12lts_2024011616strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEcvT_INSt3__16vectorIS5_NS9_9allocatorIS5_EEEETnNS9_9enable_ifIXaantsr22ShouldUseLifetimeBoundIS5_S7_EE5valuesr23SplitterIsConvertibleToIS7_EE5valueEDnE4typeELDn0EEEv: 319| 375| operator Container() const { 320| 375| return ConvertToContainer::value>()(*this); 322| 375| } _ZNK4absl12lts_2024011616strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE18ConvertToContainerINSt3__16vectorIS5_NS8_9allocatorIS5_EEEES5_Lb0EEclERKS6_: 388| 375| const Splitter& splitter) const { 389| 375| struct raw_view { 390| 375| const char* data; 391| 375| size_t size; 392| 375| operator absl::string_view() const { // NOLINT(runtime/explicit) 393| 375| return {data, size}; 394| 375| } 395| 375| }; 396| 375| std::vector v; 397| 375| std::array ar; 398| 441k| for (auto it = splitter.begin(); !it.at_end();) { ------------------ | Branch (398:40): [True: 440k, False: 375] ------------------ 399| 440k| size_t index = 0; 400| 7.04M| do { 401| 7.04M| ar[index].data = it->data(); 402| 7.04M| ar[index].size = it->size(); 403| 7.04M| ++it; 404| 7.04M| } while (++index != ar.size() && !it.at_end()); ------------------ | Branch (404:18): [True: 6.60M, False: 440k] | Branch (404:42): [True: 6.60M, False: 348] ------------------ 405| 440k| v.insert(v.end(), ar.begin(), ar.begin() + index); 406| 440k| } 407| 375| return v; 408| 375| } _ZNK4absl12lts_2024011616strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE5beginEv: 297| 375| const_iterator begin() const { return {const_iterator::kInitState, this}; } _ZN4absl12lts_2024011616strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEEEC2ENS8_5StateEPKS7_: 94| 375| : pos_(0), 95| 375| state_(state), 96| 375| splitter_(splitter), 97| 375| delimiter_(splitter->delimiter()), 98| 375| 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| 375| if (splitter_->text().data() == nullptr) { ------------------ | Branch (108:9): [True: 0, False: 375] ------------------ 109| 0| state_ = kEndState; 110| 0| pos_ = splitter_->text().size(); 111| 0| return; 112| 0| } 113| | 114| 375| if (state_ == kEndState) { ------------------ | Branch (114:9): [True: 0, False: 375] ------------------ 115| 0| pos_ = splitter_->text().size(); 116| 375| } else { 117| 375| ++(*this); 118| 375| } 119| 375| } _ZNK4absl12lts_2024011616strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE9delimiterEv: 291| 375| const Delimiter& delimiter() const { return delimiter_; } _ZNK4absl12lts_2024011616strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE9predicateEv: 292| 375| const Predicate& predicate() const { return predicate_; } _ZNK4absl12lts_2024011616strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE4textEv: 290| 7.05M| absl::string_view text() const { return text_; } _ZNK4absl12lts_2024011616strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEEE6at_endEv: 121| 7.05M| bool at_end() const { return state_ == kEndState; } _ZNK4absl12lts_2024011616strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEEEptEv: 124| 14.0M| pointer operator->() const { return &curr_; } _ZN4absl12lts_2024011616strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEEEEppEv: 126| 7.05M| SplitIterator& operator++() { 127| 7.05M| do { 128| 7.05M| if (state_ == kLastState) { ------------------ | Branch (128:11): [True: 375, False: 7.04M] ------------------ 129| 375| state_ = kEndState; 130| 375| return *this; 131| 375| } 132| 7.04M| const absl::string_view text = splitter_->text(); 133| 7.04M| const absl::string_view d = delimiter_.Find(text, pos_); 134| 7.04M| if (d.data() == text.data() + text.size()) state_ = kLastState; ------------------ | Branch (134:11): [True: 375, False: 7.04M] ------------------ 135| 7.04M| curr_ = text.substr(pos_, 136| 7.04M| static_cast(d.data() - (text.data() + pos_))); 137| 7.04M| pos_ += curr_.size() + d.size(); 138| 7.04M| } while (!predicate_(curr_)); ------------------ | Branch (138:14): [True: 155, False: 7.04M] ------------------ 139| 7.04M| return *this; 140| 7.05M| } _ZZNK4absl12lts_2024011616strings_internal8SplitterINS0_6ByCharENS0_9SkipEmptyENS0_11string_viewEE18ConvertToContainerINSt3__16vectorIS5_NS8_9allocatorIS5_EEEES5_Lb0EEclERKS6_ENK8raw_viewcvS5_Ev: 392| 7.04M| operator absl::string_view() const { // NOLINT(runtime/explicit) 393| 7.04M| return {data, size}; 394| 7.04M| } _ZN4absl12lts_2024011611StrContainsENS0_11string_viewES1_: 47| 486| absl::string_view needle) noexcept { 48| 486| return haystack.find(needle, 0) != haystack.npos; 49| 486|} _ZN4absl12lts_202401166StrCatERKNS0_8AlphaNumES3_: 58| 111|std::string StrCat(const AlphaNum& a, const AlphaNum& b) { 59| 111| std::string result; 60| 111| absl::strings_internal::STLStringResizeUninitialized(&result, 61| 111| a.size() + b.size()); 62| 111| char* const begin = &result[0]; 63| 111| char* out = begin; 64| 111| out = Append(out, a); 65| 111| out = Append(out, b); 66| 111| assert(out == begin + result.size()); 67| 111| return result; 68| 111|} _ZN4absl12lts_2024011616strings_internal37STLStringAppendUninitializedAmortizedEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEm: 102| 111| size_t to_append) { 103| 111| strings_internal::AppendUninitializedTraits::Append(dest, 104| 111| to_append); 105| 111|} _ZN4absl12lts_202401169StrAppendEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS0_8AlphaNumE: 277| 111|void StrAppend(absl::Nonnull dest, const AlphaNum& a) { 278| 111| ASSERT_NO_OVERLAP(*dest, a); ------------------ | | 250| 111| assert(((src).size() == 0) || \ | | 251| 111| (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size()))) ------------------ 279| 111| std::string::size_type old_size = dest->size(); 280| 111| strings_internal::STLStringAppendUninitializedAmortized(dest, a.size()); 281| 111| char* const begin = &(*dest)[0]; 282| 111| char* out = begin + old_size; 283| 111| out = Append(out, a); 284| 111| assert(out == begin + dest->size()); 285| 111|} str_cat.cc:_ZN4absl12lts_2024011612_GLOBAL__N_16AppendEPcRKNS0_8AlphaNumE: 46| 333|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| 333| char* after = out + x.size(); 50| 333| if (x.size() != 0) { ------------------ | Branch (50:7): [True: 333, False: 0] ------------------ 51| 333| memcpy(out, x.data(), x.size()); 52| 333| } 53| 333| return after; 54| 333|} _ZN4absl12lts_202401168AlphaNumC2EPKc: 353| 222| : piece_(NullSafeStringView(c_str)) {} _ZN4absl12lts_202401168AlphaNumC2ENS0_11string_viewE: 356| 111| : piece_(pc) {} _ZNK4absl12lts_202401168AlphaNum4sizeEv: 377| 1.44k| absl::string_view::size_type size() const { return piece_.size(); } _ZNK4absl12lts_202401168AlphaNum4dataEv: 378| 444| absl::Nullable data() const { return piece_.data(); } _ZNK4absl12lts_202401168AlphaNum5PieceEv: 379| 222| absl::string_view Piece() const { return piece_; } _ZN4absl12lts_202401168AlphaNumC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE: 369| 222| : piece_(str) {} _ZNK4absl12lts_202401166ByChar4FindENS0_11string_viewEm: 108| 7.04M|absl::string_view ByChar::Find(absl::string_view text, size_t pos) const { 109| 7.04M| size_t found_pos = text.find(c_, pos); 110| 7.04M| if (found_pos == absl::string_view::npos) ------------------ | Branch (110:7): [True: 375, False: 7.04M] ------------------ 111| 375| return absl::string_view(text.data() + text.size(), 0); 112| 7.04M| return text.substr(found_pos, 1); 113| 7.04M|} _ZN4absl12lts_202401168StrSplitIcNS0_9SkipEmptyEEENS0_16strings_internal8SplitterINS3_15SelectDelimiterIT_E4typeET0_NS0_11string_viewEEENS3_23ConvertibleToStringViewES6_S9_: 542| 375| Predicate p) { 543| 375| using DelimiterType = 544| 375| typename strings_internal::SelectDelimiter::type; 545| 375| return strings_internal::Splitter( 547| 375| text.value(), DelimiterType(d), std::move(p)); 548| 375|} _ZN4absl12lts_202401166ByCharC2Ec: 176| 375| explicit ByChar(char c) : c_(c) {} _ZNK4absl12lts_202401169SkipEmptyclENS0_11string_viewE: 366| 7.04M| bool operator()(absl::string_view sp) const { return !sp.empty(); } _ZNK4absl12lts_2024011611string_view4findES1_m: 109| 486| size_type pos) const noexcept { 110| 486| if (empty() || pos > length_) { ------------------ | Branch (110:7): [True: 0, False: 486] | Branch (110:18): [True: 0, False: 486] ------------------ 111| 0| if (empty() && pos == 0 && s.empty()) return 0; ------------------ | Branch (111:9): [True: 0, False: 0] | Branch (111:20): [True: 0, False: 0] | Branch (111:32): [True: 0, False: 0] ------------------ 112| 0| return npos; 113| 0| } 114| 486| const char* result = memmatch(ptr_ + pos, length_ - pos, s.ptr_, s.length_); 115| 486| return result ? static_cast(result - ptr_) : npos; ------------------ | Branch (115:10): [True: 111, False: 375] ------------------ 116| 486|} _ZNK4absl12lts_2024011611string_view4findEcm: 118| 7.04M|string_view::size_type string_view::find(char c, size_type pos) const noexcept { 119| 7.04M| if (empty() || pos >= length_) { ------------------ | Branch (119:7): [True: 0, False: 7.04M] | Branch (119:18): [True: 59, False: 7.04M] ------------------ 120| 59| return npos; 121| 59| } 122| 7.04M| const char* result = 123| 7.04M| static_cast(memchr(ptr_ + pos, c, length_ - pos)); 124| 7.04M| return result != nullptr ? static_cast(result - ptr_) : npos; ------------------ | Branch (124:10): [True: 7.04M, False: 316] ------------------ 125| 7.04M|} string_view.cc:_ZN4absl12lts_2024011612_GLOBAL__N_18memmatchEPKcmS3_m: 36| 486| size_t neelen) { 37| 486| if (0 == neelen) { ------------------ | Branch (37:7): [True: 0, False: 486] ------------------ 38| 0| return phaystack; // even if haylen is 0 39| 0| } 40| 486| if (haylen < neelen) return nullptr; ------------------ | Branch (40:7): [True: 2, False: 484] ------------------ 41| | 42| 484| const char* match; 43| 484| const char* hayend = phaystack + haylen - neelen + 1; 44| | // A static cast is used here as memchr returns a const void *, and pointer 45| | // arithmetic is not allowed on pointers to void. 46| 484| while ( 47| 7.72M| (match = static_cast(memchr( ------------------ | Branch (47:7): [True: 7.71M, False: 373] ------------------ 48| 7.72M| phaystack, pneedle[0], static_cast(hayend - phaystack))))) { 49| 7.71M| if (memcmp(match, pneedle, neelen) == 0) ------------------ | Branch (49:9): [True: 111, False: 7.71M] ------------------ 50| 111| return match; 51| 7.71M| else 52| 7.71M| phaystack = match + 1; 53| 7.71M| } 54| 373| return nullptr; 55| 484|} _ZN4absl12lts_2024011611string_viewC2Ev: 180| 375| constexpr string_view() noexcept : ptr_(nullptr), length_(0) {} _ZN4absl12lts_2024011611string_viewC2EPKc: 200| 708| : ptr_(str), length_(str ? StrlenInternal(str) : 0) {} ------------------ | Branch (200:28): [True: 708, False: 0] ------------------ _ZN4absl12lts_2024011611string_viewC2EPKcm: 204| 21.1M| : ptr_(data), length_(CheckLengthInternal(len)) {} _ZNK4absl12lts_2024011611string_view4sizeEv: 273| 35.2M| constexpr size_type size() const noexcept { return length_; } _ZNK4absl12lts_2024011611string_view5emptyEv: 288| 14.1M| constexpr bool empty() const noexcept { return length_ == 0; } _ZNK4absl12lts_2024011611string_view4dataEv: 332| 49.3M| constexpr const_pointer data() const noexcept { return ptr_; } _ZNK4absl12lts_2024011611string_view6substrEmm: 395| 14.0M| constexpr string_view substr(size_type pos = 0, size_type n = npos) const { 396| 14.0M| return ABSL_PREDICT_FALSE(pos > length_) ------------------ | | 178| 14.0M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) | | ------------------ | | | Branch (178:31): [True: 0, False: 14.0M] | | | Branch (178:49): [Folded - Ignored] | | | Branch (178:58): [True: 0, False: 14.0M] | | ------------------ ------------------ 397| 14.0M| ? (base_internal::ThrowStdOutOfRange( 398| 0| "absl::string_view::substr"), 399| 0| string_view()) 400| 14.0M| : string_view(ptr_ + pos, Min(n, length_ - pos)); 401| 14.0M| } _ZN4absl12lts_2024011611string_viewC2EPKcmNS1_18SkipCheckLengthTagE: 663| 708| : ptr_(data), length_(len) {} _ZN4absl12lts_2024011611string_view19CheckLengthInternalEm: 668| 21.1M| static constexpr size_type CheckLengthInternal(size_type len) { 669| 21.1M| return ABSL_HARDENING_ASSERT(len <= kMaxSize), len; ------------------ | | 128| 21.1M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr) | | ------------------ | | | | 98| 21.1M| (ABSL_PREDICT_TRUE((expr)) ? static_cast(0) \ | | | | ------------------ | | | | | | 179| 21.1M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true)) | | | | | | ------------------ | | | | | | | Branch (179:30): [True: 21.1M, False: 0] | | | | | | | Branch (179:48): [Folded - Ignored] | | | | | | | Branch (179:57): [True: 21.1M, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 99| 21.1M| : [] { assert(false && #expr); }()) // NOLINT | | ------------------ ------------------ 670| 21.1M| } _ZN4absl12lts_2024011611string_view14StrlenInternalEPKc: 672| 708| static constexpr size_type StrlenInternal(absl::Nonnull str) { 673| |#if defined(_MSC_VER) && _MSC_VER >= 1910 && !defined(__clang__) 674| | // MSVC 2017+ can evaluate this at compile-time. 675| | const char* begin = str; 676| | while (*str != '\0') ++str; 677| | return str - begin; 678| |#elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \ 679| | (defined(__GNUC__) && !defined(__clang__)) 680| | // GCC has __builtin_strlen according to 681| | // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but 682| | // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above. 683| | // __builtin_strlen is constexpr. 684| 708| return __builtin_strlen(str); 685| |#else 686| | return str ? strlen(str) : 0; 687| |#endif 688| 708| } _ZN4absl12lts_2024011611string_view3MinEmm: 690| 14.0M| static constexpr size_t Min(size_type length_a, size_type length_b) { 691| 14.0M| return length_a < length_b ? length_a : length_b; ------------------ | Branch (691:12): [True: 14.0M, False: 434] ------------------ 692| 14.0M| } _ZN4absl12lts_2024011618NullSafeStringViewEPKc: 762| 222|constexpr string_view NullSafeStringView(absl::Nullable p) { 763| 222| return p ? string_view(p) : string_view(); ------------------ | Branch (763:10): [True: 222, False: 0] ------------------ 764| 222|} _ZN4absl12lts_2024011611string_viewC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE: 192| 708| : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {} _ZNK4absl12lts_2024011611string_viewcvNSt3__112basic_stringIcNS2_11char_traitsIcEET_EEINS2_9allocatorIcEEEEv: 368| 7.04M| explicit operator std::basic_string() const { 369| 7.04M| if (!data()) return {}; ------------------ | Branch (369:9): [True: 0, False: 7.04M] ------------------ 370| 7.04M| return std::basic_string(data(), size()); 371| 7.04M| }