_ZN8FuzzDataC2EPKhm: 50| 10.7k| size_t size) : Data(data),Size(size){} _ZN8FuzzData16splitIntoStringsEv: 117| 10.7k| std::vector splitIntoStrings() { 118| 10.7k| std::vector ret; 119| 10.7k| if(Size>0) { ------------------ | Branch (119:8): [True: 10.7k, False: 10] ------------------ 120| 10.7k| ret=split(chardata(),Size); 121| | // all data consumed. 122| 10.7k| Data+=Size; 123| 10.7k| Size=0; 124| 10.7k| } 125| 10.7k| return ret; 126| 10.7k| } _Z5splitPKcm: 26| 10.7k|inline std::vector split(const char* Data, size_t Size) { 27| | 28| 10.7k| std::vector ret; 29| | 30| 10.7k| using namespace std::literals; 31| 10.7k| constexpr auto sep="\n~~\n"sv; 32| | 33| 10.7k| std::string_view all(Data,Size); 34| 10.7k| auto pos=all.find(sep); 35| 472k| while(pos!=std::string_view::npos) { ------------------ | Branch (35:11): [True: 461k, False: 10.7k] ------------------ 36| 461k| ret.push_back(all.substr(0,pos)); 37| 461k| all=all.substr(pos+sep.size()); 38| 461k| pos=all.find(sep); 39| 461k| } 40| 10.7k| ret.push_back(all); 41| 10.7k| return ret; 42| 10.7k|} _ZNK8FuzzData8chardataEv: 158| 10.7k| const char* chardata() const {return static_cast(static_cast(Data));} _ZNK8FuzzDatacvbEv: 129| 10.7k| explicit operator bool() const { return Data!=nullptr;} _ZN8FuzzData6getIntILi0ELi31EEEiv: 54| 10.7k| int getInt() { 55| 10.7k| 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| 21.5k| T get() { 74| 21.5k| const auto Nbytes=sizeof(T); 75| 21.5k| T ret{}; 76| 21.5k| 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| 10.7k| T get() { 74| 10.7k| const auto Nbytes=sizeof(T); 75| 10.7k| T ret{}; 76| 10.7k| 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| 10.7k| const int selecttype=fd.getInt<0,7>(); 17| 10.7k| auto invoke_with_type=[selecttype](auto cb) { 18| 10.7k| using constcharstar=const char*; 19| 10.7k| switch(selecttype) { 20| 10.7k| case 0: cb(bool{});break; 21| 10.7k| case 1: cb(double{});break; 22| 10.7k| case 2: cb(uint64_t{});break; 23| 10.7k| case 3: cb(int64_t{});break; 24| 10.7k| case 4: cb(std::string_view{});break; 25| 10.7k| case 5: cb(constcharstar{});break; 26| 10.7k| case 6: cb(simdjson::dom::array{});break; 27| 10.7k| case 7: cb(simdjson::dom::object{});break; 28| 10.7k| } 29| 10.7k| }; 30| | 31| 10.7k| const auto index = fd.get(); 32| | 33| | // split the remainder of the document into strings 34| 10.7k| auto strings = fd.splitIntoStrings(); 35| 10.8k| while (strings.size() < 2) { ------------------ | Branch (35:10): [True: 68, False: 10.7k] ------------------ 36| 68| strings.emplace_back(); 37| 68| } 38| 10.7k| const auto str = strings[0]; 39| | 40| | // exit if there was too little data 41| 10.7k| if (!fd) ------------------ | Branch (41:7): [True: 8, False: 10.7k] ------------------ 42| 8| return 0; 43| | 44| 10.7k| simdjson::dom::parser parser; 45| 10.7k| simdjson_unused simdjson::dom::element elem; ------------------ | | 99| 10.7k| #define simdjson_unused __attribute__((unused)) ------------------ 46| 10.7k| simdjson_unused auto error = parser.parse(strings[1]).get(elem); ------------------ | | 99| 10.7k| #define simdjson_unused __attribute__((unused)) ------------------ 47| | 48| 10.7k| if (error) ------------------ | Branch (48:7): [True: 4.40k, False: 6.36k] ------------------ 49| 4.40k| return 0; 50| | 51| 6.36k|#define CASE(num, fun) \ 52| 6.36k| case num: { \ 53| 6.36k| simdjson_unused auto v = elem.fun(); \ 54| 6.36k| break; \ 55| 6.36k| } 56| 6.36k|#define CASE2(num, fun) \ 57| 6.36k| case num: { \ 58| 6.36k| simdjson_unused auto v = elem fun; \ 59| 6.36k| break; \ 60| 6.36k| } 61| 6.36k|#if SIMDJSON_EXCEPTIONS 62| 6.36k| try { 63| 6.36k|#endif 64| | 65| 6.36k| switch (action) { 66| 360| CASE(0, type); ------------------ | | 52| 360| case num: { \ | | ------------------ | | | Branch (52:3): [True: 360, False: 6.00k] | | ------------------ | | 53| 360| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 360| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 360| break; \ | | 55| 360| } ------------------ 67| 87| CASE(1, get_array); ------------------ | | 52| 87| case num: { \ | | ------------------ | | | Branch (52:3): [True: 87, False: 6.27k] | | ------------------ | | 53| 87| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 87| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 87| break; \ | | 55| 87| } ------------------ 68| 73| CASE(2, get_object); ------------------ | | 52| 73| case num: { \ | | ------------------ | | | Branch (52:3): [True: 73, False: 6.28k] | | ------------------ | | 53| 73| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 73| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 73| break; \ | | 55| 73| } ------------------ 69| 87| CASE(3, get_c_str); ------------------ | | 52| 87| case num: { \ | | ------------------ | | | Branch (52:3): [True: 87, False: 6.27k] | | ------------------ | | 53| 87| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 87| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 87| break; \ | | 55| 87| } ------------------ 70| 60| CASE(4, get_string_length); ------------------ | | 52| 60| case num: { \ | | ------------------ | | | Branch (52:3): [True: 60, False: 6.30k] | | ------------------ | | 53| 60| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 60| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 60| break; \ | | 55| 60| } ------------------ 71| 34| CASE(5, get_string); ------------------ | | 52| 34| case num: { \ | | ------------------ | | | Branch (52:3): [True: 34, False: 6.32k] | | ------------------ | | 53| 34| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 34| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 34| break; \ | | 55| 34| } ------------------ 72| 38| CASE(6, get_int64); ------------------ | | 52| 38| case num: { \ | | ------------------ | | | Branch (52:3): [True: 38, False: 6.32k] | | ------------------ | | 53| 38| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 38| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 38| break; \ | | 55| 38| } ------------------ 73| 43| CASE(7, get_uint64); ------------------ | | 52| 43| case num: { \ | | ------------------ | | | Branch (52:3): [True: 43, False: 6.31k] | | ------------------ | | 53| 43| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 43| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 43| break; \ | | 55| 43| } ------------------ 74| 41| CASE(8, get_double); ------------------ | | 52| 41| case num: { \ | | ------------------ | | | Branch (52:3): [True: 41, False: 6.32k] | | ------------------ | | 53| 41| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 41| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 41| break; \ | | 55| 41| } ------------------ 75| 47| CASE(9, get_bool); ------------------ | | 52| 47| case num: { \ | | ------------------ | | | Branch (52:3): [True: 47, False: 6.31k] | | ------------------ | | 53| 47| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 47| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 47| break; \ | | 55| 47| } ------------------ 76| 66| CASE(10, is_array); ------------------ | | 52| 66| case num: { \ | | ------------------ | | | Branch (52:3): [True: 66, False: 6.29k] | | ------------------ | | 53| 66| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 66| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 66| break; \ | | 55| 66| } ------------------ 77| 45| CASE(11, is_object); ------------------ | | 52| 45| case num: { \ | | ------------------ | | | Branch (52:3): [True: 45, False: 6.31k] | | ------------------ | | 53| 45| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 45| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 45| break; \ | | 55| 45| } ------------------ 78| 62| CASE(12, is_string); ------------------ | | 52| 62| case num: { \ | | ------------------ | | | Branch (52:3): [True: 62, False: 6.29k] | | ------------------ | | 53| 62| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 62| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 62| break; \ | | 55| 62| } ------------------ 79| 83| CASE(13, is_int64); ------------------ | | 52| 83| case num: { \ | | ------------------ | | | Branch (52:3): [True: 83, False: 6.27k] | | ------------------ | | 53| 83| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 83| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 83| break; \ | | 55| 83| } ------------------ 80| 78| CASE(14, is_uint64); ------------------ | | 52| 78| case num: { \ | | ------------------ | | | Branch (52:3): [True: 78, False: 6.28k] | | ------------------ | | 53| 78| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 78| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 78| break; \ | | 55| 78| } ------------------ 81| 79| CASE(15, is_double); ------------------ | | 52| 79| case num: { \ | | ------------------ | | | Branch (52:3): [True: 79, False: 6.28k] | | ------------------ | | 53| 79| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 79| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 79| break; \ | | 55| 79| } ------------------ 82| 338| CASE(16, is_number); ------------------ | | 52| 338| case num: { \ | | ------------------ | | | Branch (52:3): [True: 338, False: 6.02k] | | ------------------ | | 53| 338| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 338| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 338| break; \ | | 55| 338| } ------------------ 83| 60| CASE(17, is_bool); ------------------ | | 52| 60| case num: { \ | | ------------------ | | | Branch (52:3): [True: 60, False: 6.30k] | | ------------------ | | 53| 60| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 60| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 60| break; \ | | 55| 60| } ------------------ 84| 84| CASE(18, is_null); ------------------ | | 52| 84| case num: { \ | | ------------------ | | | Branch (52:3): [True: 84, False: 6.27k] | | ------------------ | | 53| 84| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 84| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 84| break; \ | | 55| 84| } ------------------ 85| | // element.is<>() : 86| 126| case 19: { ------------------ | Branch (86:5): [True: 126, False: 6.23k] ------------------ 87| 126| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); 88| 126| } break; 89| | 90| | // CASE(xx,get); 91| 58| case 20: { ------------------ | Branch (91:7): [True: 58, False: 6.30k] ------------------ 92| 58| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); 93| 58| } break; 94| | 95| | // CASE(xx,tie); 96| 74| case 21: { ------------------ | Branch (96:7): [True: 74, False: 6.28k] ------------------ 97| 74| invoke_with_type([&elem](auto t){ 98| 74| simdjson::error_code ec; 99| 74| simdjson::dom::element{elem}.tie(t,ec); }); 100| 74| } break; 101| | 102| 0|#if SIMDJSON_EXCEPTIONS 103| | // cast to type 104| 618| case 22: { ------------------ | Branch (104:7): [True: 618, False: 5.74k] ------------------ 105| 618| invoke_with_type([&elem](auto t){ 106| 618| using T=decltype(t); 107| 618| simdjson_unused auto v = static_cast(elem); }); 108| 618| } break; 109| | 110| 117| CASE(23, begin); ------------------ | | 52| 117| case num: { \ | | ------------------ | | | Branch (52:3): [True: 117, False: 6.24k] | | ------------------ | | 53| 117| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 117| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 117| break; \ | | 55| 117| } ------------------ 111| 83| CASE(24, end); ------------------ | | 52| 83| case num: { \ | | ------------------ | | | Branch (52:3): [True: 83, False: 6.27k] | | ------------------ | | 53| 83| simdjson_unused auto v = elem.fun(); \ | | ------------------ | | | | 99| 83| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 54| 83| break; \ | | 55| 83| } ------------------ 112| 0|#endif 113| 255| CASE2(25, [str]); ------------------ | | 57| 255| case num: { \ | | ------------------ | | | Branch (57:3): [True: 255, False: 6.10k] | | ------------------ | | 58| 255| simdjson_unused auto v = elem fun; \ | | ------------------ | | | | 99| 255| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 59| 255| break; \ | | 60| 255| } ------------------ 114| 1.09k| CASE2(26, .at_pointer(str)); ------------------ | | 57| 1.09k| case num: { \ | | ------------------ | | | Branch (57:3): [True: 1.09k, False: 5.26k] | | ------------------ | | 58| 1.09k| simdjson_unused auto v = elem fun; \ | | ------------------ | | | | 99| 1.09k| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 59| 1.09k| break; \ | | 60| 1.09k| } ------------------ 115| | // CASE2(xx,at(str)); deprecated 116| 492| CASE2(28, .at(index)); ------------------ | | 57| 492| case num: { \ | | ------------------ | | | Branch (57:3): [True: 492, False: 5.86k] | | ------------------ | | 58| 492| simdjson_unused auto v = elem fun; \ | | ------------------ | | | | 99| 492| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 59| 492| break; \ | | 60| 492| } ------------------ 117| 331| CASE2(29, .at_key(str)); ------------------ | | 57| 331| case num: { \ | | ------------------ | | | Branch (57:3): [True: 331, False: 6.03k] | | ------------------ | | 58| 331| simdjson_unused auto v = elem fun; \ | | ------------------ | | | | 99| 331| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 59| 331| break; \ | | 60| 331| } ------------------ 118| 384| CASE2(30, .at_key_case_insensitive(str)); ------------------ | | 57| 384| case num: { \ | | ------------------ | | | Branch (57:3): [True: 384, False: 5.97k] | | ------------------ | | 58| 384| simdjson_unused auto v = elem fun; \ | | ------------------ | | | | 99| 384| #define simdjson_unused __attribute__((unused)) | | ------------------ | | 59| 384| break; \ | | 60| 384| } ------------------ 119| 909| case 31: { NulOStream os; ------------------ | Branch (119:7): [True: 909, False: 5.45k] ------------------ 120| 909| simdjson_unused auto dumpstatus = elem.dump_raw_tape(os);} ;break; ------------------ | | 99| 909| #define simdjson_unused __attribute__((unused)) ------------------ 121| 56| default: ------------------ | Branch (121:5): [True: 56, False: 6.30k] ------------------ 122| 56| return 0; 123| 6.36k| } 124| 6.36k|#undef CASE 125| 6.36k|#undef CASE2 126| | 127| 6.36k|#if SIMDJSON_EXCEPTIONS 128| 6.36k| } catch (std::exception &) { 129| | // do nothing 130| 664| } 131| 0|#endif 132| | 133| 6.30k| return 0; 134| 6.36k|} fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_1clIZ22LLVMFuzzerTestOneInputE3$_0EEDaT_: 17| 126| auto invoke_with_type=[selecttype](auto cb) { 18| 126| using constcharstar=const char*; 19| 126| switch(selecttype) { ------------------ | Branch (19:12): [True: 0, False: 126] ------------------ 20| 64| case 0: cb(bool{});break; ------------------ | Branch (20:5): [True: 64, False: 62] ------------------ 21| 17| case 1: cb(double{});break; ------------------ | Branch (21:5): [True: 17, False: 109] ------------------ 22| 7| case 2: cb(uint64_t{});break; ------------------ | Branch (22:5): [True: 7, False: 119] ------------------ 23| 3| case 3: cb(int64_t{});break; ------------------ | Branch (23:5): [True: 3, False: 123] ------------------ 24| 12| case 4: cb(std::string_view{});break; ------------------ | Branch (24:5): [True: 12, False: 114] ------------------ 25| 3| case 5: cb(constcharstar{});break; ------------------ | Branch (25:5): [True: 3, False: 123] ------------------ 26| 18| case 6: cb(simdjson::dom::array{});break; ------------------ | Branch (26:5): [True: 18, False: 108] ------------------ 27| 2| case 7: cb(simdjson::dom::object{});break; ------------------ | Branch (27:5): [True: 2, False: 124] ------------------ 28| 126| } 29| 126| }; fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIbEEDaT_: 87| 64| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 99| 64| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIdEEDaT_: 87| 17| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 99| 17| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clImEEDaT_: 87| 7| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 99| 7| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIlEEDaT_: 87| 3| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 99| 3| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEDaT_: 87| 12| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 99| 12| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIPKcEEDaT_: 87| 3| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 99| 3| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIN8simdjson3dom5arrayEEEDaT_: 87| 18| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 99| 18| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_0clIN8simdjson3dom6objectEEEDaT_: 87| 2| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.is(); }); ------------------ | | 99| 2| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_1clIZ22LLVMFuzzerTestOneInputE3$_2EEDaT_: 17| 58| auto invoke_with_type=[selecttype](auto cb) { 18| 58| using constcharstar=const char*; 19| 58| switch(selecttype) { ------------------ | Branch (19:12): [True: 0, False: 58] ------------------ 20| 13| case 0: cb(bool{});break; ------------------ | Branch (20:5): [True: 13, False: 45] ------------------ 21| 18| case 1: cb(double{});break; ------------------ | Branch (21:5): [True: 18, False: 40] ------------------ 22| 11| case 2: cb(uint64_t{});break; ------------------ | Branch (22:5): [True: 11, False: 47] ------------------ 23| 3| case 3: cb(int64_t{});break; ------------------ | Branch (23:5): [True: 3, False: 55] ------------------ 24| 1| case 4: cb(std::string_view{});break; ------------------ | Branch (24:5): [True: 1, False: 57] ------------------ 25| 2| case 5: cb(constcharstar{});break; ------------------ | Branch (25:5): [True: 2, False: 56] ------------------ 26| 9| case 6: cb(simdjson::dom::array{});break; ------------------ | Branch (26:5): [True: 9, False: 49] ------------------ 27| 1| case 7: cb(simdjson::dom::object{});break; ------------------ | Branch (27:5): [True: 1, False: 57] ------------------ 28| 58| } 29| 58| }; fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIbEEDaT_: 92| 13| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 99| 13| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIdEEDaT_: 92| 18| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 99| 18| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clImEEDaT_: 92| 11| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 99| 11| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIlEEDaT_: 92| 3| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 99| 3| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEDaT_: 92| 1| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 99| 1| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIPKcEEDaT_: 92| 2| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 99| 2| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIN8simdjson3dom5arrayEEEDaT_: 92| 9| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 99| 9| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_2clIN8simdjson3dom6objectEEEDaT_: 92| 1| invoke_with_type([&elem](auto t){ simdjson_unused auto v = elem.get(); }); ------------------ | | 99| 1| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_1clIZ22LLVMFuzzerTestOneInputE3$_3EEDaT_: 17| 74| auto invoke_with_type=[selecttype](auto cb) { 18| 74| using constcharstar=const char*; 19| 74| switch(selecttype) { ------------------ | Branch (19:12): [True: 0, False: 74] ------------------ 20| 31| case 0: cb(bool{});break; ------------------ | Branch (20:5): [True: 31, False: 43] ------------------ 21| 5| case 1: cb(double{});break; ------------------ | Branch (21:5): [True: 5, False: 69] ------------------ 22| 8| case 2: cb(uint64_t{});break; ------------------ | Branch (22:5): [True: 8, False: 66] ------------------ 23| 6| case 3: cb(int64_t{});break; ------------------ | Branch (23:5): [True: 6, False: 68] ------------------ 24| 2| case 4: cb(std::string_view{});break; ------------------ | Branch (24:5): [True: 2, False: 72] ------------------ 25| 12| case 5: cb(constcharstar{});break; ------------------ | Branch (25:5): [True: 12, False: 62] ------------------ 26| 7| case 6: cb(simdjson::dom::array{});break; ------------------ | Branch (26:5): [True: 7, False: 67] ------------------ 27| 3| case 7: cb(simdjson::dom::object{});break; ------------------ | Branch (27:5): [True: 3, False: 71] ------------------ 28| 74| } 29| 74| }; fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIbEEDaT_: 97| 31| invoke_with_type([&elem](auto t){ 98| 31| simdjson::error_code ec; 99| 31| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIdEEDaT_: 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$_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| 6| invoke_with_type([&elem](auto t){ 98| 6| simdjson::error_code ec; 99| 6| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEDaT_: 97| 2| invoke_with_type([&elem](auto t){ 98| 2| simdjson::error_code ec; 99| 2| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIPKcEEDaT_: 97| 12| invoke_with_type([&elem](auto t){ 98| 12| simdjson::error_code ec; 99| 12| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIN8simdjson3dom5arrayEEEDaT_: 97| 7| invoke_with_type([&elem](auto t){ 98| 7| simdjson::error_code ec; 99| 7| simdjson::dom::element{elem}.tie(t,ec); }); fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_3clIN8simdjson3dom6objectEEEDaT_: 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$_1clIZ22LLVMFuzzerTestOneInputE3$_4EEDaT_: 17| 618| auto invoke_with_type=[selecttype](auto cb) { 18| 618| using constcharstar=const char*; 19| 618| switch(selecttype) { ------------------ | Branch (19:12): [True: 0, False: 618] ------------------ 20| 79| case 0: cb(bool{});break; ------------------ | Branch (20:5): [True: 79, False: 539] ------------------ 21| 82| case 1: cb(double{});break; ------------------ | Branch (21:5): [True: 82, False: 536] ------------------ 22| 202| case 2: cb(uint64_t{});break; ------------------ | Branch (22:5): [True: 202, False: 416] ------------------ 23| 171| case 3: cb(int64_t{});break; ------------------ | Branch (23:5): [True: 171, False: 447] ------------------ 24| 19| case 4: cb(std::string_view{});break; ------------------ | Branch (24:5): [True: 19, False: 599] ------------------ 25| 9| case 5: cb(constcharstar{});break; ------------------ | Branch (25:5): [True: 9, False: 609] ------------------ 26| 21| case 6: cb(simdjson::dom::array{});break; ------------------ | Branch (26:5): [True: 21, False: 597] ------------------ 27| 35| case 7: cb(simdjson::dom::object{});break; ------------------ | Branch (27:5): [True: 35, False: 583] ------------------ 28| 618| } 29| 618| }; fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIbEEDaT_: 105| 79| invoke_with_type([&elem](auto t){ 106| 79| using T=decltype(t); 107| 79| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 99| 79| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIdEEDaT_: 105| 82| invoke_with_type([&elem](auto t){ 106| 82| using T=decltype(t); 107| 82| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 99| 82| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clImEEDaT_: 105| 202| invoke_with_type([&elem](auto t){ 106| 202| using T=decltype(t); 107| 202| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 99| 202| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIlEEDaT_: 105| 171| invoke_with_type([&elem](auto t){ 106| 171| using T=decltype(t); 107| 171| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 99| 171| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEDaT_: 105| 19| invoke_with_type([&elem](auto t){ 106| 19| using T=decltype(t); 107| 19| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 99| 19| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIPKcEEDaT_: 105| 9| invoke_with_type([&elem](auto t){ 106| 9| using T=decltype(t); 107| 9| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 99| 9| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIN8simdjson3dom5arrayEEEDaT_: 105| 21| invoke_with_type([&elem](auto t){ 106| 21| using T=decltype(t); 107| 21| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 99| 21| #define simdjson_unused __attribute__((unused)) ------------------ fuzz_element.cpp:_ZZ22LLVMFuzzerTestOneInputENK3$_4clIN8simdjson3dom6objectEEEDaT_: 105| 35| invoke_with_type([&elem](auto t){ 106| 35| using T=decltype(t); 107| 35| simdjson_unused auto v = static_cast(elem); }); ------------------ | | 99| 35| #define simdjson_unused __attribute__((unused)) ------------------ _ZN8simdjson3dom5arrayC2ERKNS_8internal8tape_refE: 66| 19.3k|simdjson_inline array::array(const internal::tape_ref &_tape) noexcept : tape{_tape} {} _ZN8simdjson15simdjson_resultINS_3dom5arrayEEC2ES2_: 23| 532| : internal::simdjson_result_base(std::forward(value)) {} _ZN8simdjson15simdjson_resultINS_3dom5arrayEEC2ENS_10error_codeE: 25| 368| : internal::simdjson_result_base(error) {} _ZN8simdjson3dom5arrayC2Ev: 65| 423|simdjson_inline array::array() noexcept : tape{} {} _ZNK8simdjson15simdjson_resultINS_3dom5arrayEE5beginEv: 29| 117|inline dom::array::iterator simdjson_result::begin() const noexcept(false) { 30| 117| if (error()) { throw simdjson_error(error()); } ------------------ | Branch (30:7): [True: 71, False: 46] ------------------ 31| 46| return first.begin(); 32| 117|} _ZNK8simdjson3dom5array5beginEv: 67| 9.78k|inline array::iterator array::begin() const noexcept { 68| 9.78k| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 322| 9.78k|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (322:57): [Folded - Ignored] | | ------------------ ------------------ 69| 9.78k| return internal::tape_ref(tape.doc, tape.json_index + 1); 70| 9.78k|} _ZN8simdjson3dom5array8iteratorC2ERKNS_8internal8tape_refE: 147| 19.5k|simdjson_inline array::iterator::iterator(const internal::tape_ref &_tape) noexcept : tape{_tape} { } _ZNK8simdjson15simdjson_resultINS_3dom5arrayEE3endEv: 33| 83|inline dom::array::iterator simdjson_result::end() const noexcept(false) { 34| 83| if (error()) { throw simdjson_error(error()); } ------------------ | Branch (34:7): [True: 59, False: 24] ------------------ 35| 24| return first.end(); 36| 83|} _ZNK8simdjson3dom5array3endEv: 71| 9.76k|inline array::iterator array::end() const noexcept { 72| 9.76k| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 322| 9.76k|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (322:57): [Folded - Ignored] | | ------------------ ------------------ 73| 9.76k| return internal::tape_ref(tape.doc, tape.after_element() - 1); 74| 9.76k|} _ZNK8simdjson3dom5array10at_pointerENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 83| 9.48k|inline simdjson_result array::at_pointer(std::string_view json_pointer) const noexcept { 84| 9.48k| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 322| 9.48k|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (322:57): [Folded - Ignored] | | ------------------ ------------------ 85| 9.48k| if(json_pointer.empty()) { // an empty string means that we return the current node ------------------ | Branch (85:6): [True: 51, False: 9.43k] ------------------ 86| 51| return element(this->tape); // copy the current node 87| 9.43k| } else if(json_pointer[0] != '/') { // otherwise there is an error ------------------ | Branch (87:13): [True: 7, False: 9.42k] ------------------ 88| 7| return INVALID_JSON_POINTER; 89| 7| } 90| 9.42k| json_pointer = json_pointer.substr(1); 91| | // - means "the append position" or "the element after the end of the array" 92| | // We don't support this, because we're returning a real element, not a position. 93| 9.42k| if (json_pointer == "-") { return INDEX_OUT_OF_BOUNDS; } ------------------ | Branch (93:7): [True: 1, False: 9.42k] ------------------ 94| | 95| | // Read the array index 96| 9.42k| size_t array_index = 0; 97| 9.42k| size_t i; 98| 2.12M| for (i = 0; i < json_pointer.length() && json_pointer[i] != '/'; i++) { ------------------ | Branch (98:15): [True: 2.12M, False: 282] | Branch (98:44): [True: 2.11M, False: 9.12k] ------------------ 99| 2.11M| uint8_t digit = uint8_t(json_pointer[i] - '0'); 100| | // Check for non-digit in array index. If it's there, we're trying to get a field in an object 101| 2.11M| if (digit > 9) { return INCORRECT_TYPE; } ------------------ | Branch (101:9): [True: 22, False: 2.11M] ------------------ 102| 2.11M| array_index = array_index*10 + digit; 103| 2.11M| } 104| | 105| | // 0 followed by other digits is invalid 106| 9.40k| if (i > 1 && json_pointer[0] == '0') { return INVALID_JSON_POINTER; } // "JSON pointer array index has other characters after 0" ------------------ | Branch (106:7): [True: 248, False: 9.15k] | Branch (106:16): [True: 2, False: 246] ------------------ 107| | 108| | // Empty string is invalid; so is a "/" with no digits before it 109| 9.40k| if (i == 0) { return INVALID_JSON_POINTER; } // "Empty string in JSON pointer array index" ------------------ | Branch (109:7): [True: 48, False: 9.35k] ------------------ 110| | 111| | // Get the child 112| 9.35k| auto child = array(tape).at(array_index); 113| | // If there is an error, it ends here 114| 9.35k| if(child.error()) { ------------------ | Branch (114:6): [True: 227, False: 9.12k] ------------------ 115| 227| return child; 116| 227| } 117| | // If there is a /, we're not done yet, call recursively. 118| 9.12k| if (i < json_pointer.length()) { ------------------ | Branch (118:7): [True: 9.11k, False: 13] ------------------ 119| 9.11k| child = child.at_pointer(json_pointer.substr(i)); 120| 9.11k| } 121| 9.12k| return child; 122| 9.35k|} _ZNK8simdjson3dom5array2atEm: 130| 9.73k|inline simdjson_result array::at(size_t index) const noexcept { 131| 9.73k| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 322| 9.73k|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (322:57): [Folded - Ignored] | | ------------------ ------------------ 132| 9.73k| size_t i=0; 133| 1.61M| for (auto element : *this) { ------------------ | Branch (133:21): [True: 1.61M, False: 611] ------------------ 134| 1.61M| if (i == index) { return element; } ------------------ | Branch (134:9): [True: 9.12k, False: 1.60M] ------------------ 135| 1.60M| i++; 136| 1.60M| } 137| 611| return INDEX_OUT_OF_BOUNDS; 138| 9.73k|} _ZNK8simdjson3dom5array8iteratorneERKS2_: 160| 1.61M|inline bool array::iterator::operator!=(const array::iterator& other) const noexcept { 161| 1.61M| return tape.json_index != other.tape.json_index; 162| 1.61M|} _ZNK8simdjson3dom5array8iteratordeEv: 148| 1.61M|inline element array::iterator::operator*() const noexcept { 149| 1.61M| return element(tape); 150| 1.61M|} _ZN8simdjson3dom5array8iteratorppEv: 151| 1.60M|inline array::iterator& array::iterator::operator++() noexcept { 152| 1.60M| tape.json_index = tape.after_element(); 153| 1.60M| return *this; 154| 1.60M|} _ZNK8simdjson15simdjson_resultINS_3dom5arrayEE2atEm: 55| 492|inline simdjson_result simdjson_result::at(size_t index) const noexcept { 56| 492| if (error()) { return error(); } ------------------ | Branch (56:7): [True: 106, False: 386] ------------------ 57| 386| return first.at(index); 58| 492|} _ZNK8simdjson3dom8document8capacityEv: 24| 10.7k|inline size_t document::capacity() const noexcept { 25| 10.7k| return allocated_capacity; 26| 10.7k|} _ZN8simdjson3dom8document8allocateEm: 29| 10.7k|inline error_code document::allocate(size_t capacity) noexcept { 30| 10.7k| if (capacity == 0) { ------------------ | Branch (30:7): [True: 0, False: 10.7k] ------------------ 31| 0| string_buf.reset(); 32| 0| tape.reset(); 33| 0| allocated_capacity = 0; 34| 0| return SUCCESS; 35| 0| } 36| | 37| | // a pathological input like "[[[[..." would generate capacity tape elements, so 38| | // need a capacity of at least capacity + 1, but it is also possible to do 39| | // 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" 40| | //where capacity + 1 tape elements are 41| | // generated, see issue https://github.com/simdjson/simdjson/issues/345 42| 10.7k| size_t tape_capacity = SIMDJSON_ROUNDUP_N(capacity + 3, 64); ------------------ | | 47| 10.7k|#define SIMDJSON_ROUNDUP_N(a, n) (((a) + ((n)-1)) & ~((n)-1)) ------------------ 43| | // a document with only zero-length strings... could have capacity/3 string 44| | // and we would need capacity/3 * 5 bytes on the string buffer 45| 10.7k| size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * capacity / 3 + SIMDJSON_PADDING, 64); ------------------ | | 47| 10.7k|#define SIMDJSON_ROUNDUP_N(a, n) (((a) + ((n)-1)) & ~((n)-1)) ------------------ 46| 10.7k| string_buf.reset( new (std::nothrow) uint8_t[string_capacity]); 47| 10.7k| tape.reset(new (std::nothrow) uint64_t[tape_capacity]); 48| 10.7k| if(!(string_buf && tape)) { ------------------ | Branch (48:8): [True: 10.7k, False: 0] | Branch (48:22): [True: 10.7k, False: 0] ------------------ 49| 0| allocated_capacity = 0; 50| 0| string_buf.reset(); 51| 0| tape.reset(); 52| 0| return MEMALLOC; 53| 0| } 54| | // Technically the allocated_capacity might be larger than capacity 55| | // so the next line is pessimistic. 56| 10.7k| allocated_capacity = capacity; 57| 10.7k| return SUCCESS; 58| 10.7k|} _ZNK8simdjson3dom8document4rootEv: 20| 6.36k|inline element document::root() const noexcept { 21| 6.36k| return element(internal::tape_ref(this, 1)); 22| 6.36k|} _ZNK8simdjson3dom8document13dump_raw_tapeERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEE: 60| 909|inline bool document::dump_raw_tape(std::ostream &os) const noexcept { 61| 909| uint32_t string_length; 62| 909| size_t tape_idx = 0; 63| 909| uint64_t tape_val = tape[tape_idx]; 64| 909| uint8_t type = uint8_t(tape_val >> 56); 65| 909| os << tape_idx << " : " << type; 66| 909| tape_idx++; 67| 909| size_t how_many = 0; 68| 909| if (type == 'r') { ------------------ | Branch (68:7): [True: 909, False: 0] ------------------ 69| 909| how_many = size_t(tape_val & internal::JSON_VALUE_MASK); 70| 909| } else { 71| | // Error: no starting root node? 72| 0| return false; 73| 0| } 74| 909| os << "\t// pointing to " << how_many << " (right after last node)\n"; 75| 909| uint64_t payload; 76| 1.60M| for (; tape_idx < how_many; tape_idx++) { ------------------ | Branch (76:10): [True: 1.60M, False: 0] ------------------ 77| 1.60M| os << tape_idx << " : "; 78| 1.60M| tape_val = tape[tape_idx]; 79| 1.60M| payload = tape_val & internal::JSON_VALUE_MASK; 80| 1.60M| type = uint8_t(tape_val >> 56); 81| 1.60M| switch (type) { 82| 3.70k| case '"': // we have a string ------------------ | Branch (82:5): [True: 3.70k, False: 1.60M] ------------------ 83| 3.70k| os << "string \""; 84| 3.70k| std::memcpy(&string_length, string_buf.get() + payload, sizeof(uint32_t)); 85| 3.70k| os << internal::escape_json_string(std::string_view( 86| 3.70k| reinterpret_cast(string_buf.get() + payload + sizeof(uint32_t)), 87| 3.70k| string_length 88| 3.70k| )); 89| 3.70k| os << '"'; 90| 3.70k| os << '\n'; 91| 3.70k| break; 92| 1.59M| case 'l': // we have a long int ------------------ | Branch (92:5): [True: 1.59M, False: 13.7k] ------------------ 93| 1.59M| if (tape_idx + 1 >= how_many) { ------------------ | Branch (93:11): [True: 0, False: 1.59M] ------------------ 94| 0| return false; 95| 0| } 96| 1.59M| os << "integer " << static_cast(tape[++tape_idx]) << "\n"; 97| 1.59M| break; 98| 437| case 'u': // we have a long uint ------------------ | Branch (98:5): [True: 437, False: 1.60M] ------------------ 99| 437| if (tape_idx + 1 >= how_many) { ------------------ | Branch (99:11): [True: 0, False: 437] ------------------ 100| 0| return false; 101| 0| } 102| 437| os << "unsigned integer " << tape[++tape_idx] << "\n"; 103| 437| break; 104| 4.24k| case 'd': // we have a double ------------------ | Branch (104:5): [True: 4.24k, False: 1.60M] ------------------ 105| 4.24k| os << "float "; 106| 4.24k| if (tape_idx + 1 >= how_many) { ------------------ | Branch (106:11): [True: 0, False: 4.24k] ------------------ 107| 0| return false; 108| 0| } 109| 4.24k| double answer; 110| 4.24k| std::memcpy(&answer, &tape[++tape_idx], sizeof(answer)); 111| 4.24k| os << answer << '\n'; 112| 4.24k| break; 113| 257| case 'n': // we have a null ------------------ | Branch (113:5): [True: 257, False: 1.60M] ------------------ 114| 257| os << "null\n"; 115| 257| break; 116| 389| case 't': // we have a true ------------------ | Branch (116:5): [True: 389, False: 1.60M] ------------------ 117| 389| os << "true\n"; 118| 389| break; 119| 389| case 'f': // we have a false ------------------ | Branch (119:5): [True: 389, False: 1.60M] ------------------ 120| 389| os << "false\n"; 121| 389| break; 122| 546| case '{': // we have an object ------------------ | Branch (122:5): [True: 546, False: 1.60M] ------------------ 123| 546| os << "{\t// pointing to next tape location " << uint32_t(payload) 124| 546| << " (first node after the scope), " 125| 546| << " saturated count " 126| 546| << ((payload >> 32) & internal::JSON_COUNT_MASK)<< "\n"; 127| 546| break; case '}': // we end an object ------------------ | Branch (127:17): [True: 546, False: 1.60M] ------------------ 128| 546| os << "}\t// pointing to previous tape location " << uint32_t(payload) 129| 546| << " (start of the scope)\n"; 130| 546| break; 131| 1.15k| case '[': // we start an array ------------------ | Branch (131:5): [True: 1.15k, False: 1.60M] ------------------ 132| 1.15k| os << "[\t// pointing to next tape location " << uint32_t(payload) 133| 1.15k| << " (first node after the scope), " 134| 1.15k| << " saturated count " 135| 1.15k| << ((payload >> 32) & internal::JSON_COUNT_MASK)<< "\n"; 136| 1.15k| break; 137| 1.15k| case ']': // we end an array ------------------ | Branch (137:5): [True: 1.15k, False: 1.60M] ------------------ 138| 1.15k| os << "]\t// pointing to previous tape location " << uint32_t(payload) 139| 1.15k| << " (start of the scope)\n"; 140| 1.15k| break; 141| 909| case 'r': // we start and end with the root node ------------------ | Branch (141:5): [True: 909, False: 1.60M] ------------------ 142| | // should we be hitting the root node? 143| 909| return false; 144| 0| default: ------------------ | Branch (144:5): [True: 0, False: 1.60M] ------------------ 145| 0| return false; 146| 1.60M| } 147| 1.60M| } 148| 0| tape_val = tape[tape_idx]; 149| 0| payload = tape_val & internal::JSON_VALUE_MASK; 150| 0| type = uint8_t(tape_val >> 56); 151| 0| os << tape_idx << " : " << type << "\t// pointing to " << payload 152| 0| << " (start root)\n"; 153| 0| return true; 154| 909|} _ZN8simdjson3dom8documentC2Ev: 23| 10.7k| document() noexcept = default; _ZN8simdjson3dom8documentD2Ev: 24| 10.7k| ~document() noexcept = default; _ZN8simdjson3dom7elementC2Ev: 197| 17.8k|simdjson_inline element::element() noexcept : tape{} {} _ZN8simdjson15simdjson_resultINS_3dom7elementEEC2ENS_10error_codeE: 27| 6.50k| : internal::simdjson_result_base(error) {} _ZN8simdjson3dom7elementC2ERKNS_8internal8tape_refE: 198| 1.62M|simdjson_inline element::element(const internal::tape_ref &_tape) noexcept : tape{_tape} { } _ZN8simdjson15simdjson_resultINS_3dom7elementEEC2EOS2_: 25| 16.1k| : internal::simdjson_result_base(std::forward(value)) {} _ZNK8simdjson3dom7element4typeEv: 200| 360|inline element_type element::type() const noexcept { 201| 360| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 322| 360|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (322:57): [Folded - Ignored] | | ------------------ ------------------ 202| 360| auto tape_type = tape.tape_ref_type(); 203| 360| return tape_type == internal::tape_type::FALSE_VALUE ? element_type::BOOL : static_cast(tape_type); ------------------ | Branch (203:10): [True: 0, False: 360] ------------------ 204| 360|} _ZNK8simdjson3dom7element9get_arrayEv: 295| 900|inline simdjson_result element::get_array() const noexcept { 296| 900| SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914 ------------------ | | 322| 900|#define SIMDJSON_DEVELOPMENT_ASSERT(expr) do { } while (0) | | ------------------ | | | Branch (322:57): [Folded - Ignored] | | ------------------ ------------------ 297| 900| switch (tape.tape_ref_type()) { 298| 532| case internal::tape_type::START_ARRAY: ------------------ | Branch (298:5): [True: 532, False: 368] ------------------ 299| 532| return array(tape); 300| 368| default: ------------------ | Branch (300:5): [True: 368, False: 532] ------------------ 301| 368| return INCORRECT_TYPE; 302| 900| } 303| 900|} _ZNK8simdjson3dom7element10get_objectEv: 304| 1.12k|inline simdjson_result