flb_utils.c:flb_log_check: 103| 60.8k|static inline int flb_log_check(int l) { 104| 60.8k| struct flb_worker *w; 105| 60.8k| w = (struct flb_worker *) FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 60.8k|#define FLB_TLS_GET(key) key ------------------ 106| 60.8k| if (!w && l <= 3) { ------------------ | Branch (106:9): [True: 60.8k, False: 0] | Branch (106:15): [True: 0, False: 60.8k] ------------------ 107| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 108| 0| } 109| | 110| 60.8k| if (w == NULL || flb_worker_log_level(w) < l) { ------------------ | Branch (110:9): [True: 60.8k, False: 0] | Branch (110:22): [True: 0, False: 0] ------------------ 111| 60.8k| return FLB_FALSE; ------------------ | | 25| 60.8k|#define FLB_FALSE 0 ------------------ 112| 60.8k| } 113| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 114| 60.8k|} flb_log.c:flb_log_check: 103| 2|static inline int flb_log_check(int l) { 104| 2| struct flb_worker *w; 105| 2| w = (struct flb_worker *) FLB_TLS_GET(flb_worker_ctx); ------------------ | | 34| 2|#define FLB_TLS_GET(key) key ------------------ 106| 2| if (!w && l <= 3) { ------------------ | Branch (106:9): [True: 2, False: 0] | Branch (106:15): [True: 2, False: 0] ------------------ 107| 2| return FLB_TRUE; ------------------ | | 26| 2|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 2|#define FLB_FALSE 0 | | ------------------ ------------------ 108| 2| } 109| | 110| 0| if (w == NULL || flb_worker_log_level(w) < l) { ------------------ | Branch (110:9): [True: 0, False: 0] | Branch (110:22): [True: 0, False: 0] ------------------ 111| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 112| 0| } 113| 0| return FLB_TRUE; ------------------ | | 26| 0|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 0|#define FLB_FALSE 0 | | ------------------ ------------------ 114| 0|} flb_sds.c:flb_malloc: 67| 802|void *flb_malloc(const size_t size) { 68| | 69| 802|#ifdef FLB_HAVE_TESTS_OSSFUZZ 70| | // 1% chance of failure 71| 802| if (flb_fuzz_get_probability(1)) { ------------------ | Branch (71:8): [True: 1, False: 801] ------------------ 72| 1| return NULL; 73| 1| } 74| 801|#endif 75| | 76| 801| if (size == 0) { ------------------ | Branch (76:9): [True: 0, False: 801] ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 801| return malloc(size); 81| 801|} flb_sds.c:flb_fuzz_get_probability: 56| 802|static inline int flb_fuzz_get_probability(int val) { 57| 802| flb_malloc_p += 1; 58| 802| flb_malloc_p = flb_malloc_p % flb_malloc_mod; 59| 802| if (val > flb_malloc_p) { ------------------ | Branch (59:7): [True: 1, False: 801] ------------------ 60| 1| return 1; 61| 1| } 62| 801| return 0; 63| 802|} flb_sds.c:flb_realloc: 100| 559|{ 101| 559| return realloc(ptr, size); 102| 559|} flb_sds.c:flb_free: 126| 801|static inline void flb_free(void *ptr) { 127| 801| free(ptr); 128| 801|} flb_pack.c:flb_sds_alloc: 68| 559|{ 69| 559| return (size_t) FLB_SDS_HEADER(s)->alloc; ------------------ | | 46| 559|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 559|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 70| 559|} flb_pack.c:flb_sds_len_set: 63| 321|{ 64| 321| FLB_SDS_HEADER(s)->len = len; ------------------ | | 46| 321|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 321|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 65| 321|} flb_sds.c:flb_sds_alloc: 68| 559|{ 69| 559| return (size_t) FLB_SDS_HEADER(s)->alloc; ------------------ | | 46| 559|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 559|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 70| 559|} flb_utils.c:flb_vector8_load: 92| 102k|{ 93| |#if defined(FLB_SIMD_SSE2) 94| | *v = _mm_loadu_si128((const __m128i *) s); 95| |#elif defined(FLB_SIMD_NEON) 96| | *v = vld1q_u8(s); 97| |#else 98| 102k| memset(v, 0, sizeof(flb_vector8)); 99| 102k|#endif 100| 102k|} flb_utils.c:flb_vector8_has_le: 207| 102k|{ 208| 102k| bool result = false; 209| | 210| 102k|#if defined(FLB_SIMD_NONE) 211| | /* 212| | * To find bytes <= c, we can use bitwise operations to find bytes < c+1, 213| | * but it only works if c+1 <= 128 and if the highest bit in v is not set. 214| | * 215| | * Adapted from 216| | * 217| | * https://graphics.stanford.edu/~seander/bithacks.html#HasLessInWord 218| | */ 219| 102k| if ((int64_t) v >= 0 && c < 0x80) { ------------------ | Branch (219:6): [True: 102k, False: 0] | Branch (219:26): [True: 102k, False: 0] ------------------ 220| 102k| result = (v - flb_vector8_broadcast(c + 1)) & ~v & flb_vector8_broadcast(0x80); 221| 102k| } 222| 0| else { 223| 0| size_t i; 224| 0| for (i = 0; i < sizeof(flb_vector8); i++) { ------------------ | Branch (224:16): [True: 0, False: 0] ------------------ 225| 0| if (((const uint8_t *) &v)[i] <= c) { ------------------ | Branch (225:8): [True: 0, False: 0] ------------------ 226| 0| result = true; 227| 0| break; 228| 0| } 229| 0| } 230| 0| } 231| | 232| 102k| return result; 233| |#else 234| | /* 235| | * Use saturating subtraction to find bytes <= c, which will present as 236| | * NUL bytes. This approach is a workaround for the lack of unsigned 237| | * comparison instructions on some architectures. 238| | */ 239| | result = flb_vector8_has_zero(flb_vector8_ssub(v, flb_vector8_broadcast(c))); 240| |#endif 241| | 242| 0| return result; 243| 102k|} flb_utils.c:flb_vector8_broadcast: 166| 204k|{ 167| |#if defined(FLB_SIMD_SSE2) 168| | return _mm_set1_epi8(c); 169| |#elif defined(FLB_SIMD_NEON) 170| | return vdupq_n_u8(c); 171| |#else 172| 204k| return ~UINT64CONST(0) / 0xFF * c; ------------------ | | 27| 204k|#define UINT64CONST(x) (x##ULL) ------------------ 173| 204k|#endif 174| 204k|} flb_pack.c:msgpack_unpacked_init: 253| 801|{ 254| 801| memset(result, 0, sizeof(msgpack_unpacked)); 255| 801|} flb_pack.c:msgpack_unpacked_destroy: 258| 801|{ 259| 801| if(result->zone != NULL) { ------------------ | Branch (259:8): [True: 692, False: 109] ------------------ 260| 692| msgpack_zone_free(result->zone); 261| 692| result->zone = NULL; 262| 692| memset(&result->data, 0, sizeof(msgpack_object)); 263| 692| } 264| 801|} unpack.c:msgpack_unpacked_destroy: 258| 801|{ 259| 801| if(result->zone != NULL) { ------------------ | Branch (259:8): [True: 0, False: 801] ------------------ 260| 0| msgpack_zone_free(result->zone); 261| 0| result->zone = NULL; 262| 0| memset(&result->data, 0, sizeof(msgpack_object)); 263| 0| } 264| 801|} unpack.c:template_init: 68| 801|{ 69| 801| ctx->cs = MSGPACK_CS_HEADER; 70| 801| ctx->trail = 0; 71| 801| ctx->top = 0; 72| | /* 73| | ctx->stack = ctx->embed_stack; 74| | ctx->stack_size = MSGPACK_EMBED_STACK_SIZE; 75| | */ 76| 801| ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user); ------------------ | | 33| 801| template_callback ## name ------------------ 77| 801|} unpack.c:template_execute: 95| 801|{ 96| 801| assert(len >= *off); 97| 801| { 98| 801| const unsigned char* p = (unsigned char*)data + *off; 99| 801| const unsigned char* const pe = (unsigned char*)data + len; 100| 801| const void* n = NULL; 101| | 102| 801| unsigned int trail = ctx->trail; 103| 801| unsigned int cs = ctx->cs; 104| 801| unsigned int top = ctx->top; 105| 801| msgpack_unpack_struct(_stack)* stack = ctx->stack; ------------------ | | 27| 801| struct template ## name ------------------ 106| | /* 107| | unsigned int stack_size = ctx->stack_size; 108| | */ 109| 801| msgpack_unpack_user* user = &ctx->user; ------------------ | | 37| 801|#define msgpack_unpack_user unpack_user ------------------ 110| | 111| 801| msgpack_unpack_object obj; ------------------ | | 35| 801|#define msgpack_unpack_object msgpack_object ------------------ 112| 801| msgpack_unpack_struct(_stack)* c = NULL; ------------------ | | 27| 801| struct template ## name ------------------ 113| | 114| 801| int ret; 115| | 116| 801|#define push_simple_value(func) \ 117| 801| ret = msgpack_unpack_callback(func)(user, &obj); \ 118| 801| if(ret < 0) { goto _failed; } \ 119| 801| goto _push 120| 801|#define push_fixed_value(func, arg) \ 121| 801| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ 122| 801| if(ret < 0) { goto _failed; } \ 123| 801| goto _push 124| 801|#define push_variable_value(func, base, pos, len) \ 125| 801| ret = msgpack_unpack_callback(func)(user, \ 126| 801| (const char*)base, (const char*)pos, len, &obj); \ 127| 801| if(ret < 0) { goto _failed; } \ 128| 801| goto _push 129| | 130| 801|#define again_fixed_trail(_cs, trail_len) \ 131| 801| trail = trail_len; \ 132| 801| cs = _cs; \ 133| 801| goto _fixed_trail_again 134| 801|#define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \ 135| 801| trail = trail_len; \ 136| 801| if(trail == 0) { goto ifzero; } \ 137| 801| cs = _cs; \ 138| 801| goto _fixed_trail_again 139| | 140| 801|#define start_container(func, count_, ct_) \ 141| 801| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ 142| 801| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ 143| 801| goto _failed; \ 144| 801| } /* FIXME */ \ 145| 801| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ 146| 801| if(ret < 0) { goto _failed; } \ 147| 801| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ 148| 801| stack[top].ct = ct_; \ 149| 801| stack[top].count = count_; \ 150| 801| ++top; \ 151| 801| goto _header_again 152| | 153| 801|#define NEXT_CS(p) \ 154| 801| ((unsigned int)*p & 0x1f) 155| | 156| 801|#ifdef USE_CASE_RANGE 157| 801|#define SWITCH_RANGE_BEGIN switch(*p) { 158| 801|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: 159| 801|#define SWITCH_RANGE_DEFAULT default: 160| 801|#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| 801| if(p == pe) { goto _out; } ------------------ | Branch (168:12): [True: 0, False: 801] ------------------ 169| 142k| do { 170| 142k| switch(cs) { 171| 142k| case MSGPACK_CS_HEADER: ------------------ | Branch (171:13): [True: 142k, False: 0] ------------------ 172| 142k| SWITCH_RANGE_BEGIN ------------------ | | 157| 284k|#define SWITCH_RANGE_BEGIN switch(*p) { ------------------ 173| 45.4k| SWITCH_RANGE(0x00, 0x7f) // Positive Fixnum ------------------ | | 158| 45.4k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 45.4k, False: 96.8k] | | ------------------ ------------------ 174| 45.4k| push_fixed_value(_uint8, *(uint8_t*)p); ------------------ | | 121| 45.4k| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 45.4k| template_callback ## name | | ------------------ | | 122| 45.4k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 45.4k] | | ------------------ | | 123| 45.4k| goto _push ------------------ 175| 45.4k| SWITCH_RANGE(0xe0, 0xff) // Negative Fixnum ------------------ | | 158| 45.2k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 45.2k, False: 97.0k] | | ------------------ ------------------ 176| 45.2k| push_fixed_value(_int8, *(int8_t*)p); ------------------ | | 121| 45.2k| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 45.2k| template_callback ## name | | ------------------ | | 122| 45.2k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 45.2k] | | ------------------ | | 123| 45.2k| goto _push ------------------ 177| 45.2k| SWITCH_RANGE(0xc0, 0xdf) // Variable ------------------ | | 158| 23.8k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 23.8k, False: 118k] | | ------------------ ------------------ 178| 23.8k| switch(*p) { 179| 2.23k| case 0xc0: // nil ------------------ | Branch (179:21): [True: 2.23k, False: 21.6k] ------------------ 180| 2.23k| push_simple_value(_nil); ------------------ | | 117| 2.23k| ret = msgpack_unpack_callback(func)(user, &obj); \ | | ------------------ | | | | 33| 2.23k| template_callback ## name | | ------------------ | | 118| 2.23k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (118:12): [True: 0, False: 2.23k] | | ------------------ | | 119| 2.23k| goto _push ------------------ 181| | //case 0xc1: // string 182| | // again_terminal_trail(NEXT_CS(p), p+1); 183| 2.78k| case 0xc2: // false ------------------ | Branch (183:21): [True: 2.78k, False: 21.0k] ------------------ 184| 2.78k| push_simple_value(_false); ------------------ | | 117| 2.78k| ret = msgpack_unpack_callback(func)(user, &obj); \ | | ------------------ | | | | 33| 2.78k| template_callback ## name | | ------------------ | | 118| 2.78k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (118:12): [True: 0, False: 2.78k] | | ------------------ | | 119| 2.78k| goto _push ------------------ 185| 2.78k| case 0xc3: // true ------------------ | Branch (185:21): [True: 1.47k, False: 22.4k] ------------------ 186| 1.47k| push_simple_value(_true); ------------------ | | 117| 1.47k| ret = msgpack_unpack_callback(func)(user, &obj); \ | | ------------------ | | | | 33| 1.47k| template_callback ## name | | ------------------ | | 118| 1.47k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (118:12): [True: 0, False: 1.47k] | | ------------------ | | 119| 1.47k| goto _push ------------------ 187| 1.47k| case 0xc4: // bin 8 ------------------ | Branch (187:21): [True: 1.05k, False: 22.8k] ------------------ 188| 1.54k| case 0xc5: // bin 16 ------------------ | Branch (188:21): [True: 491, False: 23.3k] ------------------ 189| 1.95k| case 0xc6: // bin 32 ------------------ | Branch (189:21): [True: 401, False: 23.4k] ------------------ 190| 1.95k| again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); ------------------ | | 131| 1.95k| trail = trail_len; \ | | 132| 1.95k| cs = _cs; \ | | 133| 1.95k| goto _fixed_trail_again ------------------ 191| 303| case 0xc7: // ext 8 ------------------ | Branch (191:21): [True: 303, False: 23.5k] ------------------ 192| 543| case 0xc8: // ext 16 ------------------ | Branch (192:21): [True: 240, False: 23.6k] ------------------ 193| 800| case 0xc9: // ext 32 ------------------ | Branch (193:21): [True: 257, False: 23.6k] ------------------ 194| 800| again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) + 1) & 0x03)); ------------------ | | 131| 800| trail = trail_len; \ | | 132| 800| cs = _cs; \ | | 133| 800| goto _fixed_trail_again ------------------ 195| 769| case 0xca: // float ------------------ | Branch (195:21): [True: 769, False: 23.1k] ------------------ 196| 1.09k| case 0xcb: // double ------------------ | Branch (196:21): [True: 326, False: 23.5k] ------------------ 197| 1.84k| case 0xcc: // unsigned int 8 ------------------ | Branch (197:21): [True: 752, False: 23.1k] ------------------ 198| 2.21k| case 0xcd: // unsigned int 16 ------------------ | Branch (198:21): [True: 365, False: 23.5k] ------------------ 199| 2.43k| case 0xce: // unsigned int 32 ------------------ | Branch (199:21): [True: 226, False: 23.6k] ------------------ 200| 2.56k| case 0xcf: // unsigned int 64 ------------------ | Branch (200:21): [True: 130, False: 23.7k] ------------------ 201| 3.78k| case 0xd0: // signed int 8 ------------------ | Branch (201:21): [True: 1.21k, False: 22.6k] ------------------ 202| 4.72k| case 0xd1: // signed int 16 ------------------ | Branch (202:21): [True: 946, False: 22.9k] ------------------ 203| 5.49k| case 0xd2: // signed int 32 ------------------ | Branch (203:21): [True: 762, False: 23.1k] ------------------ 204| 6.44k| case 0xd3: // signed int 64 ------------------ | Branch (204:21): [True: 950, False: 22.9k] ------------------ 205| 6.44k| again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); ------------------ | | 131| 6.44k| trail = trail_len; \ | | 132| 6.44k| cs = _cs; \ | | 133| 6.44k| goto _fixed_trail_again ------------------ 206| 801| case 0xd4: // fixext 1 ------------------ | Branch (206:21): [True: 801, False: 23.0k] ------------------ 207| 1.22k| case 0xd5: // fixext 2 ------------------ | Branch (207:21): [True: 420, False: 23.4k] ------------------ 208| 2.34k| case 0xd6: // fixext 4 ------------------ | Branch (208:21): [True: 1.12k, False: 22.7k] ------------------ 209| 2.77k| case 0xd7: // fixext 8 ------------------ | Branch (209:21): [True: 431, False: 23.4k] ------------------ 210| 2.77k| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, ------------------ | | 135| 2.77k| trail = trail_len; \ | | 136| 2.77k| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 2.77k] | | ------------------ | | 137| 2.77k| cs = _cs; \ | | 138| 2.77k| goto _fixed_trail_again ------------------ 211| 2.77k| (1 << (((unsigned int)*p) & 0x03)) + 1, _ext_zero); 212| 806| case 0xd8: // fixext 16 ------------------ | Branch (212:21): [True: 806, False: 23.0k] ------------------ 213| 806| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, 16+1, _ext_zero); ------------------ | | 135| 806| trail = trail_len; \ | | 136| 806| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 806] | | ------------------ | | 137| 806| cs = _cs; \ | | 138| 806| goto _fixed_trail_again ------------------ 214| | 215| 497| case 0xd9: // str 8 ------------------ | Branch (215:21): [True: 497, False: 23.3k] ------------------ 216| 1.02k| case 0xda: // str 16 ------------------ | Branch (216:21): [True: 526, False: 23.3k] ------------------ 217| 1.48k| case 0xdb: // str 32 ------------------ | Branch (217:21): [True: 461, False: 23.4k] ------------------ 218| 1.48k| again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1)); ------------------ | | 131| 1.48k| trail = trail_len; \ | | 132| 1.48k| cs = _cs; \ | | 133| 1.48k| goto _fixed_trail_again ------------------ 219| 883| case 0xdc: // array 16 ------------------ | Branch (219:21): [True: 883, False: 22.9k] ------------------ 220| 1.43k| case 0xdd: // array 32 ------------------ | Branch (220:21): [True: 550, False: 23.3k] ------------------ 221| 2.66k| case 0xde: // map 16 ------------------ | Branch (221:21): [True: 1.22k, False: 22.6k] ------------------ 222| 3.12k| case 0xdf: // map 32 ------------------ | Branch (222:21): [True: 465, False: 23.4k] ------------------ 223| 3.12k| again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01)); ------------------ | | 131| 3.12k| trail = trail_len; \ | | 132| 3.12k| cs = _cs; \ | | 133| 3.12k| goto _fixed_trail_again ------------------ 224| 4| default: ------------------ | Branch (224:21): [True: 4, False: 23.8k] ------------------ 225| 4| ret = MSGPACK_UNPACK_PARSE_ERROR; 226| 4| goto _failed; 227| 23.8k| } 228| 10.9k| SWITCH_RANGE(0xa0, 0xbf) // FixStr ------------------ | | 158| 10.9k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 10.9k, False: 131k] | | ------------------ ------------------ 229| 10.9k| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero); ------------------ | | 135| 10.9k| trail = trail_len; \ | | 136| 10.9k| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 2.47k, False: 8.45k] | | ------------------ | | 137| 10.9k| cs = _cs; \ | | 138| 8.45k| goto _fixed_trail_again ------------------ 230| 8.45k| SWITCH_RANGE(0x90, 0x9f) // FixArray ------------------ | | 158| 8.45k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 8.45k, False: 133k] | | ------------------ ------------------ 231| 16.8k| start_container(_array, ((unsigned int)*p) & 0x0f, MSGPACK_CT_ARRAY_ITEM); ------------------ | | 141| 8.45k| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 8.45k|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 16, False: 8.43k] | | ------------------ | | 142| 16| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 16| goto _failed; \ | | 144| 16| } /* FIXME */ \ | | 145| 8.45k| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 8.43k| template_callback ## name | | ------------------ | | 146| 8.43k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 8.43k] | | ------------------ | | 147| 8.43k| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 1.68k, False: 6.75k] | | ------------------ | | 148| 8.43k| stack[top].ct = ct_; \ | | 149| 6.75k| stack[top].count = count_; \ | | 150| 6.75k| ++top; \ | | 151| 6.75k| goto _header_again ------------------ 232| 8.32k| SWITCH_RANGE(0x80, 0x8f) // FixMap ------------------ | | 158| 8.32k|#define SWITCH_RANGE(FROM, TO) case FROM ... TO: | | ------------------ | | | Branch (158:32): [True: 8.32k, False: 133k] | | ------------------ ------------------ 233| 16.6k| start_container(_map, ((unsigned int)*p) & 0x0f, MSGPACK_CT_MAP_KEY); ------------------ | | 141| 8.32k| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 8.32k|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 22, False: 8.30k] | | ------------------ | | 142| 22| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 22| goto _failed; \ | | 144| 22| } /* FIXME */ \ | | 145| 8.32k| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 8.30k| template_callback ## name | | ------------------ | | 146| 8.30k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 8.30k] | | ------------------ | | 147| 8.30k| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 2.25k, False: 6.05k] | | ------------------ | | 148| 8.30k| stack[top].ct = ct_; \ | | 149| 6.05k| stack[top].count = count_; \ | | 150| 6.05k| ++top; \ | | 151| 6.05k| goto _header_again ------------------ 234| | 235| 0| SWITCH_RANGE_DEFAULT ------------------ | | 159| 0|#define SWITCH_RANGE_DEFAULT default: | | ------------------ | | | Branch (159:32): [True: 0, False: 142k] | | ------------------ ------------------ 236| 0| ret = MSGPACK_UNPACK_PARSE_ERROR; 237| 0| goto _failed; 238| 142k| SWITCH_RANGE_END ------------------ | | 160| 142k|#define SWITCH_RANGE_END } ------------------ 239| | // end MSGPACK_CS_HEADER 240| | 241| | 242| 28.2k| _fixed_trail_again: 243| 28.2k| ++p; 244| | // fallthrough 245| | 246| 28.2k| default: ------------------ | Branch (246:13): [True: 0, False: 142k] ------------------ 247| 28.2k| if((size_t)(pe - p) < trail) { goto _out; } ------------------ | Branch (247:20): [True: 294, False: 27.9k] ------------------ 248| 27.9k| n = p; p += trail - 1; 249| 27.9k| switch(cs) { 250| | //case MSGPACK_CS_ 251| | //case MSGPACK_CS_ 252| 766| case MSGPACK_CS_FLOAT: { ------------------ | Branch (252:17): [True: 766, False: 27.1k] ------------------ 253| 766| union { uint32_t i; float f; } mem; 254| 766| _msgpack_load32(uint32_t, n, &mem.i); ------------------ | | 172| 766|#define _msgpack_load32(cast, from, to) do { \ | | 173| 766| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 766| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 766|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 766| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 255| 766| push_fixed_value(_float, mem.f); } ------------------ | | 121| 766| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 766| template_callback ## name | | ------------------ | | 122| 766| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 766] | | ------------------ | | 123| 766| goto _push ------------------ 256| 766| case MSGPACK_CS_DOUBLE: { ------------------ | Branch (256:17): [True: 325, False: 27.6k] ------------------ 257| 325| union { uint64_t i; double f; } mem; 258| 325| _msgpack_load64(uint64_t, n, &mem.i); ------------------ | | 176| 325|#define _msgpack_load64(cast, from, to) do { \ | | 177| 325| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 178| 325| *(to) = (cast)_msgpack_be64(*(to)); \ | | ------------------ | | | | 142| 325|# define _msgpack_be64(x) bswap_64(x) | | ------------------ | | 179| 325| } 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| 325| push_fixed_value(_double, mem.f); } ------------------ | | 121| 325| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 325| template_callback ## name | | ------------------ | | 122| 325| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 325] | | ------------------ | | 123| 325| goto _push ------------------ 266| 752| case MSGPACK_CS_UINT_8: ------------------ | Branch (266:17): [True: 752, False: 27.2k] ------------------ 267| 752| push_fixed_value(_uint8, *(uint8_t*)n); ------------------ | | 121| 752| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 752| template_callback ## name | | ------------------ | | 122| 752| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 752] | | ------------------ | | 123| 752| goto _push ------------------ 268| 752| case MSGPACK_CS_UINT_16:{ ------------------ | Branch (268:17): [True: 364, False: 27.5k] ------------------ 269| 364| uint16_t tmp; 270| 364| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 364|#define _msgpack_load16(cast, from, to) do { \ | | 168| 364| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 364| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 364|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 364| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 271| 364| push_fixed_value(_uint16, tmp); ------------------ | | 121| 364| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 364| template_callback ## name | | ------------------ | | 122| 364| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 364] | | ------------------ | | 123| 364| goto _push ------------------ 272| 364| } 273| 364| case MSGPACK_CS_UINT_32:{ ------------------ | Branch (273:17): [True: 226, False: 27.7k] ------------------ 274| 226| uint32_t tmp; 275| 226| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 226|#define _msgpack_load32(cast, from, to) do { \ | | 173| 226| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 226| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 226|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 226| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 276| 226| push_fixed_value(_uint32, tmp); ------------------ | | 121| 226| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 226| template_callback ## name | | ------------------ | | 122| 226| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 226] | | ------------------ | | 123| 226| goto _push ------------------ 277| 226| } 278| 226| case MSGPACK_CS_UINT_64:{ ------------------ | Branch (278:17): [True: 130, False: 27.8k] ------------------ 279| 130| uint64_t tmp; 280| 130| _msgpack_load64(uint64_t,n,&tmp); ------------------ | | 176| 130|#define _msgpack_load64(cast, from, to) do { \ | | 177| 130| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 178| 130| *(to) = (cast)_msgpack_be64(*(to)); \ | | ------------------ | | | | 142| 130|# define _msgpack_be64(x) bswap_64(x) | | ------------------ | | 179| 130| } while (0); | | ------------------ | | | Branch (179:14): [Folded - Ignored] | | ------------------ ------------------ 281| 130| push_fixed_value(_uint64, tmp); ------------------ | | 121| 130| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 130| template_callback ## name | | ------------------ | | 122| 130| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 130] | | ------------------ | | 123| 130| goto _push ------------------ 282| 130| } 283| 1.21k| case MSGPACK_CS_INT_8: ------------------ | Branch (283:17): [True: 1.21k, False: 26.7k] ------------------ 284| 1.21k| push_fixed_value(_int8, *(int8_t*)n); ------------------ | | 121| 1.21k| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 1.21k| template_callback ## name | | ------------------ | | 122| 1.21k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 1.21k] | | ------------------ | | 123| 1.21k| goto _push ------------------ 285| 1.21k| case MSGPACK_CS_INT_16:{ ------------------ | Branch (285:17): [True: 945, False: 27.0k] ------------------ 286| 945| int16_t tmp; 287| 945| _msgpack_load16(int16_t,n,&tmp); ------------------ | | 167| 945|#define _msgpack_load16(cast, from, to) do { \ | | 168| 945| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 945| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 945|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 945| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 288| 945| push_fixed_value(_int16, tmp); ------------------ | | 121| 945| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 945| template_callback ## name | | ------------------ | | 122| 945| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 945] | | ------------------ | | 123| 945| goto _push ------------------ 289| 945| } 290| 945| case MSGPACK_CS_INT_32:{ ------------------ | Branch (290:17): [True: 762, False: 27.1k] ------------------ 291| 762| int32_t tmp; 292| 762| _msgpack_load32(int32_t,n,&tmp); ------------------ | | 172| 762|#define _msgpack_load32(cast, from, to) do { \ | | 173| 762| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 762| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 762|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 762| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 293| 762| push_fixed_value(_int32, tmp); ------------------ | | 121| 762| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 762| template_callback ## name | | ------------------ | | 122| 762| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 762] | | ------------------ | | 123| 762| goto _push ------------------ 294| 762| } 295| 946| case MSGPACK_CS_INT_64:{ ------------------ | Branch (295:17): [True: 946, False: 27.0k] ------------------ 296| 946| int64_t tmp; 297| 946| _msgpack_load64(int64_t,n,&tmp); ------------------ | | 176| 946|#define _msgpack_load64(cast, from, to) do { \ | | 177| 946| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 178| 946| *(to) = (cast)_msgpack_be64(*(to)); \ | | ------------------ | | | | 142| 946|# define _msgpack_be64(x) bswap_64(x) | | ------------------ | | 179| 946| } while (0); | | ------------------ | | | Branch (179:14): [Folded - Ignored] | | ------------------ ------------------ 298| 946| push_fixed_value(_int64, tmp); ------------------ | | 121| 946| ret = msgpack_unpack_callback(func)(user, arg, &obj); \ | | ------------------ | | | | 33| 946| template_callback ## name | | ------------------ | | 122| 946| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (122:12): [True: 0, False: 946] | | ------------------ | | 123| 946| goto _push ------------------ 299| 946| } 300| 946| case MSGPACK_CS_FIXEXT_1: ------------------ | Branch (300:17): [True: 0, False: 27.9k] ------------------ 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: 27.9k] ------------------ 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: 27.9k] ------------------ 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: 27.9k] ------------------ 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: 27.9k] ------------------ 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| 497| case MSGPACK_CS_STR_8: ------------------ | Branch (310:17): [True: 497, False: 27.4k] ------------------ 311| 497| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, *(uint8_t*)n, _str_zero); ------------------ | | 135| 497| trail = trail_len; \ | | 136| 497| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 364, False: 133] | | ------------------ | | 137| 497| cs = _cs; \ | | 138| 133| goto _fixed_trail_again ------------------ 312| 1.05k| case MSGPACK_CS_BIN_8: ------------------ | Branch (312:17): [True: 1.05k, False: 26.8k] ------------------ 313| 1.05k| again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero); ------------------ | | 135| 1.05k| trail = trail_len; \ | | 136| 1.05k| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 571, False: 487] | | ------------------ | | 137| 1.05k| cs = _cs; \ | | 138| 487| goto _fixed_trail_again ------------------ 314| 303| case MSGPACK_CS_EXT_8: ------------------ | Branch (314:17): [True: 303, False: 27.6k] ------------------ 315| 303| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, (*(uint8_t*)n) + 1, _ext_zero); ------------------ | | 135| 303| trail = trail_len; \ | | 136| 303| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 303] | | ------------------ | | 137| 303| cs = _cs; \ | | 138| 303| goto _fixed_trail_again ------------------ 316| 525| case MSGPACK_CS_STR_16:{ ------------------ | Branch (316:17): [True: 525, False: 27.4k] ------------------ 317| 525| uint16_t tmp; 318| 525| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 525|#define _msgpack_load16(cast, from, to) do { \ | | 168| 525| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 525| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 525|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 525| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 319| 525| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero); ------------------ | | 135| 525| trail = trail_len; \ | | 136| 525| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 268, False: 257] | | ------------------ | | 137| 525| cs = _cs; \ | | 138| 257| goto _fixed_trail_again ------------------ 320| 525| } 321| 491| case MSGPACK_CS_BIN_16:{ ------------------ | Branch (321:17): [True: 491, False: 27.4k] ------------------ 322| 491| uint16_t tmp; 323| 491| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 491|#define _msgpack_load16(cast, from, to) do { \ | | 168| 491| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 491| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 491|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 491| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 324| 491| again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero); ------------------ | | 135| 491| trail = trail_len; \ | | 136| 491| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 206, False: 285] | | ------------------ | | 137| 491| cs = _cs; \ | | 138| 285| goto _fixed_trail_again ------------------ 325| 491| } 326| 240| case MSGPACK_CS_EXT_16:{ ------------------ | Branch (326:17): [True: 240, False: 27.7k] ------------------ 327| 240| uint16_t tmp; 328| 240| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 240|#define _msgpack_load16(cast, from, to) do { \ | | 168| 240| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 240| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 240|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 240| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 329| 240| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero); ------------------ | | 135| 240| trail = trail_len; \ | | 136| 240| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 0, False: 240] | | ------------------ | | 137| 240| cs = _cs; \ | | 138| 240| goto _fixed_trail_again ------------------ 330| 240| } 331| 460| case MSGPACK_CS_STR_32:{ ------------------ | Branch (331:17): [True: 460, False: 27.4k] ------------------ 332| 460| uint32_t tmp; 333| 460| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 460|#define _msgpack_load32(cast, from, to) do { \ | | 173| 460| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 460| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 460|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 460| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 334| 460| again_fixed_trail_if_zero(MSGPACK_ACS_STR_VALUE, tmp, _str_zero); ------------------ | | 135| 460| trail = trail_len; \ | | 136| 460| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 213, False: 247] | | ------------------ | | 137| 460| cs = _cs; \ | | 138| 247| goto _fixed_trail_again ------------------ 335| 460| } 336| 401| case MSGPACK_CS_BIN_32:{ ------------------ | Branch (336:17): [True: 401, False: 27.5k] ------------------ 337| 401| uint32_t tmp; 338| 401| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 401|#define _msgpack_load32(cast, from, to) do { \ | | 173| 401| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 401| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 401|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 401| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 339| 401| again_fixed_trail_if_zero(MSGPACK_ACS_BIN_VALUE, tmp, _bin_zero); ------------------ | | 135| 401| trail = trail_len; \ | | 136| 401| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 198, False: 203] | | ------------------ | | 137| 401| cs = _cs; \ | | 138| 203| goto _fixed_trail_again ------------------ 340| 401| } 341| 257| case MSGPACK_CS_EXT_32:{ ------------------ | Branch (341:17): [True: 257, False: 27.6k] ------------------ 342| 257| uint32_t tmp; 343| 257| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 257|#define _msgpack_load32(cast, from, to) do { \ | | 173| 257| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 257| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 257|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 257| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 344| 257| again_fixed_trail_if_zero(MSGPACK_ACS_EXT_VALUE, tmp + 1, _ext_zero); ------------------ | | 135| 257| trail = trail_len; \ | | 136| 257| if(trail == 0) { goto ifzero; } \ | | ------------------ | | | Branch (136:12): [True: 1, False: 256] | | ------------------ | | 137| 257| cs = _cs; \ | | 138| 256| goto _fixed_trail_again ------------------ 345| 257| } 346| 8.94k| case MSGPACK_ACS_STR_VALUE: ------------------ | Branch (346:17): [True: 8.94k, False: 19.0k] ------------------ 347| 12.2k| _str_zero: 348| 12.2k| push_variable_value(_str, data, n, trail); ------------------ | | 125| 12.2k| ret = msgpack_unpack_callback(func)(user, \ | | ------------------ | | | | 33| 12.2k| template_callback ## name | | ------------------ | | 126| 12.2k| (const char*)base, (const char*)pos, len, &obj); \ | | 127| 12.2k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (127:12): [True: 0, False: 12.2k] | | ------------------ | | 128| 12.2k| goto _push ------------------ 349| 12.2k| case MSGPACK_ACS_BIN_VALUE: ------------------ | Branch (349:17): [True: 913, False: 27.0k] ------------------ 350| 1.88k| _bin_zero: 351| 1.88k| push_variable_value(_bin, data, n, trail); ------------------ | | 125| 1.88k| ret = msgpack_unpack_callback(func)(user, \ | | ------------------ | | | | 33| 1.88k| template_callback ## name | | ------------------ | | 126| 1.88k| (const char*)base, (const char*)pos, len, &obj); \ | | 127| 1.88k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (127:12): [True: 0, False: 1.88k] | | ------------------ | | 128| 1.88k| goto _push ------------------ 352| 4.31k| case MSGPACK_ACS_EXT_VALUE: ------------------ | Branch (352:17): [True: 4.31k, False: 23.6k] ------------------ 353| 4.31k| _ext_zero: 354| 4.31k| push_variable_value(_ext, data, n, trail); ------------------ | | 125| 4.31k| ret = msgpack_unpack_callback(func)(user, \ | | ------------------ | | | | 33| 4.31k| template_callback ## name | | ------------------ | | 126| 4.31k| (const char*)base, (const char*)pos, len, &obj); \ | | 127| 4.31k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (127:12): [True: 1, False: 4.31k] | | ------------------ | | 128| 4.31k| goto _push ------------------ 355| | 356| 4.31k| case MSGPACK_CS_ARRAY_16:{ ------------------ | Branch (356:17): [True: 882, False: 27.0k] ------------------ 357| 882| uint16_t tmp; 358| 882| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 882|#define _msgpack_load16(cast, from, to) do { \ | | 168| 882| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 882| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 882|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 882| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 359| 1.75k| start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM); ------------------ | | 141| 882| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 882|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 5, False: 877] | | ------------------ | | 142| 5| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 5| goto _failed; \ | | 144| 5| } /* FIXME */ \ | | 145| 882| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 877| template_callback ## name | | ------------------ | | 146| 877| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 877] | | ------------------ | | 147| 877| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 182, False: 695] | | ------------------ | | 148| 877| stack[top].ct = ct_; \ | | 149| 695| stack[top].count = count_; \ | | 150| 695| ++top; \ | | 151| 695| goto _header_again ------------------ 360| 1.75k| } 361| 549| case MSGPACK_CS_ARRAY_32:{ ------------------ | Branch (361:17): [True: 549, False: 27.4k] ------------------ 362| | /* FIXME security guard */ 363| 549| uint32_t tmp; 364| 549| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 549|#define _msgpack_load32(cast, from, to) do { \ | | 173| 549| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 549| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 549|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 549| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 365| 1.06k| start_container(_array, tmp, MSGPACK_CT_ARRAY_ITEM); ------------------ | | 141| 549| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 549|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 3, False: 546] | | ------------------ | | 142| 3| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 3| goto _failed; \ | | 144| 3| } /* FIXME */ \ | | 145| 549| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 546| template_callback ## name | | ------------------ | | 146| 546| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 28, False: 518] | | ------------------ | | 147| 546| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 195, False: 323] | | ------------------ | | 148| 518| stack[top].ct = ct_; \ | | 149| 323| stack[top].count = count_; \ | | 150| 323| ++top; \ | | 151| 323| goto _header_again ------------------ 366| 1.06k| } 367| | 368| 1.22k| case MSGPACK_CS_MAP_16:{ ------------------ | Branch (368:17): [True: 1.22k, False: 26.7k] ------------------ 369| 1.22k| uint16_t tmp; 370| 1.22k| _msgpack_load16(uint16_t,n,&tmp); ------------------ | | 167| 1.22k|#define _msgpack_load16(cast, from, to) do { \ | | 168| 1.22k| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 169| 1.22k| *(to) = (cast)_msgpack_be16(*(to)); \ | | ------------------ | | | | 110| 1.22k|# define _msgpack_be16(x) ntohs((uint16_t)x) | | ------------------ | | 170| 1.22k| } while (0); | | ------------------ | | | Branch (170:14): [Folded - Ignored] | | ------------------ ------------------ 371| 2.44k| start_container(_map, tmp, MSGPACK_CT_MAP_KEY); ------------------ | | 141| 1.22k| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 1.22k|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 3, False: 1.22k] | | ------------------ | | 142| 3| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 3| goto _failed; \ | | 144| 3| } /* FIXME */ \ | | 145| 1.22k| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 1.22k| template_callback ## name | | ------------------ | | 146| 1.22k| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 0, False: 1.22k] | | ------------------ | | 147| 1.22k| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 246, False: 978] | | ------------------ | | 148| 1.22k| stack[top].ct = ct_; \ | | 149| 978| stack[top].count = count_; \ | | 150| 978| ++top; \ | | 151| 978| goto _header_again ------------------ 372| 2.44k| } 373| 465| case MSGPACK_CS_MAP_32:{ ------------------ | Branch (373:17): [True: 465, False: 27.4k] ------------------ 374| | /* FIXME security guard */ 375| 465| uint32_t tmp; 376| 465| _msgpack_load32(uint32_t,n,&tmp); ------------------ | | 172| 465|#define _msgpack_load32(cast, from, to) do { \ | | 173| 465| memcpy((cast*)(to), (from), sizeof(cast)); \ | | 174| 465| *(to) = (cast)_msgpack_be32(*(to)); \ | | ------------------ | | | | 124| 465|# define _msgpack_be32(x) ntohl((uint32_t)x) | | ------------------ | | 175| 465| } while (0); | | ------------------ | | | Branch (175:14): [Folded - Ignored] | | ------------------ ------------------ 377| 904| start_container(_map, tmp, MSGPACK_CT_MAP_KEY); ------------------ | | 141| 465| if(top >= MSGPACK_EMBED_STACK_SIZE) { \ | | ------------------ | | | | 25| 465|#define MSGPACK_EMBED_STACK_SIZE 32 | | ------------------ | | | Branch (141:12): [True: 1, False: 464] | | ------------------ | | 142| 1| ret = MSGPACK_UNPACK_NOMEM_ERROR; \ | | 143| 1| goto _failed; \ | | 144| 1| } /* FIXME */ \ | | 145| 465| ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ | | ------------------ | | | | 33| 464| template_callback ## name | | ------------------ | | 146| 464| if(ret < 0) { goto _failed; } \ | | ------------------ | | | Branch (146:12): [True: 24, False: 440] | | ------------------ | | 147| 464| if((count_) == 0) { obj = stack[top].obj; goto _push; } \ | | ------------------ | | | Branch (147:12): [True: 164, False: 276] | | ------------------ | | 148| 440| stack[top].ct = ct_; \ | | 149| 276| stack[top].count = count_; \ | | 150| 276| ++top; \ | | 151| 276| goto _header_again ------------------ 378| 904| } 379| | 380| 0| default: ------------------ | Branch (380:17): [True: 0, False: 27.9k] ------------------ 381| 0| ret = MSGPACK_UNPACK_PARSE_ERROR; 382| 0| goto _failed; 383| 27.9k| } 384| 142k| } 385| | 386| 136k| _push: 387| 136k| if(top == 0) { goto _finish; } ------------------ | Branch (387:12): [True: 321, False: 136k] ------------------ 388| 136k| c = &stack[top-1]; 389| 136k| switch(c->ct) { 390| 51.1k| case MSGPACK_CT_ARRAY_ITEM: ------------------ | Branch (390:9): [True: 51.1k, False: 85.3k] ------------------ 391| 51.1k| ret = msgpack_unpack_callback(_array_item)(user, &c->obj, obj); \ ------------------ | | 33| 51.1k| template_callback ## name ------------------ 392| 51.1k| if(ret < 0) { goto _failed; } ------------------ | Branch (392:16): [True: 0, False: 51.1k] ------------------ 393| 51.1k| if(--c->count == 0) { ------------------ | Branch (393:16): [True: 5.57k, False: 45.5k] ------------------ 394| 5.57k| obj = c->obj; 395| 5.57k| --top; 396| | /*printf("stack pop %d\n", top);*/ 397| 5.57k| goto _push; 398| 5.57k| } 399| 45.5k| goto _header_again; 400| 45.5k| case MSGPACK_CT_MAP_KEY: ------------------ | Branch (400:9): [True: 43.0k, False: 93.3k] ------------------ 401| 43.0k| c->map_key = obj; 402| 43.0k| c->ct = MSGPACK_CT_MAP_VALUE; 403| 43.0k| goto _header_again; 404| 42.2k| case MSGPACK_CT_MAP_VALUE: ------------------ | Branch (404:9): [True: 42.2k, False: 94.1k] ------------------ 405| 42.2k| ret = msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj); \ ------------------ | | 33| 42.2k| template_callback ## name ------------------ 406| 42.2k| if(ret < 0) { goto _failed; } ------------------ | Branch (406:16): [True: 0, False: 42.2k] ------------------ 407| 42.2k| if(--c->count == 0) { ------------------ | Branch (407:16): [True: 4.42k, False: 37.8k] ------------------ 408| 4.42k| obj = c->obj; 409| 4.42k| --top; 410| | /*printf("stack pop %d\n", top);*/ 411| 4.42k| goto _push; 412| 4.42k| } 413| 37.8k| c->ct = MSGPACK_CT_MAP_KEY; 414| 37.8k| goto _header_again; 415| | 416| 0| default: ------------------ | Branch (416:9): [True: 0, False: 136k] ------------------ 417| 0| ret = MSGPACK_UNPACK_PARSE_ERROR; 418| 0| goto _failed; 419| 136k| } 420| | 421| 141k| _header_again: 422| 141k| cs = MSGPACK_CS_HEADER; 423| 141k| ++p; 424| 141k| } while(p != pe); ------------------ | Branch (424:17): [True: 141k, False: 79] ------------------ 425| 79| goto _out; 426| | 427| | 428| 321| _finish: 429| 321| stack[0].obj = obj; 430| 321| ++p; 431| 321| ret = 1; 432| | /*printf("-- finish --\n"); */ 433| 321| goto _end; 434| | 435| 107| _failed: 436| | /*printf("** FAILED **\n"); */ 437| 107| goto _end; 438| | 439| 373| _out: 440| 373| ret = 0; 441| 373| goto _end; 442| | 443| 801| _end: 444| 801| ctx->cs = cs; 445| 801| ctx->trail = trail; 446| 801| ctx->top = top; 447| 801| *off = (size_t)(p - (const unsigned char*)data); 448| | 449| 801| return ret; 450| 801| } 451| 801|} unpack.c:template_data: 89| 321|{ 90| 321| return (ctx)->stack[0].obj; 91| 321|} unpack.c:msgpack_zone_malloc: 107| 19.8k|{ 108| 19.8k| char* aligned = 109| 19.8k| (char*)( 110| 19.8k| (size_t)( 111| 19.8k| zone->chunk_list.ptr + (MSGPACK_ZONE_ALIGN - 1) ------------------ | | 84| 19.8k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 112| 19.8k| ) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN ------------------ | | 84| 19.8k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ ) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN ------------------ | | 84| 19.8k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 113| 19.8k| ); 114| 19.8k| size_t adjusted_size = size + (size_t)(aligned - zone->chunk_list.ptr); 115| 19.8k| if(zone->chunk_list.free >= adjusted_size) { ------------------ | Branch (115:8): [True: 18.4k, False: 1.38k] ------------------ 116| 18.4k| zone->chunk_list.free -= adjusted_size; 117| 18.4k| zone->chunk_list.ptr += adjusted_size; 118| 18.4k| return aligned; 119| 18.4k| } 120| 1.38k| { 121| 1.38k| void* ptr = msgpack_zone_malloc_expand(zone, size + (MSGPACK_ZONE_ALIGN - 1)); ------------------ | | 84| 1.38k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 122| 1.38k| if (ptr) { ------------------ | Branch (122:13): [True: 1.33k, False: 52] ------------------ 123| 1.33k| return (char*)((size_t)(ptr) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN); ------------------ | | 84| 1.33k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ return (char*)((size_t)(ptr) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN); ------------------ | | 84| 1.33k|#define MSGPACK_ZONE_ALIGN sizeof(void*) ------------------ 124| 1.33k| } 125| 1.38k| } 126| 52| return NULL; 127| 1.38k|} msgpack_unpack_next: 659| 801|{ 660| 801| size_t noff = 0; 661| 801| msgpack_unpacked_destroy(result); 662| | 663| 801| if(off != NULL) { noff = *off; } ------------------ | Branch (663:8): [True: 801, False: 0] ------------------ 664| | 665| 801| if(len <= noff) { ------------------ | Branch (665:8): [True: 0, False: 801] ------------------ 666| 0| return MSGPACK_UNPACK_CONTINUE; 667| 0| } 668| | 669| 801| { 670| 801| int e; 671| 801| template_context ctx; 672| 801| template_init(&ctx); 673| | 674| 801| ctx.user.z = &result->zone; 675| 801| ctx.user.referenced = false; 676| | 677| 801| e = template_execute(&ctx, data, len, &noff); 678| | 679| 801| if(off != NULL) { *off = noff; } ------------------ | Branch (679:12): [True: 801, False: 0] ------------------ 680| | 681| 801| if(e < 0) { ------------------ | Branch (681:12): [True: 107, False: 694] ------------------ 682| 107| msgpack_zone_free(result->zone); 683| 107| result->zone = NULL; 684| 107| return (msgpack_unpack_return)e; 685| 107| } 686| | 687| 694| if(e == 0) { ------------------ | Branch (687:12): [True: 373, False: 321] ------------------ 688| 373| return MSGPACK_UNPACK_CONTINUE; 689| 373| } 690| | 691| 321| result->data = template_data(&ctx); 692| | 693| 321| return MSGPACK_UNPACK_SUCCESS; 694| 694| } 695| 694|} unpack.c:template_callback_root: 52| 801|{ 53| 801| msgpack_object o; 54| 801| MSGPACK_UNUSED(u); ------------------ | | 13| 801|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 55| 801| o.type = MSGPACK_OBJECT_NIL; 56| 801| return o; 57| 801|} unpack.c:template_callback_uint8: 60| 46.1k|{ 61| 46.1k| MSGPACK_UNUSED(u); ------------------ | | 13| 46.1k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 62| 46.1k| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 63| 46.1k| o->via.u64 = d; 64| 46.1k| return 0; 65| 46.1k|} unpack.c:template_callback_int8: 92| 46.4k|{ 93| 46.4k| MSGPACK_UNUSED(u); ------------------ | | 13| 46.4k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 94| 46.4k| if(d >= 0) { ------------------ | Branch (94:8): [True: 247, False: 46.2k] ------------------ 95| 247| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 96| 247| o->via.u64 = (uint64_t)d; 97| 247| return 0; 98| 247| } 99| 46.2k| else { 100| 46.2k| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 101| 46.2k| o->via.i64 = d; 102| 46.2k| return 0; 103| 46.2k| } 104| 46.4k|} unpack.c:template_callback_nil: 168| 2.23k|{ 169| 2.23k| MSGPACK_UNUSED(u); ------------------ | | 13| 2.23k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 170| 2.23k| o->type = MSGPACK_OBJECT_NIL; 171| 2.23k| return 0; 172| 2.23k|} unpack.c:template_callback_false: 183| 2.78k|{ 184| 2.78k| MSGPACK_UNUSED(u); ------------------ | | 13| 2.78k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 185| 2.78k| o->type = MSGPACK_OBJECT_BOOLEAN; 186| 2.78k| o->via.boolean = false; 187| 2.78k| return 0; 188| 2.78k|} unpack.c:template_callback_true: 175| 1.47k|{ 176| 1.47k| MSGPACK_UNUSED(u); ------------------ | | 13| 1.47k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 177| 1.47k| o->type = MSGPACK_OBJECT_BOOLEAN; 178| 1.47k| o->via.boolean = true; 179| 1.47k| return 0; 180| 1.47k|} unpack.c:template_callback_array: 191| 9.86k|{ 192| 9.86k| 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| 9.86k| o->type = MSGPACK_OBJECT_ARRAY; 203| 9.86k| o->via.array.size = 0; 204| | 205| 9.86k| size = n * sizeof(msgpack_object); 206| | 207| 9.86k| if (*u->z == NULL) { ------------------ | Branch (207:9): [True: 220, False: 9.64k] ------------------ 208| 220| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 220|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 209| 220| if(*u->z == NULL) { ------------------ | Branch (209:12): [True: 0, False: 220] ------------------ 210| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 211| 0| } 212| 220| } 213| | 214| | // Unsure whether size = 0 should be an error, and if so, what to return 215| 9.86k| o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(*u->z, size); 216| 9.86k| if(o->via.array.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; } ------------------ | Branch (216:8): [True: 28, False: 9.83k] ------------------ 217| 9.83k| return 0; 218| 9.86k|} unpack.c:template_callback_map: 233| 9.99k|{ 234| 9.99k| 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.99k| o->type = MSGPACK_OBJECT_MAP; 247| 9.99k| o->via.map.size = 0; 248| | 249| 9.99k| size = n * sizeof(msgpack_object_kv); 250| | 251| 9.99k| if (*u->z == NULL) { ------------------ | Branch (251:9): [True: 574, False: 9.42k] ------------------ 252| 574| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 574|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 253| 574| if(*u->z == NULL) { ------------------ | Branch (253:12): [True: 0, False: 574] ------------------ 254| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 255| 0| } 256| 574| } 257| | 258| | // Should size = 0 be an error? If so, what error to return? 259| 9.99k| o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(*u->z, size); 260| 9.99k| if(o->via.map.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; } ------------------ | Branch (260:8): [True: 24, False: 9.97k] ------------------ 261| 9.97k| return 0; 262| 9.99k|} unpack.c:template_callback_float: 152| 766|{ 153| 766| MSGPACK_UNUSED(u); ------------------ | | 13| 766|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 154| 766| o->type = MSGPACK_OBJECT_FLOAT32; 155| 766| o->via.f64 = d; 156| 766| return 0; 157| 766|} unpack.c:template_callback_double: 160| 325|{ 161| 325| MSGPACK_UNUSED(u); ------------------ | | 13| 325|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 162| 325| o->type = MSGPACK_OBJECT_FLOAT64; 163| 325| o->via.f64 = d; 164| 325| return 0; 165| 325|} unpack.c:template_callback_uint16: 68| 364|{ 69| 364| MSGPACK_UNUSED(u); ------------------ | | 13| 364|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 70| 364| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 71| 364| o->via.u64 = d; 72| 364| return 0; 73| 364|} unpack.c:template_callback_uint32: 76| 226|{ 77| 226| MSGPACK_UNUSED(u); ------------------ | | 13| 226|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 78| 226| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 79| 226| o->via.u64 = d; 80| 226| return 0; 81| 226|} unpack.c:template_callback_uint64: 84| 130|{ 85| 130| MSGPACK_UNUSED(u); ------------------ | | 13| 130|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 86| 130| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 87| 130| o->via.u64 = d; 88| 130| return 0; 89| 130|} unpack.c:template_callback_int16: 107| 945|{ 108| 945| MSGPACK_UNUSED(u); ------------------ | | 13| 945|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 109| 945| if(d >= 0) { ------------------ | Branch (109:8): [True: 253, False: 692] ------------------ 110| 253| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 111| 253| o->via.u64 = (uint64_t)d; 112| 253| return 0; 113| 253| } 114| 692| else { 115| 692| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 116| 692| o->via.i64 = d; 117| 692| return 0; 118| 692| } 119| 945|} unpack.c:template_callback_int32: 122| 762|{ 123| 762| MSGPACK_UNUSED(u); ------------------ | | 13| 762|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 124| 762| if(d >= 0) { ------------------ | Branch (124:8): [True: 253, False: 509] ------------------ 125| 253| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 126| 253| o->via.u64 = (uint64_t)d; 127| 253| return 0; 128| 253| } 129| 509| else { 130| 509| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 131| 509| o->via.i64 = d; 132| 509| return 0; 133| 509| } 134| 762|} unpack.c:template_callback_int64: 137| 946|{ 138| 946| MSGPACK_UNUSED(u); ------------------ | | 13| 946|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 139| 946| if(d >= 0) { ------------------ | Branch (139:8): [True: 271, False: 675] ------------------ 140| 271| o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; 141| 271| o->via.u64 = (uint64_t)d; 142| 271| return 0; 143| 271| } 144| 675| else { 145| 675| o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; 146| 675| o->via.i64 = d; 147| 675| return 0; 148| 675| } 149| 946|} unpack.c:template_callback_str: 279| 12.2k|{ 280| 12.2k| MSGPACK_UNUSED(b); ------------------ | | 13| 12.2k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 281| 12.2k| if (*u->z == NULL) { ------------------ | Branch (281:9): [True: 1, False: 12.2k] ------------------ 282| 1| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 1|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 283| 1| if(*u->z == NULL) { ------------------ | Branch (283:12): [True: 0, False: 1] ------------------ 284| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 285| 0| } 286| 1| } 287| 12.2k| o->type = MSGPACK_OBJECT_STR; 288| 12.2k| o->via.str.ptr = p; 289| 12.2k| o->via.str.size = l; 290| 12.2k| u->referenced = true; 291| 12.2k| return 0; 292| 12.2k|} unpack.c:template_callback_bin: 295| 1.88k|{ 296| 1.88k| MSGPACK_UNUSED(b); ------------------ | | 13| 1.88k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 297| 1.88k| if (*u->z == NULL) { ------------------ | Branch (297:9): [True: 2, False: 1.88k] ------------------ 298| 2| *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); ------------------ | | 53| 2|#define MSGPACK_ZONE_CHUNK_SIZE 8192 ------------------ 299| 2| if(*u->z == NULL) { ------------------ | Branch (299:12): [True: 0, False: 2] ------------------ 300| 0| return MSGPACK_UNPACK_NOMEM_ERROR; 301| 0| } 302| 2| } 303| 1.88k| o->type = MSGPACK_OBJECT_BIN; 304| 1.88k| o->via.bin.ptr = p; 305| 1.88k| o->via.bin.size = l; 306| 1.88k| u->referenced = true; 307| 1.88k| return 0; 308| 1.88k|} unpack.c:template_callback_ext: 311| 4.31k|{ 312| 4.31k| MSGPACK_UNUSED(b); ------------------ | | 13| 4.31k|#define MSGPACK_UNUSED(a) (void)(a) ------------------ 313| 4.31k| if (l == 0) { ------------------ | Branch (313:9): [True: 1, False: 4.31k] ------------------ 314| 1| return MSGPACK_UNPACK_PARSE_ERROR; 315| 1| } 316| 4.31k| if (*u->z == NULL) { ------------------ | Branch (316:9): [True: 1, False: 4.31k] ------------------ 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| 4.31k| o->type = MSGPACK_OBJECT_EXT; 323| 4.31k| o->via.ext.type = *p; 324| 4.31k| o->via.ext.ptr = p + 1; 325| 4.31k| o->via.ext.size = l - 1; 326| 4.31k| u->referenced = true; 327| 4.31k| return 0; 328| 4.31k|} unpack.c:template_callback_array_item: 221| 51.1k|{ 222| 51.1k| MSGPACK_UNUSED(u); ------------------ | | 13| 51.1k|#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| 51.1k| c->via.array.ptr[c->via.array.size] = o; 227| 51.1k|#endif /* __GNUC__ && !__clang__ */ 228| 51.1k| ++c->via.array.size; 229| 51.1k| return 0; 230| 51.1k|} unpack.c:template_callback_map_item: 265| 42.2k|{ 266| 42.2k| MSGPACK_UNUSED(u); ------------------ | | 13| 42.2k|#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| 42.2k| c->via.map.ptr[c->via.map.size].key = k; 272| 42.2k| c->via.map.ptr[c->via.map.size].val = v; 273| 42.2k|#endif /* __GNUC__ && !__clang__ */ 274| 42.2k| ++c->via.map.size; 275| 42.2k| return 0; 276| 42.2k|} fuzz_malloc: 14| 2.98k|void *fuzz_malloc(size_t size) {if (size > 0xa00000) return NULL; ------------------ | Branch (14:37): [True: 52, False: 2.92k] ------------------ 15| 2.92k|return malloc(size);} msgpack_zone_malloc_expand: 70| 1.38k|{ 71| 1.38k| msgpack_zone_chunk_list* const cl = &zone->chunk_list; 72| 1.38k| msgpack_zone_chunk* chunk; 73| | 74| 1.38k| size_t sz = zone->chunk_size; 75| | 76| 9.84k| while(sz < size) { ------------------ | Branch (76:11): [True: 8.46k, False: 1.38k] ------------------ 77| 8.46k| size_t tmp_sz = sz * 2; 78| 8.46k| if (tmp_sz <= sz) { ------------------ | Branch (78:13): [True: 0, False: 8.46k] ------------------ 79| 0| sz = size; 80| 0| break; 81| 0| } 82| 8.46k| sz = tmp_sz; 83| 8.46k| } 84| | 85| 1.38k| chunk = (msgpack_zone_chunk*)fuzz_malloc( 86| 1.38k| sizeof(msgpack_zone_chunk) + sz); 87| 1.38k| if (chunk == NULL) { ------------------ | Branch (87:9): [True: 52, False: 1.33k] ------------------ 88| 52| return NULL; 89| 52| } 90| 1.33k| else { 91| 1.33k| char* ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); 92| 1.33k| chunk->next = cl->head; 93| 1.33k| cl->head = chunk; 94| 1.33k| cl->free = sz - size; 95| 1.33k| cl->ptr = ptr + size; 96| | 97| 1.33k| return ptr; 98| 1.33k| } 99| 1.38k|} msgpack_zone_destroy: 175| 798|{ 176| 798| destroy_finalizer_array(&zone->finalizer_array); 177| 798| destroy_chunk_list(&zone->chunk_list); 178| 798|} msgpack_zone_new: 200| 798|{ 201| 798| msgpack_zone* zone = (msgpack_zone*)fuzz_malloc( 202| 798| sizeof(msgpack_zone)); 203| 798| if(zone == NULL) { ------------------ | Branch (203:8): [True: 0, False: 798] ------------------ 204| 0| return NULL; 205| 0| } 206| | 207| 798| zone->chunk_size = chunk_size; 208| | 209| 798| if(!init_chunk_list(&zone->chunk_list, chunk_size)) { ------------------ | Branch (209:8): [True: 0, False: 798] ------------------ 210| 0| free(zone); 211| 0| return NULL; 212| 0| } 213| | 214| 798| init_finalizer_array(&zone->finalizer_array); 215| | 216| 798| return zone; 217| 798|} msgpack_zone_free: 220| 799|{ 221| 799| if(zone == NULL) { return; } ------------------ | Branch (221:8): [True: 1, False: 798] ------------------ 222| 798| msgpack_zone_destroy(zone); 223| 798| free(zone); 224| 798|} zone.c:destroy_finalizer_array: 118| 798|{ 119| 798| call_finalizer_array(fa); 120| 798| free(fa->array); 121| 798|} zone.c:call_finalizer_array: 110| 798|{ 111| 798| msgpack_zone_finalizer* fin = fa->tail; 112| 798| for(; fin != fa->array; --fin) { ------------------ | Branch (112:11): [True: 0, False: 798] ------------------ 113| 0| (*(fin-1)->func)((fin-1)->data); 114| 0| } 115| 798|} zone.c:destroy_chunk_list: 38| 798|{ 39| 798| msgpack_zone_chunk* c = cl->head; 40| 2.13k| while(true) { 41| 2.13k| msgpack_zone_chunk* n = c->next; 42| 2.13k| free(c); 43| 2.13k| if(n != NULL) { ------------------ | Branch (43:12): [True: 1.33k, False: 798] ------------------ 44| 1.33k| c = n; 45| 1.33k| } else { 46| 798| break; 47| 798| } 48| 2.13k| } 49| 798|} zone.c:init_chunk_list: 22| 798|{ 23| 798| msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)fuzz_malloc( 24| 798| sizeof(msgpack_zone_chunk) + chunk_size); 25| 798| if(chunk == NULL) { ------------------ | Branch (25:8): [True: 0, False: 798] ------------------ 26| 0| return false; 27| 0| } 28| | 29| 798| cl->head = chunk; 30| 798| cl->free = chunk_size; 31| 798| cl->ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); 32| 798| chunk->next = NULL; 33| | 34| 798| return true; 35| 798|} zone.c:init_finalizer_array: 103| 798|{ 104| 798| fa->tail = NULL; 105| 798| fa->end = NULL; 106| 798| fa->array = NULL; 107| 798|} flb_log_construct: 501| 2|{ 502| 2| int body_size; 503| 2| int ret; 504| 2| int len; 505| 2| int total; 506| 2| time_t now; 507| 2| const char *header_color = NULL; 508| 2| const char *header_title = NULL; 509| 2| const char *bold_color = ANSI_BOLD; ------------------ | | 47| 2|#define ANSI_BOLD "\033[1m" ------------------ 510| 2| const char *reset_color = ANSI_RESET; ------------------ | | 46| 2|#define ANSI_RESET "\033[0m" ------------------ 511| 2| struct tm result; 512| 2| struct tm *current; 513| | 514| 2| switch (type) { ------------------ | Branch (514:13): [True: 0, False: 2] ------------------ 515| 0| case FLB_LOG_HELP: ------------------ | | 45| 0|#define FLB_LOG_HELP 6 /* unused by log level */ ------------------ | Branch (515:5): [True: 0, False: 2] ------------------ 516| 0| header_title = "help"; 517| 0| header_color = ANSI_CYAN; ------------------ | | 48| 0|#define ANSI_CYAN "\033[96m" ------------------ 518| 0| break; 519| 0| case FLB_LOG_INFO: ------------------ | | 42| 0|#define FLB_LOG_INFO 3 /* default */ ------------------ | Branch (519:5): [True: 0, False: 2] ------------------ 520| 0| header_title = "info"; 521| 0| header_color = ANSI_GREEN; ------------------ | | 53| 0|#define ANSI_GREEN "\033[92m" ------------------ 522| 0| break; 523| 0| case FLB_LOG_WARN: ------------------ | | 41| 0|#define FLB_LOG_WARN 2 ------------------ | Branch (523:5): [True: 0, False: 2] ------------------ 524| 0| header_title = "warn"; 525| 0| header_color = ANSI_YELLOW; ------------------ | | 51| 0|#define ANSI_YELLOW "\033[93m" ------------------ 526| 0| break; 527| 2| case FLB_LOG_ERROR: ------------------ | | 40| 2|#define FLB_LOG_ERROR 1 ------------------ | Branch (527:5): [True: 2, False: 0] ------------------ 528| 2| header_title = "error"; 529| 2| header_color = ANSI_RED; ------------------ | | 50| 2|#define ANSI_RED "\033[91m" ------------------ 530| 2| break; 531| 0| case FLB_LOG_DEBUG: ------------------ | | 43| 0|#define FLB_LOG_DEBUG 4 ------------------ | Branch (531:5): [True: 0, False: 2] ------------------ 532| 0| header_title = "debug"; 533| 0| header_color = ANSI_YELLOW; ------------------ | | 51| 0|#define ANSI_YELLOW "\033[93m" ------------------ 534| 0| break; 535| 0| case FLB_LOG_IDEBUG: ------------------ | | 47| 0|#define FLB_LOG_IDEBUG 10 ------------------ | Branch (535:5): [True: 0, False: 2] ------------------ 536| 0| header_title = "debug"; 537| 0| header_color = ANSI_CYAN; ------------------ | | 48| 0|#define ANSI_CYAN "\033[96m" ------------------ 538| 0| break; 539| 0| case FLB_LOG_TRACE: ------------------ | | 44| 0|#define FLB_LOG_TRACE 5 ------------------ | Branch (539:5): [True: 0, False: 2] ------------------ 540| 0| header_title = "trace"; 541| 0| header_color = ANSI_BLUE; ------------------ | | 52| 0|#define ANSI_BLUE "\033[94m" ------------------ 542| 0| break; 543| 2| } 544| | 545| | #ifdef FLB_LOG_NO_CONTROL_CHARS 546| | header_color = ""; 547| | bold_color = ""; 548| | reset_color = ""; 549| | #else 550| | /* Only print colors to a terminal */ 551| 2| if (!isatty(STDOUT_FILENO)) { ------------------ | Branch (551:9): [True: 2, False: 0] ------------------ 552| 2| header_color = ""; 553| 2| bold_color = ""; 554| 2| reset_color = ""; 555| 2| } 556| 2| #endif // FLB_LOG_NO_CONTROL_CHARS 557| | 558| 2| now = time(NULL); 559| 2| current = localtime_r(&now, &result); 560| | 561| 2| if (current == NULL) { ------------------ | Branch (561:9): [True: 0, False: 2] ------------------ 562| 0| return -1; 563| 0| } 564| | 565| 2| len = snprintf(msg->msg, sizeof(msg->msg) - 1, 566| 2| "%s[%s%i/%02i/%02i %02i:%02i:%02i%s]%s [%s%5s%s] ", 567| | /* time */ /* type */ 568| | 569| | /* time variables */ 570| 2| bold_color, reset_color, 571| 2| current->tm_year + 1900, 572| 2| current->tm_mon + 1, 573| 2| current->tm_mday, 574| 2| current->tm_hour, 575| 2| current->tm_min, 576| 2| current->tm_sec, 577| 2| bold_color, reset_color, 578| | 579| | /* type format */ 580| 2| header_color, header_title, reset_color); 581| | 582| 2| body_size = (sizeof(msg->msg) - 2) - len; 583| 2| total = vsnprintf(msg->msg + len, 584| 2| body_size, 585| 2| fmt, *args); 586| 2| if (total < 0) { ------------------ | Branch (586:9): [True: 0, False: 2] ------------------ 587| 0| return -1; 588| 0| } 589| 2| ret = total; /* ret means a buffer size need to save log body */ 590| | 591| 2| total = strlen(msg->msg + len) + len; 592| 2| msg->msg[total++] = '\n'; 593| 2| msg->msg[total] = '\0'; 594| 2| msg->size = total; 595| | 596| 2| *ret_len = len; 597| | 598| 2| if (ret >= body_size) { ------------------ | Branch (598:9): [True: 0, False: 2] ------------------ 599| | /* log is truncated */ 600| 0| return ret - body_size; 601| 0| } 602| | 603| 2| return 0; 604| 2|} flb_log_print: 633| 2|{ 634| 2| int n; 635| 2| int len; 636| 2| int ret; 637| 2| struct log_message msg = {0}; 638| 2| va_list args; 639| | 640| 2| struct flb_worker *w; 641| | 642| 2| va_start(args, fmt); 643| 2| ret = flb_log_construct(&msg, &len, type, file, line, fmt, &args); 644| 2| va_end(args); 645| | 646| 2| if (ret < 0) { ------------------ | Branch (646:9): [True: 0, False: 2] ------------------ 647| 0| return; 648| 0| } 649| | 650| 2| w = flb_worker_get(); 651| 2| if (w) { ------------------ | Branch (651:9): [True: 0, False: 2] ------------------ 652| 0| n = flb_pipe_write_all(w->log[1], &msg, sizeof(msg)); 653| 0| if (n == -1) { ------------------ | Branch (653:13): [True: 0, False: 0] ------------------ 654| 0| fprintf(stderr, "%s", (char *) msg.msg); 655| 0| perror("write"); 656| 0| } 657| 0| } 658| 2| else { 659| 2| fprintf(stderr, "%s", (char *) msg.msg); 660| 2| } 661| | 662| | #ifdef FLB_HAVE_AWS_ERROR_REPORTER 663| | if (is_error_reporting_enabled()) { 664| | if (type == FLB_LOG_ERROR) { 665| | flb_aws_error_reporter_write(error_reporter, msg.msg + len); 666| | } 667| | 668| | flb_aws_error_reporter_clean(error_reporter); 669| | } 670| | #endif 671| 2|} flb_errno_print: 674| 2|{ 675| 2| char buf[256]; 676| | 677| 2| strerror_r(errnum, buf, sizeof(buf) - 1); 678| 2| flb_error("[%s:%i errno=%i] %s", file, line, errnum, buf); ------------------ | | 170| 2| if (flb_log_check(FLB_LOG_ERROR)) \ | | ------------------ | | | | 40| 2|#define FLB_LOG_ERROR 1 | | ------------------ | | | Branch (170:9): [True: 2, False: 0] | | ------------------ | | 171| 2| flb_log_print(FLB_LOG_ERROR, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 40| 2|#define FLB_LOG_ERROR 1 | | ------------------ ------------------ 679| 2| return 0; 680| 2|} flb_msgpack_to_json: 759| 880|{ 760| 880| int ret = -1; 761| 880| int off = 0; 762| | 763| 880| if (json_str == NULL || obj == NULL) { ------------------ | Branch (763:9): [True: 0, False: 880] | Branch (763:29): [True: 0, False: 880] ------------------ 764| 0| return -1; 765| 0| } 766| | 767| 880| ret = msgpack2json(json_str, &off, json_size - 1, obj); 768| 880| json_str[off] = '\0'; 769| 880| return ret ? off: ret; ------------------ | Branch (769:12): [True: 321, False: 559] ------------------ 770| 880|} flb_msgpack_raw_to_json_sds: 773| 802|{ 774| 802| int ret; 775| 802| size_t off = 0; 776| 802| size_t out_size; 777| 802| size_t realloc_size; 778| | 779| 802| msgpack_unpacked result; 780| 802| msgpack_object *root; 781| 802| flb_sds_t out_buf; 782| 802| flb_sds_t tmp_buf; 783| | 784| | /* buffer size strategy */ 785| 802| out_size = in_size * FLB_MSGPACK_TO_JSON_INIT_BUFFER_SIZE; 786| 802| realloc_size = in_size * FLB_MSGPACK_TO_JSON_REALLOC_BUFFER_SIZE; 787| 802| if (realloc_size < 256) { ------------------ | Branch (787:9): [True: 802, False: 0] ------------------ 788| 802| realloc_size = 256; 789| 802| } 790| | 791| 802| out_buf = flb_sds_create_size(out_size); 792| 802| if (!out_buf) { ------------------ | Branch (792:9): [True: 1, False: 801] ------------------ 793| 1| flb_errno(); ------------------ | | 232| 1|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 794| 1| return NULL; 795| 1| } 796| | 797| 801| msgpack_unpacked_init(&result); 798| 801| ret = msgpack_unpack_next(&result, in_buf, in_size, &off); 799| 801| if (ret != MSGPACK_UNPACK_SUCCESS) { ------------------ | Branch (799:9): [True: 480, False: 321] ------------------ 800| 480| flb_sds_destroy(out_buf); 801| 480| msgpack_unpacked_destroy(&result); 802| 480| return NULL; 803| 480| } 804| | 805| 321| root = &result.data; 806| 880| while (1) { ------------------ | Branch (806:12): [Folded - Ignored] ------------------ 807| 880| ret = flb_msgpack_to_json(out_buf, out_size, root); 808| 880| if (ret <= 0) { ------------------ | Branch (808:13): [True: 559, False: 321] ------------------ 809| 559| realloc_size *= 2; 810| 559| tmp_buf = flb_sds_increase(out_buf, realloc_size); 811| 559| if (tmp_buf) { ------------------ | Branch (811:17): [True: 559, False: 0] ------------------ 812| 559| out_buf = tmp_buf; 813| 559| out_size = flb_sds_alloc(out_buf); 814| 559| } 815| 0| else { 816| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 817| 0| flb_sds_destroy(out_buf); 818| 0| msgpack_unpacked_destroy(&result); 819| 0| return NULL; 820| 0| } 821| 559| } 822| 321| else { 823| 321| break; 824| 321| } 825| 880| } 826| | 827| 321| msgpack_unpacked_destroy(&result); 828| 321| flb_sds_len_set(out_buf, ret); 829| | 830| 321| return out_buf; 831| 321|} flb_pack.c:msgpack2json: 587| 115k|{ 588| 115k| int i; 589| 115k| int dup; 590| 115k| int ret = FLB_FALSE; ------------------ | | 25| 115k|#define FLB_FALSE 0 ------------------ 591| 115k| int loop; 592| 115k| int packed; 593| | 594| 115k| switch(o->type) { 595| 3.03k| case MSGPACK_OBJECT_NIL: ------------------ | Branch (595:5): [True: 3.03k, False: 112k] ------------------ 596| 3.03k| ret = try_to_write(buf, off, left, "null", 4); 597| 3.03k| break; 598| | 599| 5.20k| case MSGPACK_OBJECT_BOOLEAN: ------------------ | Branch (599:5): [True: 5.20k, False: 110k] ------------------ 600| 5.20k| ret = try_to_write(buf, off, left, 601| 5.20k| (o->via.boolean ? "true":"false"),0); ------------------ | Branch (601:29): [True: 1.10k, False: 4.09k] ------------------ 602| | 603| 5.20k| break; 604| | 605| 36.0k| case MSGPACK_OBJECT_POSITIVE_INTEGER: ------------------ | Branch (605:5): [True: 36.0k, False: 79.3k] ------------------ 606| 36.0k| { 607| 36.0k| char temp[32] = {0}; 608| 36.0k| i = snprintf(temp, sizeof(temp)-1, "%"PRIu64, o->via.u64); 609| 36.0k| ret = try_to_write(buf, off, left, temp, i); 610| 36.0k| } 611| 36.0k| break; 612| | 613| 37.1k| case MSGPACK_OBJECT_NEGATIVE_INTEGER: ------------------ | Branch (613:5): [True: 37.1k, False: 78.2k] ------------------ 614| 37.1k| { 615| 37.1k| char temp[32] = {0}; 616| 37.1k| i = snprintf(temp, sizeof(temp)-1, "%"PRId64, o->via.i64); 617| 37.1k| ret = try_to_write(buf, off, left, temp, i); 618| 37.1k| } 619| 37.1k| break; 620| 967| case MSGPACK_OBJECT_FLOAT32: ------------------ | Branch (620:5): [True: 967, False: 114k] ------------------ 621| 1.35k| case MSGPACK_OBJECT_FLOAT64: ------------------ | Branch (621:5): [True: 387, False: 115k] ------------------ 622| 1.35k| { 623| 1.35k| char temp[512] = {0}; 624| 1.35k| if (o->via.f64 == (double)(long long int)o->via.f64) { ------------------ | Branch (624:17): [True: 479, False: 875] ------------------ 625| 479| i = snprintf(temp, sizeof(temp)-1, "%.1f", o->via.f64); 626| 479| } 627| 875| else if (convert_nan_to_null && isnan(o->via.f64) ) { ------------------ | Branch (627:22): [True: 0, False: 875] ------------------ 628| 0| i = snprintf(temp, sizeof(temp)-1, "null"); 629| 0| } 630| 875| else { 631| 875| i = snprintf(temp, sizeof(temp)-1, "%.16g", o->via.f64); 632| 875| } 633| 1.35k| ret = try_to_write(buf, off, left, temp, i); 634| 1.35k| } 635| 1.35k| break; 636| | 637| 9.92k| case MSGPACK_OBJECT_STR: ------------------ | Branch (637:5): [True: 9.92k, False: 105k] ------------------ 638| 9.92k| if (try_to_write(buf, off, left, "\"", 1) && ------------------ | Branch (638:13): [True: 9.91k, False: 9] ------------------ 639| 9.92k| (o->via.str.size > 0 ? ------------------ | Branch (639:13): [True: 9.76k, False: 153] | Branch (639:14): [True: 7.43k, False: 2.47k] ------------------ 640| 7.43k| try_to_write_str(buf, off, left, o->via.str.ptr, o->via.str.size) ------------------ | | 42| 7.43k|#define try_to_write_str flb_utils_write_str ------------------ 641| 9.91k| : 1/* nothing to do */) && 642| 9.92k| try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (642:13): [True: 9.74k, False: 15] ------------------ 643| 9.74k| ret = FLB_TRUE; ------------------ | | 26| 9.74k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 9.74k|#define FLB_FALSE 0 | | ------------------ ------------------ 644| 9.74k| } 645| 9.92k| break; 646| | 647| 1.94k| case MSGPACK_OBJECT_BIN: ------------------ | Branch (647:5): [True: 1.94k, False: 113k] ------------------ 648| 1.94k| if (try_to_write(buf, off, left, "\"", 1) && ------------------ | Branch (648:13): [True: 1.93k, False: 7] ------------------ 649| 1.94k| (o->via.bin.size > 0 ? ------------------ | Branch (649:13): [True: 1.92k, False: 14] | Branch (649:14): [True: 924, False: 1.01k] ------------------ 650| 924| try_to_write_str(buf, off, left, o->via.bin.ptr, o->via.bin.size) ------------------ | | 42| 924|#define try_to_write_str flb_utils_write_str ------------------ 651| 1.93k| : 1 /* nothing to do */) && 652| 1.94k| try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (652:13): [True: 1.91k, False: 9] ------------------ 653| 1.91k| ret = FLB_TRUE; ------------------ | | 26| 1.91k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 1.91k|#define FLB_FALSE 0 | | ------------------ ------------------ 654| 1.91k| } 655| 1.94k| break; 656| | 657| 5.50k| case MSGPACK_OBJECT_EXT: ------------------ | Branch (657:5): [True: 5.50k, False: 109k] ------------------ 658| 5.50k| if (!try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (658:13): [True: 8, False: 5.49k] ------------------ 659| 8| goto msg2json_end; 660| 8| } 661| | /* ext body. fortmat is similar to printf(1) */ 662| 5.49k| { 663| 5.49k| char temp[32] = {0}; 664| 5.49k| int len; 665| 5.49k| loop = o->via.ext.size; 666| 79.2k| for(i=0; ivia.ext.ptr[i]); 668| 73.9k| if (!try_to_write(buf, off, left, temp, len)) { ------------------ | Branch (668:21): [True: 147, False: 73.7k] ------------------ 669| 147| goto msg2json_end; 670| 147| } 671| 73.9k| } 672| 5.49k| } 673| 5.34k| if (!try_to_write(buf, off, left, "\"", 1)) { ------------------ | Branch (673:13): [True: 8, False: 5.33k] ------------------ 674| 8| goto msg2json_end; 675| 8| } 676| 5.33k| ret = FLB_TRUE; ------------------ | | 26| 5.33k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 5.33k|#define FLB_FALSE 0 | | ------------------ ------------------ 677| 5.33k| break; 678| | 679| 7.41k| case MSGPACK_OBJECT_ARRAY: ------------------ | Branch (679:5): [True: 7.41k, False: 108k] ------------------ 680| 7.41k| loop = o->via.array.size; 681| | 682| 7.41k| if (!try_to_write(buf, off, left, "[", 1)) { ------------------ | Branch (682:13): [True: 9, False: 7.40k] ------------------ 683| 9| goto msg2json_end; 684| 9| } 685| 7.40k| if (loop != 0) { ------------------ | Branch (685:13): [True: 5.76k, False: 1.64k] ------------------ 686| 5.76k| msgpack_object* p = o->via.array.ptr; 687| 5.76k| if (!msgpack2json(buf, off, left, p)) { ------------------ | Branch (687:17): [True: 362, False: 5.40k] ------------------ 688| 362| goto msg2json_end; 689| 362| } 690| 44.8k| for (i=1; ivia.map.size; 703| 7.82k| if (!try_to_write(buf, off, left, "{", 1)) { ------------------ | Branch (703:13): [True: 14, False: 7.80k] ------------------ 704| 14| goto msg2json_end; 705| 14| } 706| 7.80k| if (loop != 0) { ------------------ | Branch (706:13): [True: 5.33k, False: 2.46k] ------------------ 707| 5.33k| msgpack_object k; 708| 5.33k| msgpack_object_kv *p = o->via.map.ptr; 709| | 710| 5.33k| packed = 0; 711| 5.33k| dup = FLB_FALSE; ------------------ | | 25| 5.33k|#define FLB_FALSE 0 ------------------ 712| | 713| 5.33k| k = o->via.map.ptr[0].key; 714| 40.0k| for (i = 0; i < loop; i++) { ------------------ | Branch (714:25): [True: 35.5k, False: 4.53k] ------------------ 715| 35.5k| k = o->via.map.ptr[i].key; 716| 35.5k| dup = key_exists_in_map(k, *o, i + 1); 717| 35.5k| if (dup == FLB_TRUE) { ------------------ | | 26| 35.5k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 35.5k|#define FLB_FALSE 0 | | ------------------ ------------------ | Branch (717:21): [True: 857, False: 34.6k] ------------------ 718| 857| continue; 719| 857| } 720| | 721| 34.6k| if (packed > 0) { ------------------ | Branch (721:21): [True: 29.3k, False: 5.33k] ------------------ 722| 29.3k| if (!try_to_write(buf, off, left, ",", 1)) { ------------------ | Branch (722:25): [True: 15, False: 29.3k] ------------------ 723| 15| goto msg2json_end; 724| 15| } 725| 29.3k| } 726| | 727| 34.6k| if ( 728| 34.6k| !msgpack2json(buf, off, left, &(p+i)->key) || ------------------ | Branch (728:21): [True: 452, False: 34.2k] ------------------ 729| 34.6k| !try_to_write(buf, off, left, ":", 1) || ------------------ | Branch (729:21): [True: 18, False: 34.2k] ------------------ 730| 34.6k| !msgpack2json(buf, off, left, &(p+i)->val) ) { ------------------ | Branch (730:21): [True: 319, False: 33.8k] ------------------ 731| 789| goto msg2json_end; 732| 789| } 733| 33.8k| packed++; 734| 33.8k| } 735| 5.33k| } 736| | 737| 7.00k| ret = try_to_write(buf, off, left, "}", 1); 738| 7.00k| break; 739| | 740| 0| default: ------------------ | Branch (740:5): [True: 0, False: 115k] ------------------ 741| 0| flb_warn("[%s] unknown msgpack type %i", __FUNCTION__, o->type); ------------------ | | 179| 0| if (flb_log_check(FLB_LOG_WARN)) \ | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ | | | Branch (179:9): [True: 0, False: 0] | | ------------------ | | 180| 0| flb_log_print(FLB_LOG_WARN, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ ------------------ 742| 115k| } 743| | 744| 115k| msg2json_end: 745| 115k| return ret; 746| 115k|} flb_pack.c:try_to_write: 541| 323k|{ 542| 323k| if (str_len <= 0){ ------------------ | Branch (542:9): [True: 5.20k, False: 318k] ------------------ 543| 5.20k| str_len = strlen(str); 544| 5.20k| } 545| 323k| if (left <= *off+str_len) { ------------------ | Branch (545:9): [True: 392, False: 323k] ------------------ 546| 392| return FLB_FALSE; ------------------ | | 25| 392|#define FLB_FALSE 0 ------------------ 547| 392| } 548| 323k| memcpy(buf+*off, str, str_len); 549| 323k| *off += str_len; 550| 323k| return FLB_TRUE; ------------------ | | 26| 323k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 323k|#define FLB_FALSE 0 | | ------------------ ------------------ 551| 323k|} flb_pack.c:key_exists_in_map: 559| 35.5k|{ 560| 35.5k| int i; 561| 35.5k| msgpack_object p; 562| | 563| 35.5k| if (key.type != MSGPACK_OBJECT_STR) { ------------------ | Branch (563:9): [True: 31.3k, False: 4.19k] ------------------ 564| 31.3k| return FLB_FALSE; ------------------ | | 25| 31.3k|#define FLB_FALSE 0 ------------------ 565| 31.3k| } 566| | 567| 74.9k| for (i = offset; i < map.via.map.size; i++) { ------------------ | Branch (567:22): [True: 71.5k, False: 3.33k] ------------------ 568| 71.5k| p = map.via.map.ptr[i].key; 569| 71.5k| if (p.type != MSGPACK_OBJECT_STR) { ------------------ | Branch (569:13): [True: 59.1k, False: 12.3k] ------------------ 570| 59.1k| continue; 571| 59.1k| } 572| | 573| 12.3k| if (key.via.str.size != p.via.str.size) { ------------------ | Branch (573:13): [True: 8.02k, False: 4.36k] ------------------ 574| 8.02k| continue; 575| 8.02k| } 576| | 577| 4.36k| if (memcmp(key.via.str.ptr, p.via.str.ptr, p.via.str.size) == 0) { ------------------ | Branch (577:13): [True: 857, False: 3.51k] ------------------ 578| 857| return FLB_TRUE; ------------------ | | 26| 857|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 857|#define FLB_FALSE 0 | | ------------------ ------------------ 579| 857| } 580| 4.36k| } 581| | 582| 3.33k| return FLB_FALSE; ------------------ | | 25| 3.33k|#define FLB_FALSE 0 ------------------ 583| 4.19k|} flb_sds_create_size: 93| 802|{ 94| 802| return sds_alloc(size); 95| 802|} flb_sds_increase: 99| 559|{ 100| 559| size_t new_size; 101| 559| struct flb_sds *head; 102| 559| flb_sds_t out; 103| 559| void *tmp; 104| | 105| 559| out = s; 106| 559| new_size = (FLB_SDS_HEADER_SIZE + flb_sds_alloc(s) + len + 1); ------------------ | | 34| 559|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) ------------------ 107| 559| head = FLB_SDS_HEADER(s); ------------------ | | 46| 559|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 559|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 108| 559| tmp = flb_realloc(head, new_size); 109| 559| if (!tmp) { ------------------ | Branch (109:9): [True: 0, False: 559] ------------------ 110| 0| flb_errno(); ------------------ | | 232| 0|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 111| 0| return NULL; 112| 0| } 113| 559| head = (struct flb_sds *) tmp; 114| 559| head->alloc += len; 115| 559| out = head->buf; 116| | 117| 559| return out; 118| 559|} flb_sds_destroy: 390| 1.28k|{ 391| 1.28k| struct flb_sds *head; 392| | 393| 1.28k| if (!s) { ------------------ | Branch (393:9): [True: 481, False: 801] ------------------ 394| 481| return; 395| 481| } 396| | 397| 801| head = FLB_SDS_HEADER(s); ------------------ | | 46| 801|#define FLB_SDS_HEADER(s) ((struct flb_sds *) (s - FLB_SDS_HEADER_SIZE)) | | ------------------ | | | | 34| 801|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) | | ------------------ ------------------ 398| 801| flb_free(head); 399| 801|} flb_sds.c:sds_alloc: 37| 802|{ 38| 802| void *buf; 39| 802| flb_sds_t s; 40| 802| struct flb_sds *head; 41| | 42| 802| buf = flb_malloc(FLB_SDS_HEADER_SIZE + size + 1); ------------------ | | 34| 802|#define FLB_SDS_HEADER_SIZE (sizeof(uint64_t) + sizeof(uint64_t)) ------------------ 43| 802| if (!buf) { ------------------ | Branch (43:9): [True: 1, False: 801] ------------------ 44| 1| flb_errno(); ------------------ | | 232| 1|#define flb_errno() flb_errno_print(errno, __FLB_FILENAME__, __LINE__) ------------------ 45| 1| return NULL; 46| 1| } 47| | 48| 801| head = buf; 49| 801| head->len = 0; 50| 801| head->alloc = size; 51| | 52| 801| s = head->buf; 53| 801| *s = '\0'; 54| | 55| 801| return s; 56| 802|} flb_utf8_len: 40| 68.4k|{ 41| 68.4k| return trailing_bytes_for_utf8[(unsigned int)(unsigned char)s[0]] + 1; 42| 68.4k|} flb_utf8_decode: 45| 87.2k|{ 46| | /* Start of a new character */ 47| 87.2k| if (*state == 0) { ------------------ | Branch (47:9): [True: 63.4k, False: 23.8k] ------------------ 48| 63.4k| if (byte <= 0x7F) { ------------------ | Branch (48:13): [True: 0, False: 63.4k] ------------------ 49| | /* ASCII */ 50| 0| *codep = byte; 51| 0| return FLB_UTF8_ACCEPT; ------------------ | | 23| 0|#define FLB_UTF8_ACCEPT 0 ------------------ 52| 0| } 53| 63.4k| else if ((byte & 0xE0) == 0xC0) { ------------------ | Branch (53:18): [True: 9.34k, False: 54.1k] ------------------ 54| | /* start of a 2-byte sequence */ 55| 9.34k| *codep = byte & 0x1F; 56| 9.34k| *state = 1; 57| 9.34k| } 58| 54.1k| else if ((byte & 0xF0) == 0xE0) { ------------------ | Branch (58:18): [True: 5.39k, False: 48.7k] ------------------ 59| | /* start of a 3-byte sequence */ 60| 5.39k| *codep = byte & 0x0F; 61| 5.39k| *state = 2; 62| 5.39k| } 63| 48.7k| else if ((byte & 0xF8) == 0xF0) { ------------------ | Branch (63:18): [True: 4.79k, False: 43.9k] ------------------ 64| | /* start of a 4-byte sequence */ 65| 4.79k| *codep = byte & 0x07; 66| 4.79k| *state = 3; 67| 4.79k| } 68| 43.9k| else { 69| | /* invalid first byte */ 70| 43.9k| *state = FLB_UTF8_REJECT; ------------------ | | 24| 43.9k|#define FLB_UTF8_REJECT 1 ------------------ 71| 43.9k| return FLB_UTF8_REJECT; ------------------ | | 24| 43.9k|#define FLB_UTF8_REJECT 1 ------------------ 72| 43.9k| } 73| 63.4k| } 74| 23.8k| else { 75| | /* continuation byte */ 76| 23.8k| if ((byte & 0xC0) == 0x80) { ------------------ | Branch (76:13): [True: 7.65k, False: 16.1k] ------------------ 77| 7.65k| *codep = (*codep << 6) | (byte & 0x3F); 78| | 79| | /* reduce the expected continuation bytes */ 80| 7.65k| (*state)--; 81| 7.65k| } 82| 16.1k| else { 83| | /* invalid continuation byte */ 84| 16.1k| *state = FLB_UTF8_REJECT; ------------------ | | 24| 16.1k|#define FLB_UTF8_REJECT 1 ------------------ 85| 16.1k| return FLB_UTF8_REJECT; ------------------ | | 24| 16.1k|#define FLB_UTF8_REJECT 1 ------------------ 86| 16.1k| } 87| 23.8k| } 88| | 89| 27.1k| if (*state == 0) { ------------------ | Branch (89:9): [True: 3.36k, False: 23.8k] ------------------ 90| | /* sequence complete */ 91| 3.36k| if (*codep >= 0xD800 && *codep <= 0xDFFF) { ------------------ | Branch (91:13): [True: 1.52k, False: 1.83k] | Branch (91:33): [True: 382, False: 1.14k] ------------------ 92| | /* invalid surrogate pair */ 93| 382| *state = FLB_UTF8_REJECT; ------------------ | | 24| 382|#define FLB_UTF8_REJECT 1 ------------------ 94| 382| return FLB_UTF8_REJECT; ------------------ | | 24| 382|#define FLB_UTF8_REJECT 1 ------------------ 95| 382| } 96| 2.98k| else if (*codep > 0x10FFFF) { ------------------ | Branch (96:18): [True: 401, False: 2.57k] ------------------ 97| | /* codepoint is out of range */ 98| 401| *state = FLB_UTF8_REJECT; ------------------ | | 24| 401|#define FLB_UTF8_REJECT 1 ------------------ 99| 401| return FLB_UTF8_REJECT; ------------------ | | 24| 401|#define FLB_UTF8_REJECT 1 ------------------ 100| 401| } 101| 2.57k| return FLB_UTF8_ACCEPT; ------------------ | | 23| 2.57k|#define FLB_UTF8_ACCEPT 0 ------------------ 102| 3.36k| } 103| | 104| | /* we are still processing the current sequence */ 105| 23.8k| return FLB_UTF8_CONTINUE; ------------------ | | 25| 23.8k|#define FLB_UTF8_CONTINUE 2 ------------------ 106| 27.1k|} flb_utils_write_str: 792| 8.36k|{ 793| 8.36k| int i, b, ret, len, hex_bytes, utf_sequence_length, utf_sequence_number; 794| 8.36k| int processed_bytes = 0; 795| 8.36k| int is_valid, copypos = 0, vlen; 796| 8.36k| uint32_t c; 797| 8.36k| uint32_t codepoint = 0; 798| 8.36k| uint32_t state = 0; 799| 8.36k| size_t available; 800| 8.36k| uint8_t *s; 801| 8.36k| off_t offset = 0; 802| 8.36k| char tmp[16]; 803| 8.36k| char *p; 804| | 805| | /* to encode codepoints > 0xFFFF */ 806| 8.36k| uint16_t high; 807| 8.36k| uint16_t low; 808| | 809| 8.36k| available = size - *off; 810| | 811| | /* Ensure we have some minimum space in the buffer */ 812| 8.36k| if (available < str_len) { ------------------ | Branch (812:9): [True: 44, False: 8.31k] ------------------ 813| 44| return FLB_FALSE; ------------------ | | 25| 44|#define FLB_FALSE 0 ------------------ 814| 44| } 815| | 816| 8.31k| p = buf + *off; 817| | 818| | /* align length to the nearest multiple of the vector size for safe SIMD processing */ 819| 8.31k| vlen = str_len & ~(sizeof(flb_vector8) - 1); 820| 110k| for (i = 0;;) { 821| | /* SIMD optimization: Process chunk of input string */ 822| 110k| for (; i < vlen; i += sizeof(flb_vector8)) { ------------------ | Branch (822:16): [True: 102k, False: 8.19k] ------------------ 823| 102k| flb_vector8 chunk; 824| 102k| flb_vector8_load(&chunk, (const uint8_t *)&str[i]); 825| | 826| | /* 827| | * Look for the special characters we are interested in, 828| | * if they are found we break the loop and escape them 829| | * in a char-by-char basis. Otherwise the do a bulk copy 830| | */ 831| 102k| if (flb_vector8_has_le(chunk, (unsigned char) 0x1F) || ------------------ | Branch (831:17): [True: 102k, False: 0] ------------------ 832| 102k| flb_vector8_has(chunk, (unsigned char) '"') || ------------------ | Branch (832:17): [True: 0, False: 0] ------------------ 833| 102k| flb_vector8_has(chunk, (unsigned char) '\\')) { ------------------ | Branch (833:17): [True: 0, False: 0] ------------------ 834| 102k| break; 835| 102k| } 836| 102k| } 837| | 838| | /* Copy the chunk processed so far */ 839| 110k| if (copypos < i) { ------------------ | Branch (839:13): [True: 0, False: 110k] ------------------ 840| | /* check if we have enough space */ 841| 0| if (available < i - copypos) { ------------------ | Branch (841:17): [True: 0, False: 0] ------------------ 842| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 843| 0| } 844| | 845| | /* copy and adjust pointers */ 846| 0| memcpy(p, &str[copypos], i - copypos); 847| 0| p += i - copypos; 848| 0| offset += i - copypos; 849| 0| available -= (i - copypos); 850| 0| copypos = i; 851| 0| } 852| | 853| | /* Process remaining characters one by one */ 854| 207k| for (b = 0; b < sizeof(flb_vector8); b++) { ------------------ | Branch (854:21): [True: 110k, False: 96.9k] ------------------ 855| 110k| if (i >= str_len) { ------------------ | Branch (855:17): [True: 8.19k, False: 102k] ------------------ 856| | /* all characters has been processed */ 857| 8.19k| goto done; 858| 8.19k| } 859| | 860| 102k| c = (uint32_t) str[i]; 861| | 862| | /* Use lookup table for escaping known sequences */ 863| 102k| if (c < 128 && json_escape_table[c].seq) { ------------------ | Branch (863:17): [True: 33.6k, False: 68.4k] | Branch (863:28): [True: 23.8k, False: 9.81k] ------------------ 864| | /* 865| | * All characters in the table have a lenght of 2 or 6 bytes, 866| | * just check if the second byte starts with 'u' so we know 867| | * it's unicode and needs 6 bytes of space. 868| | */ 869| 23.8k| if (json_escape_table[c].seq[1] == 'u') { ------------------ | Branch (869:21): [True: 21.9k, False: 1.85k] ------------------ 870| 21.9k| len = 6; 871| 21.9k| } 872| 1.85k| else { 873| 1.85k| len = 2; 874| 1.85k| } 875| | 876| | /* check if we have anough space */ 877| 23.8k| if (available < len) { ------------------ | Branch (877:21): [True: 48, False: 23.7k] ------------------ 878| 48| return FLB_FALSE; ------------------ | | 25| 48|#define FLB_FALSE 0 ------------------ 879| 48| } 880| | 881| | /* copy the escape sequence */ 882| 23.7k| memcpy(p, json_escape_table[c].seq, len); 883| 23.7k| p += len; 884| 23.7k| offset += len; 885| 23.7k| available -= len; 886| 23.7k| } 887| | /* Handle UTF-8 sequences from 0x80 to 0xFFFF */ 888| 78.2k| else if (c >= 0x80 && c <= 0xFFFF) { ------------------ | Branch (888:22): [True: 68.4k, False: 9.81k] | Branch (888:35): [True: 0, False: 68.4k] ------------------ 889| 0| hex_bytes = flb_utf8_len(&str[i]); 890| | 891| | /* Handle invalid or truncated sequence */ 892| 0| if (hex_bytes == 0 || i + hex_bytes > str_len) { ------------------ | Branch (892:21): [True: 0, False: 0] | Branch (892:39): [True: 0, False: 0] ------------------ 893| | /* check for the minimum space required */ 894| 0| if (available < 3) { ------------------ | Branch (894:25): [True: 0, False: 0] ------------------ 895| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 896| 0| } 897| | 898| | /* insert replacement character (U+FFFD) */ 899| 0| p[0] = 0xEF; 900| 0| p[1] = 0xBF; 901| 0| p[2] = 0xBD; 902| 0| p += 3; 903| 0| offset += 3; 904| 0| available -= 3; 905| | 906| | /* skip the original byte */ 907| 0| i++; 908| 0| continue; 909| 0| } 910| | 911| | /* decode UTF-8 sequence */ 912| 0| state = FLB_UTF8_ACCEPT; ------------------ | | 23| 0|#define FLB_UTF8_ACCEPT 0 ------------------ 913| 0| codepoint = 0; 914| 0| processed_bytes = 0; 915| | 916| 0| for (b = 0; b < hex_bytes; b++) { ------------------ | Branch (916:29): [True: 0, False: 0] ------------------ 917| 0| s = (unsigned char *) &str[i + b]; 918| 0| ret = flb_utf8_decode(&state, &codepoint, *s); 919| 0| processed_bytes++; 920| | 921| 0| if (ret == FLB_UTF8_ACCEPT) { ------------------ | | 23| 0|#define FLB_UTF8_ACCEPT 0 ------------------ | Branch (921:25): [True: 0, False: 0] ------------------ 922| | /* check if all required bytes for the sequence are processed */ 923| 0| if (processed_bytes == hex_bytes) { ------------------ | Branch (923:29): [True: 0, False: 0] ------------------ 924| 0| break; 925| 0| } 926| 0| } 927| 0| else if (ret == FLB_UTF8_REJECT) { ------------------ | | 24| 0|#define FLB_UTF8_REJECT 1 ------------------ | Branch (927:30): [True: 0, False: 0] ------------------ 928| 0| flb_warn("[pack] Invalid UTF-8 bytes found, skipping."); ------------------ | | 179| 0| if (flb_log_check(FLB_LOG_WARN)) \ | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ | | | Branch (179:9): [True: 0, False: 0] | | ------------------ | | 180| 0| flb_log_print(FLB_LOG_WARN, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ ------------------ 929| 0| break; 930| 0| } 931| 0| } 932| | 933| 0| if (state == FLB_UTF8_ACCEPT) { ------------------ | | 23| 0|#define FLB_UTF8_ACCEPT 0 ------------------ | Branch (933:21): [True: 0, False: 0] ------------------ 934| 0| len = snprintf(tmp, sizeof(tmp), "\\u%.4x", codepoint); 935| 0| if (available < len) { ------------------ | Branch (935:25): [True: 0, False: 0] ------------------ 936| 0| return FLB_FALSE; ------------------ | | 25| 0|#define FLB_FALSE 0 ------------------ 937| 0| } 938| 0| memcpy(p, tmp, len); 939| 0| p += len; 940| 0| offset += len; 941| 0| available -= len; 942| 0| } 943| 0| else { 944| 0| flb_warn("[pack] Invalid UTF-8 bytes found, skipping."); ------------------ | | 179| 0| if (flb_log_check(FLB_LOG_WARN)) \ | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ | | | Branch (179:9): [True: 0, False: 0] | | ------------------ | | 180| 0| flb_log_print(FLB_LOG_WARN, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 41| 0|#define FLB_LOG_WARN 2 | | ------------------ ------------------ 945| 0| } 946| | 947| 0| i += processed_bytes; 948| 0| } 949| | /* Handle sequences beyond 0xFFFF */ 950| 78.2k| else if (c > 0xFFFF) { ------------------ | Branch (950:22): [True: 68.4k, False: 9.81k] ------------------ 951| 68.4k| utf_sequence_length = flb_utf8_len(str + i); 952| | 953| | /* skip truncated UTF-8 ? */ 954| 68.4k| if (i + utf_sequence_length > str_len) { ------------------ | Branch (954:21): [True: 5.02k, False: 63.4k] ------------------ 955| 5.02k| i++; 956| 5.02k| break; 957| 5.02k| } 958| | 959| 63.4k| state = FLB_UTF8_ACCEPT; ------------------ | | 23| 63.4k|#define FLB_UTF8_ACCEPT 0 ------------------ 960| 63.4k| codepoint = 0; 961| 63.4k| is_valid = FLB_TRUE; ------------------ | | 26| 63.4k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 63.4k|#define FLB_FALSE 0 | | ------------------ ------------------ 962| | 963| | /* Decode the sequence */ 964| 89.8k| for (utf_sequence_number = 0; utf_sequence_number < utf_sequence_length; utf_sequence_number++) { ------------------ | Branch (964:47): [True: 87.2k, False: 2.57k] ------------------ 965| 87.2k| ret = flb_utf8_decode(&state, &codepoint, (uint8_t) str[i]); 966| | 967| 87.2k| if (ret == FLB_UTF8_REJECT) { ------------------ | | 24| 87.2k|#define FLB_UTF8_REJECT 1 ------------------ | Branch (967:25): [True: 60.8k, False: 26.4k] ------------------ 968| | /* Handle invalid leading byte */ 969| 60.8k| if (utf_sequence_number == 0) { ------------------ | Branch (969:29): [True: 43.9k, False: 16.9k] ------------------ 970| 43.9k| flb_debug("[pack] unexpected UTF-8 leading byte, substituting character"); ------------------ | | 197| 43.9k| if (flb_log_check(FLB_LOG_DEBUG)) \ | | ------------------ | | | | 43| 43.9k|#define FLB_LOG_DEBUG 4 | | ------------------ | | | Branch (197:9): [True: 0, False: 43.9k] | | ------------------ | | 198| 43.9k| flb_log_print(FLB_LOG_DEBUG, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 43| 0|#define FLB_LOG_DEBUG 4 | | ------------------ ------------------ 971| 43.9k| tmp[utf_sequence_number] = str[i]; 972| 43.9k| utf_sequence_length = utf_sequence_number + 1; /* Process only this invalid byte */ 973| 43.9k| i++; /* Consume invalid byte */ 974| 43.9k| } 975| | /* Handle invalid continuation byte */ 976| 16.9k| else { 977| 16.9k| flb_debug("[pack] unexpected UTF-8 continuation byte, substituting character"); ------------------ | | 197| 16.9k| if (flb_log_check(FLB_LOG_DEBUG)) \ | | ------------------ | | | | 43| 16.9k|#define FLB_LOG_DEBUG 4 | | ------------------ | | | Branch (197:9): [True: 0, False: 16.9k] | | ------------------ | | 198| 16.9k| flb_log_print(FLB_LOG_DEBUG, NULL, 0, fmt, ##__VA_ARGS__) | | ------------------ | | | | 43| 0|#define FLB_LOG_DEBUG 4 | | ------------------ ------------------ 978| 16.9k| utf_sequence_length = utf_sequence_number; /* Adjust length */ 979| 16.9k| } 980| 60.8k| is_valid = FLB_FALSE; ------------------ | | 25| 60.8k|#define FLB_FALSE 0 ------------------ 981| 60.8k| break; 982| 60.8k| } 983| | 984| 26.4k| tmp[utf_sequence_number] = str[i]; 985| 26.4k| ++i; 986| 26.4k| } 987| | 988| 63.4k| --i; 989| | 990| 63.4k| if (is_valid) { ------------------ | Branch (990:21): [True: 2.57k, False: 60.8k] ------------------ 991| 2.57k| if (available < utf_sequence_length) { ------------------ | Branch (991:25): [True: 9, False: 2.57k] ------------------ 992| | /* not enough space */ 993| 9| return FLB_FALSE; ------------------ | | 25| 9|#define FLB_FALSE 0 ------------------ 994| 9| } 995| | 996| | /* Handle codepoints beyond BMP (requires surrogate pairs in UTF-16) */ 997| 2.57k| if (codepoint > 0xFFFF) { ------------------ | Branch (997:25): [True: 536, False: 2.03k] ------------------ 998| 536| high = 0xD800 + ((codepoint - 0x10000) >> 10); 999| 536| low = 0xDC00 + ((codepoint - 0x10000) & 0x3FF); 1000| | 1001| 536| len = snprintf(tmp, sizeof(tmp), "\\u%.4x\\u%.4x", high, low); 1002| 536| } 1003| 2.03k| else { 1004| 2.03k| len = snprintf(tmp, sizeof(tmp), "\\u%.4x", codepoint); 1005| 2.03k| } 1006| | 1007| 2.57k| if (available < len) { ------------------ | Branch (1007:25): [True: 13, False: 2.55k] ------------------ 1008| | /* not enough space */ 1009| 13| return FLB_FALSE; ------------------ | | 25| 13|#define FLB_FALSE 0 ------------------ 1010| 13| } 1011| 2.55k| memcpy(p, tmp, len); 1012| 2.55k| p += len; 1013| 2.55k| offset += len; 1014| 2.55k| available -= len; 1015| 2.55k| } 1016| 60.8k| else { 1017| 60.8k| if (available < utf_sequence_length * 3) { ------------------ | Branch (1017:25): [True: 45, False: 60.8k] ------------------ 1018| 45| return FLB_FALSE; ------------------ | | 25| 45|#define FLB_FALSE 0 ------------------ 1019| 45| } 1020| | 1021| | /* 1022| | * Utf-8 sequence is invalid. Map fragments to private use area 1023| | * codepoints in range: 1024| | * 0x00 to 1025| | * 0xFF 1026| | */ 1027| 124k| for (b = 0; b < utf_sequence_length; ++b) { ------------------ | Branch (1027:33): [True: 63.3k, False: 60.8k] ------------------ 1028| | /* 1029| | * Utf-8 private block invalid hex mapping. Format unicode charpoint 1030| | * in the following format: 1031| | * 1032| | * +--------+--------+--------+ 1033| | * |1110PPPP|10PPPPHH|10HHHHHH| 1034| | * +--------+--------+--------+ 1035| | * 1036| | * Where: 1037| | * P is FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR bits (1 byte) 1038| | * H is Utf-8 fragment hex bits (1 byte) 1039| | * 1 is bit 1 1040| | * 0 is bit 0 1041| | */ 1042| | 1043| | /* unicode codepoint start */ 1044| 63.3k| *p = 0xE0; 1045| | 1046| | /* print unicode private block header first 4 bits */ 1047| 63.3k| *p |= FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR >> 4; ------------------ | | 67| 63.3k|#define FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR 0xE0 ------------------ 1048| 63.3k| ++p; 1049| | 1050| | /* unicode codepoint middle */ 1051| 63.3k| *p = 0x80; 1052| | 1053| | /* print end of unicode private block header last 4 bits */ 1054| 63.3k| *p |= ((FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR << 2) & 0x3f); ------------------ | | 67| 63.3k|#define FLB_UTILS_FRAGMENT_PRIVATE_BLOCK_DESCRIPTOR 0xE0 ------------------ 1055| | 1056| | /* print hex fragment first 2 bits */ 1057| 63.3k| *p |= (tmp[b] >> 6) & 0x03; 1058| 63.3k| ++p; 1059| | 1060| | /* unicode codepoint middle */ 1061| 63.3k| *p = 0x80; 1062| | 1063| | /* print hex fragment last 6 bits */ 1064| 63.3k| *p |= tmp[b] & 0x3f; 1065| 63.3k| ++p; 1066| | 1067| 63.3k| offset += 3; 1068| 63.3k| available -= 3; 1069| 63.3k| } 1070| 60.8k| } 1071| | 1072| 63.4k| } 1073| 9.81k| else { 1074| 9.81k| if (available < 1) { ------------------ | Branch (1074:21): [True: 8, False: 9.80k] ------------------ 1075| | /* no space for a single byte */ 1076| 8| return FLB_FALSE; ------------------ | | 25| 8|#define FLB_FALSE 0 ------------------ 1077| 8| } 1078| 9.80k| *p++ = c; 1079| 9.80k| offset++; 1080| 9.80k| available--; 1081| 9.80k| } 1082| | 1083| 96.9k| i++; 1084| 96.9k| } 1085| | 1086| 101k| copypos = i; 1087| 101k| } 1088| | 1089| 8.19k|done: 1090| | /* update the buffer offset */ 1091| 8.19k| *off += offset; 1092| | 1093| 8.19k| return FLB_TRUE; ------------------ | | 26| 8.19k|#define FLB_TRUE !FLB_FALSE | | ------------------ | | | | 25| 8.19k|#define FLB_FALSE 0 | | ------------------ ------------------ 1094| 8.31k|} 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| 895|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size){ 7| | /* Set flb_malloc_mod to be fuzzer-data dependent */ 8| 895| if (size < 4) { ------------------ | Branch (8:9): [True: 2, False: 893] ------------------ 9| 2| return 0; 10| 2| } 11| 893| flb_malloc_p = 0; 12| 893| flb_malloc_mod = *(int*)data; 13| 893| data += 4; 14| 893| size -= 4; 15| | 16| | /* Avoid division by zero for modulo operations */ 17| 893| if (flb_malloc_mod == 0) { ------------------ | Branch (17:9): [True: 4, False: 889] ------------------ 18| 4| flb_malloc_mod = 1; 19| 4| } 20| | 21| 893| if (size != 512) ------------------ | Branch (21:9): [True: 91, False: 802] ------------------ 22| 91| return 0; 23| | 24| | /* target the conversion of raw msgpack to json */ 25| 802| flb_sds_t record; 26| 802| record = flb_msgpack_raw_to_json_sds(data, size); 27| 802| flb_sds_destroy(record); 28| | 29| 802| return 0; 30| 893|}