flb_utils.c:flb_log_check: 102| 72.8k|static inline int flb_log_check(int l) { 103| 72.8k| struct flb_worker *w; 104| 72.8k| w = (struct flb_worker *) FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 72.8k|#define FLB_TLS_GET(key) key ------------------ 105| 72.8k| if (!w && l <= 3) { ------------------ | Branch (105:9): [True: 72.8k, False: 0] | Branch (105:15): [True: 0, False: 72.8k] ------------------ 106| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 107| 0| } 108| | 109| 72.8k| if (w == NULL || flb_worker_log_level(w) < l) { ------------------ | Branch (109:9): [True: 72.8k, False: 0] | Branch (109:22): [True: 0, False: 0] ------------------ 110| 72.8k| return FLB_FALSE; ------------------ | | 25| 72.8k|#define FLB_FALSE 0 ------------------ 111| 72.8k| } 112| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 113| 72.8k|} flb_log.c:flb_log_check: 102| 2|static inline int flb_log_check(int l) { 103| 2| struct flb_worker *w; 104| 2| w = (struct flb_worker *) FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 2|#define FLB_TLS_GET(key) key ------------------ 105| 2| if (!w && l <= 3) { ------------------ | Branch (105:9): [True: 2, False: 0] | Branch (105:15): [True: 2, False: 0] ------------------ 106| 2| return FLB_TRUE; ------------------ | | 26| 2|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 2|#define FLB_FALSE 0 | | ------------------ ------------------ 107| 2| } 108| | 109| 0| if (w == NULL || flb_worker_log_level(w) < l) { ------------------ | Branch (109:9): [True: 0, False: 0] | Branch (109:22): [True: 0, False: 0] ------------------ 110| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 111| 0| } 112| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 113| 0|} flb_sds.c:flb_malloc: 67| 845|void *flb_malloc(const size_t size) { 68| | 69| 845|#ifdef FLB_HAVE_TESTS_OSSFUZZ 70| | // 1% chance of failure 71| 845| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (71:8): [True: 1, False: 844] ------------------ 72| 1| return NULL; 73| 1| } 74| 844|#endif 75| | 76| 844| if (size == 0) { ------------------ | Branch (76:9): [True: 0, False: 844] ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 844| return malloc(size); 81| 844|} flb_sds.c:flb_fuzz_get_probability: 56| 845|static inline int flb_fuzz_get_probability(int val) { 57| 845| flb_malloc_p += 1; 58| 845| flb_malloc_p = flb_malloc_p % flb_malloc_mod; 59| 845| if (val > flb_malloc_p) { ------------------ | Branch (59:7): [True: 1, False: 844] ------------------ 60| 1| return 1; 61| 1| } 62| 844| return 0; 63| 845|} flb_sds.c:flb_realloc: 100| 1.32k|{ 101| 1.32k| return realloc(ptr, size); 102| 1.32k|} flb_sds.c:flb_free: 126| 844|static inline void flb_free(void *ptr) { 127| 844| free(ptr); 128| 844|} flb_pack.c:flb_sds_len_set: 63| 335|{ 64| 335| FLB_SDS_HEADER(s)->len = len; ------------------ | | 46| 335|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 335|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 65| 335|} flb_sds.c:flb_sds_alloc: 68| 1.32k|{ 69| 1.32k| return (size_t) FLB_SDS_HEADER(s)->alloc; ------------------ | | 46| 1.32k|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 1.32k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 70| 1.32k|} flb_utils.c:flb_utf8_len: 42| 81.0k|{ 43| 81.0k| return trailingBytesForUTF8[(unsigned int)(unsigned char)s[0]] + 1; 44| 81.0k|} flb_pack.c:msgpack_unpacked_init: 253| 844|{ 254| 844| memset(result, 0, sizeof(msgpack_unpacked)); 255| 844|} flb_pack.c:msgpack_unpacked_destroy: 258| 844|{ 259| 844| if(result->zone != NULL) { ------------------ | Branch (259:8): [True: 743, False: 101] ------------------ 260| 743| msgpack_zone_free(result->zone); 261| 743| result->zone = NULL; 262| 743| memset(&result->data, 0, sizeof(msgpack_object)); 263| 743| } 264| 844|} unpack.c:msgpack_unpacked_destroy: 258| 844|{ 259| 844| if(result->zone != NULL) { ------------------ | Branch (259:8): [True: 0, False: 844] ------------------ 260| 0| msgpack_zone_free(result->zone); 261| 0| result->zone = NULL; 262| 0| memset(&result->data, 0, sizeof(msgpack_object)); 263| 0| } 264| 844|} unpack.c:template_init: 68| 844|{ 69| 844| ctx->cs = MSGPACK_CS_HEADER; 70| 844| ctx->trail = 0; 71| 844| ctx->top = 0; 72| | /* 73| | ctx->stack = ctx->embed_stack; 74| | ctx->stack_size = MSGPACK_EMBED_STACK_SIZE; 75| | */ 76| 844| ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user); ------------------ | | 33| 844| template_callback ## name ------------------ 77| 844|} unpack.c:template_execute: 95| 844|{ 96| 844| assert(len >= *off); 97| 844| { 98| 844| const unsigned char* p = (unsigned char*)data + *off; 99| 844| const unsigned char* const pe = (unsigned char*)data + len; 100| 844| const void* n = NULL; 101| | 102| 844| unsigned int trail = ctx->trail; 103| 844| unsigned int cs = ctx->cs; 104| 844| unsigned int top = ctx->top; 105| 844| msgpack_unpack_struct(_stack)* stack = ctx->stack; ------------------ | | 27| 844| struct template ## name ------------------ 106| | /* 107| | unsigned int stack_size = ctx->stack_size; 108| | */ 109| 844| msgpack_unpack_user* user = &ctx->user; ------------------ | | 37| 844|#define msgpack_unpack_user unpack_user ------------------ 110| | 111| 844| msgpack_unpack_object obj; ------------------ | | 35| 844|#define msgpack_unpack_object msgpack_object ------------------ 112| 844| msgpack_unpack_struct(_stack)* c = NULL; ------------------ | | 27| 844| struct template ## name ------------------ 113| | 114| 844| int ret; 115| | 116| 844|#define push_simple_value(func) \ 117| 844| ret = msgpack_unpack_callback(func)(user, &obj); \ 118| 844| if(ret < 0) { goto _failed; } \ 119| 844| goto _push 120| 844|#define push_fixed_value(func, arg) \ 121| 844| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ 122| 844| if(ret < 0) { goto _failed; } \ 123| 844| goto _push 124| 844|#define push_variable_value(func, base, pos, len) \ 125| 844| ret = msgpack_unpack_callback(func)(user, \ 126| 844| (const char*)base, (const char*)pos, len, &obj); \ 127| 844| if(ret < 0) { goto _failed; } \ 128| 844| goto _push 129| | 130| 844|#define again_fixed_trail(_cs, trail_len) \ 131| 844| trail = trail_len; \ 132| 844| cs = _cs; \ 133| 844| goto _fixed_trail_again 134| 844|#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \ 135| 844| trail = trail_len; \ 136| 844| if(trail == 0) { goto ifzero; } \ 137| 844| cs = _cs; \ 138| 844| goto _fixed_trail_again 139| | 140| 844|#define start_container(func, count_, ct_) \ 141| 844| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ 142| 844| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ 143| 844| goto _failed; \ 144| 844| } /* FIXME */ \ 145| 844| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ 146| 844| if(ret < 0) { goto _failed; } \ 147| 844| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ 148| 844| stack[top].ct = ct_; \ 149| 844| stack[top].count = count_; \ 150| 844| ++top; \ 151| 844| goto _header_again 152| | 153| 844|#define NEXT_CS(p) \ 154| 844| ((unsigned int)*p & 0x1f) 155| | 156| 844|#ifdef USE_CASE_RANGE 157| 844|#define SWITCH_RANGE_BEGIN switch(*p) { 158| 844|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: 159| 844|#define SWITCH_RANGE_DEFAULT default: 160| 844|#define SWITCH_RANGE_END } 161| |#else 162| |#define SWITCH_RANGE_BEGIN { if(0) { 163| |#define SWITCH_RANGE(FROM, TO) } else if(FROM <= *p && *p <= TO) { 164| |#define SWITCH_RANGE_DEFAULT } else { 165| |#define SWITCH_RANGE_END } } 166| |#endif 167| | 168| 844| if(p == pe) { goto _out; } ------------------ | Branch (168:12): [True: 0, False: 844] ------------------ 169| 152k| do { 170| 152k| switch(cs) { 171| 152k| case MSGPACK_CS_HEADER: ------------------ | Branch (171:13): [True: 152k, False: 0] ------------------ 172| 152k| SWITCH_RANGE_BEGIN ------------------ | | 157| 304k|#define SWITCH_RANGE_BEGIN switch(*p) { ------------------ 173| | SWITCH_RANGE(0x00, 0x7f) // Positive Fixnum ------------------ | | 158| 55.6k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 55.6k, False: 96.4k] | | ------------------ ------------------ 174| 55.6k| push_fixed_value(_uint8, *(uint8_t*)p); ------------------ | | 121| 55.6k| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 55.6k| template_callback ## name | | ------------------ | | 122| 55.6k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 55.6k] | | ------------------ | | 123| 55.6k| goto _push ------------------ 175| | SWITCH_RANGE(0xe0, 0xff) // Negative Fixnum ------------------ | | 158| 44.0k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 44.0k, False: 108k] | | ------------------ ------------------ 176| 44.0k| push_fixed_value(_int8, *(int8_t*)p); ------------------ | | 121| 44.0k| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 44.0k| template_callback ## name | | ------------------ | | 122| 44.0k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 44.0k] | | ------------------ | | 123| 44.0k| goto _push ------------------ 177| | SWITCH_RANGE(0xc0, 0xdf) // Variable ------------------ | | 158| 26.0k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 26.0k, False: 125k] | | ------------------ ------------------ 178| 26.0k| switch(*p) { 179| 2.18k| case 0xc0: // nil ------------------ | Branch (179:21): [True: 2.18k, False: 23.8k] ------------------ 180| 2.18k| push_simple_value(_nil); ------------------ | | 117| 2.18k| ret = msgpack_unpack_callback(func)(user, &obj); \ | | ------------------ | | | | 33| 2.18k| template_callback ## name | | ------------------ | | 118| 2.18k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (118:12): [True: 0, False: 2.18k] | | ------------------ | | 119| 2.18k| goto _push ------------------ 181| | //case 0xc1: // string 182| | // again_terminal_trail(NEXT_CS(p), p+1); 183| 3.38k| case 0xc2: // false ------------------ | Branch (183:21): [True: 3.38k, False: 22.6k] ------------------ 184| 3.38k| push_simple_value(_false); ------------------ | | 117| 3.38k| ret = msgpack_unpack_callback(func)(user, &obj); \ | | ------------------ | | | | 33| 3.38k| template_callback ## name | | ------------------ | | 118| 3.38k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (118:12): [True: 0, False: 3.38k] | | ------------------ | | 119| 3.38k| goto _push ------------------ 185| 3.38k| case 0xc3: // true ------------------ | Branch (185:21): [True: 1.64k, False: 24.4k] ------------------ 186| 1.64k| push_simple_value(_true); ------------------ | | 117| 1.64k| ret = msgpack_unpack_callback(func)(user, &obj); \ | | ------------------ | | | | 33| 1.64k| template_callback ## name | | ------------------ | | 118| 1.64k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (118:12): [True: 0, False: 1.64k] | | ------------------ | | 119| 1.64k| goto _push ------------------ 187| 1.64k| case 0xc4: // bin 8 ------------------ | Branch (187:21): [True: 1.09k, False: 24.9k] ------------------ 188| 1.50k| case 0xc5: // bin 16 ------------------ | Branch (188:21): [True: 411, False: 25.6k] ------------------ 189| 1.99k| case 0xc6: // bin 32 ------------------ | Branch (189:21): [True: 487, False: 25.5k] ------------------ 190| 1.99k| again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); ------------------ | | 131| 1.99k| trail = trail_len; \ | | 132| 1.99k| cs = _cs; \ | | 133| 1.99k| goto _fixed_trail_again ------------------ 191| 227| case 0xc7: // ext 8 ------------------ | Branch (191:21): [True: 227, False: 25.8k] ------------------ 192| 420| case 0xc8: // ext 16 ------------------ | Branch (192:21): [True: 193, False: 25.8k] ------------------ 193| 615| case 0xc9: // ext 32 ------------------ | Branch (193:21): [True: 195, False: 25.8k] ------------------ 194| 615| again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) + 1) & 0x03)); ------------------ | | 131| 615| trail = trail_len; \ | | 132| 615| cs = _cs; \ | | 133| 615| goto _fixed_trail_again ------------------ 195| 1.47k| case 0xca: // float ------------------ | Branch (195:21): [True: 1.47k, False: 24.5k] ------------------ 196| 1.75k| case 0xcb: // double ------------------ | Branch (196:21): [True: 283, False: 25.7k] ------------------ 197| 2.30k| case 0xcc: // unsigned int 8 ------------------ | Branch (197:21): [True: 543, False: 25.5k] ------------------ 198| 2.79k| case 0xcd: // unsigned int 16 ------------------ | Branch (198:21): [True: 492, False: 25.5k] ------------------ 199| 3.07k| case 0xce: // unsigned int 32 ------------------ | Branch (199:21): [True: 282, False: 25.7k] ------------------ 200| 3.30k| case 0xcf: // unsigned int 64 ------------------ | Branch (200:21): [True: 231, False: 25.8k] ------------------ 201| 4.47k| case 0xd0: // signed int 8 ------------------ | Branch (201:21): [True: 1.17k, False: 24.8k] ------------------ 202| 5.40k| case 0xd1: // signed int 16 ------------------ | Branch (202:21): [True: 922, False: 25.1k] ------------------ 203| 6.30k| case 0xd2: // signed int 32 ------------------ | Branch (203:21): [True: 902, False: 25.1k] ------------------ 204| 7.20k| case 0xd3: // signed int 64 ------------------ | Branch (204:21): [True: 899, False: 25.1k] ------------------ 205| 7.20k| again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); ------------------ | | 131| 7.20k| trail = trail_len; \ | | 132| 7.20k| cs = _cs; \ | | 133| 7.20k| goto _fixed_trail_again ------------------ 206| 860| case 0xd4: // fixext 1 ------------------ | Branch (206:21): [True: 860, False: 25.2k] ------------------ 207| 1.45k| case 0xd5: // fixext 2 ------------------ | Branch (207:21): [True: 594, False: 25.4k] ------------------ 208| 2.03k| case 0xd6: // fixext 4 ------------------ | Branch (208:21): [True: 584, False: 25.4k] ------------------ 209| 3.79k| case 0xd7: // fixext 8 ------------------ | Branch (209:21): [True: 1.76k, False: 24.3k] ------------------ 210| 3.79k| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, ------------------ | | 135| 3.79k| trail = trail_len; \ | | 136| 3.79k| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 3.79k] | | ------------------ | | 137| 3.79k| cs = _cs; \ | | 138| 3.79k| goto _fixed_trail_again ------------------ 211| 3.79k| (1 << (((unsigned int)*p) & 0x03)) + 1, _ext_zero); 212| 805| case 0xd8: // fixext 16 ------------------ | Branch (212:21): [True: 805, False: 25.2k] ------------------ 213| 805| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero); ------------------ | | 135| 805| trail = trail_len; \ | | 136| 805| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 805] | | ------------------ | | 137| 805| cs = _cs; \ | | 138| 805| goto _fixed_trail_again ------------------ 214| | 215| 510| case 0xd9: // str 8 ------------------ | Branch (215:21): [True: 510, False: 25.5k] ------------------ 216| 1.02k| case 0xda: // str 16 ------------------ | Branch (216:21): [True: 514, False: 25.5k] ------------------ 217| 1.46k| case 0xdb: // str 32 ------------------ | Branch (217:21): [True: 437, False: 25.6k] ------------------ 218| 1.46k| again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1)); ------------------ | | 131| 1.46k| trail = trail_len; \ | | 132| 1.46k| cs = _cs; \ | | 133| 1.46k| goto _fixed_trail_again ------------------ 219| 718| case 0xdc: // array 16 ------------------ | Branch (219:21): [True: 718, False: 25.3k] ------------------ 220| 1.26k| case 0xdd: // array 32 ------------------ | Branch (220:21): [True: 547, False: 25.5k] ------------------ 221| 2.41k| case 0xde: // map 16 ------------------ | Branch (221:21): [True: 1.14k, False: 24.9k] ------------------ 222| 2.97k| case 0xdf: // map 32 ------------------ | Branch (222:21): [True: 559, False: 25.5k] ------------------ 223| 2.97k| again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01)); ------------------ | | 131| 2.97k| trail = trail_len; \ | | 132| 2.97k| cs = _cs; \ | | 133| 2.97k| goto _fixed_trail_again ------------------ 224| 4| default: ------------------ | Branch (224:21): [True: 4, False: 26.0k] ------------------ 225| 4| ret = MSGPACK_UNPACK_PARSE_ERROR; 226| 4| goto _failed; 227| 26.0k| } 228| | SWITCH_RANGE(0xa0, 0xbf) // FixStr ------------------ | | 158| 9.82k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 9.82k, False: 142k] | | ------------------ ------------------ 229| 9.82k| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero); ------------------ | | 135| 9.82k| trail = trail_len; \ | | 136| 9.82k| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 1.46k, False: 8.36k] | | ------------------ | | 137| 9.82k| cs = _cs; \ | | 138| 8.36k| goto _fixed_trail_again ------------------ 230| | SWITCH_RANGE(0x90, 0x9f) // FixArray ------------------ | | 158| 9.03k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 9.03k, False: 143k] | | ------------------ ------------------ 231| 18.0k| start_container(_array, ((unsigned int)*p) & 0x0f, MSGPACK_CT_ARRAY_ITEM); ------------------ | | 141| 9.03k| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 9.03k|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 11, False: 9.01k] | | ------------------ | | 142| 11| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 11| goto _failed; \ | | 144| 11| } /* FIXME */ \ | | 145| 9.03k| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 9.01k| template_callback ## name | | ------------------ | | 146| 9.01k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 9.01k] | | ------------------ | | 147| 9.01k| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 1.03k, False: 7.98k] | | ------------------ | | 148| 9.01k| stack[top].ct = ct_; \ | | 149| 7.98k| stack[top].count = count_; \ | | 150| 7.98k| ++top; \ | | 151| 7.98k| goto _header_again ------------------ 232| | SWITCH_RANGE(0x80, 0x8f) // FixMap ------------------ | | 158| 7.43k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 7.43k, False: 144k] | | ------------------ ------------------ 233| 14.8k| start_container(_map, ((unsigned int)*p) & 0x0f, MSGPACK_CT_MAP_KEY); ------------------ | | 141| 7.43k| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 7.43k|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 24, False: 7.40k] | | ------------------ | | 142| 24| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 24| goto _failed; \ | | 144| 24| } /* FIXME */ \ | | 145| 7.43k| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 7.40k| template_callback ## name | | ------------------ | | 146| 7.40k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 7.40k] | | ------------------ | | 147| 7.40k| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 1.85k, False: 5.55k] | | ------------------ | | 148| 7.40k| stack[top].ct = ct_; \ | | 149| 5.55k| stack[top].count = count_; \ | | 150| 5.55k| ++top; \ | | 151| 5.55k| goto _header_again ------------------ 234| | 235| 0| SWITCH_RANGE_DEFAULT ------------------ | | 159| 0|#define SWITCH_RANGE_DEFAULT default: | | ------------------ | | | Branch (159:32): [True: 0, False: 152k] | | ------------------ ------------------ 236| 0| ret = MSGPACK_UNPACK_PARSE_ERROR; 237| 0| goto _failed; 238| 152k| SWITCH_RANGE_END ------------------ | | 160| 152k|#define SWITCH_RANGE_END } ------------------ 239| | // end MSGPACK_CS_HEADER 240| | 241| | 242| 29.4k| _fixed_trail_again: 243| 29.4k| ++p; 244| | // fallthrough 245| | 246| 29.4k| default: ------------------ | Branch (246:13): [True: 0, False: 152k] ------------------ 247| 29.4k| if((size_t)(pe - p) < trail) { goto _out; } ------------------ | Branch (247:20): [True: 291, False: 29.1k] ------------------ 248| 29.1k| n = p; p += trail - 1; 249| 29.1k| switch(cs) { 250| | //case MSGPACK_CS_ 251| | //case MSGPACK_CS_ 252| 1.46k| case MSGPACK_CS_FLOAT: { ------------------ | Branch (252:17): [True: 1.46k, False: 27.7k] ------------------ 253| 1.46k| union { uint32_t i; float f; } mem; 254| 1.46k| _msgpack_load32(uint32_t, n, &mem.i); ------------------ | | 172| 1.46k|#define _msgpack_load32(cast, from, to) do { \ | | 173| 1.46k| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 1.46k| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 1.46k|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 1.46k| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 255| 1.46k| push_fixed_value(_float, mem.f); } ------------------ | | 121| 1.46k| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 1.46k| template_callback ## name | | ------------------ | | 122| 1.46k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 1.46k] | | ------------------ | | 123| 1.46k| goto _push ------------------ 256| 1.46k| case MSGPACK_CS_DOUBLE: { ------------------ | Branch (256:17): [True: 283, False: 28.9k] ------------------ 257| 283| union { uint64_t i; double f; } mem; 258| 283| _msgpack_load64(uint64_t, n, &mem.i); ------------------ | | 176| 283|#define _msgpack_load64(cast, from, to) do { \ | | 177| 283| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 178| 283| *(to) = (cast)_msgpack_be64(*(to)); \ | | ------------------ | | | | 142| 283|# define _msgpack_be64(x) bswap_64(x) | | ------------------ | | 179| 283| } while (0); | | ------------------ | | | Branch (179:14): [Folded - Ignored] | | ------------------ ------------------ 259| |#if defined(TARGET_OS_IPHONE) 260| | // ok 261| |#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi 262| | // https://github.com/msgpack/msgpack-perl/pull/1 263| | mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); 264| |#endif 265| 283| push_fixed_value(_double, mem.f); } ------------------ | | 121| 283| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 283| template_callback ## name | | ------------------ | | 122| 283| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 283] | | ------------------ | | 123| 283| goto _push ------------------ 266| 543| case MSGPACK_CS_UINT_8: ------------------ | Branch (266:17): [True: 543, False: 28.6k] ------------------ 267| 543| push_fixed_value(_uint8, *(uint8_t*)n); ------------------ | | 121| 543| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 543| template_callback ## name | | ------------------ | | 122| 543| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 543] | | ------------------ | | 123| 543| goto _push ------------------ 268| 543| case MSGPACK_CS_UINT_16:{ ------------------ | Branch (268:17): [True: 492, False: 28.6k] ------------------ 269| 492| uint16_t tmp; 270| 492| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 492|#define _msgpack_load16(cast, from, to) do { \ | | 168| 492| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 492| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 492|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 492| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 271| 492| push_fixed_value(_uint16, tmp); ------------------ | | 121| 492| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 492| template_callback ## name | | ------------------ | | 122| 492| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 492] | | ------------------ | | 123| 492| goto _push ------------------ 272| 492| } 273| 492| case MSGPACK_CS_UINT_32:{ ------------------ | Branch (273:17): [True: 277, False: 28.9k] ------------------ 274| 277| uint32_t tmp; 275| 277| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 277|#define _msgpack_load32(cast, from, to) do { \ | | 173| 277| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 277| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 277|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 277| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 276| 277| push_fixed_value(_uint32, tmp); ------------------ | | 121| 277| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 277| template_callback ## name | | ------------------ | | 122| 277| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 277] | | ------------------ | | 123| 277| goto _push ------------------ 277| 277| } 278| 277| case MSGPACK_CS_UINT_64:{ ------------------ | Branch (278:17): [True: 231, False: 28.9k] ------------------ 279| 231| uint64_t tmp; 280| 231| _msgpack_load64(uint64_t,n,&tmp); ------------------ | | 176| 231|#define _msgpack_load64(cast, from, to) do { \ | | 177| 231| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 178| 231| *(to) = (cast)_msgpack_be64(*(to)); \ | | ------------------ | | | | 142| 231|# define _msgpack_be64(x) bswap_64(x) | | ------------------ | | 179| 231| } while (0); | | ------------------ | | | Branch (179:14): [Folded - Ignored] | | ------------------ ------------------ 281| 231| push_fixed_value(_uint64, tmp); ------------------ | | 121| 231| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 231| template_callback ## name | | ------------------ | | 122| 231| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 231] | | ------------------ | | 123| 231| goto _push ------------------ 282| 231| } 283| 1.17k| case MSGPACK_CS_INT_8: ------------------ | Branch (283:17): [True: 1.17k, False: 28.0k] ------------------ 284| 1.17k| push_fixed_value(_int8, *(int8_t*)n); ------------------ | | 121| 1.17k| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 1.17k| template_callback ## name | | ------------------ | | 122| 1.17k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 1.17k] | | ------------------ | | 123| 1.17k| goto _push ------------------ 285| 1.17k| case MSGPACK_CS_INT_16:{ ------------------ | Branch (285:17): [True: 921, False: 28.2k] ------------------ 286| 921| int16_t tmp; 287| 921| _msgpack_load16(int16_t,n,&tmp); ------------------ | | 167| 921|#define _msgpack_load16(cast, from, to) do { \ | | 168| 921| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 921| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 921|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 921| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 288| 921| push_fixed_value(_int16, tmp); ------------------ | | 121| 921| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 921| template_callback ## name | | ------------------ | | 122| 921| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 921] | | ------------------ | | 123| 921| goto _push ------------------ 289| 921| } 290| 921| case MSGPACK_CS_INT_32:{ ------------------ | Branch (290:17): [True: 902, False: 28.2k] ------------------ 291| 902| int32_t tmp; 292| 902| _msgpack_load32(int32_t,n,&tmp); ------------------ | | 172| 902|#define _msgpack_load32(cast, from, to) do { \ | | 173| 902| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 902| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 902|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 902| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 293| 902| push_fixed_value(_int32, tmp); ------------------ | | 121| 902| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 902| template_callback ## name | | ------------------ | | 122| 902| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 902] | | ------------------ | | 123| 902| goto _push ------------------ 294| 902| } 295| 902| case MSGPACK_CS_INT_64:{ ------------------ | Branch (295:17): [True: 892, False: 28.2k] ------------------ 296| 892| int64_t tmp; 297| 892| _msgpack_load64(int64_t,n,&tmp); ------------------ | | 176| 892|#define _msgpack_load64(cast, from, to) do { \ | | 177| 892| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 178| 892| *(to) = (cast)_msgpack_be64(*(to)); \ | | ------------------ | | | | 142| 892|# define _msgpack_be64(x) bswap_64(x) | | ------------------ | | 179| 892| } while (0); | | ------------------ | | | Branch (179:14): [Folded - Ignored] | | ------------------ ------------------ 298| 892| push_fixed_value(_int64, tmp); ------------------ | | 121| 892| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 892| template_callback ## name | | ------------------ | | 122| 892| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 892] | | ------------------ | | 123| 892| goto _push ------------------ 299| 892| } 300| 892| case MSGPACK_CS_FIXEXT_1: ------------------ | Branch (300:17): [True: 0, False: 29.1k] ------------------ 301| 0| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 1+1, _ext_zero); ------------------ | | 135| 0| trail = trail_len; \ | | 136| 0| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 0] | | ------------------ | | 137| 0| cs = _cs; \ | | 138| 0| goto _fixed_trail_again ------------------ 302| 0| case MSGPACK_CS_FIXEXT_2: ------------------ | Branch (302:17): [True: 0, False: 29.1k] ------------------ 303| 0| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 2+1, _ext_zero); ------------------ | | 135| 0| trail = trail_len; \ | | 136| 0| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 0] | | ------------------ | | 137| 0| cs = _cs; \ | | 138| 0| goto _fixed_trail_again ------------------ 304| 0| case MSGPACK_CS_FIXEXT_4: ------------------ | Branch (304:17): [True: 0, False: 29.1k] ------------------ 305| 0| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 4+1, _ext_zero); ------------------ | | 135| 0| trail = trail_len; \ | | 136| 0| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 0] | | ------------------ | | 137| 0| cs = _cs; \ | | 138| 0| goto _fixed_trail_again ------------------ 306| 0| case MSGPACK_CS_FIXEXT_8: ------------------ | Branch (306:17): [True: 0, False: 29.1k] ------------------ 307| 0| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 8+1, _ext_zero); ------------------ | | 135| 0| trail = trail_len; \ | | 136| 0| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 0] | | ------------------ | | 137| 0| cs = _cs; \ | | 138| 0| goto _fixed_trail_again ------------------ 308| 0| case MSGPACK_CS_FIXEXT_16: ------------------ | Branch (308:17): [True: 0, False: 29.1k] ------------------ 309| 0| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero); ------------------ | | 135| 0| trail = trail_len; \ | | 136| 0| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 0] | | ------------------ | | 137| 0| cs = _cs; \ | | 138| 0| goto _fixed_trail_again ------------------ 310| 507| case MSGPACK_CS_STR_8: ------------------ | Branch (310:17): [True: 507, False: 28.6k] ------------------ 311| 507| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, *(uint8_t*)n, _str_zero); ------------------ | | 135| 507| trail = trail_len; \ | | 136| 507| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 281, False: 226] | | ------------------ | | 137| 507| cs = _cs; \ | | 138| 226| goto _fixed_trail_again ------------------ 312| 1.09k| case MSGPACK_CS_BIN_8: ------------------ | Branch (312:17): [True: 1.09k, False: 28.0k] ------------------ 313| 1.09k| again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero); ------------------ | | 135| 1.09k| trail = trail_len; \ | | 136| 1.09k| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 402, False: 695] | | ------------------ | | 137| 1.09k| cs = _cs; \ | | 138| 695| goto _fixed_trail_again ------------------ 314| 227| case MSGPACK_CS_EXT_8: ------------------ | Branch (314:17): [True: 227, False: 28.9k] ------------------ 315| 227| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, (*(uint8_t*)n) + 1, _ext_zero); ------------------ | | 135| 227| trail = trail_len; \ | | 136| 227| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 227] | | ------------------ | | 137| 227| cs = _cs; \ | | 138| 227| goto _fixed_trail_again ------------------ 316| 514| case MSGPACK_CS_STR_16:{ ------------------ | Branch (316:17): [True: 514, False: 28.6k] ------------------ 317| 514| uint16_t tmp; 318| 514| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 514|#define _msgpack_load16(cast, from, to) do { \ | | 168| 514| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 514| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 514|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 514| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 319| 514| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero); ------------------ | | 135| 514| trail = trail_len; \ | | 136| 514| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 340, False: 174] | | ------------------ | | 137| 514| cs = _cs; \ | | 138| 174| goto _fixed_trail_again ------------------ 320| 514| } 321| 411| case MSGPACK_CS_BIN_16:{ ------------------ | Branch (321:17): [True: 411, False: 28.7k] ------------------ 322| 411| uint16_t tmp; 323| 411| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 411|#define _msgpack_load16(cast, from, to) do { \ | | 168| 411| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 411| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 411|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 411| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 324| 411| again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero); ------------------ | | 135| 411| trail = trail_len; \ | | 136| 411| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 190, False: 221] | | ------------------ | | 137| 411| cs = _cs; \ | | 138| 221| goto _fixed_trail_again ------------------ 325| 411| } 326| 193| case MSGPACK_CS_EXT_16:{ ------------------ | Branch (326:17): [True: 193, False: 28.9k] ------------------ 327| 193| uint16_t tmp; 328| 193| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 193|#define _msgpack_load16(cast, from, to) do { \ | | 168| 193| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 193| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 193|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 193| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 329| 193| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero); ------------------ | | 135| 193| trail = trail_len; \ | | 136| 193| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 193] | | ------------------ | | 137| 193| cs = _cs; \ | | 138| 193| goto _fixed_trail_again ------------------ 330| 193| } 331| 436| case MSGPACK_CS_STR_32:{ ------------------ | Branch (331:17): [True: 436, False: 28.7k] ------------------ 332| 436| uint32_t tmp; 333| 436| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 436|#define _msgpack_load32(cast, from, to) do { \ | | 173| 436| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 436| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 436|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 436| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 334| 436| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero); ------------------ | | 135| 436| trail = trail_len; \ | | 136| 436| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 269, False: 167] | | ------------------ | | 137| 436| cs = _cs; \ | | 138| 167| goto _fixed_trail_again ------------------ 335| 436| } 336| 487| case MSGPACK_CS_BIN_32:{ ------------------ | Branch (336:17): [True: 487, False: 28.7k] ------------------ 337| 487| uint32_t tmp; 338| 487| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 487|#define _msgpack_load32(cast, from, to) do { \ | | 173| 487| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 487| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 487|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 487| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 339| 487| again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero); ------------------ | | 135| 487| trail = trail_len; \ | | 136| 487| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 314, False: 173] | | ------------------ | | 137| 487| cs = _cs; \ | | 138| 173| goto _fixed_trail_again ------------------ 340| 487| } 341| 194| case MSGPACK_CS_EXT_32:{ ------------------ | Branch (341:17): [True: 194, False: 28.9k] ------------------ 342| 194| uint32_t tmp; 343| 194| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 194|#define _msgpack_load32(cast, from, to) do { \ | | 173| 194| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 194| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 194|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 194| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 344| 194| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero); ------------------ | | 135| 194| trail = trail_len; \ | | 136| 194| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 1, False: 193] | | ------------------ | | 137| 194| cs = _cs; \ | | 138| 193| goto _fixed_trail_again ------------------ 345| 194| } 346| 8.79k| case MSGPACK_ACS_STR_VALUE: ------------------ | Branch (346:17): [True: 8.79k, False: 20.3k] ------------------ 347| 11.1k| _str_zero: 348| 11.1k| push_variable_value(_str, data, n, trail); ------------------ | | 125| 11.1k| ret = msgpack_unpack_callback(func)(user, \ | | ------------------ | | | | 33| 11.1k| template_callback ## name | | ------------------ | | 126| 11.1k| (const char*)base, (const char*)pos, len, &obj); \ | | 127| 11.1k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (127:12): [True: 0, False: 11.1k] | | ------------------ | | 128| 11.1k| goto _push ------------------ 349| 11.1k| case MSGPACK_ACS_BIN_VALUE: ------------------ | Branch (349:17): [True: 1.02k, False: 28.1k] ------------------ 350| 1.93k| _bin_zero: 351| 1.93k| push_variable_value(_bin, data, n, trail); ------------------ | | 125| 1.93k| ret = msgpack_unpack_callback(func)(user, \ | | ------------------ | | | | 33| 1.93k| template_callback ## name | | ------------------ | | 126| 1.93k| (const char*)base, (const char*)pos, len, &obj); \ | | 127| 1.93k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (127:12): [True: 0, False: 1.93k] | | ------------------ | | 128| 1.93k| goto _push ------------------ 352| 5.15k| case MSGPACK_ACS_EXT_VALUE: ------------------ | Branch (352:17): [True: 5.15k, False: 24.0k] ------------------ 353| 5.15k| _ext_zero: 354| 5.15k| push_variable_value(_ext, data, n, trail); ------------------ | | 125| 5.15k| ret = msgpack_unpack_callback(func)(user, \ | | ------------------ | | | | 33| 5.15k| template_callback ## name | | ------------------ | | 126| 5.15k| (const char*)base, (const char*)pos, len, &obj); \ | | 127| 5.15k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (127:12): [True: 1, False: 5.15k] | | ------------------ | | 128| 5.15k| goto _push ------------------ 355| | 356| 5.15k| case MSGPACK_CS_ARRAY_16:{ ------------------ | Branch (356:17): [True: 716, False: 28.4k] ------------------ 357| 716| uint16_t tmp; 358| 716| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 716|#define _msgpack_load16(cast, from, to) do { \ | | 168| 716| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 716| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 716|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 716| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 359| 1.42k| start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM); ------------------ | | 141| 716| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 716|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 5, False: 711] | | ------------------ | | 142| 5| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 5| goto _failed; \ | | 144| 5| } /* FIXME */ \ | | 145| 716| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 711| template_callback ## name | | ------------------ | | 146| 711| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 711] | | ------------------ | | 147| 711| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 226, False: 485] | | ------------------ | | 148| 711| stack[top].ct = ct_; \ | | 149| 485| stack[top].count = count_; \ | | 150| 485| ++top; \ | | 151| 485| goto _header_again ------------------ 360| 1.42k| } 361| 546| case MSGPACK_CS_ARRAY_32:{ ------------------ | Branch (361:17): [True: 546, False: 28.6k] ------------------ 362| | /* FIXME security guard */ 363| 546| uint32_t tmp; 364| 546| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 546|#define _msgpack_load32(cast, from, to) do { \ | | 173| 546| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 546| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 546|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 546| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 365| 1.07k| start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM); ------------------ | | 141| 546| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 546|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 1, False: 545] | | ------------------ | | 142| 1| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 1| goto _failed; \ | | 144| 1| } /* FIXME */ \ | | 145| 546| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 545| template_callback ## name | | ------------------ | | 146| 545| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 18, False: 527] | | ------------------ | | 147| 545| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 223, False: 304] | | ------------------ | | 148| 527| stack[top].ct = ct_; \ | | 149| 304| stack[top].count = count_; \ | | 150| 304| ++top; \ | | 151| 304| goto _header_again ------------------ 366| 1.07k| } 367| | 368| 1.14k| case MSGPACK_CS_MAP_16:{ ------------------ | Branch (368:17): [True: 1.14k, False: 28.0k] ------------------ 369| 1.14k| uint16_t tmp; 370| 1.14k| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 1.14k|#define _msgpack_load16(cast, from, to) do { \ | | 168| 1.14k| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 1.14k| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 1.14k|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 1.14k| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 371| 2.28k| start_container(_map, tmp, MSGPACK_CT_MAP_KEY); ------------------ | | 141| 1.14k| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 1.14k|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 4, False: 1.14k] | | ------------------ | | 142| 4| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 4| goto _failed; \ | | 144| 4| } /* FIXME */ \ | | 145| 1.14k| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 1.14k| template_callback ## name | | ------------------ | | 146| 1.14k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 1.14k] | | ------------------ | | 147| 1.14k| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 182, False: 960] | | ------------------ | | 148| 1.14k| stack[top].ct = ct_; \ | | 149| 960| stack[top].count = count_; \ | | 150| 960| ++top; \ | | 151| 960| goto _header_again ------------------ 372| 2.28k| } 373| 557| case MSGPACK_CS_MAP_32:{ ------------------ | Branch (373:17): [True: 557, False: 28.6k] ------------------ 374| | /* FIXME security guard */ 375| 557| uint32_t tmp; 376| 557| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 557|#define _msgpack_load32(cast, from, to) do { \ | | 173| 557| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 557| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 557|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 557| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 377| 1.08k| start_container(_map, tmp, MSGPACK_CT_MAP_KEY); ------------------ | | 141| 557| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 557|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 1, False: 556] | | ------------------ | | 142| 1| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 1| goto _failed; \ | | 144| 1| } /* FIXME */ \ | | 145| 557| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 556| template_callback ## name | | ------------------ | | 146| 556| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 30, False: 526] | | ------------------ | | 147| 556| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 301, False: 225] | | ------------------ | | 148| 526| stack[top].ct = ct_; \ | | 149| 225| stack[top].count = count_; \ | | 150| 225| ++top; \ | | 151| 225| goto _header_again ------------------ 378| 1.08k| } 379| | 380| 0| default: ------------------ | Branch (380:17): [True: 0, False: 29.1k] ------------------ 381| 0| ret = MSGPACK_UNPACK_PARSE_ERROR; 382| 0| goto _failed; 383| 29.1k| } 384| 152k| } 385| | 386| 145k| _push: 387| 145k| if(top == 0) { goto _finish; } ------------------ | Branch (387:12): [True: 335, False: 145k] ------------------ 388| 145k| c = &stack[top-1]; 389| 145k| switch(c->ct) { 390| 55.0k| case MSGPACK_CT_ARRAY_ITEM: ------------------ | Branch (390:9): [True: 55.0k, False: 90.3k] ------------------ 391| 55.0k| ret = msgpack_unpack_callback(_array_item)(user, &c->obj, obj); \ ------------------ | | 33| 55.0k| template_callback ## name ------------------ 392| 55.0k| if(ret < 0) { goto _failed; } ------------------ | Branch (392:16): [True: 0, False: 55.0k] ------------------ 393| 55.0k| if(--c->count == 0) { ------------------ | Branch (393:16): [True: 5.92k, False: 49.1k] ------------------ 394| 5.92k| obj = c->obj; 395| 5.92k| --top; 396| | /*printf("stack pop %d\n", top);*/ 397| 5.92k| goto _push; 398| 5.92k| } 399| 49.1k| goto _header_again; 400| 49.1k| case MSGPACK_CT_MAP_KEY: ------------------ | Branch (400:9): [True: 45.6k, False: 99.7k] ------------------ 401| 45.6k| c->map_key = obj; 402| 45.6k| c->ct = MSGPACK_CT_MAP_VALUE; 403| 45.6k| goto _header_again; 404| 44.6k| case MSGPACK_CT_MAP_VALUE: ------------------ | Branch (404:9): [True: 44.6k, False: 100k] ------------------ 405| 44.6k| ret = msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj); \ ------------------ | | 33| 44.6k| template_callback ## name ------------------ 406| 44.6k| if(ret < 0) { goto _failed; } ------------------ | Branch (406:16): [True: 0, False: 44.6k] ------------------ 407| 44.6k| if(--c->count == 0) { ------------------ | Branch (407:16): [True: 3.67k, False: 40.9k] ------------------ 408| 3.67k| obj = c->obj; 409| 3.67k| --top; 410| | /*printf("stack pop %d\n", top);*/ 411| 3.67k| goto _push; 412| 3.67k| } 413| 40.9k| c->ct = MSGPACK_CT_MAP_KEY; 414| 40.9k| goto _header_again; 415| | 416| 0| default: ------------------ | Branch (416:9): [True: 0, False: 145k] ------------------ 417| 0| ret = MSGPACK_UNPACK_PARSE_ERROR; 418| 0| goto _failed; 419| 145k| } 420| | 421| 151k| _header_again: 422| 151k| cs = MSGPACK_CS_HEADER; 423| 151k| ++p; 424| 151k| } while(p != pe); ------------------ | Branch (424:17): [True: 151k, False: 119] ------------------ 425| 119| goto _out; 426| | 427| | 428| 335| _finish: 429| 335| stack[0].obj = obj; 430| 335| ++p; 431| 335| ret = 1; 432| | /*printf("-- finish --\n"); */ 433| 335| goto _end; 434| | 435| 99| _failed: 436| | /*printf("** FAILED **\n"); */ 437| 99| goto _end; 438| | 439| 410| _out: 440| 410| ret = 0; 441| 410| goto _end; 442| | 443| 844| _end: 444| 844| ctx->cs = cs; 445| 844| ctx->trail = trail; 446| 844| ctx->top = top; 447| 844| *off = (size_t)(p - (const unsigned char*)data); 448| | 449| 844| return ret; 450| 844| } 451| 844|} unpack.c:template_data: 89| 335|{ 90| 335| return (ctx)->stack[0].obj; 91| 335|} unpack.c:msgpack_zone_malloc: 107| 19.3k|{ 108| 19.3k| char* aligned = 109| 19.3k| (char*)( 110| 19.3k| (size_t)( 111| 19.3k| zone->chunk_list.ptr + (MSGPACK_ZONE_ALIGN - 1) ------------------ | | 84| 19.3k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 112| 19.3k| ) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN ------------------ | | 84| 19.3k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ ) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN ------------------ | | 84| 19.3k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 113| 19.3k| ); 114| 19.3k| size_t adjusted_size = size + (size_t)(aligned - zone->chunk_list.ptr); 115| 19.3k| if(zone->chunk_list.free >= adjusted_size) { ------------------ | Branch (115:8): [True: 18.1k, False: 1.27k] ------------------ 116| 18.1k| zone->chunk_list.free -= adjusted_size; 117| 18.1k| zone->chunk_list.ptr += adjusted_size; 118| 18.1k| return aligned; 119| 18.1k| } 120| 1.27k| { 121| 1.27k| void* ptr = msgpack_zone_malloc_expand(zone, size + (MSGPACK_ZONE_ALIGN - 1)); ------------------ | | 84| 1.27k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 122| 1.27k| if (ptr) { ------------------ | Branch (122:13): [True: 1.23k, False: 48] ------------------ 123| 1.23k| return (char*)((size_t)(ptr) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN); ------------------ | | 84| 1.23k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ return (char*)((size_t)(ptr) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN); ------------------ | | 84| 1.23k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 124| 1.23k| } 125| 1.27k| } 126| 48| return NULL; 127| 1.27k|} msgpack_unpack_next: 659| 844|{ 660| 844| size_t noff = 0; 661| 844| msgpack_unpacked_destroy(result); 662| | 663| 844| if(off != NULL) { noff = *off; } ------------------ | Branch (663:8): [True: 844, False: 0] ------------------ 664| | 665| 844| if(len <= noff) { ------------------ | Branch (665:8): [True: 0, False: 844] ------------------ 666| 0| return MSGPACK_UNPACK_CONTINUE; 667| 0| } 668| | 669| 844| { 670| 844| int e; 671| 844| template_context ctx; 672| 844| template_init(&ctx); 673| | 674| 844| ctx.user.z = &result->zone; 675| 844| ctx.user.referenced = false; 676| | 677| 844| e = template_execute(&ctx, data, len, &noff); 678| | 679| 844| if(off != NULL) { *off = noff; } ------------------ | Branch (679:12): [True: 844, False: 0] ------------------ 680| | 681| 844| if(e < 0) { ------------------ | Branch (681:12): [True: 99, False: 745] ------------------ 682| 99| msgpack_zone_free(result->zone); 683| 99| result->zone = NULL; 684| 99| return (msgpack_unpack_return)e; 685| 99| } 686| | 687| 745| if(e == 0) { ------------------ | Branch (687:12): [True: 410, False: 335] ------------------ 688| 410| return MSGPACK_UNPACK_CONTINUE; 689| 410| } 690| | 691| 335| result->data = template_data(&ctx); 692| | 693| 335| return MSGPACK_UNPACK_SUCCESS; 694| 745| } 695| 745|} unpack.c:template_callback_root: 52| 844|{ 53| 844| msgpack_object o; 54| 844| MSGPACK_UNUSED(u); ------------------ | | 13| 844|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 55| 844| o.type = MSGPACK_OBJECT_NIL; 56| 844| return o; 57| 844|} unpack.c:template_callback_uint8: 60| 56.1k|{ 61| 56.1k| MSGPACK_UNUSED(u); ------------------ | | 13| 56.1k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 62| 56.1k| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 63| 56.1k| o->via.u64 = d; 64| 56.1k| return 0; 65| 56.1k|} unpack.c:template_callback_int8: 92| 45.2k|{ 93| 45.2k| MSGPACK_UNUSED(u); ------------------ | | 13| 45.2k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 94| 45.2k| if(d >= 0) { ------------------ | Branch (94:8): [True: 211, False: 45.0k] ------------------ 95| 211| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 96| 211| o->via.u64 = (uint64_t)d; 97| 211| return 0; 98| 211| } 99| 45.0k| else { 100| 45.0k| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 101| 45.0k| o->via.i64 = d; 102| 45.0k| return 0; 103| 45.0k| } 104| 45.2k|} unpack.c:template_callback_nil: 168| 2.18k|{ 169| 2.18k| MSGPACK_UNUSED(u); ------------------ | | 13| 2.18k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 170| 2.18k| o->type = MSGPACK_OBJECT_NIL; 171| 2.18k| return 0; 172| 2.18k|} unpack.c:template_callback_false: 183| 3.38k|{ 184| 3.38k| MSGPACK_UNUSED(u); ------------------ | | 13| 3.38k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 185| 3.38k| o->type = MSGPACK_OBJECT_BOOLEAN; 186| 3.38k| o->via.boolean = false; 187| 3.38k| return 0; 188| 3.38k|} unpack.c:template_callback_true: 175| 1.64k|{ 176| 1.64k| MSGPACK_UNUSED(u); ------------------ | | 13| 1.64k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 177| 1.64k| o->type = MSGPACK_OBJECT_BOOLEAN; 178| 1.64k| o->via.boolean = true; 179| 1.64k| return 0; 180| 1.64k|} unpack.c:template_callback_array: 191| 10.2k|{ 192| 10.2k| size_t size; 193| | // Let's leverage the fact that sizeof(msgpack_object) is a compile time constant 194| | // to check for int overflows. 195| | // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object) 196| | // might not be constrained to 4GB on 64-bit systems 197| |#if SIZE_MAX == UINT_MAX 198| | if (n > SIZE_MAX/sizeof(msgpack_object)) 199| | return MSGPACK_UNPACK_NOMEM_ERROR; 200| |#endif 201| | 202| 10.2k| o->type = MSGPACK_OBJECT_ARRAY; 203| 10.2k| o->via.array.size = 0; 204| | 205| 10.2k| size = n * sizeof(msgpack_object); 206| | 207| 10.2k| if (*u->z == NULL) { ------------------ | Branch (207:9): [True: 520, False: 9.75k] ------------------ 208| 520| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 520|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 209| 520| if(*u->z == NULL) { ------------------ | Branch (209:12): [True: 0, False: 520] ------------------ 210| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 211| 0| } 212| 520| } 213| | 214| | // Unsure whether size = 0 should be an error, and if so, what to return 215| 10.2k| o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(*u->z, size); 216| 10.2k| if(o->via.array.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; } ------------------ | Branch (216:8): [True: 18, False: 10.2k] ------------------ 217| 10.2k| return 0; 218| 10.2k|} unpack.c:template_callback_map: 233| 9.10k|{ 234| 9.10k| size_t size; 235| | // Let's leverage the fact that sizeof(msgpack_object_kv) is a compile time constant 236| | // to check for int overflows 237| | // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object) 238| | // might not be constrained to 4GB on 64-bit systems 239| | 240| | // Note - this will always be false on 64-bit systems 241| |#if SIZE_MAX == UINT_MAX 242| | if (n > SIZE_MAX/sizeof(msgpack_object_kv)) 243| | return MSGPACK_UNPACK_NOMEM_ERROR; 244| |#endif 245| | 246| 9.10k| o->type = MSGPACK_OBJECT_MAP; 247| 9.10k| o->via.map.size = 0; 248| | 249| 9.10k| size = n * sizeof(msgpack_object_kv); 250| | 251| 9.10k| if (*u->z == NULL) { ------------------ | Branch (251:9): [True: 308, False: 8.79k] ------------------ 252| 308| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 308|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 253| 308| if(*u->z == NULL) { ------------------ | Branch (253:12): [True: 0, False: 308] ------------------ 254| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 255| 0| } 256| 308| } 257| | 258| | // Should size = 0 be an error? If so, what error to return? 259| 9.10k| o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(*u->z, size); 260| 9.10k| if(o->via.map.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; } ------------------ | Branch (260:8): [True: 30, False: 9.07k] ------------------ 261| 9.07k| return 0; 262| 9.10k|} unpack.c:template_callback_float: 152| 1.46k|{ 153| 1.46k| MSGPACK_UNUSED(u); ------------------ | | 13| 1.46k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 154| 1.46k| o->type = MSGPACK_OBJECT_FLOAT32; 155| 1.46k| o->via.f64 = d; 156| 1.46k| return 0; 157| 1.46k|} unpack.c:template_callback_double: 160| 283|{ 161| 283| MSGPACK_UNUSED(u); ------------------ | | 13| 283|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 162| 283| o->type = MSGPACK_OBJECT_FLOAT64; 163| 283| o->via.f64 = d; 164| 283| return 0; 165| 283|} unpack.c:template_callback_uint16: 68| 492|{ 69| 492| MSGPACK_UNUSED(u); ------------------ | | 13| 492|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 70| 492| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 71| 492| o->via.u64 = d; 72| 492| return 0; 73| 492|} unpack.c:template_callback_uint32: 76| 277|{ 77| 277| MSGPACK_UNUSED(u); ------------------ | | 13| 277|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 78| 277| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 79| 277| o->via.u64 = d; 80| 277| return 0; 81| 277|} unpack.c:template_callback_uint64: 84| 231|{ 85| 231| MSGPACK_UNUSED(u); ------------------ | | 13| 231|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 86| 231| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 87| 231| o->via.u64 = d; 88| 231| return 0; 89| 231|} unpack.c:template_callback_int16: 107| 921|{ 108| 921| MSGPACK_UNUSED(u); ------------------ | | 13| 921|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 109| 921| if(d >= 0) { ------------------ | Branch (109:8): [True: 326, False: 595] ------------------ 110| 326| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 111| 326| o->via.u64 = (uint64_t)d; 112| 326| return 0; 113| 326| } 114| 595| else { 115| 595| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 116| 595| o->via.i64 = d; 117| 595| return 0; 118| 595| } 119| 921|} unpack.c:template_callback_int32: 122| 902|{ 123| 902| MSGPACK_UNUSED(u); ------------------ | | 13| 902|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 124| 902| if(d >= 0) { ------------------ | Branch (124:8): [True: 249, False: 653] ------------------ 125| 249| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 126| 249| o->via.u64 = (uint64_t)d; 127| 249| return 0; 128| 249| } 129| 653| else { 130| 653| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 131| 653| o->via.i64 = d; 132| 653| return 0; 133| 653| } 134| 902|} unpack.c:template_callback_int64: 137| 892|{ 138| 892| MSGPACK_UNUSED(u); ------------------ | | 13| 892|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 139| 892| if(d >= 0) { ------------------ | Branch (139:8): [True: 316, False: 576] ------------------ 140| 316| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 141| 316| o->via.u64 = (uint64_t)d; 142| 316| return 0; 143| 316| } 144| 576| else { 145| 576| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 146| 576| o->via.i64 = d; 147| 576| return 0; 148| 576| } 149| 892|} unpack.c:template_callback_str: 279| 11.1k|{ 280| 11.1k| MSGPACK_UNUSED(b); ------------------ | | 13| 11.1k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 281| 11.1k| if (*u->z == NULL) { ------------------ | Branch (281:9): [True: 7, False: 11.1k] ------------------ 282| 7| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 7|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 283| 7| if(*u->z == NULL) { ------------------ | Branch (283:12): [True: 0, False: 7] ------------------ 284| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 285| 0| } 286| 7| } 287| 11.1k| o->type = MSGPACK_OBJECT_STR; 288| 11.1k| o->via.str.ptr = p; 289| 11.1k| o->via.str.size = l; 290| 11.1k| u->referenced = true; 291| 11.1k| return 0; 292| 11.1k|} unpack.c:template_callback_bin: 295| 1.93k|{ 296| 1.93k| MSGPACK_UNUSED(b); ------------------ | | 13| 1.93k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 297| 1.93k| if (*u->z == NULL) { ------------------ | Branch (297:9): [True: 5, False: 1.92k] ------------------ 298| 5| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 5|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 299| 5| if(*u->z == NULL) { ------------------ | Branch (299:12): [True: 0, False: 5] ------------------ 300| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 301| 0| } 302| 5| } 303| 1.93k| o->type = MSGPACK_OBJECT_BIN; 304| 1.93k| o->via.bin.ptr = p; 305| 1.93k| o->via.bin.size = l; 306| 1.93k| u->referenced = true; 307| 1.93k| return 0; 308| 1.93k|} unpack.c:template_callback_ext: 311| 5.15k|{ 312| 5.15k| MSGPACK_UNUSED(b); ------------------ | | 13| 5.15k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 313| 5.15k| if (l == 0) { ------------------ | Branch (313:9): [True: 1, False: 5.15k] ------------------ 314| 1| return MSGPACK_UNPACK_PARSE_ERROR; 315| 1| } 316| 5.15k| if (*u->z == NULL) { ------------------ | Branch (316:9): [True: 1, False: 5.15k] ------------------ 317| 1| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 1|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 318| 1| if(*u->z == NULL) { ------------------ | Branch (318:12): [True: 0, False: 1] ------------------ 319| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 320| 0| } 321| 1| } 322| 5.15k| o->type = MSGPACK_OBJECT_EXT; 323| 5.15k| o->via.ext.type = *p; 324| 5.15k| o->via.ext.ptr = p + 1; 325| 5.15k| o->via.ext.size = l - 1; 326| 5.15k| u->referenced = true; 327| 5.15k| return 0; 328| 5.15k|} unpack.c:template_callback_array_item: 221| 55.0k|{ 222| 55.0k| MSGPACK_UNUSED(u); ------------------ | | 13| 55.0k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 223| |#if defined(__GNUC__) && !defined(__clang__) 224| | memcpy(&c->via.array.ptr[c->via.array.size], &o, sizeof(msgpack_object)); 225| |#else /* __GNUC__ && !__clang__ */ 226| 55.0k| c->via.array.ptr[c->via.array.size] = o; 227| 55.0k|#endif /* __GNUC__ && !__clang__ */ 228| 55.0k| ++c->via.array.size; 229| 55.0k| return 0; 230| 55.0k|} unpack.c:template_callback_map_item: 265| 44.6k|{ 266| 44.6k| MSGPACK_UNUSED(u); ------------------ | | 13| 44.6k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 267| |#if defined(__GNUC__) && !defined(__clang__) 268| | memcpy(&c->via.map.ptr[c->via.map.size].key, &k, sizeof(msgpack_object)); 269| | memcpy(&c->via.map.ptr[c->via.map.size].val, &v, sizeof(msgpack_object)); 270| |#else /* __GNUC__ && !__clang__ */ 271| 44.6k| c->via.map.ptr[c->via.map.size].key = k; 272| 44.6k| c->via.map.ptr[c->via.map.size].val = v; 273| 44.6k|#endif /* __GNUC__ && !__clang__ */ 274| 44.6k| ++c->via.map.size; 275| 44.6k| return 0; 276| 44.6k|} fuzz_malloc: 14| 2.96k|void *fuzz_malloc(size_t size) {if (size > 0xa00000) return NULL; ------------------ | Branch (14:37): [True: 48, False: 2.91k] ------------------ 15| 2.91k|return malloc(size);} msgpack_zone_malloc_expand: 70| 1.27k|{ 71| 1.27k| msgpack_zone_chunk_list* const cl = &zone->chunk_list; 72| 1.27k| msgpack_zone_chunk* chunk; 73| | 74| 1.27k| size_t sz = zone->chunk_size; 75| | 76| 8.15k| while(sz < size) { ------------------ | Branch (76:11): [True: 6.87k, False: 1.27k] ------------------ 77| 6.87k| size_t tmp_sz = sz * 2; 78| 6.87k| if (tmp_sz <= sz) { ------------------ | Branch (78:13): [True: 0, False: 6.87k] ------------------ 79| 0| sz = size; 80| 0| break; 81| 0| } 82| 6.87k| sz = tmp_sz; 83| 6.87k| } 84| | 85| 1.27k| chunk = (msgpack_zone_chunk*)fuzz_malloc( 86| 1.27k| sizeof(msgpack_zone_chunk) + sz); 87| 1.27k| if (chunk == NULL) { ------------------ | Branch (87:9): [True: 48, False: 1.23k] ------------------ 88| 48| return NULL; 89| 48| } 90| 1.23k| else { 91| 1.23k| char* ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); 92| 1.23k| chunk->next = cl->head; 93| 1.23k| cl->head = chunk; 94| 1.23k| cl->free = sz - size; 95| 1.23k| cl->ptr = ptr + size; 96| | 97| 1.23k| return ptr; 98| 1.23k| } 99| 1.27k|} msgpack_zone_destroy: 175| 841|{ 176| 841| destroy_finalizer_array(&zone->finalizer_array); 177| 841| destroy_chunk_list(&zone->chunk_list); 178| 841|} msgpack_zone_new: 200| 841|{ 201| 841| msgpack_zone* zone = (msgpack_zone*)fuzz_malloc( 202| 841| sizeof(msgpack_zone)); 203| 841| if(zone == NULL) { ------------------ | Branch (203:8): [True: 0, False: 841] ------------------ 204| 0| return NULL; 205| 0| } 206| | 207| 841| zone->chunk_size = chunk_size; 208| | 209| 841| if(!init_chunk_list(&zone->chunk_list, chunk_size)) { ------------------ | Branch (209:8): [True: 0, False: 841] ------------------ 210| 0| free(zone); 211| 0| return NULL; 212| 0| } 213| | 214| 841| init_finalizer_array(&zone->finalizer_array); 215| | 216| 841| return zone; 217| 841|} msgpack_zone_free: 220| 842|{ 221| 842| if(zone == NULL) { return; } ------------------ | Branch (221:8): [True: 1, False: 841] ------------------ 222| 841| msgpack_zone_destroy(zone); 223| 841| free(zone); 224| 841|} zone.c:destroy_finalizer_array: 118| 841|{ 119| 841| call_finalizer_array(fa); 120| 841| free(fa->array); 121| 841|} zone.c:call_finalizer_array: 110| 841|{ 111| 841| msgpack_zone_finalizer* fin = fa->tail; 112| 841| for(; fin != fa->array; --fin) { ------------------ | Branch (112:11): [True: 0, False: 841] ------------------ 113| 0| (*(fin-1)->func)((fin-1)->data); 114| 0| } 115| 841|} zone.c:destroy_chunk_list: 38| 841|{ 39| 841| msgpack_zone_chunk* c = cl->head; 40| 2.07k| while(true) { 41| 2.07k| msgpack_zone_chunk* n = c->next; 42| 2.07k| free(c); 43| 2.07k| if(n != NULL) { ------------------ | Branch (43:12): [True: 1.23k, False: 841] ------------------ 44| 1.23k| c = n; 45| 1.23k| } else { 46| 841| break; 47| 841| } 48| 2.07k| } 49| 841|} zone.c:init_chunk_list: 22| 841|{ 23| 841| msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)fuzz_malloc( 24| 841| sizeof(msgpack_zone_chunk) + chunk_size); 25| 841| if(chunk == NULL) { ------------------ | Branch (25:8): [True: 0, False: 841] ------------------ 26| 0| return false; 27| 0| } 28| | 29| 841| cl->head = chunk; 30| 841| cl->free = chunk_size; 31| 841| cl->ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); 32| 841| chunk->next = NULL; 33| | 34| 841| return true; 35| 841|} zone.c:init_finalizer_array: 103| 841|{ 104| 841| fa->tail = NULL; 105| 841| fa->end = NULL; 106| 841| fa->array = NULL; 107| 841|} flb_log_construct: 497| 2|{ 498| 2| int body_size; 499| 2| int ret; 500| 2| int len; 501| 2| int total; 502| 2| time_t now; 503| 2| const char *header_color = NULL; 504| 2| const char *header_title = NULL; 505| 2| const char *bold_color = ANSI_BOLD; ------------------ | | 47| 2|#define ANSI_BOLD "\033[1m" ------------------ 506| 2| const char *reset_color = ANSI_RESET; ------------------ | | 46| 2|#define ANSI_RESET "\033[0m" ------------------ 507| 2| struct tm result; 508| 2| struct tm *current; 509| | 510| 2| switch (type) { ------------------ | Branch (510:13): [True: 0, False: 2] ------------------ 511| 0| case FLB_LOG_HELP: ------------------ | | 44| 0|#define FLB_LOG_HELP 6 /* unused by log level */ ------------------ | Branch (511:5): [True: 0, False: 2] ------------------ 512| 0| header_title = "help"; 513| 0| header_color = ANSI_CYAN; ------------------ | | 48| 0|#define ANSI_CYAN "\033[96m" ------------------ 514| 0| break; 515| 0| case FLB_LOG_INFO: ------------------ | | 41| 0|#define FLB_LOG_INFO 3 /* default */ ------------------ | Branch (515:5): [True: 0, False: 2] ------------------ 516| 0| header_title = "info"; 517| 0| header_color = ANSI_GREEN; ------------------ | | 53| 0|#define ANSI_GREEN "\033[92m" ------------------ 518| 0| break; 519| 0| case FLB_LOG_WARN: ------------------ | | 40| 0|#define FLB_LOG_WARN 2 ------------------ | Branch (519:5): [True: 0, False: 2] ------------------ 520| 0| header_title = "warn"; 521| 0| header_color = ANSI_YELLOW; ------------------ | | 51| 0|#define ANSI_YELLOW "\033[93m" ------------------ 522| 0| break; 523| 2| case FLB_LOG_ERROR: ------------------ | | 39| 2|#define FLB_LOG_ERROR 1 ------------------ | Branch (523:5): [True: 2, False: 0] ------------------ 524| 2| header_title = "error"; 525| 2| header_color = ANSI_RED; ------------------ | | 50| 2|#define ANSI_RED "\033[91m" ------------------ 526| 2| break; 527| 0| case FLB_LOG_DEBUG: ------------------ | | 42| 0|#define FLB_LOG_DEBUG 4 ------------------ | Branch (527:5): [True: 0, False: 2] ------------------ 528| 0| header_title = "debug"; 529| 0| header_color = ANSI_YELLOW; ------------------ | | 51| 0|#define ANSI_YELLOW "\033[93m" ------------------ 530| 0| break; 531| 0| case FLB_LOG_IDEBUG: ------------------ | | 46| 0|#define FLB_LOG_IDEBUG 10 ------------------ | Branch (531:5): [True: 0, False: 2] ------------------ 532| 0| header_title = "debug"; 533| 0| header_color = ANSI_CYAN; ------------------ | | 48| 0|#define ANSI_CYAN "\033[96m" ------------------ 534| 0| break; 535| 0| case FLB_LOG_TRACE: ------------------ | | 43| 0|#define FLB_LOG_TRACE 5 ------------------ | Branch (535:5): [True: 0, False: 2] ------------------ 536| 0| header_title = "trace"; 537| 0| header_color = ANSI_BLUE; ------------------ | | 52| 0|#define ANSI_BLUE "\033[94m" ------------------ 538| 0| break; 539| 2| } 540| | 541| | #ifdef FLB_LOG_NO_CONTROL_CHARS 542| | header_color = ""; 543| | bold_color = ""; 544| | reset_color = ""; 545| | #else 546| | /* Only print colors to a terminal */ 547| 2| if (!isatty(STDOUT_FILENO)) { ------------------ | Branch (547:9): [True: 2, False: 0] ------------------ 548| 2| header_color = ""; 549| 2| bold_color = ""; 550| 2| reset_color = ""; 551| 2| } 552| 2| #endif // FLB_LOG_NO_CONTROL_CHARS 553| | 554| 2| now = time(NULL); 555| 2| current = localtime_r(&now, &result); 556| | 557| 2| if (current == NULL) { ------------------ | Branch (557:9): [True: 0, False: 2] ------------------ 558| 0| return -1; 559| 0| } 560| | 561| 2| len = snprintf(msg->msg, sizeof(msg->msg) - 1, 562| 2| "%s[%s%i/%02i/%02i %02i:%02i:%02i%s]%s [%s%5s%s] ", 563| | /* time */ /* type */ 564| | 565| | /* time variables */ 566| 2| bold_color, reset_color, 567| 2| current->tm_year + 1900, 568| 2| current->tm_mon + 1, 569| 2| current->tm_mday, 570| 2| current->tm_hour, 571| 2| current->tm_min, 572| 2| current->tm_sec, 573| 2| bold_color, reset_color, 574| | 575| | /* type format */ 576| 2| header_color, header_title, reset_color); 577| | 578| 2| body_size = (sizeof(msg->msg) - 2) - len; 579| 2| total = vsnprintf(msg->msg + len, 580| 2| body_size, 581| 2| fmt, *args); 582| 2| if (total < 0) { ------------------ | Branch (582:9): [True: 0, False: 2] ------------------ 583| 0| return -1; 584| 0| } 585| 2| ret = total; /* ret means a buffer size need to save log body */ 586| | 587| 2| total = strlen(msg->msg + len) + len; 588| 2| msg->msg[total++] = '\n'; 589| 2| msg->msg[total] = '\0'; 590| 2| msg->size = total; 591| | 592| 2| *ret_len = len; 593| | 594| 2| if (ret >= body_size) { ------------------ | Branch (594:9): [True: 0, False: 2] ------------------ 595| | /* log is truncated */ 596| 0| return ret - body_size; 597| 0| } 598| | 599| 2| return 0; 600| 2|} flb_log_print: 629| 2|{ 630| 2| int n; 631| 2| int len; 632| 2| int ret; 633| 2| struct log_message msg = {0}; 634| 2| va_list args; 635| | 636| 2| struct flb_worker *w; 637| | 638| 2| va_start(args, fmt); 639| 2| ret = flb_log_construct(&msg, &len, type, file, line, fmt, &args); 640| 2| va_end(args); 641| | 642| 2| if (ret < 0) { ------------------ | Branch (642:9): [True: 0, False: 2] ------------------ 643| 0| return; 644| 0| } 645| | 646| 2| w = flb_worker_get(); 647| 2| if (w) { ------------------ | Branch (647:9): [True: 0, False: 2] ------------------ 648| 0| n = flb_pipe_write_all(w->log[1], &msg, sizeof(msg)); 649| 0| if (n == -1) { ------------------ | Branch (649:13): [True: 0, False: 0] ------------------ 650| 0| fprintf(stderr, "%s", (char *) msg.msg); 651| 0| perror("write"); 652| 0| } 653| 0| } 654| 2| else { 655| 2| fprintf(stderr, "%s", (char *) msg.msg); 656| 2| } 657| | 658| | #ifdef FLB_HAVE_AWS_ERROR_REPORTER 659| | if (is_error_reporting_enabled()) { 660| | if (type == FLB_LOG_ERROR) { 661| | flb_aws_error_reporter_write(error_reporter, msg.msg + len); 662| | } 663| | 664| | flb_aws_error_reporter_clean(error_reporter); 665| | } 666| | #endif 667| 2|} flb_errno_print: 670| 2|{ 671| 2| char buf[256]; 672| | 673| 2| strerror_r(errnum, buf, sizeof(buf) - 1); 674| 2| flb_error("[%s:%i errno=%i] %s", file, line, errnum, buf); ------------------ | | 140| 2| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 39| 2|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (140:9): [True: 2, False: 0] | | ------------------ | | 141| 2| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 39| 2|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 675| 2| return 0; 676| 2|} flb_msgpack_to_json: 724| 1.65k|{ 725| 1.65k| int ret = -1; 726| 1.65k| int off = 0; 727| | 728| 1.65k| if (json_str == NULL || obj == NULL) { ------------------ | Branch (728:9): [True: 0, False: 1.65k] | Branch (728:29): [True: 0, False: 1.65k] ------------------ 729| 0| return -1; 730| 0| } 731| | 732| 1.65k| ret = msgpack2json(json_str, &off, json_size - 1, obj); 733| 1.65k| json_str[off] = '\0'; 734| 1.65k| return ret ? off: ret; ------------------ | Branch (734:12): [True: 335, False: 1.32k] ------------------ 735| 1.65k|} flb_msgpack_raw_to_json_sds: 738| 845|{ 739| 845| int ret; 740| 845| size_t off = 0; 741| 845| size_t out_size; 742| 845| size_t realloc_size; 743| | 744| 845| msgpack_unpacked result; 745| 845| msgpack_object *root; 746| 845| flb_sds_t out_buf; 747| 845| flb_sds_t tmp_buf; 748| | 749| | /* buffer size strategy */ 750| 845| out_size = in_size * FLB_MSGPACK_TO_JSON_INIT_BUFFER_SIZE; 751| 845| realloc_size = in_size * FLB_MSGPACK_TO_JSON_REALLOC_BUFFER_SIZE; 752| 845| if (realloc_size < 256) { ------------------ | Branch (752:9): [True: 845, False: 0] ------------------ 753| 845| realloc_size = 256; 754| 845| } 755| | 756| 845| out_buf = flb_sds_create_size(out_size); 757| 845| if (!out_buf) { ------------------ | Branch (757:9): [True: 1, False: 844] ------------------ 758| 1| flb_errno(); ------------------ | | 201| 1|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 759| 1| return NULL; 760| 1| } 761| | 762| 844| msgpack_unpacked_init(&result); 763| 844| ret = msgpack_unpack_next(&result, in_buf, in_size, &off); 764| 844| if (ret != MSGPACK_UNPACK_SUCCESS) { ------------------ | Branch (764:9): [True: 509, False: 335] ------------------ 765| 509| flb_sds_destroy(out_buf); 766| 509| msgpack_unpacked_destroy(&result); 767| 509| return NULL; 768| 509| } 769| | 770| 335| root = &result.data; 771| 1.65k| while (1) { ------------------ | Branch (771:12): [Folded - Ignored] ------------------ 772| 1.65k| ret = flb_msgpack_to_json(out_buf, out_size, root); 773| 1.65k| if (ret <= 0) { ------------------ | Branch (773:13): [True: 1.32k, False: 335] ------------------ 774| 1.32k| tmp_buf = flb_sds_increase(out_buf, realloc_size); 775| 1.32k| if (tmp_buf) { ------------------ | Branch (775:17): [True: 1.32k, False: 0] ------------------ 776| 1.32k| out_buf = tmp_buf; 777| 1.32k| out_size += realloc_size; 778| 1.32k| } 779| 0| else { 780| 0| flb_errno(); ------------------ | | 201| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 781| 0| flb_sds_destroy(out_buf); 782| 0| msgpack_unpacked_destroy(&result); 783| 0| return NULL; 784| 0| } 785| 1.32k| } 786| 335| else { 787| 335| break; 788| 335| } 789| 1.65k| } 790| | 791| 335| msgpack_unpacked_destroy(&result); 792| 335| flb_sds_len_set(out_buf, ret); 793| | 794| 335| return out_buf; 795| 335|} flb_pack.c:msgpack2json: 552| 177k|{ 553| 177k| int i; 554| 177k| int dup; 555| 177k| int ret = FLB_FALSE; ------------------ | | 25| 177k|#define FLB_FALSE 0 ------------------ 556| 177k| int loop; 557| 177k| int packed; 558| | 559| 177k| switch(o->type) { 560| 3.81k| case MSGPACK_OBJECT_NIL: ------------------ | Branch (560:5): [True: 3.81k, False: 173k] ------------------ 561| 3.81k| ret = try_to_write(buf, off, left, "null", 4); 562| 3.81k| break; 563| | 564| 6.18k| case MSGPACK_OBJECT_BOOLEAN: ------------------ | Branch (564:5): [True: 6.18k, False: 171k] ------------------ 565| 6.18k| ret = try_to_write(buf, off, left, 566| 6.18k| (o->via.boolean ? "true":"false"),0); ------------------ | Branch (566:29): [True: 630, False: 5.55k] ------------------ 567| | 568| 6.18k| break; 569| | 570| 66.2k| case MSGPACK_OBJECT_POSITIVE_INTEGER: ------------------ | Branch (570:5): [True: 66.2k, False: 111k] ------------------ 571| 66.2k| { 572| 66.2k| char temp[32] = {0}; 573| 66.2k| i = snprintf(temp, sizeof(temp)-1, "%"PRIu64, o->via.u64); 574| 66.2k| ret = try_to_write(buf, off, left, temp, i); 575| 66.2k| } 576| 66.2k| break; 577| | 578| 48.4k| case MSGPACK_OBJECT_NEGATIVE_INTEGER: ------------------ | Branch (578:5): [True: 48.4k, False: 128k] ------------------ 579| 48.4k| { 580| 48.4k| char temp[32] = {0}; 581| 48.4k| i = snprintf(temp, sizeof(temp)-1, "%"PRId64, o->via.i64); 582| 48.4k| ret = try_to_write(buf, off, left, temp, i); 583| 48.4k| } 584| 48.4k| break; 585| 3.48k| case MSGPACK_OBJECT_FLOAT32: ------------------ | Branch (585:5): [True: 3.48k, False: 173k] ------------------ 586| 3.98k| case MSGPACK_OBJECT_FLOAT64: ------------------ | Branch (586:5): [True: 502, False: 176k] ------------------ 587| 3.98k| { 588| 3.98k| char temp[512] = {0}; 589| 3.98k| if (o->via.f64 == (double)(long long int)o->via.f64) { ------------------ | Branch (589:17): [True: 498, False: 3.48k] ------------------ 590| 498| i = snprintf(temp, sizeof(temp)-1, "%.1f", o->via.f64); 591| 498| } 592| 3.48k| else if (convert_nan_to_null && isnan(o->via.f64) ) { ------------------ | Branch (592:22): [True: 0, False: 3.48k] ------------------ 593| 0| i = snprintf(temp, sizeof(temp)-1, "null"); 594| 0| } 595| 3.48k| else { 596| 3.48k| i = snprintf(temp, sizeof(temp)-1, "%.16g", o->via.f64); 597| 3.48k| } 598| 3.98k| ret = try_to_write(buf, off, left, temp, i); 599| 3.98k| } 600| 3.98k| break; 601| | 602| 11.9k| case MSGPACK_OBJECT_STR: ------------------ | Branch (602:5): [True: 11.9k, False: 165k] ------------------ 603| 11.9k| if (try_to_write(buf, off, left, "\"", 1) && ------------------ | Branch (603:13): [True: 11.9k, False: 24] ------------------ 604| 11.9k| (o->via.str.size > 0 ? ------------------ | Branch (604:13): [True: 11.7k, False: 187] | Branch (604:14): [True: 10.8k, False: 1.11k] ------------------ 605| 10.8k| try_to_write_str(buf, off, left, o->via.str.ptr, o->via.str.size) ------------------ | | 42| 10.8k|#define try_to_write_str flb_utils_write_str ------------------ 606| 11.9k| : 1/* nothing to do */) && 607| 11.9k| try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (607:13): [True: 11.7k, False: 24] ------------------ 608| 11.7k| ret = FLB_TRUE; ------------------ | | 26| 11.7k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 11.7k|#define FLB_FALSE 0 | | ------------------ ------------------ 609| 11.7k| } 610| 11.9k| break; 611| | 612| 2.28k| case MSGPACK_OBJECT_BIN: ------------------ | Branch (612:5): [True: 2.28k, False: 175k] ------------------ 613| 2.28k| if (try_to_write(buf, off, left, "\"", 1) && ------------------ | Branch (613:13): [True: 2.27k, False: 13] ------------------ 614| 2.28k| (o->via.bin.size > 0 ? ------------------ | Branch (614:13): [True: 2.22k, False: 50] | Branch (614:14): [True: 1.46k, False: 812] ------------------ 615| 1.46k| try_to_write_str(buf, off, left, o->via.bin.ptr, o->via.bin.size) ------------------ | | 42| 1.46k|#define try_to_write_str flb_utils_write_str ------------------ 616| 2.27k| : 1 /* nothing to do */) && 617| 2.28k| try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (617:13): [True: 2.21k, False: 13] ------------------ 618| 2.21k| ret = FLB_TRUE; ------------------ | | 26| 2.21k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 2.21k|#define FLB_FALSE 0 | | ------------------ ------------------ 619| 2.21k| } 620| 2.28k| break; 621| | 622| 13.1k| case MSGPACK_OBJECT_EXT: ------------------ | Branch (622:5): [True: 13.1k, False: 164k] ------------------ 623| 13.1k| if (!try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (623:13): [True: 20, False: 13.0k] ------------------ 624| 20| goto msg2json_end; 625| 20| } 626| | /* ext body. fortmat is similar to printf(1) */ 627| 13.0k| { 628| 13.0k| char temp[32] = {0}; 629| 13.0k| int len; 630| 13.0k| loop = o->via.ext.size; 631| 220k| for(i=0; ivia.ext.ptr[i]); 633| 208k| if (!try_to_write(buf, off, left, temp, len)) { ------------------ | Branch (633:21): [True: 524, False: 207k] ------------------ 634| 524| goto msg2json_end; 635| 524| } 636| 208k| } 637| 13.0k| } 638| 12.5k| if (!try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (638:13): [True: 33, False: 12.5k] ------------------ 639| 33| goto msg2json_end; 640| 33| } 641| 12.5k| ret = FLB_TRUE; ------------------ | | 26| 12.5k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 12.5k|#define FLB_FALSE 0 | | ------------------ ------------------ 642| 12.5k| break; 643| | 644| 11.9k| case MSGPACK_OBJECT_ARRAY: ------------------ | Branch (644:5): [True: 11.9k, False: 165k] ------------------ 645| 11.9k| loop = o->via.array.size; 646| | 647| 11.9k| if (!try_to_write(buf, off, left, "[", 1)) { ------------------ | Branch (647:13): [True: 14, False: 11.9k] ------------------ 648| 14| goto msg2json_end; 649| 14| } 650| 11.9k| if (loop != 0) { ------------------ | Branch (650:13): [True: 9.89k, False: 2.02k] ------------------ 651| 9.89k| msgpack_object* p = o->via.array.ptr; 652| 9.89k| if (!msgpack2json(buf, off, left, p)) { ------------------ | Branch (652:17): [True: 1.57k, False: 8.31k] ------------------ 653| 1.57k| goto msg2json_end; 654| 1.57k| } 655| 68.2k| for (i=1; ivia.map.size; 668| 9.45k| if (!try_to_write(buf, off, left, "{", 1)) { ------------------ | Branch (668:13): [True: 22, False: 9.43k] ------------------ 669| 22| goto msg2json_end; 670| 22| } 671| 9.43k| if (loop != 0) { ------------------ | Branch (671:13): [True: 6.78k, False: 2.64k] ------------------ 672| 6.78k| msgpack_object k; 673| 6.78k| msgpack_object_kv *p = o->via.map.ptr; 674| | 675| 6.78k| packed = 0; 676| 6.78k| dup = FLB_FALSE; ------------------ | | 25| 6.78k|#define FLB_FALSE 0 ------------------ 677| | 678| 6.78k| k = o->via.map.ptr[0].key; 679| 58.8k| for (i = 0; i < loop; i++) { ------------------ | Branch (679:25): [True: 53.7k, False: 5.05k] ------------------ 680| 53.7k| k = o->via.map.ptr[i].key; 681| 53.7k| dup = key_exists_in_map(k, *o, i + 1); 682| 53.7k| if (dup == FLB_TRUE) { ------------------ | | 26| 53.7k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 53.7k|#define FLB_FALSE 0 | | ------------------ ------------------ | Branch (682:21): [True: 972, False: 52.8k] ------------------ 683| 972| continue; 684| 972| } 685| | 686| 52.8k| if (packed > 0) { ------------------ | Branch (686:21): [True: 46.0k, False: 6.78k] ------------------ 687| 46.0k| if (!try_to_write(buf, off, left, ",", 1)) { ------------------ | Branch (687:25): [True: 28, False: 45.9k] ------------------ 688| 28| goto msg2json_end; 689| 28| } 690| 46.0k| } 691| | 692| 52.7k| if ( 693| 52.7k| !msgpack2json(buf, off, left, &(p+i)->key) || ------------------ | Branch (693:21): [True: 833, False: 51.9k] ------------------ 694| 52.7k| !try_to_write(buf, off, left, ":", 1) || ------------------ | Branch (694:21): [True: 34, False: 51.9k] ------------------ 695| 52.7k| !msgpack2json(buf, off, left, &(p+i)->val) ) { ------------------ | Branch (695:21): [True: 839, False: 51.0k] ------------------ 696| 1.70k| goto msg2json_end; 697| 1.70k| } 698| 51.0k| packed++; 699| 51.0k| } 700| 6.78k| } 701| | 702| 7.69k| ret = try_to_write(buf, off, left, "}", 1); 703| 7.69k| break; 704| | 705| 0| default: ------------------ | Branch (705:5): [True: 0, False: 177k] ------------------ 706| 0| flb_warn("[%s] unknown msgpack type %i", __FUNCTION__, o->type); ------------------ | | 149| 0| if (flb_log_check(FLB_LOG_WARN)) \ | | ------------------ | | | | 40| 0|#define FLB_LOG_WARN 2 | | ------------------ | | | Branch (149:9): [True: 0, False: 0] | | ------------------ | | 150| 0| flb_log_print(FLB_LOG_WARN, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 0|#define FLB_LOG_WARN 2 | | ------------------ ------------------ 707| 177k| } 708| | 709| 177k| msg2json_end: 710| 177k| return ret; 711| 177k|} flb_pack.c:try_to_write: 506| 588k|{ 507| 588k| if (str_len <= 0){ ------------------ | Branch (507:9): [True: 6.18k, False: 581k] ------------------ 508| 6.18k| str_len = strlen(str); 509| 6.18k| } 510| 588k| if (left <= *off+str_len) { ------------------ | Branch (510:9): [True: 1.08k, False: 587k] ------------------ 511| 1.08k| return FLB_FALSE; ------------------ | | 25| 1.08k|#define FLB_FALSE 0 ------------------ 512| 1.08k| } 513| 587k| memcpy(buf+*off, str, str_len); 514| 587k| *off += str_len; 515| 587k| return FLB_TRUE; ------------------ | | 26| 587k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 587k|#define FLB_FALSE 0 | | ------------------ ------------------ 516| 588k|} flb_pack.c:key_exists_in_map: 524| 53.7k|{ 525| 53.7k| int i; 526| 53.7k| msgpack_object p; 527| | 528| 53.7k| if (key.type != MSGPACK_OBJECT_STR) { ------------------ | Branch (528:9): [True: 46.9k, False: 6.78k] ------------------ 529| 46.9k| return FLB_FALSE; ------------------ | | 25| 46.9k|#define FLB_FALSE 0 ------------------ 530| 46.9k| } 531| | 532| 117k| for (i = offset; i < map.via.map.size; i++) { ------------------ | Branch (532:22): [True: 111k, False: 5.81k] ------------------ 533| 111k| p = map.via.map.ptr[i].key; 534| 111k| if (p.type != MSGPACK_OBJECT_STR) { ------------------ | Branch (534:13): [True: 99.9k, False: 11.8k] ------------------ 535| 99.9k| continue; 536| 99.9k| } 537| | 538| 11.8k| if (key.via.str.size != p.via.str.size) { ------------------ | Branch (538:13): [True: 7.39k, False: 4.43k] ------------------ 539| 7.39k| continue; 540| 7.39k| } 541| | 542| 4.43k| if (memcmp(key.via.str.ptr, p.via.str.ptr, p.via.str.size) == 0) { ------------------ | Branch (542:13): [True: 972, False: 3.46k] ------------------ 543| 972| return FLB_TRUE; ------------------ | | 26| 972|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 972|#define FLB_FALSE 0 | | ------------------ ------------------ 544| 972| } 545| 4.43k| } 546| | 547| 5.81k| return FLB_FALSE; ------------------ | | 25| 5.81k|#define FLB_FALSE 0 ------------------ 548| 6.78k|} flb_sds_create_size: 92| 845|{ 93| 845| return sds_alloc(size); 94| 845|} flb_sds_increase: 98| 1.32k|{ 99| 1.32k| size_t new_size; 100| 1.32k| struct flb_sds *head; 101| 1.32k| flb_sds_t out; 102| 1.32k| void *tmp; 103| | 104| 1.32k| out = s; 105| 1.32k| new_size = (FLB_SDS_HEADER_SIZE + flb_sds_alloc(s) + len + 1); ------------------ | | 34| 1.32k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) ------------------ 106| 1.32k| head = FLB_SDS_HEADER(s); ------------------ | | 46| 1.32k|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 1.32k|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 107| 1.32k| tmp = flb_realloc(head, new_size); 108| 1.32k| if (!tmp) { ------------------ | Branch (108:9): [True: 0, False: 1.32k] ------------------ 109| 0| flb_errno(); ------------------ | | 201| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 110| 0| return NULL; 111| 0| } 112| 1.32k| head = (struct flb_sds *) tmp; 113| 1.32k| head->alloc += len; 114| 1.32k| out = head->buf; 115| | 116| 1.32k| return out; 117| 1.32k|} flb_sds_destroy: 462| 1.35k|{ 463| 1.35k| struct flb_sds *head; 464| | 465| 1.35k| if (!s) { ------------------ | Branch (465:9): [True: 510, False: 844] ------------------ 466| 510| return; 467| 510| } 468| | 469| 844| head = FLB_SDS_HEADER(s); ------------------ | | 46| 844|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 844|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 470| 844| flb_free(head); 471| 844|} flb_sds.c:sds_alloc: 36| 845|{ 37| 845| void *buf; 38| 845| flb_sds_t s; 39| 845| struct flb_sds *head; 40| | 41| 845| buf = flb_malloc(FLB_SDS_HEADER_SIZE + size + 1); ------------------ | | 34| 845|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) ------------------ 42| 845| if (!buf) { ------------------ | Branch (42:9): [True: 1, False: 844] ------------------ 43| 1| flb_errno(); ------------------ | | 201| 1|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 44| 1| return NULL; 45| 1| } 46| | 47| 844| head = buf; 48| 844| head->len = 0; 49| 844| head->alloc = size; 50| | 51| 844| s = head->buf; 52| 844| *s = '\0'; 53| | 54| 844| return s; 55| 845|} flb_utils_write_str: 638| 12.2k|{ 639| 12.2k| int i; 640| 12.2k| int b; 641| 12.2k| int ret; 642| 12.2k| int written = 0; 643| 12.2k| int required; 644| 12.2k| int len; 645| 12.2k| int hex_bytes; 646| 12.2k| int is_valid; 647| 12.2k| int utf_sequence_number; 648| 12.2k| int utf_sequence_length; 649| 12.2k| uint32_t codepoint; 650| 12.2k| uint32_t state = 0; 651| 12.2k| char tmp[16]; 652| 12.2k| size_t available; 653| 12.2k| uint32_t c; 654| 12.2k| char *p; 655| 12.2k| uint8_t *s; 656| | 657| 12.2k| available = (size - *off); 658| 12.2k| required = str_len; 659| 12.2k| if (available <= required) { ------------------ | Branch (659:9): [True: 50, False: 12.2k] ------------------ 660| 50| return FLB_FALSE; ------------------ | | 25| 50|#define FLB_FALSE 0 ------------------ 661| 50| } 662| | 663| 12.2k| p = buf + *off; 664| 146k| for (i = 0; i < str_len; i++) { ------------------ | Branch (664:17): [True: 139k, False: 6.81k] ------------------ 665| 139k| if ((available - written) < 2) { ------------------ | Branch (665:13): [True: 76, False: 139k] ------------------ 666| 76| return FLB_FALSE; ------------------ | | 25| 76|#define FLB_FALSE 0 ------------------ 667| 76| } 668| | 669| 139k| c = (uint32_t) str[i]; 670| 139k| if (c == '\"') { ------------------ | Branch (670:13): [True: 763, False: 138k] ------------------ 671| 763| *p++ = '\\'; 672| 763| *p++ = '\"'; 673| 763| } 674| 138k| else if (c == '\\') { ------------------ | Branch (674:18): [True: 632, False: 137k] ------------------ 675| 632| *p++ = '\\'; 676| 632| *p++ = '\\'; 677| 632| } 678| 137k| else if (c == '\n') { ------------------ | Branch (678:18): [True: 1.27k, False: 136k] ------------------ 679| 1.27k| *p++ = '\\'; 680| 1.27k| *p++ = 'n'; 681| 1.27k| } 682| 136k| else if (c == '\r') { ------------------ | Branch (682:18): [True: 708, False: 135k] ------------------ 683| 708| *p++ = '\\'; 684| 708| *p++ = 'r'; 685| 708| } 686| 135k| else if (c == '\t') { ------------------ | Branch (686:18): [True: 546, False: 135k] ------------------ 687| 546| *p++ = '\\'; 688| 546| *p++ = 't'; 689| 546| } 690| 135k| else if (c == '\b') { ------------------ | Branch (690:18): [True: 628, False: 134k] ------------------ 691| 628| *p++ = '\\'; 692| 628| *p++ = 'b'; 693| 628| } 694| 134k| else if (c == '\f') { ------------------ | Branch (694:18): [True: 639, False: 134k] ------------------ 695| 639| *p++ = '\\'; 696| 639| *p++ = 'f'; 697| 639| } 698| 134k| else if (c < 32 || c == 0x7f) { ------------------ | Branch (698:18): [True: 38.4k, False: 95.6k] | Branch (698:28): [True: 579, False: 95.0k] ------------------ 699| 38.9k| if ((available - written) < 6) { ------------------ | Branch (699:17): [True: 65, False: 38.9k] ------------------ 700| 65| return FLB_FALSE; ------------------ | | 25| 65|#define FLB_FALSE 0 ------------------ 701| 65| } 702| 38.9k| len = snprintf(tmp, sizeof(tmp) - 1, "\\u%.4hhx", (unsigned char) c); 703| 38.9k| if ((available - written) < len) { ------------------ | Branch (703:17): [True: 0, False: 38.9k] ------------------ 704| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 705| 0| } 706| 38.9k| encoded_to_buf(p, tmp, len); 707| 38.9k| p += len; 708| 38.9k| } 709| 95.0k| else if (c >= 0x80 && c <= 0xFFFF) { ------------------ | Branch (709:18): [True: 81.0k, False: 14.0k] | Branch (709:31): [True: 0, False: 81.0k] ------------------ 710| 0| hex_bytes = flb_utf8_len(str + i); 711| 0| if (available - written < 6) { ------------------ | Branch (711:17): [True: 0, False: 0] ------------------ 712| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 713| 0| } 714| | 715| 0| if (i + hex_bytes > str_len) { ------------------ | Branch (715:17): [True: 0, False: 0] ------------------ 716| 0| break; /* skip truncated UTF-8 */ 717| 0| } 718| | 719| 0| state = FLB_UTF8_ACCEPT; ------------------ | | 55| 0|#define FLB_UTF8_ACCEPT 0 ------------------ 720| 0| codepoint = 0; 721| | 722| 0| for (b = 0; b < hex_bytes; b++) { ------------------ | Branch (722:25): [True: 0, False: 0] ------------------ 723| 0| s = (unsigned char *) str + i + b; 724| 0| ret = flb_utf8_decode(&state, &codepoint, *s); 725| 0| if (ret == 0) { ------------------ | Branch (725:21): [True: 0, False: 0] ------------------ 726| 0| break; 727| 0| } 728| 0| } 729| | 730| 0| if (state != FLB_UTF8_ACCEPT) { ------------------ | | 55| 0|#define FLB_UTF8_ACCEPT 0 ------------------ | Branch (730:17): [True: 0, False: 0] ------------------ 731| | /* Invalid UTF-8 hex, just skip utf-8 bytes */ 732| 0| flb_warn("[pack] invalid UTF-8 bytes found, skipping bytes"); ------------------ | | 149| 0| if (flb_log_check(FLB_LOG_WARN)) \ | | ------------------ | | | | 40| 0|#define FLB_LOG_WARN 2 | | ------------------ | | | Branch (149:9): [True: 0, False: 0] | | ------------------ | | 150| 0| flb_log_print(FLB_LOG_WARN, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 0|#define FLB_LOG_WARN 2 | | ------------------ ------------------ 733| 0| } 734| 0| else { 735| 0| len = snprintf(tmp, sizeof(tmp) - 1, "\\u%.4x", codepoint); 736| 0| if ((available - written) < len) { ------------------ | Branch (736:21): [True: 0, False: 0] ------------------ 737| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 738| 0| } 739| 0| encoded_to_buf(p, tmp, len); 740| 0| p += len; 741| 0| } 742| 0| i += (hex_bytes - 1); 743| 0| } 744| 95.0k| else if (c > 0xFFFF) { ------------------ | Branch (744:18): [True: 81.0k, False: 14.0k] ------------------ 745| 81.0k| utf_sequence_length = flb_utf8_len(str + i); 746| | 747| 81.0k| if (i + utf_sequence_length > str_len) { ------------------ | Branch (747:17): [True: 5.22k, False: 75.7k] ------------------ 748| 5.22k| break; /* skip truncated UTF-8 */ 749| 5.22k| } 750| | 751| 75.7k| is_valid = FLB_TRUE; ------------------ | | 26| 75.7k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 75.7k|#define FLB_FALSE 0 | | ------------------ ------------------ 752| 116k| for (utf_sequence_number = 0; utf_sequence_number < utf_sequence_length; ------------------ | Branch (752:43): [True: 113k, False: 2.92k] ------------------ 753| 113k| utf_sequence_number++) { 754| | /* Leading characters must start with bits 11 */ 755| 113k| if (utf_sequence_number == 0 && ((str[i] & 0xC0) != 0xC0)) { ------------------ | Branch (755:21): [True: 75.7k, False: 37.8k] | Branch (755:49): [True: 42.6k, False: 33.1k] ------------------ 756| | /* Invalid unicode character. replace */ 757| 42.6k| flb_debug("[pack] unexpected UTF-8 leading byte, " ------------------ | | 167| 42.6k| if (flb_log_check(FLB_LOG_DEBUG)) \ | | ------------------ | | | | 42| 42.6k|#define FLB_LOG_DEBUG 4 | | ------------------ | | | Branch (167:9): [True: 0, False: 42.6k] | | ------------------ | | 168| 42.6k| flb_log_print(FLB_LOG_DEBUG, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 42| 0|#define FLB_LOG_DEBUG 4 | | ------------------ ------------------ 758| 42.6k| "substituting character with replacement character"); 759| 42.6k| tmp[utf_sequence_number] = str[i]; 760| 42.6k| ++i; /* Consume invalid leading byte */ 761| 42.6k| utf_sequence_length = utf_sequence_number + 1; 762| 42.6k| is_valid = FLB_FALSE; ------------------ | | 25| 42.6k|#define FLB_FALSE 0 ------------------ 763| 42.6k| break; 764| 42.6k| } 765| | /* Trailing characters must start with bits 10 */ 766| 71.0k| else if (utf_sequence_number > 0 && ((str[i] & 0xC0) != 0x80)) { ------------------ | Branch (766:26): [True: 37.8k, False: 33.1k] | Branch (766:53): [True: 30.2k, False: 7.59k] ------------------ 767| | /* Invalid unicode character. replace */ 768| 30.2k| flb_debug("[pack] unexpected UTF-8 continuation byte, " ------------------ | | 167| 30.2k| if (flb_log_check(FLB_LOG_DEBUG)) \ | | ------------------ | | | | 42| 30.2k|#define FLB_LOG_DEBUG 4 | | ------------------ | | | Branch (167:9): [True: 0, False: 30.2k] | | ------------------ | | 168| 30.2k| flb_log_print(FLB_LOG_DEBUG, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 42| 0|#define FLB_LOG_DEBUG 4 | | ------------------ ------------------ 769| 30.2k| "substituting character with replacement character"); 770| | /* This byte, i, is the start of the next unicode character */ 771| 30.2k| utf_sequence_length = utf_sequence_number; 772| 30.2k| is_valid = FLB_FALSE; ------------------ | | 25| 30.2k|#define FLB_FALSE 0 ------------------ 773| 30.2k| break; 774| 30.2k| } 775| | 776| 40.7k| tmp[utf_sequence_number] = str[i]; 777| 40.7k| ++i; 778| 40.7k| } 779| 75.7k| --i; 780| | 781| 75.7k| if (is_valid) { ------------------ | Branch (781:17): [True: 2.92k, False: 72.8k] ------------------ 782| 2.92k| if (available - written < utf_sequence_length) { ------------------ | Branch (782:21): [True: 11, False: 2.91k] ------------------ 783| 11| return FLB_FALSE; ------------------ | | 25| 11|#define FLB_FALSE 0 ------------------ 784| 11| } 785| | 786| 2.91k| encoded_to_buf(p, tmp, utf_sequence_length); 787| 2.91k| p += utf_sequence_length; 788| 2.91k| } 789| 72.8k| else { 790| 72.8k| if (available - written < utf_sequence_length * 3) { ------------------ | Branch (790:21): [True: 35, False: 72.8k] ------------------ 791| 35| return FLB_FALSE; ------------------ | | 25| 35|#define FLB_FALSE 0 ------------------ 792| 35| } 793| | 794| | /* 795| | * Utf-8 sequence is invalid. Map fragments to private use area 796| | * codepoints in range: 797| | * 0x00 to 798| | * 0xFF 799| | */ 800| 148k| for (b = 0; b < utf_sequence_length; ++b) { ------------------ | Branch (800:29): [True: 75.5k, False: 72.8k] ------------------ 801| | /* 802| | * Utf-8 private block invalid hex mapping. Format unicode charpoint 803| | * in the following format: 804| | * 805| | * +--------+--------+--------+ 806| | * |1110PPPP|10PPPPHH|10HHHHHH| 807| | * +--------+--------+--------+ 808| | * 809| | * Where: 810| | * P is FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR bits (1 byte) 811| | * H is Utf-8 fragment hex bits (1 byte) 812| | * 1 is bit 1 813| | * 0 is bit 0 814| | */ 815| | 816| | /* unicode codepoint start */ 817| 75.5k| *p = 0xE0; 818| | 819| | /* print unicode private block header first 4 bits */ 820| 75.5k| *p |= FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR >> 4; ------------------ | | 55| 75.5k|#define FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR 0xE0 ------------------ 821| 75.5k| ++p; 822| | 823| | /* unicode codepoint middle */ 824| 75.5k| *p = 0x80; 825| | 826| | /* print end of unicode private block header last 4 bits */ 827| 75.5k| *p |= ((FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR << 2) & 0x3f); ------------------ | | 55| 75.5k|#define FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR 0xE0 ------------------ 828| | 829| | /* print hex fragment first 2 bits */ 830| 75.5k| *p |= (tmp[b] >> 6) & 0x03; 831| 75.5k| ++p; 832| | 833| | /* unicode codepoint middle */ 834| 75.5k| *p = 0x80; 835| | 836| | /* print hex fragment last 6 bits */ 837| 75.5k| *p |= tmp[b] & 0x3f; 838| 75.5k| ++p; 839| 75.5k| } 840| 72.8k| } 841| 75.7k| } 842| 14.0k| else { 843| 14.0k| *p++ = c; 844| 14.0k| } 845| 133k| written = (p - (buf + *off)); 846| 133k| } 847| | 848| 12.0k| *off += written; 849| | 850| 12.0k| return FLB_TRUE; ------------------ | | 26| 12.0k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 12.0k|#define FLB_FALSE 0 | | ------------------ ------------------ 851| 12.2k|} flb_utils.c:encoded_to_buf: 622| 41.8k|{ 623| 41.8k| int i; 624| 41.8k| char *p = out; 625| | 626| 283k| for (i = 0; i < len; i++) { ------------------ | Branch (626:17): [True: 241k, False: 41.8k] ------------------ 627| 241k| *p++ = in[i]; 628| 241k| } 629| 41.8k|} flb_worker_get: 135| 2|{ 136| 2| return FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 2|#define FLB_TLS_GET(key) key ------------------ 137| 2|} LLVMFuzzerTestOneInput: 6| 945|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size){ 7| | /* Set flb_malloc_mod to be fuzzer-data dependent */ 8| 945| if (size < 4) { ------------------ | Branch (8:9): [True: 2, False: 943] ------------------ 9| 2| return 0; 10| 2| } 11| 943| flb_malloc_p = 0; 12| 943| flb_malloc_mod = *(int*)data; 13| 943| data += 4; 14| 943| size -= 4; 15| | 16| | /* Avoid division by zero for modulo operations */ 17| 943| if (flb_malloc_mod == 0) { ------------------ | Branch (17:9): [True: 2, False: 941] ------------------ 18| 2| flb_malloc_mod = 1; 19| 2| } 20| | 21| 943| if (size != 512) ------------------ | Branch (21:9): [True: 98, False: 845] ------------------ 22| 98| return 0; 23| | 24| | /* target the conversion of raw msgpack to json */ 25| 845| flb_sds_t record; 26| 845| record = flb_msgpack_raw_to_json_sds(data, size); 27| 845| flb_sds_destroy(record); 28| | 29| 845| return 0; 30| 943|}