_ZN8FuzzDataC2EPKhm: 50| 11.0k| size_t size) : Data(data),Size(size){} _ZN8FuzzData16splitIntoStringsEv: 117| 11.0k| std::vector splitIntoStrings() { 118| 11.0k| std::vector ret; 119| 11.0k| if(Size>0) { ------------------ | Branch (119:8): [True: 11.0k, False: 10] ------------------ 120| 11.0k| ret=split(chardata(),Size); 121| | // all data consumed. 122| 11.0k| Data+=Size; 123| 11.0k| Size=0; 124| 11.0k| } 125| 11.0k| return ret; 126| 11.0k| } _Z5splitPKcm: 26| 11.0k|inline std::vector split(const char* Data, size_t Size) { 27| | 28| 11.0k| std::vector ret; 29| | 30| 11.0k| using namespace std::literals; 31| 11.0k| constexpr auto sep="\n~~\n"sv; 32| | 33| 11.0k| std::string_view all(Data,Size); 34| 11.0k| auto pos=all.find(sep); 35| 546k| while(pos!=std::string_view::npos) { ------------------ | Branch (35:11): [True: 535k, False: 11.0k] ------------------ 36| 535k| ret.push_back(all.substr(0,pos)); 37| 535k| all=all.substr(pos+sep.size()); 38| 535k| pos=all.find(sep); 39| 535k| } 40| 11.0k| ret.push_back(all); 41| 11.0k| return ret; 42| 11.0k|} _ZNK8FuzzData8chardataEv: 158| 11.0k| const char* chardata() const {return static_cast(static_cast(Data));} _ZNK8FuzzDatacvbEv: 129| 11.0k| explicit operator bool() const { return Data!=nullptr;} _ZN8FuzzData6getIntILi0ELi31EEEiv: 54| 11.0k| int getInt() { 55| 11.0k| static_assert (Min(get()%urange); 66| 0| if(range<65536) ------------------ | Branch (66:8): [Folded - Ignored] ------------------ 67| 0| return Min+static_cast(get()%urange); 68| | 69| 0| return Min+static_cast(get()%urange); 70| 0| } _ZN8FuzzData3getIhEET_v: 73| 22.1k| T get() { 74| 22.1k| const auto Nbytes=sizeof(T); 75| 22.1k| T ret{}; 76| 22.1k| if(Size(get()%urange); 66| 0| if(range<65536) ------------------ | Branch (66:8): [Folded - Ignored] ------------------ 67| 0| return Min+static_cast(get()%urange); 68| | 69| 0| return Min+static_cast(get()%urange); 70| 0| } _ZN8FuzzData3getImEET_v: 73| 11.0k| T get() { 74| 11.0k| const auto Nbytes=sizeof(T); 75| 11.0k| T ret{}; 76| 11.0k| if(Size(); 12| | 13| | // there will be some templatized functions like is() which need to be tested 14| | // on a type. select one dynamically and create a function that will invoke 15| | // with that type 16| 11.0k| const int selecttype=fd.getInt<0,7>(); 17| 11.0k| auto invoke_with_type=[selecttype](auto cb) { 18| 11.0k| using constcharstar=const char*; 19| 11.0k| switch(selecttype) { 20| 11.0k| case 0: cb(bool{});break; 21| 11.0k| case 1: cb(double{});break; 22| 11.0k| case 2: cb(uint64_t{});break; 23| 11.0k| case 3: cb(int64_t{});break; 24| 11.0k| case 4: cb(std::string_view{});break; 25| 11.0k| case 5: cb(constcharstar{});break; 26| 11.0k| case 6: cb(simdjson::dom::array{});break; 27| 11.0k| case 7: cb(simdjson::dom::object{});break; 28| 11.0k| } 29| 11.0k| }; 30| | 31| 11.0k| const auto index = fd.get(); 32| | 33| | // split the remainder of the document into strings 34| 11.0k| auto strings = fd.splitIntoStrings(); 35| 11.1k| while (strings.size() < 2) { ------------------ | Branch (35:10): [True: 66, False: 11.0k] ------------------ 36| 66| strings.emplace_back(); 37| 66| } 38| 11.0k| const auto str = strings[0]; 39| | 40| | // exit if there was too little data 41| 11.0k| if (!fd) ------------------ | Branch (41:7): [True: 8, False: 11.0k] ------------------ 42| 8| return 0; 43| | 44| 11.0k| simdjson::dom::parser parser; 45| 11.0k| simdjson_unused simdjson::dom::element elem; ------------------ | | 113| 11.0k| #define simdjson_unused __attribute__((unused)) ------------------ 46| 11.0k| simdjson_unused auto error = parser.parse(strings[1]).get(elem); ------------------ | | 113| 11.0k| #define simdjson_unused __attribute__((unused)) ------------------ 47| | 48| 11.0k| if (error) ------------------ | Branch (48:7): [True: 4.31k, False: 6.75k] ------------------ 49| 4.31k| return 0; 50| | 51| 6.75k|#define CASE(num, fun) \ 52| 6.75k| case num: { \ 53| 6.75k| simdjson_unused auto v = elem.fun(); \ 54| 6.75k| break; \ 55| 6.75k| } 56| 6.75k|#define CASE2(num, fun) \ 57| 6.75k| case num: { \ 58| 6.75k| simdjson_unused auto v = elem fun; \ 59| 6.75k| break; \ 60| 6.75k| } 61| 6.75k|#if SIMDJSON_EXCEPTIONS 62| 6.75k| try { 63| 6.75k|#endif 64| | 65| 6.75k| switch (action) { 66| 427| CASE(0, type); ------------------ | | 52| 427| case num: { \ | | ------------------ | | | Branch (52:3): [True: 427, False: 6.32k] | | ------------------ | | 53| 427| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 427| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 427| break; \ | | 55| 427| } ------------------ 67| 158| CASE(1, get_array); ------------------ | | 52| 158| case num: { \ | | ------------------ | | | Branch (52:3): [True: 158, False: 6.59k] | | ------------------ | | 53| 158| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 158| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 158| break; \ | | 55| 158| } ------------------ 68| 81| CASE(2, get_object); ------------------ | | 52| 81| case num: { \ | | ------------------ | | | Branch (52:3): [True: 81, False: 6.67k] | | ------------------ | | 53| 81| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 81| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 81| break; \ | | 55| 81| } ------------------ 69| 52| CASE(3, get_c_str); ------------------ | | 52| 52| case num: { \ | | ------------------ | | | Branch (52:3): [True: 52, False: 6.70k] | | ------------------ | | 53| 52| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 52| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 52| break; \ | | 55| 52| } ------------------ 70| 66| CASE(4, get_string_length); ------------------ | | 52| 66| case num: { \ | | ------------------ | | | Branch (52:3): [True: 66, False: 6.68k] | | ------------------ | | 53| 66| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 66| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 66| break; \ | | 55| 66| } ------------------ 71| 38| CASE(5, get_string); ------------------ | | 52| 38| case num: { \ | | ------------------ | | | Branch (52:3): [True: 38, False: 6.71k] | | ------------------ | | 53| 38| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 38| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 38| break; \ | | 55| 38| } ------------------ 72| 50| CASE(6, get_int64); ------------------ | | 52| 50| case num: { \ | | ------------------ | | | Branch (52:3): [True: 50, False: 6.70k] | | ------------------ | | 53| 50| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 50| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 50| break; \ | | 55| 50| } ------------------ 73| 39| CASE(7, get_uint64); ------------------ | | 52| 39| case num: { \ | | ------------------ | | | Branch (52:3): [True: 39, False: 6.71k] | | ------------------ | | 53| 39| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 39| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 39| break; \ | | 55| 39| } ------------------ 74| 125| CASE(8, get_double); ------------------ | | 52| 125| case num: { \ | | ------------------ | | | Branch (52:3): [True: 125, False: 6.62k] | | ------------------ | | 53| 125| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 125| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 125| break; \ | | 55| 125| } ------------------ 75| 36| CASE(9, get_bool); ------------------ | | 52| 36| case num: { \ | | ------------------ | | | Branch (52:3): [True: 36, False: 6.71k] | | ------------------ | | 53| 36| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 36| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 36| break; \ | | 55| 36| } ------------------ 76| 106| CASE(10, is_array); ------------------ | | 52| 106| case num: { \ | | ------------------ | | | Branch (52:3): [True: 106, False: 6.64k] | | ------------------ | | 53| 106| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 106| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 106| break; \ | | 55| 106| } ------------------ 77| 50| CASE(11, is_object); ------------------ | | 52| 50| case num: { \ | | ------------------ | | | Branch (52:3): [True: 50, False: 6.70k] | | ------------------ | | 53| 50| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 50| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 50| break; \ | | 55| 50| } ------------------ 78| 78| CASE(12, is_string); ------------------ | | 52| 78| case num: { \ | | ------------------ | | | Branch (52:3): [True: 78, False: 6.67k] | | ------------------ | | 53| 78| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 78| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 78| break; \ | | 55| 78| } ------------------ 79| 66| CASE(13, is_int64); ------------------ | | 52| 66| case num: { \ | | ------------------ | | | Branch (52:3): [True: 66, False: 6.68k] | | ------------------ | | 53| 66| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 66| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 66| break; \ | | 55| 66| } ------------------ 80| 49| CASE(14, is_uint64); ------------------ | | 52| 49| case num: { \ | | ------------------ | | | Branch (52:3): [True: 49, False: 6.70k] | | ------------------ | | 53| 49| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 49| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 49| break; \ | | 55| 49| } ------------------ 81| 71| CASE(15, is_double); ------------------ | | 52| 71| case num: { \ | | ------------------ | | | Branch (52:3): [True: 71, False: 6.68k] | | ------------------ | | 53| 71| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 71| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 71| break; \ | | 55| 71| } ------------------ 82| 281| CASE(16, is_number); ------------------ | | 52| 281| case num: { \ | | ------------------ | | | Branch (52:3): [True: 281, False: 6.47k] | | ------------------ | | 53| 281| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 281| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 281| break; \ | | 55| 281| } ------------------ 83| 117| CASE(17, is_bool); ------------------ | | 52| 117| case num: { \ | | ------------------ | | | Branch (52:3): [True: 117, False: 6.63k] | | ------------------ | | 53| 117| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 117| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 117| break; \ | | 55| 117| } ------------------ 84| 59| CASE(18, is_null); ------------------ | | 52| 59| case num: { \ | | ------------------ | | | Branch (52:3): [True: 59, False: 6.69k] | | ------------------ | | 53| 59| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 59| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 59| break; \ | | 55| 59| } ------------------ 85| | // element.is<>() : 86| 104| case 19: { ------------------ | Branch (86:5): [True: 104, False: 6.65k] ------------------ 87| 104| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); 88| 104| } break; 89| | 90| | // CASE(xx,get); 91| 84| case 20: { ------------------ | Branch (91:7): [True: 84, False: 6.67k] ------------------ 92| 84| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); 93| 84| } break; 94| | 95| | // CASE(xx,tie); 96| 69| case 21: { ------------------ | Branch (96:7): [True: 69, False: 6.68k] ------------------ 97| 69| invoke_with_type([&elem](auto t){ 98| 69| simdjson::error_code ec; 99| 69| simdjson::dom::element{elem}.tie(t,ec); }); 100| 69| } break; 101| | 102| 0|#if SIMDJSON_EXCEPTIONS 103| | // cast to type 104| 638| case 22: { ------------------ | Branch (104:7): [True: 638, False: 6.11k] ------------------ 105| 638| invoke_with_type([&elem](auto t){ 106| 638| using T=decltype(t); 107| 638| simdjson_unused auto v = static_cast(elem); }); 108| 638| } break; 109| | 110| 76| CASE(23, begin); ------------------ | | 52| 76| case num: { \ | | ------------------ | | | Branch (52:3): [True: 76, False: 6.67k] | | ------------------ | | 53| 76| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 76| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 76| break; \ | | 55| 76| } ------------------ 111| 75| CASE(24, end); ------------------ | | 52| 75| case num: { \ | | ------------------ | | | Branch (52:3): [True: 75, False: 6.67k] | | ------------------ | | 53| 75| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 113| 75| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 75| break; \ | | 55| 75| } ------------------ 112| 0|#endif 113| 354| CASE2(25, [str]); ------------------ | | 57| 354| case num: { \ | | ------------------ | | | Branch (57:3): [True: 354, False: 6.40k] | | ------------------ | | 58| 354| simdjson_unused auto v = elem fun; \ | | ------------------ | | | | 113| 354| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 59| 354| break; \ | | 60| 354| } ------------------ 114| 1.03k| CASE2(26, .at_pointer(str)); ------------------ | | 57| 1.03k| case num: { \ | | ------------------ | | | Branch (57:3): [True: 1.03k, False: 5.72k] | | ------------------ | | 58| 1.03k| simdjson_unused auto v = elem fun; \ | | ------------------ | | | | 113| 1.03k| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 59| 1.03k| break; \ | | 60| 1.03k| } ------------------ 115| | // CASE2(xx,at(str)); deprecated 116| 429| CASE2(28, .at(index)); ------------------ | | 57| 429| case num: { \ | | ------------------ | | | Branch (57:3): [True: 429, False: 6.32k] | | ------------------ | | 58| 429| simdjson_unused auto v = elem fun; \ | | ------------------ | | | | 113| 429| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 59| 429| break; \ | | 60| 429| } ------------------ 117| 328| CASE2(29, .at_key(str)); ------------------ | | 57| 328| case num: { \ | | ------------------ | | | Branch (57:3): [True: 328, False: 6.42k] | | ------------------ | | 58| 328| simdjson_unused auto v = elem fun; \ | | ------------------ | | | | 113| 328| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 59| 328| break; \ | | 60| 328| } ------------------ 118| 440| CASE2(30, .at_key_case_insensitive(str)); ------------------ | | 57| 440| case num: { \ | | ------------------ | | | Branch (57:3): [True: 440, False: 6.31k] | | ------------------ | | 58| 440| simdjson_unused auto v = elem fun; \ | | ------------------ | | | | 113| 440| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 59| 440| break; \ | | 60| 440| } ------------------ 119| 1.03k| case 31: { NulOStream os; ------------------ | Branch (119:7): [True: 1.03k, False: 5.71k] ------------------ 120| 1.03k| simdjson_unused auto dumpstatus = elem.dump_raw_tape(os);} ;break; ------------------ | | 113| 1.03k| #define simdjson_unused __attribute__((unused)) ------------------ 121| 142| default: ------------------ | Branch (121:5): [True: 142, False: 6.61k] ------------------ 122| 142| return 0; 123| 6.75k| } 124| 6.75k|#undef CASE 125| 6.75k|#undef CASE2 126| | 127| 6.75k|#if SIMDJSON_EXCEPTIONS 128| 6.75k| } catch (std::exception &) { 129| | // do nothing 130| 682| } 131| 0|#endif 132| | 133| 6.61k| return 0; 134| 6.75k|} fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_1clIZ22LLVMFuzzerTestOneInputE3$_0EEDaT_: 17| 104| auto invoke_with_type=[selecttype](auto cb) { 18| 104| using constcharstar=const char*; 19| 104| switch(selecttype) { ------------------ | Branch (19:12): [True: 0, False: 104] ------------------ 20| 52| case 0: cb(bool{});break; ------------------ | Branch (20:5): [True: 52, False: 52] ------------------ 21| 3| case 1: cb(double{});break; ------------------ | Branch (21:5): [True: 3, False: 101] ------------------ 22| 13| case 2: cb(uint64_t{});break; ------------------ | Branch (22:5): [True: 13, False: 91] ------------------ 23| 6| case 3: cb(int64_t{});break; ------------------ | Branch (23:5): [True: 6, False: 98] ------------------ 24| 6| case 4: cb(std::string_view{});break; ------------------ | Branch (24:5): [True: 6, False: 98] ------------------ 25| 5| case 5: cb(constcharstar{});break; ------------------ | Branch (25:5): [True: 5, False: 99] ------------------ 26| 9| case 6: cb(simdjson::dom::array{});break; ------------------ | Branch (26:5): [True: 9, False: 95] ------------------ 27| 10| case 7: cb(simdjson::dom::object{});break; ------------------ | Branch (27:5): [True: 10, False: 94] ------------------ 28| 104| } 29| 104| }; fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIbEEDaT_: 87| 52| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 113| 52| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIdEEDaT_: 87| 3| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 113| 3| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clImEEDaT_: 87| 13| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 113| 13| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIlEEDaT_: 87| 6| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 113| 6| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEDaT_: 87| 6| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 113| 6| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIPKcEEDaT_: 87| 5| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 113| 5| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIN8simdjson3dom5arrayEEEDaT_: 87| 9| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 113| 9| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIN8simdjson3dom6objectEEEDaT_: 87| 10| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 113| 10| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_1clIZ22LLVMFuzzerTestOneInputE3$_2EEDaT_: 17| 84| auto invoke_with_type=[selecttype](auto cb) { 18| 84| using constcharstar=const char*; 19| 84| switch(selecttype) { ------------------ | Branch (19:12): [True: 0, False: 84] ------------------ 20| 14| case 0: cb(bool{});break; ------------------ | Branch (20:5): [True: 14, False: 70] ------------------ 21| 9| case 1: cb(double{});break; ------------------ | Branch (21:5): [True: 9, False: 75] ------------------ 22| 8| case 2: cb(uint64_t{});break; ------------------ | Branch (22:5): [True: 8, False: 76] ------------------ 23| 9| case 3: cb(int64_t{});break; ------------------ | Branch (23:5): [True: 9, False: 75] ------------------ 24| 15| case 4: cb(std::string_view{});break; ------------------ | Branch (24:5): [True: 15, False: 69] ------------------ 25| 14| case 5: cb(constcharstar{});break; ------------------ | Branch (25:5): [True: 14, False: 70] ------------------ 26| 5| case 6: cb(simdjson::dom::array{});break; ------------------ | Branch (26:5): [True: 5, False: 79] ------------------ 27| 10| case 7: cb(simdjson::dom::object{});break; ------------------ | Branch (27:5): [True: 10, False: 74] ------------------ 28| 84| } 29| 84| }; fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIbEEDaT_: 92| 14| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 113| 14| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIdEEDaT_: 92| 9| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 113| 9| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clImEEDaT_: 92| 8| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 113| 8| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIlEEDaT_: 92| 9| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 113| 9| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEDaT_: 92| 15| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 113| 15| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIPKcEEDaT_: 92| 14| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 113| 14| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIN8simdjson3dom5arrayEEEDaT_: 92| 5| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 113| 5| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIN8simdjson3dom6objectEEEDaT_: 92| 10| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 113| 10| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_1clIZ22LLVMFuzzerTestOneInputE3$_3EEDaT_: 17| 69| auto invoke_with_type=[selecttype](auto cb) { 18| 69| using constcharstar=const char*; 19| 69| switch(selecttype) { ------------------ | Branch (19:12): [True: 0, False: 69] ------------------ 20| 21| case 0: cb(bool{});break; ------------------ | Branch (20:5): [True: 21, False: 48] ------------------ 21| 4| case 1: cb(double{});break; ------------------ | Branch (21:5): [True: 4, False: 65] ------------------ 22| 8| case 2: cb(uint64_t{});break; ------------------ | Branch (22:5): [True: 8, False: 61] ------------------ 23| 5| case 3: cb(int64_t{});break; ------------------ | Branch (23:5): [True: 5, False: 64] ------------------ 24| 11| case 4: cb(std::string_view{});break; ------------------ | Branch (24:5): [True: 11, False: 58] ------------------ 25| 13| case 5: cb(constcharstar{});break; ------------------ | Branch (25:5): [True: 13, False: 56] ------------------ 26| 3| case 6: cb(simdjson::dom::array{});break; ------------------ | Branch (26:5): [True: 3, False: 66] ------------------ 27| 4| case 7: cb(simdjson::dom::object{});break; ------------------ | Branch (27:5): [True: 4, False: 65] ------------------ 28| 69| } 29| 69| }; fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIbEEDaT_: 97| 21| invoke_with_type([&elem](auto t){ 98| 21| simdjson::error_code ec; 99| 21| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIdEEDaT_: 97| 4| invoke_with_type([&elem](auto t){ 98| 4| simdjson::error_code ec; 99| 4| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clImEEDaT_: 97| 8| invoke_with_type([&elem](auto t){ 98| 8| simdjson::error_code ec; 99| 8| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIlEEDaT_: 97| 5| invoke_with_type([&elem](auto t){ 98| 5| simdjson::error_code ec; 99| 5| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEDaT_: 97| 11| invoke_with_type([&elem](auto t){ 98| 11| simdjson::error_code ec; 99| 11| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIPKcEEDaT_: 97| 13| invoke_with_type([&elem](auto t){ 98| 13| simdjson::error_code ec; 99| 13| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIN8simdjson3dom5arrayEEEDaT_: 97| 3| invoke_with_type([&elem](auto t){ 98| 3| simdjson::error_code ec; 99| 3| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIN8simdjson3dom6objectEEEDaT_: 97| 4| invoke_with_type([&elem](auto t){ 98| 4| simdjson::error_code ec; 99| 4| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_1clIZ22LLVMFuzzerTestOneInputE3$_4EEDaT_: 17| 638| auto invoke_with_type=[selecttype](auto cb) { 18| 638| using constcharstar=const char*; 19| 638| switch(selecttype) { ------------------ | Branch (19:12): [True: 0, False: 638] ------------------ 20| 73| case 0: cb(bool{});break; ------------------ | Branch (20:5): [True: 73, False: 565] ------------------ 21| 81| case 1: cb(double{});break; ------------------ | Branch (21:5): [True: 81, False: 557] ------------------ 22| 201| case 2: cb(uint64_t{});break; ------------------ | Branch (22:5): [True: 201, False: 437] ------------------ 23| 185| case 3: cb(int64_t{});break; ------------------ | Branch (23:5): [True: 185, False: 453] ------------------ 24| 23| case 4: cb(std::string_view{});break; ------------------ | Branch (24:5): [True: 23, False: 615] ------------------ 25| 20| case 5: cb(constcharstar{});break; ------------------ | Branch (25:5): [True: 20, False: 618] ------------------ 26| 24| case 6: cb(simdjson::dom::array{});break; ------------------ | Branch (26:5): [True: 24, False: 614] ------------------ 27| 31| case 7: cb(simdjson::dom::object{});break; ------------------ | Branch (27:5): [True: 31, False: 607] ------------------ 28| 638| } 29| 638| }; fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIbEEDaT_: 105| 73| invoke_with_type([&elem](auto t){ 106| 73| using T=decltype(t); 107| 73| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 113| 73| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIdEEDaT_: 105| 81| invoke_with_type([&elem](auto t){ 106| 81| using T=decltype(t); 107| 81| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 113| 81| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clImEEDaT_: 105| 201| invoke_with_type([&elem](auto t){ 106| 201| using T=decltype(t); 107| 201| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 113| 201| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIlEEDaT_: 105| 185| invoke_with_type([&elem](auto t){ 106| 185| using T=decltype(t); 107| 185| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 113| 185| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEDaT_: 105| 23| invoke_with_type([&elem](auto t){ 106| 23| using T=decltype(t); 107| 23| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 113| 23| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIPKcEEDaT_: 105| 20| invoke_with_type([&elem](auto t){ 106| 20| using T=decltype(t); 107| 20| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 113| 20| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIN8simdjson3dom5arrayEEEDaT_: 105| 24| invoke_with_type([&elem](auto t){ 106| 24| using T=decltype(t); 107| 24| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 113| 24| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIN8simdjson3dom6objectEEEDaT_: 105| 31| invoke_with_type([&elem](auto t){ 106| 31| using T=decltype(t); 107| 31| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 113| 31| #define simdjson_unused __attribute__((unused)) ------------------ _ZN8simdjson3dom5arrayC2ERKNS_8internal8tape_refE: 54| 29.5k|simdjson_inline array::array(const internal::tape_ref &_tape) noexcept : tape{_tape} {} _ZN8simdjson15simdjson_resultINS_3dom5arrayEEC2ES2_: 18| 492| : internal::simdjson_result_base(std::forward(value)) {} _ZN8simdjson15simdjson_resultINS_3dom5arrayEEC2ENS_10error_codeE: 20| 393| : internal::simdjson_result_base(error) {} _ZN8simdjson3dom5arrayC2Ev: 53| 434|simdjson_inline array::array() noexcept : tape{} {} _ZNK8simdjson15simdjson_resultINS_3dom5arrayEE5beginEv: 24| 76|inline dom::array::iterator simdjson_result::begin() const noexcept(false) { 25| 76| if (error()) { throw simdjson_error(error()); } ------------------ | Branch (25:7): [True: 60, False: 16] ------------------ 26| 16| return first.begin(); 27| 76|} _ZNK8simdjson3dom5array5beginEv: 55| 14.8k|inline array::iterator array::begin() const noexcept { 56| 14.8k| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 329| 14.8k|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (329:57): [Folded - Ignored] | | ------------------ ------------------ 57| 14.8k| return internal::tape_ref(tape.doc, tape.json_index + 1); 58| 14.8k|} _ZN8simdjson3dom5array8iteratorC2ERKNS_8internal8tape_refE: 125| 29.6k|simdjson_inline array::iterator::iterator(const internal::tape_ref &_tape) noexcept : tape{_tape} { } _ZNK8simdjson15simdjson_resultINS_3dom5arrayEE3endEv: 28| 75|inline dom::array::iterator simdjson_result::end() const noexcept(false) { 29| 75| if (error()) { throw simdjson_error(error()); } ------------------ | Branch (29:7): [True: 62, False: 13] ------------------ 30| 13| return first.end(); 31| 75|} _ZNK8simdjson3dom5array3endEv: 59| 14.8k|inline array::iterator array::end() const noexcept { 60| 14.8k| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 329| 14.8k|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (329:57): [Folded - Ignored] | | ------------------ ------------------ 61| 14.8k| return internal::tape_ref(tape.doc, tape.after_element() - 1); 62| 14.8k|} _ZNK8simdjson3dom5array10at_pointerENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 71| 14.6k|inline simdjson_result array::at_pointer(std::string_view json_pointer) const noexcept { 72| 14.6k| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 329| 14.6k|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (329:57): [Folded - Ignored] | | ------------------ ------------------ 73| 14.6k| if(json_pointer.empty()) { // an empty string means that we return the current node ------------------ | Branch (73:6): [True: 69, False: 14.5k] ------------------ 74| 69| return element(this->tape); // copy the current node 75| 14.5k| } else if(json_pointer[0] != '/') { // otherwise there is an error ------------------ | Branch (75:13): [True: 12, False: 14.5k] ------------------ 76| 12| return INVALID_JSON_POINTER; 77| 12| } 78| 14.5k| json_pointer = json_pointer.substr(1); 79| | // - means "the append position" or "the element after the end of the array" 80| | // We don't support this, because we're returning a real element, not a position. 81| 14.5k| if (json_pointer == "-") { return INDEX_OUT_OF_BOUNDS; } ------------------ | Branch (81:7): [True: 1, False: 14.5k] ------------------ 82| | 83| | // Read the array index 84| 14.5k| size_t array_index = 0; 85| 14.5k| size_t i; 86| 1.40M| for (i = 0; i < json_pointer.length() && json_pointer[i] != '/'; i++) { ------------------ | Branch (86:15): [True: 1.40M, False: 240] | Branch (86:44): [True: 1.39M, False: 14.2k] ------------------ 87| 1.39M| uint8_t digit = uint8_t(json_pointer[i] - '0'); 88| | // Check for non-digit in array index. If it's there, we're trying to get a field in an object 89| 1.39M| if (digit > 9) { return INCORRECT_TYPE; } ------------------ | Branch (89:9): [True: 30, False: 1.39M] ------------------ 90| 1.39M| array_index = array_index*10 + digit; 91| 1.39M| } 92| | 93| | // 0 followed by other digits is invalid 94| 14.5k| if (i > 1 && json_pointer[0] == '0') { return INVALID_JSON_POINTER; } // "JSON pointer array index has other characters after 0" ------------------ | Branch (94:7): [True: 316, False: 14.1k] | Branch (94:16): [True: 2, False: 314] ------------------ 95| | 96| | // Empty string is invalid; so is a "/" with no digits before it 97| 14.5k| if (i == 0) { return INVALID_JSON_POINTER; } // "Empty string in JSON pointer array index" ------------------ | Branch (97:7): [True: 59, False: 14.4k] ------------------ 98| | 99| | // Get the child 100| 14.4k| auto child = array(tape).at(array_index); 101| | // If there is an error, it ends here 102| 14.4k| if(child.error()) { ------------------ | Branch (102:6): [True: 172, False: 14.2k] ------------------ 103| 172| return child; 104| 172| } 105| | // If there is a /, we're not done yet, call recursively. 106| 14.2k| if (i < json_pointer.length()) { ------------------ | Branch (106:7): [True: 14.2k, False: 9] ------------------ 107| 14.2k| child = child.at_pointer(json_pointer.substr(i)); 108| 14.2k| } 109| 14.2k| return child; 110| 14.4k|} _ZNK8simdjson3dom5array2atEm: 112| 14.7k|inline simdjson_result array::at(size_t index) const noexcept { 113| 14.7k| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 329| 14.7k|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (329:57): [Folded - Ignored] | | ------------------ ------------------ 114| 14.7k| size_t i=0; 115| 1.04M| for (auto element : *this) { ------------------ | Branch (115:21): [True: 1.04M, False: 510] ------------------ 116| 1.04M| if (i == index) { return element; } ------------------ | Branch (116:9): [True: 14.2k, False: 1.03M] ------------------ 117| 1.03M| i++; 118| 1.03M| } 119| 510| return INDEX_OUT_OF_BOUNDS; 120| 14.7k|} _ZNK8simdjson3dom5array8iteratorneERKS2_: 138| 1.04M|inline bool array::iterator::operator!=(const array::iterator& other) const noexcept { 139| 1.04M| return tape.json_index != other.tape.json_index; 140| 1.04M|} _ZNK8simdjson3dom5array8iteratordeEv: 126| 1.04M|inline element array::iterator::operator*() const noexcept { 127| 1.04M| return element(tape); 128| 1.04M|} _ZN8simdjson3dom5array8iteratorppEv: 129| 1.03M|inline array::iterator& array::iterator::operator++() noexcept { 130| 1.03M| tape.json_index = tape.after_element(); 131| 1.03M| return *this; 132| 1.03M|} _ZNK8simdjson15simdjson_resultINS_3dom5arrayEE2atEm: 43| 429|inline simdjson_result simdjson_result::at(size_t index) const noexcept { 44| 429| if (error()) { return error(); } ------------------ | Branch (44:7): [True: 85, False: 344] ------------------ 45| 344| return first.at(index); 46| 429|} _ZNK8simdjson3dom8document8capacityEv: 23| 11.0k|inline size_t document::capacity() const noexcept { 24| 11.0k| return allocated_capacity; 25| 11.0k|} _ZN8simdjson3dom8document8allocateEm: 28| 11.0k|inline error_code document::allocate(size_t capacity) noexcept { 29| 11.0k| if (capacity == 0) { ------------------ | Branch (29:7): [True: 0, False: 11.0k] ------------------ 30| 0| string_buf.reset(); 31| 0| tape.reset(); 32| 0| allocated_capacity = 0; 33| 0| return SUCCESS; 34| 0| } 35| | 36| | // a pathological input like "[[[[..." would generate capacity tape elements, so 37| | // need a capacity of at least capacity + 1, but it is also possible to do 38| | // worse with "[7,7,7,7,6,7,7,7,6,7,7,6,[7,7,7,7,6,7,7,7,6,7,7,6,7,7,7,7,7,7,6" 39| | //where capacity + 1 tape elements are 40| | // generated, see issue https://github.com/simdjson/simdjson/issues/345 41| 11.0k| size_t tape_capacity = SIMDJSON_ROUNDUP_N(capacity + 3, 64); ------------------ | | 68| 11.0k|#define SIMDJSON_ROUNDUP_N(a, n) (((a) + ((n)-1)) & ~((n)-1)) ------------------ 42| | // a document with only zero-length strings... could have capacity/3 string 43| | // and we would need capacity/3 * 5 bytes on the string buffer 44| 11.0k| size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * capacity / 3 + SIMDJSON_PADDING, 64); ------------------ | | 68| 11.0k|#define SIMDJSON_ROUNDUP_N(a, n) (((a) + ((n)-1)) & ~((n)-1)) ------------------ 45| 11.0k| string_buf.reset( new (std::nothrow) uint8_t[string_capacity]); 46| 11.0k| tape.reset(new (std::nothrow) uint64_t[tape_capacity]); 47| 11.0k| if(!(string_buf && tape)) { ------------------ | Branch (47:8): [True: 11.0k, False: 0] | Branch (47:22): [True: 11.0k, False: 0] ------------------ 48| 0| allocated_capacity = 0; 49| 0| string_buf.reset(); 50| 0| tape.reset(); 51| 0| return MEMALLOC; 52| 0| } 53| | // Technically the allocated_capacity might be larger than capacity 54| | // so the next line is pessimistic. 55| 11.0k| allocated_capacity = capacity; 56| 11.0k| return SUCCESS; 57| 11.0k|} _ZNK8simdjson3dom8document4rootEv: 19| 6.75k|inline element document::root() const noexcept { 20| 6.75k| return element(internal::tape_ref(this, 1)); 21| 6.75k|} _ZNK8simdjson3dom8document13dump_raw_tapeERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEE: 59| 1.03k|inline bool document::dump_raw_tape(std::ostream &os) const noexcept { 60| 1.03k| uint32_t string_length; 61| 1.03k| size_t tape_idx = 0; 62| 1.03k| uint64_t tape_val = tape[tape_idx]; 63| 1.03k| uint8_t type = uint8_t(tape_val >> 56); 64| 1.03k| os << tape_idx << " : " << type; 65| 1.03k| tape_idx++; 66| 1.03k| size_t how_many = 0; 67| 1.03k| if (type == 'r') { ------------------ | Branch (67:7): [True: 1.03k, False: 0] ------------------ 68| 1.03k| how_many = size_t(tape_val & internal::JSON_VALUE_MASK); 69| 1.03k| } else { 70| | // Error: no starting root node? 71| 0| return false; 72| 0| } 73| 1.03k| os << "\t// pointing to " << how_many << " (right after last node)\n"; 74| 1.03k| uint64_t payload; 75| 1.07M| for (; tape_idx < how_many; tape_idx++) { ------------------ | Branch (75:10): [True: 1.07M, False: 0] ------------------ 76| 1.07M| os << tape_idx << " : "; 77| 1.07M| tape_val = tape[tape_idx]; 78| 1.07M| payload = tape_val & internal::JSON_VALUE_MASK; 79| 1.07M| type = uint8_t(tape_val >> 56); 80| 1.07M| switch (type) { 81| 3.84k| case '"': // we have a string ------------------ | Branch (81:5): [True: 3.84k, False: 1.07M] ------------------ 82| 3.84k| os << "string \""; 83| 3.84k| std::memcpy(&string_length, string_buf.get() + payload, sizeof(uint32_t)); 84| 3.84k| os << internal::escape_json_string(std::string_view( 85| 3.84k| reinterpret_cast(string_buf.get() + payload + sizeof(uint32_t)), 86| 3.84k| string_length 87| 3.84k| )); 88| 3.84k| os << '"'; 89| 3.84k| os << '\n'; 90| 3.84k| break; 91| 1.06M| case 'l': // we have a long int ------------------ | Branch (91:5): [True: 1.06M, False: 16.7k] ------------------ 92| 1.06M| if (tape_idx + 1 >= how_many) { ------------------ | Branch (92:11): [True: 0, False: 1.06M] ------------------ 93| 0| return false; 94| 0| } 95| 1.06M| os << "integer " << static_cast(tape[++tape_idx]) << "\n"; 96| 1.06M| break; 97| 351| case 'u': // we have a long uint ------------------ | Branch (97:5): [True: 351, False: 1.07M] ------------------ 98| 351| if (tape_idx + 1 >= how_many) { ------------------ | Branch (98:11): [True: 0, False: 351] ------------------ 99| 0| return false; 100| 0| } 101| 351| os << "unsigned integer " << tape[++tape_idx] << "\n"; 102| 351| break; 103| 6.54k| case 'd': // we have a double ------------------ | Branch (103:5): [True: 6.54k, False: 1.07M] ------------------ 104| 6.54k| os << "float "; 105| 6.54k| if (tape_idx + 1 >= how_many) { ------------------ | Branch (105:11): [True: 0, False: 6.54k] ------------------ 106| 0| return false; 107| 0| } 108| 6.54k| double answer; 109| 6.54k| std::memcpy(&answer, &tape[++tape_idx], sizeof(answer)); 110| 6.54k| os << answer << '\n'; 111| 6.54k| break; 112| 387| case 'n': // we have a null ------------------ | Branch (112:5): [True: 387, False: 1.07M] ------------------ 113| 387| os << "null\n"; 114| 387| break; 115| 389| case 't': // we have a true ------------------ | Branch (115:5): [True: 389, False: 1.07M] ------------------ 116| 389| os << "true\n"; 117| 389| break; 118| 260| case 'f': // we have a false ------------------ | Branch (118:5): [True: 260, False: 1.07M] ------------------ 119| 260| os << "false\n"; 120| 260| break; 121| 616| case '{': // we have an object ------------------ | Branch (121:5): [True: 616, False: 1.07M] ------------------ 122| 616| os << "{\t// pointing to next tape location " << uint32_t(payload) 123| 616| << " (first node after the scope), " 124| 616| << " saturated count " 125| 616| << ((payload >> 32) & internal::JSON_COUNT_MASK)<< "\n"; 126| 616| break; case '}': // we end an object ------------------ | Branch (126:17): [True: 616, False: 1.07M] ------------------ 127| 616| os << "}\t// pointing to previous tape location " << uint32_t(payload) 128| 616| << " (start of the scope)\n"; 129| 616| break; 130| 1.33k| case '[': // we start an array ------------------ | Branch (130:5): [True: 1.33k, False: 1.07M] ------------------ 131| 1.33k| os << "[\t// pointing to next tape location " << uint32_t(payload) 132| 1.33k| << " (first node after the scope), " 133| 1.33k| << " saturated count " 134| 1.33k| << ((payload >> 32) & internal::JSON_COUNT_MASK)<< "\n"; 135| 1.33k| break; 136| 1.33k| case ']': // we end an array ------------------ | Branch (136:5): [True: 1.33k, False: 1.07M] ------------------ 137| 1.33k| os << "]\t// pointing to previous tape location " << uint32_t(payload) 138| 1.33k| << " (start of the scope)\n"; 139| 1.33k| break; 140| 1.03k| case 'r': // we start and end with the root node ------------------ | Branch (140:5): [True: 1.03k, False: 1.07M] ------------------ 141| | // should we be hitting the root node? 142| 1.03k| return false; 143| 0| default: ------------------ | Branch (143:5): [True: 0, False: 1.07M] ------------------ 144| 0| return false; 145| 1.07M| } 146| 1.07M| } 147| 0| tape_val = tape[tape_idx]; 148| 0| payload = tape_val & internal::JSON_VALUE_MASK; 149| 0| type = uint8_t(tape_val >> 56); 150| 0| os << tape_idx << " : " << type << "\t// pointing to " << payload 151| 0| << " (start root)\n"; 152| 0| return true; 153| 1.03k|} _ZN8simdjson3dom8documentC2Ev: 25| 11.0k| document() noexcept = default; _ZN8simdjson3dom8documentD2Ev: 26| 11.0k| ~document() noexcept = default; _ZN8simdjson3dom7elementC2Ev: 185| 18.2k|simdjson_inline element::element() noexcept : tape{} {} _ZN8simdjson15simdjson_resultINS_3dom7elementEEC2ENS_10error_codeE: 20| 6.44k| : internal::simdjson_result_base(error) {} _ZN8simdjson3dom7elementC2ERKNS_8internal8tape_refE: 186| 1.06M|simdjson_inline element::element(const internal::tape_ref &_tape) noexcept : tape{_tape} { } _ZN8simdjson15simdjson_resultINS_3dom7elementEEC2EOS2_: 18| 21.7k| : internal::simdjson_result_base(std::forward(value)) {} _ZNK8simdjson3dom7element4typeEv: 188| 427|inline element_type element::type() const noexcept { 189| 427| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 329| 427|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (329:57): [Folded - Ignored] | | ------------------ ------------------ 190| 427| auto tape_type = tape.tape_ref_type(); 191| 427| return tape_type == internal::tape_type::FALSE_VALUE ? element_type::BOOL : static_cast(tape_type); ------------------ | Branch (191:10): [True: 0, False: 427] ------------------ 192| 427|} _ZNK8simdjson3dom7element9get_arrayEv: 283| 885|inline simdjson_result element::get_array() const noexcept { 284| 885| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 329| 885|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (329:57): [Folded - Ignored] | | ------------------ ------------------ 285| 885| switch (tape.tape_ref_type()) { 286| 492| case internal::tape_type::START_ARRAY: ------------------ | Branch (286:5): [True: 492, False: 393] ------------------ 287| 492| return array(tape); 288| 393| default: ------------------ | Branch (288:5): [True: 393, False: 492] ------------------ 289| 393| return INCORRECT_TYPE; 290| 885| } 291| 885|} _ZNK8simdjson3dom7element10get_objectEv: 292| 1.30k|inline simdjson_result